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> 2579154b1bSChris Mason #include "ctree.h" 2679154b1bSChris Mason #include "disk-io.h" 2779154b1bSChris Mason #include "transaction.h" 28925baeddSChris Mason #include "locking.h" 29e02119d5SChris Mason #include "tree-log.h" 30581bb050SLi Zefan #include "inode-map.h" 3179154b1bSChris Mason 320f7d52f4SChris Mason #define BTRFS_ROOT_TRANS_TAG 0 330f7d52f4SChris Mason 3480b6794dSChris Mason static noinline void put_transaction(struct btrfs_transaction *transaction) 3579154b1bSChris Mason { 3613c5a93eSJosef Bacik WARN_ON(atomic_read(&transaction->use_count) == 0); 3713c5a93eSJosef Bacik if (atomic_dec_and_test(&transaction->use_count)) { 38a4abeea4SJosef Bacik BUG_ON(!list_empty(&transaction->list)); 3900f04b88SArne Jansen WARN_ON(transaction->delayed_refs.root.rb_node); 4000f04b88SArne Jansen WARN_ON(!list_empty(&transaction->delayed_refs.seq_head)); 412c90e5d6SChris Mason memset(transaction, 0, sizeof(*transaction)); 422c90e5d6SChris Mason kmem_cache_free(btrfs_transaction_cachep, transaction); 4379154b1bSChris Mason } 4478fae27eSChris Mason } 4579154b1bSChris Mason 46817d52f8SJosef Bacik static noinline void switch_commit_root(struct btrfs_root *root) 47817d52f8SJosef Bacik { 48817d52f8SJosef Bacik free_extent_buffer(root->commit_root); 49817d52f8SJosef Bacik root->commit_root = btrfs_root_node(root); 50817d52f8SJosef Bacik } 51817d52f8SJosef Bacik 52d352ac68SChris Mason /* 53d352ac68SChris Mason * either allocate a new transaction or hop into the existing one 54d352ac68SChris Mason */ 55a4abeea4SJosef Bacik static noinline int join_transaction(struct btrfs_root *root, int nofail) 5679154b1bSChris Mason { 5779154b1bSChris Mason struct btrfs_transaction *cur_trans; 58a4abeea4SJosef Bacik 59a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 60d43317dcSChris Mason loop: 61a4abeea4SJosef Bacik if (root->fs_info->trans_no_join) { 62a4abeea4SJosef Bacik if (!nofail) { 63a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 64a4abeea4SJosef Bacik return -EBUSY; 65a4abeea4SJosef Bacik } 66a4abeea4SJosef Bacik } 67a4abeea4SJosef Bacik 6879154b1bSChris Mason cur_trans = root->fs_info->running_transaction; 69a4abeea4SJosef Bacik if (cur_trans) { 70a4abeea4SJosef Bacik atomic_inc(&cur_trans->use_count); 71a4abeea4SJosef Bacik atomic_inc(&cur_trans->num_writers); 72a4abeea4SJosef Bacik cur_trans->num_joined++; 73a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 74a4abeea4SJosef Bacik return 0; 75a4abeea4SJosef Bacik } 76a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 77a4abeea4SJosef Bacik 78a4abeea4SJosef Bacik cur_trans = kmem_cache_alloc(btrfs_transaction_cachep, GFP_NOFS); 79db5b493aSTsutomu Itoh if (!cur_trans) 80db5b493aSTsutomu Itoh return -ENOMEM; 81d43317dcSChris Mason 82a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 83a4abeea4SJosef Bacik if (root->fs_info->running_transaction) { 84d43317dcSChris Mason /* 85d43317dcSChris Mason * someone started a transaction after we unlocked. Make sure 86d43317dcSChris Mason * to redo the trans_no_join checks above 87d43317dcSChris Mason */ 88a4abeea4SJosef Bacik kmem_cache_free(btrfs_transaction_cachep, cur_trans); 89a4abeea4SJosef Bacik cur_trans = root->fs_info->running_transaction; 90d43317dcSChris Mason goto loop; 91a4abeea4SJosef Bacik } 92d43317dcSChris Mason 9313c5a93eSJosef Bacik atomic_set(&cur_trans->num_writers, 1); 9415ee9bc7SJosef Bacik cur_trans->num_joined = 0; 9579154b1bSChris Mason init_waitqueue_head(&cur_trans->writer_wait); 9679154b1bSChris Mason init_waitqueue_head(&cur_trans->commit_wait); 9779154b1bSChris Mason cur_trans->in_commit = 0; 98f9295749SChris Mason cur_trans->blocked = 0; 99a4abeea4SJosef Bacik /* 100a4abeea4SJosef Bacik * One for this trans handle, one so it will live on until we 101a4abeea4SJosef Bacik * commit the transaction. 102a4abeea4SJosef Bacik */ 103a4abeea4SJosef Bacik atomic_set(&cur_trans->use_count, 2); 10479154b1bSChris Mason cur_trans->commit_done = 0; 10508607c1bSChris Mason cur_trans->start_time = get_seconds(); 10656bec294SChris Mason 1076bef4d31SEric Paris cur_trans->delayed_refs.root = RB_ROOT; 10856bec294SChris Mason cur_trans->delayed_refs.num_entries = 0; 109c3e69d58SChris Mason cur_trans->delayed_refs.num_heads_ready = 0; 110c3e69d58SChris Mason cur_trans->delayed_refs.num_heads = 0; 11156bec294SChris Mason cur_trans->delayed_refs.flushing = 0; 112c3e69d58SChris Mason cur_trans->delayed_refs.run_delayed_start = 0; 11300f04b88SArne Jansen cur_trans->delayed_refs.seq = 1; 114a168650cSJan Schmidt init_waitqueue_head(&cur_trans->delayed_refs.seq_wait); 115a4abeea4SJosef Bacik spin_lock_init(&cur_trans->commit_lock); 11656bec294SChris Mason spin_lock_init(&cur_trans->delayed_refs.lock); 11700f04b88SArne Jansen INIT_LIST_HEAD(&cur_trans->delayed_refs.seq_head); 11856bec294SChris Mason 1193063d29fSChris Mason INIT_LIST_HEAD(&cur_trans->pending_snapshots); 1208fd17795SChris Mason list_add_tail(&cur_trans->list, &root->fs_info->trans_list); 121d1310b2eSChris Mason extent_io_tree_init(&cur_trans->dirty_pages, 122f993c883SDavid Sterba root->fs_info->btree_inode->i_mapping); 123a4abeea4SJosef Bacik root->fs_info->generation++; 124a4abeea4SJosef Bacik cur_trans->transid = root->fs_info->generation; 12548ec2cf8SChris Mason root->fs_info->running_transaction = cur_trans; 126a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 12715ee9bc7SJosef Bacik 12879154b1bSChris Mason return 0; 12979154b1bSChris Mason } 13079154b1bSChris Mason 131d352ac68SChris Mason /* 132d397712bSChris Mason * this does all the record keeping required to make sure that a reference 133d397712bSChris Mason * counted root is properly recorded in a given transaction. This is required 134d397712bSChris Mason * to make sure the old root from before we joined the transaction is deleted 135d397712bSChris Mason * when the transaction commits 136d352ac68SChris Mason */ 1377585717fSChris Mason static int record_root_in_trans(struct btrfs_trans_handle *trans, 1385d4f98a2SYan Zheng struct btrfs_root *root) 1396702ed49SChris Mason { 1405d4f98a2SYan Zheng if (root->ref_cows && root->last_trans < trans->transid) { 1416702ed49SChris Mason WARN_ON(root == root->fs_info->extent_root); 1425d4f98a2SYan Zheng WARN_ON(root->commit_root != root->node); 1435d4f98a2SYan Zheng 1447585717fSChris Mason /* 1457585717fSChris Mason * see below for in_trans_setup usage rules 1467585717fSChris Mason * we have the reloc mutex held now, so there 1477585717fSChris Mason * is only one writer in this function 1487585717fSChris Mason */ 1497585717fSChris Mason root->in_trans_setup = 1; 1507585717fSChris Mason 1517585717fSChris Mason /* make sure readers find in_trans_setup before 1527585717fSChris Mason * they find our root->last_trans update 1537585717fSChris Mason */ 1547585717fSChris Mason smp_wmb(); 1557585717fSChris Mason 156a4abeea4SJosef Bacik spin_lock(&root->fs_info->fs_roots_radix_lock); 157a4abeea4SJosef Bacik if (root->last_trans == trans->transid) { 158a4abeea4SJosef Bacik spin_unlock(&root->fs_info->fs_roots_radix_lock); 159a4abeea4SJosef Bacik return 0; 160a4abeea4SJosef Bacik } 1616702ed49SChris Mason radix_tree_tag_set(&root->fs_info->fs_roots_radix, 1626702ed49SChris Mason (unsigned long)root->root_key.objectid, 1636702ed49SChris Mason BTRFS_ROOT_TRANS_TAG); 164a4abeea4SJosef Bacik spin_unlock(&root->fs_info->fs_roots_radix_lock); 1657585717fSChris Mason root->last_trans = trans->transid; 1667585717fSChris Mason 1677585717fSChris Mason /* this is pretty tricky. We don't want to 1687585717fSChris Mason * take the relocation lock in btrfs_record_root_in_trans 1697585717fSChris Mason * unless we're really doing the first setup for this root in 1707585717fSChris Mason * this transaction. 1717585717fSChris Mason * 1727585717fSChris Mason * Normally we'd use root->last_trans as a flag to decide 1737585717fSChris Mason * if we want to take the expensive mutex. 1747585717fSChris Mason * 1757585717fSChris Mason * But, we have to set root->last_trans before we 1767585717fSChris Mason * init the relocation root, otherwise, we trip over warnings 1777585717fSChris Mason * in ctree.c. The solution used here is to flag ourselves 1787585717fSChris Mason * with root->in_trans_setup. When this is 1, we're still 1797585717fSChris Mason * fixing up the reloc trees and everyone must wait. 1807585717fSChris Mason * 1817585717fSChris Mason * When this is zero, they can trust root->last_trans and fly 1827585717fSChris Mason * through btrfs_record_root_in_trans without having to take the 1837585717fSChris Mason * lock. smp_wmb() makes sure that all the writes above are 1847585717fSChris Mason * done before we pop in the zero below 1857585717fSChris Mason */ 1865d4f98a2SYan Zheng btrfs_init_reloc_root(trans, root); 1877585717fSChris Mason smp_wmb(); 1887585717fSChris Mason root->in_trans_setup = 0; 1896702ed49SChris Mason } 1905d4f98a2SYan Zheng return 0; 1916702ed49SChris Mason } 1925d4f98a2SYan Zheng 1937585717fSChris Mason 1947585717fSChris Mason int btrfs_record_root_in_trans(struct btrfs_trans_handle *trans, 1957585717fSChris Mason struct btrfs_root *root) 1967585717fSChris Mason { 1977585717fSChris Mason if (!root->ref_cows) 1987585717fSChris Mason return 0; 1997585717fSChris Mason 2007585717fSChris Mason /* 2017585717fSChris Mason * see record_root_in_trans for comments about in_trans_setup usage 2027585717fSChris Mason * and barriers 2037585717fSChris Mason */ 2047585717fSChris Mason smp_rmb(); 2057585717fSChris Mason if (root->last_trans == trans->transid && 2067585717fSChris Mason !root->in_trans_setup) 2077585717fSChris Mason return 0; 2087585717fSChris Mason 2097585717fSChris Mason mutex_lock(&root->fs_info->reloc_mutex); 2107585717fSChris Mason record_root_in_trans(trans, root); 2117585717fSChris Mason mutex_unlock(&root->fs_info->reloc_mutex); 2127585717fSChris Mason 2137585717fSChris Mason return 0; 2147585717fSChris Mason } 2157585717fSChris Mason 216d352ac68SChris Mason /* wait for commit against the current transaction to become unblocked 217d352ac68SChris Mason * when this is done, it is safe to start a new transaction, but the current 218d352ac68SChris Mason * transaction might not be fully on disk. 219d352ac68SChris Mason */ 22037d1aeeeSChris Mason static void wait_current_trans(struct btrfs_root *root) 22179154b1bSChris Mason { 222f9295749SChris Mason struct btrfs_transaction *cur_trans; 22379154b1bSChris Mason 224a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 225f9295749SChris Mason cur_trans = root->fs_info->running_transaction; 22637d1aeeeSChris Mason if (cur_trans && cur_trans->blocked) { 22713c5a93eSJosef Bacik atomic_inc(&cur_trans->use_count); 228a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 22972d63ed6SLi Zefan 23072d63ed6SLi Zefan wait_event(root->fs_info->transaction_wait, 23172d63ed6SLi Zefan !cur_trans->blocked); 232f9295749SChris Mason put_transaction(cur_trans); 233a4abeea4SJosef Bacik } else { 234a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 235f9295749SChris Mason } 23637d1aeeeSChris Mason } 23737d1aeeeSChris Mason 238249ac1e5SJosef Bacik enum btrfs_trans_type { 239249ac1e5SJosef Bacik TRANS_START, 240249ac1e5SJosef Bacik TRANS_JOIN, 241249ac1e5SJosef Bacik TRANS_USERSPACE, 2420af3d00bSJosef Bacik TRANS_JOIN_NOLOCK, 243249ac1e5SJosef Bacik }; 244249ac1e5SJosef Bacik 245a22285a6SYan, Zheng static int may_wait_transaction(struct btrfs_root *root, int type) 24637d1aeeeSChris Mason { 247a4abeea4SJosef Bacik if (root->fs_info->log_root_recovering) 248a4abeea4SJosef Bacik return 0; 249a4abeea4SJosef Bacik 250a4abeea4SJosef Bacik if (type == TRANS_USERSPACE) 251a22285a6SYan, Zheng return 1; 252a4abeea4SJosef Bacik 253a4abeea4SJosef Bacik if (type == TRANS_START && 254a4abeea4SJosef Bacik !atomic_read(&root->fs_info->open_ioctl_trans)) 255a4abeea4SJosef Bacik return 1; 256a4abeea4SJosef Bacik 257a22285a6SYan, Zheng return 0; 258a22285a6SYan, Zheng } 259a22285a6SYan, Zheng 260a22285a6SYan, Zheng static struct btrfs_trans_handle *start_transaction(struct btrfs_root *root, 261a22285a6SYan, Zheng u64 num_items, int type) 262a22285a6SYan, Zheng { 263a22285a6SYan, Zheng struct btrfs_trans_handle *h; 264a22285a6SYan, Zheng struct btrfs_transaction *cur_trans; 265b5009945SJosef Bacik u64 num_bytes = 0; 266a22285a6SYan, Zheng int ret; 267acce952bSliubo 268acce952bSliubo if (root->fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) 269acce952bSliubo return ERR_PTR(-EROFS); 2702a1eb461SJosef Bacik 2712a1eb461SJosef Bacik if (current->journal_info) { 2722a1eb461SJosef Bacik WARN_ON(type != TRANS_JOIN && type != TRANS_JOIN_NOLOCK); 2732a1eb461SJosef Bacik h = current->journal_info; 2742a1eb461SJosef Bacik h->use_count++; 2752a1eb461SJosef Bacik h->orig_rsv = h->block_rsv; 2762a1eb461SJosef Bacik h->block_rsv = NULL; 2772a1eb461SJosef Bacik goto got_it; 2782a1eb461SJosef Bacik } 279b5009945SJosef Bacik 280b5009945SJosef Bacik /* 281b5009945SJosef Bacik * Do the reservation before we join the transaction so we can do all 282b5009945SJosef Bacik * the appropriate flushing if need be. 283b5009945SJosef Bacik */ 284b5009945SJosef Bacik if (num_items > 0 && root != root->fs_info->chunk_root) { 285b5009945SJosef Bacik num_bytes = btrfs_calc_trans_metadata_size(root, num_items); 2864a92b1b8SJosef Bacik ret = btrfs_block_rsv_add(root, 287b5009945SJosef Bacik &root->fs_info->trans_block_rsv, 288b5009945SJosef Bacik num_bytes); 289b5009945SJosef Bacik if (ret) 290b5009945SJosef Bacik return ERR_PTR(ret); 291b5009945SJosef Bacik } 292a22285a6SYan, Zheng again: 293a22285a6SYan, Zheng h = kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS); 294a22285a6SYan, Zheng if (!h) 295a22285a6SYan, Zheng return ERR_PTR(-ENOMEM); 296a22285a6SYan, Zheng 297a22285a6SYan, Zheng if (may_wait_transaction(root, type)) 29837d1aeeeSChris Mason wait_current_trans(root); 299a22285a6SYan, Zheng 300a4abeea4SJosef Bacik do { 301a4abeea4SJosef Bacik ret = join_transaction(root, type == TRANS_JOIN_NOLOCK); 302a4abeea4SJosef Bacik if (ret == -EBUSY) 303a4abeea4SJosef Bacik wait_current_trans(root); 304a4abeea4SJosef Bacik } while (ret == -EBUSY); 305a4abeea4SJosef Bacik 306db5b493aSTsutomu Itoh if (ret < 0) { 3076e8df2aeSYoshinori Sano kmem_cache_free(btrfs_trans_handle_cachep, h); 308db5b493aSTsutomu Itoh return ERR_PTR(ret); 309db5b493aSTsutomu Itoh } 3100f7d52f4SChris Mason 311a22285a6SYan, Zheng cur_trans = root->fs_info->running_transaction; 312a22285a6SYan, Zheng 313a22285a6SYan, Zheng h->transid = cur_trans->transid; 314a22285a6SYan, Zheng h->transaction = cur_trans; 31579154b1bSChris Mason h->blocks_used = 0; 316a22285a6SYan, Zheng h->bytes_reserved = 0; 31756bec294SChris Mason h->delayed_ref_updates = 0; 3182a1eb461SJosef Bacik h->use_count = 1; 319f0486c68SYan, Zheng h->block_rsv = NULL; 3202a1eb461SJosef Bacik h->orig_rsv = NULL; 321b7ec40d7SChris Mason 322a22285a6SYan, Zheng smp_mb(); 323a22285a6SYan, Zheng if (cur_trans->blocked && may_wait_transaction(root, type)) { 324a22285a6SYan, Zheng btrfs_commit_transaction(h, root); 325a22285a6SYan, Zheng goto again; 326a22285a6SYan, Zheng } 3279ed74f2dSJosef Bacik 328b5009945SJosef Bacik if (num_bytes) { 329b5009945SJosef Bacik h->block_rsv = &root->fs_info->trans_block_rsv; 330b5009945SJosef Bacik h->bytes_reserved = num_bytes; 331a22285a6SYan, Zheng } 332a22285a6SYan, Zheng 3332a1eb461SJosef Bacik got_it: 334a4abeea4SJosef Bacik btrfs_record_root_in_trans(h, root); 335a22285a6SYan, Zheng 336a22285a6SYan, Zheng if (!current->journal_info && type != TRANS_USERSPACE) 337a22285a6SYan, Zheng current->journal_info = h; 33879154b1bSChris Mason return h; 33979154b1bSChris Mason } 34079154b1bSChris Mason 341f9295749SChris Mason struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root, 342a22285a6SYan, Zheng int num_items) 343f9295749SChris Mason { 344a22285a6SYan, Zheng return start_transaction(root, num_items, TRANS_START); 345f9295749SChris Mason } 3467a7eaa40SJosef Bacik struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root) 347f9295749SChris Mason { 348a22285a6SYan, Zheng return start_transaction(root, 0, TRANS_JOIN); 349f9295749SChris Mason } 350f9295749SChris Mason 3517a7eaa40SJosef Bacik struct btrfs_trans_handle *btrfs_join_transaction_nolock(struct btrfs_root *root) 3520af3d00bSJosef Bacik { 3530af3d00bSJosef Bacik return start_transaction(root, 0, TRANS_JOIN_NOLOCK); 3540af3d00bSJosef Bacik } 3550af3d00bSJosef Bacik 3567a7eaa40SJosef Bacik struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *root) 3579ca9ee09SSage Weil { 3587a7eaa40SJosef Bacik return start_transaction(root, 0, TRANS_USERSPACE); 3599ca9ee09SSage Weil } 3609ca9ee09SSage Weil 361d352ac68SChris Mason /* wait for a transaction commit to be fully complete */ 362b9c8300cSLi Zefan static noinline void wait_for_commit(struct btrfs_root *root, 36389ce8a63SChris Mason struct btrfs_transaction *commit) 36489ce8a63SChris Mason { 36572d63ed6SLi Zefan wait_event(commit->commit_wait, commit->commit_done); 36689ce8a63SChris Mason } 36789ce8a63SChris Mason 36846204592SSage Weil int btrfs_wait_for_commit(struct btrfs_root *root, u64 transid) 36946204592SSage Weil { 37046204592SSage Weil struct btrfs_transaction *cur_trans = NULL, *t; 37146204592SSage Weil int ret; 37246204592SSage Weil 37346204592SSage Weil ret = 0; 37446204592SSage Weil if (transid) { 37546204592SSage Weil if (transid <= root->fs_info->last_trans_committed) 376a4abeea4SJosef Bacik goto out; 37746204592SSage Weil 37846204592SSage Weil /* find specified transaction */ 379a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 38046204592SSage Weil list_for_each_entry(t, &root->fs_info->trans_list, list) { 38146204592SSage Weil if (t->transid == transid) { 38246204592SSage Weil cur_trans = t; 383a4abeea4SJosef Bacik atomic_inc(&cur_trans->use_count); 38446204592SSage Weil break; 38546204592SSage Weil } 38646204592SSage Weil if (t->transid > transid) 38746204592SSage Weil break; 38846204592SSage Weil } 389a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 39046204592SSage Weil ret = -EINVAL; 39146204592SSage Weil if (!cur_trans) 392a4abeea4SJosef Bacik goto out; /* bad transid */ 39346204592SSage Weil } else { 39446204592SSage Weil /* find newest transaction that is committing | committed */ 395a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 39646204592SSage Weil list_for_each_entry_reverse(t, &root->fs_info->trans_list, 39746204592SSage Weil list) { 39846204592SSage Weil if (t->in_commit) { 39946204592SSage Weil if (t->commit_done) 4003473f3c0SJosef Bacik break; 40146204592SSage Weil cur_trans = t; 402a4abeea4SJosef Bacik atomic_inc(&cur_trans->use_count); 40346204592SSage Weil break; 40446204592SSage Weil } 40546204592SSage Weil } 406a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 40746204592SSage Weil if (!cur_trans) 408a4abeea4SJosef Bacik goto out; /* nothing committing|committed */ 40946204592SSage Weil } 41046204592SSage Weil 41146204592SSage Weil wait_for_commit(root, cur_trans); 41246204592SSage Weil 41346204592SSage Weil put_transaction(cur_trans); 41446204592SSage Weil ret = 0; 415a4abeea4SJosef Bacik out: 41646204592SSage Weil return ret; 41746204592SSage Weil } 41846204592SSage Weil 41937d1aeeeSChris Mason void btrfs_throttle(struct btrfs_root *root) 42037d1aeeeSChris Mason { 421a4abeea4SJosef Bacik if (!atomic_read(&root->fs_info->open_ioctl_trans)) 42237d1aeeeSChris Mason wait_current_trans(root); 42337d1aeeeSChris Mason } 42437d1aeeeSChris Mason 4258929ecfaSYan, Zheng static int should_end_transaction(struct btrfs_trans_handle *trans, 4268929ecfaSYan, Zheng struct btrfs_root *root) 4278929ecfaSYan, Zheng { 4288929ecfaSYan, Zheng int ret; 42936ba022aSJosef Bacik 43036ba022aSJosef Bacik ret = btrfs_block_rsv_check(root, &root->fs_info->global_block_rsv, 5); 4318929ecfaSYan, Zheng return ret ? 1 : 0; 4328929ecfaSYan, Zheng } 4338929ecfaSYan, Zheng 4348929ecfaSYan, Zheng int btrfs_should_end_transaction(struct btrfs_trans_handle *trans, 4358929ecfaSYan, Zheng struct btrfs_root *root) 4368929ecfaSYan, Zheng { 4378929ecfaSYan, Zheng struct btrfs_transaction *cur_trans = trans->transaction; 4389c8d86dbSJosef Bacik struct btrfs_block_rsv *rsv = trans->block_rsv; 4398929ecfaSYan, Zheng int updates; 4408929ecfaSYan, Zheng 441a4abeea4SJosef Bacik smp_mb(); 4428929ecfaSYan, Zheng if (cur_trans->blocked || cur_trans->delayed_refs.flushing) 4438929ecfaSYan, Zheng return 1; 4448929ecfaSYan, Zheng 4459c8d86dbSJosef Bacik /* 4469c8d86dbSJosef Bacik * We need to do this in case we're deleting csums so the global block 4479c8d86dbSJosef Bacik * rsv get's used instead of the csum block rsv. 4489c8d86dbSJosef Bacik */ 4499c8d86dbSJosef Bacik trans->block_rsv = NULL; 4509c8d86dbSJosef Bacik 4518929ecfaSYan, Zheng updates = trans->delayed_ref_updates; 4528929ecfaSYan, Zheng trans->delayed_ref_updates = 0; 4538929ecfaSYan, Zheng if (updates) 4548929ecfaSYan, Zheng btrfs_run_delayed_refs(trans, root, updates); 4558929ecfaSYan, Zheng 4569c8d86dbSJosef Bacik trans->block_rsv = rsv; 4579c8d86dbSJosef Bacik 4588929ecfaSYan, Zheng return should_end_transaction(trans, root); 4598929ecfaSYan, Zheng } 4608929ecfaSYan, Zheng 46189ce8a63SChris Mason static int __btrfs_end_transaction(struct btrfs_trans_handle *trans, 4620af3d00bSJosef Bacik struct btrfs_root *root, int throttle, int lock) 46379154b1bSChris Mason { 4648929ecfaSYan, Zheng struct btrfs_transaction *cur_trans = trans->transaction; 465ab78c84dSChris Mason struct btrfs_fs_info *info = root->fs_info; 466c3e69d58SChris Mason int count = 0; 467d6e4a428SChris Mason 4682a1eb461SJosef Bacik if (--trans->use_count) { 4692a1eb461SJosef Bacik trans->block_rsv = trans->orig_rsv; 4702a1eb461SJosef Bacik return 0; 4712a1eb461SJosef Bacik } 4722a1eb461SJosef Bacik 473b24e03dbSJosef Bacik btrfs_trans_release_metadata(trans, root); 4744c13d758SJosef Bacik trans->block_rsv = NULL; 475c3e69d58SChris Mason while (count < 4) { 476c3e69d58SChris Mason unsigned long cur = trans->delayed_ref_updates; 477c3e69d58SChris Mason trans->delayed_ref_updates = 0; 478c3e69d58SChris Mason if (cur && 479c3e69d58SChris Mason trans->transaction->delayed_refs.num_heads_ready > 64) { 480c3e69d58SChris Mason trans->delayed_ref_updates = 0; 481b7ec40d7SChris Mason 482b7ec40d7SChris Mason /* 483b7ec40d7SChris Mason * do a full flush if the transaction is trying 484b7ec40d7SChris Mason * to close 485b7ec40d7SChris Mason */ 486b7ec40d7SChris Mason if (trans->transaction->delayed_refs.flushing) 487b7ec40d7SChris Mason cur = 0; 488c3e69d58SChris Mason btrfs_run_delayed_refs(trans, root, cur); 489c3e69d58SChris Mason } else { 490c3e69d58SChris Mason break; 491c3e69d58SChris Mason } 492c3e69d58SChris Mason count++; 49356bec294SChris Mason } 49456bec294SChris Mason 495a4abeea4SJosef Bacik if (lock && !atomic_read(&root->fs_info->open_ioctl_trans) && 496a4abeea4SJosef Bacik should_end_transaction(trans, root)) { 4978929ecfaSYan, Zheng trans->transaction->blocked = 1; 498a4abeea4SJosef Bacik smp_wmb(); 499a4abeea4SJosef Bacik } 5008929ecfaSYan, Zheng 5010af3d00bSJosef Bacik if (lock && cur_trans->blocked && !cur_trans->in_commit) { 50281317fdeSJosef Bacik if (throttle) { 50381317fdeSJosef Bacik /* 50481317fdeSJosef Bacik * We may race with somebody else here so end up having 50581317fdeSJosef Bacik * to call end_transaction on ourselves again, so inc 50681317fdeSJosef Bacik * our use_count. 50781317fdeSJosef Bacik */ 50881317fdeSJosef Bacik trans->use_count++; 5098929ecfaSYan, Zheng return btrfs_commit_transaction(trans, root); 51081317fdeSJosef Bacik } else { 5118929ecfaSYan, Zheng wake_up_process(info->transaction_kthread); 5128929ecfaSYan, Zheng } 51381317fdeSJosef Bacik } 5148929ecfaSYan, Zheng 5158929ecfaSYan, Zheng WARN_ON(cur_trans != info->running_transaction); 51613c5a93eSJosef Bacik WARN_ON(atomic_read(&cur_trans->num_writers) < 1); 51713c5a93eSJosef Bacik atomic_dec(&cur_trans->num_writers); 51889ce8a63SChris Mason 51999d16cbcSSage Weil smp_mb(); 52079154b1bSChris Mason if (waitqueue_active(&cur_trans->writer_wait)) 52179154b1bSChris Mason wake_up(&cur_trans->writer_wait); 52279154b1bSChris Mason put_transaction(cur_trans); 5239ed74f2dSJosef Bacik 5249ed74f2dSJosef Bacik if (current->journal_info == trans) 5259ed74f2dSJosef Bacik current->journal_info = NULL; 526d6025579SChris Mason memset(trans, 0, sizeof(*trans)); 5272c90e5d6SChris Mason kmem_cache_free(btrfs_trans_handle_cachep, trans); 528ab78c84dSChris Mason 52924bbcf04SYan, Zheng if (throttle) 53024bbcf04SYan, Zheng btrfs_run_delayed_iputs(root); 53124bbcf04SYan, Zheng 53279154b1bSChris Mason return 0; 53379154b1bSChris Mason } 53479154b1bSChris Mason 53589ce8a63SChris Mason int btrfs_end_transaction(struct btrfs_trans_handle *trans, 53689ce8a63SChris Mason struct btrfs_root *root) 53789ce8a63SChris Mason { 53816cdcec7SMiao Xie int ret; 53916cdcec7SMiao Xie 54016cdcec7SMiao Xie ret = __btrfs_end_transaction(trans, root, 0, 1); 54116cdcec7SMiao Xie if (ret) 54216cdcec7SMiao Xie return ret; 54316cdcec7SMiao Xie return 0; 54489ce8a63SChris Mason } 54589ce8a63SChris Mason 54689ce8a63SChris Mason int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans, 54789ce8a63SChris Mason struct btrfs_root *root) 54889ce8a63SChris Mason { 54916cdcec7SMiao Xie int ret; 55016cdcec7SMiao Xie 55116cdcec7SMiao Xie ret = __btrfs_end_transaction(trans, root, 1, 1); 55216cdcec7SMiao Xie if (ret) 55316cdcec7SMiao Xie return ret; 55416cdcec7SMiao Xie return 0; 5550af3d00bSJosef Bacik } 5560af3d00bSJosef Bacik 5570af3d00bSJosef Bacik int btrfs_end_transaction_nolock(struct btrfs_trans_handle *trans, 5580af3d00bSJosef Bacik struct btrfs_root *root) 5590af3d00bSJosef Bacik { 56016cdcec7SMiao Xie int ret; 56116cdcec7SMiao Xie 56216cdcec7SMiao Xie ret = __btrfs_end_transaction(trans, root, 0, 0); 56316cdcec7SMiao Xie if (ret) 56416cdcec7SMiao Xie return ret; 56516cdcec7SMiao Xie return 0; 56616cdcec7SMiao Xie } 56716cdcec7SMiao Xie 56816cdcec7SMiao Xie int btrfs_end_transaction_dmeta(struct btrfs_trans_handle *trans, 56916cdcec7SMiao Xie struct btrfs_root *root) 57016cdcec7SMiao Xie { 57116cdcec7SMiao Xie return __btrfs_end_transaction(trans, root, 1, 1); 57289ce8a63SChris Mason } 57389ce8a63SChris Mason 574d352ac68SChris Mason /* 575d352ac68SChris Mason * when btree blocks are allocated, they have some corresponding bits set for 576d352ac68SChris Mason * them in one of two extent_io trees. This is used to make sure all of 577690587d1SChris Mason * those extents are sent to disk but does not wait on them 578d352ac68SChris Mason */ 579690587d1SChris Mason int btrfs_write_marked_extents(struct btrfs_root *root, 5808cef4e16SYan, Zheng struct extent_io_tree *dirty_pages, int mark) 58179154b1bSChris Mason { 582777e6bd7SChris Mason int err = 0; 5837c4452b9SChris Mason int werr = 0; 5841728366eSJosef Bacik struct address_space *mapping = root->fs_info->btree_inode->i_mapping; 585777e6bd7SChris Mason u64 start = 0; 5865f39d397SChris Mason u64 end; 5877c4452b9SChris Mason 5881728366eSJosef Bacik while (!find_first_extent_bit(dirty_pages, start, &start, &end, 5891728366eSJosef Bacik mark)) { 5901728366eSJosef Bacik convert_extent_bit(dirty_pages, start, end, EXTENT_NEED_WAIT, mark, 5911728366eSJosef Bacik GFP_NOFS); 5921728366eSJosef Bacik err = filemap_fdatawrite_range(mapping, start, end); 5937c4452b9SChris Mason if (err) 5947c4452b9SChris Mason werr = err; 5951728366eSJosef Bacik cond_resched(); 5961728366eSJosef Bacik start = end + 1; 5977c4452b9SChris Mason } 598690587d1SChris Mason if (err) 599690587d1SChris Mason werr = err; 600690587d1SChris Mason return werr; 601690587d1SChris Mason } 602690587d1SChris Mason 603690587d1SChris Mason /* 604690587d1SChris Mason * when btree blocks are allocated, they have some corresponding bits set for 605690587d1SChris Mason * them in one of two extent_io trees. This is used to make sure all of 606690587d1SChris Mason * those extents are on disk for transaction or log commit. We wait 607690587d1SChris Mason * on all the pages and clear them from the dirty pages state tree 608690587d1SChris Mason */ 609690587d1SChris Mason int btrfs_wait_marked_extents(struct btrfs_root *root, 6108cef4e16SYan, Zheng struct extent_io_tree *dirty_pages, int mark) 611690587d1SChris Mason { 612690587d1SChris Mason int err = 0; 613690587d1SChris Mason int werr = 0; 6141728366eSJosef Bacik struct address_space *mapping = root->fs_info->btree_inode->i_mapping; 615690587d1SChris Mason u64 start = 0; 616690587d1SChris Mason u64 end; 617690587d1SChris Mason 6181728366eSJosef Bacik while (!find_first_extent_bit(dirty_pages, start, &start, &end, 6191728366eSJosef Bacik EXTENT_NEED_WAIT)) { 6201728366eSJosef Bacik clear_extent_bits(dirty_pages, start, end, EXTENT_NEED_WAIT, GFP_NOFS); 6211728366eSJosef Bacik err = filemap_fdatawait_range(mapping, start, end); 622777e6bd7SChris Mason if (err) 623777e6bd7SChris Mason werr = err; 624777e6bd7SChris Mason cond_resched(); 6251728366eSJosef Bacik start = end + 1; 626777e6bd7SChris Mason } 6277c4452b9SChris Mason if (err) 6287c4452b9SChris Mason werr = err; 6297c4452b9SChris Mason return werr; 63079154b1bSChris Mason } 63179154b1bSChris Mason 632690587d1SChris Mason /* 633690587d1SChris Mason * when btree blocks are allocated, they have some corresponding bits set for 634690587d1SChris Mason * them in one of two extent_io trees. This is used to make sure all of 635690587d1SChris Mason * those extents are on disk for transaction or log commit 636690587d1SChris Mason */ 637690587d1SChris Mason int btrfs_write_and_wait_marked_extents(struct btrfs_root *root, 6388cef4e16SYan, Zheng struct extent_io_tree *dirty_pages, int mark) 639690587d1SChris Mason { 640690587d1SChris Mason int ret; 641690587d1SChris Mason int ret2; 642690587d1SChris Mason 6438cef4e16SYan, Zheng ret = btrfs_write_marked_extents(root, dirty_pages, mark); 6448cef4e16SYan, Zheng ret2 = btrfs_wait_marked_extents(root, dirty_pages, mark); 645bf0da8c1SChris Mason 646bf0da8c1SChris Mason if (ret) 647bf0da8c1SChris Mason return ret; 648bf0da8c1SChris Mason if (ret2) 649bf0da8c1SChris Mason return ret2; 650bf0da8c1SChris Mason return 0; 651690587d1SChris Mason } 652690587d1SChris Mason 653d0c803c4SChris Mason int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans, 654d0c803c4SChris Mason struct btrfs_root *root) 655d0c803c4SChris Mason { 656d0c803c4SChris Mason if (!trans || !trans->transaction) { 657d0c803c4SChris Mason struct inode *btree_inode; 658d0c803c4SChris Mason btree_inode = root->fs_info->btree_inode; 659d0c803c4SChris Mason return filemap_write_and_wait(btree_inode->i_mapping); 660d0c803c4SChris Mason } 661d0c803c4SChris Mason return btrfs_write_and_wait_marked_extents(root, 6628cef4e16SYan, Zheng &trans->transaction->dirty_pages, 6638cef4e16SYan, Zheng EXTENT_DIRTY); 664d0c803c4SChris Mason } 665d0c803c4SChris Mason 666d352ac68SChris Mason /* 667d352ac68SChris Mason * this is used to update the root pointer in the tree of tree roots. 668d352ac68SChris Mason * 669d352ac68SChris Mason * But, in the case of the extent allocation tree, updating the root 670d352ac68SChris Mason * pointer may allocate blocks which may change the root of the extent 671d352ac68SChris Mason * allocation tree. 672d352ac68SChris Mason * 673d352ac68SChris Mason * So, this loops and repeats and makes sure the cowonly root didn't 674d352ac68SChris Mason * change while the root pointer was being updated in the metadata. 675d352ac68SChris Mason */ 6760b86a832SChris Mason static int update_cowonly_root(struct btrfs_trans_handle *trans, 67779154b1bSChris Mason struct btrfs_root *root) 67879154b1bSChris Mason { 67979154b1bSChris Mason int ret; 6800b86a832SChris Mason u64 old_root_bytenr; 68186b9f2ecSYan, Zheng u64 old_root_used; 6820b86a832SChris Mason struct btrfs_root *tree_root = root->fs_info->tree_root; 68379154b1bSChris Mason 68486b9f2ecSYan, Zheng old_root_used = btrfs_root_used(&root->root_item); 6850b86a832SChris Mason btrfs_write_dirty_block_groups(trans, root); 68656bec294SChris Mason 68779154b1bSChris Mason while (1) { 6880b86a832SChris Mason old_root_bytenr = btrfs_root_bytenr(&root->root_item); 68986b9f2ecSYan, Zheng if (old_root_bytenr == root->node->start && 69086b9f2ecSYan, Zheng old_root_used == btrfs_root_used(&root->root_item)) 69179154b1bSChris Mason break; 69287ef2bb4SChris Mason 6935d4f98a2SYan Zheng btrfs_set_root_node(&root->root_item, root->node); 69479154b1bSChris Mason ret = btrfs_update_root(trans, tree_root, 6950b86a832SChris Mason &root->root_key, 6960b86a832SChris Mason &root->root_item); 69779154b1bSChris Mason BUG_ON(ret); 69856bec294SChris Mason 69986b9f2ecSYan, Zheng old_root_used = btrfs_root_used(&root->root_item); 7004a8c9a62SYan Zheng ret = btrfs_write_dirty_block_groups(trans, root); 70156bec294SChris Mason BUG_ON(ret); 7020b86a832SChris Mason } 703276e680dSYan Zheng 704276e680dSYan Zheng if (root != root->fs_info->extent_root) 705817d52f8SJosef Bacik switch_commit_root(root); 706276e680dSYan Zheng 7070b86a832SChris Mason return 0; 7080b86a832SChris Mason } 7090b86a832SChris Mason 710d352ac68SChris Mason /* 711d352ac68SChris Mason * update all the cowonly tree roots on disk 712d352ac68SChris Mason */ 7135d4f98a2SYan Zheng static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans, 7140b86a832SChris Mason struct btrfs_root *root) 7150b86a832SChris Mason { 7160b86a832SChris Mason struct btrfs_fs_info *fs_info = root->fs_info; 7170b86a832SChris Mason struct list_head *next; 71884234f3aSYan Zheng struct extent_buffer *eb; 71956bec294SChris Mason int ret; 72084234f3aSYan Zheng 72156bec294SChris Mason ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); 72256bec294SChris Mason BUG_ON(ret); 72387ef2bb4SChris Mason 72484234f3aSYan Zheng eb = btrfs_lock_root_node(fs_info->tree_root); 7259fa8cfe7SChris Mason btrfs_cow_block(trans, fs_info->tree_root, eb, NULL, 0, &eb); 72684234f3aSYan Zheng btrfs_tree_unlock(eb); 72784234f3aSYan Zheng free_extent_buffer(eb); 7280b86a832SChris Mason 72956bec294SChris Mason ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); 73056bec294SChris Mason BUG_ON(ret); 73187ef2bb4SChris Mason 7320b86a832SChris Mason while (!list_empty(&fs_info->dirty_cowonly_roots)) { 7330b86a832SChris Mason next = fs_info->dirty_cowonly_roots.next; 7340b86a832SChris Mason list_del_init(next); 7350b86a832SChris Mason root = list_entry(next, struct btrfs_root, dirty_list); 73687ef2bb4SChris Mason 7370b86a832SChris Mason update_cowonly_root(trans, root); 73879154b1bSChris Mason } 739276e680dSYan Zheng 740276e680dSYan Zheng down_write(&fs_info->extent_commit_sem); 741276e680dSYan Zheng switch_commit_root(fs_info->extent_root); 742276e680dSYan Zheng up_write(&fs_info->extent_commit_sem); 743276e680dSYan Zheng 74479154b1bSChris Mason return 0; 74579154b1bSChris Mason } 74679154b1bSChris Mason 747d352ac68SChris Mason /* 748d352ac68SChris Mason * dead roots are old snapshots that need to be deleted. This allocates 749d352ac68SChris Mason * a dirty root struct and adds it into the list of dead roots that need to 750d352ac68SChris Mason * be deleted 751d352ac68SChris Mason */ 7525d4f98a2SYan Zheng int btrfs_add_dead_root(struct btrfs_root *root) 7535eda7b5eSChris Mason { 754a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 7555d4f98a2SYan Zheng list_add(&root->root_list, &root->fs_info->dead_roots); 756a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 7575eda7b5eSChris Mason return 0; 7585eda7b5eSChris Mason } 7595eda7b5eSChris Mason 760d352ac68SChris Mason /* 7615d4f98a2SYan Zheng * update all the cowonly tree roots on disk 762d352ac68SChris Mason */ 7635d4f98a2SYan Zheng static noinline int commit_fs_roots(struct btrfs_trans_handle *trans, 7645d4f98a2SYan Zheng struct btrfs_root *root) 7650f7d52f4SChris Mason { 7660f7d52f4SChris Mason struct btrfs_root *gang[8]; 7675d4f98a2SYan Zheng struct btrfs_fs_info *fs_info = root->fs_info; 7680f7d52f4SChris Mason int i; 7690f7d52f4SChris Mason int ret; 77054aa1f4dSChris Mason int err = 0; 77154aa1f4dSChris Mason 772a4abeea4SJosef Bacik spin_lock(&fs_info->fs_roots_radix_lock); 7730f7d52f4SChris Mason while (1) { 7745d4f98a2SYan Zheng ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix, 7755d4f98a2SYan Zheng (void **)gang, 0, 7760f7d52f4SChris Mason ARRAY_SIZE(gang), 7770f7d52f4SChris Mason BTRFS_ROOT_TRANS_TAG); 7780f7d52f4SChris Mason if (ret == 0) 7790f7d52f4SChris Mason break; 7800f7d52f4SChris Mason for (i = 0; i < ret; i++) { 7810f7d52f4SChris Mason root = gang[i]; 7825d4f98a2SYan Zheng radix_tree_tag_clear(&fs_info->fs_roots_radix, 7832619ba1fSChris Mason (unsigned long)root->root_key.objectid, 7840f7d52f4SChris Mason BTRFS_ROOT_TRANS_TAG); 785a4abeea4SJosef Bacik spin_unlock(&fs_info->fs_roots_radix_lock); 78631153d81SYan Zheng 787e02119d5SChris Mason btrfs_free_log(trans, root); 7885d4f98a2SYan Zheng btrfs_update_reloc_root(trans, root); 789d68fc57bSYan, Zheng btrfs_orphan_commit_root(trans, root); 790e02119d5SChris Mason 79182d5902dSLi Zefan btrfs_save_ino_cache(root, trans); 79282d5902dSLi Zefan 793f1ebcc74SLiu Bo /* see comments in should_cow_block() */ 794f1ebcc74SLiu Bo root->force_cow = 0; 795f1ebcc74SLiu Bo smp_wmb(); 796f1ebcc74SLiu Bo 797978d910dSYan Zheng if (root->commit_root != root->node) { 798581bb050SLi Zefan mutex_lock(&root->fs_commit_mutex); 799817d52f8SJosef Bacik switch_commit_root(root); 800581bb050SLi Zefan btrfs_unpin_free_ino(root); 801581bb050SLi Zefan mutex_unlock(&root->fs_commit_mutex); 802581bb050SLi Zefan 803978d910dSYan Zheng btrfs_set_root_node(&root->root_item, 804978d910dSYan Zheng root->node); 805978d910dSYan Zheng } 80631153d81SYan Zheng 8075d4f98a2SYan Zheng err = btrfs_update_root(trans, fs_info->tree_root, 8080f7d52f4SChris Mason &root->root_key, 8090f7d52f4SChris Mason &root->root_item); 810a4abeea4SJosef Bacik spin_lock(&fs_info->fs_roots_radix_lock); 81154aa1f4dSChris Mason if (err) 81254aa1f4dSChris Mason break; 8130f7d52f4SChris Mason } 8149f3a7427SChris Mason } 815a4abeea4SJosef Bacik spin_unlock(&fs_info->fs_roots_radix_lock); 81654aa1f4dSChris Mason return err; 8170f7d52f4SChris Mason } 8180f7d52f4SChris Mason 819d352ac68SChris Mason /* 820d352ac68SChris Mason * defrag a given btree. If cacheonly == 1, this won't read from the disk, 821d352ac68SChris Mason * otherwise every leaf in the btree is read and defragged. 822d352ac68SChris Mason */ 823e9d0b13bSChris Mason int btrfs_defrag_root(struct btrfs_root *root, int cacheonly) 824e9d0b13bSChris Mason { 825e9d0b13bSChris Mason struct btrfs_fs_info *info = root->fs_info; 826e9d0b13bSChris Mason struct btrfs_trans_handle *trans; 8278929ecfaSYan, Zheng int ret; 828d3c2fdcfSChris Mason unsigned long nr; 829e9d0b13bSChris Mason 8308929ecfaSYan, Zheng if (xchg(&root->defrag_running, 1)) 831e9d0b13bSChris Mason return 0; 8328929ecfaSYan, Zheng 8336b80053dSChris Mason while (1) { 8348929ecfaSYan, Zheng trans = btrfs_start_transaction(root, 0); 8358929ecfaSYan, Zheng if (IS_ERR(trans)) 8368929ecfaSYan, Zheng return PTR_ERR(trans); 8378929ecfaSYan, Zheng 838e9d0b13bSChris Mason ret = btrfs_defrag_leaves(trans, root, cacheonly); 8398929ecfaSYan, Zheng 840d3c2fdcfSChris Mason nr = trans->blocks_used; 841e9d0b13bSChris Mason btrfs_end_transaction(trans, root); 842d3c2fdcfSChris Mason btrfs_btree_balance_dirty(info->tree_root, nr); 843e9d0b13bSChris Mason cond_resched(); 844e9d0b13bSChris Mason 8457841cb28SDavid Sterba if (btrfs_fs_closing(root->fs_info) || ret != -EAGAIN) 846e9d0b13bSChris Mason break; 847e9d0b13bSChris Mason } 848e9d0b13bSChris Mason root->defrag_running = 0; 8498929ecfaSYan, Zheng return ret; 850e9d0b13bSChris Mason } 851e9d0b13bSChris Mason 852d352ac68SChris Mason /* 853d352ac68SChris Mason * new snapshots need to be created at a very specific time in the 854d352ac68SChris Mason * transaction commit. This does the actual creation 855d352ac68SChris Mason */ 85680b6794dSChris Mason static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans, 8573063d29fSChris Mason struct btrfs_fs_info *fs_info, 8583063d29fSChris Mason struct btrfs_pending_snapshot *pending) 8593063d29fSChris Mason { 8603063d29fSChris Mason struct btrfs_key key; 86180b6794dSChris Mason struct btrfs_root_item *new_root_item; 8623063d29fSChris Mason struct btrfs_root *tree_root = fs_info->tree_root; 8633063d29fSChris Mason struct btrfs_root *root = pending->root; 8646bdb72deSSage Weil struct btrfs_root *parent_root; 86598c9942aSLiu Bo struct btrfs_block_rsv *rsv; 8666bdb72deSSage Weil struct inode *parent_inode; 8676a912213SJosef Bacik struct dentry *parent; 868a22285a6SYan, Zheng struct dentry *dentry; 8693063d29fSChris Mason struct extent_buffer *tmp; 870925baeddSChris Mason struct extent_buffer *old; 8713063d29fSChris Mason int ret; 872d68fc57bSYan, Zheng u64 to_reserve = 0; 8736bdb72deSSage Weil u64 index = 0; 874a22285a6SYan, Zheng u64 objectid; 875b83cc969SLi Zefan u64 root_flags; 8763063d29fSChris Mason 87798c9942aSLiu Bo rsv = trans->block_rsv; 87898c9942aSLiu Bo 87980b6794dSChris Mason new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS); 88080b6794dSChris Mason if (!new_root_item) { 881a22285a6SYan, Zheng pending->error = -ENOMEM; 88280b6794dSChris Mason goto fail; 88380b6794dSChris Mason } 884a22285a6SYan, Zheng 885581bb050SLi Zefan ret = btrfs_find_free_objectid(tree_root, &objectid); 886a22285a6SYan, Zheng if (ret) { 887a22285a6SYan, Zheng pending->error = ret; 8883063d29fSChris Mason goto fail; 889a22285a6SYan, Zheng } 8903063d29fSChris Mason 8913fd0a558SYan, Zheng btrfs_reloc_pre_snapshot(trans, pending, &to_reserve); 892d68fc57bSYan, Zheng 893d68fc57bSYan, Zheng if (to_reserve > 0) { 89462f30c54SMiao Xie ret = btrfs_block_rsv_add_noflush(root, &pending->block_rsv, 8958bb8ab2eSJosef Bacik to_reserve); 896d68fc57bSYan, Zheng if (ret) { 897d68fc57bSYan, Zheng pending->error = ret; 898d68fc57bSYan, Zheng goto fail; 899d68fc57bSYan, Zheng } 900d68fc57bSYan, Zheng } 901d68fc57bSYan, Zheng 9023063d29fSChris Mason key.objectid = objectid; 903a22285a6SYan, Zheng key.offset = (u64)-1; 904a22285a6SYan, Zheng key.type = BTRFS_ROOT_ITEM_KEY; 9053063d29fSChris Mason 906a22285a6SYan, Zheng trans->block_rsv = &pending->block_rsv; 9076bdb72deSSage Weil 908a22285a6SYan, Zheng dentry = pending->dentry; 9096a912213SJosef Bacik parent = dget_parent(dentry); 9106a912213SJosef Bacik parent_inode = parent->d_inode; 911a22285a6SYan, Zheng parent_root = BTRFS_I(parent_inode)->root; 9127585717fSChris Mason record_root_in_trans(trans, parent_root); 913a22285a6SYan, Zheng 9146bdb72deSSage Weil /* 9156bdb72deSSage Weil * insert the directory item 9166bdb72deSSage Weil */ 9176bdb72deSSage Weil ret = btrfs_set_inode_index(parent_inode, &index); 9186bdb72deSSage Weil BUG_ON(ret); 9196bdb72deSSage Weil ret = btrfs_insert_dir_item(trans, parent_root, 920a22285a6SYan, Zheng dentry->d_name.name, dentry->d_name.len, 92116cdcec7SMiao Xie parent_inode, &key, 922a22285a6SYan, Zheng BTRFS_FT_DIR, index); 9236bdb72deSSage Weil BUG_ON(ret); 9246bdb72deSSage Weil 925a22285a6SYan, Zheng btrfs_i_size_write(parent_inode, parent_inode->i_size + 926a22285a6SYan, Zheng dentry->d_name.len * 2); 9276bdb72deSSage Weil ret = btrfs_update_inode(trans, parent_root, parent_inode); 9286bdb72deSSage Weil BUG_ON(ret); 9296bdb72deSSage Weil 930e999376fSChris Mason /* 931e999376fSChris Mason * pull in the delayed directory update 932e999376fSChris Mason * and the delayed inode item 933e999376fSChris Mason * otherwise we corrupt the FS during 934e999376fSChris Mason * snapshot 935e999376fSChris Mason */ 936e999376fSChris Mason ret = btrfs_run_delayed_items(trans, root); 937e999376fSChris Mason BUG_ON(ret); 938e999376fSChris Mason 9397585717fSChris Mason record_root_in_trans(trans, root); 9406bdb72deSSage Weil btrfs_set_root_last_snapshot(&root->root_item, trans->transid); 9416bdb72deSSage Weil memcpy(new_root_item, &root->root_item, sizeof(*new_root_item)); 94208fe4db1SLi Zefan btrfs_check_and_init_root_item(new_root_item); 9436bdb72deSSage Weil 944b83cc969SLi Zefan root_flags = btrfs_root_flags(new_root_item); 945b83cc969SLi Zefan if (pending->readonly) 946b83cc969SLi Zefan root_flags |= BTRFS_ROOT_SUBVOL_RDONLY; 947b83cc969SLi Zefan else 948b83cc969SLi Zefan root_flags &= ~BTRFS_ROOT_SUBVOL_RDONLY; 949b83cc969SLi Zefan btrfs_set_root_flags(new_root_item, root_flags); 950b83cc969SLi Zefan 951925baeddSChris Mason old = btrfs_lock_root_node(root); 9529fa8cfe7SChris Mason btrfs_cow_block(trans, root, old, NULL, 0, &old); 9535d4f98a2SYan Zheng btrfs_set_lock_blocking(old); 9543063d29fSChris Mason 955925baeddSChris Mason btrfs_copy_root(trans, root, old, &tmp, objectid); 956925baeddSChris Mason btrfs_tree_unlock(old); 957925baeddSChris Mason free_extent_buffer(old); 9583063d29fSChris Mason 959f1ebcc74SLiu Bo /* see comments in should_cow_block() */ 960f1ebcc74SLiu Bo root->force_cow = 1; 961f1ebcc74SLiu Bo smp_wmb(); 962f1ebcc74SLiu Bo 9635d4f98a2SYan Zheng btrfs_set_root_node(new_root_item, tmp); 964a22285a6SYan, Zheng /* record when the snapshot was created in key.offset */ 965a22285a6SYan, Zheng key.offset = trans->transid; 966a22285a6SYan, Zheng ret = btrfs_insert_root(trans, tree_root, &key, new_root_item); 967925baeddSChris Mason btrfs_tree_unlock(tmp); 9683063d29fSChris Mason free_extent_buffer(tmp); 9690660b5afSChris Mason BUG_ON(ret); 9700660b5afSChris Mason 971a22285a6SYan, Zheng /* 972a22285a6SYan, Zheng * insert root back/forward references 973a22285a6SYan, Zheng */ 974a22285a6SYan, Zheng ret = btrfs_add_root_ref(trans, tree_root, objectid, 975a22285a6SYan, Zheng parent_root->root_key.objectid, 97633345d01SLi Zefan btrfs_ino(parent_inode), index, 977a22285a6SYan, Zheng dentry->d_name.name, dentry->d_name.len); 978a22285a6SYan, Zheng BUG_ON(ret); 9796a912213SJosef Bacik dput(parent); 980a22285a6SYan, Zheng 981a22285a6SYan, Zheng key.offset = (u64)-1; 982a22285a6SYan, Zheng pending->snap = btrfs_read_fs_root_no_name(root->fs_info, &key); 983a22285a6SYan, Zheng BUG_ON(IS_ERR(pending->snap)); 984d68fc57bSYan, Zheng 9853fd0a558SYan, Zheng btrfs_reloc_post_snapshot(trans, pending); 9863063d29fSChris Mason fail: 9876bdb72deSSage Weil kfree(new_root_item); 98898c9942aSLiu Bo trans->block_rsv = rsv; 989a22285a6SYan, Zheng btrfs_block_rsv_release(root, &pending->block_rsv, (u64)-1); 990a22285a6SYan, Zheng return 0; 9913063d29fSChris Mason } 9923063d29fSChris Mason 993d352ac68SChris Mason /* 994d352ac68SChris Mason * create all the snapshots we've scheduled for creation 995d352ac68SChris Mason */ 99680b6794dSChris Mason static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans, 9973063d29fSChris Mason struct btrfs_fs_info *fs_info) 9983063d29fSChris Mason { 9993063d29fSChris Mason struct btrfs_pending_snapshot *pending; 10003063d29fSChris Mason struct list_head *head = &trans->transaction->pending_snapshots; 10013de4586cSChris Mason int ret; 10023de4586cSChris Mason 1003c6e30871SQinghuang Feng list_for_each_entry(pending, head, list) { 10043de4586cSChris Mason ret = create_pending_snapshot(trans, fs_info, pending); 10053de4586cSChris Mason BUG_ON(ret); 10063de4586cSChris Mason } 10073de4586cSChris Mason return 0; 10083de4586cSChris Mason } 10093de4586cSChris Mason 10105d4f98a2SYan Zheng static void update_super_roots(struct btrfs_root *root) 10115d4f98a2SYan Zheng { 10125d4f98a2SYan Zheng struct btrfs_root_item *root_item; 10135d4f98a2SYan Zheng struct btrfs_super_block *super; 10145d4f98a2SYan Zheng 10156c41761fSDavid Sterba super = root->fs_info->super_copy; 10165d4f98a2SYan Zheng 10175d4f98a2SYan Zheng root_item = &root->fs_info->chunk_root->root_item; 10185d4f98a2SYan Zheng super->chunk_root = root_item->bytenr; 10195d4f98a2SYan Zheng super->chunk_root_generation = root_item->generation; 10205d4f98a2SYan Zheng super->chunk_root_level = root_item->level; 10215d4f98a2SYan Zheng 10225d4f98a2SYan Zheng root_item = &root->fs_info->tree_root->root_item; 10235d4f98a2SYan Zheng super->root = root_item->bytenr; 10245d4f98a2SYan Zheng super->generation = root_item->generation; 10255d4f98a2SYan Zheng super->root_level = root_item->level; 102673bc1876SJosef Bacik if (btrfs_test_opt(root, SPACE_CACHE)) 10270af3d00bSJosef Bacik super->cache_generation = root_item->generation; 10285d4f98a2SYan Zheng } 10295d4f98a2SYan Zheng 1030f36f3042SChris Mason int btrfs_transaction_in_commit(struct btrfs_fs_info *info) 1031f36f3042SChris Mason { 1032f36f3042SChris Mason int ret = 0; 1033a4abeea4SJosef Bacik spin_lock(&info->trans_lock); 1034f36f3042SChris Mason if (info->running_transaction) 1035f36f3042SChris Mason ret = info->running_transaction->in_commit; 1036a4abeea4SJosef Bacik spin_unlock(&info->trans_lock); 1037f36f3042SChris Mason return ret; 1038f36f3042SChris Mason } 1039f36f3042SChris Mason 10408929ecfaSYan, Zheng int btrfs_transaction_blocked(struct btrfs_fs_info *info) 10418929ecfaSYan, Zheng { 10428929ecfaSYan, Zheng int ret = 0; 1043a4abeea4SJosef Bacik spin_lock(&info->trans_lock); 10448929ecfaSYan, Zheng if (info->running_transaction) 10458929ecfaSYan, Zheng ret = info->running_transaction->blocked; 1046a4abeea4SJosef Bacik spin_unlock(&info->trans_lock); 10478929ecfaSYan, Zheng return ret; 10488929ecfaSYan, Zheng } 10498929ecfaSYan, Zheng 1050bb9c12c9SSage Weil /* 1051bb9c12c9SSage Weil * wait for the current transaction commit to start and block subsequent 1052bb9c12c9SSage Weil * transaction joins 1053bb9c12c9SSage Weil */ 1054bb9c12c9SSage Weil static void wait_current_trans_commit_start(struct btrfs_root *root, 1055bb9c12c9SSage Weil struct btrfs_transaction *trans) 1056bb9c12c9SSage Weil { 105772d63ed6SLi Zefan wait_event(root->fs_info->transaction_blocked_wait, trans->in_commit); 1058bb9c12c9SSage Weil } 1059bb9c12c9SSage Weil 1060bb9c12c9SSage Weil /* 1061bb9c12c9SSage Weil * wait for the current transaction to start and then become unblocked. 1062bb9c12c9SSage Weil * caller holds ref. 1063bb9c12c9SSage Weil */ 1064bb9c12c9SSage Weil static void wait_current_trans_commit_start_and_unblock(struct btrfs_root *root, 1065bb9c12c9SSage Weil struct btrfs_transaction *trans) 1066bb9c12c9SSage Weil { 106772d63ed6SLi Zefan wait_event(root->fs_info->transaction_wait, 106872d63ed6SLi Zefan trans->commit_done || (trans->in_commit && !trans->blocked)); 1069bb9c12c9SSage Weil } 1070bb9c12c9SSage Weil 1071bb9c12c9SSage Weil /* 1072bb9c12c9SSage Weil * commit transactions asynchronously. once btrfs_commit_transaction_async 1073bb9c12c9SSage Weil * returns, any subsequent transaction will not be allowed to join. 1074bb9c12c9SSage Weil */ 1075bb9c12c9SSage Weil struct btrfs_async_commit { 1076bb9c12c9SSage Weil struct btrfs_trans_handle *newtrans; 1077bb9c12c9SSage Weil struct btrfs_root *root; 1078bb9c12c9SSage Weil struct delayed_work work; 1079bb9c12c9SSage Weil }; 1080bb9c12c9SSage Weil 1081bb9c12c9SSage Weil static void do_async_commit(struct work_struct *work) 1082bb9c12c9SSage Weil { 1083bb9c12c9SSage Weil struct btrfs_async_commit *ac = 1084bb9c12c9SSage Weil container_of(work, struct btrfs_async_commit, work.work); 1085bb9c12c9SSage Weil 1086bb9c12c9SSage Weil btrfs_commit_transaction(ac->newtrans, ac->root); 1087bb9c12c9SSage Weil kfree(ac); 1088bb9c12c9SSage Weil } 1089bb9c12c9SSage Weil 1090bb9c12c9SSage Weil int btrfs_commit_transaction_async(struct btrfs_trans_handle *trans, 1091bb9c12c9SSage Weil struct btrfs_root *root, 1092bb9c12c9SSage Weil int wait_for_unblock) 1093bb9c12c9SSage Weil { 1094bb9c12c9SSage Weil struct btrfs_async_commit *ac; 1095bb9c12c9SSage Weil struct btrfs_transaction *cur_trans; 1096bb9c12c9SSage Weil 1097bb9c12c9SSage Weil ac = kmalloc(sizeof(*ac), GFP_NOFS); 1098db5b493aSTsutomu Itoh if (!ac) 1099db5b493aSTsutomu Itoh return -ENOMEM; 1100bb9c12c9SSage Weil 1101bb9c12c9SSage Weil INIT_DELAYED_WORK(&ac->work, do_async_commit); 1102bb9c12c9SSage Weil ac->root = root; 11037a7eaa40SJosef Bacik ac->newtrans = btrfs_join_transaction(root); 11043612b495STsutomu Itoh if (IS_ERR(ac->newtrans)) { 11053612b495STsutomu Itoh int err = PTR_ERR(ac->newtrans); 11063612b495STsutomu Itoh kfree(ac); 11073612b495STsutomu Itoh return err; 11083612b495STsutomu Itoh } 1109bb9c12c9SSage Weil 1110bb9c12c9SSage Weil /* take transaction reference */ 1111bb9c12c9SSage Weil cur_trans = trans->transaction; 111213c5a93eSJosef Bacik atomic_inc(&cur_trans->use_count); 1113bb9c12c9SSage Weil 1114bb9c12c9SSage Weil btrfs_end_transaction(trans, root); 1115bb9c12c9SSage Weil schedule_delayed_work(&ac->work, 0); 1116bb9c12c9SSage Weil 1117bb9c12c9SSage Weil /* wait for transaction to start and unblock */ 1118bb9c12c9SSage Weil if (wait_for_unblock) 1119bb9c12c9SSage Weil wait_current_trans_commit_start_and_unblock(root, cur_trans); 1120bb9c12c9SSage Weil else 1121bb9c12c9SSage Weil wait_current_trans_commit_start(root, cur_trans); 1122bb9c12c9SSage Weil 112338e88054SSage Weil if (current->journal_info == trans) 112438e88054SSage Weil current->journal_info = NULL; 112538e88054SSage Weil 112638e88054SSage Weil put_transaction(cur_trans); 1127bb9c12c9SSage Weil return 0; 1128bb9c12c9SSage Weil } 1129bb9c12c9SSage Weil 1130bb9c12c9SSage Weil /* 1131bb9c12c9SSage Weil * btrfs_transaction state sequence: 1132bb9c12c9SSage Weil * in_commit = 0, blocked = 0 (initial) 1133bb9c12c9SSage Weil * in_commit = 1, blocked = 1 1134bb9c12c9SSage Weil * blocked = 0 1135bb9c12c9SSage Weil * commit_done = 1 1136bb9c12c9SSage Weil */ 113779154b1bSChris Mason int btrfs_commit_transaction(struct btrfs_trans_handle *trans, 113879154b1bSChris Mason struct btrfs_root *root) 113979154b1bSChris Mason { 114015ee9bc7SJosef Bacik unsigned long joined = 0; 114179154b1bSChris Mason struct btrfs_transaction *cur_trans; 11428fd17795SChris Mason struct btrfs_transaction *prev_trans = NULL; 114379154b1bSChris Mason DEFINE_WAIT(wait); 114415ee9bc7SJosef Bacik int ret; 114589573b9cSChris Mason int should_grow = 0; 114689573b9cSChris Mason unsigned long now = get_seconds(); 1147dccae999SSage Weil int flush_on_commit = btrfs_test_opt(root, FLUSHONCOMMIT); 114879154b1bSChris Mason 11495a3f23d5SChris Mason btrfs_run_ordered_operations(root, 0); 11505a3f23d5SChris Mason 1151b24e03dbSJosef Bacik btrfs_trans_release_metadata(trans, root); 11529c8d86dbSJosef Bacik trans->block_rsv = NULL; 11539c8d86dbSJosef Bacik 115456bec294SChris Mason /* make a pass through all the delayed refs we have so far 115556bec294SChris Mason * any runnings procs may add more while we are here 115656bec294SChris Mason */ 115756bec294SChris Mason ret = btrfs_run_delayed_refs(trans, root, 0); 115856bec294SChris Mason BUG_ON(ret); 115956bec294SChris Mason 1160b7ec40d7SChris Mason cur_trans = trans->transaction; 116156bec294SChris Mason /* 116256bec294SChris Mason * set the flushing flag so procs in this transaction have to 116356bec294SChris Mason * start sending their work down. 116456bec294SChris Mason */ 1165b7ec40d7SChris Mason cur_trans->delayed_refs.flushing = 1; 116656bec294SChris Mason 1167c3e69d58SChris Mason ret = btrfs_run_delayed_refs(trans, root, 0); 116856bec294SChris Mason BUG_ON(ret); 116956bec294SChris Mason 1170a4abeea4SJosef Bacik spin_lock(&cur_trans->commit_lock); 1171b7ec40d7SChris Mason if (cur_trans->in_commit) { 1172a4abeea4SJosef Bacik spin_unlock(&cur_trans->commit_lock); 117313c5a93eSJosef Bacik atomic_inc(&cur_trans->use_count); 117479154b1bSChris Mason btrfs_end_transaction(trans, root); 1175ccd467d6SChris Mason 1176b9c8300cSLi Zefan wait_for_commit(root, cur_trans); 117715ee9bc7SJosef Bacik 117879154b1bSChris Mason put_transaction(cur_trans); 117915ee9bc7SJosef Bacik 118079154b1bSChris Mason return 0; 118179154b1bSChris Mason } 11824313b399SChris Mason 11832c90e5d6SChris Mason trans->transaction->in_commit = 1; 1184f9295749SChris Mason trans->transaction->blocked = 1; 1185a4abeea4SJosef Bacik spin_unlock(&cur_trans->commit_lock); 1186bb9c12c9SSage Weil wake_up(&root->fs_info->transaction_blocked_wait); 1187bb9c12c9SSage Weil 1188a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 1189ccd467d6SChris Mason if (cur_trans->list.prev != &root->fs_info->trans_list) { 1190ccd467d6SChris Mason prev_trans = list_entry(cur_trans->list.prev, 1191ccd467d6SChris Mason struct btrfs_transaction, list); 1192ccd467d6SChris Mason if (!prev_trans->commit_done) { 119313c5a93eSJosef Bacik atomic_inc(&prev_trans->use_count); 1194a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 1195ccd467d6SChris Mason 1196ccd467d6SChris Mason wait_for_commit(root, prev_trans); 1197ccd467d6SChris Mason 119815ee9bc7SJosef Bacik put_transaction(prev_trans); 1199a4abeea4SJosef Bacik } else { 1200a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 1201ccd467d6SChris Mason } 1202a4abeea4SJosef Bacik } else { 1203a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 1204ccd467d6SChris Mason } 120515ee9bc7SJosef Bacik 120689573b9cSChris Mason if (now < cur_trans->start_time || now - cur_trans->start_time < 1) 120789573b9cSChris Mason should_grow = 1; 120889573b9cSChris Mason 120915ee9bc7SJosef Bacik do { 12107ea394f1SYan Zheng int snap_pending = 0; 1211a4abeea4SJosef Bacik 121215ee9bc7SJosef Bacik joined = cur_trans->num_joined; 12137ea394f1SYan Zheng if (!list_empty(&trans->transaction->pending_snapshots)) 12147ea394f1SYan Zheng snap_pending = 1; 12157ea394f1SYan Zheng 12162c90e5d6SChris Mason WARN_ON(cur_trans != trans->transaction); 121715ee9bc7SJosef Bacik 12180bdb1db2SSage Weil if (flush_on_commit || snap_pending) { 121924bbcf04SYan, Zheng btrfs_start_delalloc_inodes(root, 1); 122024bbcf04SYan, Zheng ret = btrfs_wait_ordered_extents(root, 0, 1); 1221ebecd3d9SSage Weil BUG_ON(ret); 12227ea394f1SYan Zheng } 12237ea394f1SYan Zheng 122416cdcec7SMiao Xie ret = btrfs_run_delayed_items(trans, root); 122516cdcec7SMiao Xie BUG_ON(ret); 122616cdcec7SMiao Xie 12275a3f23d5SChris Mason /* 12285a3f23d5SChris Mason * rename don't use btrfs_join_transaction, so, once we 12295a3f23d5SChris Mason * set the transaction to blocked above, we aren't going 12305a3f23d5SChris Mason * to get any new ordered operations. We can safely run 12315a3f23d5SChris Mason * it here and no for sure that nothing new will be added 12325a3f23d5SChris Mason * to the list 12335a3f23d5SChris Mason */ 12345a3f23d5SChris Mason btrfs_run_ordered_operations(root, 1); 12355a3f23d5SChris Mason 1236ed3b3d31SChris Mason prepare_to_wait(&cur_trans->writer_wait, &wait, 1237ed3b3d31SChris Mason TASK_UNINTERRUPTIBLE); 1238ed3b3d31SChris Mason 123913c5a93eSJosef Bacik if (atomic_read(&cur_trans->num_writers) > 1) 124099d16cbcSSage Weil schedule_timeout(MAX_SCHEDULE_TIMEOUT); 124199d16cbcSSage Weil else if (should_grow) 124299d16cbcSSage Weil schedule_timeout(1); 124315ee9bc7SJosef Bacik 124415ee9bc7SJosef Bacik finish_wait(&cur_trans->writer_wait, &wait); 1245ed0ca140SJosef Bacik } while (atomic_read(&cur_trans->num_writers) > 1 || 1246ed0ca140SJosef Bacik (should_grow && cur_trans->num_joined != joined)); 1247ed0ca140SJosef Bacik 1248ed0ca140SJosef Bacik /* 1249ed0ca140SJosef Bacik * Ok now we need to make sure to block out any other joins while we 1250ed0ca140SJosef Bacik * commit the transaction. We could have started a join before setting 1251ed0ca140SJosef Bacik * no_join so make sure to wait for num_writers to == 1 again. 1252ed0ca140SJosef Bacik */ 1253a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 1254a4abeea4SJosef Bacik root->fs_info->trans_no_join = 1; 1255a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 1256ed0ca140SJosef Bacik wait_event(cur_trans->writer_wait, 1257ed0ca140SJosef Bacik atomic_read(&cur_trans->num_writers) == 1); 125815ee9bc7SJosef Bacik 12597585717fSChris Mason /* 12607585717fSChris Mason * the reloc mutex makes sure that we stop 12617585717fSChris Mason * the balancing code from coming in and moving 12627585717fSChris Mason * extents around in the middle of the commit 12637585717fSChris Mason */ 12647585717fSChris Mason mutex_lock(&root->fs_info->reloc_mutex); 12657585717fSChris Mason 1266e999376fSChris Mason ret = btrfs_run_delayed_items(trans, root); 12673063d29fSChris Mason BUG_ON(ret); 12683063d29fSChris Mason 1269e999376fSChris Mason ret = create_pending_snapshots(trans, root->fs_info); 127016cdcec7SMiao Xie BUG_ON(ret); 127116cdcec7SMiao Xie 127256bec294SChris Mason ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); 127356bec294SChris Mason BUG_ON(ret); 127456bec294SChris Mason 1275e999376fSChris Mason /* 1276e999376fSChris Mason * make sure none of the code above managed to slip in a 1277e999376fSChris Mason * delayed item 1278e999376fSChris Mason */ 1279e999376fSChris Mason btrfs_assert_delayed_root_empty(root); 1280e999376fSChris Mason 12812c90e5d6SChris Mason WARN_ON(cur_trans != trans->transaction); 1282dc17ff8fSChris Mason 1283a2de733cSArne Jansen btrfs_scrub_pause(root); 1284e02119d5SChris Mason /* btrfs_commit_tree_roots is responsible for getting the 1285e02119d5SChris Mason * various roots consistent with each other. Every pointer 1286e02119d5SChris Mason * in the tree of tree roots has to point to the most up to date 1287e02119d5SChris Mason * root for every subvolume and other tree. So, we have to keep 1288e02119d5SChris Mason * the tree logging code from jumping in and changing any 1289e02119d5SChris Mason * of the trees. 1290e02119d5SChris Mason * 1291e02119d5SChris Mason * At this point in the commit, there can't be any tree-log 1292e02119d5SChris Mason * writers, but a little lower down we drop the trans mutex 1293e02119d5SChris Mason * and let new people in. By holding the tree_log_mutex 1294e02119d5SChris Mason * from now until after the super is written, we avoid races 1295e02119d5SChris Mason * with the tree-log code. 1296e02119d5SChris Mason */ 1297e02119d5SChris Mason mutex_lock(&root->fs_info->tree_log_mutex); 12981a40e23bSZheng Yan 12995d4f98a2SYan Zheng ret = commit_fs_roots(trans, root); 130054aa1f4dSChris Mason BUG_ON(ret); 130154aa1f4dSChris Mason 13025d4f98a2SYan Zheng /* commit_fs_roots gets rid of all the tree log roots, it is now 1303e02119d5SChris Mason * safe to free the root of tree log roots 1304e02119d5SChris Mason */ 1305e02119d5SChris Mason btrfs_free_log_root_tree(trans, root->fs_info); 1306e02119d5SChris Mason 13075d4f98a2SYan Zheng ret = commit_cowonly_roots(trans, root); 130879154b1bSChris Mason BUG_ON(ret); 130954aa1f4dSChris Mason 131011833d66SYan Zheng btrfs_prepare_extent_commit(trans, root); 131111833d66SYan Zheng 131278fae27eSChris Mason cur_trans = root->fs_info->running_transaction; 13135f39d397SChris Mason 13145d4f98a2SYan Zheng btrfs_set_root_node(&root->fs_info->tree_root->root_item, 13155d4f98a2SYan Zheng root->fs_info->tree_root->node); 1316817d52f8SJosef Bacik switch_commit_root(root->fs_info->tree_root); 13175d4f98a2SYan Zheng 13185d4f98a2SYan Zheng btrfs_set_root_node(&root->fs_info->chunk_root->root_item, 13195d4f98a2SYan Zheng root->fs_info->chunk_root->node); 1320817d52f8SJosef Bacik switch_commit_root(root->fs_info->chunk_root); 13215d4f98a2SYan Zheng 13225d4f98a2SYan Zheng update_super_roots(root); 1323e02119d5SChris Mason 1324e02119d5SChris Mason if (!root->fs_info->log_root_recovering) { 13256c41761fSDavid Sterba btrfs_set_super_log_root(root->fs_info->super_copy, 0); 13266c41761fSDavid Sterba btrfs_set_super_log_root_level(root->fs_info->super_copy, 0); 1327e02119d5SChris Mason } 1328e02119d5SChris Mason 13296c41761fSDavid Sterba memcpy(root->fs_info->super_for_commit, root->fs_info->super_copy, 13306c41761fSDavid Sterba sizeof(*root->fs_info->super_copy)); 1331ccd467d6SChris Mason 1332f9295749SChris Mason trans->transaction->blocked = 0; 1333a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 1334a4abeea4SJosef Bacik root->fs_info->running_transaction = NULL; 1335a4abeea4SJosef Bacik root->fs_info->trans_no_join = 0; 1336a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 13377585717fSChris Mason mutex_unlock(&root->fs_info->reloc_mutex); 1338b7ec40d7SChris Mason 1339f9295749SChris Mason wake_up(&root->fs_info->transaction_wait); 1340e6dcd2dcSChris Mason 134179154b1bSChris Mason ret = btrfs_write_and_wait_transaction(trans, root); 134279154b1bSChris Mason BUG_ON(ret); 1343a512bbf8SYan Zheng write_ctree_super(trans, root, 0); 13444313b399SChris Mason 1345e02119d5SChris Mason /* 1346e02119d5SChris Mason * the super is written, we can safely allow the tree-loggers 1347e02119d5SChris Mason * to go about their business 1348e02119d5SChris Mason */ 1349e02119d5SChris Mason mutex_unlock(&root->fs_info->tree_log_mutex); 1350e02119d5SChris Mason 135111833d66SYan Zheng btrfs_finish_extent_commit(trans, root); 13524313b399SChris Mason 13532c90e5d6SChris Mason cur_trans->commit_done = 1; 1354b7ec40d7SChris Mason 135515ee9bc7SJosef Bacik root->fs_info->last_trans_committed = cur_trans->transid; 1356817d52f8SJosef Bacik 13572c90e5d6SChris Mason wake_up(&cur_trans->commit_wait); 13583de4586cSChris Mason 1359a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 136013c5a93eSJosef Bacik list_del_init(&cur_trans->list); 1361a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 1362a4abeea4SJosef Bacik 136379154b1bSChris Mason put_transaction(cur_trans); 136478fae27eSChris Mason put_transaction(cur_trans); 136558176a96SJosef Bacik 13661abe9b8aSliubo trace_btrfs_transaction_commit(root); 13671abe9b8aSliubo 1368a2de733cSArne Jansen btrfs_scrub_continue(root); 1369a2de733cSArne Jansen 13709ed74f2dSJosef Bacik if (current->journal_info == trans) 13719ed74f2dSJosef Bacik current->journal_info = NULL; 13729ed74f2dSJosef Bacik 13732c90e5d6SChris Mason kmem_cache_free(btrfs_trans_handle_cachep, trans); 137424bbcf04SYan, Zheng 137524bbcf04SYan, Zheng if (current != root->fs_info->transaction_kthread) 137624bbcf04SYan, Zheng btrfs_run_delayed_iputs(root); 137724bbcf04SYan, Zheng 137879154b1bSChris Mason return ret; 137979154b1bSChris Mason } 138079154b1bSChris Mason 1381d352ac68SChris Mason /* 1382d352ac68SChris Mason * interface function to delete all the snapshots we have scheduled for deletion 1383d352ac68SChris Mason */ 1384e9d0b13bSChris Mason int btrfs_clean_old_snapshots(struct btrfs_root *root) 1385e9d0b13bSChris Mason { 13865d4f98a2SYan Zheng LIST_HEAD(list); 13875d4f98a2SYan Zheng struct btrfs_fs_info *fs_info = root->fs_info; 1388e9d0b13bSChris Mason 1389a4abeea4SJosef Bacik spin_lock(&fs_info->trans_lock); 13905d4f98a2SYan Zheng list_splice_init(&fs_info->dead_roots, &list); 1391a4abeea4SJosef Bacik spin_unlock(&fs_info->trans_lock); 13925d4f98a2SYan Zheng 13935d4f98a2SYan Zheng while (!list_empty(&list)) { 13945d4f98a2SYan Zheng root = list_entry(list.next, struct btrfs_root, root_list); 139576dda93cSYan, Zheng list_del(&root->root_list); 139676dda93cSYan, Zheng 139716cdcec7SMiao Xie btrfs_kill_all_delayed_nodes(root); 139816cdcec7SMiao Xie 139976dda93cSYan, Zheng if (btrfs_header_backref_rev(root->node) < 140076dda93cSYan, Zheng BTRFS_MIXED_BACKREF_REV) 140166d7e7f0SArne Jansen btrfs_drop_snapshot(root, NULL, 0, 0); 140276dda93cSYan, Zheng else 140366d7e7f0SArne Jansen btrfs_drop_snapshot(root, NULL, 1, 0); 1404e9d0b13bSChris Mason } 1405e9d0b13bSChris Mason return 0; 1406e9d0b13bSChris Mason } 1407