1c1d7c514SDavid Sterba // SPDX-License-Identifier: GPL-2.0 26cbd5570SChris Mason /* 36cbd5570SChris Mason * Copyright (C) 2007 Oracle. All rights reserved. 46cbd5570SChris Mason */ 56cbd5570SChris Mason 679154b1bSChris Mason #include <linux/fs.h> 75a0e3ad6STejun Heo #include <linux/slab.h> 834088780SChris Mason #include <linux/sched.h> 9d3c2fdcfSChris Mason #include <linux/writeback.h> 105f39d397SChris Mason #include <linux/pagemap.h> 115f2cc086SChris Mason #include <linux/blkdev.h> 128ea05e3aSAlexander Block #include <linux/uuid.h> 13e55958c8SIoannis Angelakopoulos #include <linux/timekeeping.h> 14602cbe91SDavid Sterba #include "misc.h" 1579154b1bSChris Mason #include "ctree.h" 1679154b1bSChris Mason #include "disk-io.h" 1779154b1bSChris Mason #include "transaction.h" 18925baeddSChris Mason #include "locking.h" 19e02119d5SChris Mason #include "tree-log.h" 20733f4fbbSStefan Behrens #include "volumes.h" 218dabb742SStefan Behrens #include "dev-replace.h" 22fcebe456SJosef Bacik #include "qgroup.h" 23aac0023cSJosef Bacik #include "block-group.h" 249c343784SJosef Bacik #include "space-info.h" 25d3575156SNaohiro Aota #include "zoned.h" 2679154b1bSChris Mason 27fc7cbcd4SDavid Sterba #define BTRFS_ROOT_TRANS_TAG 0 280f7d52f4SChris Mason 2961c047b5SQu Wenruo /* 3061c047b5SQu Wenruo * Transaction states and transitions 3161c047b5SQu Wenruo * 3261c047b5SQu Wenruo * No running transaction (fs tree blocks are not modified) 3361c047b5SQu Wenruo * | 3461c047b5SQu Wenruo * | To next stage: 3561c047b5SQu Wenruo * | Call start_transaction() variants. Except btrfs_join_transaction_nostart(). 3661c047b5SQu Wenruo * V 3761c047b5SQu Wenruo * Transaction N [[TRANS_STATE_RUNNING]] 3861c047b5SQu Wenruo * | 3961c047b5SQu Wenruo * | New trans handles can be attached to transaction N by calling all 4061c047b5SQu Wenruo * | start_transaction() variants. 4161c047b5SQu Wenruo * | 4261c047b5SQu Wenruo * | To next stage: 4361c047b5SQu Wenruo * | Call btrfs_commit_transaction() on any trans handle attached to 4461c047b5SQu Wenruo * | transaction N 4561c047b5SQu Wenruo * V 4661c047b5SQu Wenruo * Transaction N [[TRANS_STATE_COMMIT_START]] 4761c047b5SQu Wenruo * | 4861c047b5SQu Wenruo * | Will wait for previous running transaction to completely finish if there 4961c047b5SQu Wenruo * | is one 5061c047b5SQu Wenruo * | 5161c047b5SQu Wenruo * | Then one of the following happes: 5261c047b5SQu Wenruo * | - Wait for all other trans handle holders to release. 5361c047b5SQu Wenruo * | The btrfs_commit_transaction() caller will do the commit work. 5461c047b5SQu Wenruo * | - Wait for current transaction to be committed by others. 5561c047b5SQu Wenruo * | Other btrfs_commit_transaction() caller will do the commit work. 5661c047b5SQu Wenruo * | 5761c047b5SQu Wenruo * | At this stage, only btrfs_join_transaction*() variants can attach 5861c047b5SQu Wenruo * | to this running transaction. 5961c047b5SQu Wenruo * | All other variants will wait for current one to finish and attach to 6061c047b5SQu Wenruo * | transaction N+1. 6161c047b5SQu Wenruo * | 6261c047b5SQu Wenruo * | To next stage: 6361c047b5SQu Wenruo * | Caller is chosen to commit transaction N, and all other trans handle 6461c047b5SQu Wenruo * | haven been released. 6561c047b5SQu Wenruo * V 6661c047b5SQu Wenruo * Transaction N [[TRANS_STATE_COMMIT_DOING]] 6761c047b5SQu Wenruo * | 6861c047b5SQu Wenruo * | The heavy lifting transaction work is started. 6961c047b5SQu Wenruo * | From running delayed refs (modifying extent tree) to creating pending 7061c047b5SQu Wenruo * | snapshots, running qgroups. 7161c047b5SQu Wenruo * | In short, modify supporting trees to reflect modifications of subvolume 7261c047b5SQu Wenruo * | trees. 7361c047b5SQu Wenruo * | 7461c047b5SQu Wenruo * | At this stage, all start_transaction() calls will wait for this 7561c047b5SQu Wenruo * | transaction to finish and attach to transaction N+1. 7661c047b5SQu Wenruo * | 7761c047b5SQu Wenruo * | To next stage: 7861c047b5SQu Wenruo * | Until all supporting trees are updated. 7961c047b5SQu Wenruo * V 8061c047b5SQu Wenruo * Transaction N [[TRANS_STATE_UNBLOCKED]] 8161c047b5SQu Wenruo * | Transaction N+1 8261c047b5SQu Wenruo * | All needed trees are modified, thus we only [[TRANS_STATE_RUNNING]] 8361c047b5SQu Wenruo * | need to write them back to disk and update | 8461c047b5SQu Wenruo * | super blocks. | 8561c047b5SQu Wenruo * | | 8661c047b5SQu Wenruo * | At this stage, new transaction is allowed to | 8761c047b5SQu Wenruo * | start. | 8861c047b5SQu Wenruo * | All new start_transaction() calls will be | 8961c047b5SQu Wenruo * | attached to transid N+1. | 9061c047b5SQu Wenruo * | | 9161c047b5SQu Wenruo * | To next stage: | 9261c047b5SQu Wenruo * | Until all tree blocks are super blocks are | 9361c047b5SQu Wenruo * | written to block devices | 9461c047b5SQu Wenruo * V | 9561c047b5SQu Wenruo * Transaction N [[TRANS_STATE_COMPLETED]] V 9661c047b5SQu Wenruo * All tree blocks and super blocks are written. Transaction N+1 9761c047b5SQu Wenruo * This transaction is finished and all its [[TRANS_STATE_COMMIT_START]] 9861c047b5SQu Wenruo * data structures will be cleaned up. | Life goes on 9961c047b5SQu Wenruo */ 100e8c9f186SDavid Sterba static const unsigned int btrfs_blocked_trans_types[TRANS_STATE_MAX] = { 1014a9d8bdeSMiao Xie [TRANS_STATE_RUNNING] = 0U, 102bcf3a3e7SNikolay Borisov [TRANS_STATE_COMMIT_START] = (__TRANS_START | __TRANS_ATTACH), 103bcf3a3e7SNikolay Borisov [TRANS_STATE_COMMIT_DOING] = (__TRANS_START | 1044a9d8bdeSMiao Xie __TRANS_ATTACH | 105a6d155d2SFilipe Manana __TRANS_JOIN | 106a6d155d2SFilipe Manana __TRANS_JOIN_NOSTART), 107bcf3a3e7SNikolay Borisov [TRANS_STATE_UNBLOCKED] = (__TRANS_START | 1084a9d8bdeSMiao Xie __TRANS_ATTACH | 1094a9d8bdeSMiao Xie __TRANS_JOIN | 110a6d155d2SFilipe Manana __TRANS_JOIN_NOLOCK | 111a6d155d2SFilipe Manana __TRANS_JOIN_NOSTART), 112d0c2f4faSFilipe Manana [TRANS_STATE_SUPER_COMMITTED] = (__TRANS_START | 113d0c2f4faSFilipe Manana __TRANS_ATTACH | 114d0c2f4faSFilipe Manana __TRANS_JOIN | 115d0c2f4faSFilipe Manana __TRANS_JOIN_NOLOCK | 116d0c2f4faSFilipe Manana __TRANS_JOIN_NOSTART), 117bcf3a3e7SNikolay Borisov [TRANS_STATE_COMPLETED] = (__TRANS_START | 1184a9d8bdeSMiao Xie __TRANS_ATTACH | 1194a9d8bdeSMiao Xie __TRANS_JOIN | 120a6d155d2SFilipe Manana __TRANS_JOIN_NOLOCK | 121a6d155d2SFilipe Manana __TRANS_JOIN_NOSTART), 1224a9d8bdeSMiao Xie }; 1234a9d8bdeSMiao Xie 124724e2315SJosef Bacik void btrfs_put_transaction(struct btrfs_transaction *transaction) 12579154b1bSChris Mason { 1269b64f57dSElena Reshetova WARN_ON(refcount_read(&transaction->use_count) == 0); 1279b64f57dSElena Reshetova if (refcount_dec_and_test(&transaction->use_count)) { 128a4abeea4SJosef Bacik BUG_ON(!list_empty(&transaction->list)); 1295c9d028bSLiu Bo WARN_ON(!RB_EMPTY_ROOT( 1305c9d028bSLiu Bo &transaction->delayed_refs.href_root.rb_root)); 13181f7eb00SJeff Mahoney WARN_ON(!RB_EMPTY_ROOT( 13281f7eb00SJeff Mahoney &transaction->delayed_refs.dirty_extent_root)); 1331262133bSJosef Bacik if (transaction->delayed_refs.pending_csums) 134ab8d0fc4SJeff Mahoney btrfs_err(transaction->fs_info, 135ab8d0fc4SJeff Mahoney "pending csums is %llu", 1361262133bSJosef Bacik transaction->delayed_refs.pending_csums); 1377785a663SFilipe Manana /* 1387785a663SFilipe Manana * If any block groups are found in ->deleted_bgs then it's 1397785a663SFilipe Manana * because the transaction was aborted and a commit did not 1407785a663SFilipe Manana * happen (things failed before writing the new superblock 1417785a663SFilipe Manana * and calling btrfs_finish_extent_commit()), so we can not 1427785a663SFilipe Manana * discard the physical locations of the block groups. 1437785a663SFilipe Manana */ 1447785a663SFilipe Manana while (!list_empty(&transaction->deleted_bgs)) { 14532da5386SDavid Sterba struct btrfs_block_group *cache; 1467785a663SFilipe Manana 1477785a663SFilipe Manana cache = list_first_entry(&transaction->deleted_bgs, 14832da5386SDavid Sterba struct btrfs_block_group, 1497785a663SFilipe Manana bg_list); 1507785a663SFilipe Manana list_del_init(&cache->bg_list); 1516b7304afSFilipe Manana btrfs_unfreeze_block_group(cache); 1527785a663SFilipe Manana btrfs_put_block_group(cache); 1537785a663SFilipe Manana } 154bbbf7243SNikolay Borisov WARN_ON(!list_empty(&transaction->dev_update_list)); 1554b5faeacSDavid Sterba kfree(transaction); 15679154b1bSChris Mason } 15778fae27eSChris Mason } 15879154b1bSChris Mason 159889bfa39SJosef Bacik static noinline void switch_commit_roots(struct btrfs_trans_handle *trans) 160817d52f8SJosef Bacik { 161889bfa39SJosef Bacik struct btrfs_transaction *cur_trans = trans->transaction; 16216916a88SNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 1639e351cc8SJosef Bacik struct btrfs_root *root, *tmp; 16427d56e62SJosef Bacik struct btrfs_caching_control *caching_ctl, *next; 1659e351cc8SJosef Bacik 166dfba78dcSFilipe Manana /* 167dfba78dcSFilipe Manana * At this point no one can be using this transaction to modify any tree 168dfba78dcSFilipe Manana * and no one can start another transaction to modify any tree either. 169dfba78dcSFilipe Manana */ 170dfba78dcSFilipe Manana ASSERT(cur_trans->state == TRANS_STATE_COMMIT_DOING); 171dfba78dcSFilipe Manana 1729e351cc8SJosef Bacik down_write(&fs_info->commit_root_sem); 173d96b3424SFilipe Manana 174d96b3424SFilipe Manana if (test_bit(BTRFS_FS_RELOC_RUNNING, &fs_info->flags)) 175d96b3424SFilipe Manana fs_info->last_reloc_trans = trans->transid; 176d96b3424SFilipe Manana 177889bfa39SJosef Bacik list_for_each_entry_safe(root, tmp, &cur_trans->switch_commits, 1789e351cc8SJosef Bacik dirty_list) { 1799e351cc8SJosef Bacik list_del_init(&root->dirty_list); 180817d52f8SJosef Bacik free_extent_buffer(root->commit_root); 181817d52f8SJosef Bacik root->commit_root = btrfs_root_node(root); 18241e7acd3SNikolay Borisov extent_io_tree_release(&root->dirty_log_pages); 183370a11b8SQu Wenruo btrfs_qgroup_clean_swapped_blocks(root); 1849e351cc8SJosef Bacik } 1852b9dbef2SJosef Bacik 1862b9dbef2SJosef Bacik /* We can free old roots now. */ 187889bfa39SJosef Bacik spin_lock(&cur_trans->dropped_roots_lock); 188889bfa39SJosef Bacik while (!list_empty(&cur_trans->dropped_roots)) { 189889bfa39SJosef Bacik root = list_first_entry(&cur_trans->dropped_roots, 1902b9dbef2SJosef Bacik struct btrfs_root, root_list); 1912b9dbef2SJosef Bacik list_del_init(&root->root_list); 192889bfa39SJosef Bacik spin_unlock(&cur_trans->dropped_roots_lock); 193889bfa39SJosef Bacik btrfs_free_log(trans, root); 1942b9dbef2SJosef Bacik btrfs_drop_and_free_fs_root(fs_info, root); 195889bfa39SJosef Bacik spin_lock(&cur_trans->dropped_roots_lock); 1962b9dbef2SJosef Bacik } 197889bfa39SJosef Bacik spin_unlock(&cur_trans->dropped_roots_lock); 19827d56e62SJosef Bacik 19927d56e62SJosef Bacik /* 20027d56e62SJosef Bacik * We have to update the last_byte_to_unpin under the commit_root_sem, 20127d56e62SJosef Bacik * at the same time we swap out the commit roots. 20227d56e62SJosef Bacik * 20327d56e62SJosef Bacik * This is because we must have a real view of the last spot the caching 20427d56e62SJosef Bacik * kthreads were while caching. Consider the following views of the 20527d56e62SJosef Bacik * extent tree for a block group 20627d56e62SJosef Bacik * 20727d56e62SJosef Bacik * commit root 20827d56e62SJosef Bacik * +----+----+----+----+----+----+----+ 20927d56e62SJosef Bacik * |\\\\| |\\\\|\\\\| |\\\\|\\\\| 21027d56e62SJosef Bacik * +----+----+----+----+----+----+----+ 21127d56e62SJosef Bacik * 0 1 2 3 4 5 6 7 21227d56e62SJosef Bacik * 21327d56e62SJosef Bacik * new commit root 21427d56e62SJosef Bacik * +----+----+----+----+----+----+----+ 21527d56e62SJosef Bacik * | | | |\\\\| | |\\\\| 21627d56e62SJosef Bacik * +----+----+----+----+----+----+----+ 21727d56e62SJosef Bacik * 0 1 2 3 4 5 6 7 21827d56e62SJosef Bacik * 21927d56e62SJosef Bacik * If the cache_ctl->progress was at 3, then we are only allowed to 22027d56e62SJosef Bacik * unpin [0,1) and [2,3], because the caching thread has already 22127d56e62SJosef Bacik * processed those extents. We are not allowed to unpin [5,6), because 22227d56e62SJosef Bacik * the caching thread will re-start it's search from 3, and thus find 22327d56e62SJosef Bacik * the hole from [4,6) to add to the free space cache. 22427d56e62SJosef Bacik */ 22516b0c258SFilipe Manana write_lock(&fs_info->block_group_cache_lock); 22627d56e62SJosef Bacik list_for_each_entry_safe(caching_ctl, next, 22727d56e62SJosef Bacik &fs_info->caching_block_groups, list) { 22827d56e62SJosef Bacik struct btrfs_block_group *cache = caching_ctl->block_group; 22927d56e62SJosef Bacik 23027d56e62SJosef Bacik if (btrfs_block_group_done(cache)) { 23127d56e62SJosef Bacik cache->last_byte_to_unpin = (u64)-1; 23227d56e62SJosef Bacik list_del_init(&caching_ctl->list); 23327d56e62SJosef Bacik btrfs_put_caching_control(caching_ctl); 23427d56e62SJosef Bacik } else { 23527d56e62SJosef Bacik cache->last_byte_to_unpin = caching_ctl->progress; 23627d56e62SJosef Bacik } 23727d56e62SJosef Bacik } 23816b0c258SFilipe Manana write_unlock(&fs_info->block_group_cache_lock); 2399e351cc8SJosef Bacik up_write(&fs_info->commit_root_sem); 240817d52f8SJosef Bacik } 241817d52f8SJosef Bacik 2420860adfdSMiao Xie static inline void extwriter_counter_inc(struct btrfs_transaction *trans, 2430860adfdSMiao Xie unsigned int type) 2440860adfdSMiao Xie { 2450860adfdSMiao Xie if (type & TRANS_EXTWRITERS) 2460860adfdSMiao Xie atomic_inc(&trans->num_extwriters); 2470860adfdSMiao Xie } 2480860adfdSMiao Xie 2490860adfdSMiao Xie static inline void extwriter_counter_dec(struct btrfs_transaction *trans, 2500860adfdSMiao Xie unsigned int type) 2510860adfdSMiao Xie { 2520860adfdSMiao Xie if (type & TRANS_EXTWRITERS) 2530860adfdSMiao Xie atomic_dec(&trans->num_extwriters); 2540860adfdSMiao Xie } 2550860adfdSMiao Xie 2560860adfdSMiao Xie static inline void extwriter_counter_init(struct btrfs_transaction *trans, 2570860adfdSMiao Xie unsigned int type) 2580860adfdSMiao Xie { 2590860adfdSMiao Xie atomic_set(&trans->num_extwriters, ((type & TRANS_EXTWRITERS) ? 1 : 0)); 2600860adfdSMiao Xie } 2610860adfdSMiao Xie 2620860adfdSMiao Xie static inline int extwriter_counter_read(struct btrfs_transaction *trans) 2630860adfdSMiao Xie { 2640860adfdSMiao Xie return atomic_read(&trans->num_extwriters); 265178260b2SMiao Xie } 266178260b2SMiao Xie 267d352ac68SChris Mason /* 26879bd3712SFilipe Manana * To be called after doing the chunk btree updates right after allocating a new 26979bd3712SFilipe Manana * chunk (after btrfs_chunk_alloc_add_chunk_item() is called), when removing a 27079bd3712SFilipe Manana * chunk after all chunk btree updates and after finishing the second phase of 27179bd3712SFilipe Manana * chunk allocation (btrfs_create_pending_block_groups()) in case some block 27279bd3712SFilipe Manana * group had its chunk item insertion delayed to the second phase. 273fb6dea26SJosef Bacik */ 274fb6dea26SJosef Bacik void btrfs_trans_release_chunk_metadata(struct btrfs_trans_handle *trans) 275fb6dea26SJosef Bacik { 276fb6dea26SJosef Bacik struct btrfs_fs_info *fs_info = trans->fs_info; 277fb6dea26SJosef Bacik 278fb6dea26SJosef Bacik if (!trans->chunk_bytes_reserved) 279fb6dea26SJosef Bacik return; 280fb6dea26SJosef Bacik 281fb6dea26SJosef Bacik btrfs_block_rsv_release(fs_info, &fs_info->chunk_block_rsv, 28263f018beSNikolay Borisov trans->chunk_bytes_reserved, NULL); 283fb6dea26SJosef Bacik trans->chunk_bytes_reserved = 0; 284fb6dea26SJosef Bacik } 285fb6dea26SJosef Bacik 286fb6dea26SJosef Bacik /* 287d352ac68SChris Mason * either allocate a new transaction or hop into the existing one 288d352ac68SChris Mason */ 2892ff7e61eSJeff Mahoney static noinline int join_transaction(struct btrfs_fs_info *fs_info, 2902ff7e61eSJeff Mahoney unsigned int type) 29179154b1bSChris Mason { 29279154b1bSChris Mason struct btrfs_transaction *cur_trans; 293a4abeea4SJosef Bacik 29419ae4e81SJan Schmidt spin_lock(&fs_info->trans_lock); 295d43317dcSChris Mason loop: 29649b25e05SJeff Mahoney /* The file system has been taken offline. No new transactions. */ 29784961539SJosef Bacik if (BTRFS_FS_ERROR(fs_info)) { 29819ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 29949b25e05SJeff Mahoney return -EROFS; 30049b25e05SJeff Mahoney } 30149b25e05SJeff Mahoney 30219ae4e81SJan Schmidt cur_trans = fs_info->running_transaction; 303a4abeea4SJosef Bacik if (cur_trans) { 304bf31f87fSDavid Sterba if (TRANS_ABORTED(cur_trans)) { 30519ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 30649b25e05SJeff Mahoney return cur_trans->aborted; 307871383beSDavid Sterba } 3084a9d8bdeSMiao Xie if (btrfs_blocked_trans_types[cur_trans->state] & type) { 309178260b2SMiao Xie spin_unlock(&fs_info->trans_lock); 310178260b2SMiao Xie return -EBUSY; 311178260b2SMiao Xie } 3129b64f57dSElena Reshetova refcount_inc(&cur_trans->use_count); 313a4abeea4SJosef Bacik atomic_inc(&cur_trans->num_writers); 3140860adfdSMiao Xie extwriter_counter_inc(cur_trans, type); 31519ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 316a4abeea4SJosef Bacik return 0; 317a4abeea4SJosef Bacik } 31819ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 319a4abeea4SJosef Bacik 320354aa0fbSMiao Xie /* 321354aa0fbSMiao Xie * If we are ATTACH, we just want to catch the current transaction, 322354aa0fbSMiao Xie * and commit it. If there is no transaction, just return ENOENT. 323354aa0fbSMiao Xie */ 324354aa0fbSMiao Xie if (type == TRANS_ATTACH) 325354aa0fbSMiao Xie return -ENOENT; 326354aa0fbSMiao Xie 3274a9d8bdeSMiao Xie /* 3284a9d8bdeSMiao Xie * JOIN_NOLOCK only happens during the transaction commit, so 3294a9d8bdeSMiao Xie * it is impossible that ->running_transaction is NULL 3304a9d8bdeSMiao Xie */ 3314a9d8bdeSMiao Xie BUG_ON(type == TRANS_JOIN_NOLOCK); 3324a9d8bdeSMiao Xie 3334b5faeacSDavid Sterba cur_trans = kmalloc(sizeof(*cur_trans), GFP_NOFS); 334db5b493aSTsutomu Itoh if (!cur_trans) 335db5b493aSTsutomu Itoh return -ENOMEM; 336d43317dcSChris Mason 33719ae4e81SJan Schmidt spin_lock(&fs_info->trans_lock); 33819ae4e81SJan Schmidt if (fs_info->running_transaction) { 339d43317dcSChris Mason /* 340d43317dcSChris Mason * someone started a transaction after we unlocked. Make sure 3414a9d8bdeSMiao Xie * to redo the checks above 342d43317dcSChris Mason */ 3434b5faeacSDavid Sterba kfree(cur_trans); 344d43317dcSChris Mason goto loop; 34584961539SJosef Bacik } else if (BTRFS_FS_ERROR(fs_info)) { 346e4b50e14SDan Carpenter spin_unlock(&fs_info->trans_lock); 3474b5faeacSDavid Sterba kfree(cur_trans); 3487b8b92afSJosef Bacik return -EROFS; 349a4abeea4SJosef Bacik } 350d43317dcSChris Mason 351ab8d0fc4SJeff Mahoney cur_trans->fs_info = fs_info; 35248778179SFilipe Manana atomic_set(&cur_trans->pending_ordered, 0); 35348778179SFilipe Manana init_waitqueue_head(&cur_trans->pending_wait); 35413c5a93eSJosef Bacik atomic_set(&cur_trans->num_writers, 1); 3550860adfdSMiao Xie extwriter_counter_init(cur_trans, type); 35679154b1bSChris Mason init_waitqueue_head(&cur_trans->writer_wait); 35779154b1bSChris Mason init_waitqueue_head(&cur_trans->commit_wait); 3584a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_RUNNING; 359a4abeea4SJosef Bacik /* 360a4abeea4SJosef Bacik * One for this trans handle, one so it will live on until we 361a4abeea4SJosef Bacik * commit the transaction. 362a4abeea4SJosef Bacik */ 3639b64f57dSElena Reshetova refcount_set(&cur_trans->use_count, 2); 3643204d33cSJosef Bacik cur_trans->flags = 0; 365afd48513SArnd Bergmann cur_trans->start_time = ktime_get_seconds(); 36656bec294SChris Mason 367a099d0fdSAlexandru Moise memset(&cur_trans->delayed_refs, 0, sizeof(cur_trans->delayed_refs)); 368a099d0fdSAlexandru Moise 3695c9d028bSLiu Bo cur_trans->delayed_refs.href_root = RB_ROOT_CACHED; 3703368d001SQu Wenruo cur_trans->delayed_refs.dirty_extent_root = RB_ROOT; 371d7df2c79SJosef Bacik atomic_set(&cur_trans->delayed_refs.num_entries, 0); 37220b297d6SJan Schmidt 37320b297d6SJan Schmidt /* 37420b297d6SJan Schmidt * although the tree mod log is per file system and not per transaction, 37520b297d6SJan Schmidt * the log must never go across transaction boundaries. 37620b297d6SJan Schmidt */ 37720b297d6SJan Schmidt smp_mb(); 37831b1a2bdSJulia Lawall if (!list_empty(&fs_info->tree_mod_seq_list)) 3795d163e0eSJeff Mahoney WARN(1, KERN_ERR "BTRFS: tree_mod_seq_list not empty when creating a fresh transaction\n"); 38031b1a2bdSJulia Lawall if (!RB_EMPTY_ROOT(&fs_info->tree_mod_log)) 3815d163e0eSJeff Mahoney WARN(1, KERN_ERR "BTRFS: tree_mod_log rb tree not empty when creating a fresh transaction\n"); 382fc36ed7eSJan Schmidt atomic64_set(&fs_info->tree_mod_seq, 0); 38320b297d6SJan Schmidt 38456bec294SChris Mason spin_lock_init(&cur_trans->delayed_refs.lock); 38556bec294SChris Mason 3863063d29fSChris Mason INIT_LIST_HEAD(&cur_trans->pending_snapshots); 387bbbf7243SNikolay Borisov INIT_LIST_HEAD(&cur_trans->dev_update_list); 3889e351cc8SJosef Bacik INIT_LIST_HEAD(&cur_trans->switch_commits); 389ce93ec54SJosef Bacik INIT_LIST_HEAD(&cur_trans->dirty_bgs); 3901bbc621eSChris Mason INIT_LIST_HEAD(&cur_trans->io_bgs); 3912b9dbef2SJosef Bacik INIT_LIST_HEAD(&cur_trans->dropped_roots); 3921bbc621eSChris Mason mutex_init(&cur_trans->cache_write_mutex); 393ce93ec54SJosef Bacik spin_lock_init(&cur_trans->dirty_bgs_lock); 394e33e17eeSJeff Mahoney INIT_LIST_HEAD(&cur_trans->deleted_bgs); 3952b9dbef2SJosef Bacik spin_lock_init(&cur_trans->dropped_roots_lock); 396d3575156SNaohiro Aota INIT_LIST_HEAD(&cur_trans->releasing_ebs); 397d3575156SNaohiro Aota spin_lock_init(&cur_trans->releasing_ebs_lock); 39819ae4e81SJan Schmidt list_add_tail(&cur_trans->list, &fs_info->trans_list); 399c258d6e3SQu Wenruo extent_io_tree_init(fs_info, &cur_trans->dirty_pages, 40043eb5f29SQu Wenruo IO_TREE_TRANS_DIRTY_PAGES, fs_info->btree_inode); 401fe119a6eSNikolay Borisov extent_io_tree_init(fs_info, &cur_trans->pinned_extents, 402fe119a6eSNikolay Borisov IO_TREE_FS_PINNED_EXTENTS, NULL); 40319ae4e81SJan Schmidt fs_info->generation++; 40419ae4e81SJan Schmidt cur_trans->transid = fs_info->generation; 40519ae4e81SJan Schmidt fs_info->running_transaction = cur_trans; 40649b25e05SJeff Mahoney cur_trans->aborted = 0; 40719ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 40815ee9bc7SJosef Bacik 40979154b1bSChris Mason return 0; 41079154b1bSChris Mason } 41179154b1bSChris Mason 412d352ac68SChris Mason /* 41392a7cc42SQu Wenruo * This does all the record keeping required to make sure that a shareable root 41492a7cc42SQu Wenruo * is properly recorded in a given transaction. This is required to make sure 41592a7cc42SQu Wenruo * the old root from before we joined the transaction is deleted when the 41692a7cc42SQu Wenruo * transaction commits. 417d352ac68SChris Mason */ 4187585717fSChris Mason static int record_root_in_trans(struct btrfs_trans_handle *trans, 4196426c7adSQu Wenruo struct btrfs_root *root, 4206426c7adSQu Wenruo int force) 4216702ed49SChris Mason { 4220b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 42303a7e111SJosef Bacik int ret = 0; 4240b246afaSJeff Mahoney 42592a7cc42SQu Wenruo if ((test_bit(BTRFS_ROOT_SHAREABLE, &root->state) && 4266426c7adSQu Wenruo root->last_trans < trans->transid) || force) { 4274d31778aSQu Wenruo WARN_ON(!force && root->commit_root != root->node); 4285d4f98a2SYan Zheng 4297585717fSChris Mason /* 43027cdeb70SMiao Xie * see below for IN_TRANS_SETUP usage rules 4317585717fSChris Mason * we have the reloc mutex held now, so there 4327585717fSChris Mason * is only one writer in this function 4337585717fSChris Mason */ 43427cdeb70SMiao Xie set_bit(BTRFS_ROOT_IN_TRANS_SETUP, &root->state); 4357585717fSChris Mason 43627cdeb70SMiao Xie /* make sure readers find IN_TRANS_SETUP before 4377585717fSChris Mason * they find our root->last_trans update 4387585717fSChris Mason */ 4397585717fSChris Mason smp_wmb(); 4407585717fSChris Mason 441fc7cbcd4SDavid Sterba spin_lock(&fs_info->fs_roots_radix_lock); 4426426c7adSQu Wenruo if (root->last_trans == trans->transid && !force) { 443fc7cbcd4SDavid Sterba spin_unlock(&fs_info->fs_roots_radix_lock); 444a4abeea4SJosef Bacik return 0; 445a4abeea4SJosef Bacik } 446fc7cbcd4SDavid Sterba radix_tree_tag_set(&fs_info->fs_roots_radix, 4476702ed49SChris Mason (unsigned long)root->root_key.objectid, 4486702ed49SChris Mason BTRFS_ROOT_TRANS_TAG); 449fc7cbcd4SDavid Sterba spin_unlock(&fs_info->fs_roots_radix_lock); 4507585717fSChris Mason root->last_trans = trans->transid; 4517585717fSChris Mason 4527585717fSChris Mason /* this is pretty tricky. We don't want to 4537585717fSChris Mason * take the relocation lock in btrfs_record_root_in_trans 4547585717fSChris Mason * unless we're really doing the first setup for this root in 4557585717fSChris Mason * this transaction. 4567585717fSChris Mason * 4577585717fSChris Mason * Normally we'd use root->last_trans as a flag to decide 4587585717fSChris Mason * if we want to take the expensive mutex. 4597585717fSChris Mason * 4607585717fSChris Mason * But, we have to set root->last_trans before we 4617585717fSChris Mason * init the relocation root, otherwise, we trip over warnings 4627585717fSChris Mason * in ctree.c. The solution used here is to flag ourselves 46327cdeb70SMiao Xie * with root IN_TRANS_SETUP. When this is 1, we're still 4647585717fSChris Mason * fixing up the reloc trees and everyone must wait. 4657585717fSChris Mason * 4667585717fSChris Mason * When this is zero, they can trust root->last_trans and fly 4677585717fSChris Mason * through btrfs_record_root_in_trans without having to take the 4687585717fSChris Mason * lock. smp_wmb() makes sure that all the writes above are 4697585717fSChris Mason * done before we pop in the zero below 4707585717fSChris Mason */ 47103a7e111SJosef Bacik ret = btrfs_init_reloc_root(trans, root); 472c7548af6SChris Mason smp_mb__before_atomic(); 47327cdeb70SMiao Xie clear_bit(BTRFS_ROOT_IN_TRANS_SETUP, &root->state); 4746702ed49SChris Mason } 47503a7e111SJosef Bacik return ret; 4766702ed49SChris Mason } 4775d4f98a2SYan Zheng 4787585717fSChris Mason 4792b9dbef2SJosef Bacik void btrfs_add_dropped_root(struct btrfs_trans_handle *trans, 4802b9dbef2SJosef Bacik struct btrfs_root *root) 4812b9dbef2SJosef Bacik { 4820b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 4832b9dbef2SJosef Bacik struct btrfs_transaction *cur_trans = trans->transaction; 4842b9dbef2SJosef Bacik 4852b9dbef2SJosef Bacik /* Add ourselves to the transaction dropped list */ 4862b9dbef2SJosef Bacik spin_lock(&cur_trans->dropped_roots_lock); 4872b9dbef2SJosef Bacik list_add_tail(&root->root_list, &cur_trans->dropped_roots); 4882b9dbef2SJosef Bacik spin_unlock(&cur_trans->dropped_roots_lock); 4892b9dbef2SJosef Bacik 4902b9dbef2SJosef Bacik /* Make sure we don't try to update the root at commit time */ 491fc7cbcd4SDavid Sterba spin_lock(&fs_info->fs_roots_radix_lock); 492fc7cbcd4SDavid Sterba radix_tree_tag_clear(&fs_info->fs_roots_radix, 4932b9dbef2SJosef Bacik (unsigned long)root->root_key.objectid, 4942b9dbef2SJosef Bacik BTRFS_ROOT_TRANS_TAG); 495fc7cbcd4SDavid Sterba spin_unlock(&fs_info->fs_roots_radix_lock); 4962b9dbef2SJosef Bacik } 4972b9dbef2SJosef Bacik 4987585717fSChris Mason int btrfs_record_root_in_trans(struct btrfs_trans_handle *trans, 4997585717fSChris Mason struct btrfs_root *root) 5007585717fSChris Mason { 5010b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 5021409e6ccSJosef Bacik int ret; 5030b246afaSJeff Mahoney 50492a7cc42SQu Wenruo if (!test_bit(BTRFS_ROOT_SHAREABLE, &root->state)) 5057585717fSChris Mason return 0; 5067585717fSChris Mason 5077585717fSChris Mason /* 50827cdeb70SMiao Xie * see record_root_in_trans for comments about IN_TRANS_SETUP usage 5097585717fSChris Mason * and barriers 5107585717fSChris Mason */ 5117585717fSChris Mason smp_rmb(); 5127585717fSChris Mason if (root->last_trans == trans->transid && 51327cdeb70SMiao Xie !test_bit(BTRFS_ROOT_IN_TRANS_SETUP, &root->state)) 5147585717fSChris Mason return 0; 5157585717fSChris Mason 5160b246afaSJeff Mahoney mutex_lock(&fs_info->reloc_mutex); 5171409e6ccSJosef Bacik ret = record_root_in_trans(trans, root, 0); 5180b246afaSJeff Mahoney mutex_unlock(&fs_info->reloc_mutex); 5197585717fSChris Mason 5201409e6ccSJosef Bacik return ret; 5217585717fSChris Mason } 5227585717fSChris Mason 5234a9d8bdeSMiao Xie static inline int is_transaction_blocked(struct btrfs_transaction *trans) 5244a9d8bdeSMiao Xie { 5253296bf56SQu Wenruo return (trans->state >= TRANS_STATE_COMMIT_START && 526501407aaSJosef Bacik trans->state < TRANS_STATE_UNBLOCKED && 527bf31f87fSDavid Sterba !TRANS_ABORTED(trans)); 5284a9d8bdeSMiao Xie } 5294a9d8bdeSMiao Xie 530d352ac68SChris Mason /* wait for commit against the current transaction to become unblocked 531d352ac68SChris Mason * when this is done, it is safe to start a new transaction, but the current 532d352ac68SChris Mason * transaction might not be fully on disk. 533d352ac68SChris Mason */ 5342ff7e61eSJeff Mahoney static void wait_current_trans(struct btrfs_fs_info *fs_info) 53579154b1bSChris Mason { 536f9295749SChris Mason struct btrfs_transaction *cur_trans; 53779154b1bSChris Mason 5380b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 5390b246afaSJeff Mahoney cur_trans = fs_info->running_transaction; 5404a9d8bdeSMiao Xie if (cur_trans && is_transaction_blocked(cur_trans)) { 5419b64f57dSElena Reshetova refcount_inc(&cur_trans->use_count); 5420b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 54372d63ed6SLi Zefan 5440b246afaSJeff Mahoney wait_event(fs_info->transaction_wait, 545501407aaSJosef Bacik cur_trans->state >= TRANS_STATE_UNBLOCKED || 546bf31f87fSDavid Sterba TRANS_ABORTED(cur_trans)); 547724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 548a4abeea4SJosef Bacik } else { 5490b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 550f9295749SChris Mason } 55137d1aeeeSChris Mason } 55237d1aeeeSChris Mason 5532ff7e61eSJeff Mahoney static int may_wait_transaction(struct btrfs_fs_info *fs_info, int type) 55437d1aeeeSChris Mason { 5550b246afaSJeff Mahoney if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags)) 556a4abeea4SJosef Bacik return 0; 557a4abeea4SJosef Bacik 55892e2f7e3SNikolay Borisov if (type == TRANS_START) 559a4abeea4SJosef Bacik return 1; 560a4abeea4SJosef Bacik 561a22285a6SYan, Zheng return 0; 562a22285a6SYan, Zheng } 563a22285a6SYan, Zheng 56420dd2cbfSMiao Xie static inline bool need_reserve_reloc_root(struct btrfs_root *root) 56520dd2cbfSMiao Xie { 5660b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 5670b246afaSJeff Mahoney 5680b246afaSJeff Mahoney if (!fs_info->reloc_ctl || 56992a7cc42SQu Wenruo !test_bit(BTRFS_ROOT_SHAREABLE, &root->state) || 57020dd2cbfSMiao Xie root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID || 57120dd2cbfSMiao Xie root->reloc_root) 57220dd2cbfSMiao Xie return false; 57320dd2cbfSMiao Xie 57420dd2cbfSMiao Xie return true; 57520dd2cbfSMiao Xie } 57620dd2cbfSMiao Xie 57708e007d2SMiao Xie static struct btrfs_trans_handle * 5785aed1dd8SAlexandru Moise start_transaction(struct btrfs_root *root, unsigned int num_items, 579003d7c59SJeff Mahoney unsigned int type, enum btrfs_reserve_flush_enum flush, 580003d7c59SJeff Mahoney bool enforce_qgroups) 581a22285a6SYan, Zheng { 5820b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 583ba2c4d4eSJosef Bacik struct btrfs_block_rsv *delayed_refs_rsv = &fs_info->delayed_refs_rsv; 584a22285a6SYan, Zheng struct btrfs_trans_handle *h; 585a22285a6SYan, Zheng struct btrfs_transaction *cur_trans; 586b5009945SJosef Bacik u64 num_bytes = 0; 587c5567237SArne Jansen u64 qgroup_reserved = 0; 58820dd2cbfSMiao Xie bool reloc_reserved = false; 5899c343784SJosef Bacik bool do_chunk_alloc = false; 59020dd2cbfSMiao Xie int ret; 591acce952bSliubo 59284961539SJosef Bacik if (BTRFS_FS_ERROR(fs_info)) 593acce952bSliubo return ERR_PTR(-EROFS); 5942a1eb461SJosef Bacik 59546c4e71eSFilipe Manana if (current->journal_info) { 5960860adfdSMiao Xie WARN_ON(type & TRANS_EXTWRITERS); 5972a1eb461SJosef Bacik h = current->journal_info; 598b50fff81SDavid Sterba refcount_inc(&h->use_count); 599b50fff81SDavid Sterba WARN_ON(refcount_read(&h->use_count) > 2); 6002a1eb461SJosef Bacik h->orig_rsv = h->block_rsv; 6012a1eb461SJosef Bacik h->block_rsv = NULL; 6022a1eb461SJosef Bacik goto got_it; 6032a1eb461SJosef Bacik } 604b5009945SJosef Bacik 605b5009945SJosef Bacik /* 606b5009945SJosef Bacik * Do the reservation before we join the transaction so we can do all 607b5009945SJosef Bacik * the appropriate flushing if need be. 608b5009945SJosef Bacik */ 609003d7c59SJeff Mahoney if (num_items && root != fs_info->chunk_root) { 610ba2c4d4eSJosef Bacik struct btrfs_block_rsv *rsv = &fs_info->trans_block_rsv; 611ba2c4d4eSJosef Bacik u64 delayed_refs_bytes = 0; 612ba2c4d4eSJosef Bacik 6130b246afaSJeff Mahoney qgroup_reserved = num_items * fs_info->nodesize; 614733e03a0SQu Wenruo ret = btrfs_qgroup_reserve_meta_pertrans(root, qgroup_reserved, 615003d7c59SJeff Mahoney enforce_qgroups); 616c5567237SArne Jansen if (ret) 617c5567237SArne Jansen return ERR_PTR(ret); 618c5567237SArne Jansen 619ba2c4d4eSJosef Bacik /* 620ba2c4d4eSJosef Bacik * We want to reserve all the bytes we may need all at once, so 621ba2c4d4eSJosef Bacik * we only do 1 enospc flushing cycle per transaction start. We 622ba2c4d4eSJosef Bacik * accomplish this by simply assuming we'll do 2 x num_items 623ba2c4d4eSJosef Bacik * worth of delayed refs updates in this trans handle, and 624ba2c4d4eSJosef Bacik * refill that amount for whatever is missing in the reserve. 625ba2c4d4eSJosef Bacik */ 6262bd36e7bSJosef Bacik num_bytes = btrfs_calc_insert_metadata_size(fs_info, num_items); 6277f9fe614SJosef Bacik if (flush == BTRFS_RESERVE_FLUSH_ALL && 6287f9fe614SJosef Bacik delayed_refs_rsv->full == 0) { 629ba2c4d4eSJosef Bacik delayed_refs_bytes = num_bytes; 630ba2c4d4eSJosef Bacik num_bytes <<= 1; 631ba2c4d4eSJosef Bacik } 632ba2c4d4eSJosef Bacik 63320dd2cbfSMiao Xie /* 63420dd2cbfSMiao Xie * Do the reservation for the relocation root creation 63520dd2cbfSMiao Xie */ 636ee39b432SDavid Sterba if (need_reserve_reloc_root(root)) { 6370b246afaSJeff Mahoney num_bytes += fs_info->nodesize; 63820dd2cbfSMiao Xie reloc_reserved = true; 63920dd2cbfSMiao Xie } 64020dd2cbfSMiao Xie 6419270501cSJosef Bacik ret = btrfs_block_rsv_add(fs_info, rsv, num_bytes, flush); 642ba2c4d4eSJosef Bacik if (ret) 643ba2c4d4eSJosef Bacik goto reserve_fail; 644ba2c4d4eSJosef Bacik if (delayed_refs_bytes) { 645ba2c4d4eSJosef Bacik btrfs_migrate_to_delayed_refs_rsv(fs_info, rsv, 646ba2c4d4eSJosef Bacik delayed_refs_bytes); 647ba2c4d4eSJosef Bacik num_bytes -= delayed_refs_bytes; 648ba2c4d4eSJosef Bacik } 6499c343784SJosef Bacik 6509c343784SJosef Bacik if (rsv->space_info->force_alloc) 6519c343784SJosef Bacik do_chunk_alloc = true; 652ba2c4d4eSJosef Bacik } else if (num_items == 0 && flush == BTRFS_RESERVE_FLUSH_ALL && 653ba2c4d4eSJosef Bacik !delayed_refs_rsv->full) { 654ba2c4d4eSJosef Bacik /* 655ba2c4d4eSJosef Bacik * Some people call with btrfs_start_transaction(root, 0) 656ba2c4d4eSJosef Bacik * because they can be throttled, but have some other mechanism 657ba2c4d4eSJosef Bacik * for reserving space. We still want these guys to refill the 658ba2c4d4eSJosef Bacik * delayed block_rsv so just add 1 items worth of reservation 659ba2c4d4eSJosef Bacik * here. 660ba2c4d4eSJosef Bacik */ 661ba2c4d4eSJosef Bacik ret = btrfs_delayed_refs_rsv_refill(fs_info, flush); 662b5009945SJosef Bacik if (ret) 663843fcf35SMiao Xie goto reserve_fail; 664b5009945SJosef Bacik } 665a22285a6SYan, Zheng again: 666f2f767e7SAlexandru Moise h = kmem_cache_zalloc(btrfs_trans_handle_cachep, GFP_NOFS); 667843fcf35SMiao Xie if (!h) { 668843fcf35SMiao Xie ret = -ENOMEM; 669843fcf35SMiao Xie goto alloc_fail; 670843fcf35SMiao Xie } 671a22285a6SYan, Zheng 67298114659SJosef Bacik /* 67398114659SJosef Bacik * If we are JOIN_NOLOCK we're already committing a transaction and 67498114659SJosef Bacik * waiting on this guy, so we don't need to do the sb_start_intwrite 67598114659SJosef Bacik * because we're already holding a ref. We need this because we could 67698114659SJosef Bacik * have raced in and did an fsync() on a file which can kick a commit 67798114659SJosef Bacik * and then we deadlock with somebody doing a freeze. 678354aa0fbSMiao Xie * 679354aa0fbSMiao Xie * If we are ATTACH, it means we just want to catch the current 680354aa0fbSMiao Xie * transaction and commit it, so we needn't do sb_start_intwrite(). 68198114659SJosef Bacik */ 6820860adfdSMiao Xie if (type & __TRANS_FREEZABLE) 6830b246afaSJeff Mahoney sb_start_intwrite(fs_info->sb); 684b2b5ef5cSJan Kara 6852ff7e61eSJeff Mahoney if (may_wait_transaction(fs_info, type)) 6862ff7e61eSJeff Mahoney wait_current_trans(fs_info); 687a22285a6SYan, Zheng 688a4abeea4SJosef Bacik do { 6892ff7e61eSJeff Mahoney ret = join_transaction(fs_info, type); 690178260b2SMiao Xie if (ret == -EBUSY) { 6912ff7e61eSJeff Mahoney wait_current_trans(fs_info); 692a6d155d2SFilipe Manana if (unlikely(type == TRANS_ATTACH || 693a6d155d2SFilipe Manana type == TRANS_JOIN_NOSTART)) 694178260b2SMiao Xie ret = -ENOENT; 695178260b2SMiao Xie } 696a4abeea4SJosef Bacik } while (ret == -EBUSY); 697a4abeea4SJosef Bacik 698a43f7f82SLiu Bo if (ret < 0) 699843fcf35SMiao Xie goto join_fail; 7000f7d52f4SChris Mason 7010b246afaSJeff Mahoney cur_trans = fs_info->running_transaction; 702a22285a6SYan, Zheng 703a22285a6SYan, Zheng h->transid = cur_trans->transid; 704a22285a6SYan, Zheng h->transaction = cur_trans; 705b50fff81SDavid Sterba refcount_set(&h->use_count, 1); 70664b63580SJeff Mahoney h->fs_info = root->fs_info; 7077174109cSQu Wenruo 708a698d075SMiao Xie h->type = type; 709ea658badSJosef Bacik INIT_LIST_HEAD(&h->new_bgs); 710b7ec40d7SChris Mason 711a22285a6SYan, Zheng smp_mb(); 7123296bf56SQu Wenruo if (cur_trans->state >= TRANS_STATE_COMMIT_START && 7132ff7e61eSJeff Mahoney may_wait_transaction(fs_info, type)) { 714abdd2e80SFilipe Manana current->journal_info = h; 7153a45bb20SJeff Mahoney btrfs_commit_transaction(h); 716a22285a6SYan, Zheng goto again; 717a22285a6SYan, Zheng } 7189ed74f2dSJosef Bacik 719b5009945SJosef Bacik if (num_bytes) { 7200b246afaSJeff Mahoney trace_btrfs_space_reservation(fs_info, "transaction", 7212bcc0328SLiu Bo h->transid, num_bytes, 1); 7220b246afaSJeff Mahoney h->block_rsv = &fs_info->trans_block_rsv; 723b5009945SJosef Bacik h->bytes_reserved = num_bytes; 72420dd2cbfSMiao Xie h->reloc_reserved = reloc_reserved; 725a22285a6SYan, Zheng } 726a22285a6SYan, Zheng 7272a1eb461SJosef Bacik got_it: 728bcf3a3e7SNikolay Borisov if (!current->journal_info) 729a22285a6SYan, Zheng current->journal_info = h; 730fcc99734SQu Wenruo 731fcc99734SQu Wenruo /* 7329c343784SJosef Bacik * If the space_info is marked ALLOC_FORCE then we'll get upgraded to 7339c343784SJosef Bacik * ALLOC_FORCE the first run through, and then we won't allocate for 7349c343784SJosef Bacik * anybody else who races in later. We don't care about the return 7359c343784SJosef Bacik * value here. 7369c343784SJosef Bacik */ 7379c343784SJosef Bacik if (do_chunk_alloc && num_bytes) { 7389c343784SJosef Bacik u64 flags = h->block_rsv->space_info->flags; 7399c343784SJosef Bacik 7409c343784SJosef Bacik btrfs_chunk_alloc(h, btrfs_get_alloc_profile(fs_info, flags), 7419c343784SJosef Bacik CHUNK_ALLOC_NO_FORCE); 7429c343784SJosef Bacik } 7439c343784SJosef Bacik 7449c343784SJosef Bacik /* 745fcc99734SQu Wenruo * btrfs_record_root_in_trans() needs to alloc new extents, and may 746fcc99734SQu Wenruo * call btrfs_join_transaction() while we're also starting a 747fcc99734SQu Wenruo * transaction. 748fcc99734SQu Wenruo * 749fcc99734SQu Wenruo * Thus it need to be called after current->journal_info initialized, 750fcc99734SQu Wenruo * or we can deadlock. 751fcc99734SQu Wenruo */ 75268075ea8SJosef Bacik ret = btrfs_record_root_in_trans(h, root); 75368075ea8SJosef Bacik if (ret) { 75468075ea8SJosef Bacik /* 75568075ea8SJosef Bacik * The transaction handle is fully initialized and linked with 75668075ea8SJosef Bacik * other structures so it needs to be ended in case of errors, 75768075ea8SJosef Bacik * not just freed. 75868075ea8SJosef Bacik */ 75968075ea8SJosef Bacik btrfs_end_transaction(h); 76068075ea8SJosef Bacik return ERR_PTR(ret); 76168075ea8SJosef Bacik } 762fcc99734SQu Wenruo 76379154b1bSChris Mason return h; 764843fcf35SMiao Xie 765843fcf35SMiao Xie join_fail: 7660860adfdSMiao Xie if (type & __TRANS_FREEZABLE) 7670b246afaSJeff Mahoney sb_end_intwrite(fs_info->sb); 768843fcf35SMiao Xie kmem_cache_free(btrfs_trans_handle_cachep, h); 769843fcf35SMiao Xie alloc_fail: 770843fcf35SMiao Xie if (num_bytes) 7712ff7e61eSJeff Mahoney btrfs_block_rsv_release(fs_info, &fs_info->trans_block_rsv, 77263f018beSNikolay Borisov num_bytes, NULL); 773843fcf35SMiao Xie reserve_fail: 774733e03a0SQu Wenruo btrfs_qgroup_free_meta_pertrans(root, qgroup_reserved); 775843fcf35SMiao Xie return ERR_PTR(ret); 77679154b1bSChris Mason } 77779154b1bSChris Mason 778f9295749SChris Mason struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root, 7795aed1dd8SAlexandru Moise unsigned int num_items) 780f9295749SChris Mason { 78108e007d2SMiao Xie return start_transaction(root, num_items, TRANS_START, 782003d7c59SJeff Mahoney BTRFS_RESERVE_FLUSH_ALL, true); 783f9295749SChris Mason } 784003d7c59SJeff Mahoney 7858eab77ffSFilipe Manana struct btrfs_trans_handle *btrfs_start_transaction_fallback_global_rsv( 7868eab77ffSFilipe Manana struct btrfs_root *root, 7877f9fe614SJosef Bacik unsigned int num_items) 7888eab77ffSFilipe Manana { 7897f9fe614SJosef Bacik return start_transaction(root, num_items, TRANS_START, 7907f9fe614SJosef Bacik BTRFS_RESERVE_FLUSH_ALL_STEAL, false); 7918eab77ffSFilipe Manana } 7928407aa46SMiao Xie 7937a7eaa40SJosef Bacik struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root) 794f9295749SChris Mason { 795003d7c59SJeff Mahoney return start_transaction(root, 0, TRANS_JOIN, BTRFS_RESERVE_NO_FLUSH, 796003d7c59SJeff Mahoney true); 797f9295749SChris Mason } 798f9295749SChris Mason 7998d510121SNikolay Borisov struct btrfs_trans_handle *btrfs_join_transaction_spacecache(struct btrfs_root *root) 8000af3d00bSJosef Bacik { 801575a75d6SAlexandru Moise return start_transaction(root, 0, TRANS_JOIN_NOLOCK, 802003d7c59SJeff Mahoney BTRFS_RESERVE_NO_FLUSH, true); 8030af3d00bSJosef Bacik } 8040af3d00bSJosef Bacik 805d4edf39bSMiao Xie /* 806a6d155d2SFilipe Manana * Similar to regular join but it never starts a transaction when none is 807a6d155d2SFilipe Manana * running or after waiting for the current one to finish. 808a6d155d2SFilipe Manana */ 809a6d155d2SFilipe Manana struct btrfs_trans_handle *btrfs_join_transaction_nostart(struct btrfs_root *root) 810a6d155d2SFilipe Manana { 811a6d155d2SFilipe Manana return start_transaction(root, 0, TRANS_JOIN_NOSTART, 812a6d155d2SFilipe Manana BTRFS_RESERVE_NO_FLUSH, true); 813a6d155d2SFilipe Manana } 814a6d155d2SFilipe Manana 815a6d155d2SFilipe Manana /* 816d4edf39bSMiao Xie * btrfs_attach_transaction() - catch the running transaction 817d4edf39bSMiao Xie * 818d4edf39bSMiao Xie * It is used when we want to commit the current the transaction, but 819d4edf39bSMiao Xie * don't want to start a new one. 820d4edf39bSMiao Xie * 821d4edf39bSMiao Xie * Note: If this function return -ENOENT, it just means there is no 822d4edf39bSMiao Xie * running transaction. But it is possible that the inactive transaction 823d4edf39bSMiao Xie * is still in the memory, not fully on disk. If you hope there is no 824d4edf39bSMiao Xie * inactive transaction in the fs when -ENOENT is returned, you should 825d4edf39bSMiao Xie * invoke 826d4edf39bSMiao Xie * btrfs_attach_transaction_barrier() 827d4edf39bSMiao Xie */ 828354aa0fbSMiao Xie struct btrfs_trans_handle *btrfs_attach_transaction(struct btrfs_root *root) 82960376ce4SJosef Bacik { 830575a75d6SAlexandru Moise return start_transaction(root, 0, TRANS_ATTACH, 831003d7c59SJeff Mahoney BTRFS_RESERVE_NO_FLUSH, true); 83260376ce4SJosef Bacik } 83360376ce4SJosef Bacik 834d4edf39bSMiao Xie /* 83590b6d283SWang Sheng-Hui * btrfs_attach_transaction_barrier() - catch the running transaction 836d4edf39bSMiao Xie * 83752042d8eSAndrea Gelmini * It is similar to the above function, the difference is this one 838d4edf39bSMiao Xie * will wait for all the inactive transactions until they fully 839d4edf39bSMiao Xie * complete. 840d4edf39bSMiao Xie */ 841d4edf39bSMiao Xie struct btrfs_trans_handle * 842d4edf39bSMiao Xie btrfs_attach_transaction_barrier(struct btrfs_root *root) 843d4edf39bSMiao Xie { 844d4edf39bSMiao Xie struct btrfs_trans_handle *trans; 845d4edf39bSMiao Xie 846575a75d6SAlexandru Moise trans = start_transaction(root, 0, TRANS_ATTACH, 847003d7c59SJeff Mahoney BTRFS_RESERVE_NO_FLUSH, true); 8488d9e220cSAl Viro if (trans == ERR_PTR(-ENOENT)) 8492ff7e61eSJeff Mahoney btrfs_wait_for_commit(root->fs_info, 0); 850d4edf39bSMiao Xie 851d4edf39bSMiao Xie return trans; 852d4edf39bSMiao Xie } 853d4edf39bSMiao Xie 854d0c2f4faSFilipe Manana /* Wait for a transaction commit to reach at least the given state. */ 855d0c2f4faSFilipe Manana static noinline void wait_for_commit(struct btrfs_transaction *commit, 856d0c2f4faSFilipe Manana const enum btrfs_trans_state min_state) 85789ce8a63SChris Mason { 8585fd76bf3SOmar Sandoval struct btrfs_fs_info *fs_info = commit->fs_info; 8595fd76bf3SOmar Sandoval u64 transid = commit->transid; 8605fd76bf3SOmar Sandoval bool put = false; 8615fd76bf3SOmar Sandoval 8625fd76bf3SOmar Sandoval while (1) { 863d0c2f4faSFilipe Manana wait_event(commit->commit_wait, commit->state >= min_state); 8645fd76bf3SOmar Sandoval if (put) 8655fd76bf3SOmar Sandoval btrfs_put_transaction(commit); 8665fd76bf3SOmar Sandoval 8675fd76bf3SOmar Sandoval if (min_state < TRANS_STATE_COMPLETED) 8685fd76bf3SOmar Sandoval break; 8695fd76bf3SOmar Sandoval 8705fd76bf3SOmar Sandoval /* 8715fd76bf3SOmar Sandoval * A transaction isn't really completed until all of the 8725fd76bf3SOmar Sandoval * previous transactions are completed, but with fsync we can 8735fd76bf3SOmar Sandoval * end up with SUPER_COMMITTED transactions before a COMPLETED 8745fd76bf3SOmar Sandoval * transaction. Wait for those. 8755fd76bf3SOmar Sandoval */ 8765fd76bf3SOmar Sandoval 8775fd76bf3SOmar Sandoval spin_lock(&fs_info->trans_lock); 8785fd76bf3SOmar Sandoval commit = list_first_entry_or_null(&fs_info->trans_list, 8795fd76bf3SOmar Sandoval struct btrfs_transaction, 8805fd76bf3SOmar Sandoval list); 8815fd76bf3SOmar Sandoval if (!commit || commit->transid > transid) { 8825fd76bf3SOmar Sandoval spin_unlock(&fs_info->trans_lock); 8835fd76bf3SOmar Sandoval break; 8845fd76bf3SOmar Sandoval } 8855fd76bf3SOmar Sandoval refcount_inc(&commit->use_count); 8865fd76bf3SOmar Sandoval put = true; 8875fd76bf3SOmar Sandoval spin_unlock(&fs_info->trans_lock); 8885fd76bf3SOmar Sandoval } 88989ce8a63SChris Mason } 89089ce8a63SChris Mason 8912ff7e61eSJeff Mahoney int btrfs_wait_for_commit(struct btrfs_fs_info *fs_info, u64 transid) 89246204592SSage Weil { 89346204592SSage Weil struct btrfs_transaction *cur_trans = NULL, *t; 8948cd2807fSMiao Xie int ret = 0; 89546204592SSage Weil 89646204592SSage Weil if (transid) { 8970b246afaSJeff Mahoney if (transid <= fs_info->last_trans_committed) 898a4abeea4SJosef Bacik goto out; 89946204592SSage Weil 90046204592SSage Weil /* find specified transaction */ 9010b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 9020b246afaSJeff Mahoney list_for_each_entry(t, &fs_info->trans_list, list) { 90346204592SSage Weil if (t->transid == transid) { 90446204592SSage Weil cur_trans = t; 9059b64f57dSElena Reshetova refcount_inc(&cur_trans->use_count); 9068cd2807fSMiao Xie ret = 0; 90746204592SSage Weil break; 90846204592SSage Weil } 9098cd2807fSMiao Xie if (t->transid > transid) { 9108cd2807fSMiao Xie ret = 0; 91146204592SSage Weil break; 91246204592SSage Weil } 9138cd2807fSMiao Xie } 9140b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 91542383020SSage Weil 91642383020SSage Weil /* 91742383020SSage Weil * The specified transaction doesn't exist, or we 91842383020SSage Weil * raced with btrfs_commit_transaction 91942383020SSage Weil */ 92042383020SSage Weil if (!cur_trans) { 9210b246afaSJeff Mahoney if (transid > fs_info->last_trans_committed) 92242383020SSage Weil ret = -EINVAL; 9238cd2807fSMiao Xie goto out; 92442383020SSage Weil } 92546204592SSage Weil } else { 92646204592SSage Weil /* find newest transaction that is committing | committed */ 9270b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 9280b246afaSJeff Mahoney list_for_each_entry_reverse(t, &fs_info->trans_list, 92946204592SSage Weil list) { 9304a9d8bdeSMiao Xie if (t->state >= TRANS_STATE_COMMIT_START) { 9314a9d8bdeSMiao Xie if (t->state == TRANS_STATE_COMPLETED) 9323473f3c0SJosef Bacik break; 93346204592SSage Weil cur_trans = t; 9349b64f57dSElena Reshetova refcount_inc(&cur_trans->use_count); 93546204592SSage Weil break; 93646204592SSage Weil } 93746204592SSage Weil } 9380b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 93946204592SSage Weil if (!cur_trans) 940a4abeea4SJosef Bacik goto out; /* nothing committing|committed */ 94146204592SSage Weil } 94246204592SSage Weil 943d0c2f4faSFilipe Manana wait_for_commit(cur_trans, TRANS_STATE_COMPLETED); 944724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 945a4abeea4SJosef Bacik out: 94646204592SSage Weil return ret; 94746204592SSage Weil } 94846204592SSage Weil 9492ff7e61eSJeff Mahoney void btrfs_throttle(struct btrfs_fs_info *fs_info) 95037d1aeeeSChris Mason { 9512ff7e61eSJeff Mahoney wait_current_trans(fs_info); 95237d1aeeeSChris Mason } 95337d1aeeeSChris Mason 9548a8f4deaSNikolay Borisov static bool should_end_transaction(struct btrfs_trans_handle *trans) 9558929ecfaSYan, Zheng { 9562ff7e61eSJeff Mahoney struct btrfs_fs_info *fs_info = trans->fs_info; 9570b246afaSJeff Mahoney 95864403612SJosef Bacik if (btrfs_check_space_for_delayed_refs(fs_info)) 9598a8f4deaSNikolay Borisov return true; 96036ba022aSJosef Bacik 9612ff7e61eSJeff Mahoney return !!btrfs_block_rsv_check(&fs_info->global_block_rsv, 5); 9628929ecfaSYan, Zheng } 9638929ecfaSYan, Zheng 964a2633b6aSNikolay Borisov bool btrfs_should_end_transaction(struct btrfs_trans_handle *trans) 9658929ecfaSYan, Zheng { 9668929ecfaSYan, Zheng struct btrfs_transaction *cur_trans = trans->transaction; 9678929ecfaSYan, Zheng 9683296bf56SQu Wenruo if (cur_trans->state >= TRANS_STATE_COMMIT_START || 969e19eb11fSJosef Bacik test_bit(BTRFS_DELAYED_REFS_FLUSHING, &cur_trans->delayed_refs.flags)) 970a2633b6aSNikolay Borisov return true; 9718929ecfaSYan, Zheng 9722ff7e61eSJeff Mahoney return should_end_transaction(trans); 9738929ecfaSYan, Zheng } 9748929ecfaSYan, Zheng 975dc60c525SNikolay Borisov static void btrfs_trans_release_metadata(struct btrfs_trans_handle *trans) 976dc60c525SNikolay Borisov 9770e34693fSNikolay Borisov { 978dc60c525SNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 979dc60c525SNikolay Borisov 9800e34693fSNikolay Borisov if (!trans->block_rsv) { 9810e34693fSNikolay Borisov ASSERT(!trans->bytes_reserved); 9820e34693fSNikolay Borisov return; 9830e34693fSNikolay Borisov } 9840e34693fSNikolay Borisov 9850e34693fSNikolay Borisov if (!trans->bytes_reserved) 9860e34693fSNikolay Borisov return; 9870e34693fSNikolay Borisov 9880e34693fSNikolay Borisov ASSERT(trans->block_rsv == &fs_info->trans_block_rsv); 9890e34693fSNikolay Borisov trace_btrfs_space_reservation(fs_info, "transaction", 9900e34693fSNikolay Borisov trans->transid, trans->bytes_reserved, 0); 9910e34693fSNikolay Borisov btrfs_block_rsv_release(fs_info, trans->block_rsv, 99263f018beSNikolay Borisov trans->bytes_reserved, NULL); 9930e34693fSNikolay Borisov trans->bytes_reserved = 0; 9940e34693fSNikolay Borisov } 9950e34693fSNikolay Borisov 99689ce8a63SChris Mason static int __btrfs_end_transaction(struct btrfs_trans_handle *trans, 9973a45bb20SJeff Mahoney int throttle) 99879154b1bSChris Mason { 9993a45bb20SJeff Mahoney struct btrfs_fs_info *info = trans->fs_info; 10008929ecfaSYan, Zheng struct btrfs_transaction *cur_trans = trans->transaction; 10014edc2ca3SDave Jones int err = 0; 1002d6e4a428SChris Mason 1003b50fff81SDavid Sterba if (refcount_read(&trans->use_count) > 1) { 1004b50fff81SDavid Sterba refcount_dec(&trans->use_count); 10052a1eb461SJosef Bacik trans->block_rsv = trans->orig_rsv; 10062a1eb461SJosef Bacik return 0; 10072a1eb461SJosef Bacik } 10082a1eb461SJosef Bacik 1009dc60c525SNikolay Borisov btrfs_trans_release_metadata(trans); 10104c13d758SJosef Bacik trans->block_rsv = NULL; 1011c5567237SArne Jansen 10126c686b35SNikolay Borisov btrfs_create_pending_block_groups(trans); 1013ea658badSJosef Bacik 10144fbcdf66SFilipe Manana btrfs_trans_release_chunk_metadata(trans); 10154fbcdf66SFilipe Manana 10160860adfdSMiao Xie if (trans->type & __TRANS_FREEZABLE) 10170b246afaSJeff Mahoney sb_end_intwrite(info->sb); 10186df7881aSJosef Bacik 10198929ecfaSYan, Zheng WARN_ON(cur_trans != info->running_transaction); 102013c5a93eSJosef Bacik WARN_ON(atomic_read(&cur_trans->num_writers) < 1); 102113c5a93eSJosef Bacik atomic_dec(&cur_trans->num_writers); 10220860adfdSMiao Xie extwriter_counter_dec(cur_trans, trans->type); 102389ce8a63SChris Mason 1024093258e6SDavid Sterba cond_wake_up(&cur_trans->writer_wait); 1025724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 10269ed74f2dSJosef Bacik 10279ed74f2dSJosef Bacik if (current->journal_info == trans) 10289ed74f2dSJosef Bacik current->journal_info = NULL; 1029ab78c84dSChris Mason 103024bbcf04SYan, Zheng if (throttle) 10312ff7e61eSJeff Mahoney btrfs_run_delayed_iputs(info); 103224bbcf04SYan, Zheng 103384961539SJosef Bacik if (TRANS_ABORTED(trans) || BTRFS_FS_ERROR(info)) { 10344e121c06SJosef Bacik wake_up_process(info->transaction_kthread); 1035fbabd4a3SJosef Bacik if (TRANS_ABORTED(trans)) 1036fbabd4a3SJosef Bacik err = trans->aborted; 1037fbabd4a3SJosef Bacik else 1038fbabd4a3SJosef Bacik err = -EROFS; 10394e121c06SJosef Bacik } 104049b25e05SJeff Mahoney 10414edc2ca3SDave Jones kmem_cache_free(btrfs_trans_handle_cachep, trans); 10424edc2ca3SDave Jones return err; 104379154b1bSChris Mason } 104479154b1bSChris Mason 10453a45bb20SJeff Mahoney int btrfs_end_transaction(struct btrfs_trans_handle *trans) 104689ce8a63SChris Mason { 10473a45bb20SJeff Mahoney return __btrfs_end_transaction(trans, 0); 104889ce8a63SChris Mason } 104989ce8a63SChris Mason 10503a45bb20SJeff Mahoney int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans) 105189ce8a63SChris Mason { 10523a45bb20SJeff Mahoney return __btrfs_end_transaction(trans, 1); 105316cdcec7SMiao Xie } 105416cdcec7SMiao Xie 1055d352ac68SChris Mason /* 1056d352ac68SChris Mason * when btree blocks are allocated, they have some corresponding bits set for 1057d352ac68SChris Mason * them in one of two extent_io trees. This is used to make sure all of 1058690587d1SChris Mason * those extents are sent to disk but does not wait on them 1059d352ac68SChris Mason */ 10602ff7e61eSJeff Mahoney int btrfs_write_marked_extents(struct btrfs_fs_info *fs_info, 10618cef4e16SYan, Zheng struct extent_io_tree *dirty_pages, int mark) 106279154b1bSChris Mason { 1063777e6bd7SChris Mason int err = 0; 10647c4452b9SChris Mason int werr = 0; 10650b246afaSJeff Mahoney struct address_space *mapping = fs_info->btree_inode->i_mapping; 1066e6138876SJosef Bacik struct extent_state *cached_state = NULL; 1067777e6bd7SChris Mason u64 start = 0; 10685f39d397SChris Mason u64 end; 10697c4452b9SChris Mason 10706300463bSLiu Bo atomic_inc(&BTRFS_I(fs_info->btree_inode)->sync_writers); 10711728366eSJosef Bacik while (!find_first_extent_bit(dirty_pages, start, &start, &end, 1072e6138876SJosef Bacik mark, &cached_state)) { 1073663dfbb0SFilipe Manana bool wait_writeback = false; 1074663dfbb0SFilipe Manana 1075663dfbb0SFilipe Manana err = convert_extent_bit(dirty_pages, start, end, 1076663dfbb0SFilipe Manana EXTENT_NEED_WAIT, 1077210aa277SDavid Sterba mark, &cached_state); 1078663dfbb0SFilipe Manana /* 1079663dfbb0SFilipe Manana * convert_extent_bit can return -ENOMEM, which is most of the 1080663dfbb0SFilipe Manana * time a temporary error. So when it happens, ignore the error 1081663dfbb0SFilipe Manana * and wait for writeback of this range to finish - because we 1082663dfbb0SFilipe Manana * failed to set the bit EXTENT_NEED_WAIT for the range, a call 1083bf89d38fSJeff Mahoney * to __btrfs_wait_marked_extents() would not know that 1084bf89d38fSJeff Mahoney * writeback for this range started and therefore wouldn't 1085bf89d38fSJeff Mahoney * wait for it to finish - we don't want to commit a 1086bf89d38fSJeff Mahoney * superblock that points to btree nodes/leafs for which 1087bf89d38fSJeff Mahoney * writeback hasn't finished yet (and without errors). 1088663dfbb0SFilipe Manana * We cleanup any entries left in the io tree when committing 108941e7acd3SNikolay Borisov * the transaction (through extent_io_tree_release()). 1090663dfbb0SFilipe Manana */ 1091663dfbb0SFilipe Manana if (err == -ENOMEM) { 1092663dfbb0SFilipe Manana err = 0; 1093663dfbb0SFilipe Manana wait_writeback = true; 1094663dfbb0SFilipe Manana } 1095663dfbb0SFilipe Manana if (!err) 10961728366eSJosef Bacik err = filemap_fdatawrite_range(mapping, start, end); 10977c4452b9SChris Mason if (err) 10987c4452b9SChris Mason werr = err; 1099663dfbb0SFilipe Manana else if (wait_writeback) 1100663dfbb0SFilipe Manana werr = filemap_fdatawait_range(mapping, start, end); 1101e38e2ed7SFilipe Manana free_extent_state(cached_state); 1102663dfbb0SFilipe Manana cached_state = NULL; 11031728366eSJosef Bacik cond_resched(); 11041728366eSJosef Bacik start = end + 1; 11057c4452b9SChris Mason } 11066300463bSLiu Bo atomic_dec(&BTRFS_I(fs_info->btree_inode)->sync_writers); 1107690587d1SChris Mason return werr; 1108690587d1SChris Mason } 1109690587d1SChris Mason 1110690587d1SChris Mason /* 1111690587d1SChris Mason * when btree blocks are allocated, they have some corresponding bits set for 1112690587d1SChris Mason * them in one of two extent_io trees. This is used to make sure all of 1113690587d1SChris Mason * those extents are on disk for transaction or log commit. We wait 1114690587d1SChris Mason * on all the pages and clear them from the dirty pages state tree 1115690587d1SChris Mason */ 1116bf89d38fSJeff Mahoney static int __btrfs_wait_marked_extents(struct btrfs_fs_info *fs_info, 1117bf89d38fSJeff Mahoney struct extent_io_tree *dirty_pages) 1118690587d1SChris Mason { 1119690587d1SChris Mason int err = 0; 1120690587d1SChris Mason int werr = 0; 11210b246afaSJeff Mahoney struct address_space *mapping = fs_info->btree_inode->i_mapping; 1122e6138876SJosef Bacik struct extent_state *cached_state = NULL; 1123690587d1SChris Mason u64 start = 0; 1124690587d1SChris Mason u64 end; 1125690587d1SChris Mason 11261728366eSJosef Bacik while (!find_first_extent_bit(dirty_pages, start, &start, &end, 1127e6138876SJosef Bacik EXTENT_NEED_WAIT, &cached_state)) { 1128663dfbb0SFilipe Manana /* 1129663dfbb0SFilipe Manana * Ignore -ENOMEM errors returned by clear_extent_bit(). 1130663dfbb0SFilipe Manana * When committing the transaction, we'll remove any entries 1131663dfbb0SFilipe Manana * left in the io tree. For a log commit, we don't remove them 1132663dfbb0SFilipe Manana * after committing the log because the tree can be accessed 1133663dfbb0SFilipe Manana * concurrently - we do it only at transaction commit time when 113441e7acd3SNikolay Borisov * it's safe to do it (through extent_io_tree_release()). 1135663dfbb0SFilipe Manana */ 1136663dfbb0SFilipe Manana err = clear_extent_bit(dirty_pages, start, end, 1137ae0f1625SDavid Sterba EXTENT_NEED_WAIT, 0, 0, &cached_state); 1138663dfbb0SFilipe Manana if (err == -ENOMEM) 1139663dfbb0SFilipe Manana err = 0; 1140663dfbb0SFilipe Manana if (!err) 11411728366eSJosef Bacik err = filemap_fdatawait_range(mapping, start, end); 1142777e6bd7SChris Mason if (err) 1143777e6bd7SChris Mason werr = err; 1144e38e2ed7SFilipe Manana free_extent_state(cached_state); 1145e38e2ed7SFilipe Manana cached_state = NULL; 1146777e6bd7SChris Mason cond_resched(); 11471728366eSJosef Bacik start = end + 1; 1148777e6bd7SChris Mason } 11497c4452b9SChris Mason if (err) 11507c4452b9SChris Mason werr = err; 1151bf89d38fSJeff Mahoney return werr; 1152bf89d38fSJeff Mahoney } 1153656f30dbSFilipe Manana 1154b9fae2ebSFilipe Manana static int btrfs_wait_extents(struct btrfs_fs_info *fs_info, 1155bf89d38fSJeff Mahoney struct extent_io_tree *dirty_pages) 1156bf89d38fSJeff Mahoney { 1157bf89d38fSJeff Mahoney bool errors = false; 1158bf89d38fSJeff Mahoney int err; 1159bf89d38fSJeff Mahoney 1160bf89d38fSJeff Mahoney err = __btrfs_wait_marked_extents(fs_info, dirty_pages); 1161bf89d38fSJeff Mahoney if (test_and_clear_bit(BTRFS_FS_BTREE_ERR, &fs_info->flags)) 1162bf89d38fSJeff Mahoney errors = true; 1163bf89d38fSJeff Mahoney 1164bf89d38fSJeff Mahoney if (errors && !err) 1165bf89d38fSJeff Mahoney err = -EIO; 1166bf89d38fSJeff Mahoney return err; 1167bf89d38fSJeff Mahoney } 1168bf89d38fSJeff Mahoney 1169bf89d38fSJeff Mahoney int btrfs_wait_tree_log_extents(struct btrfs_root *log_root, int mark) 1170bf89d38fSJeff Mahoney { 1171bf89d38fSJeff Mahoney struct btrfs_fs_info *fs_info = log_root->fs_info; 1172bf89d38fSJeff Mahoney struct extent_io_tree *dirty_pages = &log_root->dirty_log_pages; 1173bf89d38fSJeff Mahoney bool errors = false; 1174bf89d38fSJeff Mahoney int err; 1175bf89d38fSJeff Mahoney 1176bf89d38fSJeff Mahoney ASSERT(log_root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID); 1177bf89d38fSJeff Mahoney 1178bf89d38fSJeff Mahoney err = __btrfs_wait_marked_extents(fs_info, dirty_pages); 1179656f30dbSFilipe Manana if ((mark & EXTENT_DIRTY) && 11800b246afaSJeff Mahoney test_and_clear_bit(BTRFS_FS_LOG1_ERR, &fs_info->flags)) 1181656f30dbSFilipe Manana errors = true; 1182656f30dbSFilipe Manana 1183656f30dbSFilipe Manana if ((mark & EXTENT_NEW) && 11840b246afaSJeff Mahoney test_and_clear_bit(BTRFS_FS_LOG2_ERR, &fs_info->flags)) 1185656f30dbSFilipe Manana errors = true; 1186656f30dbSFilipe Manana 1187bf89d38fSJeff Mahoney if (errors && !err) 1188bf89d38fSJeff Mahoney err = -EIO; 1189bf89d38fSJeff Mahoney return err; 119079154b1bSChris Mason } 119179154b1bSChris Mason 1192690587d1SChris Mason /* 1193c9b577c0SNikolay Borisov * When btree blocks are allocated the corresponding extents are marked dirty. 1194c9b577c0SNikolay Borisov * This function ensures such extents are persisted on disk for transaction or 1195c9b577c0SNikolay Borisov * log commit. 1196c9b577c0SNikolay Borisov * 1197c9b577c0SNikolay Borisov * @trans: transaction whose dirty pages we'd like to write 1198690587d1SChris Mason */ 119970458a58SNikolay Borisov static int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans) 1200d0c803c4SChris Mason { 1201663dfbb0SFilipe Manana int ret; 1202c9b577c0SNikolay Borisov int ret2; 1203c9b577c0SNikolay Borisov struct extent_io_tree *dirty_pages = &trans->transaction->dirty_pages; 120470458a58SNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 1205c9b577c0SNikolay Borisov struct blk_plug plug; 1206663dfbb0SFilipe Manana 1207c9b577c0SNikolay Borisov blk_start_plug(&plug); 1208c9b577c0SNikolay Borisov ret = btrfs_write_marked_extents(fs_info, dirty_pages, EXTENT_DIRTY); 1209c9b577c0SNikolay Borisov blk_finish_plug(&plug); 1210c9b577c0SNikolay Borisov ret2 = btrfs_wait_extents(fs_info, dirty_pages); 1211c9b577c0SNikolay Borisov 121241e7acd3SNikolay Borisov extent_io_tree_release(&trans->transaction->dirty_pages); 1213663dfbb0SFilipe Manana 1214c9b577c0SNikolay Borisov if (ret) 1215663dfbb0SFilipe Manana return ret; 1216c9b577c0SNikolay Borisov else if (ret2) 1217c9b577c0SNikolay Borisov return ret2; 1218c9b577c0SNikolay Borisov else 1219c9b577c0SNikolay Borisov return 0; 1220d0c803c4SChris Mason } 1221d0c803c4SChris Mason 1222d352ac68SChris Mason /* 1223d352ac68SChris Mason * this is used to update the root pointer in the tree of tree roots. 1224d352ac68SChris Mason * 1225d352ac68SChris Mason * But, in the case of the extent allocation tree, updating the root 1226d352ac68SChris Mason * pointer may allocate blocks which may change the root of the extent 1227d352ac68SChris Mason * allocation tree. 1228d352ac68SChris Mason * 1229d352ac68SChris Mason * So, this loops and repeats and makes sure the cowonly root didn't 1230d352ac68SChris Mason * change while the root pointer was being updated in the metadata. 1231d352ac68SChris Mason */ 12320b86a832SChris Mason static int update_cowonly_root(struct btrfs_trans_handle *trans, 123379154b1bSChris Mason struct btrfs_root *root) 123479154b1bSChris Mason { 123579154b1bSChris Mason int ret; 12360b86a832SChris Mason u64 old_root_bytenr; 123786b9f2ecSYan, Zheng u64 old_root_used; 12380b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 12390b246afaSJeff Mahoney struct btrfs_root *tree_root = fs_info->tree_root; 124079154b1bSChris Mason 124186b9f2ecSYan, Zheng old_root_used = btrfs_root_used(&root->root_item); 124256bec294SChris Mason 124379154b1bSChris Mason while (1) { 12440b86a832SChris Mason old_root_bytenr = btrfs_root_bytenr(&root->root_item); 124586b9f2ecSYan, Zheng if (old_root_bytenr == root->node->start && 1246ea526d18SJosef Bacik old_root_used == btrfs_root_used(&root->root_item)) 124779154b1bSChris Mason break; 124887ef2bb4SChris Mason 12495d4f98a2SYan Zheng btrfs_set_root_node(&root->root_item, root->node); 125079154b1bSChris Mason ret = btrfs_update_root(trans, tree_root, 12510b86a832SChris Mason &root->root_key, 12520b86a832SChris Mason &root->root_item); 125349b25e05SJeff Mahoney if (ret) 125449b25e05SJeff Mahoney return ret; 125556bec294SChris Mason 125686b9f2ecSYan, Zheng old_root_used = btrfs_root_used(&root->root_item); 1257e7070be1SJosef Bacik } 1258276e680dSYan Zheng 12590b86a832SChris Mason return 0; 12600b86a832SChris Mason } 12610b86a832SChris Mason 1262d352ac68SChris Mason /* 1263d352ac68SChris Mason * update all the cowonly tree roots on disk 126449b25e05SJeff Mahoney * 126549b25e05SJeff Mahoney * The error handling in this function may not be obvious. Any of the 126649b25e05SJeff Mahoney * failures will cause the file system to go offline. We still need 126749b25e05SJeff Mahoney * to clean up the delayed refs. 1268d352ac68SChris Mason */ 12699386d8bcSNikolay Borisov static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans) 12700b86a832SChris Mason { 12719386d8bcSNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 1272ea526d18SJosef Bacik struct list_head *dirty_bgs = &trans->transaction->dirty_bgs; 12731bbc621eSChris Mason struct list_head *io_bgs = &trans->transaction->io_bgs; 12740b86a832SChris Mason struct list_head *next; 127584234f3aSYan Zheng struct extent_buffer *eb; 127656bec294SChris Mason int ret; 127784234f3aSYan Zheng 1278dfba78dcSFilipe Manana /* 1279dfba78dcSFilipe Manana * At this point no one can be using this transaction to modify any tree 1280dfba78dcSFilipe Manana * and no one can start another transaction to modify any tree either. 1281dfba78dcSFilipe Manana */ 1282dfba78dcSFilipe Manana ASSERT(trans->transaction->state == TRANS_STATE_COMMIT_DOING); 1283dfba78dcSFilipe Manana 128484234f3aSYan Zheng eb = btrfs_lock_root_node(fs_info->tree_root); 128549b25e05SJeff Mahoney ret = btrfs_cow_block(trans, fs_info->tree_root, eb, NULL, 12869631e4ccSJosef Bacik 0, &eb, BTRFS_NESTING_COW); 128784234f3aSYan Zheng btrfs_tree_unlock(eb); 128884234f3aSYan Zheng free_extent_buffer(eb); 12890b86a832SChris Mason 129049b25e05SJeff Mahoney if (ret) 129149b25e05SJeff Mahoney return ret; 129249b25e05SJeff Mahoney 1293196c9d8dSDavid Sterba ret = btrfs_run_dev_stats(trans); 1294c16ce190SJosef Bacik if (ret) 1295c16ce190SJosef Bacik return ret; 12962b584c68SDavid Sterba ret = btrfs_run_dev_replace(trans); 1297c16ce190SJosef Bacik if (ret) 1298c16ce190SJosef Bacik return ret; 1299280f8bd2SLu Fengqi ret = btrfs_run_qgroups(trans); 1300c16ce190SJosef Bacik if (ret) 1301c16ce190SJosef Bacik return ret; 1302546adb0dSJan Schmidt 1303bbebb3e0SDavid Sterba ret = btrfs_setup_space_cache(trans); 1304dcdf7f6dSJosef Bacik if (ret) 1305dcdf7f6dSJosef Bacik return ret; 1306dcdf7f6dSJosef Bacik 1307ea526d18SJosef Bacik again: 13080b86a832SChris Mason while (!list_empty(&fs_info->dirty_cowonly_roots)) { 13092ff7e61eSJeff Mahoney struct btrfs_root *root; 13100b86a832SChris Mason next = fs_info->dirty_cowonly_roots.next; 13110b86a832SChris Mason list_del_init(next); 13120b86a832SChris Mason root = list_entry(next, struct btrfs_root, dirty_list); 1313e7070be1SJosef Bacik clear_bit(BTRFS_ROOT_DIRTY, &root->state); 131487ef2bb4SChris Mason 13159e351cc8SJosef Bacik list_add_tail(&root->dirty_list, 13169e351cc8SJosef Bacik &trans->transaction->switch_commits); 131749b25e05SJeff Mahoney ret = update_cowonly_root(trans, root); 131849b25e05SJeff Mahoney if (ret) 131949b25e05SJeff Mahoney return ret; 1320488bc2a2SJosef Bacik } 1321488bc2a2SJosef Bacik 1322488bc2a2SJosef Bacik /* Now flush any delayed refs generated by updating all of the roots */ 1323c79a70b1SNikolay Borisov ret = btrfs_run_delayed_refs(trans, (unsigned long)-1); 1324ea526d18SJosef Bacik if (ret) 1325ea526d18SJosef Bacik return ret; 1326276e680dSYan Zheng 13271bbc621eSChris Mason while (!list_empty(dirty_bgs) || !list_empty(io_bgs)) { 13285742d15fSDavid Sterba ret = btrfs_write_dirty_block_groups(trans); 1329ea526d18SJosef Bacik if (ret) 1330ea526d18SJosef Bacik return ret; 1331488bc2a2SJosef Bacik 1332488bc2a2SJosef Bacik /* 1333488bc2a2SJosef Bacik * We're writing the dirty block groups, which could generate 1334488bc2a2SJosef Bacik * delayed refs, which could generate more dirty block groups, 1335488bc2a2SJosef Bacik * so we want to keep this flushing in this loop to make sure 1336488bc2a2SJosef Bacik * everything gets run. 1337488bc2a2SJosef Bacik */ 1338c79a70b1SNikolay Borisov ret = btrfs_run_delayed_refs(trans, (unsigned long)-1); 1339ea526d18SJosef Bacik if (ret) 1340ea526d18SJosef Bacik return ret; 1341ea526d18SJosef Bacik } 1342ea526d18SJosef Bacik 1343ea526d18SJosef Bacik if (!list_empty(&fs_info->dirty_cowonly_roots)) 1344ea526d18SJosef Bacik goto again; 1345ea526d18SJosef Bacik 13469f6cbcbbSDavid Sterba /* Update dev-replace pointer once everything is committed */ 13479f6cbcbbSDavid Sterba fs_info->dev_replace.committed_cursor_left = 13489f6cbcbbSDavid Sterba fs_info->dev_replace.cursor_left_last_write_of_item; 13498dabb742SStefan Behrens 135079154b1bSChris Mason return 0; 135179154b1bSChris Mason } 135279154b1bSChris Mason 1353d352ac68SChris Mason /* 1354b4be6aefSJosef Bacik * If we had a pending drop we need to see if there are any others left in our 1355b4be6aefSJosef Bacik * dead roots list, and if not clear our bit and wake any waiters. 1356b4be6aefSJosef Bacik */ 1357b4be6aefSJosef Bacik void btrfs_maybe_wake_unfinished_drop(struct btrfs_fs_info *fs_info) 1358b4be6aefSJosef Bacik { 1359b4be6aefSJosef Bacik /* 1360b4be6aefSJosef Bacik * We put the drop in progress roots at the front of the list, so if the 1361b4be6aefSJosef Bacik * first entry doesn't have UNFINISHED_DROP set we can wake everybody 1362b4be6aefSJosef Bacik * up. 1363b4be6aefSJosef Bacik */ 1364b4be6aefSJosef Bacik spin_lock(&fs_info->trans_lock); 1365b4be6aefSJosef Bacik if (!list_empty(&fs_info->dead_roots)) { 1366b4be6aefSJosef Bacik struct btrfs_root *root = list_first_entry(&fs_info->dead_roots, 1367b4be6aefSJosef Bacik struct btrfs_root, 1368b4be6aefSJosef Bacik root_list); 1369b4be6aefSJosef Bacik if (test_bit(BTRFS_ROOT_UNFINISHED_DROP, &root->state)) { 1370b4be6aefSJosef Bacik spin_unlock(&fs_info->trans_lock); 1371b4be6aefSJosef Bacik return; 1372b4be6aefSJosef Bacik } 1373b4be6aefSJosef Bacik } 1374b4be6aefSJosef Bacik spin_unlock(&fs_info->trans_lock); 1375b4be6aefSJosef Bacik 1376b4be6aefSJosef Bacik btrfs_wake_unfinished_drop(fs_info); 1377b4be6aefSJosef Bacik } 1378b4be6aefSJosef Bacik 1379b4be6aefSJosef Bacik /* 1380d352ac68SChris Mason * dead roots are old snapshots that need to be deleted. This allocates 1381d352ac68SChris Mason * a dirty root struct and adds it into the list of dead roots that need to 1382d352ac68SChris Mason * be deleted 1383d352ac68SChris Mason */ 1384cfad392bSJosef Bacik void btrfs_add_dead_root(struct btrfs_root *root) 13855eda7b5eSChris Mason { 13860b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 13870b246afaSJeff Mahoney 13880b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 1389dc9492c1SJosef Bacik if (list_empty(&root->root_list)) { 1390dc9492c1SJosef Bacik btrfs_grab_root(root); 1391b4be6aefSJosef Bacik 1392b4be6aefSJosef Bacik /* We want to process the partially complete drops first. */ 1393b4be6aefSJosef Bacik if (test_bit(BTRFS_ROOT_UNFINISHED_DROP, &root->state)) 1394b4be6aefSJosef Bacik list_add(&root->root_list, &fs_info->dead_roots); 1395b4be6aefSJosef Bacik else 13960b246afaSJeff Mahoney list_add_tail(&root->root_list, &fs_info->dead_roots); 1397dc9492c1SJosef Bacik } 13980b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 13995eda7b5eSChris Mason } 14005eda7b5eSChris Mason 1401d352ac68SChris Mason /* 1402dfba78dcSFilipe Manana * Update each subvolume root and its relocation root, if it exists, in the tree 1403dfba78dcSFilipe Manana * of tree roots. Also free log roots if they exist. 1404d352ac68SChris Mason */ 14057e4443d9SNikolay Borisov static noinline int commit_fs_roots(struct btrfs_trans_handle *trans) 14060f7d52f4SChris Mason { 14077e4443d9SNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 1408fc7cbcd4SDavid Sterba struct btrfs_root *gang[8]; 1409fc7cbcd4SDavid Sterba int i; 1410fc7cbcd4SDavid Sterba int ret; 141154aa1f4dSChris Mason 1412dfba78dcSFilipe Manana /* 1413dfba78dcSFilipe Manana * At this point no one can be using this transaction to modify any tree 1414dfba78dcSFilipe Manana * and no one can start another transaction to modify any tree either. 1415dfba78dcSFilipe Manana */ 1416dfba78dcSFilipe Manana ASSERT(trans->transaction->state == TRANS_STATE_COMMIT_DOING); 1417dfba78dcSFilipe Manana 1418fc7cbcd4SDavid Sterba spin_lock(&fs_info->fs_roots_radix_lock); 1419fc7cbcd4SDavid Sterba while (1) { 1420fc7cbcd4SDavid Sterba ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix, 1421fc7cbcd4SDavid Sterba (void **)gang, 0, 1422fc7cbcd4SDavid Sterba ARRAY_SIZE(gang), 1423fc7cbcd4SDavid Sterba BTRFS_ROOT_TRANS_TAG); 1424fc7cbcd4SDavid Sterba if (ret == 0) 1425fc7cbcd4SDavid Sterba break; 1426fc7cbcd4SDavid Sterba for (i = 0; i < ret; i++) { 1427fc7cbcd4SDavid Sterba struct btrfs_root *root = gang[i]; 1428fc7cbcd4SDavid Sterba int ret2; 14294f4317c1SJosef Bacik 1430dfba78dcSFilipe Manana /* 1431dfba78dcSFilipe Manana * At this point we can neither have tasks logging inodes 1432dfba78dcSFilipe Manana * from a root nor trying to commit a log tree. 1433dfba78dcSFilipe Manana */ 1434dfba78dcSFilipe Manana ASSERT(atomic_read(&root->log_writers) == 0); 1435dfba78dcSFilipe Manana ASSERT(atomic_read(&root->log_commit[0]) == 0); 1436dfba78dcSFilipe Manana ASSERT(atomic_read(&root->log_commit[1]) == 0); 1437dfba78dcSFilipe Manana 1438fc7cbcd4SDavid Sterba radix_tree_tag_clear(&fs_info->fs_roots_radix, 14392619ba1fSChris Mason (unsigned long)root->root_key.objectid, 14400f7d52f4SChris Mason BTRFS_ROOT_TRANS_TAG); 1441fc7cbcd4SDavid Sterba spin_unlock(&fs_info->fs_roots_radix_lock); 144231153d81SYan Zheng 1443e02119d5SChris Mason btrfs_free_log(trans, root); 1444fc7cbcd4SDavid Sterba ret2 = btrfs_update_reloc_root(trans, root); 1445fc7cbcd4SDavid Sterba if (ret2) 1446fc7cbcd4SDavid Sterba return ret2; 1447e02119d5SChris Mason 1448fc7cbcd4SDavid Sterba /* see comments in should_cow_block() */ 144927cdeb70SMiao Xie clear_bit(BTRFS_ROOT_FORCE_COW, &root->state); 1450c7548af6SChris Mason smp_mb__after_atomic(); 1451f1ebcc74SLiu Bo 1452978d910dSYan Zheng if (root->commit_root != root->node) { 14539e351cc8SJosef Bacik list_add_tail(&root->dirty_list, 14549e351cc8SJosef Bacik &trans->transaction->switch_commits); 1455fc7cbcd4SDavid Sterba btrfs_set_root_node(&root->root_item, 1456fc7cbcd4SDavid Sterba root->node); 1457978d910dSYan Zheng } 145831153d81SYan Zheng 1459fc7cbcd4SDavid Sterba ret2 = btrfs_update_root(trans, fs_info->tree_root, 1460fc7cbcd4SDavid Sterba &root->root_key, 1461fc7cbcd4SDavid Sterba &root->root_item); 1462fc7cbcd4SDavid Sterba if (ret2) 1463fc7cbcd4SDavid Sterba return ret2; 1464fc7cbcd4SDavid Sterba spin_lock(&fs_info->fs_roots_radix_lock); 1465733e03a0SQu Wenruo btrfs_qgroup_free_meta_all_pertrans(root); 14660f7d52f4SChris Mason } 1467fc7cbcd4SDavid Sterba } 1468fc7cbcd4SDavid Sterba spin_unlock(&fs_info->fs_roots_radix_lock); 14694f4317c1SJosef Bacik return 0; 14700f7d52f4SChris Mason } 14710f7d52f4SChris Mason 1472d352ac68SChris Mason /* 1473de78b51aSEric Sandeen * defrag a given btree. 1474de78b51aSEric Sandeen * Every leaf in the btree is read and defragged. 1475d352ac68SChris Mason */ 1476de78b51aSEric Sandeen int btrfs_defrag_root(struct btrfs_root *root) 1477e9d0b13bSChris Mason { 1478e9d0b13bSChris Mason struct btrfs_fs_info *info = root->fs_info; 1479e9d0b13bSChris Mason struct btrfs_trans_handle *trans; 14808929ecfaSYan, Zheng int ret; 1481e9d0b13bSChris Mason 148227cdeb70SMiao Xie if (test_and_set_bit(BTRFS_ROOT_DEFRAG_RUNNING, &root->state)) 1483e9d0b13bSChris Mason return 0; 14848929ecfaSYan, Zheng 14856b80053dSChris Mason while (1) { 14868929ecfaSYan, Zheng trans = btrfs_start_transaction(root, 0); 14876819703fSDavid Sterba if (IS_ERR(trans)) { 14886819703fSDavid Sterba ret = PTR_ERR(trans); 14896819703fSDavid Sterba break; 14906819703fSDavid Sterba } 14918929ecfaSYan, Zheng 1492de78b51aSEric Sandeen ret = btrfs_defrag_leaves(trans, root); 14938929ecfaSYan, Zheng 14943a45bb20SJeff Mahoney btrfs_end_transaction(trans); 14952ff7e61eSJeff Mahoney btrfs_btree_balance_dirty(info); 1496e9d0b13bSChris Mason cond_resched(); 1497e9d0b13bSChris Mason 1498ab8d0fc4SJeff Mahoney if (btrfs_fs_closing(info) || ret != -EAGAIN) 1499e9d0b13bSChris Mason break; 1500210549ebSDavid Sterba 1501ab8d0fc4SJeff Mahoney if (btrfs_defrag_cancelled(info)) { 1502ab8d0fc4SJeff Mahoney btrfs_debug(info, "defrag_root cancelled"); 1503210549ebSDavid Sterba ret = -EAGAIN; 1504210549ebSDavid Sterba break; 1505210549ebSDavid Sterba } 1506e9d0b13bSChris Mason } 150727cdeb70SMiao Xie clear_bit(BTRFS_ROOT_DEFRAG_RUNNING, &root->state); 15088929ecfaSYan, Zheng return ret; 1509e9d0b13bSChris Mason } 1510e9d0b13bSChris Mason 1511d352ac68SChris Mason /* 15126426c7adSQu Wenruo * Do all special snapshot related qgroup dirty hack. 15136426c7adSQu Wenruo * 15146426c7adSQu Wenruo * Will do all needed qgroup inherit and dirty hack like switch commit 15156426c7adSQu Wenruo * roots inside one transaction and write all btree into disk, to make 15166426c7adSQu Wenruo * qgroup works. 15176426c7adSQu Wenruo */ 15186426c7adSQu Wenruo static int qgroup_account_snapshot(struct btrfs_trans_handle *trans, 15196426c7adSQu Wenruo struct btrfs_root *src, 15206426c7adSQu Wenruo struct btrfs_root *parent, 15216426c7adSQu Wenruo struct btrfs_qgroup_inherit *inherit, 15226426c7adSQu Wenruo u64 dst_objectid) 15236426c7adSQu Wenruo { 15246426c7adSQu Wenruo struct btrfs_fs_info *fs_info = src->fs_info; 15256426c7adSQu Wenruo int ret; 15266426c7adSQu Wenruo 15276426c7adSQu Wenruo /* 15286426c7adSQu Wenruo * Save some performance in the case that qgroups are not 15296426c7adSQu Wenruo * enabled. If this check races with the ioctl, rescan will 15306426c7adSQu Wenruo * kick in anyway. 15316426c7adSQu Wenruo */ 15329ea6e2b5SDavid Sterba if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags)) 15336426c7adSQu Wenruo return 0; 15346426c7adSQu Wenruo 15356426c7adSQu Wenruo /* 153652042d8eSAndrea Gelmini * Ensure dirty @src will be committed. Or, after coming 15374d31778aSQu Wenruo * commit_fs_roots() and switch_commit_roots(), any dirty but not 15384d31778aSQu Wenruo * recorded root will never be updated again, causing an outdated root 15394d31778aSQu Wenruo * item. 15404d31778aSQu Wenruo */ 15411c442d22SJosef Bacik ret = record_root_in_trans(trans, src, 1); 15421c442d22SJosef Bacik if (ret) 15431c442d22SJosef Bacik return ret; 15444d31778aSQu Wenruo 15454d31778aSQu Wenruo /* 15462a4d84c1SJosef Bacik * btrfs_qgroup_inherit relies on a consistent view of the usage for the 15472a4d84c1SJosef Bacik * src root, so we must run the delayed refs here. 15482a4d84c1SJosef Bacik * 15492a4d84c1SJosef Bacik * However this isn't particularly fool proof, because there's no 15502a4d84c1SJosef Bacik * synchronization keeping us from changing the tree after this point 15512a4d84c1SJosef Bacik * before we do the qgroup_inherit, or even from making changes while 15522a4d84c1SJosef Bacik * we're doing the qgroup_inherit. But that's a problem for the future, 15532a4d84c1SJosef Bacik * for now flush the delayed refs to narrow the race window where the 15542a4d84c1SJosef Bacik * qgroup counters could end up wrong. 15552a4d84c1SJosef Bacik */ 15562a4d84c1SJosef Bacik ret = btrfs_run_delayed_refs(trans, (unsigned long)-1); 15572a4d84c1SJosef Bacik if (ret) { 15582a4d84c1SJosef Bacik btrfs_abort_transaction(trans, ret); 155944365827SNaohiro Aota return ret; 15602a4d84c1SJosef Bacik } 15612a4d84c1SJosef Bacik 15627e4443d9SNikolay Borisov ret = commit_fs_roots(trans); 15636426c7adSQu Wenruo if (ret) 15646426c7adSQu Wenruo goto out; 1565460fb20aSNikolay Borisov ret = btrfs_qgroup_account_extents(trans); 15666426c7adSQu Wenruo if (ret < 0) 15676426c7adSQu Wenruo goto out; 15686426c7adSQu Wenruo 15696426c7adSQu Wenruo /* Now qgroup are all updated, we can inherit it to new qgroups */ 1570a9377422SLu Fengqi ret = btrfs_qgroup_inherit(trans, src->root_key.objectid, dst_objectid, 15716426c7adSQu Wenruo inherit); 15726426c7adSQu Wenruo if (ret < 0) 15736426c7adSQu Wenruo goto out; 15746426c7adSQu Wenruo 15756426c7adSQu Wenruo /* 15766426c7adSQu Wenruo * Now we do a simplified commit transaction, which will: 15776426c7adSQu Wenruo * 1) commit all subvolume and extent tree 15786426c7adSQu Wenruo * To ensure all subvolume and extent tree have a valid 15796426c7adSQu Wenruo * commit_root to accounting later insert_dir_item() 15806426c7adSQu Wenruo * 2) write all btree blocks onto disk 15816426c7adSQu Wenruo * This is to make sure later btree modification will be cowed 15826426c7adSQu Wenruo * Or commit_root can be populated and cause wrong qgroup numbers 15836426c7adSQu Wenruo * In this simplified commit, we don't really care about other trees 15846426c7adSQu Wenruo * like chunk and root tree, as they won't affect qgroup. 15856426c7adSQu Wenruo * And we don't write super to avoid half committed status. 15866426c7adSQu Wenruo */ 15879386d8bcSNikolay Borisov ret = commit_cowonly_roots(trans); 15886426c7adSQu Wenruo if (ret) 15896426c7adSQu Wenruo goto out; 1590889bfa39SJosef Bacik switch_commit_roots(trans); 159170458a58SNikolay Borisov ret = btrfs_write_and_wait_transaction(trans); 15926426c7adSQu Wenruo if (ret) 1593f7af3934SDavid Sterba btrfs_handle_fs_error(fs_info, ret, 15946426c7adSQu Wenruo "Error while writing out transaction for qgroup"); 15956426c7adSQu Wenruo 15966426c7adSQu Wenruo out: 15976426c7adSQu Wenruo /* 15986426c7adSQu Wenruo * Force parent root to be updated, as we recorded it before so its 15996426c7adSQu Wenruo * last_trans == cur_transid. 16006426c7adSQu Wenruo * Or it won't be committed again onto disk after later 16016426c7adSQu Wenruo * insert_dir_item() 16026426c7adSQu Wenruo */ 16036426c7adSQu Wenruo if (!ret) 16041c442d22SJosef Bacik ret = record_root_in_trans(trans, parent, 1); 16056426c7adSQu Wenruo return ret; 16066426c7adSQu Wenruo } 16076426c7adSQu Wenruo 16086426c7adSQu Wenruo /* 1609d352ac68SChris Mason * new snapshots need to be created at a very specific time in the 1610aec8030aSMiao Xie * transaction commit. This does the actual creation. 1611aec8030aSMiao Xie * 1612aec8030aSMiao Xie * Note: 1613aec8030aSMiao Xie * If the error which may affect the commitment of the current transaction 1614aec8030aSMiao Xie * happens, we should return the error number. If the error which just affect 1615aec8030aSMiao Xie * the creation of the pending snapshots, just return 0. 1616d352ac68SChris Mason */ 161780b6794dSChris Mason static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans, 16183063d29fSChris Mason struct btrfs_pending_snapshot *pending) 16193063d29fSChris Mason { 162008d50ca3SNikolay Borisov 162108d50ca3SNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 16223063d29fSChris Mason struct btrfs_key key; 162380b6794dSChris Mason struct btrfs_root_item *new_root_item; 16243063d29fSChris Mason struct btrfs_root *tree_root = fs_info->tree_root; 16253063d29fSChris Mason struct btrfs_root *root = pending->root; 16266bdb72deSSage Weil struct btrfs_root *parent_root; 162798c9942aSLiu Bo struct btrfs_block_rsv *rsv; 16286bdb72deSSage Weil struct inode *parent_inode; 162942874b3dSMiao Xie struct btrfs_path *path; 163042874b3dSMiao Xie struct btrfs_dir_item *dir_item; 1631a22285a6SYan, Zheng struct dentry *dentry; 16323063d29fSChris Mason struct extent_buffer *tmp; 1633925baeddSChris Mason struct extent_buffer *old; 163495582b00SDeepa Dinamani struct timespec64 cur_time; 1635aec8030aSMiao Xie int ret = 0; 1636d68fc57bSYan, Zheng u64 to_reserve = 0; 16376bdb72deSSage Weil u64 index = 0; 1638a22285a6SYan, Zheng u64 objectid; 1639b83cc969SLi Zefan u64 root_flags; 16403063d29fSChris Mason 16418546b570SDavid Sterba ASSERT(pending->path); 16428546b570SDavid Sterba path = pending->path; 164342874b3dSMiao Xie 1644b0c0ea63SDavid Sterba ASSERT(pending->root_item); 1645b0c0ea63SDavid Sterba new_root_item = pending->root_item; 1646a22285a6SYan, Zheng 1647543068a2SNikolay Borisov pending->error = btrfs_get_free_objectid(tree_root, &objectid); 1648aec8030aSMiao Xie if (pending->error) 16496fa9700eSMiao Xie goto no_free_objectid; 16503063d29fSChris Mason 1651d6726335SQu Wenruo /* 1652d6726335SQu Wenruo * Make qgroup to skip current new snapshot's qgroupid, as it is 1653d6726335SQu Wenruo * accounted by later btrfs_qgroup_inherit(). 1654d6726335SQu Wenruo */ 1655d6726335SQu Wenruo btrfs_set_skip_qgroup(trans, objectid); 1656d6726335SQu Wenruo 1657147d256eSZhaolei btrfs_reloc_pre_snapshot(pending, &to_reserve); 1658d68fc57bSYan, Zheng 1659d68fc57bSYan, Zheng if (to_reserve > 0) { 16609270501cSJosef Bacik pending->error = btrfs_block_rsv_add(fs_info, 1661aec8030aSMiao Xie &pending->block_rsv, 166208e007d2SMiao Xie to_reserve, 166308e007d2SMiao Xie BTRFS_RESERVE_NO_FLUSH); 1664aec8030aSMiao Xie if (pending->error) 1665d6726335SQu Wenruo goto clear_skip_qgroup; 1666d68fc57bSYan, Zheng } 1667d68fc57bSYan, Zheng 16683063d29fSChris Mason key.objectid = objectid; 1669a22285a6SYan, Zheng key.offset = (u64)-1; 1670a22285a6SYan, Zheng key.type = BTRFS_ROOT_ITEM_KEY; 16713063d29fSChris Mason 16726fa9700eSMiao Xie rsv = trans->block_rsv; 1673a22285a6SYan, Zheng trans->block_rsv = &pending->block_rsv; 16742382c5ccSLiu Bo trans->bytes_reserved = trans->block_rsv->reserved; 16750b246afaSJeff Mahoney trace_btrfs_space_reservation(fs_info, "transaction", 167688d3a5aaSJosef Bacik trans->transid, 167788d3a5aaSJosef Bacik trans->bytes_reserved, 1); 1678a22285a6SYan, Zheng dentry = pending->dentry; 1679e9662f70SMiao Xie parent_inode = pending->dir; 1680a22285a6SYan, Zheng parent_root = BTRFS_I(parent_inode)->root; 1681f0118cb6SJosef Bacik ret = record_root_in_trans(trans, parent_root, 0); 1682f0118cb6SJosef Bacik if (ret) 1683f0118cb6SJosef Bacik goto fail; 1684c2050a45SDeepa Dinamani cur_time = current_time(parent_inode); 168504b285f3SDeepa Dinamani 16866bdb72deSSage Weil /* 16876bdb72deSSage Weil * insert the directory item 16886bdb72deSSage Weil */ 1689877574e2SNikolay Borisov ret = btrfs_set_inode_index(BTRFS_I(parent_inode), &index); 169049b25e05SJeff Mahoney BUG_ON(ret); /* -ENOMEM */ 169142874b3dSMiao Xie 169242874b3dSMiao Xie /* check if there is a file/dir which has the same name. */ 169342874b3dSMiao Xie dir_item = btrfs_lookup_dir_item(NULL, parent_root, path, 16944a0cc7caSNikolay Borisov btrfs_ino(BTRFS_I(parent_inode)), 169542874b3dSMiao Xie dentry->d_name.name, 169642874b3dSMiao Xie dentry->d_name.len, 0); 169742874b3dSMiao Xie if (dir_item != NULL && !IS_ERR(dir_item)) { 1698fe66a05aSChris Mason pending->error = -EEXIST; 1699aec8030aSMiao Xie goto dir_item_existed; 170042874b3dSMiao Xie } else if (IS_ERR(dir_item)) { 170142874b3dSMiao Xie ret = PTR_ERR(dir_item); 170266642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 17038732d44fSMiao Xie goto fail; 170479787eaaSJeff Mahoney } 170542874b3dSMiao Xie btrfs_release_path(path); 17066bdb72deSSage Weil 1707e999376fSChris Mason /* 1708e999376fSChris Mason * pull in the delayed directory update 1709e999376fSChris Mason * and the delayed inode item 1710e999376fSChris Mason * otherwise we corrupt the FS during 1711e999376fSChris Mason * snapshot 1712e999376fSChris Mason */ 1713e5c304e6SNikolay Borisov ret = btrfs_run_delayed_items(trans); 17148732d44fSMiao Xie if (ret) { /* Transaction aborted */ 171566642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 17168732d44fSMiao Xie goto fail; 17178732d44fSMiao Xie } 1718e999376fSChris Mason 1719f0118cb6SJosef Bacik ret = record_root_in_trans(trans, root, 0); 1720f0118cb6SJosef Bacik if (ret) { 1721f0118cb6SJosef Bacik btrfs_abort_transaction(trans, ret); 1722f0118cb6SJosef Bacik goto fail; 1723f0118cb6SJosef Bacik } 17246bdb72deSSage Weil btrfs_set_root_last_snapshot(&root->root_item, trans->transid); 17256bdb72deSSage Weil memcpy(new_root_item, &root->root_item, sizeof(*new_root_item)); 172608fe4db1SLi Zefan btrfs_check_and_init_root_item(new_root_item); 17276bdb72deSSage Weil 1728b83cc969SLi Zefan root_flags = btrfs_root_flags(new_root_item); 1729b83cc969SLi Zefan if (pending->readonly) 1730b83cc969SLi Zefan root_flags |= BTRFS_ROOT_SUBVOL_RDONLY; 1731b83cc969SLi Zefan else 1732b83cc969SLi Zefan root_flags &= ~BTRFS_ROOT_SUBVOL_RDONLY; 1733b83cc969SLi Zefan btrfs_set_root_flags(new_root_item, root_flags); 1734b83cc969SLi Zefan 17358ea05e3aSAlexander Block btrfs_set_root_generation_v2(new_root_item, 17368ea05e3aSAlexander Block trans->transid); 1737807fc790SAndy Shevchenko generate_random_guid(new_root_item->uuid); 17388ea05e3aSAlexander Block memcpy(new_root_item->parent_uuid, root->root_item.uuid, 17398ea05e3aSAlexander Block BTRFS_UUID_SIZE); 174070023da2SStefan Behrens if (!(root_flags & BTRFS_ROOT_SUBVOL_RDONLY)) { 174170023da2SStefan Behrens memset(new_root_item->received_uuid, 0, 174270023da2SStefan Behrens sizeof(new_root_item->received_uuid)); 17438ea05e3aSAlexander Block memset(&new_root_item->stime, 0, sizeof(new_root_item->stime)); 17448ea05e3aSAlexander Block memset(&new_root_item->rtime, 0, sizeof(new_root_item->rtime)); 17458ea05e3aSAlexander Block btrfs_set_root_stransid(new_root_item, 0); 17468ea05e3aSAlexander Block btrfs_set_root_rtransid(new_root_item, 0); 174770023da2SStefan Behrens } 17483cae210fSQu Wenruo btrfs_set_stack_timespec_sec(&new_root_item->otime, cur_time.tv_sec); 17493cae210fSQu Wenruo btrfs_set_stack_timespec_nsec(&new_root_item->otime, cur_time.tv_nsec); 175070023da2SStefan Behrens btrfs_set_root_otransid(new_root_item, trans->transid); 17518ea05e3aSAlexander Block 1752925baeddSChris Mason old = btrfs_lock_root_node(root); 17539631e4ccSJosef Bacik ret = btrfs_cow_block(trans, root, old, NULL, 0, &old, 17549631e4ccSJosef Bacik BTRFS_NESTING_COW); 175579787eaaSJeff Mahoney if (ret) { 175679787eaaSJeff Mahoney btrfs_tree_unlock(old); 175779787eaaSJeff Mahoney free_extent_buffer(old); 175866642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 17598732d44fSMiao Xie goto fail; 176079787eaaSJeff Mahoney } 176149b25e05SJeff Mahoney 176249b25e05SJeff Mahoney ret = btrfs_copy_root(trans, root, old, &tmp, objectid); 176379787eaaSJeff Mahoney /* clean up in any case */ 1764925baeddSChris Mason btrfs_tree_unlock(old); 1765925baeddSChris Mason free_extent_buffer(old); 17668732d44fSMiao Xie if (ret) { 176766642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 17688732d44fSMiao Xie goto fail; 17698732d44fSMiao Xie } 1770f1ebcc74SLiu Bo /* see comments in should_cow_block() */ 177127cdeb70SMiao Xie set_bit(BTRFS_ROOT_FORCE_COW, &root->state); 1772f1ebcc74SLiu Bo smp_wmb(); 1773f1ebcc74SLiu Bo 17745d4f98a2SYan Zheng btrfs_set_root_node(new_root_item, tmp); 1775a22285a6SYan, Zheng /* record when the snapshot was created in key.offset */ 1776a22285a6SYan, Zheng key.offset = trans->transid; 1777a22285a6SYan, Zheng ret = btrfs_insert_root(trans, tree_root, &key, new_root_item); 1778925baeddSChris Mason btrfs_tree_unlock(tmp); 17793063d29fSChris Mason free_extent_buffer(tmp); 17808732d44fSMiao Xie if (ret) { 178166642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 17828732d44fSMiao Xie goto fail; 17838732d44fSMiao Xie } 17840660b5afSChris Mason 1785a22285a6SYan, Zheng /* 1786a22285a6SYan, Zheng * insert root back/forward references 1787a22285a6SYan, Zheng */ 17886025c19fSLu Fengqi ret = btrfs_add_root_ref(trans, objectid, 1789a22285a6SYan, Zheng parent_root->root_key.objectid, 17904a0cc7caSNikolay Borisov btrfs_ino(BTRFS_I(parent_inode)), index, 1791a22285a6SYan, Zheng dentry->d_name.name, dentry->d_name.len); 17928732d44fSMiao Xie if (ret) { 179366642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 17948732d44fSMiao Xie goto fail; 17958732d44fSMiao Xie } 1796a22285a6SYan, Zheng 1797a22285a6SYan, Zheng key.offset = (u64)-1; 17982dfb1e43SQu Wenruo pending->snap = btrfs_get_new_fs_root(fs_info, objectid, pending->anon_dev); 179979787eaaSJeff Mahoney if (IS_ERR(pending->snap)) { 180079787eaaSJeff Mahoney ret = PTR_ERR(pending->snap); 18012d892ccdSFilipe Manana pending->snap = NULL; 180266642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 18038732d44fSMiao Xie goto fail; 180479787eaaSJeff Mahoney } 1805d68fc57bSYan, Zheng 180649b25e05SJeff Mahoney ret = btrfs_reloc_post_snapshot(trans, pending); 18078732d44fSMiao Xie if (ret) { 180866642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 18098732d44fSMiao Xie goto fail; 18108732d44fSMiao Xie } 1811361048f5SMiao Xie 18126426c7adSQu Wenruo /* 18136426c7adSQu Wenruo * Do special qgroup accounting for snapshot, as we do some qgroup 18146426c7adSQu Wenruo * snapshot hack to do fast snapshot. 18156426c7adSQu Wenruo * To co-operate with that hack, we do hack again. 18166426c7adSQu Wenruo * Or snapshot will be greatly slowed down by a subtree qgroup rescan 18176426c7adSQu Wenruo */ 18186426c7adSQu Wenruo ret = qgroup_account_snapshot(trans, root, parent_root, 18196426c7adSQu Wenruo pending->inherit, objectid); 18206426c7adSQu Wenruo if (ret < 0) 18216426c7adSQu Wenruo goto fail; 18226426c7adSQu Wenruo 1823684572dfSLu Fengqi ret = btrfs_insert_dir_item(trans, dentry->d_name.name, 1824684572dfSLu Fengqi dentry->d_name.len, BTRFS_I(parent_inode), 1825684572dfSLu Fengqi &key, BTRFS_FT_DIR, index); 182642874b3dSMiao Xie /* We have check then name at the beginning, so it is impossible. */ 18279c52057cSChris Mason BUG_ON(ret == -EEXIST || ret == -EOVERFLOW); 18288732d44fSMiao Xie if (ret) { 182966642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 18308732d44fSMiao Xie goto fail; 18318732d44fSMiao Xie } 183242874b3dSMiao Xie 18336ef06d27SNikolay Borisov btrfs_i_size_write(BTRFS_I(parent_inode), parent_inode->i_size + 183442874b3dSMiao Xie dentry->d_name.len * 2); 1835*c1867eb3SDavid Sterba parent_inode->i_mtime = current_time(parent_inode); 1836*c1867eb3SDavid Sterba parent_inode->i_ctime = parent_inode->i_mtime; 1837729f7961SNikolay Borisov ret = btrfs_update_inode_fallback(trans, parent_root, BTRFS_I(parent_inode)); 1838dd5f9615SStefan Behrens if (ret) { 183966642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 1840dd5f9615SStefan Behrens goto fail; 1841dd5f9615SStefan Behrens } 1842807fc790SAndy Shevchenko ret = btrfs_uuid_tree_add(trans, new_root_item->uuid, 1843807fc790SAndy Shevchenko BTRFS_UUID_KEY_SUBVOL, 1844cdb345a8SLu Fengqi objectid); 1845dd5f9615SStefan Behrens if (ret) { 184666642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 1847dd5f9615SStefan Behrens goto fail; 1848dd5f9615SStefan Behrens } 1849dd5f9615SStefan Behrens if (!btrfs_is_empty_uuid(new_root_item->received_uuid)) { 1850cdb345a8SLu Fengqi ret = btrfs_uuid_tree_add(trans, new_root_item->received_uuid, 1851dd5f9615SStefan Behrens BTRFS_UUID_KEY_RECEIVED_SUBVOL, 1852dd5f9615SStefan Behrens objectid); 1853dd5f9615SStefan Behrens if (ret && ret != -EEXIST) { 185466642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 1855dd5f9615SStefan Behrens goto fail; 1856dd5f9615SStefan Behrens } 1857dd5f9615SStefan Behrens } 1858d6726335SQu Wenruo 18593063d29fSChris Mason fail: 1860aec8030aSMiao Xie pending->error = ret; 1861aec8030aSMiao Xie dir_item_existed: 186298c9942aSLiu Bo trans->block_rsv = rsv; 18632382c5ccSLiu Bo trans->bytes_reserved = 0; 1864d6726335SQu Wenruo clear_skip_qgroup: 1865d6726335SQu Wenruo btrfs_clear_skip_qgroup(trans); 18666fa9700eSMiao Xie no_free_objectid: 18676fa9700eSMiao Xie kfree(new_root_item); 1868b0c0ea63SDavid Sterba pending->root_item = NULL; 186942874b3dSMiao Xie btrfs_free_path(path); 18708546b570SDavid Sterba pending->path = NULL; 18718546b570SDavid Sterba 187249b25e05SJeff Mahoney return ret; 18733063d29fSChris Mason } 18743063d29fSChris Mason 1875d352ac68SChris Mason /* 1876d352ac68SChris Mason * create all the snapshots we've scheduled for creation 1877d352ac68SChris Mason */ 187808d50ca3SNikolay Borisov static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans) 18793063d29fSChris Mason { 1880aec8030aSMiao Xie struct btrfs_pending_snapshot *pending, *next; 18813063d29fSChris Mason struct list_head *head = &trans->transaction->pending_snapshots; 1882aec8030aSMiao Xie int ret = 0; 18833de4586cSChris Mason 1884aec8030aSMiao Xie list_for_each_entry_safe(pending, next, head, list) { 1885aec8030aSMiao Xie list_del(&pending->list); 188608d50ca3SNikolay Borisov ret = create_pending_snapshot(trans, pending); 1887aec8030aSMiao Xie if (ret) 1888aec8030aSMiao Xie break; 1889aec8030aSMiao Xie } 1890aec8030aSMiao Xie return ret; 18913de4586cSChris Mason } 18923de4586cSChris Mason 18932ff7e61eSJeff Mahoney static void update_super_roots(struct btrfs_fs_info *fs_info) 18945d4f98a2SYan Zheng { 18955d4f98a2SYan Zheng struct btrfs_root_item *root_item; 18965d4f98a2SYan Zheng struct btrfs_super_block *super; 18975d4f98a2SYan Zheng 18980b246afaSJeff Mahoney super = fs_info->super_copy; 18995d4f98a2SYan Zheng 19000b246afaSJeff Mahoney root_item = &fs_info->chunk_root->root_item; 1901093e037cSDavid Sterba super->chunk_root = root_item->bytenr; 1902093e037cSDavid Sterba super->chunk_root_generation = root_item->generation; 1903093e037cSDavid Sterba super->chunk_root_level = root_item->level; 19045d4f98a2SYan Zheng 19050b246afaSJeff Mahoney root_item = &fs_info->tree_root->root_item; 1906093e037cSDavid Sterba super->root = root_item->bytenr; 1907093e037cSDavid Sterba super->generation = root_item->generation; 1908093e037cSDavid Sterba super->root_level = root_item->level; 19090b246afaSJeff Mahoney if (btrfs_test_opt(fs_info, SPACE_CACHE)) 1910093e037cSDavid Sterba super->cache_generation = root_item->generation; 191194846229SBoris Burkov else if (test_bit(BTRFS_FS_CLEANUP_SPACE_CACHE_V1, &fs_info->flags)) 191294846229SBoris Burkov super->cache_generation = 0; 19130b246afaSJeff Mahoney if (test_bit(BTRFS_FS_UPDATE_UUID_TREE_GEN, &fs_info->flags)) 1914093e037cSDavid Sterba super->uuid_tree_generation = root_item->generation; 1915f7238e50SJosef Bacik 1916f7238e50SJosef Bacik if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2)) { 1917f7238e50SJosef Bacik root_item = &fs_info->block_group_root->root_item; 1918f7238e50SJosef Bacik 1919f7238e50SJosef Bacik super->block_group_root = root_item->bytenr; 1920f7238e50SJosef Bacik super->block_group_root_generation = root_item->generation; 1921f7238e50SJosef Bacik super->block_group_root_level = root_item->level; 1922f7238e50SJosef Bacik } 19235d4f98a2SYan Zheng } 19245d4f98a2SYan Zheng 1925f36f3042SChris Mason int btrfs_transaction_in_commit(struct btrfs_fs_info *info) 1926f36f3042SChris Mason { 19274a9d8bdeSMiao Xie struct btrfs_transaction *trans; 1928f36f3042SChris Mason int ret = 0; 19294a9d8bdeSMiao Xie 1930a4abeea4SJosef Bacik spin_lock(&info->trans_lock); 19314a9d8bdeSMiao Xie trans = info->running_transaction; 19324a9d8bdeSMiao Xie if (trans) 19334a9d8bdeSMiao Xie ret = (trans->state >= TRANS_STATE_COMMIT_START); 1934a4abeea4SJosef Bacik spin_unlock(&info->trans_lock); 1935f36f3042SChris Mason return ret; 1936f36f3042SChris Mason } 1937f36f3042SChris Mason 19388929ecfaSYan, Zheng int btrfs_transaction_blocked(struct btrfs_fs_info *info) 19398929ecfaSYan, Zheng { 19404a9d8bdeSMiao Xie struct btrfs_transaction *trans; 19418929ecfaSYan, Zheng int ret = 0; 19424a9d8bdeSMiao Xie 1943a4abeea4SJosef Bacik spin_lock(&info->trans_lock); 19444a9d8bdeSMiao Xie trans = info->running_transaction; 19454a9d8bdeSMiao Xie if (trans) 19464a9d8bdeSMiao Xie ret = is_transaction_blocked(trans); 1947a4abeea4SJosef Bacik spin_unlock(&info->trans_lock); 19488929ecfaSYan, Zheng return ret; 19498929ecfaSYan, Zheng } 19508929ecfaSYan, Zheng 1951fdfbf020SJosef Bacik void btrfs_commit_transaction_async(struct btrfs_trans_handle *trans) 1952bb9c12c9SSage Weil { 19533a45bb20SJeff Mahoney struct btrfs_fs_info *fs_info = trans->fs_info; 1954bb9c12c9SSage Weil struct btrfs_transaction *cur_trans; 1955bb9c12c9SSage Weil 1956fdfbf020SJosef Bacik /* Kick the transaction kthread. */ 1957fdfbf020SJosef Bacik set_bit(BTRFS_FS_COMMIT_TRANS, &fs_info->flags); 1958fdfbf020SJosef Bacik wake_up_process(fs_info->transaction_kthread); 1959bb9c12c9SSage Weil 1960bb9c12c9SSage Weil /* take transaction reference */ 1961bb9c12c9SSage Weil cur_trans = trans->transaction; 19629b64f57dSElena Reshetova refcount_inc(&cur_trans->use_count); 1963bb9c12c9SSage Weil 19643a45bb20SJeff Mahoney btrfs_end_transaction(trans); 19656fc4e354SSage Weil 19666fc4e354SSage Weil /* 1967ae5d29d4SDavid Sterba * Wait for the current transaction commit to start and block 1968ae5d29d4SDavid Sterba * subsequent transaction joins 1969ae5d29d4SDavid Sterba */ 1970ae5d29d4SDavid Sterba wait_event(fs_info->transaction_blocked_wait, 1971ae5d29d4SDavid Sterba cur_trans->state >= TRANS_STATE_COMMIT_START || 1972ae5d29d4SDavid Sterba TRANS_ABORTED(cur_trans)); 1973724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 1974bb9c12c9SSage Weil } 1975bb9c12c9SSage Weil 197697cb39bbSNikolay Borisov static void cleanup_transaction(struct btrfs_trans_handle *trans, int err) 197749b25e05SJeff Mahoney { 197897cb39bbSNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 197949b25e05SJeff Mahoney struct btrfs_transaction *cur_trans = trans->transaction; 198049b25e05SJeff Mahoney 1981b50fff81SDavid Sterba WARN_ON(refcount_read(&trans->use_count) > 1); 198249b25e05SJeff Mahoney 198366642832SJeff Mahoney btrfs_abort_transaction(trans, err); 19847b8b92afSJosef Bacik 19850b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 198666b6135bSLiu Bo 198725d8c284SMiao Xie /* 198825d8c284SMiao Xie * If the transaction is removed from the list, it means this 198925d8c284SMiao Xie * transaction has been committed successfully, so it is impossible 199025d8c284SMiao Xie * to call the cleanup function. 199125d8c284SMiao Xie */ 199225d8c284SMiao Xie BUG_ON(list_empty(&cur_trans->list)); 199366b6135bSLiu Bo 19940b246afaSJeff Mahoney if (cur_trans == fs_info->running_transaction) { 19954a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_COMMIT_DOING; 19960b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 1997f094ac32SLiu Bo wait_event(cur_trans->writer_wait, 1998f094ac32SLiu Bo atomic_read(&cur_trans->num_writers) == 1); 1999f094ac32SLiu Bo 20000b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 2001d7096fc3SJosef Bacik } 2002061dde82SFilipe Manana 2003061dde82SFilipe Manana /* 2004061dde82SFilipe Manana * Now that we know no one else is still using the transaction we can 2005061dde82SFilipe Manana * remove the transaction from the list of transactions. This avoids 2006061dde82SFilipe Manana * the transaction kthread from cleaning up the transaction while some 2007061dde82SFilipe Manana * other task is still using it, which could result in a use-after-free 2008061dde82SFilipe Manana * on things like log trees, as it forces the transaction kthread to 2009061dde82SFilipe Manana * wait for this transaction to be cleaned up by us. 2010061dde82SFilipe Manana */ 2011061dde82SFilipe Manana list_del_init(&cur_trans->list); 2012061dde82SFilipe Manana 20130b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 201449b25e05SJeff Mahoney 20152ff7e61eSJeff Mahoney btrfs_cleanup_one_transaction(trans->transaction, fs_info); 201649b25e05SJeff Mahoney 20170b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 20180b246afaSJeff Mahoney if (cur_trans == fs_info->running_transaction) 20190b246afaSJeff Mahoney fs_info->running_transaction = NULL; 20200b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 20214a9d8bdeSMiao Xie 2022e0228285SJosef Bacik if (trans->type & __TRANS_FREEZABLE) 20230b246afaSJeff Mahoney sb_end_intwrite(fs_info->sb); 2024724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 2025724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 202649b25e05SJeff Mahoney 20272e4e97abSJosef Bacik trace_btrfs_transaction_commit(fs_info); 202849b25e05SJeff Mahoney 202949b25e05SJeff Mahoney if (current->journal_info == trans) 203049b25e05SJeff Mahoney current->journal_info = NULL; 20310b246afaSJeff Mahoney btrfs_scrub_cancel(fs_info); 203249b25e05SJeff Mahoney 203349b25e05SJeff Mahoney kmem_cache_free(btrfs_trans_handle_cachep, trans); 203449b25e05SJeff Mahoney } 203549b25e05SJeff Mahoney 2036c7cc64a9SDavid Sterba /* 2037c7cc64a9SDavid Sterba * Release reserved delayed ref space of all pending block groups of the 2038c7cc64a9SDavid Sterba * transaction and remove them from the list 2039c7cc64a9SDavid Sterba */ 2040c7cc64a9SDavid Sterba static void btrfs_cleanup_pending_block_groups(struct btrfs_trans_handle *trans) 2041c7cc64a9SDavid Sterba { 2042c7cc64a9SDavid Sterba struct btrfs_fs_info *fs_info = trans->fs_info; 204332da5386SDavid Sterba struct btrfs_block_group *block_group, *tmp; 2044c7cc64a9SDavid Sterba 2045c7cc64a9SDavid Sterba list_for_each_entry_safe(block_group, tmp, &trans->new_bgs, bg_list) { 2046c7cc64a9SDavid Sterba btrfs_delayed_refs_rsv_release(fs_info, 1); 2047c7cc64a9SDavid Sterba list_del_init(&block_group->bg_list); 2048c7cc64a9SDavid Sterba } 2049c7cc64a9SDavid Sterba } 2050c7cc64a9SDavid Sterba 205188090ad3SFilipe Manana static inline int btrfs_start_delalloc_flush(struct btrfs_fs_info *fs_info) 205282436617SMiao Xie { 2053ce8ea7ccSJosef Bacik /* 2054a0f0cf83SFilipe Manana * We use try_to_writeback_inodes_sb() here because if we used 2055ce8ea7ccSJosef Bacik * btrfs_start_delalloc_roots we would deadlock with fs freeze. 2056ce8ea7ccSJosef Bacik * Currently are holding the fs freeze lock, if we do an async flush 2057ce8ea7ccSJosef Bacik * we'll do btrfs_join_transaction() and deadlock because we need to 2058ce8ea7ccSJosef Bacik * wait for the fs freeze lock. Using the direct flushing we benefit 2059ce8ea7ccSJosef Bacik * from already being in a transaction and our join_transaction doesn't 2060ce8ea7ccSJosef Bacik * have to re-take the fs freeze lock. 2061a0f0cf83SFilipe Manana * 2062a0f0cf83SFilipe Manana * Note that try_to_writeback_inodes_sb() will only trigger writeback 2063a0f0cf83SFilipe Manana * if it can read lock sb->s_umount. It will always be able to lock it, 2064a0f0cf83SFilipe Manana * except when the filesystem is being unmounted or being frozen, but in 2065a0f0cf83SFilipe Manana * those cases sync_filesystem() is called, which results in calling 2066a0f0cf83SFilipe Manana * writeback_inodes_sb() while holding a write lock on sb->s_umount. 2067a0f0cf83SFilipe Manana * Note that we don't call writeback_inodes_sb() directly, because it 2068a0f0cf83SFilipe Manana * will emit a warning if sb->s_umount is not locked. 2069ce8ea7ccSJosef Bacik */ 207088090ad3SFilipe Manana if (btrfs_test_opt(fs_info, FLUSHONCOMMIT)) 2071a0f0cf83SFilipe Manana try_to_writeback_inodes_sb(fs_info->sb, WB_REASON_SYNC); 207282436617SMiao Xie return 0; 207382436617SMiao Xie } 207482436617SMiao Xie 207588090ad3SFilipe Manana static inline void btrfs_wait_delalloc_flush(struct btrfs_fs_info *fs_info) 207682436617SMiao Xie { 207788090ad3SFilipe Manana if (btrfs_test_opt(fs_info, FLUSHONCOMMIT)) 20786374e57aSChris Mason btrfs_wait_ordered_roots(fs_info, U64_MAX, 0, (u64)-1); 207982436617SMiao Xie } 208082436617SMiao Xie 208128b21c55SFilipe Manana /* 208228b21c55SFilipe Manana * Add a pending snapshot associated with the given transaction handle to the 208328b21c55SFilipe Manana * respective handle. This must be called after the transaction commit started 208428b21c55SFilipe Manana * and while holding fs_info->trans_lock. 208528b21c55SFilipe Manana * This serves to guarantee a caller of btrfs_commit_transaction() that it can 208628b21c55SFilipe Manana * safely free the pending snapshot pointer in case btrfs_commit_transaction() 208728b21c55SFilipe Manana * returns an error. 208828b21c55SFilipe Manana */ 208928b21c55SFilipe Manana static void add_pending_snapshot(struct btrfs_trans_handle *trans) 209028b21c55SFilipe Manana { 209128b21c55SFilipe Manana struct btrfs_transaction *cur_trans = trans->transaction; 209228b21c55SFilipe Manana 209328b21c55SFilipe Manana if (!trans->pending_snapshot) 209428b21c55SFilipe Manana return; 209528b21c55SFilipe Manana 209628b21c55SFilipe Manana lockdep_assert_held(&trans->fs_info->trans_lock); 209728b21c55SFilipe Manana ASSERT(cur_trans->state >= TRANS_STATE_COMMIT_START); 209828b21c55SFilipe Manana 209928b21c55SFilipe Manana list_add(&trans->pending_snapshot->list, &cur_trans->pending_snapshots); 210028b21c55SFilipe Manana } 210128b21c55SFilipe Manana 2102e55958c8SIoannis Angelakopoulos static void update_commit_stats(struct btrfs_fs_info *fs_info, ktime_t interval) 2103e55958c8SIoannis Angelakopoulos { 2104e55958c8SIoannis Angelakopoulos fs_info->commit_stats.commit_count++; 2105e55958c8SIoannis Angelakopoulos fs_info->commit_stats.last_commit_dur = interval; 2106e55958c8SIoannis Angelakopoulos fs_info->commit_stats.max_commit_dur = 2107e55958c8SIoannis Angelakopoulos max_t(u64, fs_info->commit_stats.max_commit_dur, interval); 2108e55958c8SIoannis Angelakopoulos fs_info->commit_stats.total_commit_dur += interval; 2109e55958c8SIoannis Angelakopoulos } 2110e55958c8SIoannis Angelakopoulos 21113a45bb20SJeff Mahoney int btrfs_commit_transaction(struct btrfs_trans_handle *trans) 211279154b1bSChris Mason { 21133a45bb20SJeff Mahoney struct btrfs_fs_info *fs_info = trans->fs_info; 211449b25e05SJeff Mahoney struct btrfs_transaction *cur_trans = trans->transaction; 21158fd17795SChris Mason struct btrfs_transaction *prev_trans = NULL; 211625287e0aSMiao Xie int ret; 2117e55958c8SIoannis Angelakopoulos ktime_t start_time; 2118e55958c8SIoannis Angelakopoulos ktime_t interval; 211979154b1bSChris Mason 212035b814f3SNikolay Borisov ASSERT(refcount_read(&trans->use_count) == 1); 212135b814f3SNikolay Borisov 21228d25a086SMiao Xie /* Stop the commit early if ->aborted is set */ 2123bf31f87fSDavid Sterba if (TRANS_ABORTED(cur_trans)) { 212425287e0aSMiao Xie ret = cur_trans->aborted; 21253a45bb20SJeff Mahoney btrfs_end_transaction(trans); 2126e4a2bcacSJosef Bacik return ret; 212725287e0aSMiao Xie } 212849b25e05SJeff Mahoney 2129f45c752bSJosef Bacik btrfs_trans_release_metadata(trans); 2130f45c752bSJosef Bacik trans->block_rsv = NULL; 2131f45c752bSJosef Bacik 2132e19eb11fSJosef Bacik /* 2133e19eb11fSJosef Bacik * We only want one transaction commit doing the flushing so we do not 2134e19eb11fSJosef Bacik * waste a bunch of time on lock contention on the extent root node. 2135e19eb11fSJosef Bacik */ 2136e19eb11fSJosef Bacik if (!test_and_set_bit(BTRFS_DELAYED_REFS_FLUSHING, 2137e19eb11fSJosef Bacik &cur_trans->delayed_refs.flags)) { 2138e19eb11fSJosef Bacik /* 2139e19eb11fSJosef Bacik * Make a pass through all the delayed refs we have so far. 2140e19eb11fSJosef Bacik * Any running threads may add more while we are here. 214156bec294SChris Mason */ 2142c79a70b1SNikolay Borisov ret = btrfs_run_delayed_refs(trans, 0); 2143e4a2bcacSJosef Bacik if (ret) { 21443a45bb20SJeff Mahoney btrfs_end_transaction(trans); 2145e4a2bcacSJosef Bacik return ret; 2146e4a2bcacSJosef Bacik } 2147e19eb11fSJosef Bacik } 214856bec294SChris Mason 21496c686b35SNikolay Borisov btrfs_create_pending_block_groups(trans); 2150ea658badSJosef Bacik 21513204d33cSJosef Bacik if (!test_bit(BTRFS_TRANS_DIRTY_BG_RUN, &cur_trans->flags)) { 21521bbc621eSChris Mason int run_it = 0; 21531bbc621eSChris Mason 21541bbc621eSChris Mason /* this mutex is also taken before trying to set 21551bbc621eSChris Mason * block groups readonly. We need to make sure 21561bbc621eSChris Mason * that nobody has set a block group readonly 21571bbc621eSChris Mason * after a extents from that block group have been 21581bbc621eSChris Mason * allocated for cache files. btrfs_set_block_group_ro 21591bbc621eSChris Mason * will wait for the transaction to commit if it 21603204d33cSJosef Bacik * finds BTRFS_TRANS_DIRTY_BG_RUN set. 21611bbc621eSChris Mason * 21623204d33cSJosef Bacik * The BTRFS_TRANS_DIRTY_BG_RUN flag is also used to make sure 21633204d33cSJosef Bacik * only one process starts all the block group IO. It wouldn't 21641bbc621eSChris Mason * hurt to have more than one go through, but there's no 21651bbc621eSChris Mason * real advantage to it either. 21661bbc621eSChris Mason */ 21670b246afaSJeff Mahoney mutex_lock(&fs_info->ro_block_group_mutex); 21683204d33cSJosef Bacik if (!test_and_set_bit(BTRFS_TRANS_DIRTY_BG_RUN, 21693204d33cSJosef Bacik &cur_trans->flags)) 21701bbc621eSChris Mason run_it = 1; 21710b246afaSJeff Mahoney mutex_unlock(&fs_info->ro_block_group_mutex); 21721bbc621eSChris Mason 2173f9cacae3SNikolay Borisov if (run_it) { 217421217054SNikolay Borisov ret = btrfs_start_dirty_block_groups(trans); 21751bbc621eSChris Mason if (ret) { 21763a45bb20SJeff Mahoney btrfs_end_transaction(trans); 21771bbc621eSChris Mason return ret; 21781bbc621eSChris Mason } 2179f9cacae3SNikolay Borisov } 2180f9cacae3SNikolay Borisov } 21811bbc621eSChris Mason 21820b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 21834a9d8bdeSMiao Xie if (cur_trans->state >= TRANS_STATE_COMMIT_START) { 2184d0c2f4faSFilipe Manana enum btrfs_trans_state want_state = TRANS_STATE_COMPLETED; 2185d0c2f4faSFilipe Manana 218628b21c55SFilipe Manana add_pending_snapshot(trans); 218728b21c55SFilipe Manana 21880b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 21899b64f57dSElena Reshetova refcount_inc(&cur_trans->use_count); 2190ccd467d6SChris Mason 2191d0c2f4faSFilipe Manana if (trans->in_fsync) 2192d0c2f4faSFilipe Manana want_state = TRANS_STATE_SUPER_COMMITTED; 2193d0c2f4faSFilipe Manana ret = btrfs_end_transaction(trans); 2194d0c2f4faSFilipe Manana wait_for_commit(cur_trans, want_state); 219515ee9bc7SJosef Bacik 2196bf31f87fSDavid Sterba if (TRANS_ABORTED(cur_trans)) 2197b4924a0fSLiu Bo ret = cur_trans->aborted; 2198b4924a0fSLiu Bo 2199724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 220015ee9bc7SJosef Bacik 220149b25e05SJeff Mahoney return ret; 220279154b1bSChris Mason } 22034313b399SChris Mason 22044a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_COMMIT_START; 22050b246afaSJeff Mahoney wake_up(&fs_info->transaction_blocked_wait); 2206bb9c12c9SSage Weil 22070b246afaSJeff Mahoney if (cur_trans->list.prev != &fs_info->trans_list) { 2208d0c2f4faSFilipe Manana enum btrfs_trans_state want_state = TRANS_STATE_COMPLETED; 2209d0c2f4faSFilipe Manana 2210d0c2f4faSFilipe Manana if (trans->in_fsync) 2211d0c2f4faSFilipe Manana want_state = TRANS_STATE_SUPER_COMMITTED; 2212d0c2f4faSFilipe Manana 2213ccd467d6SChris Mason prev_trans = list_entry(cur_trans->list.prev, 2214ccd467d6SChris Mason struct btrfs_transaction, list); 2215d0c2f4faSFilipe Manana if (prev_trans->state < want_state) { 22169b64f57dSElena Reshetova refcount_inc(&prev_trans->use_count); 22170b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 2218ccd467d6SChris Mason 2219d0c2f4faSFilipe Manana wait_for_commit(prev_trans, want_state); 2220d0c2f4faSFilipe Manana 2221bf31f87fSDavid Sterba ret = READ_ONCE(prev_trans->aborted); 2222ccd467d6SChris Mason 2223724e2315SJosef Bacik btrfs_put_transaction(prev_trans); 22241f9b8c8fSFilipe Manana if (ret) 22251f9b8c8fSFilipe Manana goto cleanup_transaction; 2226a4abeea4SJosef Bacik } else { 22270b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 2228ccd467d6SChris Mason } 2229a4abeea4SJosef Bacik } else { 22300b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 2231cb2d3dadSFilipe Manana /* 2232cb2d3dadSFilipe Manana * The previous transaction was aborted and was already removed 2233cb2d3dadSFilipe Manana * from the list of transactions at fs_info->trans_list. So we 2234cb2d3dadSFilipe Manana * abort to prevent writing a new superblock that reflects a 2235cb2d3dadSFilipe Manana * corrupt state (pointing to trees with unwritten nodes/leafs). 2236cb2d3dadSFilipe Manana */ 223784961539SJosef Bacik if (BTRFS_FS_ERROR(fs_info)) { 2238cb2d3dadSFilipe Manana ret = -EROFS; 2239cb2d3dadSFilipe Manana goto cleanup_transaction; 2240cb2d3dadSFilipe Manana } 2241ccd467d6SChris Mason } 224215ee9bc7SJosef Bacik 2243e55958c8SIoannis Angelakopoulos /* 2244e55958c8SIoannis Angelakopoulos * Get the time spent on the work done by the commit thread and not 2245e55958c8SIoannis Angelakopoulos * the time spent waiting on a previous commit 2246e55958c8SIoannis Angelakopoulos */ 2247e55958c8SIoannis Angelakopoulos start_time = ktime_get_ns(); 2248e55958c8SIoannis Angelakopoulos 22490860adfdSMiao Xie extwriter_counter_dec(cur_trans, trans->type); 22500860adfdSMiao Xie 225188090ad3SFilipe Manana ret = btrfs_start_delalloc_flush(fs_info); 225282436617SMiao Xie if (ret) 225382436617SMiao Xie goto cleanup_transaction; 225482436617SMiao Xie 2255e5c304e6SNikolay Borisov ret = btrfs_run_delayed_items(trans); 225649b25e05SJeff Mahoney if (ret) 225749b25e05SJeff Mahoney goto cleanup_transaction; 225816cdcec7SMiao Xie 2259581227d0SMiao Xie wait_event(cur_trans->writer_wait, 2260581227d0SMiao Xie extwriter_counter_read(cur_trans) == 0); 2261ed3b3d31SChris Mason 2262581227d0SMiao Xie /* some pending stuffs might be added after the previous flush. */ 2263e5c304e6SNikolay Borisov ret = btrfs_run_delayed_items(trans); 2264ca469637SMiao Xie if (ret) 2265ca469637SMiao Xie goto cleanup_transaction; 2266ca469637SMiao Xie 226788090ad3SFilipe Manana btrfs_wait_delalloc_flush(fs_info); 2268cb7ab021SWang Shilong 226948778179SFilipe Manana /* 227048778179SFilipe Manana * Wait for all ordered extents started by a fast fsync that joined this 227148778179SFilipe Manana * transaction. Otherwise if this transaction commits before the ordered 227248778179SFilipe Manana * extents complete we lose logged data after a power failure. 227348778179SFilipe Manana */ 227448778179SFilipe Manana wait_event(cur_trans->pending_wait, 227548778179SFilipe Manana atomic_read(&cur_trans->pending_ordered) == 0); 227648778179SFilipe Manana 22772ff7e61eSJeff Mahoney btrfs_scrub_pause(fs_info); 2278ed0ca140SJosef Bacik /* 2279ed0ca140SJosef Bacik * Ok now we need to make sure to block out any other joins while we 2280ed0ca140SJosef Bacik * commit the transaction. We could have started a join before setting 22814a9d8bdeSMiao Xie * COMMIT_DOING so make sure to wait for num_writers to == 1 again. 2282ed0ca140SJosef Bacik */ 22830b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 228428b21c55SFilipe Manana add_pending_snapshot(trans); 22854a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_COMMIT_DOING; 22860b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 2287ed0ca140SJosef Bacik wait_event(cur_trans->writer_wait, 2288ed0ca140SJosef Bacik atomic_read(&cur_trans->num_writers) == 1); 228915ee9bc7SJosef Bacik 2290fdfbf020SJosef Bacik /* 2291fdfbf020SJosef Bacik * We've started the commit, clear the flag in case we were triggered to 2292fdfbf020SJosef Bacik * do an async commit but somebody else started before the transaction 2293fdfbf020SJosef Bacik * kthread could do the work. 2294fdfbf020SJosef Bacik */ 2295fdfbf020SJosef Bacik clear_bit(BTRFS_FS_COMMIT_TRANS, &fs_info->flags); 2296fdfbf020SJosef Bacik 2297bf31f87fSDavid Sterba if (TRANS_ABORTED(cur_trans)) { 22982cba30f1SMiao Xie ret = cur_trans->aborted; 22996cf7f77eSWang Shilong goto scrub_continue; 23002cba30f1SMiao Xie } 23017585717fSChris Mason /* 23027585717fSChris Mason * the reloc mutex makes sure that we stop 23037585717fSChris Mason * the balancing code from coming in and moving 23047585717fSChris Mason * extents around in the middle of the commit 23057585717fSChris Mason */ 23060b246afaSJeff Mahoney mutex_lock(&fs_info->reloc_mutex); 23077585717fSChris Mason 230842874b3dSMiao Xie /* 230942874b3dSMiao Xie * We needn't worry about the delayed items because we will 231042874b3dSMiao Xie * deal with them in create_pending_snapshot(), which is the 231142874b3dSMiao Xie * core function of the snapshot creation. 231242874b3dSMiao Xie */ 231308d50ca3SNikolay Borisov ret = create_pending_snapshots(trans); 231456e9f6eaSDavid Sterba if (ret) 231556e9f6eaSDavid Sterba goto unlock_reloc; 23163063d29fSChris Mason 231742874b3dSMiao Xie /* 231842874b3dSMiao Xie * We insert the dir indexes of the snapshots and update the inode 231942874b3dSMiao Xie * of the snapshots' parents after the snapshot creation, so there 232042874b3dSMiao Xie * are some delayed items which are not dealt with. Now deal with 232142874b3dSMiao Xie * them. 232242874b3dSMiao Xie * 232342874b3dSMiao Xie * We needn't worry that this operation will corrupt the snapshots, 232442874b3dSMiao Xie * because all the tree which are snapshoted will be forced to COW 232542874b3dSMiao Xie * the nodes and leaves. 232642874b3dSMiao Xie */ 2327e5c304e6SNikolay Borisov ret = btrfs_run_delayed_items(trans); 232856e9f6eaSDavid Sterba if (ret) 232956e9f6eaSDavid Sterba goto unlock_reloc; 233016cdcec7SMiao Xie 2331c79a70b1SNikolay Borisov ret = btrfs_run_delayed_refs(trans, (unsigned long)-1); 233256e9f6eaSDavid Sterba if (ret) 233356e9f6eaSDavid Sterba goto unlock_reloc; 233456bec294SChris Mason 2335e999376fSChris Mason /* 2336e999376fSChris Mason * make sure none of the code above managed to slip in a 2337e999376fSChris Mason * delayed item 2338e999376fSChris Mason */ 2339ccdf9b30SJeff Mahoney btrfs_assert_delayed_root_empty(fs_info); 2340e999376fSChris Mason 23412c90e5d6SChris Mason WARN_ON(cur_trans != trans->transaction); 2342dc17ff8fSChris Mason 23437e4443d9SNikolay Borisov ret = commit_fs_roots(trans); 234456e9f6eaSDavid Sterba if (ret) 2345dfba78dcSFilipe Manana goto unlock_reloc; 234654aa1f4dSChris Mason 23473818aea2SQu Wenruo /* 23487e1876acSDavid Sterba * Since the transaction is done, we can apply the pending changes 23497e1876acSDavid Sterba * before the next transaction. 23503818aea2SQu Wenruo */ 23510b246afaSJeff Mahoney btrfs_apply_pending_changes(fs_info); 23523818aea2SQu Wenruo 23535d4f98a2SYan Zheng /* commit_fs_roots gets rid of all the tree log roots, it is now 2354e02119d5SChris Mason * safe to free the root of tree log roots 2355e02119d5SChris Mason */ 23560b246afaSJeff Mahoney btrfs_free_log_root_tree(trans, fs_info); 2357e02119d5SChris Mason 23580ed4792aSQu Wenruo /* 23590ed4792aSQu Wenruo * Since fs roots are all committed, we can get a quite accurate 23600ed4792aSQu Wenruo * new_roots. So let's do quota accounting. 23610ed4792aSQu Wenruo */ 2362460fb20aSNikolay Borisov ret = btrfs_qgroup_account_extents(trans); 236356e9f6eaSDavid Sterba if (ret < 0) 2364dfba78dcSFilipe Manana goto unlock_reloc; 23650ed4792aSQu Wenruo 23669386d8bcSNikolay Borisov ret = commit_cowonly_roots(trans); 236756e9f6eaSDavid Sterba if (ret) 2368dfba78dcSFilipe Manana goto unlock_reloc; 236954aa1f4dSChris Mason 23702cba30f1SMiao Xie /* 23712cba30f1SMiao Xie * The tasks which save the space cache and inode cache may also 23722cba30f1SMiao Xie * update ->aborted, check it. 23732cba30f1SMiao Xie */ 2374bf31f87fSDavid Sterba if (TRANS_ABORTED(cur_trans)) { 23752cba30f1SMiao Xie ret = cur_trans->aborted; 2376dfba78dcSFilipe Manana goto unlock_reloc; 23772cba30f1SMiao Xie } 23782cba30f1SMiao Xie 23790b246afaSJeff Mahoney cur_trans = fs_info->running_transaction; 23805f39d397SChris Mason 23810b246afaSJeff Mahoney btrfs_set_root_node(&fs_info->tree_root->root_item, 23820b246afaSJeff Mahoney fs_info->tree_root->node); 23830b246afaSJeff Mahoney list_add_tail(&fs_info->tree_root->dirty_list, 23849e351cc8SJosef Bacik &cur_trans->switch_commits); 23855d4f98a2SYan Zheng 23860b246afaSJeff Mahoney btrfs_set_root_node(&fs_info->chunk_root->root_item, 23870b246afaSJeff Mahoney fs_info->chunk_root->node); 23880b246afaSJeff Mahoney list_add_tail(&fs_info->chunk_root->dirty_list, 23899e351cc8SJosef Bacik &cur_trans->switch_commits); 23909e351cc8SJosef Bacik 2391f7238e50SJosef Bacik if (btrfs_fs_incompat(fs_info, EXTENT_TREE_V2)) { 2392f7238e50SJosef Bacik btrfs_set_root_node(&fs_info->block_group_root->root_item, 2393f7238e50SJosef Bacik fs_info->block_group_root->node); 2394f7238e50SJosef Bacik list_add_tail(&fs_info->block_group_root->dirty_list, 2395f7238e50SJosef Bacik &cur_trans->switch_commits); 2396f7238e50SJosef Bacik } 2397f7238e50SJosef Bacik 2398889bfa39SJosef Bacik switch_commit_roots(trans); 23995d4f98a2SYan Zheng 2400ce93ec54SJosef Bacik ASSERT(list_empty(&cur_trans->dirty_bgs)); 24011bbc621eSChris Mason ASSERT(list_empty(&cur_trans->io_bgs)); 24022ff7e61eSJeff Mahoney update_super_roots(fs_info); 2403e02119d5SChris Mason 24040b246afaSJeff Mahoney btrfs_set_super_log_root(fs_info->super_copy, 0); 24050b246afaSJeff Mahoney btrfs_set_super_log_root_level(fs_info->super_copy, 0); 24060b246afaSJeff Mahoney memcpy(fs_info->super_for_commit, fs_info->super_copy, 24070b246afaSJeff Mahoney sizeof(*fs_info->super_copy)); 2408ccd467d6SChris Mason 2409bbbf7243SNikolay Borisov btrfs_commit_device_sizes(cur_trans); 2410935e5cc9SMiao Xie 24110b246afaSJeff Mahoney clear_bit(BTRFS_FS_LOG1_ERR, &fs_info->flags); 24120b246afaSJeff Mahoney clear_bit(BTRFS_FS_LOG2_ERR, &fs_info->flags); 2413656f30dbSFilipe Manana 24144fbcdf66SFilipe Manana btrfs_trans_release_chunk_metadata(trans); 24154fbcdf66SFilipe Manana 2416dfba78dcSFilipe Manana /* 2417dfba78dcSFilipe Manana * Before changing the transaction state to TRANS_STATE_UNBLOCKED and 2418dfba78dcSFilipe Manana * setting fs_info->running_transaction to NULL, lock tree_log_mutex to 2419dfba78dcSFilipe Manana * make sure that before we commit our superblock, no other task can 2420dfba78dcSFilipe Manana * start a new transaction and commit a log tree before we commit our 2421dfba78dcSFilipe Manana * superblock. Anyone trying to commit a log tree locks this mutex before 2422dfba78dcSFilipe Manana * writing its superblock. 2423dfba78dcSFilipe Manana */ 2424dfba78dcSFilipe Manana mutex_lock(&fs_info->tree_log_mutex); 2425dfba78dcSFilipe Manana 24260b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 24274a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_UNBLOCKED; 24280b246afaSJeff Mahoney fs_info->running_transaction = NULL; 24290b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 24300b246afaSJeff Mahoney mutex_unlock(&fs_info->reloc_mutex); 2431b7ec40d7SChris Mason 24320b246afaSJeff Mahoney wake_up(&fs_info->transaction_wait); 2433e6dcd2dcSChris Mason 243470458a58SNikolay Borisov ret = btrfs_write_and_wait_transaction(trans); 243549b25e05SJeff Mahoney if (ret) { 24360b246afaSJeff Mahoney btrfs_handle_fs_error(fs_info, ret, 243708748810SDavid Sterba "Error while writing out transaction"); 24380b246afaSJeff Mahoney mutex_unlock(&fs_info->tree_log_mutex); 24396cf7f77eSWang Shilong goto scrub_continue; 244049b25e05SJeff Mahoney } 244149b25e05SJeff Mahoney 2442d3575156SNaohiro Aota /* 2443d3575156SNaohiro Aota * At this point, we should have written all the tree blocks allocated 2444d3575156SNaohiro Aota * in this transaction. So it's now safe to free the redirtyied extent 2445d3575156SNaohiro Aota * buffers. 2446d3575156SNaohiro Aota */ 2447d3575156SNaohiro Aota btrfs_free_redirty_list(cur_trans); 2448d3575156SNaohiro Aota 2449eece6a9cSDavid Sterba ret = write_all_supers(fs_info, 0); 2450e02119d5SChris Mason /* 2451e02119d5SChris Mason * the super is written, we can safely allow the tree-loggers 2452e02119d5SChris Mason * to go about their business 2453e02119d5SChris Mason */ 24540b246afaSJeff Mahoney mutex_unlock(&fs_info->tree_log_mutex); 2455c1f32b7cSAnand Jain if (ret) 2456c1f32b7cSAnand Jain goto scrub_continue; 2457e02119d5SChris Mason 2458d0c2f4faSFilipe Manana /* 2459d0c2f4faSFilipe Manana * We needn't acquire the lock here because there is no other task 2460d0c2f4faSFilipe Manana * which can change it. 2461d0c2f4faSFilipe Manana */ 2462d0c2f4faSFilipe Manana cur_trans->state = TRANS_STATE_SUPER_COMMITTED; 2463d0c2f4faSFilipe Manana wake_up(&cur_trans->commit_wait); 2464d0c2f4faSFilipe Manana 24655ead2dd0SNikolay Borisov btrfs_finish_extent_commit(trans); 24664313b399SChris Mason 24673204d33cSJosef Bacik if (test_bit(BTRFS_TRANS_HAVE_FREE_BGS, &cur_trans->flags)) 24680b246afaSJeff Mahoney btrfs_clear_space_info_full(fs_info); 246913212b54SZhao Lei 24700b246afaSJeff Mahoney fs_info->last_trans_committed = cur_trans->transid; 24714a9d8bdeSMiao Xie /* 24724a9d8bdeSMiao Xie * We needn't acquire the lock here because there is no other task 24734a9d8bdeSMiao Xie * which can change it. 24744a9d8bdeSMiao Xie */ 24754a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_COMPLETED; 24762c90e5d6SChris Mason wake_up(&cur_trans->commit_wait); 24773de4586cSChris Mason 24780b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 247913c5a93eSJosef Bacik list_del_init(&cur_trans->list); 24800b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 2481a4abeea4SJosef Bacik 2482724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 2483724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 248458176a96SJosef Bacik 24850860adfdSMiao Xie if (trans->type & __TRANS_FREEZABLE) 24860b246afaSJeff Mahoney sb_end_intwrite(fs_info->sb); 2487b2b5ef5cSJan Kara 24882e4e97abSJosef Bacik trace_btrfs_transaction_commit(fs_info); 24891abe9b8aSliubo 2490e55958c8SIoannis Angelakopoulos interval = ktime_get_ns() - start_time; 2491e55958c8SIoannis Angelakopoulos 24922ff7e61eSJeff Mahoney btrfs_scrub_continue(fs_info); 2493a2de733cSArne Jansen 24949ed74f2dSJosef Bacik if (current->journal_info == trans) 24959ed74f2dSJosef Bacik current->journal_info = NULL; 24969ed74f2dSJosef Bacik 24972c90e5d6SChris Mason kmem_cache_free(btrfs_trans_handle_cachep, trans); 249824bbcf04SYan, Zheng 2499e55958c8SIoannis Angelakopoulos update_commit_stats(fs_info, interval); 2500e55958c8SIoannis Angelakopoulos 250179154b1bSChris Mason return ret; 250249b25e05SJeff Mahoney 250356e9f6eaSDavid Sterba unlock_reloc: 250456e9f6eaSDavid Sterba mutex_unlock(&fs_info->reloc_mutex); 25056cf7f77eSWang Shilong scrub_continue: 25062ff7e61eSJeff Mahoney btrfs_scrub_continue(fs_info); 250749b25e05SJeff Mahoney cleanup_transaction: 2508dc60c525SNikolay Borisov btrfs_trans_release_metadata(trans); 2509c7cc64a9SDavid Sterba btrfs_cleanup_pending_block_groups(trans); 25104fbcdf66SFilipe Manana btrfs_trans_release_chunk_metadata(trans); 25110e721106SJosef Bacik trans->block_rsv = NULL; 25120b246afaSJeff Mahoney btrfs_warn(fs_info, "Skipping commit of aborted transaction."); 251349b25e05SJeff Mahoney if (current->journal_info == trans) 251449b25e05SJeff Mahoney current->journal_info = NULL; 251597cb39bbSNikolay Borisov cleanup_transaction(trans, ret); 251649b25e05SJeff Mahoney 251749b25e05SJeff Mahoney return ret; 251879154b1bSChris Mason } 251979154b1bSChris Mason 2520d352ac68SChris Mason /* 25219d1a2a3aSDavid Sterba * return < 0 if error 25229d1a2a3aSDavid Sterba * 0 if there are no more dead_roots at the time of call 25239d1a2a3aSDavid Sterba * 1 there are more to be processed, call me again 25249d1a2a3aSDavid Sterba * 25259d1a2a3aSDavid Sterba * The return value indicates there are certainly more snapshots to delete, but 25269d1a2a3aSDavid Sterba * if there comes a new one during processing, it may return 0. We don't mind, 25279d1a2a3aSDavid Sterba * because btrfs_commit_super will poke cleaner thread and it will process it a 25289d1a2a3aSDavid Sterba * few seconds later. 2529d352ac68SChris Mason */ 253033c44184SJosef Bacik int btrfs_clean_one_deleted_snapshot(struct btrfs_fs_info *fs_info) 2531e9d0b13bSChris Mason { 253233c44184SJosef Bacik struct btrfs_root *root; 25339d1a2a3aSDavid Sterba int ret; 2534e9d0b13bSChris Mason 2535a4abeea4SJosef Bacik spin_lock(&fs_info->trans_lock); 25369d1a2a3aSDavid Sterba if (list_empty(&fs_info->dead_roots)) { 25379d1a2a3aSDavid Sterba spin_unlock(&fs_info->trans_lock); 25389d1a2a3aSDavid Sterba return 0; 25399d1a2a3aSDavid Sterba } 25409d1a2a3aSDavid Sterba root = list_first_entry(&fs_info->dead_roots, 25419d1a2a3aSDavid Sterba struct btrfs_root, root_list); 2542cfad392bSJosef Bacik list_del_init(&root->root_list); 2543a4abeea4SJosef Bacik spin_unlock(&fs_info->trans_lock); 25445d4f98a2SYan Zheng 25454fd786e6SMisono Tomohiro btrfs_debug(fs_info, "cleaner removing %llu", root->root_key.objectid); 254676dda93cSYan, Zheng 254716cdcec7SMiao Xie btrfs_kill_all_delayed_nodes(root); 254816cdcec7SMiao Xie 254976dda93cSYan, Zheng if (btrfs_header_backref_rev(root->node) < 255076dda93cSYan, Zheng BTRFS_MIXED_BACKREF_REV) 25510078a9f9SNikolay Borisov ret = btrfs_drop_snapshot(root, 0, 0); 255276dda93cSYan, Zheng else 25530078a9f9SNikolay Borisov ret = btrfs_drop_snapshot(root, 1, 0); 255432471dc2SDavid Sterba 2555dc9492c1SJosef Bacik btrfs_put_root(root); 25566596a928SJosef Bacik return (ret < 0) ? 0 : 1; 2557e9d0b13bSChris Mason } 2558572d9ab7SDavid Sterba 2559572d9ab7SDavid Sterba void btrfs_apply_pending_changes(struct btrfs_fs_info *fs_info) 2560572d9ab7SDavid Sterba { 2561572d9ab7SDavid Sterba unsigned long prev; 2562572d9ab7SDavid Sterba unsigned long bit; 2563572d9ab7SDavid Sterba 25646c9fe14fSQu Wenruo prev = xchg(&fs_info->pending_changes, 0); 2565572d9ab7SDavid Sterba if (!prev) 2566572d9ab7SDavid Sterba return; 2567572d9ab7SDavid Sterba 2568d51033d0SDavid Sterba bit = 1 << BTRFS_PENDING_COMMIT; 2569d51033d0SDavid Sterba if (prev & bit) 2570d51033d0SDavid Sterba btrfs_debug(fs_info, "pending commit done"); 2571d51033d0SDavid Sterba prev &= ~bit; 2572d51033d0SDavid Sterba 2573572d9ab7SDavid Sterba if (prev) 2574572d9ab7SDavid Sterba btrfs_warn(fs_info, 2575572d9ab7SDavid Sterba "unknown pending changes left 0x%lx, ignoring", prev); 2576572d9ab7SDavid Sterba } 2577