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> 9d3c2fdcfSChris Mason #include <linux/writeback.h> 105f39d397SChris Mason #include <linux/pagemap.h> 115f2cc086SChris Mason #include <linux/blkdev.h> 128ea05e3aSAlexander Block #include <linux/uuid.h> 13e55958c8SIoannis Angelakopoulos #include <linux/timekeeping.h> 14602cbe91SDavid Sterba #include "misc.h" 1579154b1bSChris Mason #include "ctree.h" 1679154b1bSChris Mason #include "disk-io.h" 1779154b1bSChris Mason #include "transaction.h" 18925baeddSChris Mason #include "locking.h" 19e02119d5SChris Mason #include "tree-log.h" 20733f4fbbSStefan Behrens #include "volumes.h" 218dabb742SStefan Behrens #include "dev-replace.h" 22fcebe456SJosef Bacik #include "qgroup.h" 23aac0023cSJosef Bacik #include "block-group.h" 249c343784SJosef Bacik #include "space-info.h" 25d3575156SNaohiro Aota #include "zoned.h" 26*c7f13d42SJosef Bacik #include "fs.h" 2779154b1bSChris Mason 28956504a3SJosef Bacik static struct kmem_cache *btrfs_trans_handle_cachep; 29956504a3SJosef Bacik 30fc7cbcd4SDavid Sterba #define BTRFS_ROOT_TRANS_TAG 0 310f7d52f4SChris Mason 3261c047b5SQu Wenruo /* 3361c047b5SQu Wenruo * Transaction states and transitions 3461c047b5SQu Wenruo * 3561c047b5SQu Wenruo * No running transaction (fs tree blocks are not modified) 3661c047b5SQu Wenruo * | 3761c047b5SQu Wenruo * | To next stage: 3861c047b5SQu Wenruo * | Call start_transaction() variants. Except btrfs_join_transaction_nostart(). 3961c047b5SQu Wenruo * V 4061c047b5SQu Wenruo * Transaction N [[TRANS_STATE_RUNNING]] 4161c047b5SQu Wenruo * | 4261c047b5SQu Wenruo * | New trans handles can be attached to transaction N by calling all 4361c047b5SQu Wenruo * | start_transaction() variants. 4461c047b5SQu Wenruo * | 4561c047b5SQu Wenruo * | To next stage: 4661c047b5SQu Wenruo * | Call btrfs_commit_transaction() on any trans handle attached to 4761c047b5SQu Wenruo * | transaction N 4861c047b5SQu Wenruo * V 4961c047b5SQu Wenruo * Transaction N [[TRANS_STATE_COMMIT_START]] 5061c047b5SQu Wenruo * | 5161c047b5SQu Wenruo * | Will wait for previous running transaction to completely finish if there 5261c047b5SQu Wenruo * | is one 5361c047b5SQu Wenruo * | 5461c047b5SQu Wenruo * | Then one of the following happes: 5561c047b5SQu Wenruo * | - Wait for all other trans handle holders to release. 5661c047b5SQu Wenruo * | The btrfs_commit_transaction() caller will do the commit work. 5761c047b5SQu Wenruo * | - Wait for current transaction to be committed by others. 5861c047b5SQu Wenruo * | Other btrfs_commit_transaction() caller will do the commit work. 5961c047b5SQu Wenruo * | 6061c047b5SQu Wenruo * | At this stage, only btrfs_join_transaction*() variants can attach 6161c047b5SQu Wenruo * | to this running transaction. 6261c047b5SQu Wenruo * | All other variants will wait for current one to finish and attach to 6361c047b5SQu Wenruo * | transaction N+1. 6461c047b5SQu Wenruo * | 6561c047b5SQu Wenruo * | To next stage: 6661c047b5SQu Wenruo * | Caller is chosen to commit transaction N, and all other trans handle 6761c047b5SQu Wenruo * | haven been released. 6861c047b5SQu Wenruo * V 6961c047b5SQu Wenruo * Transaction N [[TRANS_STATE_COMMIT_DOING]] 7061c047b5SQu Wenruo * | 7161c047b5SQu Wenruo * | The heavy lifting transaction work is started. 7261c047b5SQu Wenruo * | From running delayed refs (modifying extent tree) to creating pending 7361c047b5SQu Wenruo * | snapshots, running qgroups. 7461c047b5SQu Wenruo * | In short, modify supporting trees to reflect modifications of subvolume 7561c047b5SQu Wenruo * | trees. 7661c047b5SQu Wenruo * | 7761c047b5SQu Wenruo * | At this stage, all start_transaction() calls will wait for this 7861c047b5SQu Wenruo * | transaction to finish and attach to transaction N+1. 7961c047b5SQu Wenruo * | 8061c047b5SQu Wenruo * | To next stage: 8161c047b5SQu Wenruo * | Until all supporting trees are updated. 8261c047b5SQu Wenruo * V 8361c047b5SQu Wenruo * Transaction N [[TRANS_STATE_UNBLOCKED]] 8461c047b5SQu Wenruo * | Transaction N+1 8561c047b5SQu Wenruo * | All needed trees are modified, thus we only [[TRANS_STATE_RUNNING]] 8661c047b5SQu Wenruo * | need to write them back to disk and update | 8761c047b5SQu Wenruo * | super blocks. | 8861c047b5SQu Wenruo * | | 8961c047b5SQu Wenruo * | At this stage, new transaction is allowed to | 9061c047b5SQu Wenruo * | start. | 9161c047b5SQu Wenruo * | All new start_transaction() calls will be | 9261c047b5SQu Wenruo * | attached to transid N+1. | 9361c047b5SQu Wenruo * | | 9461c047b5SQu Wenruo * | To next stage: | 9561c047b5SQu Wenruo * | Until all tree blocks are super blocks are | 9661c047b5SQu Wenruo * | written to block devices | 9761c047b5SQu Wenruo * V | 9861c047b5SQu Wenruo * Transaction N [[TRANS_STATE_COMPLETED]] V 9961c047b5SQu Wenruo * All tree blocks and super blocks are written. Transaction N+1 10061c047b5SQu Wenruo * This transaction is finished and all its [[TRANS_STATE_COMMIT_START]] 10161c047b5SQu Wenruo * data structures will be cleaned up. | Life goes on 10261c047b5SQu Wenruo */ 103e8c9f186SDavid Sterba static const unsigned int btrfs_blocked_trans_types[TRANS_STATE_MAX] = { 1044a9d8bdeSMiao Xie [TRANS_STATE_RUNNING] = 0U, 105bcf3a3e7SNikolay Borisov [TRANS_STATE_COMMIT_START] = (__TRANS_START | __TRANS_ATTACH), 106bcf3a3e7SNikolay Borisov [TRANS_STATE_COMMIT_DOING] = (__TRANS_START | 1074a9d8bdeSMiao Xie __TRANS_ATTACH | 108a6d155d2SFilipe Manana __TRANS_JOIN | 109a6d155d2SFilipe Manana __TRANS_JOIN_NOSTART), 110bcf3a3e7SNikolay Borisov [TRANS_STATE_UNBLOCKED] = (__TRANS_START | 1114a9d8bdeSMiao Xie __TRANS_ATTACH | 1124a9d8bdeSMiao Xie __TRANS_JOIN | 113a6d155d2SFilipe Manana __TRANS_JOIN_NOLOCK | 114a6d155d2SFilipe Manana __TRANS_JOIN_NOSTART), 115d0c2f4faSFilipe Manana [TRANS_STATE_SUPER_COMMITTED] = (__TRANS_START | 116d0c2f4faSFilipe Manana __TRANS_ATTACH | 117d0c2f4faSFilipe Manana __TRANS_JOIN | 118d0c2f4faSFilipe Manana __TRANS_JOIN_NOLOCK | 119d0c2f4faSFilipe Manana __TRANS_JOIN_NOSTART), 120bcf3a3e7SNikolay Borisov [TRANS_STATE_COMPLETED] = (__TRANS_START | 1214a9d8bdeSMiao Xie __TRANS_ATTACH | 1224a9d8bdeSMiao Xie __TRANS_JOIN | 123a6d155d2SFilipe Manana __TRANS_JOIN_NOLOCK | 124a6d155d2SFilipe Manana __TRANS_JOIN_NOSTART), 1254a9d8bdeSMiao Xie }; 1264a9d8bdeSMiao Xie 127724e2315SJosef Bacik void btrfs_put_transaction(struct btrfs_transaction *transaction) 12879154b1bSChris Mason { 1299b64f57dSElena Reshetova WARN_ON(refcount_read(&transaction->use_count) == 0); 1309b64f57dSElena Reshetova if (refcount_dec_and_test(&transaction->use_count)) { 131a4abeea4SJosef Bacik BUG_ON(!list_empty(&transaction->list)); 1325c9d028bSLiu Bo WARN_ON(!RB_EMPTY_ROOT( 1335c9d028bSLiu Bo &transaction->delayed_refs.href_root.rb_root)); 13481f7eb00SJeff Mahoney WARN_ON(!RB_EMPTY_ROOT( 13581f7eb00SJeff Mahoney &transaction->delayed_refs.dirty_extent_root)); 1361262133bSJosef Bacik if (transaction->delayed_refs.pending_csums) 137ab8d0fc4SJeff Mahoney btrfs_err(transaction->fs_info, 138ab8d0fc4SJeff Mahoney "pending csums is %llu", 1391262133bSJosef Bacik transaction->delayed_refs.pending_csums); 1407785a663SFilipe Manana /* 1417785a663SFilipe Manana * If any block groups are found in ->deleted_bgs then it's 1427785a663SFilipe Manana * because the transaction was aborted and a commit did not 1437785a663SFilipe Manana * happen (things failed before writing the new superblock 1447785a663SFilipe Manana * and calling btrfs_finish_extent_commit()), so we can not 1457785a663SFilipe Manana * discard the physical locations of the block groups. 1467785a663SFilipe Manana */ 1477785a663SFilipe Manana while (!list_empty(&transaction->deleted_bgs)) { 14832da5386SDavid Sterba struct btrfs_block_group *cache; 1497785a663SFilipe Manana 1507785a663SFilipe Manana cache = list_first_entry(&transaction->deleted_bgs, 15132da5386SDavid Sterba struct btrfs_block_group, 1527785a663SFilipe Manana bg_list); 1537785a663SFilipe Manana list_del_init(&cache->bg_list); 1546b7304afSFilipe Manana btrfs_unfreeze_block_group(cache); 1557785a663SFilipe Manana btrfs_put_block_group(cache); 1567785a663SFilipe Manana } 157bbbf7243SNikolay Borisov WARN_ON(!list_empty(&transaction->dev_update_list)); 1584b5faeacSDavid Sterba kfree(transaction); 15979154b1bSChris Mason } 16078fae27eSChris Mason } 16179154b1bSChris Mason 162889bfa39SJosef Bacik static noinline void switch_commit_roots(struct btrfs_trans_handle *trans) 163817d52f8SJosef Bacik { 164889bfa39SJosef Bacik struct btrfs_transaction *cur_trans = trans->transaction; 16516916a88SNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 1669e351cc8SJosef Bacik struct btrfs_root *root, *tmp; 1679e351cc8SJosef Bacik 168dfba78dcSFilipe Manana /* 169dfba78dcSFilipe Manana * At this point no one can be using this transaction to modify any tree 170dfba78dcSFilipe Manana * and no one can start another transaction to modify any tree either. 171dfba78dcSFilipe Manana */ 172dfba78dcSFilipe Manana ASSERT(cur_trans->state == TRANS_STATE_COMMIT_DOING); 173dfba78dcSFilipe Manana 1749e351cc8SJosef Bacik down_write(&fs_info->commit_root_sem); 175d96b3424SFilipe Manana 176d96b3424SFilipe Manana if (test_bit(BTRFS_FS_RELOC_RUNNING, &fs_info->flags)) 177d96b3424SFilipe Manana fs_info->last_reloc_trans = trans->transid; 178d96b3424SFilipe Manana 179889bfa39SJosef Bacik list_for_each_entry_safe(root, tmp, &cur_trans->switch_commits, 1809e351cc8SJosef Bacik dirty_list) { 1819e351cc8SJosef Bacik list_del_init(&root->dirty_list); 182817d52f8SJosef Bacik free_extent_buffer(root->commit_root); 183817d52f8SJosef Bacik root->commit_root = btrfs_root_node(root); 18441e7acd3SNikolay Borisov extent_io_tree_release(&root->dirty_log_pages); 185370a11b8SQu Wenruo btrfs_qgroup_clean_swapped_blocks(root); 1869e351cc8SJosef Bacik } 1872b9dbef2SJosef Bacik 1882b9dbef2SJosef Bacik /* We can free old roots now. */ 189889bfa39SJosef Bacik spin_lock(&cur_trans->dropped_roots_lock); 190889bfa39SJosef Bacik while (!list_empty(&cur_trans->dropped_roots)) { 191889bfa39SJosef Bacik root = list_first_entry(&cur_trans->dropped_roots, 1922b9dbef2SJosef Bacik struct btrfs_root, root_list); 1932b9dbef2SJosef Bacik list_del_init(&root->root_list); 194889bfa39SJosef Bacik spin_unlock(&cur_trans->dropped_roots_lock); 195889bfa39SJosef Bacik btrfs_free_log(trans, root); 1962b9dbef2SJosef Bacik btrfs_drop_and_free_fs_root(fs_info, root); 197889bfa39SJosef Bacik spin_lock(&cur_trans->dropped_roots_lock); 1982b9dbef2SJosef Bacik } 199889bfa39SJosef Bacik spin_unlock(&cur_trans->dropped_roots_lock); 20027d56e62SJosef Bacik 2019e351cc8SJosef Bacik up_write(&fs_info->commit_root_sem); 202817d52f8SJosef Bacik } 203817d52f8SJosef Bacik 2040860adfdSMiao Xie static inline void extwriter_counter_inc(struct btrfs_transaction *trans, 2050860adfdSMiao Xie unsigned int type) 2060860adfdSMiao Xie { 2070860adfdSMiao Xie if (type & TRANS_EXTWRITERS) 2080860adfdSMiao Xie atomic_inc(&trans->num_extwriters); 2090860adfdSMiao Xie } 2100860adfdSMiao Xie 2110860adfdSMiao Xie static inline void extwriter_counter_dec(struct btrfs_transaction *trans, 2120860adfdSMiao Xie unsigned int type) 2130860adfdSMiao Xie { 2140860adfdSMiao Xie if (type & TRANS_EXTWRITERS) 2150860adfdSMiao Xie atomic_dec(&trans->num_extwriters); 2160860adfdSMiao Xie } 2170860adfdSMiao Xie 2180860adfdSMiao Xie static inline void extwriter_counter_init(struct btrfs_transaction *trans, 2190860adfdSMiao Xie unsigned int type) 2200860adfdSMiao Xie { 2210860adfdSMiao Xie atomic_set(&trans->num_extwriters, ((type & TRANS_EXTWRITERS) ? 1 : 0)); 2220860adfdSMiao Xie } 2230860adfdSMiao Xie 2240860adfdSMiao Xie static inline int extwriter_counter_read(struct btrfs_transaction *trans) 2250860adfdSMiao Xie { 2260860adfdSMiao Xie return atomic_read(&trans->num_extwriters); 227178260b2SMiao Xie } 228178260b2SMiao Xie 229d352ac68SChris Mason /* 23079bd3712SFilipe Manana * To be called after doing the chunk btree updates right after allocating a new 23179bd3712SFilipe Manana * chunk (after btrfs_chunk_alloc_add_chunk_item() is called), when removing a 23279bd3712SFilipe Manana * chunk after all chunk btree updates and after finishing the second phase of 23379bd3712SFilipe Manana * chunk allocation (btrfs_create_pending_block_groups()) in case some block 23479bd3712SFilipe Manana * group had its chunk item insertion delayed to the second phase. 235fb6dea26SJosef Bacik */ 236fb6dea26SJosef Bacik void btrfs_trans_release_chunk_metadata(struct btrfs_trans_handle *trans) 237fb6dea26SJosef Bacik { 238fb6dea26SJosef Bacik struct btrfs_fs_info *fs_info = trans->fs_info; 239fb6dea26SJosef Bacik 240fb6dea26SJosef Bacik if (!trans->chunk_bytes_reserved) 241fb6dea26SJosef Bacik return; 242fb6dea26SJosef Bacik 243fb6dea26SJosef Bacik btrfs_block_rsv_release(fs_info, &fs_info->chunk_block_rsv, 24463f018beSNikolay Borisov trans->chunk_bytes_reserved, NULL); 245fb6dea26SJosef Bacik trans->chunk_bytes_reserved = 0; 246fb6dea26SJosef Bacik } 247fb6dea26SJosef Bacik 248fb6dea26SJosef Bacik /* 249d352ac68SChris Mason * either allocate a new transaction or hop into the existing one 250d352ac68SChris Mason */ 2512ff7e61eSJeff Mahoney static noinline int join_transaction(struct btrfs_fs_info *fs_info, 2522ff7e61eSJeff Mahoney unsigned int type) 25379154b1bSChris Mason { 25479154b1bSChris Mason struct btrfs_transaction *cur_trans; 255a4abeea4SJosef Bacik 25619ae4e81SJan Schmidt spin_lock(&fs_info->trans_lock); 257d43317dcSChris Mason loop: 25849b25e05SJeff Mahoney /* The file system has been taken offline. No new transactions. */ 25984961539SJosef Bacik if (BTRFS_FS_ERROR(fs_info)) { 26019ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 26149b25e05SJeff Mahoney return -EROFS; 26249b25e05SJeff Mahoney } 26349b25e05SJeff Mahoney 26419ae4e81SJan Schmidt cur_trans = fs_info->running_transaction; 265a4abeea4SJosef Bacik if (cur_trans) { 266bf31f87fSDavid Sterba if (TRANS_ABORTED(cur_trans)) { 26719ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 26849b25e05SJeff Mahoney return cur_trans->aborted; 269871383beSDavid Sterba } 2704a9d8bdeSMiao Xie if (btrfs_blocked_trans_types[cur_trans->state] & type) { 271178260b2SMiao Xie spin_unlock(&fs_info->trans_lock); 272178260b2SMiao Xie return -EBUSY; 273178260b2SMiao Xie } 2749b64f57dSElena Reshetova refcount_inc(&cur_trans->use_count); 275a4abeea4SJosef Bacik atomic_inc(&cur_trans->num_writers); 2760860adfdSMiao Xie extwriter_counter_inc(cur_trans, type); 27719ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 278e1489b4fSIoannis Angelakopoulos btrfs_lockdep_acquire(fs_info, btrfs_trans_num_writers); 2795a9ba670SIoannis Angelakopoulos btrfs_lockdep_acquire(fs_info, btrfs_trans_num_extwriters); 280a4abeea4SJosef Bacik return 0; 281a4abeea4SJosef Bacik } 28219ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 283a4abeea4SJosef Bacik 284354aa0fbSMiao Xie /* 285354aa0fbSMiao Xie * If we are ATTACH, we just want to catch the current transaction, 286354aa0fbSMiao Xie * and commit it. If there is no transaction, just return ENOENT. 287354aa0fbSMiao Xie */ 288354aa0fbSMiao Xie if (type == TRANS_ATTACH) 289354aa0fbSMiao Xie return -ENOENT; 290354aa0fbSMiao Xie 2914a9d8bdeSMiao Xie /* 2924a9d8bdeSMiao Xie * JOIN_NOLOCK only happens during the transaction commit, so 2934a9d8bdeSMiao Xie * it is impossible that ->running_transaction is NULL 2944a9d8bdeSMiao Xie */ 2954a9d8bdeSMiao Xie BUG_ON(type == TRANS_JOIN_NOLOCK); 2964a9d8bdeSMiao Xie 2974b5faeacSDavid Sterba cur_trans = kmalloc(sizeof(*cur_trans), GFP_NOFS); 298db5b493aSTsutomu Itoh if (!cur_trans) 299db5b493aSTsutomu Itoh return -ENOMEM; 300d43317dcSChris Mason 301e1489b4fSIoannis Angelakopoulos btrfs_lockdep_acquire(fs_info, btrfs_trans_num_writers); 3025a9ba670SIoannis Angelakopoulos btrfs_lockdep_acquire(fs_info, btrfs_trans_num_extwriters); 303e1489b4fSIoannis Angelakopoulos 30419ae4e81SJan Schmidt spin_lock(&fs_info->trans_lock); 30519ae4e81SJan Schmidt if (fs_info->running_transaction) { 306d43317dcSChris Mason /* 307d43317dcSChris Mason * someone started a transaction after we unlocked. Make sure 3084a9d8bdeSMiao Xie * to redo the checks above 309d43317dcSChris Mason */ 3105a9ba670SIoannis Angelakopoulos btrfs_lockdep_release(fs_info, btrfs_trans_num_extwriters); 311e1489b4fSIoannis Angelakopoulos btrfs_lockdep_release(fs_info, btrfs_trans_num_writers); 3124b5faeacSDavid Sterba kfree(cur_trans); 313d43317dcSChris Mason goto loop; 31484961539SJosef Bacik } else if (BTRFS_FS_ERROR(fs_info)) { 315e4b50e14SDan Carpenter spin_unlock(&fs_info->trans_lock); 3165a9ba670SIoannis Angelakopoulos btrfs_lockdep_release(fs_info, btrfs_trans_num_extwriters); 317e1489b4fSIoannis Angelakopoulos btrfs_lockdep_release(fs_info, btrfs_trans_num_writers); 3184b5faeacSDavid Sterba kfree(cur_trans); 3197b8b92afSJosef Bacik return -EROFS; 320a4abeea4SJosef Bacik } 321d43317dcSChris Mason 322ab8d0fc4SJeff Mahoney cur_trans->fs_info = fs_info; 32348778179SFilipe Manana atomic_set(&cur_trans->pending_ordered, 0); 32448778179SFilipe Manana init_waitqueue_head(&cur_trans->pending_wait); 32513c5a93eSJosef Bacik atomic_set(&cur_trans->num_writers, 1); 3260860adfdSMiao Xie extwriter_counter_init(cur_trans, type); 32779154b1bSChris Mason init_waitqueue_head(&cur_trans->writer_wait); 32879154b1bSChris Mason init_waitqueue_head(&cur_trans->commit_wait); 3294a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_RUNNING; 330a4abeea4SJosef Bacik /* 331a4abeea4SJosef Bacik * One for this trans handle, one so it will live on until we 332a4abeea4SJosef Bacik * commit the transaction. 333a4abeea4SJosef Bacik */ 3349b64f57dSElena Reshetova refcount_set(&cur_trans->use_count, 2); 3353204d33cSJosef Bacik cur_trans->flags = 0; 336afd48513SArnd Bergmann cur_trans->start_time = ktime_get_seconds(); 33756bec294SChris Mason 338a099d0fdSAlexandru Moise memset(&cur_trans->delayed_refs, 0, sizeof(cur_trans->delayed_refs)); 339a099d0fdSAlexandru Moise 3405c9d028bSLiu Bo cur_trans->delayed_refs.href_root = RB_ROOT_CACHED; 3413368d001SQu Wenruo cur_trans->delayed_refs.dirty_extent_root = RB_ROOT; 342d7df2c79SJosef Bacik atomic_set(&cur_trans->delayed_refs.num_entries, 0); 34320b297d6SJan Schmidt 34420b297d6SJan Schmidt /* 34520b297d6SJan Schmidt * although the tree mod log is per file system and not per transaction, 34620b297d6SJan Schmidt * the log must never go across transaction boundaries. 34720b297d6SJan Schmidt */ 34820b297d6SJan Schmidt smp_mb(); 34931b1a2bdSJulia Lawall if (!list_empty(&fs_info->tree_mod_seq_list)) 3505d163e0eSJeff Mahoney WARN(1, KERN_ERR "BTRFS: tree_mod_seq_list not empty when creating a fresh transaction\n"); 35131b1a2bdSJulia Lawall if (!RB_EMPTY_ROOT(&fs_info->tree_mod_log)) 3525d163e0eSJeff Mahoney WARN(1, KERN_ERR "BTRFS: tree_mod_log rb tree not empty when creating a fresh transaction\n"); 353fc36ed7eSJan Schmidt atomic64_set(&fs_info->tree_mod_seq, 0); 35420b297d6SJan Schmidt 35556bec294SChris Mason spin_lock_init(&cur_trans->delayed_refs.lock); 35656bec294SChris Mason 3573063d29fSChris Mason INIT_LIST_HEAD(&cur_trans->pending_snapshots); 358bbbf7243SNikolay Borisov INIT_LIST_HEAD(&cur_trans->dev_update_list); 3599e351cc8SJosef Bacik INIT_LIST_HEAD(&cur_trans->switch_commits); 360ce93ec54SJosef Bacik INIT_LIST_HEAD(&cur_trans->dirty_bgs); 3611bbc621eSChris Mason INIT_LIST_HEAD(&cur_trans->io_bgs); 3622b9dbef2SJosef Bacik INIT_LIST_HEAD(&cur_trans->dropped_roots); 3631bbc621eSChris Mason mutex_init(&cur_trans->cache_write_mutex); 364ce93ec54SJosef Bacik spin_lock_init(&cur_trans->dirty_bgs_lock); 365e33e17eeSJeff Mahoney INIT_LIST_HEAD(&cur_trans->deleted_bgs); 3662b9dbef2SJosef Bacik spin_lock_init(&cur_trans->dropped_roots_lock); 367d3575156SNaohiro Aota INIT_LIST_HEAD(&cur_trans->releasing_ebs); 368d3575156SNaohiro Aota spin_lock_init(&cur_trans->releasing_ebs_lock); 36919ae4e81SJan Schmidt list_add_tail(&cur_trans->list, &fs_info->trans_list); 370c258d6e3SQu Wenruo extent_io_tree_init(fs_info, &cur_trans->dirty_pages, 371efb0645bSJosef Bacik IO_TREE_TRANS_DIRTY_PAGES, NULL); 372fe119a6eSNikolay Borisov extent_io_tree_init(fs_info, &cur_trans->pinned_extents, 373fe119a6eSNikolay Borisov IO_TREE_FS_PINNED_EXTENTS, NULL); 37419ae4e81SJan Schmidt fs_info->generation++; 37519ae4e81SJan Schmidt cur_trans->transid = fs_info->generation; 37619ae4e81SJan Schmidt fs_info->running_transaction = cur_trans; 37749b25e05SJeff Mahoney cur_trans->aborted = 0; 37819ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 37915ee9bc7SJosef Bacik 38079154b1bSChris Mason return 0; 38179154b1bSChris Mason } 38279154b1bSChris Mason 383d352ac68SChris Mason /* 38492a7cc42SQu Wenruo * This does all the record keeping required to make sure that a shareable root 38592a7cc42SQu Wenruo * is properly recorded in a given transaction. This is required to make sure 38692a7cc42SQu Wenruo * the old root from before we joined the transaction is deleted when the 38792a7cc42SQu Wenruo * transaction commits. 388d352ac68SChris Mason */ 3897585717fSChris Mason static int record_root_in_trans(struct btrfs_trans_handle *trans, 3906426c7adSQu Wenruo struct btrfs_root *root, 3916426c7adSQu Wenruo int force) 3926702ed49SChris Mason { 3930b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 39403a7e111SJosef Bacik int ret = 0; 3950b246afaSJeff Mahoney 39692a7cc42SQu Wenruo if ((test_bit(BTRFS_ROOT_SHAREABLE, &root->state) && 3976426c7adSQu Wenruo root->last_trans < trans->transid) || force) { 3984d31778aSQu Wenruo WARN_ON(!force && root->commit_root != root->node); 3995d4f98a2SYan Zheng 4007585717fSChris Mason /* 40127cdeb70SMiao Xie * see below for IN_TRANS_SETUP usage rules 4027585717fSChris Mason * we have the reloc mutex held now, so there 4037585717fSChris Mason * is only one writer in this function 4047585717fSChris Mason */ 40527cdeb70SMiao Xie set_bit(BTRFS_ROOT_IN_TRANS_SETUP, &root->state); 4067585717fSChris Mason 40727cdeb70SMiao Xie /* make sure readers find IN_TRANS_SETUP before 4087585717fSChris Mason * they find our root->last_trans update 4097585717fSChris Mason */ 4107585717fSChris Mason smp_wmb(); 4117585717fSChris Mason 412fc7cbcd4SDavid Sterba spin_lock(&fs_info->fs_roots_radix_lock); 4136426c7adSQu Wenruo if (root->last_trans == trans->transid && !force) { 414fc7cbcd4SDavid Sterba spin_unlock(&fs_info->fs_roots_radix_lock); 415a4abeea4SJosef Bacik return 0; 416a4abeea4SJosef Bacik } 417fc7cbcd4SDavid Sterba radix_tree_tag_set(&fs_info->fs_roots_radix, 4186702ed49SChris Mason (unsigned long)root->root_key.objectid, 4196702ed49SChris Mason BTRFS_ROOT_TRANS_TAG); 420fc7cbcd4SDavid Sterba spin_unlock(&fs_info->fs_roots_radix_lock); 4217585717fSChris Mason root->last_trans = trans->transid; 4227585717fSChris Mason 4237585717fSChris Mason /* this is pretty tricky. We don't want to 4247585717fSChris Mason * take the relocation lock in btrfs_record_root_in_trans 4257585717fSChris Mason * unless we're really doing the first setup for this root in 4267585717fSChris Mason * this transaction. 4277585717fSChris Mason * 4287585717fSChris Mason * Normally we'd use root->last_trans as a flag to decide 4297585717fSChris Mason * if we want to take the expensive mutex. 4307585717fSChris Mason * 4317585717fSChris Mason * But, we have to set root->last_trans before we 4327585717fSChris Mason * init the relocation root, otherwise, we trip over warnings 4337585717fSChris Mason * in ctree.c. The solution used here is to flag ourselves 43427cdeb70SMiao Xie * with root IN_TRANS_SETUP. When this is 1, we're still 4357585717fSChris Mason * fixing up the reloc trees and everyone must wait. 4367585717fSChris Mason * 4377585717fSChris Mason * When this is zero, they can trust root->last_trans and fly 4387585717fSChris Mason * through btrfs_record_root_in_trans without having to take the 4397585717fSChris Mason * lock. smp_wmb() makes sure that all the writes above are 4407585717fSChris Mason * done before we pop in the zero below 4417585717fSChris Mason */ 44203a7e111SJosef Bacik ret = btrfs_init_reloc_root(trans, root); 443c7548af6SChris Mason smp_mb__before_atomic(); 44427cdeb70SMiao Xie clear_bit(BTRFS_ROOT_IN_TRANS_SETUP, &root->state); 4456702ed49SChris Mason } 44603a7e111SJosef Bacik return ret; 4476702ed49SChris Mason } 4485d4f98a2SYan Zheng 4497585717fSChris Mason 4502b9dbef2SJosef Bacik void btrfs_add_dropped_root(struct btrfs_trans_handle *trans, 4512b9dbef2SJosef Bacik struct btrfs_root *root) 4522b9dbef2SJosef Bacik { 4530b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 4542b9dbef2SJosef Bacik struct btrfs_transaction *cur_trans = trans->transaction; 4552b9dbef2SJosef Bacik 4562b9dbef2SJosef Bacik /* Add ourselves to the transaction dropped list */ 4572b9dbef2SJosef Bacik spin_lock(&cur_trans->dropped_roots_lock); 4582b9dbef2SJosef Bacik list_add_tail(&root->root_list, &cur_trans->dropped_roots); 4592b9dbef2SJosef Bacik spin_unlock(&cur_trans->dropped_roots_lock); 4602b9dbef2SJosef Bacik 4612b9dbef2SJosef Bacik /* Make sure we don't try to update the root at commit time */ 462fc7cbcd4SDavid Sterba spin_lock(&fs_info->fs_roots_radix_lock); 463fc7cbcd4SDavid Sterba radix_tree_tag_clear(&fs_info->fs_roots_radix, 4642b9dbef2SJosef Bacik (unsigned long)root->root_key.objectid, 4652b9dbef2SJosef Bacik BTRFS_ROOT_TRANS_TAG); 466fc7cbcd4SDavid Sterba spin_unlock(&fs_info->fs_roots_radix_lock); 4672b9dbef2SJosef Bacik } 4682b9dbef2SJosef Bacik 4697585717fSChris Mason int btrfs_record_root_in_trans(struct btrfs_trans_handle *trans, 4707585717fSChris Mason struct btrfs_root *root) 4717585717fSChris Mason { 4720b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 4731409e6ccSJosef Bacik int ret; 4740b246afaSJeff Mahoney 47592a7cc42SQu Wenruo if (!test_bit(BTRFS_ROOT_SHAREABLE, &root->state)) 4767585717fSChris Mason return 0; 4777585717fSChris Mason 4787585717fSChris Mason /* 47927cdeb70SMiao Xie * see record_root_in_trans for comments about IN_TRANS_SETUP usage 4807585717fSChris Mason * and barriers 4817585717fSChris Mason */ 4827585717fSChris Mason smp_rmb(); 4837585717fSChris Mason if (root->last_trans == trans->transid && 48427cdeb70SMiao Xie !test_bit(BTRFS_ROOT_IN_TRANS_SETUP, &root->state)) 4857585717fSChris Mason return 0; 4867585717fSChris Mason 4870b246afaSJeff Mahoney mutex_lock(&fs_info->reloc_mutex); 4881409e6ccSJosef Bacik ret = record_root_in_trans(trans, root, 0); 4890b246afaSJeff Mahoney mutex_unlock(&fs_info->reloc_mutex); 4907585717fSChris Mason 4911409e6ccSJosef Bacik return ret; 4927585717fSChris Mason } 4937585717fSChris Mason 4944a9d8bdeSMiao Xie static inline int is_transaction_blocked(struct btrfs_transaction *trans) 4954a9d8bdeSMiao Xie { 4963296bf56SQu Wenruo return (trans->state >= TRANS_STATE_COMMIT_START && 497501407aaSJosef Bacik trans->state < TRANS_STATE_UNBLOCKED && 498bf31f87fSDavid Sterba !TRANS_ABORTED(trans)); 4994a9d8bdeSMiao Xie } 5004a9d8bdeSMiao Xie 501d352ac68SChris Mason /* wait for commit against the current transaction to become unblocked 502d352ac68SChris Mason * when this is done, it is safe to start a new transaction, but the current 503d352ac68SChris Mason * transaction might not be fully on disk. 504d352ac68SChris Mason */ 5052ff7e61eSJeff Mahoney static void wait_current_trans(struct btrfs_fs_info *fs_info) 50679154b1bSChris Mason { 507f9295749SChris Mason struct btrfs_transaction *cur_trans; 50879154b1bSChris Mason 5090b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 5100b246afaSJeff Mahoney cur_trans = fs_info->running_transaction; 5114a9d8bdeSMiao Xie if (cur_trans && is_transaction_blocked(cur_trans)) { 5129b64f57dSElena Reshetova refcount_inc(&cur_trans->use_count); 5130b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 51472d63ed6SLi Zefan 5153e738c53SIoannis Angelakopoulos btrfs_might_wait_for_state(fs_info, BTRFS_LOCKDEP_TRANS_UNBLOCKED); 5160b246afaSJeff Mahoney wait_event(fs_info->transaction_wait, 517501407aaSJosef Bacik cur_trans->state >= TRANS_STATE_UNBLOCKED || 518bf31f87fSDavid Sterba TRANS_ABORTED(cur_trans)); 519724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 520a4abeea4SJosef Bacik } else { 5210b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 522f9295749SChris Mason } 52337d1aeeeSChris Mason } 52437d1aeeeSChris Mason 5252ff7e61eSJeff Mahoney static int may_wait_transaction(struct btrfs_fs_info *fs_info, int type) 52637d1aeeeSChris Mason { 5270b246afaSJeff Mahoney if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags)) 528a4abeea4SJosef Bacik return 0; 529a4abeea4SJosef Bacik 53092e2f7e3SNikolay Borisov if (type == TRANS_START) 531a4abeea4SJosef Bacik return 1; 532a4abeea4SJosef Bacik 533a22285a6SYan, Zheng return 0; 534a22285a6SYan, Zheng } 535a22285a6SYan, Zheng 53620dd2cbfSMiao Xie static inline bool need_reserve_reloc_root(struct btrfs_root *root) 53720dd2cbfSMiao Xie { 5380b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 5390b246afaSJeff Mahoney 5400b246afaSJeff Mahoney if (!fs_info->reloc_ctl || 54192a7cc42SQu Wenruo !test_bit(BTRFS_ROOT_SHAREABLE, &root->state) || 54220dd2cbfSMiao Xie root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID || 54320dd2cbfSMiao Xie root->reloc_root) 54420dd2cbfSMiao Xie return false; 54520dd2cbfSMiao Xie 54620dd2cbfSMiao Xie return true; 54720dd2cbfSMiao Xie } 54820dd2cbfSMiao Xie 54908e007d2SMiao Xie static struct btrfs_trans_handle * 5505aed1dd8SAlexandru Moise start_transaction(struct btrfs_root *root, unsigned int num_items, 551003d7c59SJeff Mahoney unsigned int type, enum btrfs_reserve_flush_enum flush, 552003d7c59SJeff Mahoney bool enforce_qgroups) 553a22285a6SYan, Zheng { 5540b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 555ba2c4d4eSJosef Bacik struct btrfs_block_rsv *delayed_refs_rsv = &fs_info->delayed_refs_rsv; 556a22285a6SYan, Zheng struct btrfs_trans_handle *h; 557a22285a6SYan, Zheng struct btrfs_transaction *cur_trans; 558b5009945SJosef Bacik u64 num_bytes = 0; 559c5567237SArne Jansen u64 qgroup_reserved = 0; 56020dd2cbfSMiao Xie bool reloc_reserved = false; 5619c343784SJosef Bacik bool do_chunk_alloc = false; 56220dd2cbfSMiao Xie int ret; 563acce952bSliubo 56484961539SJosef Bacik if (BTRFS_FS_ERROR(fs_info)) 565acce952bSliubo return ERR_PTR(-EROFS); 5662a1eb461SJosef Bacik 56746c4e71eSFilipe Manana if (current->journal_info) { 5680860adfdSMiao Xie WARN_ON(type & TRANS_EXTWRITERS); 5692a1eb461SJosef Bacik h = current->journal_info; 570b50fff81SDavid Sterba refcount_inc(&h->use_count); 571b50fff81SDavid Sterba WARN_ON(refcount_read(&h->use_count) > 2); 5722a1eb461SJosef Bacik h->orig_rsv = h->block_rsv; 5732a1eb461SJosef Bacik h->block_rsv = NULL; 5742a1eb461SJosef Bacik goto got_it; 5752a1eb461SJosef Bacik } 576b5009945SJosef Bacik 577b5009945SJosef Bacik /* 578b5009945SJosef Bacik * Do the reservation before we join the transaction so we can do all 579b5009945SJosef Bacik * the appropriate flushing if need be. 580b5009945SJosef Bacik */ 581003d7c59SJeff Mahoney if (num_items && root != fs_info->chunk_root) { 582ba2c4d4eSJosef Bacik struct btrfs_block_rsv *rsv = &fs_info->trans_block_rsv; 583ba2c4d4eSJosef Bacik u64 delayed_refs_bytes = 0; 584ba2c4d4eSJosef Bacik 5850b246afaSJeff Mahoney qgroup_reserved = num_items * fs_info->nodesize; 586733e03a0SQu Wenruo ret = btrfs_qgroup_reserve_meta_pertrans(root, qgroup_reserved, 587003d7c59SJeff Mahoney enforce_qgroups); 588c5567237SArne Jansen if (ret) 589c5567237SArne Jansen return ERR_PTR(ret); 590c5567237SArne Jansen 591ba2c4d4eSJosef Bacik /* 592ba2c4d4eSJosef Bacik * We want to reserve all the bytes we may need all at once, so 593ba2c4d4eSJosef Bacik * we only do 1 enospc flushing cycle per transaction start. We 594ba2c4d4eSJosef Bacik * accomplish this by simply assuming we'll do 2 x num_items 595ba2c4d4eSJosef Bacik * worth of delayed refs updates in this trans handle, and 596ba2c4d4eSJosef Bacik * refill that amount for whatever is missing in the reserve. 597ba2c4d4eSJosef Bacik */ 5982bd36e7bSJosef Bacik num_bytes = btrfs_calc_insert_metadata_size(fs_info, num_items); 5997f9fe614SJosef Bacik if (flush == BTRFS_RESERVE_FLUSH_ALL && 600748f553cSDavid Sterba btrfs_block_rsv_full(delayed_refs_rsv) == 0) { 601ba2c4d4eSJosef Bacik delayed_refs_bytes = num_bytes; 602ba2c4d4eSJosef Bacik num_bytes <<= 1; 603ba2c4d4eSJosef Bacik } 604ba2c4d4eSJosef Bacik 60520dd2cbfSMiao Xie /* 60620dd2cbfSMiao Xie * Do the reservation for the relocation root creation 60720dd2cbfSMiao Xie */ 608ee39b432SDavid Sterba if (need_reserve_reloc_root(root)) { 6090b246afaSJeff Mahoney num_bytes += fs_info->nodesize; 61020dd2cbfSMiao Xie reloc_reserved = true; 61120dd2cbfSMiao Xie } 61220dd2cbfSMiao Xie 6139270501cSJosef Bacik ret = btrfs_block_rsv_add(fs_info, rsv, num_bytes, flush); 614ba2c4d4eSJosef Bacik if (ret) 615ba2c4d4eSJosef Bacik goto reserve_fail; 616ba2c4d4eSJosef Bacik if (delayed_refs_bytes) { 617ba2c4d4eSJosef Bacik btrfs_migrate_to_delayed_refs_rsv(fs_info, rsv, 618ba2c4d4eSJosef Bacik delayed_refs_bytes); 619ba2c4d4eSJosef Bacik num_bytes -= delayed_refs_bytes; 620ba2c4d4eSJosef Bacik } 6219c343784SJosef Bacik 6229c343784SJosef Bacik if (rsv->space_info->force_alloc) 6239c343784SJosef Bacik do_chunk_alloc = true; 624ba2c4d4eSJosef Bacik } else if (num_items == 0 && flush == BTRFS_RESERVE_FLUSH_ALL && 625748f553cSDavid Sterba !btrfs_block_rsv_full(delayed_refs_rsv)) { 626ba2c4d4eSJosef Bacik /* 627ba2c4d4eSJosef Bacik * Some people call with btrfs_start_transaction(root, 0) 628ba2c4d4eSJosef Bacik * because they can be throttled, but have some other mechanism 629ba2c4d4eSJosef Bacik * for reserving space. We still want these guys to refill the 630ba2c4d4eSJosef Bacik * delayed block_rsv so just add 1 items worth of reservation 631ba2c4d4eSJosef Bacik * here. 632ba2c4d4eSJosef Bacik */ 633ba2c4d4eSJosef Bacik ret = btrfs_delayed_refs_rsv_refill(fs_info, flush); 634b5009945SJosef Bacik if (ret) 635843fcf35SMiao Xie goto reserve_fail; 636b5009945SJosef Bacik } 637a22285a6SYan, Zheng again: 638f2f767e7SAlexandru Moise h = kmem_cache_zalloc(btrfs_trans_handle_cachep, GFP_NOFS); 639843fcf35SMiao Xie if (!h) { 640843fcf35SMiao Xie ret = -ENOMEM; 641843fcf35SMiao Xie goto alloc_fail; 642843fcf35SMiao Xie } 643a22285a6SYan, Zheng 64498114659SJosef Bacik /* 64598114659SJosef Bacik * If we are JOIN_NOLOCK we're already committing a transaction and 64698114659SJosef Bacik * waiting on this guy, so we don't need to do the sb_start_intwrite 64798114659SJosef Bacik * because we're already holding a ref. We need this because we could 64898114659SJosef Bacik * have raced in and did an fsync() on a file which can kick a commit 64998114659SJosef Bacik * and then we deadlock with somebody doing a freeze. 650354aa0fbSMiao Xie * 651354aa0fbSMiao Xie * If we are ATTACH, it means we just want to catch the current 652354aa0fbSMiao Xie * transaction and commit it, so we needn't do sb_start_intwrite(). 65398114659SJosef Bacik */ 6540860adfdSMiao Xie if (type & __TRANS_FREEZABLE) 6550b246afaSJeff Mahoney sb_start_intwrite(fs_info->sb); 656b2b5ef5cSJan Kara 6572ff7e61eSJeff Mahoney if (may_wait_transaction(fs_info, type)) 6582ff7e61eSJeff Mahoney wait_current_trans(fs_info); 659a22285a6SYan, Zheng 660a4abeea4SJosef Bacik do { 6612ff7e61eSJeff Mahoney ret = join_transaction(fs_info, type); 662178260b2SMiao Xie if (ret == -EBUSY) { 6632ff7e61eSJeff Mahoney wait_current_trans(fs_info); 664a6d155d2SFilipe Manana if (unlikely(type == TRANS_ATTACH || 665a6d155d2SFilipe Manana type == TRANS_JOIN_NOSTART)) 666178260b2SMiao Xie ret = -ENOENT; 667178260b2SMiao Xie } 668a4abeea4SJosef Bacik } while (ret == -EBUSY); 669a4abeea4SJosef Bacik 670a43f7f82SLiu Bo if (ret < 0) 671843fcf35SMiao Xie goto join_fail; 6720f7d52f4SChris Mason 6730b246afaSJeff Mahoney cur_trans = fs_info->running_transaction; 674a22285a6SYan, Zheng 675a22285a6SYan, Zheng h->transid = cur_trans->transid; 676a22285a6SYan, Zheng h->transaction = cur_trans; 677b50fff81SDavid Sterba refcount_set(&h->use_count, 1); 67864b63580SJeff Mahoney h->fs_info = root->fs_info; 6797174109cSQu Wenruo 680a698d075SMiao Xie h->type = type; 681ea658badSJosef Bacik INIT_LIST_HEAD(&h->new_bgs); 682b7ec40d7SChris Mason 683a22285a6SYan, Zheng smp_mb(); 6843296bf56SQu Wenruo if (cur_trans->state >= TRANS_STATE_COMMIT_START && 6852ff7e61eSJeff Mahoney may_wait_transaction(fs_info, type)) { 686abdd2e80SFilipe Manana current->journal_info = h; 6873a45bb20SJeff Mahoney btrfs_commit_transaction(h); 688a22285a6SYan, Zheng goto again; 689a22285a6SYan, Zheng } 6909ed74f2dSJosef Bacik 691b5009945SJosef Bacik if (num_bytes) { 6920b246afaSJeff Mahoney trace_btrfs_space_reservation(fs_info, "transaction", 6932bcc0328SLiu Bo h->transid, num_bytes, 1); 6940b246afaSJeff Mahoney h->block_rsv = &fs_info->trans_block_rsv; 695b5009945SJosef Bacik h->bytes_reserved = num_bytes; 69620dd2cbfSMiao Xie h->reloc_reserved = reloc_reserved; 697a22285a6SYan, Zheng } 698a22285a6SYan, Zheng 6992a1eb461SJosef Bacik got_it: 700bcf3a3e7SNikolay Borisov if (!current->journal_info) 701a22285a6SYan, Zheng current->journal_info = h; 702fcc99734SQu Wenruo 703fcc99734SQu Wenruo /* 7049c343784SJosef Bacik * If the space_info is marked ALLOC_FORCE then we'll get upgraded to 7059c343784SJosef Bacik * ALLOC_FORCE the first run through, and then we won't allocate for 7069c343784SJosef Bacik * anybody else who races in later. We don't care about the return 7079c343784SJosef Bacik * value here. 7089c343784SJosef Bacik */ 7099c343784SJosef Bacik if (do_chunk_alloc && num_bytes) { 7109c343784SJosef Bacik u64 flags = h->block_rsv->space_info->flags; 7119c343784SJosef Bacik 7129c343784SJosef Bacik btrfs_chunk_alloc(h, btrfs_get_alloc_profile(fs_info, flags), 7139c343784SJosef Bacik CHUNK_ALLOC_NO_FORCE); 7149c343784SJosef Bacik } 7159c343784SJosef Bacik 7169c343784SJosef Bacik /* 717fcc99734SQu Wenruo * btrfs_record_root_in_trans() needs to alloc new extents, and may 718fcc99734SQu Wenruo * call btrfs_join_transaction() while we're also starting a 719fcc99734SQu Wenruo * transaction. 720fcc99734SQu Wenruo * 721fcc99734SQu Wenruo * Thus it need to be called after current->journal_info initialized, 722fcc99734SQu Wenruo * or we can deadlock. 723fcc99734SQu Wenruo */ 72468075ea8SJosef Bacik ret = btrfs_record_root_in_trans(h, root); 72568075ea8SJosef Bacik if (ret) { 72668075ea8SJosef Bacik /* 72768075ea8SJosef Bacik * The transaction handle is fully initialized and linked with 72868075ea8SJosef Bacik * other structures so it needs to be ended in case of errors, 72968075ea8SJosef Bacik * not just freed. 73068075ea8SJosef Bacik */ 73168075ea8SJosef Bacik btrfs_end_transaction(h); 73268075ea8SJosef Bacik return ERR_PTR(ret); 73368075ea8SJosef Bacik } 734fcc99734SQu Wenruo 73579154b1bSChris Mason return h; 736843fcf35SMiao Xie 737843fcf35SMiao Xie join_fail: 7380860adfdSMiao Xie if (type & __TRANS_FREEZABLE) 7390b246afaSJeff Mahoney sb_end_intwrite(fs_info->sb); 740843fcf35SMiao Xie kmem_cache_free(btrfs_trans_handle_cachep, h); 741843fcf35SMiao Xie alloc_fail: 742843fcf35SMiao Xie if (num_bytes) 7432ff7e61eSJeff Mahoney btrfs_block_rsv_release(fs_info, &fs_info->trans_block_rsv, 74463f018beSNikolay Borisov num_bytes, NULL); 745843fcf35SMiao Xie reserve_fail: 746733e03a0SQu Wenruo btrfs_qgroup_free_meta_pertrans(root, qgroup_reserved); 747843fcf35SMiao Xie return ERR_PTR(ret); 74879154b1bSChris Mason } 74979154b1bSChris Mason 750f9295749SChris Mason struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root, 7515aed1dd8SAlexandru Moise unsigned int num_items) 752f9295749SChris Mason { 75308e007d2SMiao Xie return start_transaction(root, num_items, TRANS_START, 754003d7c59SJeff Mahoney BTRFS_RESERVE_FLUSH_ALL, true); 755f9295749SChris Mason } 756003d7c59SJeff Mahoney 7578eab77ffSFilipe Manana struct btrfs_trans_handle *btrfs_start_transaction_fallback_global_rsv( 7588eab77ffSFilipe Manana struct btrfs_root *root, 7597f9fe614SJosef Bacik unsigned int num_items) 7608eab77ffSFilipe Manana { 7617f9fe614SJosef Bacik return start_transaction(root, num_items, TRANS_START, 7627f9fe614SJosef Bacik BTRFS_RESERVE_FLUSH_ALL_STEAL, false); 7638eab77ffSFilipe Manana } 7648407aa46SMiao Xie 7657a7eaa40SJosef Bacik struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root) 766f9295749SChris Mason { 767003d7c59SJeff Mahoney return start_transaction(root, 0, TRANS_JOIN, BTRFS_RESERVE_NO_FLUSH, 768003d7c59SJeff Mahoney true); 769f9295749SChris Mason } 770f9295749SChris Mason 7718d510121SNikolay Borisov struct btrfs_trans_handle *btrfs_join_transaction_spacecache(struct btrfs_root *root) 7720af3d00bSJosef Bacik { 773575a75d6SAlexandru Moise return start_transaction(root, 0, TRANS_JOIN_NOLOCK, 774003d7c59SJeff Mahoney BTRFS_RESERVE_NO_FLUSH, true); 7750af3d00bSJosef Bacik } 7760af3d00bSJosef Bacik 777d4edf39bSMiao Xie /* 778a6d155d2SFilipe Manana * Similar to regular join but it never starts a transaction when none is 779a6d155d2SFilipe Manana * running or after waiting for the current one to finish. 780a6d155d2SFilipe Manana */ 781a6d155d2SFilipe Manana struct btrfs_trans_handle *btrfs_join_transaction_nostart(struct btrfs_root *root) 782a6d155d2SFilipe Manana { 783a6d155d2SFilipe Manana return start_transaction(root, 0, TRANS_JOIN_NOSTART, 784a6d155d2SFilipe Manana BTRFS_RESERVE_NO_FLUSH, true); 785a6d155d2SFilipe Manana } 786a6d155d2SFilipe Manana 787a6d155d2SFilipe Manana /* 788d4edf39bSMiao Xie * btrfs_attach_transaction() - catch the running transaction 789d4edf39bSMiao Xie * 790d4edf39bSMiao Xie * It is used when we want to commit the current the transaction, but 791d4edf39bSMiao Xie * don't want to start a new one. 792d4edf39bSMiao Xie * 793d4edf39bSMiao Xie * Note: If this function return -ENOENT, it just means there is no 794d4edf39bSMiao Xie * running transaction. But it is possible that the inactive transaction 795d4edf39bSMiao Xie * is still in the memory, not fully on disk. If you hope there is no 796d4edf39bSMiao Xie * inactive transaction in the fs when -ENOENT is returned, you should 797d4edf39bSMiao Xie * invoke 798d4edf39bSMiao Xie * btrfs_attach_transaction_barrier() 799d4edf39bSMiao Xie */ 800354aa0fbSMiao Xie struct btrfs_trans_handle *btrfs_attach_transaction(struct btrfs_root *root) 80160376ce4SJosef Bacik { 802575a75d6SAlexandru Moise return start_transaction(root, 0, TRANS_ATTACH, 803003d7c59SJeff Mahoney BTRFS_RESERVE_NO_FLUSH, true); 80460376ce4SJosef Bacik } 80560376ce4SJosef Bacik 806d4edf39bSMiao Xie /* 80790b6d283SWang Sheng-Hui * btrfs_attach_transaction_barrier() - catch the running transaction 808d4edf39bSMiao Xie * 80952042d8eSAndrea Gelmini * It is similar to the above function, the difference is this one 810d4edf39bSMiao Xie * will wait for all the inactive transactions until they fully 811d4edf39bSMiao Xie * complete. 812d4edf39bSMiao Xie */ 813d4edf39bSMiao Xie struct btrfs_trans_handle * 814d4edf39bSMiao Xie btrfs_attach_transaction_barrier(struct btrfs_root *root) 815d4edf39bSMiao Xie { 816d4edf39bSMiao Xie struct btrfs_trans_handle *trans; 817d4edf39bSMiao Xie 818575a75d6SAlexandru Moise trans = start_transaction(root, 0, TRANS_ATTACH, 819003d7c59SJeff Mahoney BTRFS_RESERVE_NO_FLUSH, true); 8208d9e220cSAl Viro if (trans == ERR_PTR(-ENOENT)) 8212ff7e61eSJeff Mahoney btrfs_wait_for_commit(root->fs_info, 0); 822d4edf39bSMiao Xie 823d4edf39bSMiao Xie return trans; 824d4edf39bSMiao Xie } 825d4edf39bSMiao Xie 826d0c2f4faSFilipe Manana /* Wait for a transaction commit to reach at least the given state. */ 827d0c2f4faSFilipe Manana static noinline void wait_for_commit(struct btrfs_transaction *commit, 828d0c2f4faSFilipe Manana const enum btrfs_trans_state min_state) 82989ce8a63SChris Mason { 8305fd76bf3SOmar Sandoval struct btrfs_fs_info *fs_info = commit->fs_info; 8315fd76bf3SOmar Sandoval u64 transid = commit->transid; 8325fd76bf3SOmar Sandoval bool put = false; 8335fd76bf3SOmar Sandoval 8343e738c53SIoannis Angelakopoulos /* 8353e738c53SIoannis Angelakopoulos * At the moment this function is called with min_state either being 8363e738c53SIoannis Angelakopoulos * TRANS_STATE_COMPLETED or TRANS_STATE_SUPER_COMMITTED. 8373e738c53SIoannis Angelakopoulos */ 8383e738c53SIoannis Angelakopoulos if (min_state == TRANS_STATE_COMPLETED) 8393e738c53SIoannis Angelakopoulos btrfs_might_wait_for_state(fs_info, BTRFS_LOCKDEP_TRANS_COMPLETED); 8403e738c53SIoannis Angelakopoulos else 8413e738c53SIoannis Angelakopoulos btrfs_might_wait_for_state(fs_info, BTRFS_LOCKDEP_TRANS_SUPER_COMMITTED); 8423e738c53SIoannis Angelakopoulos 8435fd76bf3SOmar Sandoval while (1) { 844d0c2f4faSFilipe Manana wait_event(commit->commit_wait, commit->state >= min_state); 8455fd76bf3SOmar Sandoval if (put) 8465fd76bf3SOmar Sandoval btrfs_put_transaction(commit); 8475fd76bf3SOmar Sandoval 8485fd76bf3SOmar Sandoval if (min_state < TRANS_STATE_COMPLETED) 8495fd76bf3SOmar Sandoval break; 8505fd76bf3SOmar Sandoval 8515fd76bf3SOmar Sandoval /* 8525fd76bf3SOmar Sandoval * A transaction isn't really completed until all of the 8535fd76bf3SOmar Sandoval * previous transactions are completed, but with fsync we can 8545fd76bf3SOmar Sandoval * end up with SUPER_COMMITTED transactions before a COMPLETED 8555fd76bf3SOmar Sandoval * transaction. Wait for those. 8565fd76bf3SOmar Sandoval */ 8575fd76bf3SOmar Sandoval 8585fd76bf3SOmar Sandoval spin_lock(&fs_info->trans_lock); 8595fd76bf3SOmar Sandoval commit = list_first_entry_or_null(&fs_info->trans_list, 8605fd76bf3SOmar Sandoval struct btrfs_transaction, 8615fd76bf3SOmar Sandoval list); 8625fd76bf3SOmar Sandoval if (!commit || commit->transid > transid) { 8635fd76bf3SOmar Sandoval spin_unlock(&fs_info->trans_lock); 8645fd76bf3SOmar Sandoval break; 8655fd76bf3SOmar Sandoval } 8665fd76bf3SOmar Sandoval refcount_inc(&commit->use_count); 8675fd76bf3SOmar Sandoval put = true; 8685fd76bf3SOmar Sandoval spin_unlock(&fs_info->trans_lock); 8695fd76bf3SOmar Sandoval } 87089ce8a63SChris Mason } 87189ce8a63SChris Mason 8722ff7e61eSJeff Mahoney int btrfs_wait_for_commit(struct btrfs_fs_info *fs_info, u64 transid) 87346204592SSage Weil { 87446204592SSage Weil struct btrfs_transaction *cur_trans = NULL, *t; 8758cd2807fSMiao Xie int ret = 0; 87646204592SSage Weil 87746204592SSage Weil if (transid) { 8780b246afaSJeff Mahoney if (transid <= fs_info->last_trans_committed) 879a4abeea4SJosef Bacik goto out; 88046204592SSage Weil 88146204592SSage Weil /* find specified transaction */ 8820b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 8830b246afaSJeff Mahoney list_for_each_entry(t, &fs_info->trans_list, list) { 88446204592SSage Weil if (t->transid == transid) { 88546204592SSage Weil cur_trans = t; 8869b64f57dSElena Reshetova refcount_inc(&cur_trans->use_count); 8878cd2807fSMiao Xie ret = 0; 88846204592SSage Weil break; 88946204592SSage Weil } 8908cd2807fSMiao Xie if (t->transid > transid) { 8918cd2807fSMiao Xie ret = 0; 89246204592SSage Weil break; 89346204592SSage Weil } 8948cd2807fSMiao Xie } 8950b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 89642383020SSage Weil 89742383020SSage Weil /* 89842383020SSage Weil * The specified transaction doesn't exist, or we 89942383020SSage Weil * raced with btrfs_commit_transaction 90042383020SSage Weil */ 90142383020SSage Weil if (!cur_trans) { 9020b246afaSJeff Mahoney if (transid > fs_info->last_trans_committed) 90342383020SSage Weil ret = -EINVAL; 9048cd2807fSMiao Xie goto out; 90542383020SSage Weil } 90646204592SSage Weil } else { 90746204592SSage Weil /* find newest transaction that is committing | committed */ 9080b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 9090b246afaSJeff Mahoney list_for_each_entry_reverse(t, &fs_info->trans_list, 91046204592SSage Weil list) { 9114a9d8bdeSMiao Xie if (t->state >= TRANS_STATE_COMMIT_START) { 9124a9d8bdeSMiao Xie if (t->state == TRANS_STATE_COMPLETED) 9133473f3c0SJosef Bacik break; 91446204592SSage Weil cur_trans = t; 9159b64f57dSElena Reshetova refcount_inc(&cur_trans->use_count); 91646204592SSage Weil break; 91746204592SSage Weil } 91846204592SSage Weil } 9190b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 92046204592SSage Weil if (!cur_trans) 921a4abeea4SJosef Bacik goto out; /* nothing committing|committed */ 92246204592SSage Weil } 92346204592SSage Weil 924d0c2f4faSFilipe Manana wait_for_commit(cur_trans, TRANS_STATE_COMPLETED); 925724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 926a4abeea4SJosef Bacik out: 92746204592SSage Weil return ret; 92846204592SSage Weil } 92946204592SSage Weil 9302ff7e61eSJeff Mahoney void btrfs_throttle(struct btrfs_fs_info *fs_info) 93137d1aeeeSChris Mason { 9322ff7e61eSJeff Mahoney wait_current_trans(fs_info); 93337d1aeeeSChris Mason } 93437d1aeeeSChris Mason 9358a8f4deaSNikolay Borisov static bool should_end_transaction(struct btrfs_trans_handle *trans) 9368929ecfaSYan, Zheng { 9372ff7e61eSJeff Mahoney struct btrfs_fs_info *fs_info = trans->fs_info; 9380b246afaSJeff Mahoney 93964403612SJosef Bacik if (btrfs_check_space_for_delayed_refs(fs_info)) 9408a8f4deaSNikolay Borisov return true; 94136ba022aSJosef Bacik 9422ff7e61eSJeff Mahoney return !!btrfs_block_rsv_check(&fs_info->global_block_rsv, 5); 9438929ecfaSYan, Zheng } 9448929ecfaSYan, Zheng 945a2633b6aSNikolay Borisov bool btrfs_should_end_transaction(struct btrfs_trans_handle *trans) 9468929ecfaSYan, Zheng { 9478929ecfaSYan, Zheng struct btrfs_transaction *cur_trans = trans->transaction; 9488929ecfaSYan, Zheng 9493296bf56SQu Wenruo if (cur_trans->state >= TRANS_STATE_COMMIT_START || 950e19eb11fSJosef Bacik test_bit(BTRFS_DELAYED_REFS_FLUSHING, &cur_trans->delayed_refs.flags)) 951a2633b6aSNikolay Borisov return true; 9528929ecfaSYan, Zheng 9532ff7e61eSJeff Mahoney return should_end_transaction(trans); 9548929ecfaSYan, Zheng } 9558929ecfaSYan, Zheng 956dc60c525SNikolay Borisov static void btrfs_trans_release_metadata(struct btrfs_trans_handle *trans) 957dc60c525SNikolay Borisov 9580e34693fSNikolay Borisov { 959dc60c525SNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 960dc60c525SNikolay Borisov 9610e34693fSNikolay Borisov if (!trans->block_rsv) { 9620e34693fSNikolay Borisov ASSERT(!trans->bytes_reserved); 9630e34693fSNikolay Borisov return; 9640e34693fSNikolay Borisov } 9650e34693fSNikolay Borisov 9660e34693fSNikolay Borisov if (!trans->bytes_reserved) 9670e34693fSNikolay Borisov return; 9680e34693fSNikolay Borisov 9690e34693fSNikolay Borisov ASSERT(trans->block_rsv == &fs_info->trans_block_rsv); 9700e34693fSNikolay Borisov trace_btrfs_space_reservation(fs_info, "transaction", 9710e34693fSNikolay Borisov trans->transid, trans->bytes_reserved, 0); 9720e34693fSNikolay Borisov btrfs_block_rsv_release(fs_info, trans->block_rsv, 97363f018beSNikolay Borisov trans->bytes_reserved, NULL); 9740e34693fSNikolay Borisov trans->bytes_reserved = 0; 9750e34693fSNikolay Borisov } 9760e34693fSNikolay Borisov 97789ce8a63SChris Mason static int __btrfs_end_transaction(struct btrfs_trans_handle *trans, 9783a45bb20SJeff Mahoney int throttle) 97979154b1bSChris Mason { 9803a45bb20SJeff Mahoney struct btrfs_fs_info *info = trans->fs_info; 9818929ecfaSYan, Zheng struct btrfs_transaction *cur_trans = trans->transaction; 9824edc2ca3SDave Jones int err = 0; 983d6e4a428SChris Mason 984b50fff81SDavid Sterba if (refcount_read(&trans->use_count) > 1) { 985b50fff81SDavid Sterba refcount_dec(&trans->use_count); 9862a1eb461SJosef Bacik trans->block_rsv = trans->orig_rsv; 9872a1eb461SJosef Bacik return 0; 9882a1eb461SJosef Bacik } 9892a1eb461SJosef Bacik 990dc60c525SNikolay Borisov btrfs_trans_release_metadata(trans); 9914c13d758SJosef Bacik trans->block_rsv = NULL; 992c5567237SArne Jansen 9936c686b35SNikolay Borisov btrfs_create_pending_block_groups(trans); 994ea658badSJosef Bacik 9954fbcdf66SFilipe Manana btrfs_trans_release_chunk_metadata(trans); 9964fbcdf66SFilipe Manana 9970860adfdSMiao Xie if (trans->type & __TRANS_FREEZABLE) 9980b246afaSJeff Mahoney sb_end_intwrite(info->sb); 9996df7881aSJosef Bacik 10008929ecfaSYan, Zheng WARN_ON(cur_trans != info->running_transaction); 100113c5a93eSJosef Bacik WARN_ON(atomic_read(&cur_trans->num_writers) < 1); 100213c5a93eSJosef Bacik atomic_dec(&cur_trans->num_writers); 10030860adfdSMiao Xie extwriter_counter_dec(cur_trans, trans->type); 100489ce8a63SChris Mason 1005093258e6SDavid Sterba cond_wake_up(&cur_trans->writer_wait); 1006e1489b4fSIoannis Angelakopoulos 10075a9ba670SIoannis Angelakopoulos btrfs_lockdep_release(info, btrfs_trans_num_extwriters); 1008e1489b4fSIoannis Angelakopoulos btrfs_lockdep_release(info, btrfs_trans_num_writers); 1009e1489b4fSIoannis Angelakopoulos 1010724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 10119ed74f2dSJosef Bacik 10129ed74f2dSJosef Bacik if (current->journal_info == trans) 10139ed74f2dSJosef Bacik current->journal_info = NULL; 1014ab78c84dSChris Mason 101524bbcf04SYan, Zheng if (throttle) 10162ff7e61eSJeff Mahoney btrfs_run_delayed_iputs(info); 101724bbcf04SYan, Zheng 101884961539SJosef Bacik if (TRANS_ABORTED(trans) || BTRFS_FS_ERROR(info)) { 10194e121c06SJosef Bacik wake_up_process(info->transaction_kthread); 1020fbabd4a3SJosef Bacik if (TRANS_ABORTED(trans)) 1021fbabd4a3SJosef Bacik err = trans->aborted; 1022fbabd4a3SJosef Bacik else 1023fbabd4a3SJosef Bacik err = -EROFS; 10244e121c06SJosef Bacik } 102549b25e05SJeff Mahoney 10264edc2ca3SDave Jones kmem_cache_free(btrfs_trans_handle_cachep, trans); 10274edc2ca3SDave Jones return err; 102879154b1bSChris Mason } 102979154b1bSChris Mason 10303a45bb20SJeff Mahoney int btrfs_end_transaction(struct btrfs_trans_handle *trans) 103189ce8a63SChris Mason { 10323a45bb20SJeff Mahoney return __btrfs_end_transaction(trans, 0); 103389ce8a63SChris Mason } 103489ce8a63SChris Mason 10353a45bb20SJeff Mahoney int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans) 103689ce8a63SChris Mason { 10373a45bb20SJeff Mahoney return __btrfs_end_transaction(trans, 1); 103816cdcec7SMiao Xie } 103916cdcec7SMiao Xie 1040d352ac68SChris Mason /* 1041d352ac68SChris Mason * when btree blocks are allocated, they have some corresponding bits set for 1042d352ac68SChris Mason * them in one of two extent_io trees. This is used to make sure all of 1043690587d1SChris Mason * those extents are sent to disk but does not wait on them 1044d352ac68SChris Mason */ 10452ff7e61eSJeff Mahoney int btrfs_write_marked_extents(struct btrfs_fs_info *fs_info, 10468cef4e16SYan, Zheng struct extent_io_tree *dirty_pages, int mark) 104779154b1bSChris Mason { 1048777e6bd7SChris Mason int err = 0; 10497c4452b9SChris Mason int werr = 0; 10500b246afaSJeff Mahoney struct address_space *mapping = fs_info->btree_inode->i_mapping; 1051e6138876SJosef Bacik struct extent_state *cached_state = NULL; 1052777e6bd7SChris Mason u64 start = 0; 10535f39d397SChris Mason u64 end; 10547c4452b9SChris Mason 10556300463bSLiu Bo atomic_inc(&BTRFS_I(fs_info->btree_inode)->sync_writers); 10561728366eSJosef Bacik while (!find_first_extent_bit(dirty_pages, start, &start, &end, 1057e6138876SJosef Bacik mark, &cached_state)) { 1058663dfbb0SFilipe Manana bool wait_writeback = false; 1059663dfbb0SFilipe Manana 1060663dfbb0SFilipe Manana err = convert_extent_bit(dirty_pages, start, end, 1061663dfbb0SFilipe Manana EXTENT_NEED_WAIT, 1062210aa277SDavid Sterba mark, &cached_state); 1063663dfbb0SFilipe Manana /* 1064663dfbb0SFilipe Manana * convert_extent_bit can return -ENOMEM, which is most of the 1065663dfbb0SFilipe Manana * time a temporary error. So when it happens, ignore the error 1066663dfbb0SFilipe Manana * and wait for writeback of this range to finish - because we 1067663dfbb0SFilipe Manana * failed to set the bit EXTENT_NEED_WAIT for the range, a call 1068bf89d38fSJeff Mahoney * to __btrfs_wait_marked_extents() would not know that 1069bf89d38fSJeff Mahoney * writeback for this range started and therefore wouldn't 1070bf89d38fSJeff Mahoney * wait for it to finish - we don't want to commit a 1071bf89d38fSJeff Mahoney * superblock that points to btree nodes/leafs for which 1072bf89d38fSJeff Mahoney * writeback hasn't finished yet (and without errors). 1073663dfbb0SFilipe Manana * We cleanup any entries left in the io tree when committing 107441e7acd3SNikolay Borisov * the transaction (through extent_io_tree_release()). 1075663dfbb0SFilipe Manana */ 1076663dfbb0SFilipe Manana if (err == -ENOMEM) { 1077663dfbb0SFilipe Manana err = 0; 1078663dfbb0SFilipe Manana wait_writeback = true; 1079663dfbb0SFilipe Manana } 1080663dfbb0SFilipe Manana if (!err) 10811728366eSJosef Bacik err = filemap_fdatawrite_range(mapping, start, end); 10827c4452b9SChris Mason if (err) 10837c4452b9SChris Mason werr = err; 1084663dfbb0SFilipe Manana else if (wait_writeback) 1085663dfbb0SFilipe Manana werr = filemap_fdatawait_range(mapping, start, end); 1086e38e2ed7SFilipe Manana free_extent_state(cached_state); 1087663dfbb0SFilipe Manana cached_state = NULL; 10881728366eSJosef Bacik cond_resched(); 10891728366eSJosef Bacik start = end + 1; 10907c4452b9SChris Mason } 10916300463bSLiu Bo atomic_dec(&BTRFS_I(fs_info->btree_inode)->sync_writers); 1092690587d1SChris Mason return werr; 1093690587d1SChris Mason } 1094690587d1SChris Mason 1095690587d1SChris Mason /* 1096690587d1SChris Mason * when btree blocks are allocated, they have some corresponding bits set for 1097690587d1SChris Mason * them in one of two extent_io trees. This is used to make sure all of 1098690587d1SChris Mason * those extents are on disk for transaction or log commit. We wait 1099690587d1SChris Mason * on all the pages and clear them from the dirty pages state tree 1100690587d1SChris Mason */ 1101bf89d38fSJeff Mahoney static int __btrfs_wait_marked_extents(struct btrfs_fs_info *fs_info, 1102bf89d38fSJeff Mahoney struct extent_io_tree *dirty_pages) 1103690587d1SChris Mason { 1104690587d1SChris Mason int err = 0; 1105690587d1SChris Mason int werr = 0; 11060b246afaSJeff Mahoney struct address_space *mapping = fs_info->btree_inode->i_mapping; 1107e6138876SJosef Bacik struct extent_state *cached_state = NULL; 1108690587d1SChris Mason u64 start = 0; 1109690587d1SChris Mason u64 end; 1110690587d1SChris Mason 11111728366eSJosef Bacik while (!find_first_extent_bit(dirty_pages, start, &start, &end, 1112e6138876SJosef Bacik EXTENT_NEED_WAIT, &cached_state)) { 1113663dfbb0SFilipe Manana /* 1114663dfbb0SFilipe Manana * Ignore -ENOMEM errors returned by clear_extent_bit(). 1115663dfbb0SFilipe Manana * When committing the transaction, we'll remove any entries 1116663dfbb0SFilipe Manana * left in the io tree. For a log commit, we don't remove them 1117663dfbb0SFilipe Manana * after committing the log because the tree can be accessed 1118663dfbb0SFilipe Manana * concurrently - we do it only at transaction commit time when 111941e7acd3SNikolay Borisov * it's safe to do it (through extent_io_tree_release()). 1120663dfbb0SFilipe Manana */ 1121663dfbb0SFilipe Manana err = clear_extent_bit(dirty_pages, start, end, 1122bd015294SJosef Bacik EXTENT_NEED_WAIT, &cached_state); 1123663dfbb0SFilipe Manana if (err == -ENOMEM) 1124663dfbb0SFilipe Manana err = 0; 1125663dfbb0SFilipe Manana if (!err) 11261728366eSJosef Bacik err = filemap_fdatawait_range(mapping, start, end); 1127777e6bd7SChris Mason if (err) 1128777e6bd7SChris Mason werr = err; 1129e38e2ed7SFilipe Manana free_extent_state(cached_state); 1130e38e2ed7SFilipe Manana cached_state = NULL; 1131777e6bd7SChris Mason cond_resched(); 11321728366eSJosef Bacik start = end + 1; 1133777e6bd7SChris Mason } 11347c4452b9SChris Mason if (err) 11357c4452b9SChris Mason werr = err; 1136bf89d38fSJeff Mahoney return werr; 1137bf89d38fSJeff Mahoney } 1138656f30dbSFilipe Manana 1139b9fae2ebSFilipe Manana static int btrfs_wait_extents(struct btrfs_fs_info *fs_info, 1140bf89d38fSJeff Mahoney struct extent_io_tree *dirty_pages) 1141bf89d38fSJeff Mahoney { 1142bf89d38fSJeff Mahoney bool errors = false; 1143bf89d38fSJeff Mahoney int err; 1144bf89d38fSJeff Mahoney 1145bf89d38fSJeff Mahoney err = __btrfs_wait_marked_extents(fs_info, dirty_pages); 1146bf89d38fSJeff Mahoney if (test_and_clear_bit(BTRFS_FS_BTREE_ERR, &fs_info->flags)) 1147bf89d38fSJeff Mahoney errors = true; 1148bf89d38fSJeff Mahoney 1149bf89d38fSJeff Mahoney if (errors && !err) 1150bf89d38fSJeff Mahoney err = -EIO; 1151bf89d38fSJeff Mahoney return err; 1152bf89d38fSJeff Mahoney } 1153bf89d38fSJeff Mahoney 1154bf89d38fSJeff Mahoney int btrfs_wait_tree_log_extents(struct btrfs_root *log_root, int mark) 1155bf89d38fSJeff Mahoney { 1156bf89d38fSJeff Mahoney struct btrfs_fs_info *fs_info = log_root->fs_info; 1157bf89d38fSJeff Mahoney struct extent_io_tree *dirty_pages = &log_root->dirty_log_pages; 1158bf89d38fSJeff Mahoney bool errors = false; 1159bf89d38fSJeff Mahoney int err; 1160bf89d38fSJeff Mahoney 1161bf89d38fSJeff Mahoney ASSERT(log_root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID); 1162bf89d38fSJeff Mahoney 1163bf89d38fSJeff Mahoney err = __btrfs_wait_marked_extents(fs_info, dirty_pages); 1164656f30dbSFilipe Manana if ((mark & EXTENT_DIRTY) && 11650b246afaSJeff Mahoney test_and_clear_bit(BTRFS_FS_LOG1_ERR, &fs_info->flags)) 1166656f30dbSFilipe Manana errors = true; 1167656f30dbSFilipe Manana 1168656f30dbSFilipe Manana if ((mark & EXTENT_NEW) && 11690b246afaSJeff Mahoney test_and_clear_bit(BTRFS_FS_LOG2_ERR, &fs_info->flags)) 1170656f30dbSFilipe Manana errors = true; 1171656f30dbSFilipe Manana 1172bf89d38fSJeff Mahoney if (errors && !err) 1173bf89d38fSJeff Mahoney err = -EIO; 1174bf89d38fSJeff Mahoney return err; 117579154b1bSChris Mason } 117679154b1bSChris Mason 1177690587d1SChris Mason /* 1178c9b577c0SNikolay Borisov * When btree blocks are allocated the corresponding extents are marked dirty. 1179c9b577c0SNikolay Borisov * This function ensures such extents are persisted on disk for transaction or 1180c9b577c0SNikolay Borisov * log commit. 1181c9b577c0SNikolay Borisov * 1182c9b577c0SNikolay Borisov * @trans: transaction whose dirty pages we'd like to write 1183690587d1SChris Mason */ 118470458a58SNikolay Borisov static int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans) 1185d0c803c4SChris Mason { 1186663dfbb0SFilipe Manana int ret; 1187c9b577c0SNikolay Borisov int ret2; 1188c9b577c0SNikolay Borisov struct extent_io_tree *dirty_pages = &trans->transaction->dirty_pages; 118970458a58SNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 1190c9b577c0SNikolay Borisov struct blk_plug plug; 1191663dfbb0SFilipe Manana 1192c9b577c0SNikolay Borisov blk_start_plug(&plug); 1193c9b577c0SNikolay Borisov ret = btrfs_write_marked_extents(fs_info, dirty_pages, EXTENT_DIRTY); 1194c9b577c0SNikolay Borisov blk_finish_plug(&plug); 1195c9b577c0SNikolay Borisov ret2 = btrfs_wait_extents(fs_info, dirty_pages); 1196c9b577c0SNikolay Borisov 119741e7acd3SNikolay Borisov extent_io_tree_release(&trans->transaction->dirty_pages); 1198663dfbb0SFilipe Manana 1199c9b577c0SNikolay Borisov if (ret) 1200663dfbb0SFilipe Manana return ret; 1201c9b577c0SNikolay Borisov else if (ret2) 1202c9b577c0SNikolay Borisov return ret2; 1203c9b577c0SNikolay Borisov else 1204c9b577c0SNikolay Borisov return 0; 1205d0c803c4SChris Mason } 1206d0c803c4SChris Mason 1207d352ac68SChris Mason /* 1208d352ac68SChris Mason * this is used to update the root pointer in the tree of tree roots. 1209d352ac68SChris Mason * 1210d352ac68SChris Mason * But, in the case of the extent allocation tree, updating the root 1211d352ac68SChris Mason * pointer may allocate blocks which may change the root of the extent 1212d352ac68SChris Mason * allocation tree. 1213d352ac68SChris Mason * 1214d352ac68SChris Mason * So, this loops and repeats and makes sure the cowonly root didn't 1215d352ac68SChris Mason * change while the root pointer was being updated in the metadata. 1216d352ac68SChris Mason */ 12170b86a832SChris Mason static int update_cowonly_root(struct btrfs_trans_handle *trans, 121879154b1bSChris Mason struct btrfs_root *root) 121979154b1bSChris Mason { 122079154b1bSChris Mason int ret; 12210b86a832SChris Mason u64 old_root_bytenr; 122286b9f2ecSYan, Zheng u64 old_root_used; 12230b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 12240b246afaSJeff Mahoney struct btrfs_root *tree_root = fs_info->tree_root; 122579154b1bSChris Mason 122686b9f2ecSYan, Zheng old_root_used = btrfs_root_used(&root->root_item); 122756bec294SChris Mason 122879154b1bSChris Mason while (1) { 12290b86a832SChris Mason old_root_bytenr = btrfs_root_bytenr(&root->root_item); 123086b9f2ecSYan, Zheng if (old_root_bytenr == root->node->start && 1231ea526d18SJosef Bacik old_root_used == btrfs_root_used(&root->root_item)) 123279154b1bSChris Mason break; 123387ef2bb4SChris Mason 12345d4f98a2SYan Zheng btrfs_set_root_node(&root->root_item, root->node); 123579154b1bSChris Mason ret = btrfs_update_root(trans, tree_root, 12360b86a832SChris Mason &root->root_key, 12370b86a832SChris Mason &root->root_item); 123849b25e05SJeff Mahoney if (ret) 123949b25e05SJeff Mahoney return ret; 124056bec294SChris Mason 124186b9f2ecSYan, Zheng old_root_used = btrfs_root_used(&root->root_item); 1242e7070be1SJosef Bacik } 1243276e680dSYan Zheng 12440b86a832SChris Mason return 0; 12450b86a832SChris Mason } 12460b86a832SChris Mason 1247d352ac68SChris Mason /* 1248d352ac68SChris Mason * update all the cowonly tree roots on disk 124949b25e05SJeff Mahoney * 125049b25e05SJeff Mahoney * The error handling in this function may not be obvious. Any of the 125149b25e05SJeff Mahoney * failures will cause the file system to go offline. We still need 125249b25e05SJeff Mahoney * to clean up the delayed refs. 1253d352ac68SChris Mason */ 12549386d8bcSNikolay Borisov static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans) 12550b86a832SChris Mason { 12569386d8bcSNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 1257ea526d18SJosef Bacik struct list_head *dirty_bgs = &trans->transaction->dirty_bgs; 12581bbc621eSChris Mason struct list_head *io_bgs = &trans->transaction->io_bgs; 12590b86a832SChris Mason struct list_head *next; 126084234f3aSYan Zheng struct extent_buffer *eb; 126156bec294SChris Mason int ret; 126284234f3aSYan Zheng 1263dfba78dcSFilipe Manana /* 1264dfba78dcSFilipe Manana * At this point no one can be using this transaction to modify any tree 1265dfba78dcSFilipe Manana * and no one can start another transaction to modify any tree either. 1266dfba78dcSFilipe Manana */ 1267dfba78dcSFilipe Manana ASSERT(trans->transaction->state == TRANS_STATE_COMMIT_DOING); 1268dfba78dcSFilipe Manana 126984234f3aSYan Zheng eb = btrfs_lock_root_node(fs_info->tree_root); 127049b25e05SJeff Mahoney ret = btrfs_cow_block(trans, fs_info->tree_root, eb, NULL, 12719631e4ccSJosef Bacik 0, &eb, BTRFS_NESTING_COW); 127284234f3aSYan Zheng btrfs_tree_unlock(eb); 127384234f3aSYan Zheng free_extent_buffer(eb); 12740b86a832SChris Mason 127549b25e05SJeff Mahoney if (ret) 127649b25e05SJeff Mahoney return ret; 127749b25e05SJeff Mahoney 1278196c9d8dSDavid Sterba ret = btrfs_run_dev_stats(trans); 1279c16ce190SJosef Bacik if (ret) 1280c16ce190SJosef Bacik return ret; 12812b584c68SDavid Sterba ret = btrfs_run_dev_replace(trans); 1282c16ce190SJosef Bacik if (ret) 1283c16ce190SJosef Bacik return ret; 1284280f8bd2SLu Fengqi ret = btrfs_run_qgroups(trans); 1285c16ce190SJosef Bacik if (ret) 1286c16ce190SJosef Bacik return ret; 1287546adb0dSJan Schmidt 1288bbebb3e0SDavid Sterba ret = btrfs_setup_space_cache(trans); 1289dcdf7f6dSJosef Bacik if (ret) 1290dcdf7f6dSJosef Bacik return ret; 1291dcdf7f6dSJosef Bacik 1292ea526d18SJosef Bacik again: 12930b86a832SChris Mason while (!list_empty(&fs_info->dirty_cowonly_roots)) { 12942ff7e61eSJeff Mahoney struct btrfs_root *root; 12950b86a832SChris Mason next = fs_info->dirty_cowonly_roots.next; 12960b86a832SChris Mason list_del_init(next); 12970b86a832SChris Mason root = list_entry(next, struct btrfs_root, dirty_list); 1298e7070be1SJosef Bacik clear_bit(BTRFS_ROOT_DIRTY, &root->state); 129987ef2bb4SChris Mason 13009e351cc8SJosef Bacik list_add_tail(&root->dirty_list, 13019e351cc8SJosef Bacik &trans->transaction->switch_commits); 130249b25e05SJeff Mahoney ret = update_cowonly_root(trans, root); 130349b25e05SJeff Mahoney if (ret) 130449b25e05SJeff Mahoney return ret; 1305488bc2a2SJosef Bacik } 1306488bc2a2SJosef Bacik 1307488bc2a2SJosef Bacik /* Now flush any delayed refs generated by updating all of the roots */ 1308c79a70b1SNikolay Borisov ret = btrfs_run_delayed_refs(trans, (unsigned long)-1); 1309ea526d18SJosef Bacik if (ret) 1310ea526d18SJosef Bacik return ret; 1311276e680dSYan Zheng 13121bbc621eSChris Mason while (!list_empty(dirty_bgs) || !list_empty(io_bgs)) { 13135742d15fSDavid Sterba ret = btrfs_write_dirty_block_groups(trans); 1314ea526d18SJosef Bacik if (ret) 1315ea526d18SJosef Bacik return ret; 1316488bc2a2SJosef Bacik 1317488bc2a2SJosef Bacik /* 1318488bc2a2SJosef Bacik * We're writing the dirty block groups, which could generate 1319488bc2a2SJosef Bacik * delayed refs, which could generate more dirty block groups, 1320488bc2a2SJosef Bacik * so we want to keep this flushing in this loop to make sure 1321488bc2a2SJosef Bacik * everything gets run. 1322488bc2a2SJosef Bacik */ 1323c79a70b1SNikolay Borisov ret = btrfs_run_delayed_refs(trans, (unsigned long)-1); 1324ea526d18SJosef Bacik if (ret) 1325ea526d18SJosef Bacik return ret; 1326ea526d18SJosef Bacik } 1327ea526d18SJosef Bacik 1328ea526d18SJosef Bacik if (!list_empty(&fs_info->dirty_cowonly_roots)) 1329ea526d18SJosef Bacik goto again; 1330ea526d18SJosef Bacik 13319f6cbcbbSDavid Sterba /* Update dev-replace pointer once everything is committed */ 13329f6cbcbbSDavid Sterba fs_info->dev_replace.committed_cursor_left = 13339f6cbcbbSDavid Sterba fs_info->dev_replace.cursor_left_last_write_of_item; 13348dabb742SStefan Behrens 133579154b1bSChris Mason return 0; 133679154b1bSChris Mason } 133779154b1bSChris Mason 1338d352ac68SChris Mason /* 1339b4be6aefSJosef Bacik * If we had a pending drop we need to see if there are any others left in our 1340b4be6aefSJosef Bacik * dead roots list, and if not clear our bit and wake any waiters. 1341b4be6aefSJosef Bacik */ 1342b4be6aefSJosef Bacik void btrfs_maybe_wake_unfinished_drop(struct btrfs_fs_info *fs_info) 1343b4be6aefSJosef Bacik { 1344b4be6aefSJosef Bacik /* 1345b4be6aefSJosef Bacik * We put the drop in progress roots at the front of the list, so if the 1346b4be6aefSJosef Bacik * first entry doesn't have UNFINISHED_DROP set we can wake everybody 1347b4be6aefSJosef Bacik * up. 1348b4be6aefSJosef Bacik */ 1349b4be6aefSJosef Bacik spin_lock(&fs_info->trans_lock); 1350b4be6aefSJosef Bacik if (!list_empty(&fs_info->dead_roots)) { 1351b4be6aefSJosef Bacik struct btrfs_root *root = list_first_entry(&fs_info->dead_roots, 1352b4be6aefSJosef Bacik struct btrfs_root, 1353b4be6aefSJosef Bacik root_list); 1354b4be6aefSJosef Bacik if (test_bit(BTRFS_ROOT_UNFINISHED_DROP, &root->state)) { 1355b4be6aefSJosef Bacik spin_unlock(&fs_info->trans_lock); 1356b4be6aefSJosef Bacik return; 1357b4be6aefSJosef Bacik } 1358b4be6aefSJosef Bacik } 1359b4be6aefSJosef Bacik spin_unlock(&fs_info->trans_lock); 1360b4be6aefSJosef Bacik 1361b4be6aefSJosef Bacik btrfs_wake_unfinished_drop(fs_info); 1362b4be6aefSJosef Bacik } 1363b4be6aefSJosef Bacik 1364b4be6aefSJosef Bacik /* 1365d352ac68SChris Mason * dead roots are old snapshots that need to be deleted. This allocates 1366d352ac68SChris Mason * a dirty root struct and adds it into the list of dead roots that need to 1367d352ac68SChris Mason * be deleted 1368d352ac68SChris Mason */ 1369cfad392bSJosef Bacik void btrfs_add_dead_root(struct btrfs_root *root) 13705eda7b5eSChris Mason { 13710b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 13720b246afaSJeff Mahoney 13730b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 1374dc9492c1SJosef Bacik if (list_empty(&root->root_list)) { 1375dc9492c1SJosef Bacik btrfs_grab_root(root); 1376b4be6aefSJosef Bacik 1377b4be6aefSJosef Bacik /* We want to process the partially complete drops first. */ 1378b4be6aefSJosef Bacik if (test_bit(BTRFS_ROOT_UNFINISHED_DROP, &root->state)) 1379b4be6aefSJosef Bacik list_add(&root->root_list, &fs_info->dead_roots); 1380b4be6aefSJosef Bacik else 13810b246afaSJeff Mahoney list_add_tail(&root->root_list, &fs_info->dead_roots); 1382dc9492c1SJosef Bacik } 13830b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 13845eda7b5eSChris Mason } 13855eda7b5eSChris Mason 1386d352ac68SChris Mason /* 1387dfba78dcSFilipe Manana * Update each subvolume root and its relocation root, if it exists, in the tree 1388dfba78dcSFilipe Manana * of tree roots. Also free log roots if they exist. 1389d352ac68SChris Mason */ 13907e4443d9SNikolay Borisov static noinline int commit_fs_roots(struct btrfs_trans_handle *trans) 13910f7d52f4SChris Mason { 13927e4443d9SNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 1393fc7cbcd4SDavid Sterba struct btrfs_root *gang[8]; 1394fc7cbcd4SDavid Sterba int i; 1395fc7cbcd4SDavid Sterba int ret; 139654aa1f4dSChris Mason 1397dfba78dcSFilipe Manana /* 1398dfba78dcSFilipe Manana * At this point no one can be using this transaction to modify any tree 1399dfba78dcSFilipe Manana * and no one can start another transaction to modify any tree either. 1400dfba78dcSFilipe Manana */ 1401dfba78dcSFilipe Manana ASSERT(trans->transaction->state == TRANS_STATE_COMMIT_DOING); 1402dfba78dcSFilipe Manana 1403fc7cbcd4SDavid Sterba spin_lock(&fs_info->fs_roots_radix_lock); 1404fc7cbcd4SDavid Sterba while (1) { 1405fc7cbcd4SDavid Sterba ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix, 1406fc7cbcd4SDavid Sterba (void **)gang, 0, 1407fc7cbcd4SDavid Sterba ARRAY_SIZE(gang), 1408fc7cbcd4SDavid Sterba BTRFS_ROOT_TRANS_TAG); 1409fc7cbcd4SDavid Sterba if (ret == 0) 1410fc7cbcd4SDavid Sterba break; 1411fc7cbcd4SDavid Sterba for (i = 0; i < ret; i++) { 1412fc7cbcd4SDavid Sterba struct btrfs_root *root = gang[i]; 1413fc7cbcd4SDavid Sterba int ret2; 14144f4317c1SJosef Bacik 1415dfba78dcSFilipe Manana /* 1416dfba78dcSFilipe Manana * At this point we can neither have tasks logging inodes 1417dfba78dcSFilipe Manana * from a root nor trying to commit a log tree. 1418dfba78dcSFilipe Manana */ 1419dfba78dcSFilipe Manana ASSERT(atomic_read(&root->log_writers) == 0); 1420dfba78dcSFilipe Manana ASSERT(atomic_read(&root->log_commit[0]) == 0); 1421dfba78dcSFilipe Manana ASSERT(atomic_read(&root->log_commit[1]) == 0); 1422dfba78dcSFilipe Manana 1423fc7cbcd4SDavid Sterba radix_tree_tag_clear(&fs_info->fs_roots_radix, 14242619ba1fSChris Mason (unsigned long)root->root_key.objectid, 14250f7d52f4SChris Mason BTRFS_ROOT_TRANS_TAG); 1426fc7cbcd4SDavid Sterba spin_unlock(&fs_info->fs_roots_radix_lock); 142731153d81SYan Zheng 1428e02119d5SChris Mason btrfs_free_log(trans, root); 1429fc7cbcd4SDavid Sterba ret2 = btrfs_update_reloc_root(trans, root); 1430fc7cbcd4SDavid Sterba if (ret2) 1431fc7cbcd4SDavid Sterba return ret2; 1432e02119d5SChris Mason 1433fc7cbcd4SDavid Sterba /* see comments in should_cow_block() */ 143427cdeb70SMiao Xie clear_bit(BTRFS_ROOT_FORCE_COW, &root->state); 1435c7548af6SChris Mason smp_mb__after_atomic(); 1436f1ebcc74SLiu Bo 1437978d910dSYan Zheng if (root->commit_root != root->node) { 14389e351cc8SJosef Bacik list_add_tail(&root->dirty_list, 14399e351cc8SJosef Bacik &trans->transaction->switch_commits); 1440fc7cbcd4SDavid Sterba btrfs_set_root_node(&root->root_item, 1441fc7cbcd4SDavid Sterba root->node); 1442978d910dSYan Zheng } 144331153d81SYan Zheng 1444fc7cbcd4SDavid Sterba ret2 = btrfs_update_root(trans, fs_info->tree_root, 1445fc7cbcd4SDavid Sterba &root->root_key, 1446fc7cbcd4SDavid Sterba &root->root_item); 1447fc7cbcd4SDavid Sterba if (ret2) 1448fc7cbcd4SDavid Sterba return ret2; 1449fc7cbcd4SDavid Sterba spin_lock(&fs_info->fs_roots_radix_lock); 1450733e03a0SQu Wenruo btrfs_qgroup_free_meta_all_pertrans(root); 14510f7d52f4SChris Mason } 1452fc7cbcd4SDavid Sterba } 1453fc7cbcd4SDavid Sterba spin_unlock(&fs_info->fs_roots_radix_lock); 14544f4317c1SJosef Bacik return 0; 14550f7d52f4SChris Mason } 14560f7d52f4SChris Mason 1457d352ac68SChris Mason /* 1458de78b51aSEric Sandeen * defrag a given btree. 1459de78b51aSEric Sandeen * Every leaf in the btree is read and defragged. 1460d352ac68SChris Mason */ 1461de78b51aSEric Sandeen int btrfs_defrag_root(struct btrfs_root *root) 1462e9d0b13bSChris Mason { 1463e9d0b13bSChris Mason struct btrfs_fs_info *info = root->fs_info; 1464e9d0b13bSChris Mason struct btrfs_trans_handle *trans; 14658929ecfaSYan, Zheng int ret; 1466e9d0b13bSChris Mason 146727cdeb70SMiao Xie if (test_and_set_bit(BTRFS_ROOT_DEFRAG_RUNNING, &root->state)) 1468e9d0b13bSChris Mason return 0; 14698929ecfaSYan, Zheng 14706b80053dSChris Mason while (1) { 14718929ecfaSYan, Zheng trans = btrfs_start_transaction(root, 0); 14726819703fSDavid Sterba if (IS_ERR(trans)) { 14736819703fSDavid Sterba ret = PTR_ERR(trans); 14746819703fSDavid Sterba break; 14756819703fSDavid Sterba } 14768929ecfaSYan, Zheng 1477de78b51aSEric Sandeen ret = btrfs_defrag_leaves(trans, root); 14788929ecfaSYan, Zheng 14793a45bb20SJeff Mahoney btrfs_end_transaction(trans); 14802ff7e61eSJeff Mahoney btrfs_btree_balance_dirty(info); 1481e9d0b13bSChris Mason cond_resched(); 1482e9d0b13bSChris Mason 1483ab8d0fc4SJeff Mahoney if (btrfs_fs_closing(info) || ret != -EAGAIN) 1484e9d0b13bSChris Mason break; 1485210549ebSDavid Sterba 1486ab8d0fc4SJeff Mahoney if (btrfs_defrag_cancelled(info)) { 1487ab8d0fc4SJeff Mahoney btrfs_debug(info, "defrag_root cancelled"); 1488210549ebSDavid Sterba ret = -EAGAIN; 1489210549ebSDavid Sterba break; 1490210549ebSDavid Sterba } 1491e9d0b13bSChris Mason } 149227cdeb70SMiao Xie clear_bit(BTRFS_ROOT_DEFRAG_RUNNING, &root->state); 14938929ecfaSYan, Zheng return ret; 1494e9d0b13bSChris Mason } 1495e9d0b13bSChris Mason 1496d352ac68SChris Mason /* 14976426c7adSQu Wenruo * Do all special snapshot related qgroup dirty hack. 14986426c7adSQu Wenruo * 14996426c7adSQu Wenruo * Will do all needed qgroup inherit and dirty hack like switch commit 15006426c7adSQu Wenruo * roots inside one transaction and write all btree into disk, to make 15016426c7adSQu Wenruo * qgroup works. 15026426c7adSQu Wenruo */ 15036426c7adSQu Wenruo static int qgroup_account_snapshot(struct btrfs_trans_handle *trans, 15046426c7adSQu Wenruo struct btrfs_root *src, 15056426c7adSQu Wenruo struct btrfs_root *parent, 15066426c7adSQu Wenruo struct btrfs_qgroup_inherit *inherit, 15076426c7adSQu Wenruo u64 dst_objectid) 15086426c7adSQu Wenruo { 15096426c7adSQu Wenruo struct btrfs_fs_info *fs_info = src->fs_info; 15106426c7adSQu Wenruo int ret; 15116426c7adSQu Wenruo 15126426c7adSQu Wenruo /* 15136426c7adSQu Wenruo * Save some performance in the case that qgroups are not 15146426c7adSQu Wenruo * enabled. If this check races with the ioctl, rescan will 15156426c7adSQu Wenruo * kick in anyway. 15166426c7adSQu Wenruo */ 15179ea6e2b5SDavid Sterba if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags)) 15186426c7adSQu Wenruo return 0; 15196426c7adSQu Wenruo 15206426c7adSQu Wenruo /* 152152042d8eSAndrea Gelmini * Ensure dirty @src will be committed. Or, after coming 15224d31778aSQu Wenruo * commit_fs_roots() and switch_commit_roots(), any dirty but not 15234d31778aSQu Wenruo * recorded root will never be updated again, causing an outdated root 15244d31778aSQu Wenruo * item. 15254d31778aSQu Wenruo */ 15261c442d22SJosef Bacik ret = record_root_in_trans(trans, src, 1); 15271c442d22SJosef Bacik if (ret) 15281c442d22SJosef Bacik return ret; 15294d31778aSQu Wenruo 15304d31778aSQu Wenruo /* 15312a4d84c1SJosef Bacik * btrfs_qgroup_inherit relies on a consistent view of the usage for the 15322a4d84c1SJosef Bacik * src root, so we must run the delayed refs here. 15332a4d84c1SJosef Bacik * 15342a4d84c1SJosef Bacik * However this isn't particularly fool proof, because there's no 15352a4d84c1SJosef Bacik * synchronization keeping us from changing the tree after this point 15362a4d84c1SJosef Bacik * before we do the qgroup_inherit, or even from making changes while 15372a4d84c1SJosef Bacik * we're doing the qgroup_inherit. But that's a problem for the future, 15382a4d84c1SJosef Bacik * for now flush the delayed refs to narrow the race window where the 15392a4d84c1SJosef Bacik * qgroup counters could end up wrong. 15402a4d84c1SJosef Bacik */ 15412a4d84c1SJosef Bacik ret = btrfs_run_delayed_refs(trans, (unsigned long)-1); 15422a4d84c1SJosef Bacik if (ret) { 15432a4d84c1SJosef Bacik btrfs_abort_transaction(trans, ret); 154444365827SNaohiro Aota return ret; 15452a4d84c1SJosef Bacik } 15462a4d84c1SJosef Bacik 15477e4443d9SNikolay Borisov ret = commit_fs_roots(trans); 15486426c7adSQu Wenruo if (ret) 15496426c7adSQu Wenruo goto out; 1550460fb20aSNikolay Borisov ret = btrfs_qgroup_account_extents(trans); 15516426c7adSQu Wenruo if (ret < 0) 15526426c7adSQu Wenruo goto out; 15536426c7adSQu Wenruo 15546426c7adSQu Wenruo /* Now qgroup are all updated, we can inherit it to new qgroups */ 1555a9377422SLu Fengqi ret = btrfs_qgroup_inherit(trans, src->root_key.objectid, dst_objectid, 15566426c7adSQu Wenruo inherit); 15576426c7adSQu Wenruo if (ret < 0) 15586426c7adSQu Wenruo goto out; 15596426c7adSQu Wenruo 15606426c7adSQu Wenruo /* 15616426c7adSQu Wenruo * Now we do a simplified commit transaction, which will: 15626426c7adSQu Wenruo * 1) commit all subvolume and extent tree 15636426c7adSQu Wenruo * To ensure all subvolume and extent tree have a valid 15646426c7adSQu Wenruo * commit_root to accounting later insert_dir_item() 15656426c7adSQu Wenruo * 2) write all btree blocks onto disk 15666426c7adSQu Wenruo * This is to make sure later btree modification will be cowed 15676426c7adSQu Wenruo * Or commit_root can be populated and cause wrong qgroup numbers 15686426c7adSQu Wenruo * In this simplified commit, we don't really care about other trees 15696426c7adSQu Wenruo * like chunk and root tree, as they won't affect qgroup. 15706426c7adSQu Wenruo * And we don't write super to avoid half committed status. 15716426c7adSQu Wenruo */ 15729386d8bcSNikolay Borisov ret = commit_cowonly_roots(trans); 15736426c7adSQu Wenruo if (ret) 15746426c7adSQu Wenruo goto out; 1575889bfa39SJosef Bacik switch_commit_roots(trans); 157670458a58SNikolay Borisov ret = btrfs_write_and_wait_transaction(trans); 15776426c7adSQu Wenruo if (ret) 1578f7af3934SDavid Sterba btrfs_handle_fs_error(fs_info, ret, 15796426c7adSQu Wenruo "Error while writing out transaction for qgroup"); 15806426c7adSQu Wenruo 15816426c7adSQu Wenruo out: 15826426c7adSQu Wenruo /* 15836426c7adSQu Wenruo * Force parent root to be updated, as we recorded it before so its 15846426c7adSQu Wenruo * last_trans == cur_transid. 15856426c7adSQu Wenruo * Or it won't be committed again onto disk after later 15866426c7adSQu Wenruo * insert_dir_item() 15876426c7adSQu Wenruo */ 15886426c7adSQu Wenruo if (!ret) 15891c442d22SJosef Bacik ret = record_root_in_trans(trans, parent, 1); 15906426c7adSQu Wenruo return ret; 15916426c7adSQu Wenruo } 15926426c7adSQu Wenruo 15936426c7adSQu Wenruo /* 1594d352ac68SChris Mason * new snapshots need to be created at a very specific time in the 1595aec8030aSMiao Xie * transaction commit. This does the actual creation. 1596aec8030aSMiao Xie * 1597aec8030aSMiao Xie * Note: 1598aec8030aSMiao Xie * If the error which may affect the commitment of the current transaction 1599aec8030aSMiao Xie * happens, we should return the error number. If the error which just affect 1600aec8030aSMiao Xie * the creation of the pending snapshots, just return 0. 1601d352ac68SChris Mason */ 160280b6794dSChris Mason static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans, 16033063d29fSChris Mason struct btrfs_pending_snapshot *pending) 16043063d29fSChris Mason { 160508d50ca3SNikolay Borisov 160608d50ca3SNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 16073063d29fSChris Mason struct btrfs_key key; 160880b6794dSChris Mason struct btrfs_root_item *new_root_item; 16093063d29fSChris Mason struct btrfs_root *tree_root = fs_info->tree_root; 16103063d29fSChris Mason struct btrfs_root *root = pending->root; 16116bdb72deSSage Weil struct btrfs_root *parent_root; 161298c9942aSLiu Bo struct btrfs_block_rsv *rsv; 16136bdb72deSSage Weil struct inode *parent_inode; 161442874b3dSMiao Xie struct btrfs_path *path; 161542874b3dSMiao Xie struct btrfs_dir_item *dir_item; 1616a22285a6SYan, Zheng struct dentry *dentry; 16173063d29fSChris Mason struct extent_buffer *tmp; 1618925baeddSChris Mason struct extent_buffer *old; 161995582b00SDeepa Dinamani struct timespec64 cur_time; 1620aec8030aSMiao Xie int ret = 0; 1621d68fc57bSYan, Zheng u64 to_reserve = 0; 16226bdb72deSSage Weil u64 index = 0; 1623a22285a6SYan, Zheng u64 objectid; 1624b83cc969SLi Zefan u64 root_flags; 16253063d29fSChris Mason 16268546b570SDavid Sterba ASSERT(pending->path); 16278546b570SDavid Sterba path = pending->path; 162842874b3dSMiao Xie 1629b0c0ea63SDavid Sterba ASSERT(pending->root_item); 1630b0c0ea63SDavid Sterba new_root_item = pending->root_item; 1631a22285a6SYan, Zheng 1632543068a2SNikolay Borisov pending->error = btrfs_get_free_objectid(tree_root, &objectid); 1633aec8030aSMiao Xie if (pending->error) 16346fa9700eSMiao Xie goto no_free_objectid; 16353063d29fSChris Mason 1636d6726335SQu Wenruo /* 1637d6726335SQu Wenruo * Make qgroup to skip current new snapshot's qgroupid, as it is 1638d6726335SQu Wenruo * accounted by later btrfs_qgroup_inherit(). 1639d6726335SQu Wenruo */ 1640d6726335SQu Wenruo btrfs_set_skip_qgroup(trans, objectid); 1641d6726335SQu Wenruo 1642147d256eSZhaolei btrfs_reloc_pre_snapshot(pending, &to_reserve); 1643d68fc57bSYan, Zheng 1644d68fc57bSYan, Zheng if (to_reserve > 0) { 16459270501cSJosef Bacik pending->error = btrfs_block_rsv_add(fs_info, 1646aec8030aSMiao Xie &pending->block_rsv, 164708e007d2SMiao Xie to_reserve, 164808e007d2SMiao Xie BTRFS_RESERVE_NO_FLUSH); 1649aec8030aSMiao Xie if (pending->error) 1650d6726335SQu Wenruo goto clear_skip_qgroup; 1651d68fc57bSYan, Zheng } 1652d68fc57bSYan, Zheng 16533063d29fSChris Mason key.objectid = objectid; 1654a22285a6SYan, Zheng key.offset = (u64)-1; 1655a22285a6SYan, Zheng key.type = BTRFS_ROOT_ITEM_KEY; 16563063d29fSChris Mason 16576fa9700eSMiao Xie rsv = trans->block_rsv; 1658a22285a6SYan, Zheng trans->block_rsv = &pending->block_rsv; 16592382c5ccSLiu Bo trans->bytes_reserved = trans->block_rsv->reserved; 16600b246afaSJeff Mahoney trace_btrfs_space_reservation(fs_info, "transaction", 166188d3a5aaSJosef Bacik trans->transid, 166288d3a5aaSJosef Bacik trans->bytes_reserved, 1); 1663a22285a6SYan, Zheng dentry = pending->dentry; 1664e9662f70SMiao Xie parent_inode = pending->dir; 1665a22285a6SYan, Zheng parent_root = BTRFS_I(parent_inode)->root; 1666f0118cb6SJosef Bacik ret = record_root_in_trans(trans, parent_root, 0); 1667f0118cb6SJosef Bacik if (ret) 1668f0118cb6SJosef Bacik goto fail; 1669c2050a45SDeepa Dinamani cur_time = current_time(parent_inode); 167004b285f3SDeepa Dinamani 16716bdb72deSSage Weil /* 16726bdb72deSSage Weil * insert the directory item 16736bdb72deSSage Weil */ 1674877574e2SNikolay Borisov ret = btrfs_set_inode_index(BTRFS_I(parent_inode), &index); 167549b25e05SJeff Mahoney BUG_ON(ret); /* -ENOMEM */ 167642874b3dSMiao Xie 167742874b3dSMiao Xie /* check if there is a file/dir which has the same name. */ 167842874b3dSMiao Xie dir_item = btrfs_lookup_dir_item(NULL, parent_root, path, 16794a0cc7caSNikolay Borisov btrfs_ino(BTRFS_I(parent_inode)), 168042874b3dSMiao Xie dentry->d_name.name, 168142874b3dSMiao Xie dentry->d_name.len, 0); 168242874b3dSMiao Xie if (dir_item != NULL && !IS_ERR(dir_item)) { 1683fe66a05aSChris Mason pending->error = -EEXIST; 1684aec8030aSMiao Xie goto dir_item_existed; 168542874b3dSMiao Xie } else if (IS_ERR(dir_item)) { 168642874b3dSMiao Xie ret = PTR_ERR(dir_item); 168766642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 16888732d44fSMiao Xie goto fail; 168979787eaaSJeff Mahoney } 169042874b3dSMiao Xie btrfs_release_path(path); 16916bdb72deSSage Weil 1692e999376fSChris Mason /* 1693e999376fSChris Mason * pull in the delayed directory update 1694e999376fSChris Mason * and the delayed inode item 1695e999376fSChris Mason * otherwise we corrupt the FS during 1696e999376fSChris Mason * snapshot 1697e999376fSChris Mason */ 1698e5c304e6SNikolay Borisov ret = btrfs_run_delayed_items(trans); 16998732d44fSMiao Xie if (ret) { /* Transaction aborted */ 170066642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 17018732d44fSMiao Xie goto fail; 17028732d44fSMiao Xie } 1703e999376fSChris Mason 1704f0118cb6SJosef Bacik ret = record_root_in_trans(trans, root, 0); 1705f0118cb6SJosef Bacik if (ret) { 1706f0118cb6SJosef Bacik btrfs_abort_transaction(trans, ret); 1707f0118cb6SJosef Bacik goto fail; 1708f0118cb6SJosef Bacik } 17096bdb72deSSage Weil btrfs_set_root_last_snapshot(&root->root_item, trans->transid); 17106bdb72deSSage Weil memcpy(new_root_item, &root->root_item, sizeof(*new_root_item)); 171108fe4db1SLi Zefan btrfs_check_and_init_root_item(new_root_item); 17126bdb72deSSage Weil 1713b83cc969SLi Zefan root_flags = btrfs_root_flags(new_root_item); 1714b83cc969SLi Zefan if (pending->readonly) 1715b83cc969SLi Zefan root_flags |= BTRFS_ROOT_SUBVOL_RDONLY; 1716b83cc969SLi Zefan else 1717b83cc969SLi Zefan root_flags &= ~BTRFS_ROOT_SUBVOL_RDONLY; 1718b83cc969SLi Zefan btrfs_set_root_flags(new_root_item, root_flags); 1719b83cc969SLi Zefan 17208ea05e3aSAlexander Block btrfs_set_root_generation_v2(new_root_item, 17218ea05e3aSAlexander Block trans->transid); 1722807fc790SAndy Shevchenko generate_random_guid(new_root_item->uuid); 17238ea05e3aSAlexander Block memcpy(new_root_item->parent_uuid, root->root_item.uuid, 17248ea05e3aSAlexander Block BTRFS_UUID_SIZE); 172570023da2SStefan Behrens if (!(root_flags & BTRFS_ROOT_SUBVOL_RDONLY)) { 172670023da2SStefan Behrens memset(new_root_item->received_uuid, 0, 172770023da2SStefan Behrens sizeof(new_root_item->received_uuid)); 17288ea05e3aSAlexander Block memset(&new_root_item->stime, 0, sizeof(new_root_item->stime)); 17298ea05e3aSAlexander Block memset(&new_root_item->rtime, 0, sizeof(new_root_item->rtime)); 17308ea05e3aSAlexander Block btrfs_set_root_stransid(new_root_item, 0); 17318ea05e3aSAlexander Block btrfs_set_root_rtransid(new_root_item, 0); 173270023da2SStefan Behrens } 17333cae210fSQu Wenruo btrfs_set_stack_timespec_sec(&new_root_item->otime, cur_time.tv_sec); 17343cae210fSQu Wenruo btrfs_set_stack_timespec_nsec(&new_root_item->otime, cur_time.tv_nsec); 173570023da2SStefan Behrens btrfs_set_root_otransid(new_root_item, trans->transid); 17368ea05e3aSAlexander Block 1737925baeddSChris Mason old = btrfs_lock_root_node(root); 17389631e4ccSJosef Bacik ret = btrfs_cow_block(trans, root, old, NULL, 0, &old, 17399631e4ccSJosef Bacik BTRFS_NESTING_COW); 174079787eaaSJeff Mahoney if (ret) { 174179787eaaSJeff Mahoney btrfs_tree_unlock(old); 174279787eaaSJeff Mahoney free_extent_buffer(old); 174366642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 17448732d44fSMiao Xie goto fail; 174579787eaaSJeff Mahoney } 174649b25e05SJeff Mahoney 174749b25e05SJeff Mahoney ret = btrfs_copy_root(trans, root, old, &tmp, objectid); 174879787eaaSJeff Mahoney /* clean up in any case */ 1749925baeddSChris Mason btrfs_tree_unlock(old); 1750925baeddSChris Mason free_extent_buffer(old); 17518732d44fSMiao Xie if (ret) { 175266642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 17538732d44fSMiao Xie goto fail; 17548732d44fSMiao Xie } 1755f1ebcc74SLiu Bo /* see comments in should_cow_block() */ 175627cdeb70SMiao Xie set_bit(BTRFS_ROOT_FORCE_COW, &root->state); 1757f1ebcc74SLiu Bo smp_wmb(); 1758f1ebcc74SLiu Bo 17595d4f98a2SYan Zheng btrfs_set_root_node(new_root_item, tmp); 1760a22285a6SYan, Zheng /* record when the snapshot was created in key.offset */ 1761a22285a6SYan, Zheng key.offset = trans->transid; 1762a22285a6SYan, Zheng ret = btrfs_insert_root(trans, tree_root, &key, new_root_item); 1763925baeddSChris Mason btrfs_tree_unlock(tmp); 17643063d29fSChris Mason free_extent_buffer(tmp); 17658732d44fSMiao Xie if (ret) { 176666642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 17678732d44fSMiao Xie goto fail; 17688732d44fSMiao Xie } 17690660b5afSChris Mason 1770a22285a6SYan, Zheng /* 1771a22285a6SYan, Zheng * insert root back/forward references 1772a22285a6SYan, Zheng */ 17736025c19fSLu Fengqi ret = btrfs_add_root_ref(trans, objectid, 1774a22285a6SYan, Zheng parent_root->root_key.objectid, 17754a0cc7caSNikolay Borisov btrfs_ino(BTRFS_I(parent_inode)), index, 1776a22285a6SYan, Zheng dentry->d_name.name, dentry->d_name.len); 17778732d44fSMiao Xie if (ret) { 177866642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 17798732d44fSMiao Xie goto fail; 17808732d44fSMiao Xie } 1781a22285a6SYan, Zheng 1782a22285a6SYan, Zheng key.offset = (u64)-1; 17832dfb1e43SQu Wenruo pending->snap = btrfs_get_new_fs_root(fs_info, objectid, pending->anon_dev); 178479787eaaSJeff Mahoney if (IS_ERR(pending->snap)) { 178579787eaaSJeff Mahoney ret = PTR_ERR(pending->snap); 17862d892ccdSFilipe Manana pending->snap = NULL; 178766642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 17888732d44fSMiao Xie goto fail; 178979787eaaSJeff Mahoney } 1790d68fc57bSYan, Zheng 179149b25e05SJeff Mahoney ret = btrfs_reloc_post_snapshot(trans, pending); 17928732d44fSMiao Xie if (ret) { 179366642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 17948732d44fSMiao Xie goto fail; 17958732d44fSMiao Xie } 1796361048f5SMiao Xie 17976426c7adSQu Wenruo /* 17986426c7adSQu Wenruo * Do special qgroup accounting for snapshot, as we do some qgroup 17996426c7adSQu Wenruo * snapshot hack to do fast snapshot. 18006426c7adSQu Wenruo * To co-operate with that hack, we do hack again. 18016426c7adSQu Wenruo * Or snapshot will be greatly slowed down by a subtree qgroup rescan 18026426c7adSQu Wenruo */ 18036426c7adSQu Wenruo ret = qgroup_account_snapshot(trans, root, parent_root, 18046426c7adSQu Wenruo pending->inherit, objectid); 18056426c7adSQu Wenruo if (ret < 0) 18066426c7adSQu Wenruo goto fail; 18076426c7adSQu Wenruo 1808684572dfSLu Fengqi ret = btrfs_insert_dir_item(trans, dentry->d_name.name, 1809684572dfSLu Fengqi dentry->d_name.len, BTRFS_I(parent_inode), 1810684572dfSLu Fengqi &key, BTRFS_FT_DIR, index); 181142874b3dSMiao Xie /* We have check then name at the beginning, so it is impossible. */ 18129c52057cSChris Mason BUG_ON(ret == -EEXIST || ret == -EOVERFLOW); 18138732d44fSMiao Xie if (ret) { 181466642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 18158732d44fSMiao Xie goto fail; 18168732d44fSMiao Xie } 181742874b3dSMiao Xie 18186ef06d27SNikolay Borisov btrfs_i_size_write(BTRFS_I(parent_inode), parent_inode->i_size + 181942874b3dSMiao Xie dentry->d_name.len * 2); 1820c1867eb3SDavid Sterba parent_inode->i_mtime = current_time(parent_inode); 1821c1867eb3SDavid Sterba parent_inode->i_ctime = parent_inode->i_mtime; 1822729f7961SNikolay Borisov ret = btrfs_update_inode_fallback(trans, parent_root, BTRFS_I(parent_inode)); 1823dd5f9615SStefan Behrens if (ret) { 182466642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 1825dd5f9615SStefan Behrens goto fail; 1826dd5f9615SStefan Behrens } 1827807fc790SAndy Shevchenko ret = btrfs_uuid_tree_add(trans, new_root_item->uuid, 1828807fc790SAndy Shevchenko BTRFS_UUID_KEY_SUBVOL, 1829cdb345a8SLu Fengqi objectid); 1830dd5f9615SStefan Behrens if (ret) { 183166642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 1832dd5f9615SStefan Behrens goto fail; 1833dd5f9615SStefan Behrens } 1834dd5f9615SStefan Behrens if (!btrfs_is_empty_uuid(new_root_item->received_uuid)) { 1835cdb345a8SLu Fengqi ret = btrfs_uuid_tree_add(trans, new_root_item->received_uuid, 1836dd5f9615SStefan Behrens BTRFS_UUID_KEY_RECEIVED_SUBVOL, 1837dd5f9615SStefan Behrens objectid); 1838dd5f9615SStefan Behrens if (ret && ret != -EEXIST) { 183966642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 1840dd5f9615SStefan Behrens goto fail; 1841dd5f9615SStefan Behrens } 1842dd5f9615SStefan Behrens } 1843d6726335SQu Wenruo 18443063d29fSChris Mason fail: 1845aec8030aSMiao Xie pending->error = ret; 1846aec8030aSMiao Xie dir_item_existed: 184798c9942aSLiu Bo trans->block_rsv = rsv; 18482382c5ccSLiu Bo trans->bytes_reserved = 0; 1849d6726335SQu Wenruo clear_skip_qgroup: 1850d6726335SQu Wenruo btrfs_clear_skip_qgroup(trans); 18516fa9700eSMiao Xie no_free_objectid: 18526fa9700eSMiao Xie kfree(new_root_item); 1853b0c0ea63SDavid Sterba pending->root_item = NULL; 185442874b3dSMiao Xie btrfs_free_path(path); 18558546b570SDavid Sterba pending->path = NULL; 18568546b570SDavid Sterba 185749b25e05SJeff Mahoney return ret; 18583063d29fSChris Mason } 18593063d29fSChris Mason 1860d352ac68SChris Mason /* 1861d352ac68SChris Mason * create all the snapshots we've scheduled for creation 1862d352ac68SChris Mason */ 186308d50ca3SNikolay Borisov static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans) 18643063d29fSChris Mason { 1865aec8030aSMiao Xie struct btrfs_pending_snapshot *pending, *next; 18663063d29fSChris Mason struct list_head *head = &trans->transaction->pending_snapshots; 1867aec8030aSMiao Xie int ret = 0; 18683de4586cSChris Mason 1869aec8030aSMiao Xie list_for_each_entry_safe(pending, next, head, list) { 1870aec8030aSMiao Xie list_del(&pending->list); 187108d50ca3SNikolay Borisov ret = create_pending_snapshot(trans, pending); 1872aec8030aSMiao Xie if (ret) 1873aec8030aSMiao Xie break; 1874aec8030aSMiao Xie } 1875aec8030aSMiao Xie return ret; 18763de4586cSChris Mason } 18773de4586cSChris Mason 18782ff7e61eSJeff Mahoney static void update_super_roots(struct btrfs_fs_info *fs_info) 18795d4f98a2SYan Zheng { 18805d4f98a2SYan Zheng struct btrfs_root_item *root_item; 18815d4f98a2SYan Zheng struct btrfs_super_block *super; 18825d4f98a2SYan Zheng 18830b246afaSJeff Mahoney super = fs_info->super_copy; 18845d4f98a2SYan Zheng 18850b246afaSJeff Mahoney root_item = &fs_info->chunk_root->root_item; 1886093e037cSDavid Sterba super->chunk_root = root_item->bytenr; 1887093e037cSDavid Sterba super->chunk_root_generation = root_item->generation; 1888093e037cSDavid Sterba super->chunk_root_level = root_item->level; 18895d4f98a2SYan Zheng 18900b246afaSJeff Mahoney root_item = &fs_info->tree_root->root_item; 1891093e037cSDavid Sterba super->root = root_item->bytenr; 1892093e037cSDavid Sterba super->generation = root_item->generation; 1893093e037cSDavid Sterba super->root_level = root_item->level; 18940b246afaSJeff Mahoney if (btrfs_test_opt(fs_info, SPACE_CACHE)) 1895093e037cSDavid Sterba super->cache_generation = root_item->generation; 189694846229SBoris Burkov else if (test_bit(BTRFS_FS_CLEANUP_SPACE_CACHE_V1, &fs_info->flags)) 189794846229SBoris Burkov super->cache_generation = 0; 18980b246afaSJeff Mahoney if (test_bit(BTRFS_FS_UPDATE_UUID_TREE_GEN, &fs_info->flags)) 1899093e037cSDavid Sterba super->uuid_tree_generation = root_item->generation; 19005d4f98a2SYan Zheng } 19015d4f98a2SYan Zheng 1902f36f3042SChris Mason int btrfs_transaction_in_commit(struct btrfs_fs_info *info) 1903f36f3042SChris Mason { 19044a9d8bdeSMiao Xie struct btrfs_transaction *trans; 1905f36f3042SChris Mason int ret = 0; 19064a9d8bdeSMiao Xie 1907a4abeea4SJosef Bacik spin_lock(&info->trans_lock); 19084a9d8bdeSMiao Xie trans = info->running_transaction; 19094a9d8bdeSMiao Xie if (trans) 19104a9d8bdeSMiao Xie ret = (trans->state >= TRANS_STATE_COMMIT_START); 1911a4abeea4SJosef Bacik spin_unlock(&info->trans_lock); 1912f36f3042SChris Mason return ret; 1913f36f3042SChris Mason } 1914f36f3042SChris Mason 19158929ecfaSYan, Zheng int btrfs_transaction_blocked(struct btrfs_fs_info *info) 19168929ecfaSYan, Zheng { 19174a9d8bdeSMiao Xie struct btrfs_transaction *trans; 19188929ecfaSYan, Zheng int ret = 0; 19194a9d8bdeSMiao Xie 1920a4abeea4SJosef Bacik spin_lock(&info->trans_lock); 19214a9d8bdeSMiao Xie trans = info->running_transaction; 19224a9d8bdeSMiao Xie if (trans) 19234a9d8bdeSMiao Xie ret = is_transaction_blocked(trans); 1924a4abeea4SJosef Bacik spin_unlock(&info->trans_lock); 19258929ecfaSYan, Zheng return ret; 19268929ecfaSYan, Zheng } 19278929ecfaSYan, Zheng 1928fdfbf020SJosef Bacik void btrfs_commit_transaction_async(struct btrfs_trans_handle *trans) 1929bb9c12c9SSage Weil { 19303a45bb20SJeff Mahoney struct btrfs_fs_info *fs_info = trans->fs_info; 1931bb9c12c9SSage Weil struct btrfs_transaction *cur_trans; 1932bb9c12c9SSage Weil 1933fdfbf020SJosef Bacik /* Kick the transaction kthread. */ 1934fdfbf020SJosef Bacik set_bit(BTRFS_FS_COMMIT_TRANS, &fs_info->flags); 1935fdfbf020SJosef Bacik wake_up_process(fs_info->transaction_kthread); 1936bb9c12c9SSage Weil 1937bb9c12c9SSage Weil /* take transaction reference */ 1938bb9c12c9SSage Weil cur_trans = trans->transaction; 19399b64f57dSElena Reshetova refcount_inc(&cur_trans->use_count); 1940bb9c12c9SSage Weil 19413a45bb20SJeff Mahoney btrfs_end_transaction(trans); 19426fc4e354SSage Weil 19436fc4e354SSage Weil /* 1944ae5d29d4SDavid Sterba * Wait for the current transaction commit to start and block 1945ae5d29d4SDavid Sterba * subsequent transaction joins 1946ae5d29d4SDavid Sterba */ 19473e738c53SIoannis Angelakopoulos btrfs_might_wait_for_state(fs_info, BTRFS_LOCKDEP_TRANS_COMMIT_START); 1948ae5d29d4SDavid Sterba wait_event(fs_info->transaction_blocked_wait, 1949ae5d29d4SDavid Sterba cur_trans->state >= TRANS_STATE_COMMIT_START || 1950ae5d29d4SDavid Sterba TRANS_ABORTED(cur_trans)); 1951724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 1952bb9c12c9SSage Weil } 1953bb9c12c9SSage Weil 195497cb39bbSNikolay Borisov static void cleanup_transaction(struct btrfs_trans_handle *trans, int err) 195549b25e05SJeff Mahoney { 195697cb39bbSNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 195749b25e05SJeff Mahoney struct btrfs_transaction *cur_trans = trans->transaction; 195849b25e05SJeff Mahoney 1959b50fff81SDavid Sterba WARN_ON(refcount_read(&trans->use_count) > 1); 196049b25e05SJeff Mahoney 196166642832SJeff Mahoney btrfs_abort_transaction(trans, err); 19627b8b92afSJosef Bacik 19630b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 196466b6135bSLiu Bo 196525d8c284SMiao Xie /* 196625d8c284SMiao Xie * If the transaction is removed from the list, it means this 196725d8c284SMiao Xie * transaction has been committed successfully, so it is impossible 196825d8c284SMiao Xie * to call the cleanup function. 196925d8c284SMiao Xie */ 197025d8c284SMiao Xie BUG_ON(list_empty(&cur_trans->list)); 197166b6135bSLiu Bo 19720b246afaSJeff Mahoney if (cur_trans == fs_info->running_transaction) { 19734a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_COMMIT_DOING; 19740b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 1975e1489b4fSIoannis Angelakopoulos 1976e1489b4fSIoannis Angelakopoulos /* 1977e1489b4fSIoannis Angelakopoulos * The thread has already released the lockdep map as reader 1978e1489b4fSIoannis Angelakopoulos * already in btrfs_commit_transaction(). 1979e1489b4fSIoannis Angelakopoulos */ 1980e1489b4fSIoannis Angelakopoulos btrfs_might_wait_for_event(fs_info, btrfs_trans_num_writers); 1981f094ac32SLiu Bo wait_event(cur_trans->writer_wait, 1982f094ac32SLiu Bo atomic_read(&cur_trans->num_writers) == 1); 1983f094ac32SLiu Bo 19840b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 1985d7096fc3SJosef Bacik } 1986061dde82SFilipe Manana 1987061dde82SFilipe Manana /* 1988061dde82SFilipe Manana * Now that we know no one else is still using the transaction we can 1989061dde82SFilipe Manana * remove the transaction from the list of transactions. This avoids 1990061dde82SFilipe Manana * the transaction kthread from cleaning up the transaction while some 1991061dde82SFilipe Manana * other task is still using it, which could result in a use-after-free 1992061dde82SFilipe Manana * on things like log trees, as it forces the transaction kthread to 1993061dde82SFilipe Manana * wait for this transaction to be cleaned up by us. 1994061dde82SFilipe Manana */ 1995061dde82SFilipe Manana list_del_init(&cur_trans->list); 1996061dde82SFilipe Manana 19970b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 199849b25e05SJeff Mahoney 19992ff7e61eSJeff Mahoney btrfs_cleanup_one_transaction(trans->transaction, fs_info); 200049b25e05SJeff Mahoney 20010b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 20020b246afaSJeff Mahoney if (cur_trans == fs_info->running_transaction) 20030b246afaSJeff Mahoney fs_info->running_transaction = NULL; 20040b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 20054a9d8bdeSMiao Xie 2006e0228285SJosef Bacik if (trans->type & __TRANS_FREEZABLE) 20070b246afaSJeff Mahoney sb_end_intwrite(fs_info->sb); 2008724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 2009724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 201049b25e05SJeff Mahoney 20112e4e97abSJosef Bacik trace_btrfs_transaction_commit(fs_info); 201249b25e05SJeff Mahoney 201349b25e05SJeff Mahoney if (current->journal_info == trans) 201449b25e05SJeff Mahoney current->journal_info = NULL; 20150b246afaSJeff Mahoney btrfs_scrub_cancel(fs_info); 201649b25e05SJeff Mahoney 201749b25e05SJeff Mahoney kmem_cache_free(btrfs_trans_handle_cachep, trans); 201849b25e05SJeff Mahoney } 201949b25e05SJeff Mahoney 2020c7cc64a9SDavid Sterba /* 2021c7cc64a9SDavid Sterba * Release reserved delayed ref space of all pending block groups of the 2022c7cc64a9SDavid Sterba * transaction and remove them from the list 2023c7cc64a9SDavid Sterba */ 2024c7cc64a9SDavid Sterba static void btrfs_cleanup_pending_block_groups(struct btrfs_trans_handle *trans) 2025c7cc64a9SDavid Sterba { 2026c7cc64a9SDavid Sterba struct btrfs_fs_info *fs_info = trans->fs_info; 202732da5386SDavid Sterba struct btrfs_block_group *block_group, *tmp; 2028c7cc64a9SDavid Sterba 2029c7cc64a9SDavid Sterba list_for_each_entry_safe(block_group, tmp, &trans->new_bgs, bg_list) { 2030c7cc64a9SDavid Sterba btrfs_delayed_refs_rsv_release(fs_info, 1); 2031c7cc64a9SDavid Sterba list_del_init(&block_group->bg_list); 2032c7cc64a9SDavid Sterba } 2033c7cc64a9SDavid Sterba } 2034c7cc64a9SDavid Sterba 203588090ad3SFilipe Manana static inline int btrfs_start_delalloc_flush(struct btrfs_fs_info *fs_info) 203682436617SMiao Xie { 2037ce8ea7ccSJosef Bacik /* 2038a0f0cf83SFilipe Manana * We use try_to_writeback_inodes_sb() here because if we used 2039ce8ea7ccSJosef Bacik * btrfs_start_delalloc_roots we would deadlock with fs freeze. 2040ce8ea7ccSJosef Bacik * Currently are holding the fs freeze lock, if we do an async flush 2041ce8ea7ccSJosef Bacik * we'll do btrfs_join_transaction() and deadlock because we need to 2042ce8ea7ccSJosef Bacik * wait for the fs freeze lock. Using the direct flushing we benefit 2043ce8ea7ccSJosef Bacik * from already being in a transaction and our join_transaction doesn't 2044ce8ea7ccSJosef Bacik * have to re-take the fs freeze lock. 2045a0f0cf83SFilipe Manana * 2046a0f0cf83SFilipe Manana * Note that try_to_writeback_inodes_sb() will only trigger writeback 2047a0f0cf83SFilipe Manana * if it can read lock sb->s_umount. It will always be able to lock it, 2048a0f0cf83SFilipe Manana * except when the filesystem is being unmounted or being frozen, but in 2049a0f0cf83SFilipe Manana * those cases sync_filesystem() is called, which results in calling 2050a0f0cf83SFilipe Manana * writeback_inodes_sb() while holding a write lock on sb->s_umount. 2051a0f0cf83SFilipe Manana * Note that we don't call writeback_inodes_sb() directly, because it 2052a0f0cf83SFilipe Manana * will emit a warning if sb->s_umount is not locked. 2053ce8ea7ccSJosef Bacik */ 205488090ad3SFilipe Manana if (btrfs_test_opt(fs_info, FLUSHONCOMMIT)) 2055a0f0cf83SFilipe Manana try_to_writeback_inodes_sb(fs_info->sb, WB_REASON_SYNC); 205682436617SMiao Xie return 0; 205782436617SMiao Xie } 205882436617SMiao Xie 205988090ad3SFilipe Manana static inline void btrfs_wait_delalloc_flush(struct btrfs_fs_info *fs_info) 206082436617SMiao Xie { 206188090ad3SFilipe Manana if (btrfs_test_opt(fs_info, FLUSHONCOMMIT)) 20626374e57aSChris Mason btrfs_wait_ordered_roots(fs_info, U64_MAX, 0, (u64)-1); 206382436617SMiao Xie } 206482436617SMiao Xie 206528b21c55SFilipe Manana /* 206628b21c55SFilipe Manana * Add a pending snapshot associated with the given transaction handle to the 206728b21c55SFilipe Manana * respective handle. This must be called after the transaction commit started 206828b21c55SFilipe Manana * and while holding fs_info->trans_lock. 206928b21c55SFilipe Manana * This serves to guarantee a caller of btrfs_commit_transaction() that it can 207028b21c55SFilipe Manana * safely free the pending snapshot pointer in case btrfs_commit_transaction() 207128b21c55SFilipe Manana * returns an error. 207228b21c55SFilipe Manana */ 207328b21c55SFilipe Manana static void add_pending_snapshot(struct btrfs_trans_handle *trans) 207428b21c55SFilipe Manana { 207528b21c55SFilipe Manana struct btrfs_transaction *cur_trans = trans->transaction; 207628b21c55SFilipe Manana 207728b21c55SFilipe Manana if (!trans->pending_snapshot) 207828b21c55SFilipe Manana return; 207928b21c55SFilipe Manana 208028b21c55SFilipe Manana lockdep_assert_held(&trans->fs_info->trans_lock); 208128b21c55SFilipe Manana ASSERT(cur_trans->state >= TRANS_STATE_COMMIT_START); 208228b21c55SFilipe Manana 208328b21c55SFilipe Manana list_add(&trans->pending_snapshot->list, &cur_trans->pending_snapshots); 208428b21c55SFilipe Manana } 208528b21c55SFilipe Manana 2086e55958c8SIoannis Angelakopoulos static void update_commit_stats(struct btrfs_fs_info *fs_info, ktime_t interval) 2087e55958c8SIoannis Angelakopoulos { 2088e55958c8SIoannis Angelakopoulos fs_info->commit_stats.commit_count++; 2089e55958c8SIoannis Angelakopoulos fs_info->commit_stats.last_commit_dur = interval; 2090e55958c8SIoannis Angelakopoulos fs_info->commit_stats.max_commit_dur = 2091e55958c8SIoannis Angelakopoulos max_t(u64, fs_info->commit_stats.max_commit_dur, interval); 2092e55958c8SIoannis Angelakopoulos fs_info->commit_stats.total_commit_dur += interval; 2093e55958c8SIoannis Angelakopoulos } 2094e55958c8SIoannis Angelakopoulos 20953a45bb20SJeff Mahoney int btrfs_commit_transaction(struct btrfs_trans_handle *trans) 209679154b1bSChris Mason { 20973a45bb20SJeff Mahoney struct btrfs_fs_info *fs_info = trans->fs_info; 209849b25e05SJeff Mahoney struct btrfs_transaction *cur_trans = trans->transaction; 20998fd17795SChris Mason struct btrfs_transaction *prev_trans = NULL; 210025287e0aSMiao Xie int ret; 2101e55958c8SIoannis Angelakopoulos ktime_t start_time; 2102e55958c8SIoannis Angelakopoulos ktime_t interval; 210379154b1bSChris Mason 210435b814f3SNikolay Borisov ASSERT(refcount_read(&trans->use_count) == 1); 21053e738c53SIoannis Angelakopoulos btrfs_trans_state_lockdep_acquire(fs_info, BTRFS_LOCKDEP_TRANS_COMMIT_START); 210635b814f3SNikolay Borisov 21078d25a086SMiao Xie /* Stop the commit early if ->aborted is set */ 2108bf31f87fSDavid Sterba if (TRANS_ABORTED(cur_trans)) { 210925287e0aSMiao Xie ret = cur_trans->aborted; 21103e738c53SIoannis Angelakopoulos goto lockdep_trans_commit_start_release; 211125287e0aSMiao Xie } 211249b25e05SJeff Mahoney 2113f45c752bSJosef Bacik btrfs_trans_release_metadata(trans); 2114f45c752bSJosef Bacik trans->block_rsv = NULL; 2115f45c752bSJosef Bacik 2116e19eb11fSJosef Bacik /* 2117e19eb11fSJosef Bacik * We only want one transaction commit doing the flushing so we do not 2118e19eb11fSJosef Bacik * waste a bunch of time on lock contention on the extent root node. 2119e19eb11fSJosef Bacik */ 2120e19eb11fSJosef Bacik if (!test_and_set_bit(BTRFS_DELAYED_REFS_FLUSHING, 2121e19eb11fSJosef Bacik &cur_trans->delayed_refs.flags)) { 2122e19eb11fSJosef Bacik /* 2123e19eb11fSJosef Bacik * Make a pass through all the delayed refs we have so far. 2124e19eb11fSJosef Bacik * Any running threads may add more while we are here. 212556bec294SChris Mason */ 2126c79a70b1SNikolay Borisov ret = btrfs_run_delayed_refs(trans, 0); 21273e738c53SIoannis Angelakopoulos if (ret) 21283e738c53SIoannis Angelakopoulos goto lockdep_trans_commit_start_release; 2129e19eb11fSJosef Bacik } 213056bec294SChris Mason 21316c686b35SNikolay Borisov btrfs_create_pending_block_groups(trans); 2132ea658badSJosef Bacik 21333204d33cSJosef Bacik if (!test_bit(BTRFS_TRANS_DIRTY_BG_RUN, &cur_trans->flags)) { 21341bbc621eSChris Mason int run_it = 0; 21351bbc621eSChris Mason 21361bbc621eSChris Mason /* this mutex is also taken before trying to set 21371bbc621eSChris Mason * block groups readonly. We need to make sure 21381bbc621eSChris Mason * that nobody has set a block group readonly 21391bbc621eSChris Mason * after a extents from that block group have been 21401bbc621eSChris Mason * allocated for cache files. btrfs_set_block_group_ro 21411bbc621eSChris Mason * will wait for the transaction to commit if it 21423204d33cSJosef Bacik * finds BTRFS_TRANS_DIRTY_BG_RUN set. 21431bbc621eSChris Mason * 21443204d33cSJosef Bacik * The BTRFS_TRANS_DIRTY_BG_RUN flag is also used to make sure 21453204d33cSJosef Bacik * only one process starts all the block group IO. It wouldn't 21461bbc621eSChris Mason * hurt to have more than one go through, but there's no 21471bbc621eSChris Mason * real advantage to it either. 21481bbc621eSChris Mason */ 21490b246afaSJeff Mahoney mutex_lock(&fs_info->ro_block_group_mutex); 21503204d33cSJosef Bacik if (!test_and_set_bit(BTRFS_TRANS_DIRTY_BG_RUN, 21513204d33cSJosef Bacik &cur_trans->flags)) 21521bbc621eSChris Mason run_it = 1; 21530b246afaSJeff Mahoney mutex_unlock(&fs_info->ro_block_group_mutex); 21541bbc621eSChris Mason 2155f9cacae3SNikolay Borisov if (run_it) { 215621217054SNikolay Borisov ret = btrfs_start_dirty_block_groups(trans); 21573e738c53SIoannis Angelakopoulos if (ret) 21583e738c53SIoannis Angelakopoulos goto lockdep_trans_commit_start_release; 2159f9cacae3SNikolay Borisov } 2160f9cacae3SNikolay Borisov } 21611bbc621eSChris Mason 21620b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 21634a9d8bdeSMiao Xie if (cur_trans->state >= TRANS_STATE_COMMIT_START) { 2164d0c2f4faSFilipe Manana enum btrfs_trans_state want_state = TRANS_STATE_COMPLETED; 2165d0c2f4faSFilipe Manana 216628b21c55SFilipe Manana add_pending_snapshot(trans); 216728b21c55SFilipe Manana 21680b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 21699b64f57dSElena Reshetova refcount_inc(&cur_trans->use_count); 2170ccd467d6SChris Mason 2171d0c2f4faSFilipe Manana if (trans->in_fsync) 2172d0c2f4faSFilipe Manana want_state = TRANS_STATE_SUPER_COMMITTED; 21733e738c53SIoannis Angelakopoulos 21743e738c53SIoannis Angelakopoulos btrfs_trans_state_lockdep_release(fs_info, 21753e738c53SIoannis Angelakopoulos BTRFS_LOCKDEP_TRANS_COMMIT_START); 2176d0c2f4faSFilipe Manana ret = btrfs_end_transaction(trans); 2177d0c2f4faSFilipe Manana wait_for_commit(cur_trans, want_state); 217815ee9bc7SJosef Bacik 2179bf31f87fSDavid Sterba if (TRANS_ABORTED(cur_trans)) 2180b4924a0fSLiu Bo ret = cur_trans->aborted; 2181b4924a0fSLiu Bo 2182724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 218315ee9bc7SJosef Bacik 218449b25e05SJeff Mahoney return ret; 218579154b1bSChris Mason } 21864313b399SChris Mason 21874a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_COMMIT_START; 21880b246afaSJeff Mahoney wake_up(&fs_info->transaction_blocked_wait); 21893e738c53SIoannis Angelakopoulos btrfs_trans_state_lockdep_release(fs_info, BTRFS_LOCKDEP_TRANS_COMMIT_START); 2190bb9c12c9SSage Weil 21910b246afaSJeff Mahoney if (cur_trans->list.prev != &fs_info->trans_list) { 2192d0c2f4faSFilipe Manana enum btrfs_trans_state want_state = TRANS_STATE_COMPLETED; 2193d0c2f4faSFilipe Manana 2194d0c2f4faSFilipe Manana if (trans->in_fsync) 2195d0c2f4faSFilipe Manana want_state = TRANS_STATE_SUPER_COMMITTED; 2196d0c2f4faSFilipe Manana 2197ccd467d6SChris Mason prev_trans = list_entry(cur_trans->list.prev, 2198ccd467d6SChris Mason struct btrfs_transaction, list); 2199d0c2f4faSFilipe Manana if (prev_trans->state < want_state) { 22009b64f57dSElena Reshetova refcount_inc(&prev_trans->use_count); 22010b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 2202ccd467d6SChris Mason 2203d0c2f4faSFilipe Manana wait_for_commit(prev_trans, want_state); 2204d0c2f4faSFilipe Manana 2205bf31f87fSDavid Sterba ret = READ_ONCE(prev_trans->aborted); 2206ccd467d6SChris Mason 2207724e2315SJosef Bacik btrfs_put_transaction(prev_trans); 22081f9b8c8fSFilipe Manana if (ret) 2209e1489b4fSIoannis Angelakopoulos goto lockdep_release; 2210a4abeea4SJosef Bacik } else { 22110b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 2212ccd467d6SChris Mason } 2213a4abeea4SJosef Bacik } else { 22140b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 2215cb2d3dadSFilipe Manana /* 2216cb2d3dadSFilipe Manana * The previous transaction was aborted and was already removed 2217cb2d3dadSFilipe Manana * from the list of transactions at fs_info->trans_list. So we 2218cb2d3dadSFilipe Manana * abort to prevent writing a new superblock that reflects a 2219cb2d3dadSFilipe Manana * corrupt state (pointing to trees with unwritten nodes/leafs). 2220cb2d3dadSFilipe Manana */ 222184961539SJosef Bacik if (BTRFS_FS_ERROR(fs_info)) { 2222cb2d3dadSFilipe Manana ret = -EROFS; 2223e1489b4fSIoannis Angelakopoulos goto lockdep_release; 2224cb2d3dadSFilipe Manana } 2225ccd467d6SChris Mason } 222615ee9bc7SJosef Bacik 2227e55958c8SIoannis Angelakopoulos /* 2228e55958c8SIoannis Angelakopoulos * Get the time spent on the work done by the commit thread and not 2229e55958c8SIoannis Angelakopoulos * the time spent waiting on a previous commit 2230e55958c8SIoannis Angelakopoulos */ 2231e55958c8SIoannis Angelakopoulos start_time = ktime_get_ns(); 2232e55958c8SIoannis Angelakopoulos 22330860adfdSMiao Xie extwriter_counter_dec(cur_trans, trans->type); 22340860adfdSMiao Xie 223588090ad3SFilipe Manana ret = btrfs_start_delalloc_flush(fs_info); 223682436617SMiao Xie if (ret) 2237e1489b4fSIoannis Angelakopoulos goto lockdep_release; 223882436617SMiao Xie 2239e5c304e6SNikolay Borisov ret = btrfs_run_delayed_items(trans); 224049b25e05SJeff Mahoney if (ret) 2241e1489b4fSIoannis Angelakopoulos goto lockdep_release; 224216cdcec7SMiao Xie 22435a9ba670SIoannis Angelakopoulos /* 22445a9ba670SIoannis Angelakopoulos * The thread has started/joined the transaction thus it holds the 22455a9ba670SIoannis Angelakopoulos * lockdep map as a reader. It has to release it before acquiring the 22465a9ba670SIoannis Angelakopoulos * lockdep map as a writer. 22475a9ba670SIoannis Angelakopoulos */ 22485a9ba670SIoannis Angelakopoulos btrfs_lockdep_release(fs_info, btrfs_trans_num_extwriters); 22495a9ba670SIoannis Angelakopoulos btrfs_might_wait_for_event(fs_info, btrfs_trans_num_extwriters); 2250581227d0SMiao Xie wait_event(cur_trans->writer_wait, 2251581227d0SMiao Xie extwriter_counter_read(cur_trans) == 0); 2252ed3b3d31SChris Mason 2253581227d0SMiao Xie /* some pending stuffs might be added after the previous flush. */ 2254e5c304e6SNikolay Borisov ret = btrfs_run_delayed_items(trans); 2255e1489b4fSIoannis Angelakopoulos if (ret) { 2256e1489b4fSIoannis Angelakopoulos btrfs_lockdep_release(fs_info, btrfs_trans_num_writers); 2257ca469637SMiao Xie goto cleanup_transaction; 2258e1489b4fSIoannis Angelakopoulos } 2259ca469637SMiao Xie 226088090ad3SFilipe Manana btrfs_wait_delalloc_flush(fs_info); 2261cb7ab021SWang Shilong 226248778179SFilipe Manana /* 226348778179SFilipe Manana * Wait for all ordered extents started by a fast fsync that joined this 226448778179SFilipe Manana * transaction. Otherwise if this transaction commits before the ordered 226548778179SFilipe Manana * extents complete we lose logged data after a power failure. 226648778179SFilipe Manana */ 22678b53779eSIoannis Angelakopoulos btrfs_might_wait_for_event(fs_info, btrfs_trans_pending_ordered); 226848778179SFilipe Manana wait_event(cur_trans->pending_wait, 226948778179SFilipe Manana atomic_read(&cur_trans->pending_ordered) == 0); 227048778179SFilipe Manana 22712ff7e61eSJeff Mahoney btrfs_scrub_pause(fs_info); 2272ed0ca140SJosef Bacik /* 2273ed0ca140SJosef Bacik * Ok now we need to make sure to block out any other joins while we 2274ed0ca140SJosef Bacik * commit the transaction. We could have started a join before setting 22754a9d8bdeSMiao Xie * COMMIT_DOING so make sure to wait for num_writers to == 1 again. 2276ed0ca140SJosef Bacik */ 22770b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 227828b21c55SFilipe Manana add_pending_snapshot(trans); 22794a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_COMMIT_DOING; 22800b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 2281e1489b4fSIoannis Angelakopoulos 2282e1489b4fSIoannis Angelakopoulos /* 2283e1489b4fSIoannis Angelakopoulos * The thread has started/joined the transaction thus it holds the 2284e1489b4fSIoannis Angelakopoulos * lockdep map as a reader. It has to release it before acquiring the 2285e1489b4fSIoannis Angelakopoulos * lockdep map as a writer. 2286e1489b4fSIoannis Angelakopoulos */ 2287e1489b4fSIoannis Angelakopoulos btrfs_lockdep_release(fs_info, btrfs_trans_num_writers); 2288e1489b4fSIoannis Angelakopoulos btrfs_might_wait_for_event(fs_info, btrfs_trans_num_writers); 2289ed0ca140SJosef Bacik wait_event(cur_trans->writer_wait, 2290ed0ca140SJosef Bacik atomic_read(&cur_trans->num_writers) == 1); 229115ee9bc7SJosef Bacik 2292fdfbf020SJosef Bacik /* 22933e738c53SIoannis Angelakopoulos * Make lockdep happy by acquiring the state locks after 22943e738c53SIoannis Angelakopoulos * btrfs_trans_num_writers is released. If we acquired the state locks 22953e738c53SIoannis Angelakopoulos * before releasing the btrfs_trans_num_writers lock then lockdep would 22963e738c53SIoannis Angelakopoulos * complain because we did not follow the reverse order unlocking rule. 22973e738c53SIoannis Angelakopoulos */ 22983e738c53SIoannis Angelakopoulos btrfs_trans_state_lockdep_acquire(fs_info, BTRFS_LOCKDEP_TRANS_COMPLETED); 22993e738c53SIoannis Angelakopoulos btrfs_trans_state_lockdep_acquire(fs_info, BTRFS_LOCKDEP_TRANS_SUPER_COMMITTED); 23003e738c53SIoannis Angelakopoulos btrfs_trans_state_lockdep_acquire(fs_info, BTRFS_LOCKDEP_TRANS_UNBLOCKED); 23013e738c53SIoannis Angelakopoulos 23023e738c53SIoannis Angelakopoulos /* 2303fdfbf020SJosef Bacik * We've started the commit, clear the flag in case we were triggered to 2304fdfbf020SJosef Bacik * do an async commit but somebody else started before the transaction 2305fdfbf020SJosef Bacik * kthread could do the work. 2306fdfbf020SJosef Bacik */ 2307fdfbf020SJosef Bacik clear_bit(BTRFS_FS_COMMIT_TRANS, &fs_info->flags); 2308fdfbf020SJosef Bacik 2309bf31f87fSDavid Sterba if (TRANS_ABORTED(cur_trans)) { 23102cba30f1SMiao Xie ret = cur_trans->aborted; 23113e738c53SIoannis Angelakopoulos btrfs_trans_state_lockdep_release(fs_info, BTRFS_LOCKDEP_TRANS_UNBLOCKED); 23126cf7f77eSWang Shilong goto scrub_continue; 23132cba30f1SMiao Xie } 23147585717fSChris Mason /* 23157585717fSChris Mason * the reloc mutex makes sure that we stop 23167585717fSChris Mason * the balancing code from coming in and moving 23177585717fSChris Mason * extents around in the middle of the commit 23187585717fSChris Mason */ 23190b246afaSJeff Mahoney mutex_lock(&fs_info->reloc_mutex); 23207585717fSChris Mason 232142874b3dSMiao Xie /* 232242874b3dSMiao Xie * We needn't worry about the delayed items because we will 232342874b3dSMiao Xie * deal with them in create_pending_snapshot(), which is the 232442874b3dSMiao Xie * core function of the snapshot creation. 232542874b3dSMiao Xie */ 232608d50ca3SNikolay Borisov ret = create_pending_snapshots(trans); 232756e9f6eaSDavid Sterba if (ret) 232856e9f6eaSDavid Sterba goto unlock_reloc; 23293063d29fSChris Mason 233042874b3dSMiao Xie /* 233142874b3dSMiao Xie * We insert the dir indexes of the snapshots and update the inode 233242874b3dSMiao Xie * of the snapshots' parents after the snapshot creation, so there 233342874b3dSMiao Xie * are some delayed items which are not dealt with. Now deal with 233442874b3dSMiao Xie * them. 233542874b3dSMiao Xie * 233642874b3dSMiao Xie * We needn't worry that this operation will corrupt the snapshots, 233742874b3dSMiao Xie * because all the tree which are snapshoted will be forced to COW 233842874b3dSMiao Xie * the nodes and leaves. 233942874b3dSMiao Xie */ 2340e5c304e6SNikolay Borisov ret = btrfs_run_delayed_items(trans); 234156e9f6eaSDavid Sterba if (ret) 234256e9f6eaSDavid Sterba goto unlock_reloc; 234316cdcec7SMiao Xie 2344c79a70b1SNikolay Borisov ret = btrfs_run_delayed_refs(trans, (unsigned long)-1); 234556e9f6eaSDavid Sterba if (ret) 234656e9f6eaSDavid Sterba goto unlock_reloc; 234756bec294SChris Mason 2348e999376fSChris Mason /* 2349e999376fSChris Mason * make sure none of the code above managed to slip in a 2350e999376fSChris Mason * delayed item 2351e999376fSChris Mason */ 2352ccdf9b30SJeff Mahoney btrfs_assert_delayed_root_empty(fs_info); 2353e999376fSChris Mason 23542c90e5d6SChris Mason WARN_ON(cur_trans != trans->transaction); 2355dc17ff8fSChris Mason 23567e4443d9SNikolay Borisov ret = commit_fs_roots(trans); 235756e9f6eaSDavid Sterba if (ret) 2358dfba78dcSFilipe Manana goto unlock_reloc; 235954aa1f4dSChris Mason 23603818aea2SQu Wenruo /* 23617e1876acSDavid Sterba * Since the transaction is done, we can apply the pending changes 23627e1876acSDavid Sterba * before the next transaction. 23633818aea2SQu Wenruo */ 23640b246afaSJeff Mahoney btrfs_apply_pending_changes(fs_info); 23653818aea2SQu Wenruo 23665d4f98a2SYan Zheng /* commit_fs_roots gets rid of all the tree log roots, it is now 2367e02119d5SChris Mason * safe to free the root of tree log roots 2368e02119d5SChris Mason */ 23690b246afaSJeff Mahoney btrfs_free_log_root_tree(trans, fs_info); 2370e02119d5SChris Mason 23710ed4792aSQu Wenruo /* 23720ed4792aSQu Wenruo * Since fs roots are all committed, we can get a quite accurate 23730ed4792aSQu Wenruo * new_roots. So let's do quota accounting. 23740ed4792aSQu Wenruo */ 2375460fb20aSNikolay Borisov ret = btrfs_qgroup_account_extents(trans); 237656e9f6eaSDavid Sterba if (ret < 0) 2377dfba78dcSFilipe Manana goto unlock_reloc; 23780ed4792aSQu Wenruo 23799386d8bcSNikolay Borisov ret = commit_cowonly_roots(trans); 238056e9f6eaSDavid Sterba if (ret) 2381dfba78dcSFilipe Manana goto unlock_reloc; 238254aa1f4dSChris Mason 23832cba30f1SMiao Xie /* 23842cba30f1SMiao Xie * The tasks which save the space cache and inode cache may also 23852cba30f1SMiao Xie * update ->aborted, check it. 23862cba30f1SMiao Xie */ 2387bf31f87fSDavid Sterba if (TRANS_ABORTED(cur_trans)) { 23882cba30f1SMiao Xie ret = cur_trans->aborted; 2389dfba78dcSFilipe Manana goto unlock_reloc; 23902cba30f1SMiao Xie } 23912cba30f1SMiao Xie 23920b246afaSJeff Mahoney cur_trans = fs_info->running_transaction; 23935f39d397SChris Mason 23940b246afaSJeff Mahoney btrfs_set_root_node(&fs_info->tree_root->root_item, 23950b246afaSJeff Mahoney fs_info->tree_root->node); 23960b246afaSJeff Mahoney list_add_tail(&fs_info->tree_root->dirty_list, 23979e351cc8SJosef Bacik &cur_trans->switch_commits); 23985d4f98a2SYan Zheng 23990b246afaSJeff Mahoney btrfs_set_root_node(&fs_info->chunk_root->root_item, 24000b246afaSJeff Mahoney fs_info->chunk_root->node); 24010b246afaSJeff Mahoney list_add_tail(&fs_info->chunk_root->dirty_list, 24029e351cc8SJosef Bacik &cur_trans->switch_commits); 24039e351cc8SJosef Bacik 2404f7238e50SJosef Bacik if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2)) { 2405f7238e50SJosef Bacik btrfs_set_root_node(&fs_info->block_group_root->root_item, 2406f7238e50SJosef Bacik fs_info->block_group_root->node); 2407f7238e50SJosef Bacik list_add_tail(&fs_info->block_group_root->dirty_list, 2408f7238e50SJosef Bacik &cur_trans->switch_commits); 2409f7238e50SJosef Bacik } 2410f7238e50SJosef Bacik 2411889bfa39SJosef Bacik switch_commit_roots(trans); 24125d4f98a2SYan Zheng 2413ce93ec54SJosef Bacik ASSERT(list_empty(&cur_trans->dirty_bgs)); 24141bbc621eSChris Mason ASSERT(list_empty(&cur_trans->io_bgs)); 24152ff7e61eSJeff Mahoney update_super_roots(fs_info); 2416e02119d5SChris Mason 24170b246afaSJeff Mahoney btrfs_set_super_log_root(fs_info->super_copy, 0); 24180b246afaSJeff Mahoney btrfs_set_super_log_root_level(fs_info->super_copy, 0); 24190b246afaSJeff Mahoney memcpy(fs_info->super_for_commit, fs_info->super_copy, 24200b246afaSJeff Mahoney sizeof(*fs_info->super_copy)); 2421ccd467d6SChris Mason 2422bbbf7243SNikolay Borisov btrfs_commit_device_sizes(cur_trans); 2423935e5cc9SMiao Xie 24240b246afaSJeff Mahoney clear_bit(BTRFS_FS_LOG1_ERR, &fs_info->flags); 24250b246afaSJeff Mahoney clear_bit(BTRFS_FS_LOG2_ERR, &fs_info->flags); 2426656f30dbSFilipe Manana 24274fbcdf66SFilipe Manana btrfs_trans_release_chunk_metadata(trans); 24284fbcdf66SFilipe Manana 2429dfba78dcSFilipe Manana /* 2430dfba78dcSFilipe Manana * Before changing the transaction state to TRANS_STATE_UNBLOCKED and 2431dfba78dcSFilipe Manana * setting fs_info->running_transaction to NULL, lock tree_log_mutex to 2432dfba78dcSFilipe Manana * make sure that before we commit our superblock, no other task can 2433dfba78dcSFilipe Manana * start a new transaction and commit a log tree before we commit our 2434dfba78dcSFilipe Manana * superblock. Anyone trying to commit a log tree locks this mutex before 2435dfba78dcSFilipe Manana * writing its superblock. 2436dfba78dcSFilipe Manana */ 2437dfba78dcSFilipe Manana mutex_lock(&fs_info->tree_log_mutex); 2438dfba78dcSFilipe Manana 24390b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 24404a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_UNBLOCKED; 24410b246afaSJeff Mahoney fs_info->running_transaction = NULL; 24420b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 24430b246afaSJeff Mahoney mutex_unlock(&fs_info->reloc_mutex); 2444b7ec40d7SChris Mason 24450b246afaSJeff Mahoney wake_up(&fs_info->transaction_wait); 24463e738c53SIoannis Angelakopoulos btrfs_trans_state_lockdep_release(fs_info, BTRFS_LOCKDEP_TRANS_UNBLOCKED); 2447e6dcd2dcSChris Mason 244870458a58SNikolay Borisov ret = btrfs_write_and_wait_transaction(trans); 244949b25e05SJeff Mahoney if (ret) { 24500b246afaSJeff Mahoney btrfs_handle_fs_error(fs_info, ret, 245108748810SDavid Sterba "Error while writing out transaction"); 24520b246afaSJeff Mahoney mutex_unlock(&fs_info->tree_log_mutex); 24536cf7f77eSWang Shilong goto scrub_continue; 245449b25e05SJeff Mahoney } 245549b25e05SJeff Mahoney 2456d3575156SNaohiro Aota /* 2457d3575156SNaohiro Aota * At this point, we should have written all the tree blocks allocated 2458d3575156SNaohiro Aota * in this transaction. So it's now safe to free the redirtyied extent 2459d3575156SNaohiro Aota * buffers. 2460d3575156SNaohiro Aota */ 2461d3575156SNaohiro Aota btrfs_free_redirty_list(cur_trans); 2462d3575156SNaohiro Aota 2463eece6a9cSDavid Sterba ret = write_all_supers(fs_info, 0); 2464e02119d5SChris Mason /* 2465e02119d5SChris Mason * the super is written, we can safely allow the tree-loggers 2466e02119d5SChris Mason * to go about their business 2467e02119d5SChris Mason */ 24680b246afaSJeff Mahoney mutex_unlock(&fs_info->tree_log_mutex); 2469c1f32b7cSAnand Jain if (ret) 2470c1f32b7cSAnand Jain goto scrub_continue; 2471e02119d5SChris Mason 2472d0c2f4faSFilipe Manana /* 2473d0c2f4faSFilipe Manana * We needn't acquire the lock here because there is no other task 2474d0c2f4faSFilipe Manana * which can change it. 2475d0c2f4faSFilipe Manana */ 2476d0c2f4faSFilipe Manana cur_trans->state = TRANS_STATE_SUPER_COMMITTED; 2477d0c2f4faSFilipe Manana wake_up(&cur_trans->commit_wait); 24783e738c53SIoannis Angelakopoulos btrfs_trans_state_lockdep_release(fs_info, BTRFS_LOCKDEP_TRANS_SUPER_COMMITTED); 2479d0c2f4faSFilipe Manana 24805ead2dd0SNikolay Borisov btrfs_finish_extent_commit(trans); 24814313b399SChris Mason 24823204d33cSJosef Bacik if (test_bit(BTRFS_TRANS_HAVE_FREE_BGS, &cur_trans->flags)) 24830b246afaSJeff Mahoney btrfs_clear_space_info_full(fs_info); 248413212b54SZhao Lei 24850b246afaSJeff Mahoney fs_info->last_trans_committed = cur_trans->transid; 24864a9d8bdeSMiao Xie /* 24874a9d8bdeSMiao Xie * We needn't acquire the lock here because there is no other task 24884a9d8bdeSMiao Xie * which can change it. 24894a9d8bdeSMiao Xie */ 24904a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_COMPLETED; 24912c90e5d6SChris Mason wake_up(&cur_trans->commit_wait); 24923e738c53SIoannis Angelakopoulos btrfs_trans_state_lockdep_release(fs_info, BTRFS_LOCKDEP_TRANS_COMPLETED); 24933de4586cSChris Mason 24940b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 249513c5a93eSJosef Bacik list_del_init(&cur_trans->list); 24960b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 2497a4abeea4SJosef Bacik 2498724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 2499724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 250058176a96SJosef Bacik 25010860adfdSMiao Xie if (trans->type & __TRANS_FREEZABLE) 25020b246afaSJeff Mahoney sb_end_intwrite(fs_info->sb); 2503b2b5ef5cSJan Kara 25042e4e97abSJosef Bacik trace_btrfs_transaction_commit(fs_info); 25051abe9b8aSliubo 2506e55958c8SIoannis Angelakopoulos interval = ktime_get_ns() - start_time; 2507e55958c8SIoannis Angelakopoulos 25082ff7e61eSJeff Mahoney btrfs_scrub_continue(fs_info); 2509a2de733cSArne Jansen 25109ed74f2dSJosef Bacik if (current->journal_info == trans) 25119ed74f2dSJosef Bacik current->journal_info = NULL; 25129ed74f2dSJosef Bacik 25132c90e5d6SChris Mason kmem_cache_free(btrfs_trans_handle_cachep, trans); 251424bbcf04SYan, Zheng 2515e55958c8SIoannis Angelakopoulos update_commit_stats(fs_info, interval); 2516e55958c8SIoannis Angelakopoulos 251779154b1bSChris Mason return ret; 251849b25e05SJeff Mahoney 251956e9f6eaSDavid Sterba unlock_reloc: 252056e9f6eaSDavid Sterba mutex_unlock(&fs_info->reloc_mutex); 25213e738c53SIoannis Angelakopoulos btrfs_trans_state_lockdep_release(fs_info, BTRFS_LOCKDEP_TRANS_UNBLOCKED); 25226cf7f77eSWang Shilong scrub_continue: 25233e738c53SIoannis Angelakopoulos btrfs_trans_state_lockdep_release(fs_info, BTRFS_LOCKDEP_TRANS_SUPER_COMMITTED); 25243e738c53SIoannis Angelakopoulos btrfs_trans_state_lockdep_release(fs_info, BTRFS_LOCKDEP_TRANS_COMPLETED); 25252ff7e61eSJeff Mahoney btrfs_scrub_continue(fs_info); 252649b25e05SJeff Mahoney cleanup_transaction: 2527dc60c525SNikolay Borisov btrfs_trans_release_metadata(trans); 2528c7cc64a9SDavid Sterba btrfs_cleanup_pending_block_groups(trans); 25294fbcdf66SFilipe Manana btrfs_trans_release_chunk_metadata(trans); 25300e721106SJosef Bacik trans->block_rsv = NULL; 25310b246afaSJeff Mahoney btrfs_warn(fs_info, "Skipping commit of aborted transaction."); 253249b25e05SJeff Mahoney if (current->journal_info == trans) 253349b25e05SJeff Mahoney current->journal_info = NULL; 253497cb39bbSNikolay Borisov cleanup_transaction(trans, ret); 253549b25e05SJeff Mahoney 253649b25e05SJeff Mahoney return ret; 2537e1489b4fSIoannis Angelakopoulos 2538e1489b4fSIoannis Angelakopoulos lockdep_release: 25395a9ba670SIoannis Angelakopoulos btrfs_lockdep_release(fs_info, btrfs_trans_num_extwriters); 2540e1489b4fSIoannis Angelakopoulos btrfs_lockdep_release(fs_info, btrfs_trans_num_writers); 2541e1489b4fSIoannis Angelakopoulos goto cleanup_transaction; 25423e738c53SIoannis Angelakopoulos 25433e738c53SIoannis Angelakopoulos lockdep_trans_commit_start_release: 25443e738c53SIoannis Angelakopoulos btrfs_trans_state_lockdep_release(fs_info, BTRFS_LOCKDEP_TRANS_COMMIT_START); 25453e738c53SIoannis Angelakopoulos btrfs_end_transaction(trans); 25463e738c53SIoannis Angelakopoulos return ret; 254779154b1bSChris Mason } 254879154b1bSChris Mason 2549d352ac68SChris Mason /* 25509d1a2a3aSDavid Sterba * return < 0 if error 25519d1a2a3aSDavid Sterba * 0 if there are no more dead_roots at the time of call 25529d1a2a3aSDavid Sterba * 1 there are more to be processed, call me again 25539d1a2a3aSDavid Sterba * 25549d1a2a3aSDavid Sterba * The return value indicates there are certainly more snapshots to delete, but 25559d1a2a3aSDavid Sterba * if there comes a new one during processing, it may return 0. We don't mind, 25569d1a2a3aSDavid Sterba * because btrfs_commit_super will poke cleaner thread and it will process it a 25579d1a2a3aSDavid Sterba * few seconds later. 2558d352ac68SChris Mason */ 255933c44184SJosef Bacik int btrfs_clean_one_deleted_snapshot(struct btrfs_fs_info *fs_info) 2560e9d0b13bSChris Mason { 256133c44184SJosef Bacik struct btrfs_root *root; 25629d1a2a3aSDavid Sterba int ret; 2563e9d0b13bSChris Mason 2564a4abeea4SJosef Bacik spin_lock(&fs_info->trans_lock); 25659d1a2a3aSDavid Sterba if (list_empty(&fs_info->dead_roots)) { 25669d1a2a3aSDavid Sterba spin_unlock(&fs_info->trans_lock); 25679d1a2a3aSDavid Sterba return 0; 25689d1a2a3aSDavid Sterba } 25699d1a2a3aSDavid Sterba root = list_first_entry(&fs_info->dead_roots, 25709d1a2a3aSDavid Sterba struct btrfs_root, root_list); 2571cfad392bSJosef Bacik list_del_init(&root->root_list); 2572a4abeea4SJosef Bacik spin_unlock(&fs_info->trans_lock); 25735d4f98a2SYan Zheng 25744fd786e6SMisono Tomohiro btrfs_debug(fs_info, "cleaner removing %llu", root->root_key.objectid); 257576dda93cSYan, Zheng 257616cdcec7SMiao Xie btrfs_kill_all_delayed_nodes(root); 257716cdcec7SMiao Xie 257876dda93cSYan, Zheng if (btrfs_header_backref_rev(root->node) < 257976dda93cSYan, Zheng BTRFS_MIXED_BACKREF_REV) 25800078a9f9SNikolay Borisov ret = btrfs_drop_snapshot(root, 0, 0); 258176dda93cSYan, Zheng else 25820078a9f9SNikolay Borisov ret = btrfs_drop_snapshot(root, 1, 0); 258332471dc2SDavid Sterba 2584dc9492c1SJosef Bacik btrfs_put_root(root); 25856596a928SJosef Bacik return (ret < 0) ? 0 : 1; 2586e9d0b13bSChris Mason } 2587572d9ab7SDavid Sterba 2588572d9ab7SDavid Sterba void btrfs_apply_pending_changes(struct btrfs_fs_info *fs_info) 2589572d9ab7SDavid Sterba { 2590572d9ab7SDavid Sterba unsigned long prev; 2591572d9ab7SDavid Sterba unsigned long bit; 2592572d9ab7SDavid Sterba 25936c9fe14fSQu Wenruo prev = xchg(&fs_info->pending_changes, 0); 2594572d9ab7SDavid Sterba if (!prev) 2595572d9ab7SDavid Sterba return; 2596572d9ab7SDavid Sterba 2597d51033d0SDavid Sterba bit = 1 << BTRFS_PENDING_COMMIT; 2598d51033d0SDavid Sterba if (prev & bit) 2599d51033d0SDavid Sterba btrfs_debug(fs_info, "pending commit done"); 2600d51033d0SDavid Sterba prev &= ~bit; 2601d51033d0SDavid Sterba 2602572d9ab7SDavid Sterba if (prev) 2603572d9ab7SDavid Sterba btrfs_warn(fs_info, 2604572d9ab7SDavid Sterba "unknown pending changes left 0x%lx, ignoring", prev); 2605572d9ab7SDavid Sterba } 2606956504a3SJosef Bacik 2607956504a3SJosef Bacik int __init btrfs_transaction_init(void) 2608956504a3SJosef Bacik { 2609956504a3SJosef Bacik btrfs_trans_handle_cachep = kmem_cache_create("btrfs_trans_handle", 2610956504a3SJosef Bacik sizeof(struct btrfs_trans_handle), 0, 2611956504a3SJosef Bacik SLAB_TEMPORARY | SLAB_MEM_SPREAD, NULL); 2612956504a3SJosef Bacik if (!btrfs_trans_handle_cachep) 2613956504a3SJosef Bacik return -ENOMEM; 2614956504a3SJosef Bacik return 0; 2615956504a3SJosef Bacik } 2616956504a3SJosef Bacik 2617956504a3SJosef Bacik void __cold btrfs_transaction_exit(void) 2618956504a3SJosef Bacik { 2619956504a3SJosef Bacik kmem_cache_destroy(btrfs_trans_handle_cachep); 2620956504a3SJosef Bacik } 2621