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