1 /* 2 * Copyright (C) 2007 Oracle. All rights reserved. 3 * 4 * This program is free software; you can redistribute it and/or 5 * modify it under the terms of the GNU General Public 6 * License v2 as published by the Free Software Foundation. 7 * 8 * This program is distributed in the hope that it will be useful, 9 * but WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 11 * General Public License for more details. 12 * 13 * You should have received a copy of the GNU General Public 14 * License along with this program; if not, write to the 15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 16 * Boston, MA 021110-1307, USA. 17 */ 18 19 #include <linux/fs.h> 20 #include <linux/slab.h> 21 #include <linux/sched.h> 22 #include <linux/writeback.h> 23 #include <linux/pagemap.h> 24 #include <linux/blkdev.h> 25 #include <linux/uuid.h> 26 #include "ctree.h" 27 #include "disk-io.h" 28 #include "transaction.h" 29 #include "locking.h" 30 #include "tree-log.h" 31 #include "inode-map.h" 32 #include "volumes.h" 33 #include "dev-replace.h" 34 #include "qgroup.h" 35 36 #define BTRFS_ROOT_TRANS_TAG 0 37 38 static const unsigned int btrfs_blocked_trans_types[TRANS_STATE_MAX] = { 39 [TRANS_STATE_RUNNING] = 0U, 40 [TRANS_STATE_BLOCKED] = (__TRANS_USERSPACE | 41 __TRANS_START), 42 [TRANS_STATE_COMMIT_START] = (__TRANS_USERSPACE | 43 __TRANS_START | 44 __TRANS_ATTACH), 45 [TRANS_STATE_COMMIT_DOING] = (__TRANS_USERSPACE | 46 __TRANS_START | 47 __TRANS_ATTACH | 48 __TRANS_JOIN), 49 [TRANS_STATE_UNBLOCKED] = (__TRANS_USERSPACE | 50 __TRANS_START | 51 __TRANS_ATTACH | 52 __TRANS_JOIN | 53 __TRANS_JOIN_NOLOCK), 54 [TRANS_STATE_COMPLETED] = (__TRANS_USERSPACE | 55 __TRANS_START | 56 __TRANS_ATTACH | 57 __TRANS_JOIN | 58 __TRANS_JOIN_NOLOCK), 59 }; 60 61 void btrfs_put_transaction(struct btrfs_transaction *transaction) 62 { 63 WARN_ON(atomic_read(&transaction->use_count) == 0); 64 if (atomic_dec_and_test(&transaction->use_count)) { 65 BUG_ON(!list_empty(&transaction->list)); 66 WARN_ON(!RB_EMPTY_ROOT(&transaction->delayed_refs.href_root)); 67 if (transaction->delayed_refs.pending_csums) 68 printk(KERN_ERR "pending csums is %llu\n", 69 transaction->delayed_refs.pending_csums); 70 while (!list_empty(&transaction->pending_chunks)) { 71 struct extent_map *em; 72 73 em = list_first_entry(&transaction->pending_chunks, 74 struct extent_map, list); 75 list_del_init(&em->list); 76 free_extent_map(em); 77 } 78 /* 79 * If any block groups are found in ->deleted_bgs then it's 80 * because the transaction was aborted and a commit did not 81 * happen (things failed before writing the new superblock 82 * and calling btrfs_finish_extent_commit()), so we can not 83 * discard the physical locations of the block groups. 84 */ 85 while (!list_empty(&transaction->deleted_bgs)) { 86 struct btrfs_block_group_cache *cache; 87 88 cache = list_first_entry(&transaction->deleted_bgs, 89 struct btrfs_block_group_cache, 90 bg_list); 91 list_del_init(&cache->bg_list); 92 btrfs_put_block_group_trimming(cache); 93 btrfs_put_block_group(cache); 94 } 95 kmem_cache_free(btrfs_transaction_cachep, transaction); 96 } 97 } 98 99 static void clear_btree_io_tree(struct extent_io_tree *tree) 100 { 101 spin_lock(&tree->lock); 102 /* 103 * Do a single barrier for the waitqueue_active check here, the state 104 * of the waitqueue should not change once clear_btree_io_tree is 105 * called. 106 */ 107 smp_mb(); 108 while (!RB_EMPTY_ROOT(&tree->state)) { 109 struct rb_node *node; 110 struct extent_state *state; 111 112 node = rb_first(&tree->state); 113 state = rb_entry(node, struct extent_state, rb_node); 114 rb_erase(&state->rb_node, &tree->state); 115 RB_CLEAR_NODE(&state->rb_node); 116 /* 117 * btree io trees aren't supposed to have tasks waiting for 118 * changes in the flags of extent states ever. 119 */ 120 ASSERT(!waitqueue_active(&state->wq)); 121 free_extent_state(state); 122 123 cond_resched_lock(&tree->lock); 124 } 125 spin_unlock(&tree->lock); 126 } 127 128 static noinline void switch_commit_roots(struct btrfs_transaction *trans, 129 struct btrfs_fs_info *fs_info) 130 { 131 struct btrfs_root *root, *tmp; 132 133 down_write(&fs_info->commit_root_sem); 134 list_for_each_entry_safe(root, tmp, &trans->switch_commits, 135 dirty_list) { 136 list_del_init(&root->dirty_list); 137 free_extent_buffer(root->commit_root); 138 root->commit_root = btrfs_root_node(root); 139 if (is_fstree(root->objectid)) 140 btrfs_unpin_free_ino(root); 141 clear_btree_io_tree(&root->dirty_log_pages); 142 } 143 144 /* We can free old roots now. */ 145 spin_lock(&trans->dropped_roots_lock); 146 while (!list_empty(&trans->dropped_roots)) { 147 root = list_first_entry(&trans->dropped_roots, 148 struct btrfs_root, root_list); 149 list_del_init(&root->root_list); 150 spin_unlock(&trans->dropped_roots_lock); 151 btrfs_drop_and_free_fs_root(fs_info, root); 152 spin_lock(&trans->dropped_roots_lock); 153 } 154 spin_unlock(&trans->dropped_roots_lock); 155 up_write(&fs_info->commit_root_sem); 156 } 157 158 static inline void extwriter_counter_inc(struct btrfs_transaction *trans, 159 unsigned int type) 160 { 161 if (type & TRANS_EXTWRITERS) 162 atomic_inc(&trans->num_extwriters); 163 } 164 165 static inline void extwriter_counter_dec(struct btrfs_transaction *trans, 166 unsigned int type) 167 { 168 if (type & TRANS_EXTWRITERS) 169 atomic_dec(&trans->num_extwriters); 170 } 171 172 static inline void extwriter_counter_init(struct btrfs_transaction *trans, 173 unsigned int type) 174 { 175 atomic_set(&trans->num_extwriters, ((type & TRANS_EXTWRITERS) ? 1 : 0)); 176 } 177 178 static inline int extwriter_counter_read(struct btrfs_transaction *trans) 179 { 180 return atomic_read(&trans->num_extwriters); 181 } 182 183 /* 184 * either allocate a new transaction or hop into the existing one 185 */ 186 static noinline int join_transaction(struct btrfs_root *root, unsigned int type) 187 { 188 struct btrfs_transaction *cur_trans; 189 struct btrfs_fs_info *fs_info = root->fs_info; 190 191 spin_lock(&fs_info->trans_lock); 192 loop: 193 /* The file system has been taken offline. No new transactions. */ 194 if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) { 195 spin_unlock(&fs_info->trans_lock); 196 return -EROFS; 197 } 198 199 cur_trans = fs_info->running_transaction; 200 if (cur_trans) { 201 if (cur_trans->aborted) { 202 spin_unlock(&fs_info->trans_lock); 203 return cur_trans->aborted; 204 } 205 if (btrfs_blocked_trans_types[cur_trans->state] & type) { 206 spin_unlock(&fs_info->trans_lock); 207 return -EBUSY; 208 } 209 atomic_inc(&cur_trans->use_count); 210 atomic_inc(&cur_trans->num_writers); 211 extwriter_counter_inc(cur_trans, type); 212 spin_unlock(&fs_info->trans_lock); 213 return 0; 214 } 215 spin_unlock(&fs_info->trans_lock); 216 217 /* 218 * If we are ATTACH, we just want to catch the current transaction, 219 * and commit it. If there is no transaction, just return ENOENT. 220 */ 221 if (type == TRANS_ATTACH) 222 return -ENOENT; 223 224 /* 225 * JOIN_NOLOCK only happens during the transaction commit, so 226 * it is impossible that ->running_transaction is NULL 227 */ 228 BUG_ON(type == TRANS_JOIN_NOLOCK); 229 230 cur_trans = kmem_cache_alloc(btrfs_transaction_cachep, GFP_NOFS); 231 if (!cur_trans) 232 return -ENOMEM; 233 234 spin_lock(&fs_info->trans_lock); 235 if (fs_info->running_transaction) { 236 /* 237 * someone started a transaction after we unlocked. Make sure 238 * to redo the checks above 239 */ 240 kmem_cache_free(btrfs_transaction_cachep, cur_trans); 241 goto loop; 242 } else if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) { 243 spin_unlock(&fs_info->trans_lock); 244 kmem_cache_free(btrfs_transaction_cachep, cur_trans); 245 return -EROFS; 246 } 247 248 atomic_set(&cur_trans->num_writers, 1); 249 extwriter_counter_init(cur_trans, type); 250 init_waitqueue_head(&cur_trans->writer_wait); 251 init_waitqueue_head(&cur_trans->commit_wait); 252 init_waitqueue_head(&cur_trans->pending_wait); 253 cur_trans->state = TRANS_STATE_RUNNING; 254 /* 255 * One for this trans handle, one so it will live on until we 256 * commit the transaction. 257 */ 258 atomic_set(&cur_trans->use_count, 2); 259 atomic_set(&cur_trans->pending_ordered, 0); 260 cur_trans->flags = 0; 261 cur_trans->start_time = get_seconds(); 262 263 memset(&cur_trans->delayed_refs, 0, sizeof(cur_trans->delayed_refs)); 264 265 cur_trans->delayed_refs.href_root = RB_ROOT; 266 cur_trans->delayed_refs.dirty_extent_root = RB_ROOT; 267 atomic_set(&cur_trans->delayed_refs.num_entries, 0); 268 269 /* 270 * although the tree mod log is per file system and not per transaction, 271 * the log must never go across transaction boundaries. 272 */ 273 smp_mb(); 274 if (!list_empty(&fs_info->tree_mod_seq_list)) 275 WARN(1, KERN_ERR "BTRFS: tree_mod_seq_list not empty when " 276 "creating a fresh transaction\n"); 277 if (!RB_EMPTY_ROOT(&fs_info->tree_mod_log)) 278 WARN(1, KERN_ERR "BTRFS: tree_mod_log rb tree not empty when " 279 "creating a fresh transaction\n"); 280 atomic64_set(&fs_info->tree_mod_seq, 0); 281 282 spin_lock_init(&cur_trans->delayed_refs.lock); 283 284 INIT_LIST_HEAD(&cur_trans->pending_snapshots); 285 INIT_LIST_HEAD(&cur_trans->pending_chunks); 286 INIT_LIST_HEAD(&cur_trans->switch_commits); 287 INIT_LIST_HEAD(&cur_trans->dirty_bgs); 288 INIT_LIST_HEAD(&cur_trans->io_bgs); 289 INIT_LIST_HEAD(&cur_trans->dropped_roots); 290 mutex_init(&cur_trans->cache_write_mutex); 291 cur_trans->num_dirty_bgs = 0; 292 spin_lock_init(&cur_trans->dirty_bgs_lock); 293 INIT_LIST_HEAD(&cur_trans->deleted_bgs); 294 spin_lock_init(&cur_trans->dropped_roots_lock); 295 list_add_tail(&cur_trans->list, &fs_info->trans_list); 296 extent_io_tree_init(&cur_trans->dirty_pages, 297 fs_info->btree_inode->i_mapping); 298 fs_info->generation++; 299 cur_trans->transid = fs_info->generation; 300 fs_info->running_transaction = cur_trans; 301 cur_trans->aborted = 0; 302 spin_unlock(&fs_info->trans_lock); 303 304 return 0; 305 } 306 307 /* 308 * this does all the record keeping required to make sure that a reference 309 * counted root is properly recorded in a given transaction. This is required 310 * to make sure the old root from before we joined the transaction is deleted 311 * when the transaction commits 312 */ 313 static int record_root_in_trans(struct btrfs_trans_handle *trans, 314 struct btrfs_root *root) 315 { 316 if (test_bit(BTRFS_ROOT_REF_COWS, &root->state) && 317 root->last_trans < trans->transid) { 318 WARN_ON(root == root->fs_info->extent_root); 319 WARN_ON(root->commit_root != root->node); 320 321 /* 322 * see below for IN_TRANS_SETUP usage rules 323 * we have the reloc mutex held now, so there 324 * is only one writer in this function 325 */ 326 set_bit(BTRFS_ROOT_IN_TRANS_SETUP, &root->state); 327 328 /* make sure readers find IN_TRANS_SETUP before 329 * they find our root->last_trans update 330 */ 331 smp_wmb(); 332 333 spin_lock(&root->fs_info->fs_roots_radix_lock); 334 if (root->last_trans == trans->transid) { 335 spin_unlock(&root->fs_info->fs_roots_radix_lock); 336 return 0; 337 } 338 radix_tree_tag_set(&root->fs_info->fs_roots_radix, 339 (unsigned long)root->root_key.objectid, 340 BTRFS_ROOT_TRANS_TAG); 341 spin_unlock(&root->fs_info->fs_roots_radix_lock); 342 root->last_trans = trans->transid; 343 344 /* this is pretty tricky. We don't want to 345 * take the relocation lock in btrfs_record_root_in_trans 346 * unless we're really doing the first setup for this root in 347 * this transaction. 348 * 349 * Normally we'd use root->last_trans as a flag to decide 350 * if we want to take the expensive mutex. 351 * 352 * But, we have to set root->last_trans before we 353 * init the relocation root, otherwise, we trip over warnings 354 * in ctree.c. The solution used here is to flag ourselves 355 * with root IN_TRANS_SETUP. When this is 1, we're still 356 * fixing up the reloc trees and everyone must wait. 357 * 358 * When this is zero, they can trust root->last_trans and fly 359 * through btrfs_record_root_in_trans without having to take the 360 * lock. smp_wmb() makes sure that all the writes above are 361 * done before we pop in the zero below 362 */ 363 btrfs_init_reloc_root(trans, root); 364 smp_mb__before_atomic(); 365 clear_bit(BTRFS_ROOT_IN_TRANS_SETUP, &root->state); 366 } 367 return 0; 368 } 369 370 371 void btrfs_add_dropped_root(struct btrfs_trans_handle *trans, 372 struct btrfs_root *root) 373 { 374 struct btrfs_transaction *cur_trans = trans->transaction; 375 376 /* Add ourselves to the transaction dropped list */ 377 spin_lock(&cur_trans->dropped_roots_lock); 378 list_add_tail(&root->root_list, &cur_trans->dropped_roots); 379 spin_unlock(&cur_trans->dropped_roots_lock); 380 381 /* Make sure we don't try to update the root at commit time */ 382 spin_lock(&root->fs_info->fs_roots_radix_lock); 383 radix_tree_tag_clear(&root->fs_info->fs_roots_radix, 384 (unsigned long)root->root_key.objectid, 385 BTRFS_ROOT_TRANS_TAG); 386 spin_unlock(&root->fs_info->fs_roots_radix_lock); 387 } 388 389 int btrfs_record_root_in_trans(struct btrfs_trans_handle *trans, 390 struct btrfs_root *root) 391 { 392 if (!test_bit(BTRFS_ROOT_REF_COWS, &root->state)) 393 return 0; 394 395 /* 396 * see record_root_in_trans for comments about IN_TRANS_SETUP usage 397 * and barriers 398 */ 399 smp_rmb(); 400 if (root->last_trans == trans->transid && 401 !test_bit(BTRFS_ROOT_IN_TRANS_SETUP, &root->state)) 402 return 0; 403 404 mutex_lock(&root->fs_info->reloc_mutex); 405 record_root_in_trans(trans, root); 406 mutex_unlock(&root->fs_info->reloc_mutex); 407 408 return 0; 409 } 410 411 static inline int is_transaction_blocked(struct btrfs_transaction *trans) 412 { 413 return (trans->state >= TRANS_STATE_BLOCKED && 414 trans->state < TRANS_STATE_UNBLOCKED && 415 !trans->aborted); 416 } 417 418 /* wait for commit against the current transaction to become unblocked 419 * when this is done, it is safe to start a new transaction, but the current 420 * transaction might not be fully on disk. 421 */ 422 static void wait_current_trans(struct btrfs_root *root) 423 { 424 struct btrfs_transaction *cur_trans; 425 426 spin_lock(&root->fs_info->trans_lock); 427 cur_trans = root->fs_info->running_transaction; 428 if (cur_trans && is_transaction_blocked(cur_trans)) { 429 atomic_inc(&cur_trans->use_count); 430 spin_unlock(&root->fs_info->trans_lock); 431 432 wait_event(root->fs_info->transaction_wait, 433 cur_trans->state >= TRANS_STATE_UNBLOCKED || 434 cur_trans->aborted); 435 btrfs_put_transaction(cur_trans); 436 } else { 437 spin_unlock(&root->fs_info->trans_lock); 438 } 439 } 440 441 static int may_wait_transaction(struct btrfs_root *root, int type) 442 { 443 if (root->fs_info->log_root_recovering) 444 return 0; 445 446 if (type == TRANS_USERSPACE) 447 return 1; 448 449 if (type == TRANS_START && 450 !atomic_read(&root->fs_info->open_ioctl_trans)) 451 return 1; 452 453 return 0; 454 } 455 456 static inline bool need_reserve_reloc_root(struct btrfs_root *root) 457 { 458 if (!root->fs_info->reloc_ctl || 459 !test_bit(BTRFS_ROOT_REF_COWS, &root->state) || 460 root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID || 461 root->reloc_root) 462 return false; 463 464 return true; 465 } 466 467 static struct btrfs_trans_handle * 468 start_transaction(struct btrfs_root *root, unsigned int num_items, 469 unsigned int type, enum btrfs_reserve_flush_enum flush) 470 { 471 struct btrfs_trans_handle *h; 472 struct btrfs_transaction *cur_trans; 473 u64 num_bytes = 0; 474 u64 qgroup_reserved = 0; 475 bool reloc_reserved = false; 476 int ret; 477 478 /* Send isn't supposed to start transactions. */ 479 ASSERT(current->journal_info != BTRFS_SEND_TRANS_STUB); 480 481 if (test_bit(BTRFS_FS_STATE_ERROR, &root->fs_info->fs_state)) 482 return ERR_PTR(-EROFS); 483 484 if (current->journal_info) { 485 WARN_ON(type & TRANS_EXTWRITERS); 486 h = current->journal_info; 487 h->use_count++; 488 WARN_ON(h->use_count > 2); 489 h->orig_rsv = h->block_rsv; 490 h->block_rsv = NULL; 491 goto got_it; 492 } 493 494 /* 495 * Do the reservation before we join the transaction so we can do all 496 * the appropriate flushing if need be. 497 */ 498 if (num_items > 0 && root != root->fs_info->chunk_root) { 499 qgroup_reserved = num_items * root->nodesize; 500 ret = btrfs_qgroup_reserve_meta(root, qgroup_reserved); 501 if (ret) 502 return ERR_PTR(ret); 503 504 num_bytes = btrfs_calc_trans_metadata_size(root, num_items); 505 /* 506 * Do the reservation for the relocation root creation 507 */ 508 if (need_reserve_reloc_root(root)) { 509 num_bytes += root->nodesize; 510 reloc_reserved = true; 511 } 512 513 ret = btrfs_block_rsv_add(root, 514 &root->fs_info->trans_block_rsv, 515 num_bytes, flush); 516 if (ret) 517 goto reserve_fail; 518 } 519 again: 520 h = kmem_cache_zalloc(btrfs_trans_handle_cachep, GFP_NOFS); 521 if (!h) { 522 ret = -ENOMEM; 523 goto alloc_fail; 524 } 525 526 /* 527 * If we are JOIN_NOLOCK we're already committing a transaction and 528 * waiting on this guy, so we don't need to do the sb_start_intwrite 529 * because we're already holding a ref. We need this because we could 530 * have raced in and did an fsync() on a file which can kick a commit 531 * and then we deadlock with somebody doing a freeze. 532 * 533 * If we are ATTACH, it means we just want to catch the current 534 * transaction and commit it, so we needn't do sb_start_intwrite(). 535 */ 536 if (type & __TRANS_FREEZABLE) 537 sb_start_intwrite(root->fs_info->sb); 538 539 if (may_wait_transaction(root, type)) 540 wait_current_trans(root); 541 542 do { 543 ret = join_transaction(root, type); 544 if (ret == -EBUSY) { 545 wait_current_trans(root); 546 if (unlikely(type == TRANS_ATTACH)) 547 ret = -ENOENT; 548 } 549 } while (ret == -EBUSY); 550 551 if (ret < 0) { 552 /* We must get the transaction if we are JOIN_NOLOCK. */ 553 BUG_ON(type == TRANS_JOIN_NOLOCK); 554 goto join_fail; 555 } 556 557 cur_trans = root->fs_info->running_transaction; 558 559 h->transid = cur_trans->transid; 560 h->transaction = cur_trans; 561 h->root = root; 562 h->use_count = 1; 563 564 h->type = type; 565 h->can_flush_pending_bgs = true; 566 INIT_LIST_HEAD(&h->qgroup_ref_list); 567 INIT_LIST_HEAD(&h->new_bgs); 568 569 smp_mb(); 570 if (cur_trans->state >= TRANS_STATE_BLOCKED && 571 may_wait_transaction(root, type)) { 572 current->journal_info = h; 573 btrfs_commit_transaction(h, root); 574 goto again; 575 } 576 577 if (num_bytes) { 578 trace_btrfs_space_reservation(root->fs_info, "transaction", 579 h->transid, num_bytes, 1); 580 h->block_rsv = &root->fs_info->trans_block_rsv; 581 h->bytes_reserved = num_bytes; 582 h->reloc_reserved = reloc_reserved; 583 } 584 585 got_it: 586 btrfs_record_root_in_trans(h, root); 587 588 if (!current->journal_info && type != TRANS_USERSPACE) 589 current->journal_info = h; 590 return h; 591 592 join_fail: 593 if (type & __TRANS_FREEZABLE) 594 sb_end_intwrite(root->fs_info->sb); 595 kmem_cache_free(btrfs_trans_handle_cachep, h); 596 alloc_fail: 597 if (num_bytes) 598 btrfs_block_rsv_release(root, &root->fs_info->trans_block_rsv, 599 num_bytes); 600 reserve_fail: 601 btrfs_qgroup_free_meta(root, qgroup_reserved); 602 return ERR_PTR(ret); 603 } 604 605 struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root, 606 unsigned int num_items) 607 { 608 return start_transaction(root, num_items, TRANS_START, 609 BTRFS_RESERVE_FLUSH_ALL); 610 } 611 struct btrfs_trans_handle *btrfs_start_transaction_fallback_global_rsv( 612 struct btrfs_root *root, 613 unsigned int num_items, 614 int min_factor) 615 { 616 struct btrfs_trans_handle *trans; 617 u64 num_bytes; 618 int ret; 619 620 trans = btrfs_start_transaction(root, num_items); 621 if (!IS_ERR(trans) || PTR_ERR(trans) != -ENOSPC) 622 return trans; 623 624 trans = btrfs_start_transaction(root, 0); 625 if (IS_ERR(trans)) 626 return trans; 627 628 num_bytes = btrfs_calc_trans_metadata_size(root, num_items); 629 ret = btrfs_cond_migrate_bytes(root->fs_info, 630 &root->fs_info->trans_block_rsv, 631 num_bytes, 632 min_factor); 633 if (ret) { 634 btrfs_end_transaction(trans, root); 635 return ERR_PTR(ret); 636 } 637 638 trans->block_rsv = &root->fs_info->trans_block_rsv; 639 trans->bytes_reserved = num_bytes; 640 641 return trans; 642 } 643 644 struct btrfs_trans_handle *btrfs_start_transaction_lflush( 645 struct btrfs_root *root, 646 unsigned int num_items) 647 { 648 return start_transaction(root, num_items, TRANS_START, 649 BTRFS_RESERVE_FLUSH_LIMIT); 650 } 651 652 struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root) 653 { 654 return start_transaction(root, 0, TRANS_JOIN, 655 BTRFS_RESERVE_NO_FLUSH); 656 } 657 658 struct btrfs_trans_handle *btrfs_join_transaction_nolock(struct btrfs_root *root) 659 { 660 return start_transaction(root, 0, TRANS_JOIN_NOLOCK, 661 BTRFS_RESERVE_NO_FLUSH); 662 } 663 664 struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *root) 665 { 666 return start_transaction(root, 0, TRANS_USERSPACE, 667 BTRFS_RESERVE_NO_FLUSH); 668 } 669 670 /* 671 * btrfs_attach_transaction() - catch the running transaction 672 * 673 * It is used when we want to commit the current the transaction, but 674 * don't want to start a new one. 675 * 676 * Note: If this function return -ENOENT, it just means there is no 677 * running transaction. But it is possible that the inactive transaction 678 * is still in the memory, not fully on disk. If you hope there is no 679 * inactive transaction in the fs when -ENOENT is returned, you should 680 * invoke 681 * btrfs_attach_transaction_barrier() 682 */ 683 struct btrfs_trans_handle *btrfs_attach_transaction(struct btrfs_root *root) 684 { 685 return start_transaction(root, 0, TRANS_ATTACH, 686 BTRFS_RESERVE_NO_FLUSH); 687 } 688 689 /* 690 * btrfs_attach_transaction_barrier() - catch the running transaction 691 * 692 * It is similar to the above function, the differentia is this one 693 * will wait for all the inactive transactions until they fully 694 * complete. 695 */ 696 struct btrfs_trans_handle * 697 btrfs_attach_transaction_barrier(struct btrfs_root *root) 698 { 699 struct btrfs_trans_handle *trans; 700 701 trans = start_transaction(root, 0, TRANS_ATTACH, 702 BTRFS_RESERVE_NO_FLUSH); 703 if (IS_ERR(trans) && PTR_ERR(trans) == -ENOENT) 704 btrfs_wait_for_commit(root, 0); 705 706 return trans; 707 } 708 709 /* wait for a transaction commit to be fully complete */ 710 static noinline void wait_for_commit(struct btrfs_root *root, 711 struct btrfs_transaction *commit) 712 { 713 wait_event(commit->commit_wait, commit->state == TRANS_STATE_COMPLETED); 714 } 715 716 int btrfs_wait_for_commit(struct btrfs_root *root, u64 transid) 717 { 718 struct btrfs_transaction *cur_trans = NULL, *t; 719 int ret = 0; 720 721 if (transid) { 722 if (transid <= root->fs_info->last_trans_committed) 723 goto out; 724 725 /* find specified transaction */ 726 spin_lock(&root->fs_info->trans_lock); 727 list_for_each_entry(t, &root->fs_info->trans_list, list) { 728 if (t->transid == transid) { 729 cur_trans = t; 730 atomic_inc(&cur_trans->use_count); 731 ret = 0; 732 break; 733 } 734 if (t->transid > transid) { 735 ret = 0; 736 break; 737 } 738 } 739 spin_unlock(&root->fs_info->trans_lock); 740 741 /* 742 * The specified transaction doesn't exist, or we 743 * raced with btrfs_commit_transaction 744 */ 745 if (!cur_trans) { 746 if (transid > root->fs_info->last_trans_committed) 747 ret = -EINVAL; 748 goto out; 749 } 750 } else { 751 /* find newest transaction that is committing | committed */ 752 spin_lock(&root->fs_info->trans_lock); 753 list_for_each_entry_reverse(t, &root->fs_info->trans_list, 754 list) { 755 if (t->state >= TRANS_STATE_COMMIT_START) { 756 if (t->state == TRANS_STATE_COMPLETED) 757 break; 758 cur_trans = t; 759 atomic_inc(&cur_trans->use_count); 760 break; 761 } 762 } 763 spin_unlock(&root->fs_info->trans_lock); 764 if (!cur_trans) 765 goto out; /* nothing committing|committed */ 766 } 767 768 wait_for_commit(root, cur_trans); 769 btrfs_put_transaction(cur_trans); 770 out: 771 return ret; 772 } 773 774 void btrfs_throttle(struct btrfs_root *root) 775 { 776 if (!atomic_read(&root->fs_info->open_ioctl_trans)) 777 wait_current_trans(root); 778 } 779 780 static int should_end_transaction(struct btrfs_trans_handle *trans, 781 struct btrfs_root *root) 782 { 783 if (root->fs_info->global_block_rsv.space_info->full && 784 btrfs_check_space_for_delayed_refs(trans, root)) 785 return 1; 786 787 return !!btrfs_block_rsv_check(root, &root->fs_info->global_block_rsv, 5); 788 } 789 790 int btrfs_should_end_transaction(struct btrfs_trans_handle *trans, 791 struct btrfs_root *root) 792 { 793 struct btrfs_transaction *cur_trans = trans->transaction; 794 int updates; 795 int err; 796 797 smp_mb(); 798 if (cur_trans->state >= TRANS_STATE_BLOCKED || 799 cur_trans->delayed_refs.flushing) 800 return 1; 801 802 updates = trans->delayed_ref_updates; 803 trans->delayed_ref_updates = 0; 804 if (updates) { 805 err = btrfs_run_delayed_refs(trans, root, updates * 2); 806 if (err) /* Error code will also eval true */ 807 return err; 808 } 809 810 return should_end_transaction(trans, root); 811 } 812 813 static int __btrfs_end_transaction(struct btrfs_trans_handle *trans, 814 struct btrfs_root *root, int throttle) 815 { 816 struct btrfs_transaction *cur_trans = trans->transaction; 817 struct btrfs_fs_info *info = root->fs_info; 818 unsigned long cur = trans->delayed_ref_updates; 819 int lock = (trans->type != TRANS_JOIN_NOLOCK); 820 int err = 0; 821 int must_run_delayed_refs = 0; 822 823 if (trans->use_count > 1) { 824 trans->use_count--; 825 trans->block_rsv = trans->orig_rsv; 826 return 0; 827 } 828 829 btrfs_trans_release_metadata(trans, root); 830 trans->block_rsv = NULL; 831 832 if (!list_empty(&trans->new_bgs)) 833 btrfs_create_pending_block_groups(trans, root); 834 835 trans->delayed_ref_updates = 0; 836 if (!trans->sync) { 837 must_run_delayed_refs = 838 btrfs_should_throttle_delayed_refs(trans, root); 839 cur = max_t(unsigned long, cur, 32); 840 841 /* 842 * don't make the caller wait if they are from a NOLOCK 843 * or ATTACH transaction, it will deadlock with commit 844 */ 845 if (must_run_delayed_refs == 1 && 846 (trans->type & (__TRANS_JOIN_NOLOCK | __TRANS_ATTACH))) 847 must_run_delayed_refs = 2; 848 } 849 850 btrfs_trans_release_metadata(trans, root); 851 trans->block_rsv = NULL; 852 853 if (!list_empty(&trans->new_bgs)) 854 btrfs_create_pending_block_groups(trans, root); 855 856 btrfs_trans_release_chunk_metadata(trans); 857 858 if (lock && !atomic_read(&root->fs_info->open_ioctl_trans) && 859 should_end_transaction(trans, root) && 860 ACCESS_ONCE(cur_trans->state) == TRANS_STATE_RUNNING) { 861 spin_lock(&info->trans_lock); 862 if (cur_trans->state == TRANS_STATE_RUNNING) 863 cur_trans->state = TRANS_STATE_BLOCKED; 864 spin_unlock(&info->trans_lock); 865 } 866 867 if (lock && ACCESS_ONCE(cur_trans->state) == TRANS_STATE_BLOCKED) { 868 if (throttle) 869 return btrfs_commit_transaction(trans, root); 870 else 871 wake_up_process(info->transaction_kthread); 872 } 873 874 if (trans->type & __TRANS_FREEZABLE) 875 sb_end_intwrite(root->fs_info->sb); 876 877 WARN_ON(cur_trans != info->running_transaction); 878 WARN_ON(atomic_read(&cur_trans->num_writers) < 1); 879 atomic_dec(&cur_trans->num_writers); 880 extwriter_counter_dec(cur_trans, trans->type); 881 882 /* 883 * Make sure counter is updated before we wake up waiters. 884 */ 885 smp_mb(); 886 if (waitqueue_active(&cur_trans->writer_wait)) 887 wake_up(&cur_trans->writer_wait); 888 btrfs_put_transaction(cur_trans); 889 890 if (current->journal_info == trans) 891 current->journal_info = NULL; 892 893 if (throttle) 894 btrfs_run_delayed_iputs(root); 895 896 if (trans->aborted || 897 test_bit(BTRFS_FS_STATE_ERROR, &root->fs_info->fs_state)) { 898 wake_up_process(info->transaction_kthread); 899 err = -EIO; 900 } 901 assert_qgroups_uptodate(trans); 902 903 kmem_cache_free(btrfs_trans_handle_cachep, trans); 904 if (must_run_delayed_refs) { 905 btrfs_async_run_delayed_refs(root, cur, 906 must_run_delayed_refs == 1); 907 } 908 return err; 909 } 910 911 int btrfs_end_transaction(struct btrfs_trans_handle *trans, 912 struct btrfs_root *root) 913 { 914 return __btrfs_end_transaction(trans, root, 0); 915 } 916 917 int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans, 918 struct btrfs_root *root) 919 { 920 return __btrfs_end_transaction(trans, root, 1); 921 } 922 923 /* 924 * when btree blocks are allocated, they have some corresponding bits set for 925 * them in one of two extent_io trees. This is used to make sure all of 926 * those extents are sent to disk but does not wait on them 927 */ 928 int btrfs_write_marked_extents(struct btrfs_root *root, 929 struct extent_io_tree *dirty_pages, int mark) 930 { 931 int err = 0; 932 int werr = 0; 933 struct address_space *mapping = root->fs_info->btree_inode->i_mapping; 934 struct extent_state *cached_state = NULL; 935 u64 start = 0; 936 u64 end; 937 938 while (!find_first_extent_bit(dirty_pages, start, &start, &end, 939 mark, &cached_state)) { 940 bool wait_writeback = false; 941 942 err = convert_extent_bit(dirty_pages, start, end, 943 EXTENT_NEED_WAIT, 944 mark, &cached_state, GFP_NOFS); 945 /* 946 * convert_extent_bit can return -ENOMEM, which is most of the 947 * time a temporary error. So when it happens, ignore the error 948 * and wait for writeback of this range to finish - because we 949 * failed to set the bit EXTENT_NEED_WAIT for the range, a call 950 * to btrfs_wait_marked_extents() would not know that writeback 951 * for this range started and therefore wouldn't wait for it to 952 * finish - we don't want to commit a superblock that points to 953 * btree nodes/leafs for which writeback hasn't finished yet 954 * (and without errors). 955 * We cleanup any entries left in the io tree when committing 956 * the transaction (through clear_btree_io_tree()). 957 */ 958 if (err == -ENOMEM) { 959 err = 0; 960 wait_writeback = true; 961 } 962 if (!err) 963 err = filemap_fdatawrite_range(mapping, start, end); 964 if (err) 965 werr = err; 966 else if (wait_writeback) 967 werr = filemap_fdatawait_range(mapping, start, end); 968 free_extent_state(cached_state); 969 cached_state = NULL; 970 cond_resched(); 971 start = end + 1; 972 } 973 return werr; 974 } 975 976 /* 977 * when btree blocks are allocated, they have some corresponding bits set for 978 * them in one of two extent_io trees. This is used to make sure all of 979 * those extents are on disk for transaction or log commit. We wait 980 * on all the pages and clear them from the dirty pages state tree 981 */ 982 int btrfs_wait_marked_extents(struct btrfs_root *root, 983 struct extent_io_tree *dirty_pages, int mark) 984 { 985 int err = 0; 986 int werr = 0; 987 struct address_space *mapping = root->fs_info->btree_inode->i_mapping; 988 struct extent_state *cached_state = NULL; 989 u64 start = 0; 990 u64 end; 991 struct btrfs_inode *btree_ino = BTRFS_I(root->fs_info->btree_inode); 992 bool errors = false; 993 994 while (!find_first_extent_bit(dirty_pages, start, &start, &end, 995 EXTENT_NEED_WAIT, &cached_state)) { 996 /* 997 * Ignore -ENOMEM errors returned by clear_extent_bit(). 998 * When committing the transaction, we'll remove any entries 999 * left in the io tree. For a log commit, we don't remove them 1000 * after committing the log because the tree can be accessed 1001 * concurrently - we do it only at transaction commit time when 1002 * it's safe to do it (through clear_btree_io_tree()). 1003 */ 1004 err = clear_extent_bit(dirty_pages, start, end, 1005 EXTENT_NEED_WAIT, 1006 0, 0, &cached_state, GFP_NOFS); 1007 if (err == -ENOMEM) 1008 err = 0; 1009 if (!err) 1010 err = filemap_fdatawait_range(mapping, start, end); 1011 if (err) 1012 werr = err; 1013 free_extent_state(cached_state); 1014 cached_state = NULL; 1015 cond_resched(); 1016 start = end + 1; 1017 } 1018 if (err) 1019 werr = err; 1020 1021 if (root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID) { 1022 if ((mark & EXTENT_DIRTY) && 1023 test_and_clear_bit(BTRFS_INODE_BTREE_LOG1_ERR, 1024 &btree_ino->runtime_flags)) 1025 errors = true; 1026 1027 if ((mark & EXTENT_NEW) && 1028 test_and_clear_bit(BTRFS_INODE_BTREE_LOG2_ERR, 1029 &btree_ino->runtime_flags)) 1030 errors = true; 1031 } else { 1032 if (test_and_clear_bit(BTRFS_INODE_BTREE_ERR, 1033 &btree_ino->runtime_flags)) 1034 errors = true; 1035 } 1036 1037 if (errors && !werr) 1038 werr = -EIO; 1039 1040 return werr; 1041 } 1042 1043 /* 1044 * when btree blocks are allocated, they have some corresponding bits set for 1045 * them in one of two extent_io trees. This is used to make sure all of 1046 * those extents are on disk for transaction or log commit 1047 */ 1048 static int btrfs_write_and_wait_marked_extents(struct btrfs_root *root, 1049 struct extent_io_tree *dirty_pages, int mark) 1050 { 1051 int ret; 1052 int ret2; 1053 struct blk_plug plug; 1054 1055 blk_start_plug(&plug); 1056 ret = btrfs_write_marked_extents(root, dirty_pages, mark); 1057 blk_finish_plug(&plug); 1058 ret2 = btrfs_wait_marked_extents(root, dirty_pages, mark); 1059 1060 if (ret) 1061 return ret; 1062 if (ret2) 1063 return ret2; 1064 return 0; 1065 } 1066 1067 static int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans, 1068 struct btrfs_root *root) 1069 { 1070 int ret; 1071 1072 ret = btrfs_write_and_wait_marked_extents(root, 1073 &trans->transaction->dirty_pages, 1074 EXTENT_DIRTY); 1075 clear_btree_io_tree(&trans->transaction->dirty_pages); 1076 1077 return ret; 1078 } 1079 1080 /* 1081 * this is used to update the root pointer in the tree of tree roots. 1082 * 1083 * But, in the case of the extent allocation tree, updating the root 1084 * pointer may allocate blocks which may change the root of the extent 1085 * allocation tree. 1086 * 1087 * So, this loops and repeats and makes sure the cowonly root didn't 1088 * change while the root pointer was being updated in the metadata. 1089 */ 1090 static int update_cowonly_root(struct btrfs_trans_handle *trans, 1091 struct btrfs_root *root) 1092 { 1093 int ret; 1094 u64 old_root_bytenr; 1095 u64 old_root_used; 1096 struct btrfs_root *tree_root = root->fs_info->tree_root; 1097 1098 old_root_used = btrfs_root_used(&root->root_item); 1099 1100 while (1) { 1101 old_root_bytenr = btrfs_root_bytenr(&root->root_item); 1102 if (old_root_bytenr == root->node->start && 1103 old_root_used == btrfs_root_used(&root->root_item)) 1104 break; 1105 1106 btrfs_set_root_node(&root->root_item, root->node); 1107 ret = btrfs_update_root(trans, tree_root, 1108 &root->root_key, 1109 &root->root_item); 1110 if (ret) 1111 return ret; 1112 1113 old_root_used = btrfs_root_used(&root->root_item); 1114 } 1115 1116 return 0; 1117 } 1118 1119 /* 1120 * update all the cowonly tree roots on disk 1121 * 1122 * The error handling in this function may not be obvious. Any of the 1123 * failures will cause the file system to go offline. We still need 1124 * to clean up the delayed refs. 1125 */ 1126 static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans, 1127 struct btrfs_root *root) 1128 { 1129 struct btrfs_fs_info *fs_info = root->fs_info; 1130 struct list_head *dirty_bgs = &trans->transaction->dirty_bgs; 1131 struct list_head *io_bgs = &trans->transaction->io_bgs; 1132 struct list_head *next; 1133 struct extent_buffer *eb; 1134 int ret; 1135 1136 eb = btrfs_lock_root_node(fs_info->tree_root); 1137 ret = btrfs_cow_block(trans, fs_info->tree_root, eb, NULL, 1138 0, &eb); 1139 btrfs_tree_unlock(eb); 1140 free_extent_buffer(eb); 1141 1142 if (ret) 1143 return ret; 1144 1145 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); 1146 if (ret) 1147 return ret; 1148 1149 ret = btrfs_run_dev_stats(trans, root->fs_info); 1150 if (ret) 1151 return ret; 1152 ret = btrfs_run_dev_replace(trans, root->fs_info); 1153 if (ret) 1154 return ret; 1155 ret = btrfs_run_qgroups(trans, root->fs_info); 1156 if (ret) 1157 return ret; 1158 1159 ret = btrfs_setup_space_cache(trans, root); 1160 if (ret) 1161 return ret; 1162 1163 /* run_qgroups might have added some more refs */ 1164 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); 1165 if (ret) 1166 return ret; 1167 again: 1168 while (!list_empty(&fs_info->dirty_cowonly_roots)) { 1169 next = fs_info->dirty_cowonly_roots.next; 1170 list_del_init(next); 1171 root = list_entry(next, struct btrfs_root, dirty_list); 1172 clear_bit(BTRFS_ROOT_DIRTY, &root->state); 1173 1174 if (root != fs_info->extent_root) 1175 list_add_tail(&root->dirty_list, 1176 &trans->transaction->switch_commits); 1177 ret = update_cowonly_root(trans, root); 1178 if (ret) 1179 return ret; 1180 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); 1181 if (ret) 1182 return ret; 1183 } 1184 1185 while (!list_empty(dirty_bgs) || !list_empty(io_bgs)) { 1186 ret = btrfs_write_dirty_block_groups(trans, root); 1187 if (ret) 1188 return ret; 1189 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); 1190 if (ret) 1191 return ret; 1192 } 1193 1194 if (!list_empty(&fs_info->dirty_cowonly_roots)) 1195 goto again; 1196 1197 list_add_tail(&fs_info->extent_root->dirty_list, 1198 &trans->transaction->switch_commits); 1199 btrfs_after_dev_replace_commit(fs_info); 1200 1201 return 0; 1202 } 1203 1204 /* 1205 * dead roots are old snapshots that need to be deleted. This allocates 1206 * a dirty root struct and adds it into the list of dead roots that need to 1207 * be deleted 1208 */ 1209 void btrfs_add_dead_root(struct btrfs_root *root) 1210 { 1211 spin_lock(&root->fs_info->trans_lock); 1212 if (list_empty(&root->root_list)) 1213 list_add_tail(&root->root_list, &root->fs_info->dead_roots); 1214 spin_unlock(&root->fs_info->trans_lock); 1215 } 1216 1217 /* 1218 * update all the cowonly tree roots on disk 1219 */ 1220 static noinline int commit_fs_roots(struct btrfs_trans_handle *trans, 1221 struct btrfs_root *root) 1222 { 1223 struct btrfs_root *gang[8]; 1224 struct btrfs_fs_info *fs_info = root->fs_info; 1225 int i; 1226 int ret; 1227 int err = 0; 1228 1229 spin_lock(&fs_info->fs_roots_radix_lock); 1230 while (1) { 1231 ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix, 1232 (void **)gang, 0, 1233 ARRAY_SIZE(gang), 1234 BTRFS_ROOT_TRANS_TAG); 1235 if (ret == 0) 1236 break; 1237 for (i = 0; i < ret; i++) { 1238 root = gang[i]; 1239 radix_tree_tag_clear(&fs_info->fs_roots_radix, 1240 (unsigned long)root->root_key.objectid, 1241 BTRFS_ROOT_TRANS_TAG); 1242 spin_unlock(&fs_info->fs_roots_radix_lock); 1243 1244 btrfs_free_log(trans, root); 1245 btrfs_update_reloc_root(trans, root); 1246 btrfs_orphan_commit_root(trans, root); 1247 1248 btrfs_save_ino_cache(root, trans); 1249 1250 /* see comments in should_cow_block() */ 1251 clear_bit(BTRFS_ROOT_FORCE_COW, &root->state); 1252 smp_mb__after_atomic(); 1253 1254 if (root->commit_root != root->node) { 1255 list_add_tail(&root->dirty_list, 1256 &trans->transaction->switch_commits); 1257 btrfs_set_root_node(&root->root_item, 1258 root->node); 1259 } 1260 1261 err = btrfs_update_root(trans, fs_info->tree_root, 1262 &root->root_key, 1263 &root->root_item); 1264 spin_lock(&fs_info->fs_roots_radix_lock); 1265 if (err) 1266 break; 1267 btrfs_qgroup_free_meta_all(root); 1268 } 1269 } 1270 spin_unlock(&fs_info->fs_roots_radix_lock); 1271 return err; 1272 } 1273 1274 /* 1275 * defrag a given btree. 1276 * Every leaf in the btree is read and defragged. 1277 */ 1278 int btrfs_defrag_root(struct btrfs_root *root) 1279 { 1280 struct btrfs_fs_info *info = root->fs_info; 1281 struct btrfs_trans_handle *trans; 1282 int ret; 1283 1284 if (test_and_set_bit(BTRFS_ROOT_DEFRAG_RUNNING, &root->state)) 1285 return 0; 1286 1287 while (1) { 1288 trans = btrfs_start_transaction(root, 0); 1289 if (IS_ERR(trans)) 1290 return PTR_ERR(trans); 1291 1292 ret = btrfs_defrag_leaves(trans, root); 1293 1294 btrfs_end_transaction(trans, root); 1295 btrfs_btree_balance_dirty(info->tree_root); 1296 cond_resched(); 1297 1298 if (btrfs_fs_closing(root->fs_info) || ret != -EAGAIN) 1299 break; 1300 1301 if (btrfs_defrag_cancelled(root->fs_info)) { 1302 pr_debug("BTRFS: defrag_root cancelled\n"); 1303 ret = -EAGAIN; 1304 break; 1305 } 1306 } 1307 clear_bit(BTRFS_ROOT_DEFRAG_RUNNING, &root->state); 1308 return ret; 1309 } 1310 1311 /* 1312 * new snapshots need to be created at a very specific time in the 1313 * transaction commit. This does the actual creation. 1314 * 1315 * Note: 1316 * If the error which may affect the commitment of the current transaction 1317 * happens, we should return the error number. If the error which just affect 1318 * the creation of the pending snapshots, just return 0. 1319 */ 1320 static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans, 1321 struct btrfs_fs_info *fs_info, 1322 struct btrfs_pending_snapshot *pending) 1323 { 1324 struct btrfs_key key; 1325 struct btrfs_root_item *new_root_item; 1326 struct btrfs_root *tree_root = fs_info->tree_root; 1327 struct btrfs_root *root = pending->root; 1328 struct btrfs_root *parent_root; 1329 struct btrfs_block_rsv *rsv; 1330 struct inode *parent_inode; 1331 struct btrfs_path *path; 1332 struct btrfs_dir_item *dir_item; 1333 struct dentry *dentry; 1334 struct extent_buffer *tmp; 1335 struct extent_buffer *old; 1336 struct timespec cur_time = CURRENT_TIME; 1337 int ret = 0; 1338 u64 to_reserve = 0; 1339 u64 index = 0; 1340 u64 objectid; 1341 u64 root_flags; 1342 uuid_le new_uuid; 1343 1344 ASSERT(pending->path); 1345 path = pending->path; 1346 1347 ASSERT(pending->root_item); 1348 new_root_item = pending->root_item; 1349 1350 pending->error = btrfs_find_free_objectid(tree_root, &objectid); 1351 if (pending->error) 1352 goto no_free_objectid; 1353 1354 /* 1355 * Make qgroup to skip current new snapshot's qgroupid, as it is 1356 * accounted by later btrfs_qgroup_inherit(). 1357 */ 1358 btrfs_set_skip_qgroup(trans, objectid); 1359 1360 btrfs_reloc_pre_snapshot(pending, &to_reserve); 1361 1362 if (to_reserve > 0) { 1363 pending->error = btrfs_block_rsv_add(root, 1364 &pending->block_rsv, 1365 to_reserve, 1366 BTRFS_RESERVE_NO_FLUSH); 1367 if (pending->error) 1368 goto clear_skip_qgroup; 1369 } 1370 1371 key.objectid = objectid; 1372 key.offset = (u64)-1; 1373 key.type = BTRFS_ROOT_ITEM_KEY; 1374 1375 rsv = trans->block_rsv; 1376 trans->block_rsv = &pending->block_rsv; 1377 trans->bytes_reserved = trans->block_rsv->reserved; 1378 1379 dentry = pending->dentry; 1380 parent_inode = pending->dir; 1381 parent_root = BTRFS_I(parent_inode)->root; 1382 record_root_in_trans(trans, parent_root); 1383 1384 /* 1385 * insert the directory item 1386 */ 1387 ret = btrfs_set_inode_index(parent_inode, &index); 1388 BUG_ON(ret); /* -ENOMEM */ 1389 1390 /* check if there is a file/dir which has the same name. */ 1391 dir_item = btrfs_lookup_dir_item(NULL, parent_root, path, 1392 btrfs_ino(parent_inode), 1393 dentry->d_name.name, 1394 dentry->d_name.len, 0); 1395 if (dir_item != NULL && !IS_ERR(dir_item)) { 1396 pending->error = -EEXIST; 1397 goto dir_item_existed; 1398 } else if (IS_ERR(dir_item)) { 1399 ret = PTR_ERR(dir_item); 1400 btrfs_abort_transaction(trans, root, ret); 1401 goto fail; 1402 } 1403 btrfs_release_path(path); 1404 1405 /* 1406 * pull in the delayed directory update 1407 * and the delayed inode item 1408 * otherwise we corrupt the FS during 1409 * snapshot 1410 */ 1411 ret = btrfs_run_delayed_items(trans, root); 1412 if (ret) { /* Transaction aborted */ 1413 btrfs_abort_transaction(trans, root, ret); 1414 goto fail; 1415 } 1416 1417 record_root_in_trans(trans, root); 1418 btrfs_set_root_last_snapshot(&root->root_item, trans->transid); 1419 memcpy(new_root_item, &root->root_item, sizeof(*new_root_item)); 1420 btrfs_check_and_init_root_item(new_root_item); 1421 1422 root_flags = btrfs_root_flags(new_root_item); 1423 if (pending->readonly) 1424 root_flags |= BTRFS_ROOT_SUBVOL_RDONLY; 1425 else 1426 root_flags &= ~BTRFS_ROOT_SUBVOL_RDONLY; 1427 btrfs_set_root_flags(new_root_item, root_flags); 1428 1429 btrfs_set_root_generation_v2(new_root_item, 1430 trans->transid); 1431 uuid_le_gen(&new_uuid); 1432 memcpy(new_root_item->uuid, new_uuid.b, BTRFS_UUID_SIZE); 1433 memcpy(new_root_item->parent_uuid, root->root_item.uuid, 1434 BTRFS_UUID_SIZE); 1435 if (!(root_flags & BTRFS_ROOT_SUBVOL_RDONLY)) { 1436 memset(new_root_item->received_uuid, 0, 1437 sizeof(new_root_item->received_uuid)); 1438 memset(&new_root_item->stime, 0, sizeof(new_root_item->stime)); 1439 memset(&new_root_item->rtime, 0, sizeof(new_root_item->rtime)); 1440 btrfs_set_root_stransid(new_root_item, 0); 1441 btrfs_set_root_rtransid(new_root_item, 0); 1442 } 1443 btrfs_set_stack_timespec_sec(&new_root_item->otime, cur_time.tv_sec); 1444 btrfs_set_stack_timespec_nsec(&new_root_item->otime, cur_time.tv_nsec); 1445 btrfs_set_root_otransid(new_root_item, trans->transid); 1446 1447 old = btrfs_lock_root_node(root); 1448 ret = btrfs_cow_block(trans, root, old, NULL, 0, &old); 1449 if (ret) { 1450 btrfs_tree_unlock(old); 1451 free_extent_buffer(old); 1452 btrfs_abort_transaction(trans, root, ret); 1453 goto fail; 1454 } 1455 1456 btrfs_set_lock_blocking(old); 1457 1458 ret = btrfs_copy_root(trans, root, old, &tmp, objectid); 1459 /* clean up in any case */ 1460 btrfs_tree_unlock(old); 1461 free_extent_buffer(old); 1462 if (ret) { 1463 btrfs_abort_transaction(trans, root, ret); 1464 goto fail; 1465 } 1466 /* see comments in should_cow_block() */ 1467 set_bit(BTRFS_ROOT_FORCE_COW, &root->state); 1468 smp_wmb(); 1469 1470 btrfs_set_root_node(new_root_item, tmp); 1471 /* record when the snapshot was created in key.offset */ 1472 key.offset = trans->transid; 1473 ret = btrfs_insert_root(trans, tree_root, &key, new_root_item); 1474 btrfs_tree_unlock(tmp); 1475 free_extent_buffer(tmp); 1476 if (ret) { 1477 btrfs_abort_transaction(trans, root, ret); 1478 goto fail; 1479 } 1480 1481 /* 1482 * insert root back/forward references 1483 */ 1484 ret = btrfs_add_root_ref(trans, tree_root, objectid, 1485 parent_root->root_key.objectid, 1486 btrfs_ino(parent_inode), index, 1487 dentry->d_name.name, dentry->d_name.len); 1488 if (ret) { 1489 btrfs_abort_transaction(trans, root, ret); 1490 goto fail; 1491 } 1492 1493 key.offset = (u64)-1; 1494 pending->snap = btrfs_read_fs_root_no_name(root->fs_info, &key); 1495 if (IS_ERR(pending->snap)) { 1496 ret = PTR_ERR(pending->snap); 1497 btrfs_abort_transaction(trans, root, ret); 1498 goto fail; 1499 } 1500 1501 ret = btrfs_reloc_post_snapshot(trans, pending); 1502 if (ret) { 1503 btrfs_abort_transaction(trans, root, ret); 1504 goto fail; 1505 } 1506 1507 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); 1508 if (ret) { 1509 btrfs_abort_transaction(trans, root, ret); 1510 goto fail; 1511 } 1512 1513 ret = btrfs_insert_dir_item(trans, parent_root, 1514 dentry->d_name.name, dentry->d_name.len, 1515 parent_inode, &key, 1516 BTRFS_FT_DIR, index); 1517 /* We have check then name at the beginning, so it is impossible. */ 1518 BUG_ON(ret == -EEXIST || ret == -EOVERFLOW); 1519 if (ret) { 1520 btrfs_abort_transaction(trans, root, ret); 1521 goto fail; 1522 } 1523 1524 btrfs_i_size_write(parent_inode, parent_inode->i_size + 1525 dentry->d_name.len * 2); 1526 parent_inode->i_mtime = parent_inode->i_ctime = CURRENT_TIME; 1527 ret = btrfs_update_inode_fallback(trans, parent_root, parent_inode); 1528 if (ret) { 1529 btrfs_abort_transaction(trans, root, ret); 1530 goto fail; 1531 } 1532 ret = btrfs_uuid_tree_add(trans, fs_info->uuid_root, new_uuid.b, 1533 BTRFS_UUID_KEY_SUBVOL, objectid); 1534 if (ret) { 1535 btrfs_abort_transaction(trans, root, ret); 1536 goto fail; 1537 } 1538 if (!btrfs_is_empty_uuid(new_root_item->received_uuid)) { 1539 ret = btrfs_uuid_tree_add(trans, fs_info->uuid_root, 1540 new_root_item->received_uuid, 1541 BTRFS_UUID_KEY_RECEIVED_SUBVOL, 1542 objectid); 1543 if (ret && ret != -EEXIST) { 1544 btrfs_abort_transaction(trans, root, ret); 1545 goto fail; 1546 } 1547 } 1548 1549 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); 1550 if (ret) { 1551 btrfs_abort_transaction(trans, root, ret); 1552 goto fail; 1553 } 1554 1555 /* 1556 * account qgroup counters before qgroup_inherit() 1557 */ 1558 ret = btrfs_qgroup_prepare_account_extents(trans, fs_info); 1559 if (ret) 1560 goto fail; 1561 ret = btrfs_qgroup_account_extents(trans, fs_info); 1562 if (ret) 1563 goto fail; 1564 ret = btrfs_qgroup_inherit(trans, fs_info, 1565 root->root_key.objectid, 1566 objectid, pending->inherit); 1567 if (ret) { 1568 btrfs_abort_transaction(trans, root, ret); 1569 goto fail; 1570 } 1571 1572 fail: 1573 pending->error = ret; 1574 dir_item_existed: 1575 trans->block_rsv = rsv; 1576 trans->bytes_reserved = 0; 1577 clear_skip_qgroup: 1578 btrfs_clear_skip_qgroup(trans); 1579 no_free_objectid: 1580 kfree(new_root_item); 1581 pending->root_item = NULL; 1582 btrfs_free_path(path); 1583 pending->path = NULL; 1584 1585 return ret; 1586 } 1587 1588 /* 1589 * create all the snapshots we've scheduled for creation 1590 */ 1591 static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans, 1592 struct btrfs_fs_info *fs_info) 1593 { 1594 struct btrfs_pending_snapshot *pending, *next; 1595 struct list_head *head = &trans->transaction->pending_snapshots; 1596 int ret = 0; 1597 1598 list_for_each_entry_safe(pending, next, head, list) { 1599 list_del(&pending->list); 1600 ret = create_pending_snapshot(trans, fs_info, pending); 1601 if (ret) 1602 break; 1603 } 1604 return ret; 1605 } 1606 1607 static void update_super_roots(struct btrfs_root *root) 1608 { 1609 struct btrfs_root_item *root_item; 1610 struct btrfs_super_block *super; 1611 1612 super = root->fs_info->super_copy; 1613 1614 root_item = &root->fs_info->chunk_root->root_item; 1615 super->chunk_root = root_item->bytenr; 1616 super->chunk_root_generation = root_item->generation; 1617 super->chunk_root_level = root_item->level; 1618 1619 root_item = &root->fs_info->tree_root->root_item; 1620 super->root = root_item->bytenr; 1621 super->generation = root_item->generation; 1622 super->root_level = root_item->level; 1623 if (btrfs_test_opt(root, SPACE_CACHE)) 1624 super->cache_generation = root_item->generation; 1625 if (root->fs_info->update_uuid_tree_gen) 1626 super->uuid_tree_generation = root_item->generation; 1627 } 1628 1629 int btrfs_transaction_in_commit(struct btrfs_fs_info *info) 1630 { 1631 struct btrfs_transaction *trans; 1632 int ret = 0; 1633 1634 spin_lock(&info->trans_lock); 1635 trans = info->running_transaction; 1636 if (trans) 1637 ret = (trans->state >= TRANS_STATE_COMMIT_START); 1638 spin_unlock(&info->trans_lock); 1639 return ret; 1640 } 1641 1642 int btrfs_transaction_blocked(struct btrfs_fs_info *info) 1643 { 1644 struct btrfs_transaction *trans; 1645 int ret = 0; 1646 1647 spin_lock(&info->trans_lock); 1648 trans = info->running_transaction; 1649 if (trans) 1650 ret = is_transaction_blocked(trans); 1651 spin_unlock(&info->trans_lock); 1652 return ret; 1653 } 1654 1655 /* 1656 * wait for the current transaction commit to start and block subsequent 1657 * transaction joins 1658 */ 1659 static void wait_current_trans_commit_start(struct btrfs_root *root, 1660 struct btrfs_transaction *trans) 1661 { 1662 wait_event(root->fs_info->transaction_blocked_wait, 1663 trans->state >= TRANS_STATE_COMMIT_START || 1664 trans->aborted); 1665 } 1666 1667 /* 1668 * wait for the current transaction to start and then become unblocked. 1669 * caller holds ref. 1670 */ 1671 static void wait_current_trans_commit_start_and_unblock(struct btrfs_root *root, 1672 struct btrfs_transaction *trans) 1673 { 1674 wait_event(root->fs_info->transaction_wait, 1675 trans->state >= TRANS_STATE_UNBLOCKED || 1676 trans->aborted); 1677 } 1678 1679 /* 1680 * commit transactions asynchronously. once btrfs_commit_transaction_async 1681 * returns, any subsequent transaction will not be allowed to join. 1682 */ 1683 struct btrfs_async_commit { 1684 struct btrfs_trans_handle *newtrans; 1685 struct btrfs_root *root; 1686 struct work_struct work; 1687 }; 1688 1689 static void do_async_commit(struct work_struct *work) 1690 { 1691 struct btrfs_async_commit *ac = 1692 container_of(work, struct btrfs_async_commit, work); 1693 1694 /* 1695 * We've got freeze protection passed with the transaction. 1696 * Tell lockdep about it. 1697 */ 1698 if (ac->newtrans->type & __TRANS_FREEZABLE) 1699 __sb_writers_acquired(ac->root->fs_info->sb, SB_FREEZE_FS); 1700 1701 current->journal_info = ac->newtrans; 1702 1703 btrfs_commit_transaction(ac->newtrans, ac->root); 1704 kfree(ac); 1705 } 1706 1707 int btrfs_commit_transaction_async(struct btrfs_trans_handle *trans, 1708 struct btrfs_root *root, 1709 int wait_for_unblock) 1710 { 1711 struct btrfs_async_commit *ac; 1712 struct btrfs_transaction *cur_trans; 1713 1714 ac = kmalloc(sizeof(*ac), GFP_NOFS); 1715 if (!ac) 1716 return -ENOMEM; 1717 1718 INIT_WORK(&ac->work, do_async_commit); 1719 ac->root = root; 1720 ac->newtrans = btrfs_join_transaction(root); 1721 if (IS_ERR(ac->newtrans)) { 1722 int err = PTR_ERR(ac->newtrans); 1723 kfree(ac); 1724 return err; 1725 } 1726 1727 /* take transaction reference */ 1728 cur_trans = trans->transaction; 1729 atomic_inc(&cur_trans->use_count); 1730 1731 btrfs_end_transaction(trans, root); 1732 1733 /* 1734 * Tell lockdep we've released the freeze rwsem, since the 1735 * async commit thread will be the one to unlock it. 1736 */ 1737 if (ac->newtrans->type & __TRANS_FREEZABLE) 1738 __sb_writers_release(root->fs_info->sb, SB_FREEZE_FS); 1739 1740 schedule_work(&ac->work); 1741 1742 /* wait for transaction to start and unblock */ 1743 if (wait_for_unblock) 1744 wait_current_trans_commit_start_and_unblock(root, cur_trans); 1745 else 1746 wait_current_trans_commit_start(root, cur_trans); 1747 1748 if (current->journal_info == trans) 1749 current->journal_info = NULL; 1750 1751 btrfs_put_transaction(cur_trans); 1752 return 0; 1753 } 1754 1755 1756 static void cleanup_transaction(struct btrfs_trans_handle *trans, 1757 struct btrfs_root *root, int err) 1758 { 1759 struct btrfs_transaction *cur_trans = trans->transaction; 1760 DEFINE_WAIT(wait); 1761 1762 WARN_ON(trans->use_count > 1); 1763 1764 btrfs_abort_transaction(trans, root, err); 1765 1766 spin_lock(&root->fs_info->trans_lock); 1767 1768 /* 1769 * If the transaction is removed from the list, it means this 1770 * transaction has been committed successfully, so it is impossible 1771 * to call the cleanup function. 1772 */ 1773 BUG_ON(list_empty(&cur_trans->list)); 1774 1775 list_del_init(&cur_trans->list); 1776 if (cur_trans == root->fs_info->running_transaction) { 1777 cur_trans->state = TRANS_STATE_COMMIT_DOING; 1778 spin_unlock(&root->fs_info->trans_lock); 1779 wait_event(cur_trans->writer_wait, 1780 atomic_read(&cur_trans->num_writers) == 1); 1781 1782 spin_lock(&root->fs_info->trans_lock); 1783 } 1784 spin_unlock(&root->fs_info->trans_lock); 1785 1786 btrfs_cleanup_one_transaction(trans->transaction, root); 1787 1788 spin_lock(&root->fs_info->trans_lock); 1789 if (cur_trans == root->fs_info->running_transaction) 1790 root->fs_info->running_transaction = NULL; 1791 spin_unlock(&root->fs_info->trans_lock); 1792 1793 if (trans->type & __TRANS_FREEZABLE) 1794 sb_end_intwrite(root->fs_info->sb); 1795 btrfs_put_transaction(cur_trans); 1796 btrfs_put_transaction(cur_trans); 1797 1798 trace_btrfs_transaction_commit(root); 1799 1800 if (current->journal_info == trans) 1801 current->journal_info = NULL; 1802 btrfs_scrub_cancel(root->fs_info); 1803 1804 kmem_cache_free(btrfs_trans_handle_cachep, trans); 1805 } 1806 1807 static inline int btrfs_start_delalloc_flush(struct btrfs_fs_info *fs_info) 1808 { 1809 if (btrfs_test_opt(fs_info->tree_root, FLUSHONCOMMIT)) 1810 return btrfs_start_delalloc_roots(fs_info, 1, -1); 1811 return 0; 1812 } 1813 1814 static inline void btrfs_wait_delalloc_flush(struct btrfs_fs_info *fs_info) 1815 { 1816 if (btrfs_test_opt(fs_info->tree_root, FLUSHONCOMMIT)) 1817 btrfs_wait_ordered_roots(fs_info, -1); 1818 } 1819 1820 static inline void 1821 btrfs_wait_pending_ordered(struct btrfs_transaction *cur_trans) 1822 { 1823 wait_event(cur_trans->pending_wait, 1824 atomic_read(&cur_trans->pending_ordered) == 0); 1825 } 1826 1827 int btrfs_commit_transaction(struct btrfs_trans_handle *trans, 1828 struct btrfs_root *root) 1829 { 1830 struct btrfs_transaction *cur_trans = trans->transaction; 1831 struct btrfs_transaction *prev_trans = NULL; 1832 struct btrfs_inode *btree_ino = BTRFS_I(root->fs_info->btree_inode); 1833 int ret; 1834 1835 /* Stop the commit early if ->aborted is set */ 1836 if (unlikely(ACCESS_ONCE(cur_trans->aborted))) { 1837 ret = cur_trans->aborted; 1838 btrfs_end_transaction(trans, root); 1839 return ret; 1840 } 1841 1842 /* make a pass through all the delayed refs we have so far 1843 * any runnings procs may add more while we are here 1844 */ 1845 ret = btrfs_run_delayed_refs(trans, root, 0); 1846 if (ret) { 1847 btrfs_end_transaction(trans, root); 1848 return ret; 1849 } 1850 1851 btrfs_trans_release_metadata(trans, root); 1852 trans->block_rsv = NULL; 1853 1854 cur_trans = trans->transaction; 1855 1856 /* 1857 * set the flushing flag so procs in this transaction have to 1858 * start sending their work down. 1859 */ 1860 cur_trans->delayed_refs.flushing = 1; 1861 smp_wmb(); 1862 1863 if (!list_empty(&trans->new_bgs)) 1864 btrfs_create_pending_block_groups(trans, root); 1865 1866 ret = btrfs_run_delayed_refs(trans, root, 0); 1867 if (ret) { 1868 btrfs_end_transaction(trans, root); 1869 return ret; 1870 } 1871 1872 if (!test_bit(BTRFS_TRANS_DIRTY_BG_RUN, &cur_trans->flags)) { 1873 int run_it = 0; 1874 1875 /* this mutex is also taken before trying to set 1876 * block groups readonly. We need to make sure 1877 * that nobody has set a block group readonly 1878 * after a extents from that block group have been 1879 * allocated for cache files. btrfs_set_block_group_ro 1880 * will wait for the transaction to commit if it 1881 * finds BTRFS_TRANS_DIRTY_BG_RUN set. 1882 * 1883 * The BTRFS_TRANS_DIRTY_BG_RUN flag is also used to make sure 1884 * only one process starts all the block group IO. It wouldn't 1885 * hurt to have more than one go through, but there's no 1886 * real advantage to it either. 1887 */ 1888 mutex_lock(&root->fs_info->ro_block_group_mutex); 1889 if (!test_and_set_bit(BTRFS_TRANS_DIRTY_BG_RUN, 1890 &cur_trans->flags)) 1891 run_it = 1; 1892 mutex_unlock(&root->fs_info->ro_block_group_mutex); 1893 1894 if (run_it) 1895 ret = btrfs_start_dirty_block_groups(trans, root); 1896 } 1897 if (ret) { 1898 btrfs_end_transaction(trans, root); 1899 return ret; 1900 } 1901 1902 spin_lock(&root->fs_info->trans_lock); 1903 if (cur_trans->state >= TRANS_STATE_COMMIT_START) { 1904 spin_unlock(&root->fs_info->trans_lock); 1905 atomic_inc(&cur_trans->use_count); 1906 ret = btrfs_end_transaction(trans, root); 1907 1908 wait_for_commit(root, cur_trans); 1909 1910 if (unlikely(cur_trans->aborted)) 1911 ret = cur_trans->aborted; 1912 1913 btrfs_put_transaction(cur_trans); 1914 1915 return ret; 1916 } 1917 1918 cur_trans->state = TRANS_STATE_COMMIT_START; 1919 wake_up(&root->fs_info->transaction_blocked_wait); 1920 1921 if (cur_trans->list.prev != &root->fs_info->trans_list) { 1922 prev_trans = list_entry(cur_trans->list.prev, 1923 struct btrfs_transaction, list); 1924 if (prev_trans->state != TRANS_STATE_COMPLETED) { 1925 atomic_inc(&prev_trans->use_count); 1926 spin_unlock(&root->fs_info->trans_lock); 1927 1928 wait_for_commit(root, prev_trans); 1929 ret = prev_trans->aborted; 1930 1931 btrfs_put_transaction(prev_trans); 1932 if (ret) 1933 goto cleanup_transaction; 1934 } else { 1935 spin_unlock(&root->fs_info->trans_lock); 1936 } 1937 } else { 1938 spin_unlock(&root->fs_info->trans_lock); 1939 } 1940 1941 extwriter_counter_dec(cur_trans, trans->type); 1942 1943 ret = btrfs_start_delalloc_flush(root->fs_info); 1944 if (ret) 1945 goto cleanup_transaction; 1946 1947 ret = btrfs_run_delayed_items(trans, root); 1948 if (ret) 1949 goto cleanup_transaction; 1950 1951 wait_event(cur_trans->writer_wait, 1952 extwriter_counter_read(cur_trans) == 0); 1953 1954 /* some pending stuffs might be added after the previous flush. */ 1955 ret = btrfs_run_delayed_items(trans, root); 1956 if (ret) 1957 goto cleanup_transaction; 1958 1959 btrfs_wait_delalloc_flush(root->fs_info); 1960 1961 btrfs_wait_pending_ordered(cur_trans); 1962 1963 btrfs_scrub_pause(root); 1964 /* 1965 * Ok now we need to make sure to block out any other joins while we 1966 * commit the transaction. We could have started a join before setting 1967 * COMMIT_DOING so make sure to wait for num_writers to == 1 again. 1968 */ 1969 spin_lock(&root->fs_info->trans_lock); 1970 cur_trans->state = TRANS_STATE_COMMIT_DOING; 1971 spin_unlock(&root->fs_info->trans_lock); 1972 wait_event(cur_trans->writer_wait, 1973 atomic_read(&cur_trans->num_writers) == 1); 1974 1975 /* ->aborted might be set after the previous check, so check it */ 1976 if (unlikely(ACCESS_ONCE(cur_trans->aborted))) { 1977 ret = cur_trans->aborted; 1978 goto scrub_continue; 1979 } 1980 /* 1981 * the reloc mutex makes sure that we stop 1982 * the balancing code from coming in and moving 1983 * extents around in the middle of the commit 1984 */ 1985 mutex_lock(&root->fs_info->reloc_mutex); 1986 1987 /* 1988 * We needn't worry about the delayed items because we will 1989 * deal with them in create_pending_snapshot(), which is the 1990 * core function of the snapshot creation. 1991 */ 1992 ret = create_pending_snapshots(trans, root->fs_info); 1993 if (ret) { 1994 mutex_unlock(&root->fs_info->reloc_mutex); 1995 goto scrub_continue; 1996 } 1997 1998 /* 1999 * We insert the dir indexes of the snapshots and update the inode 2000 * of the snapshots' parents after the snapshot creation, so there 2001 * are some delayed items which are not dealt with. Now deal with 2002 * them. 2003 * 2004 * We needn't worry that this operation will corrupt the snapshots, 2005 * because all the tree which are snapshoted will be forced to COW 2006 * the nodes and leaves. 2007 */ 2008 ret = btrfs_run_delayed_items(trans, root); 2009 if (ret) { 2010 mutex_unlock(&root->fs_info->reloc_mutex); 2011 goto scrub_continue; 2012 } 2013 2014 ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); 2015 if (ret) { 2016 mutex_unlock(&root->fs_info->reloc_mutex); 2017 goto scrub_continue; 2018 } 2019 2020 /* Reocrd old roots for later qgroup accounting */ 2021 ret = btrfs_qgroup_prepare_account_extents(trans, root->fs_info); 2022 if (ret) { 2023 mutex_unlock(&root->fs_info->reloc_mutex); 2024 goto scrub_continue; 2025 } 2026 2027 /* 2028 * make sure none of the code above managed to slip in a 2029 * delayed item 2030 */ 2031 btrfs_assert_delayed_root_empty(root); 2032 2033 WARN_ON(cur_trans != trans->transaction); 2034 2035 /* btrfs_commit_tree_roots is responsible for getting the 2036 * various roots consistent with each other. Every pointer 2037 * in the tree of tree roots has to point to the most up to date 2038 * root for every subvolume and other tree. So, we have to keep 2039 * the tree logging code from jumping in and changing any 2040 * of the trees. 2041 * 2042 * At this point in the commit, there can't be any tree-log 2043 * writers, but a little lower down we drop the trans mutex 2044 * and let new people in. By holding the tree_log_mutex 2045 * from now until after the super is written, we avoid races 2046 * with the tree-log code. 2047 */ 2048 mutex_lock(&root->fs_info->tree_log_mutex); 2049 2050 ret = commit_fs_roots(trans, root); 2051 if (ret) { 2052 mutex_unlock(&root->fs_info->tree_log_mutex); 2053 mutex_unlock(&root->fs_info->reloc_mutex); 2054 goto scrub_continue; 2055 } 2056 2057 /* 2058 * Since the transaction is done, we can apply the pending changes 2059 * before the next transaction. 2060 */ 2061 btrfs_apply_pending_changes(root->fs_info); 2062 2063 /* commit_fs_roots gets rid of all the tree log roots, it is now 2064 * safe to free the root of tree log roots 2065 */ 2066 btrfs_free_log_root_tree(trans, root->fs_info); 2067 2068 /* 2069 * Since fs roots are all committed, we can get a quite accurate 2070 * new_roots. So let's do quota accounting. 2071 */ 2072 ret = btrfs_qgroup_account_extents(trans, root->fs_info); 2073 if (ret < 0) { 2074 mutex_unlock(&root->fs_info->tree_log_mutex); 2075 mutex_unlock(&root->fs_info->reloc_mutex); 2076 goto scrub_continue; 2077 } 2078 2079 ret = commit_cowonly_roots(trans, root); 2080 if (ret) { 2081 mutex_unlock(&root->fs_info->tree_log_mutex); 2082 mutex_unlock(&root->fs_info->reloc_mutex); 2083 goto scrub_continue; 2084 } 2085 2086 /* 2087 * The tasks which save the space cache and inode cache may also 2088 * update ->aborted, check it. 2089 */ 2090 if (unlikely(ACCESS_ONCE(cur_trans->aborted))) { 2091 ret = cur_trans->aborted; 2092 mutex_unlock(&root->fs_info->tree_log_mutex); 2093 mutex_unlock(&root->fs_info->reloc_mutex); 2094 goto scrub_continue; 2095 } 2096 2097 btrfs_prepare_extent_commit(trans, root); 2098 2099 cur_trans = root->fs_info->running_transaction; 2100 2101 btrfs_set_root_node(&root->fs_info->tree_root->root_item, 2102 root->fs_info->tree_root->node); 2103 list_add_tail(&root->fs_info->tree_root->dirty_list, 2104 &cur_trans->switch_commits); 2105 2106 btrfs_set_root_node(&root->fs_info->chunk_root->root_item, 2107 root->fs_info->chunk_root->node); 2108 list_add_tail(&root->fs_info->chunk_root->dirty_list, 2109 &cur_trans->switch_commits); 2110 2111 switch_commit_roots(cur_trans, root->fs_info); 2112 2113 assert_qgroups_uptodate(trans); 2114 ASSERT(list_empty(&cur_trans->dirty_bgs)); 2115 ASSERT(list_empty(&cur_trans->io_bgs)); 2116 update_super_roots(root); 2117 2118 btrfs_set_super_log_root(root->fs_info->super_copy, 0); 2119 btrfs_set_super_log_root_level(root->fs_info->super_copy, 0); 2120 memcpy(root->fs_info->super_for_commit, root->fs_info->super_copy, 2121 sizeof(*root->fs_info->super_copy)); 2122 2123 btrfs_update_commit_device_size(root->fs_info); 2124 btrfs_update_commit_device_bytes_used(root, cur_trans); 2125 2126 clear_bit(BTRFS_INODE_BTREE_LOG1_ERR, &btree_ino->runtime_flags); 2127 clear_bit(BTRFS_INODE_BTREE_LOG2_ERR, &btree_ino->runtime_flags); 2128 2129 btrfs_trans_release_chunk_metadata(trans); 2130 2131 spin_lock(&root->fs_info->trans_lock); 2132 cur_trans->state = TRANS_STATE_UNBLOCKED; 2133 root->fs_info->running_transaction = NULL; 2134 spin_unlock(&root->fs_info->trans_lock); 2135 mutex_unlock(&root->fs_info->reloc_mutex); 2136 2137 wake_up(&root->fs_info->transaction_wait); 2138 2139 ret = btrfs_write_and_wait_transaction(trans, root); 2140 if (ret) { 2141 btrfs_std_error(root->fs_info, ret, 2142 "Error while writing out transaction"); 2143 mutex_unlock(&root->fs_info->tree_log_mutex); 2144 goto scrub_continue; 2145 } 2146 2147 ret = write_ctree_super(trans, root, 0); 2148 if (ret) { 2149 mutex_unlock(&root->fs_info->tree_log_mutex); 2150 goto scrub_continue; 2151 } 2152 2153 /* 2154 * the super is written, we can safely allow the tree-loggers 2155 * to go about their business 2156 */ 2157 mutex_unlock(&root->fs_info->tree_log_mutex); 2158 2159 btrfs_finish_extent_commit(trans, root); 2160 2161 if (test_bit(BTRFS_TRANS_HAVE_FREE_BGS, &cur_trans->flags)) 2162 btrfs_clear_space_info_full(root->fs_info); 2163 2164 root->fs_info->last_trans_committed = cur_trans->transid; 2165 /* 2166 * We needn't acquire the lock here because there is no other task 2167 * which can change it. 2168 */ 2169 cur_trans->state = TRANS_STATE_COMPLETED; 2170 wake_up(&cur_trans->commit_wait); 2171 2172 spin_lock(&root->fs_info->trans_lock); 2173 list_del_init(&cur_trans->list); 2174 spin_unlock(&root->fs_info->trans_lock); 2175 2176 btrfs_put_transaction(cur_trans); 2177 btrfs_put_transaction(cur_trans); 2178 2179 if (trans->type & __TRANS_FREEZABLE) 2180 sb_end_intwrite(root->fs_info->sb); 2181 2182 trace_btrfs_transaction_commit(root); 2183 2184 btrfs_scrub_continue(root); 2185 2186 if (current->journal_info == trans) 2187 current->journal_info = NULL; 2188 2189 kmem_cache_free(btrfs_trans_handle_cachep, trans); 2190 2191 if (current != root->fs_info->transaction_kthread && 2192 current != root->fs_info->cleaner_kthread) 2193 btrfs_run_delayed_iputs(root); 2194 2195 return ret; 2196 2197 scrub_continue: 2198 btrfs_scrub_continue(root); 2199 cleanup_transaction: 2200 btrfs_trans_release_metadata(trans, root); 2201 btrfs_trans_release_chunk_metadata(trans); 2202 trans->block_rsv = NULL; 2203 btrfs_warn(root->fs_info, "Skipping commit of aborted transaction."); 2204 if (current->journal_info == trans) 2205 current->journal_info = NULL; 2206 cleanup_transaction(trans, root, ret); 2207 2208 return ret; 2209 } 2210 2211 /* 2212 * return < 0 if error 2213 * 0 if there are no more dead_roots at the time of call 2214 * 1 there are more to be processed, call me again 2215 * 2216 * The return value indicates there are certainly more snapshots to delete, but 2217 * if there comes a new one during processing, it may return 0. We don't mind, 2218 * because btrfs_commit_super will poke cleaner thread and it will process it a 2219 * few seconds later. 2220 */ 2221 int btrfs_clean_one_deleted_snapshot(struct btrfs_root *root) 2222 { 2223 int ret; 2224 struct btrfs_fs_info *fs_info = root->fs_info; 2225 2226 spin_lock(&fs_info->trans_lock); 2227 if (list_empty(&fs_info->dead_roots)) { 2228 spin_unlock(&fs_info->trans_lock); 2229 return 0; 2230 } 2231 root = list_first_entry(&fs_info->dead_roots, 2232 struct btrfs_root, root_list); 2233 list_del_init(&root->root_list); 2234 spin_unlock(&fs_info->trans_lock); 2235 2236 pr_debug("BTRFS: cleaner removing %llu\n", root->objectid); 2237 2238 btrfs_kill_all_delayed_nodes(root); 2239 2240 if (btrfs_header_backref_rev(root->node) < 2241 BTRFS_MIXED_BACKREF_REV) 2242 ret = btrfs_drop_snapshot(root, NULL, 0, 0); 2243 else 2244 ret = btrfs_drop_snapshot(root, NULL, 1, 0); 2245 2246 return (ret < 0) ? 0 : 1; 2247 } 2248 2249 void btrfs_apply_pending_changes(struct btrfs_fs_info *fs_info) 2250 { 2251 unsigned long prev; 2252 unsigned long bit; 2253 2254 prev = xchg(&fs_info->pending_changes, 0); 2255 if (!prev) 2256 return; 2257 2258 bit = 1 << BTRFS_PENDING_SET_INODE_MAP_CACHE; 2259 if (prev & bit) 2260 btrfs_set_opt(fs_info->mount_opt, INODE_MAP_CACHE); 2261 prev &= ~bit; 2262 2263 bit = 1 << BTRFS_PENDING_CLEAR_INODE_MAP_CACHE; 2264 if (prev & bit) 2265 btrfs_clear_opt(fs_info->mount_opt, INODE_MAP_CACHE); 2266 prev &= ~bit; 2267 2268 bit = 1 << BTRFS_PENDING_COMMIT; 2269 if (prev & bit) 2270 btrfs_debug(fs_info, "pending commit done"); 2271 prev &= ~bit; 2272 2273 if (prev) 2274 btrfs_warn(fs_info, 2275 "unknown pending changes left 0x%lx, ignoring", prev); 2276 } 2277