1c1d7c514SDavid Sterba // SPDX-License-Identifier: GPL-2.0 26cbd5570SChris Mason /* 36cbd5570SChris Mason * Copyright (C) 2007 Oracle. All rights reserved. 46cbd5570SChris Mason */ 56cbd5570SChris Mason 679154b1bSChris Mason #include <linux/fs.h> 75a0e3ad6STejun Heo #include <linux/slab.h> 834088780SChris Mason #include <linux/sched.h> 9ab3c5c18SSweet Tea Dorminy #include <linux/sched/mm.h> 10d3c2fdcfSChris Mason #include <linux/writeback.h> 115f39d397SChris Mason #include <linux/pagemap.h> 125f2cc086SChris Mason #include <linux/blkdev.h> 138ea05e3aSAlexander Block #include <linux/uuid.h> 14e55958c8SIoannis Angelakopoulos #include <linux/timekeeping.h> 15602cbe91SDavid Sterba #include "misc.h" 1679154b1bSChris Mason #include "ctree.h" 1779154b1bSChris Mason #include "disk-io.h" 1879154b1bSChris Mason #include "transaction.h" 19925baeddSChris Mason #include "locking.h" 20e02119d5SChris Mason #include "tree-log.h" 21733f4fbbSStefan Behrens #include "volumes.h" 228dabb742SStefan Behrens #include "dev-replace.h" 23fcebe456SJosef Bacik #include "qgroup.h" 24aac0023cSJosef Bacik #include "block-group.h" 259c343784SJosef Bacik #include "space-info.h" 26d3575156SNaohiro Aota #include "zoned.h" 27c7f13d42SJosef Bacik #include "fs.h" 2807e81dc9SJosef Bacik #include "accessors.h" 29a0231804SJosef Bacik #include "extent-tree.h" 3045c40c8fSJosef Bacik #include "root-tree.h" 3159b818e0SJosef Bacik #include "defrag.h" 32f2b39277SJosef Bacik #include "dir-item.h" 33c7a03b52SJosef Bacik #include "uuid-tree.h" 347572dec8SJosef Bacik #include "ioctl.h" 3567707479SJosef Bacik #include "relocation.h" 362fc6822cSJosef Bacik #include "scrub.h" 3779154b1bSChris Mason 38956504a3SJosef Bacik static struct kmem_cache *btrfs_trans_handle_cachep; 39956504a3SJosef Bacik 4061c047b5SQu Wenruo /* 4161c047b5SQu Wenruo * Transaction states and transitions 4261c047b5SQu Wenruo * 4361c047b5SQu Wenruo * No running transaction (fs tree blocks are not modified) 4461c047b5SQu Wenruo * | 4561c047b5SQu Wenruo * | To next stage: 4661c047b5SQu Wenruo * | Call start_transaction() variants. Except btrfs_join_transaction_nostart(). 4761c047b5SQu Wenruo * V 4861c047b5SQu Wenruo * Transaction N [[TRANS_STATE_RUNNING]] 4961c047b5SQu Wenruo * | 5061c047b5SQu Wenruo * | New trans handles can be attached to transaction N by calling all 5161c047b5SQu Wenruo * | start_transaction() variants. 5261c047b5SQu Wenruo * | 5361c047b5SQu Wenruo * | To next stage: 5461c047b5SQu Wenruo * | Call btrfs_commit_transaction() on any trans handle attached to 5561c047b5SQu Wenruo * | transaction N 5661c047b5SQu Wenruo * V 5777d20c68SJosef Bacik * Transaction N [[TRANS_STATE_COMMIT_PREP]] 5877d20c68SJosef Bacik * | 5977d20c68SJosef Bacik * | If there are simultaneous calls to btrfs_commit_transaction() one will win 6077d20c68SJosef Bacik * | the race and the rest will wait for the winner to commit the transaction. 6177d20c68SJosef Bacik * | 6277d20c68SJosef Bacik * | The winner will wait for previous running transaction to completely finish 6377d20c68SJosef Bacik * | if there is one. 6477d20c68SJosef Bacik * | 6561c047b5SQu Wenruo * Transaction N [[TRANS_STATE_COMMIT_START]] 6661c047b5SQu Wenruo * | 6777d20c68SJosef Bacik * | Then one of the following happens: 6861c047b5SQu Wenruo * | - Wait for all other trans handle holders to release. 6961c047b5SQu Wenruo * | The btrfs_commit_transaction() caller will do the commit work. 7061c047b5SQu Wenruo * | - Wait for current transaction to be committed by others. 7161c047b5SQu Wenruo * | Other btrfs_commit_transaction() caller will do the commit work. 7261c047b5SQu Wenruo * | 7361c047b5SQu Wenruo * | At this stage, only btrfs_join_transaction*() variants can attach 7461c047b5SQu Wenruo * | to this running transaction. 7561c047b5SQu Wenruo * | All other variants will wait for current one to finish and attach to 7661c047b5SQu Wenruo * | transaction N+1. 7761c047b5SQu Wenruo * | 7861c047b5SQu Wenruo * | To next stage: 7961c047b5SQu Wenruo * | Caller is chosen to commit transaction N, and all other trans handle 8061c047b5SQu Wenruo * | haven been released. 8161c047b5SQu Wenruo * V 8261c047b5SQu Wenruo * Transaction N [[TRANS_STATE_COMMIT_DOING]] 8361c047b5SQu Wenruo * | 8461c047b5SQu Wenruo * | The heavy lifting transaction work is started. 8561c047b5SQu Wenruo * | From running delayed refs (modifying extent tree) to creating pending 8661c047b5SQu Wenruo * | snapshots, running qgroups. 8761c047b5SQu Wenruo * | In short, modify supporting trees to reflect modifications of subvolume 8861c047b5SQu Wenruo * | trees. 8961c047b5SQu Wenruo * | 9061c047b5SQu Wenruo * | At this stage, all start_transaction() calls will wait for this 9161c047b5SQu Wenruo * | transaction to finish and attach to transaction N+1. 9261c047b5SQu Wenruo * | 9361c047b5SQu Wenruo * | To next stage: 9461c047b5SQu Wenruo * | Until all supporting trees are updated. 9561c047b5SQu Wenruo * V 9661c047b5SQu Wenruo * Transaction N [[TRANS_STATE_UNBLOCKED]] 9761c047b5SQu Wenruo * | Transaction N+1 9861c047b5SQu Wenruo * | All needed trees are modified, thus we only [[TRANS_STATE_RUNNING]] 9961c047b5SQu Wenruo * | need to write them back to disk and update | 10061c047b5SQu Wenruo * | super blocks. | 10161c047b5SQu Wenruo * | | 10261c047b5SQu Wenruo * | At this stage, new transaction is allowed to | 10361c047b5SQu Wenruo * | start. | 10461c047b5SQu Wenruo * | All new start_transaction() calls will be | 10561c047b5SQu Wenruo * | attached to transid N+1. | 10661c047b5SQu Wenruo * | | 10761c047b5SQu Wenruo * | To next stage: | 10861c047b5SQu Wenruo * | Until all tree blocks are super blocks are | 10961c047b5SQu Wenruo * | written to block devices | 11061c047b5SQu Wenruo * V | 11161c047b5SQu Wenruo * Transaction N [[TRANS_STATE_COMPLETED]] V 11261c047b5SQu Wenruo * All tree blocks and super blocks are written. Transaction N+1 11361c047b5SQu Wenruo * This transaction is finished and all its [[TRANS_STATE_COMMIT_START]] 11461c047b5SQu Wenruo * data structures will be cleaned up. | Life goes on 11561c047b5SQu Wenruo */ 116e8c9f186SDavid Sterba static const unsigned int btrfs_blocked_trans_types[TRANS_STATE_MAX] = { 1174a9d8bdeSMiao Xie [TRANS_STATE_RUNNING] = 0U, 11877d20c68SJosef Bacik [TRANS_STATE_COMMIT_PREP] = 0U, 119bcf3a3e7SNikolay Borisov [TRANS_STATE_COMMIT_START] = (__TRANS_START | __TRANS_ATTACH), 120bcf3a3e7SNikolay Borisov [TRANS_STATE_COMMIT_DOING] = (__TRANS_START | 1214a9d8bdeSMiao Xie __TRANS_ATTACH | 122a6d155d2SFilipe Manana __TRANS_JOIN | 123a6d155d2SFilipe Manana __TRANS_JOIN_NOSTART), 124bcf3a3e7SNikolay Borisov [TRANS_STATE_UNBLOCKED] = (__TRANS_START | 1254a9d8bdeSMiao Xie __TRANS_ATTACH | 1264a9d8bdeSMiao Xie __TRANS_JOIN | 127a6d155d2SFilipe Manana __TRANS_JOIN_NOLOCK | 128a6d155d2SFilipe Manana __TRANS_JOIN_NOSTART), 129d0c2f4faSFilipe Manana [TRANS_STATE_SUPER_COMMITTED] = (__TRANS_START | 130d0c2f4faSFilipe Manana __TRANS_ATTACH | 131d0c2f4faSFilipe Manana __TRANS_JOIN | 132d0c2f4faSFilipe Manana __TRANS_JOIN_NOLOCK | 133d0c2f4faSFilipe Manana __TRANS_JOIN_NOSTART), 134bcf3a3e7SNikolay Borisov [TRANS_STATE_COMPLETED] = (__TRANS_START | 1354a9d8bdeSMiao Xie __TRANS_ATTACH | 1364a9d8bdeSMiao Xie __TRANS_JOIN | 137a6d155d2SFilipe Manana __TRANS_JOIN_NOLOCK | 138a6d155d2SFilipe Manana __TRANS_JOIN_NOSTART), 1394a9d8bdeSMiao Xie }; 1404a9d8bdeSMiao Xie 141724e2315SJosef Bacik void btrfs_put_transaction(struct btrfs_transaction *transaction) 14279154b1bSChris Mason { 1439b64f57dSElena Reshetova WARN_ON(refcount_read(&transaction->use_count) == 0); 1449b64f57dSElena Reshetova if (refcount_dec_and_test(&transaction->use_count)) { 145a4abeea4SJosef Bacik BUG_ON(!list_empty(&transaction->list)); 1465c9d028bSLiu Bo WARN_ON(!RB_EMPTY_ROOT( 1475c9d028bSLiu Bo &transaction->delayed_refs.href_root.rb_root)); 14881f7eb00SJeff Mahoney WARN_ON(!RB_EMPTY_ROOT( 14981f7eb00SJeff Mahoney &transaction->delayed_refs.dirty_extent_root)); 1501262133bSJosef Bacik if (transaction->delayed_refs.pending_csums) 151ab8d0fc4SJeff Mahoney btrfs_err(transaction->fs_info, 152ab8d0fc4SJeff Mahoney "pending csums is %llu", 1531262133bSJosef Bacik transaction->delayed_refs.pending_csums); 1547785a663SFilipe Manana /* 1557785a663SFilipe Manana * If any block groups are found in ->deleted_bgs then it's 1567785a663SFilipe Manana * because the transaction was aborted and a commit did not 1577785a663SFilipe Manana * happen (things failed before writing the new superblock 1587785a663SFilipe Manana * and calling btrfs_finish_extent_commit()), so we can not 1597785a663SFilipe Manana * discard the physical locations of the block groups. 1607785a663SFilipe Manana */ 1617785a663SFilipe Manana while (!list_empty(&transaction->deleted_bgs)) { 16232da5386SDavid Sterba struct btrfs_block_group *cache; 1637785a663SFilipe Manana 1647785a663SFilipe Manana cache = list_first_entry(&transaction->deleted_bgs, 16532da5386SDavid Sterba struct btrfs_block_group, 1667785a663SFilipe Manana bg_list); 1677785a663SFilipe Manana list_del_init(&cache->bg_list); 1686b7304afSFilipe Manana btrfs_unfreeze_block_group(cache); 1697785a663SFilipe Manana btrfs_put_block_group(cache); 1707785a663SFilipe Manana } 171bbbf7243SNikolay Borisov WARN_ON(!list_empty(&transaction->dev_update_list)); 1724b5faeacSDavid Sterba kfree(transaction); 17379154b1bSChris Mason } 17478fae27eSChris Mason } 17579154b1bSChris Mason 176889bfa39SJosef Bacik static noinline void switch_commit_roots(struct btrfs_trans_handle *trans) 177817d52f8SJosef Bacik { 178889bfa39SJosef Bacik struct btrfs_transaction *cur_trans = trans->transaction; 17916916a88SNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 1809e351cc8SJosef Bacik struct btrfs_root *root, *tmp; 1819e351cc8SJosef Bacik 182dfba78dcSFilipe Manana /* 183dfba78dcSFilipe Manana * At this point no one can be using this transaction to modify any tree 184dfba78dcSFilipe Manana * and no one can start another transaction to modify any tree either. 185dfba78dcSFilipe Manana */ 186dfba78dcSFilipe Manana ASSERT(cur_trans->state == TRANS_STATE_COMMIT_DOING); 187dfba78dcSFilipe Manana 1889e351cc8SJosef Bacik down_write(&fs_info->commit_root_sem); 189d96b3424SFilipe Manana 190d96b3424SFilipe Manana if (test_bit(BTRFS_FS_RELOC_RUNNING, &fs_info->flags)) 191d96b3424SFilipe Manana fs_info->last_reloc_trans = trans->transid; 192d96b3424SFilipe Manana 193889bfa39SJosef Bacik list_for_each_entry_safe(root, tmp, &cur_trans->switch_commits, 1949e351cc8SJosef Bacik dirty_list) { 1959e351cc8SJosef Bacik list_del_init(&root->dirty_list); 196817d52f8SJosef Bacik free_extent_buffer(root->commit_root); 197817d52f8SJosef Bacik root->commit_root = btrfs_root_node(root); 19841e7acd3SNikolay Borisov extent_io_tree_release(&root->dirty_log_pages); 199370a11b8SQu Wenruo btrfs_qgroup_clean_swapped_blocks(root); 2009e351cc8SJosef Bacik } 2012b9dbef2SJosef Bacik 2022b9dbef2SJosef Bacik /* We can free old roots now. */ 203889bfa39SJosef Bacik spin_lock(&cur_trans->dropped_roots_lock); 204889bfa39SJosef Bacik while (!list_empty(&cur_trans->dropped_roots)) { 205889bfa39SJosef Bacik root = list_first_entry(&cur_trans->dropped_roots, 2062b9dbef2SJosef Bacik struct btrfs_root, root_list); 2072b9dbef2SJosef Bacik list_del_init(&root->root_list); 208889bfa39SJosef Bacik spin_unlock(&cur_trans->dropped_roots_lock); 209889bfa39SJosef Bacik btrfs_free_log(trans, root); 2102b9dbef2SJosef Bacik btrfs_drop_and_free_fs_root(fs_info, root); 211889bfa39SJosef Bacik spin_lock(&cur_trans->dropped_roots_lock); 2122b9dbef2SJosef Bacik } 213889bfa39SJosef Bacik spin_unlock(&cur_trans->dropped_roots_lock); 21427d56e62SJosef Bacik 2159e351cc8SJosef Bacik up_write(&fs_info->commit_root_sem); 216817d52f8SJosef Bacik } 217817d52f8SJosef Bacik 2180860adfdSMiao Xie static inline void extwriter_counter_inc(struct btrfs_transaction *trans, 2190860adfdSMiao Xie unsigned int type) 2200860adfdSMiao Xie { 2210860adfdSMiao Xie if (type & TRANS_EXTWRITERS) 2220860adfdSMiao Xie atomic_inc(&trans->num_extwriters); 2230860adfdSMiao Xie } 2240860adfdSMiao Xie 2250860adfdSMiao Xie static inline void extwriter_counter_dec(struct btrfs_transaction *trans, 2260860adfdSMiao Xie unsigned int type) 2270860adfdSMiao Xie { 2280860adfdSMiao Xie if (type & TRANS_EXTWRITERS) 2290860adfdSMiao Xie atomic_dec(&trans->num_extwriters); 2300860adfdSMiao Xie } 2310860adfdSMiao Xie 2320860adfdSMiao Xie static inline void extwriter_counter_init(struct btrfs_transaction *trans, 2330860adfdSMiao Xie unsigned int type) 2340860adfdSMiao Xie { 2350860adfdSMiao Xie atomic_set(&trans->num_extwriters, ((type & TRANS_EXTWRITERS) ? 1 : 0)); 2360860adfdSMiao Xie } 2370860adfdSMiao Xie 2380860adfdSMiao Xie static inline int extwriter_counter_read(struct btrfs_transaction *trans) 2390860adfdSMiao Xie { 2400860adfdSMiao Xie return atomic_read(&trans->num_extwriters); 241178260b2SMiao Xie } 242178260b2SMiao Xie 243d352ac68SChris Mason /* 24479bd3712SFilipe Manana * To be called after doing the chunk btree updates right after allocating a new 24579bd3712SFilipe Manana * chunk (after btrfs_chunk_alloc_add_chunk_item() is called), when removing a 24679bd3712SFilipe Manana * chunk after all chunk btree updates and after finishing the second phase of 24779bd3712SFilipe Manana * chunk allocation (btrfs_create_pending_block_groups()) in case some block 24879bd3712SFilipe Manana * group had its chunk item insertion delayed to the second phase. 249fb6dea26SJosef Bacik */ 250fb6dea26SJosef Bacik void btrfs_trans_release_chunk_metadata(struct btrfs_trans_handle *trans) 251fb6dea26SJosef Bacik { 252fb6dea26SJosef Bacik struct btrfs_fs_info *fs_info = trans->fs_info; 253fb6dea26SJosef Bacik 254fb6dea26SJosef Bacik if (!trans->chunk_bytes_reserved) 255fb6dea26SJosef Bacik return; 256fb6dea26SJosef Bacik 257fb6dea26SJosef Bacik btrfs_block_rsv_release(fs_info, &fs_info->chunk_block_rsv, 25863f018beSNikolay Borisov trans->chunk_bytes_reserved, NULL); 259fb6dea26SJosef Bacik trans->chunk_bytes_reserved = 0; 260fb6dea26SJosef Bacik } 261fb6dea26SJosef Bacik 262fb6dea26SJosef Bacik /* 263d352ac68SChris Mason * either allocate a new transaction or hop into the existing one 264d352ac68SChris Mason */ 2652ff7e61eSJeff Mahoney static noinline int join_transaction(struct btrfs_fs_info *fs_info, 2662ff7e61eSJeff Mahoney unsigned int type) 26779154b1bSChris Mason { 26879154b1bSChris Mason struct btrfs_transaction *cur_trans; 269a4abeea4SJosef Bacik 27019ae4e81SJan Schmidt spin_lock(&fs_info->trans_lock); 271d43317dcSChris Mason loop: 27249b25e05SJeff Mahoney /* The file system has been taken offline. No new transactions. */ 27384961539SJosef Bacik if (BTRFS_FS_ERROR(fs_info)) { 27419ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 27549b25e05SJeff Mahoney return -EROFS; 27649b25e05SJeff Mahoney } 27749b25e05SJeff Mahoney 27819ae4e81SJan Schmidt cur_trans = fs_info->running_transaction; 279a4abeea4SJosef Bacik if (cur_trans) { 280bf31f87fSDavid Sterba if (TRANS_ABORTED(cur_trans)) { 28119ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 28249b25e05SJeff Mahoney return cur_trans->aborted; 283871383beSDavid Sterba } 2844a9d8bdeSMiao Xie if (btrfs_blocked_trans_types[cur_trans->state] & type) { 285178260b2SMiao Xie spin_unlock(&fs_info->trans_lock); 286178260b2SMiao Xie return -EBUSY; 287178260b2SMiao Xie } 2889b64f57dSElena Reshetova refcount_inc(&cur_trans->use_count); 289a4abeea4SJosef Bacik atomic_inc(&cur_trans->num_writers); 2900860adfdSMiao Xie extwriter_counter_inc(cur_trans, type); 29119ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 292e1489b4fSIoannis Angelakopoulos btrfs_lockdep_acquire(fs_info, btrfs_trans_num_writers); 2935a9ba670SIoannis Angelakopoulos btrfs_lockdep_acquire(fs_info, btrfs_trans_num_extwriters); 294a4abeea4SJosef Bacik return 0; 295a4abeea4SJosef Bacik } 29619ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 297a4abeea4SJosef Bacik 298354aa0fbSMiao Xie /* 2994490e803SFilipe Manana * If we are ATTACH or TRANS_JOIN_NOSTART, we just want to catch the 3004490e803SFilipe Manana * current transaction, and commit it. If there is no transaction, just 3014490e803SFilipe Manana * return ENOENT. 302354aa0fbSMiao Xie */ 3034490e803SFilipe Manana if (type == TRANS_ATTACH || type == TRANS_JOIN_NOSTART) 304354aa0fbSMiao Xie return -ENOENT; 305354aa0fbSMiao Xie 3064a9d8bdeSMiao Xie /* 3074a9d8bdeSMiao Xie * JOIN_NOLOCK only happens during the transaction commit, so 3084a9d8bdeSMiao Xie * it is impossible that ->running_transaction is NULL 3094a9d8bdeSMiao Xie */ 3104a9d8bdeSMiao Xie BUG_ON(type == TRANS_JOIN_NOLOCK); 3114a9d8bdeSMiao Xie 3124b5faeacSDavid Sterba cur_trans = kmalloc(sizeof(*cur_trans), GFP_NOFS); 313db5b493aSTsutomu Itoh if (!cur_trans) 314db5b493aSTsutomu Itoh return -ENOMEM; 315d43317dcSChris Mason 316e1489b4fSIoannis Angelakopoulos btrfs_lockdep_acquire(fs_info, btrfs_trans_num_writers); 3175a9ba670SIoannis Angelakopoulos btrfs_lockdep_acquire(fs_info, btrfs_trans_num_extwriters); 318e1489b4fSIoannis Angelakopoulos 31919ae4e81SJan Schmidt spin_lock(&fs_info->trans_lock); 32019ae4e81SJan Schmidt if (fs_info->running_transaction) { 321d43317dcSChris Mason /* 322d43317dcSChris Mason * someone started a transaction after we unlocked. Make sure 3234a9d8bdeSMiao Xie * to redo the checks above 324d43317dcSChris Mason */ 3255a9ba670SIoannis Angelakopoulos btrfs_lockdep_release(fs_info, btrfs_trans_num_extwriters); 326e1489b4fSIoannis Angelakopoulos btrfs_lockdep_release(fs_info, btrfs_trans_num_writers); 3274b5faeacSDavid Sterba kfree(cur_trans); 328d43317dcSChris Mason goto loop; 32984961539SJosef Bacik } else if (BTRFS_FS_ERROR(fs_info)) { 330e4b50e14SDan Carpenter spin_unlock(&fs_info->trans_lock); 3315a9ba670SIoannis Angelakopoulos btrfs_lockdep_release(fs_info, btrfs_trans_num_extwriters); 332e1489b4fSIoannis Angelakopoulos btrfs_lockdep_release(fs_info, btrfs_trans_num_writers); 3334b5faeacSDavid Sterba kfree(cur_trans); 3347b8b92afSJosef Bacik return -EROFS; 335a4abeea4SJosef Bacik } 336d43317dcSChris Mason 337ab8d0fc4SJeff Mahoney cur_trans->fs_info = fs_info; 33848778179SFilipe Manana atomic_set(&cur_trans->pending_ordered, 0); 33948778179SFilipe Manana init_waitqueue_head(&cur_trans->pending_wait); 34013c5a93eSJosef Bacik atomic_set(&cur_trans->num_writers, 1); 3410860adfdSMiao Xie extwriter_counter_init(cur_trans, type); 34279154b1bSChris Mason init_waitqueue_head(&cur_trans->writer_wait); 34379154b1bSChris Mason init_waitqueue_head(&cur_trans->commit_wait); 3444a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_RUNNING; 345a4abeea4SJosef Bacik /* 346a4abeea4SJosef Bacik * One for this trans handle, one so it will live on until we 347a4abeea4SJosef Bacik * commit the transaction. 348a4abeea4SJosef Bacik */ 3499b64f57dSElena Reshetova refcount_set(&cur_trans->use_count, 2); 3503204d33cSJosef Bacik cur_trans->flags = 0; 351afd48513SArnd Bergmann cur_trans->start_time = ktime_get_seconds(); 35256bec294SChris Mason 353a099d0fdSAlexandru Moise memset(&cur_trans->delayed_refs, 0, sizeof(cur_trans->delayed_refs)); 354a099d0fdSAlexandru Moise 3555c9d028bSLiu Bo cur_trans->delayed_refs.href_root = RB_ROOT_CACHED; 3563368d001SQu Wenruo cur_trans->delayed_refs.dirty_extent_root = RB_ROOT; 357d7df2c79SJosef Bacik atomic_set(&cur_trans->delayed_refs.num_entries, 0); 35820b297d6SJan Schmidt 35920b297d6SJan Schmidt /* 36020b297d6SJan Schmidt * although the tree mod log is per file system and not per transaction, 36120b297d6SJan Schmidt * the log must never go across transaction boundaries. 36220b297d6SJan Schmidt */ 36320b297d6SJan Schmidt smp_mb(); 36431b1a2bdSJulia Lawall if (!list_empty(&fs_info->tree_mod_seq_list)) 3655d163e0eSJeff Mahoney WARN(1, KERN_ERR "BTRFS: tree_mod_seq_list not empty when creating a fresh transaction\n"); 36631b1a2bdSJulia Lawall if (!RB_EMPTY_ROOT(&fs_info->tree_mod_log)) 3675d163e0eSJeff Mahoney WARN(1, KERN_ERR "BTRFS: tree_mod_log rb tree not empty when creating a fresh transaction\n"); 368fc36ed7eSJan Schmidt atomic64_set(&fs_info->tree_mod_seq, 0); 36920b297d6SJan Schmidt 37056bec294SChris Mason spin_lock_init(&cur_trans->delayed_refs.lock); 37156bec294SChris Mason 3723063d29fSChris Mason INIT_LIST_HEAD(&cur_trans->pending_snapshots); 373bbbf7243SNikolay Borisov INIT_LIST_HEAD(&cur_trans->dev_update_list); 3749e351cc8SJosef Bacik INIT_LIST_HEAD(&cur_trans->switch_commits); 375ce93ec54SJosef Bacik INIT_LIST_HEAD(&cur_trans->dirty_bgs); 3761bbc621eSChris Mason INIT_LIST_HEAD(&cur_trans->io_bgs); 3772b9dbef2SJosef Bacik INIT_LIST_HEAD(&cur_trans->dropped_roots); 3781bbc621eSChris Mason mutex_init(&cur_trans->cache_write_mutex); 379ce93ec54SJosef Bacik spin_lock_init(&cur_trans->dirty_bgs_lock); 380e33e17eeSJeff Mahoney INIT_LIST_HEAD(&cur_trans->deleted_bgs); 3812b9dbef2SJosef Bacik spin_lock_init(&cur_trans->dropped_roots_lock); 38219ae4e81SJan Schmidt list_add_tail(&cur_trans->list, &fs_info->trans_list); 383c258d6e3SQu Wenruo extent_io_tree_init(fs_info, &cur_trans->dirty_pages, 38435da5a7eSDavid Sterba IO_TREE_TRANS_DIRTY_PAGES); 385fe119a6eSNikolay Borisov extent_io_tree_init(fs_info, &cur_trans->pinned_extents, 38635da5a7eSDavid Sterba IO_TREE_FS_PINNED_EXTENTS); 38719ae4e81SJan Schmidt fs_info->generation++; 38819ae4e81SJan Schmidt cur_trans->transid = fs_info->generation; 38919ae4e81SJan Schmidt fs_info->running_transaction = cur_trans; 39049b25e05SJeff Mahoney cur_trans->aborted = 0; 39119ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 39215ee9bc7SJosef Bacik 39379154b1bSChris Mason return 0; 39479154b1bSChris Mason } 39579154b1bSChris Mason 396d352ac68SChris Mason /* 39792a7cc42SQu Wenruo * This does all the record keeping required to make sure that a shareable root 39892a7cc42SQu Wenruo * is properly recorded in a given transaction. This is required to make sure 39992a7cc42SQu Wenruo * the old root from before we joined the transaction is deleted when the 40092a7cc42SQu Wenruo * transaction commits. 401d352ac68SChris Mason */ 4027585717fSChris Mason static int record_root_in_trans(struct btrfs_trans_handle *trans, 4036426c7adSQu Wenruo struct btrfs_root *root, 4046426c7adSQu Wenruo int force) 4056702ed49SChris Mason { 4060b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 40703a7e111SJosef Bacik int ret = 0; 4080b246afaSJeff Mahoney 40992a7cc42SQu Wenruo if ((test_bit(BTRFS_ROOT_SHAREABLE, &root->state) && 4106426c7adSQu Wenruo root->last_trans < trans->transid) || force) { 4114d31778aSQu Wenruo WARN_ON(!force && root->commit_root != root->node); 4125d4f98a2SYan Zheng 4137585717fSChris Mason /* 41427cdeb70SMiao Xie * see below for IN_TRANS_SETUP usage rules 4157585717fSChris Mason * we have the reloc mutex held now, so there 4167585717fSChris Mason * is only one writer in this function 4177585717fSChris Mason */ 41827cdeb70SMiao Xie set_bit(BTRFS_ROOT_IN_TRANS_SETUP, &root->state); 4197585717fSChris Mason 42027cdeb70SMiao Xie /* make sure readers find IN_TRANS_SETUP before 4217585717fSChris Mason * they find our root->last_trans update 4227585717fSChris Mason */ 4237585717fSChris Mason smp_wmb(); 4247585717fSChris Mason 425fc7cbcd4SDavid Sterba spin_lock(&fs_info->fs_roots_radix_lock); 4266426c7adSQu Wenruo if (root->last_trans == trans->transid && !force) { 427fc7cbcd4SDavid Sterba spin_unlock(&fs_info->fs_roots_radix_lock); 428a4abeea4SJosef Bacik return 0; 429a4abeea4SJosef Bacik } 430fc7cbcd4SDavid Sterba radix_tree_tag_set(&fs_info->fs_roots_radix, 4316702ed49SChris Mason (unsigned long)root->root_key.objectid, 4326702ed49SChris Mason BTRFS_ROOT_TRANS_TAG); 433fc7cbcd4SDavid Sterba spin_unlock(&fs_info->fs_roots_radix_lock); 4347585717fSChris Mason root->last_trans = trans->transid; 4357585717fSChris Mason 4367585717fSChris Mason /* this is pretty tricky. We don't want to 4377585717fSChris Mason * take the relocation lock in btrfs_record_root_in_trans 4387585717fSChris Mason * unless we're really doing the first setup for this root in 4397585717fSChris Mason * this transaction. 4407585717fSChris Mason * 4417585717fSChris Mason * Normally we'd use root->last_trans as a flag to decide 4427585717fSChris Mason * if we want to take the expensive mutex. 4437585717fSChris Mason * 4447585717fSChris Mason * But, we have to set root->last_trans before we 4457585717fSChris Mason * init the relocation root, otherwise, we trip over warnings 4467585717fSChris Mason * in ctree.c. The solution used here is to flag ourselves 44727cdeb70SMiao Xie * with root IN_TRANS_SETUP. When this is 1, we're still 4487585717fSChris Mason * fixing up the reloc trees and everyone must wait. 4497585717fSChris Mason * 4507585717fSChris Mason * When this is zero, they can trust root->last_trans and fly 4517585717fSChris Mason * through btrfs_record_root_in_trans without having to take the 4527585717fSChris Mason * lock. smp_wmb() makes sure that all the writes above are 4537585717fSChris Mason * done before we pop in the zero below 4547585717fSChris Mason */ 45503a7e111SJosef Bacik ret = btrfs_init_reloc_root(trans, root); 456c7548af6SChris Mason smp_mb__before_atomic(); 45727cdeb70SMiao Xie clear_bit(BTRFS_ROOT_IN_TRANS_SETUP, &root->state); 4586702ed49SChris Mason } 45903a7e111SJosef Bacik return ret; 4606702ed49SChris Mason } 4615d4f98a2SYan Zheng 4627585717fSChris Mason 4632b9dbef2SJosef Bacik void btrfs_add_dropped_root(struct btrfs_trans_handle *trans, 4642b9dbef2SJosef Bacik struct btrfs_root *root) 4652b9dbef2SJosef Bacik { 4660b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 4672b9dbef2SJosef Bacik struct btrfs_transaction *cur_trans = trans->transaction; 4682b9dbef2SJosef Bacik 4692b9dbef2SJosef Bacik /* Add ourselves to the transaction dropped list */ 4702b9dbef2SJosef Bacik spin_lock(&cur_trans->dropped_roots_lock); 4712b9dbef2SJosef Bacik list_add_tail(&root->root_list, &cur_trans->dropped_roots); 4722b9dbef2SJosef Bacik spin_unlock(&cur_trans->dropped_roots_lock); 4732b9dbef2SJosef Bacik 4742b9dbef2SJosef Bacik /* Make sure we don't try to update the root at commit time */ 475fc7cbcd4SDavid Sterba spin_lock(&fs_info->fs_roots_radix_lock); 476fc7cbcd4SDavid Sterba radix_tree_tag_clear(&fs_info->fs_roots_radix, 4772b9dbef2SJosef Bacik (unsigned long)root->root_key.objectid, 4782b9dbef2SJosef Bacik BTRFS_ROOT_TRANS_TAG); 479fc7cbcd4SDavid Sterba spin_unlock(&fs_info->fs_roots_radix_lock); 4802b9dbef2SJosef Bacik } 4812b9dbef2SJosef Bacik 4827585717fSChris Mason int btrfs_record_root_in_trans(struct btrfs_trans_handle *trans, 4837585717fSChris Mason struct btrfs_root *root) 4847585717fSChris Mason { 4850b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 4861409e6ccSJosef Bacik int ret; 4870b246afaSJeff Mahoney 48892a7cc42SQu Wenruo if (!test_bit(BTRFS_ROOT_SHAREABLE, &root->state)) 4897585717fSChris Mason return 0; 4907585717fSChris Mason 4917585717fSChris Mason /* 49227cdeb70SMiao Xie * see record_root_in_trans for comments about IN_TRANS_SETUP usage 4937585717fSChris Mason * and barriers 4947585717fSChris Mason */ 4957585717fSChris Mason smp_rmb(); 4967585717fSChris Mason if (root->last_trans == trans->transid && 49727cdeb70SMiao Xie !test_bit(BTRFS_ROOT_IN_TRANS_SETUP, &root->state)) 4987585717fSChris Mason return 0; 4997585717fSChris Mason 5000b246afaSJeff Mahoney mutex_lock(&fs_info->reloc_mutex); 5011409e6ccSJosef Bacik ret = record_root_in_trans(trans, root, 0); 5020b246afaSJeff Mahoney mutex_unlock(&fs_info->reloc_mutex); 5037585717fSChris Mason 5041409e6ccSJosef Bacik return ret; 5057585717fSChris Mason } 5067585717fSChris Mason 5074a9d8bdeSMiao Xie static inline int is_transaction_blocked(struct btrfs_transaction *trans) 5084a9d8bdeSMiao Xie { 5093296bf56SQu Wenruo return (trans->state >= TRANS_STATE_COMMIT_START && 510501407aaSJosef Bacik trans->state < TRANS_STATE_UNBLOCKED && 511bf31f87fSDavid Sterba !TRANS_ABORTED(trans)); 5124a9d8bdeSMiao Xie } 5134a9d8bdeSMiao Xie 514d352ac68SChris Mason /* wait for commit against the current transaction to become unblocked 515d352ac68SChris Mason * when this is done, it is safe to start a new transaction, but the current 516d352ac68SChris Mason * transaction might not be fully on disk. 517d352ac68SChris Mason */ 5182ff7e61eSJeff Mahoney static void wait_current_trans(struct btrfs_fs_info *fs_info) 51979154b1bSChris Mason { 520f9295749SChris Mason struct btrfs_transaction *cur_trans; 52179154b1bSChris Mason 5220b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 5230b246afaSJeff Mahoney cur_trans = fs_info->running_transaction; 5244a9d8bdeSMiao Xie if (cur_trans && is_transaction_blocked(cur_trans)) { 5259b64f57dSElena Reshetova refcount_inc(&cur_trans->use_count); 5260b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 52772d63ed6SLi Zefan 5283e738c53SIoannis Angelakopoulos btrfs_might_wait_for_state(fs_info, BTRFS_LOCKDEP_TRANS_UNBLOCKED); 5290b246afaSJeff Mahoney wait_event(fs_info->transaction_wait, 530501407aaSJosef Bacik cur_trans->state >= TRANS_STATE_UNBLOCKED || 531bf31f87fSDavid Sterba TRANS_ABORTED(cur_trans)); 532724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 533a4abeea4SJosef Bacik } else { 5340b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 535f9295749SChris Mason } 53637d1aeeeSChris Mason } 53737d1aeeeSChris Mason 5382ff7e61eSJeff Mahoney static int may_wait_transaction(struct btrfs_fs_info *fs_info, int type) 53937d1aeeeSChris Mason { 5400b246afaSJeff Mahoney if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags)) 541a4abeea4SJosef Bacik return 0; 542a4abeea4SJosef Bacik 54392e2f7e3SNikolay Borisov if (type == TRANS_START) 544a4abeea4SJosef Bacik return 1; 545a4abeea4SJosef Bacik 546a22285a6SYan, Zheng return 0; 547a22285a6SYan, Zheng } 548a22285a6SYan, Zheng 54920dd2cbfSMiao Xie static inline bool need_reserve_reloc_root(struct btrfs_root *root) 55020dd2cbfSMiao Xie { 5510b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 5520b246afaSJeff Mahoney 5530b246afaSJeff Mahoney if (!fs_info->reloc_ctl || 55492a7cc42SQu Wenruo !test_bit(BTRFS_ROOT_SHAREABLE, &root->state) || 55520dd2cbfSMiao Xie root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID || 55620dd2cbfSMiao Xie root->reloc_root) 55720dd2cbfSMiao Xie return false; 55820dd2cbfSMiao Xie 55920dd2cbfSMiao Xie return true; 56020dd2cbfSMiao Xie } 56120dd2cbfSMiao Xie 56208e007d2SMiao Xie static struct btrfs_trans_handle * 5635aed1dd8SAlexandru Moise start_transaction(struct btrfs_root *root, unsigned int num_items, 564003d7c59SJeff Mahoney unsigned int type, enum btrfs_reserve_flush_enum flush, 565003d7c59SJeff Mahoney bool enforce_qgroups) 566a22285a6SYan, Zheng { 5670b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 568ba2c4d4eSJosef Bacik struct btrfs_block_rsv *delayed_refs_rsv = &fs_info->delayed_refs_rsv; 569a22285a6SYan, Zheng struct btrfs_trans_handle *h; 570a22285a6SYan, Zheng struct btrfs_transaction *cur_trans; 571b5009945SJosef Bacik u64 num_bytes = 0; 572c5567237SArne Jansen u64 qgroup_reserved = 0; 57320dd2cbfSMiao Xie bool reloc_reserved = false; 5749c343784SJosef Bacik bool do_chunk_alloc = false; 57520dd2cbfSMiao Xie int ret; 576acce952bSliubo 57784961539SJosef Bacik if (BTRFS_FS_ERROR(fs_info)) 578acce952bSliubo return ERR_PTR(-EROFS); 5792a1eb461SJosef Bacik 58046c4e71eSFilipe Manana if (current->journal_info) { 5810860adfdSMiao Xie WARN_ON(type & TRANS_EXTWRITERS); 5822a1eb461SJosef Bacik h = current->journal_info; 583b50fff81SDavid Sterba refcount_inc(&h->use_count); 584b50fff81SDavid Sterba WARN_ON(refcount_read(&h->use_count) > 2); 5852a1eb461SJosef Bacik h->orig_rsv = h->block_rsv; 5862a1eb461SJosef Bacik h->block_rsv = NULL; 5872a1eb461SJosef Bacik goto got_it; 5882a1eb461SJosef Bacik } 589b5009945SJosef Bacik 590b5009945SJosef Bacik /* 591b5009945SJosef Bacik * Do the reservation before we join the transaction so we can do all 592b5009945SJosef Bacik * the appropriate flushing if need be. 593b5009945SJosef Bacik */ 594003d7c59SJeff Mahoney if (num_items && root != fs_info->chunk_root) { 595ba2c4d4eSJosef Bacik struct btrfs_block_rsv *rsv = &fs_info->trans_block_rsv; 596ba2c4d4eSJosef Bacik u64 delayed_refs_bytes = 0; 597ba2c4d4eSJosef Bacik 5980b246afaSJeff Mahoney qgroup_reserved = num_items * fs_info->nodesize; 599a6496849SBoris Burkov /* 600a6496849SBoris Burkov * Use prealloc for now, as there might be a currently running 601a6496849SBoris Burkov * transaction that could free this reserved space prematurely 602a6496849SBoris Burkov * by committing. 603a6496849SBoris Burkov */ 604a6496849SBoris Burkov ret = btrfs_qgroup_reserve_meta_prealloc(root, qgroup_reserved, 605a6496849SBoris Burkov enforce_qgroups, false); 606c5567237SArne Jansen if (ret) 607c5567237SArne Jansen return ERR_PTR(ret); 608c5567237SArne Jansen 609ba2c4d4eSJosef Bacik /* 610ba2c4d4eSJosef Bacik * We want to reserve all the bytes we may need all at once, so 611ba2c4d4eSJosef Bacik * we only do 1 enospc flushing cycle per transaction start. We 6120f69d1f4SFilipe Manana * accomplish this by simply assuming we'll do num_items worth 6130f69d1f4SFilipe Manana * of delayed refs updates in this trans handle, and refill that 6140f69d1f4SFilipe Manana * amount for whatever is missing in the reserve. 615ba2c4d4eSJosef Bacik */ 6162bd36e7bSJosef Bacik num_bytes = btrfs_calc_insert_metadata_size(fs_info, num_items); 6177f9fe614SJosef Bacik if (flush == BTRFS_RESERVE_FLUSH_ALL && 618e4773b57SFilipe Manana !btrfs_block_rsv_full(delayed_refs_rsv)) { 6190f69d1f4SFilipe Manana delayed_refs_bytes = btrfs_calc_delayed_ref_bytes(fs_info, 6200f69d1f4SFilipe Manana num_items); 6210f69d1f4SFilipe Manana num_bytes += delayed_refs_bytes; 622ba2c4d4eSJosef Bacik } 623ba2c4d4eSJosef Bacik 62420dd2cbfSMiao Xie /* 62520dd2cbfSMiao Xie * Do the reservation for the relocation root creation 62620dd2cbfSMiao Xie */ 627ee39b432SDavid Sterba if (need_reserve_reloc_root(root)) { 6280b246afaSJeff Mahoney num_bytes += fs_info->nodesize; 62920dd2cbfSMiao Xie reloc_reserved = true; 63020dd2cbfSMiao Xie } 63120dd2cbfSMiao Xie 632a7ddeeb0SFilipe Manana ret = btrfs_reserve_metadata_bytes(fs_info, rsv, num_bytes, flush); 633ba2c4d4eSJosef Bacik if (ret) 634ba2c4d4eSJosef Bacik goto reserve_fail; 635ba2c4d4eSJosef Bacik if (delayed_refs_bytes) { 636a7ddeeb0SFilipe Manana btrfs_migrate_to_delayed_refs_rsv(fs_info, delayed_refs_bytes); 637ba2c4d4eSJosef Bacik num_bytes -= delayed_refs_bytes; 638ba2c4d4eSJosef Bacik } 639a7ddeeb0SFilipe Manana btrfs_block_rsv_add_bytes(rsv, num_bytes, true); 6409c343784SJosef Bacik 6419c343784SJosef Bacik if (rsv->space_info->force_alloc) 6429c343784SJosef Bacik do_chunk_alloc = true; 643ba2c4d4eSJosef Bacik } else if (num_items == 0 && flush == BTRFS_RESERVE_FLUSH_ALL && 644748f553cSDavid Sterba !btrfs_block_rsv_full(delayed_refs_rsv)) { 645ba2c4d4eSJosef Bacik /* 646ba2c4d4eSJosef Bacik * Some people call with btrfs_start_transaction(root, 0) 647ba2c4d4eSJosef Bacik * because they can be throttled, but have some other mechanism 648ba2c4d4eSJosef Bacik * for reserving space. We still want these guys to refill the 649ba2c4d4eSJosef Bacik * delayed block_rsv so just add 1 items worth of reservation 650ba2c4d4eSJosef Bacik * here. 651ba2c4d4eSJosef Bacik */ 652ba2c4d4eSJosef Bacik ret = btrfs_delayed_refs_rsv_refill(fs_info, flush); 653b5009945SJosef Bacik if (ret) 654843fcf35SMiao Xie goto reserve_fail; 655b5009945SJosef Bacik } 656a22285a6SYan, Zheng again: 657f2f767e7SAlexandru Moise h = kmem_cache_zalloc(btrfs_trans_handle_cachep, GFP_NOFS); 658843fcf35SMiao Xie if (!h) { 659843fcf35SMiao Xie ret = -ENOMEM; 660843fcf35SMiao Xie goto alloc_fail; 661843fcf35SMiao Xie } 662a22285a6SYan, Zheng 66398114659SJosef Bacik /* 66498114659SJosef Bacik * If we are JOIN_NOLOCK we're already committing a transaction and 66598114659SJosef Bacik * waiting on this guy, so we don't need to do the sb_start_intwrite 66698114659SJosef Bacik * because we're already holding a ref. We need this because we could 66798114659SJosef Bacik * have raced in and did an fsync() on a file which can kick a commit 66898114659SJosef Bacik * and then we deadlock with somebody doing a freeze. 669354aa0fbSMiao Xie * 670354aa0fbSMiao Xie * If we are ATTACH, it means we just want to catch the current 671354aa0fbSMiao Xie * transaction and commit it, so we needn't do sb_start_intwrite(). 67298114659SJosef Bacik */ 6730860adfdSMiao Xie if (type & __TRANS_FREEZABLE) 6740b246afaSJeff Mahoney sb_start_intwrite(fs_info->sb); 675b2b5ef5cSJan Kara 6762ff7e61eSJeff Mahoney if (may_wait_transaction(fs_info, type)) 6772ff7e61eSJeff Mahoney wait_current_trans(fs_info); 678a22285a6SYan, Zheng 679a4abeea4SJosef Bacik do { 6802ff7e61eSJeff Mahoney ret = join_transaction(fs_info, type); 681178260b2SMiao Xie if (ret == -EBUSY) { 6822ff7e61eSJeff Mahoney wait_current_trans(fs_info); 683a6d155d2SFilipe Manana if (unlikely(type == TRANS_ATTACH || 684a6d155d2SFilipe Manana type == TRANS_JOIN_NOSTART)) 685178260b2SMiao Xie ret = -ENOENT; 686178260b2SMiao Xie } 687a4abeea4SJosef Bacik } while (ret == -EBUSY); 688a4abeea4SJosef Bacik 689a43f7f82SLiu Bo if (ret < 0) 690843fcf35SMiao Xie goto join_fail; 6910f7d52f4SChris Mason 6920b246afaSJeff Mahoney cur_trans = fs_info->running_transaction; 693a22285a6SYan, Zheng 694a22285a6SYan, Zheng h->transid = cur_trans->transid; 695a22285a6SYan, Zheng h->transaction = cur_trans; 696b50fff81SDavid Sterba refcount_set(&h->use_count, 1); 69764b63580SJeff Mahoney h->fs_info = root->fs_info; 6987174109cSQu Wenruo 699a698d075SMiao Xie h->type = type; 700ea658badSJosef Bacik INIT_LIST_HEAD(&h->new_bgs); 701b7ec40d7SChris Mason 702a22285a6SYan, Zheng smp_mb(); 7033296bf56SQu Wenruo if (cur_trans->state >= TRANS_STATE_COMMIT_START && 7042ff7e61eSJeff Mahoney may_wait_transaction(fs_info, type)) { 705abdd2e80SFilipe Manana current->journal_info = h; 7063a45bb20SJeff Mahoney btrfs_commit_transaction(h); 707a22285a6SYan, Zheng goto again; 708a22285a6SYan, Zheng } 7099ed74f2dSJosef Bacik 710b5009945SJosef Bacik if (num_bytes) { 7110b246afaSJeff Mahoney trace_btrfs_space_reservation(fs_info, "transaction", 7122bcc0328SLiu Bo h->transid, num_bytes, 1); 7130b246afaSJeff Mahoney h->block_rsv = &fs_info->trans_block_rsv; 714b5009945SJosef Bacik h->bytes_reserved = num_bytes; 71520dd2cbfSMiao Xie h->reloc_reserved = reloc_reserved; 716a22285a6SYan, Zheng } 717a22285a6SYan, Zheng 718a6496849SBoris Burkov /* 719a6496849SBoris Burkov * Now that we have found a transaction to be a part of, convert the 720a6496849SBoris Burkov * qgroup reservation from prealloc to pertrans. A different transaction 721a6496849SBoris Burkov * can't race in and free our pertrans out from under us. 722a6496849SBoris Burkov */ 723a6496849SBoris Burkov if (qgroup_reserved) 724a6496849SBoris Burkov btrfs_qgroup_convert_reserved_meta(root, qgroup_reserved); 725a6496849SBoris Burkov 7262a1eb461SJosef Bacik got_it: 727bcf3a3e7SNikolay Borisov if (!current->journal_info) 728a22285a6SYan, Zheng current->journal_info = h; 729fcc99734SQu Wenruo 730fcc99734SQu Wenruo /* 7319c343784SJosef Bacik * If the space_info is marked ALLOC_FORCE then we'll get upgraded to 7329c343784SJosef Bacik * ALLOC_FORCE the first run through, and then we won't allocate for 7339c343784SJosef Bacik * anybody else who races in later. We don't care about the return 7349c343784SJosef Bacik * value here. 7359c343784SJosef Bacik */ 7369c343784SJosef Bacik if (do_chunk_alloc && num_bytes) { 7379c343784SJosef Bacik u64 flags = h->block_rsv->space_info->flags; 7389c343784SJosef Bacik 7399c343784SJosef Bacik btrfs_chunk_alloc(h, btrfs_get_alloc_profile(fs_info, flags), 7409c343784SJosef Bacik CHUNK_ALLOC_NO_FORCE); 7419c343784SJosef Bacik } 7429c343784SJosef Bacik 7439c343784SJosef Bacik /* 744fcc99734SQu Wenruo * btrfs_record_root_in_trans() needs to alloc new extents, and may 745fcc99734SQu Wenruo * call btrfs_join_transaction() while we're also starting a 746fcc99734SQu Wenruo * transaction. 747fcc99734SQu Wenruo * 748fcc99734SQu Wenruo * Thus it need to be called after current->journal_info initialized, 749fcc99734SQu Wenruo * or we can deadlock. 750fcc99734SQu Wenruo */ 75168075ea8SJosef Bacik ret = btrfs_record_root_in_trans(h, root); 75268075ea8SJosef Bacik if (ret) { 75368075ea8SJosef Bacik /* 75468075ea8SJosef Bacik * The transaction handle is fully initialized and linked with 75568075ea8SJosef Bacik * other structures so it needs to be ended in case of errors, 75668075ea8SJosef Bacik * not just freed. 75768075ea8SJosef Bacik */ 75868075ea8SJosef Bacik btrfs_end_transaction(h); 75968075ea8SJosef Bacik return ERR_PTR(ret); 76068075ea8SJosef Bacik } 761fcc99734SQu Wenruo 76279154b1bSChris Mason return h; 763843fcf35SMiao Xie 764843fcf35SMiao Xie join_fail: 7650860adfdSMiao Xie if (type & __TRANS_FREEZABLE) 7660b246afaSJeff Mahoney sb_end_intwrite(fs_info->sb); 767843fcf35SMiao Xie kmem_cache_free(btrfs_trans_handle_cachep, h); 768843fcf35SMiao Xie alloc_fail: 769843fcf35SMiao Xie if (num_bytes) 7702ff7e61eSJeff Mahoney btrfs_block_rsv_release(fs_info, &fs_info->trans_block_rsv, 77163f018beSNikolay Borisov num_bytes, NULL); 772843fcf35SMiao Xie reserve_fail: 773a6496849SBoris Burkov btrfs_qgroup_free_meta_prealloc(root, qgroup_reserved); 774843fcf35SMiao Xie return ERR_PTR(ret); 77579154b1bSChris Mason } 77679154b1bSChris Mason 777f9295749SChris Mason struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root, 7785aed1dd8SAlexandru Moise unsigned int num_items) 779f9295749SChris Mason { 78008e007d2SMiao Xie return start_transaction(root, num_items, TRANS_START, 781003d7c59SJeff Mahoney BTRFS_RESERVE_FLUSH_ALL, true); 782f9295749SChris Mason } 783003d7c59SJeff Mahoney 7848eab77ffSFilipe Manana struct btrfs_trans_handle *btrfs_start_transaction_fallback_global_rsv( 7858eab77ffSFilipe Manana struct btrfs_root *root, 7867f9fe614SJosef Bacik unsigned int num_items) 7878eab77ffSFilipe Manana { 7887f9fe614SJosef Bacik return start_transaction(root, num_items, TRANS_START, 7897f9fe614SJosef Bacik BTRFS_RESERVE_FLUSH_ALL_STEAL, false); 7908eab77ffSFilipe Manana } 7918407aa46SMiao Xie 7927a7eaa40SJosef Bacik struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root) 793f9295749SChris Mason { 794003d7c59SJeff Mahoney return start_transaction(root, 0, TRANS_JOIN, BTRFS_RESERVE_NO_FLUSH, 795003d7c59SJeff Mahoney true); 796f9295749SChris Mason } 797f9295749SChris Mason 7988d510121SNikolay Borisov struct btrfs_trans_handle *btrfs_join_transaction_spacecache(struct btrfs_root *root) 7990af3d00bSJosef Bacik { 800575a75d6SAlexandru Moise return start_transaction(root, 0, TRANS_JOIN_NOLOCK, 801003d7c59SJeff Mahoney BTRFS_RESERVE_NO_FLUSH, true); 8020af3d00bSJosef Bacik } 8030af3d00bSJosef Bacik 804d4edf39bSMiao Xie /* 805a6d155d2SFilipe Manana * Similar to regular join but it never starts a transaction when none is 80619288951SFilipe Manana * running or when there's a running one at a state >= TRANS_STATE_UNBLOCKED. 80719288951SFilipe Manana * This is similar to btrfs_attach_transaction() but it allows the join to 80819288951SFilipe Manana * happen if the transaction commit already started but it's not yet in the 80919288951SFilipe Manana * "doing" phase (the state is < TRANS_STATE_COMMIT_DOING). 810a6d155d2SFilipe Manana */ 811a6d155d2SFilipe Manana struct btrfs_trans_handle *btrfs_join_transaction_nostart(struct btrfs_root *root) 812a6d155d2SFilipe Manana { 813a6d155d2SFilipe Manana return start_transaction(root, 0, TRANS_JOIN_NOSTART, 814a6d155d2SFilipe Manana BTRFS_RESERVE_NO_FLUSH, true); 815a6d155d2SFilipe Manana } 816a6d155d2SFilipe Manana 817a6d155d2SFilipe Manana /* 818d4edf39bSMiao Xie * btrfs_attach_transaction() - catch the running transaction 819d4edf39bSMiao Xie * 820d4edf39bSMiao Xie * It is used when we want to commit the current the transaction, but 821d4edf39bSMiao Xie * don't want to start a new one. 822d4edf39bSMiao Xie * 823d4edf39bSMiao Xie * Note: If this function return -ENOENT, it just means there is no 824d4edf39bSMiao Xie * running transaction. But it is possible that the inactive transaction 825d4edf39bSMiao Xie * is still in the memory, not fully on disk. If you hope there is no 826d4edf39bSMiao Xie * inactive transaction in the fs when -ENOENT is returned, you should 827d4edf39bSMiao Xie * invoke 828d4edf39bSMiao Xie * btrfs_attach_transaction_barrier() 829d4edf39bSMiao Xie */ 830354aa0fbSMiao Xie struct btrfs_trans_handle *btrfs_attach_transaction(struct btrfs_root *root) 83160376ce4SJosef Bacik { 832575a75d6SAlexandru Moise return start_transaction(root, 0, TRANS_ATTACH, 833003d7c59SJeff Mahoney BTRFS_RESERVE_NO_FLUSH, true); 83460376ce4SJosef Bacik } 83560376ce4SJosef Bacik 836d4edf39bSMiao Xie /* 83790b6d283SWang Sheng-Hui * btrfs_attach_transaction_barrier() - catch the running transaction 838d4edf39bSMiao Xie * 83952042d8eSAndrea Gelmini * It is similar to the above function, the difference is this one 840d4edf39bSMiao Xie * will wait for all the inactive transactions until they fully 841d4edf39bSMiao Xie * complete. 842d4edf39bSMiao Xie */ 843d4edf39bSMiao Xie struct btrfs_trans_handle * 844d4edf39bSMiao Xie btrfs_attach_transaction_barrier(struct btrfs_root *root) 845d4edf39bSMiao Xie { 846d4edf39bSMiao Xie struct btrfs_trans_handle *trans; 847d4edf39bSMiao Xie 848575a75d6SAlexandru Moise trans = start_transaction(root, 0, TRANS_ATTACH, 849003d7c59SJeff Mahoney BTRFS_RESERVE_NO_FLUSH, true); 850b28ff3a7SFilipe Manana if (trans == ERR_PTR(-ENOENT)) { 851b28ff3a7SFilipe Manana int ret; 852b28ff3a7SFilipe Manana 853b28ff3a7SFilipe Manana ret = btrfs_wait_for_commit(root->fs_info, 0); 854b28ff3a7SFilipe Manana if (ret) 855b28ff3a7SFilipe Manana return ERR_PTR(ret); 856b28ff3a7SFilipe Manana } 857d4edf39bSMiao Xie 858d4edf39bSMiao Xie return trans; 859d4edf39bSMiao Xie } 860d4edf39bSMiao Xie 861d0c2f4faSFilipe Manana /* Wait for a transaction commit to reach at least the given state. */ 862d0c2f4faSFilipe Manana static noinline void wait_for_commit(struct btrfs_transaction *commit, 863d0c2f4faSFilipe Manana const enum btrfs_trans_state min_state) 86489ce8a63SChris Mason { 8655fd76bf3SOmar Sandoval struct btrfs_fs_info *fs_info = commit->fs_info; 8665fd76bf3SOmar Sandoval u64 transid = commit->transid; 8675fd76bf3SOmar Sandoval bool put = false; 8685fd76bf3SOmar Sandoval 8693e738c53SIoannis Angelakopoulos /* 8703e738c53SIoannis Angelakopoulos * At the moment this function is called with min_state either being 8713e738c53SIoannis Angelakopoulos * TRANS_STATE_COMPLETED or TRANS_STATE_SUPER_COMMITTED. 8723e738c53SIoannis Angelakopoulos */ 8733e738c53SIoannis Angelakopoulos if (min_state == TRANS_STATE_COMPLETED) 8743e738c53SIoannis Angelakopoulos btrfs_might_wait_for_state(fs_info, BTRFS_LOCKDEP_TRANS_COMPLETED); 8753e738c53SIoannis Angelakopoulos else 8763e738c53SIoannis Angelakopoulos btrfs_might_wait_for_state(fs_info, BTRFS_LOCKDEP_TRANS_SUPER_COMMITTED); 8773e738c53SIoannis Angelakopoulos 8785fd76bf3SOmar Sandoval while (1) { 879d0c2f4faSFilipe Manana wait_event(commit->commit_wait, commit->state >= min_state); 8805fd76bf3SOmar Sandoval if (put) 8815fd76bf3SOmar Sandoval btrfs_put_transaction(commit); 8825fd76bf3SOmar Sandoval 8835fd76bf3SOmar Sandoval if (min_state < TRANS_STATE_COMPLETED) 8845fd76bf3SOmar Sandoval break; 8855fd76bf3SOmar Sandoval 8865fd76bf3SOmar Sandoval /* 8875fd76bf3SOmar Sandoval * A transaction isn't really completed until all of the 8885fd76bf3SOmar Sandoval * previous transactions are completed, but with fsync we can 8895fd76bf3SOmar Sandoval * end up with SUPER_COMMITTED transactions before a COMPLETED 8905fd76bf3SOmar Sandoval * transaction. Wait for those. 8915fd76bf3SOmar Sandoval */ 8925fd76bf3SOmar Sandoval 8935fd76bf3SOmar Sandoval spin_lock(&fs_info->trans_lock); 8945fd76bf3SOmar Sandoval commit = list_first_entry_or_null(&fs_info->trans_list, 8955fd76bf3SOmar Sandoval struct btrfs_transaction, 8965fd76bf3SOmar Sandoval list); 8975fd76bf3SOmar Sandoval if (!commit || commit->transid > transid) { 8985fd76bf3SOmar Sandoval spin_unlock(&fs_info->trans_lock); 8995fd76bf3SOmar Sandoval break; 9005fd76bf3SOmar Sandoval } 9015fd76bf3SOmar Sandoval refcount_inc(&commit->use_count); 9025fd76bf3SOmar Sandoval put = true; 9035fd76bf3SOmar Sandoval spin_unlock(&fs_info->trans_lock); 9045fd76bf3SOmar Sandoval } 90589ce8a63SChris Mason } 90689ce8a63SChris Mason 9072ff7e61eSJeff Mahoney int btrfs_wait_for_commit(struct btrfs_fs_info *fs_info, u64 transid) 90846204592SSage Weil { 90946204592SSage Weil struct btrfs_transaction *cur_trans = NULL, *t; 9108cd2807fSMiao Xie int ret = 0; 91146204592SSage Weil 91246204592SSage Weil if (transid) { 9130b246afaSJeff Mahoney if (transid <= fs_info->last_trans_committed) 914a4abeea4SJosef Bacik goto out; 91546204592SSage Weil 91646204592SSage Weil /* find specified transaction */ 9170b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 9180b246afaSJeff Mahoney list_for_each_entry(t, &fs_info->trans_list, list) { 91946204592SSage Weil if (t->transid == transid) { 92046204592SSage Weil cur_trans = t; 9219b64f57dSElena Reshetova refcount_inc(&cur_trans->use_count); 9228cd2807fSMiao Xie ret = 0; 92346204592SSage Weil break; 92446204592SSage Weil } 9258cd2807fSMiao Xie if (t->transid > transid) { 9268cd2807fSMiao Xie ret = 0; 92746204592SSage Weil break; 92846204592SSage Weil } 9298cd2807fSMiao Xie } 9300b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 93142383020SSage Weil 93242383020SSage Weil /* 93342383020SSage Weil * The specified transaction doesn't exist, or we 93442383020SSage Weil * raced with btrfs_commit_transaction 93542383020SSage Weil */ 93642383020SSage Weil if (!cur_trans) { 9370b246afaSJeff Mahoney if (transid > fs_info->last_trans_committed) 93842383020SSage Weil ret = -EINVAL; 9398cd2807fSMiao Xie goto out; 94042383020SSage Weil } 94146204592SSage Weil } else { 94246204592SSage Weil /* find newest transaction that is committing | committed */ 9430b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 9440b246afaSJeff Mahoney list_for_each_entry_reverse(t, &fs_info->trans_list, 94546204592SSage Weil list) { 9464a9d8bdeSMiao Xie if (t->state >= TRANS_STATE_COMMIT_START) { 9474a9d8bdeSMiao Xie if (t->state == TRANS_STATE_COMPLETED) 9483473f3c0SJosef Bacik break; 94946204592SSage Weil cur_trans = t; 9509b64f57dSElena Reshetova refcount_inc(&cur_trans->use_count); 95146204592SSage Weil break; 95246204592SSage Weil } 95346204592SSage Weil } 9540b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 95546204592SSage Weil if (!cur_trans) 956a4abeea4SJosef Bacik goto out; /* nothing committing|committed */ 95746204592SSage Weil } 95846204592SSage Weil 959d0c2f4faSFilipe Manana wait_for_commit(cur_trans, TRANS_STATE_COMPLETED); 960bf7ecbe9SFilipe Manana ret = cur_trans->aborted; 961724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 962a4abeea4SJosef Bacik out: 96346204592SSage Weil return ret; 96446204592SSage Weil } 96546204592SSage Weil 9662ff7e61eSJeff Mahoney void btrfs_throttle(struct btrfs_fs_info *fs_info) 96737d1aeeeSChris Mason { 9682ff7e61eSJeff Mahoney wait_current_trans(fs_info); 96937d1aeeeSChris Mason } 97037d1aeeeSChris Mason 971a2633b6aSNikolay Borisov bool btrfs_should_end_transaction(struct btrfs_trans_handle *trans) 9728929ecfaSYan, Zheng { 9738929ecfaSYan, Zheng struct btrfs_transaction *cur_trans = trans->transaction; 9748929ecfaSYan, Zheng 9753296bf56SQu Wenruo if (cur_trans->state >= TRANS_STATE_COMMIT_START || 976e19eb11fSJosef Bacik test_bit(BTRFS_DELAYED_REFS_FLUSHING, &cur_trans->delayed_refs.flags)) 977a2633b6aSNikolay Borisov return true; 9788929ecfaSYan, Zheng 97904fb3285SFilipe Manana if (btrfs_check_space_for_delayed_refs(trans->fs_info)) 98004fb3285SFilipe Manana return true; 98104fb3285SFilipe Manana 98204fb3285SFilipe Manana return !!btrfs_block_rsv_check(&trans->fs_info->global_block_rsv, 50); 9838929ecfaSYan, Zheng } 9848929ecfaSYan, Zheng 985dc60c525SNikolay Borisov static void btrfs_trans_release_metadata(struct btrfs_trans_handle *trans) 986dc60c525SNikolay Borisov 9870e34693fSNikolay Borisov { 988dc60c525SNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 989dc60c525SNikolay Borisov 9900e34693fSNikolay Borisov if (!trans->block_rsv) { 9910e34693fSNikolay Borisov ASSERT(!trans->bytes_reserved); 9920e34693fSNikolay Borisov return; 9930e34693fSNikolay Borisov } 9940e34693fSNikolay Borisov 9950e34693fSNikolay Borisov if (!trans->bytes_reserved) 9960e34693fSNikolay Borisov return; 9970e34693fSNikolay Borisov 9980e34693fSNikolay Borisov ASSERT(trans->block_rsv == &fs_info->trans_block_rsv); 9990e34693fSNikolay Borisov trace_btrfs_space_reservation(fs_info, "transaction", 10000e34693fSNikolay Borisov trans->transid, trans->bytes_reserved, 0); 10010e34693fSNikolay Borisov btrfs_block_rsv_release(fs_info, trans->block_rsv, 100263f018beSNikolay Borisov trans->bytes_reserved, NULL); 10030e34693fSNikolay Borisov trans->bytes_reserved = 0; 10040e34693fSNikolay Borisov } 10050e34693fSNikolay Borisov 100689ce8a63SChris Mason static int __btrfs_end_transaction(struct btrfs_trans_handle *trans, 10073a45bb20SJeff Mahoney int throttle) 100879154b1bSChris Mason { 10093a45bb20SJeff Mahoney struct btrfs_fs_info *info = trans->fs_info; 10108929ecfaSYan, Zheng struct btrfs_transaction *cur_trans = trans->transaction; 10114edc2ca3SDave Jones int err = 0; 1012d6e4a428SChris Mason 1013b50fff81SDavid Sterba if (refcount_read(&trans->use_count) > 1) { 1014b50fff81SDavid Sterba refcount_dec(&trans->use_count); 10152a1eb461SJosef Bacik trans->block_rsv = trans->orig_rsv; 10162a1eb461SJosef Bacik return 0; 10172a1eb461SJosef Bacik } 10182a1eb461SJosef Bacik 1019dc60c525SNikolay Borisov btrfs_trans_release_metadata(trans); 10204c13d758SJosef Bacik trans->block_rsv = NULL; 1021c5567237SArne Jansen 10226c686b35SNikolay Borisov btrfs_create_pending_block_groups(trans); 1023ea658badSJosef Bacik 10244fbcdf66SFilipe Manana btrfs_trans_release_chunk_metadata(trans); 10254fbcdf66SFilipe Manana 10260860adfdSMiao Xie if (trans->type & __TRANS_FREEZABLE) 10270b246afaSJeff Mahoney sb_end_intwrite(info->sb); 10286df7881aSJosef Bacik 10298929ecfaSYan, Zheng WARN_ON(cur_trans != info->running_transaction); 103013c5a93eSJosef Bacik WARN_ON(atomic_read(&cur_trans->num_writers) < 1); 103113c5a93eSJosef Bacik atomic_dec(&cur_trans->num_writers); 10320860adfdSMiao Xie extwriter_counter_dec(cur_trans, trans->type); 103389ce8a63SChris Mason 1034093258e6SDavid Sterba cond_wake_up(&cur_trans->writer_wait); 1035e1489b4fSIoannis Angelakopoulos 10365a9ba670SIoannis Angelakopoulos btrfs_lockdep_release(info, btrfs_trans_num_extwriters); 1037e1489b4fSIoannis Angelakopoulos btrfs_lockdep_release(info, btrfs_trans_num_writers); 1038e1489b4fSIoannis Angelakopoulos 1039724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 10409ed74f2dSJosef Bacik 10419ed74f2dSJosef Bacik if (current->journal_info == trans) 10429ed74f2dSJosef Bacik current->journal_info = NULL; 1043ab78c84dSChris Mason 104424bbcf04SYan, Zheng if (throttle) 10452ff7e61eSJeff Mahoney btrfs_run_delayed_iputs(info); 104624bbcf04SYan, Zheng 104784961539SJosef Bacik if (TRANS_ABORTED(trans) || BTRFS_FS_ERROR(info)) { 10484e121c06SJosef Bacik wake_up_process(info->transaction_kthread); 1049fbabd4a3SJosef Bacik if (TRANS_ABORTED(trans)) 1050fbabd4a3SJosef Bacik err = trans->aborted; 1051fbabd4a3SJosef Bacik else 1052fbabd4a3SJosef Bacik err = -EROFS; 10534e121c06SJosef Bacik } 105449b25e05SJeff Mahoney 10554edc2ca3SDave Jones kmem_cache_free(btrfs_trans_handle_cachep, trans); 10564edc2ca3SDave Jones return err; 105779154b1bSChris Mason } 105879154b1bSChris Mason 10593a45bb20SJeff Mahoney int btrfs_end_transaction(struct btrfs_trans_handle *trans) 106089ce8a63SChris Mason { 10613a45bb20SJeff Mahoney return __btrfs_end_transaction(trans, 0); 106289ce8a63SChris Mason } 106389ce8a63SChris Mason 10643a45bb20SJeff Mahoney int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans) 106589ce8a63SChris Mason { 10663a45bb20SJeff Mahoney return __btrfs_end_transaction(trans, 1); 106716cdcec7SMiao Xie } 106816cdcec7SMiao Xie 1069d352ac68SChris Mason /* 1070d352ac68SChris Mason * when btree blocks are allocated, they have some corresponding bits set for 1071d352ac68SChris Mason * them in one of two extent_io trees. This is used to make sure all of 1072690587d1SChris Mason * those extents are sent to disk but does not wait on them 1073d352ac68SChris Mason */ 10742ff7e61eSJeff Mahoney int btrfs_write_marked_extents(struct btrfs_fs_info *fs_info, 10758cef4e16SYan, Zheng struct extent_io_tree *dirty_pages, int mark) 107679154b1bSChris Mason { 1077777e6bd7SChris Mason int err = 0; 10787c4452b9SChris Mason int werr = 0; 10790b246afaSJeff Mahoney struct address_space *mapping = fs_info->btree_inode->i_mapping; 1080e6138876SJosef Bacik struct extent_state *cached_state = NULL; 1081777e6bd7SChris Mason u64 start = 0; 10825f39d397SChris Mason u64 end; 10837c4452b9SChris Mason 1084e5860f82SFilipe Manana while (find_first_extent_bit(dirty_pages, start, &start, &end, 1085e6138876SJosef Bacik mark, &cached_state)) { 1086663dfbb0SFilipe Manana bool wait_writeback = false; 1087663dfbb0SFilipe Manana 1088663dfbb0SFilipe Manana err = convert_extent_bit(dirty_pages, start, end, 1089663dfbb0SFilipe Manana EXTENT_NEED_WAIT, 1090210aa277SDavid Sterba mark, &cached_state); 1091663dfbb0SFilipe Manana /* 1092663dfbb0SFilipe Manana * convert_extent_bit can return -ENOMEM, which is most of the 1093663dfbb0SFilipe Manana * time a temporary error. So when it happens, ignore the error 1094663dfbb0SFilipe Manana * and wait for writeback of this range to finish - because we 1095663dfbb0SFilipe Manana * failed to set the bit EXTENT_NEED_WAIT for the range, a call 1096bf89d38fSJeff Mahoney * to __btrfs_wait_marked_extents() would not know that 1097bf89d38fSJeff Mahoney * writeback for this range started and therefore wouldn't 1098bf89d38fSJeff Mahoney * wait for it to finish - we don't want to commit a 1099bf89d38fSJeff Mahoney * superblock that points to btree nodes/leafs for which 1100bf89d38fSJeff Mahoney * writeback hasn't finished yet (and without errors). 1101663dfbb0SFilipe Manana * We cleanup any entries left in the io tree when committing 110241e7acd3SNikolay Borisov * the transaction (through extent_io_tree_release()). 1103663dfbb0SFilipe Manana */ 1104663dfbb0SFilipe Manana if (err == -ENOMEM) { 1105663dfbb0SFilipe Manana err = 0; 1106663dfbb0SFilipe Manana wait_writeback = true; 1107663dfbb0SFilipe Manana } 1108663dfbb0SFilipe Manana if (!err) 11091728366eSJosef Bacik err = filemap_fdatawrite_range(mapping, start, end); 11107c4452b9SChris Mason if (err) 11117c4452b9SChris Mason werr = err; 1112663dfbb0SFilipe Manana else if (wait_writeback) 1113663dfbb0SFilipe Manana werr = filemap_fdatawait_range(mapping, start, end); 1114e38e2ed7SFilipe Manana free_extent_state(cached_state); 1115663dfbb0SFilipe Manana cached_state = NULL; 11161728366eSJosef Bacik cond_resched(); 11171728366eSJosef Bacik start = end + 1; 11187c4452b9SChris Mason } 1119690587d1SChris Mason return werr; 1120690587d1SChris Mason } 1121690587d1SChris Mason 1122690587d1SChris Mason /* 1123690587d1SChris Mason * when btree blocks are allocated, they have some corresponding bits set for 1124690587d1SChris Mason * them in one of two extent_io trees. This is used to make sure all of 1125690587d1SChris Mason * those extents are on disk for transaction or log commit. We wait 1126690587d1SChris Mason * on all the pages and clear them from the dirty pages state tree 1127690587d1SChris Mason */ 1128bf89d38fSJeff Mahoney static int __btrfs_wait_marked_extents(struct btrfs_fs_info *fs_info, 1129bf89d38fSJeff Mahoney struct extent_io_tree *dirty_pages) 1130690587d1SChris Mason { 1131690587d1SChris Mason int err = 0; 1132690587d1SChris Mason int werr = 0; 11330b246afaSJeff Mahoney struct address_space *mapping = fs_info->btree_inode->i_mapping; 1134e6138876SJosef Bacik struct extent_state *cached_state = NULL; 1135690587d1SChris Mason u64 start = 0; 1136690587d1SChris Mason u64 end; 1137690587d1SChris Mason 1138e5860f82SFilipe Manana while (find_first_extent_bit(dirty_pages, start, &start, &end, 1139e6138876SJosef Bacik EXTENT_NEED_WAIT, &cached_state)) { 1140663dfbb0SFilipe Manana /* 1141663dfbb0SFilipe Manana * Ignore -ENOMEM errors returned by clear_extent_bit(). 1142663dfbb0SFilipe Manana * When committing the transaction, we'll remove any entries 1143663dfbb0SFilipe Manana * left in the io tree. For a log commit, we don't remove them 1144663dfbb0SFilipe Manana * after committing the log because the tree can be accessed 1145663dfbb0SFilipe Manana * concurrently - we do it only at transaction commit time when 114641e7acd3SNikolay Borisov * it's safe to do it (through extent_io_tree_release()). 1147663dfbb0SFilipe Manana */ 1148663dfbb0SFilipe Manana err = clear_extent_bit(dirty_pages, start, end, 1149bd015294SJosef Bacik EXTENT_NEED_WAIT, &cached_state); 1150663dfbb0SFilipe Manana if (err == -ENOMEM) 1151663dfbb0SFilipe Manana err = 0; 1152663dfbb0SFilipe Manana if (!err) 11531728366eSJosef Bacik err = filemap_fdatawait_range(mapping, start, end); 1154777e6bd7SChris Mason if (err) 1155777e6bd7SChris Mason werr = err; 1156e38e2ed7SFilipe Manana free_extent_state(cached_state); 1157e38e2ed7SFilipe Manana cached_state = NULL; 1158777e6bd7SChris Mason cond_resched(); 11591728366eSJosef Bacik start = end + 1; 1160777e6bd7SChris Mason } 11617c4452b9SChris Mason if (err) 11627c4452b9SChris Mason werr = err; 1163bf89d38fSJeff Mahoney return werr; 1164bf89d38fSJeff Mahoney } 1165656f30dbSFilipe Manana 1166b9fae2ebSFilipe Manana static int btrfs_wait_extents(struct btrfs_fs_info *fs_info, 1167bf89d38fSJeff Mahoney struct extent_io_tree *dirty_pages) 1168bf89d38fSJeff Mahoney { 1169bf89d38fSJeff Mahoney bool errors = false; 1170bf89d38fSJeff Mahoney int err; 1171bf89d38fSJeff Mahoney 1172bf89d38fSJeff Mahoney err = __btrfs_wait_marked_extents(fs_info, dirty_pages); 1173bf89d38fSJeff Mahoney if (test_and_clear_bit(BTRFS_FS_BTREE_ERR, &fs_info->flags)) 1174bf89d38fSJeff Mahoney errors = true; 1175bf89d38fSJeff Mahoney 1176bf89d38fSJeff Mahoney if (errors && !err) 1177bf89d38fSJeff Mahoney err = -EIO; 1178bf89d38fSJeff Mahoney return err; 1179bf89d38fSJeff Mahoney } 1180bf89d38fSJeff Mahoney 1181bf89d38fSJeff Mahoney int btrfs_wait_tree_log_extents(struct btrfs_root *log_root, int mark) 1182bf89d38fSJeff Mahoney { 1183bf89d38fSJeff Mahoney struct btrfs_fs_info *fs_info = log_root->fs_info; 1184bf89d38fSJeff Mahoney struct extent_io_tree *dirty_pages = &log_root->dirty_log_pages; 1185bf89d38fSJeff Mahoney bool errors = false; 1186bf89d38fSJeff Mahoney int err; 1187bf89d38fSJeff Mahoney 1188bf89d38fSJeff Mahoney ASSERT(log_root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID); 1189bf89d38fSJeff Mahoney 1190bf89d38fSJeff Mahoney err = __btrfs_wait_marked_extents(fs_info, dirty_pages); 1191656f30dbSFilipe Manana if ((mark & EXTENT_DIRTY) && 11920b246afaSJeff Mahoney test_and_clear_bit(BTRFS_FS_LOG1_ERR, &fs_info->flags)) 1193656f30dbSFilipe Manana errors = true; 1194656f30dbSFilipe Manana 1195656f30dbSFilipe Manana if ((mark & EXTENT_NEW) && 11960b246afaSJeff Mahoney test_and_clear_bit(BTRFS_FS_LOG2_ERR, &fs_info->flags)) 1197656f30dbSFilipe Manana errors = true; 1198656f30dbSFilipe Manana 1199bf89d38fSJeff Mahoney if (errors && !err) 1200bf89d38fSJeff Mahoney err = -EIO; 1201bf89d38fSJeff Mahoney return err; 120279154b1bSChris Mason } 120379154b1bSChris Mason 1204690587d1SChris Mason /* 1205c9b577c0SNikolay Borisov * When btree blocks are allocated the corresponding extents are marked dirty. 1206c9b577c0SNikolay Borisov * This function ensures such extents are persisted on disk for transaction or 1207c9b577c0SNikolay Borisov * log commit. 1208c9b577c0SNikolay Borisov * 1209c9b577c0SNikolay Borisov * @trans: transaction whose dirty pages we'd like to write 1210690587d1SChris Mason */ 121170458a58SNikolay Borisov static int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans) 1212d0c803c4SChris Mason { 1213663dfbb0SFilipe Manana int ret; 1214c9b577c0SNikolay Borisov int ret2; 1215c9b577c0SNikolay Borisov struct extent_io_tree *dirty_pages = &trans->transaction->dirty_pages; 121670458a58SNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 1217c9b577c0SNikolay Borisov struct blk_plug plug; 1218663dfbb0SFilipe Manana 1219c9b577c0SNikolay Borisov blk_start_plug(&plug); 1220c9b577c0SNikolay Borisov ret = btrfs_write_marked_extents(fs_info, dirty_pages, EXTENT_DIRTY); 1221c9b577c0SNikolay Borisov blk_finish_plug(&plug); 1222c9b577c0SNikolay Borisov ret2 = btrfs_wait_extents(fs_info, dirty_pages); 1223c9b577c0SNikolay Borisov 122441e7acd3SNikolay Borisov extent_io_tree_release(&trans->transaction->dirty_pages); 1225663dfbb0SFilipe Manana 1226c9b577c0SNikolay Borisov if (ret) 1227663dfbb0SFilipe Manana return ret; 1228c9b577c0SNikolay Borisov else if (ret2) 1229c9b577c0SNikolay Borisov return ret2; 1230c9b577c0SNikolay Borisov else 1231c9b577c0SNikolay Borisov return 0; 1232d0c803c4SChris Mason } 1233d0c803c4SChris Mason 1234d352ac68SChris Mason /* 1235d352ac68SChris Mason * this is used to update the root pointer in the tree of tree roots. 1236d352ac68SChris Mason * 1237d352ac68SChris Mason * But, in the case of the extent allocation tree, updating the root 1238d352ac68SChris Mason * pointer may allocate blocks which may change the root of the extent 1239d352ac68SChris Mason * allocation tree. 1240d352ac68SChris Mason * 1241d352ac68SChris Mason * So, this loops and repeats and makes sure the cowonly root didn't 1242d352ac68SChris Mason * change while the root pointer was being updated in the metadata. 1243d352ac68SChris Mason */ 12440b86a832SChris Mason static int update_cowonly_root(struct btrfs_trans_handle *trans, 124579154b1bSChris Mason struct btrfs_root *root) 124679154b1bSChris Mason { 124779154b1bSChris Mason int ret; 12480b86a832SChris Mason u64 old_root_bytenr; 124986b9f2ecSYan, Zheng u64 old_root_used; 12500b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 12510b246afaSJeff Mahoney struct btrfs_root *tree_root = fs_info->tree_root; 125279154b1bSChris Mason 125386b9f2ecSYan, Zheng old_root_used = btrfs_root_used(&root->root_item); 125456bec294SChris Mason 125579154b1bSChris Mason while (1) { 12560b86a832SChris Mason old_root_bytenr = btrfs_root_bytenr(&root->root_item); 125786b9f2ecSYan, Zheng if (old_root_bytenr == root->node->start && 1258ea526d18SJosef Bacik old_root_used == btrfs_root_used(&root->root_item)) 125979154b1bSChris Mason break; 126087ef2bb4SChris Mason 12615d4f98a2SYan Zheng btrfs_set_root_node(&root->root_item, root->node); 126279154b1bSChris Mason ret = btrfs_update_root(trans, tree_root, 12630b86a832SChris Mason &root->root_key, 12640b86a832SChris Mason &root->root_item); 126549b25e05SJeff Mahoney if (ret) 126649b25e05SJeff Mahoney return ret; 126756bec294SChris Mason 126886b9f2ecSYan, Zheng old_root_used = btrfs_root_used(&root->root_item); 1269e7070be1SJosef Bacik } 1270276e680dSYan Zheng 12710b86a832SChris Mason return 0; 12720b86a832SChris Mason } 12730b86a832SChris Mason 1274d352ac68SChris Mason /* 1275d352ac68SChris Mason * update all the cowonly tree roots on disk 127649b25e05SJeff Mahoney * 127749b25e05SJeff Mahoney * The error handling in this function may not be obvious. Any of the 127849b25e05SJeff Mahoney * failures will cause the file system to go offline. We still need 127949b25e05SJeff Mahoney * to clean up the delayed refs. 1280d352ac68SChris Mason */ 12819386d8bcSNikolay Borisov static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans) 12820b86a832SChris Mason { 12839386d8bcSNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 1284ea526d18SJosef Bacik struct list_head *dirty_bgs = &trans->transaction->dirty_bgs; 12851bbc621eSChris Mason struct list_head *io_bgs = &trans->transaction->io_bgs; 12860b86a832SChris Mason struct list_head *next; 128784234f3aSYan Zheng struct extent_buffer *eb; 128856bec294SChris Mason int ret; 128984234f3aSYan Zheng 1290dfba78dcSFilipe Manana /* 1291dfba78dcSFilipe Manana * At this point no one can be using this transaction to modify any tree 1292dfba78dcSFilipe Manana * and no one can start another transaction to modify any tree either. 1293dfba78dcSFilipe Manana */ 1294dfba78dcSFilipe Manana ASSERT(trans->transaction->state == TRANS_STATE_COMMIT_DOING); 1295dfba78dcSFilipe Manana 129684234f3aSYan Zheng eb = btrfs_lock_root_node(fs_info->tree_root); 129749b25e05SJeff Mahoney ret = btrfs_cow_block(trans, fs_info->tree_root, eb, NULL, 12989631e4ccSJosef Bacik 0, &eb, BTRFS_NESTING_COW); 129984234f3aSYan Zheng btrfs_tree_unlock(eb); 130084234f3aSYan Zheng free_extent_buffer(eb); 13010b86a832SChris Mason 130249b25e05SJeff Mahoney if (ret) 130349b25e05SJeff Mahoney return ret; 130449b25e05SJeff Mahoney 1305196c9d8dSDavid Sterba ret = btrfs_run_dev_stats(trans); 1306c16ce190SJosef Bacik if (ret) 1307c16ce190SJosef Bacik return ret; 13082b584c68SDavid Sterba ret = btrfs_run_dev_replace(trans); 1309c16ce190SJosef Bacik if (ret) 1310c16ce190SJosef Bacik return ret; 1311280f8bd2SLu Fengqi ret = btrfs_run_qgroups(trans); 1312c16ce190SJosef Bacik if (ret) 1313c16ce190SJosef Bacik return ret; 1314546adb0dSJan Schmidt 1315bbebb3e0SDavid Sterba ret = btrfs_setup_space_cache(trans); 1316dcdf7f6dSJosef Bacik if (ret) 1317dcdf7f6dSJosef Bacik return ret; 1318dcdf7f6dSJosef Bacik 1319ea526d18SJosef Bacik again: 13200b86a832SChris Mason while (!list_empty(&fs_info->dirty_cowonly_roots)) { 13212ff7e61eSJeff Mahoney struct btrfs_root *root; 13220b86a832SChris Mason next = fs_info->dirty_cowonly_roots.next; 13230b86a832SChris Mason list_del_init(next); 13240b86a832SChris Mason root = list_entry(next, struct btrfs_root, dirty_list); 1325e7070be1SJosef Bacik clear_bit(BTRFS_ROOT_DIRTY, &root->state); 132687ef2bb4SChris Mason 13279e351cc8SJosef Bacik list_add_tail(&root->dirty_list, 13289e351cc8SJosef Bacik &trans->transaction->switch_commits); 132949b25e05SJeff Mahoney ret = update_cowonly_root(trans, root); 133049b25e05SJeff Mahoney if (ret) 133149b25e05SJeff Mahoney return ret; 1332488bc2a2SJosef Bacik } 1333488bc2a2SJosef Bacik 1334488bc2a2SJosef Bacik /* Now flush any delayed refs generated by updating all of the roots */ 1335c79a70b1SNikolay Borisov ret = btrfs_run_delayed_refs(trans, (unsigned long)-1); 1336ea526d18SJosef Bacik if (ret) 1337ea526d18SJosef Bacik return ret; 1338276e680dSYan Zheng 13391bbc621eSChris Mason while (!list_empty(dirty_bgs) || !list_empty(io_bgs)) { 13405742d15fSDavid Sterba ret = btrfs_write_dirty_block_groups(trans); 1341ea526d18SJosef Bacik if (ret) 1342ea526d18SJosef Bacik return ret; 1343488bc2a2SJosef Bacik 1344488bc2a2SJosef Bacik /* 1345488bc2a2SJosef Bacik * We're writing the dirty block groups, which could generate 1346488bc2a2SJosef Bacik * delayed refs, which could generate more dirty block groups, 1347488bc2a2SJosef Bacik * so we want to keep this flushing in this loop to make sure 1348488bc2a2SJosef Bacik * everything gets run. 1349488bc2a2SJosef Bacik */ 1350c79a70b1SNikolay Borisov ret = btrfs_run_delayed_refs(trans, (unsigned long)-1); 1351ea526d18SJosef Bacik if (ret) 1352ea526d18SJosef Bacik return ret; 1353ea526d18SJosef Bacik } 1354ea526d18SJosef Bacik 1355ea526d18SJosef Bacik if (!list_empty(&fs_info->dirty_cowonly_roots)) 1356ea526d18SJosef Bacik goto again; 1357ea526d18SJosef Bacik 13589f6cbcbbSDavid Sterba /* Update dev-replace pointer once everything is committed */ 13599f6cbcbbSDavid Sterba fs_info->dev_replace.committed_cursor_left = 13609f6cbcbbSDavid Sterba fs_info->dev_replace.cursor_left_last_write_of_item; 13618dabb742SStefan Behrens 136279154b1bSChris Mason return 0; 136379154b1bSChris Mason } 136479154b1bSChris Mason 1365d352ac68SChris Mason /* 1366b4be6aefSJosef Bacik * If we had a pending drop we need to see if there are any others left in our 1367b4be6aefSJosef Bacik * dead roots list, and if not clear our bit and wake any waiters. 1368b4be6aefSJosef Bacik */ 1369b4be6aefSJosef Bacik void btrfs_maybe_wake_unfinished_drop(struct btrfs_fs_info *fs_info) 1370b4be6aefSJosef Bacik { 1371b4be6aefSJosef Bacik /* 1372b4be6aefSJosef Bacik * We put the drop in progress roots at the front of the list, so if the 1373b4be6aefSJosef Bacik * first entry doesn't have UNFINISHED_DROP set we can wake everybody 1374b4be6aefSJosef Bacik * up. 1375b4be6aefSJosef Bacik */ 1376b4be6aefSJosef Bacik spin_lock(&fs_info->trans_lock); 1377b4be6aefSJosef Bacik if (!list_empty(&fs_info->dead_roots)) { 1378b4be6aefSJosef Bacik struct btrfs_root *root = list_first_entry(&fs_info->dead_roots, 1379b4be6aefSJosef Bacik struct btrfs_root, 1380b4be6aefSJosef Bacik root_list); 1381b4be6aefSJosef Bacik if (test_bit(BTRFS_ROOT_UNFINISHED_DROP, &root->state)) { 1382b4be6aefSJosef Bacik spin_unlock(&fs_info->trans_lock); 1383b4be6aefSJosef Bacik return; 1384b4be6aefSJosef Bacik } 1385b4be6aefSJosef Bacik } 1386b4be6aefSJosef Bacik spin_unlock(&fs_info->trans_lock); 1387b4be6aefSJosef Bacik 1388b4be6aefSJosef Bacik btrfs_wake_unfinished_drop(fs_info); 1389b4be6aefSJosef Bacik } 1390b4be6aefSJosef Bacik 1391b4be6aefSJosef Bacik /* 1392d352ac68SChris Mason * dead roots are old snapshots that need to be deleted. This allocates 1393d352ac68SChris Mason * a dirty root struct and adds it into the list of dead roots that need to 1394d352ac68SChris Mason * be deleted 1395d352ac68SChris Mason */ 1396cfad392bSJosef Bacik void btrfs_add_dead_root(struct btrfs_root *root) 13975eda7b5eSChris Mason { 13980b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 13990b246afaSJeff Mahoney 14000b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 1401dc9492c1SJosef Bacik if (list_empty(&root->root_list)) { 1402dc9492c1SJosef Bacik btrfs_grab_root(root); 1403b4be6aefSJosef Bacik 1404b4be6aefSJosef Bacik /* We want to process the partially complete drops first. */ 1405b4be6aefSJosef Bacik if (test_bit(BTRFS_ROOT_UNFINISHED_DROP, &root->state)) 1406b4be6aefSJosef Bacik list_add(&root->root_list, &fs_info->dead_roots); 1407b4be6aefSJosef Bacik else 14080b246afaSJeff Mahoney list_add_tail(&root->root_list, &fs_info->dead_roots); 1409dc9492c1SJosef Bacik } 14100b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 14115eda7b5eSChris Mason } 14125eda7b5eSChris Mason 1413d352ac68SChris Mason /* 1414dfba78dcSFilipe Manana * Update each subvolume root and its relocation root, if it exists, in the tree 1415dfba78dcSFilipe Manana * of tree roots. Also free log roots if they exist. 1416d352ac68SChris Mason */ 14177e4443d9SNikolay Borisov static noinline int commit_fs_roots(struct btrfs_trans_handle *trans) 14180f7d52f4SChris Mason { 14197e4443d9SNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 1420fc7cbcd4SDavid Sterba struct btrfs_root *gang[8]; 1421fc7cbcd4SDavid Sterba int i; 1422fc7cbcd4SDavid Sterba int ret; 142354aa1f4dSChris Mason 1424dfba78dcSFilipe Manana /* 1425dfba78dcSFilipe Manana * At this point no one can be using this transaction to modify any tree 1426dfba78dcSFilipe Manana * and no one can start another transaction to modify any tree either. 1427dfba78dcSFilipe Manana */ 1428dfba78dcSFilipe Manana ASSERT(trans->transaction->state == TRANS_STATE_COMMIT_DOING); 1429dfba78dcSFilipe Manana 1430fc7cbcd4SDavid Sterba spin_lock(&fs_info->fs_roots_radix_lock); 1431fc7cbcd4SDavid Sterba while (1) { 1432fc7cbcd4SDavid Sterba ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix, 1433fc7cbcd4SDavid Sterba (void **)gang, 0, 1434fc7cbcd4SDavid Sterba ARRAY_SIZE(gang), 1435fc7cbcd4SDavid Sterba BTRFS_ROOT_TRANS_TAG); 1436fc7cbcd4SDavid Sterba if (ret == 0) 1437fc7cbcd4SDavid Sterba break; 1438fc7cbcd4SDavid Sterba for (i = 0; i < ret; i++) { 1439fc7cbcd4SDavid Sterba struct btrfs_root *root = gang[i]; 1440fc7cbcd4SDavid Sterba int ret2; 14414f4317c1SJosef Bacik 1442dfba78dcSFilipe Manana /* 1443dfba78dcSFilipe Manana * At this point we can neither have tasks logging inodes 1444dfba78dcSFilipe Manana * from a root nor trying to commit a log tree. 1445dfba78dcSFilipe Manana */ 1446dfba78dcSFilipe Manana ASSERT(atomic_read(&root->log_writers) == 0); 1447dfba78dcSFilipe Manana ASSERT(atomic_read(&root->log_commit[0]) == 0); 1448dfba78dcSFilipe Manana ASSERT(atomic_read(&root->log_commit[1]) == 0); 1449dfba78dcSFilipe Manana 1450fc7cbcd4SDavid Sterba radix_tree_tag_clear(&fs_info->fs_roots_radix, 14512619ba1fSChris Mason (unsigned long)root->root_key.objectid, 14520f7d52f4SChris Mason BTRFS_ROOT_TRANS_TAG); 1453fc7cbcd4SDavid Sterba spin_unlock(&fs_info->fs_roots_radix_lock); 145431153d81SYan Zheng 1455e02119d5SChris Mason btrfs_free_log(trans, root); 1456fc7cbcd4SDavid Sterba ret2 = btrfs_update_reloc_root(trans, root); 1457fc7cbcd4SDavid Sterba if (ret2) 1458fc7cbcd4SDavid Sterba return ret2; 1459e02119d5SChris Mason 1460fc7cbcd4SDavid Sterba /* see comments in should_cow_block() */ 146127cdeb70SMiao Xie clear_bit(BTRFS_ROOT_FORCE_COW, &root->state); 1462c7548af6SChris Mason smp_mb__after_atomic(); 1463f1ebcc74SLiu Bo 1464978d910dSYan Zheng if (root->commit_root != root->node) { 14659e351cc8SJosef Bacik list_add_tail(&root->dirty_list, 14669e351cc8SJosef Bacik &trans->transaction->switch_commits); 1467fc7cbcd4SDavid Sterba btrfs_set_root_node(&root->root_item, 1468fc7cbcd4SDavid Sterba root->node); 1469978d910dSYan Zheng } 147031153d81SYan Zheng 1471fc7cbcd4SDavid Sterba ret2 = btrfs_update_root(trans, fs_info->tree_root, 1472fc7cbcd4SDavid Sterba &root->root_key, 1473fc7cbcd4SDavid Sterba &root->root_item); 1474fc7cbcd4SDavid Sterba if (ret2) 1475fc7cbcd4SDavid Sterba return ret2; 1476fc7cbcd4SDavid Sterba spin_lock(&fs_info->fs_roots_radix_lock); 1477733e03a0SQu Wenruo btrfs_qgroup_free_meta_all_pertrans(root); 14780f7d52f4SChris Mason } 1479fc7cbcd4SDavid Sterba } 1480fc7cbcd4SDavid Sterba spin_unlock(&fs_info->fs_roots_radix_lock); 14814f4317c1SJosef Bacik return 0; 14820f7d52f4SChris Mason } 14830f7d52f4SChris Mason 1484d352ac68SChris Mason /* 1485de78b51aSEric Sandeen * defrag a given btree. 1486de78b51aSEric Sandeen * Every leaf in the btree is read and defragged. 1487d352ac68SChris Mason */ 1488de78b51aSEric Sandeen int btrfs_defrag_root(struct btrfs_root *root) 1489e9d0b13bSChris Mason { 1490e9d0b13bSChris Mason struct btrfs_fs_info *info = root->fs_info; 1491e9d0b13bSChris Mason struct btrfs_trans_handle *trans; 14928929ecfaSYan, Zheng int ret; 1493e9d0b13bSChris Mason 149427cdeb70SMiao Xie if (test_and_set_bit(BTRFS_ROOT_DEFRAG_RUNNING, &root->state)) 1495e9d0b13bSChris Mason return 0; 14968929ecfaSYan, Zheng 14976b80053dSChris Mason while (1) { 14988929ecfaSYan, Zheng trans = btrfs_start_transaction(root, 0); 14996819703fSDavid Sterba if (IS_ERR(trans)) { 15006819703fSDavid Sterba ret = PTR_ERR(trans); 15016819703fSDavid Sterba break; 15026819703fSDavid Sterba } 15038929ecfaSYan, Zheng 1504de78b51aSEric Sandeen ret = btrfs_defrag_leaves(trans, root); 15058929ecfaSYan, Zheng 15063a45bb20SJeff Mahoney btrfs_end_transaction(trans); 15072ff7e61eSJeff Mahoney btrfs_btree_balance_dirty(info); 1508e9d0b13bSChris Mason cond_resched(); 1509e9d0b13bSChris Mason 1510ab8d0fc4SJeff Mahoney if (btrfs_fs_closing(info) || ret != -EAGAIN) 1511e9d0b13bSChris Mason break; 1512210549ebSDavid Sterba 1513ab8d0fc4SJeff Mahoney if (btrfs_defrag_cancelled(info)) { 1514ab8d0fc4SJeff Mahoney btrfs_debug(info, "defrag_root cancelled"); 1515210549ebSDavid Sterba ret = -EAGAIN; 1516210549ebSDavid Sterba break; 1517210549ebSDavid Sterba } 1518e9d0b13bSChris Mason } 151927cdeb70SMiao Xie clear_bit(BTRFS_ROOT_DEFRAG_RUNNING, &root->state); 15208929ecfaSYan, Zheng return ret; 1521e9d0b13bSChris Mason } 1522e9d0b13bSChris Mason 1523d352ac68SChris Mason /* 15246426c7adSQu Wenruo * Do all special snapshot related qgroup dirty hack. 15256426c7adSQu Wenruo * 15266426c7adSQu Wenruo * Will do all needed qgroup inherit and dirty hack like switch commit 15276426c7adSQu Wenruo * roots inside one transaction and write all btree into disk, to make 15286426c7adSQu Wenruo * qgroup works. 15296426c7adSQu Wenruo */ 15306426c7adSQu Wenruo static int qgroup_account_snapshot(struct btrfs_trans_handle *trans, 15316426c7adSQu Wenruo struct btrfs_root *src, 15326426c7adSQu Wenruo struct btrfs_root *parent, 15336426c7adSQu Wenruo struct btrfs_qgroup_inherit *inherit, 15346426c7adSQu Wenruo u64 dst_objectid) 15356426c7adSQu Wenruo { 15366426c7adSQu Wenruo struct btrfs_fs_info *fs_info = src->fs_info; 15376426c7adSQu Wenruo int ret; 15386426c7adSQu Wenruo 15396426c7adSQu Wenruo /* 15406426c7adSQu Wenruo * Save some performance in the case that qgroups are not 15416426c7adSQu Wenruo * enabled. If this check races with the ioctl, rescan will 15426426c7adSQu Wenruo * kick in anyway. 15436426c7adSQu Wenruo */ 15449ea6e2b5SDavid Sterba if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags)) 15456426c7adSQu Wenruo return 0; 15466426c7adSQu Wenruo 15476426c7adSQu Wenruo /* 154852042d8eSAndrea Gelmini * Ensure dirty @src will be committed. Or, after coming 15494d31778aSQu Wenruo * commit_fs_roots() and switch_commit_roots(), any dirty but not 15504d31778aSQu Wenruo * recorded root will never be updated again, causing an outdated root 15514d31778aSQu Wenruo * item. 15524d31778aSQu Wenruo */ 15531c442d22SJosef Bacik ret = record_root_in_trans(trans, src, 1); 15541c442d22SJosef Bacik if (ret) 15551c442d22SJosef Bacik return ret; 15564d31778aSQu Wenruo 15574d31778aSQu Wenruo /* 15582a4d84c1SJosef Bacik * btrfs_qgroup_inherit relies on a consistent view of the usage for the 15592a4d84c1SJosef Bacik * src root, so we must run the delayed refs here. 15602a4d84c1SJosef Bacik * 15612a4d84c1SJosef Bacik * However this isn't particularly fool proof, because there's no 15622a4d84c1SJosef Bacik * synchronization keeping us from changing the tree after this point 15632a4d84c1SJosef Bacik * before we do the qgroup_inherit, or even from making changes while 15642a4d84c1SJosef Bacik * we're doing the qgroup_inherit. But that's a problem for the future, 15652a4d84c1SJosef Bacik * for now flush the delayed refs to narrow the race window where the 15662a4d84c1SJosef Bacik * qgroup counters could end up wrong. 15672a4d84c1SJosef Bacik */ 15682a4d84c1SJosef Bacik ret = btrfs_run_delayed_refs(trans, (unsigned long)-1); 15692a4d84c1SJosef Bacik if (ret) { 15702a4d84c1SJosef Bacik btrfs_abort_transaction(trans, ret); 157144365827SNaohiro Aota return ret; 15722a4d84c1SJosef Bacik } 15732a4d84c1SJosef Bacik 15747e4443d9SNikolay Borisov ret = commit_fs_roots(trans); 15756426c7adSQu Wenruo if (ret) 15766426c7adSQu Wenruo goto out; 1577460fb20aSNikolay Borisov ret = btrfs_qgroup_account_extents(trans); 15786426c7adSQu Wenruo if (ret < 0) 15796426c7adSQu Wenruo goto out; 15806426c7adSQu Wenruo 15816426c7adSQu Wenruo /* Now qgroup are all updated, we can inherit it to new qgroups */ 1582a9377422SLu Fengqi ret = btrfs_qgroup_inherit(trans, src->root_key.objectid, dst_objectid, 15836426c7adSQu Wenruo inherit); 15846426c7adSQu Wenruo if (ret < 0) 15856426c7adSQu Wenruo goto out; 15866426c7adSQu Wenruo 15876426c7adSQu Wenruo /* 15886426c7adSQu Wenruo * Now we do a simplified commit transaction, which will: 15896426c7adSQu Wenruo * 1) commit all subvolume and extent tree 15906426c7adSQu Wenruo * To ensure all subvolume and extent tree have a valid 15916426c7adSQu Wenruo * commit_root to accounting later insert_dir_item() 15926426c7adSQu Wenruo * 2) write all btree blocks onto disk 15936426c7adSQu Wenruo * This is to make sure later btree modification will be cowed 15946426c7adSQu Wenruo * Or commit_root can be populated and cause wrong qgroup numbers 15956426c7adSQu Wenruo * In this simplified commit, we don't really care about other trees 15966426c7adSQu Wenruo * like chunk and root tree, as they won't affect qgroup. 15976426c7adSQu Wenruo * And we don't write super to avoid half committed status. 15986426c7adSQu Wenruo */ 15999386d8bcSNikolay Borisov ret = commit_cowonly_roots(trans); 16006426c7adSQu Wenruo if (ret) 16016426c7adSQu Wenruo goto out; 1602889bfa39SJosef Bacik switch_commit_roots(trans); 160370458a58SNikolay Borisov ret = btrfs_write_and_wait_transaction(trans); 16046426c7adSQu Wenruo if (ret) 1605f7af3934SDavid Sterba btrfs_handle_fs_error(fs_info, ret, 16066426c7adSQu Wenruo "Error while writing out transaction for qgroup"); 16076426c7adSQu Wenruo 16086426c7adSQu Wenruo out: 16096426c7adSQu Wenruo /* 16106426c7adSQu Wenruo * Force parent root to be updated, as we recorded it before so its 16116426c7adSQu Wenruo * last_trans == cur_transid. 16126426c7adSQu Wenruo * Or it won't be committed again onto disk after later 16136426c7adSQu Wenruo * insert_dir_item() 16146426c7adSQu Wenruo */ 16156426c7adSQu Wenruo if (!ret) 16161c442d22SJosef Bacik ret = record_root_in_trans(trans, parent, 1); 16176426c7adSQu Wenruo return ret; 16186426c7adSQu Wenruo } 16196426c7adSQu Wenruo 16206426c7adSQu Wenruo /* 1621d352ac68SChris Mason * new snapshots need to be created at a very specific time in the 1622aec8030aSMiao Xie * transaction commit. This does the actual creation. 1623aec8030aSMiao Xie * 1624aec8030aSMiao Xie * Note: 1625aec8030aSMiao Xie * If the error which may affect the commitment of the current transaction 1626aec8030aSMiao Xie * happens, we should return the error number. If the error which just affect 1627aec8030aSMiao Xie * the creation of the pending snapshots, just return 0. 1628d352ac68SChris Mason */ 162980b6794dSChris Mason static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans, 16303063d29fSChris Mason struct btrfs_pending_snapshot *pending) 16313063d29fSChris Mason { 163208d50ca3SNikolay Borisov 163308d50ca3SNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 16343063d29fSChris Mason struct btrfs_key key; 163580b6794dSChris Mason struct btrfs_root_item *new_root_item; 16363063d29fSChris Mason struct btrfs_root *tree_root = fs_info->tree_root; 16373063d29fSChris Mason struct btrfs_root *root = pending->root; 16386bdb72deSSage Weil struct btrfs_root *parent_root; 163998c9942aSLiu Bo struct btrfs_block_rsv *rsv; 1640ab3c5c18SSweet Tea Dorminy struct inode *parent_inode = pending->dir; 164142874b3dSMiao Xie struct btrfs_path *path; 164242874b3dSMiao Xie struct btrfs_dir_item *dir_item; 16433063d29fSChris Mason struct extent_buffer *tmp; 1644925baeddSChris Mason struct extent_buffer *old; 164595582b00SDeepa Dinamani struct timespec64 cur_time; 1646aec8030aSMiao Xie int ret = 0; 1647d68fc57bSYan, Zheng u64 to_reserve = 0; 16486bdb72deSSage Weil u64 index = 0; 1649a22285a6SYan, Zheng u64 objectid; 1650b83cc969SLi Zefan u64 root_flags; 1651ab3c5c18SSweet Tea Dorminy unsigned int nofs_flags; 1652ab3c5c18SSweet Tea Dorminy struct fscrypt_name fname; 16533063d29fSChris Mason 16548546b570SDavid Sterba ASSERT(pending->path); 16558546b570SDavid Sterba path = pending->path; 165642874b3dSMiao Xie 1657b0c0ea63SDavid Sterba ASSERT(pending->root_item); 1658b0c0ea63SDavid Sterba new_root_item = pending->root_item; 1659a22285a6SYan, Zheng 1660ab3c5c18SSweet Tea Dorminy /* 1661ab3c5c18SSweet Tea Dorminy * We're inside a transaction and must make sure that any potential 1662ab3c5c18SSweet Tea Dorminy * allocations with GFP_KERNEL in fscrypt won't recurse back to 1663ab3c5c18SSweet Tea Dorminy * filesystem. 1664ab3c5c18SSweet Tea Dorminy */ 1665ab3c5c18SSweet Tea Dorminy nofs_flags = memalloc_nofs_save(); 1666ab3c5c18SSweet Tea Dorminy pending->error = fscrypt_setup_filename(parent_inode, 1667ab3c5c18SSweet Tea Dorminy &pending->dentry->d_name, 0, 1668ab3c5c18SSweet Tea Dorminy &fname); 1669ab3c5c18SSweet Tea Dorminy memalloc_nofs_restore(nofs_flags); 1670ab3c5c18SSweet Tea Dorminy if (pending->error) 1671ab3c5c18SSweet Tea Dorminy goto free_pending; 1672ab3c5c18SSweet Tea Dorminy 1673543068a2SNikolay Borisov pending->error = btrfs_get_free_objectid(tree_root, &objectid); 1674aec8030aSMiao Xie if (pending->error) 1675ab3c5c18SSweet Tea Dorminy goto free_fname; 16763063d29fSChris Mason 1677d6726335SQu Wenruo /* 1678d6726335SQu Wenruo * Make qgroup to skip current new snapshot's qgroupid, as it is 1679d6726335SQu Wenruo * accounted by later btrfs_qgroup_inherit(). 1680d6726335SQu Wenruo */ 1681d6726335SQu Wenruo btrfs_set_skip_qgroup(trans, objectid); 1682d6726335SQu Wenruo 1683147d256eSZhaolei btrfs_reloc_pre_snapshot(pending, &to_reserve); 1684d68fc57bSYan, Zheng 1685d68fc57bSYan, Zheng if (to_reserve > 0) { 16869270501cSJosef Bacik pending->error = btrfs_block_rsv_add(fs_info, 1687aec8030aSMiao Xie &pending->block_rsv, 168808e007d2SMiao Xie to_reserve, 168908e007d2SMiao Xie BTRFS_RESERVE_NO_FLUSH); 1690aec8030aSMiao Xie if (pending->error) 1691d6726335SQu Wenruo goto clear_skip_qgroup; 1692d68fc57bSYan, Zheng } 1693d68fc57bSYan, Zheng 16943063d29fSChris Mason key.objectid = objectid; 1695a22285a6SYan, Zheng key.offset = (u64)-1; 1696a22285a6SYan, Zheng key.type = BTRFS_ROOT_ITEM_KEY; 16973063d29fSChris Mason 16986fa9700eSMiao Xie rsv = trans->block_rsv; 1699a22285a6SYan, Zheng trans->block_rsv = &pending->block_rsv; 17002382c5ccSLiu Bo trans->bytes_reserved = trans->block_rsv->reserved; 17010b246afaSJeff Mahoney trace_btrfs_space_reservation(fs_info, "transaction", 170288d3a5aaSJosef Bacik trans->transid, 170388d3a5aaSJosef Bacik trans->bytes_reserved, 1); 1704a22285a6SYan, Zheng parent_root = BTRFS_I(parent_inode)->root; 1705f0118cb6SJosef Bacik ret = record_root_in_trans(trans, parent_root, 0); 1706f0118cb6SJosef Bacik if (ret) 1707f0118cb6SJosef Bacik goto fail; 1708c2050a45SDeepa Dinamani cur_time = current_time(parent_inode); 170904b285f3SDeepa Dinamani 17106bdb72deSSage Weil /* 17116bdb72deSSage Weil * insert the directory item 17126bdb72deSSage Weil */ 1713877574e2SNikolay Borisov ret = btrfs_set_inode_index(BTRFS_I(parent_inode), &index); 1714df9f2782SFilipe Manana if (ret) { 1715df9f2782SFilipe Manana btrfs_abort_transaction(trans, ret); 1716df9f2782SFilipe Manana goto fail; 1717df9f2782SFilipe Manana } 171842874b3dSMiao Xie 171942874b3dSMiao Xie /* check if there is a file/dir which has the same name. */ 172042874b3dSMiao Xie dir_item = btrfs_lookup_dir_item(NULL, parent_root, path, 17214a0cc7caSNikolay Borisov btrfs_ino(BTRFS_I(parent_inode)), 17226db75318SSweet Tea Dorminy &fname.disk_name, 0); 172342874b3dSMiao Xie if (dir_item != NULL && !IS_ERR(dir_item)) { 1724fe66a05aSChris Mason pending->error = -EEXIST; 1725aec8030aSMiao Xie goto dir_item_existed; 172642874b3dSMiao Xie } else if (IS_ERR(dir_item)) { 172742874b3dSMiao Xie ret = PTR_ERR(dir_item); 172866642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 17298732d44fSMiao Xie goto fail; 173079787eaaSJeff Mahoney } 173142874b3dSMiao Xie btrfs_release_path(path); 17326bdb72deSSage Weil 1733e999376fSChris Mason /* 1734e999376fSChris Mason * pull in the delayed directory update 1735e999376fSChris Mason * and the delayed inode item 1736e999376fSChris Mason * otherwise we corrupt the FS during 1737e999376fSChris Mason * snapshot 1738e999376fSChris Mason */ 1739e5c304e6SNikolay Borisov ret = btrfs_run_delayed_items(trans); 17408732d44fSMiao Xie if (ret) { /* Transaction aborted */ 174166642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 17428732d44fSMiao Xie goto fail; 17438732d44fSMiao Xie } 1744e999376fSChris Mason 1745f0118cb6SJosef Bacik ret = record_root_in_trans(trans, root, 0); 1746f0118cb6SJosef Bacik if (ret) { 1747f0118cb6SJosef Bacik btrfs_abort_transaction(trans, ret); 1748f0118cb6SJosef Bacik goto fail; 1749f0118cb6SJosef Bacik } 17506bdb72deSSage Weil btrfs_set_root_last_snapshot(&root->root_item, trans->transid); 17516bdb72deSSage Weil memcpy(new_root_item, &root->root_item, sizeof(*new_root_item)); 175208fe4db1SLi Zefan btrfs_check_and_init_root_item(new_root_item); 17536bdb72deSSage Weil 1754b83cc969SLi Zefan root_flags = btrfs_root_flags(new_root_item); 1755b83cc969SLi Zefan if (pending->readonly) 1756b83cc969SLi Zefan root_flags |= BTRFS_ROOT_SUBVOL_RDONLY; 1757b83cc969SLi Zefan else 1758b83cc969SLi Zefan root_flags &= ~BTRFS_ROOT_SUBVOL_RDONLY; 1759b83cc969SLi Zefan btrfs_set_root_flags(new_root_item, root_flags); 1760b83cc969SLi Zefan 17618ea05e3aSAlexander Block btrfs_set_root_generation_v2(new_root_item, 17628ea05e3aSAlexander Block trans->transid); 1763807fc790SAndy Shevchenko generate_random_guid(new_root_item->uuid); 17648ea05e3aSAlexander Block memcpy(new_root_item->parent_uuid, root->root_item.uuid, 17658ea05e3aSAlexander Block BTRFS_UUID_SIZE); 176670023da2SStefan Behrens if (!(root_flags & BTRFS_ROOT_SUBVOL_RDONLY)) { 176770023da2SStefan Behrens memset(new_root_item->received_uuid, 0, 176870023da2SStefan Behrens sizeof(new_root_item->received_uuid)); 17698ea05e3aSAlexander Block memset(&new_root_item->stime, 0, sizeof(new_root_item->stime)); 17708ea05e3aSAlexander Block memset(&new_root_item->rtime, 0, sizeof(new_root_item->rtime)); 17718ea05e3aSAlexander Block btrfs_set_root_stransid(new_root_item, 0); 17728ea05e3aSAlexander Block btrfs_set_root_rtransid(new_root_item, 0); 177370023da2SStefan Behrens } 17743cae210fSQu Wenruo btrfs_set_stack_timespec_sec(&new_root_item->otime, cur_time.tv_sec); 17753cae210fSQu Wenruo btrfs_set_stack_timespec_nsec(&new_root_item->otime, cur_time.tv_nsec); 177670023da2SStefan Behrens btrfs_set_root_otransid(new_root_item, trans->transid); 17778ea05e3aSAlexander Block 1778925baeddSChris Mason old = btrfs_lock_root_node(root); 17799631e4ccSJosef Bacik ret = btrfs_cow_block(trans, root, old, NULL, 0, &old, 17809631e4ccSJosef Bacik BTRFS_NESTING_COW); 178179787eaaSJeff Mahoney if (ret) { 178279787eaaSJeff Mahoney btrfs_tree_unlock(old); 178379787eaaSJeff Mahoney free_extent_buffer(old); 178466642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 17858732d44fSMiao Xie goto fail; 178679787eaaSJeff Mahoney } 178749b25e05SJeff Mahoney 178849b25e05SJeff Mahoney ret = btrfs_copy_root(trans, root, old, &tmp, objectid); 178979787eaaSJeff Mahoney /* clean up in any case */ 1790925baeddSChris Mason btrfs_tree_unlock(old); 1791925baeddSChris Mason free_extent_buffer(old); 17928732d44fSMiao Xie if (ret) { 179366642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 17948732d44fSMiao Xie goto fail; 17958732d44fSMiao Xie } 1796f1ebcc74SLiu Bo /* see comments in should_cow_block() */ 179727cdeb70SMiao Xie set_bit(BTRFS_ROOT_FORCE_COW, &root->state); 1798f1ebcc74SLiu Bo smp_wmb(); 1799f1ebcc74SLiu Bo 18005d4f98a2SYan Zheng btrfs_set_root_node(new_root_item, tmp); 1801a22285a6SYan, Zheng /* record when the snapshot was created in key.offset */ 1802a22285a6SYan, Zheng key.offset = trans->transid; 1803a22285a6SYan, Zheng ret = btrfs_insert_root(trans, tree_root, &key, new_root_item); 1804925baeddSChris Mason btrfs_tree_unlock(tmp); 18053063d29fSChris Mason free_extent_buffer(tmp); 18068732d44fSMiao Xie if (ret) { 180766642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 18088732d44fSMiao Xie goto fail; 18098732d44fSMiao Xie } 18100660b5afSChris Mason 1811a22285a6SYan, Zheng /* 1812a22285a6SYan, Zheng * insert root back/forward references 1813a22285a6SYan, Zheng */ 18146025c19fSLu Fengqi ret = btrfs_add_root_ref(trans, objectid, 1815a22285a6SYan, Zheng parent_root->root_key.objectid, 18164a0cc7caSNikolay Borisov btrfs_ino(BTRFS_I(parent_inode)), index, 18176db75318SSweet Tea Dorminy &fname.disk_name); 18188732d44fSMiao Xie if (ret) { 181966642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 18208732d44fSMiao Xie goto fail; 18218732d44fSMiao Xie } 1822a22285a6SYan, Zheng 1823a22285a6SYan, Zheng key.offset = (u64)-1; 1824*eb344109SFilipe Manana pending->snap = btrfs_get_new_fs_root(fs_info, objectid, &pending->anon_dev); 182579787eaaSJeff Mahoney if (IS_ERR(pending->snap)) { 182679787eaaSJeff Mahoney ret = PTR_ERR(pending->snap); 18272d892ccdSFilipe Manana pending->snap = NULL; 182866642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 18298732d44fSMiao Xie goto fail; 183079787eaaSJeff Mahoney } 1831d68fc57bSYan, Zheng 183249b25e05SJeff Mahoney ret = btrfs_reloc_post_snapshot(trans, pending); 18338732d44fSMiao Xie if (ret) { 183466642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 18358732d44fSMiao Xie goto fail; 18368732d44fSMiao Xie } 1837361048f5SMiao Xie 18386426c7adSQu Wenruo /* 18396426c7adSQu Wenruo * Do special qgroup accounting for snapshot, as we do some qgroup 18406426c7adSQu Wenruo * snapshot hack to do fast snapshot. 18416426c7adSQu Wenruo * To co-operate with that hack, we do hack again. 18426426c7adSQu Wenruo * Or snapshot will be greatly slowed down by a subtree qgroup rescan 18436426c7adSQu Wenruo */ 18446426c7adSQu Wenruo ret = qgroup_account_snapshot(trans, root, parent_root, 18456426c7adSQu Wenruo pending->inherit, objectid); 18466426c7adSQu Wenruo if (ret < 0) 18476426c7adSQu Wenruo goto fail; 18486426c7adSQu Wenruo 18496db75318SSweet Tea Dorminy ret = btrfs_insert_dir_item(trans, &fname.disk_name, 18506db75318SSweet Tea Dorminy BTRFS_I(parent_inode), &key, BTRFS_FT_DIR, 18516db75318SSweet Tea Dorminy index); 185242874b3dSMiao Xie /* We have check then name at the beginning, so it is impossible. */ 18539c52057cSChris Mason BUG_ON(ret == -EEXIST || ret == -EOVERFLOW); 18548732d44fSMiao Xie if (ret) { 185566642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 18568732d44fSMiao Xie goto fail; 18578732d44fSMiao Xie } 185842874b3dSMiao Xie 18596ef06d27SNikolay Borisov btrfs_i_size_write(BTRFS_I(parent_inode), parent_inode->i_size + 18606db75318SSweet Tea Dorminy fname.disk_name.len * 2); 18612a9462deSJeff Layton parent_inode->i_mtime = inode_set_ctime_current(parent_inode); 1862729f7961SNikolay Borisov ret = btrfs_update_inode_fallback(trans, parent_root, BTRFS_I(parent_inode)); 1863dd5f9615SStefan Behrens if (ret) { 186466642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 1865dd5f9615SStefan Behrens goto fail; 1866dd5f9615SStefan Behrens } 1867807fc790SAndy Shevchenko ret = btrfs_uuid_tree_add(trans, new_root_item->uuid, 1868807fc790SAndy Shevchenko BTRFS_UUID_KEY_SUBVOL, 1869cdb345a8SLu Fengqi objectid); 1870dd5f9615SStefan Behrens if (ret) { 187166642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 1872dd5f9615SStefan Behrens goto fail; 1873dd5f9615SStefan Behrens } 1874dd5f9615SStefan Behrens if (!btrfs_is_empty_uuid(new_root_item->received_uuid)) { 1875cdb345a8SLu Fengqi ret = btrfs_uuid_tree_add(trans, new_root_item->received_uuid, 1876dd5f9615SStefan Behrens BTRFS_UUID_KEY_RECEIVED_SUBVOL, 1877dd5f9615SStefan Behrens objectid); 1878dd5f9615SStefan Behrens if (ret && ret != -EEXIST) { 187966642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 1880dd5f9615SStefan Behrens goto fail; 1881dd5f9615SStefan Behrens } 1882dd5f9615SStefan Behrens } 1883d6726335SQu Wenruo 18843063d29fSChris Mason fail: 1885aec8030aSMiao Xie pending->error = ret; 1886aec8030aSMiao Xie dir_item_existed: 188798c9942aSLiu Bo trans->block_rsv = rsv; 18882382c5ccSLiu Bo trans->bytes_reserved = 0; 1889d6726335SQu Wenruo clear_skip_qgroup: 1890d6726335SQu Wenruo btrfs_clear_skip_qgroup(trans); 1891ab3c5c18SSweet Tea Dorminy free_fname: 1892ab3c5c18SSweet Tea Dorminy fscrypt_free_filename(&fname); 1893ab3c5c18SSweet Tea Dorminy free_pending: 18946fa9700eSMiao Xie kfree(new_root_item); 1895b0c0ea63SDavid Sterba pending->root_item = NULL; 189642874b3dSMiao Xie btrfs_free_path(path); 18978546b570SDavid Sterba pending->path = NULL; 18988546b570SDavid Sterba 189949b25e05SJeff Mahoney return ret; 19003063d29fSChris Mason } 19013063d29fSChris Mason 1902d352ac68SChris Mason /* 1903d352ac68SChris Mason * create all the snapshots we've scheduled for creation 1904d352ac68SChris Mason */ 190508d50ca3SNikolay Borisov static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans) 19063063d29fSChris Mason { 1907aec8030aSMiao Xie struct btrfs_pending_snapshot *pending, *next; 19083063d29fSChris Mason struct list_head *head = &trans->transaction->pending_snapshots; 1909aec8030aSMiao Xie int ret = 0; 19103de4586cSChris Mason 1911aec8030aSMiao Xie list_for_each_entry_safe(pending, next, head, list) { 1912aec8030aSMiao Xie list_del(&pending->list); 191308d50ca3SNikolay Borisov ret = create_pending_snapshot(trans, pending); 1914aec8030aSMiao Xie if (ret) 1915aec8030aSMiao Xie break; 1916aec8030aSMiao Xie } 1917aec8030aSMiao Xie return ret; 19183de4586cSChris Mason } 19193de4586cSChris Mason 19202ff7e61eSJeff Mahoney static void update_super_roots(struct btrfs_fs_info *fs_info) 19215d4f98a2SYan Zheng { 19225d4f98a2SYan Zheng struct btrfs_root_item *root_item; 19235d4f98a2SYan Zheng struct btrfs_super_block *super; 19245d4f98a2SYan Zheng 19250b246afaSJeff Mahoney super = fs_info->super_copy; 19265d4f98a2SYan Zheng 19270b246afaSJeff Mahoney root_item = &fs_info->chunk_root->root_item; 1928093e037cSDavid Sterba super->chunk_root = root_item->bytenr; 1929093e037cSDavid Sterba super->chunk_root_generation = root_item->generation; 1930093e037cSDavid Sterba super->chunk_root_level = root_item->level; 19315d4f98a2SYan Zheng 19320b246afaSJeff Mahoney root_item = &fs_info->tree_root->root_item; 1933093e037cSDavid Sterba super->root = root_item->bytenr; 1934093e037cSDavid Sterba super->generation = root_item->generation; 1935093e037cSDavid Sterba super->root_level = root_item->level; 19360b246afaSJeff Mahoney if (btrfs_test_opt(fs_info, SPACE_CACHE)) 1937093e037cSDavid Sterba super->cache_generation = root_item->generation; 193894846229SBoris Burkov else if (test_bit(BTRFS_FS_CLEANUP_SPACE_CACHE_V1, &fs_info->flags)) 193994846229SBoris Burkov super->cache_generation = 0; 19400b246afaSJeff Mahoney if (test_bit(BTRFS_FS_UPDATE_UUID_TREE_GEN, &fs_info->flags)) 1941093e037cSDavid Sterba super->uuid_tree_generation = root_item->generation; 19425d4f98a2SYan Zheng } 19435d4f98a2SYan Zheng 1944f36f3042SChris Mason int btrfs_transaction_in_commit(struct btrfs_fs_info *info) 1945f36f3042SChris Mason { 19464a9d8bdeSMiao Xie struct btrfs_transaction *trans; 1947f36f3042SChris Mason int ret = 0; 19484a9d8bdeSMiao Xie 1949a4abeea4SJosef Bacik spin_lock(&info->trans_lock); 19504a9d8bdeSMiao Xie trans = info->running_transaction; 19514a9d8bdeSMiao Xie if (trans) 19524a9d8bdeSMiao Xie ret = (trans->state >= TRANS_STATE_COMMIT_START); 1953a4abeea4SJosef Bacik spin_unlock(&info->trans_lock); 1954f36f3042SChris Mason return ret; 1955f36f3042SChris Mason } 1956f36f3042SChris Mason 19578929ecfaSYan, Zheng int btrfs_transaction_blocked(struct btrfs_fs_info *info) 19588929ecfaSYan, Zheng { 19594a9d8bdeSMiao Xie struct btrfs_transaction *trans; 19608929ecfaSYan, Zheng int ret = 0; 19614a9d8bdeSMiao Xie 1962a4abeea4SJosef Bacik spin_lock(&info->trans_lock); 19634a9d8bdeSMiao Xie trans = info->running_transaction; 19644a9d8bdeSMiao Xie if (trans) 19654a9d8bdeSMiao Xie ret = is_transaction_blocked(trans); 1966a4abeea4SJosef Bacik spin_unlock(&info->trans_lock); 19678929ecfaSYan, Zheng return ret; 19688929ecfaSYan, Zheng } 19698929ecfaSYan, Zheng 1970fdfbf020SJosef Bacik void btrfs_commit_transaction_async(struct btrfs_trans_handle *trans) 1971bb9c12c9SSage Weil { 19723a45bb20SJeff Mahoney struct btrfs_fs_info *fs_info = trans->fs_info; 1973bb9c12c9SSage Weil struct btrfs_transaction *cur_trans; 1974bb9c12c9SSage Weil 1975fdfbf020SJosef Bacik /* Kick the transaction kthread. */ 1976fdfbf020SJosef Bacik set_bit(BTRFS_FS_COMMIT_TRANS, &fs_info->flags); 1977fdfbf020SJosef Bacik wake_up_process(fs_info->transaction_kthread); 1978bb9c12c9SSage Weil 1979bb9c12c9SSage Weil /* take transaction reference */ 1980bb9c12c9SSage Weil cur_trans = trans->transaction; 19819b64f57dSElena Reshetova refcount_inc(&cur_trans->use_count); 1982bb9c12c9SSage Weil 19833a45bb20SJeff Mahoney btrfs_end_transaction(trans); 19846fc4e354SSage Weil 19856fc4e354SSage Weil /* 1986ae5d29d4SDavid Sterba * Wait for the current transaction commit to start and block 1987ae5d29d4SDavid Sterba * subsequent transaction joins 1988ae5d29d4SDavid Sterba */ 198977d20c68SJosef Bacik btrfs_might_wait_for_state(fs_info, BTRFS_LOCKDEP_TRANS_COMMIT_PREP); 1990ae5d29d4SDavid Sterba wait_event(fs_info->transaction_blocked_wait, 1991ae5d29d4SDavid Sterba cur_trans->state >= TRANS_STATE_COMMIT_START || 1992ae5d29d4SDavid Sterba TRANS_ABORTED(cur_trans)); 1993724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 1994bb9c12c9SSage Weil } 1995bb9c12c9SSage Weil 199697cb39bbSNikolay Borisov static void cleanup_transaction(struct btrfs_trans_handle *trans, int err) 199749b25e05SJeff Mahoney { 199897cb39bbSNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 199949b25e05SJeff Mahoney struct btrfs_transaction *cur_trans = trans->transaction; 200049b25e05SJeff Mahoney 2001b50fff81SDavid Sterba WARN_ON(refcount_read(&trans->use_count) > 1); 200249b25e05SJeff Mahoney 200366642832SJeff Mahoney btrfs_abort_transaction(trans, err); 20047b8b92afSJosef Bacik 20050b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 200666b6135bSLiu Bo 200725d8c284SMiao Xie /* 200825d8c284SMiao Xie * If the transaction is removed from the list, it means this 200925d8c284SMiao Xie * transaction has been committed successfully, so it is impossible 201025d8c284SMiao Xie * to call the cleanup function. 201125d8c284SMiao Xie */ 201225d8c284SMiao Xie BUG_ON(list_empty(&cur_trans->list)); 201366b6135bSLiu Bo 20140b246afaSJeff Mahoney if (cur_trans == fs_info->running_transaction) { 20154a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_COMMIT_DOING; 20160b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 2017e1489b4fSIoannis Angelakopoulos 2018e1489b4fSIoannis Angelakopoulos /* 2019e1489b4fSIoannis Angelakopoulos * The thread has already released the lockdep map as reader 2020e1489b4fSIoannis Angelakopoulos * already in btrfs_commit_transaction(). 2021e1489b4fSIoannis Angelakopoulos */ 2022e1489b4fSIoannis Angelakopoulos btrfs_might_wait_for_event(fs_info, btrfs_trans_num_writers); 2023f094ac32SLiu Bo wait_event(cur_trans->writer_wait, 2024f094ac32SLiu Bo atomic_read(&cur_trans->num_writers) == 1); 2025f094ac32SLiu Bo 20260b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 2027d7096fc3SJosef Bacik } 2028061dde82SFilipe Manana 2029061dde82SFilipe Manana /* 2030061dde82SFilipe Manana * Now that we know no one else is still using the transaction we can 2031061dde82SFilipe Manana * remove the transaction from the list of transactions. This avoids 2032061dde82SFilipe Manana * the transaction kthread from cleaning up the transaction while some 2033061dde82SFilipe Manana * other task is still using it, which could result in a use-after-free 2034061dde82SFilipe Manana * on things like log trees, as it forces the transaction kthread to 2035061dde82SFilipe Manana * wait for this transaction to be cleaned up by us. 2036061dde82SFilipe Manana */ 2037061dde82SFilipe Manana list_del_init(&cur_trans->list); 2038061dde82SFilipe Manana 20390b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 204049b25e05SJeff Mahoney 20412ff7e61eSJeff Mahoney btrfs_cleanup_one_transaction(trans->transaction, fs_info); 204249b25e05SJeff Mahoney 20430b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 20440b246afaSJeff Mahoney if (cur_trans == fs_info->running_transaction) 20450b246afaSJeff Mahoney fs_info->running_transaction = NULL; 20460b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 20474a9d8bdeSMiao Xie 2048e0228285SJosef Bacik if (trans->type & __TRANS_FREEZABLE) 20490b246afaSJeff Mahoney sb_end_intwrite(fs_info->sb); 2050724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 2051724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 205249b25e05SJeff Mahoney 20532e4e97abSJosef Bacik trace_btrfs_transaction_commit(fs_info); 205449b25e05SJeff Mahoney 205549b25e05SJeff Mahoney if (current->journal_info == trans) 205649b25e05SJeff Mahoney current->journal_info = NULL; 20572d82a40aSFilipe Manana 20582d82a40aSFilipe Manana /* 20592d82a40aSFilipe Manana * If relocation is running, we can't cancel scrub because that will 20602d82a40aSFilipe Manana * result in a deadlock. Before relocating a block group, relocation 20612d82a40aSFilipe Manana * pauses scrub, then starts and commits a transaction before unpausing 20622d82a40aSFilipe Manana * scrub. If the transaction commit is being done by the relocation 20632d82a40aSFilipe Manana * task or triggered by another task and the relocation task is waiting 20642d82a40aSFilipe Manana * for the commit, and we end up here due to an error in the commit 20652d82a40aSFilipe Manana * path, then calling btrfs_scrub_cancel() will deadlock, as we are 20662d82a40aSFilipe Manana * asking for scrub to stop while having it asked to be paused higher 20672d82a40aSFilipe Manana * above in relocation code. 20682d82a40aSFilipe Manana */ 20692d82a40aSFilipe Manana if (!test_bit(BTRFS_FS_RELOC_RUNNING, &fs_info->flags)) 20700b246afaSJeff Mahoney btrfs_scrub_cancel(fs_info); 207149b25e05SJeff Mahoney 207249b25e05SJeff Mahoney kmem_cache_free(btrfs_trans_handle_cachep, trans); 207349b25e05SJeff Mahoney } 207449b25e05SJeff Mahoney 2075c7cc64a9SDavid Sterba /* 2076c7cc64a9SDavid Sterba * Release reserved delayed ref space of all pending block groups of the 2077c7cc64a9SDavid Sterba * transaction and remove them from the list 2078c7cc64a9SDavid Sterba */ 2079c7cc64a9SDavid Sterba static void btrfs_cleanup_pending_block_groups(struct btrfs_trans_handle *trans) 2080c7cc64a9SDavid Sterba { 2081c7cc64a9SDavid Sterba struct btrfs_fs_info *fs_info = trans->fs_info; 208232da5386SDavid Sterba struct btrfs_block_group *block_group, *tmp; 2083c7cc64a9SDavid Sterba 2084c7cc64a9SDavid Sterba list_for_each_entry_safe(block_group, tmp, &trans->new_bgs, bg_list) { 2085c7cc64a9SDavid Sterba btrfs_delayed_refs_rsv_release(fs_info, 1); 2086c7cc64a9SDavid Sterba list_del_init(&block_group->bg_list); 2087c7cc64a9SDavid Sterba } 2088c7cc64a9SDavid Sterba } 2089c7cc64a9SDavid Sterba 209088090ad3SFilipe Manana static inline int btrfs_start_delalloc_flush(struct btrfs_fs_info *fs_info) 209182436617SMiao Xie { 2092ce8ea7ccSJosef Bacik /* 2093a0f0cf83SFilipe Manana * We use try_to_writeback_inodes_sb() here because if we used 2094ce8ea7ccSJosef Bacik * btrfs_start_delalloc_roots we would deadlock with fs freeze. 2095ce8ea7ccSJosef Bacik * Currently are holding the fs freeze lock, if we do an async flush 2096ce8ea7ccSJosef Bacik * we'll do btrfs_join_transaction() and deadlock because we need to 2097ce8ea7ccSJosef Bacik * wait for the fs freeze lock. Using the direct flushing we benefit 2098ce8ea7ccSJosef Bacik * from already being in a transaction and our join_transaction doesn't 2099ce8ea7ccSJosef Bacik * have to re-take the fs freeze lock. 2100a0f0cf83SFilipe Manana * 2101a0f0cf83SFilipe Manana * Note that try_to_writeback_inodes_sb() will only trigger writeback 2102a0f0cf83SFilipe Manana * if it can read lock sb->s_umount. It will always be able to lock it, 2103a0f0cf83SFilipe Manana * except when the filesystem is being unmounted or being frozen, but in 2104a0f0cf83SFilipe Manana * those cases sync_filesystem() is called, which results in calling 2105a0f0cf83SFilipe Manana * writeback_inodes_sb() while holding a write lock on sb->s_umount. 2106a0f0cf83SFilipe Manana * Note that we don't call writeback_inodes_sb() directly, because it 2107a0f0cf83SFilipe Manana * will emit a warning if sb->s_umount is not locked. 2108ce8ea7ccSJosef Bacik */ 210988090ad3SFilipe Manana if (btrfs_test_opt(fs_info, FLUSHONCOMMIT)) 2110a0f0cf83SFilipe Manana try_to_writeback_inodes_sb(fs_info->sb, WB_REASON_SYNC); 211182436617SMiao Xie return 0; 211282436617SMiao Xie } 211382436617SMiao Xie 211488090ad3SFilipe Manana static inline void btrfs_wait_delalloc_flush(struct btrfs_fs_info *fs_info) 211582436617SMiao Xie { 211688090ad3SFilipe Manana if (btrfs_test_opt(fs_info, FLUSHONCOMMIT)) 21176374e57aSChris Mason btrfs_wait_ordered_roots(fs_info, U64_MAX, 0, (u64)-1); 211882436617SMiao Xie } 211982436617SMiao Xie 212028b21c55SFilipe Manana /* 212128b21c55SFilipe Manana * Add a pending snapshot associated with the given transaction handle to the 212228b21c55SFilipe Manana * respective handle. This must be called after the transaction commit started 212328b21c55SFilipe Manana * and while holding fs_info->trans_lock. 212428b21c55SFilipe Manana * This serves to guarantee a caller of btrfs_commit_transaction() that it can 212528b21c55SFilipe Manana * safely free the pending snapshot pointer in case btrfs_commit_transaction() 212628b21c55SFilipe Manana * returns an error. 212728b21c55SFilipe Manana */ 212828b21c55SFilipe Manana static void add_pending_snapshot(struct btrfs_trans_handle *trans) 212928b21c55SFilipe Manana { 213028b21c55SFilipe Manana struct btrfs_transaction *cur_trans = trans->transaction; 213128b21c55SFilipe Manana 213228b21c55SFilipe Manana if (!trans->pending_snapshot) 213328b21c55SFilipe Manana return; 213428b21c55SFilipe Manana 213528b21c55SFilipe Manana lockdep_assert_held(&trans->fs_info->trans_lock); 213677d20c68SJosef Bacik ASSERT(cur_trans->state >= TRANS_STATE_COMMIT_PREP); 213728b21c55SFilipe Manana 213828b21c55SFilipe Manana list_add(&trans->pending_snapshot->list, &cur_trans->pending_snapshots); 213928b21c55SFilipe Manana } 214028b21c55SFilipe Manana 2141e55958c8SIoannis Angelakopoulos static void update_commit_stats(struct btrfs_fs_info *fs_info, ktime_t interval) 2142e55958c8SIoannis Angelakopoulos { 2143e55958c8SIoannis Angelakopoulos fs_info->commit_stats.commit_count++; 2144e55958c8SIoannis Angelakopoulos fs_info->commit_stats.last_commit_dur = interval; 2145e55958c8SIoannis Angelakopoulos fs_info->commit_stats.max_commit_dur = 2146e55958c8SIoannis Angelakopoulos max_t(u64, fs_info->commit_stats.max_commit_dur, interval); 2147e55958c8SIoannis Angelakopoulos fs_info->commit_stats.total_commit_dur += interval; 2148e55958c8SIoannis Angelakopoulos } 2149e55958c8SIoannis Angelakopoulos 21503a45bb20SJeff Mahoney int btrfs_commit_transaction(struct btrfs_trans_handle *trans) 215179154b1bSChris Mason { 21523a45bb20SJeff Mahoney struct btrfs_fs_info *fs_info = trans->fs_info; 215349b25e05SJeff Mahoney struct btrfs_transaction *cur_trans = trans->transaction; 21548fd17795SChris Mason struct btrfs_transaction *prev_trans = NULL; 215525287e0aSMiao Xie int ret; 2156e55958c8SIoannis Angelakopoulos ktime_t start_time; 2157e55958c8SIoannis Angelakopoulos ktime_t interval; 215879154b1bSChris Mason 215935b814f3SNikolay Borisov ASSERT(refcount_read(&trans->use_count) == 1); 216077d20c68SJosef Bacik btrfs_trans_state_lockdep_acquire(fs_info, BTRFS_LOCKDEP_TRANS_COMMIT_PREP); 216135b814f3SNikolay Borisov 2162c52cc7b7SJosef Bacik clear_bit(BTRFS_FS_NEED_TRANS_COMMIT, &fs_info->flags); 2163c52cc7b7SJosef Bacik 21648d25a086SMiao Xie /* Stop the commit early if ->aborted is set */ 2165bf31f87fSDavid Sterba if (TRANS_ABORTED(cur_trans)) { 216625287e0aSMiao Xie ret = cur_trans->aborted; 21673e738c53SIoannis Angelakopoulos goto lockdep_trans_commit_start_release; 216825287e0aSMiao Xie } 216949b25e05SJeff Mahoney 2170f45c752bSJosef Bacik btrfs_trans_release_metadata(trans); 2171f45c752bSJosef Bacik trans->block_rsv = NULL; 2172f45c752bSJosef Bacik 2173e19eb11fSJosef Bacik /* 2174e19eb11fSJosef Bacik * We only want one transaction commit doing the flushing so we do not 2175e19eb11fSJosef Bacik * waste a bunch of time on lock contention on the extent root node. 2176e19eb11fSJosef Bacik */ 2177e19eb11fSJosef Bacik if (!test_and_set_bit(BTRFS_DELAYED_REFS_FLUSHING, 2178e19eb11fSJosef Bacik &cur_trans->delayed_refs.flags)) { 2179e19eb11fSJosef Bacik /* 2180e19eb11fSJosef Bacik * Make a pass through all the delayed refs we have so far. 2181e19eb11fSJosef Bacik * Any running threads may add more while we are here. 218256bec294SChris Mason */ 2183c79a70b1SNikolay Borisov ret = btrfs_run_delayed_refs(trans, 0); 21843e738c53SIoannis Angelakopoulos if (ret) 21853e738c53SIoannis Angelakopoulos goto lockdep_trans_commit_start_release; 2186e19eb11fSJosef Bacik } 218756bec294SChris Mason 21886c686b35SNikolay Borisov btrfs_create_pending_block_groups(trans); 2189ea658badSJosef Bacik 21903204d33cSJosef Bacik if (!test_bit(BTRFS_TRANS_DIRTY_BG_RUN, &cur_trans->flags)) { 21911bbc621eSChris Mason int run_it = 0; 21921bbc621eSChris Mason 21931bbc621eSChris Mason /* this mutex is also taken before trying to set 21941bbc621eSChris Mason * block groups readonly. We need to make sure 21951bbc621eSChris Mason * that nobody has set a block group readonly 21961bbc621eSChris Mason * after a extents from that block group have been 21971bbc621eSChris Mason * allocated for cache files. btrfs_set_block_group_ro 21981bbc621eSChris Mason * will wait for the transaction to commit if it 21993204d33cSJosef Bacik * finds BTRFS_TRANS_DIRTY_BG_RUN set. 22001bbc621eSChris Mason * 22013204d33cSJosef Bacik * The BTRFS_TRANS_DIRTY_BG_RUN flag is also used to make sure 22023204d33cSJosef Bacik * only one process starts all the block group IO. It wouldn't 22031bbc621eSChris Mason * hurt to have more than one go through, but there's no 22041bbc621eSChris Mason * real advantage to it either. 22051bbc621eSChris Mason */ 22060b246afaSJeff Mahoney mutex_lock(&fs_info->ro_block_group_mutex); 22073204d33cSJosef Bacik if (!test_and_set_bit(BTRFS_TRANS_DIRTY_BG_RUN, 22083204d33cSJosef Bacik &cur_trans->flags)) 22091bbc621eSChris Mason run_it = 1; 22100b246afaSJeff Mahoney mutex_unlock(&fs_info->ro_block_group_mutex); 22111bbc621eSChris Mason 2212f9cacae3SNikolay Borisov if (run_it) { 221321217054SNikolay Borisov ret = btrfs_start_dirty_block_groups(trans); 22143e738c53SIoannis Angelakopoulos if (ret) 22153e738c53SIoannis Angelakopoulos goto lockdep_trans_commit_start_release; 2216f9cacae3SNikolay Borisov } 2217f9cacae3SNikolay Borisov } 22181bbc621eSChris Mason 22190b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 222077d20c68SJosef Bacik if (cur_trans->state >= TRANS_STATE_COMMIT_PREP) { 2221d0c2f4faSFilipe Manana enum btrfs_trans_state want_state = TRANS_STATE_COMPLETED; 2222d0c2f4faSFilipe Manana 222328b21c55SFilipe Manana add_pending_snapshot(trans); 222428b21c55SFilipe Manana 22250b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 22269b64f57dSElena Reshetova refcount_inc(&cur_trans->use_count); 2227ccd467d6SChris Mason 2228d0c2f4faSFilipe Manana if (trans->in_fsync) 2229d0c2f4faSFilipe Manana want_state = TRANS_STATE_SUPER_COMMITTED; 22303e738c53SIoannis Angelakopoulos 22313e738c53SIoannis Angelakopoulos btrfs_trans_state_lockdep_release(fs_info, 223277d20c68SJosef Bacik BTRFS_LOCKDEP_TRANS_COMMIT_PREP); 2233d0c2f4faSFilipe Manana ret = btrfs_end_transaction(trans); 2234d0c2f4faSFilipe Manana wait_for_commit(cur_trans, want_state); 223515ee9bc7SJosef Bacik 2236bf31f87fSDavid Sterba if (TRANS_ABORTED(cur_trans)) 2237b4924a0fSLiu Bo ret = cur_trans->aborted; 2238b4924a0fSLiu Bo 2239724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 224015ee9bc7SJosef Bacik 224149b25e05SJeff Mahoney return ret; 224279154b1bSChris Mason } 22434313b399SChris Mason 224477d20c68SJosef Bacik cur_trans->state = TRANS_STATE_COMMIT_PREP; 22450b246afaSJeff Mahoney wake_up(&fs_info->transaction_blocked_wait); 224677d20c68SJosef Bacik btrfs_trans_state_lockdep_release(fs_info, BTRFS_LOCKDEP_TRANS_COMMIT_PREP); 2247bb9c12c9SSage Weil 22480b246afaSJeff Mahoney if (cur_trans->list.prev != &fs_info->trans_list) { 2249d0c2f4faSFilipe Manana enum btrfs_trans_state want_state = TRANS_STATE_COMPLETED; 2250d0c2f4faSFilipe Manana 2251d0c2f4faSFilipe Manana if (trans->in_fsync) 2252d0c2f4faSFilipe Manana want_state = TRANS_STATE_SUPER_COMMITTED; 2253d0c2f4faSFilipe Manana 2254ccd467d6SChris Mason prev_trans = list_entry(cur_trans->list.prev, 2255ccd467d6SChris Mason struct btrfs_transaction, list); 2256d0c2f4faSFilipe Manana if (prev_trans->state < want_state) { 22579b64f57dSElena Reshetova refcount_inc(&prev_trans->use_count); 22580b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 2259ccd467d6SChris Mason 2260d0c2f4faSFilipe Manana wait_for_commit(prev_trans, want_state); 2261d0c2f4faSFilipe Manana 2262bf31f87fSDavid Sterba ret = READ_ONCE(prev_trans->aborted); 2263ccd467d6SChris Mason 2264724e2315SJosef Bacik btrfs_put_transaction(prev_trans); 22651f9b8c8fSFilipe Manana if (ret) 2266e1489b4fSIoannis Angelakopoulos goto lockdep_release; 226777d20c68SJosef Bacik spin_lock(&fs_info->trans_lock); 2268ccd467d6SChris Mason } 2269a4abeea4SJosef Bacik } else { 2270cb2d3dadSFilipe Manana /* 2271cb2d3dadSFilipe Manana * The previous transaction was aborted and was already removed 2272cb2d3dadSFilipe Manana * from the list of transactions at fs_info->trans_list. So we 2273cb2d3dadSFilipe Manana * abort to prevent writing a new superblock that reflects a 2274cb2d3dadSFilipe Manana * corrupt state (pointing to trees with unwritten nodes/leafs). 2275cb2d3dadSFilipe Manana */ 227684961539SJosef Bacik if (BTRFS_FS_ERROR(fs_info)) { 227777d20c68SJosef Bacik spin_unlock(&fs_info->trans_lock); 2278cb2d3dadSFilipe Manana ret = -EROFS; 2279e1489b4fSIoannis Angelakopoulos goto lockdep_release; 2280cb2d3dadSFilipe Manana } 2281ccd467d6SChris Mason } 228215ee9bc7SJosef Bacik 228377d20c68SJosef Bacik cur_trans->state = TRANS_STATE_COMMIT_START; 228477d20c68SJosef Bacik wake_up(&fs_info->transaction_blocked_wait); 228577d20c68SJosef Bacik spin_unlock(&fs_info->trans_lock); 228677d20c68SJosef Bacik 2287e55958c8SIoannis Angelakopoulos /* 2288e55958c8SIoannis Angelakopoulos * Get the time spent on the work done by the commit thread and not 2289e55958c8SIoannis Angelakopoulos * the time spent waiting on a previous commit 2290e55958c8SIoannis Angelakopoulos */ 2291e55958c8SIoannis Angelakopoulos start_time = ktime_get_ns(); 2292e55958c8SIoannis Angelakopoulos 22930860adfdSMiao Xie extwriter_counter_dec(cur_trans, trans->type); 22940860adfdSMiao Xie 229588090ad3SFilipe Manana ret = btrfs_start_delalloc_flush(fs_info); 229682436617SMiao Xie if (ret) 2297e1489b4fSIoannis Angelakopoulos goto lockdep_release; 229882436617SMiao Xie 2299e5c304e6SNikolay Borisov ret = btrfs_run_delayed_items(trans); 230049b25e05SJeff Mahoney if (ret) 2301e1489b4fSIoannis Angelakopoulos goto lockdep_release; 230216cdcec7SMiao Xie 23035a9ba670SIoannis Angelakopoulos /* 23045a9ba670SIoannis Angelakopoulos * The thread has started/joined the transaction thus it holds the 23055a9ba670SIoannis Angelakopoulos * lockdep map as a reader. It has to release it before acquiring the 23065a9ba670SIoannis Angelakopoulos * lockdep map as a writer. 23075a9ba670SIoannis Angelakopoulos */ 23085a9ba670SIoannis Angelakopoulos btrfs_lockdep_release(fs_info, btrfs_trans_num_extwriters); 23095a9ba670SIoannis Angelakopoulos btrfs_might_wait_for_event(fs_info, btrfs_trans_num_extwriters); 2310581227d0SMiao Xie wait_event(cur_trans->writer_wait, 2311581227d0SMiao Xie extwriter_counter_read(cur_trans) == 0); 2312ed3b3d31SChris Mason 2313581227d0SMiao Xie /* some pending stuffs might be added after the previous flush. */ 2314e5c304e6SNikolay Borisov ret = btrfs_run_delayed_items(trans); 2315e1489b4fSIoannis Angelakopoulos if (ret) { 2316e1489b4fSIoannis Angelakopoulos btrfs_lockdep_release(fs_info, btrfs_trans_num_writers); 2317ca469637SMiao Xie goto cleanup_transaction; 2318e1489b4fSIoannis Angelakopoulos } 2319ca469637SMiao Xie 232088090ad3SFilipe Manana btrfs_wait_delalloc_flush(fs_info); 2321cb7ab021SWang Shilong 232248778179SFilipe Manana /* 232348778179SFilipe Manana * Wait for all ordered extents started by a fast fsync that joined this 232448778179SFilipe Manana * transaction. Otherwise if this transaction commits before the ordered 232548778179SFilipe Manana * extents complete we lose logged data after a power failure. 232648778179SFilipe Manana */ 23278b53779eSIoannis Angelakopoulos btrfs_might_wait_for_event(fs_info, btrfs_trans_pending_ordered); 232848778179SFilipe Manana wait_event(cur_trans->pending_wait, 232948778179SFilipe Manana atomic_read(&cur_trans->pending_ordered) == 0); 233048778179SFilipe Manana 23312ff7e61eSJeff Mahoney btrfs_scrub_pause(fs_info); 2332ed0ca140SJosef Bacik /* 2333ed0ca140SJosef Bacik * Ok now we need to make sure to block out any other joins while we 2334ed0ca140SJosef Bacik * commit the transaction. We could have started a join before setting 23354a9d8bdeSMiao Xie * COMMIT_DOING so make sure to wait for num_writers to == 1 again. 2336ed0ca140SJosef Bacik */ 23370b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 233828b21c55SFilipe Manana add_pending_snapshot(trans); 23394a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_COMMIT_DOING; 23400b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 2341e1489b4fSIoannis Angelakopoulos 2342e1489b4fSIoannis Angelakopoulos /* 2343e1489b4fSIoannis Angelakopoulos * The thread has started/joined the transaction thus it holds the 2344e1489b4fSIoannis Angelakopoulos * lockdep map as a reader. It has to release it before acquiring the 2345e1489b4fSIoannis Angelakopoulos * lockdep map as a writer. 2346e1489b4fSIoannis Angelakopoulos */ 2347e1489b4fSIoannis Angelakopoulos btrfs_lockdep_release(fs_info, btrfs_trans_num_writers); 2348e1489b4fSIoannis Angelakopoulos btrfs_might_wait_for_event(fs_info, btrfs_trans_num_writers); 2349ed0ca140SJosef Bacik wait_event(cur_trans->writer_wait, 2350ed0ca140SJosef Bacik atomic_read(&cur_trans->num_writers) == 1); 235115ee9bc7SJosef Bacik 2352fdfbf020SJosef Bacik /* 23533e738c53SIoannis Angelakopoulos * Make lockdep happy by acquiring the state locks after 23543e738c53SIoannis Angelakopoulos * btrfs_trans_num_writers is released. If we acquired the state locks 23553e738c53SIoannis Angelakopoulos * before releasing the btrfs_trans_num_writers lock then lockdep would 23563e738c53SIoannis Angelakopoulos * complain because we did not follow the reverse order unlocking rule. 23573e738c53SIoannis Angelakopoulos */ 23583e738c53SIoannis Angelakopoulos btrfs_trans_state_lockdep_acquire(fs_info, BTRFS_LOCKDEP_TRANS_COMPLETED); 23593e738c53SIoannis Angelakopoulos btrfs_trans_state_lockdep_acquire(fs_info, BTRFS_LOCKDEP_TRANS_SUPER_COMMITTED); 23603e738c53SIoannis Angelakopoulos btrfs_trans_state_lockdep_acquire(fs_info, BTRFS_LOCKDEP_TRANS_UNBLOCKED); 23613e738c53SIoannis Angelakopoulos 23623e738c53SIoannis Angelakopoulos /* 2363fdfbf020SJosef Bacik * We've started the commit, clear the flag in case we were triggered to 2364fdfbf020SJosef Bacik * do an async commit but somebody else started before the transaction 2365fdfbf020SJosef Bacik * kthread could do the work. 2366fdfbf020SJosef Bacik */ 2367fdfbf020SJosef Bacik clear_bit(BTRFS_FS_COMMIT_TRANS, &fs_info->flags); 2368fdfbf020SJosef Bacik 2369bf31f87fSDavid Sterba if (TRANS_ABORTED(cur_trans)) { 23702cba30f1SMiao Xie ret = cur_trans->aborted; 23713e738c53SIoannis Angelakopoulos btrfs_trans_state_lockdep_release(fs_info, BTRFS_LOCKDEP_TRANS_UNBLOCKED); 23726cf7f77eSWang Shilong goto scrub_continue; 23732cba30f1SMiao Xie } 23747585717fSChris Mason /* 23757585717fSChris Mason * the reloc mutex makes sure that we stop 23767585717fSChris Mason * the balancing code from coming in and moving 23777585717fSChris Mason * extents around in the middle of the commit 23787585717fSChris Mason */ 23790b246afaSJeff Mahoney mutex_lock(&fs_info->reloc_mutex); 23807585717fSChris Mason 238142874b3dSMiao Xie /* 238242874b3dSMiao Xie * We needn't worry about the delayed items because we will 238342874b3dSMiao Xie * deal with them in create_pending_snapshot(), which is the 238442874b3dSMiao Xie * core function of the snapshot creation. 238542874b3dSMiao Xie */ 238608d50ca3SNikolay Borisov ret = create_pending_snapshots(trans); 238756e9f6eaSDavid Sterba if (ret) 238856e9f6eaSDavid Sterba goto unlock_reloc; 23893063d29fSChris Mason 239042874b3dSMiao Xie /* 239142874b3dSMiao Xie * We insert the dir indexes of the snapshots and update the inode 239242874b3dSMiao Xie * of the snapshots' parents after the snapshot creation, so there 239342874b3dSMiao Xie * are some delayed items which are not dealt with. Now deal with 239442874b3dSMiao Xie * them. 239542874b3dSMiao Xie * 239642874b3dSMiao Xie * We needn't worry that this operation will corrupt the snapshots, 239742874b3dSMiao Xie * because all the tree which are snapshoted will be forced to COW 239842874b3dSMiao Xie * the nodes and leaves. 239942874b3dSMiao Xie */ 2400e5c304e6SNikolay Borisov ret = btrfs_run_delayed_items(trans); 240156e9f6eaSDavid Sterba if (ret) 240256e9f6eaSDavid Sterba goto unlock_reloc; 240316cdcec7SMiao Xie 2404c79a70b1SNikolay Borisov ret = btrfs_run_delayed_refs(trans, (unsigned long)-1); 240556e9f6eaSDavid Sterba if (ret) 240656e9f6eaSDavid Sterba goto unlock_reloc; 240756bec294SChris Mason 2408e999376fSChris Mason /* 2409e999376fSChris Mason * make sure none of the code above managed to slip in a 2410e999376fSChris Mason * delayed item 2411e999376fSChris Mason */ 2412ccdf9b30SJeff Mahoney btrfs_assert_delayed_root_empty(fs_info); 2413e999376fSChris Mason 24142c90e5d6SChris Mason WARN_ON(cur_trans != trans->transaction); 2415dc17ff8fSChris Mason 24167e4443d9SNikolay Borisov ret = commit_fs_roots(trans); 241756e9f6eaSDavid Sterba if (ret) 2418dfba78dcSFilipe Manana goto unlock_reloc; 241954aa1f4dSChris Mason 24205d4f98a2SYan Zheng /* commit_fs_roots gets rid of all the tree log roots, it is now 2421e02119d5SChris Mason * safe to free the root of tree log roots 2422e02119d5SChris Mason */ 24230b246afaSJeff Mahoney btrfs_free_log_root_tree(trans, fs_info); 2424e02119d5SChris Mason 24250ed4792aSQu Wenruo /* 24260ed4792aSQu Wenruo * Since fs roots are all committed, we can get a quite accurate 24270ed4792aSQu Wenruo * new_roots. So let's do quota accounting. 24280ed4792aSQu Wenruo */ 2429460fb20aSNikolay Borisov ret = btrfs_qgroup_account_extents(trans); 243056e9f6eaSDavid Sterba if (ret < 0) 2431dfba78dcSFilipe Manana goto unlock_reloc; 24320ed4792aSQu Wenruo 24339386d8bcSNikolay Borisov ret = commit_cowonly_roots(trans); 243456e9f6eaSDavid Sterba if (ret) 2435dfba78dcSFilipe Manana goto unlock_reloc; 243654aa1f4dSChris Mason 24372cba30f1SMiao Xie /* 24382cba30f1SMiao Xie * The tasks which save the space cache and inode cache may also 24392cba30f1SMiao Xie * update ->aborted, check it. 24402cba30f1SMiao Xie */ 2441bf31f87fSDavid Sterba if (TRANS_ABORTED(cur_trans)) { 24422cba30f1SMiao Xie ret = cur_trans->aborted; 2443dfba78dcSFilipe Manana goto unlock_reloc; 24442cba30f1SMiao Xie } 24452cba30f1SMiao Xie 24460b246afaSJeff Mahoney cur_trans = fs_info->running_transaction; 24475f39d397SChris Mason 24480b246afaSJeff Mahoney btrfs_set_root_node(&fs_info->tree_root->root_item, 24490b246afaSJeff Mahoney fs_info->tree_root->node); 24500b246afaSJeff Mahoney list_add_tail(&fs_info->tree_root->dirty_list, 24519e351cc8SJosef Bacik &cur_trans->switch_commits); 24525d4f98a2SYan Zheng 24530b246afaSJeff Mahoney btrfs_set_root_node(&fs_info->chunk_root->root_item, 24540b246afaSJeff Mahoney fs_info->chunk_root->node); 24550b246afaSJeff Mahoney list_add_tail(&fs_info->chunk_root->dirty_list, 24569e351cc8SJosef Bacik &cur_trans->switch_commits); 24579e351cc8SJosef Bacik 2458f7238e50SJosef Bacik if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2)) { 2459f7238e50SJosef Bacik btrfs_set_root_node(&fs_info->block_group_root->root_item, 2460f7238e50SJosef Bacik fs_info->block_group_root->node); 2461f7238e50SJosef Bacik list_add_tail(&fs_info->block_group_root->dirty_list, 2462f7238e50SJosef Bacik &cur_trans->switch_commits); 2463f7238e50SJosef Bacik } 2464f7238e50SJosef Bacik 2465889bfa39SJosef Bacik switch_commit_roots(trans); 24665d4f98a2SYan Zheng 2467ce93ec54SJosef Bacik ASSERT(list_empty(&cur_trans->dirty_bgs)); 24681bbc621eSChris Mason ASSERT(list_empty(&cur_trans->io_bgs)); 24692ff7e61eSJeff Mahoney update_super_roots(fs_info); 2470e02119d5SChris Mason 24710b246afaSJeff Mahoney btrfs_set_super_log_root(fs_info->super_copy, 0); 24720b246afaSJeff Mahoney btrfs_set_super_log_root_level(fs_info->super_copy, 0); 24730b246afaSJeff Mahoney memcpy(fs_info->super_for_commit, fs_info->super_copy, 24740b246afaSJeff Mahoney sizeof(*fs_info->super_copy)); 2475ccd467d6SChris Mason 2476bbbf7243SNikolay Borisov btrfs_commit_device_sizes(cur_trans); 2477935e5cc9SMiao Xie 24780b246afaSJeff Mahoney clear_bit(BTRFS_FS_LOG1_ERR, &fs_info->flags); 24790b246afaSJeff Mahoney clear_bit(BTRFS_FS_LOG2_ERR, &fs_info->flags); 2480656f30dbSFilipe Manana 24814fbcdf66SFilipe Manana btrfs_trans_release_chunk_metadata(trans); 24824fbcdf66SFilipe Manana 2483dfba78dcSFilipe Manana /* 2484dfba78dcSFilipe Manana * Before changing the transaction state to TRANS_STATE_UNBLOCKED and 2485dfba78dcSFilipe Manana * setting fs_info->running_transaction to NULL, lock tree_log_mutex to 2486dfba78dcSFilipe Manana * make sure that before we commit our superblock, no other task can 2487dfba78dcSFilipe Manana * start a new transaction and commit a log tree before we commit our 2488dfba78dcSFilipe Manana * superblock. Anyone trying to commit a log tree locks this mutex before 2489dfba78dcSFilipe Manana * writing its superblock. 2490dfba78dcSFilipe Manana */ 2491dfba78dcSFilipe Manana mutex_lock(&fs_info->tree_log_mutex); 2492dfba78dcSFilipe Manana 24930b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 24944a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_UNBLOCKED; 24950b246afaSJeff Mahoney fs_info->running_transaction = NULL; 24960b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 24970b246afaSJeff Mahoney mutex_unlock(&fs_info->reloc_mutex); 2498b7ec40d7SChris Mason 24990b246afaSJeff Mahoney wake_up(&fs_info->transaction_wait); 25003e738c53SIoannis Angelakopoulos btrfs_trans_state_lockdep_release(fs_info, BTRFS_LOCKDEP_TRANS_UNBLOCKED); 2501e6dcd2dcSChris Mason 2502b7625f46SQu Wenruo /* If we have features changed, wake up the cleaner to update sysfs. */ 2503b7625f46SQu Wenruo if (test_bit(BTRFS_FS_FEATURE_CHANGED, &fs_info->flags) && 2504b7625f46SQu Wenruo fs_info->cleaner_kthread) 2505b7625f46SQu Wenruo wake_up_process(fs_info->cleaner_kthread); 2506b7625f46SQu Wenruo 250770458a58SNikolay Borisov ret = btrfs_write_and_wait_transaction(trans); 250849b25e05SJeff Mahoney if (ret) { 25090b246afaSJeff Mahoney btrfs_handle_fs_error(fs_info, ret, 251008748810SDavid Sterba "Error while writing out transaction"); 25110b246afaSJeff Mahoney mutex_unlock(&fs_info->tree_log_mutex); 25126cf7f77eSWang Shilong goto scrub_continue; 251349b25e05SJeff Mahoney } 251449b25e05SJeff Mahoney 2515eece6a9cSDavid Sterba ret = write_all_supers(fs_info, 0); 2516e02119d5SChris Mason /* 2517e02119d5SChris Mason * the super is written, we can safely allow the tree-loggers 2518e02119d5SChris Mason * to go about their business 2519e02119d5SChris Mason */ 25200b246afaSJeff Mahoney mutex_unlock(&fs_info->tree_log_mutex); 2521c1f32b7cSAnand Jain if (ret) 2522c1f32b7cSAnand Jain goto scrub_continue; 2523e02119d5SChris Mason 2524d0c2f4faSFilipe Manana /* 2525d0c2f4faSFilipe Manana * We needn't acquire the lock here because there is no other task 2526d0c2f4faSFilipe Manana * which can change it. 2527d0c2f4faSFilipe Manana */ 2528d0c2f4faSFilipe Manana cur_trans->state = TRANS_STATE_SUPER_COMMITTED; 2529d0c2f4faSFilipe Manana wake_up(&cur_trans->commit_wait); 25303e738c53SIoannis Angelakopoulos btrfs_trans_state_lockdep_release(fs_info, BTRFS_LOCKDEP_TRANS_SUPER_COMMITTED); 2531d0c2f4faSFilipe Manana 25325ead2dd0SNikolay Borisov btrfs_finish_extent_commit(trans); 25334313b399SChris Mason 25343204d33cSJosef Bacik if (test_bit(BTRFS_TRANS_HAVE_FREE_BGS, &cur_trans->flags)) 25350b246afaSJeff Mahoney btrfs_clear_space_info_full(fs_info); 253613212b54SZhao Lei 25370b246afaSJeff Mahoney fs_info->last_trans_committed = cur_trans->transid; 25384a9d8bdeSMiao Xie /* 25394a9d8bdeSMiao Xie * We needn't acquire the lock here because there is no other task 25404a9d8bdeSMiao Xie * which can change it. 25414a9d8bdeSMiao Xie */ 25424a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_COMPLETED; 25432c90e5d6SChris Mason wake_up(&cur_trans->commit_wait); 25443e738c53SIoannis Angelakopoulos btrfs_trans_state_lockdep_release(fs_info, BTRFS_LOCKDEP_TRANS_COMPLETED); 25453de4586cSChris Mason 25460b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 254713c5a93eSJosef Bacik list_del_init(&cur_trans->list); 25480b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 2549a4abeea4SJosef Bacik 2550724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 2551724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 255258176a96SJosef Bacik 25530860adfdSMiao Xie if (trans->type & __TRANS_FREEZABLE) 25540b246afaSJeff Mahoney sb_end_intwrite(fs_info->sb); 2555b2b5ef5cSJan Kara 25562e4e97abSJosef Bacik trace_btrfs_transaction_commit(fs_info); 25571abe9b8aSliubo 2558e55958c8SIoannis Angelakopoulos interval = ktime_get_ns() - start_time; 2559e55958c8SIoannis Angelakopoulos 25602ff7e61eSJeff Mahoney btrfs_scrub_continue(fs_info); 2561a2de733cSArne Jansen 25629ed74f2dSJosef Bacik if (current->journal_info == trans) 25639ed74f2dSJosef Bacik current->journal_info = NULL; 25649ed74f2dSJosef Bacik 25652c90e5d6SChris Mason kmem_cache_free(btrfs_trans_handle_cachep, trans); 256624bbcf04SYan, Zheng 2567e55958c8SIoannis Angelakopoulos update_commit_stats(fs_info, interval); 2568e55958c8SIoannis Angelakopoulos 256979154b1bSChris Mason return ret; 257049b25e05SJeff Mahoney 257156e9f6eaSDavid Sterba unlock_reloc: 257256e9f6eaSDavid Sterba mutex_unlock(&fs_info->reloc_mutex); 25733e738c53SIoannis Angelakopoulos btrfs_trans_state_lockdep_release(fs_info, BTRFS_LOCKDEP_TRANS_UNBLOCKED); 25746cf7f77eSWang Shilong scrub_continue: 25753e738c53SIoannis Angelakopoulos btrfs_trans_state_lockdep_release(fs_info, BTRFS_LOCKDEP_TRANS_SUPER_COMMITTED); 25763e738c53SIoannis Angelakopoulos btrfs_trans_state_lockdep_release(fs_info, BTRFS_LOCKDEP_TRANS_COMPLETED); 25772ff7e61eSJeff Mahoney btrfs_scrub_continue(fs_info); 257849b25e05SJeff Mahoney cleanup_transaction: 2579dc60c525SNikolay Borisov btrfs_trans_release_metadata(trans); 2580c7cc64a9SDavid Sterba btrfs_cleanup_pending_block_groups(trans); 25814fbcdf66SFilipe Manana btrfs_trans_release_chunk_metadata(trans); 25820e721106SJosef Bacik trans->block_rsv = NULL; 25830b246afaSJeff Mahoney btrfs_warn(fs_info, "Skipping commit of aborted transaction."); 258449b25e05SJeff Mahoney if (current->journal_info == trans) 258549b25e05SJeff Mahoney current->journal_info = NULL; 258697cb39bbSNikolay Borisov cleanup_transaction(trans, ret); 258749b25e05SJeff Mahoney 258849b25e05SJeff Mahoney return ret; 2589e1489b4fSIoannis Angelakopoulos 2590e1489b4fSIoannis Angelakopoulos lockdep_release: 25915a9ba670SIoannis Angelakopoulos btrfs_lockdep_release(fs_info, btrfs_trans_num_extwriters); 2592e1489b4fSIoannis Angelakopoulos btrfs_lockdep_release(fs_info, btrfs_trans_num_writers); 2593e1489b4fSIoannis Angelakopoulos goto cleanup_transaction; 25943e738c53SIoannis Angelakopoulos 25953e738c53SIoannis Angelakopoulos lockdep_trans_commit_start_release: 259677d20c68SJosef Bacik btrfs_trans_state_lockdep_release(fs_info, BTRFS_LOCKDEP_TRANS_COMMIT_PREP); 25973e738c53SIoannis Angelakopoulos btrfs_end_transaction(trans); 25983e738c53SIoannis Angelakopoulos return ret; 259979154b1bSChris Mason } 260079154b1bSChris Mason 2601d352ac68SChris Mason /* 26029d1a2a3aSDavid Sterba * return < 0 if error 26039d1a2a3aSDavid Sterba * 0 if there are no more dead_roots at the time of call 26049d1a2a3aSDavid Sterba * 1 there are more to be processed, call me again 26059d1a2a3aSDavid Sterba * 26069d1a2a3aSDavid Sterba * The return value indicates there are certainly more snapshots to delete, but 26079d1a2a3aSDavid Sterba * if there comes a new one during processing, it may return 0. We don't mind, 26089d1a2a3aSDavid Sterba * because btrfs_commit_super will poke cleaner thread and it will process it a 26099d1a2a3aSDavid Sterba * few seconds later. 2610d352ac68SChris Mason */ 261133c44184SJosef Bacik int btrfs_clean_one_deleted_snapshot(struct btrfs_fs_info *fs_info) 2612e9d0b13bSChris Mason { 261333c44184SJosef Bacik struct btrfs_root *root; 26149d1a2a3aSDavid Sterba int ret; 2615e9d0b13bSChris Mason 2616a4abeea4SJosef Bacik spin_lock(&fs_info->trans_lock); 26179d1a2a3aSDavid Sterba if (list_empty(&fs_info->dead_roots)) { 26189d1a2a3aSDavid Sterba spin_unlock(&fs_info->trans_lock); 26199d1a2a3aSDavid Sterba return 0; 26209d1a2a3aSDavid Sterba } 26219d1a2a3aSDavid Sterba root = list_first_entry(&fs_info->dead_roots, 26229d1a2a3aSDavid Sterba struct btrfs_root, root_list); 2623cfad392bSJosef Bacik list_del_init(&root->root_list); 2624a4abeea4SJosef Bacik spin_unlock(&fs_info->trans_lock); 26255d4f98a2SYan Zheng 26264fd786e6SMisono Tomohiro btrfs_debug(fs_info, "cleaner removing %llu", root->root_key.objectid); 262776dda93cSYan, Zheng 262816cdcec7SMiao Xie btrfs_kill_all_delayed_nodes(root); 262916cdcec7SMiao Xie 263076dda93cSYan, Zheng if (btrfs_header_backref_rev(root->node) < 263176dda93cSYan, Zheng BTRFS_MIXED_BACKREF_REV) 26320078a9f9SNikolay Borisov ret = btrfs_drop_snapshot(root, 0, 0); 263376dda93cSYan, Zheng else 26340078a9f9SNikolay Borisov ret = btrfs_drop_snapshot(root, 1, 0); 263532471dc2SDavid Sterba 2636dc9492c1SJosef Bacik btrfs_put_root(root); 26376596a928SJosef Bacik return (ret < 0) ? 0 : 1; 2638e9d0b13bSChris Mason } 2639572d9ab7SDavid Sterba 2640fccf0c84SJosef Bacik /* 2641fccf0c84SJosef Bacik * We only mark the transaction aborted and then set the file system read-only. 2642fccf0c84SJosef Bacik * This will prevent new transactions from starting or trying to join this 2643fccf0c84SJosef Bacik * one. 2644fccf0c84SJosef Bacik * 2645fccf0c84SJosef Bacik * This means that error recovery at the call site is limited to freeing 2646fccf0c84SJosef Bacik * any local memory allocations and passing the error code up without 2647fccf0c84SJosef Bacik * further cleanup. The transaction should complete as it normally would 2648fccf0c84SJosef Bacik * in the call path but will return -EIO. 2649fccf0c84SJosef Bacik * 2650fccf0c84SJosef Bacik * We'll complete the cleanup in btrfs_end_transaction and 2651fccf0c84SJosef Bacik * btrfs_commit_transaction. 2652fccf0c84SJosef Bacik */ 2653fccf0c84SJosef Bacik void __cold __btrfs_abort_transaction(struct btrfs_trans_handle *trans, 2654fccf0c84SJosef Bacik const char *function, 2655fccf0c84SJosef Bacik unsigned int line, int errno, bool first_hit) 2656fccf0c84SJosef Bacik { 2657fccf0c84SJosef Bacik struct btrfs_fs_info *fs_info = trans->fs_info; 2658fccf0c84SJosef Bacik 2659fccf0c84SJosef Bacik WRITE_ONCE(trans->aborted, errno); 2660fccf0c84SJosef Bacik WRITE_ONCE(trans->transaction->aborted, errno); 2661fccf0c84SJosef Bacik if (first_hit && errno == -ENOSPC) 2662fccf0c84SJosef Bacik btrfs_dump_space_info_for_trans_abort(fs_info); 2663fccf0c84SJosef Bacik /* Wake up anybody who may be waiting on this transaction */ 2664fccf0c84SJosef Bacik wake_up(&fs_info->transaction_wait); 2665fccf0c84SJosef Bacik wake_up(&fs_info->transaction_blocked_wait); 2666fccf0c84SJosef Bacik __btrfs_handle_fs_error(fs_info, function, line, errno, NULL); 2667fccf0c84SJosef Bacik } 2668fccf0c84SJosef Bacik 2669956504a3SJosef Bacik int __init btrfs_transaction_init(void) 2670956504a3SJosef Bacik { 2671956504a3SJosef Bacik btrfs_trans_handle_cachep = kmem_cache_create("btrfs_trans_handle", 2672956504a3SJosef Bacik sizeof(struct btrfs_trans_handle), 0, 2673956504a3SJosef Bacik SLAB_TEMPORARY | SLAB_MEM_SPREAD, NULL); 2674956504a3SJosef Bacik if (!btrfs_trans_handle_cachep) 2675956504a3SJosef Bacik return -ENOMEM; 2676956504a3SJosef Bacik return 0; 2677956504a3SJosef Bacik } 2678956504a3SJosef Bacik 2679956504a3SJosef Bacik void __cold btrfs_transaction_exit(void) 2680956504a3SJosef Bacik { 2681956504a3SJosef Bacik kmem_cache_destroy(btrfs_trans_handle_cachep); 2682956504a3SJosef Bacik } 2683