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)); 392c90e5d6SChris Mason memset(transaction, 0, sizeof(*transaction)); 402c90e5d6SChris Mason kmem_cache_free(btrfs_transaction_cachep, transaction); 4179154b1bSChris Mason } 4278fae27eSChris Mason } 4379154b1bSChris Mason 44817d52f8SJosef Bacik static noinline void switch_commit_root(struct btrfs_root *root) 45817d52f8SJosef Bacik { 46817d52f8SJosef Bacik free_extent_buffer(root->commit_root); 47817d52f8SJosef Bacik root->commit_root = btrfs_root_node(root); 48817d52f8SJosef Bacik } 49817d52f8SJosef Bacik 50d352ac68SChris Mason /* 51d352ac68SChris Mason * either allocate a new transaction or hop into the existing one 52d352ac68SChris Mason */ 53a4abeea4SJosef Bacik static noinline int join_transaction(struct btrfs_root *root, int nofail) 5479154b1bSChris Mason { 5579154b1bSChris Mason struct btrfs_transaction *cur_trans; 56a4abeea4SJosef Bacik 57a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 58a4abeea4SJosef Bacik if (root->fs_info->trans_no_join) { 59a4abeea4SJosef Bacik if (!nofail) { 60a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 61a4abeea4SJosef Bacik return -EBUSY; 62a4abeea4SJosef Bacik } 63a4abeea4SJosef Bacik } 64a4abeea4SJosef Bacik 6579154b1bSChris Mason cur_trans = root->fs_info->running_transaction; 66a4abeea4SJosef Bacik if (cur_trans) { 67a4abeea4SJosef Bacik atomic_inc(&cur_trans->use_count); 68a4abeea4SJosef Bacik atomic_inc(&cur_trans->num_writers); 69a4abeea4SJosef Bacik cur_trans->num_joined++; 70a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 71a4abeea4SJosef Bacik return 0; 72a4abeea4SJosef Bacik } 73a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 74a4abeea4SJosef Bacik 75a4abeea4SJosef Bacik cur_trans = kmem_cache_alloc(btrfs_transaction_cachep, GFP_NOFS); 76db5b493aSTsutomu Itoh if (!cur_trans) 77db5b493aSTsutomu Itoh return -ENOMEM; 78a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 79a4abeea4SJosef Bacik if (root->fs_info->running_transaction) { 80a4abeea4SJosef Bacik kmem_cache_free(btrfs_transaction_cachep, cur_trans); 81a4abeea4SJosef Bacik cur_trans = root->fs_info->running_transaction; 82a4abeea4SJosef Bacik atomic_inc(&cur_trans->use_count); 83a4abeea4SJosef Bacik atomic_inc(&cur_trans->num_writers); 84a4abeea4SJosef Bacik cur_trans->num_joined++; 85a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 86a4abeea4SJosef Bacik return 0; 87a4abeea4SJosef Bacik } 8813c5a93eSJosef Bacik atomic_set(&cur_trans->num_writers, 1); 8915ee9bc7SJosef Bacik cur_trans->num_joined = 0; 9079154b1bSChris Mason init_waitqueue_head(&cur_trans->writer_wait); 9179154b1bSChris Mason init_waitqueue_head(&cur_trans->commit_wait); 9279154b1bSChris Mason cur_trans->in_commit = 0; 93f9295749SChris Mason cur_trans->blocked = 0; 94a4abeea4SJosef Bacik /* 95a4abeea4SJosef Bacik * One for this trans handle, one so it will live on until we 96a4abeea4SJosef Bacik * commit the transaction. 97a4abeea4SJosef Bacik */ 98a4abeea4SJosef Bacik atomic_set(&cur_trans->use_count, 2); 9979154b1bSChris Mason cur_trans->commit_done = 0; 10008607c1bSChris Mason cur_trans->start_time = get_seconds(); 10156bec294SChris Mason 1026bef4d31SEric Paris cur_trans->delayed_refs.root = RB_ROOT; 10356bec294SChris Mason cur_trans->delayed_refs.num_entries = 0; 104c3e69d58SChris Mason cur_trans->delayed_refs.num_heads_ready = 0; 105c3e69d58SChris Mason cur_trans->delayed_refs.num_heads = 0; 10656bec294SChris Mason cur_trans->delayed_refs.flushing = 0; 107c3e69d58SChris Mason cur_trans->delayed_refs.run_delayed_start = 0; 108a4abeea4SJosef Bacik spin_lock_init(&cur_trans->commit_lock); 10956bec294SChris Mason spin_lock_init(&cur_trans->delayed_refs.lock); 11056bec294SChris Mason 1113063d29fSChris Mason INIT_LIST_HEAD(&cur_trans->pending_snapshots); 1128fd17795SChris Mason list_add_tail(&cur_trans->list, &root->fs_info->trans_list); 113d1310b2eSChris Mason extent_io_tree_init(&cur_trans->dirty_pages, 114f993c883SDavid Sterba root->fs_info->btree_inode->i_mapping); 115a4abeea4SJosef Bacik root->fs_info->generation++; 116a4abeea4SJosef Bacik cur_trans->transid = root->fs_info->generation; 11748ec2cf8SChris Mason root->fs_info->running_transaction = cur_trans; 118a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 11915ee9bc7SJosef Bacik 12079154b1bSChris Mason return 0; 12179154b1bSChris Mason } 12279154b1bSChris Mason 123d352ac68SChris Mason /* 124d397712bSChris Mason * this does all the record keeping required to make sure that a reference 125d397712bSChris Mason * counted root is properly recorded in a given transaction. This is required 126d397712bSChris Mason * to make sure the old root from before we joined the transaction is deleted 127d397712bSChris Mason * when the transaction commits 128d352ac68SChris Mason */ 1297585717fSChris Mason static int record_root_in_trans(struct btrfs_trans_handle *trans, 1305d4f98a2SYan Zheng struct btrfs_root *root) 1316702ed49SChris Mason { 1325d4f98a2SYan Zheng if (root->ref_cows && root->last_trans < trans->transid) { 1336702ed49SChris Mason WARN_ON(root == root->fs_info->extent_root); 1345d4f98a2SYan Zheng WARN_ON(root->commit_root != root->node); 1355d4f98a2SYan Zheng 1367585717fSChris Mason /* 1377585717fSChris Mason * see below for in_trans_setup usage rules 1387585717fSChris Mason * we have the reloc mutex held now, so there 1397585717fSChris Mason * is only one writer in this function 1407585717fSChris Mason */ 1417585717fSChris Mason root->in_trans_setup = 1; 1427585717fSChris Mason 1437585717fSChris Mason /* make sure readers find in_trans_setup before 1447585717fSChris Mason * they find our root->last_trans update 1457585717fSChris Mason */ 1467585717fSChris Mason smp_wmb(); 1477585717fSChris Mason 148a4abeea4SJosef Bacik spin_lock(&root->fs_info->fs_roots_radix_lock); 149a4abeea4SJosef Bacik if (root->last_trans == trans->transid) { 150a4abeea4SJosef Bacik spin_unlock(&root->fs_info->fs_roots_radix_lock); 151a4abeea4SJosef Bacik return 0; 152a4abeea4SJosef Bacik } 1536702ed49SChris Mason radix_tree_tag_set(&root->fs_info->fs_roots_radix, 1546702ed49SChris Mason (unsigned long)root->root_key.objectid, 1556702ed49SChris Mason BTRFS_ROOT_TRANS_TAG); 156a4abeea4SJosef Bacik spin_unlock(&root->fs_info->fs_roots_radix_lock); 1577585717fSChris Mason root->last_trans = trans->transid; 1587585717fSChris Mason 1597585717fSChris Mason /* this is pretty tricky. We don't want to 1607585717fSChris Mason * take the relocation lock in btrfs_record_root_in_trans 1617585717fSChris Mason * unless we're really doing the first setup for this root in 1627585717fSChris Mason * this transaction. 1637585717fSChris Mason * 1647585717fSChris Mason * Normally we'd use root->last_trans as a flag to decide 1657585717fSChris Mason * if we want to take the expensive mutex. 1667585717fSChris Mason * 1677585717fSChris Mason * But, we have to set root->last_trans before we 1687585717fSChris Mason * init the relocation root, otherwise, we trip over warnings 1697585717fSChris Mason * in ctree.c. The solution used here is to flag ourselves 1707585717fSChris Mason * with root->in_trans_setup. When this is 1, we're still 1717585717fSChris Mason * fixing up the reloc trees and everyone must wait. 1727585717fSChris Mason * 1737585717fSChris Mason * When this is zero, they can trust root->last_trans and fly 1747585717fSChris Mason * through btrfs_record_root_in_trans without having to take the 1757585717fSChris Mason * lock. smp_wmb() makes sure that all the writes above are 1767585717fSChris Mason * done before we pop in the zero below 1777585717fSChris Mason */ 1785d4f98a2SYan Zheng btrfs_init_reloc_root(trans, root); 1797585717fSChris Mason smp_wmb(); 1807585717fSChris Mason root->in_trans_setup = 0; 1816702ed49SChris Mason } 1825d4f98a2SYan Zheng return 0; 1836702ed49SChris Mason } 1845d4f98a2SYan Zheng 1857585717fSChris Mason 1867585717fSChris Mason int btrfs_record_root_in_trans(struct btrfs_trans_handle *trans, 1877585717fSChris Mason struct btrfs_root *root) 1887585717fSChris Mason { 1897585717fSChris Mason if (!root->ref_cows) 1907585717fSChris Mason return 0; 1917585717fSChris Mason 1927585717fSChris Mason /* 1937585717fSChris Mason * see record_root_in_trans for comments about in_trans_setup usage 1947585717fSChris Mason * and barriers 1957585717fSChris Mason */ 1967585717fSChris Mason smp_rmb(); 1977585717fSChris Mason if (root->last_trans == trans->transid && 1987585717fSChris Mason !root->in_trans_setup) 1997585717fSChris Mason return 0; 2007585717fSChris Mason 2017585717fSChris Mason mutex_lock(&root->fs_info->reloc_mutex); 2027585717fSChris Mason record_root_in_trans(trans, root); 2037585717fSChris Mason mutex_unlock(&root->fs_info->reloc_mutex); 2047585717fSChris Mason 2057585717fSChris Mason return 0; 2067585717fSChris Mason } 2077585717fSChris Mason 208d352ac68SChris Mason /* wait for commit against the current transaction to become unblocked 209d352ac68SChris Mason * when this is done, it is safe to start a new transaction, but the current 210d352ac68SChris Mason * transaction might not be fully on disk. 211d352ac68SChris Mason */ 21237d1aeeeSChris Mason static void wait_current_trans(struct btrfs_root *root) 21379154b1bSChris Mason { 214f9295749SChris Mason struct btrfs_transaction *cur_trans; 21579154b1bSChris Mason 216a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 217f9295749SChris Mason cur_trans = root->fs_info->running_transaction; 21837d1aeeeSChris Mason if (cur_trans && cur_trans->blocked) { 219f9295749SChris Mason DEFINE_WAIT(wait); 22013c5a93eSJosef Bacik atomic_inc(&cur_trans->use_count); 221a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 222f9295749SChris Mason while (1) { 223f9295749SChris Mason prepare_to_wait(&root->fs_info->transaction_wait, &wait, 224f9295749SChris Mason TASK_UNINTERRUPTIBLE); 225471fa17dSZhao Lei if (!cur_trans->blocked) 226471fa17dSZhao Lei break; 227f9295749SChris Mason schedule(); 228f9295749SChris Mason } 229471fa17dSZhao Lei finish_wait(&root->fs_info->transaction_wait, &wait); 230f9295749SChris Mason put_transaction(cur_trans); 231a4abeea4SJosef Bacik } else { 232a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 233f9295749SChris Mason } 23437d1aeeeSChris Mason } 23537d1aeeeSChris Mason 236249ac1e5SJosef Bacik enum btrfs_trans_type { 237249ac1e5SJosef Bacik TRANS_START, 238249ac1e5SJosef Bacik TRANS_JOIN, 239249ac1e5SJosef Bacik TRANS_USERSPACE, 2400af3d00bSJosef Bacik TRANS_JOIN_NOLOCK, 241249ac1e5SJosef Bacik }; 242249ac1e5SJosef Bacik 243a22285a6SYan, Zheng static int may_wait_transaction(struct btrfs_root *root, int type) 24437d1aeeeSChris Mason { 245a4abeea4SJosef Bacik if (root->fs_info->log_root_recovering) 246a4abeea4SJosef Bacik return 0; 247a4abeea4SJosef Bacik 248a4abeea4SJosef Bacik if (type == TRANS_USERSPACE) 249a22285a6SYan, Zheng return 1; 250a4abeea4SJosef Bacik 251a4abeea4SJosef Bacik if (type == TRANS_START && 252a4abeea4SJosef Bacik !atomic_read(&root->fs_info->open_ioctl_trans)) 253a4abeea4SJosef Bacik return 1; 254a4abeea4SJosef Bacik 255a22285a6SYan, Zheng return 0; 256a22285a6SYan, Zheng } 257a22285a6SYan, Zheng 258a22285a6SYan, Zheng static struct btrfs_trans_handle *start_transaction(struct btrfs_root *root, 259a22285a6SYan, Zheng u64 num_items, int type) 260a22285a6SYan, Zheng { 261a22285a6SYan, Zheng struct btrfs_trans_handle *h; 262a22285a6SYan, Zheng struct btrfs_transaction *cur_trans; 263b5009945SJosef Bacik u64 num_bytes = 0; 264a22285a6SYan, Zheng int ret; 265acce952bSliubo 266acce952bSliubo if (root->fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) 267acce952bSliubo return ERR_PTR(-EROFS); 2682a1eb461SJosef Bacik 2692a1eb461SJosef Bacik if (current->journal_info) { 2702a1eb461SJosef Bacik WARN_ON(type != TRANS_JOIN && type != TRANS_JOIN_NOLOCK); 2712a1eb461SJosef Bacik h = current->journal_info; 2722a1eb461SJosef Bacik h->use_count++; 2732a1eb461SJosef Bacik h->orig_rsv = h->block_rsv; 2742a1eb461SJosef Bacik h->block_rsv = NULL; 2752a1eb461SJosef Bacik goto got_it; 2762a1eb461SJosef Bacik } 277b5009945SJosef Bacik 278b5009945SJosef Bacik /* 279b5009945SJosef Bacik * Do the reservation before we join the transaction so we can do all 280b5009945SJosef Bacik * the appropriate flushing if need be. 281b5009945SJosef Bacik */ 282b5009945SJosef Bacik if (num_items > 0 && root != root->fs_info->chunk_root) { 283b5009945SJosef Bacik num_bytes = btrfs_calc_trans_metadata_size(root, num_items); 284b5009945SJosef Bacik ret = btrfs_block_rsv_add(NULL, root, 285b5009945SJosef Bacik &root->fs_info->trans_block_rsv, 286b5009945SJosef Bacik num_bytes); 287b5009945SJosef Bacik if (ret) 288b5009945SJosef Bacik return ERR_PTR(ret); 289b5009945SJosef Bacik } 290a22285a6SYan, Zheng again: 291a22285a6SYan, Zheng h = kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS); 292a22285a6SYan, Zheng if (!h) 293a22285a6SYan, Zheng return ERR_PTR(-ENOMEM); 294a22285a6SYan, Zheng 295a22285a6SYan, Zheng if (may_wait_transaction(root, type)) 29637d1aeeeSChris Mason wait_current_trans(root); 297a22285a6SYan, Zheng 298a4abeea4SJosef Bacik do { 299a4abeea4SJosef Bacik ret = join_transaction(root, type == TRANS_JOIN_NOLOCK); 300a4abeea4SJosef Bacik if (ret == -EBUSY) 301a4abeea4SJosef Bacik wait_current_trans(root); 302a4abeea4SJosef Bacik } while (ret == -EBUSY); 303a4abeea4SJosef Bacik 304db5b493aSTsutomu Itoh if (ret < 0) { 3056e8df2aeSYoshinori Sano kmem_cache_free(btrfs_trans_handle_cachep, h); 306db5b493aSTsutomu Itoh return ERR_PTR(ret); 307db5b493aSTsutomu Itoh } 3080f7d52f4SChris Mason 309a22285a6SYan, Zheng cur_trans = root->fs_info->running_transaction; 310a22285a6SYan, Zheng 311a22285a6SYan, Zheng h->transid = cur_trans->transid; 312a22285a6SYan, Zheng h->transaction = cur_trans; 31379154b1bSChris Mason h->blocks_used = 0; 314a22285a6SYan, Zheng h->bytes_reserved = 0; 31556bec294SChris Mason h->delayed_ref_updates = 0; 3162a1eb461SJosef Bacik h->use_count = 1; 317f0486c68SYan, Zheng h->block_rsv = NULL; 3182a1eb461SJosef Bacik h->orig_rsv = NULL; 319b7ec40d7SChris Mason 320a22285a6SYan, Zheng smp_mb(); 321a22285a6SYan, Zheng if (cur_trans->blocked && may_wait_transaction(root, type)) { 322a22285a6SYan, Zheng btrfs_commit_transaction(h, root); 323a22285a6SYan, Zheng goto again; 324a22285a6SYan, Zheng } 3259ed74f2dSJosef Bacik 326b5009945SJosef Bacik if (num_bytes) { 327b5009945SJosef Bacik h->block_rsv = &root->fs_info->trans_block_rsv; 328b5009945SJosef Bacik h->bytes_reserved = num_bytes; 329a22285a6SYan, Zheng } 330a22285a6SYan, Zheng 3312a1eb461SJosef Bacik got_it: 332a4abeea4SJosef Bacik btrfs_record_root_in_trans(h, root); 333a22285a6SYan, Zheng 334a22285a6SYan, Zheng if (!current->journal_info && type != TRANS_USERSPACE) 335a22285a6SYan, Zheng current->journal_info = h; 33679154b1bSChris Mason return h; 33779154b1bSChris Mason } 33879154b1bSChris Mason 339f9295749SChris Mason struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root, 340a22285a6SYan, Zheng int num_items) 341f9295749SChris Mason { 342a22285a6SYan, Zheng return start_transaction(root, num_items, TRANS_START); 343f9295749SChris Mason } 3447a7eaa40SJosef Bacik struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root) 345f9295749SChris Mason { 346a22285a6SYan, Zheng return start_transaction(root, 0, TRANS_JOIN); 347f9295749SChris Mason } 348f9295749SChris Mason 3497a7eaa40SJosef Bacik struct btrfs_trans_handle *btrfs_join_transaction_nolock(struct btrfs_root *root) 3500af3d00bSJosef Bacik { 3510af3d00bSJosef Bacik return start_transaction(root, 0, TRANS_JOIN_NOLOCK); 3520af3d00bSJosef Bacik } 3530af3d00bSJosef Bacik 3547a7eaa40SJosef Bacik struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *root) 3559ca9ee09SSage Weil { 3567a7eaa40SJosef Bacik return start_transaction(root, 0, TRANS_USERSPACE); 3579ca9ee09SSage Weil } 3589ca9ee09SSage Weil 359d352ac68SChris Mason /* wait for a transaction commit to be fully complete */ 36089ce8a63SChris Mason static noinline int wait_for_commit(struct btrfs_root *root, 36189ce8a63SChris Mason struct btrfs_transaction *commit) 36289ce8a63SChris Mason { 36389ce8a63SChris Mason DEFINE_WAIT(wait); 36489ce8a63SChris Mason while (!commit->commit_done) { 36589ce8a63SChris Mason prepare_to_wait(&commit->commit_wait, &wait, 36689ce8a63SChris Mason TASK_UNINTERRUPTIBLE); 36789ce8a63SChris Mason if (commit->commit_done) 36889ce8a63SChris Mason break; 36989ce8a63SChris Mason schedule(); 37089ce8a63SChris Mason } 37189ce8a63SChris Mason finish_wait(&commit->commit_wait, &wait); 37289ce8a63SChris Mason return 0; 37389ce8a63SChris Mason } 37489ce8a63SChris Mason 37546204592SSage Weil int btrfs_wait_for_commit(struct btrfs_root *root, u64 transid) 37646204592SSage Weil { 37746204592SSage Weil struct btrfs_transaction *cur_trans = NULL, *t; 37846204592SSage Weil int ret; 37946204592SSage Weil 38046204592SSage Weil ret = 0; 38146204592SSage Weil if (transid) { 38246204592SSage Weil if (transid <= root->fs_info->last_trans_committed) 383a4abeea4SJosef Bacik goto out; 38446204592SSage Weil 38546204592SSage Weil /* find specified transaction */ 386a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 38746204592SSage Weil list_for_each_entry(t, &root->fs_info->trans_list, list) { 38846204592SSage Weil if (t->transid == transid) { 38946204592SSage Weil cur_trans = t; 390a4abeea4SJosef Bacik atomic_inc(&cur_trans->use_count); 39146204592SSage Weil break; 39246204592SSage Weil } 39346204592SSage Weil if (t->transid > transid) 39446204592SSage Weil break; 39546204592SSage Weil } 396a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 39746204592SSage Weil ret = -EINVAL; 39846204592SSage Weil if (!cur_trans) 399a4abeea4SJosef Bacik goto out; /* bad transid */ 40046204592SSage Weil } else { 40146204592SSage Weil /* find newest transaction that is committing | committed */ 402a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 40346204592SSage Weil list_for_each_entry_reverse(t, &root->fs_info->trans_list, 40446204592SSage Weil list) { 40546204592SSage Weil if (t->in_commit) { 40646204592SSage Weil if (t->commit_done) 4073473f3c0SJosef Bacik break; 40846204592SSage Weil cur_trans = t; 409a4abeea4SJosef Bacik atomic_inc(&cur_trans->use_count); 41046204592SSage Weil break; 41146204592SSage Weil } 41246204592SSage Weil } 413a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 41446204592SSage Weil if (!cur_trans) 415a4abeea4SJosef Bacik goto out; /* nothing committing|committed */ 41646204592SSage Weil } 41746204592SSage Weil 41846204592SSage Weil wait_for_commit(root, cur_trans); 41946204592SSage Weil 42046204592SSage Weil put_transaction(cur_trans); 42146204592SSage Weil ret = 0; 422a4abeea4SJosef Bacik out: 42346204592SSage Weil return ret; 42446204592SSage Weil } 42546204592SSage Weil 42637d1aeeeSChris Mason void btrfs_throttle(struct btrfs_root *root) 42737d1aeeeSChris Mason { 428a4abeea4SJosef Bacik if (!atomic_read(&root->fs_info->open_ioctl_trans)) 42937d1aeeeSChris Mason wait_current_trans(root); 43037d1aeeeSChris Mason } 43137d1aeeeSChris Mason 4328929ecfaSYan, Zheng static int should_end_transaction(struct btrfs_trans_handle *trans, 4338929ecfaSYan, Zheng struct btrfs_root *root) 4348929ecfaSYan, Zheng { 4358929ecfaSYan, Zheng int ret; 4368929ecfaSYan, Zheng ret = btrfs_block_rsv_check(trans, root, 4378929ecfaSYan, Zheng &root->fs_info->global_block_rsv, 0, 5); 4388929ecfaSYan, Zheng return ret ? 1 : 0; 4398929ecfaSYan, Zheng } 4408929ecfaSYan, Zheng 4418929ecfaSYan, Zheng int btrfs_should_end_transaction(struct btrfs_trans_handle *trans, 4428929ecfaSYan, Zheng struct btrfs_root *root) 4438929ecfaSYan, Zheng { 4448929ecfaSYan, Zheng struct btrfs_transaction *cur_trans = trans->transaction; 4458929ecfaSYan, Zheng int updates; 4468929ecfaSYan, Zheng 447a4abeea4SJosef Bacik smp_mb(); 4488929ecfaSYan, Zheng if (cur_trans->blocked || cur_trans->delayed_refs.flushing) 4498929ecfaSYan, Zheng return 1; 4508929ecfaSYan, Zheng 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 4568929ecfaSYan, Zheng return should_end_transaction(trans, root); 4578929ecfaSYan, Zheng } 4588929ecfaSYan, Zheng 45989ce8a63SChris Mason static int __btrfs_end_transaction(struct btrfs_trans_handle *trans, 4600af3d00bSJosef Bacik struct btrfs_root *root, int throttle, int lock) 46179154b1bSChris Mason { 4628929ecfaSYan, Zheng struct btrfs_transaction *cur_trans = trans->transaction; 463ab78c84dSChris Mason struct btrfs_fs_info *info = root->fs_info; 464c3e69d58SChris Mason int count = 0; 465d6e4a428SChris Mason 4662a1eb461SJosef Bacik if (--trans->use_count) { 4672a1eb461SJosef Bacik trans->block_rsv = trans->orig_rsv; 4682a1eb461SJosef Bacik return 0; 4692a1eb461SJosef Bacik } 4702a1eb461SJosef Bacik 471c3e69d58SChris Mason while (count < 4) { 472c3e69d58SChris Mason unsigned long cur = trans->delayed_ref_updates; 473c3e69d58SChris Mason trans->delayed_ref_updates = 0; 474c3e69d58SChris Mason if (cur && 475c3e69d58SChris Mason trans->transaction->delayed_refs.num_heads_ready > 64) { 476c3e69d58SChris Mason trans->delayed_ref_updates = 0; 477b7ec40d7SChris Mason 478b7ec40d7SChris Mason /* 479b7ec40d7SChris Mason * do a full flush if the transaction is trying 480b7ec40d7SChris Mason * to close 481b7ec40d7SChris Mason */ 482b7ec40d7SChris Mason if (trans->transaction->delayed_refs.flushing) 483b7ec40d7SChris Mason cur = 0; 484c3e69d58SChris Mason btrfs_run_delayed_refs(trans, root, cur); 485c3e69d58SChris Mason } else { 486c3e69d58SChris Mason break; 487c3e69d58SChris Mason } 488c3e69d58SChris Mason count++; 48956bec294SChris Mason } 49056bec294SChris Mason 491a22285a6SYan, Zheng btrfs_trans_release_metadata(trans, root); 492a22285a6SYan, Zheng 493a4abeea4SJosef Bacik if (lock && !atomic_read(&root->fs_info->open_ioctl_trans) && 494a4abeea4SJosef Bacik should_end_transaction(trans, root)) { 4958929ecfaSYan, Zheng trans->transaction->blocked = 1; 496a4abeea4SJosef Bacik smp_wmb(); 497a4abeea4SJosef Bacik } 4988929ecfaSYan, Zheng 4990af3d00bSJosef Bacik if (lock && cur_trans->blocked && !cur_trans->in_commit) { 50081317fdeSJosef Bacik if (throttle) { 50181317fdeSJosef Bacik /* 50281317fdeSJosef Bacik * We may race with somebody else here so end up having 50381317fdeSJosef Bacik * to call end_transaction on ourselves again, so inc 50481317fdeSJosef Bacik * our use_count. 50581317fdeSJosef Bacik */ 50681317fdeSJosef Bacik trans->use_count++; 5078929ecfaSYan, Zheng return btrfs_commit_transaction(trans, root); 50881317fdeSJosef Bacik } else { 5098929ecfaSYan, Zheng wake_up_process(info->transaction_kthread); 5108929ecfaSYan, Zheng } 51181317fdeSJosef Bacik } 5128929ecfaSYan, Zheng 5138929ecfaSYan, Zheng WARN_ON(cur_trans != info->running_transaction); 51413c5a93eSJosef Bacik WARN_ON(atomic_read(&cur_trans->num_writers) < 1); 51513c5a93eSJosef Bacik atomic_dec(&cur_trans->num_writers); 51689ce8a63SChris Mason 51799d16cbcSSage Weil smp_mb(); 51879154b1bSChris Mason if (waitqueue_active(&cur_trans->writer_wait)) 51979154b1bSChris Mason wake_up(&cur_trans->writer_wait); 52079154b1bSChris Mason put_transaction(cur_trans); 5219ed74f2dSJosef Bacik 5229ed74f2dSJosef Bacik if (current->journal_info == trans) 5239ed74f2dSJosef Bacik current->journal_info = NULL; 524d6025579SChris Mason memset(trans, 0, sizeof(*trans)); 5252c90e5d6SChris Mason kmem_cache_free(btrfs_trans_handle_cachep, trans); 526ab78c84dSChris Mason 52724bbcf04SYan, Zheng if (throttle) 52824bbcf04SYan, Zheng btrfs_run_delayed_iputs(root); 52924bbcf04SYan, Zheng 53079154b1bSChris Mason return 0; 53179154b1bSChris Mason } 53279154b1bSChris Mason 53389ce8a63SChris Mason int btrfs_end_transaction(struct btrfs_trans_handle *trans, 53489ce8a63SChris Mason struct btrfs_root *root) 53589ce8a63SChris Mason { 53616cdcec7SMiao Xie int ret; 53716cdcec7SMiao Xie 53816cdcec7SMiao Xie ret = __btrfs_end_transaction(trans, root, 0, 1); 53916cdcec7SMiao Xie if (ret) 54016cdcec7SMiao Xie return ret; 54116cdcec7SMiao Xie return 0; 54289ce8a63SChris Mason } 54389ce8a63SChris Mason 54489ce8a63SChris Mason int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans, 54589ce8a63SChris Mason struct btrfs_root *root) 54689ce8a63SChris Mason { 54716cdcec7SMiao Xie int ret; 54816cdcec7SMiao Xie 54916cdcec7SMiao Xie ret = __btrfs_end_transaction(trans, root, 1, 1); 55016cdcec7SMiao Xie if (ret) 55116cdcec7SMiao Xie return ret; 55216cdcec7SMiao Xie return 0; 5530af3d00bSJosef Bacik } 5540af3d00bSJosef Bacik 5550af3d00bSJosef Bacik int btrfs_end_transaction_nolock(struct btrfs_trans_handle *trans, 5560af3d00bSJosef Bacik struct btrfs_root *root) 5570af3d00bSJosef Bacik { 55816cdcec7SMiao Xie int ret; 55916cdcec7SMiao Xie 56016cdcec7SMiao Xie ret = __btrfs_end_transaction(trans, root, 0, 0); 56116cdcec7SMiao Xie if (ret) 56216cdcec7SMiao Xie return ret; 56316cdcec7SMiao Xie return 0; 56416cdcec7SMiao Xie } 56516cdcec7SMiao Xie 56616cdcec7SMiao Xie int btrfs_end_transaction_dmeta(struct btrfs_trans_handle *trans, 56716cdcec7SMiao Xie struct btrfs_root *root) 56816cdcec7SMiao Xie { 56916cdcec7SMiao Xie return __btrfs_end_transaction(trans, root, 1, 1); 57089ce8a63SChris Mason } 57189ce8a63SChris Mason 572d352ac68SChris Mason /* 573d352ac68SChris Mason * when btree blocks are allocated, they have some corresponding bits set for 574d352ac68SChris Mason * them in one of two extent_io trees. This is used to make sure all of 575690587d1SChris Mason * those extents are sent to disk but does not wait on them 576d352ac68SChris Mason */ 577690587d1SChris Mason int btrfs_write_marked_extents(struct btrfs_root *root, 5788cef4e16SYan, Zheng struct extent_io_tree *dirty_pages, int mark) 57979154b1bSChris Mason { 5807c4452b9SChris Mason int ret; 581777e6bd7SChris Mason int err = 0; 5827c4452b9SChris Mason int werr = 0; 5837c4452b9SChris Mason struct page *page; 5847c4452b9SChris Mason struct inode *btree_inode = root->fs_info->btree_inode; 585777e6bd7SChris Mason u64 start = 0; 5865f39d397SChris Mason u64 end; 5875f39d397SChris Mason unsigned long index; 5887c4452b9SChris Mason 5897c4452b9SChris Mason while (1) { 590777e6bd7SChris Mason ret = find_first_extent_bit(dirty_pages, start, &start, &end, 5918cef4e16SYan, Zheng mark); 5925f39d397SChris Mason if (ret) 5937c4452b9SChris Mason break; 5945f39d397SChris Mason while (start <= end) { 595777e6bd7SChris Mason cond_resched(); 596777e6bd7SChris Mason 5975f39d397SChris Mason index = start >> PAGE_CACHE_SHIFT; 59835ebb934SChris Mason start = (u64)(index + 1) << PAGE_CACHE_SHIFT; 5994bef0848SChris Mason page = find_get_page(btree_inode->i_mapping, index); 6007c4452b9SChris Mason if (!page) 6017c4452b9SChris Mason continue; 6024bef0848SChris Mason 6034bef0848SChris Mason btree_lock_page_hook(page); 6044bef0848SChris Mason if (!page->mapping) { 6054bef0848SChris Mason unlock_page(page); 6064bef0848SChris Mason page_cache_release(page); 6074bef0848SChris Mason continue; 6084bef0848SChris Mason } 6094bef0848SChris Mason 6106702ed49SChris Mason if (PageWriteback(page)) { 6116702ed49SChris Mason if (PageDirty(page)) 6126702ed49SChris Mason wait_on_page_writeback(page); 6136702ed49SChris Mason else { 6146702ed49SChris Mason unlock_page(page); 6156702ed49SChris Mason page_cache_release(page); 6166702ed49SChris Mason continue; 6176702ed49SChris Mason } 6186702ed49SChris Mason } 6197c4452b9SChris Mason err = write_one_page(page, 0); 6207c4452b9SChris Mason if (err) 6217c4452b9SChris Mason werr = err; 6227c4452b9SChris Mason page_cache_release(page); 6237c4452b9SChris Mason } 6247c4452b9SChris Mason } 625690587d1SChris Mason if (err) 626690587d1SChris Mason werr = err; 627690587d1SChris Mason return werr; 628690587d1SChris Mason } 629690587d1SChris Mason 630690587d1SChris Mason /* 631690587d1SChris Mason * when btree blocks are allocated, they have some corresponding bits set for 632690587d1SChris Mason * them in one of two extent_io trees. This is used to make sure all of 633690587d1SChris Mason * those extents are on disk for transaction or log commit. We wait 634690587d1SChris Mason * on all the pages and clear them from the dirty pages state tree 635690587d1SChris Mason */ 636690587d1SChris Mason int btrfs_wait_marked_extents(struct btrfs_root *root, 6378cef4e16SYan, Zheng struct extent_io_tree *dirty_pages, int mark) 638690587d1SChris Mason { 639690587d1SChris Mason int ret; 640690587d1SChris Mason int err = 0; 641690587d1SChris Mason int werr = 0; 642690587d1SChris Mason struct page *page; 643690587d1SChris Mason struct inode *btree_inode = root->fs_info->btree_inode; 644690587d1SChris Mason u64 start = 0; 645690587d1SChris Mason u64 end; 646690587d1SChris Mason unsigned long index; 647690587d1SChris Mason 648777e6bd7SChris Mason while (1) { 6498cef4e16SYan, Zheng ret = find_first_extent_bit(dirty_pages, start, &start, &end, 6508cef4e16SYan, Zheng mark); 651777e6bd7SChris Mason if (ret) 652777e6bd7SChris Mason break; 653777e6bd7SChris Mason 6548cef4e16SYan, Zheng clear_extent_bits(dirty_pages, start, end, mark, GFP_NOFS); 655777e6bd7SChris Mason while (start <= end) { 656777e6bd7SChris Mason index = start >> PAGE_CACHE_SHIFT; 657777e6bd7SChris Mason start = (u64)(index + 1) << PAGE_CACHE_SHIFT; 658777e6bd7SChris Mason page = find_get_page(btree_inode->i_mapping, index); 659777e6bd7SChris Mason if (!page) 660777e6bd7SChris Mason continue; 661777e6bd7SChris Mason if (PageDirty(page)) { 6624bef0848SChris Mason btree_lock_page_hook(page); 6634bef0848SChris Mason wait_on_page_writeback(page); 664777e6bd7SChris Mason err = write_one_page(page, 0); 665777e6bd7SChris Mason if (err) 666777e6bd7SChris Mason werr = err; 667777e6bd7SChris Mason } 668777e6bd7SChris Mason wait_on_page_writeback(page); 669777e6bd7SChris Mason page_cache_release(page); 670777e6bd7SChris Mason cond_resched(); 671777e6bd7SChris Mason } 672777e6bd7SChris Mason } 6737c4452b9SChris Mason if (err) 6747c4452b9SChris Mason werr = err; 6757c4452b9SChris Mason return werr; 67679154b1bSChris Mason } 67779154b1bSChris Mason 678690587d1SChris Mason /* 679690587d1SChris Mason * when btree blocks are allocated, they have some corresponding bits set for 680690587d1SChris Mason * them in one of two extent_io trees. This is used to make sure all of 681690587d1SChris Mason * those extents are on disk for transaction or log commit 682690587d1SChris Mason */ 683690587d1SChris Mason int btrfs_write_and_wait_marked_extents(struct btrfs_root *root, 6848cef4e16SYan, Zheng struct extent_io_tree *dirty_pages, int mark) 685690587d1SChris Mason { 686690587d1SChris Mason int ret; 687690587d1SChris Mason int ret2; 688690587d1SChris Mason 6898cef4e16SYan, Zheng ret = btrfs_write_marked_extents(root, dirty_pages, mark); 6908cef4e16SYan, Zheng ret2 = btrfs_wait_marked_extents(root, dirty_pages, mark); 691690587d1SChris Mason return ret || ret2; 692690587d1SChris Mason } 693690587d1SChris Mason 694d0c803c4SChris Mason int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans, 695d0c803c4SChris Mason struct btrfs_root *root) 696d0c803c4SChris Mason { 697d0c803c4SChris Mason if (!trans || !trans->transaction) { 698d0c803c4SChris Mason struct inode *btree_inode; 699d0c803c4SChris Mason btree_inode = root->fs_info->btree_inode; 700d0c803c4SChris Mason return filemap_write_and_wait(btree_inode->i_mapping); 701d0c803c4SChris Mason } 702d0c803c4SChris Mason return btrfs_write_and_wait_marked_extents(root, 7038cef4e16SYan, Zheng &trans->transaction->dirty_pages, 7048cef4e16SYan, Zheng EXTENT_DIRTY); 705d0c803c4SChris Mason } 706d0c803c4SChris Mason 707d352ac68SChris Mason /* 708d352ac68SChris Mason * this is used to update the root pointer in the tree of tree roots. 709d352ac68SChris Mason * 710d352ac68SChris Mason * But, in the case of the extent allocation tree, updating the root 711d352ac68SChris Mason * pointer may allocate blocks which may change the root of the extent 712d352ac68SChris Mason * allocation tree. 713d352ac68SChris Mason * 714d352ac68SChris Mason * So, this loops and repeats and makes sure the cowonly root didn't 715d352ac68SChris Mason * change while the root pointer was being updated in the metadata. 716d352ac68SChris Mason */ 7170b86a832SChris Mason static int update_cowonly_root(struct btrfs_trans_handle *trans, 71879154b1bSChris Mason struct btrfs_root *root) 71979154b1bSChris Mason { 72079154b1bSChris Mason int ret; 7210b86a832SChris Mason u64 old_root_bytenr; 72286b9f2ecSYan, Zheng u64 old_root_used; 7230b86a832SChris Mason struct btrfs_root *tree_root = root->fs_info->tree_root; 72479154b1bSChris Mason 72586b9f2ecSYan, Zheng old_root_used = btrfs_root_used(&root->root_item); 7260b86a832SChris Mason btrfs_write_dirty_block_groups(trans, root); 72756bec294SChris Mason 72879154b1bSChris Mason while (1) { 7290b86a832SChris Mason old_root_bytenr = btrfs_root_bytenr(&root->root_item); 73086b9f2ecSYan, Zheng if (old_root_bytenr == root->node->start && 73186b9f2ecSYan, Zheng old_root_used == btrfs_root_used(&root->root_item)) 73279154b1bSChris Mason break; 73387ef2bb4SChris Mason 7345d4f98a2SYan Zheng btrfs_set_root_node(&root->root_item, root->node); 73579154b1bSChris Mason ret = btrfs_update_root(trans, tree_root, 7360b86a832SChris Mason &root->root_key, 7370b86a832SChris Mason &root->root_item); 73879154b1bSChris Mason BUG_ON(ret); 73956bec294SChris Mason 74086b9f2ecSYan, Zheng old_root_used = btrfs_root_used(&root->root_item); 7414a8c9a62SYan Zheng ret = btrfs_write_dirty_block_groups(trans, root); 74256bec294SChris Mason BUG_ON(ret); 7430b86a832SChris Mason } 744276e680dSYan Zheng 745276e680dSYan Zheng if (root != root->fs_info->extent_root) 746817d52f8SJosef Bacik switch_commit_root(root); 747276e680dSYan Zheng 7480b86a832SChris Mason return 0; 7490b86a832SChris Mason } 7500b86a832SChris Mason 751d352ac68SChris Mason /* 752d352ac68SChris Mason * update all the cowonly tree roots on disk 753d352ac68SChris Mason */ 7545d4f98a2SYan Zheng static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans, 7550b86a832SChris Mason struct btrfs_root *root) 7560b86a832SChris Mason { 7570b86a832SChris Mason struct btrfs_fs_info *fs_info = root->fs_info; 7580b86a832SChris Mason struct list_head *next; 75984234f3aSYan Zheng struct extent_buffer *eb; 76056bec294SChris Mason int ret; 76184234f3aSYan Zheng 76256bec294SChris Mason ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); 76356bec294SChris Mason BUG_ON(ret); 76487ef2bb4SChris Mason 76584234f3aSYan Zheng eb = btrfs_lock_root_node(fs_info->tree_root); 7669fa8cfe7SChris Mason btrfs_cow_block(trans, fs_info->tree_root, eb, NULL, 0, &eb); 76784234f3aSYan Zheng btrfs_tree_unlock(eb); 76884234f3aSYan Zheng free_extent_buffer(eb); 7690b86a832SChris Mason 77056bec294SChris Mason ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); 77156bec294SChris Mason BUG_ON(ret); 77287ef2bb4SChris Mason 7730b86a832SChris Mason while (!list_empty(&fs_info->dirty_cowonly_roots)) { 7740b86a832SChris Mason next = fs_info->dirty_cowonly_roots.next; 7750b86a832SChris Mason list_del_init(next); 7760b86a832SChris Mason root = list_entry(next, struct btrfs_root, dirty_list); 77787ef2bb4SChris Mason 7780b86a832SChris Mason update_cowonly_root(trans, root); 77979154b1bSChris Mason } 780276e680dSYan Zheng 781276e680dSYan Zheng down_write(&fs_info->extent_commit_sem); 782276e680dSYan Zheng switch_commit_root(fs_info->extent_root); 783276e680dSYan Zheng up_write(&fs_info->extent_commit_sem); 784276e680dSYan Zheng 78579154b1bSChris Mason return 0; 78679154b1bSChris Mason } 78779154b1bSChris Mason 788d352ac68SChris Mason /* 789d352ac68SChris Mason * dead roots are old snapshots that need to be deleted. This allocates 790d352ac68SChris Mason * a dirty root struct and adds it into the list of dead roots that need to 791d352ac68SChris Mason * be deleted 792d352ac68SChris Mason */ 7935d4f98a2SYan Zheng int btrfs_add_dead_root(struct btrfs_root *root) 7945eda7b5eSChris Mason { 795a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 7965d4f98a2SYan Zheng list_add(&root->root_list, &root->fs_info->dead_roots); 797a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 7985eda7b5eSChris Mason return 0; 7995eda7b5eSChris Mason } 8005eda7b5eSChris Mason 801d352ac68SChris Mason /* 8025d4f98a2SYan Zheng * update all the cowonly tree roots on disk 803d352ac68SChris Mason */ 8045d4f98a2SYan Zheng static noinline int commit_fs_roots(struct btrfs_trans_handle *trans, 8055d4f98a2SYan Zheng struct btrfs_root *root) 8060f7d52f4SChris Mason { 8070f7d52f4SChris Mason struct btrfs_root *gang[8]; 8085d4f98a2SYan Zheng struct btrfs_fs_info *fs_info = root->fs_info; 8090f7d52f4SChris Mason int i; 8100f7d52f4SChris Mason int ret; 81154aa1f4dSChris Mason int err = 0; 81254aa1f4dSChris Mason 813a4abeea4SJosef Bacik spin_lock(&fs_info->fs_roots_radix_lock); 8140f7d52f4SChris Mason while (1) { 8155d4f98a2SYan Zheng ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix, 8165d4f98a2SYan Zheng (void **)gang, 0, 8170f7d52f4SChris Mason ARRAY_SIZE(gang), 8180f7d52f4SChris Mason BTRFS_ROOT_TRANS_TAG); 8190f7d52f4SChris Mason if (ret == 0) 8200f7d52f4SChris Mason break; 8210f7d52f4SChris Mason for (i = 0; i < ret; i++) { 8220f7d52f4SChris Mason root = gang[i]; 8235d4f98a2SYan Zheng radix_tree_tag_clear(&fs_info->fs_roots_radix, 8242619ba1fSChris Mason (unsigned long)root->root_key.objectid, 8250f7d52f4SChris Mason BTRFS_ROOT_TRANS_TAG); 826a4abeea4SJosef Bacik spin_unlock(&fs_info->fs_roots_radix_lock); 82731153d81SYan Zheng 828e02119d5SChris Mason btrfs_free_log(trans, root); 8295d4f98a2SYan Zheng btrfs_update_reloc_root(trans, root); 830d68fc57bSYan, Zheng btrfs_orphan_commit_root(trans, root); 831e02119d5SChris Mason 83282d5902dSLi Zefan btrfs_save_ino_cache(root, trans); 83382d5902dSLi Zefan 834978d910dSYan Zheng if (root->commit_root != root->node) { 835581bb050SLi Zefan mutex_lock(&root->fs_commit_mutex); 836817d52f8SJosef Bacik switch_commit_root(root); 837581bb050SLi Zefan btrfs_unpin_free_ino(root); 838581bb050SLi Zefan mutex_unlock(&root->fs_commit_mutex); 839581bb050SLi Zefan 840978d910dSYan Zheng btrfs_set_root_node(&root->root_item, 841978d910dSYan Zheng root->node); 842978d910dSYan Zheng } 84331153d81SYan Zheng 8445d4f98a2SYan Zheng err = btrfs_update_root(trans, fs_info->tree_root, 8450f7d52f4SChris Mason &root->root_key, 8460f7d52f4SChris Mason &root->root_item); 847a4abeea4SJosef Bacik spin_lock(&fs_info->fs_roots_radix_lock); 84854aa1f4dSChris Mason if (err) 84954aa1f4dSChris Mason break; 8500f7d52f4SChris Mason } 8519f3a7427SChris Mason } 852a4abeea4SJosef Bacik spin_unlock(&fs_info->fs_roots_radix_lock); 85354aa1f4dSChris Mason return err; 8540f7d52f4SChris Mason } 8550f7d52f4SChris Mason 856d352ac68SChris Mason /* 857d352ac68SChris Mason * defrag a given btree. If cacheonly == 1, this won't read from the disk, 858d352ac68SChris Mason * otherwise every leaf in the btree is read and defragged. 859d352ac68SChris Mason */ 860e9d0b13bSChris Mason int btrfs_defrag_root(struct btrfs_root *root, int cacheonly) 861e9d0b13bSChris Mason { 862e9d0b13bSChris Mason struct btrfs_fs_info *info = root->fs_info; 863e9d0b13bSChris Mason struct btrfs_trans_handle *trans; 8648929ecfaSYan, Zheng int ret; 865d3c2fdcfSChris Mason unsigned long nr; 866e9d0b13bSChris Mason 8678929ecfaSYan, Zheng if (xchg(&root->defrag_running, 1)) 868e9d0b13bSChris Mason return 0; 8698929ecfaSYan, Zheng 8706b80053dSChris Mason while (1) { 8718929ecfaSYan, Zheng trans = btrfs_start_transaction(root, 0); 8728929ecfaSYan, Zheng if (IS_ERR(trans)) 8738929ecfaSYan, Zheng return PTR_ERR(trans); 8748929ecfaSYan, Zheng 875e9d0b13bSChris Mason ret = btrfs_defrag_leaves(trans, root, cacheonly); 8768929ecfaSYan, Zheng 877d3c2fdcfSChris Mason nr = trans->blocks_used; 878e9d0b13bSChris Mason btrfs_end_transaction(trans, root); 879d3c2fdcfSChris Mason btrfs_btree_balance_dirty(info->tree_root, nr); 880e9d0b13bSChris Mason cond_resched(); 881e9d0b13bSChris Mason 8827841cb28SDavid Sterba if (btrfs_fs_closing(root->fs_info) || ret != -EAGAIN) 883e9d0b13bSChris Mason break; 884e9d0b13bSChris Mason } 885e9d0b13bSChris Mason root->defrag_running = 0; 8868929ecfaSYan, Zheng return ret; 887e9d0b13bSChris Mason } 888e9d0b13bSChris Mason 889d352ac68SChris Mason /* 890d352ac68SChris Mason * new snapshots need to be created at a very specific time in the 891d352ac68SChris Mason * transaction commit. This does the actual creation 892d352ac68SChris Mason */ 89380b6794dSChris Mason static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans, 8943063d29fSChris Mason struct btrfs_fs_info *fs_info, 8953063d29fSChris Mason struct btrfs_pending_snapshot *pending) 8963063d29fSChris Mason { 8973063d29fSChris Mason struct btrfs_key key; 89880b6794dSChris Mason struct btrfs_root_item *new_root_item; 8993063d29fSChris Mason struct btrfs_root *tree_root = fs_info->tree_root; 9003063d29fSChris Mason struct btrfs_root *root = pending->root; 9016bdb72deSSage Weil struct btrfs_root *parent_root; 9026bdb72deSSage Weil struct inode *parent_inode; 9036a912213SJosef Bacik struct dentry *parent; 904a22285a6SYan, Zheng struct dentry *dentry; 9053063d29fSChris Mason struct extent_buffer *tmp; 906925baeddSChris Mason struct extent_buffer *old; 9073063d29fSChris Mason int ret; 908d68fc57bSYan, Zheng u64 to_reserve = 0; 9096bdb72deSSage Weil u64 index = 0; 910a22285a6SYan, Zheng u64 objectid; 911b83cc969SLi Zefan u64 root_flags; 9123063d29fSChris Mason 91380b6794dSChris Mason new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS); 91480b6794dSChris Mason if (!new_root_item) { 915a22285a6SYan, Zheng pending->error = -ENOMEM; 91680b6794dSChris Mason goto fail; 91780b6794dSChris Mason } 918a22285a6SYan, Zheng 919581bb050SLi Zefan ret = btrfs_find_free_objectid(tree_root, &objectid); 920a22285a6SYan, Zheng if (ret) { 921a22285a6SYan, Zheng pending->error = ret; 9223063d29fSChris Mason goto fail; 923a22285a6SYan, Zheng } 9243063d29fSChris Mason 9253fd0a558SYan, Zheng btrfs_reloc_pre_snapshot(trans, pending, &to_reserve); 926d68fc57bSYan, Zheng btrfs_orphan_pre_snapshot(trans, pending, &to_reserve); 927d68fc57bSYan, Zheng 928d68fc57bSYan, Zheng if (to_reserve > 0) { 929d68fc57bSYan, Zheng ret = btrfs_block_rsv_add(trans, root, &pending->block_rsv, 9308bb8ab2eSJosef Bacik to_reserve); 931d68fc57bSYan, Zheng if (ret) { 932d68fc57bSYan, Zheng pending->error = ret; 933d68fc57bSYan, Zheng goto fail; 934d68fc57bSYan, Zheng } 935d68fc57bSYan, Zheng } 936d68fc57bSYan, Zheng 9373063d29fSChris Mason key.objectid = objectid; 938a22285a6SYan, Zheng key.offset = (u64)-1; 939a22285a6SYan, Zheng key.type = BTRFS_ROOT_ITEM_KEY; 9403063d29fSChris Mason 941a22285a6SYan, Zheng trans->block_rsv = &pending->block_rsv; 9426bdb72deSSage Weil 943a22285a6SYan, Zheng dentry = pending->dentry; 9446a912213SJosef Bacik parent = dget_parent(dentry); 9456a912213SJosef Bacik parent_inode = parent->d_inode; 946a22285a6SYan, Zheng parent_root = BTRFS_I(parent_inode)->root; 9477585717fSChris Mason record_root_in_trans(trans, parent_root); 948a22285a6SYan, Zheng 9496bdb72deSSage Weil /* 9506bdb72deSSage Weil * insert the directory item 9516bdb72deSSage Weil */ 9526bdb72deSSage Weil ret = btrfs_set_inode_index(parent_inode, &index); 9536bdb72deSSage Weil BUG_ON(ret); 9546bdb72deSSage Weil ret = btrfs_insert_dir_item(trans, parent_root, 955a22285a6SYan, Zheng dentry->d_name.name, dentry->d_name.len, 95616cdcec7SMiao Xie parent_inode, &key, 957a22285a6SYan, Zheng BTRFS_FT_DIR, index); 9586bdb72deSSage Weil BUG_ON(ret); 9596bdb72deSSage Weil 960a22285a6SYan, Zheng btrfs_i_size_write(parent_inode, parent_inode->i_size + 961a22285a6SYan, Zheng dentry->d_name.len * 2); 9626bdb72deSSage Weil ret = btrfs_update_inode(trans, parent_root, parent_inode); 9636bdb72deSSage Weil BUG_ON(ret); 9646bdb72deSSage Weil 965e999376fSChris Mason /* 966e999376fSChris Mason * pull in the delayed directory update 967e999376fSChris Mason * and the delayed inode item 968e999376fSChris Mason * otherwise we corrupt the FS during 969e999376fSChris Mason * snapshot 970e999376fSChris Mason */ 971e999376fSChris Mason ret = btrfs_run_delayed_items(trans, root); 972e999376fSChris Mason BUG_ON(ret); 973e999376fSChris Mason 9747585717fSChris Mason record_root_in_trans(trans, root); 9756bdb72deSSage Weil btrfs_set_root_last_snapshot(&root->root_item, trans->transid); 9766bdb72deSSage Weil memcpy(new_root_item, &root->root_item, sizeof(*new_root_item)); 97708fe4db1SLi Zefan btrfs_check_and_init_root_item(new_root_item); 9786bdb72deSSage Weil 979b83cc969SLi Zefan root_flags = btrfs_root_flags(new_root_item); 980b83cc969SLi Zefan if (pending->readonly) 981b83cc969SLi Zefan root_flags |= BTRFS_ROOT_SUBVOL_RDONLY; 982b83cc969SLi Zefan else 983b83cc969SLi Zefan root_flags &= ~BTRFS_ROOT_SUBVOL_RDONLY; 984b83cc969SLi Zefan btrfs_set_root_flags(new_root_item, root_flags); 985b83cc969SLi Zefan 986925baeddSChris Mason old = btrfs_lock_root_node(root); 9879fa8cfe7SChris Mason btrfs_cow_block(trans, root, old, NULL, 0, &old); 9885d4f98a2SYan Zheng btrfs_set_lock_blocking(old); 9893063d29fSChris Mason 990925baeddSChris Mason btrfs_copy_root(trans, root, old, &tmp, objectid); 991925baeddSChris Mason btrfs_tree_unlock(old); 992925baeddSChris Mason free_extent_buffer(old); 9933063d29fSChris Mason 9945d4f98a2SYan Zheng btrfs_set_root_node(new_root_item, tmp); 995a22285a6SYan, Zheng /* record when the snapshot was created in key.offset */ 996a22285a6SYan, Zheng key.offset = trans->transid; 997a22285a6SYan, Zheng ret = btrfs_insert_root(trans, tree_root, &key, new_root_item); 998925baeddSChris Mason btrfs_tree_unlock(tmp); 9993063d29fSChris Mason free_extent_buffer(tmp); 10000660b5afSChris Mason BUG_ON(ret); 10010660b5afSChris Mason 1002a22285a6SYan, Zheng /* 1003a22285a6SYan, Zheng * insert root back/forward references 1004a22285a6SYan, Zheng */ 1005a22285a6SYan, Zheng ret = btrfs_add_root_ref(trans, tree_root, objectid, 1006a22285a6SYan, Zheng parent_root->root_key.objectid, 100733345d01SLi Zefan btrfs_ino(parent_inode), index, 1008a22285a6SYan, Zheng dentry->d_name.name, dentry->d_name.len); 1009a22285a6SYan, Zheng BUG_ON(ret); 10106a912213SJosef Bacik dput(parent); 1011a22285a6SYan, Zheng 1012a22285a6SYan, Zheng key.offset = (u64)-1; 1013a22285a6SYan, Zheng pending->snap = btrfs_read_fs_root_no_name(root->fs_info, &key); 1014a22285a6SYan, Zheng BUG_ON(IS_ERR(pending->snap)); 1015d68fc57bSYan, Zheng 10163fd0a558SYan, Zheng btrfs_reloc_post_snapshot(trans, pending); 1017d68fc57bSYan, Zheng btrfs_orphan_post_snapshot(trans, pending); 10183063d29fSChris Mason fail: 10196bdb72deSSage Weil kfree(new_root_item); 1020a22285a6SYan, Zheng btrfs_block_rsv_release(root, &pending->block_rsv, (u64)-1); 1021a22285a6SYan, Zheng return 0; 10223063d29fSChris Mason } 10233063d29fSChris Mason 1024d352ac68SChris Mason /* 1025d352ac68SChris Mason * create all the snapshots we've scheduled for creation 1026d352ac68SChris Mason */ 102780b6794dSChris Mason static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans, 10283063d29fSChris Mason struct btrfs_fs_info *fs_info) 10293063d29fSChris Mason { 10303063d29fSChris Mason struct btrfs_pending_snapshot *pending; 10313063d29fSChris Mason struct list_head *head = &trans->transaction->pending_snapshots; 10323de4586cSChris Mason int ret; 10333de4586cSChris Mason 1034c6e30871SQinghuang Feng list_for_each_entry(pending, head, list) { 10353de4586cSChris Mason ret = create_pending_snapshot(trans, fs_info, pending); 10363de4586cSChris Mason BUG_ON(ret); 10373de4586cSChris Mason } 10383de4586cSChris Mason return 0; 10393de4586cSChris Mason } 10403de4586cSChris Mason 10415d4f98a2SYan Zheng static void update_super_roots(struct btrfs_root *root) 10425d4f98a2SYan Zheng { 10435d4f98a2SYan Zheng struct btrfs_root_item *root_item; 10445d4f98a2SYan Zheng struct btrfs_super_block *super; 10455d4f98a2SYan Zheng 10465d4f98a2SYan Zheng super = &root->fs_info->super_copy; 10475d4f98a2SYan Zheng 10485d4f98a2SYan Zheng root_item = &root->fs_info->chunk_root->root_item; 10495d4f98a2SYan Zheng super->chunk_root = root_item->bytenr; 10505d4f98a2SYan Zheng super->chunk_root_generation = root_item->generation; 10515d4f98a2SYan Zheng super->chunk_root_level = root_item->level; 10525d4f98a2SYan Zheng 10535d4f98a2SYan Zheng root_item = &root->fs_info->tree_root->root_item; 10545d4f98a2SYan Zheng super->root = root_item->bytenr; 10555d4f98a2SYan Zheng super->generation = root_item->generation; 10565d4f98a2SYan Zheng super->root_level = root_item->level; 10570af3d00bSJosef Bacik if (super->cache_generation != 0 || btrfs_test_opt(root, SPACE_CACHE)) 10580af3d00bSJosef Bacik super->cache_generation = root_item->generation; 10595d4f98a2SYan Zheng } 10605d4f98a2SYan Zheng 1061f36f3042SChris Mason int btrfs_transaction_in_commit(struct btrfs_fs_info *info) 1062f36f3042SChris Mason { 1063f36f3042SChris Mason int ret = 0; 1064a4abeea4SJosef Bacik spin_lock(&info->trans_lock); 1065f36f3042SChris Mason if (info->running_transaction) 1066f36f3042SChris Mason ret = info->running_transaction->in_commit; 1067a4abeea4SJosef Bacik spin_unlock(&info->trans_lock); 1068f36f3042SChris Mason return ret; 1069f36f3042SChris Mason } 1070f36f3042SChris Mason 10718929ecfaSYan, Zheng int btrfs_transaction_blocked(struct btrfs_fs_info *info) 10728929ecfaSYan, Zheng { 10738929ecfaSYan, Zheng int ret = 0; 1074a4abeea4SJosef Bacik spin_lock(&info->trans_lock); 10758929ecfaSYan, Zheng if (info->running_transaction) 10768929ecfaSYan, Zheng ret = info->running_transaction->blocked; 1077a4abeea4SJosef Bacik spin_unlock(&info->trans_lock); 10788929ecfaSYan, Zheng return ret; 10798929ecfaSYan, Zheng } 10808929ecfaSYan, Zheng 1081bb9c12c9SSage Weil /* 1082bb9c12c9SSage Weil * wait for the current transaction commit to start and block subsequent 1083bb9c12c9SSage Weil * transaction joins 1084bb9c12c9SSage Weil */ 1085bb9c12c9SSage Weil static void wait_current_trans_commit_start(struct btrfs_root *root, 1086bb9c12c9SSage Weil struct btrfs_transaction *trans) 1087bb9c12c9SSage Weil { 1088bb9c12c9SSage Weil DEFINE_WAIT(wait); 1089bb9c12c9SSage Weil 1090bb9c12c9SSage Weil if (trans->in_commit) 1091bb9c12c9SSage Weil return; 1092bb9c12c9SSage Weil 1093bb9c12c9SSage Weil while (1) { 1094bb9c12c9SSage Weil prepare_to_wait(&root->fs_info->transaction_blocked_wait, &wait, 1095bb9c12c9SSage Weil TASK_UNINTERRUPTIBLE); 1096bb9c12c9SSage Weil if (trans->in_commit) { 1097bb9c12c9SSage Weil finish_wait(&root->fs_info->transaction_blocked_wait, 1098bb9c12c9SSage Weil &wait); 1099bb9c12c9SSage Weil break; 1100bb9c12c9SSage Weil } 1101bb9c12c9SSage Weil schedule(); 1102bb9c12c9SSage Weil finish_wait(&root->fs_info->transaction_blocked_wait, &wait); 1103bb9c12c9SSage Weil } 1104bb9c12c9SSage Weil } 1105bb9c12c9SSage Weil 1106bb9c12c9SSage Weil /* 1107bb9c12c9SSage Weil * wait for the current transaction to start and then become unblocked. 1108bb9c12c9SSage Weil * caller holds ref. 1109bb9c12c9SSage Weil */ 1110bb9c12c9SSage Weil static void wait_current_trans_commit_start_and_unblock(struct btrfs_root *root, 1111bb9c12c9SSage Weil struct btrfs_transaction *trans) 1112bb9c12c9SSage Weil { 1113bb9c12c9SSage Weil DEFINE_WAIT(wait); 1114bb9c12c9SSage Weil 1115bb9c12c9SSage Weil if (trans->commit_done || (trans->in_commit && !trans->blocked)) 1116bb9c12c9SSage Weil return; 1117bb9c12c9SSage Weil 1118bb9c12c9SSage Weil while (1) { 1119bb9c12c9SSage Weil prepare_to_wait(&root->fs_info->transaction_wait, &wait, 1120bb9c12c9SSage Weil TASK_UNINTERRUPTIBLE); 1121bb9c12c9SSage Weil if (trans->commit_done || 1122bb9c12c9SSage Weil (trans->in_commit && !trans->blocked)) { 1123bb9c12c9SSage Weil finish_wait(&root->fs_info->transaction_wait, 1124bb9c12c9SSage Weil &wait); 1125bb9c12c9SSage Weil break; 1126bb9c12c9SSage Weil } 1127bb9c12c9SSage Weil schedule(); 1128bb9c12c9SSage Weil finish_wait(&root->fs_info->transaction_wait, 1129bb9c12c9SSage Weil &wait); 1130bb9c12c9SSage Weil } 1131bb9c12c9SSage Weil } 1132bb9c12c9SSage Weil 1133bb9c12c9SSage Weil /* 1134bb9c12c9SSage Weil * commit transactions asynchronously. once btrfs_commit_transaction_async 1135bb9c12c9SSage Weil * returns, any subsequent transaction will not be allowed to join. 1136bb9c12c9SSage Weil */ 1137bb9c12c9SSage Weil struct btrfs_async_commit { 1138bb9c12c9SSage Weil struct btrfs_trans_handle *newtrans; 1139bb9c12c9SSage Weil struct btrfs_root *root; 1140bb9c12c9SSage Weil struct delayed_work work; 1141bb9c12c9SSage Weil }; 1142bb9c12c9SSage Weil 1143bb9c12c9SSage Weil static void do_async_commit(struct work_struct *work) 1144bb9c12c9SSage Weil { 1145bb9c12c9SSage Weil struct btrfs_async_commit *ac = 1146bb9c12c9SSage Weil container_of(work, struct btrfs_async_commit, work.work); 1147bb9c12c9SSage Weil 1148bb9c12c9SSage Weil btrfs_commit_transaction(ac->newtrans, ac->root); 1149bb9c12c9SSage Weil kfree(ac); 1150bb9c12c9SSage Weil } 1151bb9c12c9SSage Weil 1152bb9c12c9SSage Weil int btrfs_commit_transaction_async(struct btrfs_trans_handle *trans, 1153bb9c12c9SSage Weil struct btrfs_root *root, 1154bb9c12c9SSage Weil int wait_for_unblock) 1155bb9c12c9SSage Weil { 1156bb9c12c9SSage Weil struct btrfs_async_commit *ac; 1157bb9c12c9SSage Weil struct btrfs_transaction *cur_trans; 1158bb9c12c9SSage Weil 1159bb9c12c9SSage Weil ac = kmalloc(sizeof(*ac), GFP_NOFS); 1160db5b493aSTsutomu Itoh if (!ac) 1161db5b493aSTsutomu Itoh return -ENOMEM; 1162bb9c12c9SSage Weil 1163bb9c12c9SSage Weil INIT_DELAYED_WORK(&ac->work, do_async_commit); 1164bb9c12c9SSage Weil ac->root = root; 11657a7eaa40SJosef Bacik ac->newtrans = btrfs_join_transaction(root); 11663612b495STsutomu Itoh if (IS_ERR(ac->newtrans)) { 11673612b495STsutomu Itoh int err = PTR_ERR(ac->newtrans); 11683612b495STsutomu Itoh kfree(ac); 11693612b495STsutomu Itoh return err; 11703612b495STsutomu Itoh } 1171bb9c12c9SSage Weil 1172bb9c12c9SSage Weil /* take transaction reference */ 1173bb9c12c9SSage Weil cur_trans = trans->transaction; 117413c5a93eSJosef Bacik atomic_inc(&cur_trans->use_count); 1175bb9c12c9SSage Weil 1176bb9c12c9SSage Weil btrfs_end_transaction(trans, root); 1177bb9c12c9SSage Weil schedule_delayed_work(&ac->work, 0); 1178bb9c12c9SSage Weil 1179bb9c12c9SSage Weil /* wait for transaction to start and unblock */ 1180bb9c12c9SSage Weil if (wait_for_unblock) 1181bb9c12c9SSage Weil wait_current_trans_commit_start_and_unblock(root, cur_trans); 1182bb9c12c9SSage Weil else 1183bb9c12c9SSage Weil wait_current_trans_commit_start(root, cur_trans); 1184bb9c12c9SSage Weil 118538e88054SSage Weil if (current->journal_info == trans) 118638e88054SSage Weil current->journal_info = NULL; 118738e88054SSage Weil 118838e88054SSage Weil put_transaction(cur_trans); 1189bb9c12c9SSage Weil return 0; 1190bb9c12c9SSage Weil } 1191bb9c12c9SSage Weil 1192bb9c12c9SSage Weil /* 1193bb9c12c9SSage Weil * btrfs_transaction state sequence: 1194bb9c12c9SSage Weil * in_commit = 0, blocked = 0 (initial) 1195bb9c12c9SSage Weil * in_commit = 1, blocked = 1 1196bb9c12c9SSage Weil * blocked = 0 1197bb9c12c9SSage Weil * commit_done = 1 1198bb9c12c9SSage Weil */ 119979154b1bSChris Mason int btrfs_commit_transaction(struct btrfs_trans_handle *trans, 120079154b1bSChris Mason struct btrfs_root *root) 120179154b1bSChris Mason { 120215ee9bc7SJosef Bacik unsigned long joined = 0; 120379154b1bSChris Mason struct btrfs_transaction *cur_trans; 12048fd17795SChris Mason struct btrfs_transaction *prev_trans = NULL; 120579154b1bSChris Mason DEFINE_WAIT(wait); 120615ee9bc7SJosef Bacik int ret; 120789573b9cSChris Mason int should_grow = 0; 120889573b9cSChris Mason unsigned long now = get_seconds(); 1209dccae999SSage Weil int flush_on_commit = btrfs_test_opt(root, FLUSHONCOMMIT); 121079154b1bSChris Mason 12115a3f23d5SChris Mason btrfs_run_ordered_operations(root, 0); 12125a3f23d5SChris Mason 121356bec294SChris Mason /* make a pass through all the delayed refs we have so far 121456bec294SChris Mason * any runnings procs may add more while we are here 121556bec294SChris Mason */ 121656bec294SChris Mason ret = btrfs_run_delayed_refs(trans, root, 0); 121756bec294SChris Mason BUG_ON(ret); 121856bec294SChris Mason 1219a22285a6SYan, Zheng btrfs_trans_release_metadata(trans, root); 1220a22285a6SYan, Zheng 1221b7ec40d7SChris Mason cur_trans = trans->transaction; 122256bec294SChris Mason /* 122356bec294SChris Mason * set the flushing flag so procs in this transaction have to 122456bec294SChris Mason * start sending their work down. 122556bec294SChris Mason */ 1226b7ec40d7SChris Mason cur_trans->delayed_refs.flushing = 1; 122756bec294SChris Mason 1228c3e69d58SChris Mason ret = btrfs_run_delayed_refs(trans, root, 0); 122956bec294SChris Mason BUG_ON(ret); 123056bec294SChris Mason 1231a4abeea4SJosef Bacik spin_lock(&cur_trans->commit_lock); 1232b7ec40d7SChris Mason if (cur_trans->in_commit) { 1233a4abeea4SJosef Bacik spin_unlock(&cur_trans->commit_lock); 123413c5a93eSJosef Bacik atomic_inc(&cur_trans->use_count); 123579154b1bSChris Mason btrfs_end_transaction(trans, root); 1236ccd467d6SChris Mason 123779154b1bSChris Mason ret = wait_for_commit(root, cur_trans); 123879154b1bSChris Mason BUG_ON(ret); 123915ee9bc7SJosef Bacik 124079154b1bSChris Mason put_transaction(cur_trans); 124115ee9bc7SJosef Bacik 124279154b1bSChris Mason return 0; 124379154b1bSChris Mason } 12444313b399SChris Mason 12452c90e5d6SChris Mason trans->transaction->in_commit = 1; 1246f9295749SChris Mason trans->transaction->blocked = 1; 1247a4abeea4SJosef Bacik spin_unlock(&cur_trans->commit_lock); 1248bb9c12c9SSage Weil wake_up(&root->fs_info->transaction_blocked_wait); 1249bb9c12c9SSage Weil 1250a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 1251ccd467d6SChris Mason if (cur_trans->list.prev != &root->fs_info->trans_list) { 1252ccd467d6SChris Mason prev_trans = list_entry(cur_trans->list.prev, 1253ccd467d6SChris Mason struct btrfs_transaction, list); 1254ccd467d6SChris Mason if (!prev_trans->commit_done) { 125513c5a93eSJosef Bacik atomic_inc(&prev_trans->use_count); 1256a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 1257ccd467d6SChris Mason 1258ccd467d6SChris Mason wait_for_commit(root, prev_trans); 1259ccd467d6SChris Mason 126015ee9bc7SJosef Bacik put_transaction(prev_trans); 1261a4abeea4SJosef Bacik } else { 1262a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 1263ccd467d6SChris Mason } 1264a4abeea4SJosef Bacik } else { 1265a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 1266ccd467d6SChris Mason } 126715ee9bc7SJosef Bacik 126889573b9cSChris Mason if (now < cur_trans->start_time || now - cur_trans->start_time < 1) 126989573b9cSChris Mason should_grow = 1; 127089573b9cSChris Mason 127115ee9bc7SJosef Bacik do { 12727ea394f1SYan Zheng int snap_pending = 0; 1273a4abeea4SJosef Bacik 127415ee9bc7SJosef Bacik joined = cur_trans->num_joined; 12757ea394f1SYan Zheng if (!list_empty(&trans->transaction->pending_snapshots)) 12767ea394f1SYan Zheng snap_pending = 1; 12777ea394f1SYan Zheng 12782c90e5d6SChris Mason WARN_ON(cur_trans != trans->transaction); 127915ee9bc7SJosef Bacik 12800bdb1db2SSage Weil if (flush_on_commit || snap_pending) { 128124bbcf04SYan, Zheng btrfs_start_delalloc_inodes(root, 1); 128224bbcf04SYan, Zheng ret = btrfs_wait_ordered_extents(root, 0, 1); 1283ebecd3d9SSage Weil BUG_ON(ret); 12847ea394f1SYan Zheng } 12857ea394f1SYan Zheng 128616cdcec7SMiao Xie ret = btrfs_run_delayed_items(trans, root); 128716cdcec7SMiao Xie BUG_ON(ret); 128816cdcec7SMiao Xie 12895a3f23d5SChris Mason /* 12905a3f23d5SChris Mason * rename don't use btrfs_join_transaction, so, once we 12915a3f23d5SChris Mason * set the transaction to blocked above, we aren't going 12925a3f23d5SChris Mason * to get any new ordered operations. We can safely run 12935a3f23d5SChris Mason * it here and no for sure that nothing new will be added 12945a3f23d5SChris Mason * to the list 12955a3f23d5SChris Mason */ 12965a3f23d5SChris Mason btrfs_run_ordered_operations(root, 1); 12975a3f23d5SChris Mason 1298ed3b3d31SChris Mason prepare_to_wait(&cur_trans->writer_wait, &wait, 1299ed3b3d31SChris Mason TASK_UNINTERRUPTIBLE); 1300ed3b3d31SChris Mason 130113c5a93eSJosef Bacik if (atomic_read(&cur_trans->num_writers) > 1) 130299d16cbcSSage Weil schedule_timeout(MAX_SCHEDULE_TIMEOUT); 130399d16cbcSSage Weil else if (should_grow) 130499d16cbcSSage Weil schedule_timeout(1); 130515ee9bc7SJosef Bacik 130615ee9bc7SJosef Bacik finish_wait(&cur_trans->writer_wait, &wait); 1307ed0ca140SJosef Bacik } while (atomic_read(&cur_trans->num_writers) > 1 || 1308ed0ca140SJosef Bacik (should_grow && cur_trans->num_joined != joined)); 1309ed0ca140SJosef Bacik 1310ed0ca140SJosef Bacik /* 1311ed0ca140SJosef Bacik * Ok now we need to make sure to block out any other joins while we 1312ed0ca140SJosef Bacik * commit the transaction. We could have started a join before setting 1313ed0ca140SJosef Bacik * no_join so make sure to wait for num_writers to == 1 again. 1314ed0ca140SJosef Bacik */ 1315a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 1316a4abeea4SJosef Bacik root->fs_info->trans_no_join = 1; 1317a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 1318ed0ca140SJosef Bacik wait_event(cur_trans->writer_wait, 1319ed0ca140SJosef Bacik atomic_read(&cur_trans->num_writers) == 1); 132015ee9bc7SJosef Bacik 13217585717fSChris Mason /* 13227585717fSChris Mason * the reloc mutex makes sure that we stop 13237585717fSChris Mason * the balancing code from coming in and moving 13247585717fSChris Mason * extents around in the middle of the commit 13257585717fSChris Mason */ 13267585717fSChris Mason mutex_lock(&root->fs_info->reloc_mutex); 13277585717fSChris Mason 1328e999376fSChris Mason ret = btrfs_run_delayed_items(trans, root); 13293063d29fSChris Mason BUG_ON(ret); 13303063d29fSChris Mason 1331e999376fSChris Mason ret = create_pending_snapshots(trans, root->fs_info); 133216cdcec7SMiao Xie BUG_ON(ret); 133316cdcec7SMiao Xie 133456bec294SChris Mason ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); 133556bec294SChris Mason BUG_ON(ret); 133656bec294SChris Mason 1337e999376fSChris Mason /* 1338e999376fSChris Mason * make sure none of the code above managed to slip in a 1339e999376fSChris Mason * delayed item 1340e999376fSChris Mason */ 1341e999376fSChris Mason btrfs_assert_delayed_root_empty(root); 1342e999376fSChris Mason 13432c90e5d6SChris Mason WARN_ON(cur_trans != trans->transaction); 1344dc17ff8fSChris Mason 1345a2de733cSArne Jansen btrfs_scrub_pause(root); 1346e02119d5SChris Mason /* btrfs_commit_tree_roots is responsible for getting the 1347e02119d5SChris Mason * various roots consistent with each other. Every pointer 1348e02119d5SChris Mason * in the tree of tree roots has to point to the most up to date 1349e02119d5SChris Mason * root for every subvolume and other tree. So, we have to keep 1350e02119d5SChris Mason * the tree logging code from jumping in and changing any 1351e02119d5SChris Mason * of the trees. 1352e02119d5SChris Mason * 1353e02119d5SChris Mason * At this point in the commit, there can't be any tree-log 1354e02119d5SChris Mason * writers, but a little lower down we drop the trans mutex 1355e02119d5SChris Mason * and let new people in. By holding the tree_log_mutex 1356e02119d5SChris Mason * from now until after the super is written, we avoid races 1357e02119d5SChris Mason * with the tree-log code. 1358e02119d5SChris Mason */ 1359e02119d5SChris Mason mutex_lock(&root->fs_info->tree_log_mutex); 13601a40e23bSZheng Yan 13615d4f98a2SYan Zheng ret = commit_fs_roots(trans, root); 136254aa1f4dSChris Mason BUG_ON(ret); 136354aa1f4dSChris Mason 13645d4f98a2SYan Zheng /* commit_fs_roots gets rid of all the tree log roots, it is now 1365e02119d5SChris Mason * safe to free the root of tree log roots 1366e02119d5SChris Mason */ 1367e02119d5SChris Mason btrfs_free_log_root_tree(trans, root->fs_info); 1368e02119d5SChris Mason 13695d4f98a2SYan Zheng ret = commit_cowonly_roots(trans, root); 137079154b1bSChris Mason BUG_ON(ret); 137154aa1f4dSChris Mason 137211833d66SYan Zheng btrfs_prepare_extent_commit(trans, root); 137311833d66SYan Zheng 137478fae27eSChris Mason cur_trans = root->fs_info->running_transaction; 13755f39d397SChris Mason 13765d4f98a2SYan Zheng btrfs_set_root_node(&root->fs_info->tree_root->root_item, 13775d4f98a2SYan Zheng root->fs_info->tree_root->node); 1378817d52f8SJosef Bacik switch_commit_root(root->fs_info->tree_root); 13795d4f98a2SYan Zheng 13805d4f98a2SYan Zheng btrfs_set_root_node(&root->fs_info->chunk_root->root_item, 13815d4f98a2SYan Zheng root->fs_info->chunk_root->node); 1382817d52f8SJosef Bacik switch_commit_root(root->fs_info->chunk_root); 13835d4f98a2SYan Zheng 13845d4f98a2SYan Zheng update_super_roots(root); 1385e02119d5SChris Mason 1386e02119d5SChris Mason if (!root->fs_info->log_root_recovering) { 1387e02119d5SChris Mason btrfs_set_super_log_root(&root->fs_info->super_copy, 0); 1388e02119d5SChris Mason btrfs_set_super_log_root_level(&root->fs_info->super_copy, 0); 1389e02119d5SChris Mason } 1390e02119d5SChris Mason 1391a061fc8dSChris Mason memcpy(&root->fs_info->super_for_commit, &root->fs_info->super_copy, 13924b52dff6SChris Mason sizeof(root->fs_info->super_copy)); 1393ccd467d6SChris Mason 1394f9295749SChris Mason trans->transaction->blocked = 0; 1395a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 1396a4abeea4SJosef Bacik root->fs_info->running_transaction = NULL; 1397a4abeea4SJosef Bacik root->fs_info->trans_no_join = 0; 1398a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 13997585717fSChris Mason mutex_unlock(&root->fs_info->reloc_mutex); 1400b7ec40d7SChris Mason 1401f9295749SChris Mason wake_up(&root->fs_info->transaction_wait); 1402e6dcd2dcSChris Mason 140379154b1bSChris Mason ret = btrfs_write_and_wait_transaction(trans, root); 140479154b1bSChris Mason BUG_ON(ret); 1405a512bbf8SYan Zheng write_ctree_super(trans, root, 0); 14064313b399SChris Mason 1407e02119d5SChris Mason /* 1408e02119d5SChris Mason * the super is written, we can safely allow the tree-loggers 1409e02119d5SChris Mason * to go about their business 1410e02119d5SChris Mason */ 1411e02119d5SChris Mason mutex_unlock(&root->fs_info->tree_log_mutex); 1412e02119d5SChris Mason 141311833d66SYan Zheng btrfs_finish_extent_commit(trans, root); 14144313b399SChris Mason 14152c90e5d6SChris Mason cur_trans->commit_done = 1; 1416b7ec40d7SChris Mason 141715ee9bc7SJosef Bacik root->fs_info->last_trans_committed = cur_trans->transid; 1418817d52f8SJosef Bacik 14192c90e5d6SChris Mason wake_up(&cur_trans->commit_wait); 14203de4586cSChris Mason 1421a4abeea4SJosef Bacik spin_lock(&root->fs_info->trans_lock); 142213c5a93eSJosef Bacik list_del_init(&cur_trans->list); 1423a4abeea4SJosef Bacik spin_unlock(&root->fs_info->trans_lock); 1424a4abeea4SJosef Bacik 142579154b1bSChris Mason put_transaction(cur_trans); 142678fae27eSChris Mason put_transaction(cur_trans); 142758176a96SJosef Bacik 14281abe9b8aSliubo trace_btrfs_transaction_commit(root); 14291abe9b8aSliubo 1430a2de733cSArne Jansen btrfs_scrub_continue(root); 1431a2de733cSArne Jansen 14329ed74f2dSJosef Bacik if (current->journal_info == trans) 14339ed74f2dSJosef Bacik current->journal_info = NULL; 14349ed74f2dSJosef Bacik 14352c90e5d6SChris Mason kmem_cache_free(btrfs_trans_handle_cachep, trans); 143624bbcf04SYan, Zheng 143724bbcf04SYan, Zheng if (current != root->fs_info->transaction_kthread) 143824bbcf04SYan, Zheng btrfs_run_delayed_iputs(root); 143924bbcf04SYan, Zheng 144079154b1bSChris Mason return ret; 144179154b1bSChris Mason } 144279154b1bSChris Mason 1443d352ac68SChris Mason /* 1444d352ac68SChris Mason * interface function to delete all the snapshots we have scheduled for deletion 1445d352ac68SChris Mason */ 1446e9d0b13bSChris Mason int btrfs_clean_old_snapshots(struct btrfs_root *root) 1447e9d0b13bSChris Mason { 14485d4f98a2SYan Zheng LIST_HEAD(list); 14495d4f98a2SYan Zheng struct btrfs_fs_info *fs_info = root->fs_info; 1450e9d0b13bSChris Mason 1451a4abeea4SJosef Bacik spin_lock(&fs_info->trans_lock); 14525d4f98a2SYan Zheng list_splice_init(&fs_info->dead_roots, &list); 1453a4abeea4SJosef Bacik spin_unlock(&fs_info->trans_lock); 14545d4f98a2SYan Zheng 14555d4f98a2SYan Zheng while (!list_empty(&list)) { 14565d4f98a2SYan Zheng root = list_entry(list.next, struct btrfs_root, root_list); 145776dda93cSYan, Zheng list_del(&root->root_list); 145876dda93cSYan, Zheng 145916cdcec7SMiao Xie btrfs_kill_all_delayed_nodes(root); 146016cdcec7SMiao Xie 146176dda93cSYan, Zheng if (btrfs_header_backref_rev(root->node) < 146276dda93cSYan, Zheng BTRFS_MIXED_BACKREF_REV) 14633fd0a558SYan, Zheng btrfs_drop_snapshot(root, NULL, 0); 146476dda93cSYan, Zheng else 14653fd0a558SYan, Zheng btrfs_drop_snapshot(root, NULL, 1); 1466e9d0b13bSChris Mason } 1467e9d0b13bSChris Mason return 0; 1468e9d0b13bSChris Mason } 1469