16cbd5570SChris Mason /* 26cbd5570SChris Mason * Copyright (C) 2007 Oracle. All rights reserved. 36cbd5570SChris Mason * 46cbd5570SChris Mason * This program is free software; you can redistribute it and/or 56cbd5570SChris Mason * modify it under the terms of the GNU General Public 66cbd5570SChris Mason * License v2 as published by the Free Software Foundation. 76cbd5570SChris Mason * 86cbd5570SChris Mason * This program is distributed in the hope that it will be useful, 96cbd5570SChris Mason * but WITHOUT ANY WARRANTY; without even the implied warranty of 106cbd5570SChris Mason * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 116cbd5570SChris Mason * General Public License for more details. 126cbd5570SChris Mason * 136cbd5570SChris Mason * You should have received a copy of the GNU General Public 146cbd5570SChris Mason * License along with this program; if not, write to the 156cbd5570SChris Mason * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 166cbd5570SChris Mason * Boston, MA 021110-1307, USA. 176cbd5570SChris Mason */ 186cbd5570SChris Mason 1979154b1bSChris Mason #include <linux/fs.h> 205a0e3ad6STejun Heo #include <linux/slab.h> 2134088780SChris Mason #include <linux/sched.h> 22d3c2fdcfSChris Mason #include <linux/writeback.h> 235f39d397SChris Mason #include <linux/pagemap.h> 245f2cc086SChris Mason #include <linux/blkdev.h> 258ea05e3aSAlexander Block #include <linux/uuid.h> 2679154b1bSChris Mason #include "ctree.h" 2779154b1bSChris Mason #include "disk-io.h" 2879154b1bSChris Mason #include "transaction.h" 29925baeddSChris Mason #include "locking.h" 30e02119d5SChris Mason #include "tree-log.h" 31581bb050SLi Zefan #include "inode-map.h" 32733f4fbbSStefan Behrens #include "volumes.h" 338dabb742SStefan Behrens #include "dev-replace.h" 34fcebe456SJosef Bacik #include "qgroup.h" 3579154b1bSChris Mason 360f7d52f4SChris Mason #define BTRFS_ROOT_TRANS_TAG 0 370f7d52f4SChris Mason 38e8c9f186SDavid Sterba static const unsigned int btrfs_blocked_trans_types[TRANS_STATE_MAX] = { 394a9d8bdeSMiao Xie [TRANS_STATE_RUNNING] = 0U, 404a9d8bdeSMiao Xie [TRANS_STATE_BLOCKED] = (__TRANS_USERSPACE | 414a9d8bdeSMiao Xie __TRANS_START), 424a9d8bdeSMiao Xie [TRANS_STATE_COMMIT_START] = (__TRANS_USERSPACE | 434a9d8bdeSMiao Xie __TRANS_START | 444a9d8bdeSMiao Xie __TRANS_ATTACH), 454a9d8bdeSMiao Xie [TRANS_STATE_COMMIT_DOING] = (__TRANS_USERSPACE | 464a9d8bdeSMiao Xie __TRANS_START | 474a9d8bdeSMiao Xie __TRANS_ATTACH | 484a9d8bdeSMiao Xie __TRANS_JOIN), 494a9d8bdeSMiao Xie [TRANS_STATE_UNBLOCKED] = (__TRANS_USERSPACE | 504a9d8bdeSMiao Xie __TRANS_START | 514a9d8bdeSMiao Xie __TRANS_ATTACH | 524a9d8bdeSMiao Xie __TRANS_JOIN | 534a9d8bdeSMiao Xie __TRANS_JOIN_NOLOCK), 544a9d8bdeSMiao Xie [TRANS_STATE_COMPLETED] = (__TRANS_USERSPACE | 554a9d8bdeSMiao Xie __TRANS_START | 564a9d8bdeSMiao Xie __TRANS_ATTACH | 574a9d8bdeSMiao Xie __TRANS_JOIN | 584a9d8bdeSMiao Xie __TRANS_JOIN_NOLOCK), 594a9d8bdeSMiao Xie }; 604a9d8bdeSMiao Xie 61724e2315SJosef Bacik void btrfs_put_transaction(struct btrfs_transaction *transaction) 6279154b1bSChris Mason { 6313c5a93eSJosef Bacik WARN_ON(atomic_read(&transaction->use_count) == 0); 6413c5a93eSJosef Bacik if (atomic_dec_and_test(&transaction->use_count)) { 65a4abeea4SJosef Bacik BUG_ON(!list_empty(&transaction->list)); 66c46effa6SLiu Bo WARN_ON(!RB_EMPTY_ROOT(&transaction->delayed_refs.href_root)); 671262133bSJosef Bacik if (transaction->delayed_refs.pending_csums) 681262133bSJosef Bacik printk(KERN_ERR "pending csums is %llu\n", 691262133bSJosef Bacik transaction->delayed_refs.pending_csums); 706df9a95eSJosef Bacik while (!list_empty(&transaction->pending_chunks)) { 716df9a95eSJosef Bacik struct extent_map *em; 726df9a95eSJosef Bacik 736df9a95eSJosef Bacik em = list_first_entry(&transaction->pending_chunks, 746df9a95eSJosef Bacik struct extent_map, list); 756df9a95eSJosef Bacik list_del_init(&em->list); 766df9a95eSJosef Bacik free_extent_map(em); 776df9a95eSJosef Bacik } 782c90e5d6SChris Mason kmem_cache_free(btrfs_transaction_cachep, transaction); 7979154b1bSChris Mason } 8078fae27eSChris Mason } 8179154b1bSChris Mason 82663dfbb0SFilipe Manana static void clear_btree_io_tree(struct extent_io_tree *tree) 83663dfbb0SFilipe Manana { 84663dfbb0SFilipe Manana spin_lock(&tree->lock); 85663dfbb0SFilipe Manana while (!RB_EMPTY_ROOT(&tree->state)) { 86663dfbb0SFilipe Manana struct rb_node *node; 87663dfbb0SFilipe Manana struct extent_state *state; 88663dfbb0SFilipe Manana 89663dfbb0SFilipe Manana node = rb_first(&tree->state); 90663dfbb0SFilipe Manana state = rb_entry(node, struct extent_state, rb_node); 91663dfbb0SFilipe Manana rb_erase(&state->rb_node, &tree->state); 92663dfbb0SFilipe Manana RB_CLEAR_NODE(&state->rb_node); 93663dfbb0SFilipe Manana /* 94663dfbb0SFilipe Manana * btree io trees aren't supposed to have tasks waiting for 95663dfbb0SFilipe Manana * changes in the flags of extent states ever. 96663dfbb0SFilipe Manana */ 97663dfbb0SFilipe Manana ASSERT(!waitqueue_active(&state->wq)); 98663dfbb0SFilipe Manana free_extent_state(state); 99351810c1SDavid Sterba 100351810c1SDavid Sterba cond_resched_lock(&tree->lock); 101663dfbb0SFilipe Manana } 102663dfbb0SFilipe Manana spin_unlock(&tree->lock); 103663dfbb0SFilipe Manana } 104663dfbb0SFilipe Manana 1059e351cc8SJosef Bacik static noinline void switch_commit_roots(struct btrfs_transaction *trans, 1069e351cc8SJosef Bacik struct btrfs_fs_info *fs_info) 107817d52f8SJosef Bacik { 1089e351cc8SJosef Bacik struct btrfs_root *root, *tmp; 1099e351cc8SJosef Bacik 1109e351cc8SJosef Bacik down_write(&fs_info->commit_root_sem); 1119e351cc8SJosef Bacik list_for_each_entry_safe(root, tmp, &trans->switch_commits, 1129e351cc8SJosef Bacik dirty_list) { 1139e351cc8SJosef Bacik list_del_init(&root->dirty_list); 114817d52f8SJosef Bacik free_extent_buffer(root->commit_root); 115817d52f8SJosef Bacik root->commit_root = btrfs_root_node(root); 1169e351cc8SJosef Bacik if (is_fstree(root->objectid)) 1179e351cc8SJosef Bacik btrfs_unpin_free_ino(root); 118663dfbb0SFilipe Manana clear_btree_io_tree(&root->dirty_log_pages); 1199e351cc8SJosef Bacik } 1202b9dbef2SJosef Bacik 1212b9dbef2SJosef Bacik /* We can free old roots now. */ 1222b9dbef2SJosef Bacik spin_lock(&trans->dropped_roots_lock); 1232b9dbef2SJosef Bacik while (!list_empty(&trans->dropped_roots)) { 1242b9dbef2SJosef Bacik root = list_first_entry(&trans->dropped_roots, 1252b9dbef2SJosef Bacik struct btrfs_root, root_list); 1262b9dbef2SJosef Bacik list_del_init(&root->root_list); 1272b9dbef2SJosef Bacik spin_unlock(&trans->dropped_roots_lock); 1282b9dbef2SJosef Bacik btrfs_drop_and_free_fs_root(fs_info, root); 1292b9dbef2SJosef Bacik spin_lock(&trans->dropped_roots_lock); 1302b9dbef2SJosef Bacik } 1312b9dbef2SJosef Bacik spin_unlock(&trans->dropped_roots_lock); 1329e351cc8SJosef Bacik up_write(&fs_info->commit_root_sem); 133817d52f8SJosef Bacik } 134817d52f8SJosef Bacik 1350860adfdSMiao Xie static inline void extwriter_counter_inc(struct btrfs_transaction *trans, 1360860adfdSMiao Xie unsigned int type) 1370860adfdSMiao Xie { 1380860adfdSMiao Xie if (type & TRANS_EXTWRITERS) 1390860adfdSMiao Xie atomic_inc(&trans->num_extwriters); 1400860adfdSMiao Xie } 1410860adfdSMiao Xie 1420860adfdSMiao Xie static inline void extwriter_counter_dec(struct btrfs_transaction *trans, 1430860adfdSMiao Xie unsigned int type) 1440860adfdSMiao Xie { 1450860adfdSMiao Xie if (type & TRANS_EXTWRITERS) 1460860adfdSMiao Xie atomic_dec(&trans->num_extwriters); 1470860adfdSMiao Xie } 1480860adfdSMiao Xie 1490860adfdSMiao Xie static inline void extwriter_counter_init(struct btrfs_transaction *trans, 1500860adfdSMiao Xie unsigned int type) 1510860adfdSMiao Xie { 1520860adfdSMiao Xie atomic_set(&trans->num_extwriters, ((type & TRANS_EXTWRITERS) ? 1 : 0)); 1530860adfdSMiao Xie } 1540860adfdSMiao Xie 1550860adfdSMiao Xie static inline int extwriter_counter_read(struct btrfs_transaction *trans) 1560860adfdSMiao Xie { 1570860adfdSMiao Xie return atomic_read(&trans->num_extwriters); 158178260b2SMiao Xie } 159178260b2SMiao Xie 160d352ac68SChris Mason /* 161d352ac68SChris Mason * either allocate a new transaction or hop into the existing one 162d352ac68SChris Mason */ 1630860adfdSMiao Xie static noinline int join_transaction(struct btrfs_root *root, unsigned int type) 16479154b1bSChris Mason { 16579154b1bSChris Mason struct btrfs_transaction *cur_trans; 16619ae4e81SJan Schmidt struct btrfs_fs_info *fs_info = root->fs_info; 167a4abeea4SJosef Bacik 16819ae4e81SJan Schmidt spin_lock(&fs_info->trans_lock); 169d43317dcSChris Mason loop: 17049b25e05SJeff Mahoney /* The file system has been taken offline. No new transactions. */ 17187533c47SMiao Xie if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) { 17219ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 17349b25e05SJeff Mahoney return -EROFS; 17449b25e05SJeff Mahoney } 17549b25e05SJeff Mahoney 17619ae4e81SJan Schmidt cur_trans = fs_info->running_transaction; 177a4abeea4SJosef Bacik if (cur_trans) { 178871383beSDavid Sterba if (cur_trans->aborted) { 17919ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 18049b25e05SJeff Mahoney return cur_trans->aborted; 181871383beSDavid Sterba } 1824a9d8bdeSMiao Xie if (btrfs_blocked_trans_types[cur_trans->state] & type) { 183178260b2SMiao Xie spin_unlock(&fs_info->trans_lock); 184178260b2SMiao Xie return -EBUSY; 185178260b2SMiao Xie } 186a4abeea4SJosef Bacik atomic_inc(&cur_trans->use_count); 187a4abeea4SJosef Bacik atomic_inc(&cur_trans->num_writers); 1880860adfdSMiao Xie extwriter_counter_inc(cur_trans, type); 18919ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 190a4abeea4SJosef Bacik return 0; 191a4abeea4SJosef Bacik } 19219ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 193a4abeea4SJosef Bacik 194354aa0fbSMiao Xie /* 195354aa0fbSMiao Xie * If we are ATTACH, we just want to catch the current transaction, 196354aa0fbSMiao Xie * and commit it. If there is no transaction, just return ENOENT. 197354aa0fbSMiao Xie */ 198354aa0fbSMiao Xie if (type == TRANS_ATTACH) 199354aa0fbSMiao Xie return -ENOENT; 200354aa0fbSMiao Xie 2014a9d8bdeSMiao Xie /* 2024a9d8bdeSMiao Xie * JOIN_NOLOCK only happens during the transaction commit, so 2034a9d8bdeSMiao Xie * it is impossible that ->running_transaction is NULL 2044a9d8bdeSMiao Xie */ 2054a9d8bdeSMiao Xie BUG_ON(type == TRANS_JOIN_NOLOCK); 2064a9d8bdeSMiao Xie 207a4abeea4SJosef Bacik cur_trans = kmem_cache_alloc(btrfs_transaction_cachep, GFP_NOFS); 208db5b493aSTsutomu Itoh if (!cur_trans) 209db5b493aSTsutomu Itoh return -ENOMEM; 210d43317dcSChris Mason 21119ae4e81SJan Schmidt spin_lock(&fs_info->trans_lock); 21219ae4e81SJan Schmidt if (fs_info->running_transaction) { 213d43317dcSChris Mason /* 214d43317dcSChris Mason * someone started a transaction after we unlocked. Make sure 2154a9d8bdeSMiao Xie * to redo the checks above 216d43317dcSChris Mason */ 217a4abeea4SJosef Bacik kmem_cache_free(btrfs_transaction_cachep, cur_trans); 218d43317dcSChris Mason goto loop; 21987533c47SMiao Xie } else if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) { 220e4b50e14SDan Carpenter spin_unlock(&fs_info->trans_lock); 2217b8b92afSJosef Bacik kmem_cache_free(btrfs_transaction_cachep, cur_trans); 2227b8b92afSJosef Bacik return -EROFS; 223a4abeea4SJosef Bacik } 224d43317dcSChris Mason 22513c5a93eSJosef Bacik atomic_set(&cur_trans->num_writers, 1); 2260860adfdSMiao Xie extwriter_counter_init(cur_trans, type); 22779154b1bSChris Mason init_waitqueue_head(&cur_trans->writer_wait); 22879154b1bSChris Mason init_waitqueue_head(&cur_trans->commit_wait); 2294a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_RUNNING; 230a4abeea4SJosef Bacik /* 231a4abeea4SJosef Bacik * One for this trans handle, one so it will live on until we 232a4abeea4SJosef Bacik * commit the transaction. 233a4abeea4SJosef Bacik */ 234a4abeea4SJosef Bacik atomic_set(&cur_trans->use_count, 2); 23513212b54SZhao Lei cur_trans->have_free_bgs = 0; 23608607c1bSChris Mason cur_trans->start_time = get_seconds(); 2371bbc621eSChris Mason cur_trans->dirty_bg_run = 0; 23856bec294SChris Mason 239a099d0fdSAlexandru Moise memset(&cur_trans->delayed_refs, 0, sizeof(cur_trans->delayed_refs)); 240a099d0fdSAlexandru Moise 241c46effa6SLiu Bo cur_trans->delayed_refs.href_root = RB_ROOT; 2423368d001SQu Wenruo cur_trans->delayed_refs.dirty_extent_root = RB_ROOT; 243d7df2c79SJosef Bacik atomic_set(&cur_trans->delayed_refs.num_entries, 0); 24420b297d6SJan Schmidt 24520b297d6SJan Schmidt /* 24620b297d6SJan Schmidt * although the tree mod log is per file system and not per transaction, 24720b297d6SJan Schmidt * the log must never go across transaction boundaries. 24820b297d6SJan Schmidt */ 24920b297d6SJan Schmidt smp_mb(); 25031b1a2bdSJulia Lawall if (!list_empty(&fs_info->tree_mod_seq_list)) 251efe120a0SFrank Holton WARN(1, KERN_ERR "BTRFS: tree_mod_seq_list not empty when " 25220b297d6SJan Schmidt "creating a fresh transaction\n"); 25331b1a2bdSJulia Lawall if (!RB_EMPTY_ROOT(&fs_info->tree_mod_log)) 254efe120a0SFrank Holton WARN(1, KERN_ERR "BTRFS: tree_mod_log rb tree not empty when " 25520b297d6SJan Schmidt "creating a fresh transaction\n"); 256fc36ed7eSJan Schmidt atomic64_set(&fs_info->tree_mod_seq, 0); 25720b297d6SJan Schmidt 25856bec294SChris Mason spin_lock_init(&cur_trans->delayed_refs.lock); 25956bec294SChris Mason 2603063d29fSChris Mason INIT_LIST_HEAD(&cur_trans->pending_snapshots); 2616df9a95eSJosef Bacik INIT_LIST_HEAD(&cur_trans->pending_chunks); 2629e351cc8SJosef Bacik INIT_LIST_HEAD(&cur_trans->switch_commits); 26350d9aa99SJosef Bacik INIT_LIST_HEAD(&cur_trans->pending_ordered); 264ce93ec54SJosef Bacik INIT_LIST_HEAD(&cur_trans->dirty_bgs); 2651bbc621eSChris Mason INIT_LIST_HEAD(&cur_trans->io_bgs); 2662b9dbef2SJosef Bacik INIT_LIST_HEAD(&cur_trans->dropped_roots); 2671bbc621eSChris Mason mutex_init(&cur_trans->cache_write_mutex); 268cb723e49SJosef Bacik cur_trans->num_dirty_bgs = 0; 269ce93ec54SJosef Bacik spin_lock_init(&cur_trans->dirty_bgs_lock); 270e33e17eeSJeff Mahoney INIT_LIST_HEAD(&cur_trans->deleted_bgs); 271e33e17eeSJeff Mahoney spin_lock_init(&cur_trans->deleted_bgs_lock); 2722b9dbef2SJosef Bacik spin_lock_init(&cur_trans->dropped_roots_lock); 27319ae4e81SJan Schmidt list_add_tail(&cur_trans->list, &fs_info->trans_list); 274d1310b2eSChris Mason extent_io_tree_init(&cur_trans->dirty_pages, 27519ae4e81SJan Schmidt fs_info->btree_inode->i_mapping); 27619ae4e81SJan Schmidt fs_info->generation++; 27719ae4e81SJan Schmidt cur_trans->transid = fs_info->generation; 27819ae4e81SJan Schmidt fs_info->running_transaction = cur_trans; 27949b25e05SJeff Mahoney cur_trans->aborted = 0; 28019ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 28115ee9bc7SJosef Bacik 28279154b1bSChris Mason return 0; 28379154b1bSChris Mason } 28479154b1bSChris Mason 285d352ac68SChris Mason /* 286d397712bSChris Mason * this does all the record keeping required to make sure that a reference 287d397712bSChris Mason * counted root is properly recorded in a given transaction. This is required 288d397712bSChris Mason * to make sure the old root from before we joined the transaction is deleted 289d397712bSChris Mason * when the transaction commits 290d352ac68SChris Mason */ 2917585717fSChris Mason static int record_root_in_trans(struct btrfs_trans_handle *trans, 2925d4f98a2SYan Zheng struct btrfs_root *root) 2936702ed49SChris Mason { 29427cdeb70SMiao Xie if (test_bit(BTRFS_ROOT_REF_COWS, &root->state) && 29527cdeb70SMiao Xie root->last_trans < trans->transid) { 2966702ed49SChris Mason WARN_ON(root == root->fs_info->extent_root); 2975d4f98a2SYan Zheng WARN_ON(root->commit_root != root->node); 2985d4f98a2SYan Zheng 2997585717fSChris Mason /* 30027cdeb70SMiao Xie * see below for IN_TRANS_SETUP usage rules 3017585717fSChris Mason * we have the reloc mutex held now, so there 3027585717fSChris Mason * is only one writer in this function 3037585717fSChris Mason */ 30427cdeb70SMiao Xie set_bit(BTRFS_ROOT_IN_TRANS_SETUP, &root->state); 3057585717fSChris Mason 30627cdeb70SMiao Xie /* make sure readers find IN_TRANS_SETUP before 3077585717fSChris Mason * they find our root->last_trans update 3087585717fSChris Mason */ 3097585717fSChris Mason smp_wmb(); 3107585717fSChris Mason 311a4abeea4SJosef Bacik spin_lock(&root->fs_info->fs_roots_radix_lock); 312a4abeea4SJosef Bacik if (root->last_trans == trans->transid) { 313a4abeea4SJosef Bacik spin_unlock(&root->fs_info->fs_roots_radix_lock); 314a4abeea4SJosef Bacik return 0; 315a4abeea4SJosef Bacik } 3166702ed49SChris Mason radix_tree_tag_set(&root->fs_info->fs_roots_radix, 3176702ed49SChris Mason (unsigned long)root->root_key.objectid, 3186702ed49SChris Mason BTRFS_ROOT_TRANS_TAG); 319a4abeea4SJosef Bacik spin_unlock(&root->fs_info->fs_roots_radix_lock); 3207585717fSChris Mason root->last_trans = trans->transid; 3217585717fSChris Mason 3227585717fSChris Mason /* this is pretty tricky. We don't want to 3237585717fSChris Mason * take the relocation lock in btrfs_record_root_in_trans 3247585717fSChris Mason * unless we're really doing the first setup for this root in 3257585717fSChris Mason * this transaction. 3267585717fSChris Mason * 3277585717fSChris Mason * Normally we'd use root->last_trans as a flag to decide 3287585717fSChris Mason * if we want to take the expensive mutex. 3297585717fSChris Mason * 3307585717fSChris Mason * But, we have to set root->last_trans before we 3317585717fSChris Mason * init the relocation root, otherwise, we trip over warnings 3327585717fSChris Mason * in ctree.c. The solution used here is to flag ourselves 33327cdeb70SMiao Xie * with root IN_TRANS_SETUP. When this is 1, we're still 3347585717fSChris Mason * fixing up the reloc trees and everyone must wait. 3357585717fSChris Mason * 3367585717fSChris Mason * When this is zero, they can trust root->last_trans and fly 3377585717fSChris Mason * through btrfs_record_root_in_trans without having to take the 3387585717fSChris Mason * lock. smp_wmb() makes sure that all the writes above are 3397585717fSChris Mason * done before we pop in the zero below 3407585717fSChris Mason */ 3415d4f98a2SYan Zheng btrfs_init_reloc_root(trans, root); 342c7548af6SChris Mason smp_mb__before_atomic(); 34327cdeb70SMiao Xie clear_bit(BTRFS_ROOT_IN_TRANS_SETUP, &root->state); 3446702ed49SChris Mason } 3455d4f98a2SYan Zheng return 0; 3466702ed49SChris Mason } 3475d4f98a2SYan Zheng 3487585717fSChris Mason 3492b9dbef2SJosef Bacik void btrfs_add_dropped_root(struct btrfs_trans_handle *trans, 3502b9dbef2SJosef Bacik struct btrfs_root *root) 3512b9dbef2SJosef Bacik { 3522b9dbef2SJosef Bacik struct btrfs_transaction *cur_trans = trans->transaction; 3532b9dbef2SJosef Bacik 3542b9dbef2SJosef Bacik /* Add ourselves to the transaction dropped list */ 3552b9dbef2SJosef Bacik spin_lock(&cur_trans->dropped_roots_lock); 3562b9dbef2SJosef Bacik list_add_tail(&root->root_list, &cur_trans->dropped_roots); 3572b9dbef2SJosef Bacik spin_unlock(&cur_trans->dropped_roots_lock); 3582b9dbef2SJosef Bacik 3592b9dbef2SJosef Bacik /* Make sure we don't try to update the root at commit time */ 3602b9dbef2SJosef Bacik spin_lock(&root->fs_info->fs_roots_radix_lock); 3612b9dbef2SJosef Bacik radix_tree_tag_clear(&root->fs_info->fs_roots_radix, 3622b9dbef2SJosef Bacik (unsigned long)root->root_key.objectid, 3632b9dbef2SJosef Bacik BTRFS_ROOT_TRANS_TAG); 3642b9dbef2SJosef Bacik spin_unlock(&root->fs_info->fs_roots_radix_lock); 3652b9dbef2SJosef Bacik } 3662b9dbef2SJosef Bacik 3677585717fSChris Mason int btrfs_record_root_in_trans(struct btrfs_trans_handle *trans, 3687585717fSChris Mason struct btrfs_root *root) 3697585717fSChris Mason { 37027cdeb70SMiao Xie if (!test_bit(BTRFS_ROOT_REF_COWS, &root->state)) 3717585717fSChris Mason return 0; 3727585717fSChris Mason 3737585717fSChris Mason /* 37427cdeb70SMiao Xie * see record_root_in_trans for comments about IN_TRANS_SETUP usage 3757585717fSChris Mason * and barriers 3767585717fSChris Mason */ 3777585717fSChris Mason smp_rmb(); 3787585717fSChris Mason if (root->last_trans == trans->transid && 37927cdeb70SMiao Xie !test_bit(BTRFS_ROOT_IN_TRANS_SETUP, &root->state)) 3807585717fSChris Mason return 0; 3817585717fSChris Mason 3827585717fSChris Mason mutex_lock(&root->fs_info->reloc_mutex); 3837585717fSChris Mason record_root_in_trans(trans, root); 3847585717fSChris Mason mutex_unlock(&root->fs_info->reloc_mutex); 3857585717fSChris Mason 3867585717fSChris Mason return 0; 3877585717fSChris Mason } 3887585717fSChris Mason 3894a9d8bdeSMiao Xie static inline int is_transaction_blocked(struct btrfs_transaction *trans) 3904a9d8bdeSMiao Xie { 3914a9d8bdeSMiao Xie return (trans->state >= TRANS_STATE_BLOCKED && 392501407aaSJosef Bacik trans->state < TRANS_STATE_UNBLOCKED && 393501407aaSJosef Bacik !trans->aborted); 3944a9d8bdeSMiao Xie } 3954a9d8bdeSMiao Xie 396d352ac68SChris Mason /* wait for commit against the current transaction to become unblocked 397d352ac68SChris Mason * when this is done, it is safe to start a new transaction, but the current 398d352ac68SChris Mason * transaction might not be fully on disk. 399d352ac68SChris Mason */ 40037d1aeeeSChris Mason static void wait_current_trans(struct btrfs_root *root) 40179154b1bSChris Mason { 402f9295749SChris Mason struct btrfs_transaction *cur_trans; 40379154b1bSChris Mason 404a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 405f9295749SChris Mason cur_trans = root->fs_info->running_transaction; 4064a9d8bdeSMiao Xie if (cur_trans && is_transaction_blocked(cur_trans)) { 40713c5a93eSJosef Bacik atomic_inc(&cur_trans->use_count); 408a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 40972d63ed6SLi Zefan 41072d63ed6SLi Zefan wait_event(root->fs_info->transaction_wait, 411501407aaSJosef Bacik cur_trans->state >= TRANS_STATE_UNBLOCKED || 412501407aaSJosef Bacik cur_trans->aborted); 413724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 414a4abeea4SJosef Bacik } else { 415a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 416f9295749SChris Mason } 41737d1aeeeSChris Mason } 41837d1aeeeSChris Mason 419a22285a6SYan, Zheng static int may_wait_transaction(struct btrfs_root *root, int type) 42037d1aeeeSChris Mason { 421a4abeea4SJosef Bacik if (root->fs_info->log_root_recovering) 422a4abeea4SJosef Bacik return 0; 423a4abeea4SJosef Bacik 424a4abeea4SJosef Bacik if (type == TRANS_USERSPACE) 425a22285a6SYan, Zheng return 1; 426a4abeea4SJosef Bacik 427a4abeea4SJosef Bacik if (type == TRANS_START && 428a4abeea4SJosef Bacik !atomic_read(&root->fs_info->open_ioctl_trans)) 429a4abeea4SJosef Bacik return 1; 430a4abeea4SJosef Bacik 431a22285a6SYan, Zheng return 0; 432a22285a6SYan, Zheng } 433a22285a6SYan, Zheng 43420dd2cbfSMiao Xie static inline bool need_reserve_reloc_root(struct btrfs_root *root) 43520dd2cbfSMiao Xie { 43620dd2cbfSMiao Xie if (!root->fs_info->reloc_ctl || 43727cdeb70SMiao Xie !test_bit(BTRFS_ROOT_REF_COWS, &root->state) || 43820dd2cbfSMiao Xie root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID || 43920dd2cbfSMiao Xie root->reloc_root) 44020dd2cbfSMiao Xie return false; 44120dd2cbfSMiao Xie 44220dd2cbfSMiao Xie return true; 44320dd2cbfSMiao Xie } 44420dd2cbfSMiao Xie 44508e007d2SMiao Xie static struct btrfs_trans_handle * 4465aed1dd8SAlexandru Moise start_transaction(struct btrfs_root *root, unsigned int num_items, 4475aed1dd8SAlexandru Moise unsigned int type, enum btrfs_reserve_flush_enum flush) 448a22285a6SYan, Zheng { 449a22285a6SYan, Zheng struct btrfs_trans_handle *h; 450a22285a6SYan, Zheng struct btrfs_transaction *cur_trans; 451b5009945SJosef Bacik u64 num_bytes = 0; 452c5567237SArne Jansen u64 qgroup_reserved = 0; 45320dd2cbfSMiao Xie bool reloc_reserved = false; 45420dd2cbfSMiao Xie int ret; 455acce952bSliubo 45646c4e71eSFilipe Manana /* Send isn't supposed to start transactions. */ 4572755a0deSDavid Sterba ASSERT(current->journal_info != BTRFS_SEND_TRANS_STUB); 45846c4e71eSFilipe Manana 45987533c47SMiao Xie if (test_bit(BTRFS_FS_STATE_ERROR, &root->fs_info->fs_state)) 460acce952bSliubo return ERR_PTR(-EROFS); 4612a1eb461SJosef Bacik 46246c4e71eSFilipe Manana if (current->journal_info) { 4630860adfdSMiao Xie WARN_ON(type & TRANS_EXTWRITERS); 4642a1eb461SJosef Bacik h = current->journal_info; 4652a1eb461SJosef Bacik h->use_count++; 466b7d5b0a8SMiao Xie WARN_ON(h->use_count > 2); 4672a1eb461SJosef Bacik h->orig_rsv = h->block_rsv; 4682a1eb461SJosef Bacik h->block_rsv = NULL; 4692a1eb461SJosef Bacik goto got_it; 4702a1eb461SJosef Bacik } 471b5009945SJosef Bacik 472b5009945SJosef Bacik /* 473b5009945SJosef Bacik * Do the reservation before we join the transaction so we can do all 474b5009945SJosef Bacik * the appropriate flushing if need be. 475b5009945SJosef Bacik */ 476b5009945SJosef Bacik if (num_items > 0 && root != root->fs_info->chunk_root) { 477c5567237SArne Jansen if (root->fs_info->quota_enabled && 478c5567237SArne Jansen is_fstree(root->root_key.objectid)) { 479707e8a07SDavid Sterba qgroup_reserved = num_items * root->nodesize; 480c5567237SArne Jansen ret = btrfs_qgroup_reserve(root, qgroup_reserved); 481c5567237SArne Jansen if (ret) 482c5567237SArne Jansen return ERR_PTR(ret); 483c5567237SArne Jansen } 484c5567237SArne Jansen 485b5009945SJosef Bacik num_bytes = btrfs_calc_trans_metadata_size(root, num_items); 48620dd2cbfSMiao Xie /* 48720dd2cbfSMiao Xie * Do the reservation for the relocation root creation 48820dd2cbfSMiao Xie */ 489ee39b432SDavid Sterba if (need_reserve_reloc_root(root)) { 49020dd2cbfSMiao Xie num_bytes += root->nodesize; 49120dd2cbfSMiao Xie reloc_reserved = true; 49220dd2cbfSMiao Xie } 49320dd2cbfSMiao Xie 4944a92b1b8SJosef Bacik ret = btrfs_block_rsv_add(root, 495b5009945SJosef Bacik &root->fs_info->trans_block_rsv, 49608e007d2SMiao Xie num_bytes, flush); 497b5009945SJosef Bacik if (ret) 498843fcf35SMiao Xie goto reserve_fail; 499b5009945SJosef Bacik } 500a22285a6SYan, Zheng again: 501f2f767e7SAlexandru Moise h = kmem_cache_zalloc(btrfs_trans_handle_cachep, GFP_NOFS); 502843fcf35SMiao Xie if (!h) { 503843fcf35SMiao Xie ret = -ENOMEM; 504843fcf35SMiao Xie goto alloc_fail; 505843fcf35SMiao Xie } 506a22285a6SYan, Zheng 50798114659SJosef Bacik /* 50898114659SJosef Bacik * If we are JOIN_NOLOCK we're already committing a transaction and 50998114659SJosef Bacik * waiting on this guy, so we don't need to do the sb_start_intwrite 51098114659SJosef Bacik * because we're already holding a ref. We need this because we could 51198114659SJosef Bacik * have raced in and did an fsync() on a file which can kick a commit 51298114659SJosef Bacik * and then we deadlock with somebody doing a freeze. 513354aa0fbSMiao Xie * 514354aa0fbSMiao Xie * If we are ATTACH, it means we just want to catch the current 515354aa0fbSMiao Xie * transaction and commit it, so we needn't do sb_start_intwrite(). 51698114659SJosef Bacik */ 5170860adfdSMiao Xie if (type & __TRANS_FREEZABLE) 518b2b5ef5cSJan Kara sb_start_intwrite(root->fs_info->sb); 519b2b5ef5cSJan Kara 520a22285a6SYan, Zheng if (may_wait_transaction(root, type)) 52137d1aeeeSChris Mason wait_current_trans(root); 522a22285a6SYan, Zheng 523a4abeea4SJosef Bacik do { 524354aa0fbSMiao Xie ret = join_transaction(root, type); 525178260b2SMiao Xie if (ret == -EBUSY) { 526a4abeea4SJosef Bacik wait_current_trans(root); 527178260b2SMiao Xie if (unlikely(type == TRANS_ATTACH)) 528178260b2SMiao Xie ret = -ENOENT; 529178260b2SMiao Xie } 530a4abeea4SJosef Bacik } while (ret == -EBUSY); 531a4abeea4SJosef Bacik 532db5b493aSTsutomu Itoh if (ret < 0) { 533354aa0fbSMiao Xie /* We must get the transaction if we are JOIN_NOLOCK. */ 534354aa0fbSMiao Xie BUG_ON(type == TRANS_JOIN_NOLOCK); 535843fcf35SMiao Xie goto join_fail; 536db5b493aSTsutomu Itoh } 5370f7d52f4SChris Mason 538a22285a6SYan, Zheng cur_trans = root->fs_info->running_transaction; 539a22285a6SYan, Zheng 540a22285a6SYan, Zheng h->transid = cur_trans->transid; 541a22285a6SYan, Zheng h->transaction = cur_trans; 542d13603efSArne Jansen h->root = root; 5432a1eb461SJosef Bacik h->use_count = 1; 544a698d075SMiao Xie h->type = type; 545d9a0540aSFilipe Manana h->can_flush_pending_bgs = true; 546bed92eaeSArne Jansen INIT_LIST_HEAD(&h->qgroup_ref_list); 547ea658badSJosef Bacik INIT_LIST_HEAD(&h->new_bgs); 54850d9aa99SJosef Bacik INIT_LIST_HEAD(&h->ordered); 549b7ec40d7SChris Mason 550a22285a6SYan, Zheng smp_mb(); 5514a9d8bdeSMiao Xie if (cur_trans->state >= TRANS_STATE_BLOCKED && 5524a9d8bdeSMiao Xie may_wait_transaction(root, type)) { 553abdd2e80SFilipe Manana current->journal_info = h; 554a22285a6SYan, Zheng btrfs_commit_transaction(h, root); 555a22285a6SYan, Zheng goto again; 556a22285a6SYan, Zheng } 5579ed74f2dSJosef Bacik 558b5009945SJosef Bacik if (num_bytes) { 5598c2a3ca2SJosef Bacik trace_btrfs_space_reservation(root->fs_info, "transaction", 5602bcc0328SLiu Bo h->transid, num_bytes, 1); 561b5009945SJosef Bacik h->block_rsv = &root->fs_info->trans_block_rsv; 562b5009945SJosef Bacik h->bytes_reserved = num_bytes; 56320dd2cbfSMiao Xie h->reloc_reserved = reloc_reserved; 564a22285a6SYan, Zheng } 5654b824906SMiao Xie h->qgroup_reserved = qgroup_reserved; 566a22285a6SYan, Zheng 5672a1eb461SJosef Bacik got_it: 568a4abeea4SJosef Bacik btrfs_record_root_in_trans(h, root); 569a22285a6SYan, Zheng 570a22285a6SYan, Zheng if (!current->journal_info && type != TRANS_USERSPACE) 571a22285a6SYan, Zheng current->journal_info = h; 57279154b1bSChris Mason return h; 573843fcf35SMiao Xie 574843fcf35SMiao Xie join_fail: 5750860adfdSMiao Xie if (type & __TRANS_FREEZABLE) 576843fcf35SMiao Xie sb_end_intwrite(root->fs_info->sb); 577843fcf35SMiao Xie kmem_cache_free(btrfs_trans_handle_cachep, h); 578843fcf35SMiao Xie alloc_fail: 579843fcf35SMiao Xie if (num_bytes) 580843fcf35SMiao Xie btrfs_block_rsv_release(root, &root->fs_info->trans_block_rsv, 581843fcf35SMiao Xie num_bytes); 582843fcf35SMiao Xie reserve_fail: 583843fcf35SMiao Xie if (qgroup_reserved) 584843fcf35SMiao Xie btrfs_qgroup_free(root, qgroup_reserved); 585843fcf35SMiao Xie return ERR_PTR(ret); 58679154b1bSChris Mason } 58779154b1bSChris Mason 588f9295749SChris Mason struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root, 5895aed1dd8SAlexandru Moise unsigned int num_items) 590f9295749SChris Mason { 59108e007d2SMiao Xie return start_transaction(root, num_items, TRANS_START, 59208e007d2SMiao Xie BTRFS_RESERVE_FLUSH_ALL); 593f9295749SChris Mason } 5948407aa46SMiao Xie 59508e007d2SMiao Xie struct btrfs_trans_handle *btrfs_start_transaction_lflush( 5965aed1dd8SAlexandru Moise struct btrfs_root *root, 5975aed1dd8SAlexandru Moise unsigned int num_items) 5988407aa46SMiao Xie { 59908e007d2SMiao Xie return start_transaction(root, num_items, TRANS_START, 60008e007d2SMiao Xie BTRFS_RESERVE_FLUSH_LIMIT); 6018407aa46SMiao Xie } 6028407aa46SMiao Xie 6037a7eaa40SJosef Bacik struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root) 604f9295749SChris Mason { 6058407aa46SMiao Xie return start_transaction(root, 0, TRANS_JOIN, 0); 606f9295749SChris Mason } 607f9295749SChris Mason 6087a7eaa40SJosef Bacik struct btrfs_trans_handle *btrfs_join_transaction_nolock(struct btrfs_root *root) 6090af3d00bSJosef Bacik { 6108407aa46SMiao Xie return start_transaction(root, 0, TRANS_JOIN_NOLOCK, 0); 6110af3d00bSJosef Bacik } 6120af3d00bSJosef Bacik 6137a7eaa40SJosef Bacik struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *root) 6149ca9ee09SSage Weil { 6158407aa46SMiao Xie return start_transaction(root, 0, TRANS_USERSPACE, 0); 6169ca9ee09SSage Weil } 6179ca9ee09SSage Weil 618d4edf39bSMiao Xie /* 619d4edf39bSMiao Xie * btrfs_attach_transaction() - catch the running transaction 620d4edf39bSMiao Xie * 621d4edf39bSMiao Xie * It is used when we want to commit the current the transaction, but 622d4edf39bSMiao Xie * don't want to start a new one. 623d4edf39bSMiao Xie * 624d4edf39bSMiao Xie * Note: If this function return -ENOENT, it just means there is no 625d4edf39bSMiao Xie * running transaction. But it is possible that the inactive transaction 626d4edf39bSMiao Xie * is still in the memory, not fully on disk. If you hope there is no 627d4edf39bSMiao Xie * inactive transaction in the fs when -ENOENT is returned, you should 628d4edf39bSMiao Xie * invoke 629d4edf39bSMiao Xie * btrfs_attach_transaction_barrier() 630d4edf39bSMiao Xie */ 631354aa0fbSMiao Xie struct btrfs_trans_handle *btrfs_attach_transaction(struct btrfs_root *root) 63260376ce4SJosef Bacik { 633354aa0fbSMiao Xie return start_transaction(root, 0, TRANS_ATTACH, 0); 63460376ce4SJosef Bacik } 63560376ce4SJosef Bacik 636d4edf39bSMiao Xie /* 63790b6d283SWang Sheng-Hui * btrfs_attach_transaction_barrier() - catch the running transaction 638d4edf39bSMiao Xie * 639d4edf39bSMiao Xie * It is similar to the above function, the differentia is this one 640d4edf39bSMiao Xie * will wait for all the inactive transactions until they fully 641d4edf39bSMiao Xie * complete. 642d4edf39bSMiao Xie */ 643d4edf39bSMiao Xie struct btrfs_trans_handle * 644d4edf39bSMiao Xie btrfs_attach_transaction_barrier(struct btrfs_root *root) 645d4edf39bSMiao Xie { 646d4edf39bSMiao Xie struct btrfs_trans_handle *trans; 647d4edf39bSMiao Xie 648d4edf39bSMiao Xie trans = start_transaction(root, 0, TRANS_ATTACH, 0); 649d4edf39bSMiao Xie if (IS_ERR(trans) && PTR_ERR(trans) == -ENOENT) 650d4edf39bSMiao Xie btrfs_wait_for_commit(root, 0); 651d4edf39bSMiao Xie 652d4edf39bSMiao Xie return trans; 653d4edf39bSMiao Xie } 654d4edf39bSMiao Xie 655d352ac68SChris Mason /* wait for a transaction commit to be fully complete */ 656b9c8300cSLi Zefan static noinline void wait_for_commit(struct btrfs_root *root, 65789ce8a63SChris Mason struct btrfs_transaction *commit) 65889ce8a63SChris Mason { 6594a9d8bdeSMiao Xie wait_event(commit->commit_wait, commit->state == TRANS_STATE_COMPLETED); 66089ce8a63SChris Mason } 66189ce8a63SChris Mason 66246204592SSage Weil int btrfs_wait_for_commit(struct btrfs_root *root, u64 transid) 66346204592SSage Weil { 66446204592SSage Weil struct btrfs_transaction *cur_trans = NULL, *t; 6658cd2807fSMiao Xie int ret = 0; 66646204592SSage Weil 66746204592SSage Weil if (transid) { 66846204592SSage Weil if (transid <= root->fs_info->last_trans_committed) 669a4abeea4SJosef Bacik goto out; 67046204592SSage Weil 67146204592SSage Weil /* find specified transaction */ 672a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 67346204592SSage Weil list_for_each_entry(t, &root->fs_info->trans_list, list) { 67446204592SSage Weil if (t->transid == transid) { 67546204592SSage Weil cur_trans = t; 676a4abeea4SJosef Bacik atomic_inc(&cur_trans->use_count); 6778cd2807fSMiao Xie ret = 0; 67846204592SSage Weil break; 67946204592SSage Weil } 6808cd2807fSMiao Xie if (t->transid > transid) { 6818cd2807fSMiao Xie ret = 0; 68246204592SSage Weil break; 68346204592SSage Weil } 6848cd2807fSMiao Xie } 685a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 68642383020SSage Weil 68742383020SSage Weil /* 68842383020SSage Weil * The specified transaction doesn't exist, or we 68942383020SSage Weil * raced with btrfs_commit_transaction 69042383020SSage Weil */ 69142383020SSage Weil if (!cur_trans) { 69242383020SSage Weil if (transid > root->fs_info->last_trans_committed) 69342383020SSage Weil ret = -EINVAL; 6948cd2807fSMiao Xie goto out; 69542383020SSage Weil } 69646204592SSage Weil } else { 69746204592SSage Weil /* find newest transaction that is committing | committed */ 698a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 69946204592SSage Weil list_for_each_entry_reverse(t, &root->fs_info->trans_list, 70046204592SSage Weil list) { 7014a9d8bdeSMiao Xie if (t->state >= TRANS_STATE_COMMIT_START) { 7024a9d8bdeSMiao Xie if (t->state == TRANS_STATE_COMPLETED) 7033473f3c0SJosef Bacik break; 70446204592SSage Weil cur_trans = t; 705a4abeea4SJosef Bacik atomic_inc(&cur_trans->use_count); 70646204592SSage Weil break; 70746204592SSage Weil } 70846204592SSage Weil } 709a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 71046204592SSage Weil if (!cur_trans) 711a4abeea4SJosef Bacik goto out; /* nothing committing|committed */ 71246204592SSage Weil } 71346204592SSage Weil 71446204592SSage Weil wait_for_commit(root, cur_trans); 715724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 716a4abeea4SJosef Bacik out: 71746204592SSage Weil return ret; 71846204592SSage Weil } 71946204592SSage Weil 72037d1aeeeSChris Mason void btrfs_throttle(struct btrfs_root *root) 72137d1aeeeSChris Mason { 722a4abeea4SJosef Bacik if (!atomic_read(&root->fs_info->open_ioctl_trans)) 72337d1aeeeSChris Mason wait_current_trans(root); 72437d1aeeeSChris Mason } 72537d1aeeeSChris Mason 7268929ecfaSYan, Zheng static int should_end_transaction(struct btrfs_trans_handle *trans, 7278929ecfaSYan, Zheng struct btrfs_root *root) 7288929ecfaSYan, Zheng { 7291be41b78SJosef Bacik if (root->fs_info->global_block_rsv.space_info->full && 7300a2b2a84SJosef Bacik btrfs_check_space_for_delayed_refs(trans, root)) 7311be41b78SJosef Bacik return 1; 73236ba022aSJosef Bacik 7331be41b78SJosef Bacik return !!btrfs_block_rsv_check(root, &root->fs_info->global_block_rsv, 5); 7348929ecfaSYan, Zheng } 7358929ecfaSYan, Zheng 7368929ecfaSYan, Zheng int btrfs_should_end_transaction(struct btrfs_trans_handle *trans, 7378929ecfaSYan, Zheng struct btrfs_root *root) 7388929ecfaSYan, Zheng { 7398929ecfaSYan, Zheng struct btrfs_transaction *cur_trans = trans->transaction; 7408929ecfaSYan, Zheng int updates; 74149b25e05SJeff Mahoney int err; 7428929ecfaSYan, Zheng 743a4abeea4SJosef Bacik smp_mb(); 7444a9d8bdeSMiao Xie if (cur_trans->state >= TRANS_STATE_BLOCKED || 7454a9d8bdeSMiao Xie cur_trans->delayed_refs.flushing) 7468929ecfaSYan, Zheng return 1; 7478929ecfaSYan, Zheng 7488929ecfaSYan, Zheng updates = trans->delayed_ref_updates; 7498929ecfaSYan, Zheng trans->delayed_ref_updates = 0; 75049b25e05SJeff Mahoney if (updates) { 75128ed1345SChris Mason err = btrfs_run_delayed_refs(trans, root, updates * 2); 75249b25e05SJeff Mahoney if (err) /* Error code will also eval true */ 75349b25e05SJeff Mahoney return err; 75449b25e05SJeff Mahoney } 7558929ecfaSYan, Zheng 7568929ecfaSYan, Zheng return should_end_transaction(trans, root); 7578929ecfaSYan, Zheng } 7588929ecfaSYan, Zheng 75989ce8a63SChris Mason static int __btrfs_end_transaction(struct btrfs_trans_handle *trans, 760a698d075SMiao Xie struct btrfs_root *root, int throttle) 76179154b1bSChris Mason { 7628929ecfaSYan, Zheng struct btrfs_transaction *cur_trans = trans->transaction; 763ab78c84dSChris Mason struct btrfs_fs_info *info = root->fs_info; 7641be41b78SJosef Bacik unsigned long cur = trans->delayed_ref_updates; 765a698d075SMiao Xie int lock = (trans->type != TRANS_JOIN_NOLOCK); 7664edc2ca3SDave Jones int err = 0; 767a79b7d4bSChris Mason int must_run_delayed_refs = 0; 768d6e4a428SChris Mason 7693bbb24b2SJosef Bacik if (trans->use_count > 1) { 7703bbb24b2SJosef Bacik trans->use_count--; 7712a1eb461SJosef Bacik trans->block_rsv = trans->orig_rsv; 7722a1eb461SJosef Bacik return 0; 7732a1eb461SJosef Bacik } 7742a1eb461SJosef Bacik 775b24e03dbSJosef Bacik btrfs_trans_release_metadata(trans, root); 7764c13d758SJosef Bacik trans->block_rsv = NULL; 777c5567237SArne Jansen 778ea658badSJosef Bacik if (!list_empty(&trans->new_bgs)) 779ea658badSJosef Bacik btrfs_create_pending_block_groups(trans, root); 780ea658badSJosef Bacik 78150d9aa99SJosef Bacik if (!list_empty(&trans->ordered)) { 78250d9aa99SJosef Bacik spin_lock(&info->trans_lock); 783d3efe084SFilipe Manana list_splice_init(&trans->ordered, &cur_trans->pending_ordered); 78450d9aa99SJosef Bacik spin_unlock(&info->trans_lock); 78550d9aa99SJosef Bacik } 78650d9aa99SJosef Bacik 787c3e69d58SChris Mason trans->delayed_ref_updates = 0; 788a79b7d4bSChris Mason if (!trans->sync) { 789a79b7d4bSChris Mason must_run_delayed_refs = 790a79b7d4bSChris Mason btrfs_should_throttle_delayed_refs(trans, root); 7910a2b2a84SJosef Bacik cur = max_t(unsigned long, cur, 32); 792a79b7d4bSChris Mason 793a79b7d4bSChris Mason /* 794a79b7d4bSChris Mason * don't make the caller wait if they are from a NOLOCK 795a79b7d4bSChris Mason * or ATTACH transaction, it will deadlock with commit 796a79b7d4bSChris Mason */ 797a79b7d4bSChris Mason if (must_run_delayed_refs == 1 && 798a79b7d4bSChris Mason (trans->type & (__TRANS_JOIN_NOLOCK | __TRANS_ATTACH))) 799a79b7d4bSChris Mason must_run_delayed_refs = 2; 80056bec294SChris Mason } 801bb721703SChris Mason 802fcebe456SJosef Bacik if (trans->qgroup_reserved) { 803fcebe456SJosef Bacik /* 804fcebe456SJosef Bacik * the same root has to be passed here between start_transaction 805fcebe456SJosef Bacik * and end_transaction. Subvolume quota depends on this. 806fcebe456SJosef Bacik */ 807fcebe456SJosef Bacik btrfs_qgroup_free(trans->root, trans->qgroup_reserved); 808fcebe456SJosef Bacik trans->qgroup_reserved = 0; 809fcebe456SJosef Bacik } 810fcebe456SJosef Bacik 8110e721106SJosef Bacik btrfs_trans_release_metadata(trans, root); 8120e721106SJosef Bacik trans->block_rsv = NULL; 81356bec294SChris Mason 814ea658badSJosef Bacik if (!list_empty(&trans->new_bgs)) 815ea658badSJosef Bacik btrfs_create_pending_block_groups(trans, root); 816ea658badSJosef Bacik 8174fbcdf66SFilipe Manana btrfs_trans_release_chunk_metadata(trans); 8184fbcdf66SFilipe Manana 819a4abeea4SJosef Bacik if (lock && !atomic_read(&root->fs_info->open_ioctl_trans) && 8204a9d8bdeSMiao Xie should_end_transaction(trans, root) && 8214a9d8bdeSMiao Xie ACCESS_ONCE(cur_trans->state) == TRANS_STATE_RUNNING) { 8224a9d8bdeSMiao Xie spin_lock(&info->trans_lock); 8234a9d8bdeSMiao Xie if (cur_trans->state == TRANS_STATE_RUNNING) 8244a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_BLOCKED; 8254a9d8bdeSMiao Xie spin_unlock(&info->trans_lock); 826a4abeea4SJosef Bacik } 8278929ecfaSYan, Zheng 8284a9d8bdeSMiao Xie if (lock && ACCESS_ONCE(cur_trans->state) == TRANS_STATE_BLOCKED) { 8293bbb24b2SJosef Bacik if (throttle) 8308929ecfaSYan, Zheng return btrfs_commit_transaction(trans, root); 8313bbb24b2SJosef Bacik else 8328929ecfaSYan, Zheng wake_up_process(info->transaction_kthread); 8338929ecfaSYan, Zheng } 8348929ecfaSYan, Zheng 8350860adfdSMiao Xie if (trans->type & __TRANS_FREEZABLE) 8366df7881aSJosef Bacik sb_end_intwrite(root->fs_info->sb); 8376df7881aSJosef Bacik 8388929ecfaSYan, Zheng WARN_ON(cur_trans != info->running_transaction); 83913c5a93eSJosef Bacik WARN_ON(atomic_read(&cur_trans->num_writers) < 1); 84013c5a93eSJosef Bacik atomic_dec(&cur_trans->num_writers); 8410860adfdSMiao Xie extwriter_counter_dec(cur_trans, trans->type); 84289ce8a63SChris Mason 84399d16cbcSSage Weil smp_mb(); 84479154b1bSChris Mason if (waitqueue_active(&cur_trans->writer_wait)) 84579154b1bSChris Mason wake_up(&cur_trans->writer_wait); 846724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 8479ed74f2dSJosef Bacik 8489ed74f2dSJosef Bacik if (current->journal_info == trans) 8499ed74f2dSJosef Bacik current->journal_info = NULL; 850ab78c84dSChris Mason 85124bbcf04SYan, Zheng if (throttle) 85224bbcf04SYan, Zheng btrfs_run_delayed_iputs(root); 85324bbcf04SYan, Zheng 85449b25e05SJeff Mahoney if (trans->aborted || 8554e121c06SJosef Bacik test_bit(BTRFS_FS_STATE_ERROR, &root->fs_info->fs_state)) { 8564e121c06SJosef Bacik wake_up_process(info->transaction_kthread); 8574edc2ca3SDave Jones err = -EIO; 8584e121c06SJosef Bacik } 859edf39272SJan Schmidt assert_qgroups_uptodate(trans); 86049b25e05SJeff Mahoney 8614edc2ca3SDave Jones kmem_cache_free(btrfs_trans_handle_cachep, trans); 862a79b7d4bSChris Mason if (must_run_delayed_refs) { 863a79b7d4bSChris Mason btrfs_async_run_delayed_refs(root, cur, 864a79b7d4bSChris Mason must_run_delayed_refs == 1); 865a79b7d4bSChris Mason } 8664edc2ca3SDave Jones return err; 86779154b1bSChris Mason } 86879154b1bSChris Mason 86989ce8a63SChris Mason int btrfs_end_transaction(struct btrfs_trans_handle *trans, 87089ce8a63SChris Mason struct btrfs_root *root) 87189ce8a63SChris Mason { 87298ad43beSWang Shilong return __btrfs_end_transaction(trans, root, 0); 87389ce8a63SChris Mason } 87489ce8a63SChris Mason 87589ce8a63SChris Mason int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans, 87689ce8a63SChris Mason struct btrfs_root *root) 87789ce8a63SChris Mason { 87898ad43beSWang Shilong return __btrfs_end_transaction(trans, root, 1); 87916cdcec7SMiao Xie } 88016cdcec7SMiao Xie 881d352ac68SChris Mason /* 882d352ac68SChris Mason * when btree blocks are allocated, they have some corresponding bits set for 883d352ac68SChris Mason * them in one of two extent_io trees. This is used to make sure all of 884690587d1SChris Mason * those extents are sent to disk but does not wait on them 885d352ac68SChris Mason */ 886690587d1SChris Mason int btrfs_write_marked_extents(struct btrfs_root *root, 8878cef4e16SYan, Zheng struct extent_io_tree *dirty_pages, int mark) 88879154b1bSChris Mason { 889777e6bd7SChris Mason int err = 0; 8907c4452b9SChris Mason int werr = 0; 8911728366eSJosef Bacik struct address_space *mapping = root->fs_info->btree_inode->i_mapping; 892e6138876SJosef Bacik struct extent_state *cached_state = NULL; 893777e6bd7SChris Mason u64 start = 0; 8945f39d397SChris Mason u64 end; 8957c4452b9SChris Mason 8961728366eSJosef Bacik while (!find_first_extent_bit(dirty_pages, start, &start, &end, 897e6138876SJosef Bacik mark, &cached_state)) { 898663dfbb0SFilipe Manana bool wait_writeback = false; 899663dfbb0SFilipe Manana 900663dfbb0SFilipe Manana err = convert_extent_bit(dirty_pages, start, end, 901663dfbb0SFilipe Manana EXTENT_NEED_WAIT, 902e6138876SJosef Bacik mark, &cached_state, GFP_NOFS); 903663dfbb0SFilipe Manana /* 904663dfbb0SFilipe Manana * convert_extent_bit can return -ENOMEM, which is most of the 905663dfbb0SFilipe Manana * time a temporary error. So when it happens, ignore the error 906663dfbb0SFilipe Manana * and wait for writeback of this range to finish - because we 907663dfbb0SFilipe Manana * failed to set the bit EXTENT_NEED_WAIT for the range, a call 908663dfbb0SFilipe Manana * to btrfs_wait_marked_extents() would not know that writeback 909663dfbb0SFilipe Manana * for this range started and therefore wouldn't wait for it to 910663dfbb0SFilipe Manana * finish - we don't want to commit a superblock that points to 911663dfbb0SFilipe Manana * btree nodes/leafs for which writeback hasn't finished yet 912663dfbb0SFilipe Manana * (and without errors). 913663dfbb0SFilipe Manana * We cleanup any entries left in the io tree when committing 914663dfbb0SFilipe Manana * the transaction (through clear_btree_io_tree()). 915663dfbb0SFilipe Manana */ 916663dfbb0SFilipe Manana if (err == -ENOMEM) { 917663dfbb0SFilipe Manana err = 0; 918663dfbb0SFilipe Manana wait_writeback = true; 919663dfbb0SFilipe Manana } 920663dfbb0SFilipe Manana if (!err) 9211728366eSJosef Bacik err = filemap_fdatawrite_range(mapping, start, end); 9227c4452b9SChris Mason if (err) 9237c4452b9SChris Mason werr = err; 924663dfbb0SFilipe Manana else if (wait_writeback) 925663dfbb0SFilipe Manana werr = filemap_fdatawait_range(mapping, start, end); 926e38e2ed7SFilipe Manana free_extent_state(cached_state); 927663dfbb0SFilipe Manana cached_state = NULL; 9281728366eSJosef Bacik cond_resched(); 9291728366eSJosef Bacik start = end + 1; 9307c4452b9SChris Mason } 931690587d1SChris Mason return werr; 932690587d1SChris Mason } 933690587d1SChris Mason 934690587d1SChris Mason /* 935690587d1SChris Mason * when btree blocks are allocated, they have some corresponding bits set for 936690587d1SChris Mason * them in one of two extent_io trees. This is used to make sure all of 937690587d1SChris Mason * those extents are on disk for transaction or log commit. We wait 938690587d1SChris Mason * on all the pages and clear them from the dirty pages state tree 939690587d1SChris Mason */ 940690587d1SChris Mason int btrfs_wait_marked_extents(struct btrfs_root *root, 9418cef4e16SYan, Zheng struct extent_io_tree *dirty_pages, int mark) 942690587d1SChris Mason { 943690587d1SChris Mason int err = 0; 944690587d1SChris Mason int werr = 0; 9451728366eSJosef Bacik struct address_space *mapping = root->fs_info->btree_inode->i_mapping; 946e6138876SJosef Bacik struct extent_state *cached_state = NULL; 947690587d1SChris Mason u64 start = 0; 948690587d1SChris Mason u64 end; 949656f30dbSFilipe Manana struct btrfs_inode *btree_ino = BTRFS_I(root->fs_info->btree_inode); 950656f30dbSFilipe Manana bool errors = false; 951690587d1SChris Mason 9521728366eSJosef Bacik while (!find_first_extent_bit(dirty_pages, start, &start, &end, 953e6138876SJosef Bacik EXTENT_NEED_WAIT, &cached_state)) { 954663dfbb0SFilipe Manana /* 955663dfbb0SFilipe Manana * Ignore -ENOMEM errors returned by clear_extent_bit(). 956663dfbb0SFilipe Manana * When committing the transaction, we'll remove any entries 957663dfbb0SFilipe Manana * left in the io tree. For a log commit, we don't remove them 958663dfbb0SFilipe Manana * after committing the log because the tree can be accessed 959663dfbb0SFilipe Manana * concurrently - we do it only at transaction commit time when 960663dfbb0SFilipe Manana * it's safe to do it (through clear_btree_io_tree()). 961663dfbb0SFilipe Manana */ 962663dfbb0SFilipe Manana err = clear_extent_bit(dirty_pages, start, end, 963663dfbb0SFilipe Manana EXTENT_NEED_WAIT, 964e6138876SJosef Bacik 0, 0, &cached_state, GFP_NOFS); 965663dfbb0SFilipe Manana if (err == -ENOMEM) 966663dfbb0SFilipe Manana err = 0; 967663dfbb0SFilipe Manana if (!err) 9681728366eSJosef Bacik err = filemap_fdatawait_range(mapping, start, end); 969777e6bd7SChris Mason if (err) 970777e6bd7SChris Mason werr = err; 971e38e2ed7SFilipe Manana free_extent_state(cached_state); 972e38e2ed7SFilipe Manana cached_state = NULL; 973777e6bd7SChris Mason cond_resched(); 9741728366eSJosef Bacik start = end + 1; 975777e6bd7SChris Mason } 9767c4452b9SChris Mason if (err) 9777c4452b9SChris Mason werr = err; 978656f30dbSFilipe Manana 979656f30dbSFilipe Manana if (root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID) { 980656f30dbSFilipe Manana if ((mark & EXTENT_DIRTY) && 981656f30dbSFilipe Manana test_and_clear_bit(BTRFS_INODE_BTREE_LOG1_ERR, 982656f30dbSFilipe Manana &btree_ino->runtime_flags)) 983656f30dbSFilipe Manana errors = true; 984656f30dbSFilipe Manana 985656f30dbSFilipe Manana if ((mark & EXTENT_NEW) && 986656f30dbSFilipe Manana test_and_clear_bit(BTRFS_INODE_BTREE_LOG2_ERR, 987656f30dbSFilipe Manana &btree_ino->runtime_flags)) 988656f30dbSFilipe Manana errors = true; 989656f30dbSFilipe Manana } else { 990656f30dbSFilipe Manana if (test_and_clear_bit(BTRFS_INODE_BTREE_ERR, 991656f30dbSFilipe Manana &btree_ino->runtime_flags)) 992656f30dbSFilipe Manana errors = true; 993656f30dbSFilipe Manana } 994656f30dbSFilipe Manana 995656f30dbSFilipe Manana if (errors && !werr) 996656f30dbSFilipe Manana werr = -EIO; 997656f30dbSFilipe Manana 9987c4452b9SChris Mason return werr; 99979154b1bSChris Mason } 100079154b1bSChris Mason 1001690587d1SChris Mason /* 1002690587d1SChris Mason * when btree blocks are allocated, they have some corresponding bits set for 1003690587d1SChris Mason * them in one of two extent_io trees. This is used to make sure all of 1004690587d1SChris Mason * those extents are on disk for transaction or log commit 1005690587d1SChris Mason */ 1006171170c1SSergei Trofimovich static int btrfs_write_and_wait_marked_extents(struct btrfs_root *root, 10078cef4e16SYan, Zheng struct extent_io_tree *dirty_pages, int mark) 1008690587d1SChris Mason { 1009690587d1SChris Mason int ret; 1010690587d1SChris Mason int ret2; 1011c6adc9ccSMiao Xie struct blk_plug plug; 1012690587d1SChris Mason 1013c6adc9ccSMiao Xie blk_start_plug(&plug); 10148cef4e16SYan, Zheng ret = btrfs_write_marked_extents(root, dirty_pages, mark); 1015c6adc9ccSMiao Xie blk_finish_plug(&plug); 10168cef4e16SYan, Zheng ret2 = btrfs_wait_marked_extents(root, dirty_pages, mark); 1017bf0da8c1SChris Mason 1018bf0da8c1SChris Mason if (ret) 1019bf0da8c1SChris Mason return ret; 1020bf0da8c1SChris Mason if (ret2) 1021bf0da8c1SChris Mason return ret2; 1022bf0da8c1SChris Mason return 0; 1023690587d1SChris Mason } 1024690587d1SChris Mason 1025663dfbb0SFilipe Manana static int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans, 1026d0c803c4SChris Mason struct btrfs_root *root) 1027d0c803c4SChris Mason { 1028663dfbb0SFilipe Manana int ret; 1029663dfbb0SFilipe Manana 1030663dfbb0SFilipe Manana ret = btrfs_write_and_wait_marked_extents(root, 10318cef4e16SYan, Zheng &trans->transaction->dirty_pages, 10328cef4e16SYan, Zheng EXTENT_DIRTY); 1033663dfbb0SFilipe Manana clear_btree_io_tree(&trans->transaction->dirty_pages); 1034663dfbb0SFilipe Manana 1035663dfbb0SFilipe Manana return ret; 1036d0c803c4SChris Mason } 1037d0c803c4SChris Mason 1038d352ac68SChris Mason /* 1039d352ac68SChris Mason * this is used to update the root pointer in the tree of tree roots. 1040d352ac68SChris Mason * 1041d352ac68SChris Mason * But, in the case of the extent allocation tree, updating the root 1042d352ac68SChris Mason * pointer may allocate blocks which may change the root of the extent 1043d352ac68SChris Mason * allocation tree. 1044d352ac68SChris Mason * 1045d352ac68SChris Mason * So, this loops and repeats and makes sure the cowonly root didn't 1046d352ac68SChris Mason * change while the root pointer was being updated in the metadata. 1047d352ac68SChris Mason */ 10480b86a832SChris Mason static int update_cowonly_root(struct btrfs_trans_handle *trans, 104979154b1bSChris Mason struct btrfs_root *root) 105079154b1bSChris Mason { 105179154b1bSChris Mason int ret; 10520b86a832SChris Mason u64 old_root_bytenr; 105386b9f2ecSYan, Zheng u64 old_root_used; 10540b86a832SChris Mason struct btrfs_root *tree_root = root->fs_info->tree_root; 105579154b1bSChris Mason 105686b9f2ecSYan, Zheng old_root_used = btrfs_root_used(&root->root_item); 105756bec294SChris Mason 105879154b1bSChris Mason while (1) { 10590b86a832SChris Mason old_root_bytenr = btrfs_root_bytenr(&root->root_item); 106086b9f2ecSYan, Zheng if (old_root_bytenr == root->node->start && 1061ea526d18SJosef Bacik old_root_used == btrfs_root_used(&root->root_item)) 106279154b1bSChris Mason break; 106387ef2bb4SChris Mason 10645d4f98a2SYan Zheng btrfs_set_root_node(&root->root_item, root->node); 106579154b1bSChris Mason ret = btrfs_update_root(trans, tree_root, 10660b86a832SChris Mason &root->root_key, 10670b86a832SChris Mason &root->root_item); 106849b25e05SJeff Mahoney if (ret) 106949b25e05SJeff Mahoney return ret; 107056bec294SChris Mason 107186b9f2ecSYan, Zheng old_root_used = btrfs_root_used(&root->root_item); 1072e7070be1SJosef Bacik } 1073276e680dSYan Zheng 10740b86a832SChris Mason return 0; 10750b86a832SChris Mason } 10760b86a832SChris Mason 1077d352ac68SChris Mason /* 1078d352ac68SChris Mason * update all the cowonly tree roots on disk 107949b25e05SJeff Mahoney * 108049b25e05SJeff Mahoney * The error handling in this function may not be obvious. Any of the 108149b25e05SJeff Mahoney * failures will cause the file system to go offline. We still need 108249b25e05SJeff Mahoney * to clean up the delayed refs. 1083d352ac68SChris Mason */ 10845d4f98a2SYan Zheng static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans, 10850b86a832SChris Mason struct btrfs_root *root) 10860b86a832SChris Mason { 10870b86a832SChris Mason struct btrfs_fs_info *fs_info = root->fs_info; 1088ea526d18SJosef Bacik struct list_head *dirty_bgs = &trans->transaction->dirty_bgs; 10891bbc621eSChris Mason struct list_head *io_bgs = &trans->transaction->io_bgs; 10900b86a832SChris Mason struct list_head *next; 109184234f3aSYan Zheng struct extent_buffer *eb; 109256bec294SChris Mason int ret; 109384234f3aSYan Zheng 109484234f3aSYan Zheng eb = btrfs_lock_root_node(fs_info->tree_root); 109549b25e05SJeff Mahoney ret = btrfs_cow_block(trans, fs_info->tree_root, eb, NULL, 109649b25e05SJeff Mahoney 0, &eb); 109784234f3aSYan Zheng btrfs_tree_unlock(eb); 109884234f3aSYan Zheng free_extent_buffer(eb); 10990b86a832SChris Mason 110049b25e05SJeff Mahoney if (ret) 110149b25e05SJeff Mahoney return ret; 110249b25e05SJeff Mahoney 110356bec294SChris Mason ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); 110449b25e05SJeff Mahoney if (ret) 110549b25e05SJeff Mahoney return ret; 110687ef2bb4SChris Mason 1107733f4fbbSStefan Behrens ret = btrfs_run_dev_stats(trans, root->fs_info); 1108c16ce190SJosef Bacik if (ret) 1109c16ce190SJosef Bacik return ret; 11108dabb742SStefan Behrens ret = btrfs_run_dev_replace(trans, root->fs_info); 1111c16ce190SJosef Bacik if (ret) 1112c16ce190SJosef Bacik return ret; 1113546adb0dSJan Schmidt ret = btrfs_run_qgroups(trans, root->fs_info); 1114c16ce190SJosef Bacik if (ret) 1115c16ce190SJosef Bacik return ret; 1116546adb0dSJan Schmidt 1117dcdf7f6dSJosef Bacik ret = btrfs_setup_space_cache(trans, root); 1118dcdf7f6dSJosef Bacik if (ret) 1119dcdf7f6dSJosef Bacik return ret; 1120dcdf7f6dSJosef Bacik 1121546adb0dSJan Schmidt /* run_qgroups might have added some more refs */ 1122546adb0dSJan Schmidt ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); 1123c16ce190SJosef Bacik if (ret) 1124c16ce190SJosef Bacik return ret; 1125ea526d18SJosef Bacik again: 11260b86a832SChris Mason while (!list_empty(&fs_info->dirty_cowonly_roots)) { 11270b86a832SChris Mason next = fs_info->dirty_cowonly_roots.next; 11280b86a832SChris Mason list_del_init(next); 11290b86a832SChris Mason root = list_entry(next, struct btrfs_root, dirty_list); 1130e7070be1SJosef Bacik clear_bit(BTRFS_ROOT_DIRTY, &root->state); 113187ef2bb4SChris Mason 11329e351cc8SJosef Bacik if (root != fs_info->extent_root) 11339e351cc8SJosef Bacik list_add_tail(&root->dirty_list, 11349e351cc8SJosef Bacik &trans->transaction->switch_commits); 113549b25e05SJeff Mahoney ret = update_cowonly_root(trans, root); 113649b25e05SJeff Mahoney if (ret) 113749b25e05SJeff Mahoney return ret; 1138ea526d18SJosef Bacik ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); 1139ea526d18SJosef Bacik if (ret) 1140ea526d18SJosef Bacik return ret; 114179154b1bSChris Mason } 1142276e680dSYan Zheng 11431bbc621eSChris Mason while (!list_empty(dirty_bgs) || !list_empty(io_bgs)) { 1144ea526d18SJosef Bacik ret = btrfs_write_dirty_block_groups(trans, root); 1145ea526d18SJosef Bacik if (ret) 1146ea526d18SJosef Bacik return ret; 1147ea526d18SJosef Bacik ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); 1148ea526d18SJosef Bacik if (ret) 1149ea526d18SJosef Bacik return ret; 1150ea526d18SJosef Bacik } 1151ea526d18SJosef Bacik 1152ea526d18SJosef Bacik if (!list_empty(&fs_info->dirty_cowonly_roots)) 1153ea526d18SJosef Bacik goto again; 1154ea526d18SJosef Bacik 11559e351cc8SJosef Bacik list_add_tail(&fs_info->extent_root->dirty_list, 11569e351cc8SJosef Bacik &trans->transaction->switch_commits); 11578dabb742SStefan Behrens btrfs_after_dev_replace_commit(fs_info); 11588dabb742SStefan Behrens 115979154b1bSChris Mason return 0; 116079154b1bSChris Mason } 116179154b1bSChris Mason 1162d352ac68SChris Mason /* 1163d352ac68SChris Mason * dead roots are old snapshots that need to be deleted. This allocates 1164d352ac68SChris Mason * a dirty root struct and adds it into the list of dead roots that need to 1165d352ac68SChris Mason * be deleted 1166d352ac68SChris Mason */ 1167cfad392bSJosef Bacik void btrfs_add_dead_root(struct btrfs_root *root) 11685eda7b5eSChris Mason { 1169a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 1170cfad392bSJosef Bacik if (list_empty(&root->root_list)) 11719d1a2a3aSDavid Sterba list_add_tail(&root->root_list, &root->fs_info->dead_roots); 1172a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 11735eda7b5eSChris Mason } 11745eda7b5eSChris Mason 1175d352ac68SChris Mason /* 11765d4f98a2SYan Zheng * update all the cowonly tree roots on disk 1177d352ac68SChris Mason */ 11785d4f98a2SYan Zheng static noinline int commit_fs_roots(struct btrfs_trans_handle *trans, 11795d4f98a2SYan Zheng struct btrfs_root *root) 11800f7d52f4SChris Mason { 11810f7d52f4SChris Mason struct btrfs_root *gang[8]; 11825d4f98a2SYan Zheng struct btrfs_fs_info *fs_info = root->fs_info; 11830f7d52f4SChris Mason int i; 11840f7d52f4SChris Mason int ret; 118554aa1f4dSChris Mason int err = 0; 118654aa1f4dSChris Mason 1187a4abeea4SJosef Bacik spin_lock(&fs_info->fs_roots_radix_lock); 11880f7d52f4SChris Mason while (1) { 11895d4f98a2SYan Zheng ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix, 11905d4f98a2SYan Zheng (void **)gang, 0, 11910f7d52f4SChris Mason ARRAY_SIZE(gang), 11920f7d52f4SChris Mason BTRFS_ROOT_TRANS_TAG); 11930f7d52f4SChris Mason if (ret == 0) 11940f7d52f4SChris Mason break; 11950f7d52f4SChris Mason for (i = 0; i < ret; i++) { 11960f7d52f4SChris Mason root = gang[i]; 11975d4f98a2SYan Zheng radix_tree_tag_clear(&fs_info->fs_roots_radix, 11982619ba1fSChris Mason (unsigned long)root->root_key.objectid, 11990f7d52f4SChris Mason BTRFS_ROOT_TRANS_TAG); 1200a4abeea4SJosef Bacik spin_unlock(&fs_info->fs_roots_radix_lock); 120131153d81SYan Zheng 1202e02119d5SChris Mason btrfs_free_log(trans, root); 12035d4f98a2SYan Zheng btrfs_update_reloc_root(trans, root); 1204d68fc57bSYan, Zheng btrfs_orphan_commit_root(trans, root); 1205e02119d5SChris Mason 120682d5902dSLi Zefan btrfs_save_ino_cache(root, trans); 120782d5902dSLi Zefan 1208f1ebcc74SLiu Bo /* see comments in should_cow_block() */ 120927cdeb70SMiao Xie clear_bit(BTRFS_ROOT_FORCE_COW, &root->state); 1210c7548af6SChris Mason smp_mb__after_atomic(); 1211f1ebcc74SLiu Bo 1212978d910dSYan Zheng if (root->commit_root != root->node) { 12139e351cc8SJosef Bacik list_add_tail(&root->dirty_list, 12149e351cc8SJosef Bacik &trans->transaction->switch_commits); 1215978d910dSYan Zheng btrfs_set_root_node(&root->root_item, 1216978d910dSYan Zheng root->node); 1217978d910dSYan Zheng } 121831153d81SYan Zheng 12195d4f98a2SYan Zheng err = btrfs_update_root(trans, fs_info->tree_root, 12200f7d52f4SChris Mason &root->root_key, 12210f7d52f4SChris Mason &root->root_item); 1222a4abeea4SJosef Bacik spin_lock(&fs_info->fs_roots_radix_lock); 122354aa1f4dSChris Mason if (err) 122454aa1f4dSChris Mason break; 12250f7d52f4SChris Mason } 12269f3a7427SChris Mason } 1227a4abeea4SJosef Bacik spin_unlock(&fs_info->fs_roots_radix_lock); 122854aa1f4dSChris Mason return err; 12290f7d52f4SChris Mason } 12300f7d52f4SChris Mason 1231d352ac68SChris Mason /* 1232de78b51aSEric Sandeen * defrag a given btree. 1233de78b51aSEric Sandeen * Every leaf in the btree is read and defragged. 1234d352ac68SChris Mason */ 1235de78b51aSEric Sandeen int btrfs_defrag_root(struct btrfs_root *root) 1236e9d0b13bSChris Mason { 1237e9d0b13bSChris Mason struct btrfs_fs_info *info = root->fs_info; 1238e9d0b13bSChris Mason struct btrfs_trans_handle *trans; 12398929ecfaSYan, Zheng int ret; 1240e9d0b13bSChris Mason 124127cdeb70SMiao Xie if (test_and_set_bit(BTRFS_ROOT_DEFRAG_RUNNING, &root->state)) 1242e9d0b13bSChris Mason return 0; 12438929ecfaSYan, Zheng 12446b80053dSChris Mason while (1) { 12458929ecfaSYan, Zheng trans = btrfs_start_transaction(root, 0); 12468929ecfaSYan, Zheng if (IS_ERR(trans)) 12478929ecfaSYan, Zheng return PTR_ERR(trans); 12488929ecfaSYan, Zheng 1249de78b51aSEric Sandeen ret = btrfs_defrag_leaves(trans, root); 12508929ecfaSYan, Zheng 1251e9d0b13bSChris Mason btrfs_end_transaction(trans, root); 1252b53d3f5dSLiu Bo btrfs_btree_balance_dirty(info->tree_root); 1253e9d0b13bSChris Mason cond_resched(); 1254e9d0b13bSChris Mason 12557841cb28SDavid Sterba if (btrfs_fs_closing(root->fs_info) || ret != -EAGAIN) 1256e9d0b13bSChris Mason break; 1257210549ebSDavid Sterba 1258210549ebSDavid Sterba if (btrfs_defrag_cancelled(root->fs_info)) { 1259efe120a0SFrank Holton pr_debug("BTRFS: defrag_root cancelled\n"); 1260210549ebSDavid Sterba ret = -EAGAIN; 1261210549ebSDavid Sterba break; 1262210549ebSDavid Sterba } 1263e9d0b13bSChris Mason } 126427cdeb70SMiao Xie clear_bit(BTRFS_ROOT_DEFRAG_RUNNING, &root->state); 12658929ecfaSYan, Zheng return ret; 1266e9d0b13bSChris Mason } 1267e9d0b13bSChris Mason 1268d352ac68SChris Mason /* 1269d352ac68SChris Mason * new snapshots need to be created at a very specific time in the 1270aec8030aSMiao Xie * transaction commit. This does the actual creation. 1271aec8030aSMiao Xie * 1272aec8030aSMiao Xie * Note: 1273aec8030aSMiao Xie * If the error which may affect the commitment of the current transaction 1274aec8030aSMiao Xie * happens, we should return the error number. If the error which just affect 1275aec8030aSMiao Xie * the creation of the pending snapshots, just return 0. 1276d352ac68SChris Mason */ 127780b6794dSChris Mason static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans, 12783063d29fSChris Mason struct btrfs_fs_info *fs_info, 12793063d29fSChris Mason struct btrfs_pending_snapshot *pending) 12803063d29fSChris Mason { 12813063d29fSChris Mason struct btrfs_key key; 128280b6794dSChris Mason struct btrfs_root_item *new_root_item; 12833063d29fSChris Mason struct btrfs_root *tree_root = fs_info->tree_root; 12843063d29fSChris Mason struct btrfs_root *root = pending->root; 12856bdb72deSSage Weil struct btrfs_root *parent_root; 128698c9942aSLiu Bo struct btrfs_block_rsv *rsv; 12876bdb72deSSage Weil struct inode *parent_inode; 128842874b3dSMiao Xie struct btrfs_path *path; 128942874b3dSMiao Xie struct btrfs_dir_item *dir_item; 1290a22285a6SYan, Zheng struct dentry *dentry; 12913063d29fSChris Mason struct extent_buffer *tmp; 1292925baeddSChris Mason struct extent_buffer *old; 12938ea05e3aSAlexander Block struct timespec cur_time = CURRENT_TIME; 1294aec8030aSMiao Xie int ret = 0; 1295d68fc57bSYan, Zheng u64 to_reserve = 0; 12966bdb72deSSage Weil u64 index = 0; 1297a22285a6SYan, Zheng u64 objectid; 1298b83cc969SLi Zefan u64 root_flags; 12998ea05e3aSAlexander Block uuid_le new_uuid; 13003063d29fSChris Mason 130142874b3dSMiao Xie path = btrfs_alloc_path(); 130242874b3dSMiao Xie if (!path) { 1303aec8030aSMiao Xie pending->error = -ENOMEM; 1304aec8030aSMiao Xie return 0; 130542874b3dSMiao Xie } 130642874b3dSMiao Xie 130780b6794dSChris Mason new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS); 130880b6794dSChris Mason if (!new_root_item) { 1309aec8030aSMiao Xie pending->error = -ENOMEM; 13106fa9700eSMiao Xie goto root_item_alloc_fail; 131180b6794dSChris Mason } 1312a22285a6SYan, Zheng 1313aec8030aSMiao Xie pending->error = btrfs_find_free_objectid(tree_root, &objectid); 1314aec8030aSMiao Xie if (pending->error) 13156fa9700eSMiao Xie goto no_free_objectid; 13163063d29fSChris Mason 1317d6726335SQu Wenruo /* 1318d6726335SQu Wenruo * Make qgroup to skip current new snapshot's qgroupid, as it is 1319d6726335SQu Wenruo * accounted by later btrfs_qgroup_inherit(). 1320d6726335SQu Wenruo */ 1321d6726335SQu Wenruo btrfs_set_skip_qgroup(trans, objectid); 1322d6726335SQu Wenruo 1323147d256eSZhaolei btrfs_reloc_pre_snapshot(pending, &to_reserve); 1324d68fc57bSYan, Zheng 1325d68fc57bSYan, Zheng if (to_reserve > 0) { 1326aec8030aSMiao Xie pending->error = btrfs_block_rsv_add(root, 1327aec8030aSMiao Xie &pending->block_rsv, 132808e007d2SMiao Xie to_reserve, 132908e007d2SMiao Xie BTRFS_RESERVE_NO_FLUSH); 1330aec8030aSMiao Xie if (pending->error) 1331d6726335SQu Wenruo goto clear_skip_qgroup; 1332d68fc57bSYan, Zheng } 1333d68fc57bSYan, Zheng 13343063d29fSChris Mason key.objectid = objectid; 1335a22285a6SYan, Zheng key.offset = (u64)-1; 1336a22285a6SYan, Zheng key.type = BTRFS_ROOT_ITEM_KEY; 13373063d29fSChris Mason 13386fa9700eSMiao Xie rsv = trans->block_rsv; 1339a22285a6SYan, Zheng trans->block_rsv = &pending->block_rsv; 13402382c5ccSLiu Bo trans->bytes_reserved = trans->block_rsv->reserved; 13416bdb72deSSage Weil 1342a22285a6SYan, Zheng dentry = pending->dentry; 1343e9662f70SMiao Xie parent_inode = pending->dir; 1344a22285a6SYan, Zheng parent_root = BTRFS_I(parent_inode)->root; 13457585717fSChris Mason record_root_in_trans(trans, parent_root); 1346a22285a6SYan, Zheng 13476bdb72deSSage Weil /* 13486bdb72deSSage Weil * insert the directory item 13496bdb72deSSage Weil */ 13506bdb72deSSage Weil ret = btrfs_set_inode_index(parent_inode, &index); 135149b25e05SJeff Mahoney BUG_ON(ret); /* -ENOMEM */ 135242874b3dSMiao Xie 135342874b3dSMiao Xie /* check if there is a file/dir which has the same name. */ 135442874b3dSMiao Xie dir_item = btrfs_lookup_dir_item(NULL, parent_root, path, 135542874b3dSMiao Xie btrfs_ino(parent_inode), 135642874b3dSMiao Xie dentry->d_name.name, 135742874b3dSMiao Xie dentry->d_name.len, 0); 135842874b3dSMiao Xie if (dir_item != NULL && !IS_ERR(dir_item)) { 1359fe66a05aSChris Mason pending->error = -EEXIST; 1360aec8030aSMiao Xie goto dir_item_existed; 136142874b3dSMiao Xie } else if (IS_ERR(dir_item)) { 136242874b3dSMiao Xie ret = PTR_ERR(dir_item); 13638732d44fSMiao Xie btrfs_abort_transaction(trans, root, ret); 13648732d44fSMiao Xie goto fail; 136579787eaaSJeff Mahoney } 136642874b3dSMiao Xie btrfs_release_path(path); 13676bdb72deSSage Weil 1368e999376fSChris Mason /* 1369e999376fSChris Mason * pull in the delayed directory update 1370e999376fSChris Mason * and the delayed inode item 1371e999376fSChris Mason * otherwise we corrupt the FS during 1372e999376fSChris Mason * snapshot 1373e999376fSChris Mason */ 1374e999376fSChris Mason ret = btrfs_run_delayed_items(trans, root); 13758732d44fSMiao Xie if (ret) { /* Transaction aborted */ 13768732d44fSMiao Xie btrfs_abort_transaction(trans, root, ret); 13778732d44fSMiao Xie goto fail; 13788732d44fSMiao Xie } 1379e999376fSChris Mason 13807585717fSChris Mason record_root_in_trans(trans, root); 13816bdb72deSSage Weil btrfs_set_root_last_snapshot(&root->root_item, trans->transid); 13826bdb72deSSage Weil memcpy(new_root_item, &root->root_item, sizeof(*new_root_item)); 138308fe4db1SLi Zefan btrfs_check_and_init_root_item(new_root_item); 13846bdb72deSSage Weil 1385b83cc969SLi Zefan root_flags = btrfs_root_flags(new_root_item); 1386b83cc969SLi Zefan if (pending->readonly) 1387b83cc969SLi Zefan root_flags |= BTRFS_ROOT_SUBVOL_RDONLY; 1388b83cc969SLi Zefan else 1389b83cc969SLi Zefan root_flags &= ~BTRFS_ROOT_SUBVOL_RDONLY; 1390b83cc969SLi Zefan btrfs_set_root_flags(new_root_item, root_flags); 1391b83cc969SLi Zefan 13928ea05e3aSAlexander Block btrfs_set_root_generation_v2(new_root_item, 13938ea05e3aSAlexander Block trans->transid); 13948ea05e3aSAlexander Block uuid_le_gen(&new_uuid); 13958ea05e3aSAlexander Block memcpy(new_root_item->uuid, new_uuid.b, BTRFS_UUID_SIZE); 13968ea05e3aSAlexander Block memcpy(new_root_item->parent_uuid, root->root_item.uuid, 13978ea05e3aSAlexander Block BTRFS_UUID_SIZE); 139870023da2SStefan Behrens if (!(root_flags & BTRFS_ROOT_SUBVOL_RDONLY)) { 139970023da2SStefan Behrens memset(new_root_item->received_uuid, 0, 140070023da2SStefan Behrens sizeof(new_root_item->received_uuid)); 14018ea05e3aSAlexander Block memset(&new_root_item->stime, 0, sizeof(new_root_item->stime)); 14028ea05e3aSAlexander Block memset(&new_root_item->rtime, 0, sizeof(new_root_item->rtime)); 14038ea05e3aSAlexander Block btrfs_set_root_stransid(new_root_item, 0); 14048ea05e3aSAlexander Block btrfs_set_root_rtransid(new_root_item, 0); 140570023da2SStefan Behrens } 14063cae210fSQu Wenruo btrfs_set_stack_timespec_sec(&new_root_item->otime, cur_time.tv_sec); 14073cae210fSQu Wenruo btrfs_set_stack_timespec_nsec(&new_root_item->otime, cur_time.tv_nsec); 140870023da2SStefan Behrens btrfs_set_root_otransid(new_root_item, trans->transid); 14098ea05e3aSAlexander Block 1410925baeddSChris Mason old = btrfs_lock_root_node(root); 141149b25e05SJeff Mahoney ret = btrfs_cow_block(trans, root, old, NULL, 0, &old); 141279787eaaSJeff Mahoney if (ret) { 141379787eaaSJeff Mahoney btrfs_tree_unlock(old); 141479787eaaSJeff Mahoney free_extent_buffer(old); 14158732d44fSMiao Xie btrfs_abort_transaction(trans, root, ret); 14168732d44fSMiao Xie goto fail; 141779787eaaSJeff Mahoney } 141849b25e05SJeff Mahoney 14195d4f98a2SYan Zheng btrfs_set_lock_blocking(old); 14203063d29fSChris Mason 142149b25e05SJeff Mahoney ret = btrfs_copy_root(trans, root, old, &tmp, objectid); 142279787eaaSJeff Mahoney /* clean up in any case */ 1423925baeddSChris Mason btrfs_tree_unlock(old); 1424925baeddSChris Mason free_extent_buffer(old); 14258732d44fSMiao Xie if (ret) { 14268732d44fSMiao Xie btrfs_abort_transaction(trans, root, ret); 14278732d44fSMiao Xie goto fail; 14288732d44fSMiao Xie } 1429f1ebcc74SLiu Bo /* see comments in should_cow_block() */ 143027cdeb70SMiao Xie set_bit(BTRFS_ROOT_FORCE_COW, &root->state); 1431f1ebcc74SLiu Bo smp_wmb(); 1432f1ebcc74SLiu Bo 14335d4f98a2SYan Zheng btrfs_set_root_node(new_root_item, tmp); 1434a22285a6SYan, Zheng /* record when the snapshot was created in key.offset */ 1435a22285a6SYan, Zheng key.offset = trans->transid; 1436a22285a6SYan, Zheng ret = btrfs_insert_root(trans, tree_root, &key, new_root_item); 1437925baeddSChris Mason btrfs_tree_unlock(tmp); 14383063d29fSChris Mason free_extent_buffer(tmp); 14398732d44fSMiao Xie if (ret) { 14408732d44fSMiao Xie btrfs_abort_transaction(trans, root, ret); 14418732d44fSMiao Xie goto fail; 14428732d44fSMiao Xie } 14430660b5afSChris Mason 1444a22285a6SYan, Zheng /* 1445a22285a6SYan, Zheng * insert root back/forward references 1446a22285a6SYan, Zheng */ 1447a22285a6SYan, Zheng ret = btrfs_add_root_ref(trans, tree_root, objectid, 1448a22285a6SYan, Zheng parent_root->root_key.objectid, 144933345d01SLi Zefan btrfs_ino(parent_inode), index, 1450a22285a6SYan, Zheng dentry->d_name.name, dentry->d_name.len); 14518732d44fSMiao Xie if (ret) { 14528732d44fSMiao Xie btrfs_abort_transaction(trans, root, ret); 14538732d44fSMiao Xie goto fail; 14548732d44fSMiao Xie } 1455a22285a6SYan, Zheng 1456a22285a6SYan, Zheng key.offset = (u64)-1; 1457a22285a6SYan, Zheng pending->snap = btrfs_read_fs_root_no_name(root->fs_info, &key); 145879787eaaSJeff Mahoney if (IS_ERR(pending->snap)) { 145979787eaaSJeff Mahoney ret = PTR_ERR(pending->snap); 14608732d44fSMiao Xie btrfs_abort_transaction(trans, root, ret); 14618732d44fSMiao Xie goto fail; 146279787eaaSJeff Mahoney } 1463d68fc57bSYan, Zheng 146449b25e05SJeff Mahoney ret = btrfs_reloc_post_snapshot(trans, pending); 14658732d44fSMiao Xie if (ret) { 14668732d44fSMiao Xie btrfs_abort_transaction(trans, root, ret); 14678732d44fSMiao Xie goto fail; 14688732d44fSMiao Xie } 1469361048f5SMiao Xie 1470361048f5SMiao Xie ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); 14718732d44fSMiao Xie if (ret) { 14728732d44fSMiao Xie btrfs_abort_transaction(trans, root, ret); 14738732d44fSMiao Xie goto fail; 14748732d44fSMiao Xie } 147542874b3dSMiao Xie 147642874b3dSMiao Xie ret = btrfs_insert_dir_item(trans, parent_root, 147742874b3dSMiao Xie dentry->d_name.name, dentry->d_name.len, 147842874b3dSMiao Xie parent_inode, &key, 147942874b3dSMiao Xie BTRFS_FT_DIR, index); 148042874b3dSMiao Xie /* We have check then name at the beginning, so it is impossible. */ 14819c52057cSChris Mason BUG_ON(ret == -EEXIST || ret == -EOVERFLOW); 14828732d44fSMiao Xie if (ret) { 14838732d44fSMiao Xie btrfs_abort_transaction(trans, root, ret); 14848732d44fSMiao Xie goto fail; 14858732d44fSMiao Xie } 148642874b3dSMiao Xie 148742874b3dSMiao Xie btrfs_i_size_write(parent_inode, parent_inode->i_size + 148842874b3dSMiao Xie dentry->d_name.len * 2); 148942874b3dSMiao Xie parent_inode->i_mtime = parent_inode->i_ctime = CURRENT_TIME; 1490be6aef60SJosef Bacik ret = btrfs_update_inode_fallback(trans, parent_root, parent_inode); 1491dd5f9615SStefan Behrens if (ret) { 14928732d44fSMiao Xie btrfs_abort_transaction(trans, root, ret); 1493dd5f9615SStefan Behrens goto fail; 1494dd5f9615SStefan Behrens } 1495dd5f9615SStefan Behrens ret = btrfs_uuid_tree_add(trans, fs_info->uuid_root, new_uuid.b, 1496dd5f9615SStefan Behrens BTRFS_UUID_KEY_SUBVOL, objectid); 1497dd5f9615SStefan Behrens if (ret) { 1498dd5f9615SStefan Behrens btrfs_abort_transaction(trans, root, ret); 1499dd5f9615SStefan Behrens goto fail; 1500dd5f9615SStefan Behrens } 1501dd5f9615SStefan Behrens if (!btrfs_is_empty_uuid(new_root_item->received_uuid)) { 1502dd5f9615SStefan Behrens ret = btrfs_uuid_tree_add(trans, fs_info->uuid_root, 1503dd5f9615SStefan Behrens new_root_item->received_uuid, 1504dd5f9615SStefan Behrens BTRFS_UUID_KEY_RECEIVED_SUBVOL, 1505dd5f9615SStefan Behrens objectid); 1506dd5f9615SStefan Behrens if (ret && ret != -EEXIST) { 1507dd5f9615SStefan Behrens btrfs_abort_transaction(trans, root, ret); 1508dd5f9615SStefan Behrens goto fail; 1509dd5f9615SStefan Behrens } 1510dd5f9615SStefan Behrens } 1511d6726335SQu Wenruo 1512d6726335SQu Wenruo ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); 1513d6726335SQu Wenruo if (ret) { 1514d6726335SQu Wenruo btrfs_abort_transaction(trans, root, ret); 1515d6726335SQu Wenruo goto fail; 1516d6726335SQu Wenruo } 1517d6726335SQu Wenruo 1518d6726335SQu Wenruo /* 1519d6726335SQu Wenruo * account qgroup counters before qgroup_inherit() 1520d6726335SQu Wenruo */ 1521d6726335SQu Wenruo ret = btrfs_qgroup_prepare_account_extents(trans, fs_info); 1522d6726335SQu Wenruo if (ret) 1523d6726335SQu Wenruo goto fail; 1524d6726335SQu Wenruo ret = btrfs_qgroup_account_extents(trans, fs_info); 1525d6726335SQu Wenruo if (ret) 1526d6726335SQu Wenruo goto fail; 1527d6726335SQu Wenruo ret = btrfs_qgroup_inherit(trans, fs_info, 1528d6726335SQu Wenruo root->root_key.objectid, 1529d6726335SQu Wenruo objectid, pending->inherit); 1530d6726335SQu Wenruo if (ret) { 1531d6726335SQu Wenruo btrfs_abort_transaction(trans, root, ret); 1532d6726335SQu Wenruo goto fail; 1533d6726335SQu Wenruo } 1534d6726335SQu Wenruo 15353063d29fSChris Mason fail: 1536aec8030aSMiao Xie pending->error = ret; 1537aec8030aSMiao Xie dir_item_existed: 153898c9942aSLiu Bo trans->block_rsv = rsv; 15392382c5ccSLiu Bo trans->bytes_reserved = 0; 1540d6726335SQu Wenruo clear_skip_qgroup: 1541d6726335SQu Wenruo btrfs_clear_skip_qgroup(trans); 15426fa9700eSMiao Xie no_free_objectid: 15436fa9700eSMiao Xie kfree(new_root_item); 15446fa9700eSMiao Xie root_item_alloc_fail: 154542874b3dSMiao Xie btrfs_free_path(path); 154649b25e05SJeff Mahoney return ret; 15473063d29fSChris Mason } 15483063d29fSChris Mason 1549d352ac68SChris Mason /* 1550d352ac68SChris Mason * create all the snapshots we've scheduled for creation 1551d352ac68SChris Mason */ 155280b6794dSChris Mason static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans, 15533063d29fSChris Mason struct btrfs_fs_info *fs_info) 15543063d29fSChris Mason { 1555aec8030aSMiao Xie struct btrfs_pending_snapshot *pending, *next; 15563063d29fSChris Mason struct list_head *head = &trans->transaction->pending_snapshots; 1557aec8030aSMiao Xie int ret = 0; 15583de4586cSChris Mason 1559aec8030aSMiao Xie list_for_each_entry_safe(pending, next, head, list) { 1560aec8030aSMiao Xie list_del(&pending->list); 1561aec8030aSMiao Xie ret = create_pending_snapshot(trans, fs_info, pending); 1562aec8030aSMiao Xie if (ret) 1563aec8030aSMiao Xie break; 1564aec8030aSMiao Xie } 1565aec8030aSMiao Xie return ret; 15663de4586cSChris Mason } 15673de4586cSChris Mason 15685d4f98a2SYan Zheng static void update_super_roots(struct btrfs_root *root) 15695d4f98a2SYan Zheng { 15705d4f98a2SYan Zheng struct btrfs_root_item *root_item; 15715d4f98a2SYan Zheng struct btrfs_super_block *super; 15725d4f98a2SYan Zheng 15736c41761fSDavid Sterba super = root->fs_info->super_copy; 15745d4f98a2SYan Zheng 15755d4f98a2SYan Zheng root_item = &root->fs_info->chunk_root->root_item; 15765d4f98a2SYan Zheng super->chunk_root = root_item->bytenr; 15775d4f98a2SYan Zheng super->chunk_root_generation = root_item->generation; 15785d4f98a2SYan Zheng super->chunk_root_level = root_item->level; 15795d4f98a2SYan Zheng 15805d4f98a2SYan Zheng root_item = &root->fs_info->tree_root->root_item; 15815d4f98a2SYan Zheng super->root = root_item->bytenr; 15825d4f98a2SYan Zheng super->generation = root_item->generation; 15835d4f98a2SYan Zheng super->root_level = root_item->level; 158473bc1876SJosef Bacik if (btrfs_test_opt(root, SPACE_CACHE)) 15850af3d00bSJosef Bacik super->cache_generation = root_item->generation; 158670f80175SStefan Behrens if (root->fs_info->update_uuid_tree_gen) 158726432799SStefan Behrens super->uuid_tree_generation = root_item->generation; 15885d4f98a2SYan Zheng } 15895d4f98a2SYan Zheng 1590f36f3042SChris Mason int btrfs_transaction_in_commit(struct btrfs_fs_info *info) 1591f36f3042SChris Mason { 15924a9d8bdeSMiao Xie struct btrfs_transaction *trans; 1593f36f3042SChris Mason int ret = 0; 15944a9d8bdeSMiao Xie 1595a4abeea4SJosef Bacik spin_lock(&info->trans_lock); 15964a9d8bdeSMiao Xie trans = info->running_transaction; 15974a9d8bdeSMiao Xie if (trans) 15984a9d8bdeSMiao Xie ret = (trans->state >= TRANS_STATE_COMMIT_START); 1599a4abeea4SJosef Bacik spin_unlock(&info->trans_lock); 1600f36f3042SChris Mason return ret; 1601f36f3042SChris Mason } 1602f36f3042SChris Mason 16038929ecfaSYan, Zheng int btrfs_transaction_blocked(struct btrfs_fs_info *info) 16048929ecfaSYan, Zheng { 16054a9d8bdeSMiao Xie struct btrfs_transaction *trans; 16068929ecfaSYan, Zheng int ret = 0; 16074a9d8bdeSMiao Xie 1608a4abeea4SJosef Bacik spin_lock(&info->trans_lock); 16094a9d8bdeSMiao Xie trans = info->running_transaction; 16104a9d8bdeSMiao Xie if (trans) 16114a9d8bdeSMiao Xie ret = is_transaction_blocked(trans); 1612a4abeea4SJosef Bacik spin_unlock(&info->trans_lock); 16138929ecfaSYan, Zheng return ret; 16148929ecfaSYan, Zheng } 16158929ecfaSYan, Zheng 1616bb9c12c9SSage Weil /* 1617bb9c12c9SSage Weil * wait for the current transaction commit to start and block subsequent 1618bb9c12c9SSage Weil * transaction joins 1619bb9c12c9SSage Weil */ 1620bb9c12c9SSage Weil static void wait_current_trans_commit_start(struct btrfs_root *root, 1621bb9c12c9SSage Weil struct btrfs_transaction *trans) 1622bb9c12c9SSage Weil { 16234a9d8bdeSMiao Xie wait_event(root->fs_info->transaction_blocked_wait, 1624501407aaSJosef Bacik trans->state >= TRANS_STATE_COMMIT_START || 1625501407aaSJosef Bacik trans->aborted); 1626bb9c12c9SSage Weil } 1627bb9c12c9SSage Weil 1628bb9c12c9SSage Weil /* 1629bb9c12c9SSage Weil * wait for the current transaction to start and then become unblocked. 1630bb9c12c9SSage Weil * caller holds ref. 1631bb9c12c9SSage Weil */ 1632bb9c12c9SSage Weil static void wait_current_trans_commit_start_and_unblock(struct btrfs_root *root, 1633bb9c12c9SSage Weil struct btrfs_transaction *trans) 1634bb9c12c9SSage Weil { 163572d63ed6SLi Zefan wait_event(root->fs_info->transaction_wait, 1636501407aaSJosef Bacik trans->state >= TRANS_STATE_UNBLOCKED || 1637501407aaSJosef Bacik trans->aborted); 1638bb9c12c9SSage Weil } 1639bb9c12c9SSage Weil 1640bb9c12c9SSage Weil /* 1641bb9c12c9SSage Weil * commit transactions asynchronously. once btrfs_commit_transaction_async 1642bb9c12c9SSage Weil * returns, any subsequent transaction will not be allowed to join. 1643bb9c12c9SSage Weil */ 1644bb9c12c9SSage Weil struct btrfs_async_commit { 1645bb9c12c9SSage Weil struct btrfs_trans_handle *newtrans; 1646bb9c12c9SSage Weil struct btrfs_root *root; 16477892b5afSMiao Xie struct work_struct work; 1648bb9c12c9SSage Weil }; 1649bb9c12c9SSage Weil 1650bb9c12c9SSage Weil static void do_async_commit(struct work_struct *work) 1651bb9c12c9SSage Weil { 1652bb9c12c9SSage Weil struct btrfs_async_commit *ac = 16537892b5afSMiao Xie container_of(work, struct btrfs_async_commit, work); 1654bb9c12c9SSage Weil 16556fc4e354SSage Weil /* 16566fc4e354SSage Weil * We've got freeze protection passed with the transaction. 16576fc4e354SSage Weil * Tell lockdep about it. 16586fc4e354SSage Weil */ 1659b1a06a4bSLiu Bo if (ac->newtrans->type & __TRANS_FREEZABLE) 1660bee9182dSOleg Nesterov __sb_writers_acquired(ac->root->fs_info->sb, SB_FREEZE_FS); 16616fc4e354SSage Weil 1662e209db7aSSage Weil current->journal_info = ac->newtrans; 1663e209db7aSSage Weil 1664bb9c12c9SSage Weil btrfs_commit_transaction(ac->newtrans, ac->root); 1665bb9c12c9SSage Weil kfree(ac); 1666bb9c12c9SSage Weil } 1667bb9c12c9SSage Weil 1668bb9c12c9SSage Weil int btrfs_commit_transaction_async(struct btrfs_trans_handle *trans, 1669bb9c12c9SSage Weil struct btrfs_root *root, 1670bb9c12c9SSage Weil int wait_for_unblock) 1671bb9c12c9SSage Weil { 1672bb9c12c9SSage Weil struct btrfs_async_commit *ac; 1673bb9c12c9SSage Weil struct btrfs_transaction *cur_trans; 1674bb9c12c9SSage Weil 1675bb9c12c9SSage Weil ac = kmalloc(sizeof(*ac), GFP_NOFS); 1676db5b493aSTsutomu Itoh if (!ac) 1677db5b493aSTsutomu Itoh return -ENOMEM; 1678bb9c12c9SSage Weil 16797892b5afSMiao Xie INIT_WORK(&ac->work, do_async_commit); 1680bb9c12c9SSage Weil ac->root = root; 16817a7eaa40SJosef Bacik ac->newtrans = btrfs_join_transaction(root); 16823612b495STsutomu Itoh if (IS_ERR(ac->newtrans)) { 16833612b495STsutomu Itoh int err = PTR_ERR(ac->newtrans); 16843612b495STsutomu Itoh kfree(ac); 16853612b495STsutomu Itoh return err; 16863612b495STsutomu Itoh } 1687bb9c12c9SSage Weil 1688bb9c12c9SSage Weil /* take transaction reference */ 1689bb9c12c9SSage Weil cur_trans = trans->transaction; 169013c5a93eSJosef Bacik atomic_inc(&cur_trans->use_count); 1691bb9c12c9SSage Weil 1692bb9c12c9SSage Weil btrfs_end_transaction(trans, root); 16936fc4e354SSage Weil 16946fc4e354SSage Weil /* 16956fc4e354SSage Weil * Tell lockdep we've released the freeze rwsem, since the 16966fc4e354SSage Weil * async commit thread will be the one to unlock it. 16976fc4e354SSage Weil */ 1698b1a06a4bSLiu Bo if (ac->newtrans->type & __TRANS_FREEZABLE) 1699bee9182dSOleg Nesterov __sb_writers_release(root->fs_info->sb, SB_FREEZE_FS); 17006fc4e354SSage Weil 17017892b5afSMiao Xie schedule_work(&ac->work); 1702bb9c12c9SSage Weil 1703bb9c12c9SSage Weil /* wait for transaction to start and unblock */ 1704bb9c12c9SSage Weil if (wait_for_unblock) 1705bb9c12c9SSage Weil wait_current_trans_commit_start_and_unblock(root, cur_trans); 1706bb9c12c9SSage Weil else 1707bb9c12c9SSage Weil wait_current_trans_commit_start(root, cur_trans); 1708bb9c12c9SSage Weil 170938e88054SSage Weil if (current->journal_info == trans) 171038e88054SSage Weil current->journal_info = NULL; 171138e88054SSage Weil 1712724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 1713bb9c12c9SSage Weil return 0; 1714bb9c12c9SSage Weil } 1715bb9c12c9SSage Weil 171649b25e05SJeff Mahoney 171749b25e05SJeff Mahoney static void cleanup_transaction(struct btrfs_trans_handle *trans, 17187b8b92afSJosef Bacik struct btrfs_root *root, int err) 171949b25e05SJeff Mahoney { 172049b25e05SJeff Mahoney struct btrfs_transaction *cur_trans = trans->transaction; 1721f094ac32SLiu Bo DEFINE_WAIT(wait); 172249b25e05SJeff Mahoney 172349b25e05SJeff Mahoney WARN_ON(trans->use_count > 1); 172449b25e05SJeff Mahoney 17257b8b92afSJosef Bacik btrfs_abort_transaction(trans, root, err); 17267b8b92afSJosef Bacik 172749b25e05SJeff Mahoney spin_lock(&root->fs_info->trans_lock); 172866b6135bSLiu Bo 172925d8c284SMiao Xie /* 173025d8c284SMiao Xie * If the transaction is removed from the list, it means this 173125d8c284SMiao Xie * transaction has been committed successfully, so it is impossible 173225d8c284SMiao Xie * to call the cleanup function. 173325d8c284SMiao Xie */ 173425d8c284SMiao Xie BUG_ON(list_empty(&cur_trans->list)); 173566b6135bSLiu Bo 173649b25e05SJeff Mahoney list_del_init(&cur_trans->list); 1737d7096fc3SJosef Bacik if (cur_trans == root->fs_info->running_transaction) { 17384a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_COMMIT_DOING; 1739f094ac32SLiu Bo spin_unlock(&root->fs_info->trans_lock); 1740f094ac32SLiu Bo wait_event(cur_trans->writer_wait, 1741f094ac32SLiu Bo atomic_read(&cur_trans->num_writers) == 1); 1742f094ac32SLiu Bo 1743f094ac32SLiu Bo spin_lock(&root->fs_info->trans_lock); 1744d7096fc3SJosef Bacik } 174549b25e05SJeff Mahoney spin_unlock(&root->fs_info->trans_lock); 174649b25e05SJeff Mahoney 174749b25e05SJeff Mahoney btrfs_cleanup_one_transaction(trans->transaction, root); 174849b25e05SJeff Mahoney 17494a9d8bdeSMiao Xie spin_lock(&root->fs_info->trans_lock); 17504a9d8bdeSMiao Xie if (cur_trans == root->fs_info->running_transaction) 17514a9d8bdeSMiao Xie root->fs_info->running_transaction = NULL; 17524a9d8bdeSMiao Xie spin_unlock(&root->fs_info->trans_lock); 17534a9d8bdeSMiao Xie 1754e0228285SJosef Bacik if (trans->type & __TRANS_FREEZABLE) 1755e0228285SJosef Bacik sb_end_intwrite(root->fs_info->sb); 1756724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 1757724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 175849b25e05SJeff Mahoney 175949b25e05SJeff Mahoney trace_btrfs_transaction_commit(root); 176049b25e05SJeff Mahoney 176149b25e05SJeff Mahoney if (current->journal_info == trans) 176249b25e05SJeff Mahoney current->journal_info = NULL; 1763c0af8f0bSWang Shilong btrfs_scrub_cancel(root->fs_info); 176449b25e05SJeff Mahoney 176549b25e05SJeff Mahoney kmem_cache_free(btrfs_trans_handle_cachep, trans); 176649b25e05SJeff Mahoney } 176749b25e05SJeff Mahoney 176882436617SMiao Xie static inline int btrfs_start_delalloc_flush(struct btrfs_fs_info *fs_info) 176982436617SMiao Xie { 177082436617SMiao Xie if (btrfs_test_opt(fs_info->tree_root, FLUSHONCOMMIT)) 17716c255e67SMiao Xie return btrfs_start_delalloc_roots(fs_info, 1, -1); 177282436617SMiao Xie return 0; 177382436617SMiao Xie } 177482436617SMiao Xie 177582436617SMiao Xie static inline void btrfs_wait_delalloc_flush(struct btrfs_fs_info *fs_info) 177682436617SMiao Xie { 177782436617SMiao Xie if (btrfs_test_opt(fs_info->tree_root, FLUSHONCOMMIT)) 1778b0244199SMiao Xie btrfs_wait_ordered_roots(fs_info, -1); 177982436617SMiao Xie } 178082436617SMiao Xie 178150d9aa99SJosef Bacik static inline void 178250d9aa99SJosef Bacik btrfs_wait_pending_ordered(struct btrfs_transaction *cur_trans, 178350d9aa99SJosef Bacik struct btrfs_fs_info *fs_info) 178450d9aa99SJosef Bacik { 178550d9aa99SJosef Bacik struct btrfs_ordered_extent *ordered; 178650d9aa99SJosef Bacik 178750d9aa99SJosef Bacik spin_lock(&fs_info->trans_lock); 178850d9aa99SJosef Bacik while (!list_empty(&cur_trans->pending_ordered)) { 178950d9aa99SJosef Bacik ordered = list_first_entry(&cur_trans->pending_ordered, 179050d9aa99SJosef Bacik struct btrfs_ordered_extent, 179150d9aa99SJosef Bacik trans_list); 179250d9aa99SJosef Bacik list_del_init(&ordered->trans_list); 179350d9aa99SJosef Bacik spin_unlock(&fs_info->trans_lock); 179450d9aa99SJosef Bacik 179550d9aa99SJosef Bacik wait_event(ordered->wait, test_bit(BTRFS_ORDERED_COMPLETE, 179650d9aa99SJosef Bacik &ordered->flags)); 179750d9aa99SJosef Bacik btrfs_put_ordered_extent(ordered); 179850d9aa99SJosef Bacik spin_lock(&fs_info->trans_lock); 179950d9aa99SJosef Bacik } 180050d9aa99SJosef Bacik spin_unlock(&fs_info->trans_lock); 180150d9aa99SJosef Bacik } 180250d9aa99SJosef Bacik 180379154b1bSChris Mason int btrfs_commit_transaction(struct btrfs_trans_handle *trans, 180479154b1bSChris Mason struct btrfs_root *root) 180579154b1bSChris Mason { 180649b25e05SJeff Mahoney struct btrfs_transaction *cur_trans = trans->transaction; 18078fd17795SChris Mason struct btrfs_transaction *prev_trans = NULL; 1808656f30dbSFilipe Manana struct btrfs_inode *btree_ino = BTRFS_I(root->fs_info->btree_inode); 180925287e0aSMiao Xie int ret; 181079154b1bSChris Mason 18118d25a086SMiao Xie /* Stop the commit early if ->aborted is set */ 18128d25a086SMiao Xie if (unlikely(ACCESS_ONCE(cur_trans->aborted))) { 181325287e0aSMiao Xie ret = cur_trans->aborted; 1814e4a2bcacSJosef Bacik btrfs_end_transaction(trans, root); 1815e4a2bcacSJosef Bacik return ret; 181625287e0aSMiao Xie } 181749b25e05SJeff Mahoney 181856bec294SChris Mason /* make a pass through all the delayed refs we have so far 181956bec294SChris Mason * any runnings procs may add more while we are here 182056bec294SChris Mason */ 182156bec294SChris Mason ret = btrfs_run_delayed_refs(trans, root, 0); 1822e4a2bcacSJosef Bacik if (ret) { 1823e4a2bcacSJosef Bacik btrfs_end_transaction(trans, root); 1824e4a2bcacSJosef Bacik return ret; 1825e4a2bcacSJosef Bacik } 182656bec294SChris Mason 18270e721106SJosef Bacik btrfs_trans_release_metadata(trans, root); 18280e721106SJosef Bacik trans->block_rsv = NULL; 1829272d26d0SMiao Xie if (trans->qgroup_reserved) { 1830272d26d0SMiao Xie btrfs_qgroup_free(root, trans->qgroup_reserved); 1831272d26d0SMiao Xie trans->qgroup_reserved = 0; 1832272d26d0SMiao Xie } 18330e721106SJosef Bacik 1834b7ec40d7SChris Mason cur_trans = trans->transaction; 183549b25e05SJeff Mahoney 183656bec294SChris Mason /* 183756bec294SChris Mason * set the flushing flag so procs in this transaction have to 183856bec294SChris Mason * start sending their work down. 183956bec294SChris Mason */ 1840b7ec40d7SChris Mason cur_trans->delayed_refs.flushing = 1; 18411be41b78SJosef Bacik smp_wmb(); 184256bec294SChris Mason 1843ea658badSJosef Bacik if (!list_empty(&trans->new_bgs)) 1844ea658badSJosef Bacik btrfs_create_pending_block_groups(trans, root); 1845ea658badSJosef Bacik 1846c3e69d58SChris Mason ret = btrfs_run_delayed_refs(trans, root, 0); 1847e4a2bcacSJosef Bacik if (ret) { 1848e4a2bcacSJosef Bacik btrfs_end_transaction(trans, root); 1849e4a2bcacSJosef Bacik return ret; 1850e4a2bcacSJosef Bacik } 185156bec294SChris Mason 18521bbc621eSChris Mason if (!cur_trans->dirty_bg_run) { 18531bbc621eSChris Mason int run_it = 0; 18541bbc621eSChris Mason 18551bbc621eSChris Mason /* this mutex is also taken before trying to set 18561bbc621eSChris Mason * block groups readonly. We need to make sure 18571bbc621eSChris Mason * that nobody has set a block group readonly 18581bbc621eSChris Mason * after a extents from that block group have been 18591bbc621eSChris Mason * allocated for cache files. btrfs_set_block_group_ro 18601bbc621eSChris Mason * will wait for the transaction to commit if it 18611bbc621eSChris Mason * finds dirty_bg_run = 1 18621bbc621eSChris Mason * 18631bbc621eSChris Mason * The dirty_bg_run flag is also used to make sure only 18641bbc621eSChris Mason * one process starts all the block group IO. It wouldn't 18651bbc621eSChris Mason * hurt to have more than one go through, but there's no 18661bbc621eSChris Mason * real advantage to it either. 18671bbc621eSChris Mason */ 18681bbc621eSChris Mason mutex_lock(&root->fs_info->ro_block_group_mutex); 18691bbc621eSChris Mason if (!cur_trans->dirty_bg_run) { 18701bbc621eSChris Mason run_it = 1; 18711bbc621eSChris Mason cur_trans->dirty_bg_run = 1; 18721bbc621eSChris Mason } 18731bbc621eSChris Mason mutex_unlock(&root->fs_info->ro_block_group_mutex); 18741bbc621eSChris Mason 18751bbc621eSChris Mason if (run_it) 18761bbc621eSChris Mason ret = btrfs_start_dirty_block_groups(trans, root); 18771bbc621eSChris Mason } 18781bbc621eSChris Mason if (ret) { 18791bbc621eSChris Mason btrfs_end_transaction(trans, root); 18801bbc621eSChris Mason return ret; 18811bbc621eSChris Mason } 18821bbc621eSChris Mason 18834a9d8bdeSMiao Xie spin_lock(&root->fs_info->trans_lock); 1884d3efe084SFilipe Manana list_splice_init(&trans->ordered, &cur_trans->pending_ordered); 18854a9d8bdeSMiao Xie if (cur_trans->state >= TRANS_STATE_COMMIT_START) { 18864a9d8bdeSMiao Xie spin_unlock(&root->fs_info->trans_lock); 188713c5a93eSJosef Bacik atomic_inc(&cur_trans->use_count); 188849b25e05SJeff Mahoney ret = btrfs_end_transaction(trans, root); 1889ccd467d6SChris Mason 1890b9c8300cSLi Zefan wait_for_commit(root, cur_trans); 189115ee9bc7SJosef Bacik 1892b4924a0fSLiu Bo if (unlikely(cur_trans->aborted)) 1893b4924a0fSLiu Bo ret = cur_trans->aborted; 1894b4924a0fSLiu Bo 1895724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 189615ee9bc7SJosef Bacik 189749b25e05SJeff Mahoney return ret; 189879154b1bSChris Mason } 18994313b399SChris Mason 19004a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_COMMIT_START; 1901bb9c12c9SSage Weil wake_up(&root->fs_info->transaction_blocked_wait); 1902bb9c12c9SSage Weil 1903ccd467d6SChris Mason if (cur_trans->list.prev != &root->fs_info->trans_list) { 1904ccd467d6SChris Mason prev_trans = list_entry(cur_trans->list.prev, 1905ccd467d6SChris Mason struct btrfs_transaction, list); 19064a9d8bdeSMiao Xie if (prev_trans->state != TRANS_STATE_COMPLETED) { 190713c5a93eSJosef Bacik atomic_inc(&prev_trans->use_count); 1908a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 1909ccd467d6SChris Mason 1910ccd467d6SChris Mason wait_for_commit(root, prev_trans); 19111f9b8c8fSFilipe Manana ret = prev_trans->aborted; 1912ccd467d6SChris Mason 1913724e2315SJosef Bacik btrfs_put_transaction(prev_trans); 19141f9b8c8fSFilipe Manana if (ret) 19151f9b8c8fSFilipe Manana goto cleanup_transaction; 1916a4abeea4SJosef Bacik } else { 1917a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 1918ccd467d6SChris Mason } 1919a4abeea4SJosef Bacik } else { 1920a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 1921ccd467d6SChris Mason } 192215ee9bc7SJosef Bacik 19230860adfdSMiao Xie extwriter_counter_dec(cur_trans, trans->type); 19240860adfdSMiao Xie 192582436617SMiao Xie ret = btrfs_start_delalloc_flush(root->fs_info); 192682436617SMiao Xie if (ret) 192782436617SMiao Xie goto cleanup_transaction; 192882436617SMiao Xie 19298d875f95SChris Mason ret = btrfs_run_delayed_items(trans, root); 193049b25e05SJeff Mahoney if (ret) 193149b25e05SJeff Mahoney goto cleanup_transaction; 193216cdcec7SMiao Xie 1933581227d0SMiao Xie wait_event(cur_trans->writer_wait, 1934581227d0SMiao Xie extwriter_counter_read(cur_trans) == 0); 1935ed3b3d31SChris Mason 1936581227d0SMiao Xie /* some pending stuffs might be added after the previous flush. */ 19378d875f95SChris Mason ret = btrfs_run_delayed_items(trans, root); 1938ca469637SMiao Xie if (ret) 1939ca469637SMiao Xie goto cleanup_transaction; 1940ca469637SMiao Xie 194182436617SMiao Xie btrfs_wait_delalloc_flush(root->fs_info); 1942cb7ab021SWang Shilong 194350d9aa99SJosef Bacik btrfs_wait_pending_ordered(cur_trans, root->fs_info); 194450d9aa99SJosef Bacik 1945cb7ab021SWang Shilong btrfs_scrub_pause(root); 1946ed0ca140SJosef Bacik /* 1947ed0ca140SJosef Bacik * Ok now we need to make sure to block out any other joins while we 1948ed0ca140SJosef Bacik * commit the transaction. We could have started a join before setting 19494a9d8bdeSMiao Xie * COMMIT_DOING so make sure to wait for num_writers to == 1 again. 1950ed0ca140SJosef Bacik */ 1951a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 19524a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_COMMIT_DOING; 1953a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 1954ed0ca140SJosef Bacik wait_event(cur_trans->writer_wait, 1955ed0ca140SJosef Bacik atomic_read(&cur_trans->num_writers) == 1); 195615ee9bc7SJosef Bacik 19572cba30f1SMiao Xie /* ->aborted might be set after the previous check, so check it */ 19582cba30f1SMiao Xie if (unlikely(ACCESS_ONCE(cur_trans->aborted))) { 19592cba30f1SMiao Xie ret = cur_trans->aborted; 19606cf7f77eSWang Shilong goto scrub_continue; 19612cba30f1SMiao Xie } 19627585717fSChris Mason /* 19637585717fSChris Mason * the reloc mutex makes sure that we stop 19647585717fSChris Mason * the balancing code from coming in and moving 19657585717fSChris Mason * extents around in the middle of the commit 19667585717fSChris Mason */ 19677585717fSChris Mason mutex_lock(&root->fs_info->reloc_mutex); 19687585717fSChris Mason 196942874b3dSMiao Xie /* 197042874b3dSMiao Xie * We needn't worry about the delayed items because we will 197142874b3dSMiao Xie * deal with them in create_pending_snapshot(), which is the 197242874b3dSMiao Xie * core function of the snapshot creation. 197342874b3dSMiao Xie */ 197442874b3dSMiao Xie ret = create_pending_snapshots(trans, root->fs_info); 197549b25e05SJeff Mahoney if (ret) { 197649b25e05SJeff Mahoney mutex_unlock(&root->fs_info->reloc_mutex); 19776cf7f77eSWang Shilong goto scrub_continue; 197849b25e05SJeff Mahoney } 19793063d29fSChris Mason 198042874b3dSMiao Xie /* 198142874b3dSMiao Xie * We insert the dir indexes of the snapshots and update the inode 198242874b3dSMiao Xie * of the snapshots' parents after the snapshot creation, so there 198342874b3dSMiao Xie * are some delayed items which are not dealt with. Now deal with 198442874b3dSMiao Xie * them. 198542874b3dSMiao Xie * 198642874b3dSMiao Xie * We needn't worry that this operation will corrupt the snapshots, 198742874b3dSMiao Xie * because all the tree which are snapshoted will be forced to COW 198842874b3dSMiao Xie * the nodes and leaves. 198942874b3dSMiao Xie */ 199042874b3dSMiao Xie ret = btrfs_run_delayed_items(trans, root); 199149b25e05SJeff Mahoney if (ret) { 199249b25e05SJeff Mahoney mutex_unlock(&root->fs_info->reloc_mutex); 19936cf7f77eSWang Shilong goto scrub_continue; 199449b25e05SJeff Mahoney } 199516cdcec7SMiao Xie 199656bec294SChris Mason ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); 199749b25e05SJeff Mahoney if (ret) { 199849b25e05SJeff Mahoney mutex_unlock(&root->fs_info->reloc_mutex); 19996cf7f77eSWang Shilong goto scrub_continue; 200049b25e05SJeff Mahoney } 200156bec294SChris Mason 20020ed4792aSQu Wenruo /* Reocrd old roots for later qgroup accounting */ 20030ed4792aSQu Wenruo ret = btrfs_qgroup_prepare_account_extents(trans, root->fs_info); 20040ed4792aSQu Wenruo if (ret) { 20050ed4792aSQu Wenruo mutex_unlock(&root->fs_info->reloc_mutex); 20060ed4792aSQu Wenruo goto scrub_continue; 20070ed4792aSQu Wenruo } 20080ed4792aSQu Wenruo 2009e999376fSChris Mason /* 2010e999376fSChris Mason * make sure none of the code above managed to slip in a 2011e999376fSChris Mason * delayed item 2012e999376fSChris Mason */ 2013e999376fSChris Mason btrfs_assert_delayed_root_empty(root); 2014e999376fSChris Mason 20152c90e5d6SChris Mason WARN_ON(cur_trans != trans->transaction); 2016dc17ff8fSChris Mason 2017e02119d5SChris Mason /* btrfs_commit_tree_roots is responsible for getting the 2018e02119d5SChris Mason * various roots consistent with each other. Every pointer 2019e02119d5SChris Mason * in the tree of tree roots has to point to the most up to date 2020e02119d5SChris Mason * root for every subvolume and other tree. So, we have to keep 2021e02119d5SChris Mason * the tree logging code from jumping in and changing any 2022e02119d5SChris Mason * of the trees. 2023e02119d5SChris Mason * 2024e02119d5SChris Mason * At this point in the commit, there can't be any tree-log 2025e02119d5SChris Mason * writers, but a little lower down we drop the trans mutex 2026e02119d5SChris Mason * and let new people in. By holding the tree_log_mutex 2027e02119d5SChris Mason * from now until after the super is written, we avoid races 2028e02119d5SChris Mason * with the tree-log code. 2029e02119d5SChris Mason */ 2030e02119d5SChris Mason mutex_lock(&root->fs_info->tree_log_mutex); 20311a40e23bSZheng Yan 20325d4f98a2SYan Zheng ret = commit_fs_roots(trans, root); 203349b25e05SJeff Mahoney if (ret) { 203449b25e05SJeff Mahoney mutex_unlock(&root->fs_info->tree_log_mutex); 2035871383beSDavid Sterba mutex_unlock(&root->fs_info->reloc_mutex); 20366cf7f77eSWang Shilong goto scrub_continue; 203749b25e05SJeff Mahoney } 203854aa1f4dSChris Mason 20393818aea2SQu Wenruo /* 20407e1876acSDavid Sterba * Since the transaction is done, we can apply the pending changes 20417e1876acSDavid Sterba * before the next transaction. 20423818aea2SQu Wenruo */ 2043572d9ab7SDavid Sterba btrfs_apply_pending_changes(root->fs_info); 20443818aea2SQu Wenruo 20455d4f98a2SYan Zheng /* commit_fs_roots gets rid of all the tree log roots, it is now 2046e02119d5SChris Mason * safe to free the root of tree log roots 2047e02119d5SChris Mason */ 2048e02119d5SChris Mason btrfs_free_log_root_tree(trans, root->fs_info); 2049e02119d5SChris Mason 20500ed4792aSQu Wenruo /* 20510ed4792aSQu Wenruo * Since fs roots are all committed, we can get a quite accurate 20520ed4792aSQu Wenruo * new_roots. So let's do quota accounting. 20530ed4792aSQu Wenruo */ 20540ed4792aSQu Wenruo ret = btrfs_qgroup_account_extents(trans, root->fs_info); 20550ed4792aSQu Wenruo if (ret < 0) { 20560ed4792aSQu Wenruo mutex_unlock(&root->fs_info->tree_log_mutex); 20570ed4792aSQu Wenruo mutex_unlock(&root->fs_info->reloc_mutex); 20580ed4792aSQu Wenruo goto scrub_continue; 20590ed4792aSQu Wenruo } 20600ed4792aSQu Wenruo 20615d4f98a2SYan Zheng ret = commit_cowonly_roots(trans, root); 206249b25e05SJeff Mahoney if (ret) { 206349b25e05SJeff Mahoney mutex_unlock(&root->fs_info->tree_log_mutex); 2064871383beSDavid Sterba mutex_unlock(&root->fs_info->reloc_mutex); 20656cf7f77eSWang Shilong goto scrub_continue; 206649b25e05SJeff Mahoney } 206754aa1f4dSChris Mason 20682cba30f1SMiao Xie /* 20692cba30f1SMiao Xie * The tasks which save the space cache and inode cache may also 20702cba30f1SMiao Xie * update ->aborted, check it. 20712cba30f1SMiao Xie */ 20722cba30f1SMiao Xie if (unlikely(ACCESS_ONCE(cur_trans->aborted))) { 20732cba30f1SMiao Xie ret = cur_trans->aborted; 20742cba30f1SMiao Xie mutex_unlock(&root->fs_info->tree_log_mutex); 20752cba30f1SMiao Xie mutex_unlock(&root->fs_info->reloc_mutex); 20766cf7f77eSWang Shilong goto scrub_continue; 20772cba30f1SMiao Xie } 20782cba30f1SMiao Xie 207911833d66SYan Zheng btrfs_prepare_extent_commit(trans, root); 208011833d66SYan Zheng 208178fae27eSChris Mason cur_trans = root->fs_info->running_transaction; 20825f39d397SChris Mason 20835d4f98a2SYan Zheng btrfs_set_root_node(&root->fs_info->tree_root->root_item, 20845d4f98a2SYan Zheng root->fs_info->tree_root->node); 20859e351cc8SJosef Bacik list_add_tail(&root->fs_info->tree_root->dirty_list, 20869e351cc8SJosef Bacik &cur_trans->switch_commits); 20875d4f98a2SYan Zheng 20885d4f98a2SYan Zheng btrfs_set_root_node(&root->fs_info->chunk_root->root_item, 20895d4f98a2SYan Zheng root->fs_info->chunk_root->node); 20909e351cc8SJosef Bacik list_add_tail(&root->fs_info->chunk_root->dirty_list, 20919e351cc8SJosef Bacik &cur_trans->switch_commits); 20929e351cc8SJosef Bacik 20939e351cc8SJosef Bacik switch_commit_roots(cur_trans, root->fs_info); 20945d4f98a2SYan Zheng 2095edf39272SJan Schmidt assert_qgroups_uptodate(trans); 2096ce93ec54SJosef Bacik ASSERT(list_empty(&cur_trans->dirty_bgs)); 20971bbc621eSChris Mason ASSERT(list_empty(&cur_trans->io_bgs)); 20985d4f98a2SYan Zheng update_super_roots(root); 2099e02119d5SChris Mason 21006c41761fSDavid Sterba btrfs_set_super_log_root(root->fs_info->super_copy, 0); 21016c41761fSDavid Sterba btrfs_set_super_log_root_level(root->fs_info->super_copy, 0); 21026c41761fSDavid Sterba memcpy(root->fs_info->super_for_commit, root->fs_info->super_copy, 21036c41761fSDavid Sterba sizeof(*root->fs_info->super_copy)); 2104ccd467d6SChris Mason 2105935e5cc9SMiao Xie btrfs_update_commit_device_size(root->fs_info); 2106ce7213c7SMiao Xie btrfs_update_commit_device_bytes_used(root, cur_trans); 2107935e5cc9SMiao Xie 2108656f30dbSFilipe Manana clear_bit(BTRFS_INODE_BTREE_LOG1_ERR, &btree_ino->runtime_flags); 2109656f30dbSFilipe Manana clear_bit(BTRFS_INODE_BTREE_LOG2_ERR, &btree_ino->runtime_flags); 2110656f30dbSFilipe Manana 21114fbcdf66SFilipe Manana btrfs_trans_release_chunk_metadata(trans); 21124fbcdf66SFilipe Manana 2113a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 21144a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_UNBLOCKED; 2115a4abeea4SJosef Bacik root->fs_info->running_transaction = NULL; 2116a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 21177585717fSChris Mason mutex_unlock(&root->fs_info->reloc_mutex); 2118b7ec40d7SChris Mason 2119f9295749SChris Mason wake_up(&root->fs_info->transaction_wait); 2120e6dcd2dcSChris Mason 212179154b1bSChris Mason ret = btrfs_write_and_wait_transaction(trans, root); 212249b25e05SJeff Mahoney if (ret) { 212349b25e05SJeff Mahoney btrfs_error(root->fs_info, ret, 212408748810SDavid Sterba "Error while writing out transaction"); 212549b25e05SJeff Mahoney mutex_unlock(&root->fs_info->tree_log_mutex); 21266cf7f77eSWang Shilong goto scrub_continue; 212749b25e05SJeff Mahoney } 212849b25e05SJeff Mahoney 212949b25e05SJeff Mahoney ret = write_ctree_super(trans, root, 0); 213049b25e05SJeff Mahoney if (ret) { 213149b25e05SJeff Mahoney mutex_unlock(&root->fs_info->tree_log_mutex); 21326cf7f77eSWang Shilong goto scrub_continue; 213349b25e05SJeff Mahoney } 21344313b399SChris Mason 2135e02119d5SChris Mason /* 2136e02119d5SChris Mason * the super is written, we can safely allow the tree-loggers 2137e02119d5SChris Mason * to go about their business 2138e02119d5SChris Mason */ 2139e02119d5SChris Mason mutex_unlock(&root->fs_info->tree_log_mutex); 2140e02119d5SChris Mason 214111833d66SYan Zheng btrfs_finish_extent_commit(trans, root); 21424313b399SChris Mason 214313212b54SZhao Lei if (cur_trans->have_free_bgs) 214413212b54SZhao Lei btrfs_clear_space_info_full(root->fs_info); 214513212b54SZhao Lei 214615ee9bc7SJosef Bacik root->fs_info->last_trans_committed = cur_trans->transid; 21474a9d8bdeSMiao Xie /* 21484a9d8bdeSMiao Xie * We needn't acquire the lock here because there is no other task 21494a9d8bdeSMiao Xie * which can change it. 21504a9d8bdeSMiao Xie */ 21514a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_COMPLETED; 21522c90e5d6SChris Mason wake_up(&cur_trans->commit_wait); 21533de4586cSChris Mason 2154a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 215513c5a93eSJosef Bacik list_del_init(&cur_trans->list); 2156a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 2157a4abeea4SJosef Bacik 2158724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 2159724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 216058176a96SJosef Bacik 21610860adfdSMiao Xie if (trans->type & __TRANS_FREEZABLE) 2162b2b5ef5cSJan Kara sb_end_intwrite(root->fs_info->sb); 2163b2b5ef5cSJan Kara 21641abe9b8aSliubo trace_btrfs_transaction_commit(root); 21651abe9b8aSliubo 2166a2de733cSArne Jansen btrfs_scrub_continue(root); 2167a2de733cSArne Jansen 21689ed74f2dSJosef Bacik if (current->journal_info == trans) 21699ed74f2dSJosef Bacik current->journal_info = NULL; 21709ed74f2dSJosef Bacik 21712c90e5d6SChris Mason kmem_cache_free(btrfs_trans_handle_cachep, trans); 217224bbcf04SYan, Zheng 21738a733013SZhao Lei if (current != root->fs_info->transaction_kthread && 21748a733013SZhao Lei current != root->fs_info->cleaner_kthread) 217524bbcf04SYan, Zheng btrfs_run_delayed_iputs(root); 217624bbcf04SYan, Zheng 217779154b1bSChris Mason return ret; 217849b25e05SJeff Mahoney 21796cf7f77eSWang Shilong scrub_continue: 21806cf7f77eSWang Shilong btrfs_scrub_continue(root); 218149b25e05SJeff Mahoney cleanup_transaction: 21820e721106SJosef Bacik btrfs_trans_release_metadata(trans, root); 21834fbcdf66SFilipe Manana btrfs_trans_release_chunk_metadata(trans); 21840e721106SJosef Bacik trans->block_rsv = NULL; 2185272d26d0SMiao Xie if (trans->qgroup_reserved) { 2186272d26d0SMiao Xie btrfs_qgroup_free(root, trans->qgroup_reserved); 2187272d26d0SMiao Xie trans->qgroup_reserved = 0; 2188272d26d0SMiao Xie } 2189c2cf52ebSSimon Kirby btrfs_warn(root->fs_info, "Skipping commit of aborted transaction."); 219049b25e05SJeff Mahoney if (current->journal_info == trans) 219149b25e05SJeff Mahoney current->journal_info = NULL; 21927b8b92afSJosef Bacik cleanup_transaction(trans, root, ret); 219349b25e05SJeff Mahoney 219449b25e05SJeff Mahoney return ret; 219579154b1bSChris Mason } 219679154b1bSChris Mason 2197d352ac68SChris Mason /* 21989d1a2a3aSDavid Sterba * return < 0 if error 21999d1a2a3aSDavid Sterba * 0 if there are no more dead_roots at the time of call 22009d1a2a3aSDavid Sterba * 1 there are more to be processed, call me again 22019d1a2a3aSDavid Sterba * 22029d1a2a3aSDavid Sterba * The return value indicates there are certainly more snapshots to delete, but 22039d1a2a3aSDavid Sterba * if there comes a new one during processing, it may return 0. We don't mind, 22049d1a2a3aSDavid Sterba * because btrfs_commit_super will poke cleaner thread and it will process it a 22059d1a2a3aSDavid Sterba * few seconds later. 2206d352ac68SChris Mason */ 22079d1a2a3aSDavid Sterba int btrfs_clean_one_deleted_snapshot(struct btrfs_root *root) 2208e9d0b13bSChris Mason { 22099d1a2a3aSDavid Sterba int ret; 22105d4f98a2SYan Zheng struct btrfs_fs_info *fs_info = root->fs_info; 2211e9d0b13bSChris Mason 2212a4abeea4SJosef Bacik spin_lock(&fs_info->trans_lock); 22139d1a2a3aSDavid Sterba if (list_empty(&fs_info->dead_roots)) { 22149d1a2a3aSDavid Sterba spin_unlock(&fs_info->trans_lock); 22159d1a2a3aSDavid Sterba return 0; 22169d1a2a3aSDavid Sterba } 22179d1a2a3aSDavid Sterba root = list_first_entry(&fs_info->dead_roots, 22189d1a2a3aSDavid Sterba struct btrfs_root, root_list); 2219cfad392bSJosef Bacik list_del_init(&root->root_list); 2220a4abeea4SJosef Bacik spin_unlock(&fs_info->trans_lock); 22215d4f98a2SYan Zheng 2222efe120a0SFrank Holton pr_debug("BTRFS: cleaner removing %llu\n", root->objectid); 222376dda93cSYan, Zheng 222416cdcec7SMiao Xie btrfs_kill_all_delayed_nodes(root); 222516cdcec7SMiao Xie 222676dda93cSYan, Zheng if (btrfs_header_backref_rev(root->node) < 222776dda93cSYan, Zheng BTRFS_MIXED_BACKREF_REV) 22282c536799SJeff Mahoney ret = btrfs_drop_snapshot(root, NULL, 0, 0); 222976dda93cSYan, Zheng else 22302c536799SJeff Mahoney ret = btrfs_drop_snapshot(root, NULL, 1, 0); 223132471dc2SDavid Sterba 22326596a928SJosef Bacik return (ret < 0) ? 0 : 1; 2233e9d0b13bSChris Mason } 2234572d9ab7SDavid Sterba 2235572d9ab7SDavid Sterba void btrfs_apply_pending_changes(struct btrfs_fs_info *fs_info) 2236572d9ab7SDavid Sterba { 2237572d9ab7SDavid Sterba unsigned long prev; 2238572d9ab7SDavid Sterba unsigned long bit; 2239572d9ab7SDavid Sterba 22406c9fe14fSQu Wenruo prev = xchg(&fs_info->pending_changes, 0); 2241572d9ab7SDavid Sterba if (!prev) 2242572d9ab7SDavid Sterba return; 2243572d9ab7SDavid Sterba 22447e1876acSDavid Sterba bit = 1 << BTRFS_PENDING_SET_INODE_MAP_CACHE; 22457e1876acSDavid Sterba if (prev & bit) 22467e1876acSDavid Sterba btrfs_set_opt(fs_info->mount_opt, INODE_MAP_CACHE); 22477e1876acSDavid Sterba prev &= ~bit; 22487e1876acSDavid Sterba 22497e1876acSDavid Sterba bit = 1 << BTRFS_PENDING_CLEAR_INODE_MAP_CACHE; 22507e1876acSDavid Sterba if (prev & bit) 22517e1876acSDavid Sterba btrfs_clear_opt(fs_info->mount_opt, INODE_MAP_CACHE); 22527e1876acSDavid Sterba prev &= ~bit; 22537e1876acSDavid Sterba 2254d51033d0SDavid Sterba bit = 1 << BTRFS_PENDING_COMMIT; 2255d51033d0SDavid Sterba if (prev & bit) 2256d51033d0SDavid Sterba btrfs_debug(fs_info, "pending commit done"); 2257d51033d0SDavid Sterba prev &= ~bit; 2258d51033d0SDavid Sterba 2259572d9ab7SDavid Sterba if (prev) 2260572d9ab7SDavid Sterba btrfs_warn(fs_info, 2261572d9ab7SDavid Sterba "unknown pending changes left 0x%lx, ignoring", prev); 2262572d9ab7SDavid Sterba } 2263