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/sched.h>
  21 #include <linux/writeback.h>
  22 #include <linux/pagemap.h>
  23 #include <linux/blkdev.h>
  24 #include "ctree.h"
  25 #include "disk-io.h"
  26 #include "transaction.h"
  27 #include "locking.h"
  28 #include "tree-log.h"
  29
  30 #define BTRFS_ROOT_TRANS_TAG 0
  31
  32 static noinline void put_transaction(struct btrfs_transaction *transaction)
  33 {
  34         WARN_ON(transaction->use_count == 0);
  35         transaction->use_count--;
  36         if (transaction->use_count == 0) {
  37                 list_del_init(&transaction->list);
  38                 memset(transaction, 0, sizeof(*transaction));
  39                 kmem_cache_free(btrfs_transaction_cachep, transaction);
  40         }
  41 }
  42
  43 static noinline void switch_commit_root(struct btrfs_root *root)
  44 {
  45         down_write(&root->commit_root_sem);
  46         free_extent_buffer(root->commit_root);
  47         root->commit_root = btrfs_root_node(root);
  48         up_write(&root->commit_root_sem);
  49 }
  50
  51 /*
  52  * either allocate a new transaction or hop into the existing one
  53  */
  54 static noinline int join_transaction(struct btrfs_root *root)
  55 {
  56         struct btrfs_transaction *cur_trans;
  57         cur_trans = root->fs_info->running_transaction;
  58         if (!cur_trans) {
  59                 cur_trans = kmem_cache_alloc(btrfs_transaction_cachep,
  60                                              GFP_NOFS);
  61                 BUG_ON(!cur_trans);
  62                 root->fs_info->generation++;
  63                 cur_trans->num_writers = 1;
  64                 cur_trans->num_joined = 0;
  65                 cur_trans->transid = root->fs_info->generation;
  66                 init_waitqueue_head(&cur_trans->writer_wait);
  67                 init_waitqueue_head(&cur_trans->commit_wait);
  68                 cur_trans->in_commit = 0;
  69                 cur_trans->blocked = 0;
  70                 cur_trans->use_count = 1;
  71                 cur_trans->commit_done = 0;
  72                 cur_trans->start_time = get_seconds();
  73
  74                 cur_trans->delayed_refs.root.rb_node = NULL;
  75                 cur_trans->delayed_refs.num_entries = 0;
  76                 cur_trans->delayed_refs.num_heads_ready = 0;
  77                 cur_trans->delayed_refs.num_heads = 0;
  78                 cur_trans->delayed_refs.flushing = 0;
  79                 cur_trans->delayed_refs.run_delayed_start = 0;
  80                 spin_lock_init(&cur_trans->delayed_refs.lock);
  81
  82                 INIT_LIST_HEAD(&cur_trans->pending_snapshots);
  83                 list_add_tail(&cur_trans->list, &root->fs_info->trans_list);
  84                 extent_io_tree_init(&cur_trans->dirty_pages,
  85                                      root->fs_info->btree_inode->i_mapping,
  86                                      GFP_NOFS);
  87                 spin_lock(&root->fs_info->new_trans_lock);
  88                 root->fs_info->running_transaction = cur_trans;
  89                 spin_unlock(&root->fs_info->new_trans_lock);
  90         } else {
  91                 cur_trans->num_writers++;
  92                 cur_trans->num_joined++;
  93         }
  94
  95         return 0;
  96 }
  97
  98 /*
  99  * this does all the record keeping required to make sure that a reference
 100  * counted root is properly recorded in a given transaction.  This is required
 101  * to make sure the old root from before we joined the transaction is deleted
 102  * when the transaction commits
 103  */
 104 static noinline int record_root_in_trans(struct btrfs_trans_handle *trans,
 105                                          struct btrfs_root *root)
 106 {
 107         if (root->ref_cows && root->last_trans < trans->transid) {
 108                 WARN_ON(root == root->fs_info->extent_root);
 109                 WARN_ON(root->root_item.refs == 0);
 110                 WARN_ON(root->commit_root != root->node);
 111
 112                 radix_tree_tag_set(&root->fs_info->fs_roots_radix,
 113                            (unsigned long)root->root_key.objectid,
 114                            BTRFS_ROOT_TRANS_TAG);
 115                 root->last_trans = trans->transid;
 116                 btrfs_init_reloc_root(trans, root);
 117         }
 118         return 0;
 119 }
 120
 121 int btrfs_record_root_in_trans(struct btrfs_trans_handle *trans,
 122                                struct btrfs_root *root)
 123 {
 124         if (!root->ref_cows)
 125                 return 0;
 126
 127         mutex_lock(&root->fs_info->trans_mutex);
 128         if (root->last_trans == trans->transid) {
 129                 mutex_unlock(&root->fs_info->trans_mutex);
 130                 return 0;
 131         }
 132
 133         record_root_in_trans(trans, root);
 134         mutex_unlock(&root->fs_info->trans_mutex);
 135         return 0;
 136 }
 137
 138 /* wait for commit against the current transaction to become unblocked
 139  * when this is done, it is safe to start a new transaction, but the current
 140  * transaction might not be fully on disk.
 141  */
 142 static void wait_current_trans(struct btrfs_root *root)
 143 {
 144         struct btrfs_transaction *cur_trans;
 145
 146         cur_trans = root->fs_info->running_transaction;
 147         if (cur_trans && cur_trans->blocked) {
 148                 DEFINE_WAIT(wait);
 149                 cur_trans->use_count++;
 150                 while (1) {
 151                         prepare_to_wait(&root->fs_info->transaction_wait, &wait,
 152                                         TASK_UNINTERRUPTIBLE);
 153                         if (cur_trans->blocked) {
 154                                 mutex_unlock(&root->fs_info->trans_mutex);
 155                                 schedule();
 156                                 mutex_lock(&root->fs_info->trans_mutex);
 157                                 finish_wait(&root->fs_info->transaction_wait,
 158                                             &wait);
 159                         } else {
 160                                 finish_wait(&root->fs_info->transaction_wait,
 161                                             &wait);
 162                                 break;
 163                         }
 164                 }
 165                 put_transaction(cur_trans);
 166         }
 167 }
 168
 169 static struct btrfs_trans_handle *start_transaction(struct btrfs_root *root,
 170                                              int num_blocks, int wait)
 171 {
 172         struct btrfs_trans_handle *h =
 173                 kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS);
 174         int ret;
 175
 176         mutex_lock(&root->fs_info->trans_mutex);
 177         if (!root->fs_info->log_root_recovering &&
 178             ((wait == 1 && !root->fs_info->open_ioctl_trans) || wait == 2))
 179                 wait_current_trans(root);
 180         ret = join_transaction(root);
 181         BUG_ON(ret);
 182
 183         h->transid = root->fs_info->running_transaction->transid;
 184         h->transaction = root->fs_info->running_transaction;
 185         h->blocks_reserved = num_blocks;
 186         h->blocks_used = 0;
 187         h->block_group = 0;
 188         h->alloc_exclude_nr = 0;
 189         h->alloc_exclude_start = 0;
 190         h->delayed_ref_updates = 0;
 191
 192         root->fs_info->running_transaction->use_count++;
 193         record_root_in_trans(h, root);
 194         mutex_unlock(&root->fs_info->trans_mutex);
 195         return h;
 196 }
 197
 198 struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
 199                                                    int num_blocks)
 200 {
 201         return start_transaction(root, num_blocks, 1);
 202 }
 203 struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root,
 204                                                    int num_blocks)
 205 {
 206         return start_transaction(root, num_blocks, 0);
 207 }
 208
 209 struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *r,
 210                                                          int num_blocks)
 211 {
 212         return start_transaction(r, num_blocks, 2);
 213 }
 214
 215 /* wait for a transaction commit to be fully complete */
 216 static noinline int wait_for_commit(struct btrfs_root *root,
 217                                     struct btrfs_transaction *commit)
 218 {
 219         DEFINE_WAIT(wait);
 220         mutex_lock(&root->fs_info->trans_mutex);
 221         while (!commit->commit_done) {
 222                 prepare_to_wait(&commit->commit_wait, &wait,
 223                                 TASK_UNINTERRUPTIBLE);
 224                 if (commit->commit_done)
 225                         break;
 226                 mutex_unlock(&root->fs_info->trans_mutex);
 227                 schedule();
 228                 mutex_lock(&root->fs_info->trans_mutex);
 229         }
 230         mutex_unlock(&root->fs_info->trans_mutex);
 231         finish_wait(&commit->commit_wait, &wait);
 232         return 0;
 233 }
 234
 235 #if 0
 236 /*
 237  * rate limit against the drop_snapshot code.  This helps to slow down new
 238  * operations if the drop_snapshot code isn't able to keep up.
 239  */
 240 static void throttle_on_drops(struct btrfs_root *root)
 241 {
 242         struct btrfs_fs_info *info = root->fs_info;
 243         int harder_count = 0;
 244
 245 harder:
 246         if (atomic_read(&info->throttles)) {
 247                 DEFINE_WAIT(wait);
 248                 int thr;
 249                 thr = atomic_read(&info->throttle_gen);
 250
 251                 do {
 252                         prepare_to_wait(&info->transaction_throttle,
 253                                         &wait, TASK_UNINTERRUPTIBLE);
 254                         if (!atomic_read(&info->throttles)) {
 255                                 finish_wait(&info->transaction_throttle, &wait);
 256                                 break;
 257                         }
 258                         schedule();
 259                         finish_wait(&info->transaction_throttle, &wait);
 260                 } while (thr == atomic_read(&info->throttle_gen));
 261                 harder_count++;
 262
 263                 if (root->fs_info->total_ref_cache_size > 1 * 1024 * 1024 &&
 264                     harder_count < 2)
 265                         goto harder;
 266
 267                 if (root->fs_info->total_ref_cache_size > 5 * 1024 * 1024 &&
 268                     harder_count < 10)
 269                         goto harder;
 270
 271                 if (root->fs_info->total_ref_cache_size > 10 * 1024 * 1024 &&
 272                     harder_count < 20)
 273                         goto harder;
 274         }
 275 }
 276 #endif
 277
 278 void btrfs_throttle(struct btrfs_root *root)
 279 {
 280         mutex_lock(&root->fs_info->trans_mutex);
 281         if (!root->fs_info->open_ioctl_trans)
 282                 wait_current_trans(root);
 283         mutex_unlock(&root->fs_info->trans_mutex);
 284 }
 285
 286 static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
 287                           struct btrfs_root *root, int throttle)
 288 {
 289         struct btrfs_transaction *cur_trans;
 290         struct btrfs_fs_info *info = root->fs_info;
 291         int count = 0;
 292
 293         while (count < 4) {
 294                 unsigned long cur = trans->delayed_ref_updates;
 295                 trans->delayed_ref_updates = 0;
 296                 if (cur &&
 297                     trans->transaction->delayed_refs.num_heads_ready > 64) {
 298                         trans->delayed_ref_updates = 0;
 299
 300                         /*
 301                          * do a full flush if the transaction is trying
 302                          * to close
 303                          */
 304                         if (trans->transaction->delayed_refs.flushing)
 305                                 cur = 0;
 306                         btrfs_run_delayed_refs(trans, root, cur);
 307                 } else {
 308                         break;
 309                 }
 310                 count++;
 311         }
 312
 313         mutex_lock(&info->trans_mutex);
 314         cur_trans = info->running_transaction;
 315         WARN_ON(cur_trans != trans->transaction);
 316         WARN_ON(cur_trans->num_writers < 1);
 317         cur_trans->num_writers--;
 318
 319         if (waitqueue_active(&cur_trans->writer_wait))
 320                 wake_up(&cur_trans->writer_wait);
 321         put_transaction(cur_trans);
 322         mutex_unlock(&info->trans_mutex);
 323         memset(trans, 0, sizeof(*trans));
 324         kmem_cache_free(btrfs_trans_handle_cachep, trans);
 325
 326         return 0;
 327 }
 328
 329 int btrfs_end_transaction(struct btrfs_trans_handle *trans,
 330                           struct btrfs_root *root)
 331 {
 332         return __btrfs_end_transaction(trans, root, 0);
 333 }
 334
 335 int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans,
 336                                    struct btrfs_root *root)
 337 {
 338         return __btrfs_end_transaction(trans, root, 1);
 339 }
 340
 341 /*
 342  * when btree blocks are allocated, they have some corresponding bits set for
 343  * them in one of two extent_io trees.  This is used to make sure all of
 344  * those extents are on disk for transaction or log commit
 345  */
 346 int btrfs_write_and_wait_marked_extents(struct btrfs_root *root,
 347                                         struct extent_io_tree *dirty_pages)
 348 {
 349         int ret;
 350         int err = 0;
 351         int werr = 0;
 352         struct page *page;
 353         struct inode *btree_inode = root->fs_info->btree_inode;
 354         u64 start = 0;
 355         u64 end;
 356         unsigned long index;
 357
 358         while (1) {
 359                 ret = find_first_extent_bit(dirty_pages, start, &start, &end,
 360                                             EXTENT_DIRTY);
 361                 if (ret)
 362                         break;
 363                 while (start <= end) {
 364                         cond_resched();
 365
 366                         index = start >> PAGE_CACHE_SHIFT;
 367                         start = (u64)(index + 1) << PAGE_CACHE_SHIFT;
 368                         page = find_get_page(btree_inode->i_mapping, index);
 369                         if (!page)
 370                                 continue;
 371
 372                         btree_lock_page_hook(page);
 373                         if (!page->mapping) {
 374                                 unlock_page(page);
 375                                 page_cache_release(page);
 376                                 continue;
 377                         }
 378
 379                         if (PageWriteback(page)) {
 380                                 if (PageDirty(page))
 381                                         wait_on_page_writeback(page);
 382                                 else {
 383                                         unlock_page(page);
 384                                         page_cache_release(page);
 385                                         continue;
 386                                 }
 387                         }
 388                         err = write_one_page(page, 0);
 389                         if (err)
 390                                 werr = err;
 391                         page_cache_release(page);
 392                 }
 393         }
 394         while (1) {
 395                 ret = find_first_extent_bit(dirty_pages, 0, &start, &end,
 396                                             EXTENT_DIRTY);
 397                 if (ret)
 398                         break;
 399
 400                 clear_extent_dirty(dirty_pages, start, end, GFP_NOFS);
 401                 while (start <= end) {
 402                         index = start >> PAGE_CACHE_SHIFT;
 403                         start = (u64)(index + 1) << PAGE_CACHE_SHIFT;
 404                         page = find_get_page(btree_inode->i_mapping, index);
 405                         if (!page)
 406                                 continue;
 407                         if (PageDirty(page)) {
 408                                 btree_lock_page_hook(page);
 409                                 wait_on_page_writeback(page);
 410                                 err = write_one_page(page, 0);
 411                                 if (err)
 412                                         werr = err;
 413                         }
 414                         wait_on_page_writeback(page);
 415                         page_cache_release(page);
 416                         cond_resched();
 417                 }
 418         }
 419         if (err)
 420                 werr = err;
 421         return werr;
 422 }
 423
 424 int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans,
 425                                      struct btrfs_root *root)
 426 {
 427         if (!trans || !trans->transaction) {
 428                 struct inode *btree_inode;
 429                 btree_inode = root->fs_info->btree_inode;
 430                 return filemap_write_and_wait(btree_inode->i_mapping);
 431         }
 432         return btrfs_write_and_wait_marked_extents(root,
 433                                            &trans->transaction->dirty_pages);
 434 }
 435
 436 /*
 437  * this is used to update the root pointer in the tree of tree roots.
 438  *
 439  * But, in the case of the extent allocation tree, updating the root
 440  * pointer may allocate blocks which may change the root of the extent
 441  * allocation tree.
 442  *
 443  * So, this loops and repeats and makes sure the cowonly root didn't
 444  * change while the root pointer was being updated in the metadata.
 445  */
 446 static int update_cowonly_root(struct btrfs_trans_handle *trans,
 447                                struct btrfs_root *root)
 448 {
 449         int ret;
 450         u64 old_root_bytenr;
 451         struct btrfs_root *tree_root = root->fs_info->tree_root;
 452
 453         btrfs_write_dirty_block_groups(trans, root);
 454
 455         while (1) {
 456                 old_root_bytenr = btrfs_root_bytenr(&root->root_item);
 457                 if (old_root_bytenr == root->node->start)
 458                         break;
 459
 460                 btrfs_set_root_node(&root->root_item, root->node);
 461                 ret = btrfs_update_root(trans, tree_root,
 462                                         &root->root_key,
 463                                         &root->root_item);
 464                 BUG_ON(ret);
 465
 466                 ret = btrfs_write_dirty_block_groups(trans, root);
 467                 BUG_ON(ret);
 468         }
 469         switch_commit_root(root);
 470         return 0;
 471 }
 472
 473 /*
 474  * update all the cowonly tree roots on disk
 475  */
 476 static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans,
 477                                          struct btrfs_root *root)
 478 {
 479         struct btrfs_fs_info *fs_info = root->fs_info;
 480         struct list_head *next;
 481         struct extent_buffer *eb;
 482         int ret;
 483
 484         ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
 485         BUG_ON(ret);
 486
 487         eb = btrfs_lock_root_node(fs_info->tree_root);
 488         btrfs_cow_block(trans, fs_info->tree_root, eb, NULL, 0, &eb);
 489         btrfs_tree_unlock(eb);
 490         free_extent_buffer(eb);
 491
 492         ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
 493         BUG_ON(ret);
 494
 495         while (!list_empty(&fs_info->dirty_cowonly_roots)) {
 496                 next = fs_info->dirty_cowonly_roots.next;
 497                 list_del_init(next);
 498                 root = list_entry(next, struct btrfs_root, dirty_list);
 499
 500                 update_cowonly_root(trans, root);
 501         }
 502         return 0;
 503 }
 504
 505 /*
 506  * dead roots are old snapshots that need to be deleted.  This allocates
 507  * a dirty root struct and adds it into the list of dead roots that need to
 508  * be deleted
 509  */
 510 int btrfs_add_dead_root(struct btrfs_root *root)
 511 {
 512         mutex_lock(&root->fs_info->trans_mutex);
 513         list_add(&root->root_list, &root->fs_info->dead_roots);
 514         mutex_unlock(&root->fs_info->trans_mutex);
 515         return 0;
 516 }
 517
 518 /*
 519  * update all the cowonly tree roots on disk
 520  */
 521 static noinline int commit_fs_roots(struct btrfs_trans_handle *trans,
 522                                     struct btrfs_root *root)
 523 {
 524         struct btrfs_root *gang[8];
 525         struct btrfs_fs_info *fs_info = root->fs_info;
 526         int i;
 527         int ret;
 528         int err = 0;
 529
 530         while (1) {
 531                 ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix,
 532                                                  (void **)gang, 0,
 533                                                  ARRAY_SIZE(gang),
 534                                                  BTRFS_ROOT_TRANS_TAG);
 535                 if (ret == 0)
 536                         break;
 537                 for (i = 0; i < ret; i++) {
 538                         root = gang[i];
 539                         radix_tree_tag_clear(&fs_info->fs_roots_radix,
 540                                         (unsigned long)root->root_key.objectid,
 541                                         BTRFS_ROOT_TRANS_TAG);
 542
 543                         btrfs_free_log(trans, root);
 544                         btrfs_update_reloc_root(trans, root);
 545
 546                         if (root->commit_root != root->node) {
 547                                 switch_commit_root(root);
 548                                 btrfs_set_root_node(&root->root_item,
 549                                                     root->node);
 550                         }
 551
 552                         err = btrfs_update_root(trans, fs_info->tree_root,
 553                                                 &root->root_key,
 554                                                 &root->root_item);
 555                         if (err)
 556                                 break;
 557                 }
 558         }
 559         return err;
 560 }
 561
 562 /*
 563  * defrag a given btree.  If cacheonly == 1, this won't read from the disk,
 564  * otherwise every leaf in the btree is read and defragged.
 565  */
 566 int btrfs_defrag_root(struct btrfs_root *root, int cacheonly)
 567 {
 568         struct btrfs_fs_info *info = root->fs_info;
 569         int ret;
 570         struct btrfs_trans_handle *trans;
 571         unsigned long nr;
 572
 573         smp_mb();
 574         if (root->defrag_running)
 575                 return 0;
 576         trans = btrfs_start_transaction(root, 1);
 577         while (1) {
 578                 root->defrag_running = 1;
 579                 ret = btrfs_defrag_leaves(trans, root, cacheonly);
 580                 nr = trans->blocks_used;
 581                 btrfs_end_transaction(trans, root);
 582                 btrfs_btree_balance_dirty(info->tree_root, nr);
 583                 cond_resched();
 584
 585                 trans = btrfs_start_transaction(root, 1);
 586                 if (root->fs_info->closing || ret != -EAGAIN)
 587                         break;
 588         }
 589         root->defrag_running = 0;
 590         smp_mb();
 591         btrfs_end_transaction(trans, root);
 592         return 0;
 593 }
 594
 595 #if 0
 596 /*
 597  * when dropping snapshots, we generate a ton of delayed refs, and it makes
 598  * sense not to join the transaction while it is trying to flush the current
 599  * queue of delayed refs out.
 600  *
 601  * This is used by the drop snapshot code only
 602  */
 603 static noinline int wait_transaction_pre_flush(struct btrfs_fs_info *info)
 604 {
 605         DEFINE_WAIT(wait);
 606
 607         mutex_lock(&info->trans_mutex);
 608         while (info->running_transaction &&
 609                info->running_transaction->delayed_refs.flushing) {
 610                 prepare_to_wait(&info->transaction_wait, &wait,
 611                                 TASK_UNINTERRUPTIBLE);
 612                 mutex_unlock(&info->trans_mutex);
 613
 614                 schedule();
 615
 616                 mutex_lock(&info->trans_mutex);
 617                 finish_wait(&info->transaction_wait, &wait);
 618         }
 619         mutex_unlock(&info->trans_mutex);
 620         return 0;
 621 }
 622
 623 /*
 624  * Given a list of roots that need to be deleted, call btrfs_drop_snapshot on
 625  * all of them
 626  */
 627 int btrfs_drop_dead_root(struct btrfs_root *root)
 628 {
 629         struct btrfs_trans_handle *trans;
 630         struct btrfs_root *tree_root = root->fs_info->tree_root;
 631         unsigned long nr;
 632         int ret;
 633
 634         while (1) {
 635                 /*
 636                  * we don't want to jump in and create a bunch of
 637                  * delayed refs if the transaction is starting to close
 638                  */
 639                 wait_transaction_pre_flush(tree_root->fs_info);
 640                 trans = btrfs_start_transaction(tree_root, 1);
 641
 642                 /*
 643                  * we've joined a transaction, make sure it isn't
 644                  * closing right now
 645                  */
 646                 if (trans->transaction->delayed_refs.flushing) {
 647                         btrfs_end_transaction(trans, tree_root);
 648                         continue;
 649                 }
 650
 651                 ret = btrfs_drop_snapshot(trans, root);
 652                 if (ret != -EAGAIN)
 653                         break;
 654
 655                 ret = btrfs_update_root(trans, tree_root,
 656                                         &root->root_key,
 657                                         &root->root_item);
 658                 if (ret)
 659                         break;
 660
 661                 nr = trans->blocks_used;
 662                 ret = btrfs_end_transaction(trans, tree_root);
 663                 BUG_ON(ret);
 664
 665                 btrfs_btree_balance_dirty(tree_root, nr);
 666                 cond_resched();
 667         }
 668         BUG_ON(ret);
 669
 670         ret = btrfs_del_root(trans, tree_root, &root->root_key);
 671         BUG_ON(ret);
 672
 673         nr = trans->blocks_used;
 674         ret = btrfs_end_transaction(trans, tree_root);
 675         BUG_ON(ret);
 676
 677         free_extent_buffer(root->node);
 678         free_extent_buffer(root->commit_root);
 679         kfree(root);
 680
 681         btrfs_btree_balance_dirty(tree_root, nr);
 682         return ret;
 683 }
 684 #endif
 685
 686 /*
 687  * new snapshots need to be created at a very specific time in the
 688  * transaction commit.  This does the actual creation
 689  */
 690 static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
 691                                    struct btrfs_fs_info *fs_info,
 692                                    struct btrfs_pending_snapshot *pending)
 693 {
 694         struct btrfs_key key;
 695         struct btrfs_root_item *new_root_item;
 696         struct btrfs_root *tree_root = fs_info->tree_root;
 697         struct btrfs_root *root = pending->root;
 698         struct extent_buffer *tmp;
 699         struct extent_buffer *old;
 700         int ret;
 701         u64 objectid;
 702
 703         new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS);
 704         if (!new_root_item) {
 705                 ret = -ENOMEM;
 706                 goto fail;
 707         }
 708         ret = btrfs_find_free_objectid(trans, tree_root, 0, &objectid);
 709         if (ret)
 710                 goto fail;
 711
 712         record_root_in_trans(trans, root);
 713         btrfs_set_root_last_snapshot(&root->root_item, trans->transid);
 714         memcpy(new_root_item, &root->root_item, sizeof(*new_root_item));
 715
 716         key.objectid = objectid;
 717         key.offset = 0;
 718         btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY);
 719
 720         old = btrfs_lock_root_node(root);
 721         btrfs_cow_block(trans, root, old, NULL, 0, &old);
 722         btrfs_set_lock_blocking(old);
 723
 724         btrfs_copy_root(trans, root, old, &tmp, objectid);
 725         btrfs_tree_unlock(old);
 726         free_extent_buffer(old);
 727
 728         btrfs_set_root_node(new_root_item, tmp);
 729         ret = btrfs_insert_root(trans, root->fs_info->tree_root, &key,
 730                                 new_root_item);
 731         btrfs_tree_unlock(tmp);
 732         free_extent_buffer(tmp);
 733         if (ret)
 734                 goto fail;
 735
 736         key.offset = (u64)-1;
 737         memcpy(&pending->root_key, &key, sizeof(key));
 738 fail:
 739         kfree(new_root_item);
 740         return ret;
 741 }
 742
 743 static noinline int finish_pending_snapshot(struct btrfs_fs_info *fs_info,
 744                                    struct btrfs_pending_snapshot *pending)
 745 {
 746         int ret;
 747         int namelen;
 748         u64 index = 0;
 749         struct btrfs_trans_handle *trans;
 750         struct inode *parent_inode;
 751         struct inode *inode;
 752         struct btrfs_root *parent_root;
 753
 754         parent_inode = pending->dentry->d_parent->d_inode;
 755         parent_root = BTRFS_I(parent_inode)->root;
 756         trans = btrfs_join_transaction(parent_root, 1);
 757
 758         /*
 759          * insert the directory item
 760          */
 761         namelen = strlen(pending->name);
 762         ret = btrfs_set_inode_index(parent_inode, &index);
 763         ret = btrfs_insert_dir_item(trans, parent_root,
 764                             pending->name, namelen,
 765                             parent_inode->i_ino,
 766                             &pending->root_key, BTRFS_FT_DIR, index);
 767
 768         if (ret)
 769                 goto fail;
 770
 771         btrfs_i_size_write(parent_inode, parent_inode->i_size + namelen * 2);
 772         ret = btrfs_update_inode(trans, parent_root, parent_inode);
 773         BUG_ON(ret);
 774
 775         /* add the backref first */
 776         ret = btrfs_add_root_ref(trans, parent_root->fs_info->tree_root,
 777                                  pending->root_key.objectid,
 778                                  BTRFS_ROOT_BACKREF_KEY,
 779                                  parent_root->root_key.objectid,
 780                                  parent_inode->i_ino, index, pending->name,
 781                                  namelen);
 782
 783         BUG_ON(ret);
 784
 785         /* now add the forward ref */
 786         ret = btrfs_add_root_ref(trans, parent_root->fs_info->tree_root,
 787                                  parent_root->root_key.objectid,
 788                                  BTRFS_ROOT_REF_KEY,
 789                                  pending->root_key.objectid,
 790                                  parent_inode->i_ino, index, pending->name,
 791                                  namelen);
 792
 793         inode = btrfs_lookup_dentry(parent_inode, pending->dentry);
 794         d_instantiate(pending->dentry, inode);
 795 fail:
 796         btrfs_end_transaction(trans, fs_info->fs_root);
 797         return ret;
 798 }
 799
 800 /*
 801  * create all the snapshots we've scheduled for creation
 802  */
 803 static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans,
 804                                              struct btrfs_fs_info *fs_info)
 805 {
 806         struct btrfs_pending_snapshot *pending;
 807         struct list_head *head = &trans->transaction->pending_snapshots;
 808         int ret;
 809
 810         list_for_each_entry(pending, head, list) {
 811                 ret = create_pending_snapshot(trans, fs_info, pending);
 812                 BUG_ON(ret);
 813         }
 814         return 0;
 815 }
 816
 817 static noinline int finish_pending_snapshots(struct btrfs_trans_handle *trans,
 818                                              struct btrfs_fs_info *fs_info)
 819 {
 820         struct btrfs_pending_snapshot *pending;
 821         struct list_head *head = &trans->transaction->pending_snapshots;
 822         int ret;
 823
 824         while (!list_empty(head)) {
 825                 pending = list_entry(head->next,
 826                                      struct btrfs_pending_snapshot, list);
 827                 ret = finish_pending_snapshot(fs_info, pending);
 828                 BUG_ON(ret);
 829                 list_del(&pending->list);
 830                 kfree(pending->name);
 831                 kfree(pending);
 832         }
 833         return 0;
 834 }
 835
 836 static void update_super_roots(struct btrfs_root *root)
 837 {
 838         struct btrfs_root_item *root_item;
 839         struct btrfs_super_block *super;
 840
 841         super = &root->fs_info->super_copy;
 842
 843         root_item = &root->fs_info->chunk_root->root_item;
 844         super->chunk_root = root_item->bytenr;
 845         super->chunk_root_generation = root_item->generation;
 846         super->chunk_root_level = root_item->level;
 847
 848         root_item = &root->fs_info->tree_root->root_item;
 849         super->root = root_item->bytenr;
 850         super->generation = root_item->generation;
 851         super->root_level = root_item->level;
 852 }
 853
 854 int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
 855                              struct btrfs_root *root)
 856 {
 857         unsigned long joined = 0;
 858         unsigned long timeout = 1;
 859         struct btrfs_transaction *cur_trans;
 860         struct btrfs_transaction *prev_trans = NULL;
 861         struct extent_io_tree *pinned_copy;
 862         DEFINE_WAIT(wait);
 863         int ret;
 864         int should_grow = 0;
 865         unsigned long now = get_seconds();
 866         int flush_on_commit = btrfs_test_opt(root, FLUSHONCOMMIT);
 867
 868         btrfs_run_ordered_operations(root, 0);
 869
 870         /* make a pass through all the delayed refs we have so far
 871          * any runnings procs may add more while we are here
 872          */
 873         ret = btrfs_run_delayed_refs(trans, root, 0);
 874         BUG_ON(ret);
 875
 876         cur_trans = trans->transaction;
 877         /*
 878          * set the flushing flag so procs in this transaction have to
 879          * start sending their work down.
 880          */
 881         cur_trans->delayed_refs.flushing = 1;
 882
 883         ret = btrfs_run_delayed_refs(trans, root, 0);
 884         BUG_ON(ret);
 885
 886         mutex_lock(&root->fs_info->trans_mutex);
 887         if (cur_trans->in_commit) {
 888                 cur_trans->use_count++;
 889                 mutex_unlock(&root->fs_info->trans_mutex);
 890                 btrfs_end_transaction(trans, root);
 891
 892                 ret = wait_for_commit(root, cur_trans);
 893                 BUG_ON(ret);
 894
 895                 mutex_lock(&root->fs_info->trans_mutex);
 896                 put_transaction(cur_trans);
 897                 mutex_unlock(&root->fs_info->trans_mutex);
 898
 899                 return 0;
 900         }
 901
 902         pinned_copy = kmalloc(sizeof(*pinned_copy), GFP_NOFS);
 903         if (!pinned_copy)
 904                 return -ENOMEM;
 905
 906         extent_io_tree_init(pinned_copy,
 907                              root->fs_info->btree_inode->i_mapping, GFP_NOFS);
 908
 909         trans->transaction->in_commit = 1;
 910         trans->transaction->blocked = 1;
 911         if (cur_trans->list.prev != &root->fs_info->trans_list) {
 912                 prev_trans = list_entry(cur_trans->list.prev,
 913                                         struct btrfs_transaction, list);
 914                 if (!prev_trans->commit_done) {
 915                         prev_trans->use_count++;
 916                         mutex_unlock(&root->fs_info->trans_mutex);
 917
 918                         wait_for_commit(root, prev_trans);
 919
 920                         mutex_lock(&root->fs_info->trans_mutex);
 921                         put_transaction(prev_trans);
 922                 }
 923         }
 924
 925         if (now < cur_trans->start_time || now - cur_trans->start_time < 1)
 926                 should_grow = 1;
 927
 928         do {
 929                 int snap_pending = 0;
 930                 joined = cur_trans->num_joined;
 931                 if (!list_empty(&trans->transaction->pending_snapshots))
 932                         snap_pending = 1;
 933
 934                 WARN_ON(cur_trans != trans->transaction);
 935                 prepare_to_wait(&cur_trans->writer_wait, &wait,
 936                                 TASK_UNINTERRUPTIBLE);
 937
 938                 if (cur_trans->num_writers > 1)
 939                         timeout = MAX_SCHEDULE_TIMEOUT;
 940                 else if (should_grow)
 941                         timeout = 1;
 942
 943                 mutex_unlock(&root->fs_info->trans_mutex);
 944
 945                 if (flush_on_commit) {
 946                         btrfs_start_delalloc_inodes(root);
 947                         ret = btrfs_wait_ordered_extents(root, 0);
 948                         BUG_ON(ret);
 949                 } else if (snap_pending) {
 950                         ret = btrfs_wait_ordered_extents(root, 1);
 951                         BUG_ON(ret);
 952                 }
 953
 954                 /*
 955                  * rename don't use btrfs_join_transaction, so, once we
 956                  * set the transaction to blocked above, we aren't going
 957                  * to get any new ordered operations.  We can safely run
 958                  * it here and no for sure that nothing new will be added
 959                  * to the list
 960                  */
 961                 btrfs_run_ordered_operations(root, 1);
 962
 963                 smp_mb();
 964                 if (cur_trans->num_writers > 1 || should_grow)
 965                         schedule_timeout(timeout);
 966
 967                 mutex_lock(&root->fs_info->trans_mutex);
 968                 finish_wait(&cur_trans->writer_wait, &wait);
 969         } while (cur_trans->num_writers > 1 ||
 970                  (should_grow && cur_trans->num_joined != joined));
 971
 972         ret = create_pending_snapshots(trans, root->fs_info);
 973         BUG_ON(ret);
 974
 975         ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
 976         BUG_ON(ret);
 977
 978         WARN_ON(cur_trans != trans->transaction);
 979
 980         /* btrfs_commit_tree_roots is responsible for getting the
 981          * various roots consistent with each other.  Every pointer
 982          * in the tree of tree roots has to point to the most up to date
 983          * root for every subvolume and other tree.  So, we have to keep
 984          * the tree logging code from jumping in and changing any
 985          * of the trees.
 986          *
 987          * At this point in the commit, there can't be any tree-log
 988          * writers, but a little lower down we drop the trans mutex
 989          * and let new people in.  By holding the tree_log_mutex
 990          * from now until after the super is written, we avoid races
 991          * with the tree-log code.
 992          */
 993         mutex_lock(&root->fs_info->tree_log_mutex);
 994
 995         ret = commit_fs_roots(trans, root);
 996         BUG_ON(ret);
 997
 998         /* commit_fs_roots gets rid of all the tree log roots, it is now
 999          * safe to free the root of tree log roots
1000          */
1001         btrfs_free_log_root_tree(trans, root->fs_info);
1002
1003         ret = commit_cowonly_roots(trans, root);
1004         BUG_ON(ret);
1005
1006         cur_trans = root->fs_info->running_transaction;
1007         spin_lock(&root->fs_info->new_trans_lock);
1008         root->fs_info->running_transaction = NULL;
1009         spin_unlock(&root->fs_info->new_trans_lock);
1010
1011         btrfs_set_root_node(&root->fs_info->tree_root->root_item,
1012                             root->fs_info->tree_root->node);
1013         switch_commit_root(root->fs_info->tree_root);
1014
1015         btrfs_set_root_node(&root->fs_info->chunk_root->root_item,
1016                             root->fs_info->chunk_root->node);
1017         switch_commit_root(root->fs_info->chunk_root);
1018
1019         update_super_roots(root);
1020
1021         if (!root->fs_info->log_root_recovering) {
1022                 btrfs_set_super_log_root(&root->fs_info->super_copy, 0);
1023                 btrfs_set_super_log_root_level(&root->fs_info->super_copy, 0);
1024         }
1025
1026         memcpy(&root->fs_info->super_for_commit, &root->fs_info->super_copy,
1027                sizeof(root->fs_info->super_copy));
1028
1029         btrfs_copy_pinned(root, pinned_copy);
1030
1031         trans->transaction->blocked = 0;
1032
1033         wake_up(&root->fs_info->transaction_wait);
1034
1035         mutex_unlock(&root->fs_info->trans_mutex);
1036         ret = btrfs_write_and_wait_transaction(trans, root);
1037         BUG_ON(ret);
1038         write_ctree_super(trans, root, 0);
1039
1040         /*
1041          * the super is written, we can safely allow the tree-loggers
1042          * to go about their business
1043          */
1044         mutex_unlock(&root->fs_info->tree_log_mutex);
1045
1046         btrfs_finish_extent_commit(trans, root, pinned_copy);
1047         kfree(pinned_copy);
1048
1049         /* do the directory inserts of any pending snapshot creations */
1050         finish_pending_snapshots(trans, root->fs_info);
1051
1052         mutex_lock(&root->fs_info->trans_mutex);
1053
1054         cur_trans->commit_done = 1;
1055
1056         root->fs_info->last_trans_committed = cur_trans->transid;
1057
1058         wake_up(&cur_trans->commit_wait);
1059
1060         put_transaction(cur_trans);
1061         put_transaction(cur_trans);
1062
1063         mutex_unlock(&root->fs_info->trans_mutex);
1064
1065         kmem_cache_free(btrfs_trans_handle_cachep, trans);
1066         return ret;
1067 }
1068
1069 /*
1070  * interface function to delete all the snapshots we have scheduled for deletion
1071  */
1072 int btrfs_clean_old_snapshots(struct btrfs_root *root)
1073 {
1074         LIST_HEAD(list);
1075         struct btrfs_fs_info *fs_info = root->fs_info;
1076
1077         mutex_lock(&fs_info->trans_mutex);
1078         list_splice_init(&fs_info->dead_roots, &list);
1079         mutex_unlock(&fs_info->trans_mutex);
1080
1081         while (!list_empty(&list)) {
1082                 root = list_entry(list.next, struct btrfs_root, root_list);
1083                 list_del_init(&root->root_list);
1084                 btrfs_drop_snapshot(root, 0);
1085         }
1086         return 0;
1087 }