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" 3379154b1bSChris Mason 340f7d52f4SChris Mason #define BTRFS_ROOT_TRANS_TAG 0 350f7d52f4SChris Mason 3649b25e05SJeff Mahoney void put_transaction(struct btrfs_transaction *transaction) 3779154b1bSChris Mason { 3813c5a93eSJosef Bacik WARN_ON(atomic_read(&transaction->use_count) == 0); 3913c5a93eSJosef Bacik if (atomic_dec_and_test(&transaction->use_count)) { 40a4abeea4SJosef Bacik BUG_ON(!list_empty(&transaction->list)); 4100f04b88SArne Jansen WARN_ON(transaction->delayed_refs.root.rb_node); 422c90e5d6SChris Mason memset(transaction, 0, sizeof(*transaction)); 432c90e5d6SChris Mason kmem_cache_free(btrfs_transaction_cachep, transaction); 4479154b1bSChris Mason } 4578fae27eSChris Mason } 4679154b1bSChris Mason 47817d52f8SJosef Bacik static noinline void switch_commit_root(struct btrfs_root *root) 48817d52f8SJosef Bacik { 49817d52f8SJosef Bacik free_extent_buffer(root->commit_root); 50817d52f8SJosef Bacik root->commit_root = btrfs_root_node(root); 51817d52f8SJosef Bacik } 52817d52f8SJosef Bacik 53d352ac68SChris Mason /* 54d352ac68SChris Mason * either allocate a new transaction or hop into the existing one 55d352ac68SChris Mason */ 56a4abeea4SJosef Bacik static noinline int join_transaction(struct btrfs_root *root, int nofail) 5779154b1bSChris Mason { 5879154b1bSChris Mason struct btrfs_transaction *cur_trans; 5919ae4e81SJan Schmidt struct btrfs_fs_info *fs_info = root->fs_info; 60a4abeea4SJosef Bacik 6119ae4e81SJan Schmidt spin_lock(&fs_info->trans_lock); 62d43317dcSChris Mason loop: 6349b25e05SJeff Mahoney /* The file system has been taken offline. No new transactions. */ 6419ae4e81SJan Schmidt if (fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) { 6519ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 6649b25e05SJeff Mahoney return -EROFS; 6749b25e05SJeff Mahoney } 6849b25e05SJeff Mahoney 6919ae4e81SJan Schmidt if (fs_info->trans_no_join) { 70a4abeea4SJosef Bacik if (!nofail) { 7119ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 72a4abeea4SJosef Bacik return -EBUSY; 73a4abeea4SJosef Bacik } 74a4abeea4SJosef Bacik } 75a4abeea4SJosef Bacik 7619ae4e81SJan Schmidt cur_trans = fs_info->running_transaction; 77a4abeea4SJosef Bacik if (cur_trans) { 78871383beSDavid Sterba if (cur_trans->aborted) { 7919ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 8049b25e05SJeff Mahoney return cur_trans->aborted; 81871383beSDavid Sterba } 82a4abeea4SJosef Bacik atomic_inc(&cur_trans->use_count); 83a4abeea4SJosef Bacik atomic_inc(&cur_trans->num_writers); 84a4abeea4SJosef Bacik cur_trans->num_joined++; 8519ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 86a4abeea4SJosef Bacik return 0; 87a4abeea4SJosef Bacik } 8819ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 89a4abeea4SJosef Bacik 90a4abeea4SJosef Bacik cur_trans = kmem_cache_alloc(btrfs_transaction_cachep, GFP_NOFS); 91db5b493aSTsutomu Itoh if (!cur_trans) 92db5b493aSTsutomu Itoh return -ENOMEM; 93d43317dcSChris Mason 9419ae4e81SJan Schmidt spin_lock(&fs_info->trans_lock); 9519ae4e81SJan Schmidt if (fs_info->running_transaction) { 96d43317dcSChris Mason /* 97d43317dcSChris Mason * someone started a transaction after we unlocked. Make sure 98d43317dcSChris Mason * to redo the trans_no_join checks above 99d43317dcSChris Mason */ 100a4abeea4SJosef Bacik kmem_cache_free(btrfs_transaction_cachep, cur_trans); 10119ae4e81SJan Schmidt cur_trans = fs_info->running_transaction; 102d43317dcSChris Mason goto loop; 103e4b50e14SDan Carpenter } else if (fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) { 104e4b50e14SDan Carpenter spin_unlock(&fs_info->trans_lock); 1057b8b92afSJosef Bacik kmem_cache_free(btrfs_transaction_cachep, cur_trans); 1067b8b92afSJosef Bacik return -EROFS; 107a4abeea4SJosef Bacik } 108d43317dcSChris Mason 10913c5a93eSJosef Bacik atomic_set(&cur_trans->num_writers, 1); 11015ee9bc7SJosef Bacik cur_trans->num_joined = 0; 11179154b1bSChris Mason init_waitqueue_head(&cur_trans->writer_wait); 11279154b1bSChris Mason init_waitqueue_head(&cur_trans->commit_wait); 11379154b1bSChris Mason cur_trans->in_commit = 0; 114f9295749SChris Mason cur_trans->blocked = 0; 115a4abeea4SJosef Bacik /* 116a4abeea4SJosef Bacik * One for this trans handle, one so it will live on until we 117a4abeea4SJosef Bacik * commit the transaction. 118a4abeea4SJosef Bacik */ 119a4abeea4SJosef Bacik atomic_set(&cur_trans->use_count, 2); 12079154b1bSChris Mason cur_trans->commit_done = 0; 12108607c1bSChris Mason cur_trans->start_time = get_seconds(); 12256bec294SChris Mason 1236bef4d31SEric Paris cur_trans->delayed_refs.root = RB_ROOT; 12456bec294SChris Mason cur_trans->delayed_refs.num_entries = 0; 125c3e69d58SChris Mason cur_trans->delayed_refs.num_heads_ready = 0; 126c3e69d58SChris Mason cur_trans->delayed_refs.num_heads = 0; 12756bec294SChris Mason cur_trans->delayed_refs.flushing = 0; 128c3e69d58SChris Mason cur_trans->delayed_refs.run_delayed_start = 0; 12920b297d6SJan Schmidt 13020b297d6SJan Schmidt /* 13120b297d6SJan Schmidt * although the tree mod log is per file system and not per transaction, 13220b297d6SJan Schmidt * the log must never go across transaction boundaries. 13320b297d6SJan Schmidt */ 13420b297d6SJan Schmidt smp_mb(); 13520b297d6SJan Schmidt if (!list_empty(&fs_info->tree_mod_seq_list)) { 13620b297d6SJan Schmidt printk(KERN_ERR "btrfs: tree_mod_seq_list not empty when " 13720b297d6SJan Schmidt "creating a fresh transaction\n"); 13820b297d6SJan Schmidt WARN_ON(1); 13920b297d6SJan Schmidt } 14020b297d6SJan Schmidt if (!RB_EMPTY_ROOT(&fs_info->tree_mod_log)) { 14120b297d6SJan Schmidt printk(KERN_ERR "btrfs: tree_mod_log rb tree not empty when " 14220b297d6SJan Schmidt "creating a fresh transaction\n"); 14320b297d6SJan Schmidt WARN_ON(1); 14420b297d6SJan Schmidt } 14520b297d6SJan Schmidt atomic_set(&fs_info->tree_mod_seq, 0); 14620b297d6SJan Schmidt 147a4abeea4SJosef Bacik spin_lock_init(&cur_trans->commit_lock); 14856bec294SChris Mason spin_lock_init(&cur_trans->delayed_refs.lock); 14956bec294SChris Mason 1503063d29fSChris Mason INIT_LIST_HEAD(&cur_trans->pending_snapshots); 15119ae4e81SJan Schmidt list_add_tail(&cur_trans->list, &fs_info->trans_list); 152d1310b2eSChris Mason extent_io_tree_init(&cur_trans->dirty_pages, 15319ae4e81SJan Schmidt fs_info->btree_inode->i_mapping); 15419ae4e81SJan Schmidt fs_info->generation++; 15519ae4e81SJan Schmidt cur_trans->transid = fs_info->generation; 15619ae4e81SJan Schmidt fs_info->running_transaction = cur_trans; 15749b25e05SJeff Mahoney cur_trans->aborted = 0; 15819ae4e81SJan Schmidt spin_unlock(&fs_info->trans_lock); 15915ee9bc7SJosef Bacik 16079154b1bSChris Mason return 0; 16179154b1bSChris Mason } 16279154b1bSChris Mason 163d352ac68SChris Mason /* 164d397712bSChris Mason * this does all the record keeping required to make sure that a reference 165d397712bSChris Mason * counted root is properly recorded in a given transaction. This is required 166d397712bSChris Mason * to make sure the old root from before we joined the transaction is deleted 167d397712bSChris Mason * when the transaction commits 168d352ac68SChris Mason */ 1697585717fSChris Mason static int record_root_in_trans(struct btrfs_trans_handle *trans, 1705d4f98a2SYan Zheng struct btrfs_root *root) 1716702ed49SChris Mason { 1725d4f98a2SYan Zheng if (root->ref_cows && root->last_trans < trans->transid) { 1736702ed49SChris Mason WARN_ON(root == root->fs_info->extent_root); 1745d4f98a2SYan Zheng WARN_ON(root->commit_root != root->node); 1755d4f98a2SYan Zheng 1767585717fSChris Mason /* 1777585717fSChris Mason * see below for in_trans_setup usage rules 1787585717fSChris Mason * we have the reloc mutex held now, so there 1797585717fSChris Mason * is only one writer in this function 1807585717fSChris Mason */ 1817585717fSChris Mason root->in_trans_setup = 1; 1827585717fSChris Mason 1837585717fSChris Mason /* make sure readers find in_trans_setup before 1847585717fSChris Mason * they find our root->last_trans update 1857585717fSChris Mason */ 1867585717fSChris Mason smp_wmb(); 1877585717fSChris Mason 188a4abeea4SJosef Bacik spin_lock(&root->fs_info->fs_roots_radix_lock); 189a4abeea4SJosef Bacik if (root->last_trans == trans->transid) { 190a4abeea4SJosef Bacik spin_unlock(&root->fs_info->fs_roots_radix_lock); 191a4abeea4SJosef Bacik return 0; 192a4abeea4SJosef Bacik } 1936702ed49SChris Mason radix_tree_tag_set(&root->fs_info->fs_roots_radix, 1946702ed49SChris Mason (unsigned long)root->root_key.objectid, 1956702ed49SChris Mason BTRFS_ROOT_TRANS_TAG); 196a4abeea4SJosef Bacik spin_unlock(&root->fs_info->fs_roots_radix_lock); 1977585717fSChris Mason root->last_trans = trans->transid; 1987585717fSChris Mason 1997585717fSChris Mason /* this is pretty tricky. We don't want to 2007585717fSChris Mason * take the relocation lock in btrfs_record_root_in_trans 2017585717fSChris Mason * unless we're really doing the first setup for this root in 2027585717fSChris Mason * this transaction. 2037585717fSChris Mason * 2047585717fSChris Mason * Normally we'd use root->last_trans as a flag to decide 2057585717fSChris Mason * if we want to take the expensive mutex. 2067585717fSChris Mason * 2077585717fSChris Mason * But, we have to set root->last_trans before we 2087585717fSChris Mason * init the relocation root, otherwise, we trip over warnings 2097585717fSChris Mason * in ctree.c. The solution used here is to flag ourselves 2107585717fSChris Mason * with root->in_trans_setup. When this is 1, we're still 2117585717fSChris Mason * fixing up the reloc trees and everyone must wait. 2127585717fSChris Mason * 2137585717fSChris Mason * When this is zero, they can trust root->last_trans and fly 2147585717fSChris Mason * through btrfs_record_root_in_trans without having to take the 2157585717fSChris Mason * lock. smp_wmb() makes sure that all the writes above are 2167585717fSChris Mason * done before we pop in the zero below 2177585717fSChris Mason */ 2185d4f98a2SYan Zheng btrfs_init_reloc_root(trans, root); 2197585717fSChris Mason smp_wmb(); 2207585717fSChris Mason root->in_trans_setup = 0; 2216702ed49SChris Mason } 2225d4f98a2SYan Zheng return 0; 2236702ed49SChris Mason } 2245d4f98a2SYan Zheng 2257585717fSChris Mason 2267585717fSChris Mason int btrfs_record_root_in_trans(struct btrfs_trans_handle *trans, 2277585717fSChris Mason struct btrfs_root *root) 2287585717fSChris Mason { 2297585717fSChris Mason if (!root->ref_cows) 2307585717fSChris Mason return 0; 2317585717fSChris Mason 2327585717fSChris Mason /* 2337585717fSChris Mason * see record_root_in_trans for comments about in_trans_setup usage 2347585717fSChris Mason * and barriers 2357585717fSChris Mason */ 2367585717fSChris Mason smp_rmb(); 2377585717fSChris Mason if (root->last_trans == trans->transid && 2387585717fSChris Mason !root->in_trans_setup) 2397585717fSChris Mason return 0; 2407585717fSChris Mason 2417585717fSChris Mason mutex_lock(&root->fs_info->reloc_mutex); 2427585717fSChris Mason record_root_in_trans(trans, root); 2437585717fSChris Mason mutex_unlock(&root->fs_info->reloc_mutex); 2447585717fSChris Mason 2457585717fSChris Mason return 0; 2467585717fSChris Mason } 2477585717fSChris Mason 248d352ac68SChris Mason /* wait for commit against the current transaction to become unblocked 249d352ac68SChris Mason * when this is done, it is safe to start a new transaction, but the current 250d352ac68SChris Mason * transaction might not be fully on disk. 251d352ac68SChris Mason */ 25237d1aeeeSChris Mason static void wait_current_trans(struct btrfs_root *root) 25379154b1bSChris Mason { 254f9295749SChris Mason struct btrfs_transaction *cur_trans; 25579154b1bSChris Mason 256a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 257f9295749SChris Mason cur_trans = root->fs_info->running_transaction; 25837d1aeeeSChris Mason if (cur_trans && cur_trans->blocked) { 25913c5a93eSJosef Bacik atomic_inc(&cur_trans->use_count); 260a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 26172d63ed6SLi Zefan 26272d63ed6SLi Zefan wait_event(root->fs_info->transaction_wait, 26372d63ed6SLi Zefan !cur_trans->blocked); 264f9295749SChris Mason put_transaction(cur_trans); 265a4abeea4SJosef Bacik } else { 266a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 267f9295749SChris Mason } 26837d1aeeeSChris Mason } 26937d1aeeeSChris Mason 270a22285a6SYan, Zheng static int may_wait_transaction(struct btrfs_root *root, int type) 27137d1aeeeSChris Mason { 272a4abeea4SJosef Bacik if (root->fs_info->log_root_recovering) 273a4abeea4SJosef Bacik return 0; 274a4abeea4SJosef Bacik 275a4abeea4SJosef Bacik if (type == TRANS_USERSPACE) 276a22285a6SYan, Zheng return 1; 277a4abeea4SJosef Bacik 278a4abeea4SJosef Bacik if (type == TRANS_START && 279a4abeea4SJosef Bacik !atomic_read(&root->fs_info->open_ioctl_trans)) 280a4abeea4SJosef Bacik return 1; 281a4abeea4SJosef Bacik 282a22285a6SYan, Zheng return 0; 283a22285a6SYan, Zheng } 284a22285a6SYan, Zheng 285a22285a6SYan, Zheng static struct btrfs_trans_handle *start_transaction(struct btrfs_root *root, 2868407aa46SMiao Xie u64 num_items, int type, 2878407aa46SMiao Xie int noflush) 288a22285a6SYan, Zheng { 289a22285a6SYan, Zheng struct btrfs_trans_handle *h; 290a22285a6SYan, Zheng struct btrfs_transaction *cur_trans; 291b5009945SJosef Bacik u64 num_bytes = 0; 292a22285a6SYan, Zheng int ret; 293c5567237SArne Jansen u64 qgroup_reserved = 0; 294acce952bSliubo 295acce952bSliubo if (root->fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) 296acce952bSliubo return ERR_PTR(-EROFS); 2972a1eb461SJosef Bacik 2982a1eb461SJosef Bacik if (current->journal_info) { 2992a1eb461SJosef Bacik WARN_ON(type != TRANS_JOIN && type != TRANS_JOIN_NOLOCK); 3002a1eb461SJosef Bacik h = current->journal_info; 3012a1eb461SJosef Bacik h->use_count++; 3022a1eb461SJosef Bacik h->orig_rsv = h->block_rsv; 3032a1eb461SJosef Bacik h->block_rsv = NULL; 3042a1eb461SJosef Bacik goto got_it; 3052a1eb461SJosef Bacik } 306b5009945SJosef Bacik 307b5009945SJosef Bacik /* 308b5009945SJosef Bacik * Do the reservation before we join the transaction so we can do all 309b5009945SJosef Bacik * the appropriate flushing if need be. 310b5009945SJosef Bacik */ 311b5009945SJosef Bacik if (num_items > 0 && root != root->fs_info->chunk_root) { 312c5567237SArne Jansen if (root->fs_info->quota_enabled && 313c5567237SArne Jansen is_fstree(root->root_key.objectid)) { 314c5567237SArne Jansen qgroup_reserved = num_items * root->leafsize; 315c5567237SArne Jansen ret = btrfs_qgroup_reserve(root, qgroup_reserved); 316c5567237SArne Jansen if (ret) 317c5567237SArne Jansen return ERR_PTR(ret); 318c5567237SArne Jansen } 319c5567237SArne Jansen 320b5009945SJosef Bacik num_bytes = btrfs_calc_trans_metadata_size(root, num_items); 3218407aa46SMiao Xie if (noflush) 3228407aa46SMiao Xie ret = btrfs_block_rsv_add_noflush(root, 3238407aa46SMiao Xie &root->fs_info->trans_block_rsv, 3248407aa46SMiao Xie num_bytes); 3258407aa46SMiao Xie else 3264a92b1b8SJosef Bacik ret = btrfs_block_rsv_add(root, 327b5009945SJosef Bacik &root->fs_info->trans_block_rsv, 328b5009945SJosef Bacik num_bytes); 329b5009945SJosef Bacik if (ret) 330b5009945SJosef Bacik return ERR_PTR(ret); 331b5009945SJosef Bacik } 332a22285a6SYan, Zheng again: 333a22285a6SYan, Zheng h = kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS); 334a22285a6SYan, Zheng if (!h) 335a22285a6SYan, Zheng return ERR_PTR(-ENOMEM); 336a22285a6SYan, Zheng 33798114659SJosef Bacik /* 33898114659SJosef Bacik * If we are JOIN_NOLOCK we're already committing a transaction and 33998114659SJosef Bacik * waiting on this guy, so we don't need to do the sb_start_intwrite 34098114659SJosef Bacik * because we're already holding a ref. We need this because we could 34198114659SJosef Bacik * have raced in and did an fsync() on a file which can kick a commit 34298114659SJosef Bacik * and then we deadlock with somebody doing a freeze. 34398114659SJosef Bacik */ 34498114659SJosef Bacik if (type != TRANS_JOIN_NOLOCK && 34598114659SJosef Bacik !__sb_start_write(root->fs_info->sb, SB_FREEZE_FS, false)) { 346e8830e60SMiao Xie if (type == TRANS_JOIN_FREEZE) { 347e8830e60SMiao Xie kmem_cache_free(btrfs_trans_handle_cachep, h); 34860376ce4SJosef Bacik return ERR_PTR(-EPERM); 349e8830e60SMiao Xie } 350b2b5ef5cSJan Kara sb_start_intwrite(root->fs_info->sb); 35160376ce4SJosef Bacik } 352b2b5ef5cSJan Kara 353a22285a6SYan, Zheng if (may_wait_transaction(root, type)) 35437d1aeeeSChris Mason wait_current_trans(root); 355a22285a6SYan, Zheng 356a4abeea4SJosef Bacik do { 357a4abeea4SJosef Bacik ret = join_transaction(root, type == TRANS_JOIN_NOLOCK); 358a4abeea4SJosef Bacik if (ret == -EBUSY) 359a4abeea4SJosef Bacik wait_current_trans(root); 360a4abeea4SJosef Bacik } while (ret == -EBUSY); 361a4abeea4SJosef Bacik 362db5b493aSTsutomu Itoh if (ret < 0) { 363b2b5ef5cSJan Kara sb_end_intwrite(root->fs_info->sb); 3646e8df2aeSYoshinori Sano kmem_cache_free(btrfs_trans_handle_cachep, h); 365db5b493aSTsutomu Itoh return ERR_PTR(ret); 366db5b493aSTsutomu Itoh } 3670f7d52f4SChris Mason 368a22285a6SYan, Zheng cur_trans = root->fs_info->running_transaction; 369a22285a6SYan, Zheng 370a22285a6SYan, Zheng h->transid = cur_trans->transid; 371a22285a6SYan, Zheng h->transaction = cur_trans; 37279154b1bSChris Mason h->blocks_used = 0; 373a22285a6SYan, Zheng h->bytes_reserved = 0; 374d13603efSArne Jansen h->root = root; 37556bec294SChris Mason h->delayed_ref_updates = 0; 3762a1eb461SJosef Bacik h->use_count = 1; 3770e721106SJosef Bacik h->adding_csums = 0; 378f0486c68SYan, Zheng h->block_rsv = NULL; 3792a1eb461SJosef Bacik h->orig_rsv = NULL; 38049b25e05SJeff Mahoney h->aborted = 0; 381c5567237SArne Jansen h->qgroup_reserved = qgroup_reserved; 382bed92eaeSArne Jansen h->delayed_ref_elem.seq = 0; 383a698d075SMiao Xie h->type = type; 384bed92eaeSArne Jansen INIT_LIST_HEAD(&h->qgroup_ref_list); 385ea658badSJosef Bacik INIT_LIST_HEAD(&h->new_bgs); 386b7ec40d7SChris Mason 387a22285a6SYan, Zheng smp_mb(); 388a22285a6SYan, Zheng if (cur_trans->blocked && may_wait_transaction(root, type)) { 389a22285a6SYan, Zheng btrfs_commit_transaction(h, root); 390a22285a6SYan, Zheng goto again; 391a22285a6SYan, Zheng } 3929ed74f2dSJosef Bacik 393b5009945SJosef Bacik if (num_bytes) { 3948c2a3ca2SJosef Bacik trace_btrfs_space_reservation(root->fs_info, "transaction", 3952bcc0328SLiu Bo h->transid, num_bytes, 1); 396b5009945SJosef Bacik h->block_rsv = &root->fs_info->trans_block_rsv; 397b5009945SJosef Bacik h->bytes_reserved = num_bytes; 398a22285a6SYan, Zheng } 399a22285a6SYan, Zheng 4002a1eb461SJosef Bacik got_it: 401a4abeea4SJosef Bacik btrfs_record_root_in_trans(h, root); 402a22285a6SYan, Zheng 403a22285a6SYan, Zheng if (!current->journal_info && type != TRANS_USERSPACE) 404a22285a6SYan, Zheng current->journal_info = h; 40579154b1bSChris Mason return h; 40679154b1bSChris Mason } 40779154b1bSChris Mason 408f9295749SChris Mason struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root, 409a22285a6SYan, Zheng int num_items) 410f9295749SChris Mason { 4118407aa46SMiao Xie return start_transaction(root, num_items, TRANS_START, 0); 412f9295749SChris Mason } 4138407aa46SMiao Xie 4148407aa46SMiao Xie struct btrfs_trans_handle *btrfs_start_transaction_noflush( 4158407aa46SMiao Xie struct btrfs_root *root, int num_items) 4168407aa46SMiao Xie { 4178407aa46SMiao Xie return start_transaction(root, num_items, TRANS_START, 1); 4188407aa46SMiao Xie } 4198407aa46SMiao Xie 4207a7eaa40SJosef Bacik struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root) 421f9295749SChris Mason { 4228407aa46SMiao Xie return start_transaction(root, 0, TRANS_JOIN, 0); 423f9295749SChris Mason } 424f9295749SChris Mason 4257a7eaa40SJosef Bacik struct btrfs_trans_handle *btrfs_join_transaction_nolock(struct btrfs_root *root) 4260af3d00bSJosef Bacik { 4278407aa46SMiao Xie return start_transaction(root, 0, TRANS_JOIN_NOLOCK, 0); 4280af3d00bSJosef Bacik } 4290af3d00bSJosef Bacik 4307a7eaa40SJosef Bacik struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *root) 4319ca9ee09SSage Weil { 4328407aa46SMiao Xie return start_transaction(root, 0, TRANS_USERSPACE, 0); 4339ca9ee09SSage Weil } 4349ca9ee09SSage Weil 43560376ce4SJosef Bacik struct btrfs_trans_handle *btrfs_join_transaction_freeze(struct btrfs_root *root) 43660376ce4SJosef Bacik { 43760376ce4SJosef Bacik return start_transaction(root, 0, TRANS_JOIN_FREEZE, 0); 43860376ce4SJosef Bacik } 43960376ce4SJosef Bacik 440d352ac68SChris Mason /* wait for a transaction commit to be fully complete */ 441b9c8300cSLi Zefan static noinline void wait_for_commit(struct btrfs_root *root, 44289ce8a63SChris Mason struct btrfs_transaction *commit) 44389ce8a63SChris Mason { 44472d63ed6SLi Zefan wait_event(commit->commit_wait, commit->commit_done); 44589ce8a63SChris Mason } 44689ce8a63SChris Mason 44746204592SSage Weil int btrfs_wait_for_commit(struct btrfs_root *root, u64 transid) 44846204592SSage Weil { 44946204592SSage Weil struct btrfs_transaction *cur_trans = NULL, *t; 45046204592SSage Weil int ret; 45146204592SSage Weil 45246204592SSage Weil ret = 0; 45346204592SSage Weil if (transid) { 45446204592SSage Weil if (transid <= root->fs_info->last_trans_committed) 455a4abeea4SJosef Bacik goto out; 45646204592SSage Weil 45746204592SSage Weil /* find specified transaction */ 458a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 45946204592SSage Weil list_for_each_entry(t, &root->fs_info->trans_list, list) { 46046204592SSage Weil if (t->transid == transid) { 46146204592SSage Weil cur_trans = t; 462a4abeea4SJosef Bacik atomic_inc(&cur_trans->use_count); 46346204592SSage Weil break; 46446204592SSage Weil } 46546204592SSage Weil if (t->transid > transid) 46646204592SSage Weil break; 46746204592SSage Weil } 468a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 46946204592SSage Weil ret = -EINVAL; 47046204592SSage Weil if (!cur_trans) 471a4abeea4SJosef Bacik goto out; /* bad transid */ 47246204592SSage Weil } else { 47346204592SSage Weil /* find newest transaction that is committing | committed */ 474a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 47546204592SSage Weil list_for_each_entry_reverse(t, &root->fs_info->trans_list, 47646204592SSage Weil list) { 47746204592SSage Weil if (t->in_commit) { 47846204592SSage Weil if (t->commit_done) 4793473f3c0SJosef Bacik break; 48046204592SSage Weil cur_trans = t; 481a4abeea4SJosef Bacik atomic_inc(&cur_trans->use_count); 48246204592SSage Weil break; 48346204592SSage Weil } 48446204592SSage Weil } 485a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 48646204592SSage Weil if (!cur_trans) 487a4abeea4SJosef Bacik goto out; /* nothing committing|committed */ 48846204592SSage Weil } 48946204592SSage Weil 49046204592SSage Weil wait_for_commit(root, cur_trans); 49146204592SSage Weil 49246204592SSage Weil put_transaction(cur_trans); 49346204592SSage Weil ret = 0; 494a4abeea4SJosef Bacik out: 49546204592SSage Weil return ret; 49646204592SSage Weil } 49746204592SSage Weil 49837d1aeeeSChris Mason void btrfs_throttle(struct btrfs_root *root) 49937d1aeeeSChris Mason { 500a4abeea4SJosef Bacik if (!atomic_read(&root->fs_info->open_ioctl_trans)) 50137d1aeeeSChris Mason wait_current_trans(root); 50237d1aeeeSChris Mason } 50337d1aeeeSChris Mason 5048929ecfaSYan, Zheng static int should_end_transaction(struct btrfs_trans_handle *trans, 5058929ecfaSYan, Zheng struct btrfs_root *root) 5068929ecfaSYan, Zheng { 5078929ecfaSYan, Zheng int ret; 50836ba022aSJosef Bacik 50936ba022aSJosef Bacik ret = btrfs_block_rsv_check(root, &root->fs_info->global_block_rsv, 5); 5108929ecfaSYan, Zheng return ret ? 1 : 0; 5118929ecfaSYan, Zheng } 5128929ecfaSYan, Zheng 5138929ecfaSYan, Zheng int btrfs_should_end_transaction(struct btrfs_trans_handle *trans, 5148929ecfaSYan, Zheng struct btrfs_root *root) 5158929ecfaSYan, Zheng { 5168929ecfaSYan, Zheng struct btrfs_transaction *cur_trans = trans->transaction; 5178929ecfaSYan, Zheng int updates; 51849b25e05SJeff Mahoney int err; 5198929ecfaSYan, Zheng 520a4abeea4SJosef Bacik smp_mb(); 5218929ecfaSYan, Zheng if (cur_trans->blocked || cur_trans->delayed_refs.flushing) 5228929ecfaSYan, Zheng return 1; 5238929ecfaSYan, Zheng 5248929ecfaSYan, Zheng updates = trans->delayed_ref_updates; 5258929ecfaSYan, Zheng trans->delayed_ref_updates = 0; 52649b25e05SJeff Mahoney if (updates) { 52749b25e05SJeff Mahoney err = btrfs_run_delayed_refs(trans, root, updates); 52849b25e05SJeff Mahoney if (err) /* Error code will also eval true */ 52949b25e05SJeff Mahoney return err; 53049b25e05SJeff Mahoney } 5318929ecfaSYan, Zheng 5328929ecfaSYan, Zheng return should_end_transaction(trans, root); 5338929ecfaSYan, Zheng } 5348929ecfaSYan, Zheng 53589ce8a63SChris Mason static int __btrfs_end_transaction(struct btrfs_trans_handle *trans, 536a698d075SMiao Xie struct btrfs_root *root, int throttle) 53779154b1bSChris Mason { 5388929ecfaSYan, Zheng struct btrfs_transaction *cur_trans = trans->transaction; 539ab78c84dSChris Mason struct btrfs_fs_info *info = root->fs_info; 540c3e69d58SChris Mason int count = 0; 541a698d075SMiao Xie int lock = (trans->type != TRANS_JOIN_NOLOCK); 5424edc2ca3SDave Jones int err = 0; 543d6e4a428SChris Mason 5442a1eb461SJosef Bacik if (--trans->use_count) { 5452a1eb461SJosef Bacik trans->block_rsv = trans->orig_rsv; 5462a1eb461SJosef Bacik return 0; 5472a1eb461SJosef Bacik } 5482a1eb461SJosef Bacik 549edf39272SJan Schmidt /* 550edf39272SJan Schmidt * do the qgroup accounting as early as possible 551edf39272SJan Schmidt */ 552edf39272SJan Schmidt err = btrfs_delayed_refs_qgroup_accounting(trans, info); 553edf39272SJan Schmidt 554b24e03dbSJosef Bacik btrfs_trans_release_metadata(trans, root); 5554c13d758SJosef Bacik trans->block_rsv = NULL; 556d13603efSArne Jansen /* 557d13603efSArne Jansen * the same root has to be passed to start_transaction and 558d13603efSArne Jansen * end_transaction. Subvolume quota depends on this. 559d13603efSArne Jansen */ 560d13603efSArne Jansen WARN_ON(trans->root != root); 561c5567237SArne Jansen 562c5567237SArne Jansen if (trans->qgroup_reserved) { 563c5567237SArne Jansen btrfs_qgroup_free(root, trans->qgroup_reserved); 564c5567237SArne Jansen trans->qgroup_reserved = 0; 565c5567237SArne Jansen } 566c5567237SArne Jansen 567ea658badSJosef Bacik if (!list_empty(&trans->new_bgs)) 568ea658badSJosef Bacik btrfs_create_pending_block_groups(trans, root); 569ea658badSJosef Bacik 570203bf287SChris Mason while (count < 2) { 571c3e69d58SChris Mason unsigned long cur = trans->delayed_ref_updates; 572c3e69d58SChris Mason trans->delayed_ref_updates = 0; 573c3e69d58SChris Mason if (cur && 574c3e69d58SChris Mason trans->transaction->delayed_refs.num_heads_ready > 64) { 575c3e69d58SChris Mason trans->delayed_ref_updates = 0; 576c3e69d58SChris Mason btrfs_run_delayed_refs(trans, root, cur); 577c3e69d58SChris Mason } else { 578c3e69d58SChris Mason break; 579c3e69d58SChris Mason } 580c3e69d58SChris Mason count++; 58156bec294SChris Mason } 5820e721106SJosef Bacik btrfs_trans_release_metadata(trans, root); 5830e721106SJosef Bacik trans->block_rsv = NULL; 58456bec294SChris Mason 585ea658badSJosef Bacik if (!list_empty(&trans->new_bgs)) 586ea658badSJosef Bacik btrfs_create_pending_block_groups(trans, root); 587ea658badSJosef Bacik 588a4abeea4SJosef Bacik if (lock && !atomic_read(&root->fs_info->open_ioctl_trans) && 589a4abeea4SJosef Bacik should_end_transaction(trans, root)) { 5908929ecfaSYan, Zheng trans->transaction->blocked = 1; 591a4abeea4SJosef Bacik smp_wmb(); 592a4abeea4SJosef Bacik } 5938929ecfaSYan, Zheng 5940af3d00bSJosef Bacik if (lock && cur_trans->blocked && !cur_trans->in_commit) { 59581317fdeSJosef Bacik if (throttle) { 59681317fdeSJosef Bacik /* 59781317fdeSJosef Bacik * We may race with somebody else here so end up having 59881317fdeSJosef Bacik * to call end_transaction on ourselves again, so inc 59981317fdeSJosef Bacik * our use_count. 60081317fdeSJosef Bacik */ 60181317fdeSJosef Bacik trans->use_count++; 6028929ecfaSYan, Zheng return btrfs_commit_transaction(trans, root); 60381317fdeSJosef Bacik } else { 6048929ecfaSYan, Zheng wake_up_process(info->transaction_kthread); 6058929ecfaSYan, Zheng } 60681317fdeSJosef Bacik } 6078929ecfaSYan, Zheng 60898114659SJosef Bacik if (lock) 6096df7881aSJosef Bacik sb_end_intwrite(root->fs_info->sb); 6106df7881aSJosef Bacik 6118929ecfaSYan, Zheng WARN_ON(cur_trans != info->running_transaction); 61213c5a93eSJosef Bacik WARN_ON(atomic_read(&cur_trans->num_writers) < 1); 61313c5a93eSJosef Bacik atomic_dec(&cur_trans->num_writers); 61489ce8a63SChris Mason 61599d16cbcSSage Weil smp_mb(); 61679154b1bSChris Mason if (waitqueue_active(&cur_trans->writer_wait)) 61779154b1bSChris Mason wake_up(&cur_trans->writer_wait); 61879154b1bSChris Mason put_transaction(cur_trans); 6199ed74f2dSJosef Bacik 6209ed74f2dSJosef Bacik if (current->journal_info == trans) 6219ed74f2dSJosef Bacik current->journal_info = NULL; 622ab78c84dSChris Mason 62324bbcf04SYan, Zheng if (throttle) 62424bbcf04SYan, Zheng btrfs_run_delayed_iputs(root); 62524bbcf04SYan, Zheng 62649b25e05SJeff Mahoney if (trans->aborted || 62749b25e05SJeff Mahoney root->fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) { 6284edc2ca3SDave Jones err = -EIO; 62949b25e05SJeff Mahoney } 630edf39272SJan Schmidt assert_qgroups_uptodate(trans); 63149b25e05SJeff Mahoney 6324edc2ca3SDave Jones memset(trans, 0, sizeof(*trans)); 6334edc2ca3SDave Jones kmem_cache_free(btrfs_trans_handle_cachep, trans); 6344edc2ca3SDave Jones return err; 63579154b1bSChris Mason } 63679154b1bSChris Mason 63789ce8a63SChris Mason int btrfs_end_transaction(struct btrfs_trans_handle *trans, 63889ce8a63SChris Mason struct btrfs_root *root) 63989ce8a63SChris Mason { 64016cdcec7SMiao Xie int ret; 64116cdcec7SMiao Xie 642a698d075SMiao Xie ret = __btrfs_end_transaction(trans, root, 0); 64316cdcec7SMiao Xie if (ret) 64416cdcec7SMiao Xie return ret; 64516cdcec7SMiao Xie return 0; 64689ce8a63SChris Mason } 64789ce8a63SChris Mason 64889ce8a63SChris Mason int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans, 64989ce8a63SChris Mason struct btrfs_root *root) 65089ce8a63SChris Mason { 65116cdcec7SMiao Xie int ret; 65216cdcec7SMiao Xie 653a698d075SMiao Xie ret = __btrfs_end_transaction(trans, root, 1); 65416cdcec7SMiao Xie if (ret) 65516cdcec7SMiao Xie return ret; 65616cdcec7SMiao Xie return 0; 65716cdcec7SMiao Xie } 65816cdcec7SMiao Xie 65916cdcec7SMiao Xie int btrfs_end_transaction_dmeta(struct btrfs_trans_handle *trans, 66016cdcec7SMiao Xie struct btrfs_root *root) 66116cdcec7SMiao Xie { 662a698d075SMiao Xie return __btrfs_end_transaction(trans, root, 1); 66389ce8a63SChris Mason } 66489ce8a63SChris Mason 665d352ac68SChris Mason /* 666d352ac68SChris Mason * when btree blocks are allocated, they have some corresponding bits set for 667d352ac68SChris Mason * them in one of two extent_io trees. This is used to make sure all of 668690587d1SChris Mason * those extents are sent to disk but does not wait on them 669d352ac68SChris Mason */ 670690587d1SChris Mason int btrfs_write_marked_extents(struct btrfs_root *root, 6718cef4e16SYan, Zheng struct extent_io_tree *dirty_pages, int mark) 67279154b1bSChris Mason { 673777e6bd7SChris Mason int err = 0; 6747c4452b9SChris Mason int werr = 0; 6751728366eSJosef Bacik struct address_space *mapping = root->fs_info->btree_inode->i_mapping; 676777e6bd7SChris Mason u64 start = 0; 6775f39d397SChris Mason u64 end; 6787c4452b9SChris Mason 6791728366eSJosef Bacik while (!find_first_extent_bit(dirty_pages, start, &start, &end, 6801728366eSJosef Bacik mark)) { 6811728366eSJosef Bacik convert_extent_bit(dirty_pages, start, end, EXTENT_NEED_WAIT, mark, 6821728366eSJosef Bacik GFP_NOFS); 6831728366eSJosef Bacik err = filemap_fdatawrite_range(mapping, start, end); 6847c4452b9SChris Mason if (err) 6857c4452b9SChris Mason werr = err; 6861728366eSJosef Bacik cond_resched(); 6871728366eSJosef Bacik start = end + 1; 6887c4452b9SChris Mason } 689690587d1SChris Mason if (err) 690690587d1SChris Mason werr = err; 691690587d1SChris Mason return werr; 692690587d1SChris Mason } 693690587d1SChris Mason 694690587d1SChris Mason /* 695690587d1SChris Mason * when btree blocks are allocated, they have some corresponding bits set for 696690587d1SChris Mason * them in one of two extent_io trees. This is used to make sure all of 697690587d1SChris Mason * those extents are on disk for transaction or log commit. We wait 698690587d1SChris Mason * on all the pages and clear them from the dirty pages state tree 699690587d1SChris Mason */ 700690587d1SChris Mason int btrfs_wait_marked_extents(struct btrfs_root *root, 7018cef4e16SYan, Zheng struct extent_io_tree *dirty_pages, int mark) 702690587d1SChris Mason { 703690587d1SChris Mason int err = 0; 704690587d1SChris Mason int werr = 0; 7051728366eSJosef Bacik struct address_space *mapping = root->fs_info->btree_inode->i_mapping; 706690587d1SChris Mason u64 start = 0; 707690587d1SChris Mason u64 end; 708690587d1SChris Mason 7091728366eSJosef Bacik while (!find_first_extent_bit(dirty_pages, start, &start, &end, 7101728366eSJosef Bacik EXTENT_NEED_WAIT)) { 7111728366eSJosef Bacik clear_extent_bits(dirty_pages, start, end, EXTENT_NEED_WAIT, GFP_NOFS); 7121728366eSJosef Bacik err = filemap_fdatawait_range(mapping, start, end); 713777e6bd7SChris Mason if (err) 714777e6bd7SChris Mason werr = err; 715777e6bd7SChris Mason cond_resched(); 7161728366eSJosef Bacik start = end + 1; 717777e6bd7SChris Mason } 7187c4452b9SChris Mason if (err) 7197c4452b9SChris Mason werr = err; 7207c4452b9SChris Mason return werr; 72179154b1bSChris Mason } 72279154b1bSChris Mason 723690587d1SChris Mason /* 724690587d1SChris Mason * when btree blocks are allocated, they have some corresponding bits set for 725690587d1SChris Mason * them in one of two extent_io trees. This is used to make sure all of 726690587d1SChris Mason * those extents are on disk for transaction or log commit 727690587d1SChris Mason */ 728690587d1SChris Mason int btrfs_write_and_wait_marked_extents(struct btrfs_root *root, 7298cef4e16SYan, Zheng struct extent_io_tree *dirty_pages, int mark) 730690587d1SChris Mason { 731690587d1SChris Mason int ret; 732690587d1SChris Mason int ret2; 733690587d1SChris Mason 7348cef4e16SYan, Zheng ret = btrfs_write_marked_extents(root, dirty_pages, mark); 7358cef4e16SYan, Zheng ret2 = btrfs_wait_marked_extents(root, dirty_pages, mark); 736bf0da8c1SChris Mason 737bf0da8c1SChris Mason if (ret) 738bf0da8c1SChris Mason return ret; 739bf0da8c1SChris Mason if (ret2) 740bf0da8c1SChris Mason return ret2; 741bf0da8c1SChris Mason return 0; 742690587d1SChris Mason } 743690587d1SChris Mason 744d0c803c4SChris Mason int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans, 745d0c803c4SChris Mason struct btrfs_root *root) 746d0c803c4SChris Mason { 747d0c803c4SChris Mason if (!trans || !trans->transaction) { 748d0c803c4SChris Mason struct inode *btree_inode; 749d0c803c4SChris Mason btree_inode = root->fs_info->btree_inode; 750d0c803c4SChris Mason return filemap_write_and_wait(btree_inode->i_mapping); 751d0c803c4SChris Mason } 752d0c803c4SChris Mason return btrfs_write_and_wait_marked_extents(root, 7538cef4e16SYan, Zheng &trans->transaction->dirty_pages, 7548cef4e16SYan, Zheng EXTENT_DIRTY); 755d0c803c4SChris Mason } 756d0c803c4SChris Mason 757d352ac68SChris Mason /* 758d352ac68SChris Mason * this is used to update the root pointer in the tree of tree roots. 759d352ac68SChris Mason * 760d352ac68SChris Mason * But, in the case of the extent allocation tree, updating the root 761d352ac68SChris Mason * pointer may allocate blocks which may change the root of the extent 762d352ac68SChris Mason * allocation tree. 763d352ac68SChris Mason * 764d352ac68SChris Mason * So, this loops and repeats and makes sure the cowonly root didn't 765d352ac68SChris Mason * change while the root pointer was being updated in the metadata. 766d352ac68SChris Mason */ 7670b86a832SChris Mason static int update_cowonly_root(struct btrfs_trans_handle *trans, 76879154b1bSChris Mason struct btrfs_root *root) 76979154b1bSChris Mason { 77079154b1bSChris Mason int ret; 7710b86a832SChris Mason u64 old_root_bytenr; 77286b9f2ecSYan, Zheng u64 old_root_used; 7730b86a832SChris Mason struct btrfs_root *tree_root = root->fs_info->tree_root; 77479154b1bSChris Mason 77586b9f2ecSYan, Zheng old_root_used = btrfs_root_used(&root->root_item); 7760b86a832SChris Mason btrfs_write_dirty_block_groups(trans, root); 77756bec294SChris Mason 77879154b1bSChris Mason while (1) { 7790b86a832SChris Mason old_root_bytenr = btrfs_root_bytenr(&root->root_item); 78086b9f2ecSYan, Zheng if (old_root_bytenr == root->node->start && 78186b9f2ecSYan, Zheng old_root_used == btrfs_root_used(&root->root_item)) 78279154b1bSChris Mason break; 78387ef2bb4SChris Mason 7845d4f98a2SYan Zheng btrfs_set_root_node(&root->root_item, root->node); 78579154b1bSChris Mason ret = btrfs_update_root(trans, tree_root, 7860b86a832SChris Mason &root->root_key, 7870b86a832SChris Mason &root->root_item); 78849b25e05SJeff Mahoney if (ret) 78949b25e05SJeff Mahoney return ret; 79056bec294SChris Mason 79186b9f2ecSYan, Zheng old_root_used = btrfs_root_used(&root->root_item); 7924a8c9a62SYan Zheng ret = btrfs_write_dirty_block_groups(trans, root); 79349b25e05SJeff Mahoney if (ret) 79449b25e05SJeff Mahoney return ret; 7950b86a832SChris Mason } 796276e680dSYan Zheng 797276e680dSYan Zheng if (root != root->fs_info->extent_root) 798817d52f8SJosef Bacik switch_commit_root(root); 799276e680dSYan Zheng 8000b86a832SChris Mason return 0; 8010b86a832SChris Mason } 8020b86a832SChris Mason 803d352ac68SChris Mason /* 804d352ac68SChris Mason * update all the cowonly tree roots on disk 80549b25e05SJeff Mahoney * 80649b25e05SJeff Mahoney * The error handling in this function may not be obvious. Any of the 80749b25e05SJeff Mahoney * failures will cause the file system to go offline. We still need 80849b25e05SJeff Mahoney * to clean up the delayed refs. 809d352ac68SChris Mason */ 8105d4f98a2SYan Zheng static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans, 8110b86a832SChris Mason struct btrfs_root *root) 8120b86a832SChris Mason { 8130b86a832SChris Mason struct btrfs_fs_info *fs_info = root->fs_info; 8140b86a832SChris Mason struct list_head *next; 81584234f3aSYan Zheng struct extent_buffer *eb; 81656bec294SChris Mason int ret; 81784234f3aSYan Zheng 81856bec294SChris Mason ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); 81949b25e05SJeff Mahoney if (ret) 82049b25e05SJeff Mahoney return ret; 82187ef2bb4SChris Mason 82284234f3aSYan Zheng eb = btrfs_lock_root_node(fs_info->tree_root); 82349b25e05SJeff Mahoney ret = btrfs_cow_block(trans, fs_info->tree_root, eb, NULL, 82449b25e05SJeff Mahoney 0, &eb); 82584234f3aSYan Zheng btrfs_tree_unlock(eb); 82684234f3aSYan Zheng free_extent_buffer(eb); 8270b86a832SChris Mason 82849b25e05SJeff Mahoney if (ret) 82949b25e05SJeff Mahoney return ret; 83049b25e05SJeff Mahoney 83156bec294SChris Mason ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); 83249b25e05SJeff Mahoney if (ret) 83349b25e05SJeff Mahoney return ret; 83487ef2bb4SChris Mason 835733f4fbbSStefan Behrens ret = btrfs_run_dev_stats(trans, root->fs_info); 836733f4fbbSStefan Behrens BUG_ON(ret); 837733f4fbbSStefan Behrens 838546adb0dSJan Schmidt ret = btrfs_run_qgroups(trans, root->fs_info); 839546adb0dSJan Schmidt BUG_ON(ret); 840546adb0dSJan Schmidt 841546adb0dSJan Schmidt /* run_qgroups might have added some more refs */ 842546adb0dSJan Schmidt ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); 843546adb0dSJan Schmidt BUG_ON(ret); 844546adb0dSJan Schmidt 8450b86a832SChris Mason while (!list_empty(&fs_info->dirty_cowonly_roots)) { 8460b86a832SChris Mason next = fs_info->dirty_cowonly_roots.next; 8470b86a832SChris Mason list_del_init(next); 8480b86a832SChris Mason root = list_entry(next, struct btrfs_root, dirty_list); 84987ef2bb4SChris Mason 85049b25e05SJeff Mahoney ret = update_cowonly_root(trans, root); 85149b25e05SJeff Mahoney if (ret) 85249b25e05SJeff Mahoney return ret; 85379154b1bSChris Mason } 854276e680dSYan Zheng 855276e680dSYan Zheng down_write(&fs_info->extent_commit_sem); 856276e680dSYan Zheng switch_commit_root(fs_info->extent_root); 857276e680dSYan Zheng up_write(&fs_info->extent_commit_sem); 858276e680dSYan Zheng 85979154b1bSChris Mason return 0; 86079154b1bSChris Mason } 86179154b1bSChris Mason 862d352ac68SChris Mason /* 863d352ac68SChris Mason * dead roots are old snapshots that need to be deleted. This allocates 864d352ac68SChris Mason * a dirty root struct and adds it into the list of dead roots that need to 865d352ac68SChris Mason * be deleted 866d352ac68SChris Mason */ 8675d4f98a2SYan Zheng int btrfs_add_dead_root(struct btrfs_root *root) 8685eda7b5eSChris Mason { 869a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 8705d4f98a2SYan Zheng list_add(&root->root_list, &root->fs_info->dead_roots); 871a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 8725eda7b5eSChris Mason return 0; 8735eda7b5eSChris Mason } 8745eda7b5eSChris Mason 875d352ac68SChris Mason /* 8765d4f98a2SYan Zheng * update all the cowonly tree roots on disk 877d352ac68SChris Mason */ 8785d4f98a2SYan Zheng static noinline int commit_fs_roots(struct btrfs_trans_handle *trans, 8795d4f98a2SYan Zheng struct btrfs_root *root) 8800f7d52f4SChris Mason { 8810f7d52f4SChris Mason struct btrfs_root *gang[8]; 8825d4f98a2SYan Zheng struct btrfs_fs_info *fs_info = root->fs_info; 8830f7d52f4SChris Mason int i; 8840f7d52f4SChris Mason int ret; 88554aa1f4dSChris Mason int err = 0; 88654aa1f4dSChris Mason 887a4abeea4SJosef Bacik spin_lock(&fs_info->fs_roots_radix_lock); 8880f7d52f4SChris Mason while (1) { 8895d4f98a2SYan Zheng ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix, 8905d4f98a2SYan Zheng (void **)gang, 0, 8910f7d52f4SChris Mason ARRAY_SIZE(gang), 8920f7d52f4SChris Mason BTRFS_ROOT_TRANS_TAG); 8930f7d52f4SChris Mason if (ret == 0) 8940f7d52f4SChris Mason break; 8950f7d52f4SChris Mason for (i = 0; i < ret; i++) { 8960f7d52f4SChris Mason root = gang[i]; 8975d4f98a2SYan Zheng radix_tree_tag_clear(&fs_info->fs_roots_radix, 8982619ba1fSChris Mason (unsigned long)root->root_key.objectid, 8990f7d52f4SChris Mason BTRFS_ROOT_TRANS_TAG); 900a4abeea4SJosef Bacik spin_unlock(&fs_info->fs_roots_radix_lock); 90131153d81SYan Zheng 902e02119d5SChris Mason btrfs_free_log(trans, root); 9035d4f98a2SYan Zheng btrfs_update_reloc_root(trans, root); 904d68fc57bSYan, Zheng btrfs_orphan_commit_root(trans, root); 905e02119d5SChris Mason 90682d5902dSLi Zefan btrfs_save_ino_cache(root, trans); 90782d5902dSLi Zefan 908f1ebcc74SLiu Bo /* see comments in should_cow_block() */ 909f1ebcc74SLiu Bo root->force_cow = 0; 910f1ebcc74SLiu Bo smp_wmb(); 911f1ebcc74SLiu Bo 912978d910dSYan Zheng if (root->commit_root != root->node) { 913581bb050SLi Zefan mutex_lock(&root->fs_commit_mutex); 914817d52f8SJosef Bacik switch_commit_root(root); 915581bb050SLi Zefan btrfs_unpin_free_ino(root); 916581bb050SLi Zefan mutex_unlock(&root->fs_commit_mutex); 917581bb050SLi Zefan 918978d910dSYan Zheng btrfs_set_root_node(&root->root_item, 919978d910dSYan Zheng root->node); 920978d910dSYan Zheng } 92131153d81SYan Zheng 9225d4f98a2SYan Zheng err = btrfs_update_root(trans, fs_info->tree_root, 9230f7d52f4SChris Mason &root->root_key, 9240f7d52f4SChris Mason &root->root_item); 925a4abeea4SJosef Bacik spin_lock(&fs_info->fs_roots_radix_lock); 92654aa1f4dSChris Mason if (err) 92754aa1f4dSChris Mason break; 9280f7d52f4SChris Mason } 9299f3a7427SChris Mason } 930a4abeea4SJosef Bacik spin_unlock(&fs_info->fs_roots_radix_lock); 93154aa1f4dSChris Mason return err; 9320f7d52f4SChris Mason } 9330f7d52f4SChris Mason 934d352ac68SChris Mason /* 935d352ac68SChris Mason * defrag a given btree. If cacheonly == 1, this won't read from the disk, 936d352ac68SChris Mason * otherwise every leaf in the btree is read and defragged. 937d352ac68SChris Mason */ 938e9d0b13bSChris Mason int btrfs_defrag_root(struct btrfs_root *root, int cacheonly) 939e9d0b13bSChris Mason { 940e9d0b13bSChris Mason struct btrfs_fs_info *info = root->fs_info; 941e9d0b13bSChris Mason struct btrfs_trans_handle *trans; 9428929ecfaSYan, Zheng int ret; 943d3c2fdcfSChris Mason unsigned long nr; 944e9d0b13bSChris Mason 9458929ecfaSYan, Zheng if (xchg(&root->defrag_running, 1)) 946e9d0b13bSChris Mason return 0; 9478929ecfaSYan, Zheng 9486b80053dSChris Mason while (1) { 9498929ecfaSYan, Zheng trans = btrfs_start_transaction(root, 0); 9508929ecfaSYan, Zheng if (IS_ERR(trans)) 9518929ecfaSYan, Zheng return PTR_ERR(trans); 9528929ecfaSYan, Zheng 953e9d0b13bSChris Mason ret = btrfs_defrag_leaves(trans, root, cacheonly); 9548929ecfaSYan, Zheng 955d3c2fdcfSChris Mason nr = trans->blocks_used; 956e9d0b13bSChris Mason btrfs_end_transaction(trans, root); 957d3c2fdcfSChris Mason btrfs_btree_balance_dirty(info->tree_root, nr); 958e9d0b13bSChris Mason cond_resched(); 959e9d0b13bSChris Mason 9607841cb28SDavid Sterba if (btrfs_fs_closing(root->fs_info) || ret != -EAGAIN) 961e9d0b13bSChris Mason break; 962e9d0b13bSChris Mason } 963e9d0b13bSChris Mason root->defrag_running = 0; 9648929ecfaSYan, Zheng return ret; 965e9d0b13bSChris Mason } 966e9d0b13bSChris Mason 967d352ac68SChris Mason /* 968d352ac68SChris Mason * new snapshots need to be created at a very specific time in the 969d352ac68SChris Mason * transaction commit. This does the actual creation 970d352ac68SChris Mason */ 97180b6794dSChris Mason static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans, 9723063d29fSChris Mason struct btrfs_fs_info *fs_info, 9733063d29fSChris Mason struct btrfs_pending_snapshot *pending) 9743063d29fSChris Mason { 9753063d29fSChris Mason struct btrfs_key key; 97680b6794dSChris Mason struct btrfs_root_item *new_root_item; 9773063d29fSChris Mason struct btrfs_root *tree_root = fs_info->tree_root; 9783063d29fSChris Mason struct btrfs_root *root = pending->root; 9796bdb72deSSage Weil struct btrfs_root *parent_root; 98098c9942aSLiu Bo struct btrfs_block_rsv *rsv; 9816bdb72deSSage Weil struct inode *parent_inode; 98242874b3dSMiao Xie struct btrfs_path *path; 98342874b3dSMiao Xie struct btrfs_dir_item *dir_item; 9846a912213SJosef Bacik struct dentry *parent; 985a22285a6SYan, Zheng struct dentry *dentry; 9863063d29fSChris Mason struct extent_buffer *tmp; 987925baeddSChris Mason struct extent_buffer *old; 9888ea05e3aSAlexander Block struct timespec cur_time = CURRENT_TIME; 9893063d29fSChris Mason int ret; 990d68fc57bSYan, Zheng u64 to_reserve = 0; 9916bdb72deSSage Weil u64 index = 0; 992a22285a6SYan, Zheng u64 objectid; 993b83cc969SLi Zefan u64 root_flags; 9948ea05e3aSAlexander Block uuid_le new_uuid; 9953063d29fSChris Mason 99642874b3dSMiao Xie path = btrfs_alloc_path(); 99742874b3dSMiao Xie if (!path) { 99842874b3dSMiao Xie ret = pending->error = -ENOMEM; 99942874b3dSMiao Xie goto path_alloc_fail; 100042874b3dSMiao Xie } 100142874b3dSMiao Xie 100280b6794dSChris Mason new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS); 100380b6794dSChris Mason if (!new_root_item) { 100449b25e05SJeff Mahoney ret = pending->error = -ENOMEM; 10056fa9700eSMiao Xie goto root_item_alloc_fail; 100680b6794dSChris Mason } 1007a22285a6SYan, Zheng 1008581bb050SLi Zefan ret = btrfs_find_free_objectid(tree_root, &objectid); 1009a22285a6SYan, Zheng if (ret) { 1010a22285a6SYan, Zheng pending->error = ret; 10116fa9700eSMiao Xie goto no_free_objectid; 1012a22285a6SYan, Zheng } 10133063d29fSChris Mason 10143fd0a558SYan, Zheng btrfs_reloc_pre_snapshot(trans, pending, &to_reserve); 1015d68fc57bSYan, Zheng 1016d68fc57bSYan, Zheng if (to_reserve > 0) { 101762f30c54SMiao Xie ret = btrfs_block_rsv_add_noflush(root, &pending->block_rsv, 10188bb8ab2eSJosef Bacik to_reserve); 1019d68fc57bSYan, Zheng if (ret) { 1020d68fc57bSYan, Zheng pending->error = ret; 10216fa9700eSMiao Xie goto no_free_objectid; 1022d68fc57bSYan, Zheng } 1023d68fc57bSYan, Zheng } 1024d68fc57bSYan, Zheng 10256f72c7e2SArne Jansen ret = btrfs_qgroup_inherit(trans, fs_info, root->root_key.objectid, 10266f72c7e2SArne Jansen objectid, pending->inherit); 10276f72c7e2SArne Jansen if (ret) { 10286f72c7e2SArne Jansen pending->error = ret; 10296fa9700eSMiao Xie goto no_free_objectid; 10306f72c7e2SArne Jansen } 10316f72c7e2SArne Jansen 10323063d29fSChris Mason key.objectid = objectid; 1033a22285a6SYan, Zheng key.offset = (u64)-1; 1034a22285a6SYan, Zheng key.type = BTRFS_ROOT_ITEM_KEY; 10353063d29fSChris Mason 10366fa9700eSMiao Xie rsv = trans->block_rsv; 1037a22285a6SYan, Zheng trans->block_rsv = &pending->block_rsv; 10386bdb72deSSage Weil 1039a22285a6SYan, Zheng dentry = pending->dentry; 10406a912213SJosef Bacik parent = dget_parent(dentry); 10416a912213SJosef Bacik parent_inode = parent->d_inode; 1042a22285a6SYan, Zheng parent_root = BTRFS_I(parent_inode)->root; 10437585717fSChris Mason record_root_in_trans(trans, parent_root); 1044a22285a6SYan, Zheng 10456bdb72deSSage Weil /* 10466bdb72deSSage Weil * insert the directory item 10476bdb72deSSage Weil */ 10486bdb72deSSage Weil ret = btrfs_set_inode_index(parent_inode, &index); 104949b25e05SJeff Mahoney BUG_ON(ret); /* -ENOMEM */ 105042874b3dSMiao Xie 105142874b3dSMiao Xie /* check if there is a file/dir which has the same name. */ 105242874b3dSMiao Xie dir_item = btrfs_lookup_dir_item(NULL, parent_root, path, 105342874b3dSMiao Xie btrfs_ino(parent_inode), 105442874b3dSMiao Xie dentry->d_name.name, 105542874b3dSMiao Xie dentry->d_name.len, 0); 105642874b3dSMiao Xie if (dir_item != NULL && !IS_ERR(dir_item)) { 1057fe66a05aSChris Mason pending->error = -EEXIST; 1058fe66a05aSChris Mason goto fail; 105942874b3dSMiao Xie } else if (IS_ERR(dir_item)) { 106042874b3dSMiao Xie ret = PTR_ERR(dir_item); 10618732d44fSMiao Xie btrfs_abort_transaction(trans, root, ret); 10628732d44fSMiao Xie goto fail; 106379787eaaSJeff Mahoney } 106442874b3dSMiao Xie btrfs_release_path(path); 10656bdb72deSSage Weil 1066e999376fSChris Mason /* 1067e999376fSChris Mason * pull in the delayed directory update 1068e999376fSChris Mason * and the delayed inode item 1069e999376fSChris Mason * otherwise we corrupt the FS during 1070e999376fSChris Mason * snapshot 1071e999376fSChris Mason */ 1072e999376fSChris Mason ret = btrfs_run_delayed_items(trans, root); 10738732d44fSMiao Xie if (ret) { /* Transaction aborted */ 10748732d44fSMiao Xie btrfs_abort_transaction(trans, root, ret); 10758732d44fSMiao Xie goto fail; 10768732d44fSMiao Xie } 1077e999376fSChris Mason 10787585717fSChris Mason record_root_in_trans(trans, root); 10796bdb72deSSage Weil btrfs_set_root_last_snapshot(&root->root_item, trans->transid); 10806bdb72deSSage Weil memcpy(new_root_item, &root->root_item, sizeof(*new_root_item)); 108108fe4db1SLi Zefan btrfs_check_and_init_root_item(new_root_item); 10826bdb72deSSage Weil 1083b83cc969SLi Zefan root_flags = btrfs_root_flags(new_root_item); 1084b83cc969SLi Zefan if (pending->readonly) 1085b83cc969SLi Zefan root_flags |= BTRFS_ROOT_SUBVOL_RDONLY; 1086b83cc969SLi Zefan else 1087b83cc969SLi Zefan root_flags &= ~BTRFS_ROOT_SUBVOL_RDONLY; 1088b83cc969SLi Zefan btrfs_set_root_flags(new_root_item, root_flags); 1089b83cc969SLi Zefan 10908ea05e3aSAlexander Block btrfs_set_root_generation_v2(new_root_item, 10918ea05e3aSAlexander Block trans->transid); 10928ea05e3aSAlexander Block uuid_le_gen(&new_uuid); 10938ea05e3aSAlexander Block memcpy(new_root_item->uuid, new_uuid.b, BTRFS_UUID_SIZE); 10948ea05e3aSAlexander Block memcpy(new_root_item->parent_uuid, root->root_item.uuid, 10958ea05e3aSAlexander Block BTRFS_UUID_SIZE); 10968ea05e3aSAlexander Block new_root_item->otime.sec = cpu_to_le64(cur_time.tv_sec); 1097dadd1105SDan Carpenter new_root_item->otime.nsec = cpu_to_le32(cur_time.tv_nsec); 10988ea05e3aSAlexander Block btrfs_set_root_otransid(new_root_item, trans->transid); 10998ea05e3aSAlexander Block memset(&new_root_item->stime, 0, sizeof(new_root_item->stime)); 11008ea05e3aSAlexander Block memset(&new_root_item->rtime, 0, sizeof(new_root_item->rtime)); 11018ea05e3aSAlexander Block btrfs_set_root_stransid(new_root_item, 0); 11028ea05e3aSAlexander Block btrfs_set_root_rtransid(new_root_item, 0); 11038ea05e3aSAlexander Block 1104925baeddSChris Mason old = btrfs_lock_root_node(root); 110549b25e05SJeff Mahoney ret = btrfs_cow_block(trans, root, old, NULL, 0, &old); 110679787eaaSJeff Mahoney if (ret) { 110779787eaaSJeff Mahoney btrfs_tree_unlock(old); 110879787eaaSJeff Mahoney free_extent_buffer(old); 11098732d44fSMiao Xie btrfs_abort_transaction(trans, root, ret); 11108732d44fSMiao Xie goto fail; 111179787eaaSJeff Mahoney } 111249b25e05SJeff Mahoney 11135d4f98a2SYan Zheng btrfs_set_lock_blocking(old); 11143063d29fSChris Mason 111549b25e05SJeff Mahoney ret = btrfs_copy_root(trans, root, old, &tmp, objectid); 111679787eaaSJeff Mahoney /* clean up in any case */ 1117925baeddSChris Mason btrfs_tree_unlock(old); 1118925baeddSChris Mason free_extent_buffer(old); 11198732d44fSMiao Xie if (ret) { 11208732d44fSMiao Xie btrfs_abort_transaction(trans, root, ret); 11218732d44fSMiao Xie goto fail; 11228732d44fSMiao Xie } 11233063d29fSChris Mason 1124f1ebcc74SLiu Bo /* see comments in should_cow_block() */ 1125f1ebcc74SLiu Bo root->force_cow = 1; 1126f1ebcc74SLiu Bo smp_wmb(); 1127f1ebcc74SLiu Bo 11285d4f98a2SYan Zheng btrfs_set_root_node(new_root_item, tmp); 1129a22285a6SYan, Zheng /* record when the snapshot was created in key.offset */ 1130a22285a6SYan, Zheng key.offset = trans->transid; 1131a22285a6SYan, Zheng ret = btrfs_insert_root(trans, tree_root, &key, new_root_item); 1132925baeddSChris Mason btrfs_tree_unlock(tmp); 11333063d29fSChris Mason free_extent_buffer(tmp); 11348732d44fSMiao Xie if (ret) { 11358732d44fSMiao Xie btrfs_abort_transaction(trans, root, ret); 11368732d44fSMiao Xie goto fail; 11378732d44fSMiao Xie } 11380660b5afSChris Mason 1139a22285a6SYan, Zheng /* 1140a22285a6SYan, Zheng * insert root back/forward references 1141a22285a6SYan, Zheng */ 1142a22285a6SYan, Zheng ret = btrfs_add_root_ref(trans, tree_root, objectid, 1143a22285a6SYan, Zheng parent_root->root_key.objectid, 114433345d01SLi Zefan btrfs_ino(parent_inode), index, 1145a22285a6SYan, Zheng dentry->d_name.name, dentry->d_name.len); 11468732d44fSMiao Xie if (ret) { 11478732d44fSMiao Xie btrfs_abort_transaction(trans, root, ret); 11488732d44fSMiao Xie goto fail; 11498732d44fSMiao Xie } 1150a22285a6SYan, Zheng 1151a22285a6SYan, Zheng key.offset = (u64)-1; 1152a22285a6SYan, Zheng pending->snap = btrfs_read_fs_root_no_name(root->fs_info, &key); 115379787eaaSJeff Mahoney if (IS_ERR(pending->snap)) { 115479787eaaSJeff Mahoney ret = PTR_ERR(pending->snap); 11558732d44fSMiao Xie btrfs_abort_transaction(trans, root, ret); 11568732d44fSMiao Xie goto fail; 115779787eaaSJeff Mahoney } 1158d68fc57bSYan, Zheng 115949b25e05SJeff Mahoney ret = btrfs_reloc_post_snapshot(trans, pending); 11608732d44fSMiao Xie if (ret) { 11618732d44fSMiao Xie btrfs_abort_transaction(trans, root, ret); 11628732d44fSMiao Xie goto fail; 11638732d44fSMiao Xie } 1164361048f5SMiao Xie 1165361048f5SMiao Xie ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); 11668732d44fSMiao Xie if (ret) { 11678732d44fSMiao Xie btrfs_abort_transaction(trans, root, ret); 11688732d44fSMiao Xie goto fail; 11698732d44fSMiao Xie } 117042874b3dSMiao Xie 117142874b3dSMiao Xie ret = btrfs_insert_dir_item(trans, parent_root, 117242874b3dSMiao Xie dentry->d_name.name, dentry->d_name.len, 117342874b3dSMiao Xie parent_inode, &key, 117442874b3dSMiao Xie BTRFS_FT_DIR, index); 117542874b3dSMiao Xie /* We have check then name at the beginning, so it is impossible. */ 117642874b3dSMiao Xie BUG_ON(ret == -EEXIST); 11778732d44fSMiao Xie if (ret) { 11788732d44fSMiao Xie btrfs_abort_transaction(trans, root, ret); 11798732d44fSMiao Xie goto fail; 11808732d44fSMiao Xie } 118142874b3dSMiao Xie 118242874b3dSMiao Xie btrfs_i_size_write(parent_inode, parent_inode->i_size + 118342874b3dSMiao Xie dentry->d_name.len * 2); 118442874b3dSMiao Xie parent_inode->i_mtime = parent_inode->i_ctime = CURRENT_TIME; 118542874b3dSMiao Xie ret = btrfs_update_inode(trans, parent_root, parent_inode); 118642874b3dSMiao Xie if (ret) 11878732d44fSMiao Xie btrfs_abort_transaction(trans, root, ret); 11883063d29fSChris Mason fail: 11896fa9700eSMiao Xie dput(parent); 119098c9942aSLiu Bo trans->block_rsv = rsv; 11916fa9700eSMiao Xie no_free_objectid: 11926fa9700eSMiao Xie kfree(new_root_item); 11936fa9700eSMiao Xie root_item_alloc_fail: 119442874b3dSMiao Xie btrfs_free_path(path); 119542874b3dSMiao Xie path_alloc_fail: 1196a22285a6SYan, Zheng btrfs_block_rsv_release(root, &pending->block_rsv, (u64)-1); 119749b25e05SJeff Mahoney return ret; 11983063d29fSChris Mason } 11993063d29fSChris Mason 1200d352ac68SChris Mason /* 1201d352ac68SChris Mason * create all the snapshots we've scheduled for creation 1202d352ac68SChris Mason */ 120380b6794dSChris Mason static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans, 12043063d29fSChris Mason struct btrfs_fs_info *fs_info) 12053063d29fSChris Mason { 12063063d29fSChris Mason struct btrfs_pending_snapshot *pending; 12073063d29fSChris Mason struct list_head *head = &trans->transaction->pending_snapshots; 12083de4586cSChris Mason 1209fe66a05aSChris Mason list_for_each_entry(pending, head, list) 1210fe66a05aSChris Mason create_pending_snapshot(trans, fs_info, pending); 12113de4586cSChris Mason return 0; 12123de4586cSChris Mason } 12133de4586cSChris Mason 12145d4f98a2SYan Zheng static void update_super_roots(struct btrfs_root *root) 12155d4f98a2SYan Zheng { 12165d4f98a2SYan Zheng struct btrfs_root_item *root_item; 12175d4f98a2SYan Zheng struct btrfs_super_block *super; 12185d4f98a2SYan Zheng 12196c41761fSDavid Sterba super = root->fs_info->super_copy; 12205d4f98a2SYan Zheng 12215d4f98a2SYan Zheng root_item = &root->fs_info->chunk_root->root_item; 12225d4f98a2SYan Zheng super->chunk_root = root_item->bytenr; 12235d4f98a2SYan Zheng super->chunk_root_generation = root_item->generation; 12245d4f98a2SYan Zheng super->chunk_root_level = root_item->level; 12255d4f98a2SYan Zheng 12265d4f98a2SYan Zheng root_item = &root->fs_info->tree_root->root_item; 12275d4f98a2SYan Zheng super->root = root_item->bytenr; 12285d4f98a2SYan Zheng super->generation = root_item->generation; 12295d4f98a2SYan Zheng super->root_level = root_item->level; 123073bc1876SJosef Bacik if (btrfs_test_opt(root, SPACE_CACHE)) 12310af3d00bSJosef Bacik super->cache_generation = root_item->generation; 12325d4f98a2SYan Zheng } 12335d4f98a2SYan Zheng 1234f36f3042SChris Mason int btrfs_transaction_in_commit(struct btrfs_fs_info *info) 1235f36f3042SChris Mason { 1236f36f3042SChris Mason int ret = 0; 1237a4abeea4SJosef Bacik spin_lock(&info->trans_lock); 1238f36f3042SChris Mason if (info->running_transaction) 1239f36f3042SChris Mason ret = info->running_transaction->in_commit; 1240a4abeea4SJosef Bacik spin_unlock(&info->trans_lock); 1241f36f3042SChris Mason return ret; 1242f36f3042SChris Mason } 1243f36f3042SChris Mason 12448929ecfaSYan, Zheng int btrfs_transaction_blocked(struct btrfs_fs_info *info) 12458929ecfaSYan, Zheng { 12468929ecfaSYan, Zheng int ret = 0; 1247a4abeea4SJosef Bacik spin_lock(&info->trans_lock); 12488929ecfaSYan, Zheng if (info->running_transaction) 12498929ecfaSYan, Zheng ret = info->running_transaction->blocked; 1250a4abeea4SJosef Bacik spin_unlock(&info->trans_lock); 12518929ecfaSYan, Zheng return ret; 12528929ecfaSYan, Zheng } 12538929ecfaSYan, Zheng 1254bb9c12c9SSage Weil /* 1255bb9c12c9SSage Weil * wait for the current transaction commit to start and block subsequent 1256bb9c12c9SSage Weil * transaction joins 1257bb9c12c9SSage Weil */ 1258bb9c12c9SSage Weil static void wait_current_trans_commit_start(struct btrfs_root *root, 1259bb9c12c9SSage Weil struct btrfs_transaction *trans) 1260bb9c12c9SSage Weil { 126172d63ed6SLi Zefan wait_event(root->fs_info->transaction_blocked_wait, trans->in_commit); 1262bb9c12c9SSage Weil } 1263bb9c12c9SSage Weil 1264bb9c12c9SSage Weil /* 1265bb9c12c9SSage Weil * wait for the current transaction to start and then become unblocked. 1266bb9c12c9SSage Weil * caller holds ref. 1267bb9c12c9SSage Weil */ 1268bb9c12c9SSage Weil static void wait_current_trans_commit_start_and_unblock(struct btrfs_root *root, 1269bb9c12c9SSage Weil struct btrfs_transaction *trans) 1270bb9c12c9SSage Weil { 127172d63ed6SLi Zefan wait_event(root->fs_info->transaction_wait, 127272d63ed6SLi Zefan trans->commit_done || (trans->in_commit && !trans->blocked)); 1273bb9c12c9SSage Weil } 1274bb9c12c9SSage Weil 1275bb9c12c9SSage Weil /* 1276bb9c12c9SSage Weil * commit transactions asynchronously. once btrfs_commit_transaction_async 1277bb9c12c9SSage Weil * returns, any subsequent transaction will not be allowed to join. 1278bb9c12c9SSage Weil */ 1279bb9c12c9SSage Weil struct btrfs_async_commit { 1280bb9c12c9SSage Weil struct btrfs_trans_handle *newtrans; 1281bb9c12c9SSage Weil struct btrfs_root *root; 1282bb9c12c9SSage Weil struct delayed_work work; 1283bb9c12c9SSage Weil }; 1284bb9c12c9SSage Weil 1285bb9c12c9SSage Weil static void do_async_commit(struct work_struct *work) 1286bb9c12c9SSage Weil { 1287bb9c12c9SSage Weil struct btrfs_async_commit *ac = 1288bb9c12c9SSage Weil container_of(work, struct btrfs_async_commit, work.work); 1289bb9c12c9SSage Weil 12906fc4e354SSage Weil /* 12916fc4e354SSage Weil * We've got freeze protection passed with the transaction. 12926fc4e354SSage Weil * Tell lockdep about it. 12936fc4e354SSage Weil */ 12946fc4e354SSage Weil rwsem_acquire_read( 12956fc4e354SSage Weil &ac->root->fs_info->sb->s_writers.lock_map[SB_FREEZE_FS-1], 12966fc4e354SSage Weil 0, 1, _THIS_IP_); 12976fc4e354SSage Weil 1298e209db7aSSage Weil current->journal_info = ac->newtrans; 1299e209db7aSSage Weil 1300bb9c12c9SSage Weil btrfs_commit_transaction(ac->newtrans, ac->root); 1301bb9c12c9SSage Weil kfree(ac); 1302bb9c12c9SSage Weil } 1303bb9c12c9SSage Weil 1304bb9c12c9SSage Weil int btrfs_commit_transaction_async(struct btrfs_trans_handle *trans, 1305bb9c12c9SSage Weil struct btrfs_root *root, 1306bb9c12c9SSage Weil int wait_for_unblock) 1307bb9c12c9SSage Weil { 1308bb9c12c9SSage Weil struct btrfs_async_commit *ac; 1309bb9c12c9SSage Weil struct btrfs_transaction *cur_trans; 1310bb9c12c9SSage Weil 1311bb9c12c9SSage Weil ac = kmalloc(sizeof(*ac), GFP_NOFS); 1312db5b493aSTsutomu Itoh if (!ac) 1313db5b493aSTsutomu Itoh return -ENOMEM; 1314bb9c12c9SSage Weil 1315bb9c12c9SSage Weil INIT_DELAYED_WORK(&ac->work, do_async_commit); 1316bb9c12c9SSage Weil ac->root = root; 13177a7eaa40SJosef Bacik ac->newtrans = btrfs_join_transaction(root); 13183612b495STsutomu Itoh if (IS_ERR(ac->newtrans)) { 13193612b495STsutomu Itoh int err = PTR_ERR(ac->newtrans); 13203612b495STsutomu Itoh kfree(ac); 13213612b495STsutomu Itoh return err; 13223612b495STsutomu Itoh } 1323bb9c12c9SSage Weil 1324bb9c12c9SSage Weil /* take transaction reference */ 1325bb9c12c9SSage Weil cur_trans = trans->transaction; 132613c5a93eSJosef Bacik atomic_inc(&cur_trans->use_count); 1327bb9c12c9SSage Weil 1328bb9c12c9SSage Weil btrfs_end_transaction(trans, root); 13296fc4e354SSage Weil 13306fc4e354SSage Weil /* 13316fc4e354SSage Weil * Tell lockdep we've released the freeze rwsem, since the 13326fc4e354SSage Weil * async commit thread will be the one to unlock it. 13336fc4e354SSage Weil */ 13346fc4e354SSage Weil rwsem_release(&root->fs_info->sb->s_writers.lock_map[SB_FREEZE_FS-1], 13356fc4e354SSage Weil 1, _THIS_IP_); 13366fc4e354SSage Weil 1337bb9c12c9SSage Weil schedule_delayed_work(&ac->work, 0); 1338bb9c12c9SSage Weil 1339bb9c12c9SSage Weil /* wait for transaction to start and unblock */ 1340bb9c12c9SSage Weil if (wait_for_unblock) 1341bb9c12c9SSage Weil wait_current_trans_commit_start_and_unblock(root, cur_trans); 1342bb9c12c9SSage Weil else 1343bb9c12c9SSage Weil wait_current_trans_commit_start(root, cur_trans); 1344bb9c12c9SSage Weil 134538e88054SSage Weil if (current->journal_info == trans) 134638e88054SSage Weil current->journal_info = NULL; 134738e88054SSage Weil 134838e88054SSage Weil put_transaction(cur_trans); 1349bb9c12c9SSage Weil return 0; 1350bb9c12c9SSage Weil } 1351bb9c12c9SSage Weil 135249b25e05SJeff Mahoney 135349b25e05SJeff Mahoney static void cleanup_transaction(struct btrfs_trans_handle *trans, 13547b8b92afSJosef Bacik struct btrfs_root *root, int err) 135549b25e05SJeff Mahoney { 135649b25e05SJeff Mahoney struct btrfs_transaction *cur_trans = trans->transaction; 135749b25e05SJeff Mahoney 135849b25e05SJeff Mahoney WARN_ON(trans->use_count > 1); 135949b25e05SJeff Mahoney 13607b8b92afSJosef Bacik btrfs_abort_transaction(trans, root, err); 13617b8b92afSJosef Bacik 136249b25e05SJeff Mahoney spin_lock(&root->fs_info->trans_lock); 136349b25e05SJeff Mahoney list_del_init(&cur_trans->list); 1364d7096fc3SJosef Bacik if (cur_trans == root->fs_info->running_transaction) { 1365d7096fc3SJosef Bacik root->fs_info->running_transaction = NULL; 1366d7096fc3SJosef Bacik root->fs_info->trans_no_join = 0; 1367d7096fc3SJosef Bacik } 136849b25e05SJeff Mahoney spin_unlock(&root->fs_info->trans_lock); 136949b25e05SJeff Mahoney 137049b25e05SJeff Mahoney btrfs_cleanup_one_transaction(trans->transaction, root); 137149b25e05SJeff Mahoney 137249b25e05SJeff Mahoney put_transaction(cur_trans); 137349b25e05SJeff Mahoney put_transaction(cur_trans); 137449b25e05SJeff Mahoney 137549b25e05SJeff Mahoney trace_btrfs_transaction_commit(root); 137649b25e05SJeff Mahoney 137749b25e05SJeff Mahoney btrfs_scrub_continue(root); 137849b25e05SJeff Mahoney 137949b25e05SJeff Mahoney if (current->journal_info == trans) 138049b25e05SJeff Mahoney current->journal_info = NULL; 138149b25e05SJeff Mahoney 138249b25e05SJeff Mahoney kmem_cache_free(btrfs_trans_handle_cachep, trans); 138349b25e05SJeff Mahoney } 138449b25e05SJeff Mahoney 1385bb9c12c9SSage Weil /* 1386bb9c12c9SSage Weil * btrfs_transaction state sequence: 1387bb9c12c9SSage Weil * in_commit = 0, blocked = 0 (initial) 1388bb9c12c9SSage Weil * in_commit = 1, blocked = 1 1389bb9c12c9SSage Weil * blocked = 0 1390bb9c12c9SSage Weil * commit_done = 1 1391bb9c12c9SSage Weil */ 139279154b1bSChris Mason int btrfs_commit_transaction(struct btrfs_trans_handle *trans, 139379154b1bSChris Mason struct btrfs_root *root) 139479154b1bSChris Mason { 139515ee9bc7SJosef Bacik unsigned long joined = 0; 139649b25e05SJeff Mahoney struct btrfs_transaction *cur_trans = trans->transaction; 13978fd17795SChris Mason struct btrfs_transaction *prev_trans = NULL; 139879154b1bSChris Mason DEFINE_WAIT(wait); 139949b25e05SJeff Mahoney int ret = -EIO; 140089573b9cSChris Mason int should_grow = 0; 140189573b9cSChris Mason unsigned long now = get_seconds(); 1402dccae999SSage Weil int flush_on_commit = btrfs_test_opt(root, FLUSHONCOMMIT); 140379154b1bSChris Mason 14045a3f23d5SChris Mason btrfs_run_ordered_operations(root, 0); 14055a3f23d5SChris Mason 140649b25e05SJeff Mahoney if (cur_trans->aborted) 140749b25e05SJeff Mahoney goto cleanup_transaction; 140849b25e05SJeff Mahoney 140956bec294SChris Mason /* make a pass through all the delayed refs we have so far 141056bec294SChris Mason * any runnings procs may add more while we are here 141156bec294SChris Mason */ 141256bec294SChris Mason ret = btrfs_run_delayed_refs(trans, root, 0); 141349b25e05SJeff Mahoney if (ret) 141449b25e05SJeff Mahoney goto cleanup_transaction; 141556bec294SChris Mason 14160e721106SJosef Bacik btrfs_trans_release_metadata(trans, root); 14170e721106SJosef Bacik trans->block_rsv = NULL; 14180e721106SJosef Bacik 1419b7ec40d7SChris Mason cur_trans = trans->transaction; 142049b25e05SJeff Mahoney 142156bec294SChris Mason /* 142256bec294SChris Mason * set the flushing flag so procs in this transaction have to 142356bec294SChris Mason * start sending their work down. 142456bec294SChris Mason */ 1425b7ec40d7SChris Mason cur_trans->delayed_refs.flushing = 1; 142656bec294SChris Mason 1427ea658badSJosef Bacik if (!list_empty(&trans->new_bgs)) 1428ea658badSJosef Bacik btrfs_create_pending_block_groups(trans, root); 1429ea658badSJosef Bacik 1430c3e69d58SChris Mason ret = btrfs_run_delayed_refs(trans, root, 0); 143149b25e05SJeff Mahoney if (ret) 143249b25e05SJeff Mahoney goto cleanup_transaction; 143356bec294SChris Mason 1434a4abeea4SJosef Bacik spin_lock(&cur_trans->commit_lock); 1435b7ec40d7SChris Mason if (cur_trans->in_commit) { 1436a4abeea4SJosef Bacik spin_unlock(&cur_trans->commit_lock); 143713c5a93eSJosef Bacik atomic_inc(&cur_trans->use_count); 143849b25e05SJeff Mahoney ret = btrfs_end_transaction(trans, root); 1439ccd467d6SChris Mason 1440b9c8300cSLi Zefan wait_for_commit(root, cur_trans); 144115ee9bc7SJosef Bacik 144279154b1bSChris Mason put_transaction(cur_trans); 144315ee9bc7SJosef Bacik 144449b25e05SJeff Mahoney return ret; 144579154b1bSChris Mason } 14464313b399SChris Mason 14472c90e5d6SChris Mason trans->transaction->in_commit = 1; 1448f9295749SChris Mason trans->transaction->blocked = 1; 1449a4abeea4SJosef Bacik spin_unlock(&cur_trans->commit_lock); 1450bb9c12c9SSage Weil wake_up(&root->fs_info->transaction_blocked_wait); 1451bb9c12c9SSage Weil 1452a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 1453ccd467d6SChris Mason if (cur_trans->list.prev != &root->fs_info->trans_list) { 1454ccd467d6SChris Mason prev_trans = list_entry(cur_trans->list.prev, 1455ccd467d6SChris Mason struct btrfs_transaction, list); 1456ccd467d6SChris Mason if (!prev_trans->commit_done) { 145713c5a93eSJosef Bacik atomic_inc(&prev_trans->use_count); 1458a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 1459ccd467d6SChris Mason 1460ccd467d6SChris Mason wait_for_commit(root, prev_trans); 1461ccd467d6SChris Mason 146215ee9bc7SJosef Bacik put_transaction(prev_trans); 1463a4abeea4SJosef Bacik } else { 1464a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 1465ccd467d6SChris Mason } 1466a4abeea4SJosef Bacik } else { 1467a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 1468ccd467d6SChris Mason } 146915ee9bc7SJosef Bacik 1470e39e64acSChris Mason if (!btrfs_test_opt(root, SSD) && 1471e39e64acSChris Mason (now < cur_trans->start_time || now - cur_trans->start_time < 1)) 147289573b9cSChris Mason should_grow = 1; 147389573b9cSChris Mason 147415ee9bc7SJosef Bacik do { 14757ea394f1SYan Zheng int snap_pending = 0; 1476a4abeea4SJosef Bacik 147715ee9bc7SJosef Bacik joined = cur_trans->num_joined; 14787ea394f1SYan Zheng if (!list_empty(&trans->transaction->pending_snapshots)) 14797ea394f1SYan Zheng snap_pending = 1; 14807ea394f1SYan Zheng 14812c90e5d6SChris Mason WARN_ON(cur_trans != trans->transaction); 148215ee9bc7SJosef Bacik 14830bdb1db2SSage Weil if (flush_on_commit || snap_pending) { 148424bbcf04SYan, Zheng btrfs_start_delalloc_inodes(root, 1); 14856bbe3a9cSLiu Bo btrfs_wait_ordered_extents(root, 1); 14867ea394f1SYan Zheng } 14877ea394f1SYan Zheng 148816cdcec7SMiao Xie ret = btrfs_run_delayed_items(trans, root); 148949b25e05SJeff Mahoney if (ret) 149049b25e05SJeff Mahoney goto cleanup_transaction; 149116cdcec7SMiao Xie 14925a3f23d5SChris Mason /* 1493edf39272SJan Schmidt * running the delayed items may have added new refs. account 1494edf39272SJan Schmidt * them now so that they hinder processing of more delayed refs 1495edf39272SJan Schmidt * as little as possible. 1496edf39272SJan Schmidt */ 1497edf39272SJan Schmidt btrfs_delayed_refs_qgroup_accounting(trans, root->fs_info); 1498edf39272SJan Schmidt 1499edf39272SJan Schmidt /* 15005a3f23d5SChris Mason * rename don't use btrfs_join_transaction, so, once we 15015a3f23d5SChris Mason * set the transaction to blocked above, we aren't going 15025a3f23d5SChris Mason * to get any new ordered operations. We can safely run 15035a3f23d5SChris Mason * it here and no for sure that nothing new will be added 15045a3f23d5SChris Mason * to the list 15055a3f23d5SChris Mason */ 15065a3f23d5SChris Mason btrfs_run_ordered_operations(root, 1); 15075a3f23d5SChris Mason 1508ed3b3d31SChris Mason prepare_to_wait(&cur_trans->writer_wait, &wait, 1509ed3b3d31SChris Mason TASK_UNINTERRUPTIBLE); 1510ed3b3d31SChris Mason 151113c5a93eSJosef Bacik if (atomic_read(&cur_trans->num_writers) > 1) 151299d16cbcSSage Weil schedule_timeout(MAX_SCHEDULE_TIMEOUT); 151399d16cbcSSage Weil else if (should_grow) 151499d16cbcSSage Weil schedule_timeout(1); 151515ee9bc7SJosef Bacik 151615ee9bc7SJosef Bacik finish_wait(&cur_trans->writer_wait, &wait); 1517ed0ca140SJosef Bacik } while (atomic_read(&cur_trans->num_writers) > 1 || 1518ed0ca140SJosef Bacik (should_grow && cur_trans->num_joined != joined)); 1519ed0ca140SJosef Bacik 1520ed0ca140SJosef Bacik /* 1521ed0ca140SJosef Bacik * Ok now we need to make sure to block out any other joins while we 1522ed0ca140SJosef Bacik * commit the transaction. We could have started a join before setting 1523ed0ca140SJosef Bacik * no_join so make sure to wait for num_writers to == 1 again. 1524ed0ca140SJosef Bacik */ 1525a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 1526a4abeea4SJosef Bacik root->fs_info->trans_no_join = 1; 1527a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 1528ed0ca140SJosef Bacik wait_event(cur_trans->writer_wait, 1529ed0ca140SJosef Bacik atomic_read(&cur_trans->num_writers) == 1); 153015ee9bc7SJosef Bacik 15317585717fSChris Mason /* 15327585717fSChris Mason * the reloc mutex makes sure that we stop 15337585717fSChris Mason * the balancing code from coming in and moving 15347585717fSChris Mason * extents around in the middle of the commit 15357585717fSChris Mason */ 15367585717fSChris Mason mutex_lock(&root->fs_info->reloc_mutex); 15377585717fSChris Mason 153842874b3dSMiao Xie /* 153942874b3dSMiao Xie * We needn't worry about the delayed items because we will 154042874b3dSMiao Xie * deal with them in create_pending_snapshot(), which is the 154142874b3dSMiao Xie * core function of the snapshot creation. 154242874b3dSMiao Xie */ 154342874b3dSMiao Xie ret = create_pending_snapshots(trans, root->fs_info); 154449b25e05SJeff Mahoney if (ret) { 154549b25e05SJeff Mahoney mutex_unlock(&root->fs_info->reloc_mutex); 154649b25e05SJeff Mahoney goto cleanup_transaction; 154749b25e05SJeff Mahoney } 15483063d29fSChris Mason 154942874b3dSMiao Xie /* 155042874b3dSMiao Xie * We insert the dir indexes of the snapshots and update the inode 155142874b3dSMiao Xie * of the snapshots' parents after the snapshot creation, so there 155242874b3dSMiao Xie * are some delayed items which are not dealt with. Now deal with 155342874b3dSMiao Xie * them. 155442874b3dSMiao Xie * 155542874b3dSMiao Xie * We needn't worry that this operation will corrupt the snapshots, 155642874b3dSMiao Xie * because all the tree which are snapshoted will be forced to COW 155742874b3dSMiao Xie * the nodes and leaves. 155842874b3dSMiao Xie */ 155942874b3dSMiao Xie ret = btrfs_run_delayed_items(trans, root); 156049b25e05SJeff Mahoney if (ret) { 156149b25e05SJeff Mahoney mutex_unlock(&root->fs_info->reloc_mutex); 156249b25e05SJeff Mahoney goto cleanup_transaction; 156349b25e05SJeff Mahoney } 156416cdcec7SMiao Xie 156556bec294SChris Mason ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); 156649b25e05SJeff Mahoney if (ret) { 156749b25e05SJeff Mahoney mutex_unlock(&root->fs_info->reloc_mutex); 156849b25e05SJeff Mahoney goto cleanup_transaction; 156949b25e05SJeff Mahoney } 157056bec294SChris Mason 1571e999376fSChris Mason /* 1572e999376fSChris Mason * make sure none of the code above managed to slip in a 1573e999376fSChris Mason * delayed item 1574e999376fSChris Mason */ 1575e999376fSChris Mason btrfs_assert_delayed_root_empty(root); 1576e999376fSChris Mason 15772c90e5d6SChris Mason WARN_ON(cur_trans != trans->transaction); 1578dc17ff8fSChris Mason 1579a2de733cSArne Jansen btrfs_scrub_pause(root); 1580e02119d5SChris Mason /* btrfs_commit_tree_roots is responsible for getting the 1581e02119d5SChris Mason * various roots consistent with each other. Every pointer 1582e02119d5SChris Mason * in the tree of tree roots has to point to the most up to date 1583e02119d5SChris Mason * root for every subvolume and other tree. So, we have to keep 1584e02119d5SChris Mason * the tree logging code from jumping in and changing any 1585e02119d5SChris Mason * of the trees. 1586e02119d5SChris Mason * 1587e02119d5SChris Mason * At this point in the commit, there can't be any tree-log 1588e02119d5SChris Mason * writers, but a little lower down we drop the trans mutex 1589e02119d5SChris Mason * and let new people in. By holding the tree_log_mutex 1590e02119d5SChris Mason * from now until after the super is written, we avoid races 1591e02119d5SChris Mason * with the tree-log code. 1592e02119d5SChris Mason */ 1593e02119d5SChris Mason mutex_lock(&root->fs_info->tree_log_mutex); 15941a40e23bSZheng Yan 15955d4f98a2SYan Zheng ret = commit_fs_roots(trans, root); 159649b25e05SJeff Mahoney if (ret) { 159749b25e05SJeff Mahoney mutex_unlock(&root->fs_info->tree_log_mutex); 1598871383beSDavid Sterba mutex_unlock(&root->fs_info->reloc_mutex); 159949b25e05SJeff Mahoney goto cleanup_transaction; 160049b25e05SJeff Mahoney } 160154aa1f4dSChris Mason 16025d4f98a2SYan Zheng /* commit_fs_roots gets rid of all the tree log roots, it is now 1603e02119d5SChris Mason * safe to free the root of tree log roots 1604e02119d5SChris Mason */ 1605e02119d5SChris Mason btrfs_free_log_root_tree(trans, root->fs_info); 1606e02119d5SChris Mason 16075d4f98a2SYan Zheng ret = commit_cowonly_roots(trans, root); 160849b25e05SJeff Mahoney if (ret) { 160949b25e05SJeff Mahoney mutex_unlock(&root->fs_info->tree_log_mutex); 1610871383beSDavid Sterba mutex_unlock(&root->fs_info->reloc_mutex); 161149b25e05SJeff Mahoney goto cleanup_transaction; 161249b25e05SJeff Mahoney } 161354aa1f4dSChris Mason 161411833d66SYan Zheng btrfs_prepare_extent_commit(trans, root); 161511833d66SYan Zheng 161678fae27eSChris Mason cur_trans = root->fs_info->running_transaction; 16175f39d397SChris Mason 16185d4f98a2SYan Zheng btrfs_set_root_node(&root->fs_info->tree_root->root_item, 16195d4f98a2SYan Zheng root->fs_info->tree_root->node); 1620817d52f8SJosef Bacik switch_commit_root(root->fs_info->tree_root); 16215d4f98a2SYan Zheng 16225d4f98a2SYan Zheng btrfs_set_root_node(&root->fs_info->chunk_root->root_item, 16235d4f98a2SYan Zheng root->fs_info->chunk_root->node); 1624817d52f8SJosef Bacik switch_commit_root(root->fs_info->chunk_root); 16255d4f98a2SYan Zheng 1626edf39272SJan Schmidt assert_qgroups_uptodate(trans); 16275d4f98a2SYan Zheng update_super_roots(root); 1628e02119d5SChris Mason 1629e02119d5SChris Mason if (!root->fs_info->log_root_recovering) { 16306c41761fSDavid Sterba btrfs_set_super_log_root(root->fs_info->super_copy, 0); 16316c41761fSDavid Sterba btrfs_set_super_log_root_level(root->fs_info->super_copy, 0); 1632e02119d5SChris Mason } 1633e02119d5SChris Mason 16346c41761fSDavid Sterba memcpy(root->fs_info->super_for_commit, root->fs_info->super_copy, 16356c41761fSDavid Sterba sizeof(*root->fs_info->super_copy)); 1636ccd467d6SChris Mason 1637f9295749SChris Mason trans->transaction->blocked = 0; 1638a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 1639a4abeea4SJosef Bacik root->fs_info->running_transaction = NULL; 1640a4abeea4SJosef Bacik root->fs_info->trans_no_join = 0; 1641a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 16427585717fSChris Mason mutex_unlock(&root->fs_info->reloc_mutex); 1643b7ec40d7SChris Mason 1644f9295749SChris Mason wake_up(&root->fs_info->transaction_wait); 1645e6dcd2dcSChris Mason 164679154b1bSChris Mason ret = btrfs_write_and_wait_transaction(trans, root); 164749b25e05SJeff Mahoney if (ret) { 164849b25e05SJeff Mahoney btrfs_error(root->fs_info, ret, 164949b25e05SJeff Mahoney "Error while writing out transaction."); 165049b25e05SJeff Mahoney mutex_unlock(&root->fs_info->tree_log_mutex); 165149b25e05SJeff Mahoney goto cleanup_transaction; 165249b25e05SJeff Mahoney } 165349b25e05SJeff Mahoney 165449b25e05SJeff Mahoney ret = write_ctree_super(trans, root, 0); 165549b25e05SJeff Mahoney if (ret) { 165649b25e05SJeff Mahoney mutex_unlock(&root->fs_info->tree_log_mutex); 165749b25e05SJeff Mahoney goto cleanup_transaction; 165849b25e05SJeff Mahoney } 16594313b399SChris Mason 1660e02119d5SChris Mason /* 1661e02119d5SChris Mason * the super is written, we can safely allow the tree-loggers 1662e02119d5SChris Mason * to go about their business 1663e02119d5SChris Mason */ 1664e02119d5SChris Mason mutex_unlock(&root->fs_info->tree_log_mutex); 1665e02119d5SChris Mason 166611833d66SYan Zheng btrfs_finish_extent_commit(trans, root); 16674313b399SChris Mason 16682c90e5d6SChris Mason cur_trans->commit_done = 1; 1669b7ec40d7SChris Mason 167015ee9bc7SJosef Bacik root->fs_info->last_trans_committed = cur_trans->transid; 1671817d52f8SJosef Bacik 16722c90e5d6SChris Mason wake_up(&cur_trans->commit_wait); 16733de4586cSChris Mason 1674a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 167513c5a93eSJosef Bacik list_del_init(&cur_trans->list); 1676a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 1677a4abeea4SJosef Bacik 167879154b1bSChris Mason put_transaction(cur_trans); 167978fae27eSChris Mason put_transaction(cur_trans); 168058176a96SJosef Bacik 1681b2b5ef5cSJan Kara sb_end_intwrite(root->fs_info->sb); 1682b2b5ef5cSJan Kara 16831abe9b8aSliubo trace_btrfs_transaction_commit(root); 16841abe9b8aSliubo 1685a2de733cSArne Jansen btrfs_scrub_continue(root); 1686a2de733cSArne Jansen 16879ed74f2dSJosef Bacik if (current->journal_info == trans) 16889ed74f2dSJosef Bacik current->journal_info = NULL; 16899ed74f2dSJosef Bacik 16902c90e5d6SChris Mason kmem_cache_free(btrfs_trans_handle_cachep, trans); 169124bbcf04SYan, Zheng 169224bbcf04SYan, Zheng if (current != root->fs_info->transaction_kthread) 169324bbcf04SYan, Zheng btrfs_run_delayed_iputs(root); 169424bbcf04SYan, Zheng 169579154b1bSChris Mason return ret; 169649b25e05SJeff Mahoney 169749b25e05SJeff Mahoney cleanup_transaction: 16980e721106SJosef Bacik btrfs_trans_release_metadata(trans, root); 16990e721106SJosef Bacik trans->block_rsv = NULL; 170049b25e05SJeff Mahoney btrfs_printk(root->fs_info, "Skipping commit of aborted transaction.\n"); 170149b25e05SJeff Mahoney // WARN_ON(1); 170249b25e05SJeff Mahoney if (current->journal_info == trans) 170349b25e05SJeff Mahoney current->journal_info = NULL; 17047b8b92afSJosef Bacik cleanup_transaction(trans, root, ret); 170549b25e05SJeff Mahoney 170649b25e05SJeff Mahoney return ret; 170779154b1bSChris Mason } 170879154b1bSChris Mason 1709d352ac68SChris Mason /* 1710d352ac68SChris Mason * interface function to delete all the snapshots we have scheduled for deletion 1711d352ac68SChris Mason */ 1712e9d0b13bSChris Mason int btrfs_clean_old_snapshots(struct btrfs_root *root) 1713e9d0b13bSChris Mason { 17145d4f98a2SYan Zheng LIST_HEAD(list); 17155d4f98a2SYan Zheng struct btrfs_fs_info *fs_info = root->fs_info; 1716e9d0b13bSChris Mason 1717a4abeea4SJosef Bacik spin_lock(&fs_info->trans_lock); 17185d4f98a2SYan Zheng list_splice_init(&fs_info->dead_roots, &list); 1719a4abeea4SJosef Bacik spin_unlock(&fs_info->trans_lock); 17205d4f98a2SYan Zheng 17215d4f98a2SYan Zheng while (!list_empty(&list)) { 17222c536799SJeff Mahoney int ret; 17232c536799SJeff Mahoney 17245d4f98a2SYan Zheng root = list_entry(list.next, struct btrfs_root, root_list); 172576dda93cSYan, Zheng list_del(&root->root_list); 172676dda93cSYan, Zheng 172716cdcec7SMiao Xie btrfs_kill_all_delayed_nodes(root); 172816cdcec7SMiao Xie 172976dda93cSYan, Zheng if (btrfs_header_backref_rev(root->node) < 173076dda93cSYan, Zheng BTRFS_MIXED_BACKREF_REV) 17312c536799SJeff Mahoney ret = btrfs_drop_snapshot(root, NULL, 0, 0); 173276dda93cSYan, Zheng else 17332c536799SJeff Mahoney ret =btrfs_drop_snapshot(root, NULL, 1, 0); 17342c536799SJeff Mahoney BUG_ON(ret < 0); 1735e9d0b13bSChris Mason } 1736e9d0b13bSChris Mason return 0; 1737e9d0b13bSChris Mason } 1738