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" 19733f4fbbSStefan Behrens #include "volumes.h" 208dabb742SStefan Behrens #include "dev-replace.h" 21fcebe456SJosef Bacik #include "qgroup.h" 22aac0023cSJosef Bacik #include "block-group.h" 239c343784SJosef Bacik #include "space-info.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_COMMIT_START] = (__TRANS_START | __TRANS_ATTACH), 101bcf3a3e7SNikolay Borisov [TRANS_STATE_COMMIT_DOING] = (__TRANS_START | 1024a9d8bdeSMiao Xie __TRANS_ATTACH | 103a6d155d2SFilipe Manana __TRANS_JOIN | 104a6d155d2SFilipe Manana __TRANS_JOIN_NOSTART), 105bcf3a3e7SNikolay Borisov [TRANS_STATE_UNBLOCKED] = (__TRANS_START | 1064a9d8bdeSMiao Xie __TRANS_ATTACH | 1074a9d8bdeSMiao Xie __TRANS_JOIN | 108a6d155d2SFilipe Manana __TRANS_JOIN_NOLOCK | 109a6d155d2SFilipe Manana __TRANS_JOIN_NOSTART), 110bcf3a3e7SNikolay Borisov [TRANS_STATE_COMPLETED] = (__TRANS_START | 1114a9d8bdeSMiao Xie __TRANS_ATTACH | 1124a9d8bdeSMiao Xie __TRANS_JOIN | 113a6d155d2SFilipe Manana __TRANS_JOIN_NOLOCK | 114a6d155d2SFilipe Manana __TRANS_JOIN_NOSTART), 1154a9d8bdeSMiao Xie }; 1164a9d8bdeSMiao Xie 117724e2315SJosef Bacik void btrfs_put_transaction(struct btrfs_transaction *transaction) 11879154b1bSChris Mason { 1199b64f57dSElena Reshetova WARN_ON(refcount_read(&transaction->use_count) == 0); 1209b64f57dSElena Reshetova if (refcount_dec_and_test(&transaction->use_count)) { 121a4abeea4SJosef Bacik BUG_ON(!list_empty(&transaction->list)); 1225c9d028bSLiu Bo WARN_ON(!RB_EMPTY_ROOT( 1235c9d028bSLiu Bo &transaction->delayed_refs.href_root.rb_root)); 12481f7eb00SJeff Mahoney WARN_ON(!RB_EMPTY_ROOT( 12581f7eb00SJeff Mahoney &transaction->delayed_refs.dirty_extent_root)); 1261262133bSJosef Bacik if (transaction->delayed_refs.pending_csums) 127ab8d0fc4SJeff Mahoney btrfs_err(transaction->fs_info, 128ab8d0fc4SJeff Mahoney "pending csums is %llu", 1291262133bSJosef Bacik transaction->delayed_refs.pending_csums); 1307785a663SFilipe Manana /* 1317785a663SFilipe Manana * If any block groups are found in ->deleted_bgs then it's 1327785a663SFilipe Manana * because the transaction was aborted and a commit did not 1337785a663SFilipe Manana * happen (things failed before writing the new superblock 1347785a663SFilipe Manana * and calling btrfs_finish_extent_commit()), so we can not 1357785a663SFilipe Manana * discard the physical locations of the block groups. 1367785a663SFilipe Manana */ 1377785a663SFilipe Manana while (!list_empty(&transaction->deleted_bgs)) { 13832da5386SDavid Sterba struct btrfs_block_group *cache; 1397785a663SFilipe Manana 1407785a663SFilipe Manana cache = list_first_entry(&transaction->deleted_bgs, 14132da5386SDavid Sterba struct btrfs_block_group, 1427785a663SFilipe Manana bg_list); 1437785a663SFilipe Manana list_del_init(&cache->bg_list); 1446b7304afSFilipe Manana btrfs_unfreeze_block_group(cache); 1457785a663SFilipe Manana btrfs_put_block_group(cache); 1467785a663SFilipe Manana } 147bbbf7243SNikolay Borisov WARN_ON(!list_empty(&transaction->dev_update_list)); 1484b5faeacSDavid Sterba kfree(transaction); 14979154b1bSChris Mason } 15078fae27eSChris Mason } 15179154b1bSChris Mason 152889bfa39SJosef Bacik static noinline void switch_commit_roots(struct btrfs_trans_handle *trans) 153817d52f8SJosef Bacik { 154889bfa39SJosef Bacik struct btrfs_transaction *cur_trans = trans->transaction; 15516916a88SNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 1569e351cc8SJosef Bacik struct btrfs_root *root, *tmp; 15727d56e62SJosef Bacik struct btrfs_caching_control *caching_ctl, *next; 1589e351cc8SJosef Bacik 1599e351cc8SJosef Bacik down_write(&fs_info->commit_root_sem); 160889bfa39SJosef Bacik list_for_each_entry_safe(root, tmp, &cur_trans->switch_commits, 1619e351cc8SJosef Bacik dirty_list) { 1629e351cc8SJosef Bacik list_del_init(&root->dirty_list); 163817d52f8SJosef Bacik free_extent_buffer(root->commit_root); 164817d52f8SJosef Bacik root->commit_root = btrfs_root_node(root); 16541e7acd3SNikolay Borisov extent_io_tree_release(&root->dirty_log_pages); 166370a11b8SQu Wenruo btrfs_qgroup_clean_swapped_blocks(root); 1679e351cc8SJosef Bacik } 1682b9dbef2SJosef Bacik 1692b9dbef2SJosef Bacik /* We can free old roots now. */ 170889bfa39SJosef Bacik spin_lock(&cur_trans->dropped_roots_lock); 171889bfa39SJosef Bacik while (!list_empty(&cur_trans->dropped_roots)) { 172889bfa39SJosef Bacik root = list_first_entry(&cur_trans->dropped_roots, 1732b9dbef2SJosef Bacik struct btrfs_root, root_list); 1742b9dbef2SJosef Bacik list_del_init(&root->root_list); 175889bfa39SJosef Bacik spin_unlock(&cur_trans->dropped_roots_lock); 176889bfa39SJosef Bacik btrfs_free_log(trans, root); 1772b9dbef2SJosef Bacik btrfs_drop_and_free_fs_root(fs_info, root); 178889bfa39SJosef Bacik spin_lock(&cur_trans->dropped_roots_lock); 1792b9dbef2SJosef Bacik } 180889bfa39SJosef Bacik spin_unlock(&cur_trans->dropped_roots_lock); 18127d56e62SJosef Bacik 18227d56e62SJosef Bacik /* 18327d56e62SJosef Bacik * We have to update the last_byte_to_unpin under the commit_root_sem, 18427d56e62SJosef Bacik * at the same time we swap out the commit roots. 18527d56e62SJosef Bacik * 18627d56e62SJosef Bacik * This is because we must have a real view of the last spot the caching 18727d56e62SJosef Bacik * kthreads were while caching. Consider the following views of the 18827d56e62SJosef Bacik * extent tree for a block group 18927d56e62SJosef Bacik * 19027d56e62SJosef Bacik * commit root 19127d56e62SJosef Bacik * +----+----+----+----+----+----+----+ 19227d56e62SJosef Bacik * |\\\\| |\\\\|\\\\| |\\\\|\\\\| 19327d56e62SJosef Bacik * +----+----+----+----+----+----+----+ 19427d56e62SJosef Bacik * 0 1 2 3 4 5 6 7 19527d56e62SJosef Bacik * 19627d56e62SJosef Bacik * new commit root 19727d56e62SJosef Bacik * +----+----+----+----+----+----+----+ 19827d56e62SJosef Bacik * | | | |\\\\| | |\\\\| 19927d56e62SJosef Bacik * +----+----+----+----+----+----+----+ 20027d56e62SJosef Bacik * 0 1 2 3 4 5 6 7 20127d56e62SJosef Bacik * 20227d56e62SJosef Bacik * If the cache_ctl->progress was at 3, then we are only allowed to 20327d56e62SJosef Bacik * unpin [0,1) and [2,3], because the caching thread has already 20427d56e62SJosef Bacik * processed those extents. We are not allowed to unpin [5,6), because 20527d56e62SJosef Bacik * the caching thread will re-start it's search from 3, and thus find 20627d56e62SJosef Bacik * the hole from [4,6) to add to the free space cache. 20727d56e62SJosef Bacik */ 208bbb86a37SJosef Bacik spin_lock(&fs_info->block_group_cache_lock); 20927d56e62SJosef Bacik list_for_each_entry_safe(caching_ctl, next, 21027d56e62SJosef Bacik &fs_info->caching_block_groups, list) { 21127d56e62SJosef Bacik struct btrfs_block_group *cache = caching_ctl->block_group; 21227d56e62SJosef Bacik 21327d56e62SJosef Bacik if (btrfs_block_group_done(cache)) { 21427d56e62SJosef Bacik cache->last_byte_to_unpin = (u64)-1; 21527d56e62SJosef Bacik list_del_init(&caching_ctl->list); 21627d56e62SJosef Bacik btrfs_put_caching_control(caching_ctl); 21727d56e62SJosef Bacik } else { 21827d56e62SJosef Bacik cache->last_byte_to_unpin = caching_ctl->progress; 21927d56e62SJosef Bacik } 22027d56e62SJosef Bacik } 221bbb86a37SJosef Bacik spin_unlock(&fs_info->block_group_cache_lock); 2229e351cc8SJosef Bacik up_write(&fs_info->commit_root_sem); 223817d52f8SJosef Bacik } 224817d52f8SJosef Bacik 2250860adfdSMiao Xie static inline void extwriter_counter_inc(struct btrfs_transaction *trans, 2260860adfdSMiao Xie unsigned int type) 2270860adfdSMiao Xie { 2280860adfdSMiao Xie if (type & TRANS_EXTWRITERS) 2290860adfdSMiao Xie atomic_inc(&trans->num_extwriters); 2300860adfdSMiao Xie } 2310860adfdSMiao Xie 2320860adfdSMiao Xie static inline void extwriter_counter_dec(struct btrfs_transaction *trans, 2330860adfdSMiao Xie unsigned int type) 2340860adfdSMiao Xie { 2350860adfdSMiao Xie if (type & TRANS_EXTWRITERS) 2360860adfdSMiao Xie atomic_dec(&trans->num_extwriters); 2370860adfdSMiao Xie } 2380860adfdSMiao Xie 2390860adfdSMiao Xie static inline void extwriter_counter_init(struct btrfs_transaction *trans, 2400860adfdSMiao Xie unsigned int type) 2410860adfdSMiao Xie { 2420860adfdSMiao Xie atomic_set(&trans->num_extwriters, ((type & TRANS_EXTWRITERS) ? 1 : 0)); 2430860adfdSMiao Xie } 2440860adfdSMiao Xie 2450860adfdSMiao Xie static inline int extwriter_counter_read(struct btrfs_transaction *trans) 2460860adfdSMiao Xie { 2470860adfdSMiao Xie return atomic_read(&trans->num_extwriters); 248178260b2SMiao Xie } 249178260b2SMiao Xie 250d352ac68SChris Mason /* 251fb6dea26SJosef Bacik * To be called after all the new block groups attached to the transaction 252fb6dea26SJosef Bacik * handle have been created (btrfs_create_pending_block_groups()). 253fb6dea26SJosef Bacik */ 254fb6dea26SJosef Bacik void btrfs_trans_release_chunk_metadata(struct btrfs_trans_handle *trans) 255fb6dea26SJosef Bacik { 256fb6dea26SJosef Bacik struct btrfs_fs_info *fs_info = trans->fs_info; 257fb6dea26SJosef Bacik 258fb6dea26SJosef Bacik if (!trans->chunk_bytes_reserved) 259fb6dea26SJosef Bacik return; 260fb6dea26SJosef Bacik 261fb6dea26SJosef Bacik WARN_ON_ONCE(!list_empty(&trans->new_bgs)); 262fb6dea26SJosef Bacik 263fb6dea26SJosef Bacik btrfs_block_rsv_release(fs_info, &fs_info->chunk_block_rsv, 26463f018beSNikolay Borisov trans->chunk_bytes_reserved, NULL); 265fb6dea26SJosef Bacik trans->chunk_bytes_reserved = 0; 266fb6dea26SJosef Bacik } 267fb6dea26SJosef Bacik 268fb6dea26SJosef Bacik /* 269d352ac68SChris Mason * either allocate a new transaction or hop into the existing one 270d352ac68SChris Mason */ 2712ff7e61eSJeff Mahoney static noinline int join_transaction(struct btrfs_fs_info *fs_info, 2722ff7e61eSJeff Mahoney unsigned int type) 27379154b1bSChris Mason { 27479154b1bSChris Mason struct btrfs_transaction *cur_trans; 275a4abeea4SJosef Bacik 27619ae4e81SJan Schmidt spin_lock(&fs_info->trans_lock); 277d43317dcSChris Mason loop: 27849b25e05SJeff Mahoney /* The file system has been taken offline. No new transactions. */ 27987533c47SMiao Xie if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) { 28019ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 28149b25e05SJeff Mahoney return -EROFS; 28249b25e05SJeff Mahoney } 28349b25e05SJeff Mahoney 28419ae4e81SJan Schmidt cur_trans = fs_info->running_transaction; 285a4abeea4SJosef Bacik if (cur_trans) { 286bf31f87fSDavid Sterba if (TRANS_ABORTED(cur_trans)) { 28719ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 28849b25e05SJeff Mahoney return cur_trans->aborted; 289871383beSDavid Sterba } 2904a9d8bdeSMiao Xie if (btrfs_blocked_trans_types[cur_trans->state] & type) { 291178260b2SMiao Xie spin_unlock(&fs_info->trans_lock); 292178260b2SMiao Xie return -EBUSY; 293178260b2SMiao Xie } 2949b64f57dSElena Reshetova refcount_inc(&cur_trans->use_count); 295a4abeea4SJosef Bacik atomic_inc(&cur_trans->num_writers); 2960860adfdSMiao Xie extwriter_counter_inc(cur_trans, type); 29719ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 298a4abeea4SJosef Bacik return 0; 299a4abeea4SJosef Bacik } 30019ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 301a4abeea4SJosef Bacik 302354aa0fbSMiao Xie /* 303354aa0fbSMiao Xie * If we are ATTACH, we just want to catch the current transaction, 304354aa0fbSMiao Xie * and commit it. If there is no transaction, just return ENOENT. 305354aa0fbSMiao Xie */ 306354aa0fbSMiao Xie if (type == TRANS_ATTACH) 307354aa0fbSMiao Xie return -ENOENT; 308354aa0fbSMiao Xie 3094a9d8bdeSMiao Xie /* 3104a9d8bdeSMiao Xie * JOIN_NOLOCK only happens during the transaction commit, so 3114a9d8bdeSMiao Xie * it is impossible that ->running_transaction is NULL 3124a9d8bdeSMiao Xie */ 3134a9d8bdeSMiao Xie BUG_ON(type == TRANS_JOIN_NOLOCK); 3144a9d8bdeSMiao Xie 3154b5faeacSDavid Sterba cur_trans = kmalloc(sizeof(*cur_trans), GFP_NOFS); 316db5b493aSTsutomu Itoh if (!cur_trans) 317db5b493aSTsutomu Itoh return -ENOMEM; 318d43317dcSChris Mason 31919ae4e81SJan Schmidt spin_lock(&fs_info->trans_lock); 32019ae4e81SJan Schmidt if (fs_info->running_transaction) { 321d43317dcSChris Mason /* 322d43317dcSChris Mason * someone started a transaction after we unlocked. Make sure 3234a9d8bdeSMiao Xie * to redo the checks above 324d43317dcSChris Mason */ 3254b5faeacSDavid Sterba kfree(cur_trans); 326d43317dcSChris Mason goto loop; 32787533c47SMiao Xie } else if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) { 328e4b50e14SDan Carpenter spin_unlock(&fs_info->trans_lock); 3294b5faeacSDavid Sterba kfree(cur_trans); 3307b8b92afSJosef Bacik return -EROFS; 331a4abeea4SJosef Bacik } 332d43317dcSChris Mason 333ab8d0fc4SJeff Mahoney cur_trans->fs_info = fs_info; 33448778179SFilipe Manana atomic_set(&cur_trans->pending_ordered, 0); 33548778179SFilipe Manana init_waitqueue_head(&cur_trans->pending_wait); 33613c5a93eSJosef Bacik atomic_set(&cur_trans->num_writers, 1); 3370860adfdSMiao Xie extwriter_counter_init(cur_trans, type); 33879154b1bSChris Mason init_waitqueue_head(&cur_trans->writer_wait); 33979154b1bSChris Mason init_waitqueue_head(&cur_trans->commit_wait); 3404a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_RUNNING; 341a4abeea4SJosef Bacik /* 342a4abeea4SJosef Bacik * One for this trans handle, one so it will live on until we 343a4abeea4SJosef Bacik * commit the transaction. 344a4abeea4SJosef Bacik */ 3459b64f57dSElena Reshetova refcount_set(&cur_trans->use_count, 2); 3463204d33cSJosef Bacik cur_trans->flags = 0; 347afd48513SArnd Bergmann cur_trans->start_time = ktime_get_seconds(); 34856bec294SChris Mason 349a099d0fdSAlexandru Moise memset(&cur_trans->delayed_refs, 0, sizeof(cur_trans->delayed_refs)); 350a099d0fdSAlexandru Moise 3515c9d028bSLiu Bo cur_trans->delayed_refs.href_root = RB_ROOT_CACHED; 3523368d001SQu Wenruo cur_trans->delayed_refs.dirty_extent_root = RB_ROOT; 353d7df2c79SJosef Bacik atomic_set(&cur_trans->delayed_refs.num_entries, 0); 35420b297d6SJan Schmidt 35520b297d6SJan Schmidt /* 35620b297d6SJan Schmidt * although the tree mod log is per file system and not per transaction, 35720b297d6SJan Schmidt * the log must never go across transaction boundaries. 35820b297d6SJan Schmidt */ 35920b297d6SJan Schmidt smp_mb(); 36031b1a2bdSJulia Lawall if (!list_empty(&fs_info->tree_mod_seq_list)) 3615d163e0eSJeff Mahoney WARN(1, KERN_ERR "BTRFS: tree_mod_seq_list not empty when creating a fresh transaction\n"); 36231b1a2bdSJulia Lawall if (!RB_EMPTY_ROOT(&fs_info->tree_mod_log)) 3635d163e0eSJeff Mahoney WARN(1, KERN_ERR "BTRFS: tree_mod_log rb tree not empty when creating a fresh transaction\n"); 364fc36ed7eSJan Schmidt atomic64_set(&fs_info->tree_mod_seq, 0); 36520b297d6SJan Schmidt 36656bec294SChris Mason spin_lock_init(&cur_trans->delayed_refs.lock); 36756bec294SChris Mason 3683063d29fSChris Mason INIT_LIST_HEAD(&cur_trans->pending_snapshots); 369bbbf7243SNikolay Borisov INIT_LIST_HEAD(&cur_trans->dev_update_list); 3709e351cc8SJosef Bacik INIT_LIST_HEAD(&cur_trans->switch_commits); 371ce93ec54SJosef Bacik INIT_LIST_HEAD(&cur_trans->dirty_bgs); 3721bbc621eSChris Mason INIT_LIST_HEAD(&cur_trans->io_bgs); 3732b9dbef2SJosef Bacik INIT_LIST_HEAD(&cur_trans->dropped_roots); 3741bbc621eSChris Mason mutex_init(&cur_trans->cache_write_mutex); 375ce93ec54SJosef Bacik spin_lock_init(&cur_trans->dirty_bgs_lock); 376e33e17eeSJeff Mahoney INIT_LIST_HEAD(&cur_trans->deleted_bgs); 3772b9dbef2SJosef Bacik spin_lock_init(&cur_trans->dropped_roots_lock); 37819ae4e81SJan Schmidt list_add_tail(&cur_trans->list, &fs_info->trans_list); 379c258d6e3SQu Wenruo extent_io_tree_init(fs_info, &cur_trans->dirty_pages, 38043eb5f29SQu Wenruo IO_TREE_TRANS_DIRTY_PAGES, fs_info->btree_inode); 381fe119a6eSNikolay Borisov extent_io_tree_init(fs_info, &cur_trans->pinned_extents, 382fe119a6eSNikolay Borisov IO_TREE_FS_PINNED_EXTENTS, NULL); 38319ae4e81SJan Schmidt fs_info->generation++; 38419ae4e81SJan Schmidt cur_trans->transid = fs_info->generation; 38519ae4e81SJan Schmidt fs_info->running_transaction = cur_trans; 38649b25e05SJeff Mahoney cur_trans->aborted = 0; 38719ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 38815ee9bc7SJosef Bacik 38979154b1bSChris Mason return 0; 39079154b1bSChris Mason } 39179154b1bSChris Mason 392d352ac68SChris Mason /* 39392a7cc42SQu Wenruo * This does all the record keeping required to make sure that a shareable root 39492a7cc42SQu Wenruo * is properly recorded in a given transaction. This is required to make sure 39592a7cc42SQu Wenruo * the old root from before we joined the transaction is deleted when the 39692a7cc42SQu Wenruo * transaction commits. 397d352ac68SChris Mason */ 3987585717fSChris Mason static int record_root_in_trans(struct btrfs_trans_handle *trans, 3996426c7adSQu Wenruo struct btrfs_root *root, 4006426c7adSQu Wenruo int force) 4016702ed49SChris Mason { 4020b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 4030b246afaSJeff Mahoney 40492a7cc42SQu Wenruo if ((test_bit(BTRFS_ROOT_SHAREABLE, &root->state) && 4056426c7adSQu Wenruo root->last_trans < trans->transid) || force) { 4060b246afaSJeff Mahoney WARN_ON(root == fs_info->extent_root); 4074d31778aSQu Wenruo WARN_ON(!force && root->commit_root != root->node); 4085d4f98a2SYan Zheng 4097585717fSChris Mason /* 41027cdeb70SMiao Xie * see below for IN_TRANS_SETUP usage rules 4117585717fSChris Mason * we have the reloc mutex held now, so there 4127585717fSChris Mason * is only one writer in this function 4137585717fSChris Mason */ 41427cdeb70SMiao Xie set_bit(BTRFS_ROOT_IN_TRANS_SETUP, &root->state); 4157585717fSChris Mason 41627cdeb70SMiao Xie /* make sure readers find IN_TRANS_SETUP before 4177585717fSChris Mason * they find our root->last_trans update 4187585717fSChris Mason */ 4197585717fSChris Mason smp_wmb(); 4207585717fSChris Mason 4210b246afaSJeff Mahoney spin_lock(&fs_info->fs_roots_radix_lock); 4226426c7adSQu Wenruo if (root->last_trans == trans->transid && !force) { 4230b246afaSJeff Mahoney spin_unlock(&fs_info->fs_roots_radix_lock); 424a4abeea4SJosef Bacik return 0; 425a4abeea4SJosef Bacik } 4260b246afaSJeff Mahoney radix_tree_tag_set(&fs_info->fs_roots_radix, 4276702ed49SChris Mason (unsigned long)root->root_key.objectid, 4286702ed49SChris Mason BTRFS_ROOT_TRANS_TAG); 4290b246afaSJeff Mahoney spin_unlock(&fs_info->fs_roots_radix_lock); 4307585717fSChris Mason root->last_trans = trans->transid; 4317585717fSChris Mason 4327585717fSChris Mason /* this is pretty tricky. We don't want to 4337585717fSChris Mason * take the relocation lock in btrfs_record_root_in_trans 4347585717fSChris Mason * unless we're really doing the first setup for this root in 4357585717fSChris Mason * this transaction. 4367585717fSChris Mason * 4377585717fSChris Mason * Normally we'd use root->last_trans as a flag to decide 4387585717fSChris Mason * if we want to take the expensive mutex. 4397585717fSChris Mason * 4407585717fSChris Mason * But, we have to set root->last_trans before we 4417585717fSChris Mason * init the relocation root, otherwise, we trip over warnings 4427585717fSChris Mason * in ctree.c. The solution used here is to flag ourselves 44327cdeb70SMiao Xie * with root IN_TRANS_SETUP. When this is 1, we're still 4447585717fSChris Mason * fixing up the reloc trees and everyone must wait. 4457585717fSChris Mason * 4467585717fSChris Mason * When this is zero, they can trust root->last_trans and fly 4477585717fSChris Mason * through btrfs_record_root_in_trans without having to take the 4487585717fSChris Mason * lock. smp_wmb() makes sure that all the writes above are 4497585717fSChris Mason * done before we pop in the zero below 4507585717fSChris Mason */ 4515d4f98a2SYan Zheng btrfs_init_reloc_root(trans, root); 452c7548af6SChris Mason smp_mb__before_atomic(); 45327cdeb70SMiao Xie clear_bit(BTRFS_ROOT_IN_TRANS_SETUP, &root->state); 4546702ed49SChris Mason } 4555d4f98a2SYan Zheng return 0; 4566702ed49SChris Mason } 4575d4f98a2SYan Zheng 4587585717fSChris Mason 4592b9dbef2SJosef Bacik void btrfs_add_dropped_root(struct btrfs_trans_handle *trans, 4602b9dbef2SJosef Bacik struct btrfs_root *root) 4612b9dbef2SJosef Bacik { 4620b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 4632b9dbef2SJosef Bacik struct btrfs_transaction *cur_trans = trans->transaction; 4642b9dbef2SJosef Bacik 4652b9dbef2SJosef Bacik /* Add ourselves to the transaction dropped list */ 4662b9dbef2SJosef Bacik spin_lock(&cur_trans->dropped_roots_lock); 4672b9dbef2SJosef Bacik list_add_tail(&root->root_list, &cur_trans->dropped_roots); 4682b9dbef2SJosef Bacik spin_unlock(&cur_trans->dropped_roots_lock); 4692b9dbef2SJosef Bacik 4702b9dbef2SJosef Bacik /* Make sure we don't try to update the root at commit time */ 4710b246afaSJeff Mahoney spin_lock(&fs_info->fs_roots_radix_lock); 4720b246afaSJeff Mahoney radix_tree_tag_clear(&fs_info->fs_roots_radix, 4732b9dbef2SJosef Bacik (unsigned long)root->root_key.objectid, 4742b9dbef2SJosef Bacik BTRFS_ROOT_TRANS_TAG); 4750b246afaSJeff Mahoney spin_unlock(&fs_info->fs_roots_radix_lock); 4762b9dbef2SJosef Bacik } 4772b9dbef2SJosef Bacik 4787585717fSChris Mason int btrfs_record_root_in_trans(struct btrfs_trans_handle *trans, 4797585717fSChris Mason struct btrfs_root *root) 4807585717fSChris Mason { 4810b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 4820b246afaSJeff Mahoney 48392a7cc42SQu Wenruo if (!test_bit(BTRFS_ROOT_SHAREABLE, &root->state)) 4847585717fSChris Mason return 0; 4857585717fSChris Mason 4867585717fSChris Mason /* 48727cdeb70SMiao Xie * see record_root_in_trans for comments about IN_TRANS_SETUP usage 4887585717fSChris Mason * and barriers 4897585717fSChris Mason */ 4907585717fSChris Mason smp_rmb(); 4917585717fSChris Mason if (root->last_trans == trans->transid && 49227cdeb70SMiao Xie !test_bit(BTRFS_ROOT_IN_TRANS_SETUP, &root->state)) 4937585717fSChris Mason return 0; 4947585717fSChris Mason 4950b246afaSJeff Mahoney mutex_lock(&fs_info->reloc_mutex); 4966426c7adSQu Wenruo record_root_in_trans(trans, root, 0); 4970b246afaSJeff Mahoney mutex_unlock(&fs_info->reloc_mutex); 4987585717fSChris Mason 4997585717fSChris Mason return 0; 5007585717fSChris Mason } 5017585717fSChris Mason 5024a9d8bdeSMiao Xie static inline int is_transaction_blocked(struct btrfs_transaction *trans) 5034a9d8bdeSMiao Xie { 5043296bf56SQu Wenruo return (trans->state >= TRANS_STATE_COMMIT_START && 505501407aaSJosef Bacik trans->state < TRANS_STATE_UNBLOCKED && 506bf31f87fSDavid Sterba !TRANS_ABORTED(trans)); 5074a9d8bdeSMiao Xie } 5084a9d8bdeSMiao Xie 509d352ac68SChris Mason /* wait for commit against the current transaction to become unblocked 510d352ac68SChris Mason * when this is done, it is safe to start a new transaction, but the current 511d352ac68SChris Mason * transaction might not be fully on disk. 512d352ac68SChris Mason */ 5132ff7e61eSJeff Mahoney static void wait_current_trans(struct btrfs_fs_info *fs_info) 51479154b1bSChris Mason { 515f9295749SChris Mason struct btrfs_transaction *cur_trans; 51679154b1bSChris Mason 5170b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 5180b246afaSJeff Mahoney cur_trans = fs_info->running_transaction; 5194a9d8bdeSMiao Xie if (cur_trans && is_transaction_blocked(cur_trans)) { 5209b64f57dSElena Reshetova refcount_inc(&cur_trans->use_count); 5210b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 52272d63ed6SLi Zefan 5230b246afaSJeff Mahoney wait_event(fs_info->transaction_wait, 524501407aaSJosef Bacik cur_trans->state >= TRANS_STATE_UNBLOCKED || 525bf31f87fSDavid Sterba TRANS_ABORTED(cur_trans)); 526724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 527a4abeea4SJosef Bacik } else { 5280b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 529f9295749SChris Mason } 53037d1aeeeSChris Mason } 53137d1aeeeSChris Mason 5322ff7e61eSJeff Mahoney static int may_wait_transaction(struct btrfs_fs_info *fs_info, int type) 53337d1aeeeSChris Mason { 5340b246afaSJeff Mahoney if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags)) 535a4abeea4SJosef Bacik return 0; 536a4abeea4SJosef Bacik 53792e2f7e3SNikolay Borisov if (type == TRANS_START) 538a4abeea4SJosef Bacik return 1; 539a4abeea4SJosef Bacik 540a22285a6SYan, Zheng return 0; 541a22285a6SYan, Zheng } 542a22285a6SYan, Zheng 54320dd2cbfSMiao Xie static inline bool need_reserve_reloc_root(struct btrfs_root *root) 54420dd2cbfSMiao Xie { 5450b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 5460b246afaSJeff Mahoney 5470b246afaSJeff Mahoney if (!fs_info->reloc_ctl || 54892a7cc42SQu Wenruo !test_bit(BTRFS_ROOT_SHAREABLE, &root->state) || 54920dd2cbfSMiao Xie root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID || 55020dd2cbfSMiao Xie root->reloc_root) 55120dd2cbfSMiao Xie return false; 55220dd2cbfSMiao Xie 55320dd2cbfSMiao Xie return true; 55420dd2cbfSMiao Xie } 55520dd2cbfSMiao Xie 55608e007d2SMiao Xie static struct btrfs_trans_handle * 5575aed1dd8SAlexandru Moise start_transaction(struct btrfs_root *root, unsigned int num_items, 558003d7c59SJeff Mahoney unsigned int type, enum btrfs_reserve_flush_enum flush, 559003d7c59SJeff Mahoney bool enforce_qgroups) 560a22285a6SYan, Zheng { 5610b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 562ba2c4d4eSJosef Bacik struct btrfs_block_rsv *delayed_refs_rsv = &fs_info->delayed_refs_rsv; 563a22285a6SYan, Zheng struct btrfs_trans_handle *h; 564a22285a6SYan, Zheng struct btrfs_transaction *cur_trans; 565b5009945SJosef Bacik u64 num_bytes = 0; 566c5567237SArne Jansen u64 qgroup_reserved = 0; 56720dd2cbfSMiao Xie bool reloc_reserved = false; 5689c343784SJosef Bacik bool do_chunk_alloc = false; 56920dd2cbfSMiao Xie int ret; 570acce952bSliubo 57146c4e71eSFilipe Manana /* Send isn't supposed to start transactions. */ 5722755a0deSDavid Sterba ASSERT(current->journal_info != BTRFS_SEND_TRANS_STUB); 57346c4e71eSFilipe Manana 5740b246afaSJeff Mahoney if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) 575acce952bSliubo return ERR_PTR(-EROFS); 5762a1eb461SJosef Bacik 57746c4e71eSFilipe Manana if (current->journal_info) { 5780860adfdSMiao Xie WARN_ON(type & TRANS_EXTWRITERS); 5792a1eb461SJosef Bacik h = current->journal_info; 580b50fff81SDavid Sterba refcount_inc(&h->use_count); 581b50fff81SDavid Sterba WARN_ON(refcount_read(&h->use_count) > 2); 5822a1eb461SJosef Bacik h->orig_rsv = h->block_rsv; 5832a1eb461SJosef Bacik h->block_rsv = NULL; 5842a1eb461SJosef Bacik goto got_it; 5852a1eb461SJosef Bacik } 586b5009945SJosef Bacik 587b5009945SJosef Bacik /* 588b5009945SJosef Bacik * Do the reservation before we join the transaction so we can do all 589b5009945SJosef Bacik * the appropriate flushing if need be. 590b5009945SJosef Bacik */ 591003d7c59SJeff Mahoney if (num_items && root != fs_info->chunk_root) { 592ba2c4d4eSJosef Bacik struct btrfs_block_rsv *rsv = &fs_info->trans_block_rsv; 593ba2c4d4eSJosef Bacik u64 delayed_refs_bytes = 0; 594ba2c4d4eSJosef Bacik 5950b246afaSJeff Mahoney qgroup_reserved = num_items * fs_info->nodesize; 596733e03a0SQu Wenruo ret = btrfs_qgroup_reserve_meta_pertrans(root, qgroup_reserved, 597003d7c59SJeff Mahoney enforce_qgroups); 598c5567237SArne Jansen if (ret) 599c5567237SArne Jansen return ERR_PTR(ret); 600c5567237SArne Jansen 601ba2c4d4eSJosef Bacik /* 602ba2c4d4eSJosef Bacik * We want to reserve all the bytes we may need all at once, so 603ba2c4d4eSJosef Bacik * we only do 1 enospc flushing cycle per transaction start. We 604ba2c4d4eSJosef Bacik * accomplish this by simply assuming we'll do 2 x num_items 605ba2c4d4eSJosef Bacik * worth of delayed refs updates in this trans handle, and 606ba2c4d4eSJosef Bacik * refill that amount for whatever is missing in the reserve. 607ba2c4d4eSJosef Bacik */ 6082bd36e7bSJosef Bacik num_bytes = btrfs_calc_insert_metadata_size(fs_info, num_items); 6097f9fe614SJosef Bacik if (flush == BTRFS_RESERVE_FLUSH_ALL && 6107f9fe614SJosef Bacik delayed_refs_rsv->full == 0) { 611ba2c4d4eSJosef Bacik delayed_refs_bytes = num_bytes; 612ba2c4d4eSJosef Bacik num_bytes <<= 1; 613ba2c4d4eSJosef Bacik } 614ba2c4d4eSJosef Bacik 61520dd2cbfSMiao Xie /* 61620dd2cbfSMiao Xie * Do the reservation for the relocation root creation 61720dd2cbfSMiao Xie */ 618ee39b432SDavid Sterba if (need_reserve_reloc_root(root)) { 6190b246afaSJeff Mahoney num_bytes += fs_info->nodesize; 62020dd2cbfSMiao Xie reloc_reserved = true; 62120dd2cbfSMiao Xie } 62220dd2cbfSMiao Xie 623ba2c4d4eSJosef Bacik ret = btrfs_block_rsv_add(root, rsv, num_bytes, flush); 624ba2c4d4eSJosef Bacik if (ret) 625ba2c4d4eSJosef Bacik goto reserve_fail; 626ba2c4d4eSJosef Bacik if (delayed_refs_bytes) { 627ba2c4d4eSJosef Bacik btrfs_migrate_to_delayed_refs_rsv(fs_info, rsv, 628ba2c4d4eSJosef Bacik delayed_refs_bytes); 629ba2c4d4eSJosef Bacik num_bytes -= delayed_refs_bytes; 630ba2c4d4eSJosef Bacik } 6319c343784SJosef Bacik 6329c343784SJosef Bacik if (rsv->space_info->force_alloc) 6339c343784SJosef Bacik do_chunk_alloc = true; 634ba2c4d4eSJosef Bacik } else if (num_items == 0 && flush == BTRFS_RESERVE_FLUSH_ALL && 635ba2c4d4eSJosef Bacik !delayed_refs_rsv->full) { 636ba2c4d4eSJosef Bacik /* 637ba2c4d4eSJosef Bacik * Some people call with btrfs_start_transaction(root, 0) 638ba2c4d4eSJosef Bacik * because they can be throttled, but have some other mechanism 639ba2c4d4eSJosef Bacik * for reserving space. We still want these guys to refill the 640ba2c4d4eSJosef Bacik * delayed block_rsv so just add 1 items worth of reservation 641ba2c4d4eSJosef Bacik * here. 642ba2c4d4eSJosef Bacik */ 643ba2c4d4eSJosef Bacik ret = btrfs_delayed_refs_rsv_refill(fs_info, flush); 644b5009945SJosef Bacik if (ret) 645843fcf35SMiao Xie goto reserve_fail; 646b5009945SJosef Bacik } 647a22285a6SYan, Zheng again: 648f2f767e7SAlexandru Moise h = kmem_cache_zalloc(btrfs_trans_handle_cachep, GFP_NOFS); 649843fcf35SMiao Xie if (!h) { 650843fcf35SMiao Xie ret = -ENOMEM; 651843fcf35SMiao Xie goto alloc_fail; 652843fcf35SMiao Xie } 653a22285a6SYan, Zheng 65498114659SJosef Bacik /* 65598114659SJosef Bacik * If we are JOIN_NOLOCK we're already committing a transaction and 65698114659SJosef Bacik * waiting on this guy, so we don't need to do the sb_start_intwrite 65798114659SJosef Bacik * because we're already holding a ref. We need this because we could 65898114659SJosef Bacik * have raced in and did an fsync() on a file which can kick a commit 65998114659SJosef Bacik * and then we deadlock with somebody doing a freeze. 660354aa0fbSMiao Xie * 661354aa0fbSMiao Xie * If we are ATTACH, it means we just want to catch the current 662354aa0fbSMiao Xie * transaction and commit it, so we needn't do sb_start_intwrite(). 66398114659SJosef Bacik */ 6640860adfdSMiao Xie if (type & __TRANS_FREEZABLE) 6650b246afaSJeff Mahoney sb_start_intwrite(fs_info->sb); 666b2b5ef5cSJan Kara 6672ff7e61eSJeff Mahoney if (may_wait_transaction(fs_info, type)) 6682ff7e61eSJeff Mahoney wait_current_trans(fs_info); 669a22285a6SYan, Zheng 670a4abeea4SJosef Bacik do { 6712ff7e61eSJeff Mahoney ret = join_transaction(fs_info, type); 672178260b2SMiao Xie if (ret == -EBUSY) { 6732ff7e61eSJeff Mahoney wait_current_trans(fs_info); 674a6d155d2SFilipe Manana if (unlikely(type == TRANS_ATTACH || 675a6d155d2SFilipe Manana type == TRANS_JOIN_NOSTART)) 676178260b2SMiao Xie ret = -ENOENT; 677178260b2SMiao Xie } 678a4abeea4SJosef Bacik } while (ret == -EBUSY); 679a4abeea4SJosef Bacik 680a43f7f82SLiu Bo if (ret < 0) 681843fcf35SMiao Xie goto join_fail; 6820f7d52f4SChris Mason 6830b246afaSJeff Mahoney cur_trans = fs_info->running_transaction; 684a22285a6SYan, Zheng 685a22285a6SYan, Zheng h->transid = cur_trans->transid; 686a22285a6SYan, Zheng h->transaction = cur_trans; 687d13603efSArne Jansen h->root = root; 688b50fff81SDavid Sterba refcount_set(&h->use_count, 1); 68964b63580SJeff Mahoney h->fs_info = root->fs_info; 6907174109cSQu Wenruo 691a698d075SMiao Xie h->type = type; 692d9a0540aSFilipe Manana h->can_flush_pending_bgs = true; 693ea658badSJosef Bacik INIT_LIST_HEAD(&h->new_bgs); 694b7ec40d7SChris Mason 695a22285a6SYan, Zheng smp_mb(); 6963296bf56SQu Wenruo if (cur_trans->state >= TRANS_STATE_COMMIT_START && 6972ff7e61eSJeff Mahoney may_wait_transaction(fs_info, type)) { 698abdd2e80SFilipe Manana current->journal_info = h; 6993a45bb20SJeff Mahoney btrfs_commit_transaction(h); 700a22285a6SYan, Zheng goto again; 701a22285a6SYan, Zheng } 7029ed74f2dSJosef Bacik 703b5009945SJosef Bacik if (num_bytes) { 7040b246afaSJeff Mahoney trace_btrfs_space_reservation(fs_info, "transaction", 7052bcc0328SLiu Bo h->transid, num_bytes, 1); 7060b246afaSJeff Mahoney h->block_rsv = &fs_info->trans_block_rsv; 707b5009945SJosef Bacik h->bytes_reserved = num_bytes; 70820dd2cbfSMiao Xie h->reloc_reserved = reloc_reserved; 709a22285a6SYan, Zheng } 710a22285a6SYan, Zheng 7112a1eb461SJosef Bacik got_it: 712bcf3a3e7SNikolay Borisov if (!current->journal_info) 713a22285a6SYan, Zheng current->journal_info = h; 714fcc99734SQu Wenruo 715fcc99734SQu Wenruo /* 7169c343784SJosef Bacik * If the space_info is marked ALLOC_FORCE then we'll get upgraded to 7179c343784SJosef Bacik * ALLOC_FORCE the first run through, and then we won't allocate for 7189c343784SJosef Bacik * anybody else who races in later. We don't care about the return 7199c343784SJosef Bacik * value here. 7209c343784SJosef Bacik */ 7219c343784SJosef Bacik if (do_chunk_alloc && num_bytes) { 7229c343784SJosef Bacik u64 flags = h->block_rsv->space_info->flags; 7239c343784SJosef Bacik 7249c343784SJosef Bacik btrfs_chunk_alloc(h, btrfs_get_alloc_profile(fs_info, flags), 7259c343784SJosef Bacik CHUNK_ALLOC_NO_FORCE); 7269c343784SJosef Bacik } 7279c343784SJosef Bacik 7289c343784SJosef Bacik /* 729fcc99734SQu Wenruo * btrfs_record_root_in_trans() needs to alloc new extents, and may 730fcc99734SQu Wenruo * call btrfs_join_transaction() while we're also starting a 731fcc99734SQu Wenruo * transaction. 732fcc99734SQu Wenruo * 733fcc99734SQu Wenruo * Thus it need to be called after current->journal_info initialized, 734fcc99734SQu Wenruo * or we can deadlock. 735fcc99734SQu Wenruo */ 736fcc99734SQu Wenruo btrfs_record_root_in_trans(h, root); 737fcc99734SQu Wenruo 73879154b1bSChris Mason return h; 739843fcf35SMiao Xie 740843fcf35SMiao Xie join_fail: 7410860adfdSMiao Xie if (type & __TRANS_FREEZABLE) 7420b246afaSJeff Mahoney sb_end_intwrite(fs_info->sb); 743843fcf35SMiao Xie kmem_cache_free(btrfs_trans_handle_cachep, h); 744843fcf35SMiao Xie alloc_fail: 745843fcf35SMiao Xie if (num_bytes) 7462ff7e61eSJeff Mahoney btrfs_block_rsv_release(fs_info, &fs_info->trans_block_rsv, 74763f018beSNikolay Borisov num_bytes, NULL); 748843fcf35SMiao Xie reserve_fail: 749733e03a0SQu Wenruo btrfs_qgroup_free_meta_pertrans(root, qgroup_reserved); 750843fcf35SMiao Xie return ERR_PTR(ret); 75179154b1bSChris Mason } 75279154b1bSChris Mason 753f9295749SChris Mason struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root, 7545aed1dd8SAlexandru Moise unsigned int num_items) 755f9295749SChris Mason { 75608e007d2SMiao Xie return start_transaction(root, num_items, TRANS_START, 757003d7c59SJeff Mahoney BTRFS_RESERVE_FLUSH_ALL, true); 758f9295749SChris Mason } 759003d7c59SJeff Mahoney 7608eab77ffSFilipe Manana struct btrfs_trans_handle *btrfs_start_transaction_fallback_global_rsv( 7618eab77ffSFilipe Manana struct btrfs_root *root, 7627f9fe614SJosef Bacik unsigned int num_items) 7638eab77ffSFilipe Manana { 7647f9fe614SJosef Bacik return start_transaction(root, num_items, TRANS_START, 7657f9fe614SJosef Bacik BTRFS_RESERVE_FLUSH_ALL_STEAL, false); 7668eab77ffSFilipe Manana } 7678407aa46SMiao Xie 7687a7eaa40SJosef Bacik struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root) 769f9295749SChris Mason { 770003d7c59SJeff Mahoney return start_transaction(root, 0, TRANS_JOIN, BTRFS_RESERVE_NO_FLUSH, 771003d7c59SJeff Mahoney true); 772f9295749SChris Mason } 773f9295749SChris Mason 7748d510121SNikolay Borisov struct btrfs_trans_handle *btrfs_join_transaction_spacecache(struct btrfs_root *root) 7750af3d00bSJosef Bacik { 776575a75d6SAlexandru Moise return start_transaction(root, 0, TRANS_JOIN_NOLOCK, 777003d7c59SJeff Mahoney BTRFS_RESERVE_NO_FLUSH, true); 7780af3d00bSJosef Bacik } 7790af3d00bSJosef Bacik 780d4edf39bSMiao Xie /* 781a6d155d2SFilipe Manana * Similar to regular join but it never starts a transaction when none is 782a6d155d2SFilipe Manana * running or after waiting for the current one to finish. 783a6d155d2SFilipe Manana */ 784a6d155d2SFilipe Manana struct btrfs_trans_handle *btrfs_join_transaction_nostart(struct btrfs_root *root) 785a6d155d2SFilipe Manana { 786a6d155d2SFilipe Manana return start_transaction(root, 0, TRANS_JOIN_NOSTART, 787a6d155d2SFilipe Manana BTRFS_RESERVE_NO_FLUSH, true); 788a6d155d2SFilipe Manana } 789a6d155d2SFilipe Manana 790a6d155d2SFilipe Manana /* 791d4edf39bSMiao Xie * btrfs_attach_transaction() - catch the running transaction 792d4edf39bSMiao Xie * 793d4edf39bSMiao Xie * It is used when we want to commit the current the transaction, but 794d4edf39bSMiao Xie * don't want to start a new one. 795d4edf39bSMiao Xie * 796d4edf39bSMiao Xie * Note: If this function return -ENOENT, it just means there is no 797d4edf39bSMiao Xie * running transaction. But it is possible that the inactive transaction 798d4edf39bSMiao Xie * is still in the memory, not fully on disk. If you hope there is no 799d4edf39bSMiao Xie * inactive transaction in the fs when -ENOENT is returned, you should 800d4edf39bSMiao Xie * invoke 801d4edf39bSMiao Xie * btrfs_attach_transaction_barrier() 802d4edf39bSMiao Xie */ 803354aa0fbSMiao Xie struct btrfs_trans_handle *btrfs_attach_transaction(struct btrfs_root *root) 80460376ce4SJosef Bacik { 805575a75d6SAlexandru Moise return start_transaction(root, 0, TRANS_ATTACH, 806003d7c59SJeff Mahoney BTRFS_RESERVE_NO_FLUSH, true); 80760376ce4SJosef Bacik } 80860376ce4SJosef Bacik 809d4edf39bSMiao Xie /* 81090b6d283SWang Sheng-Hui * btrfs_attach_transaction_barrier() - catch the running transaction 811d4edf39bSMiao Xie * 81252042d8eSAndrea Gelmini * It is similar to the above function, the difference is this one 813d4edf39bSMiao Xie * will wait for all the inactive transactions until they fully 814d4edf39bSMiao Xie * complete. 815d4edf39bSMiao Xie */ 816d4edf39bSMiao Xie struct btrfs_trans_handle * 817d4edf39bSMiao Xie btrfs_attach_transaction_barrier(struct btrfs_root *root) 818d4edf39bSMiao Xie { 819d4edf39bSMiao Xie struct btrfs_trans_handle *trans; 820d4edf39bSMiao Xie 821575a75d6SAlexandru Moise trans = start_transaction(root, 0, TRANS_ATTACH, 822003d7c59SJeff Mahoney BTRFS_RESERVE_NO_FLUSH, true); 8238d9e220cSAl Viro if (trans == ERR_PTR(-ENOENT)) 8242ff7e61eSJeff Mahoney btrfs_wait_for_commit(root->fs_info, 0); 825d4edf39bSMiao Xie 826d4edf39bSMiao Xie return trans; 827d4edf39bSMiao Xie } 828d4edf39bSMiao Xie 829d352ac68SChris Mason /* wait for a transaction commit to be fully complete */ 8302ff7e61eSJeff Mahoney static noinline void wait_for_commit(struct btrfs_transaction *commit) 83189ce8a63SChris Mason { 8324a9d8bdeSMiao Xie wait_event(commit->commit_wait, commit->state == TRANS_STATE_COMPLETED); 83389ce8a63SChris Mason } 83489ce8a63SChris Mason 8352ff7e61eSJeff Mahoney int btrfs_wait_for_commit(struct btrfs_fs_info *fs_info, u64 transid) 83646204592SSage Weil { 83746204592SSage Weil struct btrfs_transaction *cur_trans = NULL, *t; 8388cd2807fSMiao Xie int ret = 0; 83946204592SSage Weil 84046204592SSage Weil if (transid) { 8410b246afaSJeff Mahoney if (transid <= fs_info->last_trans_committed) 842a4abeea4SJosef Bacik goto out; 84346204592SSage Weil 84446204592SSage Weil /* find specified transaction */ 8450b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 8460b246afaSJeff Mahoney list_for_each_entry(t, &fs_info->trans_list, list) { 84746204592SSage Weil if (t->transid == transid) { 84846204592SSage Weil cur_trans = t; 8499b64f57dSElena Reshetova refcount_inc(&cur_trans->use_count); 8508cd2807fSMiao Xie ret = 0; 85146204592SSage Weil break; 85246204592SSage Weil } 8538cd2807fSMiao Xie if (t->transid > transid) { 8548cd2807fSMiao Xie ret = 0; 85546204592SSage Weil break; 85646204592SSage Weil } 8578cd2807fSMiao Xie } 8580b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 85942383020SSage Weil 86042383020SSage Weil /* 86142383020SSage Weil * The specified transaction doesn't exist, or we 86242383020SSage Weil * raced with btrfs_commit_transaction 86342383020SSage Weil */ 86442383020SSage Weil if (!cur_trans) { 8650b246afaSJeff Mahoney if (transid > fs_info->last_trans_committed) 86642383020SSage Weil ret = -EINVAL; 8678cd2807fSMiao Xie goto out; 86842383020SSage Weil } 86946204592SSage Weil } else { 87046204592SSage Weil /* find newest transaction that is committing | committed */ 8710b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 8720b246afaSJeff Mahoney list_for_each_entry_reverse(t, &fs_info->trans_list, 87346204592SSage Weil list) { 8744a9d8bdeSMiao Xie if (t->state >= TRANS_STATE_COMMIT_START) { 8754a9d8bdeSMiao Xie if (t->state == TRANS_STATE_COMPLETED) 8763473f3c0SJosef Bacik break; 87746204592SSage Weil cur_trans = t; 8789b64f57dSElena Reshetova refcount_inc(&cur_trans->use_count); 87946204592SSage Weil break; 88046204592SSage Weil } 88146204592SSage Weil } 8820b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 88346204592SSage Weil if (!cur_trans) 884a4abeea4SJosef Bacik goto out; /* nothing committing|committed */ 88546204592SSage Weil } 88646204592SSage Weil 8872ff7e61eSJeff Mahoney wait_for_commit(cur_trans); 888724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 889a4abeea4SJosef Bacik out: 89046204592SSage Weil return ret; 89146204592SSage Weil } 89246204592SSage Weil 8932ff7e61eSJeff Mahoney void btrfs_throttle(struct btrfs_fs_info *fs_info) 89437d1aeeeSChris Mason { 8952ff7e61eSJeff Mahoney wait_current_trans(fs_info); 89637d1aeeeSChris Mason } 89737d1aeeeSChris Mason 8988a8f4deaSNikolay Borisov static bool should_end_transaction(struct btrfs_trans_handle *trans) 8998929ecfaSYan, Zheng { 9002ff7e61eSJeff Mahoney struct btrfs_fs_info *fs_info = trans->fs_info; 9010b246afaSJeff Mahoney 90264403612SJosef Bacik if (btrfs_check_space_for_delayed_refs(fs_info)) 9038a8f4deaSNikolay Borisov return true; 90436ba022aSJosef Bacik 9052ff7e61eSJeff Mahoney return !!btrfs_block_rsv_check(&fs_info->global_block_rsv, 5); 9068929ecfaSYan, Zheng } 9078929ecfaSYan, Zheng 908a2633b6aSNikolay Borisov bool btrfs_should_end_transaction(struct btrfs_trans_handle *trans) 9098929ecfaSYan, Zheng { 9108929ecfaSYan, Zheng struct btrfs_transaction *cur_trans = trans->transaction; 9118929ecfaSYan, Zheng 9123296bf56SQu Wenruo if (cur_trans->state >= TRANS_STATE_COMMIT_START || 913*e19eb11fSJosef Bacik test_bit(BTRFS_DELAYED_REFS_FLUSHING, &cur_trans->delayed_refs.flags)) 914a2633b6aSNikolay Borisov return true; 9158929ecfaSYan, Zheng 9162ff7e61eSJeff Mahoney return should_end_transaction(trans); 9178929ecfaSYan, Zheng } 9188929ecfaSYan, Zheng 919dc60c525SNikolay Borisov static void btrfs_trans_release_metadata(struct btrfs_trans_handle *trans) 920dc60c525SNikolay Borisov 9210e34693fSNikolay Borisov { 922dc60c525SNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 923dc60c525SNikolay Borisov 9240e34693fSNikolay Borisov if (!trans->block_rsv) { 9250e34693fSNikolay Borisov ASSERT(!trans->bytes_reserved); 9260e34693fSNikolay Borisov return; 9270e34693fSNikolay Borisov } 9280e34693fSNikolay Borisov 9290e34693fSNikolay Borisov if (!trans->bytes_reserved) 9300e34693fSNikolay Borisov return; 9310e34693fSNikolay Borisov 9320e34693fSNikolay Borisov ASSERT(trans->block_rsv == &fs_info->trans_block_rsv); 9330e34693fSNikolay Borisov trace_btrfs_space_reservation(fs_info, "transaction", 9340e34693fSNikolay Borisov trans->transid, trans->bytes_reserved, 0); 9350e34693fSNikolay Borisov btrfs_block_rsv_release(fs_info, trans->block_rsv, 93663f018beSNikolay Borisov trans->bytes_reserved, NULL); 9370e34693fSNikolay Borisov trans->bytes_reserved = 0; 9380e34693fSNikolay Borisov } 9390e34693fSNikolay Borisov 94089ce8a63SChris Mason static int __btrfs_end_transaction(struct btrfs_trans_handle *trans, 9413a45bb20SJeff Mahoney int throttle) 94279154b1bSChris Mason { 9433a45bb20SJeff Mahoney struct btrfs_fs_info *info = trans->fs_info; 9448929ecfaSYan, Zheng struct btrfs_transaction *cur_trans = trans->transaction; 9454edc2ca3SDave Jones int err = 0; 946d6e4a428SChris Mason 947b50fff81SDavid Sterba if (refcount_read(&trans->use_count) > 1) { 948b50fff81SDavid Sterba refcount_dec(&trans->use_count); 9492a1eb461SJosef Bacik trans->block_rsv = trans->orig_rsv; 9502a1eb461SJosef Bacik return 0; 9512a1eb461SJosef Bacik } 9522a1eb461SJosef Bacik 953dc60c525SNikolay Borisov btrfs_trans_release_metadata(trans); 9544c13d758SJosef Bacik trans->block_rsv = NULL; 955c5567237SArne Jansen 9566c686b35SNikolay Borisov btrfs_create_pending_block_groups(trans); 957ea658badSJosef Bacik 9584fbcdf66SFilipe Manana btrfs_trans_release_chunk_metadata(trans); 9594fbcdf66SFilipe Manana 9600860adfdSMiao Xie if (trans->type & __TRANS_FREEZABLE) 9610b246afaSJeff Mahoney sb_end_intwrite(info->sb); 9626df7881aSJosef Bacik 9638929ecfaSYan, Zheng WARN_ON(cur_trans != info->running_transaction); 96413c5a93eSJosef Bacik WARN_ON(atomic_read(&cur_trans->num_writers) < 1); 96513c5a93eSJosef Bacik atomic_dec(&cur_trans->num_writers); 9660860adfdSMiao Xie extwriter_counter_dec(cur_trans, trans->type); 96789ce8a63SChris Mason 968093258e6SDavid Sterba cond_wake_up(&cur_trans->writer_wait); 969724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 9709ed74f2dSJosef Bacik 9719ed74f2dSJosef Bacik if (current->journal_info == trans) 9729ed74f2dSJosef Bacik current->journal_info = NULL; 973ab78c84dSChris Mason 97424bbcf04SYan, Zheng if (throttle) 9752ff7e61eSJeff Mahoney btrfs_run_delayed_iputs(info); 97624bbcf04SYan, Zheng 977bf31f87fSDavid Sterba if (TRANS_ABORTED(trans) || 9780b246afaSJeff Mahoney test_bit(BTRFS_FS_STATE_ERROR, &info->fs_state)) { 9794e121c06SJosef Bacik wake_up_process(info->transaction_kthread); 980fbabd4a3SJosef Bacik if (TRANS_ABORTED(trans)) 981fbabd4a3SJosef Bacik err = trans->aborted; 982fbabd4a3SJosef Bacik else 983fbabd4a3SJosef Bacik err = -EROFS; 9844e121c06SJosef Bacik } 98549b25e05SJeff Mahoney 9864edc2ca3SDave Jones kmem_cache_free(btrfs_trans_handle_cachep, trans); 9874edc2ca3SDave Jones return err; 98879154b1bSChris Mason } 98979154b1bSChris Mason 9903a45bb20SJeff Mahoney int btrfs_end_transaction(struct btrfs_trans_handle *trans) 99189ce8a63SChris Mason { 9923a45bb20SJeff Mahoney return __btrfs_end_transaction(trans, 0); 99389ce8a63SChris Mason } 99489ce8a63SChris Mason 9953a45bb20SJeff Mahoney int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans) 99689ce8a63SChris Mason { 9973a45bb20SJeff Mahoney return __btrfs_end_transaction(trans, 1); 99816cdcec7SMiao Xie } 99916cdcec7SMiao Xie 1000d352ac68SChris Mason /* 1001d352ac68SChris Mason * when btree blocks are allocated, they have some corresponding bits set for 1002d352ac68SChris Mason * them in one of two extent_io trees. This is used to make sure all of 1003690587d1SChris Mason * those extents are sent to disk but does not wait on them 1004d352ac68SChris Mason */ 10052ff7e61eSJeff Mahoney int btrfs_write_marked_extents(struct btrfs_fs_info *fs_info, 10068cef4e16SYan, Zheng struct extent_io_tree *dirty_pages, int mark) 100779154b1bSChris Mason { 1008777e6bd7SChris Mason int err = 0; 10097c4452b9SChris Mason int werr = 0; 10100b246afaSJeff Mahoney struct address_space *mapping = fs_info->btree_inode->i_mapping; 1011e6138876SJosef Bacik struct extent_state *cached_state = NULL; 1012777e6bd7SChris Mason u64 start = 0; 10135f39d397SChris Mason u64 end; 10147c4452b9SChris Mason 10156300463bSLiu Bo atomic_inc(&BTRFS_I(fs_info->btree_inode)->sync_writers); 10161728366eSJosef Bacik while (!find_first_extent_bit(dirty_pages, start, &start, &end, 1017e6138876SJosef Bacik mark, &cached_state)) { 1018663dfbb0SFilipe Manana bool wait_writeback = false; 1019663dfbb0SFilipe Manana 1020663dfbb0SFilipe Manana err = convert_extent_bit(dirty_pages, start, end, 1021663dfbb0SFilipe Manana EXTENT_NEED_WAIT, 1022210aa277SDavid Sterba mark, &cached_state); 1023663dfbb0SFilipe Manana /* 1024663dfbb0SFilipe Manana * convert_extent_bit can return -ENOMEM, which is most of the 1025663dfbb0SFilipe Manana * time a temporary error. So when it happens, ignore the error 1026663dfbb0SFilipe Manana * and wait for writeback of this range to finish - because we 1027663dfbb0SFilipe Manana * failed to set the bit EXTENT_NEED_WAIT for the range, a call 1028bf89d38fSJeff Mahoney * to __btrfs_wait_marked_extents() would not know that 1029bf89d38fSJeff Mahoney * writeback for this range started and therefore wouldn't 1030bf89d38fSJeff Mahoney * wait for it to finish - we don't want to commit a 1031bf89d38fSJeff Mahoney * superblock that points to btree nodes/leafs for which 1032bf89d38fSJeff Mahoney * writeback hasn't finished yet (and without errors). 1033663dfbb0SFilipe Manana * We cleanup any entries left in the io tree when committing 103441e7acd3SNikolay Borisov * the transaction (through extent_io_tree_release()). 1035663dfbb0SFilipe Manana */ 1036663dfbb0SFilipe Manana if (err == -ENOMEM) { 1037663dfbb0SFilipe Manana err = 0; 1038663dfbb0SFilipe Manana wait_writeback = true; 1039663dfbb0SFilipe Manana } 1040663dfbb0SFilipe Manana if (!err) 10411728366eSJosef Bacik err = filemap_fdatawrite_range(mapping, start, end); 10427c4452b9SChris Mason if (err) 10437c4452b9SChris Mason werr = err; 1044663dfbb0SFilipe Manana else if (wait_writeback) 1045663dfbb0SFilipe Manana werr = filemap_fdatawait_range(mapping, start, end); 1046e38e2ed7SFilipe Manana free_extent_state(cached_state); 1047663dfbb0SFilipe Manana cached_state = NULL; 10481728366eSJosef Bacik cond_resched(); 10491728366eSJosef Bacik start = end + 1; 10507c4452b9SChris Mason } 10516300463bSLiu Bo atomic_dec(&BTRFS_I(fs_info->btree_inode)->sync_writers); 1052690587d1SChris Mason return werr; 1053690587d1SChris Mason } 1054690587d1SChris Mason 1055690587d1SChris Mason /* 1056690587d1SChris Mason * when btree blocks are allocated, they have some corresponding bits set for 1057690587d1SChris Mason * them in one of two extent_io trees. This is used to make sure all of 1058690587d1SChris Mason * those extents are on disk for transaction or log commit. We wait 1059690587d1SChris Mason * on all the pages and clear them from the dirty pages state tree 1060690587d1SChris Mason */ 1061bf89d38fSJeff Mahoney static int __btrfs_wait_marked_extents(struct btrfs_fs_info *fs_info, 1062bf89d38fSJeff Mahoney struct extent_io_tree *dirty_pages) 1063690587d1SChris Mason { 1064690587d1SChris Mason int err = 0; 1065690587d1SChris Mason int werr = 0; 10660b246afaSJeff Mahoney struct address_space *mapping = fs_info->btree_inode->i_mapping; 1067e6138876SJosef Bacik struct extent_state *cached_state = NULL; 1068690587d1SChris Mason u64 start = 0; 1069690587d1SChris Mason u64 end; 1070690587d1SChris Mason 10711728366eSJosef Bacik while (!find_first_extent_bit(dirty_pages, start, &start, &end, 1072e6138876SJosef Bacik EXTENT_NEED_WAIT, &cached_state)) { 1073663dfbb0SFilipe Manana /* 1074663dfbb0SFilipe Manana * Ignore -ENOMEM errors returned by clear_extent_bit(). 1075663dfbb0SFilipe Manana * When committing the transaction, we'll remove any entries 1076663dfbb0SFilipe Manana * left in the io tree. For a log commit, we don't remove them 1077663dfbb0SFilipe Manana * after committing the log because the tree can be accessed 1078663dfbb0SFilipe Manana * concurrently - we do it only at transaction commit time when 107941e7acd3SNikolay Borisov * it's safe to do it (through extent_io_tree_release()). 1080663dfbb0SFilipe Manana */ 1081663dfbb0SFilipe Manana err = clear_extent_bit(dirty_pages, start, end, 1082ae0f1625SDavid Sterba EXTENT_NEED_WAIT, 0, 0, &cached_state); 1083663dfbb0SFilipe Manana if (err == -ENOMEM) 1084663dfbb0SFilipe Manana err = 0; 1085663dfbb0SFilipe Manana if (!err) 10861728366eSJosef Bacik err = filemap_fdatawait_range(mapping, start, end); 1087777e6bd7SChris Mason if (err) 1088777e6bd7SChris Mason werr = err; 1089e38e2ed7SFilipe Manana free_extent_state(cached_state); 1090e38e2ed7SFilipe Manana cached_state = NULL; 1091777e6bd7SChris Mason cond_resched(); 10921728366eSJosef Bacik start = end + 1; 1093777e6bd7SChris Mason } 10947c4452b9SChris Mason if (err) 10957c4452b9SChris Mason werr = err; 1096bf89d38fSJeff Mahoney return werr; 1097bf89d38fSJeff Mahoney } 1098656f30dbSFilipe Manana 1099b9fae2ebSFilipe Manana static int btrfs_wait_extents(struct btrfs_fs_info *fs_info, 1100bf89d38fSJeff Mahoney struct extent_io_tree *dirty_pages) 1101bf89d38fSJeff Mahoney { 1102bf89d38fSJeff Mahoney bool errors = false; 1103bf89d38fSJeff Mahoney int err; 1104bf89d38fSJeff Mahoney 1105bf89d38fSJeff Mahoney err = __btrfs_wait_marked_extents(fs_info, dirty_pages); 1106bf89d38fSJeff Mahoney if (test_and_clear_bit(BTRFS_FS_BTREE_ERR, &fs_info->flags)) 1107bf89d38fSJeff Mahoney errors = true; 1108bf89d38fSJeff Mahoney 1109bf89d38fSJeff Mahoney if (errors && !err) 1110bf89d38fSJeff Mahoney err = -EIO; 1111bf89d38fSJeff Mahoney return err; 1112bf89d38fSJeff Mahoney } 1113bf89d38fSJeff Mahoney 1114bf89d38fSJeff Mahoney int btrfs_wait_tree_log_extents(struct btrfs_root *log_root, int mark) 1115bf89d38fSJeff Mahoney { 1116bf89d38fSJeff Mahoney struct btrfs_fs_info *fs_info = log_root->fs_info; 1117bf89d38fSJeff Mahoney struct extent_io_tree *dirty_pages = &log_root->dirty_log_pages; 1118bf89d38fSJeff Mahoney bool errors = false; 1119bf89d38fSJeff Mahoney int err; 1120bf89d38fSJeff Mahoney 1121bf89d38fSJeff Mahoney ASSERT(log_root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID); 1122bf89d38fSJeff Mahoney 1123bf89d38fSJeff Mahoney err = __btrfs_wait_marked_extents(fs_info, dirty_pages); 1124656f30dbSFilipe Manana if ((mark & EXTENT_DIRTY) && 11250b246afaSJeff Mahoney test_and_clear_bit(BTRFS_FS_LOG1_ERR, &fs_info->flags)) 1126656f30dbSFilipe Manana errors = true; 1127656f30dbSFilipe Manana 1128656f30dbSFilipe Manana if ((mark & EXTENT_NEW) && 11290b246afaSJeff Mahoney test_and_clear_bit(BTRFS_FS_LOG2_ERR, &fs_info->flags)) 1130656f30dbSFilipe Manana errors = true; 1131656f30dbSFilipe Manana 1132bf89d38fSJeff Mahoney if (errors && !err) 1133bf89d38fSJeff Mahoney err = -EIO; 1134bf89d38fSJeff Mahoney return err; 113579154b1bSChris Mason } 113679154b1bSChris Mason 1137690587d1SChris Mason /* 1138c9b577c0SNikolay Borisov * When btree blocks are allocated the corresponding extents are marked dirty. 1139c9b577c0SNikolay Borisov * This function ensures such extents are persisted on disk for transaction or 1140c9b577c0SNikolay Borisov * log commit. 1141c9b577c0SNikolay Borisov * 1142c9b577c0SNikolay Borisov * @trans: transaction whose dirty pages we'd like to write 1143690587d1SChris Mason */ 114470458a58SNikolay Borisov static int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans) 1145d0c803c4SChris Mason { 1146663dfbb0SFilipe Manana int ret; 1147c9b577c0SNikolay Borisov int ret2; 1148c9b577c0SNikolay Borisov struct extent_io_tree *dirty_pages = &trans->transaction->dirty_pages; 114970458a58SNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 1150c9b577c0SNikolay Borisov struct blk_plug plug; 1151663dfbb0SFilipe Manana 1152c9b577c0SNikolay Borisov blk_start_plug(&plug); 1153c9b577c0SNikolay Borisov ret = btrfs_write_marked_extents(fs_info, dirty_pages, EXTENT_DIRTY); 1154c9b577c0SNikolay Borisov blk_finish_plug(&plug); 1155c9b577c0SNikolay Borisov ret2 = btrfs_wait_extents(fs_info, dirty_pages); 1156c9b577c0SNikolay Borisov 115741e7acd3SNikolay Borisov extent_io_tree_release(&trans->transaction->dirty_pages); 1158663dfbb0SFilipe Manana 1159c9b577c0SNikolay Borisov if (ret) 1160663dfbb0SFilipe Manana return ret; 1161c9b577c0SNikolay Borisov else if (ret2) 1162c9b577c0SNikolay Borisov return ret2; 1163c9b577c0SNikolay Borisov else 1164c9b577c0SNikolay Borisov return 0; 1165d0c803c4SChris Mason } 1166d0c803c4SChris Mason 1167d352ac68SChris Mason /* 1168d352ac68SChris Mason * this is used to update the root pointer in the tree of tree roots. 1169d352ac68SChris Mason * 1170d352ac68SChris Mason * But, in the case of the extent allocation tree, updating the root 1171d352ac68SChris Mason * pointer may allocate blocks which may change the root of the extent 1172d352ac68SChris Mason * allocation tree. 1173d352ac68SChris Mason * 1174d352ac68SChris Mason * So, this loops and repeats and makes sure the cowonly root didn't 1175d352ac68SChris Mason * change while the root pointer was being updated in the metadata. 1176d352ac68SChris Mason */ 11770b86a832SChris Mason static int update_cowonly_root(struct btrfs_trans_handle *trans, 117879154b1bSChris Mason struct btrfs_root *root) 117979154b1bSChris Mason { 118079154b1bSChris Mason int ret; 11810b86a832SChris Mason u64 old_root_bytenr; 118286b9f2ecSYan, Zheng u64 old_root_used; 11830b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 11840b246afaSJeff Mahoney struct btrfs_root *tree_root = fs_info->tree_root; 118579154b1bSChris Mason 118686b9f2ecSYan, Zheng old_root_used = btrfs_root_used(&root->root_item); 118756bec294SChris Mason 118879154b1bSChris Mason while (1) { 11890b86a832SChris Mason old_root_bytenr = btrfs_root_bytenr(&root->root_item); 119086b9f2ecSYan, Zheng if (old_root_bytenr == root->node->start && 1191ea526d18SJosef Bacik old_root_used == btrfs_root_used(&root->root_item)) 119279154b1bSChris Mason break; 119387ef2bb4SChris Mason 11945d4f98a2SYan Zheng btrfs_set_root_node(&root->root_item, root->node); 119579154b1bSChris Mason ret = btrfs_update_root(trans, tree_root, 11960b86a832SChris Mason &root->root_key, 11970b86a832SChris Mason &root->root_item); 119849b25e05SJeff Mahoney if (ret) 119949b25e05SJeff Mahoney return ret; 120056bec294SChris Mason 120186b9f2ecSYan, Zheng old_root_used = btrfs_root_used(&root->root_item); 1202e7070be1SJosef Bacik } 1203276e680dSYan Zheng 12040b86a832SChris Mason return 0; 12050b86a832SChris Mason } 12060b86a832SChris Mason 1207d352ac68SChris Mason /* 1208d352ac68SChris Mason * update all the cowonly tree roots on disk 120949b25e05SJeff Mahoney * 121049b25e05SJeff Mahoney * The error handling in this function may not be obvious. Any of the 121149b25e05SJeff Mahoney * failures will cause the file system to go offline. We still need 121249b25e05SJeff Mahoney * to clean up the delayed refs. 1213d352ac68SChris Mason */ 12149386d8bcSNikolay Borisov static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans) 12150b86a832SChris Mason { 12169386d8bcSNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 1217ea526d18SJosef Bacik struct list_head *dirty_bgs = &trans->transaction->dirty_bgs; 12181bbc621eSChris Mason struct list_head *io_bgs = &trans->transaction->io_bgs; 12190b86a832SChris Mason struct list_head *next; 122084234f3aSYan Zheng struct extent_buffer *eb; 122156bec294SChris Mason int ret; 122284234f3aSYan Zheng 122384234f3aSYan Zheng eb = btrfs_lock_root_node(fs_info->tree_root); 122449b25e05SJeff Mahoney ret = btrfs_cow_block(trans, fs_info->tree_root, eb, NULL, 12259631e4ccSJosef Bacik 0, &eb, BTRFS_NESTING_COW); 122684234f3aSYan Zheng btrfs_tree_unlock(eb); 122784234f3aSYan Zheng free_extent_buffer(eb); 12280b86a832SChris Mason 122949b25e05SJeff Mahoney if (ret) 123049b25e05SJeff Mahoney return ret; 123149b25e05SJeff Mahoney 1232c79a70b1SNikolay Borisov ret = btrfs_run_delayed_refs(trans, (unsigned long)-1); 123349b25e05SJeff Mahoney if (ret) 123449b25e05SJeff Mahoney return ret; 123587ef2bb4SChris Mason 1236196c9d8dSDavid Sterba ret = btrfs_run_dev_stats(trans); 1237c16ce190SJosef Bacik if (ret) 1238c16ce190SJosef Bacik return ret; 12392b584c68SDavid Sterba ret = btrfs_run_dev_replace(trans); 1240c16ce190SJosef Bacik if (ret) 1241c16ce190SJosef Bacik return ret; 1242280f8bd2SLu Fengqi ret = btrfs_run_qgroups(trans); 1243c16ce190SJosef Bacik if (ret) 1244c16ce190SJosef Bacik return ret; 1245546adb0dSJan Schmidt 1246bbebb3e0SDavid Sterba ret = btrfs_setup_space_cache(trans); 1247dcdf7f6dSJosef Bacik if (ret) 1248dcdf7f6dSJosef Bacik return ret; 1249dcdf7f6dSJosef Bacik 1250546adb0dSJan Schmidt /* run_qgroups might have added some more refs */ 1251c79a70b1SNikolay Borisov ret = btrfs_run_delayed_refs(trans, (unsigned long)-1); 1252c16ce190SJosef Bacik if (ret) 1253c16ce190SJosef Bacik return ret; 1254ea526d18SJosef Bacik again: 12550b86a832SChris Mason while (!list_empty(&fs_info->dirty_cowonly_roots)) { 12562ff7e61eSJeff Mahoney struct btrfs_root *root; 12570b86a832SChris Mason next = fs_info->dirty_cowonly_roots.next; 12580b86a832SChris Mason list_del_init(next); 12590b86a832SChris Mason root = list_entry(next, struct btrfs_root, dirty_list); 1260e7070be1SJosef Bacik clear_bit(BTRFS_ROOT_DIRTY, &root->state); 126187ef2bb4SChris Mason 12629e351cc8SJosef Bacik if (root != fs_info->extent_root) 12639e351cc8SJosef Bacik list_add_tail(&root->dirty_list, 12649e351cc8SJosef Bacik &trans->transaction->switch_commits); 126549b25e05SJeff Mahoney ret = update_cowonly_root(trans, root); 126649b25e05SJeff Mahoney if (ret) 126749b25e05SJeff Mahoney return ret; 1268c79a70b1SNikolay Borisov ret = btrfs_run_delayed_refs(trans, (unsigned long)-1); 1269ea526d18SJosef Bacik if (ret) 1270ea526d18SJosef Bacik return ret; 127179154b1bSChris Mason } 1272276e680dSYan Zheng 12731bbc621eSChris Mason while (!list_empty(dirty_bgs) || !list_empty(io_bgs)) { 12745742d15fSDavid Sterba ret = btrfs_write_dirty_block_groups(trans); 1275ea526d18SJosef Bacik if (ret) 1276ea526d18SJosef Bacik return ret; 1277c79a70b1SNikolay Borisov ret = btrfs_run_delayed_refs(trans, (unsigned long)-1); 1278ea526d18SJosef Bacik if (ret) 1279ea526d18SJosef Bacik return ret; 1280ea526d18SJosef Bacik } 1281ea526d18SJosef Bacik 1282ea526d18SJosef Bacik if (!list_empty(&fs_info->dirty_cowonly_roots)) 1283ea526d18SJosef Bacik goto again; 1284ea526d18SJosef Bacik 12859e351cc8SJosef Bacik list_add_tail(&fs_info->extent_root->dirty_list, 12869e351cc8SJosef Bacik &trans->transaction->switch_commits); 12879f6cbcbbSDavid Sterba 12889f6cbcbbSDavid Sterba /* Update dev-replace pointer once everything is committed */ 12899f6cbcbbSDavid Sterba fs_info->dev_replace.committed_cursor_left = 12909f6cbcbbSDavid Sterba fs_info->dev_replace.cursor_left_last_write_of_item; 12918dabb742SStefan Behrens 129279154b1bSChris Mason return 0; 129379154b1bSChris Mason } 129479154b1bSChris Mason 1295d352ac68SChris Mason /* 1296d352ac68SChris Mason * dead roots are old snapshots that need to be deleted. This allocates 1297d352ac68SChris Mason * a dirty root struct and adds it into the list of dead roots that need to 1298d352ac68SChris Mason * be deleted 1299d352ac68SChris Mason */ 1300cfad392bSJosef Bacik void btrfs_add_dead_root(struct btrfs_root *root) 13015eda7b5eSChris Mason { 13020b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 13030b246afaSJeff Mahoney 13040b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 1305dc9492c1SJosef Bacik if (list_empty(&root->root_list)) { 1306dc9492c1SJosef Bacik btrfs_grab_root(root); 13070b246afaSJeff Mahoney list_add_tail(&root->root_list, &fs_info->dead_roots); 1308dc9492c1SJosef Bacik } 13090b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 13105eda7b5eSChris Mason } 13115eda7b5eSChris Mason 1312d352ac68SChris Mason /* 13135d4f98a2SYan Zheng * update all the cowonly tree roots on disk 1314d352ac68SChris Mason */ 13157e4443d9SNikolay Borisov static noinline int commit_fs_roots(struct btrfs_trans_handle *trans) 13160f7d52f4SChris Mason { 13177e4443d9SNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 13180f7d52f4SChris Mason struct btrfs_root *gang[8]; 13190f7d52f4SChris Mason int i; 13200f7d52f4SChris Mason int ret; 132154aa1f4dSChris Mason 1322a4abeea4SJosef Bacik spin_lock(&fs_info->fs_roots_radix_lock); 13230f7d52f4SChris Mason while (1) { 13245d4f98a2SYan Zheng ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix, 13255d4f98a2SYan Zheng (void **)gang, 0, 13260f7d52f4SChris Mason ARRAY_SIZE(gang), 13270f7d52f4SChris Mason BTRFS_ROOT_TRANS_TAG); 13280f7d52f4SChris Mason if (ret == 0) 13290f7d52f4SChris Mason break; 13300f7d52f4SChris Mason for (i = 0; i < ret; i++) { 13315b4aacefSJeff Mahoney struct btrfs_root *root = gang[i]; 13324f4317c1SJosef Bacik int ret2; 13334f4317c1SJosef Bacik 13345d4f98a2SYan Zheng radix_tree_tag_clear(&fs_info->fs_roots_radix, 13352619ba1fSChris Mason (unsigned long)root->root_key.objectid, 13360f7d52f4SChris Mason BTRFS_ROOT_TRANS_TAG); 1337a4abeea4SJosef Bacik spin_unlock(&fs_info->fs_roots_radix_lock); 133831153d81SYan Zheng 1339e02119d5SChris Mason btrfs_free_log(trans, root); 13405d4f98a2SYan Zheng btrfs_update_reloc_root(trans, root); 1341e02119d5SChris Mason 1342f1ebcc74SLiu Bo /* see comments in should_cow_block() */ 134327cdeb70SMiao Xie clear_bit(BTRFS_ROOT_FORCE_COW, &root->state); 1344c7548af6SChris Mason smp_mb__after_atomic(); 1345f1ebcc74SLiu Bo 1346978d910dSYan Zheng if (root->commit_root != root->node) { 13479e351cc8SJosef Bacik list_add_tail(&root->dirty_list, 13489e351cc8SJosef Bacik &trans->transaction->switch_commits); 1349978d910dSYan Zheng btrfs_set_root_node(&root->root_item, 1350978d910dSYan Zheng root->node); 1351978d910dSYan Zheng } 135231153d81SYan Zheng 13534f4317c1SJosef Bacik ret2 = btrfs_update_root(trans, fs_info->tree_root, 13540f7d52f4SChris Mason &root->root_key, 13550f7d52f4SChris Mason &root->root_item); 13564f4317c1SJosef Bacik if (ret2) 13574f4317c1SJosef Bacik return ret2; 1358a4abeea4SJosef Bacik spin_lock(&fs_info->fs_roots_radix_lock); 1359733e03a0SQu Wenruo btrfs_qgroup_free_meta_all_pertrans(root); 13600f7d52f4SChris Mason } 13619f3a7427SChris Mason } 1362a4abeea4SJosef Bacik spin_unlock(&fs_info->fs_roots_radix_lock); 13634f4317c1SJosef Bacik return 0; 13640f7d52f4SChris Mason } 13650f7d52f4SChris Mason 1366d352ac68SChris Mason /* 1367de78b51aSEric Sandeen * defrag a given btree. 1368de78b51aSEric Sandeen * Every leaf in the btree is read and defragged. 1369d352ac68SChris Mason */ 1370de78b51aSEric Sandeen int btrfs_defrag_root(struct btrfs_root *root) 1371e9d0b13bSChris Mason { 1372e9d0b13bSChris Mason struct btrfs_fs_info *info = root->fs_info; 1373e9d0b13bSChris Mason struct btrfs_trans_handle *trans; 13748929ecfaSYan, Zheng int ret; 1375e9d0b13bSChris Mason 137627cdeb70SMiao Xie if (test_and_set_bit(BTRFS_ROOT_DEFRAG_RUNNING, &root->state)) 1377e9d0b13bSChris Mason return 0; 13788929ecfaSYan, Zheng 13796b80053dSChris Mason while (1) { 13808929ecfaSYan, Zheng trans = btrfs_start_transaction(root, 0); 13818929ecfaSYan, Zheng if (IS_ERR(trans)) 13828929ecfaSYan, Zheng return PTR_ERR(trans); 13838929ecfaSYan, Zheng 1384de78b51aSEric Sandeen ret = btrfs_defrag_leaves(trans, root); 13858929ecfaSYan, Zheng 13863a45bb20SJeff Mahoney btrfs_end_transaction(trans); 13872ff7e61eSJeff Mahoney btrfs_btree_balance_dirty(info); 1388e9d0b13bSChris Mason cond_resched(); 1389e9d0b13bSChris Mason 1390ab8d0fc4SJeff Mahoney if (btrfs_fs_closing(info) || ret != -EAGAIN) 1391e9d0b13bSChris Mason break; 1392210549ebSDavid Sterba 1393ab8d0fc4SJeff Mahoney if (btrfs_defrag_cancelled(info)) { 1394ab8d0fc4SJeff Mahoney btrfs_debug(info, "defrag_root cancelled"); 1395210549ebSDavid Sterba ret = -EAGAIN; 1396210549ebSDavid Sterba break; 1397210549ebSDavid Sterba } 1398e9d0b13bSChris Mason } 139927cdeb70SMiao Xie clear_bit(BTRFS_ROOT_DEFRAG_RUNNING, &root->state); 14008929ecfaSYan, Zheng return ret; 1401e9d0b13bSChris Mason } 1402e9d0b13bSChris Mason 1403d352ac68SChris Mason /* 14046426c7adSQu Wenruo * Do all special snapshot related qgroup dirty hack. 14056426c7adSQu Wenruo * 14066426c7adSQu Wenruo * Will do all needed qgroup inherit and dirty hack like switch commit 14076426c7adSQu Wenruo * roots inside one transaction and write all btree into disk, to make 14086426c7adSQu Wenruo * qgroup works. 14096426c7adSQu Wenruo */ 14106426c7adSQu Wenruo static int qgroup_account_snapshot(struct btrfs_trans_handle *trans, 14116426c7adSQu Wenruo struct btrfs_root *src, 14126426c7adSQu Wenruo struct btrfs_root *parent, 14136426c7adSQu Wenruo struct btrfs_qgroup_inherit *inherit, 14146426c7adSQu Wenruo u64 dst_objectid) 14156426c7adSQu Wenruo { 14166426c7adSQu Wenruo struct btrfs_fs_info *fs_info = src->fs_info; 14176426c7adSQu Wenruo int ret; 14186426c7adSQu Wenruo 14196426c7adSQu Wenruo /* 14206426c7adSQu Wenruo * Save some performance in the case that qgroups are not 14216426c7adSQu Wenruo * enabled. If this check races with the ioctl, rescan will 14226426c7adSQu Wenruo * kick in anyway. 14236426c7adSQu Wenruo */ 14249ea6e2b5SDavid Sterba if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags)) 14256426c7adSQu Wenruo return 0; 14266426c7adSQu Wenruo 14276426c7adSQu Wenruo /* 142852042d8eSAndrea Gelmini * Ensure dirty @src will be committed. Or, after coming 14294d31778aSQu Wenruo * commit_fs_roots() and switch_commit_roots(), any dirty but not 14304d31778aSQu Wenruo * recorded root will never be updated again, causing an outdated root 14314d31778aSQu Wenruo * item. 14324d31778aSQu Wenruo */ 14334d31778aSQu Wenruo record_root_in_trans(trans, src, 1); 14344d31778aSQu Wenruo 14354d31778aSQu Wenruo /* 14366426c7adSQu Wenruo * We are going to commit transaction, see btrfs_commit_transaction() 14376426c7adSQu Wenruo * comment for reason locking tree_log_mutex 14386426c7adSQu Wenruo */ 14396426c7adSQu Wenruo mutex_lock(&fs_info->tree_log_mutex); 14406426c7adSQu Wenruo 14417e4443d9SNikolay Borisov ret = commit_fs_roots(trans); 14426426c7adSQu Wenruo if (ret) 14436426c7adSQu Wenruo goto out; 1444460fb20aSNikolay Borisov ret = btrfs_qgroup_account_extents(trans); 14456426c7adSQu Wenruo if (ret < 0) 14466426c7adSQu Wenruo goto out; 14476426c7adSQu Wenruo 14486426c7adSQu Wenruo /* Now qgroup are all updated, we can inherit it to new qgroups */ 1449a9377422SLu Fengqi ret = btrfs_qgroup_inherit(trans, src->root_key.objectid, dst_objectid, 14506426c7adSQu Wenruo inherit); 14516426c7adSQu Wenruo if (ret < 0) 14526426c7adSQu Wenruo goto out; 14536426c7adSQu Wenruo 14546426c7adSQu Wenruo /* 14556426c7adSQu Wenruo * Now we do a simplified commit transaction, which will: 14566426c7adSQu Wenruo * 1) commit all subvolume and extent tree 14576426c7adSQu Wenruo * To ensure all subvolume and extent tree have a valid 14586426c7adSQu Wenruo * commit_root to accounting later insert_dir_item() 14596426c7adSQu Wenruo * 2) write all btree blocks onto disk 14606426c7adSQu Wenruo * This is to make sure later btree modification will be cowed 14616426c7adSQu Wenruo * Or commit_root can be populated and cause wrong qgroup numbers 14626426c7adSQu Wenruo * In this simplified commit, we don't really care about other trees 14636426c7adSQu Wenruo * like chunk and root tree, as they won't affect qgroup. 14646426c7adSQu Wenruo * And we don't write super to avoid half committed status. 14656426c7adSQu Wenruo */ 14669386d8bcSNikolay Borisov ret = commit_cowonly_roots(trans); 14676426c7adSQu Wenruo if (ret) 14686426c7adSQu Wenruo goto out; 1469889bfa39SJosef Bacik switch_commit_roots(trans); 147070458a58SNikolay Borisov ret = btrfs_write_and_wait_transaction(trans); 14716426c7adSQu Wenruo if (ret) 1472f7af3934SDavid Sterba btrfs_handle_fs_error(fs_info, ret, 14736426c7adSQu Wenruo "Error while writing out transaction for qgroup"); 14746426c7adSQu Wenruo 14756426c7adSQu Wenruo out: 14766426c7adSQu Wenruo mutex_unlock(&fs_info->tree_log_mutex); 14776426c7adSQu Wenruo 14786426c7adSQu Wenruo /* 14796426c7adSQu Wenruo * Force parent root to be updated, as we recorded it before so its 14806426c7adSQu Wenruo * last_trans == cur_transid. 14816426c7adSQu Wenruo * Or it won't be committed again onto disk after later 14826426c7adSQu Wenruo * insert_dir_item() 14836426c7adSQu Wenruo */ 14846426c7adSQu Wenruo if (!ret) 14856426c7adSQu Wenruo record_root_in_trans(trans, parent, 1); 14866426c7adSQu Wenruo return ret; 14876426c7adSQu Wenruo } 14886426c7adSQu Wenruo 14896426c7adSQu Wenruo /* 1490d352ac68SChris Mason * new snapshots need to be created at a very specific time in the 1491aec8030aSMiao Xie * transaction commit. This does the actual creation. 1492aec8030aSMiao Xie * 1493aec8030aSMiao Xie * Note: 1494aec8030aSMiao Xie * If the error which may affect the commitment of the current transaction 1495aec8030aSMiao Xie * happens, we should return the error number. If the error which just affect 1496aec8030aSMiao Xie * the creation of the pending snapshots, just return 0. 1497d352ac68SChris Mason */ 149880b6794dSChris Mason static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans, 14993063d29fSChris Mason struct btrfs_pending_snapshot *pending) 15003063d29fSChris Mason { 150108d50ca3SNikolay Borisov 150208d50ca3SNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 15033063d29fSChris Mason struct btrfs_key key; 150480b6794dSChris Mason struct btrfs_root_item *new_root_item; 15053063d29fSChris Mason struct btrfs_root *tree_root = fs_info->tree_root; 15063063d29fSChris Mason struct btrfs_root *root = pending->root; 15076bdb72deSSage Weil struct btrfs_root *parent_root; 150898c9942aSLiu Bo struct btrfs_block_rsv *rsv; 15096bdb72deSSage Weil struct inode *parent_inode; 151042874b3dSMiao Xie struct btrfs_path *path; 151142874b3dSMiao Xie struct btrfs_dir_item *dir_item; 1512a22285a6SYan, Zheng struct dentry *dentry; 15133063d29fSChris Mason struct extent_buffer *tmp; 1514925baeddSChris Mason struct extent_buffer *old; 151595582b00SDeepa Dinamani struct timespec64 cur_time; 1516aec8030aSMiao Xie int ret = 0; 1517d68fc57bSYan, Zheng u64 to_reserve = 0; 15186bdb72deSSage Weil u64 index = 0; 1519a22285a6SYan, Zheng u64 objectid; 1520b83cc969SLi Zefan u64 root_flags; 15213063d29fSChris Mason 15228546b570SDavid Sterba ASSERT(pending->path); 15238546b570SDavid Sterba path = pending->path; 152442874b3dSMiao Xie 1525b0c0ea63SDavid Sterba ASSERT(pending->root_item); 1526b0c0ea63SDavid Sterba new_root_item = pending->root_item; 1527a22285a6SYan, Zheng 1528543068a2SNikolay Borisov pending->error = btrfs_get_free_objectid(tree_root, &objectid); 1529aec8030aSMiao Xie if (pending->error) 15306fa9700eSMiao Xie goto no_free_objectid; 15313063d29fSChris Mason 1532d6726335SQu Wenruo /* 1533d6726335SQu Wenruo * Make qgroup to skip current new snapshot's qgroupid, as it is 1534d6726335SQu Wenruo * accounted by later btrfs_qgroup_inherit(). 1535d6726335SQu Wenruo */ 1536d6726335SQu Wenruo btrfs_set_skip_qgroup(trans, objectid); 1537d6726335SQu Wenruo 1538147d256eSZhaolei btrfs_reloc_pre_snapshot(pending, &to_reserve); 1539d68fc57bSYan, Zheng 1540d68fc57bSYan, Zheng if (to_reserve > 0) { 1541aec8030aSMiao Xie pending->error = btrfs_block_rsv_add(root, 1542aec8030aSMiao Xie &pending->block_rsv, 154308e007d2SMiao Xie to_reserve, 154408e007d2SMiao Xie BTRFS_RESERVE_NO_FLUSH); 1545aec8030aSMiao Xie if (pending->error) 1546d6726335SQu Wenruo goto clear_skip_qgroup; 1547d68fc57bSYan, Zheng } 1548d68fc57bSYan, Zheng 15493063d29fSChris Mason key.objectid = objectid; 1550a22285a6SYan, Zheng key.offset = (u64)-1; 1551a22285a6SYan, Zheng key.type = BTRFS_ROOT_ITEM_KEY; 15523063d29fSChris Mason 15536fa9700eSMiao Xie rsv = trans->block_rsv; 1554a22285a6SYan, Zheng trans->block_rsv = &pending->block_rsv; 15552382c5ccSLiu Bo trans->bytes_reserved = trans->block_rsv->reserved; 15560b246afaSJeff Mahoney trace_btrfs_space_reservation(fs_info, "transaction", 155788d3a5aaSJosef Bacik trans->transid, 155888d3a5aaSJosef Bacik trans->bytes_reserved, 1); 1559a22285a6SYan, Zheng dentry = pending->dentry; 1560e9662f70SMiao Xie parent_inode = pending->dir; 1561a22285a6SYan, Zheng parent_root = BTRFS_I(parent_inode)->root; 15626426c7adSQu Wenruo record_root_in_trans(trans, parent_root, 0); 1563a22285a6SYan, Zheng 1564c2050a45SDeepa Dinamani cur_time = current_time(parent_inode); 156504b285f3SDeepa Dinamani 15666bdb72deSSage Weil /* 15676bdb72deSSage Weil * insert the directory item 15686bdb72deSSage Weil */ 1569877574e2SNikolay Borisov ret = btrfs_set_inode_index(BTRFS_I(parent_inode), &index); 157049b25e05SJeff Mahoney BUG_ON(ret); /* -ENOMEM */ 157142874b3dSMiao Xie 157242874b3dSMiao Xie /* check if there is a file/dir which has the same name. */ 157342874b3dSMiao Xie dir_item = btrfs_lookup_dir_item(NULL, parent_root, path, 15744a0cc7caSNikolay Borisov btrfs_ino(BTRFS_I(parent_inode)), 157542874b3dSMiao Xie dentry->d_name.name, 157642874b3dSMiao Xie dentry->d_name.len, 0); 157742874b3dSMiao Xie if (dir_item != NULL && !IS_ERR(dir_item)) { 1578fe66a05aSChris Mason pending->error = -EEXIST; 1579aec8030aSMiao Xie goto dir_item_existed; 158042874b3dSMiao Xie } else if (IS_ERR(dir_item)) { 158142874b3dSMiao Xie ret = PTR_ERR(dir_item); 158266642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 15838732d44fSMiao Xie goto fail; 158479787eaaSJeff Mahoney } 158542874b3dSMiao Xie btrfs_release_path(path); 15866bdb72deSSage Weil 1587e999376fSChris Mason /* 1588e999376fSChris Mason * pull in the delayed directory update 1589e999376fSChris Mason * and the delayed inode item 1590e999376fSChris Mason * otherwise we corrupt the FS during 1591e999376fSChris Mason * snapshot 1592e999376fSChris Mason */ 1593e5c304e6SNikolay Borisov ret = btrfs_run_delayed_items(trans); 15948732d44fSMiao Xie if (ret) { /* Transaction aborted */ 159566642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 15968732d44fSMiao Xie goto fail; 15978732d44fSMiao Xie } 1598e999376fSChris Mason 15996426c7adSQu Wenruo record_root_in_trans(trans, root, 0); 16006bdb72deSSage Weil btrfs_set_root_last_snapshot(&root->root_item, trans->transid); 16016bdb72deSSage Weil memcpy(new_root_item, &root->root_item, sizeof(*new_root_item)); 160208fe4db1SLi Zefan btrfs_check_and_init_root_item(new_root_item); 16036bdb72deSSage Weil 1604b83cc969SLi Zefan root_flags = btrfs_root_flags(new_root_item); 1605b83cc969SLi Zefan if (pending->readonly) 1606b83cc969SLi Zefan root_flags |= BTRFS_ROOT_SUBVOL_RDONLY; 1607b83cc969SLi Zefan else 1608b83cc969SLi Zefan root_flags &= ~BTRFS_ROOT_SUBVOL_RDONLY; 1609b83cc969SLi Zefan btrfs_set_root_flags(new_root_item, root_flags); 1610b83cc969SLi Zefan 16118ea05e3aSAlexander Block btrfs_set_root_generation_v2(new_root_item, 16128ea05e3aSAlexander Block trans->transid); 1613807fc790SAndy Shevchenko generate_random_guid(new_root_item->uuid); 16148ea05e3aSAlexander Block memcpy(new_root_item->parent_uuid, root->root_item.uuid, 16158ea05e3aSAlexander Block BTRFS_UUID_SIZE); 161670023da2SStefan Behrens if (!(root_flags & BTRFS_ROOT_SUBVOL_RDONLY)) { 161770023da2SStefan Behrens memset(new_root_item->received_uuid, 0, 161870023da2SStefan Behrens sizeof(new_root_item->received_uuid)); 16198ea05e3aSAlexander Block memset(&new_root_item->stime, 0, sizeof(new_root_item->stime)); 16208ea05e3aSAlexander Block memset(&new_root_item->rtime, 0, sizeof(new_root_item->rtime)); 16218ea05e3aSAlexander Block btrfs_set_root_stransid(new_root_item, 0); 16228ea05e3aSAlexander Block btrfs_set_root_rtransid(new_root_item, 0); 162370023da2SStefan Behrens } 16243cae210fSQu Wenruo btrfs_set_stack_timespec_sec(&new_root_item->otime, cur_time.tv_sec); 16253cae210fSQu Wenruo btrfs_set_stack_timespec_nsec(&new_root_item->otime, cur_time.tv_nsec); 162670023da2SStefan Behrens btrfs_set_root_otransid(new_root_item, trans->transid); 16278ea05e3aSAlexander Block 1628925baeddSChris Mason old = btrfs_lock_root_node(root); 16299631e4ccSJosef Bacik ret = btrfs_cow_block(trans, root, old, NULL, 0, &old, 16309631e4ccSJosef Bacik BTRFS_NESTING_COW); 163179787eaaSJeff Mahoney if (ret) { 163279787eaaSJeff Mahoney btrfs_tree_unlock(old); 163379787eaaSJeff Mahoney free_extent_buffer(old); 163466642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 16358732d44fSMiao Xie goto fail; 163679787eaaSJeff Mahoney } 163749b25e05SJeff Mahoney 163849b25e05SJeff Mahoney ret = btrfs_copy_root(trans, root, old, &tmp, objectid); 163979787eaaSJeff Mahoney /* clean up in any case */ 1640925baeddSChris Mason btrfs_tree_unlock(old); 1641925baeddSChris Mason free_extent_buffer(old); 16428732d44fSMiao Xie if (ret) { 164366642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 16448732d44fSMiao Xie goto fail; 16458732d44fSMiao Xie } 1646f1ebcc74SLiu Bo /* see comments in should_cow_block() */ 164727cdeb70SMiao Xie set_bit(BTRFS_ROOT_FORCE_COW, &root->state); 1648f1ebcc74SLiu Bo smp_wmb(); 1649f1ebcc74SLiu Bo 16505d4f98a2SYan Zheng btrfs_set_root_node(new_root_item, tmp); 1651a22285a6SYan, Zheng /* record when the snapshot was created in key.offset */ 1652a22285a6SYan, Zheng key.offset = trans->transid; 1653a22285a6SYan, Zheng ret = btrfs_insert_root(trans, tree_root, &key, new_root_item); 1654925baeddSChris Mason btrfs_tree_unlock(tmp); 16553063d29fSChris Mason free_extent_buffer(tmp); 16568732d44fSMiao Xie if (ret) { 165766642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 16588732d44fSMiao Xie goto fail; 16598732d44fSMiao Xie } 16600660b5afSChris Mason 1661a22285a6SYan, Zheng /* 1662a22285a6SYan, Zheng * insert root back/forward references 1663a22285a6SYan, Zheng */ 16646025c19fSLu Fengqi ret = btrfs_add_root_ref(trans, objectid, 1665a22285a6SYan, Zheng parent_root->root_key.objectid, 16664a0cc7caSNikolay Borisov btrfs_ino(BTRFS_I(parent_inode)), index, 1667a22285a6SYan, Zheng dentry->d_name.name, dentry->d_name.len); 16688732d44fSMiao Xie if (ret) { 166966642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 16708732d44fSMiao Xie goto fail; 16718732d44fSMiao Xie } 1672a22285a6SYan, Zheng 1673a22285a6SYan, Zheng key.offset = (u64)-1; 16742dfb1e43SQu Wenruo pending->snap = btrfs_get_new_fs_root(fs_info, objectid, pending->anon_dev); 167579787eaaSJeff Mahoney if (IS_ERR(pending->snap)) { 167679787eaaSJeff Mahoney ret = PTR_ERR(pending->snap); 16772d892ccdSFilipe Manana pending->snap = NULL; 167866642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 16798732d44fSMiao Xie goto fail; 168079787eaaSJeff Mahoney } 1681d68fc57bSYan, Zheng 168249b25e05SJeff Mahoney ret = btrfs_reloc_post_snapshot(trans, pending); 16838732d44fSMiao Xie if (ret) { 168466642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 16858732d44fSMiao Xie goto fail; 16868732d44fSMiao Xie } 1687361048f5SMiao Xie 1688c79a70b1SNikolay Borisov ret = btrfs_run_delayed_refs(trans, (unsigned long)-1); 16898732d44fSMiao Xie if (ret) { 169066642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 16918732d44fSMiao Xie goto fail; 16928732d44fSMiao Xie } 169342874b3dSMiao Xie 16946426c7adSQu Wenruo /* 16956426c7adSQu Wenruo * Do special qgroup accounting for snapshot, as we do some qgroup 16966426c7adSQu Wenruo * snapshot hack to do fast snapshot. 16976426c7adSQu Wenruo * To co-operate with that hack, we do hack again. 16986426c7adSQu Wenruo * Or snapshot will be greatly slowed down by a subtree qgroup rescan 16996426c7adSQu Wenruo */ 17006426c7adSQu Wenruo ret = qgroup_account_snapshot(trans, root, parent_root, 17016426c7adSQu Wenruo pending->inherit, objectid); 17026426c7adSQu Wenruo if (ret < 0) 17036426c7adSQu Wenruo goto fail; 17046426c7adSQu Wenruo 1705684572dfSLu Fengqi ret = btrfs_insert_dir_item(trans, dentry->d_name.name, 1706684572dfSLu Fengqi dentry->d_name.len, BTRFS_I(parent_inode), 1707684572dfSLu Fengqi &key, BTRFS_FT_DIR, index); 170842874b3dSMiao Xie /* We have check then name at the beginning, so it is impossible. */ 17099c52057cSChris Mason BUG_ON(ret == -EEXIST || ret == -EOVERFLOW); 17108732d44fSMiao Xie if (ret) { 171166642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 17128732d44fSMiao Xie goto fail; 17138732d44fSMiao Xie } 171442874b3dSMiao Xie 17156ef06d27SNikolay Borisov btrfs_i_size_write(BTRFS_I(parent_inode), parent_inode->i_size + 171642874b3dSMiao Xie dentry->d_name.len * 2); 171704b285f3SDeepa Dinamani parent_inode->i_mtime = parent_inode->i_ctime = 1718c2050a45SDeepa Dinamani current_time(parent_inode); 1719729f7961SNikolay Borisov ret = btrfs_update_inode_fallback(trans, parent_root, BTRFS_I(parent_inode)); 1720dd5f9615SStefan Behrens if (ret) { 172166642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 1722dd5f9615SStefan Behrens goto fail; 1723dd5f9615SStefan Behrens } 1724807fc790SAndy Shevchenko ret = btrfs_uuid_tree_add(trans, new_root_item->uuid, 1725807fc790SAndy Shevchenko BTRFS_UUID_KEY_SUBVOL, 1726cdb345a8SLu Fengqi objectid); 1727dd5f9615SStefan Behrens if (ret) { 172866642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 1729dd5f9615SStefan Behrens goto fail; 1730dd5f9615SStefan Behrens } 1731dd5f9615SStefan Behrens if (!btrfs_is_empty_uuid(new_root_item->received_uuid)) { 1732cdb345a8SLu Fengqi ret = btrfs_uuid_tree_add(trans, new_root_item->received_uuid, 1733dd5f9615SStefan Behrens BTRFS_UUID_KEY_RECEIVED_SUBVOL, 1734dd5f9615SStefan Behrens objectid); 1735dd5f9615SStefan Behrens if (ret && ret != -EEXIST) { 173666642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 1737dd5f9615SStefan Behrens goto fail; 1738dd5f9615SStefan Behrens } 1739dd5f9615SStefan Behrens } 1740d6726335SQu Wenruo 1741c79a70b1SNikolay Borisov ret = btrfs_run_delayed_refs(trans, (unsigned long)-1); 1742d6726335SQu Wenruo if (ret) { 174366642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 1744d6726335SQu Wenruo goto fail; 1745d6726335SQu Wenruo } 1746d6726335SQu Wenruo 17473063d29fSChris Mason fail: 1748aec8030aSMiao Xie pending->error = ret; 1749aec8030aSMiao Xie dir_item_existed: 175098c9942aSLiu Bo trans->block_rsv = rsv; 17512382c5ccSLiu Bo trans->bytes_reserved = 0; 1752d6726335SQu Wenruo clear_skip_qgroup: 1753d6726335SQu Wenruo btrfs_clear_skip_qgroup(trans); 17546fa9700eSMiao Xie no_free_objectid: 17556fa9700eSMiao Xie kfree(new_root_item); 1756b0c0ea63SDavid Sterba pending->root_item = NULL; 175742874b3dSMiao Xie btrfs_free_path(path); 17588546b570SDavid Sterba pending->path = NULL; 17598546b570SDavid Sterba 176049b25e05SJeff Mahoney return ret; 17613063d29fSChris Mason } 17623063d29fSChris Mason 1763d352ac68SChris Mason /* 1764d352ac68SChris Mason * create all the snapshots we've scheduled for creation 1765d352ac68SChris Mason */ 176608d50ca3SNikolay Borisov static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans) 17673063d29fSChris Mason { 1768aec8030aSMiao Xie struct btrfs_pending_snapshot *pending, *next; 17693063d29fSChris Mason struct list_head *head = &trans->transaction->pending_snapshots; 1770aec8030aSMiao Xie int ret = 0; 17713de4586cSChris Mason 1772aec8030aSMiao Xie list_for_each_entry_safe(pending, next, head, list) { 1773aec8030aSMiao Xie list_del(&pending->list); 177408d50ca3SNikolay Borisov ret = create_pending_snapshot(trans, pending); 1775aec8030aSMiao Xie if (ret) 1776aec8030aSMiao Xie break; 1777aec8030aSMiao Xie } 1778aec8030aSMiao Xie return ret; 17793de4586cSChris Mason } 17803de4586cSChris Mason 17812ff7e61eSJeff Mahoney static void update_super_roots(struct btrfs_fs_info *fs_info) 17825d4f98a2SYan Zheng { 17835d4f98a2SYan Zheng struct btrfs_root_item *root_item; 17845d4f98a2SYan Zheng struct btrfs_super_block *super; 17855d4f98a2SYan Zheng 17860b246afaSJeff Mahoney super = fs_info->super_copy; 17875d4f98a2SYan Zheng 17880b246afaSJeff Mahoney root_item = &fs_info->chunk_root->root_item; 1789093e037cSDavid Sterba super->chunk_root = root_item->bytenr; 1790093e037cSDavid Sterba super->chunk_root_generation = root_item->generation; 1791093e037cSDavid Sterba super->chunk_root_level = root_item->level; 17925d4f98a2SYan Zheng 17930b246afaSJeff Mahoney root_item = &fs_info->tree_root->root_item; 1794093e037cSDavid Sterba super->root = root_item->bytenr; 1795093e037cSDavid Sterba super->generation = root_item->generation; 1796093e037cSDavid Sterba super->root_level = root_item->level; 17970b246afaSJeff Mahoney if (btrfs_test_opt(fs_info, SPACE_CACHE)) 1798093e037cSDavid Sterba super->cache_generation = root_item->generation; 179994846229SBoris Burkov else if (test_bit(BTRFS_FS_CLEANUP_SPACE_CACHE_V1, &fs_info->flags)) 180094846229SBoris Burkov super->cache_generation = 0; 18010b246afaSJeff Mahoney if (test_bit(BTRFS_FS_UPDATE_UUID_TREE_GEN, &fs_info->flags)) 1802093e037cSDavid Sterba super->uuid_tree_generation = root_item->generation; 18035d4f98a2SYan Zheng } 18045d4f98a2SYan Zheng 1805f36f3042SChris Mason int btrfs_transaction_in_commit(struct btrfs_fs_info *info) 1806f36f3042SChris Mason { 18074a9d8bdeSMiao Xie struct btrfs_transaction *trans; 1808f36f3042SChris Mason int ret = 0; 18094a9d8bdeSMiao Xie 1810a4abeea4SJosef Bacik spin_lock(&info->trans_lock); 18114a9d8bdeSMiao Xie trans = info->running_transaction; 18124a9d8bdeSMiao Xie if (trans) 18134a9d8bdeSMiao Xie ret = (trans->state >= TRANS_STATE_COMMIT_START); 1814a4abeea4SJosef Bacik spin_unlock(&info->trans_lock); 1815f36f3042SChris Mason return ret; 1816f36f3042SChris Mason } 1817f36f3042SChris Mason 18188929ecfaSYan, Zheng int btrfs_transaction_blocked(struct btrfs_fs_info *info) 18198929ecfaSYan, Zheng { 18204a9d8bdeSMiao Xie struct btrfs_transaction *trans; 18218929ecfaSYan, Zheng int ret = 0; 18224a9d8bdeSMiao Xie 1823a4abeea4SJosef Bacik spin_lock(&info->trans_lock); 18244a9d8bdeSMiao Xie trans = info->running_transaction; 18254a9d8bdeSMiao Xie if (trans) 18264a9d8bdeSMiao Xie ret = is_transaction_blocked(trans); 1827a4abeea4SJosef Bacik spin_unlock(&info->trans_lock); 18288929ecfaSYan, Zheng return ret; 18298929ecfaSYan, Zheng } 18308929ecfaSYan, Zheng 1831bb9c12c9SSage Weil /* 1832bb9c12c9SSage Weil * wait for the current transaction commit to start and block subsequent 1833bb9c12c9SSage Weil * transaction joins 1834bb9c12c9SSage Weil */ 18352ff7e61eSJeff Mahoney static void wait_current_trans_commit_start(struct btrfs_fs_info *fs_info, 1836bb9c12c9SSage Weil struct btrfs_transaction *trans) 1837bb9c12c9SSage Weil { 18382ff7e61eSJeff Mahoney wait_event(fs_info->transaction_blocked_wait, 1839bf31f87fSDavid Sterba trans->state >= TRANS_STATE_COMMIT_START || 1840bf31f87fSDavid Sterba TRANS_ABORTED(trans)); 1841bb9c12c9SSage Weil } 1842bb9c12c9SSage Weil 1843bb9c12c9SSage Weil /* 1844bb9c12c9SSage Weil * wait for the current transaction to start and then become unblocked. 1845bb9c12c9SSage Weil * caller holds ref. 1846bb9c12c9SSage Weil */ 18472ff7e61eSJeff Mahoney static void wait_current_trans_commit_start_and_unblock( 18482ff7e61eSJeff Mahoney struct btrfs_fs_info *fs_info, 1849bb9c12c9SSage Weil struct btrfs_transaction *trans) 1850bb9c12c9SSage Weil { 18512ff7e61eSJeff Mahoney wait_event(fs_info->transaction_wait, 1852bf31f87fSDavid Sterba trans->state >= TRANS_STATE_UNBLOCKED || 1853bf31f87fSDavid Sterba TRANS_ABORTED(trans)); 1854bb9c12c9SSage Weil } 1855bb9c12c9SSage Weil 1856bb9c12c9SSage Weil /* 1857bb9c12c9SSage Weil * commit transactions asynchronously. once btrfs_commit_transaction_async 1858bb9c12c9SSage Weil * returns, any subsequent transaction will not be allowed to join. 1859bb9c12c9SSage Weil */ 1860bb9c12c9SSage Weil struct btrfs_async_commit { 1861bb9c12c9SSage Weil struct btrfs_trans_handle *newtrans; 18627892b5afSMiao Xie struct work_struct work; 1863bb9c12c9SSage Weil }; 1864bb9c12c9SSage Weil 1865bb9c12c9SSage Weil static void do_async_commit(struct work_struct *work) 1866bb9c12c9SSage Weil { 1867bb9c12c9SSage Weil struct btrfs_async_commit *ac = 18687892b5afSMiao Xie container_of(work, struct btrfs_async_commit, work); 1869bb9c12c9SSage Weil 18706fc4e354SSage Weil /* 18716fc4e354SSage Weil * We've got freeze protection passed with the transaction. 18726fc4e354SSage Weil * Tell lockdep about it. 18736fc4e354SSage Weil */ 1874b1a06a4bSLiu Bo if (ac->newtrans->type & __TRANS_FREEZABLE) 18753a45bb20SJeff Mahoney __sb_writers_acquired(ac->newtrans->fs_info->sb, SB_FREEZE_FS); 18766fc4e354SSage Weil 1877e209db7aSSage Weil current->journal_info = ac->newtrans; 1878e209db7aSSage Weil 18793a45bb20SJeff Mahoney btrfs_commit_transaction(ac->newtrans); 1880bb9c12c9SSage Weil kfree(ac); 1881bb9c12c9SSage Weil } 1882bb9c12c9SSage Weil 1883bb9c12c9SSage Weil int btrfs_commit_transaction_async(struct btrfs_trans_handle *trans, 1884bb9c12c9SSage Weil int wait_for_unblock) 1885bb9c12c9SSage Weil { 18863a45bb20SJeff Mahoney struct btrfs_fs_info *fs_info = trans->fs_info; 1887bb9c12c9SSage Weil struct btrfs_async_commit *ac; 1888bb9c12c9SSage Weil struct btrfs_transaction *cur_trans; 1889bb9c12c9SSage Weil 1890bb9c12c9SSage Weil ac = kmalloc(sizeof(*ac), GFP_NOFS); 1891db5b493aSTsutomu Itoh if (!ac) 1892db5b493aSTsutomu Itoh return -ENOMEM; 1893bb9c12c9SSage Weil 18947892b5afSMiao Xie INIT_WORK(&ac->work, do_async_commit); 18953a45bb20SJeff Mahoney ac->newtrans = btrfs_join_transaction(trans->root); 18963612b495STsutomu Itoh if (IS_ERR(ac->newtrans)) { 18973612b495STsutomu Itoh int err = PTR_ERR(ac->newtrans); 18983612b495STsutomu Itoh kfree(ac); 18993612b495STsutomu Itoh return err; 19003612b495STsutomu Itoh } 1901bb9c12c9SSage Weil 1902bb9c12c9SSage Weil /* take transaction reference */ 1903bb9c12c9SSage Weil cur_trans = trans->transaction; 19049b64f57dSElena Reshetova refcount_inc(&cur_trans->use_count); 1905bb9c12c9SSage Weil 19063a45bb20SJeff Mahoney btrfs_end_transaction(trans); 19076fc4e354SSage Weil 19086fc4e354SSage Weil /* 19096fc4e354SSage Weil * Tell lockdep we've released the freeze rwsem, since the 19106fc4e354SSage Weil * async commit thread will be the one to unlock it. 19116fc4e354SSage Weil */ 1912b1a06a4bSLiu Bo if (ac->newtrans->type & __TRANS_FREEZABLE) 19130b246afaSJeff Mahoney __sb_writers_release(fs_info->sb, SB_FREEZE_FS); 19146fc4e354SSage Weil 19157892b5afSMiao Xie schedule_work(&ac->work); 1916bb9c12c9SSage Weil 1917bb9c12c9SSage Weil /* wait for transaction to start and unblock */ 1918bb9c12c9SSage Weil if (wait_for_unblock) 19192ff7e61eSJeff Mahoney wait_current_trans_commit_start_and_unblock(fs_info, cur_trans); 1920bb9c12c9SSage Weil else 19212ff7e61eSJeff Mahoney wait_current_trans_commit_start(fs_info, cur_trans); 1922bb9c12c9SSage Weil 192338e88054SSage Weil if (current->journal_info == trans) 192438e88054SSage Weil current->journal_info = NULL; 192538e88054SSage Weil 1926724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 1927bb9c12c9SSage Weil return 0; 1928bb9c12c9SSage Weil } 1929bb9c12c9SSage Weil 193049b25e05SJeff Mahoney 193197cb39bbSNikolay Borisov static void cleanup_transaction(struct btrfs_trans_handle *trans, int err) 193249b25e05SJeff Mahoney { 193397cb39bbSNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 193449b25e05SJeff Mahoney struct btrfs_transaction *cur_trans = trans->transaction; 193549b25e05SJeff Mahoney 1936b50fff81SDavid Sterba WARN_ON(refcount_read(&trans->use_count) > 1); 193749b25e05SJeff Mahoney 193866642832SJeff Mahoney btrfs_abort_transaction(trans, err); 19397b8b92afSJosef Bacik 19400b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 194166b6135bSLiu Bo 194225d8c284SMiao Xie /* 194325d8c284SMiao Xie * If the transaction is removed from the list, it means this 194425d8c284SMiao Xie * transaction has been committed successfully, so it is impossible 194525d8c284SMiao Xie * to call the cleanup function. 194625d8c284SMiao Xie */ 194725d8c284SMiao Xie BUG_ON(list_empty(&cur_trans->list)); 194866b6135bSLiu Bo 194949b25e05SJeff Mahoney list_del_init(&cur_trans->list); 19500b246afaSJeff Mahoney if (cur_trans == fs_info->running_transaction) { 19514a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_COMMIT_DOING; 19520b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 1953f094ac32SLiu Bo wait_event(cur_trans->writer_wait, 1954f094ac32SLiu Bo atomic_read(&cur_trans->num_writers) == 1); 1955f094ac32SLiu Bo 19560b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 1957d7096fc3SJosef Bacik } 19580b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 195949b25e05SJeff Mahoney 19602ff7e61eSJeff Mahoney btrfs_cleanup_one_transaction(trans->transaction, fs_info); 196149b25e05SJeff Mahoney 19620b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 19630b246afaSJeff Mahoney if (cur_trans == fs_info->running_transaction) 19640b246afaSJeff Mahoney fs_info->running_transaction = NULL; 19650b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 19664a9d8bdeSMiao Xie 1967e0228285SJosef Bacik if (trans->type & __TRANS_FREEZABLE) 19680b246afaSJeff Mahoney sb_end_intwrite(fs_info->sb); 1969724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 1970724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 197149b25e05SJeff Mahoney 197297cb39bbSNikolay Borisov trace_btrfs_transaction_commit(trans->root); 197349b25e05SJeff Mahoney 197449b25e05SJeff Mahoney if (current->journal_info == trans) 197549b25e05SJeff Mahoney current->journal_info = NULL; 19760b246afaSJeff Mahoney btrfs_scrub_cancel(fs_info); 197749b25e05SJeff Mahoney 197849b25e05SJeff Mahoney kmem_cache_free(btrfs_trans_handle_cachep, trans); 197949b25e05SJeff Mahoney } 198049b25e05SJeff Mahoney 1981c7cc64a9SDavid Sterba /* 1982c7cc64a9SDavid Sterba * Release reserved delayed ref space of all pending block groups of the 1983c7cc64a9SDavid Sterba * transaction and remove them from the list 1984c7cc64a9SDavid Sterba */ 1985c7cc64a9SDavid Sterba static void btrfs_cleanup_pending_block_groups(struct btrfs_trans_handle *trans) 1986c7cc64a9SDavid Sterba { 1987c7cc64a9SDavid Sterba struct btrfs_fs_info *fs_info = trans->fs_info; 198832da5386SDavid Sterba struct btrfs_block_group *block_group, *tmp; 1989c7cc64a9SDavid Sterba 1990c7cc64a9SDavid Sterba list_for_each_entry_safe(block_group, tmp, &trans->new_bgs, bg_list) { 1991c7cc64a9SDavid Sterba btrfs_delayed_refs_rsv_release(fs_info, 1); 1992c7cc64a9SDavid Sterba list_del_init(&block_group->bg_list); 1993c7cc64a9SDavid Sterba } 1994c7cc64a9SDavid Sterba } 1995c7cc64a9SDavid Sterba 199688090ad3SFilipe Manana static inline int btrfs_start_delalloc_flush(struct btrfs_fs_info *fs_info) 199782436617SMiao Xie { 1998ce8ea7ccSJosef Bacik /* 1999ce8ea7ccSJosef Bacik * We use writeback_inodes_sb here because if we used 2000ce8ea7ccSJosef Bacik * btrfs_start_delalloc_roots we would deadlock with fs freeze. 2001ce8ea7ccSJosef Bacik * Currently are holding the fs freeze lock, if we do an async flush 2002ce8ea7ccSJosef Bacik * we'll do btrfs_join_transaction() and deadlock because we need to 2003ce8ea7ccSJosef Bacik * wait for the fs freeze lock. Using the direct flushing we benefit 2004ce8ea7ccSJosef Bacik * from already being in a transaction and our join_transaction doesn't 2005ce8ea7ccSJosef Bacik * have to re-take the fs freeze lock. 2006ce8ea7ccSJosef Bacik */ 200788090ad3SFilipe Manana if (btrfs_test_opt(fs_info, FLUSHONCOMMIT)) 2008ce8ea7ccSJosef Bacik writeback_inodes_sb(fs_info->sb, WB_REASON_SYNC); 200982436617SMiao Xie return 0; 201082436617SMiao Xie } 201182436617SMiao Xie 201288090ad3SFilipe Manana static inline void btrfs_wait_delalloc_flush(struct btrfs_fs_info *fs_info) 201382436617SMiao Xie { 201488090ad3SFilipe Manana if (btrfs_test_opt(fs_info, FLUSHONCOMMIT)) 20156374e57aSChris Mason btrfs_wait_ordered_roots(fs_info, U64_MAX, 0, (u64)-1); 201682436617SMiao Xie } 201782436617SMiao Xie 20183a45bb20SJeff Mahoney int btrfs_commit_transaction(struct btrfs_trans_handle *trans) 201979154b1bSChris Mason { 20203a45bb20SJeff Mahoney struct btrfs_fs_info *fs_info = trans->fs_info; 202149b25e05SJeff Mahoney struct btrfs_transaction *cur_trans = trans->transaction; 20228fd17795SChris Mason struct btrfs_transaction *prev_trans = NULL; 202325287e0aSMiao Xie int ret; 202479154b1bSChris Mason 202535b814f3SNikolay Borisov ASSERT(refcount_read(&trans->use_count) == 1); 202635b814f3SNikolay Borisov 2027d62b23c9SJosef Bacik /* 2028d62b23c9SJosef Bacik * Some places just start a transaction to commit it. We need to make 2029d62b23c9SJosef Bacik * sure that if this commit fails that the abort code actually marks the 2030d62b23c9SJosef Bacik * transaction as failed, so set trans->dirty to make the abort code do 2031d62b23c9SJosef Bacik * the right thing. 2032d62b23c9SJosef Bacik */ 2033d62b23c9SJosef Bacik trans->dirty = true; 2034d62b23c9SJosef Bacik 20358d25a086SMiao Xie /* Stop the commit early if ->aborted is set */ 2036bf31f87fSDavid Sterba if (TRANS_ABORTED(cur_trans)) { 203725287e0aSMiao Xie ret = cur_trans->aborted; 20383a45bb20SJeff Mahoney btrfs_end_transaction(trans); 2039e4a2bcacSJosef Bacik return ret; 204025287e0aSMiao Xie } 204149b25e05SJeff Mahoney 2042f45c752bSJosef Bacik btrfs_trans_release_metadata(trans); 2043f45c752bSJosef Bacik trans->block_rsv = NULL; 2044f45c752bSJosef Bacik 2045*e19eb11fSJosef Bacik /* 2046*e19eb11fSJosef Bacik * We only want one transaction commit doing the flushing so we do not 2047*e19eb11fSJosef Bacik * waste a bunch of time on lock contention on the extent root node. 2048*e19eb11fSJosef Bacik */ 2049*e19eb11fSJosef Bacik if (!test_and_set_bit(BTRFS_DELAYED_REFS_FLUSHING, 2050*e19eb11fSJosef Bacik &cur_trans->delayed_refs.flags)) { 2051*e19eb11fSJosef Bacik /* 2052*e19eb11fSJosef Bacik * Make a pass through all the delayed refs we have so far. 2053*e19eb11fSJosef Bacik * Any running threads may add more while we are here. 205456bec294SChris Mason */ 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 } 2060*e19eb11fSJosef Bacik } 206156bec294SChris Mason 20626c686b35SNikolay Borisov btrfs_create_pending_block_groups(trans); 2063ea658badSJosef Bacik 2064c79a70b1SNikolay Borisov ret = btrfs_run_delayed_refs(trans, 0); 2065e4a2bcacSJosef Bacik if (ret) { 20663a45bb20SJeff Mahoney btrfs_end_transaction(trans); 2067e4a2bcacSJosef Bacik return ret; 2068e4a2bcacSJosef Bacik } 206956bec294SChris Mason 20703204d33cSJosef Bacik if (!test_bit(BTRFS_TRANS_DIRTY_BG_RUN, &cur_trans->flags)) { 20711bbc621eSChris Mason int run_it = 0; 20721bbc621eSChris Mason 20731bbc621eSChris Mason /* this mutex is also taken before trying to set 20741bbc621eSChris Mason * block groups readonly. We need to make sure 20751bbc621eSChris Mason * that nobody has set a block group readonly 20761bbc621eSChris Mason * after a extents from that block group have been 20771bbc621eSChris Mason * allocated for cache files. btrfs_set_block_group_ro 20781bbc621eSChris Mason * will wait for the transaction to commit if it 20793204d33cSJosef Bacik * finds BTRFS_TRANS_DIRTY_BG_RUN set. 20801bbc621eSChris Mason * 20813204d33cSJosef Bacik * The BTRFS_TRANS_DIRTY_BG_RUN flag is also used to make sure 20823204d33cSJosef Bacik * only one process starts all the block group IO. It wouldn't 20831bbc621eSChris Mason * hurt to have more than one go through, but there's no 20841bbc621eSChris Mason * real advantage to it either. 20851bbc621eSChris Mason */ 20860b246afaSJeff Mahoney mutex_lock(&fs_info->ro_block_group_mutex); 20873204d33cSJosef Bacik if (!test_and_set_bit(BTRFS_TRANS_DIRTY_BG_RUN, 20883204d33cSJosef Bacik &cur_trans->flags)) 20891bbc621eSChris Mason run_it = 1; 20900b246afaSJeff Mahoney mutex_unlock(&fs_info->ro_block_group_mutex); 20911bbc621eSChris Mason 2092f9cacae3SNikolay Borisov if (run_it) { 209321217054SNikolay Borisov ret = btrfs_start_dirty_block_groups(trans); 20941bbc621eSChris Mason if (ret) { 20953a45bb20SJeff Mahoney btrfs_end_transaction(trans); 20961bbc621eSChris Mason return ret; 20971bbc621eSChris Mason } 2098f9cacae3SNikolay Borisov } 2099f9cacae3SNikolay Borisov } 21001bbc621eSChris Mason 21010b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 21024a9d8bdeSMiao Xie if (cur_trans->state >= TRANS_STATE_COMMIT_START) { 21030b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 21049b64f57dSElena Reshetova refcount_inc(&cur_trans->use_count); 21053a45bb20SJeff Mahoney ret = btrfs_end_transaction(trans); 2106ccd467d6SChris Mason 21072ff7e61eSJeff Mahoney wait_for_commit(cur_trans); 210815ee9bc7SJosef Bacik 2109bf31f87fSDavid Sterba if (TRANS_ABORTED(cur_trans)) 2110b4924a0fSLiu Bo ret = cur_trans->aborted; 2111b4924a0fSLiu Bo 2112724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 211315ee9bc7SJosef Bacik 211449b25e05SJeff Mahoney return ret; 211579154b1bSChris Mason } 21164313b399SChris Mason 21174a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_COMMIT_START; 21180b246afaSJeff Mahoney wake_up(&fs_info->transaction_blocked_wait); 2119bb9c12c9SSage Weil 21200b246afaSJeff Mahoney if (cur_trans->list.prev != &fs_info->trans_list) { 2121ccd467d6SChris Mason prev_trans = list_entry(cur_trans->list.prev, 2122ccd467d6SChris Mason struct btrfs_transaction, list); 21234a9d8bdeSMiao Xie if (prev_trans->state != TRANS_STATE_COMPLETED) { 21249b64f57dSElena Reshetova refcount_inc(&prev_trans->use_count); 21250b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 2126ccd467d6SChris Mason 21272ff7e61eSJeff Mahoney wait_for_commit(prev_trans); 2128bf31f87fSDavid Sterba ret = READ_ONCE(prev_trans->aborted); 2129ccd467d6SChris Mason 2130724e2315SJosef Bacik btrfs_put_transaction(prev_trans); 21311f9b8c8fSFilipe Manana if (ret) 21321f9b8c8fSFilipe Manana goto cleanup_transaction; 2133a4abeea4SJosef Bacik } else { 21340b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 2135ccd467d6SChris Mason } 2136a4abeea4SJosef Bacik } else { 21370b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 2138cb2d3dadSFilipe Manana /* 2139cb2d3dadSFilipe Manana * The previous transaction was aborted and was already removed 2140cb2d3dadSFilipe Manana * from the list of transactions at fs_info->trans_list. So we 2141cb2d3dadSFilipe Manana * abort to prevent writing a new superblock that reflects a 2142cb2d3dadSFilipe Manana * corrupt state (pointing to trees with unwritten nodes/leafs). 2143cb2d3dadSFilipe Manana */ 2144cb2d3dadSFilipe Manana if (test_bit(BTRFS_FS_STATE_TRANS_ABORTED, &fs_info->fs_state)) { 2145cb2d3dadSFilipe Manana ret = -EROFS; 2146cb2d3dadSFilipe Manana goto cleanup_transaction; 2147cb2d3dadSFilipe Manana } 2148ccd467d6SChris Mason } 214915ee9bc7SJosef Bacik 21500860adfdSMiao Xie extwriter_counter_dec(cur_trans, trans->type); 21510860adfdSMiao Xie 215288090ad3SFilipe Manana ret = btrfs_start_delalloc_flush(fs_info); 215382436617SMiao Xie if (ret) 215482436617SMiao Xie goto cleanup_transaction; 215582436617SMiao Xie 2156e5c304e6SNikolay Borisov ret = btrfs_run_delayed_items(trans); 215749b25e05SJeff Mahoney if (ret) 215849b25e05SJeff Mahoney goto cleanup_transaction; 215916cdcec7SMiao Xie 2160581227d0SMiao Xie wait_event(cur_trans->writer_wait, 2161581227d0SMiao Xie extwriter_counter_read(cur_trans) == 0); 2162ed3b3d31SChris Mason 2163581227d0SMiao Xie /* some pending stuffs might be added after the previous flush. */ 2164e5c304e6SNikolay Borisov ret = btrfs_run_delayed_items(trans); 2165ca469637SMiao Xie if (ret) 2166ca469637SMiao Xie goto cleanup_transaction; 2167ca469637SMiao Xie 216888090ad3SFilipe Manana btrfs_wait_delalloc_flush(fs_info); 2169cb7ab021SWang Shilong 217048778179SFilipe Manana /* 217148778179SFilipe Manana * Wait for all ordered extents started by a fast fsync that joined this 217248778179SFilipe Manana * transaction. Otherwise if this transaction commits before the ordered 217348778179SFilipe Manana * extents complete we lose logged data after a power failure. 217448778179SFilipe Manana */ 217548778179SFilipe Manana wait_event(cur_trans->pending_wait, 217648778179SFilipe Manana atomic_read(&cur_trans->pending_ordered) == 0); 217748778179SFilipe Manana 21782ff7e61eSJeff Mahoney btrfs_scrub_pause(fs_info); 2179ed0ca140SJosef Bacik /* 2180ed0ca140SJosef Bacik * Ok now we need to make sure to block out any other joins while we 2181ed0ca140SJosef Bacik * commit the transaction. We could have started a join before setting 21824a9d8bdeSMiao Xie * COMMIT_DOING so make sure to wait for num_writers to == 1 again. 2183ed0ca140SJosef Bacik */ 21840b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 21854a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_COMMIT_DOING; 21860b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 2187ed0ca140SJosef Bacik wait_event(cur_trans->writer_wait, 2188ed0ca140SJosef Bacik atomic_read(&cur_trans->num_writers) == 1); 218915ee9bc7SJosef Bacik 2190bf31f87fSDavid Sterba if (TRANS_ABORTED(cur_trans)) { 21912cba30f1SMiao Xie ret = cur_trans->aborted; 21926cf7f77eSWang Shilong goto scrub_continue; 21932cba30f1SMiao Xie } 21947585717fSChris Mason /* 21957585717fSChris Mason * the reloc mutex makes sure that we stop 21967585717fSChris Mason * the balancing code from coming in and moving 21977585717fSChris Mason * extents around in the middle of the commit 21987585717fSChris Mason */ 21990b246afaSJeff Mahoney mutex_lock(&fs_info->reloc_mutex); 22007585717fSChris Mason 220142874b3dSMiao Xie /* 220242874b3dSMiao Xie * We needn't worry about the delayed items because we will 220342874b3dSMiao Xie * deal with them in create_pending_snapshot(), which is the 220442874b3dSMiao Xie * core function of the snapshot creation. 220542874b3dSMiao Xie */ 220608d50ca3SNikolay Borisov ret = create_pending_snapshots(trans); 220756e9f6eaSDavid Sterba if (ret) 220856e9f6eaSDavid Sterba goto unlock_reloc; 22093063d29fSChris Mason 221042874b3dSMiao Xie /* 221142874b3dSMiao Xie * We insert the dir indexes of the snapshots and update the inode 221242874b3dSMiao Xie * of the snapshots' parents after the snapshot creation, so there 221342874b3dSMiao Xie * are some delayed items which are not dealt with. Now deal with 221442874b3dSMiao Xie * them. 221542874b3dSMiao Xie * 221642874b3dSMiao Xie * We needn't worry that this operation will corrupt the snapshots, 221742874b3dSMiao Xie * because all the tree which are snapshoted will be forced to COW 221842874b3dSMiao Xie * the nodes and leaves. 221942874b3dSMiao Xie */ 2220e5c304e6SNikolay Borisov ret = btrfs_run_delayed_items(trans); 222156e9f6eaSDavid Sterba if (ret) 222256e9f6eaSDavid Sterba goto unlock_reloc; 222316cdcec7SMiao Xie 2224c79a70b1SNikolay Borisov ret = btrfs_run_delayed_refs(trans, (unsigned long)-1); 222556e9f6eaSDavid Sterba if (ret) 222656e9f6eaSDavid Sterba goto unlock_reloc; 222756bec294SChris Mason 2228e999376fSChris Mason /* 2229e999376fSChris Mason * make sure none of the code above managed to slip in a 2230e999376fSChris Mason * delayed item 2231e999376fSChris Mason */ 2232ccdf9b30SJeff Mahoney btrfs_assert_delayed_root_empty(fs_info); 2233e999376fSChris Mason 22342c90e5d6SChris Mason WARN_ON(cur_trans != trans->transaction); 2235dc17ff8fSChris Mason 2236e02119d5SChris Mason /* btrfs_commit_tree_roots is responsible for getting the 2237e02119d5SChris Mason * various roots consistent with each other. Every pointer 2238e02119d5SChris Mason * in the tree of tree roots has to point to the most up to date 2239e02119d5SChris Mason * root for every subvolume and other tree. So, we have to keep 2240e02119d5SChris Mason * the tree logging code from jumping in and changing any 2241e02119d5SChris Mason * of the trees. 2242e02119d5SChris Mason * 2243e02119d5SChris Mason * At this point in the commit, there can't be any tree-log 2244e02119d5SChris Mason * writers, but a little lower down we drop the trans mutex 2245e02119d5SChris Mason * and let new people in. By holding the tree_log_mutex 2246e02119d5SChris Mason * from now until after the super is written, we avoid races 2247e02119d5SChris Mason * with the tree-log code. 2248e02119d5SChris Mason */ 22490b246afaSJeff Mahoney mutex_lock(&fs_info->tree_log_mutex); 22501a40e23bSZheng Yan 22517e4443d9SNikolay Borisov ret = commit_fs_roots(trans); 225256e9f6eaSDavid Sterba if (ret) 225356e9f6eaSDavid Sterba goto unlock_tree_log; 225454aa1f4dSChris Mason 22553818aea2SQu Wenruo /* 22567e1876acSDavid Sterba * Since the transaction is done, we can apply the pending changes 22577e1876acSDavid Sterba * before the next transaction. 22583818aea2SQu Wenruo */ 22590b246afaSJeff Mahoney btrfs_apply_pending_changes(fs_info); 22603818aea2SQu Wenruo 22615d4f98a2SYan Zheng /* commit_fs_roots gets rid of all the tree log roots, it is now 2262e02119d5SChris Mason * safe to free the root of tree log roots 2263e02119d5SChris Mason */ 22640b246afaSJeff Mahoney btrfs_free_log_root_tree(trans, fs_info); 2265e02119d5SChris Mason 22660ed4792aSQu Wenruo /* 22670ed4792aSQu Wenruo * Since fs roots are all committed, we can get a quite accurate 22680ed4792aSQu Wenruo * new_roots. So let's do quota accounting. 22690ed4792aSQu Wenruo */ 2270460fb20aSNikolay Borisov ret = btrfs_qgroup_account_extents(trans); 227156e9f6eaSDavid Sterba if (ret < 0) 227256e9f6eaSDavid Sterba goto unlock_tree_log; 22730ed4792aSQu Wenruo 22749386d8bcSNikolay Borisov ret = commit_cowonly_roots(trans); 227556e9f6eaSDavid Sterba if (ret) 227656e9f6eaSDavid Sterba goto unlock_tree_log; 227754aa1f4dSChris Mason 22782cba30f1SMiao Xie /* 22792cba30f1SMiao Xie * The tasks which save the space cache and inode cache may also 22802cba30f1SMiao Xie * update ->aborted, check it. 22812cba30f1SMiao Xie */ 2282bf31f87fSDavid Sterba if (TRANS_ABORTED(cur_trans)) { 22832cba30f1SMiao Xie ret = cur_trans->aborted; 228456e9f6eaSDavid Sterba goto unlock_tree_log; 22852cba30f1SMiao Xie } 22862cba30f1SMiao Xie 22870b246afaSJeff Mahoney cur_trans = fs_info->running_transaction; 22885f39d397SChris Mason 22890b246afaSJeff Mahoney btrfs_set_root_node(&fs_info->tree_root->root_item, 22900b246afaSJeff Mahoney fs_info->tree_root->node); 22910b246afaSJeff Mahoney list_add_tail(&fs_info->tree_root->dirty_list, 22929e351cc8SJosef Bacik &cur_trans->switch_commits); 22935d4f98a2SYan Zheng 22940b246afaSJeff Mahoney btrfs_set_root_node(&fs_info->chunk_root->root_item, 22950b246afaSJeff Mahoney fs_info->chunk_root->node); 22960b246afaSJeff Mahoney list_add_tail(&fs_info->chunk_root->dirty_list, 22979e351cc8SJosef Bacik &cur_trans->switch_commits); 22989e351cc8SJosef Bacik 2299889bfa39SJosef Bacik switch_commit_roots(trans); 23005d4f98a2SYan Zheng 2301ce93ec54SJosef Bacik ASSERT(list_empty(&cur_trans->dirty_bgs)); 23021bbc621eSChris Mason ASSERT(list_empty(&cur_trans->io_bgs)); 23032ff7e61eSJeff Mahoney update_super_roots(fs_info); 2304e02119d5SChris Mason 23050b246afaSJeff Mahoney btrfs_set_super_log_root(fs_info->super_copy, 0); 23060b246afaSJeff Mahoney btrfs_set_super_log_root_level(fs_info->super_copy, 0); 23070b246afaSJeff Mahoney memcpy(fs_info->super_for_commit, fs_info->super_copy, 23080b246afaSJeff Mahoney sizeof(*fs_info->super_copy)); 2309ccd467d6SChris Mason 2310bbbf7243SNikolay Borisov btrfs_commit_device_sizes(cur_trans); 2311935e5cc9SMiao Xie 23120b246afaSJeff Mahoney clear_bit(BTRFS_FS_LOG1_ERR, &fs_info->flags); 23130b246afaSJeff Mahoney clear_bit(BTRFS_FS_LOG2_ERR, &fs_info->flags); 2314656f30dbSFilipe Manana 23154fbcdf66SFilipe Manana btrfs_trans_release_chunk_metadata(trans); 23164fbcdf66SFilipe Manana 23170b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 23184a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_UNBLOCKED; 23190b246afaSJeff Mahoney fs_info->running_transaction = NULL; 23200b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 23210b246afaSJeff Mahoney mutex_unlock(&fs_info->reloc_mutex); 2322b7ec40d7SChris Mason 23230b246afaSJeff Mahoney wake_up(&fs_info->transaction_wait); 2324e6dcd2dcSChris Mason 232570458a58SNikolay Borisov ret = btrfs_write_and_wait_transaction(trans); 232649b25e05SJeff Mahoney if (ret) { 23270b246afaSJeff Mahoney btrfs_handle_fs_error(fs_info, ret, 232808748810SDavid Sterba "Error while writing out transaction"); 232956e9f6eaSDavid Sterba /* 233056e9f6eaSDavid Sterba * reloc_mutex has been unlocked, tree_log_mutex is still held 233156e9f6eaSDavid Sterba * but we can't jump to unlock_tree_log causing double unlock 233256e9f6eaSDavid Sterba */ 23330b246afaSJeff Mahoney mutex_unlock(&fs_info->tree_log_mutex); 23346cf7f77eSWang Shilong goto scrub_continue; 233549b25e05SJeff Mahoney } 233649b25e05SJeff Mahoney 2337eece6a9cSDavid Sterba ret = write_all_supers(fs_info, 0); 2338e02119d5SChris Mason /* 2339e02119d5SChris Mason * the super is written, we can safely allow the tree-loggers 2340e02119d5SChris Mason * to go about their business 2341e02119d5SChris Mason */ 23420b246afaSJeff Mahoney mutex_unlock(&fs_info->tree_log_mutex); 2343c1f32b7cSAnand Jain if (ret) 2344c1f32b7cSAnand Jain goto scrub_continue; 2345e02119d5SChris Mason 23465ead2dd0SNikolay Borisov btrfs_finish_extent_commit(trans); 23474313b399SChris Mason 23483204d33cSJosef Bacik if (test_bit(BTRFS_TRANS_HAVE_FREE_BGS, &cur_trans->flags)) 23490b246afaSJeff Mahoney btrfs_clear_space_info_full(fs_info); 235013212b54SZhao Lei 23510b246afaSJeff Mahoney fs_info->last_trans_committed = cur_trans->transid; 23524a9d8bdeSMiao Xie /* 23534a9d8bdeSMiao Xie * We needn't acquire the lock here because there is no other task 23544a9d8bdeSMiao Xie * which can change it. 23554a9d8bdeSMiao Xie */ 23564a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_COMPLETED; 23572c90e5d6SChris Mason wake_up(&cur_trans->commit_wait); 23583de4586cSChris Mason 23590b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 236013c5a93eSJosef Bacik list_del_init(&cur_trans->list); 23610b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 2362a4abeea4SJosef Bacik 2363724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 2364724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 236558176a96SJosef Bacik 23660860adfdSMiao Xie if (trans->type & __TRANS_FREEZABLE) 23670b246afaSJeff Mahoney sb_end_intwrite(fs_info->sb); 2368b2b5ef5cSJan Kara 23693a45bb20SJeff Mahoney trace_btrfs_transaction_commit(trans->root); 23701abe9b8aSliubo 23712ff7e61eSJeff Mahoney btrfs_scrub_continue(fs_info); 2372a2de733cSArne Jansen 23739ed74f2dSJosef Bacik if (current->journal_info == trans) 23749ed74f2dSJosef Bacik current->journal_info = NULL; 23759ed74f2dSJosef Bacik 23762c90e5d6SChris Mason kmem_cache_free(btrfs_trans_handle_cachep, trans); 237724bbcf04SYan, Zheng 237879154b1bSChris Mason return ret; 237949b25e05SJeff Mahoney 238056e9f6eaSDavid Sterba unlock_tree_log: 238156e9f6eaSDavid Sterba mutex_unlock(&fs_info->tree_log_mutex); 238256e9f6eaSDavid Sterba unlock_reloc: 238356e9f6eaSDavid Sterba mutex_unlock(&fs_info->reloc_mutex); 23846cf7f77eSWang Shilong scrub_continue: 23852ff7e61eSJeff Mahoney btrfs_scrub_continue(fs_info); 238649b25e05SJeff Mahoney cleanup_transaction: 2387dc60c525SNikolay Borisov btrfs_trans_release_metadata(trans); 2388c7cc64a9SDavid Sterba btrfs_cleanup_pending_block_groups(trans); 23894fbcdf66SFilipe Manana btrfs_trans_release_chunk_metadata(trans); 23900e721106SJosef Bacik trans->block_rsv = NULL; 23910b246afaSJeff Mahoney btrfs_warn(fs_info, "Skipping commit of aborted transaction."); 239249b25e05SJeff Mahoney if (current->journal_info == trans) 239349b25e05SJeff Mahoney current->journal_info = NULL; 239497cb39bbSNikolay Borisov cleanup_transaction(trans, ret); 239549b25e05SJeff Mahoney 239649b25e05SJeff Mahoney return ret; 239779154b1bSChris Mason } 239879154b1bSChris Mason 2399d352ac68SChris Mason /* 24009d1a2a3aSDavid Sterba * return < 0 if error 24019d1a2a3aSDavid Sterba * 0 if there are no more dead_roots at the time of call 24029d1a2a3aSDavid Sterba * 1 there are more to be processed, call me again 24039d1a2a3aSDavid Sterba * 24049d1a2a3aSDavid Sterba * The return value indicates there are certainly more snapshots to delete, but 24059d1a2a3aSDavid Sterba * if there comes a new one during processing, it may return 0. We don't mind, 24069d1a2a3aSDavid Sterba * because btrfs_commit_super will poke cleaner thread and it will process it a 24079d1a2a3aSDavid Sterba * few seconds later. 2408d352ac68SChris Mason */ 24099d1a2a3aSDavid Sterba int btrfs_clean_one_deleted_snapshot(struct btrfs_root *root) 2410e9d0b13bSChris Mason { 24119d1a2a3aSDavid Sterba int ret; 24125d4f98a2SYan Zheng struct btrfs_fs_info *fs_info = root->fs_info; 2413e9d0b13bSChris Mason 2414a4abeea4SJosef Bacik spin_lock(&fs_info->trans_lock); 24159d1a2a3aSDavid Sterba if (list_empty(&fs_info->dead_roots)) { 24169d1a2a3aSDavid Sterba spin_unlock(&fs_info->trans_lock); 24179d1a2a3aSDavid Sterba return 0; 24189d1a2a3aSDavid Sterba } 24199d1a2a3aSDavid Sterba root = list_first_entry(&fs_info->dead_roots, 24209d1a2a3aSDavid Sterba struct btrfs_root, root_list); 2421cfad392bSJosef Bacik list_del_init(&root->root_list); 2422a4abeea4SJosef Bacik spin_unlock(&fs_info->trans_lock); 24235d4f98a2SYan Zheng 24244fd786e6SMisono Tomohiro btrfs_debug(fs_info, "cleaner removing %llu", root->root_key.objectid); 242576dda93cSYan, Zheng 242616cdcec7SMiao Xie btrfs_kill_all_delayed_nodes(root); 242716cdcec7SMiao Xie 242876dda93cSYan, Zheng if (btrfs_header_backref_rev(root->node) < 242976dda93cSYan, Zheng BTRFS_MIXED_BACKREF_REV) 24300078a9f9SNikolay Borisov ret = btrfs_drop_snapshot(root, 0, 0); 243176dda93cSYan, Zheng else 24320078a9f9SNikolay Borisov ret = btrfs_drop_snapshot(root, 1, 0); 243332471dc2SDavid Sterba 2434dc9492c1SJosef Bacik btrfs_put_root(root); 24356596a928SJosef Bacik return (ret < 0) ? 0 : 1; 2436e9d0b13bSChris Mason } 2437572d9ab7SDavid Sterba 2438572d9ab7SDavid Sterba void btrfs_apply_pending_changes(struct btrfs_fs_info *fs_info) 2439572d9ab7SDavid Sterba { 2440572d9ab7SDavid Sterba unsigned long prev; 2441572d9ab7SDavid Sterba unsigned long bit; 2442572d9ab7SDavid Sterba 24436c9fe14fSQu Wenruo prev = xchg(&fs_info->pending_changes, 0); 2444572d9ab7SDavid Sterba if (!prev) 2445572d9ab7SDavid Sterba return; 2446572d9ab7SDavid Sterba 2447d51033d0SDavid Sterba bit = 1 << BTRFS_PENDING_COMMIT; 2448d51033d0SDavid Sterba if (prev & bit) 2449d51033d0SDavid Sterba btrfs_debug(fs_info, "pending commit done"); 2450d51033d0SDavid Sterba prev &= ~bit; 2451d51033d0SDavid Sterba 2452572d9ab7SDavid Sterba if (prev) 2453572d9ab7SDavid Sterba btrfs_warn(fs_info, 2454572d9ab7SDavid Sterba "unknown pending changes left 0x%lx, ignoring", prev); 2455572d9ab7SDavid Sterba } 2456