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