1c1d7c514SDavid Sterba // SPDX-License-Identifier: GPL-2.0 26cbd5570SChris Mason /* 36cbd5570SChris Mason * Copyright (C) 2007 Oracle. All rights reserved. 46cbd5570SChris Mason */ 56cbd5570SChris Mason 679154b1bSChris Mason #include <linux/fs.h> 75a0e3ad6STejun Heo #include <linux/slab.h> 834088780SChris Mason #include <linux/sched.h> 9d3c2fdcfSChris Mason #include <linux/writeback.h> 105f39d397SChris Mason #include <linux/pagemap.h> 115f2cc086SChris Mason #include <linux/blkdev.h> 128ea05e3aSAlexander Block #include <linux/uuid.h> 13602cbe91SDavid Sterba #include "misc.h" 1479154b1bSChris Mason #include "ctree.h" 1579154b1bSChris Mason #include "disk-io.h" 1679154b1bSChris Mason #include "transaction.h" 17925baeddSChris Mason #include "locking.h" 18e02119d5SChris Mason #include "tree-log.h" 19733f4fbbSStefan Behrens #include "volumes.h" 208dabb742SStefan Behrens #include "dev-replace.h" 21fcebe456SJosef Bacik #include "qgroup.h" 22aac0023cSJosef Bacik #include "block-group.h" 239c343784SJosef Bacik #include "space-info.h" 24d3575156SNaohiro Aota #include "zoned.h" 2579154b1bSChris Mason 260f7d52f4SChris Mason #define BTRFS_ROOT_TRANS_TAG 0 270f7d52f4SChris Mason 2861c047b5SQu Wenruo /* 2961c047b5SQu Wenruo * Transaction states and transitions 3061c047b5SQu Wenruo * 3161c047b5SQu Wenruo * No running transaction (fs tree blocks are not modified) 3261c047b5SQu Wenruo * | 3361c047b5SQu Wenruo * | To next stage: 3461c047b5SQu Wenruo * | Call start_transaction() variants. Except btrfs_join_transaction_nostart(). 3561c047b5SQu Wenruo * V 3661c047b5SQu Wenruo * Transaction N [[TRANS_STATE_RUNNING]] 3761c047b5SQu Wenruo * | 3861c047b5SQu Wenruo * | New trans handles can be attached to transaction N by calling all 3961c047b5SQu Wenruo * | start_transaction() variants. 4061c047b5SQu Wenruo * | 4161c047b5SQu Wenruo * | To next stage: 4261c047b5SQu Wenruo * | Call btrfs_commit_transaction() on any trans handle attached to 4361c047b5SQu Wenruo * | transaction N 4461c047b5SQu Wenruo * V 4561c047b5SQu Wenruo * Transaction N [[TRANS_STATE_COMMIT_START]] 4661c047b5SQu Wenruo * | 4761c047b5SQu Wenruo * | Will wait for previous running transaction to completely finish if there 4861c047b5SQu Wenruo * | is one 4961c047b5SQu Wenruo * | 5061c047b5SQu Wenruo * | Then one of the following happes: 5161c047b5SQu Wenruo * | - Wait for all other trans handle holders to release. 5261c047b5SQu Wenruo * | The btrfs_commit_transaction() caller will do the commit work. 5361c047b5SQu Wenruo * | - Wait for current transaction to be committed by others. 5461c047b5SQu Wenruo * | Other btrfs_commit_transaction() caller will do the commit work. 5561c047b5SQu Wenruo * | 5661c047b5SQu Wenruo * | At this stage, only btrfs_join_transaction*() variants can attach 5761c047b5SQu Wenruo * | to this running transaction. 5861c047b5SQu Wenruo * | All other variants will wait for current one to finish and attach to 5961c047b5SQu Wenruo * | transaction N+1. 6061c047b5SQu Wenruo * | 6161c047b5SQu Wenruo * | To next stage: 6261c047b5SQu Wenruo * | Caller is chosen to commit transaction N, and all other trans handle 6361c047b5SQu Wenruo * | haven been released. 6461c047b5SQu Wenruo * V 6561c047b5SQu Wenruo * Transaction N [[TRANS_STATE_COMMIT_DOING]] 6661c047b5SQu Wenruo * | 6761c047b5SQu Wenruo * | The heavy lifting transaction work is started. 6861c047b5SQu Wenruo * | From running delayed refs (modifying extent tree) to creating pending 6961c047b5SQu Wenruo * | snapshots, running qgroups. 7061c047b5SQu Wenruo * | In short, modify supporting trees to reflect modifications of subvolume 7161c047b5SQu Wenruo * | trees. 7261c047b5SQu Wenruo * | 7361c047b5SQu Wenruo * | At this stage, all start_transaction() calls will wait for this 7461c047b5SQu Wenruo * | transaction to finish and attach to transaction N+1. 7561c047b5SQu Wenruo * | 7661c047b5SQu Wenruo * | To next stage: 7761c047b5SQu Wenruo * | Until all supporting trees are updated. 7861c047b5SQu Wenruo * V 7961c047b5SQu Wenruo * Transaction N [[TRANS_STATE_UNBLOCKED]] 8061c047b5SQu Wenruo * | Transaction N+1 8161c047b5SQu Wenruo * | All needed trees are modified, thus we only [[TRANS_STATE_RUNNING]] 8261c047b5SQu Wenruo * | need to write them back to disk and update | 8361c047b5SQu Wenruo * | super blocks. | 8461c047b5SQu Wenruo * | | 8561c047b5SQu Wenruo * | At this stage, new transaction is allowed to | 8661c047b5SQu Wenruo * | start. | 8761c047b5SQu Wenruo * | All new start_transaction() calls will be | 8861c047b5SQu Wenruo * | attached to transid N+1. | 8961c047b5SQu Wenruo * | | 9061c047b5SQu Wenruo * | To next stage: | 9161c047b5SQu Wenruo * | Until all tree blocks are super blocks are | 9261c047b5SQu Wenruo * | written to block devices | 9361c047b5SQu Wenruo * V | 9461c047b5SQu Wenruo * Transaction N [[TRANS_STATE_COMPLETED]] V 9561c047b5SQu Wenruo * All tree blocks and super blocks are written. Transaction N+1 9661c047b5SQu Wenruo * This transaction is finished and all its [[TRANS_STATE_COMMIT_START]] 9761c047b5SQu Wenruo * data structures will be cleaned up. | Life goes on 9861c047b5SQu Wenruo */ 99e8c9f186SDavid Sterba static const unsigned int btrfs_blocked_trans_types[TRANS_STATE_MAX] = { 1004a9d8bdeSMiao Xie [TRANS_STATE_RUNNING] = 0U, 101bcf3a3e7SNikolay Borisov [TRANS_STATE_COMMIT_START] = (__TRANS_START | __TRANS_ATTACH), 102bcf3a3e7SNikolay Borisov [TRANS_STATE_COMMIT_DOING] = (__TRANS_START | 1034a9d8bdeSMiao Xie __TRANS_ATTACH | 104a6d155d2SFilipe Manana __TRANS_JOIN | 105a6d155d2SFilipe Manana __TRANS_JOIN_NOSTART), 106bcf3a3e7SNikolay Borisov [TRANS_STATE_UNBLOCKED] = (__TRANS_START | 1074a9d8bdeSMiao Xie __TRANS_ATTACH | 1084a9d8bdeSMiao Xie __TRANS_JOIN | 109a6d155d2SFilipe Manana __TRANS_JOIN_NOLOCK | 110a6d155d2SFilipe Manana __TRANS_JOIN_NOSTART), 111d0c2f4faSFilipe Manana [TRANS_STATE_SUPER_COMMITTED] = (__TRANS_START | 112d0c2f4faSFilipe Manana __TRANS_ATTACH | 113d0c2f4faSFilipe Manana __TRANS_JOIN | 114d0c2f4faSFilipe Manana __TRANS_JOIN_NOLOCK | 115d0c2f4faSFilipe Manana __TRANS_JOIN_NOSTART), 116bcf3a3e7SNikolay Borisov [TRANS_STATE_COMPLETED] = (__TRANS_START | 1174a9d8bdeSMiao Xie __TRANS_ATTACH | 1184a9d8bdeSMiao Xie __TRANS_JOIN | 119a6d155d2SFilipe Manana __TRANS_JOIN_NOLOCK | 120a6d155d2SFilipe Manana __TRANS_JOIN_NOSTART), 1214a9d8bdeSMiao Xie }; 1224a9d8bdeSMiao Xie 123724e2315SJosef Bacik void btrfs_put_transaction(struct btrfs_transaction *transaction) 12479154b1bSChris Mason { 1259b64f57dSElena Reshetova WARN_ON(refcount_read(&transaction->use_count) == 0); 1269b64f57dSElena Reshetova if (refcount_dec_and_test(&transaction->use_count)) { 127a4abeea4SJosef Bacik BUG_ON(!list_empty(&transaction->list)); 1285c9d028bSLiu Bo WARN_ON(!RB_EMPTY_ROOT( 1295c9d028bSLiu Bo &transaction->delayed_refs.href_root.rb_root)); 13081f7eb00SJeff Mahoney WARN_ON(!RB_EMPTY_ROOT( 13181f7eb00SJeff Mahoney &transaction->delayed_refs.dirty_extent_root)); 1321262133bSJosef Bacik if (transaction->delayed_refs.pending_csums) 133ab8d0fc4SJeff Mahoney btrfs_err(transaction->fs_info, 134ab8d0fc4SJeff Mahoney "pending csums is %llu", 1351262133bSJosef Bacik transaction->delayed_refs.pending_csums); 1367785a663SFilipe Manana /* 1377785a663SFilipe Manana * If any block groups are found in ->deleted_bgs then it's 1387785a663SFilipe Manana * because the transaction was aborted and a commit did not 1397785a663SFilipe Manana * happen (things failed before writing the new superblock 1407785a663SFilipe Manana * and calling btrfs_finish_extent_commit()), so we can not 1417785a663SFilipe Manana * discard the physical locations of the block groups. 1427785a663SFilipe Manana */ 1437785a663SFilipe Manana while (!list_empty(&transaction->deleted_bgs)) { 14432da5386SDavid Sterba struct btrfs_block_group *cache; 1457785a663SFilipe Manana 1467785a663SFilipe Manana cache = list_first_entry(&transaction->deleted_bgs, 14732da5386SDavid Sterba struct btrfs_block_group, 1487785a663SFilipe Manana bg_list); 1497785a663SFilipe Manana list_del_init(&cache->bg_list); 1506b7304afSFilipe Manana btrfs_unfreeze_block_group(cache); 1517785a663SFilipe Manana btrfs_put_block_group(cache); 1527785a663SFilipe Manana } 153bbbf7243SNikolay Borisov WARN_ON(!list_empty(&transaction->dev_update_list)); 1544b5faeacSDavid Sterba kfree(transaction); 15579154b1bSChris Mason } 15678fae27eSChris Mason } 15779154b1bSChris Mason 158889bfa39SJosef Bacik static noinline void switch_commit_roots(struct btrfs_trans_handle *trans) 159817d52f8SJosef Bacik { 160889bfa39SJosef Bacik struct btrfs_transaction *cur_trans = trans->transaction; 16116916a88SNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 1629e351cc8SJosef Bacik struct btrfs_root *root, *tmp; 16327d56e62SJosef Bacik struct btrfs_caching_control *caching_ctl, *next; 1649e351cc8SJosef Bacik 1659e351cc8SJosef Bacik down_write(&fs_info->commit_root_sem); 166889bfa39SJosef Bacik list_for_each_entry_safe(root, tmp, &cur_trans->switch_commits, 1679e351cc8SJosef Bacik dirty_list) { 1689e351cc8SJosef Bacik list_del_init(&root->dirty_list); 169817d52f8SJosef Bacik free_extent_buffer(root->commit_root); 170817d52f8SJosef Bacik root->commit_root = btrfs_root_node(root); 17141e7acd3SNikolay Borisov extent_io_tree_release(&root->dirty_log_pages); 172370a11b8SQu Wenruo btrfs_qgroup_clean_swapped_blocks(root); 1739e351cc8SJosef Bacik } 1742b9dbef2SJosef Bacik 1752b9dbef2SJosef Bacik /* We can free old roots now. */ 176889bfa39SJosef Bacik spin_lock(&cur_trans->dropped_roots_lock); 177889bfa39SJosef Bacik while (!list_empty(&cur_trans->dropped_roots)) { 178889bfa39SJosef Bacik root = list_first_entry(&cur_trans->dropped_roots, 1792b9dbef2SJosef Bacik struct btrfs_root, root_list); 1802b9dbef2SJosef Bacik list_del_init(&root->root_list); 181889bfa39SJosef Bacik spin_unlock(&cur_trans->dropped_roots_lock); 182889bfa39SJosef Bacik btrfs_free_log(trans, root); 1832b9dbef2SJosef Bacik btrfs_drop_and_free_fs_root(fs_info, root); 184889bfa39SJosef Bacik spin_lock(&cur_trans->dropped_roots_lock); 1852b9dbef2SJosef Bacik } 186889bfa39SJosef Bacik spin_unlock(&cur_trans->dropped_roots_lock); 18727d56e62SJosef Bacik 18827d56e62SJosef Bacik /* 18927d56e62SJosef Bacik * We have to update the last_byte_to_unpin under the commit_root_sem, 19027d56e62SJosef Bacik * at the same time we swap out the commit roots. 19127d56e62SJosef Bacik * 19227d56e62SJosef Bacik * This is because we must have a real view of the last spot the caching 19327d56e62SJosef Bacik * kthreads were while caching. Consider the following views of the 19427d56e62SJosef Bacik * extent tree for a block group 19527d56e62SJosef Bacik * 19627d56e62SJosef Bacik * commit root 19727d56e62SJosef Bacik * +----+----+----+----+----+----+----+ 19827d56e62SJosef Bacik * |\\\\| |\\\\|\\\\| |\\\\|\\\\| 19927d56e62SJosef Bacik * +----+----+----+----+----+----+----+ 20027d56e62SJosef Bacik * 0 1 2 3 4 5 6 7 20127d56e62SJosef Bacik * 20227d56e62SJosef Bacik * new commit root 20327d56e62SJosef Bacik * +----+----+----+----+----+----+----+ 20427d56e62SJosef Bacik * | | | |\\\\| | |\\\\| 20527d56e62SJosef Bacik * +----+----+----+----+----+----+----+ 20627d56e62SJosef Bacik * 0 1 2 3 4 5 6 7 20727d56e62SJosef Bacik * 20827d56e62SJosef Bacik * If the cache_ctl->progress was at 3, then we are only allowed to 20927d56e62SJosef Bacik * unpin [0,1) and [2,3], because the caching thread has already 21027d56e62SJosef Bacik * processed those extents. We are not allowed to unpin [5,6), because 21127d56e62SJosef Bacik * the caching thread will re-start it's search from 3, and thus find 21227d56e62SJosef Bacik * the hole from [4,6) to add to the free space cache. 21327d56e62SJosef Bacik */ 214bbb86a37SJosef Bacik spin_lock(&fs_info->block_group_cache_lock); 21527d56e62SJosef Bacik list_for_each_entry_safe(caching_ctl, next, 21627d56e62SJosef Bacik &fs_info->caching_block_groups, list) { 21727d56e62SJosef Bacik struct btrfs_block_group *cache = caching_ctl->block_group; 21827d56e62SJosef Bacik 21927d56e62SJosef Bacik if (btrfs_block_group_done(cache)) { 22027d56e62SJosef Bacik cache->last_byte_to_unpin = (u64)-1; 22127d56e62SJosef Bacik list_del_init(&caching_ctl->list); 22227d56e62SJosef Bacik btrfs_put_caching_control(caching_ctl); 22327d56e62SJosef Bacik } else { 22427d56e62SJosef Bacik cache->last_byte_to_unpin = caching_ctl->progress; 22527d56e62SJosef Bacik } 22627d56e62SJosef Bacik } 227bbb86a37SJosef Bacik spin_unlock(&fs_info->block_group_cache_lock); 2289e351cc8SJosef Bacik up_write(&fs_info->commit_root_sem); 229817d52f8SJosef Bacik } 230817d52f8SJosef Bacik 2310860adfdSMiao Xie static inline void extwriter_counter_inc(struct btrfs_transaction *trans, 2320860adfdSMiao Xie unsigned int type) 2330860adfdSMiao Xie { 2340860adfdSMiao Xie if (type & TRANS_EXTWRITERS) 2350860adfdSMiao Xie atomic_inc(&trans->num_extwriters); 2360860adfdSMiao Xie } 2370860adfdSMiao Xie 2380860adfdSMiao Xie static inline void extwriter_counter_dec(struct btrfs_transaction *trans, 2390860adfdSMiao Xie unsigned int type) 2400860adfdSMiao Xie { 2410860adfdSMiao Xie if (type & TRANS_EXTWRITERS) 2420860adfdSMiao Xie atomic_dec(&trans->num_extwriters); 2430860adfdSMiao Xie } 2440860adfdSMiao Xie 2450860adfdSMiao Xie static inline void extwriter_counter_init(struct btrfs_transaction *trans, 2460860adfdSMiao Xie unsigned int type) 2470860adfdSMiao Xie { 2480860adfdSMiao Xie atomic_set(&trans->num_extwriters, ((type & TRANS_EXTWRITERS) ? 1 : 0)); 2490860adfdSMiao Xie } 2500860adfdSMiao Xie 2510860adfdSMiao Xie static inline int extwriter_counter_read(struct btrfs_transaction *trans) 2520860adfdSMiao Xie { 2530860adfdSMiao Xie return atomic_read(&trans->num_extwriters); 254178260b2SMiao Xie } 255178260b2SMiao Xie 256d352ac68SChris Mason /* 257fb6dea26SJosef Bacik * To be called after all the new block groups attached to the transaction 258fb6dea26SJosef Bacik * handle have been created (btrfs_create_pending_block_groups()). 259fb6dea26SJosef Bacik */ 260fb6dea26SJosef Bacik void btrfs_trans_release_chunk_metadata(struct btrfs_trans_handle *trans) 261fb6dea26SJosef Bacik { 262fb6dea26SJosef Bacik struct btrfs_fs_info *fs_info = trans->fs_info; 263eafa4fd0SFilipe Manana struct btrfs_transaction *cur_trans = trans->transaction; 264fb6dea26SJosef Bacik 265fb6dea26SJosef Bacik if (!trans->chunk_bytes_reserved) 266fb6dea26SJosef Bacik return; 267fb6dea26SJosef Bacik 268fb6dea26SJosef Bacik WARN_ON_ONCE(!list_empty(&trans->new_bgs)); 269fb6dea26SJosef Bacik 270fb6dea26SJosef Bacik btrfs_block_rsv_release(fs_info, &fs_info->chunk_block_rsv, 27163f018beSNikolay Borisov trans->chunk_bytes_reserved, NULL); 272eafa4fd0SFilipe Manana atomic64_sub(trans->chunk_bytes_reserved, &cur_trans->chunk_bytes_reserved); 273eafa4fd0SFilipe Manana cond_wake_up(&cur_trans->chunk_reserve_wait); 274fb6dea26SJosef Bacik trans->chunk_bytes_reserved = 0; 275fb6dea26SJosef Bacik } 276fb6dea26SJosef Bacik 277fb6dea26SJosef Bacik /* 278d352ac68SChris Mason * either allocate a new transaction or hop into the existing one 279d352ac68SChris Mason */ 2802ff7e61eSJeff Mahoney static noinline int join_transaction(struct btrfs_fs_info *fs_info, 2812ff7e61eSJeff Mahoney unsigned int type) 28279154b1bSChris Mason { 28379154b1bSChris Mason struct btrfs_transaction *cur_trans; 284a4abeea4SJosef Bacik 28519ae4e81SJan Schmidt spin_lock(&fs_info->trans_lock); 286d43317dcSChris Mason loop: 28749b25e05SJeff Mahoney /* The file system has been taken offline. No new transactions. */ 28887533c47SMiao Xie if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) { 28919ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 29049b25e05SJeff Mahoney return -EROFS; 29149b25e05SJeff Mahoney } 29249b25e05SJeff Mahoney 29319ae4e81SJan Schmidt cur_trans = fs_info->running_transaction; 294a4abeea4SJosef Bacik if (cur_trans) { 295bf31f87fSDavid Sterba if (TRANS_ABORTED(cur_trans)) { 29619ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 29749b25e05SJeff Mahoney return cur_trans->aborted; 298871383beSDavid Sterba } 2994a9d8bdeSMiao Xie if (btrfs_blocked_trans_types[cur_trans->state] & type) { 300178260b2SMiao Xie spin_unlock(&fs_info->trans_lock); 301178260b2SMiao Xie return -EBUSY; 302178260b2SMiao Xie } 3039b64f57dSElena Reshetova refcount_inc(&cur_trans->use_count); 304a4abeea4SJosef Bacik atomic_inc(&cur_trans->num_writers); 3050860adfdSMiao Xie extwriter_counter_inc(cur_trans, type); 30619ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 307a4abeea4SJosef Bacik return 0; 308a4abeea4SJosef Bacik } 30919ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 310a4abeea4SJosef Bacik 311354aa0fbSMiao Xie /* 312354aa0fbSMiao Xie * If we are ATTACH, we just want to catch the current transaction, 313354aa0fbSMiao Xie * and commit it. If there is no transaction, just return ENOENT. 314354aa0fbSMiao Xie */ 315354aa0fbSMiao Xie if (type == TRANS_ATTACH) 316354aa0fbSMiao Xie return -ENOENT; 317354aa0fbSMiao Xie 3184a9d8bdeSMiao Xie /* 3194a9d8bdeSMiao Xie * JOIN_NOLOCK only happens during the transaction commit, so 3204a9d8bdeSMiao Xie * it is impossible that ->running_transaction is NULL 3214a9d8bdeSMiao Xie */ 3224a9d8bdeSMiao Xie BUG_ON(type == TRANS_JOIN_NOLOCK); 3234a9d8bdeSMiao Xie 3244b5faeacSDavid Sterba cur_trans = kmalloc(sizeof(*cur_trans), GFP_NOFS); 325db5b493aSTsutomu Itoh if (!cur_trans) 326db5b493aSTsutomu Itoh return -ENOMEM; 327d43317dcSChris Mason 32819ae4e81SJan Schmidt spin_lock(&fs_info->trans_lock); 32919ae4e81SJan Schmidt if (fs_info->running_transaction) { 330d43317dcSChris Mason /* 331d43317dcSChris Mason * someone started a transaction after we unlocked. Make sure 3324a9d8bdeSMiao Xie * to redo the checks above 333d43317dcSChris Mason */ 3344b5faeacSDavid Sterba kfree(cur_trans); 335d43317dcSChris Mason goto loop; 33687533c47SMiao Xie } else if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) { 337e4b50e14SDan Carpenter spin_unlock(&fs_info->trans_lock); 3384b5faeacSDavid Sterba kfree(cur_trans); 3397b8b92afSJosef Bacik return -EROFS; 340a4abeea4SJosef Bacik } 341d43317dcSChris Mason 342ab8d0fc4SJeff Mahoney cur_trans->fs_info = fs_info; 34348778179SFilipe Manana atomic_set(&cur_trans->pending_ordered, 0); 34448778179SFilipe Manana init_waitqueue_head(&cur_trans->pending_wait); 34513c5a93eSJosef Bacik atomic_set(&cur_trans->num_writers, 1); 3460860adfdSMiao Xie extwriter_counter_init(cur_trans, type); 34779154b1bSChris Mason init_waitqueue_head(&cur_trans->writer_wait); 34879154b1bSChris Mason init_waitqueue_head(&cur_trans->commit_wait); 3494a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_RUNNING; 350a4abeea4SJosef Bacik /* 351a4abeea4SJosef Bacik * One for this trans handle, one so it will live on until we 352a4abeea4SJosef Bacik * commit the transaction. 353a4abeea4SJosef Bacik */ 3549b64f57dSElena Reshetova refcount_set(&cur_trans->use_count, 2); 3553204d33cSJosef Bacik cur_trans->flags = 0; 356afd48513SArnd Bergmann cur_trans->start_time = ktime_get_seconds(); 35756bec294SChris Mason 358a099d0fdSAlexandru Moise memset(&cur_trans->delayed_refs, 0, sizeof(cur_trans->delayed_refs)); 359a099d0fdSAlexandru Moise 3605c9d028bSLiu Bo cur_trans->delayed_refs.href_root = RB_ROOT_CACHED; 3613368d001SQu Wenruo cur_trans->delayed_refs.dirty_extent_root = RB_ROOT; 362d7df2c79SJosef Bacik atomic_set(&cur_trans->delayed_refs.num_entries, 0); 36320b297d6SJan Schmidt 36420b297d6SJan Schmidt /* 36520b297d6SJan Schmidt * although the tree mod log is per file system and not per transaction, 36620b297d6SJan Schmidt * the log must never go across transaction boundaries. 36720b297d6SJan Schmidt */ 36820b297d6SJan Schmidt smp_mb(); 36931b1a2bdSJulia Lawall if (!list_empty(&fs_info->tree_mod_seq_list)) 3705d163e0eSJeff Mahoney WARN(1, KERN_ERR "BTRFS: tree_mod_seq_list not empty when creating a fresh transaction\n"); 37131b1a2bdSJulia Lawall if (!RB_EMPTY_ROOT(&fs_info->tree_mod_log)) 3725d163e0eSJeff Mahoney WARN(1, KERN_ERR "BTRFS: tree_mod_log rb tree not empty when creating a fresh transaction\n"); 373fc36ed7eSJan Schmidt atomic64_set(&fs_info->tree_mod_seq, 0); 37420b297d6SJan Schmidt 37556bec294SChris Mason spin_lock_init(&cur_trans->delayed_refs.lock); 37656bec294SChris Mason 3773063d29fSChris Mason INIT_LIST_HEAD(&cur_trans->pending_snapshots); 378bbbf7243SNikolay Borisov INIT_LIST_HEAD(&cur_trans->dev_update_list); 3799e351cc8SJosef Bacik INIT_LIST_HEAD(&cur_trans->switch_commits); 380ce93ec54SJosef Bacik INIT_LIST_HEAD(&cur_trans->dirty_bgs); 3811bbc621eSChris Mason INIT_LIST_HEAD(&cur_trans->io_bgs); 3822b9dbef2SJosef Bacik INIT_LIST_HEAD(&cur_trans->dropped_roots); 3831bbc621eSChris Mason mutex_init(&cur_trans->cache_write_mutex); 384ce93ec54SJosef Bacik spin_lock_init(&cur_trans->dirty_bgs_lock); 385e33e17eeSJeff Mahoney INIT_LIST_HEAD(&cur_trans->deleted_bgs); 3862b9dbef2SJosef Bacik spin_lock_init(&cur_trans->dropped_roots_lock); 387d3575156SNaohiro Aota INIT_LIST_HEAD(&cur_trans->releasing_ebs); 388d3575156SNaohiro Aota spin_lock_init(&cur_trans->releasing_ebs_lock); 389eafa4fd0SFilipe Manana atomic64_set(&cur_trans->chunk_bytes_reserved, 0); 390eafa4fd0SFilipe Manana init_waitqueue_head(&cur_trans->chunk_reserve_wait); 39119ae4e81SJan Schmidt list_add_tail(&cur_trans->list, &fs_info->trans_list); 392c258d6e3SQu Wenruo extent_io_tree_init(fs_info, &cur_trans->dirty_pages, 39343eb5f29SQu Wenruo IO_TREE_TRANS_DIRTY_PAGES, fs_info->btree_inode); 394fe119a6eSNikolay Borisov extent_io_tree_init(fs_info, &cur_trans->pinned_extents, 395fe119a6eSNikolay Borisov IO_TREE_FS_PINNED_EXTENTS, NULL); 39619ae4e81SJan Schmidt fs_info->generation++; 39719ae4e81SJan Schmidt cur_trans->transid = fs_info->generation; 39819ae4e81SJan Schmidt fs_info->running_transaction = cur_trans; 39949b25e05SJeff Mahoney cur_trans->aborted = 0; 40019ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 40115ee9bc7SJosef Bacik 40279154b1bSChris Mason return 0; 40379154b1bSChris Mason } 40479154b1bSChris Mason 405d352ac68SChris Mason /* 40692a7cc42SQu Wenruo * This does all the record keeping required to make sure that a shareable root 40792a7cc42SQu Wenruo * is properly recorded in a given transaction. This is required to make sure 40892a7cc42SQu Wenruo * the old root from before we joined the transaction is deleted when the 40992a7cc42SQu Wenruo * transaction commits. 410d352ac68SChris Mason */ 4117585717fSChris Mason static int record_root_in_trans(struct btrfs_trans_handle *trans, 4126426c7adSQu Wenruo struct btrfs_root *root, 4136426c7adSQu Wenruo int force) 4146702ed49SChris Mason { 4150b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 41603a7e111SJosef Bacik int ret = 0; 4170b246afaSJeff Mahoney 41892a7cc42SQu Wenruo if ((test_bit(BTRFS_ROOT_SHAREABLE, &root->state) && 4196426c7adSQu Wenruo root->last_trans < trans->transid) || force) { 4200b246afaSJeff Mahoney WARN_ON(root == fs_info->extent_root); 4214d31778aSQu Wenruo WARN_ON(!force && root->commit_root != root->node); 4225d4f98a2SYan Zheng 4237585717fSChris Mason /* 42427cdeb70SMiao Xie * see below for IN_TRANS_SETUP usage rules 4257585717fSChris Mason * we have the reloc mutex held now, so there 4267585717fSChris Mason * is only one writer in this function 4277585717fSChris Mason */ 42827cdeb70SMiao Xie set_bit(BTRFS_ROOT_IN_TRANS_SETUP, &root->state); 4297585717fSChris Mason 43027cdeb70SMiao Xie /* make sure readers find IN_TRANS_SETUP before 4317585717fSChris Mason * they find our root->last_trans update 4327585717fSChris Mason */ 4337585717fSChris Mason smp_wmb(); 4347585717fSChris Mason 4350b246afaSJeff Mahoney spin_lock(&fs_info->fs_roots_radix_lock); 4366426c7adSQu Wenruo if (root->last_trans == trans->transid && !force) { 4370b246afaSJeff Mahoney spin_unlock(&fs_info->fs_roots_radix_lock); 438a4abeea4SJosef Bacik return 0; 439a4abeea4SJosef Bacik } 4400b246afaSJeff Mahoney radix_tree_tag_set(&fs_info->fs_roots_radix, 4416702ed49SChris Mason (unsigned long)root->root_key.objectid, 4426702ed49SChris Mason BTRFS_ROOT_TRANS_TAG); 4430b246afaSJeff Mahoney spin_unlock(&fs_info->fs_roots_radix_lock); 4447585717fSChris Mason root->last_trans = trans->transid; 4457585717fSChris Mason 4467585717fSChris Mason /* this is pretty tricky. We don't want to 4477585717fSChris Mason * take the relocation lock in btrfs_record_root_in_trans 4487585717fSChris Mason * unless we're really doing the first setup for this root in 4497585717fSChris Mason * this transaction. 4507585717fSChris Mason * 4517585717fSChris Mason * Normally we'd use root->last_trans as a flag to decide 4527585717fSChris Mason * if we want to take the expensive mutex. 4537585717fSChris Mason * 4547585717fSChris Mason * But, we have to set root->last_trans before we 4557585717fSChris Mason * init the relocation root, otherwise, we trip over warnings 4567585717fSChris Mason * in ctree.c. The solution used here is to flag ourselves 45727cdeb70SMiao Xie * with root IN_TRANS_SETUP. When this is 1, we're still 4587585717fSChris Mason * fixing up the reloc trees and everyone must wait. 4597585717fSChris Mason * 4607585717fSChris Mason * When this is zero, they can trust root->last_trans and fly 4617585717fSChris Mason * through btrfs_record_root_in_trans without having to take the 4627585717fSChris Mason * lock. smp_wmb() makes sure that all the writes above are 4637585717fSChris Mason * done before we pop in the zero below 4647585717fSChris Mason */ 46503a7e111SJosef Bacik ret = btrfs_init_reloc_root(trans, root); 466c7548af6SChris Mason smp_mb__before_atomic(); 46727cdeb70SMiao Xie clear_bit(BTRFS_ROOT_IN_TRANS_SETUP, &root->state); 4686702ed49SChris Mason } 46903a7e111SJosef Bacik return ret; 4706702ed49SChris Mason } 4715d4f98a2SYan Zheng 4727585717fSChris Mason 4732b9dbef2SJosef Bacik void btrfs_add_dropped_root(struct btrfs_trans_handle *trans, 4742b9dbef2SJosef Bacik struct btrfs_root *root) 4752b9dbef2SJosef Bacik { 4760b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 4772b9dbef2SJosef Bacik struct btrfs_transaction *cur_trans = trans->transaction; 4782b9dbef2SJosef Bacik 4792b9dbef2SJosef Bacik /* Add ourselves to the transaction dropped list */ 4802b9dbef2SJosef Bacik spin_lock(&cur_trans->dropped_roots_lock); 4812b9dbef2SJosef Bacik list_add_tail(&root->root_list, &cur_trans->dropped_roots); 4822b9dbef2SJosef Bacik spin_unlock(&cur_trans->dropped_roots_lock); 4832b9dbef2SJosef Bacik 4842b9dbef2SJosef Bacik /* Make sure we don't try to update the root at commit time */ 4850b246afaSJeff Mahoney spin_lock(&fs_info->fs_roots_radix_lock); 4860b246afaSJeff Mahoney radix_tree_tag_clear(&fs_info->fs_roots_radix, 4872b9dbef2SJosef Bacik (unsigned long)root->root_key.objectid, 4882b9dbef2SJosef Bacik BTRFS_ROOT_TRANS_TAG); 4890b246afaSJeff Mahoney spin_unlock(&fs_info->fs_roots_radix_lock); 4902b9dbef2SJosef Bacik } 4912b9dbef2SJosef Bacik 4927585717fSChris Mason int btrfs_record_root_in_trans(struct btrfs_trans_handle *trans, 4937585717fSChris Mason struct btrfs_root *root) 4947585717fSChris Mason { 4950b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 4961409e6ccSJosef Bacik int ret; 4970b246afaSJeff Mahoney 49892a7cc42SQu Wenruo if (!test_bit(BTRFS_ROOT_SHAREABLE, &root->state)) 4997585717fSChris Mason return 0; 5007585717fSChris Mason 5017585717fSChris Mason /* 50227cdeb70SMiao Xie * see record_root_in_trans for comments about IN_TRANS_SETUP usage 5037585717fSChris Mason * and barriers 5047585717fSChris Mason */ 5057585717fSChris Mason smp_rmb(); 5067585717fSChris Mason if (root->last_trans == trans->transid && 50727cdeb70SMiao Xie !test_bit(BTRFS_ROOT_IN_TRANS_SETUP, &root->state)) 5087585717fSChris Mason return 0; 5097585717fSChris Mason 5100b246afaSJeff Mahoney mutex_lock(&fs_info->reloc_mutex); 5111409e6ccSJosef Bacik ret = record_root_in_trans(trans, root, 0); 5120b246afaSJeff Mahoney mutex_unlock(&fs_info->reloc_mutex); 5137585717fSChris Mason 5141409e6ccSJosef Bacik return ret; 5157585717fSChris Mason } 5167585717fSChris Mason 5174a9d8bdeSMiao Xie static inline int is_transaction_blocked(struct btrfs_transaction *trans) 5184a9d8bdeSMiao Xie { 5193296bf56SQu Wenruo return (trans->state >= TRANS_STATE_COMMIT_START && 520501407aaSJosef Bacik trans->state < TRANS_STATE_UNBLOCKED && 521bf31f87fSDavid Sterba !TRANS_ABORTED(trans)); 5224a9d8bdeSMiao Xie } 5234a9d8bdeSMiao Xie 524d352ac68SChris Mason /* wait for commit against the current transaction to become unblocked 525d352ac68SChris Mason * when this is done, it is safe to start a new transaction, but the current 526d352ac68SChris Mason * transaction might not be fully on disk. 527d352ac68SChris Mason */ 5282ff7e61eSJeff Mahoney static void wait_current_trans(struct btrfs_fs_info *fs_info) 52979154b1bSChris Mason { 530f9295749SChris Mason struct btrfs_transaction *cur_trans; 53179154b1bSChris Mason 5320b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 5330b246afaSJeff Mahoney cur_trans = fs_info->running_transaction; 5344a9d8bdeSMiao Xie if (cur_trans && is_transaction_blocked(cur_trans)) { 5359b64f57dSElena Reshetova refcount_inc(&cur_trans->use_count); 5360b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 53772d63ed6SLi Zefan 5380b246afaSJeff Mahoney wait_event(fs_info->transaction_wait, 539501407aaSJosef Bacik cur_trans->state >= TRANS_STATE_UNBLOCKED || 540bf31f87fSDavid Sterba TRANS_ABORTED(cur_trans)); 541724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 542a4abeea4SJosef Bacik } else { 5430b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 544f9295749SChris Mason } 54537d1aeeeSChris Mason } 54637d1aeeeSChris Mason 5472ff7e61eSJeff Mahoney static int may_wait_transaction(struct btrfs_fs_info *fs_info, int type) 54837d1aeeeSChris Mason { 5490b246afaSJeff Mahoney if (test_bit(BTRFS_FS_LOG_RECOVERING, &fs_info->flags)) 550a4abeea4SJosef Bacik return 0; 551a4abeea4SJosef Bacik 55292e2f7e3SNikolay Borisov if (type == TRANS_START) 553a4abeea4SJosef Bacik return 1; 554a4abeea4SJosef Bacik 555a22285a6SYan, Zheng return 0; 556a22285a6SYan, Zheng } 557a22285a6SYan, Zheng 55820dd2cbfSMiao Xie static inline bool need_reserve_reloc_root(struct btrfs_root *root) 55920dd2cbfSMiao Xie { 5600b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 5610b246afaSJeff Mahoney 5620b246afaSJeff Mahoney if (!fs_info->reloc_ctl || 56392a7cc42SQu Wenruo !test_bit(BTRFS_ROOT_SHAREABLE, &root->state) || 56420dd2cbfSMiao Xie root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID || 56520dd2cbfSMiao Xie root->reloc_root) 56620dd2cbfSMiao Xie return false; 56720dd2cbfSMiao Xie 56820dd2cbfSMiao Xie return true; 56920dd2cbfSMiao Xie } 57020dd2cbfSMiao Xie 57108e007d2SMiao Xie static struct btrfs_trans_handle * 5725aed1dd8SAlexandru Moise start_transaction(struct btrfs_root *root, unsigned int num_items, 573003d7c59SJeff Mahoney unsigned int type, enum btrfs_reserve_flush_enum flush, 574003d7c59SJeff Mahoney bool enforce_qgroups) 575a22285a6SYan, Zheng { 5760b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 577ba2c4d4eSJosef Bacik struct btrfs_block_rsv *delayed_refs_rsv = &fs_info->delayed_refs_rsv; 578a22285a6SYan, Zheng struct btrfs_trans_handle *h; 579a22285a6SYan, Zheng struct btrfs_transaction *cur_trans; 580b5009945SJosef Bacik u64 num_bytes = 0; 581c5567237SArne Jansen u64 qgroup_reserved = 0; 58220dd2cbfSMiao Xie bool reloc_reserved = false; 5839c343784SJosef Bacik bool do_chunk_alloc = false; 58420dd2cbfSMiao Xie int ret; 585acce952bSliubo 58646c4e71eSFilipe Manana /* Send isn't supposed to start transactions. */ 5872755a0deSDavid Sterba ASSERT(current->journal_info != BTRFS_SEND_TRANS_STUB); 58846c4e71eSFilipe Manana 5890b246afaSJeff Mahoney if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) 590acce952bSliubo return ERR_PTR(-EROFS); 5912a1eb461SJosef Bacik 59246c4e71eSFilipe Manana if (current->journal_info) { 5930860adfdSMiao Xie WARN_ON(type & TRANS_EXTWRITERS); 5942a1eb461SJosef Bacik h = current->journal_info; 595b50fff81SDavid Sterba refcount_inc(&h->use_count); 596b50fff81SDavid Sterba WARN_ON(refcount_read(&h->use_count) > 2); 5972a1eb461SJosef Bacik h->orig_rsv = h->block_rsv; 5982a1eb461SJosef Bacik h->block_rsv = NULL; 5992a1eb461SJosef Bacik goto got_it; 6002a1eb461SJosef Bacik } 601b5009945SJosef Bacik 602b5009945SJosef Bacik /* 603b5009945SJosef Bacik * Do the reservation before we join the transaction so we can do all 604b5009945SJosef Bacik * the appropriate flushing if need be. 605b5009945SJosef Bacik */ 606003d7c59SJeff Mahoney if (num_items && root != fs_info->chunk_root) { 607ba2c4d4eSJosef Bacik struct btrfs_block_rsv *rsv = &fs_info->trans_block_rsv; 608ba2c4d4eSJosef Bacik u64 delayed_refs_bytes = 0; 609ba2c4d4eSJosef Bacik 6100b246afaSJeff Mahoney qgroup_reserved = num_items * fs_info->nodesize; 611733e03a0SQu Wenruo ret = btrfs_qgroup_reserve_meta_pertrans(root, qgroup_reserved, 612003d7c59SJeff Mahoney enforce_qgroups); 613c5567237SArne Jansen if (ret) 614c5567237SArne Jansen return ERR_PTR(ret); 615c5567237SArne Jansen 616ba2c4d4eSJosef Bacik /* 617ba2c4d4eSJosef Bacik * We want to reserve all the bytes we may need all at once, so 618ba2c4d4eSJosef Bacik * we only do 1 enospc flushing cycle per transaction start. We 619ba2c4d4eSJosef Bacik * accomplish this by simply assuming we'll do 2 x num_items 620ba2c4d4eSJosef Bacik * worth of delayed refs updates in this trans handle, and 621ba2c4d4eSJosef Bacik * refill that amount for whatever is missing in the reserve. 622ba2c4d4eSJosef Bacik */ 6232bd36e7bSJosef Bacik num_bytes = btrfs_calc_insert_metadata_size(fs_info, num_items); 6247f9fe614SJosef Bacik if (flush == BTRFS_RESERVE_FLUSH_ALL && 6257f9fe614SJosef Bacik delayed_refs_rsv->full == 0) { 626ba2c4d4eSJosef Bacik delayed_refs_bytes = num_bytes; 627ba2c4d4eSJosef Bacik num_bytes <<= 1; 628ba2c4d4eSJosef Bacik } 629ba2c4d4eSJosef Bacik 63020dd2cbfSMiao Xie /* 63120dd2cbfSMiao Xie * Do the reservation for the relocation root creation 63220dd2cbfSMiao Xie */ 633ee39b432SDavid Sterba if (need_reserve_reloc_root(root)) { 6340b246afaSJeff Mahoney num_bytes += fs_info->nodesize; 63520dd2cbfSMiao Xie reloc_reserved = true; 63620dd2cbfSMiao Xie } 63720dd2cbfSMiao Xie 638ba2c4d4eSJosef Bacik ret = btrfs_block_rsv_add(root, rsv, num_bytes, flush); 639ba2c4d4eSJosef Bacik if (ret) 640ba2c4d4eSJosef Bacik goto reserve_fail; 641ba2c4d4eSJosef Bacik if (delayed_refs_bytes) { 642ba2c4d4eSJosef Bacik btrfs_migrate_to_delayed_refs_rsv(fs_info, rsv, 643ba2c4d4eSJosef Bacik delayed_refs_bytes); 644ba2c4d4eSJosef Bacik num_bytes -= delayed_refs_bytes; 645ba2c4d4eSJosef Bacik } 6469c343784SJosef Bacik 6479c343784SJosef Bacik if (rsv->space_info->force_alloc) 6489c343784SJosef Bacik do_chunk_alloc = true; 649ba2c4d4eSJosef Bacik } else if (num_items == 0 && flush == BTRFS_RESERVE_FLUSH_ALL && 650ba2c4d4eSJosef Bacik !delayed_refs_rsv->full) { 651ba2c4d4eSJosef Bacik /* 652ba2c4d4eSJosef Bacik * Some people call with btrfs_start_transaction(root, 0) 653ba2c4d4eSJosef Bacik * because they can be throttled, but have some other mechanism 654ba2c4d4eSJosef Bacik * for reserving space. We still want these guys to refill the 655ba2c4d4eSJosef Bacik * delayed block_rsv so just add 1 items worth of reservation 656ba2c4d4eSJosef Bacik * here. 657ba2c4d4eSJosef Bacik */ 658ba2c4d4eSJosef Bacik ret = btrfs_delayed_refs_rsv_refill(fs_info, flush); 659b5009945SJosef Bacik if (ret) 660843fcf35SMiao Xie goto reserve_fail; 661b5009945SJosef Bacik } 662a22285a6SYan, Zheng again: 663f2f767e7SAlexandru Moise h = kmem_cache_zalloc(btrfs_trans_handle_cachep, GFP_NOFS); 664843fcf35SMiao Xie if (!h) { 665843fcf35SMiao Xie ret = -ENOMEM; 666843fcf35SMiao Xie goto alloc_fail; 667843fcf35SMiao Xie } 668a22285a6SYan, Zheng 66998114659SJosef Bacik /* 67098114659SJosef Bacik * If we are JOIN_NOLOCK we're already committing a transaction and 67198114659SJosef Bacik * waiting on this guy, so we don't need to do the sb_start_intwrite 67298114659SJosef Bacik * because we're already holding a ref. We need this because we could 67398114659SJosef Bacik * have raced in and did an fsync() on a file which can kick a commit 67498114659SJosef Bacik * and then we deadlock with somebody doing a freeze. 675354aa0fbSMiao Xie * 676354aa0fbSMiao Xie * If we are ATTACH, it means we just want to catch the current 677354aa0fbSMiao Xie * transaction and commit it, so we needn't do sb_start_intwrite(). 67898114659SJosef Bacik */ 6790860adfdSMiao Xie if (type & __TRANS_FREEZABLE) 6800b246afaSJeff Mahoney sb_start_intwrite(fs_info->sb); 681b2b5ef5cSJan Kara 6822ff7e61eSJeff Mahoney if (may_wait_transaction(fs_info, type)) 6832ff7e61eSJeff Mahoney wait_current_trans(fs_info); 684a22285a6SYan, Zheng 685a4abeea4SJosef Bacik do { 6862ff7e61eSJeff Mahoney ret = join_transaction(fs_info, type); 687178260b2SMiao Xie if (ret == -EBUSY) { 6882ff7e61eSJeff Mahoney wait_current_trans(fs_info); 689a6d155d2SFilipe Manana if (unlikely(type == TRANS_ATTACH || 690a6d155d2SFilipe Manana type == TRANS_JOIN_NOSTART)) 691178260b2SMiao Xie ret = -ENOENT; 692178260b2SMiao Xie } 693a4abeea4SJosef Bacik } while (ret == -EBUSY); 694a4abeea4SJosef Bacik 695a43f7f82SLiu Bo if (ret < 0) 696843fcf35SMiao Xie goto join_fail; 6970f7d52f4SChris Mason 6980b246afaSJeff Mahoney cur_trans = fs_info->running_transaction; 699a22285a6SYan, Zheng 700a22285a6SYan, Zheng h->transid = cur_trans->transid; 701a22285a6SYan, Zheng h->transaction = cur_trans; 702d13603efSArne Jansen h->root = root; 703b50fff81SDavid Sterba refcount_set(&h->use_count, 1); 70464b63580SJeff Mahoney h->fs_info = root->fs_info; 7057174109cSQu Wenruo 706a698d075SMiao Xie h->type = type; 707d9a0540aSFilipe Manana h->can_flush_pending_bgs = true; 708ea658badSJosef Bacik INIT_LIST_HEAD(&h->new_bgs); 709b7ec40d7SChris Mason 710a22285a6SYan, Zheng smp_mb(); 7113296bf56SQu Wenruo if (cur_trans->state >= TRANS_STATE_COMMIT_START && 7122ff7e61eSJeff Mahoney may_wait_transaction(fs_info, type)) { 713abdd2e80SFilipe Manana current->journal_info = h; 7143a45bb20SJeff Mahoney btrfs_commit_transaction(h); 715a22285a6SYan, Zheng goto again; 716a22285a6SYan, Zheng } 7179ed74f2dSJosef Bacik 718b5009945SJosef Bacik if (num_bytes) { 7190b246afaSJeff Mahoney trace_btrfs_space_reservation(fs_info, "transaction", 7202bcc0328SLiu Bo h->transid, num_bytes, 1); 7210b246afaSJeff Mahoney h->block_rsv = &fs_info->trans_block_rsv; 722b5009945SJosef Bacik h->bytes_reserved = num_bytes; 72320dd2cbfSMiao Xie h->reloc_reserved = reloc_reserved; 724a22285a6SYan, Zheng } 725a22285a6SYan, Zheng 7262a1eb461SJosef Bacik got_it: 727bcf3a3e7SNikolay Borisov if (!current->journal_info) 728a22285a6SYan, Zheng current->journal_info = h; 729fcc99734SQu Wenruo 730fcc99734SQu Wenruo /* 7319c343784SJosef Bacik * If the space_info is marked ALLOC_FORCE then we'll get upgraded to 7329c343784SJosef Bacik * ALLOC_FORCE the first run through, and then we won't allocate for 7339c343784SJosef Bacik * anybody else who races in later. We don't care about the return 7349c343784SJosef Bacik * value here. 7359c343784SJosef Bacik */ 7369c343784SJosef Bacik if (do_chunk_alloc && num_bytes) { 7379c343784SJosef Bacik u64 flags = h->block_rsv->space_info->flags; 7389c343784SJosef Bacik 7399c343784SJosef Bacik btrfs_chunk_alloc(h, btrfs_get_alloc_profile(fs_info, flags), 7409c343784SJosef Bacik CHUNK_ALLOC_NO_FORCE); 7419c343784SJosef Bacik } 7429c343784SJosef Bacik 7439c343784SJosef Bacik /* 744fcc99734SQu Wenruo * btrfs_record_root_in_trans() needs to alloc new extents, and may 745fcc99734SQu Wenruo * call btrfs_join_transaction() while we're also starting a 746fcc99734SQu Wenruo * transaction. 747fcc99734SQu Wenruo * 748fcc99734SQu Wenruo * Thus it need to be called after current->journal_info initialized, 749fcc99734SQu Wenruo * or we can deadlock. 750fcc99734SQu Wenruo */ 75168075ea8SJosef Bacik ret = btrfs_record_root_in_trans(h, root); 75268075ea8SJosef Bacik if (ret) { 75368075ea8SJosef Bacik /* 75468075ea8SJosef Bacik * The transaction handle is fully initialized and linked with 75568075ea8SJosef Bacik * other structures so it needs to be ended in case of errors, 75668075ea8SJosef Bacik * not just freed. 75768075ea8SJosef Bacik */ 75868075ea8SJosef Bacik btrfs_end_transaction(h); 75968075ea8SJosef Bacik return ERR_PTR(ret); 76068075ea8SJosef Bacik } 761fcc99734SQu Wenruo 76279154b1bSChris Mason return h; 763843fcf35SMiao Xie 764843fcf35SMiao Xie join_fail: 7650860adfdSMiao Xie if (type & __TRANS_FREEZABLE) 7660b246afaSJeff Mahoney sb_end_intwrite(fs_info->sb); 767843fcf35SMiao Xie kmem_cache_free(btrfs_trans_handle_cachep, h); 768843fcf35SMiao Xie alloc_fail: 769843fcf35SMiao Xie if (num_bytes) 7702ff7e61eSJeff Mahoney btrfs_block_rsv_release(fs_info, &fs_info->trans_block_rsv, 77163f018beSNikolay Borisov num_bytes, NULL); 772843fcf35SMiao Xie reserve_fail: 773733e03a0SQu Wenruo btrfs_qgroup_free_meta_pertrans(root, qgroup_reserved); 774843fcf35SMiao Xie return ERR_PTR(ret); 77579154b1bSChris Mason } 77679154b1bSChris Mason 777f9295749SChris Mason struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root, 7785aed1dd8SAlexandru Moise unsigned int num_items) 779f9295749SChris Mason { 78008e007d2SMiao Xie return start_transaction(root, num_items, TRANS_START, 781003d7c59SJeff Mahoney BTRFS_RESERVE_FLUSH_ALL, true); 782f9295749SChris Mason } 783003d7c59SJeff Mahoney 7848eab77ffSFilipe Manana struct btrfs_trans_handle *btrfs_start_transaction_fallback_global_rsv( 7858eab77ffSFilipe Manana struct btrfs_root *root, 7867f9fe614SJosef Bacik unsigned int num_items) 7878eab77ffSFilipe Manana { 7887f9fe614SJosef Bacik return start_transaction(root, num_items, TRANS_START, 7897f9fe614SJosef Bacik BTRFS_RESERVE_FLUSH_ALL_STEAL, false); 7908eab77ffSFilipe Manana } 7918407aa46SMiao Xie 7927a7eaa40SJosef Bacik struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root) 793f9295749SChris Mason { 794003d7c59SJeff Mahoney return start_transaction(root, 0, TRANS_JOIN, BTRFS_RESERVE_NO_FLUSH, 795003d7c59SJeff Mahoney true); 796f9295749SChris Mason } 797f9295749SChris Mason 7988d510121SNikolay Borisov struct btrfs_trans_handle *btrfs_join_transaction_spacecache(struct btrfs_root *root) 7990af3d00bSJosef Bacik { 800575a75d6SAlexandru Moise return start_transaction(root, 0, TRANS_JOIN_NOLOCK, 801003d7c59SJeff Mahoney BTRFS_RESERVE_NO_FLUSH, true); 8020af3d00bSJosef Bacik } 8030af3d00bSJosef Bacik 804d4edf39bSMiao Xie /* 805a6d155d2SFilipe Manana * Similar to regular join but it never starts a transaction when none is 806a6d155d2SFilipe Manana * running or after waiting for the current one to finish. 807a6d155d2SFilipe Manana */ 808a6d155d2SFilipe Manana struct btrfs_trans_handle *btrfs_join_transaction_nostart(struct btrfs_root *root) 809a6d155d2SFilipe Manana { 810a6d155d2SFilipe Manana return start_transaction(root, 0, TRANS_JOIN_NOSTART, 811a6d155d2SFilipe Manana BTRFS_RESERVE_NO_FLUSH, true); 812a6d155d2SFilipe Manana } 813a6d155d2SFilipe Manana 814a6d155d2SFilipe Manana /* 815d4edf39bSMiao Xie * btrfs_attach_transaction() - catch the running transaction 816d4edf39bSMiao Xie * 817d4edf39bSMiao Xie * It is used when we want to commit the current the transaction, but 818d4edf39bSMiao Xie * don't want to start a new one. 819d4edf39bSMiao Xie * 820d4edf39bSMiao Xie * Note: If this function return -ENOENT, it just means there is no 821d4edf39bSMiao Xie * running transaction. But it is possible that the inactive transaction 822d4edf39bSMiao Xie * is still in the memory, not fully on disk. If you hope there is no 823d4edf39bSMiao Xie * inactive transaction in the fs when -ENOENT is returned, you should 824d4edf39bSMiao Xie * invoke 825d4edf39bSMiao Xie * btrfs_attach_transaction_barrier() 826d4edf39bSMiao Xie */ 827354aa0fbSMiao Xie struct btrfs_trans_handle *btrfs_attach_transaction(struct btrfs_root *root) 82860376ce4SJosef Bacik { 829575a75d6SAlexandru Moise return start_transaction(root, 0, TRANS_ATTACH, 830003d7c59SJeff Mahoney BTRFS_RESERVE_NO_FLUSH, true); 83160376ce4SJosef Bacik } 83260376ce4SJosef Bacik 833d4edf39bSMiao Xie /* 83490b6d283SWang Sheng-Hui * btrfs_attach_transaction_barrier() - catch the running transaction 835d4edf39bSMiao Xie * 83652042d8eSAndrea Gelmini * It is similar to the above function, the difference is this one 837d4edf39bSMiao Xie * will wait for all the inactive transactions until they fully 838d4edf39bSMiao Xie * complete. 839d4edf39bSMiao Xie */ 840d4edf39bSMiao Xie struct btrfs_trans_handle * 841d4edf39bSMiao Xie btrfs_attach_transaction_barrier(struct btrfs_root *root) 842d4edf39bSMiao Xie { 843d4edf39bSMiao Xie struct btrfs_trans_handle *trans; 844d4edf39bSMiao Xie 845575a75d6SAlexandru Moise trans = start_transaction(root, 0, TRANS_ATTACH, 846003d7c59SJeff Mahoney BTRFS_RESERVE_NO_FLUSH, true); 8478d9e220cSAl Viro if (trans == ERR_PTR(-ENOENT)) 8482ff7e61eSJeff Mahoney btrfs_wait_for_commit(root->fs_info, 0); 849d4edf39bSMiao Xie 850d4edf39bSMiao Xie return trans; 851d4edf39bSMiao Xie } 852d4edf39bSMiao Xie 853d0c2f4faSFilipe Manana /* Wait for a transaction commit to reach at least the given state. */ 854d0c2f4faSFilipe Manana static noinline void wait_for_commit(struct btrfs_transaction *commit, 855d0c2f4faSFilipe Manana const enum btrfs_trans_state min_state) 85689ce8a63SChris Mason { 857d0c2f4faSFilipe Manana wait_event(commit->commit_wait, commit->state >= min_state); 85889ce8a63SChris Mason } 85989ce8a63SChris Mason 8602ff7e61eSJeff Mahoney int btrfs_wait_for_commit(struct btrfs_fs_info *fs_info, u64 transid) 86146204592SSage Weil { 86246204592SSage Weil struct btrfs_transaction *cur_trans = NULL, *t; 8638cd2807fSMiao Xie int ret = 0; 86446204592SSage Weil 86546204592SSage Weil if (transid) { 8660b246afaSJeff Mahoney if (transid <= fs_info->last_trans_committed) 867a4abeea4SJosef Bacik goto out; 86846204592SSage Weil 86946204592SSage Weil /* find specified transaction */ 8700b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 8710b246afaSJeff Mahoney list_for_each_entry(t, &fs_info->trans_list, list) { 87246204592SSage Weil if (t->transid == transid) { 87346204592SSage Weil cur_trans = t; 8749b64f57dSElena Reshetova refcount_inc(&cur_trans->use_count); 8758cd2807fSMiao Xie ret = 0; 87646204592SSage Weil break; 87746204592SSage Weil } 8788cd2807fSMiao Xie if (t->transid > transid) { 8798cd2807fSMiao Xie ret = 0; 88046204592SSage Weil break; 88146204592SSage Weil } 8828cd2807fSMiao Xie } 8830b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 88442383020SSage Weil 88542383020SSage Weil /* 88642383020SSage Weil * The specified transaction doesn't exist, or we 88742383020SSage Weil * raced with btrfs_commit_transaction 88842383020SSage Weil */ 88942383020SSage Weil if (!cur_trans) { 8900b246afaSJeff Mahoney if (transid > fs_info->last_trans_committed) 89142383020SSage Weil ret = -EINVAL; 8928cd2807fSMiao Xie goto out; 89342383020SSage Weil } 89446204592SSage Weil } else { 89546204592SSage Weil /* find newest transaction that is committing | committed */ 8960b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 8970b246afaSJeff Mahoney list_for_each_entry_reverse(t, &fs_info->trans_list, 89846204592SSage Weil list) { 8994a9d8bdeSMiao Xie if (t->state >= TRANS_STATE_COMMIT_START) { 9004a9d8bdeSMiao Xie if (t->state == TRANS_STATE_COMPLETED) 9013473f3c0SJosef Bacik break; 90246204592SSage Weil cur_trans = t; 9039b64f57dSElena Reshetova refcount_inc(&cur_trans->use_count); 90446204592SSage Weil break; 90546204592SSage Weil } 90646204592SSage Weil } 9070b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 90846204592SSage Weil if (!cur_trans) 909a4abeea4SJosef Bacik goto out; /* nothing committing|committed */ 91046204592SSage Weil } 91146204592SSage Weil 912d0c2f4faSFilipe Manana wait_for_commit(cur_trans, TRANS_STATE_COMPLETED); 913724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 914a4abeea4SJosef Bacik out: 91546204592SSage Weil return ret; 91646204592SSage Weil } 91746204592SSage Weil 9182ff7e61eSJeff Mahoney void btrfs_throttle(struct btrfs_fs_info *fs_info) 91937d1aeeeSChris Mason { 9202ff7e61eSJeff Mahoney wait_current_trans(fs_info); 92137d1aeeeSChris Mason } 92237d1aeeeSChris Mason 9238a8f4deaSNikolay Borisov static bool should_end_transaction(struct btrfs_trans_handle *trans) 9248929ecfaSYan, Zheng { 9252ff7e61eSJeff Mahoney struct btrfs_fs_info *fs_info = trans->fs_info; 9260b246afaSJeff Mahoney 92764403612SJosef Bacik if (btrfs_check_space_for_delayed_refs(fs_info)) 9288a8f4deaSNikolay Borisov return true; 92936ba022aSJosef Bacik 9302ff7e61eSJeff Mahoney return !!btrfs_block_rsv_check(&fs_info->global_block_rsv, 5); 9318929ecfaSYan, Zheng } 9328929ecfaSYan, Zheng 933a2633b6aSNikolay Borisov bool btrfs_should_end_transaction(struct btrfs_trans_handle *trans) 9348929ecfaSYan, Zheng { 9358929ecfaSYan, Zheng struct btrfs_transaction *cur_trans = trans->transaction; 9368929ecfaSYan, Zheng 9373296bf56SQu Wenruo if (cur_trans->state >= TRANS_STATE_COMMIT_START || 938e19eb11fSJosef Bacik test_bit(BTRFS_DELAYED_REFS_FLUSHING, &cur_trans->delayed_refs.flags)) 939a2633b6aSNikolay Borisov return true; 9408929ecfaSYan, Zheng 9412ff7e61eSJeff Mahoney return should_end_transaction(trans); 9428929ecfaSYan, Zheng } 9438929ecfaSYan, Zheng 944dc60c525SNikolay Borisov static void btrfs_trans_release_metadata(struct btrfs_trans_handle *trans) 945dc60c525SNikolay Borisov 9460e34693fSNikolay Borisov { 947dc60c525SNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 948dc60c525SNikolay Borisov 9490e34693fSNikolay Borisov if (!trans->block_rsv) { 9500e34693fSNikolay Borisov ASSERT(!trans->bytes_reserved); 9510e34693fSNikolay Borisov return; 9520e34693fSNikolay Borisov } 9530e34693fSNikolay Borisov 9540e34693fSNikolay Borisov if (!trans->bytes_reserved) 9550e34693fSNikolay Borisov return; 9560e34693fSNikolay Borisov 9570e34693fSNikolay Borisov ASSERT(trans->block_rsv == &fs_info->trans_block_rsv); 9580e34693fSNikolay Borisov trace_btrfs_space_reservation(fs_info, "transaction", 9590e34693fSNikolay Borisov trans->transid, trans->bytes_reserved, 0); 9600e34693fSNikolay Borisov btrfs_block_rsv_release(fs_info, trans->block_rsv, 96163f018beSNikolay Borisov trans->bytes_reserved, NULL); 9620e34693fSNikolay Borisov trans->bytes_reserved = 0; 9630e34693fSNikolay Borisov } 9640e34693fSNikolay Borisov 96589ce8a63SChris Mason static int __btrfs_end_transaction(struct btrfs_trans_handle *trans, 9663a45bb20SJeff Mahoney int throttle) 96779154b1bSChris Mason { 9683a45bb20SJeff Mahoney struct btrfs_fs_info *info = trans->fs_info; 9698929ecfaSYan, Zheng struct btrfs_transaction *cur_trans = trans->transaction; 9704edc2ca3SDave Jones int err = 0; 971d6e4a428SChris Mason 972b50fff81SDavid Sterba if (refcount_read(&trans->use_count) > 1) { 973b50fff81SDavid Sterba refcount_dec(&trans->use_count); 9742a1eb461SJosef Bacik trans->block_rsv = trans->orig_rsv; 9752a1eb461SJosef Bacik return 0; 9762a1eb461SJosef Bacik } 9772a1eb461SJosef Bacik 978dc60c525SNikolay Borisov btrfs_trans_release_metadata(trans); 9794c13d758SJosef Bacik trans->block_rsv = NULL; 980c5567237SArne Jansen 9816c686b35SNikolay Borisov btrfs_create_pending_block_groups(trans); 982ea658badSJosef Bacik 9834fbcdf66SFilipe Manana btrfs_trans_release_chunk_metadata(trans); 9844fbcdf66SFilipe Manana 9850860adfdSMiao Xie if (trans->type & __TRANS_FREEZABLE) 9860b246afaSJeff Mahoney sb_end_intwrite(info->sb); 9876df7881aSJosef Bacik 9888929ecfaSYan, Zheng WARN_ON(cur_trans != info->running_transaction); 98913c5a93eSJosef Bacik WARN_ON(atomic_read(&cur_trans->num_writers) < 1); 99013c5a93eSJosef Bacik atomic_dec(&cur_trans->num_writers); 9910860adfdSMiao Xie extwriter_counter_dec(cur_trans, trans->type); 99289ce8a63SChris Mason 993093258e6SDavid Sterba cond_wake_up(&cur_trans->writer_wait); 994724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 9959ed74f2dSJosef Bacik 9969ed74f2dSJosef Bacik if (current->journal_info == trans) 9979ed74f2dSJosef Bacik current->journal_info = NULL; 998ab78c84dSChris Mason 99924bbcf04SYan, Zheng if (throttle) 10002ff7e61eSJeff Mahoney btrfs_run_delayed_iputs(info); 100124bbcf04SYan, Zheng 1002bf31f87fSDavid Sterba if (TRANS_ABORTED(trans) || 10030b246afaSJeff Mahoney test_bit(BTRFS_FS_STATE_ERROR, &info->fs_state)) { 10044e121c06SJosef Bacik wake_up_process(info->transaction_kthread); 1005fbabd4a3SJosef Bacik if (TRANS_ABORTED(trans)) 1006fbabd4a3SJosef Bacik err = trans->aborted; 1007fbabd4a3SJosef Bacik else 1008fbabd4a3SJosef Bacik err = -EROFS; 10094e121c06SJosef Bacik } 101049b25e05SJeff Mahoney 10114edc2ca3SDave Jones kmem_cache_free(btrfs_trans_handle_cachep, trans); 10124edc2ca3SDave Jones return err; 101379154b1bSChris Mason } 101479154b1bSChris Mason 10153a45bb20SJeff Mahoney int btrfs_end_transaction(struct btrfs_trans_handle *trans) 101689ce8a63SChris Mason { 10173a45bb20SJeff Mahoney return __btrfs_end_transaction(trans, 0); 101889ce8a63SChris Mason } 101989ce8a63SChris Mason 10203a45bb20SJeff Mahoney int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans) 102189ce8a63SChris Mason { 10223a45bb20SJeff Mahoney return __btrfs_end_transaction(trans, 1); 102316cdcec7SMiao Xie } 102416cdcec7SMiao Xie 1025d352ac68SChris Mason /* 1026d352ac68SChris Mason * when btree blocks are allocated, they have some corresponding bits set for 1027d352ac68SChris Mason * them in one of two extent_io trees. This is used to make sure all of 1028690587d1SChris Mason * those extents are sent to disk but does not wait on them 1029d352ac68SChris Mason */ 10302ff7e61eSJeff Mahoney int btrfs_write_marked_extents(struct btrfs_fs_info *fs_info, 10318cef4e16SYan, Zheng struct extent_io_tree *dirty_pages, int mark) 103279154b1bSChris Mason { 1033777e6bd7SChris Mason int err = 0; 10347c4452b9SChris Mason int werr = 0; 10350b246afaSJeff Mahoney struct address_space *mapping = fs_info->btree_inode->i_mapping; 1036e6138876SJosef Bacik struct extent_state *cached_state = NULL; 1037777e6bd7SChris Mason u64 start = 0; 10385f39d397SChris Mason u64 end; 10397c4452b9SChris Mason 10406300463bSLiu Bo atomic_inc(&BTRFS_I(fs_info->btree_inode)->sync_writers); 10411728366eSJosef Bacik while (!find_first_extent_bit(dirty_pages, start, &start, &end, 1042e6138876SJosef Bacik mark, &cached_state)) { 1043663dfbb0SFilipe Manana bool wait_writeback = false; 1044663dfbb0SFilipe Manana 1045663dfbb0SFilipe Manana err = convert_extent_bit(dirty_pages, start, end, 1046663dfbb0SFilipe Manana EXTENT_NEED_WAIT, 1047210aa277SDavid Sterba mark, &cached_state); 1048663dfbb0SFilipe Manana /* 1049663dfbb0SFilipe Manana * convert_extent_bit can return -ENOMEM, which is most of the 1050663dfbb0SFilipe Manana * time a temporary error. So when it happens, ignore the error 1051663dfbb0SFilipe Manana * and wait for writeback of this range to finish - because we 1052663dfbb0SFilipe Manana * failed to set the bit EXTENT_NEED_WAIT for the range, a call 1053bf89d38fSJeff Mahoney * to __btrfs_wait_marked_extents() would not know that 1054bf89d38fSJeff Mahoney * writeback for this range started and therefore wouldn't 1055bf89d38fSJeff Mahoney * wait for it to finish - we don't want to commit a 1056bf89d38fSJeff Mahoney * superblock that points to btree nodes/leafs for which 1057bf89d38fSJeff Mahoney * writeback hasn't finished yet (and without errors). 1058663dfbb0SFilipe Manana * We cleanup any entries left in the io tree when committing 105941e7acd3SNikolay Borisov * the transaction (through extent_io_tree_release()). 1060663dfbb0SFilipe Manana */ 1061663dfbb0SFilipe Manana if (err == -ENOMEM) { 1062663dfbb0SFilipe Manana err = 0; 1063663dfbb0SFilipe Manana wait_writeback = true; 1064663dfbb0SFilipe Manana } 1065663dfbb0SFilipe Manana if (!err) 10661728366eSJosef Bacik err = filemap_fdatawrite_range(mapping, start, end); 10677c4452b9SChris Mason if (err) 10687c4452b9SChris Mason werr = err; 1069663dfbb0SFilipe Manana else if (wait_writeback) 1070663dfbb0SFilipe Manana werr = filemap_fdatawait_range(mapping, start, end); 1071e38e2ed7SFilipe Manana free_extent_state(cached_state); 1072663dfbb0SFilipe Manana cached_state = NULL; 10731728366eSJosef Bacik cond_resched(); 10741728366eSJosef Bacik start = end + 1; 10757c4452b9SChris Mason } 10766300463bSLiu Bo atomic_dec(&BTRFS_I(fs_info->btree_inode)->sync_writers); 1077690587d1SChris Mason return werr; 1078690587d1SChris Mason } 1079690587d1SChris Mason 1080690587d1SChris Mason /* 1081690587d1SChris Mason * when btree blocks are allocated, they have some corresponding bits set for 1082690587d1SChris Mason * them in one of two extent_io trees. This is used to make sure all of 1083690587d1SChris Mason * those extents are on disk for transaction or log commit. We wait 1084690587d1SChris Mason * on all the pages and clear them from the dirty pages state tree 1085690587d1SChris Mason */ 1086bf89d38fSJeff Mahoney static int __btrfs_wait_marked_extents(struct btrfs_fs_info *fs_info, 1087bf89d38fSJeff Mahoney struct extent_io_tree *dirty_pages) 1088690587d1SChris Mason { 1089690587d1SChris Mason int err = 0; 1090690587d1SChris Mason int werr = 0; 10910b246afaSJeff Mahoney struct address_space *mapping = fs_info->btree_inode->i_mapping; 1092e6138876SJosef Bacik struct extent_state *cached_state = NULL; 1093690587d1SChris Mason u64 start = 0; 1094690587d1SChris Mason u64 end; 1095690587d1SChris Mason 10961728366eSJosef Bacik while (!find_first_extent_bit(dirty_pages, start, &start, &end, 1097e6138876SJosef Bacik EXTENT_NEED_WAIT, &cached_state)) { 1098663dfbb0SFilipe Manana /* 1099663dfbb0SFilipe Manana * Ignore -ENOMEM errors returned by clear_extent_bit(). 1100663dfbb0SFilipe Manana * When committing the transaction, we'll remove any entries 1101663dfbb0SFilipe Manana * left in the io tree. For a log commit, we don't remove them 1102663dfbb0SFilipe Manana * after committing the log because the tree can be accessed 1103663dfbb0SFilipe Manana * concurrently - we do it only at transaction commit time when 110441e7acd3SNikolay Borisov * it's safe to do it (through extent_io_tree_release()). 1105663dfbb0SFilipe Manana */ 1106663dfbb0SFilipe Manana err = clear_extent_bit(dirty_pages, start, end, 1107ae0f1625SDavid Sterba EXTENT_NEED_WAIT, 0, 0, &cached_state); 1108663dfbb0SFilipe Manana if (err == -ENOMEM) 1109663dfbb0SFilipe Manana err = 0; 1110663dfbb0SFilipe Manana if (!err) 11111728366eSJosef Bacik err = filemap_fdatawait_range(mapping, start, end); 1112777e6bd7SChris Mason if (err) 1113777e6bd7SChris Mason werr = err; 1114e38e2ed7SFilipe Manana free_extent_state(cached_state); 1115e38e2ed7SFilipe Manana cached_state = NULL; 1116777e6bd7SChris Mason cond_resched(); 11171728366eSJosef Bacik start = end + 1; 1118777e6bd7SChris Mason } 11197c4452b9SChris Mason if (err) 11207c4452b9SChris Mason werr = err; 1121bf89d38fSJeff Mahoney return werr; 1122bf89d38fSJeff Mahoney } 1123656f30dbSFilipe Manana 1124b9fae2ebSFilipe Manana static int btrfs_wait_extents(struct btrfs_fs_info *fs_info, 1125bf89d38fSJeff Mahoney struct extent_io_tree *dirty_pages) 1126bf89d38fSJeff Mahoney { 1127bf89d38fSJeff Mahoney bool errors = false; 1128bf89d38fSJeff Mahoney int err; 1129bf89d38fSJeff Mahoney 1130bf89d38fSJeff Mahoney err = __btrfs_wait_marked_extents(fs_info, dirty_pages); 1131bf89d38fSJeff Mahoney if (test_and_clear_bit(BTRFS_FS_BTREE_ERR, &fs_info->flags)) 1132bf89d38fSJeff Mahoney errors = true; 1133bf89d38fSJeff Mahoney 1134bf89d38fSJeff Mahoney if (errors && !err) 1135bf89d38fSJeff Mahoney err = -EIO; 1136bf89d38fSJeff Mahoney return err; 1137bf89d38fSJeff Mahoney } 1138bf89d38fSJeff Mahoney 1139bf89d38fSJeff Mahoney int btrfs_wait_tree_log_extents(struct btrfs_root *log_root, int mark) 1140bf89d38fSJeff Mahoney { 1141bf89d38fSJeff Mahoney struct btrfs_fs_info *fs_info = log_root->fs_info; 1142bf89d38fSJeff Mahoney struct extent_io_tree *dirty_pages = &log_root->dirty_log_pages; 1143bf89d38fSJeff Mahoney bool errors = false; 1144bf89d38fSJeff Mahoney int err; 1145bf89d38fSJeff Mahoney 1146bf89d38fSJeff Mahoney ASSERT(log_root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID); 1147bf89d38fSJeff Mahoney 1148bf89d38fSJeff Mahoney err = __btrfs_wait_marked_extents(fs_info, dirty_pages); 1149656f30dbSFilipe Manana if ((mark & EXTENT_DIRTY) && 11500b246afaSJeff Mahoney test_and_clear_bit(BTRFS_FS_LOG1_ERR, &fs_info->flags)) 1151656f30dbSFilipe Manana errors = true; 1152656f30dbSFilipe Manana 1153656f30dbSFilipe Manana if ((mark & EXTENT_NEW) && 11540b246afaSJeff Mahoney test_and_clear_bit(BTRFS_FS_LOG2_ERR, &fs_info->flags)) 1155656f30dbSFilipe Manana errors = true; 1156656f30dbSFilipe Manana 1157bf89d38fSJeff Mahoney if (errors && !err) 1158bf89d38fSJeff Mahoney err = -EIO; 1159bf89d38fSJeff Mahoney return err; 116079154b1bSChris Mason } 116179154b1bSChris Mason 1162690587d1SChris Mason /* 1163c9b577c0SNikolay Borisov * When btree blocks are allocated the corresponding extents are marked dirty. 1164c9b577c0SNikolay Borisov * This function ensures such extents are persisted on disk for transaction or 1165c9b577c0SNikolay Borisov * log commit. 1166c9b577c0SNikolay Borisov * 1167c9b577c0SNikolay Borisov * @trans: transaction whose dirty pages we'd like to write 1168690587d1SChris Mason */ 116970458a58SNikolay Borisov static int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans) 1170d0c803c4SChris Mason { 1171663dfbb0SFilipe Manana int ret; 1172c9b577c0SNikolay Borisov int ret2; 1173c9b577c0SNikolay Borisov struct extent_io_tree *dirty_pages = &trans->transaction->dirty_pages; 117470458a58SNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 1175c9b577c0SNikolay Borisov struct blk_plug plug; 1176663dfbb0SFilipe Manana 1177c9b577c0SNikolay Borisov blk_start_plug(&plug); 1178c9b577c0SNikolay Borisov ret = btrfs_write_marked_extents(fs_info, dirty_pages, EXTENT_DIRTY); 1179c9b577c0SNikolay Borisov blk_finish_plug(&plug); 1180c9b577c0SNikolay Borisov ret2 = btrfs_wait_extents(fs_info, dirty_pages); 1181c9b577c0SNikolay Borisov 118241e7acd3SNikolay Borisov extent_io_tree_release(&trans->transaction->dirty_pages); 1183663dfbb0SFilipe Manana 1184c9b577c0SNikolay Borisov if (ret) 1185663dfbb0SFilipe Manana return ret; 1186c9b577c0SNikolay Borisov else if (ret2) 1187c9b577c0SNikolay Borisov return ret2; 1188c9b577c0SNikolay Borisov else 1189c9b577c0SNikolay Borisov return 0; 1190d0c803c4SChris Mason } 1191d0c803c4SChris Mason 1192d352ac68SChris Mason /* 1193d352ac68SChris Mason * this is used to update the root pointer in the tree of tree roots. 1194d352ac68SChris Mason * 1195d352ac68SChris Mason * But, in the case of the extent allocation tree, updating the root 1196d352ac68SChris Mason * pointer may allocate blocks which may change the root of the extent 1197d352ac68SChris Mason * allocation tree. 1198d352ac68SChris Mason * 1199d352ac68SChris Mason * So, this loops and repeats and makes sure the cowonly root didn't 1200d352ac68SChris Mason * change while the root pointer was being updated in the metadata. 1201d352ac68SChris Mason */ 12020b86a832SChris Mason static int update_cowonly_root(struct btrfs_trans_handle *trans, 120379154b1bSChris Mason struct btrfs_root *root) 120479154b1bSChris Mason { 120579154b1bSChris Mason int ret; 12060b86a832SChris Mason u64 old_root_bytenr; 120786b9f2ecSYan, Zheng u64 old_root_used; 12080b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 12090b246afaSJeff Mahoney struct btrfs_root *tree_root = fs_info->tree_root; 121079154b1bSChris Mason 121186b9f2ecSYan, Zheng old_root_used = btrfs_root_used(&root->root_item); 121256bec294SChris Mason 121379154b1bSChris Mason while (1) { 12140b86a832SChris Mason old_root_bytenr = btrfs_root_bytenr(&root->root_item); 121586b9f2ecSYan, Zheng if (old_root_bytenr == root->node->start && 1216ea526d18SJosef Bacik old_root_used == btrfs_root_used(&root->root_item)) 121779154b1bSChris Mason break; 121887ef2bb4SChris Mason 12195d4f98a2SYan Zheng btrfs_set_root_node(&root->root_item, root->node); 122079154b1bSChris Mason ret = btrfs_update_root(trans, tree_root, 12210b86a832SChris Mason &root->root_key, 12220b86a832SChris Mason &root->root_item); 122349b25e05SJeff Mahoney if (ret) 122449b25e05SJeff Mahoney return ret; 122556bec294SChris Mason 122686b9f2ecSYan, Zheng old_root_used = btrfs_root_used(&root->root_item); 1227e7070be1SJosef Bacik } 1228276e680dSYan Zheng 12290b86a832SChris Mason return 0; 12300b86a832SChris Mason } 12310b86a832SChris Mason 1232d352ac68SChris Mason /* 1233d352ac68SChris Mason * update all the cowonly tree roots on disk 123449b25e05SJeff Mahoney * 123549b25e05SJeff Mahoney * The error handling in this function may not be obvious. Any of the 123649b25e05SJeff Mahoney * failures will cause the file system to go offline. We still need 123749b25e05SJeff Mahoney * to clean up the delayed refs. 1238d352ac68SChris Mason */ 12399386d8bcSNikolay Borisov static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans) 12400b86a832SChris Mason { 12419386d8bcSNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 1242ea526d18SJosef Bacik struct list_head *dirty_bgs = &trans->transaction->dirty_bgs; 12431bbc621eSChris Mason struct list_head *io_bgs = &trans->transaction->io_bgs; 12440b86a832SChris Mason struct list_head *next; 124584234f3aSYan Zheng struct extent_buffer *eb; 124656bec294SChris Mason int ret; 124784234f3aSYan Zheng 124884234f3aSYan Zheng eb = btrfs_lock_root_node(fs_info->tree_root); 124949b25e05SJeff Mahoney ret = btrfs_cow_block(trans, fs_info->tree_root, eb, NULL, 12509631e4ccSJosef Bacik 0, &eb, BTRFS_NESTING_COW); 125184234f3aSYan Zheng btrfs_tree_unlock(eb); 125284234f3aSYan Zheng free_extent_buffer(eb); 12530b86a832SChris Mason 125449b25e05SJeff Mahoney if (ret) 125549b25e05SJeff Mahoney return ret; 125649b25e05SJeff Mahoney 1257196c9d8dSDavid Sterba ret = btrfs_run_dev_stats(trans); 1258c16ce190SJosef Bacik if (ret) 1259c16ce190SJosef Bacik return ret; 12602b584c68SDavid Sterba ret = btrfs_run_dev_replace(trans); 1261c16ce190SJosef Bacik if (ret) 1262c16ce190SJosef Bacik return ret; 1263280f8bd2SLu Fengqi ret = btrfs_run_qgroups(trans); 1264c16ce190SJosef Bacik if (ret) 1265c16ce190SJosef Bacik return ret; 1266546adb0dSJan Schmidt 1267bbebb3e0SDavid Sterba ret = btrfs_setup_space_cache(trans); 1268dcdf7f6dSJosef Bacik if (ret) 1269dcdf7f6dSJosef Bacik return ret; 1270dcdf7f6dSJosef Bacik 1271ea526d18SJosef Bacik again: 12720b86a832SChris Mason while (!list_empty(&fs_info->dirty_cowonly_roots)) { 12732ff7e61eSJeff Mahoney struct btrfs_root *root; 12740b86a832SChris Mason next = fs_info->dirty_cowonly_roots.next; 12750b86a832SChris Mason list_del_init(next); 12760b86a832SChris Mason root = list_entry(next, struct btrfs_root, dirty_list); 1277e7070be1SJosef Bacik clear_bit(BTRFS_ROOT_DIRTY, &root->state); 127887ef2bb4SChris Mason 12799e351cc8SJosef Bacik if (root != fs_info->extent_root) 12809e351cc8SJosef Bacik list_add_tail(&root->dirty_list, 12819e351cc8SJosef Bacik &trans->transaction->switch_commits); 128249b25e05SJeff Mahoney ret = update_cowonly_root(trans, root); 128349b25e05SJeff Mahoney if (ret) 128449b25e05SJeff Mahoney return ret; 1285488bc2a2SJosef Bacik } 1286488bc2a2SJosef Bacik 1287488bc2a2SJosef Bacik /* Now flush any delayed refs generated by updating all of the roots */ 1288c79a70b1SNikolay Borisov ret = btrfs_run_delayed_refs(trans, (unsigned long)-1); 1289ea526d18SJosef Bacik if (ret) 1290ea526d18SJosef Bacik return ret; 1291276e680dSYan Zheng 12921bbc621eSChris Mason while (!list_empty(dirty_bgs) || !list_empty(io_bgs)) { 12935742d15fSDavid Sterba ret = btrfs_write_dirty_block_groups(trans); 1294ea526d18SJosef Bacik if (ret) 1295ea526d18SJosef Bacik return ret; 1296488bc2a2SJosef Bacik 1297488bc2a2SJosef Bacik /* 1298488bc2a2SJosef Bacik * We're writing the dirty block groups, which could generate 1299488bc2a2SJosef Bacik * delayed refs, which could generate more dirty block groups, 1300488bc2a2SJosef Bacik * so we want to keep this flushing in this loop to make sure 1301488bc2a2SJosef Bacik * everything gets run. 1302488bc2a2SJosef Bacik */ 1303c79a70b1SNikolay Borisov ret = btrfs_run_delayed_refs(trans, (unsigned long)-1); 1304ea526d18SJosef Bacik if (ret) 1305ea526d18SJosef Bacik return ret; 1306ea526d18SJosef Bacik } 1307ea526d18SJosef Bacik 1308ea526d18SJosef Bacik if (!list_empty(&fs_info->dirty_cowonly_roots)) 1309ea526d18SJosef Bacik goto again; 1310ea526d18SJosef Bacik 13119e351cc8SJosef Bacik list_add_tail(&fs_info->extent_root->dirty_list, 13129e351cc8SJosef Bacik &trans->transaction->switch_commits); 13139f6cbcbbSDavid Sterba 13149f6cbcbbSDavid Sterba /* Update dev-replace pointer once everything is committed */ 13159f6cbcbbSDavid Sterba fs_info->dev_replace.committed_cursor_left = 13169f6cbcbbSDavid Sterba fs_info->dev_replace.cursor_left_last_write_of_item; 13178dabb742SStefan Behrens 131879154b1bSChris Mason return 0; 131979154b1bSChris Mason } 132079154b1bSChris Mason 1321d352ac68SChris Mason /* 1322d352ac68SChris Mason * dead roots are old snapshots that need to be deleted. This allocates 1323d352ac68SChris Mason * a dirty root struct and adds it into the list of dead roots that need to 1324d352ac68SChris Mason * be deleted 1325d352ac68SChris Mason */ 1326cfad392bSJosef Bacik void btrfs_add_dead_root(struct btrfs_root *root) 13275eda7b5eSChris Mason { 13280b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 13290b246afaSJeff Mahoney 13300b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 1331dc9492c1SJosef Bacik if (list_empty(&root->root_list)) { 1332dc9492c1SJosef Bacik btrfs_grab_root(root); 13330b246afaSJeff Mahoney list_add_tail(&root->root_list, &fs_info->dead_roots); 1334dc9492c1SJosef Bacik } 13350b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 13365eda7b5eSChris Mason } 13375eda7b5eSChris Mason 1338d352ac68SChris Mason /* 13395d4f98a2SYan Zheng * update all the cowonly tree roots on disk 1340d352ac68SChris Mason */ 13417e4443d9SNikolay Borisov static noinline int commit_fs_roots(struct btrfs_trans_handle *trans) 13420f7d52f4SChris Mason { 13437e4443d9SNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 13440f7d52f4SChris Mason struct btrfs_root *gang[8]; 13450f7d52f4SChris Mason int i; 13460f7d52f4SChris Mason int ret; 134754aa1f4dSChris Mason 1348a4abeea4SJosef Bacik spin_lock(&fs_info->fs_roots_radix_lock); 13490f7d52f4SChris Mason while (1) { 13505d4f98a2SYan Zheng ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix, 13515d4f98a2SYan Zheng (void **)gang, 0, 13520f7d52f4SChris Mason ARRAY_SIZE(gang), 13530f7d52f4SChris Mason BTRFS_ROOT_TRANS_TAG); 13540f7d52f4SChris Mason if (ret == 0) 13550f7d52f4SChris Mason break; 13560f7d52f4SChris Mason for (i = 0; i < ret; i++) { 13575b4aacefSJeff Mahoney struct btrfs_root *root = gang[i]; 13584f4317c1SJosef Bacik int ret2; 13594f4317c1SJosef Bacik 13605d4f98a2SYan Zheng radix_tree_tag_clear(&fs_info->fs_roots_radix, 13612619ba1fSChris Mason (unsigned long)root->root_key.objectid, 13620f7d52f4SChris Mason BTRFS_ROOT_TRANS_TAG); 1363a4abeea4SJosef Bacik spin_unlock(&fs_info->fs_roots_radix_lock); 136431153d81SYan Zheng 1365e02119d5SChris Mason btrfs_free_log(trans, root); 13662dd8298eSJosef Bacik ret2 = btrfs_update_reloc_root(trans, root); 13672dd8298eSJosef Bacik if (ret2) 13682dd8298eSJosef Bacik return ret2; 1369e02119d5SChris Mason 1370f1ebcc74SLiu Bo /* see comments in should_cow_block() */ 137127cdeb70SMiao Xie clear_bit(BTRFS_ROOT_FORCE_COW, &root->state); 1372c7548af6SChris Mason smp_mb__after_atomic(); 1373f1ebcc74SLiu Bo 1374978d910dSYan Zheng if (root->commit_root != root->node) { 13759e351cc8SJosef Bacik list_add_tail(&root->dirty_list, 13769e351cc8SJosef Bacik &trans->transaction->switch_commits); 1377978d910dSYan Zheng btrfs_set_root_node(&root->root_item, 1378978d910dSYan Zheng root->node); 1379978d910dSYan Zheng } 138031153d81SYan Zheng 13814f4317c1SJosef Bacik ret2 = btrfs_update_root(trans, fs_info->tree_root, 13820f7d52f4SChris Mason &root->root_key, 13830f7d52f4SChris Mason &root->root_item); 13844f4317c1SJosef Bacik if (ret2) 13854f4317c1SJosef Bacik return ret2; 1386a4abeea4SJosef Bacik spin_lock(&fs_info->fs_roots_radix_lock); 1387733e03a0SQu Wenruo btrfs_qgroup_free_meta_all_pertrans(root); 13880f7d52f4SChris Mason } 13899f3a7427SChris Mason } 1390a4abeea4SJosef Bacik spin_unlock(&fs_info->fs_roots_radix_lock); 13914f4317c1SJosef Bacik return 0; 13920f7d52f4SChris Mason } 13930f7d52f4SChris Mason 1394d352ac68SChris Mason /* 1395de78b51aSEric Sandeen * defrag a given btree. 1396de78b51aSEric Sandeen * Every leaf in the btree is read and defragged. 1397d352ac68SChris Mason */ 1398de78b51aSEric Sandeen int btrfs_defrag_root(struct btrfs_root *root) 1399e9d0b13bSChris Mason { 1400e9d0b13bSChris Mason struct btrfs_fs_info *info = root->fs_info; 1401e9d0b13bSChris Mason struct btrfs_trans_handle *trans; 14028929ecfaSYan, Zheng int ret; 1403e9d0b13bSChris Mason 140427cdeb70SMiao Xie if (test_and_set_bit(BTRFS_ROOT_DEFRAG_RUNNING, &root->state)) 1405e9d0b13bSChris Mason return 0; 14068929ecfaSYan, Zheng 14076b80053dSChris Mason while (1) { 14088929ecfaSYan, Zheng trans = btrfs_start_transaction(root, 0); 14096819703fSDavid Sterba if (IS_ERR(trans)) { 14106819703fSDavid Sterba ret = PTR_ERR(trans); 14116819703fSDavid Sterba break; 14126819703fSDavid Sterba } 14138929ecfaSYan, Zheng 1414de78b51aSEric Sandeen ret = btrfs_defrag_leaves(trans, root); 14158929ecfaSYan, Zheng 14163a45bb20SJeff Mahoney btrfs_end_transaction(trans); 14172ff7e61eSJeff Mahoney btrfs_btree_balance_dirty(info); 1418e9d0b13bSChris Mason cond_resched(); 1419e9d0b13bSChris Mason 1420ab8d0fc4SJeff Mahoney if (btrfs_fs_closing(info) || ret != -EAGAIN) 1421e9d0b13bSChris Mason break; 1422210549ebSDavid Sterba 1423ab8d0fc4SJeff Mahoney if (btrfs_defrag_cancelled(info)) { 1424ab8d0fc4SJeff Mahoney btrfs_debug(info, "defrag_root cancelled"); 1425210549ebSDavid Sterba ret = -EAGAIN; 1426210549ebSDavid Sterba break; 1427210549ebSDavid Sterba } 1428e9d0b13bSChris Mason } 142927cdeb70SMiao Xie clear_bit(BTRFS_ROOT_DEFRAG_RUNNING, &root->state); 14308929ecfaSYan, Zheng return ret; 1431e9d0b13bSChris Mason } 1432e9d0b13bSChris Mason 1433d352ac68SChris Mason /* 14346426c7adSQu Wenruo * Do all special snapshot related qgroup dirty hack. 14356426c7adSQu Wenruo * 14366426c7adSQu Wenruo * Will do all needed qgroup inherit and dirty hack like switch commit 14376426c7adSQu Wenruo * roots inside one transaction and write all btree into disk, to make 14386426c7adSQu Wenruo * qgroup works. 14396426c7adSQu Wenruo */ 14406426c7adSQu Wenruo static int qgroup_account_snapshot(struct btrfs_trans_handle *trans, 14416426c7adSQu Wenruo struct btrfs_root *src, 14426426c7adSQu Wenruo struct btrfs_root *parent, 14436426c7adSQu Wenruo struct btrfs_qgroup_inherit *inherit, 14446426c7adSQu Wenruo u64 dst_objectid) 14456426c7adSQu Wenruo { 14466426c7adSQu Wenruo struct btrfs_fs_info *fs_info = src->fs_info; 14476426c7adSQu Wenruo int ret; 14486426c7adSQu Wenruo 14496426c7adSQu Wenruo /* 14506426c7adSQu Wenruo * Save some performance in the case that qgroups are not 14516426c7adSQu Wenruo * enabled. If this check races with the ioctl, rescan will 14526426c7adSQu Wenruo * kick in anyway. 14536426c7adSQu Wenruo */ 14549ea6e2b5SDavid Sterba if (!test_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags)) 14556426c7adSQu Wenruo return 0; 14566426c7adSQu Wenruo 14576426c7adSQu Wenruo /* 145852042d8eSAndrea Gelmini * Ensure dirty @src will be committed. Or, after coming 14594d31778aSQu Wenruo * commit_fs_roots() and switch_commit_roots(), any dirty but not 14604d31778aSQu Wenruo * recorded root will never be updated again, causing an outdated root 14614d31778aSQu Wenruo * item. 14624d31778aSQu Wenruo */ 14631c442d22SJosef Bacik ret = record_root_in_trans(trans, src, 1); 14641c442d22SJosef Bacik if (ret) 14651c442d22SJosef Bacik return ret; 14664d31778aSQu Wenruo 14674d31778aSQu Wenruo /* 14682a4d84c1SJosef Bacik * btrfs_qgroup_inherit relies on a consistent view of the usage for the 14692a4d84c1SJosef Bacik * src root, so we must run the delayed refs here. 14702a4d84c1SJosef Bacik * 14712a4d84c1SJosef Bacik * However this isn't particularly fool proof, because there's no 14722a4d84c1SJosef Bacik * synchronization keeping us from changing the tree after this point 14732a4d84c1SJosef Bacik * before we do the qgroup_inherit, or even from making changes while 14742a4d84c1SJosef Bacik * we're doing the qgroup_inherit. But that's a problem for the future, 14752a4d84c1SJosef Bacik * for now flush the delayed refs to narrow the race window where the 14762a4d84c1SJosef Bacik * qgroup counters could end up wrong. 14772a4d84c1SJosef Bacik */ 14782a4d84c1SJosef Bacik ret = btrfs_run_delayed_refs(trans, (unsigned long)-1); 14792a4d84c1SJosef Bacik if (ret) { 14802a4d84c1SJosef Bacik btrfs_abort_transaction(trans, ret); 14812a4d84c1SJosef Bacik goto out; 14822a4d84c1SJosef Bacik } 14832a4d84c1SJosef Bacik 14842a4d84c1SJosef Bacik /* 14856426c7adSQu Wenruo * We are going to commit transaction, see btrfs_commit_transaction() 14866426c7adSQu Wenruo * comment for reason locking tree_log_mutex 14876426c7adSQu Wenruo */ 14886426c7adSQu Wenruo mutex_lock(&fs_info->tree_log_mutex); 14896426c7adSQu Wenruo 14907e4443d9SNikolay Borisov ret = commit_fs_roots(trans); 14916426c7adSQu Wenruo if (ret) 14926426c7adSQu Wenruo goto out; 1493460fb20aSNikolay Borisov ret = btrfs_qgroup_account_extents(trans); 14946426c7adSQu Wenruo if (ret < 0) 14956426c7adSQu Wenruo goto out; 14966426c7adSQu Wenruo 14976426c7adSQu Wenruo /* Now qgroup are all updated, we can inherit it to new qgroups */ 1498a9377422SLu Fengqi ret = btrfs_qgroup_inherit(trans, src->root_key.objectid, dst_objectid, 14996426c7adSQu Wenruo inherit); 15006426c7adSQu Wenruo if (ret < 0) 15016426c7adSQu Wenruo goto out; 15026426c7adSQu Wenruo 15036426c7adSQu Wenruo /* 15046426c7adSQu Wenruo * Now we do a simplified commit transaction, which will: 15056426c7adSQu Wenruo * 1) commit all subvolume and extent tree 15066426c7adSQu Wenruo * To ensure all subvolume and extent tree have a valid 15076426c7adSQu Wenruo * commit_root to accounting later insert_dir_item() 15086426c7adSQu Wenruo * 2) write all btree blocks onto disk 15096426c7adSQu Wenruo * This is to make sure later btree modification will be cowed 15106426c7adSQu Wenruo * Or commit_root can be populated and cause wrong qgroup numbers 15116426c7adSQu Wenruo * In this simplified commit, we don't really care about other trees 15126426c7adSQu Wenruo * like chunk and root tree, as they won't affect qgroup. 15136426c7adSQu Wenruo * And we don't write super to avoid half committed status. 15146426c7adSQu Wenruo */ 15159386d8bcSNikolay Borisov ret = commit_cowonly_roots(trans); 15166426c7adSQu Wenruo if (ret) 15176426c7adSQu Wenruo goto out; 1518889bfa39SJosef Bacik switch_commit_roots(trans); 151970458a58SNikolay Borisov ret = btrfs_write_and_wait_transaction(trans); 15206426c7adSQu Wenruo if (ret) 1521f7af3934SDavid Sterba btrfs_handle_fs_error(fs_info, ret, 15226426c7adSQu Wenruo "Error while writing out transaction for qgroup"); 15236426c7adSQu Wenruo 15246426c7adSQu Wenruo out: 15256426c7adSQu Wenruo mutex_unlock(&fs_info->tree_log_mutex); 15266426c7adSQu Wenruo 15276426c7adSQu Wenruo /* 15286426c7adSQu Wenruo * Force parent root to be updated, as we recorded it before so its 15296426c7adSQu Wenruo * last_trans == cur_transid. 15306426c7adSQu Wenruo * Or it won't be committed again onto disk after later 15316426c7adSQu Wenruo * insert_dir_item() 15326426c7adSQu Wenruo */ 15336426c7adSQu Wenruo if (!ret) 15341c442d22SJosef Bacik ret = record_root_in_trans(trans, parent, 1); 15356426c7adSQu Wenruo return ret; 15366426c7adSQu Wenruo } 15376426c7adSQu Wenruo 15386426c7adSQu Wenruo /* 1539d352ac68SChris Mason * new snapshots need to be created at a very specific time in the 1540aec8030aSMiao Xie * transaction commit. This does the actual creation. 1541aec8030aSMiao Xie * 1542aec8030aSMiao Xie * Note: 1543aec8030aSMiao Xie * If the error which may affect the commitment of the current transaction 1544aec8030aSMiao Xie * happens, we should return the error number. If the error which just affect 1545aec8030aSMiao Xie * the creation of the pending snapshots, just return 0. 1546d352ac68SChris Mason */ 154780b6794dSChris Mason static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans, 15483063d29fSChris Mason struct btrfs_pending_snapshot *pending) 15493063d29fSChris Mason { 155008d50ca3SNikolay Borisov 155108d50ca3SNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 15523063d29fSChris Mason struct btrfs_key key; 155380b6794dSChris Mason struct btrfs_root_item *new_root_item; 15543063d29fSChris Mason struct btrfs_root *tree_root = fs_info->tree_root; 15553063d29fSChris Mason struct btrfs_root *root = pending->root; 15566bdb72deSSage Weil struct btrfs_root *parent_root; 155798c9942aSLiu Bo struct btrfs_block_rsv *rsv; 15586bdb72deSSage Weil struct inode *parent_inode; 155942874b3dSMiao Xie struct btrfs_path *path; 156042874b3dSMiao Xie struct btrfs_dir_item *dir_item; 1561a22285a6SYan, Zheng struct dentry *dentry; 15623063d29fSChris Mason struct extent_buffer *tmp; 1563925baeddSChris Mason struct extent_buffer *old; 156495582b00SDeepa Dinamani struct timespec64 cur_time; 1565aec8030aSMiao Xie int ret = 0; 1566d68fc57bSYan, Zheng u64 to_reserve = 0; 15676bdb72deSSage Weil u64 index = 0; 1568a22285a6SYan, Zheng u64 objectid; 1569b83cc969SLi Zefan u64 root_flags; 15703063d29fSChris Mason 15718546b570SDavid Sterba ASSERT(pending->path); 15728546b570SDavid Sterba path = pending->path; 157342874b3dSMiao Xie 1574b0c0ea63SDavid Sterba ASSERT(pending->root_item); 1575b0c0ea63SDavid Sterba new_root_item = pending->root_item; 1576a22285a6SYan, Zheng 1577543068a2SNikolay Borisov pending->error = btrfs_get_free_objectid(tree_root, &objectid); 1578aec8030aSMiao Xie if (pending->error) 15796fa9700eSMiao Xie goto no_free_objectid; 15803063d29fSChris Mason 1581d6726335SQu Wenruo /* 1582d6726335SQu Wenruo * Make qgroup to skip current new snapshot's qgroupid, as it is 1583d6726335SQu Wenruo * accounted by later btrfs_qgroup_inherit(). 1584d6726335SQu Wenruo */ 1585d6726335SQu Wenruo btrfs_set_skip_qgroup(trans, objectid); 1586d6726335SQu Wenruo 1587147d256eSZhaolei btrfs_reloc_pre_snapshot(pending, &to_reserve); 1588d68fc57bSYan, Zheng 1589d68fc57bSYan, Zheng if (to_reserve > 0) { 1590aec8030aSMiao Xie pending->error = btrfs_block_rsv_add(root, 1591aec8030aSMiao Xie &pending->block_rsv, 159208e007d2SMiao Xie to_reserve, 159308e007d2SMiao Xie BTRFS_RESERVE_NO_FLUSH); 1594aec8030aSMiao Xie if (pending->error) 1595d6726335SQu Wenruo goto clear_skip_qgroup; 1596d68fc57bSYan, Zheng } 1597d68fc57bSYan, Zheng 15983063d29fSChris Mason key.objectid = objectid; 1599a22285a6SYan, Zheng key.offset = (u64)-1; 1600a22285a6SYan, Zheng key.type = BTRFS_ROOT_ITEM_KEY; 16013063d29fSChris Mason 16026fa9700eSMiao Xie rsv = trans->block_rsv; 1603a22285a6SYan, Zheng trans->block_rsv = &pending->block_rsv; 16042382c5ccSLiu Bo trans->bytes_reserved = trans->block_rsv->reserved; 16050b246afaSJeff Mahoney trace_btrfs_space_reservation(fs_info, "transaction", 160688d3a5aaSJosef Bacik trans->transid, 160788d3a5aaSJosef Bacik trans->bytes_reserved, 1); 1608a22285a6SYan, Zheng dentry = pending->dentry; 1609e9662f70SMiao Xie parent_inode = pending->dir; 1610a22285a6SYan, Zheng parent_root = BTRFS_I(parent_inode)->root; 1611f0118cb6SJosef Bacik ret = record_root_in_trans(trans, parent_root, 0); 1612f0118cb6SJosef Bacik if (ret) 1613f0118cb6SJosef Bacik goto fail; 1614c2050a45SDeepa Dinamani cur_time = current_time(parent_inode); 161504b285f3SDeepa Dinamani 16166bdb72deSSage Weil /* 16176bdb72deSSage Weil * insert the directory item 16186bdb72deSSage Weil */ 1619877574e2SNikolay Borisov ret = btrfs_set_inode_index(BTRFS_I(parent_inode), &index); 162049b25e05SJeff Mahoney BUG_ON(ret); /* -ENOMEM */ 162142874b3dSMiao Xie 162242874b3dSMiao Xie /* check if there is a file/dir which has the same name. */ 162342874b3dSMiao Xie dir_item = btrfs_lookup_dir_item(NULL, parent_root, path, 16244a0cc7caSNikolay Borisov btrfs_ino(BTRFS_I(parent_inode)), 162542874b3dSMiao Xie dentry->d_name.name, 162642874b3dSMiao Xie dentry->d_name.len, 0); 162742874b3dSMiao Xie if (dir_item != NULL && !IS_ERR(dir_item)) { 1628fe66a05aSChris Mason pending->error = -EEXIST; 1629aec8030aSMiao Xie goto dir_item_existed; 163042874b3dSMiao Xie } else if (IS_ERR(dir_item)) { 163142874b3dSMiao Xie ret = PTR_ERR(dir_item); 163266642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 16338732d44fSMiao Xie goto fail; 163479787eaaSJeff Mahoney } 163542874b3dSMiao Xie btrfs_release_path(path); 16366bdb72deSSage Weil 1637e999376fSChris Mason /* 1638e999376fSChris Mason * pull in the delayed directory update 1639e999376fSChris Mason * and the delayed inode item 1640e999376fSChris Mason * otherwise we corrupt the FS during 1641e999376fSChris Mason * snapshot 1642e999376fSChris Mason */ 1643e5c304e6SNikolay Borisov ret = btrfs_run_delayed_items(trans); 16448732d44fSMiao Xie if (ret) { /* Transaction aborted */ 164566642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 16468732d44fSMiao Xie goto fail; 16478732d44fSMiao Xie } 1648e999376fSChris Mason 1649f0118cb6SJosef Bacik ret = record_root_in_trans(trans, root, 0); 1650f0118cb6SJosef Bacik if (ret) { 1651f0118cb6SJosef Bacik btrfs_abort_transaction(trans, ret); 1652f0118cb6SJosef Bacik goto fail; 1653f0118cb6SJosef Bacik } 16546bdb72deSSage Weil btrfs_set_root_last_snapshot(&root->root_item, trans->transid); 16556bdb72deSSage Weil memcpy(new_root_item, &root->root_item, sizeof(*new_root_item)); 165608fe4db1SLi Zefan btrfs_check_and_init_root_item(new_root_item); 16576bdb72deSSage Weil 1658b83cc969SLi Zefan root_flags = btrfs_root_flags(new_root_item); 1659b83cc969SLi Zefan if (pending->readonly) 1660b83cc969SLi Zefan root_flags |= BTRFS_ROOT_SUBVOL_RDONLY; 1661b83cc969SLi Zefan else 1662b83cc969SLi Zefan root_flags &= ~BTRFS_ROOT_SUBVOL_RDONLY; 1663b83cc969SLi Zefan btrfs_set_root_flags(new_root_item, root_flags); 1664b83cc969SLi Zefan 16658ea05e3aSAlexander Block btrfs_set_root_generation_v2(new_root_item, 16668ea05e3aSAlexander Block trans->transid); 1667807fc790SAndy Shevchenko generate_random_guid(new_root_item->uuid); 16688ea05e3aSAlexander Block memcpy(new_root_item->parent_uuid, root->root_item.uuid, 16698ea05e3aSAlexander Block BTRFS_UUID_SIZE); 167070023da2SStefan Behrens if (!(root_flags & BTRFS_ROOT_SUBVOL_RDONLY)) { 167170023da2SStefan Behrens memset(new_root_item->received_uuid, 0, 167270023da2SStefan Behrens sizeof(new_root_item->received_uuid)); 16738ea05e3aSAlexander Block memset(&new_root_item->stime, 0, sizeof(new_root_item->stime)); 16748ea05e3aSAlexander Block memset(&new_root_item->rtime, 0, sizeof(new_root_item->rtime)); 16758ea05e3aSAlexander Block btrfs_set_root_stransid(new_root_item, 0); 16768ea05e3aSAlexander Block btrfs_set_root_rtransid(new_root_item, 0); 167770023da2SStefan Behrens } 16783cae210fSQu Wenruo btrfs_set_stack_timespec_sec(&new_root_item->otime, cur_time.tv_sec); 16793cae210fSQu Wenruo btrfs_set_stack_timespec_nsec(&new_root_item->otime, cur_time.tv_nsec); 168070023da2SStefan Behrens btrfs_set_root_otransid(new_root_item, trans->transid); 16818ea05e3aSAlexander Block 1682925baeddSChris Mason old = btrfs_lock_root_node(root); 16839631e4ccSJosef Bacik ret = btrfs_cow_block(trans, root, old, NULL, 0, &old, 16849631e4ccSJosef Bacik BTRFS_NESTING_COW); 168579787eaaSJeff Mahoney if (ret) { 168679787eaaSJeff Mahoney btrfs_tree_unlock(old); 168779787eaaSJeff Mahoney free_extent_buffer(old); 168866642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 16898732d44fSMiao Xie goto fail; 169079787eaaSJeff Mahoney } 169149b25e05SJeff Mahoney 169249b25e05SJeff Mahoney ret = btrfs_copy_root(trans, root, old, &tmp, objectid); 169379787eaaSJeff Mahoney /* clean up in any case */ 1694925baeddSChris Mason btrfs_tree_unlock(old); 1695925baeddSChris Mason free_extent_buffer(old); 16968732d44fSMiao Xie if (ret) { 169766642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 16988732d44fSMiao Xie goto fail; 16998732d44fSMiao Xie } 1700f1ebcc74SLiu Bo /* see comments in should_cow_block() */ 170127cdeb70SMiao Xie set_bit(BTRFS_ROOT_FORCE_COW, &root->state); 1702f1ebcc74SLiu Bo smp_wmb(); 1703f1ebcc74SLiu Bo 17045d4f98a2SYan Zheng btrfs_set_root_node(new_root_item, tmp); 1705a22285a6SYan, Zheng /* record when the snapshot was created in key.offset */ 1706a22285a6SYan, Zheng key.offset = trans->transid; 1707a22285a6SYan, Zheng ret = btrfs_insert_root(trans, tree_root, &key, new_root_item); 1708925baeddSChris Mason btrfs_tree_unlock(tmp); 17093063d29fSChris Mason free_extent_buffer(tmp); 17108732d44fSMiao Xie if (ret) { 171166642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 17128732d44fSMiao Xie goto fail; 17138732d44fSMiao Xie } 17140660b5afSChris Mason 1715a22285a6SYan, Zheng /* 1716a22285a6SYan, Zheng * insert root back/forward references 1717a22285a6SYan, Zheng */ 17186025c19fSLu Fengqi ret = btrfs_add_root_ref(trans, objectid, 1719a22285a6SYan, Zheng parent_root->root_key.objectid, 17204a0cc7caSNikolay Borisov btrfs_ino(BTRFS_I(parent_inode)), index, 1721a22285a6SYan, Zheng dentry->d_name.name, dentry->d_name.len); 17228732d44fSMiao Xie if (ret) { 172366642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 17248732d44fSMiao Xie goto fail; 17258732d44fSMiao Xie } 1726a22285a6SYan, Zheng 1727a22285a6SYan, Zheng key.offset = (u64)-1; 17282dfb1e43SQu Wenruo pending->snap = btrfs_get_new_fs_root(fs_info, objectid, pending->anon_dev); 172979787eaaSJeff Mahoney if (IS_ERR(pending->snap)) { 173079787eaaSJeff Mahoney ret = PTR_ERR(pending->snap); 17312d892ccdSFilipe Manana pending->snap = NULL; 173266642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 17338732d44fSMiao Xie goto fail; 173479787eaaSJeff Mahoney } 1735d68fc57bSYan, Zheng 173649b25e05SJeff Mahoney ret = btrfs_reloc_post_snapshot(trans, pending); 17378732d44fSMiao Xie if (ret) { 173866642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 17398732d44fSMiao Xie goto fail; 17408732d44fSMiao Xie } 1741361048f5SMiao Xie 17426426c7adSQu Wenruo /* 17436426c7adSQu Wenruo * Do special qgroup accounting for snapshot, as we do some qgroup 17446426c7adSQu Wenruo * snapshot hack to do fast snapshot. 17456426c7adSQu Wenruo * To co-operate with that hack, we do hack again. 17466426c7adSQu Wenruo * Or snapshot will be greatly slowed down by a subtree qgroup rescan 17476426c7adSQu Wenruo */ 17486426c7adSQu Wenruo ret = qgroup_account_snapshot(trans, root, parent_root, 17496426c7adSQu Wenruo pending->inherit, objectid); 17506426c7adSQu Wenruo if (ret < 0) 17516426c7adSQu Wenruo goto fail; 17526426c7adSQu Wenruo 1753684572dfSLu Fengqi ret = btrfs_insert_dir_item(trans, dentry->d_name.name, 1754684572dfSLu Fengqi dentry->d_name.len, BTRFS_I(parent_inode), 1755684572dfSLu Fengqi &key, BTRFS_FT_DIR, index); 175642874b3dSMiao Xie /* We have check then name at the beginning, so it is impossible. */ 17579c52057cSChris Mason BUG_ON(ret == -EEXIST || ret == -EOVERFLOW); 17588732d44fSMiao Xie if (ret) { 175966642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 17608732d44fSMiao Xie goto fail; 17618732d44fSMiao Xie } 176242874b3dSMiao Xie 17636ef06d27SNikolay Borisov btrfs_i_size_write(BTRFS_I(parent_inode), parent_inode->i_size + 176442874b3dSMiao Xie dentry->d_name.len * 2); 176504b285f3SDeepa Dinamani parent_inode->i_mtime = parent_inode->i_ctime = 1766c2050a45SDeepa Dinamani current_time(parent_inode); 1767729f7961SNikolay Borisov ret = btrfs_update_inode_fallback(trans, parent_root, BTRFS_I(parent_inode)); 1768dd5f9615SStefan Behrens if (ret) { 176966642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 1770dd5f9615SStefan Behrens goto fail; 1771dd5f9615SStefan Behrens } 1772807fc790SAndy Shevchenko ret = btrfs_uuid_tree_add(trans, new_root_item->uuid, 1773807fc790SAndy Shevchenko BTRFS_UUID_KEY_SUBVOL, 1774cdb345a8SLu Fengqi objectid); 1775dd5f9615SStefan Behrens if (ret) { 177666642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 1777dd5f9615SStefan Behrens goto fail; 1778dd5f9615SStefan Behrens } 1779dd5f9615SStefan Behrens if (!btrfs_is_empty_uuid(new_root_item->received_uuid)) { 1780cdb345a8SLu Fengqi ret = btrfs_uuid_tree_add(trans, new_root_item->received_uuid, 1781dd5f9615SStefan Behrens BTRFS_UUID_KEY_RECEIVED_SUBVOL, 1782dd5f9615SStefan Behrens objectid); 1783dd5f9615SStefan Behrens if (ret && ret != -EEXIST) { 178466642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 1785dd5f9615SStefan Behrens goto fail; 1786dd5f9615SStefan Behrens } 1787dd5f9615SStefan Behrens } 1788d6726335SQu Wenruo 17893063d29fSChris Mason fail: 1790aec8030aSMiao Xie pending->error = ret; 1791aec8030aSMiao Xie dir_item_existed: 179298c9942aSLiu Bo trans->block_rsv = rsv; 17932382c5ccSLiu Bo trans->bytes_reserved = 0; 1794d6726335SQu Wenruo clear_skip_qgroup: 1795d6726335SQu Wenruo btrfs_clear_skip_qgroup(trans); 17966fa9700eSMiao Xie no_free_objectid: 17976fa9700eSMiao Xie kfree(new_root_item); 1798b0c0ea63SDavid Sterba pending->root_item = NULL; 179942874b3dSMiao Xie btrfs_free_path(path); 18008546b570SDavid Sterba pending->path = NULL; 18018546b570SDavid Sterba 180249b25e05SJeff Mahoney return ret; 18033063d29fSChris Mason } 18043063d29fSChris Mason 1805d352ac68SChris Mason /* 1806d352ac68SChris Mason * create all the snapshots we've scheduled for creation 1807d352ac68SChris Mason */ 180808d50ca3SNikolay Borisov static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans) 18093063d29fSChris Mason { 1810aec8030aSMiao Xie struct btrfs_pending_snapshot *pending, *next; 18113063d29fSChris Mason struct list_head *head = &trans->transaction->pending_snapshots; 1812aec8030aSMiao Xie int ret = 0; 18133de4586cSChris Mason 1814aec8030aSMiao Xie list_for_each_entry_safe(pending, next, head, list) { 1815aec8030aSMiao Xie list_del(&pending->list); 181608d50ca3SNikolay Borisov ret = create_pending_snapshot(trans, pending); 1817aec8030aSMiao Xie if (ret) 1818aec8030aSMiao Xie break; 1819aec8030aSMiao Xie } 1820aec8030aSMiao Xie return ret; 18213de4586cSChris Mason } 18223de4586cSChris Mason 18232ff7e61eSJeff Mahoney static void update_super_roots(struct btrfs_fs_info *fs_info) 18245d4f98a2SYan Zheng { 18255d4f98a2SYan Zheng struct btrfs_root_item *root_item; 18265d4f98a2SYan Zheng struct btrfs_super_block *super; 18275d4f98a2SYan Zheng 18280b246afaSJeff Mahoney super = fs_info->super_copy; 18295d4f98a2SYan Zheng 18300b246afaSJeff Mahoney root_item = &fs_info->chunk_root->root_item; 1831093e037cSDavid Sterba super->chunk_root = root_item->bytenr; 1832093e037cSDavid Sterba super->chunk_root_generation = root_item->generation; 1833093e037cSDavid Sterba super->chunk_root_level = root_item->level; 18345d4f98a2SYan Zheng 18350b246afaSJeff Mahoney root_item = &fs_info->tree_root->root_item; 1836093e037cSDavid Sterba super->root = root_item->bytenr; 1837093e037cSDavid Sterba super->generation = root_item->generation; 1838093e037cSDavid Sterba super->root_level = root_item->level; 18390b246afaSJeff Mahoney if (btrfs_test_opt(fs_info, SPACE_CACHE)) 1840093e037cSDavid Sterba super->cache_generation = root_item->generation; 184194846229SBoris Burkov else if (test_bit(BTRFS_FS_CLEANUP_SPACE_CACHE_V1, &fs_info->flags)) 184294846229SBoris Burkov super->cache_generation = 0; 18430b246afaSJeff Mahoney if (test_bit(BTRFS_FS_UPDATE_UUID_TREE_GEN, &fs_info->flags)) 1844093e037cSDavid Sterba super->uuid_tree_generation = root_item->generation; 18455d4f98a2SYan Zheng } 18465d4f98a2SYan Zheng 1847f36f3042SChris Mason int btrfs_transaction_in_commit(struct btrfs_fs_info *info) 1848f36f3042SChris Mason { 18494a9d8bdeSMiao Xie struct btrfs_transaction *trans; 1850f36f3042SChris Mason int ret = 0; 18514a9d8bdeSMiao Xie 1852a4abeea4SJosef Bacik spin_lock(&info->trans_lock); 18534a9d8bdeSMiao Xie trans = info->running_transaction; 18544a9d8bdeSMiao Xie if (trans) 18554a9d8bdeSMiao Xie ret = (trans->state >= TRANS_STATE_COMMIT_START); 1856a4abeea4SJosef Bacik spin_unlock(&info->trans_lock); 1857f36f3042SChris Mason return ret; 1858f36f3042SChris Mason } 1859f36f3042SChris Mason 18608929ecfaSYan, Zheng int btrfs_transaction_blocked(struct btrfs_fs_info *info) 18618929ecfaSYan, Zheng { 18624a9d8bdeSMiao Xie struct btrfs_transaction *trans; 18638929ecfaSYan, Zheng int ret = 0; 18644a9d8bdeSMiao Xie 1865a4abeea4SJosef Bacik spin_lock(&info->trans_lock); 18664a9d8bdeSMiao Xie trans = info->running_transaction; 18674a9d8bdeSMiao Xie if (trans) 18684a9d8bdeSMiao Xie ret = is_transaction_blocked(trans); 1869a4abeea4SJosef Bacik spin_unlock(&info->trans_lock); 18708929ecfaSYan, Zheng return ret; 18718929ecfaSYan, Zheng } 18728929ecfaSYan, Zheng 1873bb9c12c9SSage Weil /* 1874bb9c12c9SSage Weil * wait for the current transaction commit to start and block subsequent 1875bb9c12c9SSage Weil * transaction joins 1876bb9c12c9SSage Weil */ 18772ff7e61eSJeff Mahoney static void wait_current_trans_commit_start(struct btrfs_fs_info *fs_info, 1878bb9c12c9SSage Weil struct btrfs_transaction *trans) 1879bb9c12c9SSage Weil { 18802ff7e61eSJeff Mahoney wait_event(fs_info->transaction_blocked_wait, 1881bf31f87fSDavid Sterba trans->state >= TRANS_STATE_COMMIT_START || 1882bf31f87fSDavid Sterba TRANS_ABORTED(trans)); 1883bb9c12c9SSage Weil } 1884bb9c12c9SSage Weil 1885bb9c12c9SSage Weil /* 1886bb9c12c9SSage Weil * commit transactions asynchronously. once btrfs_commit_transaction_async 1887bb9c12c9SSage Weil * returns, any subsequent transaction will not be allowed to join. 1888bb9c12c9SSage Weil */ 1889bb9c12c9SSage Weil struct btrfs_async_commit { 1890bb9c12c9SSage Weil struct btrfs_trans_handle *newtrans; 18917892b5afSMiao Xie struct work_struct work; 1892bb9c12c9SSage Weil }; 1893bb9c12c9SSage Weil 1894bb9c12c9SSage Weil static void do_async_commit(struct work_struct *work) 1895bb9c12c9SSage Weil { 1896bb9c12c9SSage Weil struct btrfs_async_commit *ac = 18977892b5afSMiao Xie container_of(work, struct btrfs_async_commit, work); 1898bb9c12c9SSage Weil 18996fc4e354SSage Weil /* 19006fc4e354SSage Weil * We've got freeze protection passed with the transaction. 19016fc4e354SSage Weil * Tell lockdep about it. 19026fc4e354SSage Weil */ 1903b1a06a4bSLiu Bo if (ac->newtrans->type & __TRANS_FREEZABLE) 19043a45bb20SJeff Mahoney __sb_writers_acquired(ac->newtrans->fs_info->sb, SB_FREEZE_FS); 19056fc4e354SSage Weil 1906e209db7aSSage Weil current->journal_info = ac->newtrans; 1907e209db7aSSage Weil 19083a45bb20SJeff Mahoney btrfs_commit_transaction(ac->newtrans); 1909bb9c12c9SSage Weil kfree(ac); 1910bb9c12c9SSage Weil } 1911bb9c12c9SSage Weil 1912*32cc4f87SDavid Sterba int btrfs_commit_transaction_async(struct btrfs_trans_handle *trans) 1913bb9c12c9SSage Weil { 19143a45bb20SJeff Mahoney struct btrfs_fs_info *fs_info = trans->fs_info; 1915bb9c12c9SSage Weil struct btrfs_async_commit *ac; 1916bb9c12c9SSage Weil struct btrfs_transaction *cur_trans; 1917bb9c12c9SSage Weil 1918bb9c12c9SSage Weil ac = kmalloc(sizeof(*ac), GFP_NOFS); 1919db5b493aSTsutomu Itoh if (!ac) 1920db5b493aSTsutomu Itoh return -ENOMEM; 1921bb9c12c9SSage Weil 19227892b5afSMiao Xie INIT_WORK(&ac->work, do_async_commit); 19233a45bb20SJeff Mahoney ac->newtrans = btrfs_join_transaction(trans->root); 19243612b495STsutomu Itoh if (IS_ERR(ac->newtrans)) { 19253612b495STsutomu Itoh int err = PTR_ERR(ac->newtrans); 19263612b495STsutomu Itoh kfree(ac); 19273612b495STsutomu Itoh return err; 19283612b495STsutomu Itoh } 1929bb9c12c9SSage Weil 1930bb9c12c9SSage Weil /* take transaction reference */ 1931bb9c12c9SSage Weil cur_trans = trans->transaction; 19329b64f57dSElena Reshetova refcount_inc(&cur_trans->use_count); 1933bb9c12c9SSage Weil 19343a45bb20SJeff Mahoney btrfs_end_transaction(trans); 19356fc4e354SSage Weil 19366fc4e354SSage Weil /* 19376fc4e354SSage Weil * Tell lockdep we've released the freeze rwsem, since the 19386fc4e354SSage Weil * async commit thread will be the one to unlock it. 19396fc4e354SSage Weil */ 1940b1a06a4bSLiu Bo if (ac->newtrans->type & __TRANS_FREEZABLE) 19410b246afaSJeff Mahoney __sb_writers_release(fs_info->sb, SB_FREEZE_FS); 19426fc4e354SSage Weil 19437892b5afSMiao Xie schedule_work(&ac->work); 19442ff7e61eSJeff Mahoney wait_current_trans_commit_start(fs_info, cur_trans); 194538e88054SSage Weil if (current->journal_info == trans) 194638e88054SSage Weil current->journal_info = NULL; 194738e88054SSage Weil 1948724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 1949bb9c12c9SSage Weil return 0; 1950bb9c12c9SSage Weil } 1951bb9c12c9SSage Weil 195249b25e05SJeff Mahoney 195397cb39bbSNikolay Borisov static void cleanup_transaction(struct btrfs_trans_handle *trans, int err) 195449b25e05SJeff Mahoney { 195597cb39bbSNikolay Borisov struct btrfs_fs_info *fs_info = trans->fs_info; 195649b25e05SJeff Mahoney struct btrfs_transaction *cur_trans = trans->transaction; 195749b25e05SJeff Mahoney 1958b50fff81SDavid Sterba WARN_ON(refcount_read(&trans->use_count) > 1); 195949b25e05SJeff Mahoney 196066642832SJeff Mahoney btrfs_abort_transaction(trans, err); 19617b8b92afSJosef Bacik 19620b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 196366b6135bSLiu Bo 196425d8c284SMiao Xie /* 196525d8c284SMiao Xie * If the transaction is removed from the list, it means this 196625d8c284SMiao Xie * transaction has been committed successfully, so it is impossible 196725d8c284SMiao Xie * to call the cleanup function. 196825d8c284SMiao Xie */ 196925d8c284SMiao Xie BUG_ON(list_empty(&cur_trans->list)); 197066b6135bSLiu Bo 19710b246afaSJeff Mahoney if (cur_trans == fs_info->running_transaction) { 19724a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_COMMIT_DOING; 19730b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 1974f094ac32SLiu Bo wait_event(cur_trans->writer_wait, 1975f094ac32SLiu Bo atomic_read(&cur_trans->num_writers) == 1); 1976f094ac32SLiu Bo 19770b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 1978d7096fc3SJosef Bacik } 1979061dde82SFilipe Manana 1980061dde82SFilipe Manana /* 1981061dde82SFilipe Manana * Now that we know no one else is still using the transaction we can 1982061dde82SFilipe Manana * remove the transaction from the list of transactions. This avoids 1983061dde82SFilipe Manana * the transaction kthread from cleaning up the transaction while some 1984061dde82SFilipe Manana * other task is still using it, which could result in a use-after-free 1985061dde82SFilipe Manana * on things like log trees, as it forces the transaction kthread to 1986061dde82SFilipe Manana * wait for this transaction to be cleaned up by us. 1987061dde82SFilipe Manana */ 1988061dde82SFilipe Manana list_del_init(&cur_trans->list); 1989061dde82SFilipe Manana 19900b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 199149b25e05SJeff Mahoney 19922ff7e61eSJeff Mahoney btrfs_cleanup_one_transaction(trans->transaction, fs_info); 199349b25e05SJeff Mahoney 19940b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 19950b246afaSJeff Mahoney if (cur_trans == fs_info->running_transaction) 19960b246afaSJeff Mahoney fs_info->running_transaction = NULL; 19970b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 19984a9d8bdeSMiao Xie 1999e0228285SJosef Bacik if (trans->type & __TRANS_FREEZABLE) 20000b246afaSJeff Mahoney sb_end_intwrite(fs_info->sb); 2001724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 2002724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 200349b25e05SJeff Mahoney 200497cb39bbSNikolay Borisov trace_btrfs_transaction_commit(trans->root); 200549b25e05SJeff Mahoney 200649b25e05SJeff Mahoney if (current->journal_info == trans) 200749b25e05SJeff Mahoney current->journal_info = NULL; 20080b246afaSJeff Mahoney btrfs_scrub_cancel(fs_info); 200949b25e05SJeff Mahoney 201049b25e05SJeff Mahoney kmem_cache_free(btrfs_trans_handle_cachep, trans); 201149b25e05SJeff Mahoney } 201249b25e05SJeff Mahoney 2013c7cc64a9SDavid Sterba /* 2014c7cc64a9SDavid Sterba * Release reserved delayed ref space of all pending block groups of the 2015c7cc64a9SDavid Sterba * transaction and remove them from the list 2016c7cc64a9SDavid Sterba */ 2017c7cc64a9SDavid Sterba static void btrfs_cleanup_pending_block_groups(struct btrfs_trans_handle *trans) 2018c7cc64a9SDavid Sterba { 2019c7cc64a9SDavid Sterba struct btrfs_fs_info *fs_info = trans->fs_info; 202032da5386SDavid Sterba struct btrfs_block_group *block_group, *tmp; 2021c7cc64a9SDavid Sterba 2022c7cc64a9SDavid Sterba list_for_each_entry_safe(block_group, tmp, &trans->new_bgs, bg_list) { 2023c7cc64a9SDavid Sterba btrfs_delayed_refs_rsv_release(fs_info, 1); 2024c7cc64a9SDavid Sterba list_del_init(&block_group->bg_list); 2025c7cc64a9SDavid Sterba } 2026c7cc64a9SDavid Sterba } 2027c7cc64a9SDavid Sterba 202888090ad3SFilipe Manana static inline int btrfs_start_delalloc_flush(struct btrfs_fs_info *fs_info) 202982436617SMiao Xie { 2030ce8ea7ccSJosef Bacik /* 2031ce8ea7ccSJosef Bacik * We use writeback_inodes_sb here because if we used 2032ce8ea7ccSJosef Bacik * btrfs_start_delalloc_roots we would deadlock with fs freeze. 2033ce8ea7ccSJosef Bacik * Currently are holding the fs freeze lock, if we do an async flush 2034ce8ea7ccSJosef Bacik * we'll do btrfs_join_transaction() and deadlock because we need to 2035ce8ea7ccSJosef Bacik * wait for the fs freeze lock. Using the direct flushing we benefit 2036ce8ea7ccSJosef Bacik * from already being in a transaction and our join_transaction doesn't 2037ce8ea7ccSJosef Bacik * have to re-take the fs freeze lock. 2038ce8ea7ccSJosef Bacik */ 203988090ad3SFilipe Manana if (btrfs_test_opt(fs_info, FLUSHONCOMMIT)) 2040ce8ea7ccSJosef Bacik writeback_inodes_sb(fs_info->sb, WB_REASON_SYNC); 204182436617SMiao Xie return 0; 204282436617SMiao Xie } 204382436617SMiao Xie 204488090ad3SFilipe Manana static inline void btrfs_wait_delalloc_flush(struct btrfs_fs_info *fs_info) 204582436617SMiao Xie { 204688090ad3SFilipe Manana if (btrfs_test_opt(fs_info, FLUSHONCOMMIT)) 20476374e57aSChris Mason btrfs_wait_ordered_roots(fs_info, U64_MAX, 0, (u64)-1); 204882436617SMiao Xie } 204982436617SMiao Xie 20503a45bb20SJeff Mahoney int btrfs_commit_transaction(struct btrfs_trans_handle *trans) 205179154b1bSChris Mason { 20523a45bb20SJeff Mahoney struct btrfs_fs_info *fs_info = trans->fs_info; 205349b25e05SJeff Mahoney struct btrfs_transaction *cur_trans = trans->transaction; 20548fd17795SChris Mason struct btrfs_transaction *prev_trans = NULL; 205525287e0aSMiao Xie int ret; 205679154b1bSChris Mason 205735b814f3SNikolay Borisov ASSERT(refcount_read(&trans->use_count) == 1); 205835b814f3SNikolay Borisov 20598d25a086SMiao Xie /* Stop the commit early if ->aborted is set */ 2060bf31f87fSDavid Sterba if (TRANS_ABORTED(cur_trans)) { 206125287e0aSMiao Xie ret = cur_trans->aborted; 20623a45bb20SJeff Mahoney btrfs_end_transaction(trans); 2063e4a2bcacSJosef Bacik return ret; 206425287e0aSMiao Xie } 206549b25e05SJeff Mahoney 2066f45c752bSJosef Bacik btrfs_trans_release_metadata(trans); 2067f45c752bSJosef Bacik trans->block_rsv = NULL; 2068f45c752bSJosef Bacik 2069e19eb11fSJosef Bacik /* 2070e19eb11fSJosef Bacik * We only want one transaction commit doing the flushing so we do not 2071e19eb11fSJosef Bacik * waste a bunch of time on lock contention on the extent root node. 2072e19eb11fSJosef Bacik */ 2073e19eb11fSJosef Bacik if (!test_and_set_bit(BTRFS_DELAYED_REFS_FLUSHING, 2074e19eb11fSJosef Bacik &cur_trans->delayed_refs.flags)) { 2075e19eb11fSJosef Bacik /* 2076e19eb11fSJosef Bacik * Make a pass through all the delayed refs we have so far. 2077e19eb11fSJosef Bacik * Any running threads may add more while we are here. 207856bec294SChris Mason */ 2079c79a70b1SNikolay Borisov ret = btrfs_run_delayed_refs(trans, 0); 2080e4a2bcacSJosef Bacik if (ret) { 20813a45bb20SJeff Mahoney btrfs_end_transaction(trans); 2082e4a2bcacSJosef Bacik return ret; 2083e4a2bcacSJosef Bacik } 2084e19eb11fSJosef Bacik } 208556bec294SChris Mason 20866c686b35SNikolay Borisov btrfs_create_pending_block_groups(trans); 2087ea658badSJosef Bacik 20883204d33cSJosef Bacik if (!test_bit(BTRFS_TRANS_DIRTY_BG_RUN, &cur_trans->flags)) { 20891bbc621eSChris Mason int run_it = 0; 20901bbc621eSChris Mason 20911bbc621eSChris Mason /* this mutex is also taken before trying to set 20921bbc621eSChris Mason * block groups readonly. We need to make sure 20931bbc621eSChris Mason * that nobody has set a block group readonly 20941bbc621eSChris Mason * after a extents from that block group have been 20951bbc621eSChris Mason * allocated for cache files. btrfs_set_block_group_ro 20961bbc621eSChris Mason * will wait for the transaction to commit if it 20973204d33cSJosef Bacik * finds BTRFS_TRANS_DIRTY_BG_RUN set. 20981bbc621eSChris Mason * 20993204d33cSJosef Bacik * The BTRFS_TRANS_DIRTY_BG_RUN flag is also used to make sure 21003204d33cSJosef Bacik * only one process starts all the block group IO. It wouldn't 21011bbc621eSChris Mason * hurt to have more than one go through, but there's no 21021bbc621eSChris Mason * real advantage to it either. 21031bbc621eSChris Mason */ 21040b246afaSJeff Mahoney mutex_lock(&fs_info->ro_block_group_mutex); 21053204d33cSJosef Bacik if (!test_and_set_bit(BTRFS_TRANS_DIRTY_BG_RUN, 21063204d33cSJosef Bacik &cur_trans->flags)) 21071bbc621eSChris Mason run_it = 1; 21080b246afaSJeff Mahoney mutex_unlock(&fs_info->ro_block_group_mutex); 21091bbc621eSChris Mason 2110f9cacae3SNikolay Borisov if (run_it) { 211121217054SNikolay Borisov ret = btrfs_start_dirty_block_groups(trans); 21121bbc621eSChris Mason if (ret) { 21133a45bb20SJeff Mahoney btrfs_end_transaction(trans); 21141bbc621eSChris Mason return ret; 21151bbc621eSChris Mason } 2116f9cacae3SNikolay Borisov } 2117f9cacae3SNikolay Borisov } 21181bbc621eSChris Mason 21190b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 21204a9d8bdeSMiao Xie if (cur_trans->state >= TRANS_STATE_COMMIT_START) { 2121d0c2f4faSFilipe Manana enum btrfs_trans_state want_state = TRANS_STATE_COMPLETED; 2122d0c2f4faSFilipe Manana 21230b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 21249b64f57dSElena Reshetova refcount_inc(&cur_trans->use_count); 2125ccd467d6SChris Mason 2126d0c2f4faSFilipe Manana if (trans->in_fsync) 2127d0c2f4faSFilipe Manana want_state = TRANS_STATE_SUPER_COMMITTED; 2128d0c2f4faSFilipe Manana ret = btrfs_end_transaction(trans); 2129d0c2f4faSFilipe Manana wait_for_commit(cur_trans, want_state); 213015ee9bc7SJosef Bacik 2131bf31f87fSDavid Sterba if (TRANS_ABORTED(cur_trans)) 2132b4924a0fSLiu Bo ret = cur_trans->aborted; 2133b4924a0fSLiu Bo 2134724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 213515ee9bc7SJosef Bacik 213649b25e05SJeff Mahoney return ret; 213779154b1bSChris Mason } 21384313b399SChris Mason 21394a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_COMMIT_START; 21400b246afaSJeff Mahoney wake_up(&fs_info->transaction_blocked_wait); 2141bb9c12c9SSage Weil 21420b246afaSJeff Mahoney if (cur_trans->list.prev != &fs_info->trans_list) { 2143d0c2f4faSFilipe Manana enum btrfs_trans_state want_state = TRANS_STATE_COMPLETED; 2144d0c2f4faSFilipe Manana 2145d0c2f4faSFilipe Manana if (trans->in_fsync) 2146d0c2f4faSFilipe Manana want_state = TRANS_STATE_SUPER_COMMITTED; 2147d0c2f4faSFilipe Manana 2148ccd467d6SChris Mason prev_trans = list_entry(cur_trans->list.prev, 2149ccd467d6SChris Mason struct btrfs_transaction, list); 2150d0c2f4faSFilipe Manana if (prev_trans->state < want_state) { 21519b64f57dSElena Reshetova refcount_inc(&prev_trans->use_count); 21520b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 2153ccd467d6SChris Mason 2154d0c2f4faSFilipe Manana wait_for_commit(prev_trans, want_state); 2155d0c2f4faSFilipe Manana 2156bf31f87fSDavid Sterba ret = READ_ONCE(prev_trans->aborted); 2157ccd467d6SChris Mason 2158724e2315SJosef Bacik btrfs_put_transaction(prev_trans); 21591f9b8c8fSFilipe Manana if (ret) 21601f9b8c8fSFilipe Manana goto cleanup_transaction; 2161a4abeea4SJosef Bacik } else { 21620b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 2163ccd467d6SChris Mason } 2164a4abeea4SJosef Bacik } else { 21650b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 2166cb2d3dadSFilipe Manana /* 2167cb2d3dadSFilipe Manana * The previous transaction was aborted and was already removed 2168cb2d3dadSFilipe Manana * from the list of transactions at fs_info->trans_list. So we 2169cb2d3dadSFilipe Manana * abort to prevent writing a new superblock that reflects a 2170cb2d3dadSFilipe Manana * corrupt state (pointing to trees with unwritten nodes/leafs). 2171cb2d3dadSFilipe Manana */ 2172cb2d3dadSFilipe Manana if (test_bit(BTRFS_FS_STATE_TRANS_ABORTED, &fs_info->fs_state)) { 2173cb2d3dadSFilipe Manana ret = -EROFS; 2174cb2d3dadSFilipe Manana goto cleanup_transaction; 2175cb2d3dadSFilipe Manana } 2176ccd467d6SChris Mason } 217715ee9bc7SJosef Bacik 21780860adfdSMiao Xie extwriter_counter_dec(cur_trans, trans->type); 21790860adfdSMiao Xie 218088090ad3SFilipe Manana ret = btrfs_start_delalloc_flush(fs_info); 218182436617SMiao Xie if (ret) 218282436617SMiao Xie goto cleanup_transaction; 218382436617SMiao Xie 2184e5c304e6SNikolay Borisov ret = btrfs_run_delayed_items(trans); 218549b25e05SJeff Mahoney if (ret) 218649b25e05SJeff Mahoney goto cleanup_transaction; 218716cdcec7SMiao Xie 2188581227d0SMiao Xie wait_event(cur_trans->writer_wait, 2189581227d0SMiao Xie extwriter_counter_read(cur_trans) == 0); 2190ed3b3d31SChris Mason 2191581227d0SMiao Xie /* some pending stuffs might be added after the previous flush. */ 2192e5c304e6SNikolay Borisov ret = btrfs_run_delayed_items(trans); 2193ca469637SMiao Xie if (ret) 2194ca469637SMiao Xie goto cleanup_transaction; 2195ca469637SMiao Xie 219688090ad3SFilipe Manana btrfs_wait_delalloc_flush(fs_info); 2197cb7ab021SWang Shilong 219848778179SFilipe Manana /* 219948778179SFilipe Manana * Wait for all ordered extents started by a fast fsync that joined this 220048778179SFilipe Manana * transaction. Otherwise if this transaction commits before the ordered 220148778179SFilipe Manana * extents complete we lose logged data after a power failure. 220248778179SFilipe Manana */ 220348778179SFilipe Manana wait_event(cur_trans->pending_wait, 220448778179SFilipe Manana atomic_read(&cur_trans->pending_ordered) == 0); 220548778179SFilipe Manana 22062ff7e61eSJeff Mahoney btrfs_scrub_pause(fs_info); 2207ed0ca140SJosef Bacik /* 2208ed0ca140SJosef Bacik * Ok now we need to make sure to block out any other joins while we 2209ed0ca140SJosef Bacik * commit the transaction. We could have started a join before setting 22104a9d8bdeSMiao Xie * COMMIT_DOING so make sure to wait for num_writers to == 1 again. 2211ed0ca140SJosef Bacik */ 22120b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 22134a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_COMMIT_DOING; 22140b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 2215ed0ca140SJosef Bacik wait_event(cur_trans->writer_wait, 2216ed0ca140SJosef Bacik atomic_read(&cur_trans->num_writers) == 1); 221715ee9bc7SJosef Bacik 2218bf31f87fSDavid Sterba if (TRANS_ABORTED(cur_trans)) { 22192cba30f1SMiao Xie ret = cur_trans->aborted; 22206cf7f77eSWang Shilong goto scrub_continue; 22212cba30f1SMiao Xie } 22227585717fSChris Mason /* 22237585717fSChris Mason * the reloc mutex makes sure that we stop 22247585717fSChris Mason * the balancing code from coming in and moving 22257585717fSChris Mason * extents around in the middle of the commit 22267585717fSChris Mason */ 22270b246afaSJeff Mahoney mutex_lock(&fs_info->reloc_mutex); 22287585717fSChris Mason 222942874b3dSMiao Xie /* 223042874b3dSMiao Xie * We needn't worry about the delayed items because we will 223142874b3dSMiao Xie * deal with them in create_pending_snapshot(), which is the 223242874b3dSMiao Xie * core function of the snapshot creation. 223342874b3dSMiao Xie */ 223408d50ca3SNikolay Borisov ret = create_pending_snapshots(trans); 223556e9f6eaSDavid Sterba if (ret) 223656e9f6eaSDavid Sterba goto unlock_reloc; 22373063d29fSChris Mason 223842874b3dSMiao Xie /* 223942874b3dSMiao Xie * We insert the dir indexes of the snapshots and update the inode 224042874b3dSMiao Xie * of the snapshots' parents after the snapshot creation, so there 224142874b3dSMiao Xie * are some delayed items which are not dealt with. Now deal with 224242874b3dSMiao Xie * them. 224342874b3dSMiao Xie * 224442874b3dSMiao Xie * We needn't worry that this operation will corrupt the snapshots, 224542874b3dSMiao Xie * because all the tree which are snapshoted will be forced to COW 224642874b3dSMiao Xie * the nodes and leaves. 224742874b3dSMiao Xie */ 2248e5c304e6SNikolay Borisov ret = btrfs_run_delayed_items(trans); 224956e9f6eaSDavid Sterba if (ret) 225056e9f6eaSDavid Sterba goto unlock_reloc; 225116cdcec7SMiao Xie 2252c79a70b1SNikolay Borisov ret = btrfs_run_delayed_refs(trans, (unsigned long)-1); 225356e9f6eaSDavid Sterba if (ret) 225456e9f6eaSDavid Sterba goto unlock_reloc; 225556bec294SChris Mason 2256e999376fSChris Mason /* 2257e999376fSChris Mason * make sure none of the code above managed to slip in a 2258e999376fSChris Mason * delayed item 2259e999376fSChris Mason */ 2260ccdf9b30SJeff Mahoney btrfs_assert_delayed_root_empty(fs_info); 2261e999376fSChris Mason 22622c90e5d6SChris Mason WARN_ON(cur_trans != trans->transaction); 2263dc17ff8fSChris Mason 2264e02119d5SChris Mason /* btrfs_commit_tree_roots is responsible for getting the 2265e02119d5SChris Mason * various roots consistent with each other. Every pointer 2266e02119d5SChris Mason * in the tree of tree roots has to point to the most up to date 2267e02119d5SChris Mason * root for every subvolume and other tree. So, we have to keep 2268e02119d5SChris Mason * the tree logging code from jumping in and changing any 2269e02119d5SChris Mason * of the trees. 2270e02119d5SChris Mason * 2271e02119d5SChris Mason * At this point in the commit, there can't be any tree-log 2272e02119d5SChris Mason * writers, but a little lower down we drop the trans mutex 2273e02119d5SChris Mason * and let new people in. By holding the tree_log_mutex 2274e02119d5SChris Mason * from now until after the super is written, we avoid races 2275e02119d5SChris Mason * with the tree-log code. 2276e02119d5SChris Mason */ 22770b246afaSJeff Mahoney mutex_lock(&fs_info->tree_log_mutex); 22781a40e23bSZheng Yan 22797e4443d9SNikolay Borisov ret = commit_fs_roots(trans); 228056e9f6eaSDavid Sterba if (ret) 228156e9f6eaSDavid Sterba goto unlock_tree_log; 228254aa1f4dSChris Mason 22833818aea2SQu Wenruo /* 22847e1876acSDavid Sterba * Since the transaction is done, we can apply the pending changes 22857e1876acSDavid Sterba * before the next transaction. 22863818aea2SQu Wenruo */ 22870b246afaSJeff Mahoney btrfs_apply_pending_changes(fs_info); 22883818aea2SQu Wenruo 22895d4f98a2SYan Zheng /* commit_fs_roots gets rid of all the tree log roots, it is now 2290e02119d5SChris Mason * safe to free the root of tree log roots 2291e02119d5SChris Mason */ 22920b246afaSJeff Mahoney btrfs_free_log_root_tree(trans, fs_info); 2293e02119d5SChris Mason 22940ed4792aSQu Wenruo /* 22950ed4792aSQu Wenruo * Since fs roots are all committed, we can get a quite accurate 22960ed4792aSQu Wenruo * new_roots. So let's do quota accounting. 22970ed4792aSQu Wenruo */ 2298460fb20aSNikolay Borisov ret = btrfs_qgroup_account_extents(trans); 229956e9f6eaSDavid Sterba if (ret < 0) 230056e9f6eaSDavid Sterba goto unlock_tree_log; 23010ed4792aSQu Wenruo 23029386d8bcSNikolay Borisov ret = commit_cowonly_roots(trans); 230356e9f6eaSDavid Sterba if (ret) 230456e9f6eaSDavid Sterba goto unlock_tree_log; 230554aa1f4dSChris Mason 23062cba30f1SMiao Xie /* 23072cba30f1SMiao Xie * The tasks which save the space cache and inode cache may also 23082cba30f1SMiao Xie * update ->aborted, check it. 23092cba30f1SMiao Xie */ 2310bf31f87fSDavid Sterba if (TRANS_ABORTED(cur_trans)) { 23112cba30f1SMiao Xie ret = cur_trans->aborted; 231256e9f6eaSDavid Sterba goto unlock_tree_log; 23132cba30f1SMiao Xie } 23142cba30f1SMiao Xie 23150b246afaSJeff Mahoney cur_trans = fs_info->running_transaction; 23165f39d397SChris Mason 23170b246afaSJeff Mahoney btrfs_set_root_node(&fs_info->tree_root->root_item, 23180b246afaSJeff Mahoney fs_info->tree_root->node); 23190b246afaSJeff Mahoney list_add_tail(&fs_info->tree_root->dirty_list, 23209e351cc8SJosef Bacik &cur_trans->switch_commits); 23215d4f98a2SYan Zheng 23220b246afaSJeff Mahoney btrfs_set_root_node(&fs_info->chunk_root->root_item, 23230b246afaSJeff Mahoney fs_info->chunk_root->node); 23240b246afaSJeff Mahoney list_add_tail(&fs_info->chunk_root->dirty_list, 23259e351cc8SJosef Bacik &cur_trans->switch_commits); 23269e351cc8SJosef Bacik 2327889bfa39SJosef Bacik switch_commit_roots(trans); 23285d4f98a2SYan Zheng 2329ce93ec54SJosef Bacik ASSERT(list_empty(&cur_trans->dirty_bgs)); 23301bbc621eSChris Mason ASSERT(list_empty(&cur_trans->io_bgs)); 23312ff7e61eSJeff Mahoney update_super_roots(fs_info); 2332e02119d5SChris Mason 23330b246afaSJeff Mahoney btrfs_set_super_log_root(fs_info->super_copy, 0); 23340b246afaSJeff Mahoney btrfs_set_super_log_root_level(fs_info->super_copy, 0); 23350b246afaSJeff Mahoney memcpy(fs_info->super_for_commit, fs_info->super_copy, 23360b246afaSJeff Mahoney sizeof(*fs_info->super_copy)); 2337ccd467d6SChris Mason 2338bbbf7243SNikolay Borisov btrfs_commit_device_sizes(cur_trans); 2339935e5cc9SMiao Xie 23400b246afaSJeff Mahoney clear_bit(BTRFS_FS_LOG1_ERR, &fs_info->flags); 23410b246afaSJeff Mahoney clear_bit(BTRFS_FS_LOG2_ERR, &fs_info->flags); 2342656f30dbSFilipe Manana 23434fbcdf66SFilipe Manana btrfs_trans_release_chunk_metadata(trans); 23444fbcdf66SFilipe Manana 23450b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 23464a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_UNBLOCKED; 23470b246afaSJeff Mahoney fs_info->running_transaction = NULL; 23480b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 23490b246afaSJeff Mahoney mutex_unlock(&fs_info->reloc_mutex); 2350b7ec40d7SChris Mason 23510b246afaSJeff Mahoney wake_up(&fs_info->transaction_wait); 2352e6dcd2dcSChris Mason 235370458a58SNikolay Borisov ret = btrfs_write_and_wait_transaction(trans); 235449b25e05SJeff Mahoney if (ret) { 23550b246afaSJeff Mahoney btrfs_handle_fs_error(fs_info, ret, 235608748810SDavid Sterba "Error while writing out transaction"); 235756e9f6eaSDavid Sterba /* 235856e9f6eaSDavid Sterba * reloc_mutex has been unlocked, tree_log_mutex is still held 235956e9f6eaSDavid Sterba * but we can't jump to unlock_tree_log causing double unlock 236056e9f6eaSDavid Sterba */ 23610b246afaSJeff Mahoney mutex_unlock(&fs_info->tree_log_mutex); 23626cf7f77eSWang Shilong goto scrub_continue; 236349b25e05SJeff Mahoney } 236449b25e05SJeff Mahoney 2365d3575156SNaohiro Aota /* 2366d3575156SNaohiro Aota * At this point, we should have written all the tree blocks allocated 2367d3575156SNaohiro Aota * in this transaction. So it's now safe to free the redirtyied extent 2368d3575156SNaohiro Aota * buffers. 2369d3575156SNaohiro Aota */ 2370d3575156SNaohiro Aota btrfs_free_redirty_list(cur_trans); 2371d3575156SNaohiro Aota 2372eece6a9cSDavid Sterba ret = write_all_supers(fs_info, 0); 2373e02119d5SChris Mason /* 2374e02119d5SChris Mason * the super is written, we can safely allow the tree-loggers 2375e02119d5SChris Mason * to go about their business 2376e02119d5SChris Mason */ 23770b246afaSJeff Mahoney mutex_unlock(&fs_info->tree_log_mutex); 2378c1f32b7cSAnand Jain if (ret) 2379c1f32b7cSAnand Jain goto scrub_continue; 2380e02119d5SChris Mason 2381d0c2f4faSFilipe Manana /* 2382d0c2f4faSFilipe Manana * We needn't acquire the lock here because there is no other task 2383d0c2f4faSFilipe Manana * which can change it. 2384d0c2f4faSFilipe Manana */ 2385d0c2f4faSFilipe Manana cur_trans->state = TRANS_STATE_SUPER_COMMITTED; 2386d0c2f4faSFilipe Manana wake_up(&cur_trans->commit_wait); 2387d0c2f4faSFilipe Manana 23885ead2dd0SNikolay Borisov btrfs_finish_extent_commit(trans); 23894313b399SChris Mason 23903204d33cSJosef Bacik if (test_bit(BTRFS_TRANS_HAVE_FREE_BGS, &cur_trans->flags)) 23910b246afaSJeff Mahoney btrfs_clear_space_info_full(fs_info); 239213212b54SZhao Lei 23930b246afaSJeff Mahoney fs_info->last_trans_committed = cur_trans->transid; 23944a9d8bdeSMiao Xie /* 23954a9d8bdeSMiao Xie * We needn't acquire the lock here because there is no other task 23964a9d8bdeSMiao Xie * which can change it. 23974a9d8bdeSMiao Xie */ 23984a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_COMPLETED; 23992c90e5d6SChris Mason wake_up(&cur_trans->commit_wait); 24003de4586cSChris Mason 24010b246afaSJeff Mahoney spin_lock(&fs_info->trans_lock); 240213c5a93eSJosef Bacik list_del_init(&cur_trans->list); 24030b246afaSJeff Mahoney spin_unlock(&fs_info->trans_lock); 2404a4abeea4SJosef Bacik 2405724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 2406724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 240758176a96SJosef Bacik 24080860adfdSMiao Xie if (trans->type & __TRANS_FREEZABLE) 24090b246afaSJeff Mahoney sb_end_intwrite(fs_info->sb); 2410b2b5ef5cSJan Kara 24113a45bb20SJeff Mahoney trace_btrfs_transaction_commit(trans->root); 24121abe9b8aSliubo 24132ff7e61eSJeff Mahoney btrfs_scrub_continue(fs_info); 2414a2de733cSArne Jansen 24159ed74f2dSJosef Bacik if (current->journal_info == trans) 24169ed74f2dSJosef Bacik current->journal_info = NULL; 24179ed74f2dSJosef Bacik 24182c90e5d6SChris Mason kmem_cache_free(btrfs_trans_handle_cachep, trans); 241924bbcf04SYan, Zheng 242079154b1bSChris Mason return ret; 242149b25e05SJeff Mahoney 242256e9f6eaSDavid Sterba unlock_tree_log: 242356e9f6eaSDavid Sterba mutex_unlock(&fs_info->tree_log_mutex); 242456e9f6eaSDavid Sterba unlock_reloc: 242556e9f6eaSDavid Sterba mutex_unlock(&fs_info->reloc_mutex); 24266cf7f77eSWang Shilong scrub_continue: 24272ff7e61eSJeff Mahoney btrfs_scrub_continue(fs_info); 242849b25e05SJeff Mahoney cleanup_transaction: 2429dc60c525SNikolay Borisov btrfs_trans_release_metadata(trans); 2430c7cc64a9SDavid Sterba btrfs_cleanup_pending_block_groups(trans); 24314fbcdf66SFilipe Manana btrfs_trans_release_chunk_metadata(trans); 24320e721106SJosef Bacik trans->block_rsv = NULL; 24330b246afaSJeff Mahoney btrfs_warn(fs_info, "Skipping commit of aborted transaction."); 243449b25e05SJeff Mahoney if (current->journal_info == trans) 243549b25e05SJeff Mahoney current->journal_info = NULL; 243697cb39bbSNikolay Borisov cleanup_transaction(trans, ret); 243749b25e05SJeff Mahoney 243849b25e05SJeff Mahoney return ret; 243979154b1bSChris Mason } 244079154b1bSChris Mason 2441d352ac68SChris Mason /* 24429d1a2a3aSDavid Sterba * return < 0 if error 24439d1a2a3aSDavid Sterba * 0 if there are no more dead_roots at the time of call 24449d1a2a3aSDavid Sterba * 1 there are more to be processed, call me again 24459d1a2a3aSDavid Sterba * 24469d1a2a3aSDavid Sterba * The return value indicates there are certainly more snapshots to delete, but 24479d1a2a3aSDavid Sterba * if there comes a new one during processing, it may return 0. We don't mind, 24489d1a2a3aSDavid Sterba * because btrfs_commit_super will poke cleaner thread and it will process it a 24499d1a2a3aSDavid Sterba * few seconds later. 2450d352ac68SChris Mason */ 24519d1a2a3aSDavid Sterba int btrfs_clean_one_deleted_snapshot(struct btrfs_root *root) 2452e9d0b13bSChris Mason { 24539d1a2a3aSDavid Sterba int ret; 24545d4f98a2SYan Zheng struct btrfs_fs_info *fs_info = root->fs_info; 2455e9d0b13bSChris Mason 2456a4abeea4SJosef Bacik spin_lock(&fs_info->trans_lock); 24579d1a2a3aSDavid Sterba if (list_empty(&fs_info->dead_roots)) { 24589d1a2a3aSDavid Sterba spin_unlock(&fs_info->trans_lock); 24599d1a2a3aSDavid Sterba return 0; 24609d1a2a3aSDavid Sterba } 24619d1a2a3aSDavid Sterba root = list_first_entry(&fs_info->dead_roots, 24629d1a2a3aSDavid Sterba struct btrfs_root, root_list); 2463cfad392bSJosef Bacik list_del_init(&root->root_list); 2464a4abeea4SJosef Bacik spin_unlock(&fs_info->trans_lock); 24655d4f98a2SYan Zheng 24664fd786e6SMisono Tomohiro btrfs_debug(fs_info, "cleaner removing %llu", root->root_key.objectid); 246776dda93cSYan, Zheng 246816cdcec7SMiao Xie btrfs_kill_all_delayed_nodes(root); 246916cdcec7SMiao Xie 247076dda93cSYan, Zheng if (btrfs_header_backref_rev(root->node) < 247176dda93cSYan, Zheng BTRFS_MIXED_BACKREF_REV) 24720078a9f9SNikolay Borisov ret = btrfs_drop_snapshot(root, 0, 0); 247376dda93cSYan, Zheng else 24740078a9f9SNikolay Borisov ret = btrfs_drop_snapshot(root, 1, 0); 247532471dc2SDavid Sterba 2476dc9492c1SJosef Bacik btrfs_put_root(root); 24776596a928SJosef Bacik return (ret < 0) ? 0 : 1; 2478e9d0b13bSChris Mason } 2479572d9ab7SDavid Sterba 2480572d9ab7SDavid Sterba void btrfs_apply_pending_changes(struct btrfs_fs_info *fs_info) 2481572d9ab7SDavid Sterba { 2482572d9ab7SDavid Sterba unsigned long prev; 2483572d9ab7SDavid Sterba unsigned long bit; 2484572d9ab7SDavid Sterba 24856c9fe14fSQu Wenruo prev = xchg(&fs_info->pending_changes, 0); 2486572d9ab7SDavid Sterba if (!prev) 2487572d9ab7SDavid Sterba return; 2488572d9ab7SDavid Sterba 2489d51033d0SDavid Sterba bit = 1 << BTRFS_PENDING_COMMIT; 2490d51033d0SDavid Sterba if (prev & bit) 2491d51033d0SDavid Sterba btrfs_debug(fs_info, "pending commit done"); 2492d51033d0SDavid Sterba prev &= ~bit; 2493d51033d0SDavid Sterba 2494572d9ab7SDavid Sterba if (prev) 2495572d9ab7SDavid Sterba btrfs_warn(fs_info, 2496572d9ab7SDavid Sterba "unknown pending changes left 0x%lx, ignoring", prev); 2497572d9ab7SDavid Sterba } 2498