fs/btrfs/transaction.c

   1 /*
   2  * Copyright (C) 2007 Oracle.  All rights reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public
   6  * License v2 as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public
  14  * License along with this program; if not, write to the
  15  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  16  * Boston, MA 021110-1307, USA.
  17  */
  18
  19 #include <linux/fs.h>
  20 #include <linux/slab.h>
  21 #include <linux/sched.h>
  22 #include <linux/writeback.h>
  23 #include <linux/pagemap.h>
  24 #include <linux/blkdev.h>
  25 #include <linux/uuid.h>
  26 #include "ctree.h"
  27 #include "disk-io.h"
  28 #include "transaction.h"
  29 #include "locking.h"
  30 #include "tree-log.h"
  31 #include "inode-map.h"
  32 #include "volumes.h"
  33 #include "dev-replace.h"
  34
  35 #define BTRFS_ROOT_TRANS_TAG 0
  36
  37 void put_transaction(struct btrfs_transaction *transaction)
  38 {
  39         WARN_ON(atomic_read(&transaction->use_count) == 0);
  40         if (atomic_dec_and_test(&transaction->use_count)) {
  41                 BUG_ON(!list_empty(&transaction->list));
  42                 WARN_ON(transaction->delayed_refs.root.rb_node);
  43                 kmem_cache_free(btrfs_transaction_cachep, transaction);
  44         }
  45 }
  46
  47 static noinline void switch_commit_root(struct btrfs_root *root)
  48 {
  49         free_extent_buffer(root->commit_root);
  50         root->commit_root = btrfs_root_node(root);
  51 }
  52
  53 static inline int can_join_transaction(struct btrfs_transaction *trans,
  54                                        int type)
  55 {
  56         return !(trans->in_commit &&
  57                  type != TRANS_JOIN &&
  58                  type != TRANS_JOIN_NOLOCK);
  59 }
  60
  61 /*
  62  * either allocate a new transaction or hop into the existing one
  63  */
  64 static noinline int join_transaction(struct btrfs_root *root, int type)
  65 {
  66         struct btrfs_transaction *cur_trans;
  67         struct btrfs_fs_info *fs_info = root->fs_info;
  68
  69         spin_lock(&fs_info->trans_lock);
  70 loop:
  71         /* The file system has been taken offline. No new transactions. */
  72         if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
  73                 spin_unlock(&fs_info->trans_lock);
  74                 return -EROFS;
  75         }
  76
  77         if (fs_info->trans_no_join) {
  78                 /*
  79                  * If we are JOIN_NOLOCK we're already committing a current
  80                  * transaction, we just need a handle to deal with something
  81                  * when committing the transaction, such as inode cache and
  82                  * space cache. It is a special case.
  83                  */
  84                 if (type != TRANS_JOIN_NOLOCK) {
  85                         spin_unlock(&fs_info->trans_lock);
  86                         return -EBUSY;
  87                 }
  88         }
  89
  90         cur_trans = fs_info->running_transaction;
  91         if (cur_trans) {
  92                 if (cur_trans->aborted) {
  93                         spin_unlock(&fs_info->trans_lock);
  94                         return cur_trans->aborted;
  95                 }
  96                 if (!can_join_transaction(cur_trans, type)) {
  97                         spin_unlock(&fs_info->trans_lock);
  98                         return -EBUSY;
  99                 }
 100                 atomic_inc(&cur_trans->use_count);
 101                 atomic_inc(&cur_trans->num_writers);
 102                 cur_trans->num_joined++;
 103                 spin_unlock(&fs_info->trans_lock);
 104                 return 0;
 105         }
 106         spin_unlock(&fs_info->trans_lock);
 107
 108         /*
 109          * If we are ATTACH, we just want to catch the current transaction,
 110          * and commit it. If there is no transaction, just return ENOENT.
 111          */
 112         if (type == TRANS_ATTACH)
 113                 return -ENOENT;
 114
 115         cur_trans = kmem_cache_alloc(btrfs_transaction_cachep, GFP_NOFS);
 116         if (!cur_trans)
 117                 return -ENOMEM;
 118
 119         spin_lock(&fs_info->trans_lock);
 120         if (fs_info->running_transaction) {
 121                 /*
 122                  * someone started a transaction after we unlocked.  Make sure
 123                  * to redo the trans_no_join checks above
 124                  */
 125                 kmem_cache_free(btrfs_transaction_cachep, cur_trans);
 126                 cur_trans = fs_info->running_transaction;
 127                 goto loop;
 128         } else if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
 129                 spin_unlock(&fs_info->trans_lock);
 130                 kmem_cache_free(btrfs_transaction_cachep, cur_trans);
 131                 return -EROFS;
 132         }
 133
 134         atomic_set(&cur_trans->num_writers, 1);
 135         cur_trans->num_joined = 0;
 136         init_waitqueue_head(&cur_trans->writer_wait);
 137         init_waitqueue_head(&cur_trans->commit_wait);
 138         cur_trans->in_commit = 0;
 139         cur_trans->blocked = 0;
 140         /*
 141          * One for this trans handle, one so it will live on until we
 142          * commit the transaction.
 143          */
 144         atomic_set(&cur_trans->use_count, 2);
 145         cur_trans->commit_done = 0;
 146         cur_trans->start_time = get_seconds();
 147
 148         cur_trans->delayed_refs.root = RB_ROOT;
 149         cur_trans->delayed_refs.num_entries = 0;
 150         cur_trans->delayed_refs.num_heads_ready = 0;
 151         cur_trans->delayed_refs.num_heads = 0;
 152         cur_trans->delayed_refs.flushing = 0;
 153         cur_trans->delayed_refs.run_delayed_start = 0;
 154
 155         /*
 156          * although the tree mod log is per file system and not per transaction,
 157          * the log must never go across transaction boundaries.
 158          */
 159         smp_mb();
 160         if (!list_empty(&fs_info->tree_mod_seq_list))
 161                 WARN(1, KERN_ERR "btrfs: tree_mod_seq_list not empty when "
 162                         "creating a fresh transaction\n");
 163         if (!RB_EMPTY_ROOT(&fs_info->tree_mod_log))
 164                 WARN(1, KERN_ERR "btrfs: tree_mod_log rb tree not empty when "
 165                         "creating a fresh transaction\n");
 166         atomic_set(&fs_info->tree_mod_seq, 0);
 167
 168         spin_lock_init(&cur_trans->commit_lock);
 169         spin_lock_init(&cur_trans->delayed_refs.lock);
 170         atomic_set(&cur_trans->delayed_refs.procs_running_refs, 0);
 171         atomic_set(&cur_trans->delayed_refs.ref_seq, 0);
 172         init_waitqueue_head(&cur_trans->delayed_refs.wait);
 173
 174         INIT_LIST_HEAD(&cur_trans->pending_snapshots);
 175         INIT_LIST_HEAD(&cur_trans->ordered_operations);
 176         list_add_tail(&cur_trans->list, &fs_info->trans_list);
 177         extent_io_tree_init(&cur_trans->dirty_pages,
 178                              fs_info->btree_inode->i_mapping);
 179         fs_info->generation++;
 180         cur_trans->transid = fs_info->generation;
 181         fs_info->running_transaction = cur_trans;
 182         cur_trans->aborted = 0;
 183         spin_unlock(&fs_info->trans_lock);
 184
 185         return 0;
 186 }
 187
 188 /*
 189  * this does all the record keeping required to make sure that a reference
 190  * counted root is properly recorded in a given transaction.  This is required
 191  * to make sure the old root from before we joined the transaction is deleted
 192  * when the transaction commits
 193  */
 194 static int record_root_in_trans(struct btrfs_trans_handle *trans,
 195                                struct btrfs_root *root)
 196 {
 197         if (root->ref_cows && root->last_trans < trans->transid) {
 198                 WARN_ON(root == root->fs_info->extent_root);
 199                 WARN_ON(root->commit_root != root->node);
 200
 201                 /*
 202                  * see below for in_trans_setup usage rules
 203                  * we have the reloc mutex held now, so there
 204                  * is only one writer in this function
 205                  */
 206                 root->in_trans_setup = 1;
 207
 208                 /* make sure readers find in_trans_setup before
 209                  * they find our root->last_trans update
 210                  */
 211                 smp_wmb();
 212
 213                 spin_lock(&root->fs_info->fs_roots_radix_lock);
 214                 if (root->last_trans == trans->transid) {
 215                         spin_unlock(&root->fs_info->fs_roots_radix_lock);
 216                         return 0;
 217                 }
 218                 radix_tree_tag_set(&root->fs_info->fs_roots_radix,
 219                            (unsigned long)root->root_key.objectid,
 220                            BTRFS_ROOT_TRANS_TAG);
 221                 spin_unlock(&root->fs_info->fs_roots_radix_lock);
 222                 root->last_trans = trans->transid;
 223
 224                 /* this is pretty tricky.  We don't want to
 225                  * take the relocation lock in btrfs_record_root_in_trans
 226                  * unless we're really doing the first setup for this root in
 227                  * this transaction.
 228                  *
 229                  * Normally we'd use root->last_trans as a flag to decide
 230                  * if we want to take the expensive mutex.
 231                  *
 232                  * But, we have to set root->last_trans before we
 233                  * init the relocation root, otherwise, we trip over warnings
 234                  * in ctree.c.  The solution used here is to flag ourselves
 235                  * with root->in_trans_setup.  When this is 1, we're still
 236                  * fixing up the reloc trees and everyone must wait.
 237                  *
 238                  * When this is zero, they can trust root->last_trans and fly
 239                  * through btrfs_record_root_in_trans without having to take the
 240                  * lock.  smp_wmb() makes sure that all the writes above are
 241                  * done before we pop in the zero below
 242                  */
 243                 btrfs_init_reloc_root(trans, root);
 244                 smp_wmb();
 245                 root->in_trans_setup = 0;
 246         }
 247         return 0;
 248 }
 249
 250
 251 int btrfs_record_root_in_trans(struct btrfs_trans_handle *trans,
 252                                struct btrfs_root *root)
 253 {
 254         if (!root->ref_cows)
 255                 return 0;
 256
 257         /*
 258          * see record_root_in_trans for comments about in_trans_setup usage
 259          * and barriers
 260          */
 261         smp_rmb();
 262         if (root->last_trans == trans->transid &&
 263             !root->in_trans_setup)
 264                 return 0;
 265
 266         mutex_lock(&root->fs_info->reloc_mutex);
 267         record_root_in_trans(trans, root);
 268         mutex_unlock(&root->fs_info->reloc_mutex);
 269
 270         return 0;
 271 }
 272
 273 /* wait for commit against the current transaction to become unblocked
 274  * when this is done, it is safe to start a new transaction, but the current
 275  * transaction might not be fully on disk.
 276  */
 277 static void wait_current_trans(struct btrfs_root *root)
 278 {
 279         struct btrfs_transaction *cur_trans;
 280
 281         spin_lock(&root->fs_info->trans_lock);
 282         cur_trans = root->fs_info->running_transaction;
 283         if (cur_trans && cur_trans->blocked) {
 284                 atomic_inc(&cur_trans->use_count);
 285                 spin_unlock(&root->fs_info->trans_lock);
 286
 287                 wait_event(root->fs_info->transaction_wait,
 288                            !cur_trans->blocked);
 289                 put_transaction(cur_trans);
 290         } else {
 291                 spin_unlock(&root->fs_info->trans_lock);
 292         }
 293 }
 294
 295 static int may_wait_transaction(struct btrfs_root *root, int type)
 296 {
 297         if (root->fs_info->log_root_recovering)
 298                 return 0;
 299
 300         if (type == TRANS_USERSPACE)
 301                 return 1;
 302
 303         if (type == TRANS_START &&
 304             !atomic_read(&root->fs_info->open_ioctl_trans))
 305                 return 1;
 306
 307         return 0;
 308 }
 309
 310 static struct btrfs_trans_handle *
 311 start_transaction(struct btrfs_root *root, u64 num_items, int type,
 312                   enum btrfs_reserve_flush_enum flush)
 313 {
 314         struct btrfs_trans_handle *h;
 315         struct btrfs_transaction *cur_trans;
 316         u64 num_bytes = 0;
 317         int ret;
 318         u64 qgroup_reserved = 0;
 319
 320         if (test_bit(BTRFS_FS_STATE_ERROR, &root->fs_info->fs_state))
 321                 return ERR_PTR(-EROFS);
 322
 323         if (current->journal_info) {
 324                 WARN_ON(type != TRANS_JOIN && type != TRANS_JOIN_NOLOCK);
 325                 h = current->journal_info;
 326                 h->use_count++;
 327                 WARN_ON(h->use_count > 2);
 328                 h->orig_rsv = h->block_rsv;
 329                 h->block_rsv = NULL;
 330                 goto got_it;
 331         }
 332
 333         /*
 334          * Do the reservation before we join the transaction so we can do all
 335          * the appropriate flushing if need be.
 336          */
 337         if (num_items > 0 && root != root->fs_info->chunk_root) {
 338                 if (root->fs_info->quota_enabled &&
 339                     is_fstree(root->root_key.objectid)) {
 340                         qgroup_reserved = num_items * root->leafsize;
 341                         ret = btrfs_qgroup_reserve(root, qgroup_reserved);
 342                         if (ret)
 343                                 return ERR_PTR(ret);
 344                 }
 345
 346                 num_bytes = btrfs_calc_trans_metadata_size(root, num_items);
 347                 ret = btrfs_block_rsv_add(root,
 348                                           &root->fs_info->trans_block_rsv,
 349                                           num_bytes, flush);
 350                 if (ret)
 351                         goto reserve_fail;
 352         }
 353 again:
 354         h = kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS);
 355         if (!h) {
 356                 ret = -ENOMEM;
 357                 goto alloc_fail;
 358         }
 359
 360         /*
 361          * If we are JOIN_NOLOCK we're already committing a transaction and
 362          * waiting on this guy, so we don't need to do the sb_start_intwrite
 363          * because we're already holding a ref.  We need this because we could
 364          * have raced in and did an fsync() on a file which can kick a commit
 365          * and then we deadlock with somebody doing a freeze.
 366          *
 367          * If we are ATTACH, it means we just want to catch the current
 368          * transaction and commit it, so we needn't do sb_start_intwrite().
 369          */
 370         if (type < TRANS_JOIN_NOLOCK)
 371                 sb_start_intwrite(root->fs_info->sb);
 372
 373         if (may_wait_transaction(root, type))
 374                 wait_current_trans(root);
 375
 376         do {
 377                 ret = join_transaction(root, type);
 378                 if (ret == -EBUSY) {
 379                         wait_current_trans(root);
 380                         if (unlikely(type == TRANS_ATTACH))
 381                                 ret = -ENOENT;
 382                 }
 383         } while (ret == -EBUSY);
 384
 385         if (ret < 0) {
 386                 /* We must get the transaction if we are JOIN_NOLOCK. */
 387                 BUG_ON(type == TRANS_JOIN_NOLOCK);
 388                 goto join_fail;
 389         }
 390
 391         cur_trans = root->fs_info->running_transaction;
 392
 393         h->transid = cur_trans->transid;
 394         h->transaction = cur_trans;
 395         h->blocks_used = 0;
 396         h->bytes_reserved = 0;
 397         h->root = root;
 398         h->delayed_ref_updates = 0;
 399         h->use_count = 1;
 400         h->adding_csums = 0;
 401         h->block_rsv = NULL;
 402         h->orig_rsv = NULL;
 403         h->aborted = 0;
 404         h->qgroup_reserved = 0;
 405         h->delayed_ref_elem.seq = 0;
 406         h->type = type;
 407         h->allocating_chunk = false;
 408         INIT_LIST_HEAD(&h->qgroup_ref_list);
 409         INIT_LIST_HEAD(&h->new_bgs);
 410
 411         smp_mb();
 412         if (cur_trans->blocked && may_wait_transaction(root, type)) {
 413                 btrfs_commit_transaction(h, root);
 414                 goto again;
 415         }
 416
 417         if (num_bytes) {
 418                 trace_btrfs_space_reservation(root->fs_info, "transaction",
 419                                               h->transid, num_bytes, 1);
 420                 h->block_rsv = &root->fs_info->trans_block_rsv;
 421                 h->bytes_reserved = num_bytes;
 422         }
 423         h->qgroup_reserved = qgroup_reserved;
 424
 425 got_it:
 426         btrfs_record_root_in_trans(h, root);
 427
 428         if (!current->journal_info && type != TRANS_USERSPACE)
 429                 current->journal_info = h;
 430         return h;
 431
 432 join_fail:
 433         if (type < TRANS_JOIN_NOLOCK)
 434                 sb_end_intwrite(root->fs_info->sb);
 435         kmem_cache_free(btrfs_trans_handle_cachep, h);
 436 alloc_fail:
 437         if (num_bytes)
 438                 btrfs_block_rsv_release(root, &root->fs_info->trans_block_rsv,
 439                                         num_bytes);
 440 reserve_fail:
 441         if (qgroup_reserved)
 442                 btrfs_qgroup_free(root, qgroup_reserved);
 443         return ERR_PTR(ret);
 444 }
 445
 446 struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
 447                                                    int num_items)
 448 {
 449         return start_transaction(root, num_items, TRANS_START,
 450                                  BTRFS_RESERVE_FLUSH_ALL);
 451 }
 452
 453 struct btrfs_trans_handle *btrfs_start_transaction_lflush(
 454                                         struct btrfs_root *root, int num_items)
 455 {
 456         return start_transaction(root, num_items, TRANS_START,
 457                                  BTRFS_RESERVE_FLUSH_LIMIT);
 458 }
 459
 460 struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root)
 461 {
 462         return start_transaction(root, 0, TRANS_JOIN, 0);
 463 }
 464
 465 struct btrfs_trans_handle *btrfs_join_transaction_nolock(struct btrfs_root *root)
 466 {
 467         return start_transaction(root, 0, TRANS_JOIN_NOLOCK, 0);
 468 }
 469
 470 struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *root)
 471 {
 472         return start_transaction(root, 0, TRANS_USERSPACE, 0);
 473 }
 474
 475 /*
 476  * btrfs_attach_transaction() - catch the running transaction
 477  *
 478  * It is used when we want to commit the current the transaction, but
 479  * don't want to start a new one.
 480  *
 481  * Note: If this function return -ENOENT, it just means there is no
 482  * running transaction. But it is possible that the inactive transaction
 483  * is still in the memory, not fully on disk. If you hope there is no
 484  * inactive transaction in the fs when -ENOENT is returned, you should
 485  * invoke
 486  *     btrfs_attach_transaction_barrier()
 487  */
 488 struct btrfs_trans_handle *btrfs_attach_transaction(struct btrfs_root *root)
 489 {
 490         return start_transaction(root, 0, TRANS_ATTACH, 0);
 491 }
 492
 493 /*
 494  * btrfs_attach_transaction() - catch the running transaction
 495  *
 496  * It is similar to the above function, the differentia is this one
 497  * will wait for all the inactive transactions until they fully
 498  * complete.
 499  */
 500 struct btrfs_trans_handle *
 501 btrfs_attach_transaction_barrier(struct btrfs_root *root)
 502 {
 503         struct btrfs_trans_handle *trans;
 504
 505         trans = start_transaction(root, 0, TRANS_ATTACH, 0);
 506         if (IS_ERR(trans) && PTR_ERR(trans) == -ENOENT)
 507                 btrfs_wait_for_commit(root, 0);
 508
 509         return trans;
 510 }
 511
 512 /* wait for a transaction commit to be fully complete */
 513 static noinline void wait_for_commit(struct btrfs_root *root,
 514                                     struct btrfs_transaction *commit)
 515 {
 516         wait_event(commit->commit_wait, commit->commit_done);
 517 }
 518
 519 int btrfs_wait_for_commit(struct btrfs_root *root, u64 transid)
 520 {
 521         struct btrfs_transaction *cur_trans = NULL, *t;
 522         int ret = 0;
 523
 524         if (transid) {
 525                 if (transid <= root->fs_info->last_trans_committed)
 526                         goto out;
 527
 528                 ret = -EINVAL;
 529                 /* find specified transaction */
 530                 spin_lock(&root->fs_info->trans_lock);
 531                 list_for_each_entry(t, &root->fs_info->trans_list, list) {
 532                         if (t->transid == transid) {
 533                                 cur_trans = t;
 534                                 atomic_inc(&cur_trans->use_count);
 535                                 ret = 0;
 536                                 break;
 537                         }
 538                         if (t->transid > transid) {
 539                                 ret = 0;
 540                                 break;
 541                         }
 542                 }
 543                 spin_unlock(&root->fs_info->trans_lock);
 544                 /* The specified transaction doesn't exist */
 545                 if (!cur_trans)
 546                         goto out;
 547         } else {
 548                 /* find newest transaction that is committing | committed */
 549                 spin_lock(&root->fs_info->trans_lock);
 550                 list_for_each_entry_reverse(t, &root->fs_info->trans_list,
 551                                             list) {
 552                         if (t->in_commit) {
 553                                 if (t->commit_done)
 554                                         break;
 555                                 cur_trans = t;
 556                                 atomic_inc(&cur_trans->use_count);
 557                                 break;
 558                         }
 559                 }
 560                 spin_unlock(&root->fs_info->trans_lock);
 561                 if (!cur_trans)
 562                         goto out;  /* nothing committing|committed */
 563         }
 564
 565         wait_for_commit(root, cur_trans);
 566         put_transaction(cur_trans);
 567 out:
 568         return ret;
 569 }
 570
 571 void btrfs_throttle(struct btrfs_root *root)
 572 {
 573         if (!atomic_read(&root->fs_info->open_ioctl_trans))
 574                 wait_current_trans(root);
 575 }
 576
 577 static int should_end_transaction(struct btrfs_trans_handle *trans,
 578                                   struct btrfs_root *root)
 579 {
 580         int ret;
 581
 582         ret = btrfs_block_rsv_check(root, &root->fs_info->global_block_rsv, 5);
 583         return ret ? 1 : 0;
 584 }
 585
 586 int btrfs_should_end_transaction(struct btrfs_trans_handle *trans,
 587                                  struct btrfs_root *root)
 588 {
 589         struct btrfs_transaction *cur_trans = trans->transaction;
 590         int updates;
 591         int err;
 592
 593         smp_mb();
 594         if (cur_trans->blocked || cur_trans->delayed_refs.flushing)
 595                 return 1;
 596
 597         updates = trans->delayed_ref_updates;
 598         trans->delayed_ref_updates = 0;
 599         if (updates) {
 600                 err = btrfs_run_delayed_refs(trans, root, updates);
 601                 if (err) /* Error code will also eval true */
 602                         return err;
 603         }
 604
 605         return should_end_transaction(trans, root);
 606 }
 607
 608 static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
 609                           struct btrfs_root *root, int throttle)
 610 {
 611         struct btrfs_transaction *cur_trans = trans->transaction;
 612         struct btrfs_fs_info *info = root->fs_info;
 613         int count = 0;
 614         int lock = (trans->type != TRANS_JOIN_NOLOCK);
 615         int err = 0;
 616
 617         if (--trans->use_count) {
 618                 trans->block_rsv = trans->orig_rsv;
 619                 return 0;
 620         }
 621
 622         /*
 623          * do the qgroup accounting as early as possible
 624          */
 625         err = btrfs_delayed_refs_qgroup_accounting(trans, info);
 626
 627         btrfs_trans_release_metadata(trans, root);
 628         trans->block_rsv = NULL;
 629         /*
 630          * the same root has to be passed to start_transaction and
 631          * end_transaction. Subvolume quota depends on this.
 632          */
 633         WARN_ON(trans->root != root);
 634
 635         if (trans->qgroup_reserved) {
 636                 btrfs_qgroup_free(root, trans->qgroup_reserved);
 637                 trans->qgroup_reserved = 0;
 638         }
 639
 640         if (!list_empty(&trans->new_bgs))
 641                 btrfs_create_pending_block_groups(trans, root);
 642
 643         while (count < 1) {
 644                 unsigned long cur = trans->delayed_ref_updates;
 645                 trans->delayed_ref_updates = 0;
 646                 if (cur &&
 647                     trans->transaction->delayed_refs.num_heads_ready > 64) {
 648                         trans->delayed_ref_updates = 0;
 649                         btrfs_run_delayed_refs(trans, root, cur);
 650                 } else {
 651                         break;
 652                 }
 653                 count++;
 654         }
 655
 656         btrfs_trans_release_metadata(trans, root);
 657         trans->block_rsv = NULL;
 658
 659         if (!list_empty(&trans->new_bgs))
 660                 btrfs_create_pending_block_groups(trans, root);
 661
 662         if (lock && !atomic_read(&root->fs_info->open_ioctl_trans) &&
 663             should_end_transaction(trans, root)) {
 664                 trans->transaction->blocked = 1;
 665                 smp_wmb();
 666         }
 667
 668         if (lock && cur_trans->blocked && !cur_trans->in_commit) {
 669                 if (throttle) {
 670                         /*
 671                          * We may race with somebody else here so end up having
 672                          * to call end_transaction on ourselves again, so inc
 673                          * our use_count.
 674                          */
 675                         trans->use_count++;
 676                         return btrfs_commit_transaction(trans, root);
 677                 } else {
 678                         wake_up_process(info->transaction_kthread);
 679                 }
 680         }
 681
 682         if (trans->type < TRANS_JOIN_NOLOCK)
 683                 sb_end_intwrite(root->fs_info->sb);
 684
 685         WARN_ON(cur_trans != info->running_transaction);
 686         WARN_ON(atomic_read(&cur_trans->num_writers) < 1);
 687         atomic_dec(&cur_trans->num_writers);
 688
 689         smp_mb();
 690         if (waitqueue_active(&cur_trans->writer_wait))
 691                 wake_up(&cur_trans->writer_wait);
 692         put_transaction(cur_trans);
 693
 694         if (current->journal_info == trans)
 695                 current->journal_info = NULL;
 696
 697         if (throttle)
 698                 btrfs_run_delayed_iputs(root);
 699
 700         if (trans->aborted ||
 701             test_bit(BTRFS_FS_STATE_ERROR, &root->fs_info->fs_state))
 702                 err = -EIO;
 703         assert_qgroups_uptodate(trans);
 704
 705         kmem_cache_free(btrfs_trans_handle_cachep, trans);
 706         return err;
 707 }
 708
 709 int btrfs_end_transaction(struct btrfs_trans_handle *trans,
 710                           struct btrfs_root *root)
 711 {
 712         int ret;
 713
 714         ret = __btrfs_end_transaction(trans, root, 0);
 715         if (ret)
 716                 return ret;
 717         return 0;
 718 }
 719
 720 int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans,
 721                                    struct btrfs_root *root)
 722 {
 723         int ret;
 724
 725         ret = __btrfs_end_transaction(trans, root, 1);
 726         if (ret)
 727                 return ret;
 728         return 0;
 729 }
 730
 731 int btrfs_end_transaction_dmeta(struct btrfs_trans_handle *trans,
 732                                 struct btrfs_root *root)
 733 {
 734         return __btrfs_end_transaction(trans, root, 1);
 735 }
 736
 737 /*
 738  * when btree blocks are allocated, they have some corresponding bits set for
 739  * them in one of two extent_io trees.  This is used to make sure all of
 740  * those extents are sent to disk but does not wait on them
 741  */
 742 int btrfs_write_marked_extents(struct btrfs_root *root,
 743                                struct extent_io_tree *dirty_pages, int mark)
 744 {
 745         int err = 0;
 746         int werr = 0;
 747         struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
 748         struct extent_state *cached_state = NULL;
 749         u64 start = 0;
 750         u64 end;
 751         struct blk_plug plug;
 752
 753         blk_start_plug(&plug);
 754         while (!find_first_extent_bit(dirty_pages, start, &start, &end,
 755                                       mark, &cached_state)) {
 756                 convert_extent_bit(dirty_pages, start, end, EXTENT_NEED_WAIT,
 757                                    mark, &cached_state, GFP_NOFS);
 758                 cached_state = NULL;
 759                 err = filemap_fdatawrite_range(mapping, start, end);
 760                 if (err)
 761                         werr = err;
 762                 cond_resched();
 763                 start = end + 1;
 764         }
 765         if (err)
 766                 werr = err;
 767         blk_finish_plug(&plug);
 768         return werr;
 769 }
 770
 771 /*
 772  * when btree blocks are allocated, they have some corresponding bits set for
 773  * them in one of two extent_io trees.  This is used to make sure all of
 774  * those extents are on disk for transaction or log commit.  We wait
 775  * on all the pages and clear them from the dirty pages state tree
 776  */
 777 int btrfs_wait_marked_extents(struct btrfs_root *root,
 778                               struct extent_io_tree *dirty_pages, int mark)
 779 {
 780         int err = 0;
 781         int werr = 0;
 782         struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
 783         struct extent_state *cached_state = NULL;
 784         u64 start = 0;
 785         u64 end;
 786
 787         while (!find_first_extent_bit(dirty_pages, start, &start, &end,
 788                                       EXTENT_NEED_WAIT, &cached_state)) {
 789                 clear_extent_bit(dirty_pages, start, end, EXTENT_NEED_WAIT,
 790                                  0, 0, &cached_state, GFP_NOFS);
 791                 err = filemap_fdatawait_range(mapping, start, end);
 792                 if (err)
 793                         werr = err;
 794                 cond_resched();
 795                 start = end + 1;
 796         }
 797         if (err)
 798                 werr = err;
 799         return werr;
 800 }
 801
 802 /*
 803  * when btree blocks are allocated, they have some corresponding bits set for
 804  * them in one of two extent_io trees.  This is used to make sure all of
 805  * those extents are on disk for transaction or log commit
 806  */
 807 int btrfs_write_and_wait_marked_extents(struct btrfs_root *root,
 808                                 struct extent_io_tree *dirty_pages, int mark)
 809 {
 810         int ret;
 811         int ret2;
 812
 813         ret = btrfs_write_marked_extents(root, dirty_pages, mark);
 814         ret2 = btrfs_wait_marked_extents(root, dirty_pages, mark);
 815
 816         if (ret)
 817                 return ret;
 818         if (ret2)
 819                 return ret2;
 820         return 0;
 821 }
 822
 823 int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans,
 824                                      struct btrfs_root *root)
 825 {
 826         if (!trans || !trans->transaction) {
 827                 struct inode *btree_inode;
 828                 btree_inode = root->fs_info->btree_inode;
 829                 return filemap_write_and_wait(btree_inode->i_mapping);
 830         }
 831         return btrfs_write_and_wait_marked_extents(root,
 832                                            &trans->transaction->dirty_pages,
 833                                            EXTENT_DIRTY);
 834 }
 835
 836 /*
 837  * this is used to update the root pointer in the tree of tree roots.
 838  *
 839  * But, in the case of the extent allocation tree, updating the root
 840  * pointer may allocate blocks which may change the root of the extent
 841  * allocation tree.
 842  *
 843  * So, this loops and repeats and makes sure the cowonly root didn't
 844  * change while the root pointer was being updated in the metadata.
 845  */
 846 static int update_cowonly_root(struct btrfs_trans_handle *trans,
 847                                struct btrfs_root *root)
 848 {
 849         int ret;
 850         u64 old_root_bytenr;
 851         u64 old_root_used;
 852         struct btrfs_root *tree_root = root->fs_info->tree_root;
 853
 854         old_root_used = btrfs_root_used(&root->root_item);
 855         btrfs_write_dirty_block_groups(trans, root);
 856
 857         while (1) {
 858                 old_root_bytenr = btrfs_root_bytenr(&root->root_item);
 859                 if (old_root_bytenr == root->node->start &&
 860                     old_root_used == btrfs_root_used(&root->root_item))
 861                         break;
 862
 863                 btrfs_set_root_node(&root->root_item, root->node);
 864                 ret = btrfs_update_root(trans, tree_root,
 865                                         &root->root_key,
 866                                         &root->root_item);
 867                 if (ret)
 868                         return ret;
 869
 870                 old_root_used = btrfs_root_used(&root->root_item);
 871                 ret = btrfs_write_dirty_block_groups(trans, root);
 872                 if (ret)
 873                         return ret;
 874         }
 875
 876         if (root != root->fs_info->extent_root)
 877                 switch_commit_root(root);
 878
 879         return 0;
 880 }
 881
 882 /*
 883  * update all the cowonly tree roots on disk
 884  *
 885  * The error handling in this function may not be obvious. Any of the
 886  * failures will cause the file system to go offline. We still need
 887  * to clean up the delayed refs.
 888  */
 889 static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans,
 890                                          struct btrfs_root *root)
 891 {
 892         struct btrfs_fs_info *fs_info = root->fs_info;
 893         struct list_head *next;
 894         struct extent_buffer *eb;
 895         int ret;
 896
 897         ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
 898         if (ret)
 899                 return ret;
 900
 901         eb = btrfs_lock_root_node(fs_info->tree_root);
 902         ret = btrfs_cow_block(trans, fs_info->tree_root, eb, NULL,
 903                               0, &eb);
 904         btrfs_tree_unlock(eb);
 905         free_extent_buffer(eb);
 906
 907         if (ret)
 908                 return ret;
 909
 910         ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
 911         if (ret)
 912                 return ret;
 913
 914         ret = btrfs_run_dev_stats(trans, root->fs_info);
 915         WARN_ON(ret);
 916         ret = btrfs_run_dev_replace(trans, root->fs_info);
 917         WARN_ON(ret);
 918
 919         ret = btrfs_run_qgroups(trans, root->fs_info);
 920         BUG_ON(ret);
 921
 922         /* run_qgroups might have added some more refs */
 923         ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
 924         BUG_ON(ret);
 925
 926         while (!list_empty(&fs_info->dirty_cowonly_roots)) {
 927                 next = fs_info->dirty_cowonly_roots.next;
 928                 list_del_init(next);
 929                 root = list_entry(next, struct btrfs_root, dirty_list);
 930
 931                 ret = update_cowonly_root(trans, root);
 932                 if (ret)
 933                         return ret;
 934         }
 935
 936         down_write(&fs_info->extent_commit_sem);
 937         switch_commit_root(fs_info->extent_root);
 938         up_write(&fs_info->extent_commit_sem);
 939
 940         btrfs_after_dev_replace_commit(fs_info);
 941
 942         return 0;
 943 }
 944
 945 /*
 946  * dead roots are old snapshots that need to be deleted.  This allocates
 947  * a dirty root struct and adds it into the list of dead roots that need to
 948  * be deleted
 949  */
 950 int btrfs_add_dead_root(struct btrfs_root *root)
 951 {
 952         spin_lock(&root->fs_info->trans_lock);
 953         list_add(&root->root_list, &root->fs_info->dead_roots);
 954         spin_unlock(&root->fs_info->trans_lock);
 955         return 0;
 956 }
 957
 958 /*
 959  * update all the cowonly tree roots on disk
 960  */
 961 static noinline int commit_fs_roots(struct btrfs_trans_handle *trans,
 962                                     struct btrfs_root *root)
 963 {
 964         struct btrfs_root *gang[8];
 965         struct btrfs_fs_info *fs_info = root->fs_info;
 966         int i;
 967         int ret;
 968         int err = 0;
 969
 970         spin_lock(&fs_info->fs_roots_radix_lock);
 971         while (1) {
 972                 ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix,
 973                                                  (void **)gang, 0,
 974                                                  ARRAY_SIZE(gang),
 975                                                  BTRFS_ROOT_TRANS_TAG);
 976                 if (ret == 0)
 977                         break;
 978                 for (i = 0; i < ret; i++) {
 979                         root = gang[i];
 980                         radix_tree_tag_clear(&fs_info->fs_roots_radix,
 981                                         (unsigned long)root->root_key.objectid,
 982                                         BTRFS_ROOT_TRANS_TAG);
 983                         spin_unlock(&fs_info->fs_roots_radix_lock);
 984
 985                         btrfs_free_log(trans, root);
 986                         btrfs_update_reloc_root(trans, root);
 987                         btrfs_orphan_commit_root(trans, root);
 988
 989                         btrfs_save_ino_cache(root, trans);
 990
 991                         /* see comments in should_cow_block() */
 992                         root->force_cow = 0;
 993                         smp_wmb();
 994
 995                         if (root->commit_root != root->node) {
 996                                 mutex_lock(&root->fs_commit_mutex);
 997                                 switch_commit_root(root);
 998                                 btrfs_unpin_free_ino(root);
 999                                 mutex_unlock(&root->fs_commit_mutex);
1000
1001                                 btrfs_set_root_node(&root->root_item,
1002                                                     root->node);
1003                         }
1004
1005                         err = btrfs_update_root(trans, fs_info->tree_root,
1006                                                 &root->root_key,
1007                                                 &root->root_item);
1008                         spin_lock(&fs_info->fs_roots_radix_lock);
1009                         if (err)
1010                                 break;
1011                 }
1012         }
1013         spin_unlock(&fs_info->fs_roots_radix_lock);
1014         return err;
1015 }
1016
1017 /*
1018  * defrag a given btree.
1019  * Every leaf in the btree is read and defragged.
1020  */
1021 int btrfs_defrag_root(struct btrfs_root *root)
1022 {
1023         struct btrfs_fs_info *info = root->fs_info;
1024         struct btrfs_trans_handle *trans;
1025         int ret;
1026
1027         if (xchg(&root->defrag_running, 1))
1028                 return 0;
1029
1030         while (1) {
1031                 trans = btrfs_start_transaction(root, 0);
1032                 if (IS_ERR(trans))
1033                         return PTR_ERR(trans);
1034
1035                 ret = btrfs_defrag_leaves(trans, root);
1036
1037                 btrfs_end_transaction(trans, root);
1038                 btrfs_btree_balance_dirty(info->tree_root);
1039                 cond_resched();
1040
1041                 if (btrfs_fs_closing(root->fs_info) || ret != -EAGAIN)
1042                         break;
1043
1044                 if (btrfs_defrag_cancelled(root->fs_info)) {
1045                         printk(KERN_DEBUG "btrfs: defrag_root cancelled\n");
1046                         ret = -EAGAIN;
1047                         break;
1048                 }
1049         }
1050         root->defrag_running = 0;
1051         return ret;
1052 }
1053
1054 /*
1055  * new snapshots need to be created at a very specific time in the
1056  * transaction commit.  This does the actual creation
1057  */
1058 static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
1059                                    struct btrfs_fs_info *fs_info,
1060                                    struct btrfs_pending_snapshot *pending)
1061 {
1062         struct btrfs_key key;
1063         struct btrfs_root_item *new_root_item;
1064         struct btrfs_root *tree_root = fs_info->tree_root;
1065         struct btrfs_root *root = pending->root;
1066         struct btrfs_root *parent_root;
1067         struct btrfs_block_rsv *rsv;
1068         struct inode *parent_inode;
1069         struct btrfs_path *path;
1070         struct btrfs_dir_item *dir_item;
1071         struct dentry *parent;
1072         struct dentry *dentry;
1073         struct extent_buffer *tmp;
1074         struct extent_buffer *old;
1075         struct timespec cur_time = CURRENT_TIME;
1076         int ret;
1077         u64 to_reserve = 0;
1078         u64 index = 0;
1079         u64 objectid;
1080         u64 root_flags;
1081         uuid_le new_uuid;
1082
1083         path = btrfs_alloc_path();
1084         if (!path) {
1085                 ret = pending->error = -ENOMEM;
1086                 goto path_alloc_fail;
1087         }
1088
1089         new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS);
1090         if (!new_root_item) {
1091                 ret = pending->error = -ENOMEM;
1092                 goto root_item_alloc_fail;
1093         }
1094
1095         ret = btrfs_find_free_objectid(tree_root, &objectid);
1096         if (ret) {
1097                 pending->error = ret;
1098                 goto no_free_objectid;
1099         }
1100
1101         btrfs_reloc_pre_snapshot(trans, pending, &to_reserve);
1102
1103         if (to_reserve > 0) {
1104                 ret = btrfs_block_rsv_add(root, &pending->block_rsv,
1105                                           to_reserve,
1106                                           BTRFS_RESERVE_NO_FLUSH);
1107                 if (ret) {
1108                         pending->error = ret;
1109                         goto no_free_objectid;
1110                 }
1111         }
1112
1113         ret = btrfs_qgroup_inherit(trans, fs_info, root->root_key.objectid,
1114                                    objectid, pending->inherit);
1115         if (ret) {
1116                 pending->error = ret;
1117                 goto no_free_objectid;
1118         }
1119
1120         key.objectid = objectid;
1121         key.offset = (u64)-1;
1122         key.type = BTRFS_ROOT_ITEM_KEY;
1123
1124         rsv = trans->block_rsv;
1125         trans->block_rsv = &pending->block_rsv;
1126
1127         dentry = pending->dentry;
1128         parent = dget_parent(dentry);
1129         parent_inode = parent->d_inode;
1130         parent_root = BTRFS_I(parent_inode)->root;
1131         record_root_in_trans(trans, parent_root);
1132
1133         /*
1134          * insert the directory item
1135          */
1136         ret = btrfs_set_inode_index(parent_inode, &index);
1137         BUG_ON(ret); /* -ENOMEM */
1138
1139         /* check if there is a file/dir which has the same name. */
1140         dir_item = btrfs_lookup_dir_item(NULL, parent_root, path,
1141                                          btrfs_ino(parent_inode),
1142                                          dentry->d_name.name,
1143                                          dentry->d_name.len, 0);
1144         if (dir_item != NULL && !IS_ERR(dir_item)) {
1145                 pending->error = -EEXIST;
1146                 goto fail;
1147         } else if (IS_ERR(dir_item)) {
1148                 ret = PTR_ERR(dir_item);
1149                 btrfs_abort_transaction(trans, root, ret);
1150                 goto fail;
1151         }
1152         btrfs_release_path(path);
1153
1154         /*
1155          * pull in the delayed directory update
1156          * and the delayed inode item
1157          * otherwise we corrupt the FS during
1158          * snapshot
1159          */
1160         ret = btrfs_run_delayed_items(trans, root);
1161         if (ret) {      /* Transaction aborted */
1162                 btrfs_abort_transaction(trans, root, ret);
1163                 goto fail;
1164         }
1165
1166         record_root_in_trans(trans, root);
1167         btrfs_set_root_last_snapshot(&root->root_item, trans->transid);
1168         memcpy(new_root_item, &root->root_item, sizeof(*new_root_item));
1169         btrfs_check_and_init_root_item(new_root_item);
1170
1171         root_flags = btrfs_root_flags(new_root_item);
1172         if (pending->readonly)
1173                 root_flags |= BTRFS_ROOT_SUBVOL_RDONLY;
1174         else
1175                 root_flags &= ~BTRFS_ROOT_SUBVOL_RDONLY;
1176         btrfs_set_root_flags(new_root_item, root_flags);
1177
1178         btrfs_set_root_generation_v2(new_root_item,
1179                         trans->transid);
1180         uuid_le_gen(&new_uuid);
1181         memcpy(new_root_item->uuid, new_uuid.b, BTRFS_UUID_SIZE);
1182         memcpy(new_root_item->parent_uuid, root->root_item.uuid,
1183                         BTRFS_UUID_SIZE);
1184         new_root_item->otime.sec = cpu_to_le64(cur_time.tv_sec);
1185         new_root_item->otime.nsec = cpu_to_le32(cur_time.tv_nsec);
1186         btrfs_set_root_otransid(new_root_item, trans->transid);
1187         memset(&new_root_item->stime, 0, sizeof(new_root_item->stime));
1188         memset(&new_root_item->rtime, 0, sizeof(new_root_item->rtime));
1189         btrfs_set_root_stransid(new_root_item, 0);
1190         btrfs_set_root_rtransid(new_root_item, 0);
1191
1192         old = btrfs_lock_root_node(root);
1193         ret = btrfs_cow_block(trans, root, old, NULL, 0, &old);
1194         if (ret) {
1195                 btrfs_tree_unlock(old);
1196                 free_extent_buffer(old);
1197                 btrfs_abort_transaction(trans, root, ret);
1198                 goto fail;
1199         }
1200
1201         btrfs_set_lock_blocking(old);
1202
1203         ret = btrfs_copy_root(trans, root, old, &tmp, objectid);
1204         /* clean up in any case */
1205         btrfs_tree_unlock(old);
1206         free_extent_buffer(old);
1207         if (ret) {
1208                 btrfs_abort_transaction(trans, root, ret);
1209                 goto fail;
1210         }
1211
1212         /* see comments in should_cow_block() */
1213         root->force_cow = 1;
1214         smp_wmb();
1215
1216         btrfs_set_root_node(new_root_item, tmp);
1217         /* record when the snapshot was created in key.offset */
1218         key.offset = trans->transid;
1219         ret = btrfs_insert_root(trans, tree_root, &key, new_root_item);
1220         btrfs_tree_unlock(tmp);
1221         free_extent_buffer(tmp);
1222         if (ret) {
1223                 btrfs_abort_transaction(trans, root, ret);
1224                 goto fail;
1225         }
1226
1227         /*
1228          * insert root back/forward references
1229          */
1230         ret = btrfs_add_root_ref(trans, tree_root, objectid,
1231                                  parent_root->root_key.objectid,
1232                                  btrfs_ino(parent_inode), index,
1233                                  dentry->d_name.name, dentry->d_name.len);
1234         if (ret) {
1235                 btrfs_abort_transaction(trans, root, ret);
1236                 goto fail;
1237         }
1238
1239         key.offset = (u64)-1;
1240         pending->snap = btrfs_read_fs_root_no_name(root->fs_info, &key);
1241         if (IS_ERR(pending->snap)) {
1242                 ret = PTR_ERR(pending->snap);
1243                 btrfs_abort_transaction(trans, root, ret);
1244                 goto fail;
1245         }
1246
1247         ret = btrfs_reloc_post_snapshot(trans, pending);
1248         if (ret) {
1249                 btrfs_abort_transaction(trans, root, ret);
1250                 goto fail;
1251         }
1252
1253         ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
1254         if (ret) {
1255                 btrfs_abort_transaction(trans, root, ret);
1256                 goto fail;
1257         }
1258
1259         ret = btrfs_insert_dir_item(trans, parent_root,
1260                                     dentry->d_name.name, dentry->d_name.len,
1261                                     parent_inode, &key,
1262                                     BTRFS_FT_DIR, index);
1263         /* We have check then name at the beginning, so it is impossible. */
1264         BUG_ON(ret == -EEXIST || ret == -EOVERFLOW);
1265         if (ret) {
1266                 btrfs_abort_transaction(trans, root, ret);
1267                 goto fail;
1268         }
1269
1270         btrfs_i_size_write(parent_inode, parent_inode->i_size +
1271                                          dentry->d_name.len * 2);
1272         parent_inode->i_mtime = parent_inode->i_ctime = CURRENT_TIME;
1273         ret = btrfs_update_inode_fallback(trans, parent_root, parent_inode);
1274         if (ret)
1275                 btrfs_abort_transaction(trans, root, ret);
1276 fail:
1277         dput(parent);
1278         trans->block_rsv = rsv;
1279 no_free_objectid:
1280         kfree(new_root_item);
1281 root_item_alloc_fail:
1282         btrfs_free_path(path);
1283 path_alloc_fail:
1284         btrfs_block_rsv_release(root, &pending->block_rsv, (u64)-1);
1285         return ret;
1286 }
1287
1288 /*
1289  * create all the snapshots we've scheduled for creation
1290  */
1291 static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans,
1292                                              struct btrfs_fs_info *fs_info)
1293 {
1294         struct btrfs_pending_snapshot *pending;
1295         struct list_head *head = &trans->transaction->pending_snapshots;
1296
1297         list_for_each_entry(pending, head, list)
1298                 create_pending_snapshot(trans, fs_info, pending);
1299         return 0;
1300 }
1301
1302 static void update_super_roots(struct btrfs_root *root)
1303 {
1304         struct btrfs_root_item *root_item;
1305         struct btrfs_super_block *super;
1306
1307         super = root->fs_info->super_copy;
1308
1309         root_item = &root->fs_info->chunk_root->root_item;
1310         super->chunk_root = root_item->bytenr;
1311         super->chunk_root_generation = root_item->generation;
1312         super->chunk_root_level = root_item->level;
1313
1314         root_item = &root->fs_info->tree_root->root_item;
1315         super->root = root_item->bytenr;
1316         super->generation = root_item->generation;
1317         super->root_level = root_item->level;
1318         if (btrfs_test_opt(root, SPACE_CACHE))
1319                 super->cache_generation = root_item->generation;
1320 }
1321
1322 int btrfs_transaction_in_commit(struct btrfs_fs_info *info)
1323 {
1324         int ret = 0;
1325         spin_lock(&info->trans_lock);
1326         if (info->running_transaction)
1327                 ret = info->running_transaction->in_commit;
1328         spin_unlock(&info->trans_lock);
1329         return ret;
1330 }
1331
1332 int btrfs_transaction_blocked(struct btrfs_fs_info *info)
1333 {
1334         int ret = 0;
1335         spin_lock(&info->trans_lock);
1336         if (info->running_transaction)
1337                 ret = info->running_transaction->blocked;
1338         spin_unlock(&info->trans_lock);
1339         return ret;
1340 }
1341
1342 /*
1343  * wait for the current transaction commit to start and block subsequent
1344  * transaction joins
1345  */
1346 static void wait_current_trans_commit_start(struct btrfs_root *root,
1347                                             struct btrfs_transaction *trans)
1348 {
1349         wait_event(root->fs_info->transaction_blocked_wait, trans->in_commit);
1350 }
1351
1352 /*
1353  * wait for the current transaction to start and then become unblocked.
1354  * caller holds ref.
1355  */
1356 static void wait_current_trans_commit_start_and_unblock(struct btrfs_root *root,
1357                                          struct btrfs_transaction *trans)
1358 {
1359         wait_event(root->fs_info->transaction_wait,
1360                    trans->commit_done || (trans->in_commit && !trans->blocked));
1361 }
1362
1363 /*
1364  * commit transactions asynchronously. once btrfs_commit_transaction_async
1365  * returns, any subsequent transaction will not be allowed to join.
1366  */
1367 struct btrfs_async_commit {
1368         struct btrfs_trans_handle *newtrans;
1369         struct btrfs_root *root;
1370         struct work_struct work;
1371 };
1372
1373 static void do_async_commit(struct work_struct *work)
1374 {
1375         struct btrfs_async_commit *ac =
1376                 container_of(work, struct btrfs_async_commit, work);
1377
1378         /*
1379          * We've got freeze protection passed with the transaction.
1380          * Tell lockdep about it.
1381          */
1382         if (ac->newtrans->type < TRANS_JOIN_NOLOCK)
1383                 rwsem_acquire_read(
1384                      &ac->root->fs_info->sb->s_writers.lock_map[SB_FREEZE_FS-1],
1385                      0, 1, _THIS_IP_);
1386
1387         current->journal_info = ac->newtrans;
1388
1389         btrfs_commit_transaction(ac->newtrans, ac->root);
1390         kfree(ac);
1391 }
1392
1393 int btrfs_commit_transaction_async(struct btrfs_trans_handle *trans,
1394                                    struct btrfs_root *root,
1395                                    int wait_for_unblock)
1396 {
1397         struct btrfs_async_commit *ac;
1398         struct btrfs_transaction *cur_trans;
1399
1400         ac = kmalloc(sizeof(*ac), GFP_NOFS);
1401         if (!ac)
1402                 return -ENOMEM;
1403
1404         INIT_WORK(&ac->work, do_async_commit);
1405         ac->root = root;
1406         ac->newtrans = btrfs_join_transaction(root);
1407         if (IS_ERR(ac->newtrans)) {
1408                 int err = PTR_ERR(ac->newtrans);
1409                 kfree(ac);
1410                 return err;
1411         }
1412
1413         /* take transaction reference */
1414         cur_trans = trans->transaction;
1415         atomic_inc(&cur_trans->use_count);
1416
1417         btrfs_end_transaction(trans, root);
1418
1419         /*
1420          * Tell lockdep we've released the freeze rwsem, since the
1421          * async commit thread will be the one to unlock it.
1422          */
1423         if (trans->type < TRANS_JOIN_NOLOCK)
1424                 rwsem_release(
1425                         &root->fs_info->sb->s_writers.lock_map[SB_FREEZE_FS-1],
1426                         1, _THIS_IP_);
1427
1428         schedule_work(&ac->work);
1429
1430         /* wait for transaction to start and unblock */
1431         if (wait_for_unblock)
1432                 wait_current_trans_commit_start_and_unblock(root, cur_trans);
1433         else
1434                 wait_current_trans_commit_start(root, cur_trans);
1435
1436         if (current->journal_info == trans)
1437                 current->journal_info = NULL;
1438
1439         put_transaction(cur_trans);
1440         return 0;
1441 }
1442
1443
1444 static void cleanup_transaction(struct btrfs_trans_handle *trans,
1445                                 struct btrfs_root *root, int err)
1446 {
1447         struct btrfs_transaction *cur_trans = trans->transaction;
1448
1449         WARN_ON(trans->use_count > 1);
1450
1451         btrfs_abort_transaction(trans, root, err);
1452
1453         spin_lock(&root->fs_info->trans_lock);
1454         list_del_init(&cur_trans->list);
1455         if (cur_trans == root->fs_info->running_transaction) {
1456                 root->fs_info->running_transaction = NULL;
1457                 root->fs_info->trans_no_join = 0;
1458         }
1459         spin_unlock(&root->fs_info->trans_lock);
1460
1461         btrfs_cleanup_one_transaction(trans->transaction, root);
1462
1463         put_transaction(cur_trans);
1464         put_transaction(cur_trans);
1465
1466         trace_btrfs_transaction_commit(root);
1467
1468         btrfs_scrub_continue(root);
1469
1470         if (current->journal_info == trans)
1471                 current->journal_info = NULL;
1472
1473         kmem_cache_free(btrfs_trans_handle_cachep, trans);
1474 }
1475
1476 static int btrfs_flush_all_pending_stuffs(struct btrfs_trans_handle *trans,
1477                                           struct btrfs_root *root)
1478 {
1479         int flush_on_commit = btrfs_test_opt(root, FLUSHONCOMMIT);
1480         int snap_pending = 0;
1481         int ret;
1482
1483         if (!flush_on_commit) {
1484                 spin_lock(&root->fs_info->trans_lock);
1485                 if (!list_empty(&trans->transaction->pending_snapshots))
1486                         snap_pending = 1;
1487                 spin_unlock(&root->fs_info->trans_lock);
1488         }
1489
1490         if (flush_on_commit || snap_pending) {
1491                 ret = btrfs_start_delalloc_inodes(root, 1);
1492                 if (ret)
1493                         return ret;
1494                 btrfs_wait_ordered_extents(root, 1);
1495         }
1496
1497         ret = btrfs_run_delayed_items(trans, root);
1498         if (ret)
1499                 return ret;
1500
1501         /*
1502          * running the delayed items may have added new refs. account
1503          * them now so that they hinder processing of more delayed refs
1504          * as little as possible.
1505          */
1506         btrfs_delayed_refs_qgroup_accounting(trans, root->fs_info);
1507
1508         /*
1509          * rename don't use btrfs_join_transaction, so, once we
1510          * set the transaction to blocked above, we aren't going
1511          * to get any new ordered operations.  We can safely run
1512          * it here and no for sure that nothing new will be added
1513          * to the list
1514          */
1515         ret = btrfs_run_ordered_operations(trans, root, 1);
1516
1517         return ret;
1518 }
1519
1520 /*
1521  * btrfs_transaction state sequence:
1522  *    in_commit = 0, blocked = 0  (initial)
1523  *    in_commit = 1, blocked = 1
1524  *    blocked = 0
1525  *    commit_done = 1
1526  */
1527 int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
1528                              struct btrfs_root *root)
1529 {
1530         unsigned long joined = 0;
1531         struct btrfs_transaction *cur_trans = trans->transaction;
1532         struct btrfs_transaction *prev_trans = NULL;
1533         DEFINE_WAIT(wait);
1534         int ret;
1535         int should_grow = 0;
1536         unsigned long now = get_seconds();
1537
1538         ret = btrfs_run_ordered_operations(trans, root, 0);
1539         if (ret) {
1540                 btrfs_abort_transaction(trans, root, ret);
1541                 btrfs_end_transaction(trans, root);
1542                 return ret;
1543         }
1544
1545         /* Stop the commit early if ->aborted is set */
1546         if (unlikely(ACCESS_ONCE(cur_trans->aborted))) {
1547                 ret = cur_trans->aborted;
1548                 btrfs_end_transaction(trans, root);
1549                 return ret;
1550         }
1551
1552         /* make a pass through all the delayed refs we have so far
1553          * any runnings procs may add more while we are here
1554          */
1555         ret = btrfs_run_delayed_refs(trans, root, 0);
1556         if (ret) {
1557                 btrfs_end_transaction(trans, root);
1558                 return ret;
1559         }
1560
1561         btrfs_trans_release_metadata(trans, root);
1562         trans->block_rsv = NULL;
1563         if (trans->qgroup_reserved) {
1564                 btrfs_qgroup_free(root, trans->qgroup_reserved);
1565                 trans->qgroup_reserved = 0;
1566         }
1567
1568         cur_trans = trans->transaction;
1569
1570         /*
1571          * set the flushing flag so procs in this transaction have to
1572          * start sending their work down.
1573          */
1574         cur_trans->delayed_refs.flushing = 1;
1575
1576         if (!list_empty(&trans->new_bgs))
1577                 btrfs_create_pending_block_groups(trans, root);
1578
1579         ret = btrfs_run_delayed_refs(trans, root, 0);
1580         if (ret) {
1581                 btrfs_end_transaction(trans, root);
1582                 return ret;
1583         }
1584
1585         spin_lock(&cur_trans->commit_lock);
1586         if (cur_trans->in_commit) {
1587                 spin_unlock(&cur_trans->commit_lock);
1588                 atomic_inc(&cur_trans->use_count);
1589                 ret = btrfs_end_transaction(trans, root);
1590
1591                 wait_for_commit(root, cur_trans);
1592
1593                 put_transaction(cur_trans);
1594
1595                 return ret;
1596         }
1597
1598         trans->transaction->in_commit = 1;
1599         trans->transaction->blocked = 1;
1600         spin_unlock(&cur_trans->commit_lock);
1601         wake_up(&root->fs_info->transaction_blocked_wait);
1602
1603         spin_lock(&root->fs_info->trans_lock);
1604         if (cur_trans->list.prev != &root->fs_info->trans_list) {
1605                 prev_trans = list_entry(cur_trans->list.prev,
1606                                         struct btrfs_transaction, list);
1607                 if (!prev_trans->commit_done) {
1608                         atomic_inc(&prev_trans->use_count);
1609                         spin_unlock(&root->fs_info->trans_lock);
1610
1611                         wait_for_commit(root, prev_trans);
1612
1613                         put_transaction(prev_trans);
1614                 } else {
1615                         spin_unlock(&root->fs_info->trans_lock);
1616                 }
1617         } else {
1618                 spin_unlock(&root->fs_info->trans_lock);
1619         }
1620
1621         if (!btrfs_test_opt(root, SSD) &&
1622             (now < cur_trans->start_time || now - cur_trans->start_time < 1))
1623                 should_grow = 1;
1624
1625         do {
1626                 joined = cur_trans->num_joined;
1627
1628                 WARN_ON(cur_trans != trans->transaction);
1629
1630                 ret = btrfs_flush_all_pending_stuffs(trans, root);
1631                 if (ret)
1632                         goto cleanup_transaction;
1633
1634                 prepare_to_wait(&cur_trans->writer_wait, &wait,
1635                                 TASK_UNINTERRUPTIBLE);
1636
1637                 if (atomic_read(&cur_trans->num_writers) > 1)
1638                         schedule_timeout(MAX_SCHEDULE_TIMEOUT);
1639                 else if (should_grow)
1640                         schedule_timeout(1);
1641
1642                 finish_wait(&cur_trans->writer_wait, &wait);
1643         } while (atomic_read(&cur_trans->num_writers) > 1 ||
1644                  (should_grow && cur_trans->num_joined != joined));
1645
1646         ret = btrfs_flush_all_pending_stuffs(trans, root);
1647         if (ret)
1648                 goto cleanup_transaction;
1649
1650         /*
1651          * Ok now we need to make sure to block out any other joins while we
1652          * commit the transaction.  We could have started a join before setting
1653          * no_join so make sure to wait for num_writers to == 1 again.
1654          */
1655         spin_lock(&root->fs_info->trans_lock);
1656         root->fs_info->trans_no_join = 1;
1657         spin_unlock(&root->fs_info->trans_lock);
1658         wait_event(cur_trans->writer_wait,
1659                    atomic_read(&cur_trans->num_writers) == 1);
1660
1661         /* ->aborted might be set after the previous check, so check it */
1662         if (unlikely(ACCESS_ONCE(cur_trans->aborted))) {
1663                 ret = cur_trans->aborted;
1664                 goto cleanup_transaction;
1665         }
1666         /*
1667          * the reloc mutex makes sure that we stop
1668          * the balancing code from coming in and moving
1669          * extents around in the middle of the commit
1670          */
1671         mutex_lock(&root->fs_info->reloc_mutex);
1672
1673         /*
1674          * We needn't worry about the delayed items because we will
1675          * deal with them in create_pending_snapshot(), which is the
1676          * core function of the snapshot creation.
1677          */
1678         ret = create_pending_snapshots(trans, root->fs_info);
1679         if (ret) {
1680                 mutex_unlock(&root->fs_info->reloc_mutex);
1681                 goto cleanup_transaction;
1682         }
1683
1684         /*
1685          * We insert the dir indexes of the snapshots and update the inode
1686          * of the snapshots' parents after the snapshot creation, so there
1687          * are some delayed items which are not dealt with. Now deal with
1688          * them.
1689          *
1690          * We needn't worry that this operation will corrupt the snapshots,
1691          * because all the tree which are snapshoted will be forced to COW
1692          * the nodes and leaves.
1693          */
1694         ret = btrfs_run_delayed_items(trans, root);
1695         if (ret) {
1696                 mutex_unlock(&root->fs_info->reloc_mutex);
1697                 goto cleanup_transaction;
1698         }
1699
1700         ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
1701         if (ret) {
1702                 mutex_unlock(&root->fs_info->reloc_mutex);
1703                 goto cleanup_transaction;
1704         }
1705
1706         /*
1707          * make sure none of the code above managed to slip in a
1708          * delayed item
1709          */
1710         btrfs_assert_delayed_root_empty(root);
1711
1712         WARN_ON(cur_trans != trans->transaction);
1713
1714         btrfs_scrub_pause(root);
1715         /* btrfs_commit_tree_roots is responsible for getting the
1716          * various roots consistent with each other.  Every pointer
1717          * in the tree of tree roots has to point to the most up to date
1718          * root for every subvolume and other tree.  So, we have to keep
1719          * the tree logging code from jumping in and changing any
1720          * of the trees.
1721          *
1722          * At this point in the commit, there can't be any tree-log
1723          * writers, but a little lower down we drop the trans mutex
1724          * and let new people in.  By holding the tree_log_mutex
1725          * from now until after the super is written, we avoid races
1726          * with the tree-log code.
1727          */
1728         mutex_lock(&root->fs_info->tree_log_mutex);
1729
1730         ret = commit_fs_roots(trans, root);
1731         if (ret) {
1732                 mutex_unlock(&root->fs_info->tree_log_mutex);
1733                 mutex_unlock(&root->fs_info->reloc_mutex);
1734                 goto cleanup_transaction;
1735         }
1736
1737         /* commit_fs_roots gets rid of all the tree log roots, it is now
1738          * safe to free the root of tree log roots
1739          */
1740         btrfs_free_log_root_tree(trans, root->fs_info);
1741
1742         ret = commit_cowonly_roots(trans, root);
1743         if (ret) {
1744                 mutex_unlock(&root->fs_info->tree_log_mutex);
1745                 mutex_unlock(&root->fs_info->reloc_mutex);
1746                 goto cleanup_transaction;
1747         }
1748
1749         /*
1750          * The tasks which save the space cache and inode cache may also
1751          * update ->aborted, check it.
1752          */
1753         if (unlikely(ACCESS_ONCE(cur_trans->aborted))) {
1754                 ret = cur_trans->aborted;
1755                 mutex_unlock(&root->fs_info->tree_log_mutex);
1756                 mutex_unlock(&root->fs_info->reloc_mutex);
1757                 goto cleanup_transaction;
1758         }
1759
1760         btrfs_prepare_extent_commit(trans, root);
1761
1762         cur_trans = root->fs_info->running_transaction;
1763
1764         btrfs_set_root_node(&root->fs_info->tree_root->root_item,
1765                             root->fs_info->tree_root->node);
1766         switch_commit_root(root->fs_info->tree_root);
1767
1768         btrfs_set_root_node(&root->fs_info->chunk_root->root_item,
1769                             root->fs_info->chunk_root->node);
1770         switch_commit_root(root->fs_info->chunk_root);
1771
1772         assert_qgroups_uptodate(trans);
1773         update_super_roots(root);
1774
1775         if (!root->fs_info->log_root_recovering) {
1776                 btrfs_set_super_log_root(root->fs_info->super_copy, 0);
1777                 btrfs_set_super_log_root_level(root->fs_info->super_copy, 0);
1778         }
1779
1780         memcpy(root->fs_info->super_for_commit, root->fs_info->super_copy,
1781                sizeof(*root->fs_info->super_copy));
1782
1783         trans->transaction->blocked = 0;
1784         spin_lock(&root->fs_info->trans_lock);
1785         root->fs_info->running_transaction = NULL;
1786         root->fs_info->trans_no_join = 0;
1787         spin_unlock(&root->fs_info->trans_lock);
1788         mutex_unlock(&root->fs_info->reloc_mutex);
1789
1790         wake_up(&root->fs_info->transaction_wait);
1791
1792         ret = btrfs_write_and_wait_transaction(trans, root);
1793         if (ret) {
1794                 btrfs_error(root->fs_info, ret,
1795                             "Error while writing out transaction.");
1796                 mutex_unlock(&root->fs_info->tree_log_mutex);
1797                 goto cleanup_transaction;
1798         }
1799
1800         ret = write_ctree_super(trans, root, 0);
1801         if (ret) {
1802                 mutex_unlock(&root->fs_info->tree_log_mutex);
1803                 goto cleanup_transaction;
1804         }
1805
1806         /*
1807          * the super is written, we can safely allow the tree-loggers
1808          * to go about their business
1809          */
1810         mutex_unlock(&root->fs_info->tree_log_mutex);
1811
1812         btrfs_finish_extent_commit(trans, root);
1813
1814         cur_trans->commit_done = 1;
1815
1816         root->fs_info->last_trans_committed = cur_trans->transid;
1817
1818         wake_up(&cur_trans->commit_wait);
1819
1820         spin_lock(&root->fs_info->trans_lock);
1821         list_del_init(&cur_trans->list);
1822         spin_unlock(&root->fs_info->trans_lock);
1823
1824         put_transaction(cur_trans);
1825         put_transaction(cur_trans);
1826
1827         if (trans->type < TRANS_JOIN_NOLOCK)
1828                 sb_end_intwrite(root->fs_info->sb);
1829
1830         trace_btrfs_transaction_commit(root);
1831
1832         btrfs_scrub_continue(root);
1833
1834         if (current->journal_info == trans)
1835                 current->journal_info = NULL;
1836
1837         kmem_cache_free(btrfs_trans_handle_cachep, trans);
1838
1839         if (current != root->fs_info->transaction_kthread)
1840                 btrfs_run_delayed_iputs(root);
1841
1842         return ret;
1843
1844 cleanup_transaction:
1845         btrfs_trans_release_metadata(trans, root);
1846         trans->block_rsv = NULL;
1847         if (trans->qgroup_reserved) {
1848                 btrfs_qgroup_free(root, trans->qgroup_reserved);
1849                 trans->qgroup_reserved = 0;
1850         }
1851         btrfs_printk(root->fs_info, "Skipping commit of aborted transaction.\n");
1852 //      WARN_ON(1);
1853         if (current->journal_info == trans)
1854                 current->journal_info = NULL;
1855         cleanup_transaction(trans, root, ret);
1856
1857         return ret;
1858 }
1859
1860 /*
1861  * interface function to delete all the snapshots we have scheduled for deletion
1862  */
1863 int btrfs_clean_old_snapshots(struct btrfs_root *root)
1864 {
1865         LIST_HEAD(list);
1866         struct btrfs_fs_info *fs_info = root->fs_info;
1867
1868         spin_lock(&fs_info->trans_lock);
1869         list_splice_init(&fs_info->dead_roots, &list);
1870         spin_unlock(&fs_info->trans_lock);
1871
1872         while (!list_empty(&list)) {
1873                 int ret;
1874
1875                 root = list_entry(list.next, struct btrfs_root, root_list);
1876                 list_del(&root->root_list);
1877
1878                 btrfs_kill_all_delayed_nodes(root);
1879
1880                 if (btrfs_header_backref_rev(root->node) <
1881                     BTRFS_MIXED_BACKREF_REV)
1882                         ret = btrfs_drop_snapshot(root, NULL, 0, 0);
1883                 else
1884                         ret =btrfs_drop_snapshot(root, NULL, 1, 0);
1885                 BUG_ON(ret < 0);
1886         }
1887         return 0;
1888 }