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> 13602cbe91SDavid Sterba #include "misc.h" 1479154b1bSChris Mason #include "ctree.h" 1579154b1bSChris Mason #include "disk-io.h" 1679154b1bSChris Mason #include "transaction.h" 17925baeddSChris Mason #include "locking.h" 18e02119d5SChris Mason #include "tree-log.h" 19581bb050SLi Zefan #include "inode-map.h" 20733f4fbbSStefan Behrens #include "volumes.h" 218dabb742SStefan Behrens #include "dev-replace.h" 22fcebe456SJosef Bacik #include "qgroup.h" 23aac0023cSJosef Bacik #include "block-group.h" 2479154b1bSChris Mason 250f7d52f4SChris Mason #define BTRFS_ROOT_TRANS_TAG 0 260f7d52f4SChris Mason 2761c047b5SQu Wenruo /* 2861c047b5SQu Wenruo * Transaction states and transitions 2961c047b5SQu Wenruo * 3061c047b5SQu Wenruo * No running transaction (fs tree blocks are not modified) 3161c047b5SQu Wenruo * | 3261c047b5SQu Wenruo * | To next stage: 3361c047b5SQu Wenruo * | Call start_transaction() variants. Except btrfs_join_transaction_nostart(). 3461c047b5SQu Wenruo * V 3561c047b5SQu Wenruo * Transaction N [[TRANS_STATE_RUNNING]] 3661c047b5SQu Wenruo * | 3761c047b5SQu Wenruo * | New trans handles can be attached to transaction N by calling all 3861c047b5SQu Wenruo * | start_transaction() variants. 3961c047b5SQu Wenruo * | 4061c047b5SQu Wenruo * | To next stage: 4161c047b5SQu Wenruo * | Call btrfs_commit_transaction() on any trans handle attached to 4261c047b5SQu Wenruo * | transaction N 4361c047b5SQu Wenruo * V 4461c047b5SQu Wenruo * Transaction N [[TRANS_STATE_COMMIT_START]] 4561c047b5SQu Wenruo * | 4661c047b5SQu Wenruo * | Will wait for previous running transaction to completely finish if there 4761c047b5SQu Wenruo * | is one 4861c047b5SQu Wenruo * | 4961c047b5SQu Wenruo * | Then one of the following happes: 5061c047b5SQu Wenruo * | - Wait for all other trans handle holders to release. 5161c047b5SQu Wenruo * | The btrfs_commit_transaction() caller will do the commit work. 5261c047b5SQu Wenruo * | - Wait for current transaction to be committed by others. 5361c047b5SQu Wenruo * | Other btrfs_commit_transaction() caller will do the commit work. 5461c047b5SQu Wenruo * | 5561c047b5SQu Wenruo * | At this stage, only btrfs_join_transaction*() variants can attach 5661c047b5SQu Wenruo * | to this running transaction. 5761c047b5SQu Wenruo * | All other variants will wait for current one to finish and attach to 5861c047b5SQu Wenruo * | transaction N+1. 5961c047b5SQu Wenruo * | 6061c047b5SQu Wenruo * | To next stage: 6161c047b5SQu Wenruo * | Caller is chosen to commit transaction N, and all other trans handle 6261c047b5SQu Wenruo * | haven been released. 6361c047b5SQu Wenruo * V 6461c047b5SQu Wenruo * Transaction N [[TRANS_STATE_COMMIT_DOING]] 6561c047b5SQu Wenruo * | 6661c047b5SQu Wenruo * | The heavy lifting transaction work is started. 6761c047b5SQu Wenruo * | From running delayed refs (modifying extent tree) to creating pending 6861c047b5SQu Wenruo * | snapshots, running qgroups. 6961c047b5SQu Wenruo * | In short, modify supporting trees to reflect modifications of subvolume 7061c047b5SQu Wenruo * | trees. 7161c047b5SQu Wenruo * | 7261c047b5SQu Wenruo * | At this stage, all start_transaction() calls will wait for this 7361c047b5SQu Wenruo * | transaction to finish and attach to transaction N+1. 7461c047b5SQu Wenruo * | 7561c047b5SQu Wenruo * | To next stage: 7661c047b5SQu Wenruo * | Until all supporting trees are updated. 7761c047b5SQu Wenruo * V 7861c047b5SQu Wenruo * Transaction N [[TRANS_STATE_UNBLOCKED]] 7961c047b5SQu Wenruo * | Transaction N+1 8061c047b5SQu Wenruo * | All needed trees are modified, thus we only [[TRANS_STATE_RUNNING]] 8161c047b5SQu Wenruo * | need to write them back to disk and update | 8261c047b5SQu Wenruo * | super blocks. | 8361c047b5SQu Wenruo * | | 8461c047b5SQu Wenruo * | At this stage, new transaction is allowed to | 8561c047b5SQu Wenruo * | start. | 8661c047b5SQu Wenruo * | All new start_transaction() calls will be | 8761c047b5SQu Wenruo * | attached to transid N+1. | 8861c047b5SQu Wenruo * | | 8961c047b5SQu Wenruo * | To next stage: | 9061c047b5SQu Wenruo * | Until all tree blocks are super blocks are | 9161c047b5SQu Wenruo * | written to block devices | 9261c047b5SQu Wenruo * V | 9361c047b5SQu Wenruo * Transaction N [[TRANS_STATE_COMPLETED]] V 9461c047b5SQu Wenruo * All tree blocks and super blocks are written. Transaction N+1 9561c047b5SQu Wenruo * This transaction is finished and all its [[TRANS_STATE_COMMIT_START]] 9661c047b5SQu Wenruo * data structures will be cleaned up. | Life goes on 9761c047b5SQu Wenruo */ 98e8c9f186SDavid Sterba static const unsigned int btrfs_blocked_trans_types[TRANS_STATE_MAX] = { 994a9d8bdeSMiao Xie [TRANS_STATE_RUNNING] = 0U, 100bcf3a3e7SNikolay Borisov [TRANS_STATE_BLOCKED] = __TRANS_START, 101bcf3a3e7SNikolay Borisov [TRANS_STATE_COMMIT_START] = (__TRANS_START | __TRANS_ATTACH), 102bcf3a3e7SNikolay Borisov [TRANS_STATE_COMMIT_DOING] = (__TRANS_START | 1034a9d8bdeSMiao Xie __TRANS_ATTACH | 104a6d155d2SFilipe Manana __TRANS_JOIN | 105a6d155d2SFilipe Manana __TRANS_JOIN_NOSTART), 106bcf3a3e7SNikolay Borisov [TRANS_STATE_UNBLOCKED] = (__TRANS_START | 1074a9d8bdeSMiao Xie __TRANS_ATTACH | 1084a9d8bdeSMiao Xie __TRANS_JOIN | 109a6d155d2SFilipe Manana __TRANS_JOIN_NOLOCK | 110a6d155d2SFilipe Manana __TRANS_JOIN_NOSTART), 111bcf3a3e7SNikolay Borisov [TRANS_STATE_COMPLETED] = (__TRANS_START | 1124a9d8bdeSMiao Xie __TRANS_ATTACH | 1134a9d8bdeSMiao Xie __TRANS_JOIN | 114a6d155d2SFilipe Manana __TRANS_JOIN_NOLOCK | 115a6d155d2SFilipe Manana __TRANS_JOIN_NOSTART), 1164a9d8bdeSMiao Xie }; 1174a9d8bdeSMiao Xie 118724e2315SJosef Bacik void btrfs_put_transaction(struct btrfs_transaction *transaction) 11979154b1bSChris Mason { 1209b64f57dSElena Reshetova WARN_ON(refcount_read(&transaction->use_count) == 0); 1219b64f57dSElena Reshetova if (refcount_dec_and_test(&transaction->use_count)) { 122a4abeea4SJosef Bacik BUG_ON(!list_empty(&transaction->list)); 1235c9d028bSLiu Bo WARN_ON(!RB_EMPTY_ROOT( 1245c9d028bSLiu Bo &transaction->delayed_refs.href_root.rb_root)); 1251262133bSJosef Bacik if (transaction->delayed_refs.pending_csums) 126ab8d0fc4SJeff Mahoney btrfs_err(transaction->fs_info, 127ab8d0fc4SJeff Mahoney "pending csums is %llu", 1281262133bSJosef Bacik transaction->delayed_refs.pending_csums); 1297785a663SFilipe Manana /* 1307785a663SFilipe Manana * If any block groups are found in ->deleted_bgs then it's 1317785a663SFilipe Manana * because the transaction was aborted and a commit did not 1327785a663SFilipe Manana * happen (things failed before writing the new superblock 1337785a663SFilipe Manana * and calling btrfs_finish_extent_commit()), so we can not 1347785a663SFilipe Manana * discard the physical locations of the block groups. 1357785a663SFilipe Manana */ 1367785a663SFilipe Manana while (!list_empty(&transaction->deleted_bgs)) { 1377785a663SFilipe Manana struct btrfs_block_group_cache *cache; 1387785a663SFilipe Manana 1397785a663SFilipe Manana cache = list_first_entry(&transaction->deleted_bgs, 1407785a663SFilipe Manana struct btrfs_block_group_cache, 1417785a663SFilipe Manana bg_list); 1427785a663SFilipe Manana list_del_init(&cache->bg_list); 1437785a663SFilipe Manana btrfs_put_block_group_trimming(cache); 1447785a663SFilipe Manana btrfs_put_block_group(cache); 1457785a663SFilipe Manana } 146bbbf7243SNikolay Borisov WARN_ON(!list_empty(&transaction->dev_update_list)); 1474b5faeacSDavid Sterba kfree(transaction); 14879154b1bSChris Mason } 14978fae27eSChris Mason } 15079154b1bSChris Mason 15116916a88SNikolay Borisov static noinline void switch_commit_roots(struct btrfs_transaction *trans) 152817d52f8SJosef Bacik { 15316916a88SNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 1549e351cc8SJosef Bacik struct btrfs_root *root, *tmp; 1559e351cc8SJosef Bacik 1569e351cc8SJosef Bacik down_write(&fs_info->commit_root_sem); 1579e351cc8SJosef Bacik list_for_each_entry_safe(root, tmp, &trans->switch_commits, 1589e351cc8SJosef Bacik dirty_list) { 1599e351cc8SJosef Bacik list_del_init(&root->dirty_list); 160817d52f8SJosef Bacik free_extent_buffer(root->commit_root); 161817d52f8SJosef Bacik root->commit_root = btrfs_root_node(root); 1624fd786e6SMisono Tomohiro if (is_fstree(root->root_key.objectid)) 1639e351cc8SJosef Bacik btrfs_unpin_free_ino(root); 16441e7acd3SNikolay Borisov extent_io_tree_release(&root->dirty_log_pages); 165370a11b8SQu Wenruo btrfs_qgroup_clean_swapped_blocks(root); 1669e351cc8SJosef Bacik } 1672b9dbef2SJosef Bacik 1682b9dbef2SJosef Bacik /* We can free old roots now. */ 1692b9dbef2SJosef Bacik spin_lock(&trans->dropped_roots_lock); 1702b9dbef2SJosef Bacik while (!list_empty(&trans->dropped_roots)) { 1712b9dbef2SJosef Bacik root = list_first_entry(&trans->dropped_roots, 1722b9dbef2SJosef Bacik struct btrfs_root, root_list); 1732b9dbef2SJosef Bacik list_del_init(&root->root_list); 1742b9dbef2SJosef Bacik spin_unlock(&trans->dropped_roots_lock); 1752b9dbef2SJosef Bacik btrfs_drop_and_free_fs_root(fs_info, root); 1762b9dbef2SJosef Bacik spin_lock(&trans->dropped_roots_lock); 1772b9dbef2SJosef Bacik } 1782b9dbef2SJosef Bacik spin_unlock(&trans->dropped_roots_lock); 1799e351cc8SJosef Bacik up_write(&fs_info->commit_root_sem); 180817d52f8SJosef Bacik } 181817d52f8SJosef Bacik 1820860adfdSMiao Xie static inline void extwriter_counter_inc(struct btrfs_transaction *trans, 1830860adfdSMiao Xie unsigned int type) 1840860adfdSMiao Xie { 1850860adfdSMiao Xie if (type & TRANS_EXTWRITERS) 1860860adfdSMiao Xie atomic_inc(&trans->num_extwriters); 1870860adfdSMiao Xie } 1880860adfdSMiao Xie 1890860adfdSMiao Xie static inline void extwriter_counter_dec(struct btrfs_transaction *trans, 1900860adfdSMiao Xie unsigned int type) 1910860adfdSMiao Xie { 1920860adfdSMiao Xie if (type & TRANS_EXTWRITERS) 1930860adfdSMiao Xie atomic_dec(&trans->num_extwriters); 1940860adfdSMiao Xie } 1950860adfdSMiao Xie 1960860adfdSMiao Xie static inline void extwriter_counter_init(struct btrfs_transaction *trans, 1970860adfdSMiao Xie unsigned int type) 1980860adfdSMiao Xie { 1990860adfdSMiao Xie atomic_set(&trans->num_extwriters, ((type & TRANS_EXTWRITERS) ? 1 : 0)); 2000860adfdSMiao Xie } 2010860adfdSMiao Xie 2020860adfdSMiao Xie static inline int extwriter_counter_read(struct btrfs_transaction *trans) 2030860adfdSMiao Xie { 2040860adfdSMiao Xie return atomic_read(&trans->num_extwriters); 205178260b2SMiao Xie } 206178260b2SMiao Xie 207d352ac68SChris Mason /* 208fb6dea26SJosef Bacik * To be called after all the new block groups attached to the transaction 209fb6dea26SJosef Bacik * handle have been created (btrfs_create_pending_block_groups()). 210fb6dea26SJosef Bacik */ 211fb6dea26SJosef Bacik void btrfs_trans_release_chunk_metadata(struct btrfs_trans_handle *trans) 212fb6dea26SJosef Bacik { 213fb6dea26SJosef Bacik struct btrfs_fs_info *fs_info = trans->fs_info; 214fb6dea26SJosef Bacik 215fb6dea26SJosef Bacik if (!trans->chunk_bytes_reserved) 216fb6dea26SJosef Bacik return; 217fb6dea26SJosef Bacik 218fb6dea26SJosef Bacik WARN_ON_ONCE(!list_empty(&trans->new_bgs)); 219fb6dea26SJosef Bacik 220fb6dea26SJosef Bacik btrfs_block_rsv_release(fs_info, &fs_info->chunk_block_rsv, 221fb6dea26SJosef Bacik trans->chunk_bytes_reserved); 222fb6dea26SJosef Bacik trans->chunk_bytes_reserved = 0; 223fb6dea26SJosef Bacik } 224fb6dea26SJosef Bacik 225fb6dea26SJosef Bacik /* 226d352ac68SChris Mason * either allocate a new transaction or hop into the existing one 227d352ac68SChris Mason */ 2282ff7e61eSJeff Mahoney static noinline int join_transaction(struct btrfs_fs_info *fs_info, 2292ff7e61eSJeff Mahoney unsigned int type) 23079154b1bSChris Mason { 23179154b1bSChris Mason struct btrfs_transaction *cur_trans; 232a4abeea4SJosef Bacik 23319ae4e81SJan Schmidt spin_lock(&fs_info->trans_lock); 234d43317dcSChris Mason loop: 23549b25e05SJeff Mahoney /* The file system has been taken offline. No new transactions. */ 23687533c47SMiao Xie if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) { 23719ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 23849b25e05SJeff Mahoney return -EROFS; 23949b25e05SJeff Mahoney } 24049b25e05SJeff Mahoney 24119ae4e81SJan Schmidt cur_trans = fs_info->running_transaction; 242a4abeea4SJosef Bacik if (cur_trans) { 243871383beSDavid Sterba if (cur_trans->aborted) { 24419ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 24549b25e05SJeff Mahoney return cur_trans->aborted; 246871383beSDavid Sterba } 2474a9d8bdeSMiao Xie if (btrfs_blocked_trans_types[cur_trans->state] & type) { 248178260b2SMiao Xie spin_unlock(&fs_info->trans_lock); 249178260b2SMiao Xie return -EBUSY; 250178260b2SMiao Xie } 2519b64f57dSElena Reshetova refcount_inc(&cur_trans->use_count); 252a4abeea4SJosef Bacik atomic_inc(&cur_trans->num_writers); 2530860adfdSMiao Xie extwriter_counter_inc(cur_trans, type); 25419ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 255a4abeea4SJosef Bacik return 0; 256a4abeea4SJosef Bacik } 25719ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 258a4abeea4SJosef Bacik 259354aa0fbSMiao Xie /* 260354aa0fbSMiao Xie * If we are ATTACH, we just want to catch the current transaction, 261354aa0fbSMiao Xie * and commit it. If there is no transaction, just return ENOENT. 262354aa0fbSMiao Xie */ 263354aa0fbSMiao Xie if (type == TRANS_ATTACH) 264354aa0fbSMiao Xie return -ENOENT; 265354aa0fbSMiao Xie 2664a9d8bdeSMiao Xie /* 2674a9d8bdeSMiao Xie * JOIN_NOLOCK only happens during the transaction commit, so 2684a9d8bdeSMiao Xie * it is impossible that ->running_transaction is NULL 2694a9d8bdeSMiao Xie */ 2704a9d8bdeSMiao Xie BUG_ON(type == TRANS_JOIN_NOLOCK); 2714a9d8bdeSMiao Xie 2724b5faeacSDavid Sterba cur_trans = kmalloc(sizeof(*cur_trans), GFP_NOFS); 273db5b493aSTsutomu Itoh if (!cur_trans) 274db5b493aSTsutomu Itoh return -ENOMEM; 275d43317dcSChris Mason 27619ae4e81SJan Schmidt spin_lock(&fs_info->trans_lock); 27719ae4e81SJan Schmidt if (fs_info->running_transaction) { 278d43317dcSChris Mason /* 279d43317dcSChris Mason * someone started a transaction after we unlocked. Make sure 2804a9d8bdeSMiao Xie * to redo the checks above 281d43317dcSChris Mason */ 2824b5faeacSDavid Sterba kfree(cur_trans); 283d43317dcSChris Mason goto loop; 28487533c47SMiao Xie } else if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) { 285e4b50e14SDan Carpenter spin_unlock(&fs_info->trans_lock); 2864b5faeacSDavid Sterba kfree(cur_trans); 2877b8b92afSJosef Bacik return -EROFS; 288a4abeea4SJosef Bacik } 289d43317dcSChris Mason 290ab8d0fc4SJeff Mahoney cur_trans->fs_info = fs_info; 29113c5a93eSJosef Bacik atomic_set(&cur_trans->num_writers, 1); 2920860adfdSMiao Xie extwriter_counter_init(cur_trans, type); 29379154b1bSChris Mason init_waitqueue_head(&cur_trans->writer_wait); 29479154b1bSChris Mason init_waitqueue_head(&cur_trans->commit_wait); 2954a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_RUNNING; 296a4abeea4SJosef Bacik /* 297a4abeea4SJosef Bacik * One for this trans handle, one so it will live on until we 298a4abeea4SJosef Bacik * commit the transaction. 299a4abeea4SJosef Bacik */ 3009b64f57dSElena Reshetova refcount_set(&cur_trans->use_count, 2); 3013204d33cSJosef Bacik cur_trans->flags = 0; 302afd48513SArnd Bergmann cur_trans->start_time = ktime_get_seconds(); 30356bec294SChris Mason 304a099d0fdSAlexandru Moise memset(&cur_trans->delayed_refs, 0, sizeof(cur_trans->delayed_refs)); 305a099d0fdSAlexandru Moise 3065c9d028bSLiu Bo cur_trans->delayed_refs.href_root = RB_ROOT_CACHED; 3073368d001SQu Wenruo cur_trans->delayed_refs.dirty_extent_root = RB_ROOT; 308d7df2c79SJosef Bacik atomic_set(&cur_trans->delayed_refs.num_entries, 0); 30920b297d6SJan Schmidt 31020b297d6SJan Schmidt /* 31120b297d6SJan Schmidt * although the tree mod log is per file system and not per transaction, 31220b297d6SJan Schmidt * the log must never go across transaction boundaries. 31320b297d6SJan Schmidt */ 31420b297d6SJan Schmidt smp_mb(); 31531b1a2bdSJulia Lawall if (!list_empty(&fs_info->tree_mod_seq_list)) 3165d163e0eSJeff Mahoney WARN(1, KERN_ERR "BTRFS: tree_mod_seq_list not empty when creating a fresh transaction\n"); 31731b1a2bdSJulia Lawall if (!RB_EMPTY_ROOT(&fs_info->tree_mod_log)) 3185d163e0eSJeff Mahoney WARN(1, KERN_ERR "BTRFS: tree_mod_log rb tree not empty when creating a fresh transaction\n"); 319fc36ed7eSJan Schmidt atomic64_set(&fs_info->tree_mod_seq, 0); 32020b297d6SJan Schmidt 32156bec294SChris Mason spin_lock_init(&cur_trans->delayed_refs.lock); 32256bec294SChris Mason 3233063d29fSChris Mason INIT_LIST_HEAD(&cur_trans->pending_snapshots); 324bbbf7243SNikolay Borisov INIT_LIST_HEAD(&cur_trans->dev_update_list); 3259e351cc8SJosef Bacik INIT_LIST_HEAD(&cur_trans->switch_commits); 326ce93ec54SJosef Bacik INIT_LIST_HEAD(&cur_trans->dirty_bgs); 3271bbc621eSChris Mason INIT_LIST_HEAD(&cur_trans->io_bgs); 3282b9dbef2SJosef Bacik INIT_LIST_HEAD(&cur_trans->dropped_roots); 3291bbc621eSChris Mason mutex_init(&cur_trans->cache_write_mutex); 330ce93ec54SJosef Bacik spin_lock_init(&cur_trans->dirty_bgs_lock); 331e33e17eeSJeff Mahoney INIT_LIST_HEAD(&cur_trans->deleted_bgs); 3322b9dbef2SJosef Bacik spin_lock_init(&cur_trans->dropped_roots_lock); 33319ae4e81SJan Schmidt list_add_tail(&cur_trans->list, &fs_info->trans_list); 334c258d6e3SQu Wenruo extent_io_tree_init(fs_info, &cur_trans->dirty_pages, 33543eb5f29SQu Wenruo IO_TREE_TRANS_DIRTY_PAGES, fs_info->btree_inode); 33619ae4e81SJan Schmidt fs_info->generation++; 33719ae4e81SJan Schmidt cur_trans->transid = fs_info->generation; 33819ae4e81SJan Schmidt fs_info->running_transaction = cur_trans; 33949b25e05SJeff Mahoney cur_trans->aborted = 0; 34019ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 34115ee9bc7SJosef Bacik 34279154b1bSChris Mason return 0; 34379154b1bSChris Mason } 34479154b1bSChris Mason 345d352ac68SChris Mason /* 346d397712bSChris Mason * this does all the record keeping required to make sure that a reference 347d397712bSChris Mason * counted root is properly recorded in a given transaction. This is required 348d397712bSChris Mason * to make sure the old root from before we joined the transaction is deleted 349d397712bSChris Mason * when the transaction commits 350d352ac68SChris Mason */ 3517585717fSChris Mason static int record_root_in_trans(struct btrfs_trans_handle *trans, 3526426c7adSQu Wenruo struct btrfs_root *root, 3536426c7adSQu Wenruo int force) 3546702ed49SChris Mason { 3550b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 3560b246afaSJeff Mahoney 3576426c7adSQu Wenruo if ((test_bit(BTRFS_ROOT_REF_COWS, &root->state) && 3586426c7adSQu Wenruo root->last_trans < trans->transid) || force) { 3590b246afaSJeff Mahoney WARN_ON(root == fs_info->extent_root); 3604d31778aSQu Wenruo WARN_ON(!force && root->commit_root != root->node); 3615d4f98a2SYan Zheng 3627585717fSChris Mason /* 36327cdeb70SMiao Xie * see below for IN_TRANS_SETUP usage rules 3647585717fSChris Mason * we have the reloc mutex held now, so there 3657585717fSChris Mason * is only one writer in this function 3667585717fSChris Mason */ 36727cdeb70SMiao Xie set_bit(BTRFS_ROOT_IN_TRANS_SETUP, &root->state); 3687585717fSChris Mason 36927cdeb70SMiao Xie /* make sure readers find IN_TRANS_SETUP before 3707585717fSChris Mason * they find our root->last_trans update 3717585717fSChris Mason */ 3727585717fSChris Mason smp_wmb(); 3737585717fSChris Mason 3740b246afaSJeff Mahoney spin_lock(&fs_info->fs_roots_radix_lock); 3756426c7adSQu Wenruo if (root->last_trans == trans->transid && !force) { 3760b246afaSJeff Mahoney spin_unlock(&fs_info->fs_roots_radix_lock); 377a4abeea4SJosef Bacik return 0; 378a4abeea4SJosef Bacik } 3790b246afaSJeff Mahoney radix_tree_tag_set(&fs_info->fs_roots_radix, 3806702ed49SChris Mason (unsigned long)root->root_key.objectid, 3816702ed49SChris Mason BTRFS_ROOT_TRANS_TAG); 3820b246afaSJeff Mahoney spin_unlock(&fs_info->fs_roots_radix_lock); 3837585717fSChris Mason root->last_trans = trans->transid; 3847585717fSChris Mason 3857585717fSChris Mason /* this is pretty tricky. We don't want to 3867585717fSChris Mason * take the relocation lock in btrfs_record_root_in_trans 3877585717fSChris Mason * unless we're really doing the first setup for this root in 3887585717fSChris Mason * this transaction. 3897585717fSChris Mason * 3907585717fSChris Mason * Normally we'd use root->last_trans as a flag to decide 3917585717fSChris Mason * if we want to take the expensive mutex. 3927585717fSChris Mason * 3937585717fSChris Mason * But, we have to set root->last_trans before we 3947585717fSChris Mason * init the relocation root, otherwise, we trip over warnings 3957585717fSChris Mason * in ctree.c. The solution used here is to flag ourselves 39627cdeb70SMiao Xie * with root IN_TRANS_SETUP. When this is 1, we're still 3977585717fSChris Mason * fixing up the reloc trees and everyone must wait. 3987585717fSChris Mason * 3997585717fSChris Mason * When this is zero, they can trust root->last_trans and fly 4007585717fSChris Mason * through btrfs_record_root_in_trans without having to take the 4017585717fSChris Mason * lock. smp_wmb() makes sure that all the writes above are 4027585717fSChris Mason * done before we pop in the zero below 4037585717fSChris Mason */ 4045d4f98a2SYan Zheng btrfs_init_reloc_root(trans, root); 405c7548af6SChris Mason smp_mb__before_atomic(); 40627cdeb70SMiao Xie clear_bit(BTRFS_ROOT_IN_TRANS_SETUP, &root->state); 4076702ed49SChris Mason } 4085d4f98a2SYan Zheng return 0; 4096702ed49SChris Mason } 4105d4f98a2SYan Zheng 4117585717fSChris Mason 4122b9dbef2SJosef Bacik void btrfs_add_dropped_root(struct btrfs_trans_handle *trans, 4132b9dbef2SJosef Bacik struct btrfs_root *root) 4142b9dbef2SJosef Bacik { 4150b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 4162b9dbef2SJosef Bacik struct btrfs_transaction *cur_trans = trans->transaction; 4172b9dbef2SJosef Bacik 4182b9dbef2SJosef Bacik /* Add ourselves to the transaction dropped list */ 4192b9dbef2SJosef Bacik spin_lock(&cur_trans->dropped_roots_lock); 4202b9dbef2SJosef Bacik list_add_tail(&root->root_list, &cur_trans->dropped_roots); 4212b9dbef2SJosef Bacik spin_unlock(&cur_trans->dropped_roots_lock); 4222b9dbef2SJosef Bacik 4232b9dbef2SJosef Bacik /* Make sure we don't try to update the root at commit time */ 4240b246afaSJeff Mahoney spin_lock(&fs_info->fs_roots_radix_lock); 4250b246afaSJeff Mahoney radix_tree_tag_clear(&fs_info->fs_roots_radix, 4262b9dbef2SJosef Bacik (unsigned long)root->root_key.objectid, 4272b9dbef2SJosef Bacik BTRFS_ROOT_TRANS_TAG); 4280b246afaSJeff Mahoney spin_unlock(&fs_info->fs_roots_radix_lock); 4292b9dbef2SJosef Bacik } 4302b9dbef2SJosef Bacik 4317585717fSChris Mason int btrfs_record_root_in_trans(struct btrfs_trans_handle *trans, 4327585717fSChris Mason struct btrfs_root *root) 4337585717fSChris Mason { 4340b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 4350b246afaSJeff Mahoney 43627cdeb70SMiao Xie if (!test_bit(BTRFS_ROOT_REF_COWS, &root->state)) 4377585717fSChris Mason return 0; 4387585717fSChris Mason 4397585717fSChris Mason /* 44027cdeb70SMiao Xie * see record_root_in_trans for comments about IN_TRANS_SETUP usage 4417585717fSChris Mason * and barriers 4427585717fSChris Mason */ 4437585717fSChris Mason smp_rmb(); 4447585717fSChris Mason if (root->last_trans == trans->transid && 44527cdeb70SMiao Xie !test_bit(BTRFS_ROOT_IN_TRANS_SETUP, &root->state)) 4467585717fSChris Mason return 0; 4477585717fSChris Mason 4480b246afaSJeff Mahoney mutex_lock(&fs_info->reloc_mutex); 4496426c7adSQu Wenruo record_root_in_trans(trans, root, 0); 4500b246afaSJeff Mahoney mutex_unlock(&fs_info->reloc_mutex); 4517585717fSChris Mason 4527585717fSChris Mason return 0; 4537585717fSChris Mason } 4547585717fSChris Mason 4554a9d8bdeSMiao Xie static inline int is_transaction_blocked(struct btrfs_transaction *trans) 4564a9d8bdeSMiao Xie { 4574a9d8bdeSMiao Xie return (trans->state >= TRANS_STATE_BLOCKED && 458501407aaSJosef Bacik trans->state < TRANS_STATE_UNBLOCKED && 459501407aaSJosef Bacik !trans->aborted); 4604a9d8bdeSMiao Xie } 4614a9d8bdeSMiao Xie 462d352ac68SChris Mason /* wait for commit against the current transaction to become unblocked 463d352ac68SChris Mason * when this is done, it is safe to start a new transaction, but the current 464d352ac68SChris Mason * transaction might not be fully on disk. 465d352ac68SChris Mason */ 4662ff7e61eSJeff Mahoney static void wait_current_trans(struct btrfs_fs_info *fs_info) 46779154b1bSChris Mason { 468f9295749SChris Mason struct btrfs_transaction *cur_trans; 46979154b1bSChris Mason 4700b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 4710b246afaSJeff Mahoney cur_trans = fs_info->running_transaction; 4724a9d8bdeSMiao Xie if (cur_trans && is_transaction_blocked(cur_trans)) { 4739b64f57dSElena Reshetova refcount_inc(&cur_trans->use_count); 4740b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 47572d63ed6SLi Zefan 4760b246afaSJeff Mahoney wait_event(fs_info->transaction_wait, 477501407aaSJosef Bacik cur_trans->state >= TRANS_STATE_UNBLOCKED || 478501407aaSJosef Bacik cur_trans->aborted); 479724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 480a4abeea4SJosef Bacik } else { 4810b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 482f9295749SChris Mason } 48337d1aeeeSChris Mason } 48437d1aeeeSChris Mason 4852ff7e61eSJeff Mahoney static int may_wait_transaction(struct btrfs_fs_info *fs_info, int type) 48637d1aeeeSChris Mason { 4870b246afaSJeff Mahoney if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags)) 488a4abeea4SJosef Bacik return 0; 489a4abeea4SJosef Bacik 49092e2f7e3SNikolay Borisov if (type == TRANS_START) 491a4abeea4SJosef Bacik return 1; 492a4abeea4SJosef Bacik 493a22285a6SYan, Zheng return 0; 494a22285a6SYan, Zheng } 495a22285a6SYan, Zheng 49620dd2cbfSMiao Xie static inline bool need_reserve_reloc_root(struct btrfs_root *root) 49720dd2cbfSMiao Xie { 4980b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 4990b246afaSJeff Mahoney 5000b246afaSJeff Mahoney if (!fs_info->reloc_ctl || 50127cdeb70SMiao Xie !test_bit(BTRFS_ROOT_REF_COWS, &root->state) || 50220dd2cbfSMiao Xie root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID || 50320dd2cbfSMiao Xie root->reloc_root) 50420dd2cbfSMiao Xie return false; 50520dd2cbfSMiao Xie 50620dd2cbfSMiao Xie return true; 50720dd2cbfSMiao Xie } 50820dd2cbfSMiao Xie 50908e007d2SMiao Xie static struct btrfs_trans_handle * 5105aed1dd8SAlexandru Moise start_transaction(struct btrfs_root *root, unsigned int num_items, 511003d7c59SJeff Mahoney unsigned int type, enum btrfs_reserve_flush_enum flush, 512003d7c59SJeff Mahoney bool enforce_qgroups) 513a22285a6SYan, Zheng { 5140b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 515ba2c4d4eSJosef Bacik struct btrfs_block_rsv *delayed_refs_rsv = &fs_info->delayed_refs_rsv; 516a22285a6SYan, Zheng struct btrfs_trans_handle *h; 517a22285a6SYan, Zheng struct btrfs_transaction *cur_trans; 518b5009945SJosef Bacik u64 num_bytes = 0; 519c5567237SArne Jansen u64 qgroup_reserved = 0; 52020dd2cbfSMiao Xie bool reloc_reserved = false; 52120dd2cbfSMiao Xie int ret; 522acce952bSliubo 52346c4e71eSFilipe Manana /* Send isn't supposed to start transactions. */ 5242755a0deSDavid Sterba ASSERT(current->journal_info != BTRFS_SEND_TRANS_STUB); 52546c4e71eSFilipe Manana 5260b246afaSJeff Mahoney if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) 527acce952bSliubo return ERR_PTR(-EROFS); 5282a1eb461SJosef Bacik 52946c4e71eSFilipe Manana if (current->journal_info) { 5300860adfdSMiao Xie WARN_ON(type & TRANS_EXTWRITERS); 5312a1eb461SJosef Bacik h = current->journal_info; 532b50fff81SDavid Sterba refcount_inc(&h->use_count); 533b50fff81SDavid Sterba WARN_ON(refcount_read(&h->use_count) > 2); 5342a1eb461SJosef Bacik h->orig_rsv = h->block_rsv; 5352a1eb461SJosef Bacik h->block_rsv = NULL; 5362a1eb461SJosef Bacik goto got_it; 5372a1eb461SJosef Bacik } 538b5009945SJosef Bacik 539b5009945SJosef Bacik /* 540b5009945SJosef Bacik * Do the reservation before we join the transaction so we can do all 541b5009945SJosef Bacik * the appropriate flushing if need be. 542b5009945SJosef Bacik */ 543003d7c59SJeff Mahoney if (num_items && root != fs_info->chunk_root) { 544ba2c4d4eSJosef Bacik struct btrfs_block_rsv *rsv = &fs_info->trans_block_rsv; 545ba2c4d4eSJosef Bacik u64 delayed_refs_bytes = 0; 546ba2c4d4eSJosef Bacik 5470b246afaSJeff Mahoney qgroup_reserved = num_items * fs_info->nodesize; 548733e03a0SQu Wenruo ret = btrfs_qgroup_reserve_meta_pertrans(root, qgroup_reserved, 549003d7c59SJeff Mahoney enforce_qgroups); 550c5567237SArne Jansen if (ret) 551c5567237SArne Jansen return ERR_PTR(ret); 552c5567237SArne Jansen 553ba2c4d4eSJosef Bacik /* 554ba2c4d4eSJosef Bacik * We want to reserve all the bytes we may need all at once, so 555ba2c4d4eSJosef Bacik * we only do 1 enospc flushing cycle per transaction start. We 556ba2c4d4eSJosef Bacik * accomplish this by simply assuming we'll do 2 x num_items 557ba2c4d4eSJosef Bacik * worth of delayed refs updates in this trans handle, and 558ba2c4d4eSJosef Bacik * refill that amount for whatever is missing in the reserve. 559ba2c4d4eSJosef Bacik */ 5602bd36e7bSJosef Bacik num_bytes = btrfs_calc_insert_metadata_size(fs_info, num_items); 561ba2c4d4eSJosef Bacik if (delayed_refs_rsv->full == 0) { 562ba2c4d4eSJosef Bacik delayed_refs_bytes = num_bytes; 563ba2c4d4eSJosef Bacik num_bytes <<= 1; 564ba2c4d4eSJosef Bacik } 565ba2c4d4eSJosef Bacik 56620dd2cbfSMiao Xie /* 56720dd2cbfSMiao Xie * Do the reservation for the relocation root creation 56820dd2cbfSMiao Xie */ 569ee39b432SDavid Sterba if (need_reserve_reloc_root(root)) { 5700b246afaSJeff Mahoney num_bytes += fs_info->nodesize; 57120dd2cbfSMiao Xie reloc_reserved = true; 57220dd2cbfSMiao Xie } 57320dd2cbfSMiao Xie 574ba2c4d4eSJosef Bacik ret = btrfs_block_rsv_add(root, rsv, num_bytes, flush); 575ba2c4d4eSJosef Bacik if (ret) 576ba2c4d4eSJosef Bacik goto reserve_fail; 577ba2c4d4eSJosef Bacik if (delayed_refs_bytes) { 578ba2c4d4eSJosef Bacik btrfs_migrate_to_delayed_refs_rsv(fs_info, rsv, 579ba2c4d4eSJosef Bacik delayed_refs_bytes); 580ba2c4d4eSJosef Bacik num_bytes -= delayed_refs_bytes; 581ba2c4d4eSJosef Bacik } 582ba2c4d4eSJosef Bacik } else if (num_items == 0 && flush == BTRFS_RESERVE_FLUSH_ALL && 583ba2c4d4eSJosef Bacik !delayed_refs_rsv->full) { 584ba2c4d4eSJosef Bacik /* 585ba2c4d4eSJosef Bacik * Some people call with btrfs_start_transaction(root, 0) 586ba2c4d4eSJosef Bacik * because they can be throttled, but have some other mechanism 587ba2c4d4eSJosef Bacik * for reserving space. We still want these guys to refill the 588ba2c4d4eSJosef Bacik * delayed block_rsv so just add 1 items worth of reservation 589ba2c4d4eSJosef Bacik * here. 590ba2c4d4eSJosef Bacik */ 591ba2c4d4eSJosef Bacik ret = btrfs_delayed_refs_rsv_refill(fs_info, flush); 592b5009945SJosef Bacik if (ret) 593843fcf35SMiao Xie goto reserve_fail; 594b5009945SJosef Bacik } 595a22285a6SYan, Zheng again: 596f2f767e7SAlexandru Moise h = kmem_cache_zalloc(btrfs_trans_handle_cachep, GFP_NOFS); 597843fcf35SMiao Xie if (!h) { 598843fcf35SMiao Xie ret = -ENOMEM; 599843fcf35SMiao Xie goto alloc_fail; 600843fcf35SMiao Xie } 601a22285a6SYan, Zheng 60298114659SJosef Bacik /* 60398114659SJosef Bacik * If we are JOIN_NOLOCK we're already committing a transaction and 60498114659SJosef Bacik * waiting on this guy, so we don't need to do the sb_start_intwrite 60598114659SJosef Bacik * because we're already holding a ref. We need this because we could 60698114659SJosef Bacik * have raced in and did an fsync() on a file which can kick a commit 60798114659SJosef Bacik * and then we deadlock with somebody doing a freeze. 608354aa0fbSMiao Xie * 609354aa0fbSMiao Xie * If we are ATTACH, it means we just want to catch the current 610354aa0fbSMiao Xie * transaction and commit it, so we needn't do sb_start_intwrite(). 61198114659SJosef Bacik */ 6120860adfdSMiao Xie if (type & __TRANS_FREEZABLE) 6130b246afaSJeff Mahoney sb_start_intwrite(fs_info->sb); 614b2b5ef5cSJan Kara 6152ff7e61eSJeff Mahoney if (may_wait_transaction(fs_info, type)) 6162ff7e61eSJeff Mahoney wait_current_trans(fs_info); 617a22285a6SYan, Zheng 618a4abeea4SJosef Bacik do { 6192ff7e61eSJeff Mahoney ret = join_transaction(fs_info, type); 620178260b2SMiao Xie if (ret == -EBUSY) { 6212ff7e61eSJeff Mahoney wait_current_trans(fs_info); 622a6d155d2SFilipe Manana if (unlikely(type == TRANS_ATTACH || 623a6d155d2SFilipe Manana type == TRANS_JOIN_NOSTART)) 624178260b2SMiao Xie ret = -ENOENT; 625178260b2SMiao Xie } 626a4abeea4SJosef Bacik } while (ret == -EBUSY); 627a4abeea4SJosef Bacik 628a43f7f82SLiu Bo if (ret < 0) 629843fcf35SMiao Xie goto join_fail; 6300f7d52f4SChris Mason 6310b246afaSJeff Mahoney cur_trans = fs_info->running_transaction; 632a22285a6SYan, Zheng 633a22285a6SYan, Zheng h->transid = cur_trans->transid; 634a22285a6SYan, Zheng h->transaction = cur_trans; 635d13603efSArne Jansen h->root = root; 636b50fff81SDavid Sterba refcount_set(&h->use_count, 1); 63764b63580SJeff Mahoney h->fs_info = root->fs_info; 6387174109cSQu Wenruo 639a698d075SMiao Xie h->type = type; 640d9a0540aSFilipe Manana h->can_flush_pending_bgs = true; 641ea658badSJosef Bacik INIT_LIST_HEAD(&h->new_bgs); 642b7ec40d7SChris Mason 643a22285a6SYan, Zheng smp_mb(); 6444a9d8bdeSMiao Xie if (cur_trans->state >= TRANS_STATE_BLOCKED && 6452ff7e61eSJeff Mahoney may_wait_transaction(fs_info, type)) { 646abdd2e80SFilipe Manana current->journal_info = h; 6473a45bb20SJeff Mahoney btrfs_commit_transaction(h); 648a22285a6SYan, Zheng goto again; 649a22285a6SYan, Zheng } 6509ed74f2dSJosef Bacik 651b5009945SJosef Bacik if (num_bytes) { 6520b246afaSJeff Mahoney trace_btrfs_space_reservation(fs_info, "transaction", 6532bcc0328SLiu Bo h->transid, num_bytes, 1); 6540b246afaSJeff Mahoney h->block_rsv = &fs_info->trans_block_rsv; 655b5009945SJosef Bacik h->bytes_reserved = num_bytes; 65620dd2cbfSMiao Xie h->reloc_reserved = reloc_reserved; 657a22285a6SYan, Zheng } 658a22285a6SYan, Zheng 6592a1eb461SJosef Bacik got_it: 660a4abeea4SJosef Bacik btrfs_record_root_in_trans(h, root); 661a22285a6SYan, Zheng 662bcf3a3e7SNikolay Borisov if (!current->journal_info) 663a22285a6SYan, Zheng current->journal_info = h; 66479154b1bSChris Mason return h; 665843fcf35SMiao Xie 666843fcf35SMiao Xie join_fail: 6670860adfdSMiao Xie if (type & __TRANS_FREEZABLE) 6680b246afaSJeff Mahoney sb_end_intwrite(fs_info->sb); 669843fcf35SMiao Xie kmem_cache_free(btrfs_trans_handle_cachep, h); 670843fcf35SMiao Xie alloc_fail: 671843fcf35SMiao Xie if (num_bytes) 6722ff7e61eSJeff Mahoney btrfs_block_rsv_release(fs_info, &fs_info->trans_block_rsv, 673843fcf35SMiao Xie num_bytes); 674843fcf35SMiao Xie reserve_fail: 675733e03a0SQu Wenruo btrfs_qgroup_free_meta_pertrans(root, qgroup_reserved); 676843fcf35SMiao Xie return ERR_PTR(ret); 67779154b1bSChris Mason } 67879154b1bSChris Mason 679f9295749SChris Mason struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root, 6805aed1dd8SAlexandru Moise unsigned int num_items) 681f9295749SChris Mason { 68208e007d2SMiao Xie return start_transaction(root, num_items, TRANS_START, 683003d7c59SJeff Mahoney BTRFS_RESERVE_FLUSH_ALL, true); 684f9295749SChris Mason } 685003d7c59SJeff Mahoney 6868eab77ffSFilipe Manana struct btrfs_trans_handle *btrfs_start_transaction_fallback_global_rsv( 6878eab77ffSFilipe Manana struct btrfs_root *root, 6888eab77ffSFilipe Manana unsigned int num_items, 6898eab77ffSFilipe Manana int min_factor) 6908eab77ffSFilipe Manana { 6910b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 6928eab77ffSFilipe Manana struct btrfs_trans_handle *trans; 6938eab77ffSFilipe Manana u64 num_bytes; 6948eab77ffSFilipe Manana int ret; 6958eab77ffSFilipe Manana 696003d7c59SJeff Mahoney /* 697003d7c59SJeff Mahoney * We have two callers: unlink and block group removal. The 698003d7c59SJeff Mahoney * former should succeed even if we will temporarily exceed 699003d7c59SJeff Mahoney * quota and the latter operates on the extent root so 700003d7c59SJeff Mahoney * qgroup enforcement is ignored anyway. 701003d7c59SJeff Mahoney */ 702003d7c59SJeff Mahoney trans = start_transaction(root, num_items, TRANS_START, 703003d7c59SJeff Mahoney BTRFS_RESERVE_FLUSH_ALL, false); 7048eab77ffSFilipe Manana if (!IS_ERR(trans) || PTR_ERR(trans) != -ENOSPC) 7058eab77ffSFilipe Manana return trans; 7068eab77ffSFilipe Manana 7078eab77ffSFilipe Manana trans = btrfs_start_transaction(root, 0); 7088eab77ffSFilipe Manana if (IS_ERR(trans)) 7098eab77ffSFilipe Manana return trans; 7108eab77ffSFilipe Manana 7112bd36e7bSJosef Bacik num_bytes = btrfs_calc_insert_metadata_size(fs_info, num_items); 7120b246afaSJeff Mahoney ret = btrfs_cond_migrate_bytes(fs_info, &fs_info->trans_block_rsv, 7130b246afaSJeff Mahoney num_bytes, min_factor); 7148eab77ffSFilipe Manana if (ret) { 7153a45bb20SJeff Mahoney btrfs_end_transaction(trans); 7168eab77ffSFilipe Manana return ERR_PTR(ret); 7178eab77ffSFilipe Manana } 7188eab77ffSFilipe Manana 7190b246afaSJeff Mahoney trans->block_rsv = &fs_info->trans_block_rsv; 7208eab77ffSFilipe Manana trans->bytes_reserved = num_bytes; 7210b246afaSJeff Mahoney trace_btrfs_space_reservation(fs_info, "transaction", 72288d3a5aaSJosef Bacik trans->transid, num_bytes, 1); 7238eab77ffSFilipe Manana 7248eab77ffSFilipe Manana return trans; 7258eab77ffSFilipe Manana } 7268407aa46SMiao Xie 7277a7eaa40SJosef Bacik struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root) 728f9295749SChris Mason { 729003d7c59SJeff Mahoney return start_transaction(root, 0, TRANS_JOIN, BTRFS_RESERVE_NO_FLUSH, 730003d7c59SJeff Mahoney true); 731f9295749SChris Mason } 732f9295749SChris Mason 7337a7eaa40SJosef Bacik struct btrfs_trans_handle *btrfs_join_transaction_nolock(struct btrfs_root *root) 7340af3d00bSJosef Bacik { 735575a75d6SAlexandru Moise return start_transaction(root, 0, TRANS_JOIN_NOLOCK, 736003d7c59SJeff Mahoney BTRFS_RESERVE_NO_FLUSH, true); 7370af3d00bSJosef Bacik } 7380af3d00bSJosef Bacik 739d4edf39bSMiao Xie /* 740a6d155d2SFilipe Manana * Similar to regular join but it never starts a transaction when none is 741a6d155d2SFilipe Manana * running or after waiting for the current one to finish. 742a6d155d2SFilipe Manana */ 743a6d155d2SFilipe Manana struct btrfs_trans_handle *btrfs_join_transaction_nostart(struct btrfs_root *root) 744a6d155d2SFilipe Manana { 745a6d155d2SFilipe Manana return start_transaction(root, 0, TRANS_JOIN_NOSTART, 746a6d155d2SFilipe Manana BTRFS_RESERVE_NO_FLUSH, true); 747a6d155d2SFilipe Manana } 748a6d155d2SFilipe Manana 749a6d155d2SFilipe Manana /* 750d4edf39bSMiao Xie * btrfs_attach_transaction() - catch the running transaction 751d4edf39bSMiao Xie * 752d4edf39bSMiao Xie * It is used when we want to commit the current the transaction, but 753d4edf39bSMiao Xie * don't want to start a new one. 754d4edf39bSMiao Xie * 755d4edf39bSMiao Xie * Note: If this function return -ENOENT, it just means there is no 756d4edf39bSMiao Xie * running transaction. But it is possible that the inactive transaction 757d4edf39bSMiao Xie * is still in the memory, not fully on disk. If you hope there is no 758d4edf39bSMiao Xie * inactive transaction in the fs when -ENOENT is returned, you should 759d4edf39bSMiao Xie * invoke 760d4edf39bSMiao Xie * btrfs_attach_transaction_barrier() 761d4edf39bSMiao Xie */ 762354aa0fbSMiao Xie struct btrfs_trans_handle *btrfs_attach_transaction(struct btrfs_root *root) 76360376ce4SJosef Bacik { 764575a75d6SAlexandru Moise return start_transaction(root, 0, TRANS_ATTACH, 765003d7c59SJeff Mahoney BTRFS_RESERVE_NO_FLUSH, true); 76660376ce4SJosef Bacik } 76760376ce4SJosef Bacik 768d4edf39bSMiao Xie /* 76990b6d283SWang Sheng-Hui * btrfs_attach_transaction_barrier() - catch the running transaction 770d4edf39bSMiao Xie * 77152042d8eSAndrea Gelmini * It is similar to the above function, the difference is this one 772d4edf39bSMiao Xie * will wait for all the inactive transactions until they fully 773d4edf39bSMiao Xie * complete. 774d4edf39bSMiao Xie */ 775d4edf39bSMiao Xie struct btrfs_trans_handle * 776d4edf39bSMiao Xie btrfs_attach_transaction_barrier(struct btrfs_root *root) 777d4edf39bSMiao Xie { 778d4edf39bSMiao Xie struct btrfs_trans_handle *trans; 779d4edf39bSMiao Xie 780575a75d6SAlexandru Moise trans = start_transaction(root, 0, TRANS_ATTACH, 781003d7c59SJeff Mahoney BTRFS_RESERVE_NO_FLUSH, true); 7828d9e220cSAl Viro if (trans == ERR_PTR(-ENOENT)) 7832ff7e61eSJeff Mahoney btrfs_wait_for_commit(root->fs_info, 0); 784d4edf39bSMiao Xie 785d4edf39bSMiao Xie return trans; 786d4edf39bSMiao Xie } 787d4edf39bSMiao Xie 788d352ac68SChris Mason /* wait for a transaction commit to be fully complete */ 7892ff7e61eSJeff Mahoney static noinline void wait_for_commit(struct btrfs_transaction *commit) 79089ce8a63SChris Mason { 7914a9d8bdeSMiao Xie wait_event(commit->commit_wait, commit->state == TRANS_STATE_COMPLETED); 79289ce8a63SChris Mason } 79389ce8a63SChris Mason 7942ff7e61eSJeff Mahoney int btrfs_wait_for_commit(struct btrfs_fs_info *fs_info, u64 transid) 79546204592SSage Weil { 79646204592SSage Weil struct btrfs_transaction *cur_trans = NULL, *t; 7978cd2807fSMiao Xie int ret = 0; 79846204592SSage Weil 79946204592SSage Weil if (transid) { 8000b246afaSJeff Mahoney if (transid <= fs_info->last_trans_committed) 801a4abeea4SJosef Bacik goto out; 80246204592SSage Weil 80346204592SSage Weil /* find specified transaction */ 8040b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 8050b246afaSJeff Mahoney list_for_each_entry(t, &fs_info->trans_list, list) { 80646204592SSage Weil if (t->transid == transid) { 80746204592SSage Weil cur_trans = t; 8089b64f57dSElena Reshetova refcount_inc(&cur_trans->use_count); 8098cd2807fSMiao Xie ret = 0; 81046204592SSage Weil break; 81146204592SSage Weil } 8128cd2807fSMiao Xie if (t->transid > transid) { 8138cd2807fSMiao Xie ret = 0; 81446204592SSage Weil break; 81546204592SSage Weil } 8168cd2807fSMiao Xie } 8170b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 81842383020SSage Weil 81942383020SSage Weil /* 82042383020SSage Weil * The specified transaction doesn't exist, or we 82142383020SSage Weil * raced with btrfs_commit_transaction 82242383020SSage Weil */ 82342383020SSage Weil if (!cur_trans) { 8240b246afaSJeff Mahoney if (transid > fs_info->last_trans_committed) 82542383020SSage Weil ret = -EINVAL; 8268cd2807fSMiao Xie goto out; 82742383020SSage Weil } 82846204592SSage Weil } else { 82946204592SSage Weil /* find newest transaction that is committing | committed */ 8300b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 8310b246afaSJeff Mahoney list_for_each_entry_reverse(t, &fs_info->trans_list, 83246204592SSage Weil list) { 8334a9d8bdeSMiao Xie if (t->state >= TRANS_STATE_COMMIT_START) { 8344a9d8bdeSMiao Xie if (t->state == TRANS_STATE_COMPLETED) 8353473f3c0SJosef Bacik break; 83646204592SSage Weil cur_trans = t; 8379b64f57dSElena Reshetova refcount_inc(&cur_trans->use_count); 83846204592SSage Weil break; 83946204592SSage Weil } 84046204592SSage Weil } 8410b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 84246204592SSage Weil if (!cur_trans) 843a4abeea4SJosef Bacik goto out; /* nothing committing|committed */ 84446204592SSage Weil } 84546204592SSage Weil 8462ff7e61eSJeff Mahoney wait_for_commit(cur_trans); 847724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 848a4abeea4SJosef Bacik out: 84946204592SSage Weil return ret; 85046204592SSage Weil } 85146204592SSage Weil 8522ff7e61eSJeff Mahoney void btrfs_throttle(struct btrfs_fs_info *fs_info) 85337d1aeeeSChris Mason { 8542ff7e61eSJeff Mahoney wait_current_trans(fs_info); 85537d1aeeeSChris Mason } 85637d1aeeeSChris Mason 8572ff7e61eSJeff Mahoney static int should_end_transaction(struct btrfs_trans_handle *trans) 8588929ecfaSYan, Zheng { 8592ff7e61eSJeff Mahoney struct btrfs_fs_info *fs_info = trans->fs_info; 8600b246afaSJeff Mahoney 86164403612SJosef Bacik if (btrfs_check_space_for_delayed_refs(fs_info)) 8621be41b78SJosef Bacik return 1; 86336ba022aSJosef Bacik 8642ff7e61eSJeff Mahoney return !!btrfs_block_rsv_check(&fs_info->global_block_rsv, 5); 8658929ecfaSYan, Zheng } 8668929ecfaSYan, Zheng 8673a45bb20SJeff Mahoney int btrfs_should_end_transaction(struct btrfs_trans_handle *trans) 8688929ecfaSYan, Zheng { 8698929ecfaSYan, Zheng struct btrfs_transaction *cur_trans = trans->transaction; 8708929ecfaSYan, Zheng 871a4abeea4SJosef Bacik smp_mb(); 8724a9d8bdeSMiao Xie if (cur_trans->state >= TRANS_STATE_BLOCKED || 8734a9d8bdeSMiao Xie cur_trans->delayed_refs.flushing) 8748929ecfaSYan, Zheng return 1; 8758929ecfaSYan, Zheng 8762ff7e61eSJeff Mahoney return should_end_transaction(trans); 8778929ecfaSYan, Zheng } 8788929ecfaSYan, Zheng 879dc60c525SNikolay Borisov static void btrfs_trans_release_metadata(struct btrfs_trans_handle *trans) 880dc60c525SNikolay Borisov 8810e34693fSNikolay Borisov { 882dc60c525SNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 883dc60c525SNikolay Borisov 8840e34693fSNikolay Borisov if (!trans->block_rsv) { 8850e34693fSNikolay Borisov ASSERT(!trans->bytes_reserved); 8860e34693fSNikolay Borisov return; 8870e34693fSNikolay Borisov } 8880e34693fSNikolay Borisov 8890e34693fSNikolay Borisov if (!trans->bytes_reserved) 8900e34693fSNikolay Borisov return; 8910e34693fSNikolay Borisov 8920e34693fSNikolay Borisov ASSERT(trans->block_rsv == &fs_info->trans_block_rsv); 8930e34693fSNikolay Borisov trace_btrfs_space_reservation(fs_info, "transaction", 8940e34693fSNikolay Borisov trans->transid, trans->bytes_reserved, 0); 8950e34693fSNikolay Borisov btrfs_block_rsv_release(fs_info, trans->block_rsv, 8960e34693fSNikolay Borisov trans->bytes_reserved); 8970e34693fSNikolay Borisov trans->bytes_reserved = 0; 8980e34693fSNikolay Borisov } 8990e34693fSNikolay Borisov 90089ce8a63SChris Mason static int __btrfs_end_transaction(struct btrfs_trans_handle *trans, 9013a45bb20SJeff Mahoney int throttle) 90279154b1bSChris Mason { 9033a45bb20SJeff Mahoney struct btrfs_fs_info *info = trans->fs_info; 9048929ecfaSYan, Zheng struct btrfs_transaction *cur_trans = trans->transaction; 905a698d075SMiao Xie int lock = (trans->type != TRANS_JOIN_NOLOCK); 9064edc2ca3SDave Jones int err = 0; 907d6e4a428SChris Mason 908b50fff81SDavid Sterba if (refcount_read(&trans->use_count) > 1) { 909b50fff81SDavid Sterba refcount_dec(&trans->use_count); 9102a1eb461SJosef Bacik trans->block_rsv = trans->orig_rsv; 9112a1eb461SJosef Bacik return 0; 9122a1eb461SJosef Bacik } 9132a1eb461SJosef Bacik 914dc60c525SNikolay Borisov btrfs_trans_release_metadata(trans); 9154c13d758SJosef Bacik trans->block_rsv = NULL; 916c5567237SArne Jansen 9176c686b35SNikolay Borisov btrfs_create_pending_block_groups(trans); 918ea658badSJosef Bacik 9194fbcdf66SFilipe Manana btrfs_trans_release_chunk_metadata(trans); 9204fbcdf66SFilipe Manana 92120c7bcecSSeraphime Kirkovski if (lock && READ_ONCE(cur_trans->state) == TRANS_STATE_BLOCKED) { 9223bbb24b2SJosef Bacik if (throttle) 9233a45bb20SJeff Mahoney return btrfs_commit_transaction(trans); 9243bbb24b2SJosef Bacik else 9258929ecfaSYan, Zheng wake_up_process(info->transaction_kthread); 9268929ecfaSYan, Zheng } 9278929ecfaSYan, Zheng 9280860adfdSMiao Xie if (trans->type & __TRANS_FREEZABLE) 9290b246afaSJeff Mahoney sb_end_intwrite(info->sb); 9306df7881aSJosef Bacik 9318929ecfaSYan, Zheng WARN_ON(cur_trans != info->running_transaction); 93213c5a93eSJosef Bacik WARN_ON(atomic_read(&cur_trans->num_writers) < 1); 93313c5a93eSJosef Bacik atomic_dec(&cur_trans->num_writers); 9340860adfdSMiao Xie extwriter_counter_dec(cur_trans, trans->type); 93589ce8a63SChris Mason 936093258e6SDavid Sterba cond_wake_up(&cur_trans->writer_wait); 937724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 9389ed74f2dSJosef Bacik 9399ed74f2dSJosef Bacik if (current->journal_info == trans) 9409ed74f2dSJosef Bacik current->journal_info = NULL; 941ab78c84dSChris Mason 94224bbcf04SYan, Zheng if (throttle) 9432ff7e61eSJeff Mahoney btrfs_run_delayed_iputs(info); 94424bbcf04SYan, Zheng 94549b25e05SJeff Mahoney if (trans->aborted || 9460b246afaSJeff Mahoney test_bit(BTRFS_FS_STATE_ERROR, &info->fs_state)) { 9474e121c06SJosef Bacik wake_up_process(info->transaction_kthread); 9484edc2ca3SDave Jones err = -EIO; 9494e121c06SJosef Bacik } 95049b25e05SJeff Mahoney 9514edc2ca3SDave Jones kmem_cache_free(btrfs_trans_handle_cachep, trans); 9524edc2ca3SDave Jones return err; 95379154b1bSChris Mason } 95479154b1bSChris Mason 9553a45bb20SJeff Mahoney int btrfs_end_transaction(struct btrfs_trans_handle *trans) 95689ce8a63SChris Mason { 9573a45bb20SJeff Mahoney return __btrfs_end_transaction(trans, 0); 95889ce8a63SChris Mason } 95989ce8a63SChris Mason 9603a45bb20SJeff Mahoney int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans) 96189ce8a63SChris Mason { 9623a45bb20SJeff Mahoney return __btrfs_end_transaction(trans, 1); 96316cdcec7SMiao Xie } 96416cdcec7SMiao Xie 965d352ac68SChris Mason /* 966d352ac68SChris Mason * when btree blocks are allocated, they have some corresponding bits set for 967d352ac68SChris Mason * them in one of two extent_io trees. This is used to make sure all of 968690587d1SChris Mason * those extents are sent to disk but does not wait on them 969d352ac68SChris Mason */ 9702ff7e61eSJeff Mahoney int btrfs_write_marked_extents(struct btrfs_fs_info *fs_info, 9718cef4e16SYan, Zheng struct extent_io_tree *dirty_pages, int mark) 97279154b1bSChris Mason { 973777e6bd7SChris Mason int err = 0; 9747c4452b9SChris Mason int werr = 0; 9750b246afaSJeff Mahoney struct address_space *mapping = fs_info->btree_inode->i_mapping; 976e6138876SJosef Bacik struct extent_state *cached_state = NULL; 977777e6bd7SChris Mason u64 start = 0; 9785f39d397SChris Mason u64 end; 9797c4452b9SChris Mason 9806300463bSLiu Bo atomic_inc(&BTRFS_I(fs_info->btree_inode)->sync_writers); 9811728366eSJosef Bacik while (!find_first_extent_bit(dirty_pages, start, &start, &end, 982e6138876SJosef Bacik mark, &cached_state)) { 983663dfbb0SFilipe Manana bool wait_writeback = false; 984663dfbb0SFilipe Manana 985663dfbb0SFilipe Manana err = convert_extent_bit(dirty_pages, start, end, 986663dfbb0SFilipe Manana EXTENT_NEED_WAIT, 987210aa277SDavid Sterba mark, &cached_state); 988663dfbb0SFilipe Manana /* 989663dfbb0SFilipe Manana * convert_extent_bit can return -ENOMEM, which is most of the 990663dfbb0SFilipe Manana * time a temporary error. So when it happens, ignore the error 991663dfbb0SFilipe Manana * and wait for writeback of this range to finish - because we 992663dfbb0SFilipe Manana * failed to set the bit EXTENT_NEED_WAIT for the range, a call 993bf89d38fSJeff Mahoney * to __btrfs_wait_marked_extents() would not know that 994bf89d38fSJeff Mahoney * writeback for this range started and therefore wouldn't 995bf89d38fSJeff Mahoney * wait for it to finish - we don't want to commit a 996bf89d38fSJeff Mahoney * superblock that points to btree nodes/leafs for which 997bf89d38fSJeff Mahoney * writeback hasn't finished yet (and without errors). 998663dfbb0SFilipe Manana * We cleanup any entries left in the io tree when committing 99941e7acd3SNikolay Borisov * the transaction (through extent_io_tree_release()). 1000663dfbb0SFilipe Manana */ 1001663dfbb0SFilipe Manana if (err == -ENOMEM) { 1002663dfbb0SFilipe Manana err = 0; 1003663dfbb0SFilipe Manana wait_writeback = true; 1004663dfbb0SFilipe Manana } 1005663dfbb0SFilipe Manana if (!err) 10061728366eSJosef Bacik err = filemap_fdatawrite_range(mapping, start, end); 10077c4452b9SChris Mason if (err) 10087c4452b9SChris Mason werr = err; 1009663dfbb0SFilipe Manana else if (wait_writeback) 1010663dfbb0SFilipe Manana werr = filemap_fdatawait_range(mapping, start, end); 1011e38e2ed7SFilipe Manana free_extent_state(cached_state); 1012663dfbb0SFilipe Manana cached_state = NULL; 10131728366eSJosef Bacik cond_resched(); 10141728366eSJosef Bacik start = end + 1; 10157c4452b9SChris Mason } 10166300463bSLiu Bo atomic_dec(&BTRFS_I(fs_info->btree_inode)->sync_writers); 1017690587d1SChris Mason return werr; 1018690587d1SChris Mason } 1019690587d1SChris Mason 1020690587d1SChris Mason /* 1021690587d1SChris Mason * when btree blocks are allocated, they have some corresponding bits set for 1022690587d1SChris Mason * them in one of two extent_io trees. This is used to make sure all of 1023690587d1SChris Mason * those extents are on disk for transaction or log commit. We wait 1024690587d1SChris Mason * on all the pages and clear them from the dirty pages state tree 1025690587d1SChris Mason */ 1026bf89d38fSJeff Mahoney static int __btrfs_wait_marked_extents(struct btrfs_fs_info *fs_info, 1027bf89d38fSJeff Mahoney struct extent_io_tree *dirty_pages) 1028690587d1SChris Mason { 1029690587d1SChris Mason int err = 0; 1030690587d1SChris Mason int werr = 0; 10310b246afaSJeff Mahoney struct address_space *mapping = fs_info->btree_inode->i_mapping; 1032e6138876SJosef Bacik struct extent_state *cached_state = NULL; 1033690587d1SChris Mason u64 start = 0; 1034690587d1SChris Mason u64 end; 1035690587d1SChris Mason 10361728366eSJosef Bacik while (!find_first_extent_bit(dirty_pages, start, &start, &end, 1037e6138876SJosef Bacik EXTENT_NEED_WAIT, &cached_state)) { 1038663dfbb0SFilipe Manana /* 1039663dfbb0SFilipe Manana * Ignore -ENOMEM errors returned by clear_extent_bit(). 1040663dfbb0SFilipe Manana * When committing the transaction, we'll remove any entries 1041663dfbb0SFilipe Manana * left in the io tree. For a log commit, we don't remove them 1042663dfbb0SFilipe Manana * after committing the log because the tree can be accessed 1043663dfbb0SFilipe Manana * concurrently - we do it only at transaction commit time when 104441e7acd3SNikolay Borisov * it's safe to do it (through extent_io_tree_release()). 1045663dfbb0SFilipe Manana */ 1046663dfbb0SFilipe Manana err = clear_extent_bit(dirty_pages, start, end, 1047ae0f1625SDavid Sterba EXTENT_NEED_WAIT, 0, 0, &cached_state); 1048663dfbb0SFilipe Manana if (err == -ENOMEM) 1049663dfbb0SFilipe Manana err = 0; 1050663dfbb0SFilipe Manana if (!err) 10511728366eSJosef Bacik err = filemap_fdatawait_range(mapping, start, end); 1052777e6bd7SChris Mason if (err) 1053777e6bd7SChris Mason werr = err; 1054e38e2ed7SFilipe Manana free_extent_state(cached_state); 1055e38e2ed7SFilipe Manana cached_state = NULL; 1056777e6bd7SChris Mason cond_resched(); 10571728366eSJosef Bacik start = end + 1; 1058777e6bd7SChris Mason } 10597c4452b9SChris Mason if (err) 10607c4452b9SChris Mason werr = err; 1061bf89d38fSJeff Mahoney return werr; 1062bf89d38fSJeff Mahoney } 1063656f30dbSFilipe Manana 1064b9fae2ebSFilipe Manana static int btrfs_wait_extents(struct btrfs_fs_info *fs_info, 1065bf89d38fSJeff Mahoney struct extent_io_tree *dirty_pages) 1066bf89d38fSJeff Mahoney { 1067bf89d38fSJeff Mahoney bool errors = false; 1068bf89d38fSJeff Mahoney int err; 1069bf89d38fSJeff Mahoney 1070bf89d38fSJeff Mahoney err = __btrfs_wait_marked_extents(fs_info, dirty_pages); 1071bf89d38fSJeff Mahoney if (test_and_clear_bit(BTRFS_FS_BTREE_ERR, &fs_info->flags)) 1072bf89d38fSJeff Mahoney errors = true; 1073bf89d38fSJeff Mahoney 1074bf89d38fSJeff Mahoney if (errors && !err) 1075bf89d38fSJeff Mahoney err = -EIO; 1076bf89d38fSJeff Mahoney return err; 1077bf89d38fSJeff Mahoney } 1078bf89d38fSJeff Mahoney 1079bf89d38fSJeff Mahoney int btrfs_wait_tree_log_extents(struct btrfs_root *log_root, int mark) 1080bf89d38fSJeff Mahoney { 1081bf89d38fSJeff Mahoney struct btrfs_fs_info *fs_info = log_root->fs_info; 1082bf89d38fSJeff Mahoney struct extent_io_tree *dirty_pages = &log_root->dirty_log_pages; 1083bf89d38fSJeff Mahoney bool errors = false; 1084bf89d38fSJeff Mahoney int err; 1085bf89d38fSJeff Mahoney 1086bf89d38fSJeff Mahoney ASSERT(log_root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID); 1087bf89d38fSJeff Mahoney 1088bf89d38fSJeff Mahoney err = __btrfs_wait_marked_extents(fs_info, dirty_pages); 1089656f30dbSFilipe Manana if ((mark & EXTENT_DIRTY) && 10900b246afaSJeff Mahoney test_and_clear_bit(BTRFS_FS_LOG1_ERR, &fs_info->flags)) 1091656f30dbSFilipe Manana errors = true; 1092656f30dbSFilipe Manana 1093656f30dbSFilipe Manana if ((mark & EXTENT_NEW) && 10940b246afaSJeff Mahoney test_and_clear_bit(BTRFS_FS_LOG2_ERR, &fs_info->flags)) 1095656f30dbSFilipe Manana errors = true; 1096656f30dbSFilipe Manana 1097bf89d38fSJeff Mahoney if (errors && !err) 1098bf89d38fSJeff Mahoney err = -EIO; 1099bf89d38fSJeff Mahoney return err; 110079154b1bSChris Mason } 110179154b1bSChris Mason 1102690587d1SChris Mason /* 1103c9b577c0SNikolay Borisov * When btree blocks are allocated the corresponding extents are marked dirty. 1104c9b577c0SNikolay Borisov * This function ensures such extents are persisted on disk for transaction or 1105c9b577c0SNikolay Borisov * log commit. 1106c9b577c0SNikolay Borisov * 1107c9b577c0SNikolay Borisov * @trans: transaction whose dirty pages we'd like to write 1108690587d1SChris Mason */ 110970458a58SNikolay Borisov static int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans) 1110d0c803c4SChris Mason { 1111663dfbb0SFilipe Manana int ret; 1112c9b577c0SNikolay Borisov int ret2; 1113c9b577c0SNikolay Borisov struct extent_io_tree *dirty_pages = &trans->transaction->dirty_pages; 111470458a58SNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 1115c9b577c0SNikolay Borisov struct blk_plug plug; 1116663dfbb0SFilipe Manana 1117c9b577c0SNikolay Borisov blk_start_plug(&plug); 1118c9b577c0SNikolay Borisov ret = btrfs_write_marked_extents(fs_info, dirty_pages, EXTENT_DIRTY); 1119c9b577c0SNikolay Borisov blk_finish_plug(&plug); 1120c9b577c0SNikolay Borisov ret2 = btrfs_wait_extents(fs_info, dirty_pages); 1121c9b577c0SNikolay Borisov 112241e7acd3SNikolay Borisov extent_io_tree_release(&trans->transaction->dirty_pages); 1123663dfbb0SFilipe Manana 1124c9b577c0SNikolay Borisov if (ret) 1125663dfbb0SFilipe Manana return ret; 1126c9b577c0SNikolay Borisov else if (ret2) 1127c9b577c0SNikolay Borisov return ret2; 1128c9b577c0SNikolay Borisov else 1129c9b577c0SNikolay Borisov return 0; 1130d0c803c4SChris Mason } 1131d0c803c4SChris Mason 1132d352ac68SChris Mason /* 1133d352ac68SChris Mason * this is used to update the root pointer in the tree of tree roots. 1134d352ac68SChris Mason * 1135d352ac68SChris Mason * But, in the case of the extent allocation tree, updating the root 1136d352ac68SChris Mason * pointer may allocate blocks which may change the root of the extent 1137d352ac68SChris Mason * allocation tree. 1138d352ac68SChris Mason * 1139d352ac68SChris Mason * So, this loops and repeats and makes sure the cowonly root didn't 1140d352ac68SChris Mason * change while the root pointer was being updated in the metadata. 1141d352ac68SChris Mason */ 11420b86a832SChris Mason static int update_cowonly_root(struct btrfs_trans_handle *trans, 114379154b1bSChris Mason struct btrfs_root *root) 114479154b1bSChris Mason { 114579154b1bSChris Mason int ret; 11460b86a832SChris Mason u64 old_root_bytenr; 114786b9f2ecSYan, Zheng u64 old_root_used; 11480b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 11490b246afaSJeff Mahoney struct btrfs_root *tree_root = fs_info->tree_root; 115079154b1bSChris Mason 115186b9f2ecSYan, Zheng old_root_used = btrfs_root_used(&root->root_item); 115256bec294SChris Mason 115379154b1bSChris Mason while (1) { 11540b86a832SChris Mason old_root_bytenr = btrfs_root_bytenr(&root->root_item); 115586b9f2ecSYan, Zheng if (old_root_bytenr == root->node->start && 1156ea526d18SJosef Bacik old_root_used == btrfs_root_used(&root->root_item)) 115779154b1bSChris Mason break; 115887ef2bb4SChris Mason 11595d4f98a2SYan Zheng btrfs_set_root_node(&root->root_item, root->node); 116079154b1bSChris Mason ret = btrfs_update_root(trans, tree_root, 11610b86a832SChris Mason &root->root_key, 11620b86a832SChris Mason &root->root_item); 116349b25e05SJeff Mahoney if (ret) 116449b25e05SJeff Mahoney return ret; 116556bec294SChris Mason 116686b9f2ecSYan, Zheng old_root_used = btrfs_root_used(&root->root_item); 1167e7070be1SJosef Bacik } 1168276e680dSYan Zheng 11690b86a832SChris Mason return 0; 11700b86a832SChris Mason } 11710b86a832SChris Mason 1172d352ac68SChris Mason /* 1173d352ac68SChris Mason * update all the cowonly tree roots on disk 117449b25e05SJeff Mahoney * 117549b25e05SJeff Mahoney * The error handling in this function may not be obvious. Any of the 117649b25e05SJeff Mahoney * failures will cause the file system to go offline. We still need 117749b25e05SJeff Mahoney * to clean up the delayed refs. 1178d352ac68SChris Mason */ 11799386d8bcSNikolay Borisov static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans) 11800b86a832SChris Mason { 11819386d8bcSNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 1182ea526d18SJosef Bacik struct list_head *dirty_bgs = &trans->transaction->dirty_bgs; 11831bbc621eSChris Mason struct list_head *io_bgs = &trans->transaction->io_bgs; 11840b86a832SChris Mason struct list_head *next; 118584234f3aSYan Zheng struct extent_buffer *eb; 118656bec294SChris Mason int ret; 118784234f3aSYan Zheng 118884234f3aSYan Zheng eb = btrfs_lock_root_node(fs_info->tree_root); 118949b25e05SJeff Mahoney ret = btrfs_cow_block(trans, fs_info->tree_root, eb, NULL, 119049b25e05SJeff Mahoney 0, &eb); 119184234f3aSYan Zheng btrfs_tree_unlock(eb); 119284234f3aSYan Zheng free_extent_buffer(eb); 11930b86a832SChris Mason 119449b25e05SJeff Mahoney if (ret) 119549b25e05SJeff Mahoney return ret; 119649b25e05SJeff Mahoney 1197c79a70b1SNikolay Borisov ret = btrfs_run_delayed_refs(trans, (unsigned long)-1); 119849b25e05SJeff Mahoney if (ret) 119949b25e05SJeff Mahoney return ret; 120087ef2bb4SChris Mason 1201196c9d8dSDavid Sterba ret = btrfs_run_dev_stats(trans); 1202c16ce190SJosef Bacik if (ret) 1203c16ce190SJosef Bacik return ret; 12042b584c68SDavid Sterba ret = btrfs_run_dev_replace(trans); 1205c16ce190SJosef Bacik if (ret) 1206c16ce190SJosef Bacik return ret; 1207280f8bd2SLu Fengqi ret = btrfs_run_qgroups(trans); 1208c16ce190SJosef Bacik if (ret) 1209c16ce190SJosef Bacik return ret; 1210546adb0dSJan Schmidt 1211bbebb3e0SDavid Sterba ret = btrfs_setup_space_cache(trans); 1212dcdf7f6dSJosef Bacik if (ret) 1213dcdf7f6dSJosef Bacik return ret; 1214dcdf7f6dSJosef Bacik 1215546adb0dSJan Schmidt /* run_qgroups might have added some more refs */ 1216c79a70b1SNikolay Borisov ret = btrfs_run_delayed_refs(trans, (unsigned long)-1); 1217c16ce190SJosef Bacik if (ret) 1218c16ce190SJosef Bacik return ret; 1219ea526d18SJosef Bacik again: 12200b86a832SChris Mason while (!list_empty(&fs_info->dirty_cowonly_roots)) { 12212ff7e61eSJeff Mahoney struct btrfs_root *root; 12220b86a832SChris Mason next = fs_info->dirty_cowonly_roots.next; 12230b86a832SChris Mason list_del_init(next); 12240b86a832SChris Mason root = list_entry(next, struct btrfs_root, dirty_list); 1225e7070be1SJosef Bacik clear_bit(BTRFS_ROOT_DIRTY, &root->state); 122687ef2bb4SChris Mason 12279e351cc8SJosef Bacik if (root != fs_info->extent_root) 12289e351cc8SJosef Bacik list_add_tail(&root->dirty_list, 12299e351cc8SJosef Bacik &trans->transaction->switch_commits); 123049b25e05SJeff Mahoney ret = update_cowonly_root(trans, root); 123149b25e05SJeff Mahoney if (ret) 123249b25e05SJeff Mahoney return ret; 1233c79a70b1SNikolay Borisov ret = btrfs_run_delayed_refs(trans, (unsigned long)-1); 1234ea526d18SJosef Bacik if (ret) 1235ea526d18SJosef Bacik return ret; 123679154b1bSChris Mason } 1237276e680dSYan Zheng 12381bbc621eSChris Mason while (!list_empty(dirty_bgs) || !list_empty(io_bgs)) { 12395742d15fSDavid Sterba ret = btrfs_write_dirty_block_groups(trans); 1240ea526d18SJosef Bacik if (ret) 1241ea526d18SJosef Bacik return ret; 1242c79a70b1SNikolay Borisov ret = btrfs_run_delayed_refs(trans, (unsigned long)-1); 1243ea526d18SJosef Bacik if (ret) 1244ea526d18SJosef Bacik return ret; 1245ea526d18SJosef Bacik } 1246ea526d18SJosef Bacik 1247ea526d18SJosef Bacik if (!list_empty(&fs_info->dirty_cowonly_roots)) 1248ea526d18SJosef Bacik goto again; 1249ea526d18SJosef Bacik 12509e351cc8SJosef Bacik list_add_tail(&fs_info->extent_root->dirty_list, 12519e351cc8SJosef Bacik &trans->transaction->switch_commits); 12529f6cbcbbSDavid Sterba 12539f6cbcbbSDavid Sterba /* Update dev-replace pointer once everything is committed */ 12549f6cbcbbSDavid Sterba fs_info->dev_replace.committed_cursor_left = 12559f6cbcbbSDavid Sterba fs_info->dev_replace.cursor_left_last_write_of_item; 12568dabb742SStefan Behrens 125779154b1bSChris Mason return 0; 125879154b1bSChris Mason } 125979154b1bSChris Mason 1260d352ac68SChris Mason /* 1261d352ac68SChris Mason * dead roots are old snapshots that need to be deleted. This allocates 1262d352ac68SChris Mason * a dirty root struct and adds it into the list of dead roots that need to 1263d352ac68SChris Mason * be deleted 1264d352ac68SChris Mason */ 1265cfad392bSJosef Bacik void btrfs_add_dead_root(struct btrfs_root *root) 12665eda7b5eSChris Mason { 12670b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 12680b246afaSJeff Mahoney 12690b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 1270cfad392bSJosef Bacik if (list_empty(&root->root_list)) 12710b246afaSJeff Mahoney list_add_tail(&root->root_list, &fs_info->dead_roots); 12720b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 12735eda7b5eSChris Mason } 12745eda7b5eSChris Mason 1275d352ac68SChris Mason /* 12765d4f98a2SYan Zheng * update all the cowonly tree roots on disk 1277d352ac68SChris Mason */ 12787e4443d9SNikolay Borisov static noinline int commit_fs_roots(struct btrfs_trans_handle *trans) 12790f7d52f4SChris Mason { 12807e4443d9SNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 12810f7d52f4SChris Mason struct btrfs_root *gang[8]; 12820f7d52f4SChris Mason int i; 12830f7d52f4SChris Mason int ret; 128454aa1f4dSChris Mason int err = 0; 128554aa1f4dSChris Mason 1286a4abeea4SJosef Bacik spin_lock(&fs_info->fs_roots_radix_lock); 12870f7d52f4SChris Mason while (1) { 12885d4f98a2SYan Zheng ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix, 12895d4f98a2SYan Zheng (void **)gang, 0, 12900f7d52f4SChris Mason ARRAY_SIZE(gang), 12910f7d52f4SChris Mason BTRFS_ROOT_TRANS_TAG); 12920f7d52f4SChris Mason if (ret == 0) 12930f7d52f4SChris Mason break; 12940f7d52f4SChris Mason for (i = 0; i < ret; i++) { 12955b4aacefSJeff Mahoney struct btrfs_root *root = gang[i]; 12965d4f98a2SYan Zheng radix_tree_tag_clear(&fs_info->fs_roots_radix, 12972619ba1fSChris Mason (unsigned long)root->root_key.objectid, 12980f7d52f4SChris Mason BTRFS_ROOT_TRANS_TAG); 1299a4abeea4SJosef Bacik spin_unlock(&fs_info->fs_roots_radix_lock); 130031153d81SYan Zheng 1301e02119d5SChris Mason btrfs_free_log(trans, root); 13025d4f98a2SYan Zheng btrfs_update_reloc_root(trans, root); 1303e02119d5SChris Mason 130482d5902dSLi Zefan btrfs_save_ino_cache(root, trans); 130582d5902dSLi Zefan 1306f1ebcc74SLiu Bo /* see comments in should_cow_block() */ 130727cdeb70SMiao Xie clear_bit(BTRFS_ROOT_FORCE_COW, &root->state); 1308c7548af6SChris Mason smp_mb__after_atomic(); 1309f1ebcc74SLiu Bo 1310978d910dSYan Zheng if (root->commit_root != root->node) { 13119e351cc8SJosef Bacik list_add_tail(&root->dirty_list, 13129e351cc8SJosef Bacik &trans->transaction->switch_commits); 1313978d910dSYan Zheng btrfs_set_root_node(&root->root_item, 1314978d910dSYan Zheng root->node); 1315978d910dSYan Zheng } 131631153d81SYan Zheng 13175d4f98a2SYan Zheng err = btrfs_update_root(trans, fs_info->tree_root, 13180f7d52f4SChris Mason &root->root_key, 13190f7d52f4SChris Mason &root->root_item); 1320a4abeea4SJosef Bacik spin_lock(&fs_info->fs_roots_radix_lock); 132154aa1f4dSChris Mason if (err) 132254aa1f4dSChris Mason break; 1323733e03a0SQu Wenruo btrfs_qgroup_free_meta_all_pertrans(root); 13240f7d52f4SChris Mason } 13259f3a7427SChris Mason } 1326a4abeea4SJosef Bacik spin_unlock(&fs_info->fs_roots_radix_lock); 132754aa1f4dSChris Mason return err; 13280f7d52f4SChris Mason } 13290f7d52f4SChris Mason 1330d352ac68SChris Mason /* 1331de78b51aSEric Sandeen * defrag a given btree. 1332de78b51aSEric Sandeen * Every leaf in the btree is read and defragged. 1333d352ac68SChris Mason */ 1334de78b51aSEric Sandeen int btrfs_defrag_root(struct btrfs_root *root) 1335e9d0b13bSChris Mason { 1336e9d0b13bSChris Mason struct btrfs_fs_info *info = root->fs_info; 1337e9d0b13bSChris Mason struct btrfs_trans_handle *trans; 13388929ecfaSYan, Zheng int ret; 1339e9d0b13bSChris Mason 134027cdeb70SMiao Xie if (test_and_set_bit(BTRFS_ROOT_DEFRAG_RUNNING, &root->state)) 1341e9d0b13bSChris Mason return 0; 13428929ecfaSYan, Zheng 13436b80053dSChris Mason while (1) { 13448929ecfaSYan, Zheng trans = btrfs_start_transaction(root, 0); 13458929ecfaSYan, Zheng if (IS_ERR(trans)) 13468929ecfaSYan, Zheng return PTR_ERR(trans); 13478929ecfaSYan, Zheng 1348de78b51aSEric Sandeen ret = btrfs_defrag_leaves(trans, root); 13498929ecfaSYan, Zheng 13503a45bb20SJeff Mahoney btrfs_end_transaction(trans); 13512ff7e61eSJeff Mahoney btrfs_btree_balance_dirty(info); 1352e9d0b13bSChris Mason cond_resched(); 1353e9d0b13bSChris Mason 1354ab8d0fc4SJeff Mahoney if (btrfs_fs_closing(info) || ret != -EAGAIN) 1355e9d0b13bSChris Mason break; 1356210549ebSDavid Sterba 1357ab8d0fc4SJeff Mahoney if (btrfs_defrag_cancelled(info)) { 1358ab8d0fc4SJeff Mahoney btrfs_debug(info, "defrag_root cancelled"); 1359210549ebSDavid Sterba ret = -EAGAIN; 1360210549ebSDavid Sterba break; 1361210549ebSDavid Sterba } 1362e9d0b13bSChris Mason } 136327cdeb70SMiao Xie clear_bit(BTRFS_ROOT_DEFRAG_RUNNING, &root->state); 13648929ecfaSYan, Zheng return ret; 1365e9d0b13bSChris Mason } 1366e9d0b13bSChris Mason 1367d352ac68SChris Mason /* 13686426c7adSQu Wenruo * Do all special snapshot related qgroup dirty hack. 13696426c7adSQu Wenruo * 13706426c7adSQu Wenruo * Will do all needed qgroup inherit and dirty hack like switch commit 13716426c7adSQu Wenruo * roots inside one transaction and write all btree into disk, to make 13726426c7adSQu Wenruo * qgroup works. 13736426c7adSQu Wenruo */ 13746426c7adSQu Wenruo static int qgroup_account_snapshot(struct btrfs_trans_handle *trans, 13756426c7adSQu Wenruo struct btrfs_root *src, 13766426c7adSQu Wenruo struct btrfs_root *parent, 13776426c7adSQu Wenruo struct btrfs_qgroup_inherit *inherit, 13786426c7adSQu Wenruo u64 dst_objectid) 13796426c7adSQu Wenruo { 13806426c7adSQu Wenruo struct btrfs_fs_info *fs_info = src->fs_info; 13816426c7adSQu Wenruo int ret; 13826426c7adSQu Wenruo 13836426c7adSQu Wenruo /* 13846426c7adSQu Wenruo * Save some performance in the case that qgroups are not 13856426c7adSQu Wenruo * enabled. If this check races with the ioctl, rescan will 13866426c7adSQu Wenruo * kick in anyway. 13876426c7adSQu Wenruo */ 13889ea6e2b5SDavid Sterba if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags)) 13896426c7adSQu Wenruo return 0; 13906426c7adSQu Wenruo 13916426c7adSQu Wenruo /* 139252042d8eSAndrea Gelmini * Ensure dirty @src will be committed. Or, after coming 13934d31778aSQu Wenruo * commit_fs_roots() and switch_commit_roots(), any dirty but not 13944d31778aSQu Wenruo * recorded root will never be updated again, causing an outdated root 13954d31778aSQu Wenruo * item. 13964d31778aSQu Wenruo */ 13974d31778aSQu Wenruo record_root_in_trans(trans, src, 1); 13984d31778aSQu Wenruo 13994d31778aSQu Wenruo /* 14006426c7adSQu Wenruo * We are going to commit transaction, see btrfs_commit_transaction() 14016426c7adSQu Wenruo * comment for reason locking tree_log_mutex 14026426c7adSQu Wenruo */ 14036426c7adSQu Wenruo mutex_lock(&fs_info->tree_log_mutex); 14046426c7adSQu Wenruo 14057e4443d9SNikolay Borisov ret = commit_fs_roots(trans); 14066426c7adSQu Wenruo if (ret) 14076426c7adSQu Wenruo goto out; 1408460fb20aSNikolay Borisov ret = btrfs_qgroup_account_extents(trans); 14096426c7adSQu Wenruo if (ret < 0) 14106426c7adSQu Wenruo goto out; 14116426c7adSQu Wenruo 14126426c7adSQu Wenruo /* Now qgroup are all updated, we can inherit it to new qgroups */ 1413a9377422SLu Fengqi ret = btrfs_qgroup_inherit(trans, src->root_key.objectid, dst_objectid, 14146426c7adSQu Wenruo inherit); 14156426c7adSQu Wenruo if (ret < 0) 14166426c7adSQu Wenruo goto out; 14176426c7adSQu Wenruo 14186426c7adSQu Wenruo /* 14196426c7adSQu Wenruo * Now we do a simplified commit transaction, which will: 14206426c7adSQu Wenruo * 1) commit all subvolume and extent tree 14216426c7adSQu Wenruo * To ensure all subvolume and extent tree have a valid 14226426c7adSQu Wenruo * commit_root to accounting later insert_dir_item() 14236426c7adSQu Wenruo * 2) write all btree blocks onto disk 14246426c7adSQu Wenruo * This is to make sure later btree modification will be cowed 14256426c7adSQu Wenruo * Or commit_root can be populated and cause wrong qgroup numbers 14266426c7adSQu Wenruo * In this simplified commit, we don't really care about other trees 14276426c7adSQu Wenruo * like chunk and root tree, as they won't affect qgroup. 14286426c7adSQu Wenruo * And we don't write super to avoid half committed status. 14296426c7adSQu Wenruo */ 14309386d8bcSNikolay Borisov ret = commit_cowonly_roots(trans); 14316426c7adSQu Wenruo if (ret) 14326426c7adSQu Wenruo goto out; 143316916a88SNikolay Borisov switch_commit_roots(trans->transaction); 143470458a58SNikolay Borisov ret = btrfs_write_and_wait_transaction(trans); 14356426c7adSQu Wenruo if (ret) 1436f7af3934SDavid Sterba btrfs_handle_fs_error(fs_info, ret, 14376426c7adSQu Wenruo "Error while writing out transaction for qgroup"); 14386426c7adSQu Wenruo 14396426c7adSQu Wenruo out: 14406426c7adSQu Wenruo mutex_unlock(&fs_info->tree_log_mutex); 14416426c7adSQu Wenruo 14426426c7adSQu Wenruo /* 14436426c7adSQu Wenruo * Force parent root to be updated, as we recorded it before so its 14446426c7adSQu Wenruo * last_trans == cur_transid. 14456426c7adSQu Wenruo * Or it won't be committed again onto disk after later 14466426c7adSQu Wenruo * insert_dir_item() 14476426c7adSQu Wenruo */ 14486426c7adSQu Wenruo if (!ret) 14496426c7adSQu Wenruo record_root_in_trans(trans, parent, 1); 14506426c7adSQu Wenruo return ret; 14516426c7adSQu Wenruo } 14526426c7adSQu Wenruo 14536426c7adSQu Wenruo /* 1454d352ac68SChris Mason * new snapshots need to be created at a very specific time in the 1455aec8030aSMiao Xie * transaction commit. This does the actual creation. 1456aec8030aSMiao Xie * 1457aec8030aSMiao Xie * Note: 1458aec8030aSMiao Xie * If the error which may affect the commitment of the current transaction 1459aec8030aSMiao Xie * happens, we should return the error number. If the error which just affect 1460aec8030aSMiao Xie * the creation of the pending snapshots, just return 0. 1461d352ac68SChris Mason */ 146280b6794dSChris Mason static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans, 14633063d29fSChris Mason struct btrfs_pending_snapshot *pending) 14643063d29fSChris Mason { 146508d50ca3SNikolay Borisov 146608d50ca3SNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 14673063d29fSChris Mason struct btrfs_key key; 146880b6794dSChris Mason struct btrfs_root_item *new_root_item; 14693063d29fSChris Mason struct btrfs_root *tree_root = fs_info->tree_root; 14703063d29fSChris Mason struct btrfs_root *root = pending->root; 14716bdb72deSSage Weil struct btrfs_root *parent_root; 147298c9942aSLiu Bo struct btrfs_block_rsv *rsv; 14736bdb72deSSage Weil struct inode *parent_inode; 147442874b3dSMiao Xie struct btrfs_path *path; 147542874b3dSMiao Xie struct btrfs_dir_item *dir_item; 1476a22285a6SYan, Zheng struct dentry *dentry; 14773063d29fSChris Mason struct extent_buffer *tmp; 1478925baeddSChris Mason struct extent_buffer *old; 147995582b00SDeepa Dinamani struct timespec64 cur_time; 1480aec8030aSMiao Xie int ret = 0; 1481d68fc57bSYan, Zheng u64 to_reserve = 0; 14826bdb72deSSage Weil u64 index = 0; 1483a22285a6SYan, Zheng u64 objectid; 1484b83cc969SLi Zefan u64 root_flags; 14858ea05e3aSAlexander Block uuid_le new_uuid; 14863063d29fSChris Mason 14878546b570SDavid Sterba ASSERT(pending->path); 14888546b570SDavid Sterba path = pending->path; 148942874b3dSMiao Xie 1490b0c0ea63SDavid Sterba ASSERT(pending->root_item); 1491b0c0ea63SDavid Sterba new_root_item = pending->root_item; 1492a22285a6SYan, Zheng 1493aec8030aSMiao Xie pending->error = btrfs_find_free_objectid(tree_root, &objectid); 1494aec8030aSMiao Xie if (pending->error) 14956fa9700eSMiao Xie goto no_free_objectid; 14963063d29fSChris Mason 1497d6726335SQu Wenruo /* 1498d6726335SQu Wenruo * Make qgroup to skip current new snapshot's qgroupid, as it is 1499d6726335SQu Wenruo * accounted by later btrfs_qgroup_inherit(). 1500d6726335SQu Wenruo */ 1501d6726335SQu Wenruo btrfs_set_skip_qgroup(trans, objectid); 1502d6726335SQu Wenruo 1503147d256eSZhaolei btrfs_reloc_pre_snapshot(pending, &to_reserve); 1504d68fc57bSYan, Zheng 1505d68fc57bSYan, Zheng if (to_reserve > 0) { 1506aec8030aSMiao Xie pending->error = btrfs_block_rsv_add(root, 1507aec8030aSMiao Xie &pending->block_rsv, 150808e007d2SMiao Xie to_reserve, 150908e007d2SMiao Xie BTRFS_RESERVE_NO_FLUSH); 1510aec8030aSMiao Xie if (pending->error) 1511d6726335SQu Wenruo goto clear_skip_qgroup; 1512d68fc57bSYan, Zheng } 1513d68fc57bSYan, Zheng 15143063d29fSChris Mason key.objectid = objectid; 1515a22285a6SYan, Zheng key.offset = (u64)-1; 1516a22285a6SYan, Zheng key.type = BTRFS_ROOT_ITEM_KEY; 15173063d29fSChris Mason 15186fa9700eSMiao Xie rsv = trans->block_rsv; 1519a22285a6SYan, Zheng trans->block_rsv = &pending->block_rsv; 15202382c5ccSLiu Bo trans->bytes_reserved = trans->block_rsv->reserved; 15210b246afaSJeff Mahoney trace_btrfs_space_reservation(fs_info, "transaction", 152288d3a5aaSJosef Bacik trans->transid, 152388d3a5aaSJosef Bacik trans->bytes_reserved, 1); 1524a22285a6SYan, Zheng dentry = pending->dentry; 1525e9662f70SMiao Xie parent_inode = pending->dir; 1526a22285a6SYan, Zheng parent_root = BTRFS_I(parent_inode)->root; 15276426c7adSQu Wenruo record_root_in_trans(trans, parent_root, 0); 1528a22285a6SYan, Zheng 1529c2050a45SDeepa Dinamani cur_time = current_time(parent_inode); 153004b285f3SDeepa Dinamani 15316bdb72deSSage Weil /* 15326bdb72deSSage Weil * insert the directory item 15336bdb72deSSage Weil */ 1534877574e2SNikolay Borisov ret = btrfs_set_inode_index(BTRFS_I(parent_inode), &index); 153549b25e05SJeff Mahoney BUG_ON(ret); /* -ENOMEM */ 153642874b3dSMiao Xie 153742874b3dSMiao Xie /* check if there is a file/dir which has the same name. */ 153842874b3dSMiao Xie dir_item = btrfs_lookup_dir_item(NULL, parent_root, path, 15394a0cc7caSNikolay Borisov btrfs_ino(BTRFS_I(parent_inode)), 154042874b3dSMiao Xie dentry->d_name.name, 154142874b3dSMiao Xie dentry->d_name.len, 0); 154242874b3dSMiao Xie if (dir_item != NULL && !IS_ERR(dir_item)) { 1543fe66a05aSChris Mason pending->error = -EEXIST; 1544aec8030aSMiao Xie goto dir_item_existed; 154542874b3dSMiao Xie } else if (IS_ERR(dir_item)) { 154642874b3dSMiao Xie ret = PTR_ERR(dir_item); 154766642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 15488732d44fSMiao Xie goto fail; 154979787eaaSJeff Mahoney } 155042874b3dSMiao Xie btrfs_release_path(path); 15516bdb72deSSage Weil 1552e999376fSChris Mason /* 1553e999376fSChris Mason * pull in the delayed directory update 1554e999376fSChris Mason * and the delayed inode item 1555e999376fSChris Mason * otherwise we corrupt the FS during 1556e999376fSChris Mason * snapshot 1557e999376fSChris Mason */ 1558e5c304e6SNikolay Borisov ret = btrfs_run_delayed_items(trans); 15598732d44fSMiao Xie if (ret) { /* Transaction aborted */ 156066642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 15618732d44fSMiao Xie goto fail; 15628732d44fSMiao Xie } 1563e999376fSChris Mason 15646426c7adSQu Wenruo record_root_in_trans(trans, root, 0); 15656bdb72deSSage Weil btrfs_set_root_last_snapshot(&root->root_item, trans->transid); 15666bdb72deSSage Weil memcpy(new_root_item, &root->root_item, sizeof(*new_root_item)); 156708fe4db1SLi Zefan btrfs_check_and_init_root_item(new_root_item); 15686bdb72deSSage Weil 1569b83cc969SLi Zefan root_flags = btrfs_root_flags(new_root_item); 1570b83cc969SLi Zefan if (pending->readonly) 1571b83cc969SLi Zefan root_flags |= BTRFS_ROOT_SUBVOL_RDONLY; 1572b83cc969SLi Zefan else 1573b83cc969SLi Zefan root_flags &= ~BTRFS_ROOT_SUBVOL_RDONLY; 1574b83cc969SLi Zefan btrfs_set_root_flags(new_root_item, root_flags); 1575b83cc969SLi Zefan 15768ea05e3aSAlexander Block btrfs_set_root_generation_v2(new_root_item, 15778ea05e3aSAlexander Block trans->transid); 15788ea05e3aSAlexander Block uuid_le_gen(&new_uuid); 15798ea05e3aSAlexander Block memcpy(new_root_item->uuid, new_uuid.b, BTRFS_UUID_SIZE); 15808ea05e3aSAlexander Block memcpy(new_root_item->parent_uuid, root->root_item.uuid, 15818ea05e3aSAlexander Block BTRFS_UUID_SIZE); 158270023da2SStefan Behrens if (!(root_flags & BTRFS_ROOT_SUBVOL_RDONLY)) { 158370023da2SStefan Behrens memset(new_root_item->received_uuid, 0, 158470023da2SStefan Behrens sizeof(new_root_item->received_uuid)); 15858ea05e3aSAlexander Block memset(&new_root_item->stime, 0, sizeof(new_root_item->stime)); 15868ea05e3aSAlexander Block memset(&new_root_item->rtime, 0, sizeof(new_root_item->rtime)); 15878ea05e3aSAlexander Block btrfs_set_root_stransid(new_root_item, 0); 15888ea05e3aSAlexander Block btrfs_set_root_rtransid(new_root_item, 0); 158970023da2SStefan Behrens } 15903cae210fSQu Wenruo btrfs_set_stack_timespec_sec(&new_root_item->otime, cur_time.tv_sec); 15913cae210fSQu Wenruo btrfs_set_stack_timespec_nsec(&new_root_item->otime, cur_time.tv_nsec); 159270023da2SStefan Behrens btrfs_set_root_otransid(new_root_item, trans->transid); 15938ea05e3aSAlexander Block 1594925baeddSChris Mason old = btrfs_lock_root_node(root); 159549b25e05SJeff Mahoney ret = btrfs_cow_block(trans, root, old, NULL, 0, &old); 159679787eaaSJeff Mahoney if (ret) { 159779787eaaSJeff Mahoney btrfs_tree_unlock(old); 159879787eaaSJeff Mahoney free_extent_buffer(old); 159966642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 16008732d44fSMiao Xie goto fail; 160179787eaaSJeff Mahoney } 160249b25e05SJeff Mahoney 16038bead258SDavid Sterba btrfs_set_lock_blocking_write(old); 16043063d29fSChris Mason 160549b25e05SJeff Mahoney ret = btrfs_copy_root(trans, root, old, &tmp, objectid); 160679787eaaSJeff Mahoney /* clean up in any case */ 1607925baeddSChris Mason btrfs_tree_unlock(old); 1608925baeddSChris Mason free_extent_buffer(old); 16098732d44fSMiao Xie if (ret) { 161066642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 16118732d44fSMiao Xie goto fail; 16128732d44fSMiao Xie } 1613f1ebcc74SLiu Bo /* see comments in should_cow_block() */ 161427cdeb70SMiao Xie set_bit(BTRFS_ROOT_FORCE_COW, &root->state); 1615f1ebcc74SLiu Bo smp_wmb(); 1616f1ebcc74SLiu Bo 16175d4f98a2SYan Zheng btrfs_set_root_node(new_root_item, tmp); 1618a22285a6SYan, Zheng /* record when the snapshot was created in key.offset */ 1619a22285a6SYan, Zheng key.offset = trans->transid; 1620a22285a6SYan, Zheng ret = btrfs_insert_root(trans, tree_root, &key, new_root_item); 1621925baeddSChris Mason btrfs_tree_unlock(tmp); 16223063d29fSChris Mason free_extent_buffer(tmp); 16238732d44fSMiao Xie if (ret) { 162466642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 16258732d44fSMiao Xie goto fail; 16268732d44fSMiao Xie } 16270660b5afSChris Mason 1628a22285a6SYan, Zheng /* 1629a22285a6SYan, Zheng * insert root back/forward references 1630a22285a6SYan, Zheng */ 16316025c19fSLu Fengqi ret = btrfs_add_root_ref(trans, objectid, 1632a22285a6SYan, Zheng parent_root->root_key.objectid, 16334a0cc7caSNikolay Borisov btrfs_ino(BTRFS_I(parent_inode)), index, 1634a22285a6SYan, Zheng dentry->d_name.name, dentry->d_name.len); 16358732d44fSMiao Xie if (ret) { 163666642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 16378732d44fSMiao Xie goto fail; 16388732d44fSMiao Xie } 1639a22285a6SYan, Zheng 1640a22285a6SYan, Zheng key.offset = (u64)-1; 16410b246afaSJeff Mahoney pending->snap = btrfs_read_fs_root_no_name(fs_info, &key); 164279787eaaSJeff Mahoney if (IS_ERR(pending->snap)) { 164379787eaaSJeff Mahoney ret = PTR_ERR(pending->snap); 164466642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 16458732d44fSMiao Xie goto fail; 164679787eaaSJeff Mahoney } 1647d68fc57bSYan, Zheng 164849b25e05SJeff Mahoney ret = btrfs_reloc_post_snapshot(trans, pending); 16498732d44fSMiao Xie if (ret) { 165066642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 16518732d44fSMiao Xie goto fail; 16528732d44fSMiao Xie } 1653361048f5SMiao Xie 1654c79a70b1SNikolay Borisov ret = btrfs_run_delayed_refs(trans, (unsigned long)-1); 16558732d44fSMiao Xie if (ret) { 165666642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 16578732d44fSMiao Xie goto fail; 16588732d44fSMiao Xie } 165942874b3dSMiao Xie 16606426c7adSQu Wenruo /* 16616426c7adSQu Wenruo * Do special qgroup accounting for snapshot, as we do some qgroup 16626426c7adSQu Wenruo * snapshot hack to do fast snapshot. 16636426c7adSQu Wenruo * To co-operate with that hack, we do hack again. 16646426c7adSQu Wenruo * Or snapshot will be greatly slowed down by a subtree qgroup rescan 16656426c7adSQu Wenruo */ 16666426c7adSQu Wenruo ret = qgroup_account_snapshot(trans, root, parent_root, 16676426c7adSQu Wenruo pending->inherit, objectid); 16686426c7adSQu Wenruo if (ret < 0) 16696426c7adSQu Wenruo goto fail; 16706426c7adSQu Wenruo 1671684572dfSLu Fengqi ret = btrfs_insert_dir_item(trans, dentry->d_name.name, 1672684572dfSLu Fengqi dentry->d_name.len, BTRFS_I(parent_inode), 1673684572dfSLu Fengqi &key, BTRFS_FT_DIR, index); 167442874b3dSMiao Xie /* We have check then name at the beginning, so it is impossible. */ 16759c52057cSChris Mason BUG_ON(ret == -EEXIST || ret == -EOVERFLOW); 16768732d44fSMiao Xie if (ret) { 167766642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 16788732d44fSMiao Xie goto fail; 16798732d44fSMiao Xie } 168042874b3dSMiao Xie 16816ef06d27SNikolay Borisov btrfs_i_size_write(BTRFS_I(parent_inode), parent_inode->i_size + 168242874b3dSMiao Xie dentry->d_name.len * 2); 168304b285f3SDeepa Dinamani parent_inode->i_mtime = parent_inode->i_ctime = 1684c2050a45SDeepa Dinamani current_time(parent_inode); 1685be6aef60SJosef Bacik ret = btrfs_update_inode_fallback(trans, parent_root, parent_inode); 1686dd5f9615SStefan Behrens if (ret) { 168766642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 1688dd5f9615SStefan Behrens goto fail; 1689dd5f9615SStefan Behrens } 1690cdb345a8SLu Fengqi ret = btrfs_uuid_tree_add(trans, new_uuid.b, BTRFS_UUID_KEY_SUBVOL, 1691cdb345a8SLu Fengqi objectid); 1692dd5f9615SStefan Behrens if (ret) { 169366642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 1694dd5f9615SStefan Behrens goto fail; 1695dd5f9615SStefan Behrens } 1696dd5f9615SStefan Behrens if (!btrfs_is_empty_uuid(new_root_item->received_uuid)) { 1697cdb345a8SLu Fengqi ret = btrfs_uuid_tree_add(trans, new_root_item->received_uuid, 1698dd5f9615SStefan Behrens BTRFS_UUID_KEY_RECEIVED_SUBVOL, 1699dd5f9615SStefan Behrens objectid); 1700dd5f9615SStefan Behrens if (ret && ret != -EEXIST) { 170166642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 1702dd5f9615SStefan Behrens goto fail; 1703dd5f9615SStefan Behrens } 1704dd5f9615SStefan Behrens } 1705d6726335SQu Wenruo 1706c79a70b1SNikolay Borisov ret = btrfs_run_delayed_refs(trans, (unsigned long)-1); 1707d6726335SQu Wenruo if (ret) { 170866642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 1709d6726335SQu Wenruo goto fail; 1710d6726335SQu Wenruo } 1711d6726335SQu Wenruo 17123063d29fSChris Mason fail: 1713aec8030aSMiao Xie pending->error = ret; 1714aec8030aSMiao Xie dir_item_existed: 171598c9942aSLiu Bo trans->block_rsv = rsv; 17162382c5ccSLiu Bo trans->bytes_reserved = 0; 1717d6726335SQu Wenruo clear_skip_qgroup: 1718d6726335SQu Wenruo btrfs_clear_skip_qgroup(trans); 17196fa9700eSMiao Xie no_free_objectid: 17206fa9700eSMiao Xie kfree(new_root_item); 1721b0c0ea63SDavid Sterba pending->root_item = NULL; 172242874b3dSMiao Xie btrfs_free_path(path); 17238546b570SDavid Sterba pending->path = NULL; 17248546b570SDavid Sterba 172549b25e05SJeff Mahoney return ret; 17263063d29fSChris Mason } 17273063d29fSChris Mason 1728d352ac68SChris Mason /* 1729d352ac68SChris Mason * create all the snapshots we've scheduled for creation 1730d352ac68SChris Mason */ 173108d50ca3SNikolay Borisov static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans) 17323063d29fSChris Mason { 1733aec8030aSMiao Xie struct btrfs_pending_snapshot *pending, *next; 17343063d29fSChris Mason struct list_head *head = &trans->transaction->pending_snapshots; 1735aec8030aSMiao Xie int ret = 0; 17363de4586cSChris Mason 1737aec8030aSMiao Xie list_for_each_entry_safe(pending, next, head, list) { 1738aec8030aSMiao Xie list_del(&pending->list); 173908d50ca3SNikolay Borisov ret = create_pending_snapshot(trans, pending); 1740aec8030aSMiao Xie if (ret) 1741aec8030aSMiao Xie break; 1742aec8030aSMiao Xie } 1743aec8030aSMiao Xie return ret; 17443de4586cSChris Mason } 17453de4586cSChris Mason 17462ff7e61eSJeff Mahoney static void update_super_roots(struct btrfs_fs_info *fs_info) 17475d4f98a2SYan Zheng { 17485d4f98a2SYan Zheng struct btrfs_root_item *root_item; 17495d4f98a2SYan Zheng struct btrfs_super_block *super; 17505d4f98a2SYan Zheng 17510b246afaSJeff Mahoney super = fs_info->super_copy; 17525d4f98a2SYan Zheng 17530b246afaSJeff Mahoney root_item = &fs_info->chunk_root->root_item; 1754093e037cSDavid Sterba super->chunk_root = root_item->bytenr; 1755093e037cSDavid Sterba super->chunk_root_generation = root_item->generation; 1756093e037cSDavid Sterba super->chunk_root_level = root_item->level; 17575d4f98a2SYan Zheng 17580b246afaSJeff Mahoney root_item = &fs_info->tree_root->root_item; 1759093e037cSDavid Sterba super->root = root_item->bytenr; 1760093e037cSDavid Sterba super->generation = root_item->generation; 1761093e037cSDavid Sterba super->root_level = root_item->level; 17620b246afaSJeff Mahoney if (btrfs_test_opt(fs_info, SPACE_CACHE)) 1763093e037cSDavid Sterba super->cache_generation = root_item->generation; 17640b246afaSJeff Mahoney if (test_bit(BTRFS_FS_UPDATE_UUID_TREE_GEN, &fs_info->flags)) 1765093e037cSDavid Sterba super->uuid_tree_generation = root_item->generation; 17665d4f98a2SYan Zheng } 17675d4f98a2SYan Zheng 1768f36f3042SChris Mason int btrfs_transaction_in_commit(struct btrfs_fs_info *info) 1769f36f3042SChris Mason { 17704a9d8bdeSMiao Xie struct btrfs_transaction *trans; 1771f36f3042SChris Mason int ret = 0; 17724a9d8bdeSMiao Xie 1773a4abeea4SJosef Bacik spin_lock(&info->trans_lock); 17744a9d8bdeSMiao Xie trans = info->running_transaction; 17754a9d8bdeSMiao Xie if (trans) 17764a9d8bdeSMiao Xie ret = (trans->state >= TRANS_STATE_COMMIT_START); 1777a4abeea4SJosef Bacik spin_unlock(&info->trans_lock); 1778f36f3042SChris Mason return ret; 1779f36f3042SChris Mason } 1780f36f3042SChris Mason 17818929ecfaSYan, Zheng int btrfs_transaction_blocked(struct btrfs_fs_info *info) 17828929ecfaSYan, Zheng { 17834a9d8bdeSMiao Xie struct btrfs_transaction *trans; 17848929ecfaSYan, Zheng int ret = 0; 17854a9d8bdeSMiao Xie 1786a4abeea4SJosef Bacik spin_lock(&info->trans_lock); 17874a9d8bdeSMiao Xie trans = info->running_transaction; 17884a9d8bdeSMiao Xie if (trans) 17894a9d8bdeSMiao Xie ret = is_transaction_blocked(trans); 1790a4abeea4SJosef Bacik spin_unlock(&info->trans_lock); 17918929ecfaSYan, Zheng return ret; 17928929ecfaSYan, Zheng } 17938929ecfaSYan, Zheng 1794bb9c12c9SSage Weil /* 1795bb9c12c9SSage Weil * wait for the current transaction commit to start and block subsequent 1796bb9c12c9SSage Weil * transaction joins 1797bb9c12c9SSage Weil */ 17982ff7e61eSJeff Mahoney static void wait_current_trans_commit_start(struct btrfs_fs_info *fs_info, 1799bb9c12c9SSage Weil struct btrfs_transaction *trans) 1800bb9c12c9SSage Weil { 18012ff7e61eSJeff Mahoney wait_event(fs_info->transaction_blocked_wait, 18022ff7e61eSJeff Mahoney trans->state >= TRANS_STATE_COMMIT_START || trans->aborted); 1803bb9c12c9SSage Weil } 1804bb9c12c9SSage Weil 1805bb9c12c9SSage Weil /* 1806bb9c12c9SSage Weil * wait for the current transaction to start and then become unblocked. 1807bb9c12c9SSage Weil * caller holds ref. 1808bb9c12c9SSage Weil */ 18092ff7e61eSJeff Mahoney static void wait_current_trans_commit_start_and_unblock( 18102ff7e61eSJeff Mahoney struct btrfs_fs_info *fs_info, 1811bb9c12c9SSage Weil struct btrfs_transaction *trans) 1812bb9c12c9SSage Weil { 18132ff7e61eSJeff Mahoney wait_event(fs_info->transaction_wait, 18142ff7e61eSJeff Mahoney trans->state >= TRANS_STATE_UNBLOCKED || trans->aborted); 1815bb9c12c9SSage Weil } 1816bb9c12c9SSage Weil 1817bb9c12c9SSage Weil /* 1818bb9c12c9SSage Weil * commit transactions asynchronously. once btrfs_commit_transaction_async 1819bb9c12c9SSage Weil * returns, any subsequent transaction will not be allowed to join. 1820bb9c12c9SSage Weil */ 1821bb9c12c9SSage Weil struct btrfs_async_commit { 1822bb9c12c9SSage Weil struct btrfs_trans_handle *newtrans; 18237892b5afSMiao Xie struct work_struct work; 1824bb9c12c9SSage Weil }; 1825bb9c12c9SSage Weil 1826bb9c12c9SSage Weil static void do_async_commit(struct work_struct *work) 1827bb9c12c9SSage Weil { 1828bb9c12c9SSage Weil struct btrfs_async_commit *ac = 18297892b5afSMiao Xie container_of(work, struct btrfs_async_commit, work); 1830bb9c12c9SSage Weil 18316fc4e354SSage Weil /* 18326fc4e354SSage Weil * We've got freeze protection passed with the transaction. 18336fc4e354SSage Weil * Tell lockdep about it. 18346fc4e354SSage Weil */ 1835b1a06a4bSLiu Bo if (ac->newtrans->type & __TRANS_FREEZABLE) 18363a45bb20SJeff Mahoney __sb_writers_acquired(ac->newtrans->fs_info->sb, SB_FREEZE_FS); 18376fc4e354SSage Weil 1838e209db7aSSage Weil current->journal_info = ac->newtrans; 1839e209db7aSSage Weil 18403a45bb20SJeff Mahoney btrfs_commit_transaction(ac->newtrans); 1841bb9c12c9SSage Weil kfree(ac); 1842bb9c12c9SSage Weil } 1843bb9c12c9SSage Weil 1844bb9c12c9SSage Weil int btrfs_commit_transaction_async(struct btrfs_trans_handle *trans, 1845bb9c12c9SSage Weil int wait_for_unblock) 1846bb9c12c9SSage Weil { 18473a45bb20SJeff Mahoney struct btrfs_fs_info *fs_info = trans->fs_info; 1848bb9c12c9SSage Weil struct btrfs_async_commit *ac; 1849bb9c12c9SSage Weil struct btrfs_transaction *cur_trans; 1850bb9c12c9SSage Weil 1851bb9c12c9SSage Weil ac = kmalloc(sizeof(*ac), GFP_NOFS); 1852db5b493aSTsutomu Itoh if (!ac) 1853db5b493aSTsutomu Itoh return -ENOMEM; 1854bb9c12c9SSage Weil 18557892b5afSMiao Xie INIT_WORK(&ac->work, do_async_commit); 18563a45bb20SJeff Mahoney ac->newtrans = btrfs_join_transaction(trans->root); 18573612b495STsutomu Itoh if (IS_ERR(ac->newtrans)) { 18583612b495STsutomu Itoh int err = PTR_ERR(ac->newtrans); 18593612b495STsutomu Itoh kfree(ac); 18603612b495STsutomu Itoh return err; 18613612b495STsutomu Itoh } 1862bb9c12c9SSage Weil 1863bb9c12c9SSage Weil /* take transaction reference */ 1864bb9c12c9SSage Weil cur_trans = trans->transaction; 18659b64f57dSElena Reshetova refcount_inc(&cur_trans->use_count); 1866bb9c12c9SSage Weil 18673a45bb20SJeff Mahoney btrfs_end_transaction(trans); 18686fc4e354SSage Weil 18696fc4e354SSage Weil /* 18706fc4e354SSage Weil * Tell lockdep we've released the freeze rwsem, since the 18716fc4e354SSage Weil * async commit thread will be the one to unlock it. 18726fc4e354SSage Weil */ 1873b1a06a4bSLiu Bo if (ac->newtrans->type & __TRANS_FREEZABLE) 18740b246afaSJeff Mahoney __sb_writers_release(fs_info->sb, SB_FREEZE_FS); 18756fc4e354SSage Weil 18767892b5afSMiao Xie schedule_work(&ac->work); 1877bb9c12c9SSage Weil 1878bb9c12c9SSage Weil /* wait for transaction to start and unblock */ 1879bb9c12c9SSage Weil if (wait_for_unblock) 18802ff7e61eSJeff Mahoney wait_current_trans_commit_start_and_unblock(fs_info, cur_trans); 1881bb9c12c9SSage Weil else 18822ff7e61eSJeff Mahoney wait_current_trans_commit_start(fs_info, cur_trans); 1883bb9c12c9SSage Weil 188438e88054SSage Weil if (current->journal_info == trans) 188538e88054SSage Weil current->journal_info = NULL; 188638e88054SSage Weil 1887724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 1888bb9c12c9SSage Weil return 0; 1889bb9c12c9SSage Weil } 1890bb9c12c9SSage Weil 189149b25e05SJeff Mahoney 189297cb39bbSNikolay Borisov static void cleanup_transaction(struct btrfs_trans_handle *trans, int err) 189349b25e05SJeff Mahoney { 189497cb39bbSNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 189549b25e05SJeff Mahoney struct btrfs_transaction *cur_trans = trans->transaction; 189649b25e05SJeff Mahoney 1897b50fff81SDavid Sterba WARN_ON(refcount_read(&trans->use_count) > 1); 189849b25e05SJeff Mahoney 189966642832SJeff Mahoney btrfs_abort_transaction(trans, err); 19007b8b92afSJosef Bacik 19010b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 190266b6135bSLiu Bo 190325d8c284SMiao Xie /* 190425d8c284SMiao Xie * If the transaction is removed from the list, it means this 190525d8c284SMiao Xie * transaction has been committed successfully, so it is impossible 190625d8c284SMiao Xie * to call the cleanup function. 190725d8c284SMiao Xie */ 190825d8c284SMiao Xie BUG_ON(list_empty(&cur_trans->list)); 190966b6135bSLiu Bo 191049b25e05SJeff Mahoney list_del_init(&cur_trans->list); 19110b246afaSJeff Mahoney if (cur_trans == fs_info->running_transaction) { 19124a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_COMMIT_DOING; 19130b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 1914f094ac32SLiu Bo wait_event(cur_trans->writer_wait, 1915f094ac32SLiu Bo atomic_read(&cur_trans->num_writers) == 1); 1916f094ac32SLiu Bo 19170b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 1918d7096fc3SJosef Bacik } 19190b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 192049b25e05SJeff Mahoney 19212ff7e61eSJeff Mahoney btrfs_cleanup_one_transaction(trans->transaction, fs_info); 192249b25e05SJeff Mahoney 19230b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 19240b246afaSJeff Mahoney if (cur_trans == fs_info->running_transaction) 19250b246afaSJeff Mahoney fs_info->running_transaction = NULL; 19260b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 19274a9d8bdeSMiao Xie 1928e0228285SJosef Bacik if (trans->type & __TRANS_FREEZABLE) 19290b246afaSJeff Mahoney sb_end_intwrite(fs_info->sb); 1930724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 1931724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 193249b25e05SJeff Mahoney 193397cb39bbSNikolay Borisov trace_btrfs_transaction_commit(trans->root); 193449b25e05SJeff Mahoney 193549b25e05SJeff Mahoney if (current->journal_info == trans) 193649b25e05SJeff Mahoney current->journal_info = NULL; 19370b246afaSJeff Mahoney btrfs_scrub_cancel(fs_info); 193849b25e05SJeff Mahoney 193949b25e05SJeff Mahoney kmem_cache_free(btrfs_trans_handle_cachep, trans); 194049b25e05SJeff Mahoney } 194149b25e05SJeff Mahoney 1942c7cc64a9SDavid Sterba /* 1943c7cc64a9SDavid Sterba * Release reserved delayed ref space of all pending block groups of the 1944c7cc64a9SDavid Sterba * transaction and remove them from the list 1945c7cc64a9SDavid Sterba */ 1946c7cc64a9SDavid Sterba static void btrfs_cleanup_pending_block_groups(struct btrfs_trans_handle *trans) 1947c7cc64a9SDavid Sterba { 1948c7cc64a9SDavid Sterba struct btrfs_fs_info *fs_info = trans->fs_info; 1949c7cc64a9SDavid Sterba struct btrfs_block_group_cache *block_group, *tmp; 1950c7cc64a9SDavid Sterba 1951c7cc64a9SDavid Sterba list_for_each_entry_safe(block_group, tmp, &trans->new_bgs, bg_list) { 1952c7cc64a9SDavid Sterba btrfs_delayed_refs_rsv_release(fs_info, 1); 1953c7cc64a9SDavid Sterba list_del_init(&block_group->bg_list); 1954c7cc64a9SDavid Sterba } 1955c7cc64a9SDavid Sterba } 1956c7cc64a9SDavid Sterba 1957609e804dSFilipe Manana static inline int btrfs_start_delalloc_flush(struct btrfs_trans_handle *trans) 195882436617SMiao Xie { 1959609e804dSFilipe Manana struct btrfs_fs_info *fs_info = trans->fs_info; 1960609e804dSFilipe Manana 1961ce8ea7ccSJosef Bacik /* 1962ce8ea7ccSJosef Bacik * We use writeback_inodes_sb here because if we used 1963ce8ea7ccSJosef Bacik * btrfs_start_delalloc_roots we would deadlock with fs freeze. 1964ce8ea7ccSJosef Bacik * Currently are holding the fs freeze lock, if we do an async flush 1965ce8ea7ccSJosef Bacik * we'll do btrfs_join_transaction() and deadlock because we need to 1966ce8ea7ccSJosef Bacik * wait for the fs freeze lock. Using the direct flushing we benefit 1967ce8ea7ccSJosef Bacik * from already being in a transaction and our join_transaction doesn't 1968ce8ea7ccSJosef Bacik * have to re-take the fs freeze lock. 1969ce8ea7ccSJosef Bacik */ 1970609e804dSFilipe Manana if (btrfs_test_opt(fs_info, FLUSHONCOMMIT)) { 1971ce8ea7ccSJosef Bacik writeback_inodes_sb(fs_info->sb, WB_REASON_SYNC); 1972609e804dSFilipe Manana } else { 1973609e804dSFilipe Manana struct btrfs_pending_snapshot *pending; 1974609e804dSFilipe Manana struct list_head *head = &trans->transaction->pending_snapshots; 1975609e804dSFilipe Manana 1976609e804dSFilipe Manana /* 1977609e804dSFilipe Manana * Flush dellaloc for any root that is going to be snapshotted. 1978609e804dSFilipe Manana * This is done to avoid a corrupted version of files, in the 1979609e804dSFilipe Manana * snapshots, that had both buffered and direct IO writes (even 1980609e804dSFilipe Manana * if they were done sequentially) due to an unordered update of 1981609e804dSFilipe Manana * the inode's size on disk. 1982609e804dSFilipe Manana */ 1983609e804dSFilipe Manana list_for_each_entry(pending, head, list) { 1984609e804dSFilipe Manana int ret; 1985609e804dSFilipe Manana 1986609e804dSFilipe Manana ret = btrfs_start_delalloc_snapshot(pending->root); 1987609e804dSFilipe Manana if (ret) 1988609e804dSFilipe Manana return ret; 1989609e804dSFilipe Manana } 1990609e804dSFilipe Manana } 199182436617SMiao Xie return 0; 199282436617SMiao Xie } 199382436617SMiao Xie 1994609e804dSFilipe Manana static inline void btrfs_wait_delalloc_flush(struct btrfs_trans_handle *trans) 199582436617SMiao Xie { 1996609e804dSFilipe Manana struct btrfs_fs_info *fs_info = trans->fs_info; 1997609e804dSFilipe Manana 1998609e804dSFilipe Manana if (btrfs_test_opt(fs_info, FLUSHONCOMMIT)) { 19996374e57aSChris Mason btrfs_wait_ordered_roots(fs_info, U64_MAX, 0, (u64)-1); 2000609e804dSFilipe Manana } else { 2001609e804dSFilipe Manana struct btrfs_pending_snapshot *pending; 2002609e804dSFilipe Manana struct list_head *head = &trans->transaction->pending_snapshots; 2003609e804dSFilipe Manana 2004609e804dSFilipe Manana /* 2005609e804dSFilipe Manana * Wait for any dellaloc that we started previously for the roots 2006609e804dSFilipe Manana * that are going to be snapshotted. This is to avoid a corrupted 2007609e804dSFilipe Manana * version of files in the snapshots that had both buffered and 2008609e804dSFilipe Manana * direct IO writes (even if they were done sequentially). 2009609e804dSFilipe Manana */ 2010609e804dSFilipe Manana list_for_each_entry(pending, head, list) 2011609e804dSFilipe Manana btrfs_wait_ordered_extents(pending->root, 2012609e804dSFilipe Manana U64_MAX, 0, U64_MAX); 2013609e804dSFilipe Manana } 201482436617SMiao Xie } 201582436617SMiao Xie 20163a45bb20SJeff Mahoney int btrfs_commit_transaction(struct btrfs_trans_handle *trans) 201779154b1bSChris Mason { 20183a45bb20SJeff Mahoney struct btrfs_fs_info *fs_info = trans->fs_info; 201949b25e05SJeff Mahoney struct btrfs_transaction *cur_trans = trans->transaction; 20208fd17795SChris Mason struct btrfs_transaction *prev_trans = NULL; 202125287e0aSMiao Xie int ret; 202279154b1bSChris Mason 202335b814f3SNikolay Borisov ASSERT(refcount_read(&trans->use_count) == 1); 202435b814f3SNikolay Borisov 20258d25a086SMiao Xie /* Stop the commit early if ->aborted is set */ 202620c7bcecSSeraphime Kirkovski if (unlikely(READ_ONCE(cur_trans->aborted))) { 202725287e0aSMiao Xie ret = cur_trans->aborted; 20283a45bb20SJeff Mahoney btrfs_end_transaction(trans); 2029e4a2bcacSJosef Bacik return ret; 203025287e0aSMiao Xie } 203149b25e05SJeff Mahoney 2032f45c752bSJosef Bacik btrfs_trans_release_metadata(trans); 2033f45c752bSJosef Bacik trans->block_rsv = NULL; 2034f45c752bSJosef Bacik 203556bec294SChris Mason /* make a pass through all the delayed refs we have so far 203656bec294SChris Mason * any runnings procs may add more while we are here 203756bec294SChris Mason */ 2038c79a70b1SNikolay Borisov ret = btrfs_run_delayed_refs(trans, 0); 2039e4a2bcacSJosef Bacik if (ret) { 20403a45bb20SJeff Mahoney btrfs_end_transaction(trans); 2041e4a2bcacSJosef Bacik return ret; 2042e4a2bcacSJosef Bacik } 204356bec294SChris Mason 2044b7ec40d7SChris Mason cur_trans = trans->transaction; 204549b25e05SJeff Mahoney 204656bec294SChris Mason /* 204756bec294SChris Mason * set the flushing flag so procs in this transaction have to 204856bec294SChris Mason * start sending their work down. 204956bec294SChris Mason */ 2050b7ec40d7SChris Mason cur_trans->delayed_refs.flushing = 1; 20511be41b78SJosef Bacik smp_wmb(); 205256bec294SChris Mason 20536c686b35SNikolay Borisov btrfs_create_pending_block_groups(trans); 2054ea658badSJosef Bacik 2055c79a70b1SNikolay Borisov ret = btrfs_run_delayed_refs(trans, 0); 2056e4a2bcacSJosef Bacik if (ret) { 20573a45bb20SJeff Mahoney btrfs_end_transaction(trans); 2058e4a2bcacSJosef Bacik return ret; 2059e4a2bcacSJosef Bacik } 206056bec294SChris Mason 20613204d33cSJosef Bacik if (!test_bit(BTRFS_TRANS_DIRTY_BG_RUN, &cur_trans->flags)) { 20621bbc621eSChris Mason int run_it = 0; 20631bbc621eSChris Mason 20641bbc621eSChris Mason /* this mutex is also taken before trying to set 20651bbc621eSChris Mason * block groups readonly. We need to make sure 20661bbc621eSChris Mason * that nobody has set a block group readonly 20671bbc621eSChris Mason * after a extents from that block group have been 20681bbc621eSChris Mason * allocated for cache files. btrfs_set_block_group_ro 20691bbc621eSChris Mason * will wait for the transaction to commit if it 20703204d33cSJosef Bacik * finds BTRFS_TRANS_DIRTY_BG_RUN set. 20711bbc621eSChris Mason * 20723204d33cSJosef Bacik * The BTRFS_TRANS_DIRTY_BG_RUN flag is also used to make sure 20733204d33cSJosef Bacik * only one process starts all the block group IO. It wouldn't 20741bbc621eSChris Mason * hurt to have more than one go through, but there's no 20751bbc621eSChris Mason * real advantage to it either. 20761bbc621eSChris Mason */ 20770b246afaSJeff Mahoney mutex_lock(&fs_info->ro_block_group_mutex); 20783204d33cSJosef Bacik if (!test_and_set_bit(BTRFS_TRANS_DIRTY_BG_RUN, 20793204d33cSJosef Bacik &cur_trans->flags)) 20801bbc621eSChris Mason run_it = 1; 20810b246afaSJeff Mahoney mutex_unlock(&fs_info->ro_block_group_mutex); 20821bbc621eSChris Mason 2083f9cacae3SNikolay Borisov if (run_it) { 208421217054SNikolay Borisov ret = btrfs_start_dirty_block_groups(trans); 20851bbc621eSChris Mason if (ret) { 20863a45bb20SJeff Mahoney btrfs_end_transaction(trans); 20871bbc621eSChris Mason return ret; 20881bbc621eSChris Mason } 2089f9cacae3SNikolay Borisov } 2090f9cacae3SNikolay Borisov } 20911bbc621eSChris Mason 20920b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 20934a9d8bdeSMiao Xie if (cur_trans->state >= TRANS_STATE_COMMIT_START) { 20940b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 20959b64f57dSElena Reshetova refcount_inc(&cur_trans->use_count); 20963a45bb20SJeff Mahoney ret = btrfs_end_transaction(trans); 2097ccd467d6SChris Mason 20982ff7e61eSJeff Mahoney wait_for_commit(cur_trans); 209915ee9bc7SJosef Bacik 2100b4924a0fSLiu Bo if (unlikely(cur_trans->aborted)) 2101b4924a0fSLiu Bo ret = cur_trans->aborted; 2102b4924a0fSLiu Bo 2103724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 210415ee9bc7SJosef Bacik 210549b25e05SJeff Mahoney return ret; 210679154b1bSChris Mason } 21074313b399SChris Mason 21084a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_COMMIT_START; 21090b246afaSJeff Mahoney wake_up(&fs_info->transaction_blocked_wait); 2110bb9c12c9SSage Weil 21110b246afaSJeff Mahoney if (cur_trans->list.prev != &fs_info->trans_list) { 2112ccd467d6SChris Mason prev_trans = list_entry(cur_trans->list.prev, 2113ccd467d6SChris Mason struct btrfs_transaction, list); 21144a9d8bdeSMiao Xie if (prev_trans->state != TRANS_STATE_COMPLETED) { 21159b64f57dSElena Reshetova refcount_inc(&prev_trans->use_count); 21160b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 2117ccd467d6SChris Mason 21182ff7e61eSJeff Mahoney wait_for_commit(prev_trans); 21191f9b8c8fSFilipe Manana ret = prev_trans->aborted; 2120ccd467d6SChris Mason 2121724e2315SJosef Bacik btrfs_put_transaction(prev_trans); 21221f9b8c8fSFilipe Manana if (ret) 21231f9b8c8fSFilipe Manana goto cleanup_transaction; 2124a4abeea4SJosef Bacik } else { 21250b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 2126ccd467d6SChris Mason } 2127a4abeea4SJosef Bacik } else { 21280b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 2129cb2d3dadSFilipe Manana /* 2130cb2d3dadSFilipe Manana * The previous transaction was aborted and was already removed 2131cb2d3dadSFilipe Manana * from the list of transactions at fs_info->trans_list. So we 2132cb2d3dadSFilipe Manana * abort to prevent writing a new superblock that reflects a 2133cb2d3dadSFilipe Manana * corrupt state (pointing to trees with unwritten nodes/leafs). 2134cb2d3dadSFilipe Manana */ 2135cb2d3dadSFilipe Manana if (test_bit(BTRFS_FS_STATE_TRANS_ABORTED, &fs_info->fs_state)) { 2136cb2d3dadSFilipe Manana ret = -EROFS; 2137cb2d3dadSFilipe Manana goto cleanup_transaction; 2138cb2d3dadSFilipe Manana } 2139ccd467d6SChris Mason } 214015ee9bc7SJosef Bacik 21410860adfdSMiao Xie extwriter_counter_dec(cur_trans, trans->type); 21420860adfdSMiao Xie 2143609e804dSFilipe Manana ret = btrfs_start_delalloc_flush(trans); 214482436617SMiao Xie if (ret) 214582436617SMiao Xie goto cleanup_transaction; 214682436617SMiao Xie 2147e5c304e6SNikolay Borisov ret = btrfs_run_delayed_items(trans); 214849b25e05SJeff Mahoney if (ret) 214949b25e05SJeff Mahoney goto cleanup_transaction; 215016cdcec7SMiao Xie 2151581227d0SMiao Xie wait_event(cur_trans->writer_wait, 2152581227d0SMiao Xie extwriter_counter_read(cur_trans) == 0); 2153ed3b3d31SChris Mason 2154581227d0SMiao Xie /* some pending stuffs might be added after the previous flush. */ 2155e5c304e6SNikolay Borisov ret = btrfs_run_delayed_items(trans); 2156ca469637SMiao Xie if (ret) 2157ca469637SMiao Xie goto cleanup_transaction; 2158ca469637SMiao Xie 2159609e804dSFilipe Manana btrfs_wait_delalloc_flush(trans); 2160cb7ab021SWang Shilong 21612ff7e61eSJeff Mahoney btrfs_scrub_pause(fs_info); 2162ed0ca140SJosef Bacik /* 2163ed0ca140SJosef Bacik * Ok now we need to make sure to block out any other joins while we 2164ed0ca140SJosef Bacik * commit the transaction. We could have started a join before setting 21654a9d8bdeSMiao Xie * COMMIT_DOING so make sure to wait for num_writers to == 1 again. 2166ed0ca140SJosef Bacik */ 21670b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 21684a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_COMMIT_DOING; 21690b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 2170ed0ca140SJosef Bacik wait_event(cur_trans->writer_wait, 2171ed0ca140SJosef Bacik atomic_read(&cur_trans->num_writers) == 1); 217215ee9bc7SJosef Bacik 21732cba30f1SMiao Xie /* ->aborted might be set after the previous check, so check it */ 217420c7bcecSSeraphime Kirkovski if (unlikely(READ_ONCE(cur_trans->aborted))) { 21752cba30f1SMiao Xie ret = cur_trans->aborted; 21766cf7f77eSWang Shilong goto scrub_continue; 21772cba30f1SMiao Xie } 21787585717fSChris Mason /* 21797585717fSChris Mason * the reloc mutex makes sure that we stop 21807585717fSChris Mason * the balancing code from coming in and moving 21817585717fSChris Mason * extents around in the middle of the commit 21827585717fSChris Mason */ 21830b246afaSJeff Mahoney mutex_lock(&fs_info->reloc_mutex); 21847585717fSChris Mason 218542874b3dSMiao Xie /* 218642874b3dSMiao Xie * We needn't worry about the delayed items because we will 218742874b3dSMiao Xie * deal with them in create_pending_snapshot(), which is the 218842874b3dSMiao Xie * core function of the snapshot creation. 218942874b3dSMiao Xie */ 219008d50ca3SNikolay Borisov ret = create_pending_snapshots(trans); 219149b25e05SJeff Mahoney if (ret) { 21920b246afaSJeff Mahoney mutex_unlock(&fs_info->reloc_mutex); 21936cf7f77eSWang Shilong goto scrub_continue; 219449b25e05SJeff Mahoney } 21953063d29fSChris Mason 219642874b3dSMiao Xie /* 219742874b3dSMiao Xie * We insert the dir indexes of the snapshots and update the inode 219842874b3dSMiao Xie * of the snapshots' parents after the snapshot creation, so there 219942874b3dSMiao Xie * are some delayed items which are not dealt with. Now deal with 220042874b3dSMiao Xie * them. 220142874b3dSMiao Xie * 220242874b3dSMiao Xie * We needn't worry that this operation will corrupt the snapshots, 220342874b3dSMiao Xie * because all the tree which are snapshoted will be forced to COW 220442874b3dSMiao Xie * the nodes and leaves. 220542874b3dSMiao Xie */ 2206e5c304e6SNikolay Borisov ret = btrfs_run_delayed_items(trans); 220749b25e05SJeff Mahoney if (ret) { 22080b246afaSJeff Mahoney mutex_unlock(&fs_info->reloc_mutex); 22096cf7f77eSWang Shilong goto scrub_continue; 221049b25e05SJeff Mahoney } 221116cdcec7SMiao Xie 2212c79a70b1SNikolay Borisov ret = btrfs_run_delayed_refs(trans, (unsigned long)-1); 221349b25e05SJeff Mahoney if (ret) { 22140b246afaSJeff Mahoney mutex_unlock(&fs_info->reloc_mutex); 22156cf7f77eSWang Shilong goto scrub_continue; 221649b25e05SJeff Mahoney } 221756bec294SChris Mason 2218e999376fSChris Mason /* 2219e999376fSChris Mason * make sure none of the code above managed to slip in a 2220e999376fSChris Mason * delayed item 2221e999376fSChris Mason */ 2222ccdf9b30SJeff Mahoney btrfs_assert_delayed_root_empty(fs_info); 2223e999376fSChris Mason 22242c90e5d6SChris Mason WARN_ON(cur_trans != trans->transaction); 2225dc17ff8fSChris Mason 2226e02119d5SChris Mason /* btrfs_commit_tree_roots is responsible for getting the 2227e02119d5SChris Mason * various roots consistent with each other. Every pointer 2228e02119d5SChris Mason * in the tree of tree roots has to point to the most up to date 2229e02119d5SChris Mason * root for every subvolume and other tree. So, we have to keep 2230e02119d5SChris Mason * the tree logging code from jumping in and changing any 2231e02119d5SChris Mason * of the trees. 2232e02119d5SChris Mason * 2233e02119d5SChris Mason * At this point in the commit, there can't be any tree-log 2234e02119d5SChris Mason * writers, but a little lower down we drop the trans mutex 2235e02119d5SChris Mason * and let new people in. By holding the tree_log_mutex 2236e02119d5SChris Mason * from now until after the super is written, we avoid races 2237e02119d5SChris Mason * with the tree-log code. 2238e02119d5SChris Mason */ 22390b246afaSJeff Mahoney mutex_lock(&fs_info->tree_log_mutex); 22401a40e23bSZheng Yan 22417e4443d9SNikolay Borisov ret = commit_fs_roots(trans); 224249b25e05SJeff Mahoney if (ret) { 22430b246afaSJeff Mahoney mutex_unlock(&fs_info->tree_log_mutex); 22440b246afaSJeff Mahoney mutex_unlock(&fs_info->reloc_mutex); 22456cf7f77eSWang Shilong goto scrub_continue; 224649b25e05SJeff Mahoney } 224754aa1f4dSChris Mason 22483818aea2SQu Wenruo /* 22497e1876acSDavid Sterba * Since the transaction is done, we can apply the pending changes 22507e1876acSDavid Sterba * before the next transaction. 22513818aea2SQu Wenruo */ 22520b246afaSJeff Mahoney btrfs_apply_pending_changes(fs_info); 22533818aea2SQu Wenruo 22545d4f98a2SYan Zheng /* commit_fs_roots gets rid of all the tree log roots, it is now 2255e02119d5SChris Mason * safe to free the root of tree log roots 2256e02119d5SChris Mason */ 22570b246afaSJeff Mahoney btrfs_free_log_root_tree(trans, fs_info); 2258e02119d5SChris Mason 22590ed4792aSQu Wenruo /* 226082bafb38SQu Wenruo * commit_fs_roots() can call btrfs_save_ino_cache(), which generates 226182bafb38SQu Wenruo * new delayed refs. Must handle them or qgroup can be wrong. 226282bafb38SQu Wenruo */ 2263c79a70b1SNikolay Borisov ret = btrfs_run_delayed_refs(trans, (unsigned long)-1); 226482bafb38SQu Wenruo if (ret) { 226582bafb38SQu Wenruo mutex_unlock(&fs_info->tree_log_mutex); 226682bafb38SQu Wenruo mutex_unlock(&fs_info->reloc_mutex); 226782bafb38SQu Wenruo goto scrub_continue; 226882bafb38SQu Wenruo } 226982bafb38SQu Wenruo 227082bafb38SQu Wenruo /* 22710ed4792aSQu Wenruo * Since fs roots are all committed, we can get a quite accurate 22720ed4792aSQu Wenruo * new_roots. So let's do quota accounting. 22730ed4792aSQu Wenruo */ 2274460fb20aSNikolay Borisov ret = btrfs_qgroup_account_extents(trans); 22750ed4792aSQu Wenruo if (ret < 0) { 22760b246afaSJeff Mahoney mutex_unlock(&fs_info->tree_log_mutex); 22770b246afaSJeff Mahoney mutex_unlock(&fs_info->reloc_mutex); 22780ed4792aSQu Wenruo goto scrub_continue; 22790ed4792aSQu Wenruo } 22800ed4792aSQu Wenruo 22819386d8bcSNikolay Borisov ret = commit_cowonly_roots(trans); 228249b25e05SJeff Mahoney if (ret) { 22830b246afaSJeff Mahoney mutex_unlock(&fs_info->tree_log_mutex); 22840b246afaSJeff Mahoney mutex_unlock(&fs_info->reloc_mutex); 22856cf7f77eSWang Shilong goto scrub_continue; 228649b25e05SJeff Mahoney } 228754aa1f4dSChris Mason 22882cba30f1SMiao Xie /* 22892cba30f1SMiao Xie * The tasks which save the space cache and inode cache may also 22902cba30f1SMiao Xie * update ->aborted, check it. 22912cba30f1SMiao Xie */ 229220c7bcecSSeraphime Kirkovski if (unlikely(READ_ONCE(cur_trans->aborted))) { 22932cba30f1SMiao Xie ret = cur_trans->aborted; 22940b246afaSJeff Mahoney mutex_unlock(&fs_info->tree_log_mutex); 22950b246afaSJeff Mahoney mutex_unlock(&fs_info->reloc_mutex); 22966cf7f77eSWang Shilong goto scrub_continue; 22972cba30f1SMiao Xie } 22982cba30f1SMiao Xie 22998b74c03eSDavid Sterba btrfs_prepare_extent_commit(fs_info); 230011833d66SYan Zheng 23010b246afaSJeff Mahoney cur_trans = fs_info->running_transaction; 23025f39d397SChris Mason 23030b246afaSJeff Mahoney btrfs_set_root_node(&fs_info->tree_root->root_item, 23040b246afaSJeff Mahoney fs_info->tree_root->node); 23050b246afaSJeff Mahoney list_add_tail(&fs_info->tree_root->dirty_list, 23069e351cc8SJosef Bacik &cur_trans->switch_commits); 23075d4f98a2SYan Zheng 23080b246afaSJeff Mahoney btrfs_set_root_node(&fs_info->chunk_root->root_item, 23090b246afaSJeff Mahoney fs_info->chunk_root->node); 23100b246afaSJeff Mahoney list_add_tail(&fs_info->chunk_root->dirty_list, 23119e351cc8SJosef Bacik &cur_trans->switch_commits); 23129e351cc8SJosef Bacik 231316916a88SNikolay Borisov switch_commit_roots(cur_trans); 23145d4f98a2SYan Zheng 2315ce93ec54SJosef Bacik ASSERT(list_empty(&cur_trans->dirty_bgs)); 23161bbc621eSChris Mason ASSERT(list_empty(&cur_trans->io_bgs)); 23172ff7e61eSJeff Mahoney update_super_roots(fs_info); 2318e02119d5SChris Mason 23190b246afaSJeff Mahoney btrfs_set_super_log_root(fs_info->super_copy, 0); 23200b246afaSJeff Mahoney btrfs_set_super_log_root_level(fs_info->super_copy, 0); 23210b246afaSJeff Mahoney memcpy(fs_info->super_for_commit, fs_info->super_copy, 23220b246afaSJeff Mahoney sizeof(*fs_info->super_copy)); 2323ccd467d6SChris Mason 2324bbbf7243SNikolay Borisov btrfs_commit_device_sizes(cur_trans); 2325935e5cc9SMiao Xie 23260b246afaSJeff Mahoney clear_bit(BTRFS_FS_LOG1_ERR, &fs_info->flags); 23270b246afaSJeff Mahoney clear_bit(BTRFS_FS_LOG2_ERR, &fs_info->flags); 2328656f30dbSFilipe Manana 23294fbcdf66SFilipe Manana btrfs_trans_release_chunk_metadata(trans); 23304fbcdf66SFilipe Manana 23310b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 23324a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_UNBLOCKED; 23330b246afaSJeff Mahoney fs_info->running_transaction = NULL; 23340b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 23350b246afaSJeff Mahoney mutex_unlock(&fs_info->reloc_mutex); 2336b7ec40d7SChris Mason 23370b246afaSJeff Mahoney wake_up(&fs_info->transaction_wait); 2338e6dcd2dcSChris Mason 233970458a58SNikolay Borisov ret = btrfs_write_and_wait_transaction(trans); 234049b25e05SJeff Mahoney if (ret) { 23410b246afaSJeff Mahoney btrfs_handle_fs_error(fs_info, ret, 234208748810SDavid Sterba "Error while writing out transaction"); 23430b246afaSJeff Mahoney mutex_unlock(&fs_info->tree_log_mutex); 23446cf7f77eSWang Shilong goto scrub_continue; 234549b25e05SJeff Mahoney } 234649b25e05SJeff Mahoney 2347eece6a9cSDavid Sterba ret = write_all_supers(fs_info, 0); 2348e02119d5SChris Mason /* 2349e02119d5SChris Mason * the super is written, we can safely allow the tree-loggers 2350e02119d5SChris Mason * to go about their business 2351e02119d5SChris Mason */ 23520b246afaSJeff Mahoney mutex_unlock(&fs_info->tree_log_mutex); 2353c1f32b7cSAnand Jain if (ret) 2354c1f32b7cSAnand Jain goto scrub_continue; 2355e02119d5SChris Mason 23565ead2dd0SNikolay Borisov btrfs_finish_extent_commit(trans); 23574313b399SChris Mason 23583204d33cSJosef Bacik if (test_bit(BTRFS_TRANS_HAVE_FREE_BGS, &cur_trans->flags)) 23590b246afaSJeff Mahoney btrfs_clear_space_info_full(fs_info); 236013212b54SZhao Lei 23610b246afaSJeff Mahoney fs_info->last_trans_committed = cur_trans->transid; 23624a9d8bdeSMiao Xie /* 23634a9d8bdeSMiao Xie * We needn't acquire the lock here because there is no other task 23644a9d8bdeSMiao Xie * which can change it. 23654a9d8bdeSMiao Xie */ 23664a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_COMPLETED; 23672c90e5d6SChris Mason wake_up(&cur_trans->commit_wait); 2368a514d638SQu Wenruo clear_bit(BTRFS_FS_NEED_ASYNC_COMMIT, &fs_info->flags); 23693de4586cSChris Mason 23700b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 237113c5a93eSJosef Bacik list_del_init(&cur_trans->list); 23720b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 2373a4abeea4SJosef Bacik 2374724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 2375724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 237658176a96SJosef Bacik 23770860adfdSMiao Xie if (trans->type & __TRANS_FREEZABLE) 23780b246afaSJeff Mahoney sb_end_intwrite(fs_info->sb); 2379b2b5ef5cSJan Kara 23803a45bb20SJeff Mahoney trace_btrfs_transaction_commit(trans->root); 23811abe9b8aSliubo 23822ff7e61eSJeff Mahoney btrfs_scrub_continue(fs_info); 2383a2de733cSArne Jansen 23849ed74f2dSJosef Bacik if (current->journal_info == trans) 23859ed74f2dSJosef Bacik current->journal_info = NULL; 23869ed74f2dSJosef Bacik 23872c90e5d6SChris Mason kmem_cache_free(btrfs_trans_handle_cachep, trans); 238824bbcf04SYan, Zheng 238979154b1bSChris Mason return ret; 239049b25e05SJeff Mahoney 23916cf7f77eSWang Shilong scrub_continue: 23922ff7e61eSJeff Mahoney btrfs_scrub_continue(fs_info); 239349b25e05SJeff Mahoney cleanup_transaction: 2394dc60c525SNikolay Borisov btrfs_trans_release_metadata(trans); 2395c7cc64a9SDavid Sterba btrfs_cleanup_pending_block_groups(trans); 23964fbcdf66SFilipe Manana btrfs_trans_release_chunk_metadata(trans); 23970e721106SJosef Bacik trans->block_rsv = NULL; 23980b246afaSJeff Mahoney btrfs_warn(fs_info, "Skipping commit of aborted transaction."); 239949b25e05SJeff Mahoney if (current->journal_info == trans) 240049b25e05SJeff Mahoney current->journal_info = NULL; 240197cb39bbSNikolay Borisov cleanup_transaction(trans, ret); 240249b25e05SJeff Mahoney 240349b25e05SJeff Mahoney return ret; 240479154b1bSChris Mason } 240579154b1bSChris Mason 2406d352ac68SChris Mason /* 24079d1a2a3aSDavid Sterba * return < 0 if error 24089d1a2a3aSDavid Sterba * 0 if there are no more dead_roots at the time of call 24099d1a2a3aSDavid Sterba * 1 there are more to be processed, call me again 24109d1a2a3aSDavid Sterba * 24119d1a2a3aSDavid Sterba * The return value indicates there are certainly more snapshots to delete, but 24129d1a2a3aSDavid Sterba * if there comes a new one during processing, it may return 0. We don't mind, 24139d1a2a3aSDavid Sterba * because btrfs_commit_super will poke cleaner thread and it will process it a 24149d1a2a3aSDavid Sterba * few seconds later. 2415d352ac68SChris Mason */ 24169d1a2a3aSDavid Sterba int btrfs_clean_one_deleted_snapshot(struct btrfs_root *root) 2417e9d0b13bSChris Mason { 24189d1a2a3aSDavid Sterba int ret; 24195d4f98a2SYan Zheng struct btrfs_fs_info *fs_info = root->fs_info; 2420e9d0b13bSChris Mason 2421a4abeea4SJosef Bacik spin_lock(&fs_info->trans_lock); 24229d1a2a3aSDavid Sterba if (list_empty(&fs_info->dead_roots)) { 24239d1a2a3aSDavid Sterba spin_unlock(&fs_info->trans_lock); 24249d1a2a3aSDavid Sterba return 0; 24259d1a2a3aSDavid Sterba } 24269d1a2a3aSDavid Sterba root = list_first_entry(&fs_info->dead_roots, 24279d1a2a3aSDavid Sterba struct btrfs_root, root_list); 2428cfad392bSJosef Bacik list_del_init(&root->root_list); 2429a4abeea4SJosef Bacik spin_unlock(&fs_info->trans_lock); 24305d4f98a2SYan Zheng 24314fd786e6SMisono Tomohiro btrfs_debug(fs_info, "cleaner removing %llu", root->root_key.objectid); 243276dda93cSYan, Zheng 243316cdcec7SMiao Xie btrfs_kill_all_delayed_nodes(root); 243416cdcec7SMiao Xie 243576dda93cSYan, Zheng if (btrfs_header_backref_rev(root->node) < 243676dda93cSYan, Zheng BTRFS_MIXED_BACKREF_REV) 24372c536799SJeff Mahoney ret = btrfs_drop_snapshot(root, NULL, 0, 0); 243876dda93cSYan, Zheng else 24392c536799SJeff Mahoney ret = btrfs_drop_snapshot(root, NULL, 1, 0); 244032471dc2SDavid Sterba 24416596a928SJosef Bacik return (ret < 0) ? 0 : 1; 2442e9d0b13bSChris Mason } 2443572d9ab7SDavid Sterba 2444572d9ab7SDavid Sterba void btrfs_apply_pending_changes(struct btrfs_fs_info *fs_info) 2445572d9ab7SDavid Sterba { 2446572d9ab7SDavid Sterba unsigned long prev; 2447572d9ab7SDavid Sterba unsigned long bit; 2448572d9ab7SDavid Sterba 24496c9fe14fSQu Wenruo prev = xchg(&fs_info->pending_changes, 0); 2450572d9ab7SDavid Sterba if (!prev) 2451572d9ab7SDavid Sterba return; 2452572d9ab7SDavid Sterba 24537e1876acSDavid Sterba bit = 1 << BTRFS_PENDING_SET_INODE_MAP_CACHE; 24547e1876acSDavid Sterba if (prev & bit) 24557e1876acSDavid Sterba btrfs_set_opt(fs_info->mount_opt, INODE_MAP_CACHE); 24567e1876acSDavid Sterba prev &= ~bit; 24577e1876acSDavid Sterba 24587e1876acSDavid Sterba bit = 1 << BTRFS_PENDING_CLEAR_INODE_MAP_CACHE; 24597e1876acSDavid Sterba if (prev & bit) 24607e1876acSDavid Sterba btrfs_clear_opt(fs_info->mount_opt, INODE_MAP_CACHE); 24617e1876acSDavid Sterba prev &= ~bit; 24627e1876acSDavid Sterba 2463d51033d0SDavid Sterba bit = 1 << BTRFS_PENDING_COMMIT; 2464d51033d0SDavid Sterba if (prev & bit) 2465d51033d0SDavid Sterba btrfs_debug(fs_info, "pending commit done"); 2466d51033d0SDavid Sterba prev &= ~bit; 2467d51033d0SDavid Sterba 2468572d9ab7SDavid Sterba if (prev) 2469572d9ab7SDavid Sterba btrfs_warn(fs_info, 2470572d9ab7SDavid Sterba "unknown pending changes left 0x%lx, ignoring", prev); 2471572d9ab7SDavid Sterba } 2472