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