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