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 "ctree.h"
  26 #include "disk-io.h"
  27 #include "transaction.h"
  28 #include "locking.h"
  29 #include "tree-log.h"
  30 #include "inode-map.h"
  31
  32 #define BTRFS_ROOT_TRANS_TAG 0
  33
  34 static noinline void put_transaction(struct btrfs_transaction *transaction)
  35 {
  36         WARN_ON(atomic_read(&transaction->use_count) == 0);
  37         if (atomic_dec_and_test(&transaction->use_count)) {
  38                 BUG_ON(!list_empty(&transaction->list));
  39                 memset(transaction, 0, sizeof(*transaction));
  40                 kmem_cache_free(btrfs_transaction_cachep, transaction);
  41         }
  42 }
  43
  44 static noinline void switch_commit_root(struct btrfs_root *root)
  45 {
  46         free_extent_buffer(root->commit_root);
  47         root->commit_root = btrfs_root_node(root);
  48 }
  49
  50 /*
  51  * either allocate a new transaction or hop into the existing one
  52  */
  53 static noinline int join_transaction(struct btrfs_root *root, int nofail)
  54 {
  55         struct btrfs_transaction *cur_trans;
  56
  57         spin_lock(&root->fs_info->trans_lock);
  58         if (root->fs_info->trans_no_join) {
  59                 if (!nofail) {
  60                         spin_unlock(&root->fs_info->trans_lock);
  61                         return -EBUSY;
  62                 }
  63         }
  64
  65         cur_trans = root->fs_info->running_transaction;
  66         if (cur_trans) {
  67                 atomic_inc(&cur_trans->use_count);
  68                 atomic_inc(&cur_trans->num_writers);
  69                 cur_trans->num_joined++;
  70                 spin_unlock(&root->fs_info->trans_lock);
  71                 return 0;
  72         }
  73         spin_unlock(&root->fs_info->trans_lock);
  74
  75         cur_trans = kmem_cache_alloc(btrfs_transaction_cachep, GFP_NOFS);
  76         if (!cur_trans)
  77                 return -ENOMEM;
  78         spin_lock(&root->fs_info->trans_lock);
  79         if (root->fs_info->running_transaction) {
  80                 kmem_cache_free(btrfs_transaction_cachep, cur_trans);
  81                 cur_trans = root->fs_info->running_transaction;
  82                 atomic_inc(&cur_trans->use_count);
  83                 atomic_inc(&cur_trans->num_writers);
  84                 cur_trans->num_joined++;
  85                 spin_unlock(&root->fs_info->trans_lock);
  86                 return 0;
  87         }
  88         atomic_set(&cur_trans->num_writers, 1);
  89         cur_trans->num_joined = 0;
  90         init_waitqueue_head(&cur_trans->writer_wait);
  91         init_waitqueue_head(&cur_trans->commit_wait);
  92         cur_trans->in_commit = 0;
  93         cur_trans->blocked = 0;
  94         /*
  95          * One for this trans handle, one so it will live on until we
  96          * commit the transaction.
  97          */
  98         atomic_set(&cur_trans->use_count, 2);
  99         cur_trans->commit_done = 0;
 100         cur_trans->start_time = get_seconds();
 101
 102         cur_trans->delayed_refs.root = RB_ROOT;
 103         cur_trans->delayed_refs.num_entries = 0;
 104         cur_trans->delayed_refs.num_heads_ready = 0;
 105         cur_trans->delayed_refs.num_heads = 0;
 106         cur_trans->delayed_refs.flushing = 0;
 107         cur_trans->delayed_refs.run_delayed_start = 0;
 108         spin_lock_init(&cur_trans->commit_lock);
 109         spin_lock_init(&cur_trans->delayed_refs.lock);
 110
 111         INIT_LIST_HEAD(&cur_trans->pending_snapshots);
 112         list_add_tail(&cur_trans->list, &root->fs_info->trans_list);
 113         extent_io_tree_init(&cur_trans->dirty_pages,
 114                              root->fs_info->btree_inode->i_mapping);
 115         root->fs_info->generation++;
 116         cur_trans->transid = root->fs_info->generation;
 117         root->fs_info->running_transaction = cur_trans;
 118         spin_unlock(&root->fs_info->trans_lock);
 119
 120         return 0;
 121 }
 122
 123 /*
 124  * this does all the record keeping required to make sure that a reference
 125  * counted root is properly recorded in a given transaction.  This is required
 126  * to make sure the old root from before we joined the transaction is deleted
 127  * when the transaction commits
 128  */
 129 static int record_root_in_trans(struct btrfs_trans_handle *trans,
 130                                struct btrfs_root *root)
 131 {
 132         if (root->ref_cows && root->last_trans < trans->transid) {
 133                 WARN_ON(root == root->fs_info->extent_root);
 134                 WARN_ON(root->commit_root != root->node);
 135
 136                 /*
 137                  * see below for in_trans_setup usage rules
 138                  * we have the reloc mutex held now, so there
 139                  * is only one writer in this function
 140                  */
 141                 root->in_trans_setup = 1;
 142
 143                 /* make sure readers find in_trans_setup before
 144                  * they find our root->last_trans update
 145                  */
 146                 smp_wmb();
 147
 148                 spin_lock(&root->fs_info->fs_roots_radix_lock);
 149                 if (root->last_trans == trans->transid) {
 150                         spin_unlock(&root->fs_info->fs_roots_radix_lock);
 151                         return 0;
 152                 }
 153                 radix_tree_tag_set(&root->fs_info->fs_roots_radix,
 154                            (unsigned long)root->root_key.objectid,
 155                            BTRFS_ROOT_TRANS_TAG);
 156                 spin_unlock(&root->fs_info->fs_roots_radix_lock);
 157                 root->last_trans = trans->transid;
 158
 159                 /* this is pretty tricky.  We don't want to
 160                  * take the relocation lock in btrfs_record_root_in_trans
 161                  * unless we're really doing the first setup for this root in
 162                  * this transaction.
 163                  *
 164                  * Normally we'd use root->last_trans as a flag to decide
 165                  * if we want to take the expensive mutex.
 166                  *
 167                  * But, we have to set root->last_trans before we
 168                  * init the relocation root, otherwise, we trip over warnings
 169                  * in ctree.c.  The solution used here is to flag ourselves
 170                  * with root->in_trans_setup.  When this is 1, we're still
 171                  * fixing up the reloc trees and everyone must wait.
 172                  *
 173                  * When this is zero, they can trust root->last_trans and fly
 174                  * through btrfs_record_root_in_trans without having to take the
 175                  * lock.  smp_wmb() makes sure that all the writes above are
 176                  * done before we pop in the zero below
 177                  */
 178                 btrfs_init_reloc_root(trans, root);
 179                 smp_wmb();
 180                 root->in_trans_setup = 0;
 181         }
 182         return 0;
 183 }
 184
 185
 186 int btrfs_record_root_in_trans(struct btrfs_trans_handle *trans,
 187                                struct btrfs_root *root)
 188 {
 189         if (!root->ref_cows)
 190                 return 0;
 191
 192         /*
 193          * see record_root_in_trans for comments about in_trans_setup usage
 194          * and barriers
 195          */
 196         smp_rmb();
 197         if (root->last_trans == trans->transid &&
 198             !root->in_trans_setup)
 199                 return 0;
 200
 201         mutex_lock(&root->fs_info->reloc_mutex);
 202         record_root_in_trans(trans, root);
 203         mutex_unlock(&root->fs_info->reloc_mutex);
 204
 205         return 0;
 206 }
 207
 208 /* wait for commit against the current transaction to become unblocked
 209  * when this is done, it is safe to start a new transaction, but the current
 210  * transaction might not be fully on disk.
 211  */
 212 static void wait_current_trans(struct btrfs_root *root)
 213 {
 214         struct btrfs_transaction *cur_trans;
 215
 216         spin_lock(&root->fs_info->trans_lock);
 217         cur_trans = root->fs_info->running_transaction;
 218         if (cur_trans && cur_trans->blocked) {
 219                 DEFINE_WAIT(wait);
 220                 atomic_inc(&cur_trans->use_count);
 221                 spin_unlock(&root->fs_info->trans_lock);
 222                 while (1) {
 223                         prepare_to_wait(&root->fs_info->transaction_wait, &wait,
 224                                         TASK_UNINTERRUPTIBLE);
 225                         if (!cur_trans->blocked)
 226                                 break;
 227                         schedule();
 228                 }
 229                 finish_wait(&root->fs_info->transaction_wait, &wait);
 230                 put_transaction(cur_trans);
 231         } else {
 232                 spin_unlock(&root->fs_info->trans_lock);
 233         }
 234 }
 235
 236 enum btrfs_trans_type {
 237         TRANS_START,
 238         TRANS_JOIN,
 239         TRANS_USERSPACE,
 240         TRANS_JOIN_NOLOCK,
 241 };
 242
 243 static int may_wait_transaction(struct btrfs_root *root, int type)
 244 {
 245         if (root->fs_info->log_root_recovering)
 246                 return 0;
 247
 248         if (type == TRANS_USERSPACE)
 249                 return 1;
 250
 251         if (type == TRANS_START &&
 252             !atomic_read(&root->fs_info->open_ioctl_trans))
 253                 return 1;
 254
 255         return 0;
 256 }
 257
 258 static struct btrfs_trans_handle *start_transaction(struct btrfs_root *root,
 259                                                     u64 num_items, int type)
 260 {
 261         struct btrfs_trans_handle *h;
 262         struct btrfs_transaction *cur_trans;
 263         u64 num_bytes = 0;
 264         int ret;
 265
 266         if (root->fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR)
 267                 return ERR_PTR(-EROFS);
 268
 269         if (current->journal_info) {
 270                 WARN_ON(type != TRANS_JOIN && type != TRANS_JOIN_NOLOCK);
 271                 h = current->journal_info;
 272                 h->use_count++;
 273                 h->orig_rsv = h->block_rsv;
 274                 h->block_rsv = NULL;
 275                 goto got_it;
 276         }
 277
 278         /*
 279          * Do the reservation before we join the transaction so we can do all
 280          * the appropriate flushing if need be.
 281          */
 282         if (num_items > 0 && root != root->fs_info->chunk_root) {
 283                 num_bytes = btrfs_calc_trans_metadata_size(root, num_items);
 284                 ret = btrfs_block_rsv_add(NULL, root,
 285                                           &root->fs_info->trans_block_rsv,
 286                                           num_bytes);
 287                 if (ret)
 288                         return ERR_PTR(ret);
 289         }
 290 again:
 291         h = kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS);
 292         if (!h)
 293                 return ERR_PTR(-ENOMEM);
 294
 295         if (may_wait_transaction(root, type))
 296                 wait_current_trans(root);
 297
 298         do {
 299                 ret = join_transaction(root, type == TRANS_JOIN_NOLOCK);
 300                 if (ret == -EBUSY)
 301                         wait_current_trans(root);
 302         } while (ret == -EBUSY);
 303
 304         if (ret < 0) {
 305                 kmem_cache_free(btrfs_trans_handle_cachep, h);
 306                 return ERR_PTR(ret);
 307         }
 308
 309         cur_trans = root->fs_info->running_transaction;
 310
 311         h->transid = cur_trans->transid;
 312         h->transaction = cur_trans;
 313         h->blocks_used = 0;
 314         h->bytes_reserved = 0;
 315         h->delayed_ref_updates = 0;
 316         h->use_count = 1;
 317         h->block_rsv = NULL;
 318         h->orig_rsv = NULL;
 319
 320         smp_mb();
 321         if (cur_trans->blocked && may_wait_transaction(root, type)) {
 322                 btrfs_commit_transaction(h, root);
 323                 goto again;
 324         }
 325
 326         if (num_bytes) {
 327                 h->block_rsv = &root->fs_info->trans_block_rsv;
 328                 h->bytes_reserved = num_bytes;
 329         }
 330
 331 got_it:
 332         btrfs_record_root_in_trans(h, root);
 333
 334         if (!current->journal_info && type != TRANS_USERSPACE)
 335                 current->journal_info = h;
 336         return h;
 337 }
 338
 339 struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
 340                                                    int num_items)
 341 {
 342         return start_transaction(root, num_items, TRANS_START);
 343 }
 344 struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root)
 345 {
 346         return start_transaction(root, 0, TRANS_JOIN);
 347 }
 348
 349 struct btrfs_trans_handle *btrfs_join_transaction_nolock(struct btrfs_root *root)
 350 {
 351         return start_transaction(root, 0, TRANS_JOIN_NOLOCK);
 352 }
 353
 354 struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *root)
 355 {
 356         return start_transaction(root, 0, TRANS_USERSPACE);
 357 }
 358
 359 /* wait for a transaction commit to be fully complete */
 360 static noinline int wait_for_commit(struct btrfs_root *root,
 361                                     struct btrfs_transaction *commit)
 362 {
 363         DEFINE_WAIT(wait);
 364         while (!commit->commit_done) {
 365                 prepare_to_wait(&commit->commit_wait, &wait,
 366                                 TASK_UNINTERRUPTIBLE);
 367                 if (commit->commit_done)
 368                         break;
 369                 schedule();
 370         }
 371         finish_wait(&commit->commit_wait, &wait);
 372         return 0;
 373 }
 374
 375 int btrfs_wait_for_commit(struct btrfs_root *root, u64 transid)
 376 {
 377         struct btrfs_transaction *cur_trans = NULL, *t;
 378         int ret;
 379
 380         ret = 0;
 381         if (transid) {
 382                 if (transid <= root->fs_info->last_trans_committed)
 383                         goto out;
 384
 385                 /* find specified transaction */
 386                 spin_lock(&root->fs_info->trans_lock);
 387                 list_for_each_entry(t, &root->fs_info->trans_list, list) {
 388                         if (t->transid == transid) {
 389                                 cur_trans = t;
 390                                 atomic_inc(&cur_trans->use_count);
 391                                 break;
 392                         }
 393                         if (t->transid > transid)
 394                                 break;
 395                 }
 396                 spin_unlock(&root->fs_info->trans_lock);
 397                 ret = -EINVAL;
 398                 if (!cur_trans)
 399                         goto out;  /* bad transid */
 400         } else {
 401                 /* find newest transaction that is committing | committed */
 402                 spin_lock(&root->fs_info->trans_lock);
 403                 list_for_each_entry_reverse(t, &root->fs_info->trans_list,
 404                                             list) {
 405                         if (t->in_commit) {
 406                                 if (t->commit_done)
 407                                         break;
 408                                 cur_trans = t;
 409                                 atomic_inc(&cur_trans->use_count);
 410                                 break;
 411                         }
 412                 }
 413                 spin_unlock(&root->fs_info->trans_lock);
 414                 if (!cur_trans)
 415                         goto out;  /* nothing committing|committed */
 416         }
 417
 418         wait_for_commit(root, cur_trans);
 419
 420         put_transaction(cur_trans);
 421         ret = 0;
 422 out:
 423         return ret;
 424 }
 425
 426 void btrfs_throttle(struct btrfs_root *root)
 427 {
 428         if (!atomic_read(&root->fs_info->open_ioctl_trans))
 429                 wait_current_trans(root);
 430 }
 431
 432 static int should_end_transaction(struct btrfs_trans_handle *trans,
 433                                   struct btrfs_root *root)
 434 {
 435         int ret;
 436         ret = btrfs_block_rsv_check(trans, root,
 437                                     &root->fs_info->global_block_rsv, 0, 5);
 438         return ret ? 1 : 0;
 439 }
 440
 441 int btrfs_should_end_transaction(struct btrfs_trans_handle *trans,
 442                                  struct btrfs_root *root)
 443 {
 444         struct btrfs_transaction *cur_trans = trans->transaction;
 445         int updates;
 446
 447         smp_mb();
 448         if (cur_trans->blocked || cur_trans->delayed_refs.flushing)
 449                 return 1;
 450
 451         updates = trans->delayed_ref_updates;
 452         trans->delayed_ref_updates = 0;
 453         if (updates)
 454                 btrfs_run_delayed_refs(trans, root, updates);
 455
 456         return should_end_transaction(trans, root);
 457 }
 458
 459 static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
 460                           struct btrfs_root *root, int throttle, int lock)
 461 {
 462         struct btrfs_transaction *cur_trans = trans->transaction;
 463         struct btrfs_fs_info *info = root->fs_info;
 464         int count = 0;
 465
 466         if (--trans->use_count) {
 467                 trans->block_rsv = trans->orig_rsv;
 468                 return 0;
 469         }
 470
 471         while (count < 4) {
 472                 unsigned long cur = trans->delayed_ref_updates;
 473                 trans->delayed_ref_updates = 0;
 474                 if (cur &&
 475                     trans->transaction->delayed_refs.num_heads_ready > 64) {
 476                         trans->delayed_ref_updates = 0;
 477
 478                         /*
 479                          * do a full flush if the transaction is trying
 480                          * to close
 481                          */
 482                         if (trans->transaction->delayed_refs.flushing)
 483                                 cur = 0;
 484                         btrfs_run_delayed_refs(trans, root, cur);
 485                 } else {
 486                         break;
 487                 }
 488                 count++;
 489         }
 490
 491         btrfs_trans_release_metadata(trans, root);
 492
 493         if (lock && !atomic_read(&root->fs_info->open_ioctl_trans) &&
 494             should_end_transaction(trans, root)) {
 495                 trans->transaction->blocked = 1;
 496                 smp_wmb();
 497         }
 498
 499         if (lock && cur_trans->blocked && !cur_trans->in_commit) {
 500                 if (throttle)
 501                         return btrfs_commit_transaction(trans, root);
 502                 else
 503                         wake_up_process(info->transaction_kthread);
 504         }
 505
 506         WARN_ON(cur_trans != info->running_transaction);
 507         WARN_ON(atomic_read(&cur_trans->num_writers) < 1);
 508         atomic_dec(&cur_trans->num_writers);
 509
 510         smp_mb();
 511         if (waitqueue_active(&cur_trans->writer_wait))
 512                 wake_up(&cur_trans->writer_wait);
 513         put_transaction(cur_trans);
 514
 515         if (current->journal_info == trans)
 516                 current->journal_info = NULL;
 517         memset(trans, 0, sizeof(*trans));
 518         kmem_cache_free(btrfs_trans_handle_cachep, trans);
 519
 520         if (throttle)
 521                 btrfs_run_delayed_iputs(root);
 522
 523         return 0;
 524 }
 525
 526 int btrfs_end_transaction(struct btrfs_trans_handle *trans,
 527                           struct btrfs_root *root)
 528 {
 529         int ret;
 530
 531         ret = __btrfs_end_transaction(trans, root, 0, 1);
 532         if (ret)
 533                 return ret;
 534         return 0;
 535 }
 536
 537 int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans,
 538                                    struct btrfs_root *root)
 539 {
 540         int ret;
 541
 542         ret = __btrfs_end_transaction(trans, root, 1, 1);
 543         if (ret)
 544                 return ret;
 545         return 0;
 546 }
 547
 548 int btrfs_end_transaction_nolock(struct btrfs_trans_handle *trans,
 549                                  struct btrfs_root *root)
 550 {
 551         int ret;
 552
 553         ret = __btrfs_end_transaction(trans, root, 0, 0);
 554         if (ret)
 555                 return ret;
 556         return 0;
 557 }
 558
 559 int btrfs_end_transaction_dmeta(struct btrfs_trans_handle *trans,
 560                                 struct btrfs_root *root)
 561 {
 562         return __btrfs_end_transaction(trans, root, 1, 1);
 563 }
 564
 565 /*
 566  * when btree blocks are allocated, they have some corresponding bits set for
 567  * them in one of two extent_io trees.  This is used to make sure all of
 568  * those extents are sent to disk but does not wait on them
 569  */
 570 int btrfs_write_marked_extents(struct btrfs_root *root,
 571                                struct extent_io_tree *dirty_pages, int mark)
 572 {
 573         int ret;
 574         int err = 0;
 575         int werr = 0;
 576         struct page *page;
 577         struct inode *btree_inode = root->fs_info->btree_inode;
 578         u64 start = 0;
 579         u64 end;
 580         unsigned long index;
 581
 582         while (1) {
 583                 ret = find_first_extent_bit(dirty_pages, start, &start, &end,
 584                                             mark);
 585                 if (ret)
 586                         break;
 587                 while (start <= end) {
 588                         cond_resched();
 589
 590                         index = start >> PAGE_CACHE_SHIFT;
 591                         start = (u64)(index + 1) << PAGE_CACHE_SHIFT;
 592                         page = find_get_page(btree_inode->i_mapping, index);
 593                         if (!page)
 594                                 continue;
 595
 596                         btree_lock_page_hook(page);
 597                         if (!page->mapping) {
 598                                 unlock_page(page);
 599                                 page_cache_release(page);
 600                                 continue;
 601                         }
 602
 603                         if (PageWriteback(page)) {
 604                                 if (PageDirty(page))
 605                                         wait_on_page_writeback(page);
 606                                 else {
 607                                         unlock_page(page);
 608                                         page_cache_release(page);
 609                                         continue;
 610                                 }
 611                         }
 612                         err = write_one_page(page, 0);
 613                         if (err)
 614                                 werr = err;
 615                         page_cache_release(page);
 616                 }
 617         }
 618         if (err)
 619                 werr = err;
 620         return werr;
 621 }
 622
 623 /*
 624  * when btree blocks are allocated, they have some corresponding bits set for
 625  * them in one of two extent_io trees.  This is used to make sure all of
 626  * those extents are on disk for transaction or log commit.  We wait
 627  * on all the pages and clear them from the dirty pages state tree
 628  */
 629 int btrfs_wait_marked_extents(struct btrfs_root *root,
 630                               struct extent_io_tree *dirty_pages, int mark)
 631 {
 632         int ret;
 633         int err = 0;
 634         int werr = 0;
 635         struct page *page;
 636         struct inode *btree_inode = root->fs_info->btree_inode;
 637         u64 start = 0;
 638         u64 end;
 639         unsigned long index;
 640
 641         while (1) {
 642                 ret = find_first_extent_bit(dirty_pages, start, &start, &end,
 643                                             mark);
 644                 if (ret)
 645                         break;
 646
 647                 clear_extent_bits(dirty_pages, start, end, mark, GFP_NOFS);
 648                 while (start <= end) {
 649                         index = start >> PAGE_CACHE_SHIFT;
 650                         start = (u64)(index + 1) << PAGE_CACHE_SHIFT;
 651                         page = find_get_page(btree_inode->i_mapping, index);
 652                         if (!page)
 653                                 continue;
 654                         if (PageDirty(page)) {
 655                                 btree_lock_page_hook(page);
 656                                 wait_on_page_writeback(page);
 657                                 err = write_one_page(page, 0);
 658                                 if (err)
 659                                         werr = err;
 660                         }
 661                         wait_on_page_writeback(page);
 662                         page_cache_release(page);
 663                         cond_resched();
 664                 }
 665         }
 666         if (err)
 667                 werr = err;
 668         return werr;
 669 }
 670
 671 /*
 672  * when btree blocks are allocated, they have some corresponding bits set for
 673  * them in one of two extent_io trees.  This is used to make sure all of
 674  * those extents are on disk for transaction or log commit
 675  */
 676 int btrfs_write_and_wait_marked_extents(struct btrfs_root *root,
 677                                 struct extent_io_tree *dirty_pages, int mark)
 678 {
 679         int ret;
 680         int ret2;
 681
 682         ret = btrfs_write_marked_extents(root, dirty_pages, mark);
 683         ret2 = btrfs_wait_marked_extents(root, dirty_pages, mark);
 684         return ret || ret2;
 685 }
 686
 687 int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans,
 688                                      struct btrfs_root *root)
 689 {
 690         if (!trans || !trans->transaction) {
 691                 struct inode *btree_inode;
 692                 btree_inode = root->fs_info->btree_inode;
 693                 return filemap_write_and_wait(btree_inode->i_mapping);
 694         }
 695         return btrfs_write_and_wait_marked_extents(root,
 696                                            &trans->transaction->dirty_pages,
 697                                            EXTENT_DIRTY);
 698 }
 699
 700 /*
 701  * this is used to update the root pointer in the tree of tree roots.
 702  *
 703  * But, in the case of the extent allocation tree, updating the root
 704  * pointer may allocate blocks which may change the root of the extent
 705  * allocation tree.
 706  *
 707  * So, this loops and repeats and makes sure the cowonly root didn't
 708  * change while the root pointer was being updated in the metadata.
 709  */
 710 static int update_cowonly_root(struct btrfs_trans_handle *trans,
 711                                struct btrfs_root *root)
 712 {
 713         int ret;
 714         u64 old_root_bytenr;
 715         u64 old_root_used;
 716         struct btrfs_root *tree_root = root->fs_info->tree_root;
 717
 718         old_root_used = btrfs_root_used(&root->root_item);
 719         btrfs_write_dirty_block_groups(trans, root);
 720
 721         while (1) {
 722                 old_root_bytenr = btrfs_root_bytenr(&root->root_item);
 723                 if (old_root_bytenr == root->node->start &&
 724                     old_root_used == btrfs_root_used(&root->root_item))
 725                         break;
 726
 727                 btrfs_set_root_node(&root->root_item, root->node);
 728                 ret = btrfs_update_root(trans, tree_root,
 729                                         &root->root_key,
 730                                         &root->root_item);
 731                 BUG_ON(ret);
 732
 733                 old_root_used = btrfs_root_used(&root->root_item);
 734                 ret = btrfs_write_dirty_block_groups(trans, root);
 735                 BUG_ON(ret);
 736         }
 737
 738         if (root != root->fs_info->extent_root)
 739                 switch_commit_root(root);
 740
 741         return 0;
 742 }
 743
 744 /*
 745  * update all the cowonly tree roots on disk
 746  */
 747 static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans,
 748                                          struct btrfs_root *root)
 749 {
 750         struct btrfs_fs_info *fs_info = root->fs_info;
 751         struct list_head *next;
 752         struct extent_buffer *eb;
 753         int ret;
 754
 755         ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
 756         BUG_ON(ret);
 757
 758         eb = btrfs_lock_root_node(fs_info->tree_root);
 759         btrfs_cow_block(trans, fs_info->tree_root, eb, NULL, 0, &eb);
 760         btrfs_tree_unlock(eb);
 761         free_extent_buffer(eb);
 762
 763         ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
 764         BUG_ON(ret);
 765
 766         while (!list_empty(&fs_info->dirty_cowonly_roots)) {
 767                 next = fs_info->dirty_cowonly_roots.next;
 768                 list_del_init(next);
 769                 root = list_entry(next, struct btrfs_root, dirty_list);
 770
 771                 update_cowonly_root(trans, root);
 772         }
 773
 774         down_write(&fs_info->extent_commit_sem);
 775         switch_commit_root(fs_info->extent_root);
 776         up_write(&fs_info->extent_commit_sem);
 777
 778         return 0;
 779 }
 780
 781 /*
 782  * dead roots are old snapshots that need to be deleted.  This allocates
 783  * a dirty root struct and adds it into the list of dead roots that need to
 784  * be deleted
 785  */
 786 int btrfs_add_dead_root(struct btrfs_root *root)
 787 {
 788         spin_lock(&root->fs_info->trans_lock);
 789         list_add(&root->root_list, &root->fs_info->dead_roots);
 790         spin_unlock(&root->fs_info->trans_lock);
 791         return 0;
 792 }
 793
 794 /*
 795  * update all the cowonly tree roots on disk
 796  */
 797 static noinline int commit_fs_roots(struct btrfs_trans_handle *trans,
 798                                     struct btrfs_root *root)
 799 {
 800         struct btrfs_root *gang[8];
 801         struct btrfs_fs_info *fs_info = root->fs_info;
 802         int i;
 803         int ret;
 804         int err = 0;
 805
 806         spin_lock(&fs_info->fs_roots_radix_lock);
 807         while (1) {
 808                 ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix,
 809                                                  (void **)gang, 0,
 810                                                  ARRAY_SIZE(gang),
 811                                                  BTRFS_ROOT_TRANS_TAG);
 812                 if (ret == 0)
 813                         break;
 814                 for (i = 0; i < ret; i++) {
 815                         root = gang[i];
 816                         radix_tree_tag_clear(&fs_info->fs_roots_radix,
 817                                         (unsigned long)root->root_key.objectid,
 818                                         BTRFS_ROOT_TRANS_TAG);
 819                         spin_unlock(&fs_info->fs_roots_radix_lock);
 820
 821                         btrfs_free_log(trans, root);
 822                         btrfs_update_reloc_root(trans, root);
 823                         btrfs_orphan_commit_root(trans, root);
 824
 825                         btrfs_save_ino_cache(root, trans);
 826
 827                         if (root->commit_root != root->node) {
 828                                 mutex_lock(&root->fs_commit_mutex);
 829                                 switch_commit_root(root);
 830                                 btrfs_unpin_free_ino(root);
 831                                 mutex_unlock(&root->fs_commit_mutex);
 832
 833                                 btrfs_set_root_node(&root->root_item,
 834                                                     root->node);
 835                         }
 836
 837                         err = btrfs_update_root(trans, fs_info->tree_root,
 838                                                 &root->root_key,
 839                                                 &root->root_item);
 840                         spin_lock(&fs_info->fs_roots_radix_lock);
 841                         if (err)
 842                                 break;
 843                 }
 844         }
 845         spin_unlock(&fs_info->fs_roots_radix_lock);
 846         return err;
 847 }
 848
 849 /*
 850  * defrag a given btree.  If cacheonly == 1, this won't read from the disk,
 851  * otherwise every leaf in the btree is read and defragged.
 852  */
 853 int btrfs_defrag_root(struct btrfs_root *root, int cacheonly)
 854 {
 855         struct btrfs_fs_info *info = root->fs_info;
 856         struct btrfs_trans_handle *trans;
 857         int ret;
 858         unsigned long nr;
 859
 860         if (xchg(&root->defrag_running, 1))
 861                 return 0;
 862
 863         while (1) {
 864                 trans = btrfs_start_transaction(root, 0);
 865                 if (IS_ERR(trans))
 866                         return PTR_ERR(trans);
 867
 868                 ret = btrfs_defrag_leaves(trans, root, cacheonly);
 869
 870                 nr = trans->blocks_used;
 871                 btrfs_end_transaction(trans, root);
 872                 btrfs_btree_balance_dirty(info->tree_root, nr);
 873                 cond_resched();
 874
 875                 if (btrfs_fs_closing(root->fs_info) || ret != -EAGAIN)
 876                         break;
 877         }
 878         root->defrag_running = 0;
 879         return ret;
 880 }
 881
 882 /*
 883  * new snapshots need to be created at a very specific time in the
 884  * transaction commit.  This does the actual creation
 885  */
 886 static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
 887                                    struct btrfs_fs_info *fs_info,
 888                                    struct btrfs_pending_snapshot *pending)
 889 {
 890         struct btrfs_key key;
 891         struct btrfs_root_item *new_root_item;
 892         struct btrfs_root *tree_root = fs_info->tree_root;
 893         struct btrfs_root *root = pending->root;
 894         struct btrfs_root *parent_root;
 895         struct inode *parent_inode;
 896         struct dentry *parent;
 897         struct dentry *dentry;
 898         struct extent_buffer *tmp;
 899         struct extent_buffer *old;
 900         int ret;
 901         u64 to_reserve = 0;
 902         u64 index = 0;
 903         u64 objectid;
 904         u64 root_flags;
 905
 906         new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS);
 907         if (!new_root_item) {
 908                 pending->error = -ENOMEM;
 909                 goto fail;
 910         }
 911
 912         ret = btrfs_find_free_objectid(tree_root, &objectid);
 913         if (ret) {
 914                 pending->error = ret;
 915                 goto fail;
 916         }
 917
 918         btrfs_reloc_pre_snapshot(trans, pending, &to_reserve);
 919         btrfs_orphan_pre_snapshot(trans, pending, &to_reserve);
 920
 921         if (to_reserve > 0) {
 922                 ret = btrfs_block_rsv_add(trans, root, &pending->block_rsv,
 923                                           to_reserve);
 924                 if (ret) {
 925                         pending->error = ret;
 926                         goto fail;
 927                 }
 928         }
 929
 930         key.objectid = objectid;
 931         key.offset = (u64)-1;
 932         key.type = BTRFS_ROOT_ITEM_KEY;
 933
 934         trans->block_rsv = &pending->block_rsv;
 935
 936         dentry = pending->dentry;
 937         parent = dget_parent(dentry);
 938         parent_inode = parent->d_inode;
 939         parent_root = BTRFS_I(parent_inode)->root;
 940         record_root_in_trans(trans, parent_root);
 941
 942         /*
 943          * insert the directory item
 944          */
 945         ret = btrfs_set_inode_index(parent_inode, &index);
 946         BUG_ON(ret);
 947         ret = btrfs_insert_dir_item(trans, parent_root,
 948                                 dentry->d_name.name, dentry->d_name.len,
 949                                 parent_inode, &key,
 950                                 BTRFS_FT_DIR, index);
 951         BUG_ON(ret);
 952
 953         btrfs_i_size_write(parent_inode, parent_inode->i_size +
 954                                          dentry->d_name.len * 2);
 955         ret = btrfs_update_inode(trans, parent_root, parent_inode);
 956         BUG_ON(ret);
 957
 958         /*
 959          * pull in the delayed directory update
 960          * and the delayed inode item
 961          * otherwise we corrupt the FS during
 962          * snapshot
 963          */
 964         ret = btrfs_run_delayed_items(trans, root);
 965         BUG_ON(ret);
 966
 967         record_root_in_trans(trans, root);
 968         btrfs_set_root_last_snapshot(&root->root_item, trans->transid);
 969         memcpy(new_root_item, &root->root_item, sizeof(*new_root_item));
 970         btrfs_check_and_init_root_item(new_root_item);
 971
 972         root_flags = btrfs_root_flags(new_root_item);
 973         if (pending->readonly)
 974                 root_flags |= BTRFS_ROOT_SUBVOL_RDONLY;
 975         else
 976                 root_flags &= ~BTRFS_ROOT_SUBVOL_RDONLY;
 977         btrfs_set_root_flags(new_root_item, root_flags);
 978
 979         old = btrfs_lock_root_node(root);
 980         btrfs_cow_block(trans, root, old, NULL, 0, &old);
 981         btrfs_set_lock_blocking(old);
 982
 983         btrfs_copy_root(trans, root, old, &tmp, objectid);
 984         btrfs_tree_unlock(old);
 985         free_extent_buffer(old);
 986
 987         btrfs_set_root_node(new_root_item, tmp);
 988         /* record when the snapshot was created in key.offset */
 989         key.offset = trans->transid;
 990         ret = btrfs_insert_root(trans, tree_root, &key, new_root_item);
 991         btrfs_tree_unlock(tmp);
 992         free_extent_buffer(tmp);
 993         BUG_ON(ret);
 994
 995         /*
 996          * insert root back/forward references
 997          */
 998         ret = btrfs_add_root_ref(trans, tree_root, objectid,
 999                                  parent_root->root_key.objectid,
1000                                  btrfs_ino(parent_inode), index,
1001                                  dentry->d_name.name, dentry->d_name.len);
1002         BUG_ON(ret);
1003         dput(parent);
1004
1005         key.offset = (u64)-1;
1006         pending->snap = btrfs_read_fs_root_no_name(root->fs_info, &key);
1007         BUG_ON(IS_ERR(pending->snap));
1008
1009         btrfs_reloc_post_snapshot(trans, pending);
1010         btrfs_orphan_post_snapshot(trans, pending);
1011 fail:
1012         kfree(new_root_item);
1013         btrfs_block_rsv_release(root, &pending->block_rsv, (u64)-1);
1014         return 0;
1015 }
1016
1017 /*
1018  * create all the snapshots we've scheduled for creation
1019  */
1020 static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans,
1021                                              struct btrfs_fs_info *fs_info)
1022 {
1023         struct btrfs_pending_snapshot *pending;
1024         struct list_head *head = &trans->transaction->pending_snapshots;
1025         int ret;
1026
1027         list_for_each_entry(pending, head, list) {
1028                 ret = create_pending_snapshot(trans, fs_info, pending);
1029                 BUG_ON(ret);
1030         }
1031         return 0;
1032 }
1033
1034 static void update_super_roots(struct btrfs_root *root)
1035 {
1036         struct btrfs_root_item *root_item;
1037         struct btrfs_super_block *super;
1038
1039         super = &root->fs_info->super_copy;
1040
1041         root_item = &root->fs_info->chunk_root->root_item;
1042         super->chunk_root = root_item->bytenr;
1043         super->chunk_root_generation = root_item->generation;
1044         super->chunk_root_level = root_item->level;
1045
1046         root_item = &root->fs_info->tree_root->root_item;
1047         super->root = root_item->bytenr;
1048         super->generation = root_item->generation;
1049         super->root_level = root_item->level;
1050         if (super->cache_generation != 0 || btrfs_test_opt(root, SPACE_CACHE))
1051                 super->cache_generation = root_item->generation;
1052 }
1053
1054 int btrfs_transaction_in_commit(struct btrfs_fs_info *info)
1055 {
1056         int ret = 0;
1057         spin_lock(&info->trans_lock);
1058         if (info->running_transaction)
1059                 ret = info->running_transaction->in_commit;
1060         spin_unlock(&info->trans_lock);
1061         return ret;
1062 }
1063
1064 int btrfs_transaction_blocked(struct btrfs_fs_info *info)
1065 {
1066         int ret = 0;
1067         spin_lock(&info->trans_lock);
1068         if (info->running_transaction)
1069                 ret = info->running_transaction->blocked;
1070         spin_unlock(&info->trans_lock);
1071         return ret;
1072 }
1073
1074 /*
1075  * wait for the current transaction commit to start and block subsequent
1076  * transaction joins
1077  */
1078 static void wait_current_trans_commit_start(struct btrfs_root *root,
1079                                             struct btrfs_transaction *trans)
1080 {
1081         DEFINE_WAIT(wait);
1082
1083         if (trans->in_commit)
1084                 return;
1085
1086         while (1) {
1087                 prepare_to_wait(&root->fs_info->transaction_blocked_wait, &wait,
1088                                 TASK_UNINTERRUPTIBLE);
1089                 if (trans->in_commit) {
1090                         finish_wait(&root->fs_info->transaction_blocked_wait,
1091                                     &wait);
1092                         break;
1093                 }
1094                 schedule();
1095                 finish_wait(&root->fs_info->transaction_blocked_wait, &wait);
1096         }
1097 }
1098
1099 /*
1100  * wait for the current transaction to start and then become unblocked.
1101  * caller holds ref.
1102  */
1103 static void wait_current_trans_commit_start_and_unblock(struct btrfs_root *root,
1104                                          struct btrfs_transaction *trans)
1105 {
1106         DEFINE_WAIT(wait);
1107
1108         if (trans->commit_done || (trans->in_commit && !trans->blocked))
1109                 return;
1110
1111         while (1) {
1112                 prepare_to_wait(&root->fs_info->transaction_wait, &wait,
1113                                 TASK_UNINTERRUPTIBLE);
1114                 if (trans->commit_done ||
1115                     (trans->in_commit && !trans->blocked)) {
1116                         finish_wait(&root->fs_info->transaction_wait,
1117                                     &wait);
1118                         break;
1119                 }
1120                 schedule();
1121                 finish_wait(&root->fs_info->transaction_wait,
1122                             &wait);
1123         }
1124 }
1125
1126 /*
1127  * commit transactions asynchronously. once btrfs_commit_transaction_async
1128  * returns, any subsequent transaction will not be allowed to join.
1129  */
1130 struct btrfs_async_commit {
1131         struct btrfs_trans_handle *newtrans;
1132         struct btrfs_root *root;
1133         struct delayed_work work;
1134 };
1135
1136 static void do_async_commit(struct work_struct *work)
1137 {
1138         struct btrfs_async_commit *ac =
1139                 container_of(work, struct btrfs_async_commit, work.work);
1140
1141         btrfs_commit_transaction(ac->newtrans, ac->root);
1142         kfree(ac);
1143 }
1144
1145 int btrfs_commit_transaction_async(struct btrfs_trans_handle *trans,
1146                                    struct btrfs_root *root,
1147                                    int wait_for_unblock)
1148 {
1149         struct btrfs_async_commit *ac;
1150         struct btrfs_transaction *cur_trans;
1151
1152         ac = kmalloc(sizeof(*ac), GFP_NOFS);
1153         if (!ac)
1154                 return -ENOMEM;
1155
1156         INIT_DELAYED_WORK(&ac->work, do_async_commit);
1157         ac->root = root;
1158         ac->newtrans = btrfs_join_transaction(root);
1159         if (IS_ERR(ac->newtrans)) {
1160                 int err = PTR_ERR(ac->newtrans);
1161                 kfree(ac);
1162                 return err;
1163         }
1164
1165         /* take transaction reference */
1166         cur_trans = trans->transaction;
1167         atomic_inc(&cur_trans->use_count);
1168
1169         btrfs_end_transaction(trans, root);
1170         schedule_delayed_work(&ac->work, 0);
1171
1172         /* wait for transaction to start and unblock */
1173         if (wait_for_unblock)
1174                 wait_current_trans_commit_start_and_unblock(root, cur_trans);
1175         else
1176                 wait_current_trans_commit_start(root, cur_trans);
1177
1178         if (current->journal_info == trans)
1179                 current->journal_info = NULL;
1180
1181         put_transaction(cur_trans);
1182         return 0;
1183 }
1184
1185 /*
1186  * btrfs_transaction state sequence:
1187  *    in_commit = 0, blocked = 0  (initial)
1188  *    in_commit = 1, blocked = 1
1189  *    blocked = 0
1190  *    commit_done = 1
1191  */
1192 int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
1193                              struct btrfs_root *root)
1194 {
1195         unsigned long joined = 0;
1196         struct btrfs_transaction *cur_trans;
1197         struct btrfs_transaction *prev_trans = NULL;
1198         DEFINE_WAIT(wait);
1199         int ret;
1200         int should_grow = 0;
1201         unsigned long now = get_seconds();
1202         int flush_on_commit = btrfs_test_opt(root, FLUSHONCOMMIT);
1203
1204         btrfs_run_ordered_operations(root, 0);
1205
1206         /* make a pass through all the delayed refs we have so far
1207          * any runnings procs may add more while we are here
1208          */
1209         ret = btrfs_run_delayed_refs(trans, root, 0);
1210         BUG_ON(ret);
1211
1212         btrfs_trans_release_metadata(trans, root);
1213
1214         cur_trans = trans->transaction;
1215         /*
1216          * set the flushing flag so procs in this transaction have to
1217          * start sending their work down.
1218          */
1219         cur_trans->delayed_refs.flushing = 1;
1220
1221         ret = btrfs_run_delayed_refs(trans, root, 0);
1222         BUG_ON(ret);
1223
1224         spin_lock(&cur_trans->commit_lock);
1225         if (cur_trans->in_commit) {
1226                 spin_unlock(&cur_trans->commit_lock);
1227                 atomic_inc(&cur_trans->use_count);
1228                 btrfs_end_transaction(trans, root);
1229
1230                 ret = wait_for_commit(root, cur_trans);
1231                 BUG_ON(ret);
1232
1233                 put_transaction(cur_trans);
1234
1235                 return 0;
1236         }
1237
1238         trans->transaction->in_commit = 1;
1239         trans->transaction->blocked = 1;
1240         spin_unlock(&cur_trans->commit_lock);
1241         wake_up(&root->fs_info->transaction_blocked_wait);
1242
1243         spin_lock(&root->fs_info->trans_lock);
1244         if (cur_trans->list.prev != &root->fs_info->trans_list) {
1245                 prev_trans = list_entry(cur_trans->list.prev,
1246                                         struct btrfs_transaction, list);
1247                 if (!prev_trans->commit_done) {
1248                         atomic_inc(&prev_trans->use_count);
1249                         spin_unlock(&root->fs_info->trans_lock);
1250
1251                         wait_for_commit(root, prev_trans);
1252
1253                         put_transaction(prev_trans);
1254                 } else {
1255                         spin_unlock(&root->fs_info->trans_lock);
1256                 }
1257         } else {
1258                 spin_unlock(&root->fs_info->trans_lock);
1259         }
1260
1261         if (now < cur_trans->start_time || now - cur_trans->start_time < 1)
1262                 should_grow = 1;
1263
1264         do {
1265                 int snap_pending = 0;
1266
1267                 joined = cur_trans->num_joined;
1268                 if (!list_empty(&trans->transaction->pending_snapshots))
1269                         snap_pending = 1;
1270
1271                 WARN_ON(cur_trans != trans->transaction);
1272
1273                 if (flush_on_commit || snap_pending) {
1274                         btrfs_start_delalloc_inodes(root, 1);
1275                         ret = btrfs_wait_ordered_extents(root, 0, 1);
1276                         BUG_ON(ret);
1277                 }
1278
1279                 ret = btrfs_run_delayed_items(trans, root);
1280                 BUG_ON(ret);
1281
1282                 /*
1283                  * rename don't use btrfs_join_transaction, so, once we
1284                  * set the transaction to blocked above, we aren't going
1285                  * to get any new ordered operations.  We can safely run
1286                  * it here and no for sure that nothing new will be added
1287                  * to the list
1288                  */
1289                 btrfs_run_ordered_operations(root, 1);
1290
1291                 prepare_to_wait(&cur_trans->writer_wait, &wait,
1292                                 TASK_UNINTERRUPTIBLE);
1293
1294                 if (atomic_read(&cur_trans->num_writers) > 1)
1295                         schedule_timeout(MAX_SCHEDULE_TIMEOUT);
1296                 else if (should_grow)
1297                         schedule_timeout(1);
1298
1299                 finish_wait(&cur_trans->writer_wait, &wait);
1300         } while (atomic_read(&cur_trans->num_writers) > 1 ||
1301                  (should_grow && cur_trans->num_joined != joined));
1302
1303         /*
1304          * Ok now we need to make sure to block out any other joins while we
1305          * commit the transaction.  We could have started a join before setting
1306          * no_join so make sure to wait for num_writers to == 1 again.
1307          */
1308         spin_lock(&root->fs_info->trans_lock);
1309         root->fs_info->trans_no_join = 1;
1310         spin_unlock(&root->fs_info->trans_lock);
1311         wait_event(cur_trans->writer_wait,
1312                    atomic_read(&cur_trans->num_writers) == 1);
1313
1314         /*
1315          * the reloc mutex makes sure that we stop
1316          * the balancing code from coming in and moving
1317          * extents around in the middle of the commit
1318          */
1319         mutex_lock(&root->fs_info->reloc_mutex);
1320
1321         ret = btrfs_run_delayed_items(trans, root);
1322         BUG_ON(ret);
1323
1324         ret = create_pending_snapshots(trans, root->fs_info);
1325         BUG_ON(ret);
1326
1327         ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
1328         BUG_ON(ret);
1329
1330         /*
1331          * make sure none of the code above managed to slip in a
1332          * delayed item
1333          */
1334         btrfs_assert_delayed_root_empty(root);
1335
1336         WARN_ON(cur_trans != trans->transaction);
1337
1338         btrfs_scrub_pause(root);
1339         /* btrfs_commit_tree_roots is responsible for getting the
1340          * various roots consistent with each other.  Every pointer
1341          * in the tree of tree roots has to point to the most up to date
1342          * root for every subvolume and other tree.  So, we have to keep
1343          * the tree logging code from jumping in and changing any
1344          * of the trees.
1345          *
1346          * At this point in the commit, there can't be any tree-log
1347          * writers, but a little lower down we drop the trans mutex
1348          * and let new people in.  By holding the tree_log_mutex
1349          * from now until after the super is written, we avoid races
1350          * with the tree-log code.
1351          */
1352         mutex_lock(&root->fs_info->tree_log_mutex);
1353
1354         ret = commit_fs_roots(trans, root);
1355         BUG_ON(ret);
1356
1357         /* commit_fs_roots gets rid of all the tree log roots, it is now
1358          * safe to free the root of tree log roots
1359          */
1360         btrfs_free_log_root_tree(trans, root->fs_info);
1361
1362         ret = commit_cowonly_roots(trans, root);
1363         BUG_ON(ret);
1364
1365         btrfs_prepare_extent_commit(trans, root);
1366
1367         cur_trans = root->fs_info->running_transaction;
1368
1369         btrfs_set_root_node(&root->fs_info->tree_root->root_item,
1370                             root->fs_info->tree_root->node);
1371         switch_commit_root(root->fs_info->tree_root);
1372
1373         btrfs_set_root_node(&root->fs_info->chunk_root->root_item,
1374                             root->fs_info->chunk_root->node);
1375         switch_commit_root(root->fs_info->chunk_root);
1376
1377         update_super_roots(root);
1378
1379         if (!root->fs_info->log_root_recovering) {
1380                 btrfs_set_super_log_root(&root->fs_info->super_copy, 0);
1381                 btrfs_set_super_log_root_level(&root->fs_info->super_copy, 0);
1382         }
1383
1384         memcpy(&root->fs_info->super_for_commit, &root->fs_info->super_copy,
1385                sizeof(root->fs_info->super_copy));
1386
1387         trans->transaction->blocked = 0;
1388         spin_lock(&root->fs_info->trans_lock);
1389         root->fs_info->running_transaction = NULL;
1390         root->fs_info->trans_no_join = 0;
1391         spin_unlock(&root->fs_info->trans_lock);
1392         mutex_unlock(&root->fs_info->reloc_mutex);
1393
1394         wake_up(&root->fs_info->transaction_wait);
1395
1396         ret = btrfs_write_and_wait_transaction(trans, root);
1397         BUG_ON(ret);
1398         write_ctree_super(trans, root, 0);
1399
1400         /*
1401          * the super is written, we can safely allow the tree-loggers
1402          * to go about their business
1403          */
1404         mutex_unlock(&root->fs_info->tree_log_mutex);
1405
1406         btrfs_finish_extent_commit(trans, root);
1407
1408         cur_trans->commit_done = 1;
1409
1410         root->fs_info->last_trans_committed = cur_trans->transid;
1411
1412         wake_up(&cur_trans->commit_wait);
1413
1414         spin_lock(&root->fs_info->trans_lock);
1415         list_del_init(&cur_trans->list);
1416         spin_unlock(&root->fs_info->trans_lock);
1417
1418         put_transaction(cur_trans);
1419         put_transaction(cur_trans);
1420
1421         trace_btrfs_transaction_commit(root);
1422
1423         btrfs_scrub_continue(root);
1424
1425         if (current->journal_info == trans)
1426                 current->journal_info = NULL;
1427
1428         kmem_cache_free(btrfs_trans_handle_cachep, trans);
1429
1430         if (current != root->fs_info->transaction_kthread)
1431                 btrfs_run_delayed_iputs(root);
1432
1433         return ret;
1434 }
1435
1436 /*
1437  * interface function to delete all the snapshots we have scheduled for deletion
1438  */
1439 int btrfs_clean_old_snapshots(struct btrfs_root *root)
1440 {
1441         LIST_HEAD(list);
1442         struct btrfs_fs_info *fs_info = root->fs_info;
1443
1444         spin_lock(&fs_info->trans_lock);
1445         list_splice_init(&fs_info->dead_roots, &list);
1446         spin_unlock(&fs_info->trans_lock);
1447
1448         while (!list_empty(&list)) {
1449                 root = list_entry(list.next, struct btrfs_root, root_list);
1450                 list_del(&root->root_list);
1451
1452                 btrfs_kill_all_delayed_nodes(root);
1453
1454                 if (btrfs_header_backref_rev(root->node) <
1455                     BTRFS_MIXED_BACKREF_REV)
1456                         btrfs_drop_snapshot(root, NULL, 0);
1457                 else
1458                         btrfs_drop_snapshot(root, NULL, 1);
1459         }
1460         return 0;
1461 }