16cbd5570SChris Mason /* 26cbd5570SChris Mason * Copyright (C) 2007 Oracle. All rights reserved. 36cbd5570SChris Mason * 46cbd5570SChris Mason * This program is free software; you can redistribute it and/or 56cbd5570SChris Mason * modify it under the terms of the GNU General Public 66cbd5570SChris Mason * License v2 as published by the Free Software Foundation. 76cbd5570SChris Mason * 86cbd5570SChris Mason * This program is distributed in the hope that it will be useful, 96cbd5570SChris Mason * but WITHOUT ANY WARRANTY; without even the implied warranty of 106cbd5570SChris Mason * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 116cbd5570SChris Mason * General Public License for more details. 126cbd5570SChris Mason * 136cbd5570SChris Mason * You should have received a copy of the GNU General Public 146cbd5570SChris Mason * License along with this program; if not, write to the 156cbd5570SChris Mason * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 166cbd5570SChris Mason * Boston, MA 021110-1307, USA. 176cbd5570SChris Mason */ 186cbd5570SChris Mason 1979154b1bSChris Mason #include <linux/fs.h> 205a0e3ad6STejun Heo #include <linux/slab.h> 2134088780SChris Mason #include <linux/sched.h> 22d3c2fdcfSChris Mason #include <linux/writeback.h> 235f39d397SChris Mason #include <linux/pagemap.h> 245f2cc086SChris Mason #include <linux/blkdev.h> 258ea05e3aSAlexander Block #include <linux/uuid.h> 2679154b1bSChris Mason #include "ctree.h" 2779154b1bSChris Mason #include "disk-io.h" 2879154b1bSChris Mason #include "transaction.h" 29925baeddSChris Mason #include "locking.h" 30e02119d5SChris Mason #include "tree-log.h" 31581bb050SLi Zefan #include "inode-map.h" 32733f4fbbSStefan Behrens #include "volumes.h" 338dabb742SStefan Behrens #include "dev-replace.h" 3479154b1bSChris Mason 350f7d52f4SChris Mason #define BTRFS_ROOT_TRANS_TAG 0 360f7d52f4SChris Mason 374a9d8bdeSMiao Xie static unsigned int btrfs_blocked_trans_types[TRANS_STATE_MAX] = { 384a9d8bdeSMiao Xie [TRANS_STATE_RUNNING] = 0U, 394a9d8bdeSMiao Xie [TRANS_STATE_BLOCKED] = (__TRANS_USERSPACE | 404a9d8bdeSMiao Xie __TRANS_START), 414a9d8bdeSMiao Xie [TRANS_STATE_COMMIT_START] = (__TRANS_USERSPACE | 424a9d8bdeSMiao Xie __TRANS_START | 434a9d8bdeSMiao Xie __TRANS_ATTACH), 444a9d8bdeSMiao Xie [TRANS_STATE_COMMIT_DOING] = (__TRANS_USERSPACE | 454a9d8bdeSMiao Xie __TRANS_START | 464a9d8bdeSMiao Xie __TRANS_ATTACH | 474a9d8bdeSMiao Xie __TRANS_JOIN), 484a9d8bdeSMiao Xie [TRANS_STATE_UNBLOCKED] = (__TRANS_USERSPACE | 494a9d8bdeSMiao Xie __TRANS_START | 504a9d8bdeSMiao Xie __TRANS_ATTACH | 514a9d8bdeSMiao Xie __TRANS_JOIN | 524a9d8bdeSMiao Xie __TRANS_JOIN_NOLOCK), 534a9d8bdeSMiao Xie [TRANS_STATE_COMPLETED] = (__TRANS_USERSPACE | 544a9d8bdeSMiao Xie __TRANS_START | 554a9d8bdeSMiao Xie __TRANS_ATTACH | 564a9d8bdeSMiao Xie __TRANS_JOIN | 574a9d8bdeSMiao Xie __TRANS_JOIN_NOLOCK), 584a9d8bdeSMiao Xie }; 594a9d8bdeSMiao Xie 60724e2315SJosef Bacik void btrfs_put_transaction(struct btrfs_transaction *transaction) 6179154b1bSChris Mason { 6213c5a93eSJosef Bacik WARN_ON(atomic_read(&transaction->use_count) == 0); 6313c5a93eSJosef Bacik if (atomic_dec_and_test(&transaction->use_count)) { 64a4abeea4SJosef Bacik BUG_ON(!list_empty(&transaction->list)); 65c46effa6SLiu Bo WARN_ON(!RB_EMPTY_ROOT(&transaction->delayed_refs.href_root)); 666df9a95eSJosef Bacik while (!list_empty(&transaction->pending_chunks)) { 676df9a95eSJosef Bacik struct extent_map *em; 686df9a95eSJosef Bacik 696df9a95eSJosef Bacik em = list_first_entry(&transaction->pending_chunks, 706df9a95eSJosef Bacik struct extent_map, list); 716df9a95eSJosef Bacik list_del_init(&em->list); 726df9a95eSJosef Bacik free_extent_map(em); 736df9a95eSJosef Bacik } 742c90e5d6SChris Mason kmem_cache_free(btrfs_transaction_cachep, transaction); 7579154b1bSChris Mason } 7678fae27eSChris Mason } 7779154b1bSChris Mason 78817d52f8SJosef Bacik static noinline void switch_commit_root(struct btrfs_root *root) 79817d52f8SJosef Bacik { 80817d52f8SJosef Bacik free_extent_buffer(root->commit_root); 81817d52f8SJosef Bacik root->commit_root = btrfs_root_node(root); 82817d52f8SJosef Bacik } 83817d52f8SJosef Bacik 840860adfdSMiao Xie static inline void extwriter_counter_inc(struct btrfs_transaction *trans, 850860adfdSMiao Xie unsigned int type) 860860adfdSMiao Xie { 870860adfdSMiao Xie if (type & TRANS_EXTWRITERS) 880860adfdSMiao Xie atomic_inc(&trans->num_extwriters); 890860adfdSMiao Xie } 900860adfdSMiao Xie 910860adfdSMiao Xie static inline void extwriter_counter_dec(struct btrfs_transaction *trans, 920860adfdSMiao Xie unsigned int type) 930860adfdSMiao Xie { 940860adfdSMiao Xie if (type & TRANS_EXTWRITERS) 950860adfdSMiao Xie atomic_dec(&trans->num_extwriters); 960860adfdSMiao Xie } 970860adfdSMiao Xie 980860adfdSMiao Xie static inline void extwriter_counter_init(struct btrfs_transaction *trans, 990860adfdSMiao Xie unsigned int type) 1000860adfdSMiao Xie { 1010860adfdSMiao Xie atomic_set(&trans->num_extwriters, ((type & TRANS_EXTWRITERS) ? 1 : 0)); 1020860adfdSMiao Xie } 1030860adfdSMiao Xie 1040860adfdSMiao Xie static inline int extwriter_counter_read(struct btrfs_transaction *trans) 1050860adfdSMiao Xie { 1060860adfdSMiao Xie return atomic_read(&trans->num_extwriters); 107178260b2SMiao Xie } 108178260b2SMiao Xie 109d352ac68SChris Mason /* 110d352ac68SChris Mason * either allocate a new transaction or hop into the existing one 111d352ac68SChris Mason */ 1120860adfdSMiao Xie static noinline int join_transaction(struct btrfs_root *root, unsigned int type) 11379154b1bSChris Mason { 11479154b1bSChris Mason struct btrfs_transaction *cur_trans; 11519ae4e81SJan Schmidt struct btrfs_fs_info *fs_info = root->fs_info; 116a4abeea4SJosef Bacik 11719ae4e81SJan Schmidt spin_lock(&fs_info->trans_lock); 118d43317dcSChris Mason loop: 11949b25e05SJeff Mahoney /* The file system has been taken offline. No new transactions. */ 12087533c47SMiao Xie if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) { 12119ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 12249b25e05SJeff Mahoney return -EROFS; 12349b25e05SJeff Mahoney } 12449b25e05SJeff Mahoney 12519ae4e81SJan Schmidt cur_trans = fs_info->running_transaction; 126a4abeea4SJosef Bacik if (cur_trans) { 127871383beSDavid Sterba if (cur_trans->aborted) { 12819ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 12949b25e05SJeff Mahoney return cur_trans->aborted; 130871383beSDavid Sterba } 1314a9d8bdeSMiao Xie if (btrfs_blocked_trans_types[cur_trans->state] & type) { 132178260b2SMiao Xie spin_unlock(&fs_info->trans_lock); 133178260b2SMiao Xie return -EBUSY; 134178260b2SMiao Xie } 135a4abeea4SJosef Bacik atomic_inc(&cur_trans->use_count); 136a4abeea4SJosef Bacik atomic_inc(&cur_trans->num_writers); 1370860adfdSMiao Xie extwriter_counter_inc(cur_trans, type); 13819ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 139a4abeea4SJosef Bacik return 0; 140a4abeea4SJosef Bacik } 14119ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 142a4abeea4SJosef Bacik 143354aa0fbSMiao Xie /* 144354aa0fbSMiao Xie * If we are ATTACH, we just want to catch the current transaction, 145354aa0fbSMiao Xie * and commit it. If there is no transaction, just return ENOENT. 146354aa0fbSMiao Xie */ 147354aa0fbSMiao Xie if (type == TRANS_ATTACH) 148354aa0fbSMiao Xie return -ENOENT; 149354aa0fbSMiao Xie 1504a9d8bdeSMiao Xie /* 1514a9d8bdeSMiao Xie * JOIN_NOLOCK only happens during the transaction commit, so 1524a9d8bdeSMiao Xie * it is impossible that ->running_transaction is NULL 1534a9d8bdeSMiao Xie */ 1544a9d8bdeSMiao Xie BUG_ON(type == TRANS_JOIN_NOLOCK); 1554a9d8bdeSMiao Xie 156a4abeea4SJosef Bacik cur_trans = kmem_cache_alloc(btrfs_transaction_cachep, GFP_NOFS); 157db5b493aSTsutomu Itoh if (!cur_trans) 158db5b493aSTsutomu Itoh return -ENOMEM; 159d43317dcSChris Mason 16019ae4e81SJan Schmidt spin_lock(&fs_info->trans_lock); 16119ae4e81SJan Schmidt if (fs_info->running_transaction) { 162d43317dcSChris Mason /* 163d43317dcSChris Mason * someone started a transaction after we unlocked. Make sure 1644a9d8bdeSMiao Xie * to redo the checks above 165d43317dcSChris Mason */ 166a4abeea4SJosef Bacik kmem_cache_free(btrfs_transaction_cachep, cur_trans); 167d43317dcSChris Mason goto loop; 16887533c47SMiao Xie } else if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) { 169e4b50e14SDan Carpenter spin_unlock(&fs_info->trans_lock); 1707b8b92afSJosef Bacik kmem_cache_free(btrfs_transaction_cachep, cur_trans); 1717b8b92afSJosef Bacik return -EROFS; 172a4abeea4SJosef Bacik } 173d43317dcSChris Mason 17413c5a93eSJosef Bacik atomic_set(&cur_trans->num_writers, 1); 1750860adfdSMiao Xie extwriter_counter_init(cur_trans, type); 17679154b1bSChris Mason init_waitqueue_head(&cur_trans->writer_wait); 17779154b1bSChris Mason init_waitqueue_head(&cur_trans->commit_wait); 1784a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_RUNNING; 179a4abeea4SJosef Bacik /* 180a4abeea4SJosef Bacik * One for this trans handle, one so it will live on until we 181a4abeea4SJosef Bacik * commit the transaction. 182a4abeea4SJosef Bacik */ 183a4abeea4SJosef Bacik atomic_set(&cur_trans->use_count, 2); 18408607c1bSChris Mason cur_trans->start_time = get_seconds(); 18556bec294SChris Mason 186c46effa6SLiu Bo cur_trans->delayed_refs.href_root = RB_ROOT; 187d7df2c79SJosef Bacik atomic_set(&cur_trans->delayed_refs.num_entries, 0); 188c3e69d58SChris Mason cur_trans->delayed_refs.num_heads_ready = 0; 189c3e69d58SChris Mason cur_trans->delayed_refs.num_heads = 0; 19056bec294SChris Mason cur_trans->delayed_refs.flushing = 0; 191c3e69d58SChris Mason cur_trans->delayed_refs.run_delayed_start = 0; 19220b297d6SJan Schmidt 19320b297d6SJan Schmidt /* 19420b297d6SJan Schmidt * although the tree mod log is per file system and not per transaction, 19520b297d6SJan Schmidt * the log must never go across transaction boundaries. 19620b297d6SJan Schmidt */ 19720b297d6SJan Schmidt smp_mb(); 19831b1a2bdSJulia Lawall if (!list_empty(&fs_info->tree_mod_seq_list)) 199efe120a0SFrank Holton WARN(1, KERN_ERR "BTRFS: tree_mod_seq_list not empty when " 20020b297d6SJan Schmidt "creating a fresh transaction\n"); 20131b1a2bdSJulia Lawall if (!RB_EMPTY_ROOT(&fs_info->tree_mod_log)) 202efe120a0SFrank Holton WARN(1, KERN_ERR "BTRFS: tree_mod_log rb tree not empty when " 20320b297d6SJan Schmidt "creating a fresh transaction\n"); 204fc36ed7eSJan Schmidt atomic64_set(&fs_info->tree_mod_seq, 0); 20520b297d6SJan Schmidt 20656bec294SChris Mason spin_lock_init(&cur_trans->delayed_refs.lock); 20756bec294SChris Mason 2083063d29fSChris Mason INIT_LIST_HEAD(&cur_trans->pending_snapshots); 209569e0f35SJosef Bacik INIT_LIST_HEAD(&cur_trans->ordered_operations); 2106df9a95eSJosef Bacik INIT_LIST_HEAD(&cur_trans->pending_chunks); 21119ae4e81SJan Schmidt list_add_tail(&cur_trans->list, &fs_info->trans_list); 212d1310b2eSChris Mason extent_io_tree_init(&cur_trans->dirty_pages, 21319ae4e81SJan Schmidt fs_info->btree_inode->i_mapping); 21419ae4e81SJan Schmidt fs_info->generation++; 21519ae4e81SJan Schmidt cur_trans->transid = fs_info->generation; 21619ae4e81SJan Schmidt fs_info->running_transaction = cur_trans; 21749b25e05SJeff Mahoney cur_trans->aborted = 0; 21819ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 21915ee9bc7SJosef Bacik 22079154b1bSChris Mason return 0; 22179154b1bSChris Mason } 22279154b1bSChris Mason 223d352ac68SChris Mason /* 224d397712bSChris Mason * this does all the record keeping required to make sure that a reference 225d397712bSChris Mason * counted root is properly recorded in a given transaction. This is required 226d397712bSChris Mason * to make sure the old root from before we joined the transaction is deleted 227d397712bSChris Mason * when the transaction commits 228d352ac68SChris Mason */ 2297585717fSChris Mason static int record_root_in_trans(struct btrfs_trans_handle *trans, 2305d4f98a2SYan Zheng struct btrfs_root *root) 2316702ed49SChris Mason { 2325d4f98a2SYan Zheng if (root->ref_cows && root->last_trans < trans->transid) { 2336702ed49SChris Mason WARN_ON(root == root->fs_info->extent_root); 2345d4f98a2SYan Zheng WARN_ON(root->commit_root != root->node); 2355d4f98a2SYan Zheng 2367585717fSChris Mason /* 2377585717fSChris Mason * see below for in_trans_setup usage rules 2387585717fSChris Mason * we have the reloc mutex held now, so there 2397585717fSChris Mason * is only one writer in this function 2407585717fSChris Mason */ 2417585717fSChris Mason root->in_trans_setup = 1; 2427585717fSChris Mason 2437585717fSChris Mason /* make sure readers find in_trans_setup before 2447585717fSChris Mason * they find our root->last_trans update 2457585717fSChris Mason */ 2467585717fSChris Mason smp_wmb(); 2477585717fSChris Mason 248a4abeea4SJosef Bacik spin_lock(&root->fs_info->fs_roots_radix_lock); 249a4abeea4SJosef Bacik if (root->last_trans == trans->transid) { 250a4abeea4SJosef Bacik spin_unlock(&root->fs_info->fs_roots_radix_lock); 251a4abeea4SJosef Bacik return 0; 252a4abeea4SJosef Bacik } 2536702ed49SChris Mason radix_tree_tag_set(&root->fs_info->fs_roots_radix, 2546702ed49SChris Mason (unsigned long)root->root_key.objectid, 2556702ed49SChris Mason BTRFS_ROOT_TRANS_TAG); 256a4abeea4SJosef Bacik spin_unlock(&root->fs_info->fs_roots_radix_lock); 2577585717fSChris Mason root->last_trans = trans->transid; 2587585717fSChris Mason 2597585717fSChris Mason /* this is pretty tricky. We don't want to 2607585717fSChris Mason * take the relocation lock in btrfs_record_root_in_trans 2617585717fSChris Mason * unless we're really doing the first setup for this root in 2627585717fSChris Mason * this transaction. 2637585717fSChris Mason * 2647585717fSChris Mason * Normally we'd use root->last_trans as a flag to decide 2657585717fSChris Mason * if we want to take the expensive mutex. 2667585717fSChris Mason * 2677585717fSChris Mason * But, we have to set root->last_trans before we 2687585717fSChris Mason * init the relocation root, otherwise, we trip over warnings 2697585717fSChris Mason * in ctree.c. The solution used here is to flag ourselves 2707585717fSChris Mason * with root->in_trans_setup. When this is 1, we're still 2717585717fSChris Mason * fixing up the reloc trees and everyone must wait. 2727585717fSChris Mason * 2737585717fSChris Mason * When this is zero, they can trust root->last_trans and fly 2747585717fSChris Mason * through btrfs_record_root_in_trans without having to take the 2757585717fSChris Mason * lock. smp_wmb() makes sure that all the writes above are 2767585717fSChris Mason * done before we pop in the zero below 2777585717fSChris Mason */ 2785d4f98a2SYan Zheng btrfs_init_reloc_root(trans, root); 2797585717fSChris Mason smp_wmb(); 2807585717fSChris Mason root->in_trans_setup = 0; 2816702ed49SChris Mason } 2825d4f98a2SYan Zheng return 0; 2836702ed49SChris Mason } 2845d4f98a2SYan Zheng 2857585717fSChris Mason 2867585717fSChris Mason int btrfs_record_root_in_trans(struct btrfs_trans_handle *trans, 2877585717fSChris Mason struct btrfs_root *root) 2887585717fSChris Mason { 2897585717fSChris Mason if (!root->ref_cows) 2907585717fSChris Mason return 0; 2917585717fSChris Mason 2927585717fSChris Mason /* 2937585717fSChris Mason * see record_root_in_trans for comments about in_trans_setup usage 2947585717fSChris Mason * and barriers 2957585717fSChris Mason */ 2967585717fSChris Mason smp_rmb(); 2977585717fSChris Mason if (root->last_trans == trans->transid && 2987585717fSChris Mason !root->in_trans_setup) 2997585717fSChris Mason return 0; 3007585717fSChris Mason 3017585717fSChris Mason mutex_lock(&root->fs_info->reloc_mutex); 3027585717fSChris Mason record_root_in_trans(trans, root); 3037585717fSChris Mason mutex_unlock(&root->fs_info->reloc_mutex); 3047585717fSChris Mason 3057585717fSChris Mason return 0; 3067585717fSChris Mason } 3077585717fSChris Mason 3084a9d8bdeSMiao Xie static inline int is_transaction_blocked(struct btrfs_transaction *trans) 3094a9d8bdeSMiao Xie { 3104a9d8bdeSMiao Xie return (trans->state >= TRANS_STATE_BLOCKED && 311501407aaSJosef Bacik trans->state < TRANS_STATE_UNBLOCKED && 312501407aaSJosef Bacik !trans->aborted); 3134a9d8bdeSMiao Xie } 3144a9d8bdeSMiao Xie 315d352ac68SChris Mason /* wait for commit against the current transaction to become unblocked 316d352ac68SChris Mason * when this is done, it is safe to start a new transaction, but the current 317d352ac68SChris Mason * transaction might not be fully on disk. 318d352ac68SChris Mason */ 31937d1aeeeSChris Mason static void wait_current_trans(struct btrfs_root *root) 32079154b1bSChris Mason { 321f9295749SChris Mason struct btrfs_transaction *cur_trans; 32279154b1bSChris Mason 323a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 324f9295749SChris Mason cur_trans = root->fs_info->running_transaction; 3254a9d8bdeSMiao Xie if (cur_trans && is_transaction_blocked(cur_trans)) { 32613c5a93eSJosef Bacik atomic_inc(&cur_trans->use_count); 327a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 32872d63ed6SLi Zefan 32972d63ed6SLi Zefan wait_event(root->fs_info->transaction_wait, 330501407aaSJosef Bacik cur_trans->state >= TRANS_STATE_UNBLOCKED || 331501407aaSJosef Bacik cur_trans->aborted); 332724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 333a4abeea4SJosef Bacik } else { 334a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 335f9295749SChris Mason } 33637d1aeeeSChris Mason } 33737d1aeeeSChris Mason 338a22285a6SYan, Zheng static int may_wait_transaction(struct btrfs_root *root, int type) 33937d1aeeeSChris Mason { 340a4abeea4SJosef Bacik if (root->fs_info->log_root_recovering) 341a4abeea4SJosef Bacik return 0; 342a4abeea4SJosef Bacik 343a4abeea4SJosef Bacik if (type == TRANS_USERSPACE) 344a22285a6SYan, Zheng return 1; 345a4abeea4SJosef Bacik 346a4abeea4SJosef Bacik if (type == TRANS_START && 347a4abeea4SJosef Bacik !atomic_read(&root->fs_info->open_ioctl_trans)) 348a4abeea4SJosef Bacik return 1; 349a4abeea4SJosef Bacik 350a22285a6SYan, Zheng return 0; 351a22285a6SYan, Zheng } 352a22285a6SYan, Zheng 35320dd2cbfSMiao Xie static inline bool need_reserve_reloc_root(struct btrfs_root *root) 35420dd2cbfSMiao Xie { 35520dd2cbfSMiao Xie if (!root->fs_info->reloc_ctl || 35620dd2cbfSMiao Xie !root->ref_cows || 35720dd2cbfSMiao Xie root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID || 35820dd2cbfSMiao Xie root->reloc_root) 35920dd2cbfSMiao Xie return false; 36020dd2cbfSMiao Xie 36120dd2cbfSMiao Xie return true; 36220dd2cbfSMiao Xie } 36320dd2cbfSMiao Xie 36408e007d2SMiao Xie static struct btrfs_trans_handle * 3650860adfdSMiao Xie start_transaction(struct btrfs_root *root, u64 num_items, unsigned int type, 36608e007d2SMiao Xie enum btrfs_reserve_flush_enum flush) 367a22285a6SYan, Zheng { 368a22285a6SYan, Zheng struct btrfs_trans_handle *h; 369a22285a6SYan, Zheng struct btrfs_transaction *cur_trans; 370b5009945SJosef Bacik u64 num_bytes = 0; 371c5567237SArne Jansen u64 qgroup_reserved = 0; 37220dd2cbfSMiao Xie bool reloc_reserved = false; 37320dd2cbfSMiao Xie int ret; 374acce952bSliubo 37587533c47SMiao Xie if (test_bit(BTRFS_FS_STATE_ERROR, &root->fs_info->fs_state)) 376acce952bSliubo return ERR_PTR(-EROFS); 3772a1eb461SJosef Bacik 378a26e8c9fSJosef Bacik if (current->journal_info && 379a26e8c9fSJosef Bacik current->journal_info != (void *)BTRFS_SEND_TRANS_STUB) { 3800860adfdSMiao Xie WARN_ON(type & TRANS_EXTWRITERS); 3812a1eb461SJosef Bacik h = current->journal_info; 3822a1eb461SJosef Bacik h->use_count++; 383b7d5b0a8SMiao Xie WARN_ON(h->use_count > 2); 3842a1eb461SJosef Bacik h->orig_rsv = h->block_rsv; 3852a1eb461SJosef Bacik h->block_rsv = NULL; 3862a1eb461SJosef Bacik goto got_it; 3872a1eb461SJosef Bacik } 388b5009945SJosef Bacik 389b5009945SJosef Bacik /* 390b5009945SJosef Bacik * Do the reservation before we join the transaction so we can do all 391b5009945SJosef Bacik * the appropriate flushing if need be. 392b5009945SJosef Bacik */ 393b5009945SJosef Bacik if (num_items > 0 && root != root->fs_info->chunk_root) { 394c5567237SArne Jansen if (root->fs_info->quota_enabled && 395c5567237SArne Jansen is_fstree(root->root_key.objectid)) { 396c5567237SArne Jansen qgroup_reserved = num_items * root->leafsize; 397c5567237SArne Jansen ret = btrfs_qgroup_reserve(root, qgroup_reserved); 398c5567237SArne Jansen if (ret) 399c5567237SArne Jansen return ERR_PTR(ret); 400c5567237SArne Jansen } 401c5567237SArne Jansen 402b5009945SJosef Bacik num_bytes = btrfs_calc_trans_metadata_size(root, num_items); 40320dd2cbfSMiao Xie /* 40420dd2cbfSMiao Xie * Do the reservation for the relocation root creation 40520dd2cbfSMiao Xie */ 40620dd2cbfSMiao Xie if (unlikely(need_reserve_reloc_root(root))) { 40720dd2cbfSMiao Xie num_bytes += root->nodesize; 40820dd2cbfSMiao Xie reloc_reserved = true; 40920dd2cbfSMiao Xie } 41020dd2cbfSMiao Xie 4114a92b1b8SJosef Bacik ret = btrfs_block_rsv_add(root, 412b5009945SJosef Bacik &root->fs_info->trans_block_rsv, 41308e007d2SMiao Xie num_bytes, flush); 414b5009945SJosef Bacik if (ret) 415843fcf35SMiao Xie goto reserve_fail; 416b5009945SJosef Bacik } 417a22285a6SYan, Zheng again: 418a22285a6SYan, Zheng h = kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS); 419843fcf35SMiao Xie if (!h) { 420843fcf35SMiao Xie ret = -ENOMEM; 421843fcf35SMiao Xie goto alloc_fail; 422843fcf35SMiao Xie } 423a22285a6SYan, Zheng 42498114659SJosef Bacik /* 42598114659SJosef Bacik * If we are JOIN_NOLOCK we're already committing a transaction and 42698114659SJosef Bacik * waiting on this guy, so we don't need to do the sb_start_intwrite 42798114659SJosef Bacik * because we're already holding a ref. We need this because we could 42898114659SJosef Bacik * have raced in and did an fsync() on a file which can kick a commit 42998114659SJosef Bacik * and then we deadlock with somebody doing a freeze. 430354aa0fbSMiao Xie * 431354aa0fbSMiao Xie * If we are ATTACH, it means we just want to catch the current 432354aa0fbSMiao Xie * transaction and commit it, so we needn't do sb_start_intwrite(). 43398114659SJosef Bacik */ 4340860adfdSMiao Xie if (type & __TRANS_FREEZABLE) 435b2b5ef5cSJan Kara sb_start_intwrite(root->fs_info->sb); 436b2b5ef5cSJan Kara 437a22285a6SYan, Zheng if (may_wait_transaction(root, type)) 43837d1aeeeSChris Mason wait_current_trans(root); 439a22285a6SYan, Zheng 440a4abeea4SJosef Bacik do { 441354aa0fbSMiao Xie ret = join_transaction(root, type); 442178260b2SMiao Xie if (ret == -EBUSY) { 443a4abeea4SJosef Bacik wait_current_trans(root); 444178260b2SMiao Xie if (unlikely(type == TRANS_ATTACH)) 445178260b2SMiao Xie ret = -ENOENT; 446178260b2SMiao Xie } 447a4abeea4SJosef Bacik } while (ret == -EBUSY); 448a4abeea4SJosef Bacik 449db5b493aSTsutomu Itoh if (ret < 0) { 450354aa0fbSMiao Xie /* We must get the transaction if we are JOIN_NOLOCK. */ 451354aa0fbSMiao Xie BUG_ON(type == TRANS_JOIN_NOLOCK); 452843fcf35SMiao Xie goto join_fail; 453db5b493aSTsutomu Itoh } 4540f7d52f4SChris Mason 455a22285a6SYan, Zheng cur_trans = root->fs_info->running_transaction; 456a22285a6SYan, Zheng 457a22285a6SYan, Zheng h->transid = cur_trans->transid; 458a22285a6SYan, Zheng h->transaction = cur_trans; 45979154b1bSChris Mason h->blocks_used = 0; 460a22285a6SYan, Zheng h->bytes_reserved = 0; 461d13603efSArne Jansen h->root = root; 46256bec294SChris Mason h->delayed_ref_updates = 0; 4632a1eb461SJosef Bacik h->use_count = 1; 4640e721106SJosef Bacik h->adding_csums = 0; 465f0486c68SYan, Zheng h->block_rsv = NULL; 4662a1eb461SJosef Bacik h->orig_rsv = NULL; 46749b25e05SJeff Mahoney h->aborted = 0; 4684b824906SMiao Xie h->qgroup_reserved = 0; 469bed92eaeSArne Jansen h->delayed_ref_elem.seq = 0; 470a698d075SMiao Xie h->type = type; 471c6b305a8SJosef Bacik h->allocating_chunk = false; 47220dd2cbfSMiao Xie h->reloc_reserved = false; 4735039eddcSJosef Bacik h->sync = false; 474bed92eaeSArne Jansen INIT_LIST_HEAD(&h->qgroup_ref_list); 475ea658badSJosef Bacik INIT_LIST_HEAD(&h->new_bgs); 476b7ec40d7SChris Mason 477a22285a6SYan, Zheng smp_mb(); 4784a9d8bdeSMiao Xie if (cur_trans->state >= TRANS_STATE_BLOCKED && 4794a9d8bdeSMiao Xie may_wait_transaction(root, type)) { 480a22285a6SYan, Zheng btrfs_commit_transaction(h, root); 481a22285a6SYan, Zheng goto again; 482a22285a6SYan, Zheng } 4839ed74f2dSJosef Bacik 484b5009945SJosef Bacik if (num_bytes) { 4858c2a3ca2SJosef Bacik trace_btrfs_space_reservation(root->fs_info, "transaction", 4862bcc0328SLiu Bo h->transid, num_bytes, 1); 487b5009945SJosef Bacik h->block_rsv = &root->fs_info->trans_block_rsv; 488b5009945SJosef Bacik h->bytes_reserved = num_bytes; 48920dd2cbfSMiao Xie h->reloc_reserved = reloc_reserved; 490a22285a6SYan, Zheng } 4914b824906SMiao Xie h->qgroup_reserved = qgroup_reserved; 492a22285a6SYan, Zheng 4932a1eb461SJosef Bacik got_it: 494a4abeea4SJosef Bacik btrfs_record_root_in_trans(h, root); 495a22285a6SYan, Zheng 496a22285a6SYan, Zheng if (!current->journal_info && type != TRANS_USERSPACE) 497a22285a6SYan, Zheng current->journal_info = h; 49879154b1bSChris Mason return h; 499843fcf35SMiao Xie 500843fcf35SMiao Xie join_fail: 5010860adfdSMiao Xie if (type & __TRANS_FREEZABLE) 502843fcf35SMiao Xie sb_end_intwrite(root->fs_info->sb); 503843fcf35SMiao Xie kmem_cache_free(btrfs_trans_handle_cachep, h); 504843fcf35SMiao Xie alloc_fail: 505843fcf35SMiao Xie if (num_bytes) 506843fcf35SMiao Xie btrfs_block_rsv_release(root, &root->fs_info->trans_block_rsv, 507843fcf35SMiao Xie num_bytes); 508843fcf35SMiao Xie reserve_fail: 509843fcf35SMiao Xie if (qgroup_reserved) 510843fcf35SMiao Xie btrfs_qgroup_free(root, qgroup_reserved); 511843fcf35SMiao Xie return ERR_PTR(ret); 51279154b1bSChris Mason } 51379154b1bSChris Mason 514f9295749SChris Mason struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root, 515a22285a6SYan, Zheng int num_items) 516f9295749SChris Mason { 51708e007d2SMiao Xie return start_transaction(root, num_items, TRANS_START, 51808e007d2SMiao Xie BTRFS_RESERVE_FLUSH_ALL); 519f9295749SChris Mason } 5208407aa46SMiao Xie 52108e007d2SMiao Xie struct btrfs_trans_handle *btrfs_start_transaction_lflush( 5228407aa46SMiao Xie struct btrfs_root *root, int num_items) 5238407aa46SMiao Xie { 52408e007d2SMiao Xie return start_transaction(root, num_items, TRANS_START, 52508e007d2SMiao Xie BTRFS_RESERVE_FLUSH_LIMIT); 5268407aa46SMiao Xie } 5278407aa46SMiao Xie 5287a7eaa40SJosef Bacik struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root) 529f9295749SChris Mason { 5308407aa46SMiao Xie return start_transaction(root, 0, TRANS_JOIN, 0); 531f9295749SChris Mason } 532f9295749SChris Mason 5337a7eaa40SJosef Bacik struct btrfs_trans_handle *btrfs_join_transaction_nolock(struct btrfs_root *root) 5340af3d00bSJosef Bacik { 5358407aa46SMiao Xie return start_transaction(root, 0, TRANS_JOIN_NOLOCK, 0); 5360af3d00bSJosef Bacik } 5370af3d00bSJosef Bacik 5387a7eaa40SJosef Bacik struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *root) 5399ca9ee09SSage Weil { 5408407aa46SMiao Xie return start_transaction(root, 0, TRANS_USERSPACE, 0); 5419ca9ee09SSage Weil } 5429ca9ee09SSage Weil 543d4edf39bSMiao Xie /* 544d4edf39bSMiao Xie * btrfs_attach_transaction() - catch the running transaction 545d4edf39bSMiao Xie * 546d4edf39bSMiao Xie * It is used when we want to commit the current the transaction, but 547d4edf39bSMiao Xie * don't want to start a new one. 548d4edf39bSMiao Xie * 549d4edf39bSMiao Xie * Note: If this function return -ENOENT, it just means there is no 550d4edf39bSMiao Xie * running transaction. But it is possible that the inactive transaction 551d4edf39bSMiao Xie * is still in the memory, not fully on disk. If you hope there is no 552d4edf39bSMiao Xie * inactive transaction in the fs when -ENOENT is returned, you should 553d4edf39bSMiao Xie * invoke 554d4edf39bSMiao Xie * btrfs_attach_transaction_barrier() 555d4edf39bSMiao Xie */ 556354aa0fbSMiao Xie struct btrfs_trans_handle *btrfs_attach_transaction(struct btrfs_root *root) 55760376ce4SJosef Bacik { 558354aa0fbSMiao Xie return start_transaction(root, 0, TRANS_ATTACH, 0); 55960376ce4SJosef Bacik } 56060376ce4SJosef Bacik 561d4edf39bSMiao Xie /* 56290b6d283SWang Sheng-Hui * btrfs_attach_transaction_barrier() - catch the running transaction 563d4edf39bSMiao Xie * 564d4edf39bSMiao Xie * It is similar to the above function, the differentia is this one 565d4edf39bSMiao Xie * will wait for all the inactive transactions until they fully 566d4edf39bSMiao Xie * complete. 567d4edf39bSMiao Xie */ 568d4edf39bSMiao Xie struct btrfs_trans_handle * 569d4edf39bSMiao Xie btrfs_attach_transaction_barrier(struct btrfs_root *root) 570d4edf39bSMiao Xie { 571d4edf39bSMiao Xie struct btrfs_trans_handle *trans; 572d4edf39bSMiao Xie 573d4edf39bSMiao Xie trans = start_transaction(root, 0, TRANS_ATTACH, 0); 574d4edf39bSMiao Xie if (IS_ERR(trans) && PTR_ERR(trans) == -ENOENT) 575d4edf39bSMiao Xie btrfs_wait_for_commit(root, 0); 576d4edf39bSMiao Xie 577d4edf39bSMiao Xie return trans; 578d4edf39bSMiao Xie } 579d4edf39bSMiao Xie 580d352ac68SChris Mason /* wait for a transaction commit to be fully complete */ 581b9c8300cSLi Zefan static noinline void wait_for_commit(struct btrfs_root *root, 58289ce8a63SChris Mason struct btrfs_transaction *commit) 58389ce8a63SChris Mason { 5844a9d8bdeSMiao Xie wait_event(commit->commit_wait, commit->state == TRANS_STATE_COMPLETED); 58589ce8a63SChris Mason } 58689ce8a63SChris Mason 58746204592SSage Weil int btrfs_wait_for_commit(struct btrfs_root *root, u64 transid) 58846204592SSage Weil { 58946204592SSage Weil struct btrfs_transaction *cur_trans = NULL, *t; 5908cd2807fSMiao Xie int ret = 0; 59146204592SSage Weil 59246204592SSage Weil if (transid) { 59346204592SSage Weil if (transid <= root->fs_info->last_trans_committed) 594a4abeea4SJosef Bacik goto out; 59546204592SSage Weil 5968cd2807fSMiao Xie ret = -EINVAL; 59746204592SSage Weil /* find specified transaction */ 598a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 59946204592SSage Weil list_for_each_entry(t, &root->fs_info->trans_list, list) { 60046204592SSage Weil if (t->transid == transid) { 60146204592SSage Weil cur_trans = t; 602a4abeea4SJosef Bacik atomic_inc(&cur_trans->use_count); 6038cd2807fSMiao Xie ret = 0; 60446204592SSage Weil break; 60546204592SSage Weil } 6068cd2807fSMiao Xie if (t->transid > transid) { 6078cd2807fSMiao Xie ret = 0; 60846204592SSage Weil break; 60946204592SSage Weil } 6108cd2807fSMiao Xie } 611a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 6128cd2807fSMiao Xie /* The specified transaction doesn't exist */ 61346204592SSage Weil if (!cur_trans) 6148cd2807fSMiao Xie goto out; 61546204592SSage Weil } else { 61646204592SSage Weil /* find newest transaction that is committing | committed */ 617a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 61846204592SSage Weil list_for_each_entry_reverse(t, &root->fs_info->trans_list, 61946204592SSage Weil list) { 6204a9d8bdeSMiao Xie if (t->state >= TRANS_STATE_COMMIT_START) { 6214a9d8bdeSMiao Xie if (t->state == TRANS_STATE_COMPLETED) 6223473f3c0SJosef Bacik break; 62346204592SSage Weil cur_trans = t; 624a4abeea4SJosef Bacik atomic_inc(&cur_trans->use_count); 62546204592SSage Weil break; 62646204592SSage Weil } 62746204592SSage Weil } 628a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 62946204592SSage Weil if (!cur_trans) 630a4abeea4SJosef Bacik goto out; /* nothing committing|committed */ 63146204592SSage Weil } 63246204592SSage Weil 63346204592SSage Weil wait_for_commit(root, cur_trans); 634724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 635a4abeea4SJosef Bacik out: 63646204592SSage Weil return ret; 63746204592SSage Weil } 63846204592SSage Weil 63937d1aeeeSChris Mason void btrfs_throttle(struct btrfs_root *root) 64037d1aeeeSChris Mason { 641a4abeea4SJosef Bacik if (!atomic_read(&root->fs_info->open_ioctl_trans)) 64237d1aeeeSChris Mason wait_current_trans(root); 64337d1aeeeSChris Mason } 64437d1aeeeSChris Mason 6458929ecfaSYan, Zheng static int should_end_transaction(struct btrfs_trans_handle *trans, 6468929ecfaSYan, Zheng struct btrfs_root *root) 6478929ecfaSYan, Zheng { 6481be41b78SJosef Bacik if (root->fs_info->global_block_rsv.space_info->full && 6490a2b2a84SJosef Bacik btrfs_check_space_for_delayed_refs(trans, root)) 6501be41b78SJosef Bacik return 1; 65136ba022aSJosef Bacik 6521be41b78SJosef Bacik return !!btrfs_block_rsv_check(root, &root->fs_info->global_block_rsv, 5); 6538929ecfaSYan, Zheng } 6548929ecfaSYan, Zheng 6558929ecfaSYan, Zheng int btrfs_should_end_transaction(struct btrfs_trans_handle *trans, 6568929ecfaSYan, Zheng struct btrfs_root *root) 6578929ecfaSYan, Zheng { 6588929ecfaSYan, Zheng struct btrfs_transaction *cur_trans = trans->transaction; 6598929ecfaSYan, Zheng int updates; 66049b25e05SJeff Mahoney int err; 6618929ecfaSYan, Zheng 662a4abeea4SJosef Bacik smp_mb(); 6634a9d8bdeSMiao Xie if (cur_trans->state >= TRANS_STATE_BLOCKED || 6644a9d8bdeSMiao Xie cur_trans->delayed_refs.flushing) 6658929ecfaSYan, Zheng return 1; 6668929ecfaSYan, Zheng 6678929ecfaSYan, Zheng updates = trans->delayed_ref_updates; 6688929ecfaSYan, Zheng trans->delayed_ref_updates = 0; 66949b25e05SJeff Mahoney if (updates) { 67049b25e05SJeff Mahoney err = btrfs_run_delayed_refs(trans, root, updates); 67149b25e05SJeff Mahoney if (err) /* Error code will also eval true */ 67249b25e05SJeff Mahoney return err; 67349b25e05SJeff Mahoney } 6748929ecfaSYan, Zheng 6758929ecfaSYan, Zheng return should_end_transaction(trans, root); 6768929ecfaSYan, Zheng } 6778929ecfaSYan, Zheng 67889ce8a63SChris Mason static int __btrfs_end_transaction(struct btrfs_trans_handle *trans, 679a698d075SMiao Xie struct btrfs_root *root, int throttle) 68079154b1bSChris Mason { 6818929ecfaSYan, Zheng struct btrfs_transaction *cur_trans = trans->transaction; 682ab78c84dSChris Mason struct btrfs_fs_info *info = root->fs_info; 6831be41b78SJosef Bacik unsigned long cur = trans->delayed_ref_updates; 684a698d075SMiao Xie int lock = (trans->type != TRANS_JOIN_NOLOCK); 6854edc2ca3SDave Jones int err = 0; 686d6e4a428SChris Mason 6873bbb24b2SJosef Bacik if (trans->use_count > 1) { 6883bbb24b2SJosef Bacik trans->use_count--; 6892a1eb461SJosef Bacik trans->block_rsv = trans->orig_rsv; 6902a1eb461SJosef Bacik return 0; 6912a1eb461SJosef Bacik } 6922a1eb461SJosef Bacik 693edf39272SJan Schmidt /* 694edf39272SJan Schmidt * do the qgroup accounting as early as possible 695edf39272SJan Schmidt */ 696edf39272SJan Schmidt err = btrfs_delayed_refs_qgroup_accounting(trans, info); 697edf39272SJan Schmidt 698b24e03dbSJosef Bacik btrfs_trans_release_metadata(trans, root); 6994c13d758SJosef Bacik trans->block_rsv = NULL; 700c5567237SArne Jansen 701c5567237SArne Jansen if (trans->qgroup_reserved) { 7027c2ec3f0SLiu Bo /* 7037c2ec3f0SLiu Bo * the same root has to be passed here between start_transaction 7047c2ec3f0SLiu Bo * and end_transaction. Subvolume quota depends on this. 7057c2ec3f0SLiu Bo */ 7067c2ec3f0SLiu Bo btrfs_qgroup_free(trans->root, trans->qgroup_reserved); 707c5567237SArne Jansen trans->qgroup_reserved = 0; 708c5567237SArne Jansen } 709c5567237SArne Jansen 710ea658badSJosef Bacik if (!list_empty(&trans->new_bgs)) 711ea658badSJosef Bacik btrfs_create_pending_block_groups(trans, root); 712ea658badSJosef Bacik 713c3e69d58SChris Mason trans->delayed_ref_updates = 0; 7145039eddcSJosef Bacik if (!trans->sync && btrfs_should_throttle_delayed_refs(trans, root)) { 7150a2b2a84SJosef Bacik cur = max_t(unsigned long, cur, 32); 716c3e69d58SChris Mason trans->delayed_ref_updates = 0; 717c3e69d58SChris Mason btrfs_run_delayed_refs(trans, root, cur); 71856bec294SChris Mason } 719bb721703SChris Mason 7200e721106SJosef Bacik btrfs_trans_release_metadata(trans, root); 7210e721106SJosef Bacik trans->block_rsv = NULL; 72256bec294SChris Mason 723ea658badSJosef Bacik if (!list_empty(&trans->new_bgs)) 724ea658badSJosef Bacik btrfs_create_pending_block_groups(trans, root); 725ea658badSJosef Bacik 726a4abeea4SJosef Bacik if (lock && !atomic_read(&root->fs_info->open_ioctl_trans) && 7274a9d8bdeSMiao Xie should_end_transaction(trans, root) && 7284a9d8bdeSMiao Xie ACCESS_ONCE(cur_trans->state) == TRANS_STATE_RUNNING) { 7294a9d8bdeSMiao Xie spin_lock(&info->trans_lock); 7304a9d8bdeSMiao Xie if (cur_trans->state == TRANS_STATE_RUNNING) 7314a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_BLOCKED; 7324a9d8bdeSMiao Xie spin_unlock(&info->trans_lock); 733a4abeea4SJosef Bacik } 7348929ecfaSYan, Zheng 7354a9d8bdeSMiao Xie if (lock && ACCESS_ONCE(cur_trans->state) == TRANS_STATE_BLOCKED) { 7363bbb24b2SJosef Bacik if (throttle) 7378929ecfaSYan, Zheng return btrfs_commit_transaction(trans, root); 7383bbb24b2SJosef Bacik else 7398929ecfaSYan, Zheng wake_up_process(info->transaction_kthread); 7408929ecfaSYan, Zheng } 7418929ecfaSYan, Zheng 7420860adfdSMiao Xie if (trans->type & __TRANS_FREEZABLE) 7436df7881aSJosef Bacik sb_end_intwrite(root->fs_info->sb); 7446df7881aSJosef Bacik 7458929ecfaSYan, Zheng WARN_ON(cur_trans != info->running_transaction); 74613c5a93eSJosef Bacik WARN_ON(atomic_read(&cur_trans->num_writers) < 1); 74713c5a93eSJosef Bacik atomic_dec(&cur_trans->num_writers); 7480860adfdSMiao Xie extwriter_counter_dec(cur_trans, trans->type); 74989ce8a63SChris Mason 75099d16cbcSSage Weil smp_mb(); 75179154b1bSChris Mason if (waitqueue_active(&cur_trans->writer_wait)) 75279154b1bSChris Mason wake_up(&cur_trans->writer_wait); 753724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 7549ed74f2dSJosef Bacik 7559ed74f2dSJosef Bacik if (current->journal_info == trans) 7569ed74f2dSJosef Bacik current->journal_info = NULL; 757ab78c84dSChris Mason 75824bbcf04SYan, Zheng if (throttle) 75924bbcf04SYan, Zheng btrfs_run_delayed_iputs(root); 76024bbcf04SYan, Zheng 76149b25e05SJeff Mahoney if (trans->aborted || 7624e121c06SJosef Bacik test_bit(BTRFS_FS_STATE_ERROR, &root->fs_info->fs_state)) { 7634e121c06SJosef Bacik wake_up_process(info->transaction_kthread); 7644edc2ca3SDave Jones err = -EIO; 7654e121c06SJosef Bacik } 766edf39272SJan Schmidt assert_qgroups_uptodate(trans); 76749b25e05SJeff Mahoney 7684edc2ca3SDave Jones kmem_cache_free(btrfs_trans_handle_cachep, trans); 7694edc2ca3SDave Jones return err; 77079154b1bSChris Mason } 77179154b1bSChris Mason 77289ce8a63SChris Mason int btrfs_end_transaction(struct btrfs_trans_handle *trans, 77389ce8a63SChris Mason struct btrfs_root *root) 77489ce8a63SChris Mason { 77598ad43beSWang Shilong return __btrfs_end_transaction(trans, root, 0); 77689ce8a63SChris Mason } 77789ce8a63SChris Mason 77889ce8a63SChris Mason int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans, 77989ce8a63SChris Mason struct btrfs_root *root) 78089ce8a63SChris Mason { 78198ad43beSWang Shilong return __btrfs_end_transaction(trans, root, 1); 78216cdcec7SMiao Xie } 78316cdcec7SMiao Xie 784d352ac68SChris Mason /* 785d352ac68SChris Mason * when btree blocks are allocated, they have some corresponding bits set for 786d352ac68SChris Mason * them in one of two extent_io trees. This is used to make sure all of 787690587d1SChris Mason * those extents are sent to disk but does not wait on them 788d352ac68SChris Mason */ 789690587d1SChris Mason int btrfs_write_marked_extents(struct btrfs_root *root, 7908cef4e16SYan, Zheng struct extent_io_tree *dirty_pages, int mark) 79179154b1bSChris Mason { 792777e6bd7SChris Mason int err = 0; 7937c4452b9SChris Mason int werr = 0; 7941728366eSJosef Bacik struct address_space *mapping = root->fs_info->btree_inode->i_mapping; 795e6138876SJosef Bacik struct extent_state *cached_state = NULL; 796777e6bd7SChris Mason u64 start = 0; 7975f39d397SChris Mason u64 end; 7987c4452b9SChris Mason 7991728366eSJosef Bacik while (!find_first_extent_bit(dirty_pages, start, &start, &end, 800e6138876SJosef Bacik mark, &cached_state)) { 801e6138876SJosef Bacik convert_extent_bit(dirty_pages, start, end, EXTENT_NEED_WAIT, 802e6138876SJosef Bacik mark, &cached_state, GFP_NOFS); 803e6138876SJosef Bacik cached_state = NULL; 8041728366eSJosef Bacik err = filemap_fdatawrite_range(mapping, start, end); 8057c4452b9SChris Mason if (err) 8067c4452b9SChris Mason werr = err; 8071728366eSJosef Bacik cond_resched(); 8081728366eSJosef Bacik start = end + 1; 8097c4452b9SChris Mason } 810690587d1SChris Mason if (err) 811690587d1SChris Mason werr = err; 812690587d1SChris Mason return werr; 813690587d1SChris Mason } 814690587d1SChris Mason 815690587d1SChris Mason /* 816690587d1SChris Mason * when btree blocks are allocated, they have some corresponding bits set for 817690587d1SChris Mason * them in one of two extent_io trees. This is used to make sure all of 818690587d1SChris Mason * those extents are on disk for transaction or log commit. We wait 819690587d1SChris Mason * on all the pages and clear them from the dirty pages state tree 820690587d1SChris Mason */ 821690587d1SChris Mason int btrfs_wait_marked_extents(struct btrfs_root *root, 8228cef4e16SYan, Zheng struct extent_io_tree *dirty_pages, int mark) 823690587d1SChris Mason { 824690587d1SChris Mason int err = 0; 825690587d1SChris Mason int werr = 0; 8261728366eSJosef Bacik struct address_space *mapping = root->fs_info->btree_inode->i_mapping; 827e6138876SJosef Bacik struct extent_state *cached_state = NULL; 828690587d1SChris Mason u64 start = 0; 829690587d1SChris Mason u64 end; 830690587d1SChris Mason 8311728366eSJosef Bacik while (!find_first_extent_bit(dirty_pages, start, &start, &end, 832e6138876SJosef Bacik EXTENT_NEED_WAIT, &cached_state)) { 833e6138876SJosef Bacik clear_extent_bit(dirty_pages, start, end, EXTENT_NEED_WAIT, 834e6138876SJosef Bacik 0, 0, &cached_state, GFP_NOFS); 8351728366eSJosef Bacik err = filemap_fdatawait_range(mapping, start, end); 836777e6bd7SChris Mason if (err) 837777e6bd7SChris Mason werr = err; 838777e6bd7SChris Mason cond_resched(); 8391728366eSJosef Bacik start = end + 1; 840777e6bd7SChris Mason } 8417c4452b9SChris Mason if (err) 8427c4452b9SChris Mason werr = err; 8437c4452b9SChris Mason return werr; 84479154b1bSChris Mason } 84579154b1bSChris Mason 846690587d1SChris Mason /* 847690587d1SChris Mason * when btree blocks are allocated, they have some corresponding bits set for 848690587d1SChris Mason * them in one of two extent_io trees. This is used to make sure all of 849690587d1SChris Mason * those extents are on disk for transaction or log commit 850690587d1SChris Mason */ 851171170c1SSergei Trofimovich static int btrfs_write_and_wait_marked_extents(struct btrfs_root *root, 8528cef4e16SYan, Zheng struct extent_io_tree *dirty_pages, int mark) 853690587d1SChris Mason { 854690587d1SChris Mason int ret; 855690587d1SChris Mason int ret2; 856c6adc9ccSMiao Xie struct blk_plug plug; 857690587d1SChris Mason 858c6adc9ccSMiao Xie blk_start_plug(&plug); 8598cef4e16SYan, Zheng ret = btrfs_write_marked_extents(root, dirty_pages, mark); 860c6adc9ccSMiao Xie blk_finish_plug(&plug); 8618cef4e16SYan, Zheng ret2 = btrfs_wait_marked_extents(root, dirty_pages, mark); 862bf0da8c1SChris Mason 863bf0da8c1SChris Mason if (ret) 864bf0da8c1SChris Mason return ret; 865bf0da8c1SChris Mason if (ret2) 866bf0da8c1SChris Mason return ret2; 867bf0da8c1SChris Mason return 0; 868690587d1SChris Mason } 869690587d1SChris Mason 870d0c803c4SChris Mason int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans, 871d0c803c4SChris Mason struct btrfs_root *root) 872d0c803c4SChris Mason { 873d0c803c4SChris Mason if (!trans || !trans->transaction) { 874d0c803c4SChris Mason struct inode *btree_inode; 875d0c803c4SChris Mason btree_inode = root->fs_info->btree_inode; 876d0c803c4SChris Mason return filemap_write_and_wait(btree_inode->i_mapping); 877d0c803c4SChris Mason } 878d0c803c4SChris Mason return btrfs_write_and_wait_marked_extents(root, 8798cef4e16SYan, Zheng &trans->transaction->dirty_pages, 8808cef4e16SYan, Zheng EXTENT_DIRTY); 881d0c803c4SChris Mason } 882d0c803c4SChris Mason 883d352ac68SChris Mason /* 884d352ac68SChris Mason * this is used to update the root pointer in the tree of tree roots. 885d352ac68SChris Mason * 886d352ac68SChris Mason * But, in the case of the extent allocation tree, updating the root 887d352ac68SChris Mason * pointer may allocate blocks which may change the root of the extent 888d352ac68SChris Mason * allocation tree. 889d352ac68SChris Mason * 890d352ac68SChris Mason * So, this loops and repeats and makes sure the cowonly root didn't 891d352ac68SChris Mason * change while the root pointer was being updated in the metadata. 892d352ac68SChris Mason */ 8930b86a832SChris Mason static int update_cowonly_root(struct btrfs_trans_handle *trans, 89479154b1bSChris Mason struct btrfs_root *root) 89579154b1bSChris Mason { 89679154b1bSChris Mason int ret; 8970b86a832SChris Mason u64 old_root_bytenr; 89886b9f2ecSYan, Zheng u64 old_root_used; 8990b86a832SChris Mason struct btrfs_root *tree_root = root->fs_info->tree_root; 90079154b1bSChris Mason 90186b9f2ecSYan, Zheng old_root_used = btrfs_root_used(&root->root_item); 9020b86a832SChris Mason btrfs_write_dirty_block_groups(trans, root); 90356bec294SChris Mason 90479154b1bSChris Mason while (1) { 9050b86a832SChris Mason old_root_bytenr = btrfs_root_bytenr(&root->root_item); 90686b9f2ecSYan, Zheng if (old_root_bytenr == root->node->start && 90786b9f2ecSYan, Zheng old_root_used == btrfs_root_used(&root->root_item)) 90879154b1bSChris Mason break; 90987ef2bb4SChris Mason 9105d4f98a2SYan Zheng btrfs_set_root_node(&root->root_item, root->node); 91179154b1bSChris Mason ret = btrfs_update_root(trans, tree_root, 9120b86a832SChris Mason &root->root_key, 9130b86a832SChris Mason &root->root_item); 91449b25e05SJeff Mahoney if (ret) 91549b25e05SJeff Mahoney return ret; 91656bec294SChris Mason 91786b9f2ecSYan, Zheng old_root_used = btrfs_root_used(&root->root_item); 9184a8c9a62SYan Zheng ret = btrfs_write_dirty_block_groups(trans, root); 91949b25e05SJeff Mahoney if (ret) 92049b25e05SJeff Mahoney return ret; 9210b86a832SChris Mason } 922276e680dSYan Zheng 923276e680dSYan Zheng if (root != root->fs_info->extent_root) 924817d52f8SJosef Bacik switch_commit_root(root); 925276e680dSYan Zheng 9260b86a832SChris Mason return 0; 9270b86a832SChris Mason } 9280b86a832SChris Mason 929d352ac68SChris Mason /* 930d352ac68SChris Mason * update all the cowonly tree roots on disk 93149b25e05SJeff Mahoney * 93249b25e05SJeff Mahoney * The error handling in this function may not be obvious. Any of the 93349b25e05SJeff Mahoney * failures will cause the file system to go offline. We still need 93449b25e05SJeff Mahoney * to clean up the delayed refs. 935d352ac68SChris Mason */ 9365d4f98a2SYan Zheng static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans, 9370b86a832SChris Mason struct btrfs_root *root) 9380b86a832SChris Mason { 9390b86a832SChris Mason struct btrfs_fs_info *fs_info = root->fs_info; 9400b86a832SChris Mason struct list_head *next; 94184234f3aSYan Zheng struct extent_buffer *eb; 94256bec294SChris Mason int ret; 94384234f3aSYan Zheng 94456bec294SChris Mason ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); 94549b25e05SJeff Mahoney if (ret) 94649b25e05SJeff Mahoney return ret; 94787ef2bb4SChris Mason 94884234f3aSYan Zheng eb = btrfs_lock_root_node(fs_info->tree_root); 94949b25e05SJeff Mahoney ret = btrfs_cow_block(trans, fs_info->tree_root, eb, NULL, 95049b25e05SJeff Mahoney 0, &eb); 95184234f3aSYan Zheng btrfs_tree_unlock(eb); 95284234f3aSYan Zheng free_extent_buffer(eb); 9530b86a832SChris Mason 95449b25e05SJeff Mahoney if (ret) 95549b25e05SJeff Mahoney return ret; 95649b25e05SJeff Mahoney 95756bec294SChris Mason ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); 95849b25e05SJeff Mahoney if (ret) 95949b25e05SJeff Mahoney return ret; 96087ef2bb4SChris Mason 961733f4fbbSStefan Behrens ret = btrfs_run_dev_stats(trans, root->fs_info); 962c16ce190SJosef Bacik if (ret) 963c16ce190SJosef Bacik return ret; 9648dabb742SStefan Behrens ret = btrfs_run_dev_replace(trans, root->fs_info); 965c16ce190SJosef Bacik if (ret) 966c16ce190SJosef Bacik return ret; 967546adb0dSJan Schmidt ret = btrfs_run_qgroups(trans, root->fs_info); 968c16ce190SJosef Bacik if (ret) 969c16ce190SJosef Bacik return ret; 970546adb0dSJan Schmidt 971546adb0dSJan Schmidt /* run_qgroups might have added some more refs */ 972546adb0dSJan Schmidt ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); 973c16ce190SJosef Bacik if (ret) 974c16ce190SJosef Bacik return ret; 975546adb0dSJan Schmidt 9760b86a832SChris Mason while (!list_empty(&fs_info->dirty_cowonly_roots)) { 9770b86a832SChris Mason next = fs_info->dirty_cowonly_roots.next; 9780b86a832SChris Mason list_del_init(next); 9790b86a832SChris Mason root = list_entry(next, struct btrfs_root, dirty_list); 98087ef2bb4SChris Mason 98149b25e05SJeff Mahoney ret = update_cowonly_root(trans, root); 98249b25e05SJeff Mahoney if (ret) 98349b25e05SJeff Mahoney return ret; 98479154b1bSChris Mason } 985276e680dSYan Zheng 986276e680dSYan Zheng down_write(&fs_info->extent_commit_sem); 987276e680dSYan Zheng switch_commit_root(fs_info->extent_root); 988276e680dSYan Zheng up_write(&fs_info->extent_commit_sem); 989276e680dSYan Zheng 9908dabb742SStefan Behrens btrfs_after_dev_replace_commit(fs_info); 9918dabb742SStefan Behrens 99279154b1bSChris Mason return 0; 99379154b1bSChris Mason } 99479154b1bSChris Mason 995d352ac68SChris Mason /* 996d352ac68SChris Mason * dead roots are old snapshots that need to be deleted. This allocates 997d352ac68SChris Mason * a dirty root struct and adds it into the list of dead roots that need to 998d352ac68SChris Mason * be deleted 999d352ac68SChris Mason */ 1000cfad392bSJosef Bacik void btrfs_add_dead_root(struct btrfs_root *root) 10015eda7b5eSChris Mason { 1002a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 1003cfad392bSJosef Bacik if (list_empty(&root->root_list)) 10049d1a2a3aSDavid Sterba list_add_tail(&root->root_list, &root->fs_info->dead_roots); 1005a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 10065eda7b5eSChris Mason } 10075eda7b5eSChris Mason 1008d352ac68SChris Mason /* 10095d4f98a2SYan Zheng * update all the cowonly tree roots on disk 1010d352ac68SChris Mason */ 10115d4f98a2SYan Zheng static noinline int commit_fs_roots(struct btrfs_trans_handle *trans, 10125d4f98a2SYan Zheng struct btrfs_root *root) 10130f7d52f4SChris Mason { 10140f7d52f4SChris Mason struct btrfs_root *gang[8]; 10155d4f98a2SYan Zheng struct btrfs_fs_info *fs_info = root->fs_info; 10160f7d52f4SChris Mason int i; 10170f7d52f4SChris Mason int ret; 101854aa1f4dSChris Mason int err = 0; 101954aa1f4dSChris Mason 1020a4abeea4SJosef Bacik spin_lock(&fs_info->fs_roots_radix_lock); 10210f7d52f4SChris Mason while (1) { 10225d4f98a2SYan Zheng ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix, 10235d4f98a2SYan Zheng (void **)gang, 0, 10240f7d52f4SChris Mason ARRAY_SIZE(gang), 10250f7d52f4SChris Mason BTRFS_ROOT_TRANS_TAG); 10260f7d52f4SChris Mason if (ret == 0) 10270f7d52f4SChris Mason break; 10280f7d52f4SChris Mason for (i = 0; i < ret; i++) { 10290f7d52f4SChris Mason root = gang[i]; 10305d4f98a2SYan Zheng radix_tree_tag_clear(&fs_info->fs_roots_radix, 10312619ba1fSChris Mason (unsigned long)root->root_key.objectid, 10320f7d52f4SChris Mason BTRFS_ROOT_TRANS_TAG); 1033a4abeea4SJosef Bacik spin_unlock(&fs_info->fs_roots_radix_lock); 103431153d81SYan Zheng 1035e02119d5SChris Mason btrfs_free_log(trans, root); 10365d4f98a2SYan Zheng btrfs_update_reloc_root(trans, root); 1037d68fc57bSYan, Zheng btrfs_orphan_commit_root(trans, root); 1038e02119d5SChris Mason 103982d5902dSLi Zefan btrfs_save_ino_cache(root, trans); 104082d5902dSLi Zefan 1041f1ebcc74SLiu Bo /* see comments in should_cow_block() */ 1042f1ebcc74SLiu Bo root->force_cow = 0; 1043f1ebcc74SLiu Bo smp_wmb(); 1044f1ebcc74SLiu Bo 1045978d910dSYan Zheng if (root->commit_root != root->node) { 1046581bb050SLi Zefan mutex_lock(&root->fs_commit_mutex); 1047817d52f8SJosef Bacik switch_commit_root(root); 1048581bb050SLi Zefan btrfs_unpin_free_ino(root); 1049581bb050SLi Zefan mutex_unlock(&root->fs_commit_mutex); 1050581bb050SLi Zefan 1051978d910dSYan Zheng btrfs_set_root_node(&root->root_item, 1052978d910dSYan Zheng root->node); 1053978d910dSYan Zheng } 105431153d81SYan Zheng 10555d4f98a2SYan Zheng err = btrfs_update_root(trans, fs_info->tree_root, 10560f7d52f4SChris Mason &root->root_key, 10570f7d52f4SChris Mason &root->root_item); 1058a4abeea4SJosef Bacik spin_lock(&fs_info->fs_roots_radix_lock); 105954aa1f4dSChris Mason if (err) 106054aa1f4dSChris Mason break; 10610f7d52f4SChris Mason } 10629f3a7427SChris Mason } 1063a4abeea4SJosef Bacik spin_unlock(&fs_info->fs_roots_radix_lock); 106454aa1f4dSChris Mason return err; 10650f7d52f4SChris Mason } 10660f7d52f4SChris Mason 1067d352ac68SChris Mason /* 1068de78b51aSEric Sandeen * defrag a given btree. 1069de78b51aSEric Sandeen * Every leaf in the btree is read and defragged. 1070d352ac68SChris Mason */ 1071de78b51aSEric Sandeen int btrfs_defrag_root(struct btrfs_root *root) 1072e9d0b13bSChris Mason { 1073e9d0b13bSChris Mason struct btrfs_fs_info *info = root->fs_info; 1074e9d0b13bSChris Mason struct btrfs_trans_handle *trans; 10758929ecfaSYan, Zheng int ret; 1076e9d0b13bSChris Mason 10778929ecfaSYan, Zheng if (xchg(&root->defrag_running, 1)) 1078e9d0b13bSChris Mason return 0; 10798929ecfaSYan, Zheng 10806b80053dSChris Mason while (1) { 10818929ecfaSYan, Zheng trans = btrfs_start_transaction(root, 0); 10828929ecfaSYan, Zheng if (IS_ERR(trans)) 10838929ecfaSYan, Zheng return PTR_ERR(trans); 10848929ecfaSYan, Zheng 1085de78b51aSEric Sandeen ret = btrfs_defrag_leaves(trans, root); 10868929ecfaSYan, Zheng 1087e9d0b13bSChris Mason btrfs_end_transaction(trans, root); 1088b53d3f5dSLiu Bo btrfs_btree_balance_dirty(info->tree_root); 1089e9d0b13bSChris Mason cond_resched(); 1090e9d0b13bSChris Mason 10917841cb28SDavid Sterba if (btrfs_fs_closing(root->fs_info) || ret != -EAGAIN) 1092e9d0b13bSChris Mason break; 1093210549ebSDavid Sterba 1094210549ebSDavid Sterba if (btrfs_defrag_cancelled(root->fs_info)) { 1095efe120a0SFrank Holton pr_debug("BTRFS: defrag_root cancelled\n"); 1096210549ebSDavid Sterba ret = -EAGAIN; 1097210549ebSDavid Sterba break; 1098210549ebSDavid Sterba } 1099e9d0b13bSChris Mason } 1100e9d0b13bSChris Mason root->defrag_running = 0; 11018929ecfaSYan, Zheng return ret; 1102e9d0b13bSChris Mason } 1103e9d0b13bSChris Mason 1104d352ac68SChris Mason /* 1105d352ac68SChris Mason * new snapshots need to be created at a very specific time in the 1106aec8030aSMiao Xie * transaction commit. This does the actual creation. 1107aec8030aSMiao Xie * 1108aec8030aSMiao Xie * Note: 1109aec8030aSMiao Xie * If the error which may affect the commitment of the current transaction 1110aec8030aSMiao Xie * happens, we should return the error number. If the error which just affect 1111aec8030aSMiao Xie * the creation of the pending snapshots, just return 0. 1112d352ac68SChris Mason */ 111380b6794dSChris Mason static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans, 11143063d29fSChris Mason struct btrfs_fs_info *fs_info, 11153063d29fSChris Mason struct btrfs_pending_snapshot *pending) 11163063d29fSChris Mason { 11173063d29fSChris Mason struct btrfs_key key; 111880b6794dSChris Mason struct btrfs_root_item *new_root_item; 11193063d29fSChris Mason struct btrfs_root *tree_root = fs_info->tree_root; 11203063d29fSChris Mason struct btrfs_root *root = pending->root; 11216bdb72deSSage Weil struct btrfs_root *parent_root; 112298c9942aSLiu Bo struct btrfs_block_rsv *rsv; 11236bdb72deSSage Weil struct inode *parent_inode; 112442874b3dSMiao Xie struct btrfs_path *path; 112542874b3dSMiao Xie struct btrfs_dir_item *dir_item; 1126a22285a6SYan, Zheng struct dentry *dentry; 11273063d29fSChris Mason struct extent_buffer *tmp; 1128925baeddSChris Mason struct extent_buffer *old; 11298ea05e3aSAlexander Block struct timespec cur_time = CURRENT_TIME; 1130aec8030aSMiao Xie int ret = 0; 1131d68fc57bSYan, Zheng u64 to_reserve = 0; 11326bdb72deSSage Weil u64 index = 0; 1133a22285a6SYan, Zheng u64 objectid; 1134b83cc969SLi Zefan u64 root_flags; 11358ea05e3aSAlexander Block uuid_le new_uuid; 11363063d29fSChris Mason 113742874b3dSMiao Xie path = btrfs_alloc_path(); 113842874b3dSMiao Xie if (!path) { 1139aec8030aSMiao Xie pending->error = -ENOMEM; 1140aec8030aSMiao Xie return 0; 114142874b3dSMiao Xie } 114242874b3dSMiao Xie 114380b6794dSChris Mason new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS); 114480b6794dSChris Mason if (!new_root_item) { 1145aec8030aSMiao Xie pending->error = -ENOMEM; 11466fa9700eSMiao Xie goto root_item_alloc_fail; 114780b6794dSChris Mason } 1148a22285a6SYan, Zheng 1149aec8030aSMiao Xie pending->error = btrfs_find_free_objectid(tree_root, &objectid); 1150aec8030aSMiao Xie if (pending->error) 11516fa9700eSMiao Xie goto no_free_objectid; 11523063d29fSChris Mason 11533fd0a558SYan, Zheng btrfs_reloc_pre_snapshot(trans, pending, &to_reserve); 1154d68fc57bSYan, Zheng 1155d68fc57bSYan, Zheng if (to_reserve > 0) { 1156aec8030aSMiao Xie pending->error = btrfs_block_rsv_add(root, 1157aec8030aSMiao Xie &pending->block_rsv, 115808e007d2SMiao Xie to_reserve, 115908e007d2SMiao Xie BTRFS_RESERVE_NO_FLUSH); 1160aec8030aSMiao Xie if (pending->error) 11616fa9700eSMiao Xie goto no_free_objectid; 1162d68fc57bSYan, Zheng } 1163d68fc57bSYan, Zheng 1164aec8030aSMiao Xie pending->error = btrfs_qgroup_inherit(trans, fs_info, 1165aec8030aSMiao Xie root->root_key.objectid, 11666f72c7e2SArne Jansen objectid, pending->inherit); 1167aec8030aSMiao Xie if (pending->error) 11686fa9700eSMiao Xie goto no_free_objectid; 11696f72c7e2SArne Jansen 11703063d29fSChris Mason key.objectid = objectid; 1171a22285a6SYan, Zheng key.offset = (u64)-1; 1172a22285a6SYan, Zheng key.type = BTRFS_ROOT_ITEM_KEY; 11733063d29fSChris Mason 11746fa9700eSMiao Xie rsv = trans->block_rsv; 1175a22285a6SYan, Zheng trans->block_rsv = &pending->block_rsv; 11762382c5ccSLiu Bo trans->bytes_reserved = trans->block_rsv->reserved; 11776bdb72deSSage Weil 1178a22285a6SYan, Zheng dentry = pending->dentry; 1179e9662f70SMiao Xie parent_inode = pending->dir; 1180a22285a6SYan, Zheng parent_root = BTRFS_I(parent_inode)->root; 11817585717fSChris Mason record_root_in_trans(trans, parent_root); 1182a22285a6SYan, Zheng 11836bdb72deSSage Weil /* 11846bdb72deSSage Weil * insert the directory item 11856bdb72deSSage Weil */ 11866bdb72deSSage Weil ret = btrfs_set_inode_index(parent_inode, &index); 118749b25e05SJeff Mahoney BUG_ON(ret); /* -ENOMEM */ 118842874b3dSMiao Xie 118942874b3dSMiao Xie /* check if there is a file/dir which has the same name. */ 119042874b3dSMiao Xie dir_item = btrfs_lookup_dir_item(NULL, parent_root, path, 119142874b3dSMiao Xie btrfs_ino(parent_inode), 119242874b3dSMiao Xie dentry->d_name.name, 119342874b3dSMiao Xie dentry->d_name.len, 0); 119442874b3dSMiao Xie if (dir_item != NULL && !IS_ERR(dir_item)) { 1195fe66a05aSChris Mason pending->error = -EEXIST; 1196aec8030aSMiao Xie goto dir_item_existed; 119742874b3dSMiao Xie } else if (IS_ERR(dir_item)) { 119842874b3dSMiao Xie ret = PTR_ERR(dir_item); 11998732d44fSMiao Xie btrfs_abort_transaction(trans, root, ret); 12008732d44fSMiao Xie goto fail; 120179787eaaSJeff Mahoney } 120242874b3dSMiao Xie btrfs_release_path(path); 12036bdb72deSSage Weil 1204e999376fSChris Mason /* 1205e999376fSChris Mason * pull in the delayed directory update 1206e999376fSChris Mason * and the delayed inode item 1207e999376fSChris Mason * otherwise we corrupt the FS during 1208e999376fSChris Mason * snapshot 1209e999376fSChris Mason */ 1210e999376fSChris Mason ret = btrfs_run_delayed_items(trans, root); 12118732d44fSMiao Xie if (ret) { /* Transaction aborted */ 12128732d44fSMiao Xie btrfs_abort_transaction(trans, root, ret); 12138732d44fSMiao Xie goto fail; 12148732d44fSMiao Xie } 1215e999376fSChris Mason 12167585717fSChris Mason record_root_in_trans(trans, root); 12176bdb72deSSage Weil btrfs_set_root_last_snapshot(&root->root_item, trans->transid); 12186bdb72deSSage Weil memcpy(new_root_item, &root->root_item, sizeof(*new_root_item)); 121908fe4db1SLi Zefan btrfs_check_and_init_root_item(new_root_item); 12206bdb72deSSage Weil 1221b83cc969SLi Zefan root_flags = btrfs_root_flags(new_root_item); 1222b83cc969SLi Zefan if (pending->readonly) 1223b83cc969SLi Zefan root_flags |= BTRFS_ROOT_SUBVOL_RDONLY; 1224b83cc969SLi Zefan else 1225b83cc969SLi Zefan root_flags &= ~BTRFS_ROOT_SUBVOL_RDONLY; 1226b83cc969SLi Zefan btrfs_set_root_flags(new_root_item, root_flags); 1227b83cc969SLi Zefan 12288ea05e3aSAlexander Block btrfs_set_root_generation_v2(new_root_item, 12298ea05e3aSAlexander Block trans->transid); 12308ea05e3aSAlexander Block uuid_le_gen(&new_uuid); 12318ea05e3aSAlexander Block memcpy(new_root_item->uuid, new_uuid.b, BTRFS_UUID_SIZE); 12328ea05e3aSAlexander Block memcpy(new_root_item->parent_uuid, root->root_item.uuid, 12338ea05e3aSAlexander Block BTRFS_UUID_SIZE); 123470023da2SStefan Behrens if (!(root_flags & BTRFS_ROOT_SUBVOL_RDONLY)) { 123570023da2SStefan Behrens memset(new_root_item->received_uuid, 0, 123670023da2SStefan Behrens sizeof(new_root_item->received_uuid)); 12378ea05e3aSAlexander Block memset(&new_root_item->stime, 0, sizeof(new_root_item->stime)); 12388ea05e3aSAlexander Block memset(&new_root_item->rtime, 0, sizeof(new_root_item->rtime)); 12398ea05e3aSAlexander Block btrfs_set_root_stransid(new_root_item, 0); 12408ea05e3aSAlexander Block btrfs_set_root_rtransid(new_root_item, 0); 124170023da2SStefan Behrens } 12423cae210fSQu Wenruo btrfs_set_stack_timespec_sec(&new_root_item->otime, cur_time.tv_sec); 12433cae210fSQu Wenruo btrfs_set_stack_timespec_nsec(&new_root_item->otime, cur_time.tv_nsec); 124470023da2SStefan Behrens btrfs_set_root_otransid(new_root_item, trans->transid); 12458ea05e3aSAlexander Block 1246925baeddSChris Mason old = btrfs_lock_root_node(root); 124749b25e05SJeff Mahoney ret = btrfs_cow_block(trans, root, old, NULL, 0, &old); 124879787eaaSJeff Mahoney if (ret) { 124979787eaaSJeff Mahoney btrfs_tree_unlock(old); 125079787eaaSJeff Mahoney free_extent_buffer(old); 12518732d44fSMiao Xie btrfs_abort_transaction(trans, root, ret); 12528732d44fSMiao Xie goto fail; 125379787eaaSJeff Mahoney } 125449b25e05SJeff Mahoney 12555d4f98a2SYan Zheng btrfs_set_lock_blocking(old); 12563063d29fSChris Mason 125749b25e05SJeff Mahoney ret = btrfs_copy_root(trans, root, old, &tmp, objectid); 125879787eaaSJeff Mahoney /* clean up in any case */ 1259925baeddSChris Mason btrfs_tree_unlock(old); 1260925baeddSChris Mason free_extent_buffer(old); 12618732d44fSMiao Xie if (ret) { 12628732d44fSMiao Xie btrfs_abort_transaction(trans, root, ret); 12638732d44fSMiao Xie goto fail; 12648732d44fSMiao Xie } 12653063d29fSChris Mason 1266f1ebcc74SLiu Bo /* see comments in should_cow_block() */ 1267f1ebcc74SLiu Bo root->force_cow = 1; 1268f1ebcc74SLiu Bo smp_wmb(); 1269f1ebcc74SLiu Bo 12705d4f98a2SYan Zheng btrfs_set_root_node(new_root_item, tmp); 1271a22285a6SYan, Zheng /* record when the snapshot was created in key.offset */ 1272a22285a6SYan, Zheng key.offset = trans->transid; 1273a22285a6SYan, Zheng ret = btrfs_insert_root(trans, tree_root, &key, new_root_item); 1274925baeddSChris Mason btrfs_tree_unlock(tmp); 12753063d29fSChris Mason free_extent_buffer(tmp); 12768732d44fSMiao Xie if (ret) { 12778732d44fSMiao Xie btrfs_abort_transaction(trans, root, ret); 12788732d44fSMiao Xie goto fail; 12798732d44fSMiao Xie } 12800660b5afSChris Mason 1281a22285a6SYan, Zheng /* 1282a22285a6SYan, Zheng * insert root back/forward references 1283a22285a6SYan, Zheng */ 1284a22285a6SYan, Zheng ret = btrfs_add_root_ref(trans, tree_root, objectid, 1285a22285a6SYan, Zheng parent_root->root_key.objectid, 128633345d01SLi Zefan btrfs_ino(parent_inode), index, 1287a22285a6SYan, Zheng dentry->d_name.name, dentry->d_name.len); 12888732d44fSMiao Xie if (ret) { 12898732d44fSMiao Xie btrfs_abort_transaction(trans, root, ret); 12908732d44fSMiao Xie goto fail; 12918732d44fSMiao Xie } 1292a22285a6SYan, Zheng 1293a22285a6SYan, Zheng key.offset = (u64)-1; 1294a22285a6SYan, Zheng pending->snap = btrfs_read_fs_root_no_name(root->fs_info, &key); 129579787eaaSJeff Mahoney if (IS_ERR(pending->snap)) { 129679787eaaSJeff Mahoney ret = PTR_ERR(pending->snap); 12978732d44fSMiao Xie btrfs_abort_transaction(trans, root, ret); 12988732d44fSMiao Xie goto fail; 129979787eaaSJeff Mahoney } 1300d68fc57bSYan, Zheng 130149b25e05SJeff Mahoney ret = btrfs_reloc_post_snapshot(trans, pending); 13028732d44fSMiao Xie if (ret) { 13038732d44fSMiao Xie btrfs_abort_transaction(trans, root, ret); 13048732d44fSMiao Xie goto fail; 13058732d44fSMiao Xie } 1306361048f5SMiao Xie 1307361048f5SMiao Xie ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); 13088732d44fSMiao Xie if (ret) { 13098732d44fSMiao Xie btrfs_abort_transaction(trans, root, ret); 13108732d44fSMiao Xie goto fail; 13118732d44fSMiao Xie } 131242874b3dSMiao Xie 131342874b3dSMiao Xie ret = btrfs_insert_dir_item(trans, parent_root, 131442874b3dSMiao Xie dentry->d_name.name, dentry->d_name.len, 131542874b3dSMiao Xie parent_inode, &key, 131642874b3dSMiao Xie BTRFS_FT_DIR, index); 131742874b3dSMiao Xie /* We have check then name at the beginning, so it is impossible. */ 13189c52057cSChris Mason BUG_ON(ret == -EEXIST || ret == -EOVERFLOW); 13198732d44fSMiao Xie if (ret) { 13208732d44fSMiao Xie btrfs_abort_transaction(trans, root, ret); 13218732d44fSMiao Xie goto fail; 13228732d44fSMiao Xie } 132342874b3dSMiao Xie 132442874b3dSMiao Xie btrfs_i_size_write(parent_inode, parent_inode->i_size + 132542874b3dSMiao Xie dentry->d_name.len * 2); 132642874b3dSMiao Xie parent_inode->i_mtime = parent_inode->i_ctime = CURRENT_TIME; 1327be6aef60SJosef Bacik ret = btrfs_update_inode_fallback(trans, parent_root, parent_inode); 1328dd5f9615SStefan Behrens if (ret) { 13298732d44fSMiao Xie btrfs_abort_transaction(trans, root, ret); 1330dd5f9615SStefan Behrens goto fail; 1331dd5f9615SStefan Behrens } 1332dd5f9615SStefan Behrens ret = btrfs_uuid_tree_add(trans, fs_info->uuid_root, new_uuid.b, 1333dd5f9615SStefan Behrens BTRFS_UUID_KEY_SUBVOL, objectid); 1334dd5f9615SStefan Behrens if (ret) { 1335dd5f9615SStefan Behrens btrfs_abort_transaction(trans, root, ret); 1336dd5f9615SStefan Behrens goto fail; 1337dd5f9615SStefan Behrens } 1338dd5f9615SStefan Behrens if (!btrfs_is_empty_uuid(new_root_item->received_uuid)) { 1339dd5f9615SStefan Behrens ret = btrfs_uuid_tree_add(trans, fs_info->uuid_root, 1340dd5f9615SStefan Behrens new_root_item->received_uuid, 1341dd5f9615SStefan Behrens BTRFS_UUID_KEY_RECEIVED_SUBVOL, 1342dd5f9615SStefan Behrens objectid); 1343dd5f9615SStefan Behrens if (ret && ret != -EEXIST) { 1344dd5f9615SStefan Behrens btrfs_abort_transaction(trans, root, ret); 1345dd5f9615SStefan Behrens goto fail; 1346dd5f9615SStefan Behrens } 1347dd5f9615SStefan Behrens } 13483063d29fSChris Mason fail: 1349aec8030aSMiao Xie pending->error = ret; 1350aec8030aSMiao Xie dir_item_existed: 135198c9942aSLiu Bo trans->block_rsv = rsv; 13522382c5ccSLiu Bo trans->bytes_reserved = 0; 13536fa9700eSMiao Xie no_free_objectid: 13546fa9700eSMiao Xie kfree(new_root_item); 13556fa9700eSMiao Xie root_item_alloc_fail: 135642874b3dSMiao Xie btrfs_free_path(path); 135749b25e05SJeff Mahoney return ret; 13583063d29fSChris Mason } 13593063d29fSChris Mason 1360d352ac68SChris Mason /* 1361d352ac68SChris Mason * create all the snapshots we've scheduled for creation 1362d352ac68SChris Mason */ 136380b6794dSChris Mason static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans, 13643063d29fSChris Mason struct btrfs_fs_info *fs_info) 13653063d29fSChris Mason { 1366aec8030aSMiao Xie struct btrfs_pending_snapshot *pending, *next; 13673063d29fSChris Mason struct list_head *head = &trans->transaction->pending_snapshots; 1368aec8030aSMiao Xie int ret = 0; 13693de4586cSChris Mason 1370aec8030aSMiao Xie list_for_each_entry_safe(pending, next, head, list) { 1371aec8030aSMiao Xie list_del(&pending->list); 1372aec8030aSMiao Xie ret = create_pending_snapshot(trans, fs_info, pending); 1373aec8030aSMiao Xie if (ret) 1374aec8030aSMiao Xie break; 1375aec8030aSMiao Xie } 1376aec8030aSMiao Xie return ret; 13773de4586cSChris Mason } 13783de4586cSChris Mason 13795d4f98a2SYan Zheng static void update_super_roots(struct btrfs_root *root) 13805d4f98a2SYan Zheng { 13815d4f98a2SYan Zheng struct btrfs_root_item *root_item; 13825d4f98a2SYan Zheng struct btrfs_super_block *super; 13835d4f98a2SYan Zheng 13846c41761fSDavid Sterba super = root->fs_info->super_copy; 13855d4f98a2SYan Zheng 13865d4f98a2SYan Zheng root_item = &root->fs_info->chunk_root->root_item; 13875d4f98a2SYan Zheng super->chunk_root = root_item->bytenr; 13885d4f98a2SYan Zheng super->chunk_root_generation = root_item->generation; 13895d4f98a2SYan Zheng super->chunk_root_level = root_item->level; 13905d4f98a2SYan Zheng 13915d4f98a2SYan Zheng root_item = &root->fs_info->tree_root->root_item; 13925d4f98a2SYan Zheng super->root = root_item->bytenr; 13935d4f98a2SYan Zheng super->generation = root_item->generation; 13945d4f98a2SYan Zheng super->root_level = root_item->level; 139573bc1876SJosef Bacik if (btrfs_test_opt(root, SPACE_CACHE)) 13960af3d00bSJosef Bacik super->cache_generation = root_item->generation; 139770f80175SStefan Behrens if (root->fs_info->update_uuid_tree_gen) 139826432799SStefan Behrens super->uuid_tree_generation = root_item->generation; 13995d4f98a2SYan Zheng } 14005d4f98a2SYan Zheng 1401f36f3042SChris Mason int btrfs_transaction_in_commit(struct btrfs_fs_info *info) 1402f36f3042SChris Mason { 14034a9d8bdeSMiao Xie struct btrfs_transaction *trans; 1404f36f3042SChris Mason int ret = 0; 14054a9d8bdeSMiao Xie 1406a4abeea4SJosef Bacik spin_lock(&info->trans_lock); 14074a9d8bdeSMiao Xie trans = info->running_transaction; 14084a9d8bdeSMiao Xie if (trans) 14094a9d8bdeSMiao Xie ret = (trans->state >= TRANS_STATE_COMMIT_START); 1410a4abeea4SJosef Bacik spin_unlock(&info->trans_lock); 1411f36f3042SChris Mason return ret; 1412f36f3042SChris Mason } 1413f36f3042SChris Mason 14148929ecfaSYan, Zheng int btrfs_transaction_blocked(struct btrfs_fs_info *info) 14158929ecfaSYan, Zheng { 14164a9d8bdeSMiao Xie struct btrfs_transaction *trans; 14178929ecfaSYan, Zheng int ret = 0; 14184a9d8bdeSMiao Xie 1419a4abeea4SJosef Bacik spin_lock(&info->trans_lock); 14204a9d8bdeSMiao Xie trans = info->running_transaction; 14214a9d8bdeSMiao Xie if (trans) 14224a9d8bdeSMiao Xie ret = is_transaction_blocked(trans); 1423a4abeea4SJosef Bacik spin_unlock(&info->trans_lock); 14248929ecfaSYan, Zheng return ret; 14258929ecfaSYan, Zheng } 14268929ecfaSYan, Zheng 1427bb9c12c9SSage Weil /* 1428bb9c12c9SSage Weil * wait for the current transaction commit to start and block subsequent 1429bb9c12c9SSage Weil * transaction joins 1430bb9c12c9SSage Weil */ 1431bb9c12c9SSage Weil static void wait_current_trans_commit_start(struct btrfs_root *root, 1432bb9c12c9SSage Weil struct btrfs_transaction *trans) 1433bb9c12c9SSage Weil { 14344a9d8bdeSMiao Xie wait_event(root->fs_info->transaction_blocked_wait, 1435501407aaSJosef Bacik trans->state >= TRANS_STATE_COMMIT_START || 1436501407aaSJosef Bacik trans->aborted); 1437bb9c12c9SSage Weil } 1438bb9c12c9SSage Weil 1439bb9c12c9SSage Weil /* 1440bb9c12c9SSage Weil * wait for the current transaction to start and then become unblocked. 1441bb9c12c9SSage Weil * caller holds ref. 1442bb9c12c9SSage Weil */ 1443bb9c12c9SSage Weil static void wait_current_trans_commit_start_and_unblock(struct btrfs_root *root, 1444bb9c12c9SSage Weil struct btrfs_transaction *trans) 1445bb9c12c9SSage Weil { 144672d63ed6SLi Zefan wait_event(root->fs_info->transaction_wait, 1447501407aaSJosef Bacik trans->state >= TRANS_STATE_UNBLOCKED || 1448501407aaSJosef Bacik trans->aborted); 1449bb9c12c9SSage Weil } 1450bb9c12c9SSage Weil 1451bb9c12c9SSage Weil /* 1452bb9c12c9SSage Weil * commit transactions asynchronously. once btrfs_commit_transaction_async 1453bb9c12c9SSage Weil * returns, any subsequent transaction will not be allowed to join. 1454bb9c12c9SSage Weil */ 1455bb9c12c9SSage Weil struct btrfs_async_commit { 1456bb9c12c9SSage Weil struct btrfs_trans_handle *newtrans; 1457bb9c12c9SSage Weil struct btrfs_root *root; 14587892b5afSMiao Xie struct work_struct work; 1459bb9c12c9SSage Weil }; 1460bb9c12c9SSage Weil 1461bb9c12c9SSage Weil static void do_async_commit(struct work_struct *work) 1462bb9c12c9SSage Weil { 1463bb9c12c9SSage Weil struct btrfs_async_commit *ac = 14647892b5afSMiao Xie container_of(work, struct btrfs_async_commit, work); 1465bb9c12c9SSage Weil 14666fc4e354SSage Weil /* 14676fc4e354SSage Weil * We've got freeze protection passed with the transaction. 14686fc4e354SSage Weil * Tell lockdep about it. 14696fc4e354SSage Weil */ 1470b1a06a4bSLiu Bo if (ac->newtrans->type & __TRANS_FREEZABLE) 14716fc4e354SSage Weil rwsem_acquire_read( 14726fc4e354SSage Weil &ac->root->fs_info->sb->s_writers.lock_map[SB_FREEZE_FS-1], 14736fc4e354SSage Weil 0, 1, _THIS_IP_); 14746fc4e354SSage Weil 1475e209db7aSSage Weil current->journal_info = ac->newtrans; 1476e209db7aSSage Weil 1477bb9c12c9SSage Weil btrfs_commit_transaction(ac->newtrans, ac->root); 1478bb9c12c9SSage Weil kfree(ac); 1479bb9c12c9SSage Weil } 1480bb9c12c9SSage Weil 1481bb9c12c9SSage Weil int btrfs_commit_transaction_async(struct btrfs_trans_handle *trans, 1482bb9c12c9SSage Weil struct btrfs_root *root, 1483bb9c12c9SSage Weil int wait_for_unblock) 1484bb9c12c9SSage Weil { 1485bb9c12c9SSage Weil struct btrfs_async_commit *ac; 1486bb9c12c9SSage Weil struct btrfs_transaction *cur_trans; 1487bb9c12c9SSage Weil 1488bb9c12c9SSage Weil ac = kmalloc(sizeof(*ac), GFP_NOFS); 1489db5b493aSTsutomu Itoh if (!ac) 1490db5b493aSTsutomu Itoh return -ENOMEM; 1491bb9c12c9SSage Weil 14927892b5afSMiao Xie INIT_WORK(&ac->work, do_async_commit); 1493bb9c12c9SSage Weil ac->root = root; 14947a7eaa40SJosef Bacik ac->newtrans = btrfs_join_transaction(root); 14953612b495STsutomu Itoh if (IS_ERR(ac->newtrans)) { 14963612b495STsutomu Itoh int err = PTR_ERR(ac->newtrans); 14973612b495STsutomu Itoh kfree(ac); 14983612b495STsutomu Itoh return err; 14993612b495STsutomu Itoh } 1500bb9c12c9SSage Weil 1501bb9c12c9SSage Weil /* take transaction reference */ 1502bb9c12c9SSage Weil cur_trans = trans->transaction; 150313c5a93eSJosef Bacik atomic_inc(&cur_trans->use_count); 1504bb9c12c9SSage Weil 1505bb9c12c9SSage Weil btrfs_end_transaction(trans, root); 15066fc4e354SSage Weil 15076fc4e354SSage Weil /* 15086fc4e354SSage Weil * Tell lockdep we've released the freeze rwsem, since the 15096fc4e354SSage Weil * async commit thread will be the one to unlock it. 15106fc4e354SSage Weil */ 1511b1a06a4bSLiu Bo if (ac->newtrans->type & __TRANS_FREEZABLE) 1512ff7c1d33SMiao Xie rwsem_release( 1513ff7c1d33SMiao Xie &root->fs_info->sb->s_writers.lock_map[SB_FREEZE_FS-1], 15146fc4e354SSage Weil 1, _THIS_IP_); 15156fc4e354SSage Weil 15167892b5afSMiao Xie schedule_work(&ac->work); 1517bb9c12c9SSage Weil 1518bb9c12c9SSage Weil /* wait for transaction to start and unblock */ 1519bb9c12c9SSage Weil if (wait_for_unblock) 1520bb9c12c9SSage Weil wait_current_trans_commit_start_and_unblock(root, cur_trans); 1521bb9c12c9SSage Weil else 1522bb9c12c9SSage Weil wait_current_trans_commit_start(root, cur_trans); 1523bb9c12c9SSage Weil 152438e88054SSage Weil if (current->journal_info == trans) 152538e88054SSage Weil current->journal_info = NULL; 152638e88054SSage Weil 1527724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 1528bb9c12c9SSage Weil return 0; 1529bb9c12c9SSage Weil } 1530bb9c12c9SSage Weil 153149b25e05SJeff Mahoney 153249b25e05SJeff Mahoney static void cleanup_transaction(struct btrfs_trans_handle *trans, 15337b8b92afSJosef Bacik struct btrfs_root *root, int err) 153449b25e05SJeff Mahoney { 153549b25e05SJeff Mahoney struct btrfs_transaction *cur_trans = trans->transaction; 1536f094ac32SLiu Bo DEFINE_WAIT(wait); 153749b25e05SJeff Mahoney 153849b25e05SJeff Mahoney WARN_ON(trans->use_count > 1); 153949b25e05SJeff Mahoney 15407b8b92afSJosef Bacik btrfs_abort_transaction(trans, root, err); 15417b8b92afSJosef Bacik 154249b25e05SJeff Mahoney spin_lock(&root->fs_info->trans_lock); 154366b6135bSLiu Bo 154425d8c284SMiao Xie /* 154525d8c284SMiao Xie * If the transaction is removed from the list, it means this 154625d8c284SMiao Xie * transaction has been committed successfully, so it is impossible 154725d8c284SMiao Xie * to call the cleanup function. 154825d8c284SMiao Xie */ 154925d8c284SMiao Xie BUG_ON(list_empty(&cur_trans->list)); 155066b6135bSLiu Bo 155149b25e05SJeff Mahoney list_del_init(&cur_trans->list); 1552d7096fc3SJosef Bacik if (cur_trans == root->fs_info->running_transaction) { 15534a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_COMMIT_DOING; 1554f094ac32SLiu Bo spin_unlock(&root->fs_info->trans_lock); 1555f094ac32SLiu Bo wait_event(cur_trans->writer_wait, 1556f094ac32SLiu Bo atomic_read(&cur_trans->num_writers) == 1); 1557f094ac32SLiu Bo 1558f094ac32SLiu Bo spin_lock(&root->fs_info->trans_lock); 1559d7096fc3SJosef Bacik } 156049b25e05SJeff Mahoney spin_unlock(&root->fs_info->trans_lock); 156149b25e05SJeff Mahoney 156249b25e05SJeff Mahoney btrfs_cleanup_one_transaction(trans->transaction, root); 156349b25e05SJeff Mahoney 15644a9d8bdeSMiao Xie spin_lock(&root->fs_info->trans_lock); 15654a9d8bdeSMiao Xie if (cur_trans == root->fs_info->running_transaction) 15664a9d8bdeSMiao Xie root->fs_info->running_transaction = NULL; 15674a9d8bdeSMiao Xie spin_unlock(&root->fs_info->trans_lock); 15684a9d8bdeSMiao Xie 1569e0228285SJosef Bacik if (trans->type & __TRANS_FREEZABLE) 1570e0228285SJosef Bacik sb_end_intwrite(root->fs_info->sb); 1571724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 1572724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 157349b25e05SJeff Mahoney 157449b25e05SJeff Mahoney trace_btrfs_transaction_commit(root); 157549b25e05SJeff Mahoney 157649b25e05SJeff Mahoney if (current->journal_info == trans) 157749b25e05SJeff Mahoney current->journal_info = NULL; 1578c0af8f0bSWang Shilong btrfs_scrub_cancel(root->fs_info); 157949b25e05SJeff Mahoney 158049b25e05SJeff Mahoney kmem_cache_free(btrfs_trans_handle_cachep, trans); 158149b25e05SJeff Mahoney } 158249b25e05SJeff Mahoney 1583ca469637SMiao Xie static int btrfs_flush_all_pending_stuffs(struct btrfs_trans_handle *trans, 1584ca469637SMiao Xie struct btrfs_root *root) 1585ca469637SMiao Xie { 1586ca469637SMiao Xie int ret; 1587ca469637SMiao Xie 1588ca469637SMiao Xie ret = btrfs_run_delayed_items(trans, root); 1589ca469637SMiao Xie /* 1590ca469637SMiao Xie * running the delayed items may have added new refs. account 1591ca469637SMiao Xie * them now so that they hinder processing of more delayed refs 1592ca469637SMiao Xie * as little as possible. 1593ca469637SMiao Xie */ 159480d94fb3SFilipe David Borba Manana if (ret) { 1595ca469637SMiao Xie btrfs_delayed_refs_qgroup_accounting(trans, root->fs_info); 159680d94fb3SFilipe David Borba Manana return ret; 159780d94fb3SFilipe David Borba Manana } 159880d94fb3SFilipe David Borba Manana 159980d94fb3SFilipe David Borba Manana ret = btrfs_delayed_refs_qgroup_accounting(trans, root->fs_info); 160080d94fb3SFilipe David Borba Manana if (ret) 160180d94fb3SFilipe David Borba Manana return ret; 1602ca469637SMiao Xie 1603ca469637SMiao Xie /* 1604ca469637SMiao Xie * rename don't use btrfs_join_transaction, so, once we 1605ca469637SMiao Xie * set the transaction to blocked above, we aren't going 1606ca469637SMiao Xie * to get any new ordered operations. We can safely run 1607ca469637SMiao Xie * it here and no for sure that nothing new will be added 1608ca469637SMiao Xie * to the list 1609ca469637SMiao Xie */ 1610569e0f35SJosef Bacik ret = btrfs_run_ordered_operations(trans, root, 1); 1611ca469637SMiao Xie 1612eebc6084SMiao Xie return ret; 1613ca469637SMiao Xie } 1614ca469637SMiao Xie 161582436617SMiao Xie static inline int btrfs_start_delalloc_flush(struct btrfs_fs_info *fs_info) 161682436617SMiao Xie { 161782436617SMiao Xie if (btrfs_test_opt(fs_info->tree_root, FLUSHONCOMMIT)) 16186c255e67SMiao Xie return btrfs_start_delalloc_roots(fs_info, 1, -1); 161982436617SMiao Xie return 0; 162082436617SMiao Xie } 162182436617SMiao Xie 162282436617SMiao Xie static inline void btrfs_wait_delalloc_flush(struct btrfs_fs_info *fs_info) 162382436617SMiao Xie { 162482436617SMiao Xie if (btrfs_test_opt(fs_info->tree_root, FLUSHONCOMMIT)) 1625b0244199SMiao Xie btrfs_wait_ordered_roots(fs_info, -1); 162682436617SMiao Xie } 162782436617SMiao Xie 162879154b1bSChris Mason int btrfs_commit_transaction(struct btrfs_trans_handle *trans, 162979154b1bSChris Mason struct btrfs_root *root) 163079154b1bSChris Mason { 163149b25e05SJeff Mahoney struct btrfs_transaction *cur_trans = trans->transaction; 16328fd17795SChris Mason struct btrfs_transaction *prev_trans = NULL; 163325287e0aSMiao Xie int ret; 163479154b1bSChris Mason 1635569e0f35SJosef Bacik ret = btrfs_run_ordered_operations(trans, root, 0); 163625287e0aSMiao Xie if (ret) { 163725287e0aSMiao Xie btrfs_abort_transaction(trans, root, ret); 1638e4a2bcacSJosef Bacik btrfs_end_transaction(trans, root); 1639e4a2bcacSJosef Bacik return ret; 164025287e0aSMiao Xie } 164125287e0aSMiao Xie 16428d25a086SMiao Xie /* Stop the commit early if ->aborted is set */ 16438d25a086SMiao Xie if (unlikely(ACCESS_ONCE(cur_trans->aborted))) { 164425287e0aSMiao Xie ret = cur_trans->aborted; 1645e4a2bcacSJosef Bacik btrfs_end_transaction(trans, root); 1646e4a2bcacSJosef Bacik return ret; 164725287e0aSMiao Xie } 164849b25e05SJeff Mahoney 164956bec294SChris Mason /* make a pass through all the delayed refs we have so far 165056bec294SChris Mason * any runnings procs may add more while we are here 165156bec294SChris Mason */ 165256bec294SChris Mason ret = btrfs_run_delayed_refs(trans, root, 0); 1653e4a2bcacSJosef Bacik if (ret) { 1654e4a2bcacSJosef Bacik btrfs_end_transaction(trans, root); 1655e4a2bcacSJosef Bacik return ret; 1656e4a2bcacSJosef Bacik } 165756bec294SChris Mason 16580e721106SJosef Bacik btrfs_trans_release_metadata(trans, root); 16590e721106SJosef Bacik trans->block_rsv = NULL; 1660272d26d0SMiao Xie if (trans->qgroup_reserved) { 1661272d26d0SMiao Xie btrfs_qgroup_free(root, trans->qgroup_reserved); 1662272d26d0SMiao Xie trans->qgroup_reserved = 0; 1663272d26d0SMiao Xie } 16640e721106SJosef Bacik 1665b7ec40d7SChris Mason cur_trans = trans->transaction; 166649b25e05SJeff Mahoney 166756bec294SChris Mason /* 166856bec294SChris Mason * set the flushing flag so procs in this transaction have to 166956bec294SChris Mason * start sending their work down. 167056bec294SChris Mason */ 1671b7ec40d7SChris Mason cur_trans->delayed_refs.flushing = 1; 16721be41b78SJosef Bacik smp_wmb(); 167356bec294SChris Mason 1674ea658badSJosef Bacik if (!list_empty(&trans->new_bgs)) 1675ea658badSJosef Bacik btrfs_create_pending_block_groups(trans, root); 1676ea658badSJosef Bacik 1677c3e69d58SChris Mason ret = btrfs_run_delayed_refs(trans, root, 0); 1678e4a2bcacSJosef Bacik if (ret) { 1679e4a2bcacSJosef Bacik btrfs_end_transaction(trans, root); 1680e4a2bcacSJosef Bacik return ret; 1681e4a2bcacSJosef Bacik } 168256bec294SChris Mason 16834a9d8bdeSMiao Xie spin_lock(&root->fs_info->trans_lock); 16844a9d8bdeSMiao Xie if (cur_trans->state >= TRANS_STATE_COMMIT_START) { 16854a9d8bdeSMiao Xie spin_unlock(&root->fs_info->trans_lock); 168613c5a93eSJosef Bacik atomic_inc(&cur_trans->use_count); 168749b25e05SJeff Mahoney ret = btrfs_end_transaction(trans, root); 1688ccd467d6SChris Mason 1689b9c8300cSLi Zefan wait_for_commit(root, cur_trans); 169015ee9bc7SJosef Bacik 1691724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 169215ee9bc7SJosef Bacik 169349b25e05SJeff Mahoney return ret; 169479154b1bSChris Mason } 16954313b399SChris Mason 16964a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_COMMIT_START; 1697bb9c12c9SSage Weil wake_up(&root->fs_info->transaction_blocked_wait); 1698bb9c12c9SSage Weil 1699ccd467d6SChris Mason if (cur_trans->list.prev != &root->fs_info->trans_list) { 1700ccd467d6SChris Mason prev_trans = list_entry(cur_trans->list.prev, 1701ccd467d6SChris Mason struct btrfs_transaction, list); 17024a9d8bdeSMiao Xie if (prev_trans->state != TRANS_STATE_COMPLETED) { 170313c5a93eSJosef Bacik atomic_inc(&prev_trans->use_count); 1704a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 1705ccd467d6SChris Mason 1706ccd467d6SChris Mason wait_for_commit(root, prev_trans); 1707ccd467d6SChris Mason 1708724e2315SJosef Bacik btrfs_put_transaction(prev_trans); 1709a4abeea4SJosef Bacik } else { 1710a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 1711ccd467d6SChris Mason } 1712a4abeea4SJosef Bacik } else { 1713a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 1714ccd467d6SChris Mason } 171515ee9bc7SJosef Bacik 17160860adfdSMiao Xie extwriter_counter_dec(cur_trans, trans->type); 17170860adfdSMiao Xie 171882436617SMiao Xie ret = btrfs_start_delalloc_flush(root->fs_info); 171982436617SMiao Xie if (ret) 172082436617SMiao Xie goto cleanup_transaction; 172182436617SMiao Xie 1722ca469637SMiao Xie ret = btrfs_flush_all_pending_stuffs(trans, root); 172349b25e05SJeff Mahoney if (ret) 172449b25e05SJeff Mahoney goto cleanup_transaction; 172516cdcec7SMiao Xie 1726581227d0SMiao Xie wait_event(cur_trans->writer_wait, 1727581227d0SMiao Xie extwriter_counter_read(cur_trans) == 0); 1728ed3b3d31SChris Mason 1729581227d0SMiao Xie /* some pending stuffs might be added after the previous flush. */ 1730ca469637SMiao Xie ret = btrfs_flush_all_pending_stuffs(trans, root); 1731ca469637SMiao Xie if (ret) 1732ca469637SMiao Xie goto cleanup_transaction; 1733ca469637SMiao Xie 173482436617SMiao Xie btrfs_wait_delalloc_flush(root->fs_info); 1735cb7ab021SWang Shilong 1736cb7ab021SWang Shilong btrfs_scrub_pause(root); 1737ed0ca140SJosef Bacik /* 1738ed0ca140SJosef Bacik * Ok now we need to make sure to block out any other joins while we 1739ed0ca140SJosef Bacik * commit the transaction. We could have started a join before setting 17404a9d8bdeSMiao Xie * COMMIT_DOING so make sure to wait for num_writers to == 1 again. 1741ed0ca140SJosef Bacik */ 1742a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 17434a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_COMMIT_DOING; 1744a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 1745ed0ca140SJosef Bacik wait_event(cur_trans->writer_wait, 1746ed0ca140SJosef Bacik atomic_read(&cur_trans->num_writers) == 1); 174715ee9bc7SJosef Bacik 17482cba30f1SMiao Xie /* ->aborted might be set after the previous check, so check it */ 17492cba30f1SMiao Xie if (unlikely(ACCESS_ONCE(cur_trans->aborted))) { 17502cba30f1SMiao Xie ret = cur_trans->aborted; 17516cf7f77eSWang Shilong goto scrub_continue; 17522cba30f1SMiao Xie } 17537585717fSChris Mason /* 17547585717fSChris Mason * the reloc mutex makes sure that we stop 17557585717fSChris Mason * the balancing code from coming in and moving 17567585717fSChris Mason * extents around in the middle of the commit 17577585717fSChris Mason */ 17587585717fSChris Mason mutex_lock(&root->fs_info->reloc_mutex); 17597585717fSChris Mason 176042874b3dSMiao Xie /* 176142874b3dSMiao Xie * We needn't worry about the delayed items because we will 176242874b3dSMiao Xie * deal with them in create_pending_snapshot(), which is the 176342874b3dSMiao Xie * core function of the snapshot creation. 176442874b3dSMiao Xie */ 176542874b3dSMiao Xie ret = create_pending_snapshots(trans, root->fs_info); 176649b25e05SJeff Mahoney if (ret) { 176749b25e05SJeff Mahoney mutex_unlock(&root->fs_info->reloc_mutex); 17686cf7f77eSWang Shilong goto scrub_continue; 176949b25e05SJeff Mahoney } 17703063d29fSChris Mason 177142874b3dSMiao Xie /* 177242874b3dSMiao Xie * We insert the dir indexes of the snapshots and update the inode 177342874b3dSMiao Xie * of the snapshots' parents after the snapshot creation, so there 177442874b3dSMiao Xie * are some delayed items which are not dealt with. Now deal with 177542874b3dSMiao Xie * them. 177642874b3dSMiao Xie * 177742874b3dSMiao Xie * We needn't worry that this operation will corrupt the snapshots, 177842874b3dSMiao Xie * because all the tree which are snapshoted will be forced to COW 177942874b3dSMiao Xie * the nodes and leaves. 178042874b3dSMiao Xie */ 178142874b3dSMiao Xie ret = btrfs_run_delayed_items(trans, root); 178249b25e05SJeff Mahoney if (ret) { 178349b25e05SJeff Mahoney mutex_unlock(&root->fs_info->reloc_mutex); 17846cf7f77eSWang Shilong goto scrub_continue; 178549b25e05SJeff Mahoney } 178616cdcec7SMiao Xie 178756bec294SChris Mason ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); 178849b25e05SJeff Mahoney if (ret) { 178949b25e05SJeff Mahoney mutex_unlock(&root->fs_info->reloc_mutex); 17906cf7f77eSWang Shilong goto scrub_continue; 179149b25e05SJeff Mahoney } 179256bec294SChris Mason 1793e999376fSChris Mason /* 1794e999376fSChris Mason * make sure none of the code above managed to slip in a 1795e999376fSChris Mason * delayed item 1796e999376fSChris Mason */ 1797e999376fSChris Mason btrfs_assert_delayed_root_empty(root); 1798e999376fSChris Mason 17992c90e5d6SChris Mason WARN_ON(cur_trans != trans->transaction); 1800dc17ff8fSChris Mason 1801e02119d5SChris Mason /* btrfs_commit_tree_roots is responsible for getting the 1802e02119d5SChris Mason * various roots consistent with each other. Every pointer 1803e02119d5SChris Mason * in the tree of tree roots has to point to the most up to date 1804e02119d5SChris Mason * root for every subvolume and other tree. So, we have to keep 1805e02119d5SChris Mason * the tree logging code from jumping in and changing any 1806e02119d5SChris Mason * of the trees. 1807e02119d5SChris Mason * 1808e02119d5SChris Mason * At this point in the commit, there can't be any tree-log 1809e02119d5SChris Mason * writers, but a little lower down we drop the trans mutex 1810e02119d5SChris Mason * and let new people in. By holding the tree_log_mutex 1811e02119d5SChris Mason * from now until after the super is written, we avoid races 1812e02119d5SChris Mason * with the tree-log code. 1813e02119d5SChris Mason */ 1814e02119d5SChris Mason mutex_lock(&root->fs_info->tree_log_mutex); 18151a40e23bSZheng Yan 18165d4f98a2SYan Zheng ret = commit_fs_roots(trans, root); 181749b25e05SJeff Mahoney if (ret) { 181849b25e05SJeff Mahoney mutex_unlock(&root->fs_info->tree_log_mutex); 1819871383beSDavid Sterba mutex_unlock(&root->fs_info->reloc_mutex); 18206cf7f77eSWang Shilong goto scrub_continue; 182149b25e05SJeff Mahoney } 182254aa1f4dSChris Mason 18233818aea2SQu Wenruo /* 18243818aea2SQu Wenruo * Since the transaction is done, we should set the inode map cache flag 18253818aea2SQu Wenruo * before any other comming transaction. 18263818aea2SQu Wenruo */ 18273818aea2SQu Wenruo if (btrfs_test_opt(root, CHANGE_INODE_CACHE)) 18283818aea2SQu Wenruo btrfs_set_opt(root->fs_info->mount_opt, INODE_MAP_CACHE); 18293818aea2SQu Wenruo else 18303818aea2SQu Wenruo btrfs_clear_opt(root->fs_info->mount_opt, INODE_MAP_CACHE); 18313818aea2SQu Wenruo 18325d4f98a2SYan Zheng /* commit_fs_roots gets rid of all the tree log roots, it is now 1833e02119d5SChris Mason * safe to free the root of tree log roots 1834e02119d5SChris Mason */ 1835e02119d5SChris Mason btrfs_free_log_root_tree(trans, root->fs_info); 1836e02119d5SChris Mason 18375d4f98a2SYan Zheng ret = commit_cowonly_roots(trans, root); 183849b25e05SJeff Mahoney if (ret) { 183949b25e05SJeff Mahoney mutex_unlock(&root->fs_info->tree_log_mutex); 1840871383beSDavid Sterba mutex_unlock(&root->fs_info->reloc_mutex); 18416cf7f77eSWang Shilong goto scrub_continue; 184249b25e05SJeff Mahoney } 184354aa1f4dSChris Mason 18442cba30f1SMiao Xie /* 18452cba30f1SMiao Xie * The tasks which save the space cache and inode cache may also 18462cba30f1SMiao Xie * update ->aborted, check it. 18472cba30f1SMiao Xie */ 18482cba30f1SMiao Xie if (unlikely(ACCESS_ONCE(cur_trans->aborted))) { 18492cba30f1SMiao Xie ret = cur_trans->aborted; 18502cba30f1SMiao Xie mutex_unlock(&root->fs_info->tree_log_mutex); 18512cba30f1SMiao Xie mutex_unlock(&root->fs_info->reloc_mutex); 18526cf7f77eSWang Shilong goto scrub_continue; 18532cba30f1SMiao Xie } 18542cba30f1SMiao Xie 185511833d66SYan Zheng btrfs_prepare_extent_commit(trans, root); 185611833d66SYan Zheng 185778fae27eSChris Mason cur_trans = root->fs_info->running_transaction; 18585f39d397SChris Mason 18595d4f98a2SYan Zheng btrfs_set_root_node(&root->fs_info->tree_root->root_item, 18605d4f98a2SYan Zheng root->fs_info->tree_root->node); 1861817d52f8SJosef Bacik switch_commit_root(root->fs_info->tree_root); 18625d4f98a2SYan Zheng 18635d4f98a2SYan Zheng btrfs_set_root_node(&root->fs_info->chunk_root->root_item, 18645d4f98a2SYan Zheng root->fs_info->chunk_root->node); 1865817d52f8SJosef Bacik switch_commit_root(root->fs_info->chunk_root); 18665d4f98a2SYan Zheng 1867edf39272SJan Schmidt assert_qgroups_uptodate(trans); 18685d4f98a2SYan Zheng update_super_roots(root); 1869e02119d5SChris Mason 18706c41761fSDavid Sterba btrfs_set_super_log_root(root->fs_info->super_copy, 0); 18716c41761fSDavid Sterba btrfs_set_super_log_root_level(root->fs_info->super_copy, 0); 18726c41761fSDavid Sterba memcpy(root->fs_info->super_for_commit, root->fs_info->super_copy, 18736c41761fSDavid Sterba sizeof(*root->fs_info->super_copy)); 1874ccd467d6SChris Mason 1875a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 18764a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_UNBLOCKED; 1877a4abeea4SJosef Bacik root->fs_info->running_transaction = NULL; 1878a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 18797585717fSChris Mason mutex_unlock(&root->fs_info->reloc_mutex); 1880b7ec40d7SChris Mason 1881f9295749SChris Mason wake_up(&root->fs_info->transaction_wait); 1882e6dcd2dcSChris Mason 188379154b1bSChris Mason ret = btrfs_write_and_wait_transaction(trans, root); 188449b25e05SJeff Mahoney if (ret) { 188549b25e05SJeff Mahoney btrfs_error(root->fs_info, ret, 188608748810SDavid Sterba "Error while writing out transaction"); 188749b25e05SJeff Mahoney mutex_unlock(&root->fs_info->tree_log_mutex); 18886cf7f77eSWang Shilong goto scrub_continue; 188949b25e05SJeff Mahoney } 189049b25e05SJeff Mahoney 189149b25e05SJeff Mahoney ret = write_ctree_super(trans, root, 0); 189249b25e05SJeff Mahoney if (ret) { 189349b25e05SJeff Mahoney mutex_unlock(&root->fs_info->tree_log_mutex); 18946cf7f77eSWang Shilong goto scrub_continue; 189549b25e05SJeff Mahoney } 18964313b399SChris Mason 1897e02119d5SChris Mason /* 1898e02119d5SChris Mason * the super is written, we can safely allow the tree-loggers 1899e02119d5SChris Mason * to go about their business 1900e02119d5SChris Mason */ 1901e02119d5SChris Mason mutex_unlock(&root->fs_info->tree_log_mutex); 1902e02119d5SChris Mason 190311833d66SYan Zheng btrfs_finish_extent_commit(trans, root); 19044313b399SChris Mason 190515ee9bc7SJosef Bacik root->fs_info->last_trans_committed = cur_trans->transid; 19064a9d8bdeSMiao Xie /* 19074a9d8bdeSMiao Xie * We needn't acquire the lock here because there is no other task 19084a9d8bdeSMiao Xie * which can change it. 19094a9d8bdeSMiao Xie */ 19104a9d8bdeSMiao Xie cur_trans->state = TRANS_STATE_COMPLETED; 19112c90e5d6SChris Mason wake_up(&cur_trans->commit_wait); 19123de4586cSChris Mason 1913a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 191413c5a93eSJosef Bacik list_del_init(&cur_trans->list); 1915a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 1916a4abeea4SJosef Bacik 1917724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 1918724e2315SJosef Bacik btrfs_put_transaction(cur_trans); 191958176a96SJosef Bacik 19200860adfdSMiao Xie if (trans->type & __TRANS_FREEZABLE) 1921b2b5ef5cSJan Kara sb_end_intwrite(root->fs_info->sb); 1922b2b5ef5cSJan Kara 19231abe9b8aSliubo trace_btrfs_transaction_commit(root); 19241abe9b8aSliubo 1925a2de733cSArne Jansen btrfs_scrub_continue(root); 1926a2de733cSArne Jansen 19279ed74f2dSJosef Bacik if (current->journal_info == trans) 19289ed74f2dSJosef Bacik current->journal_info = NULL; 19299ed74f2dSJosef Bacik 19302c90e5d6SChris Mason kmem_cache_free(btrfs_trans_handle_cachep, trans); 193124bbcf04SYan, Zheng 193224bbcf04SYan, Zheng if (current != root->fs_info->transaction_kthread) 193324bbcf04SYan, Zheng btrfs_run_delayed_iputs(root); 193424bbcf04SYan, Zheng 193579154b1bSChris Mason return ret; 193649b25e05SJeff Mahoney 19376cf7f77eSWang Shilong scrub_continue: 19386cf7f77eSWang Shilong btrfs_scrub_continue(root); 193949b25e05SJeff Mahoney cleanup_transaction: 19400e721106SJosef Bacik btrfs_trans_release_metadata(trans, root); 19410e721106SJosef Bacik trans->block_rsv = NULL; 1942272d26d0SMiao Xie if (trans->qgroup_reserved) { 1943272d26d0SMiao Xie btrfs_qgroup_free(root, trans->qgroup_reserved); 1944272d26d0SMiao Xie trans->qgroup_reserved = 0; 1945272d26d0SMiao Xie } 1946c2cf52ebSSimon Kirby btrfs_warn(root->fs_info, "Skipping commit of aborted transaction."); 194749b25e05SJeff Mahoney if (current->journal_info == trans) 194849b25e05SJeff Mahoney current->journal_info = NULL; 19497b8b92afSJosef Bacik cleanup_transaction(trans, root, ret); 195049b25e05SJeff Mahoney 195149b25e05SJeff Mahoney return ret; 195279154b1bSChris Mason } 195379154b1bSChris Mason 1954d352ac68SChris Mason /* 19559d1a2a3aSDavid Sterba * return < 0 if error 19569d1a2a3aSDavid Sterba * 0 if there are no more dead_roots at the time of call 19579d1a2a3aSDavid Sterba * 1 there are more to be processed, call me again 19589d1a2a3aSDavid Sterba * 19599d1a2a3aSDavid Sterba * The return value indicates there are certainly more snapshots to delete, but 19609d1a2a3aSDavid Sterba * if there comes a new one during processing, it may return 0. We don't mind, 19619d1a2a3aSDavid Sterba * because btrfs_commit_super will poke cleaner thread and it will process it a 19629d1a2a3aSDavid Sterba * few seconds later. 1963d352ac68SChris Mason */ 19649d1a2a3aSDavid Sterba int btrfs_clean_one_deleted_snapshot(struct btrfs_root *root) 1965e9d0b13bSChris Mason { 19669d1a2a3aSDavid Sterba int ret; 19675d4f98a2SYan Zheng struct btrfs_fs_info *fs_info = root->fs_info; 1968e9d0b13bSChris Mason 1969a4abeea4SJosef Bacik spin_lock(&fs_info->trans_lock); 19709d1a2a3aSDavid Sterba if (list_empty(&fs_info->dead_roots)) { 19719d1a2a3aSDavid Sterba spin_unlock(&fs_info->trans_lock); 19729d1a2a3aSDavid Sterba return 0; 19739d1a2a3aSDavid Sterba } 19749d1a2a3aSDavid Sterba root = list_first_entry(&fs_info->dead_roots, 19759d1a2a3aSDavid Sterba struct btrfs_root, root_list); 197618f687d5SWang Shilong /* 197718f687d5SWang Shilong * Make sure root is not involved in send, 197818f687d5SWang Shilong * if we fail with first root, we return 197918f687d5SWang Shilong * directly rather than continue. 198018f687d5SWang Shilong */ 198118f687d5SWang Shilong spin_lock(&root->root_item_lock); 198218f687d5SWang Shilong if (root->send_in_progress) { 198318f687d5SWang Shilong spin_unlock(&fs_info->trans_lock); 198418f687d5SWang Shilong spin_unlock(&root->root_item_lock); 198518f687d5SWang Shilong return 0; 198618f687d5SWang Shilong } 198718f687d5SWang Shilong spin_unlock(&root->root_item_lock); 198818f687d5SWang Shilong 1989cfad392bSJosef Bacik list_del_init(&root->root_list); 1990a4abeea4SJosef Bacik spin_unlock(&fs_info->trans_lock); 19915d4f98a2SYan Zheng 1992efe120a0SFrank Holton pr_debug("BTRFS: cleaner removing %llu\n", root->objectid); 199376dda93cSYan, Zheng 199416cdcec7SMiao Xie btrfs_kill_all_delayed_nodes(root); 199516cdcec7SMiao Xie 199676dda93cSYan, Zheng if (btrfs_header_backref_rev(root->node) < 199776dda93cSYan, Zheng BTRFS_MIXED_BACKREF_REV) 19982c536799SJeff Mahoney ret = btrfs_drop_snapshot(root, NULL, 0, 0); 199976dda93cSYan, Zheng else 20002c536799SJeff Mahoney ret = btrfs_drop_snapshot(root, NULL, 1, 0); 20019d1a2a3aSDavid Sterba /* 20029d1a2a3aSDavid Sterba * If we encounter a transaction abort during snapshot cleaning, we 20039d1a2a3aSDavid Sterba * don't want to crash here 20049d1a2a3aSDavid Sterba */ 20056596a928SJosef Bacik return (ret < 0) ? 0 : 1; 2006e9d0b13bSChris Mason } 2007