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" 3079154b1bSChris Mason 310f7d52f4SChris Mason #define BTRFS_ROOT_TRANS_TAG 0 320f7d52f4SChris Mason 3380b6794dSChris Mason static noinline void put_transaction(struct btrfs_transaction *transaction) 3479154b1bSChris Mason { 3513c5a93eSJosef Bacik WARN_ON(atomic_read(&transaction->use_count) == 0); 3613c5a93eSJosef Bacik if (atomic_dec_and_test(&transaction->use_count)) { 372c90e5d6SChris Mason memset(transaction, 0, sizeof(*transaction)); 382c90e5d6SChris Mason kmem_cache_free(btrfs_transaction_cachep, transaction); 3979154b1bSChris Mason } 4078fae27eSChris Mason } 4179154b1bSChris Mason 42817d52f8SJosef Bacik static noinline void switch_commit_root(struct btrfs_root *root) 43817d52f8SJosef Bacik { 44817d52f8SJosef Bacik free_extent_buffer(root->commit_root); 45817d52f8SJosef Bacik root->commit_root = btrfs_root_node(root); 46817d52f8SJosef Bacik } 47817d52f8SJosef Bacik 48d352ac68SChris Mason /* 49d352ac68SChris Mason * either allocate a new transaction or hop into the existing one 50d352ac68SChris Mason */ 5180b6794dSChris Mason static noinline int join_transaction(struct btrfs_root *root) 5279154b1bSChris Mason { 5379154b1bSChris Mason struct btrfs_transaction *cur_trans; 5479154b1bSChris Mason cur_trans = root->fs_info->running_transaction; 5579154b1bSChris Mason if (!cur_trans) { 562c90e5d6SChris Mason cur_trans = kmem_cache_alloc(btrfs_transaction_cachep, 572c90e5d6SChris Mason GFP_NOFS); 58db5b493aSTsutomu Itoh if (!cur_trans) 59db5b493aSTsutomu Itoh return -ENOMEM; 600f7d52f4SChris Mason root->fs_info->generation++; 6113c5a93eSJosef Bacik atomic_set(&cur_trans->num_writers, 1); 6215ee9bc7SJosef Bacik cur_trans->num_joined = 0; 630f7d52f4SChris Mason cur_trans->transid = root->fs_info->generation; 6479154b1bSChris Mason init_waitqueue_head(&cur_trans->writer_wait); 6579154b1bSChris Mason init_waitqueue_head(&cur_trans->commit_wait); 6679154b1bSChris Mason cur_trans->in_commit = 0; 67f9295749SChris Mason cur_trans->blocked = 0; 6813c5a93eSJosef Bacik atomic_set(&cur_trans->use_count, 1); 6979154b1bSChris Mason cur_trans->commit_done = 0; 7008607c1bSChris Mason cur_trans->start_time = get_seconds(); 7156bec294SChris Mason 726bef4d31SEric Paris cur_trans->delayed_refs.root = RB_ROOT; 7356bec294SChris Mason cur_trans->delayed_refs.num_entries = 0; 74c3e69d58SChris Mason cur_trans->delayed_refs.num_heads_ready = 0; 75c3e69d58SChris Mason cur_trans->delayed_refs.num_heads = 0; 7656bec294SChris Mason cur_trans->delayed_refs.flushing = 0; 77c3e69d58SChris Mason cur_trans->delayed_refs.run_delayed_start = 0; 7856bec294SChris Mason spin_lock_init(&cur_trans->delayed_refs.lock); 7956bec294SChris Mason 803063d29fSChris Mason INIT_LIST_HEAD(&cur_trans->pending_snapshots); 818fd17795SChris Mason list_add_tail(&cur_trans->list, &root->fs_info->trans_list); 82d1310b2eSChris Mason extent_io_tree_init(&cur_trans->dirty_pages, 835f39d397SChris Mason root->fs_info->btree_inode->i_mapping, 845f39d397SChris Mason GFP_NOFS); 8548ec2cf8SChris Mason spin_lock(&root->fs_info->new_trans_lock); 8648ec2cf8SChris Mason root->fs_info->running_transaction = cur_trans; 8748ec2cf8SChris Mason spin_unlock(&root->fs_info->new_trans_lock); 8815ee9bc7SJosef Bacik } else { 8913c5a93eSJosef Bacik atomic_inc(&cur_trans->num_writers); 9015ee9bc7SJosef Bacik cur_trans->num_joined++; 9115ee9bc7SJosef Bacik } 9215ee9bc7SJosef Bacik 9379154b1bSChris Mason return 0; 9479154b1bSChris Mason } 9579154b1bSChris Mason 96d352ac68SChris Mason /* 97d397712bSChris Mason * this does all the record keeping required to make sure that a reference 98d397712bSChris Mason * counted root is properly recorded in a given transaction. This is required 99d397712bSChris Mason * to make sure the old root from before we joined the transaction is deleted 100d397712bSChris Mason * when the transaction commits 101d352ac68SChris Mason */ 1025d4f98a2SYan Zheng static noinline int record_root_in_trans(struct btrfs_trans_handle *trans, 1035d4f98a2SYan Zheng struct btrfs_root *root) 1046702ed49SChris Mason { 1055d4f98a2SYan Zheng if (root->ref_cows && root->last_trans < trans->transid) { 1066702ed49SChris Mason WARN_ON(root == root->fs_info->extent_root); 1075d4f98a2SYan Zheng WARN_ON(root->commit_root != root->node); 1085d4f98a2SYan Zheng 1096702ed49SChris Mason radix_tree_tag_set(&root->fs_info->fs_roots_radix, 1106702ed49SChris Mason (unsigned long)root->root_key.objectid, 1116702ed49SChris Mason BTRFS_ROOT_TRANS_TAG); 1125d4f98a2SYan Zheng root->last_trans = trans->transid; 1135d4f98a2SYan Zheng btrfs_init_reloc_root(trans, root); 1146702ed49SChris Mason } 1155d4f98a2SYan Zheng return 0; 1166702ed49SChris Mason } 1175d4f98a2SYan Zheng 1185d4f98a2SYan Zheng int btrfs_record_root_in_trans(struct btrfs_trans_handle *trans, 1195d4f98a2SYan Zheng struct btrfs_root *root) 1205d4f98a2SYan Zheng { 1215d4f98a2SYan Zheng if (!root->ref_cows) 1225d4f98a2SYan Zheng return 0; 1235d4f98a2SYan Zheng 1245d4f98a2SYan Zheng mutex_lock(&root->fs_info->trans_mutex); 1255d4f98a2SYan Zheng if (root->last_trans == trans->transid) { 1265d4f98a2SYan Zheng mutex_unlock(&root->fs_info->trans_mutex); 1275d4f98a2SYan Zheng return 0; 1285d4f98a2SYan Zheng } 1295d4f98a2SYan Zheng 1305d4f98a2SYan Zheng record_root_in_trans(trans, root); 1315d4f98a2SYan Zheng mutex_unlock(&root->fs_info->trans_mutex); 1326702ed49SChris Mason return 0; 1336702ed49SChris Mason } 1346702ed49SChris Mason 135d352ac68SChris Mason /* wait for commit against the current transaction to become unblocked 136d352ac68SChris Mason * when this is done, it is safe to start a new transaction, but the current 137d352ac68SChris Mason * transaction might not be fully on disk. 138d352ac68SChris Mason */ 13937d1aeeeSChris Mason static void wait_current_trans(struct btrfs_root *root) 14079154b1bSChris Mason { 141f9295749SChris Mason struct btrfs_transaction *cur_trans; 14279154b1bSChris Mason 143f9295749SChris Mason cur_trans = root->fs_info->running_transaction; 14437d1aeeeSChris Mason if (cur_trans && cur_trans->blocked) { 145f9295749SChris Mason DEFINE_WAIT(wait); 14613c5a93eSJosef Bacik atomic_inc(&cur_trans->use_count); 147f9295749SChris Mason while (1) { 148f9295749SChris Mason prepare_to_wait(&root->fs_info->transaction_wait, &wait, 149f9295749SChris Mason TASK_UNINTERRUPTIBLE); 150471fa17dSZhao Lei if (!cur_trans->blocked) 151471fa17dSZhao Lei break; 152f9295749SChris Mason mutex_unlock(&root->fs_info->trans_mutex); 153f9295749SChris Mason schedule(); 154f9295749SChris Mason mutex_lock(&root->fs_info->trans_mutex); 155f9295749SChris Mason } 156471fa17dSZhao Lei finish_wait(&root->fs_info->transaction_wait, &wait); 157f9295749SChris Mason put_transaction(cur_trans); 158f9295749SChris Mason } 15937d1aeeeSChris Mason } 16037d1aeeeSChris Mason 161249ac1e5SJosef Bacik enum btrfs_trans_type { 162249ac1e5SJosef Bacik TRANS_START, 163249ac1e5SJosef Bacik TRANS_JOIN, 164249ac1e5SJosef Bacik TRANS_USERSPACE, 1650af3d00bSJosef Bacik TRANS_JOIN_NOLOCK, 166249ac1e5SJosef Bacik }; 167249ac1e5SJosef Bacik 168a22285a6SYan, Zheng static int may_wait_transaction(struct btrfs_root *root, int type) 16937d1aeeeSChris Mason { 1704bef0848SChris Mason if (!root->fs_info->log_root_recovering && 171249ac1e5SJosef Bacik ((type == TRANS_START && !root->fs_info->open_ioctl_trans) || 172249ac1e5SJosef Bacik type == TRANS_USERSPACE)) 173a22285a6SYan, Zheng return 1; 174a22285a6SYan, Zheng return 0; 175a22285a6SYan, Zheng } 176a22285a6SYan, Zheng 177a22285a6SYan, Zheng static struct btrfs_trans_handle *start_transaction(struct btrfs_root *root, 178a22285a6SYan, Zheng u64 num_items, int type) 179a22285a6SYan, Zheng { 180a22285a6SYan, Zheng struct btrfs_trans_handle *h; 181a22285a6SYan, Zheng struct btrfs_transaction *cur_trans; 18206d5a589SJosef Bacik int retries = 0; 183a22285a6SYan, Zheng int ret; 184acce952bSliubo 185acce952bSliubo if (root->fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) 186acce952bSliubo return ERR_PTR(-EROFS); 187a22285a6SYan, Zheng again: 188a22285a6SYan, Zheng h = kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS); 189a22285a6SYan, Zheng if (!h) 190a22285a6SYan, Zheng return ERR_PTR(-ENOMEM); 191a22285a6SYan, Zheng 1920af3d00bSJosef Bacik if (type != TRANS_JOIN_NOLOCK) 193a22285a6SYan, Zheng mutex_lock(&root->fs_info->trans_mutex); 194a22285a6SYan, Zheng if (may_wait_transaction(root, type)) 19537d1aeeeSChris Mason wait_current_trans(root); 196a22285a6SYan, Zheng 19779154b1bSChris Mason ret = join_transaction(root); 198db5b493aSTsutomu Itoh if (ret < 0) { 1996e8df2aeSYoshinori Sano kmem_cache_free(btrfs_trans_handle_cachep, h); 200db5b493aSTsutomu Itoh if (type != TRANS_JOIN_NOLOCK) 201db5b493aSTsutomu Itoh mutex_unlock(&root->fs_info->trans_mutex); 202db5b493aSTsutomu Itoh return ERR_PTR(ret); 203db5b493aSTsutomu Itoh } 2040f7d52f4SChris Mason 205a22285a6SYan, Zheng cur_trans = root->fs_info->running_transaction; 20613c5a93eSJosef Bacik atomic_inc(&cur_trans->use_count); 2070af3d00bSJosef Bacik if (type != TRANS_JOIN_NOLOCK) 208a22285a6SYan, Zheng mutex_unlock(&root->fs_info->trans_mutex); 209a22285a6SYan, Zheng 210a22285a6SYan, Zheng h->transid = cur_trans->transid; 211a22285a6SYan, Zheng h->transaction = cur_trans; 21279154b1bSChris Mason h->blocks_used = 0; 213d2fb3437SYan Zheng h->block_group = 0; 214a22285a6SYan, Zheng h->bytes_reserved = 0; 21556bec294SChris Mason h->delayed_ref_updates = 0; 216f0486c68SYan, Zheng h->block_rsv = NULL; 217b7ec40d7SChris Mason 218a22285a6SYan, Zheng smp_mb(); 219a22285a6SYan, Zheng if (cur_trans->blocked && may_wait_transaction(root, type)) { 220a22285a6SYan, Zheng btrfs_commit_transaction(h, root); 221a22285a6SYan, Zheng goto again; 222a22285a6SYan, Zheng } 2239ed74f2dSJosef Bacik 224a22285a6SYan, Zheng if (num_items > 0) { 2258bb8ab2eSJosef Bacik ret = btrfs_trans_reserve_metadata(h, root, num_items); 22606d5a589SJosef Bacik if (ret == -EAGAIN && !retries) { 22706d5a589SJosef Bacik retries++; 228a22285a6SYan, Zheng btrfs_commit_transaction(h, root); 229a22285a6SYan, Zheng goto again; 23006d5a589SJosef Bacik } else if (ret == -EAGAIN) { 23106d5a589SJosef Bacik /* 23206d5a589SJosef Bacik * We have already retried and got EAGAIN, so really we 23306d5a589SJosef Bacik * don't have space, so set ret to -ENOSPC. 23406d5a589SJosef Bacik */ 23506d5a589SJosef Bacik ret = -ENOSPC; 236a22285a6SYan, Zheng } 23706d5a589SJosef Bacik 238a22285a6SYan, Zheng if (ret < 0) { 239a22285a6SYan, Zheng btrfs_end_transaction(h, root); 240a22285a6SYan, Zheng return ERR_PTR(ret); 241a22285a6SYan, Zheng } 242a22285a6SYan, Zheng } 243a22285a6SYan, Zheng 2440af3d00bSJosef Bacik if (type != TRANS_JOIN_NOLOCK) 245a22285a6SYan, Zheng mutex_lock(&root->fs_info->trans_mutex); 2465d4f98a2SYan Zheng record_root_in_trans(h, root); 2470af3d00bSJosef Bacik if (type != TRANS_JOIN_NOLOCK) 24879154b1bSChris Mason mutex_unlock(&root->fs_info->trans_mutex); 249a22285a6SYan, Zheng 250a22285a6SYan, Zheng if (!current->journal_info && type != TRANS_USERSPACE) 251a22285a6SYan, Zheng current->journal_info = h; 25279154b1bSChris Mason return h; 25379154b1bSChris Mason } 25479154b1bSChris Mason 255f9295749SChris Mason struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root, 256a22285a6SYan, Zheng int num_items) 257f9295749SChris Mason { 258a22285a6SYan, Zheng return start_transaction(root, num_items, TRANS_START); 259f9295749SChris Mason } 260f9295749SChris Mason struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root, 261f9295749SChris Mason int num_blocks) 262f9295749SChris Mason { 263a22285a6SYan, Zheng return start_transaction(root, 0, TRANS_JOIN); 264f9295749SChris Mason } 265f9295749SChris Mason 2660af3d00bSJosef Bacik struct btrfs_trans_handle *btrfs_join_transaction_nolock(struct btrfs_root *root, 2670af3d00bSJosef Bacik int num_blocks) 2680af3d00bSJosef Bacik { 2690af3d00bSJosef Bacik return start_transaction(root, 0, TRANS_JOIN_NOLOCK); 2700af3d00bSJosef Bacik } 2710af3d00bSJosef Bacik 2729ca9ee09SSage Weil struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *r, 2739ca9ee09SSage Weil int num_blocks) 2749ca9ee09SSage Weil { 275a22285a6SYan, Zheng return start_transaction(r, 0, TRANS_USERSPACE); 2769ca9ee09SSage Weil } 2779ca9ee09SSage Weil 278d352ac68SChris Mason /* wait for a transaction commit to be fully complete */ 27989ce8a63SChris Mason static noinline int wait_for_commit(struct btrfs_root *root, 28089ce8a63SChris Mason struct btrfs_transaction *commit) 28189ce8a63SChris Mason { 28289ce8a63SChris Mason DEFINE_WAIT(wait); 28389ce8a63SChris Mason mutex_lock(&root->fs_info->trans_mutex); 28489ce8a63SChris Mason while (!commit->commit_done) { 28589ce8a63SChris Mason prepare_to_wait(&commit->commit_wait, &wait, 28689ce8a63SChris Mason TASK_UNINTERRUPTIBLE); 28789ce8a63SChris Mason if (commit->commit_done) 28889ce8a63SChris Mason break; 28989ce8a63SChris Mason mutex_unlock(&root->fs_info->trans_mutex); 29089ce8a63SChris Mason schedule(); 29189ce8a63SChris Mason mutex_lock(&root->fs_info->trans_mutex); 29289ce8a63SChris Mason } 29389ce8a63SChris Mason mutex_unlock(&root->fs_info->trans_mutex); 29489ce8a63SChris Mason finish_wait(&commit->commit_wait, &wait); 29589ce8a63SChris Mason return 0; 29689ce8a63SChris Mason } 29789ce8a63SChris Mason 29846204592SSage Weil int btrfs_wait_for_commit(struct btrfs_root *root, u64 transid) 29946204592SSage Weil { 30046204592SSage Weil struct btrfs_transaction *cur_trans = NULL, *t; 30146204592SSage Weil int ret; 30246204592SSage Weil 30346204592SSage Weil mutex_lock(&root->fs_info->trans_mutex); 30446204592SSage Weil 30546204592SSage Weil ret = 0; 30646204592SSage Weil if (transid) { 30746204592SSage Weil if (transid <= root->fs_info->last_trans_committed) 30846204592SSage Weil goto out_unlock; 30946204592SSage Weil 31046204592SSage Weil /* find specified transaction */ 31146204592SSage Weil list_for_each_entry(t, &root->fs_info->trans_list, list) { 31246204592SSage Weil if (t->transid == transid) { 31346204592SSage Weil cur_trans = t; 31446204592SSage Weil break; 31546204592SSage Weil } 31646204592SSage Weil if (t->transid > transid) 31746204592SSage Weil break; 31846204592SSage Weil } 31946204592SSage Weil ret = -EINVAL; 32046204592SSage Weil if (!cur_trans) 32146204592SSage Weil goto out_unlock; /* bad transid */ 32246204592SSage Weil } else { 32346204592SSage Weil /* find newest transaction that is committing | committed */ 32446204592SSage Weil list_for_each_entry_reverse(t, &root->fs_info->trans_list, 32546204592SSage Weil list) { 32646204592SSage Weil if (t->in_commit) { 32746204592SSage Weil if (t->commit_done) 32846204592SSage Weil goto out_unlock; 32946204592SSage Weil cur_trans = t; 33046204592SSage Weil break; 33146204592SSage Weil } 33246204592SSage Weil } 33346204592SSage Weil if (!cur_trans) 33446204592SSage Weil goto out_unlock; /* nothing committing|committed */ 33546204592SSage Weil } 33646204592SSage Weil 33713c5a93eSJosef Bacik atomic_inc(&cur_trans->use_count); 33846204592SSage Weil mutex_unlock(&root->fs_info->trans_mutex); 33946204592SSage Weil 34046204592SSage Weil wait_for_commit(root, cur_trans); 34146204592SSage Weil 34246204592SSage Weil mutex_lock(&root->fs_info->trans_mutex); 34346204592SSage Weil put_transaction(cur_trans); 34446204592SSage Weil ret = 0; 34546204592SSage Weil out_unlock: 34646204592SSage Weil mutex_unlock(&root->fs_info->trans_mutex); 34746204592SSage Weil return ret; 34846204592SSage Weil } 34946204592SSage Weil 3505d4f98a2SYan Zheng #if 0 351d352ac68SChris Mason /* 352d397712bSChris Mason * rate limit against the drop_snapshot code. This helps to slow down new 353d397712bSChris Mason * operations if the drop_snapshot code isn't able to keep up. 354d352ac68SChris Mason */ 35537d1aeeeSChris Mason static void throttle_on_drops(struct btrfs_root *root) 356ab78c84dSChris Mason { 357ab78c84dSChris Mason struct btrfs_fs_info *info = root->fs_info; 3582dd3e67bSChris Mason int harder_count = 0; 359ab78c84dSChris Mason 3602dd3e67bSChris Mason harder: 361ab78c84dSChris Mason if (atomic_read(&info->throttles)) { 362ab78c84dSChris Mason DEFINE_WAIT(wait); 363ab78c84dSChris Mason int thr; 364ab78c84dSChris Mason thr = atomic_read(&info->throttle_gen); 365ab78c84dSChris Mason 366ab78c84dSChris Mason do { 367ab78c84dSChris Mason prepare_to_wait(&info->transaction_throttle, 368ab78c84dSChris Mason &wait, TASK_UNINTERRUPTIBLE); 369ab78c84dSChris Mason if (!atomic_read(&info->throttles)) { 370ab78c84dSChris Mason finish_wait(&info->transaction_throttle, &wait); 371ab78c84dSChris Mason break; 372ab78c84dSChris Mason } 373ab78c84dSChris Mason schedule(); 374ab78c84dSChris Mason finish_wait(&info->transaction_throttle, &wait); 375ab78c84dSChris Mason } while (thr == atomic_read(&info->throttle_gen)); 3762dd3e67bSChris Mason harder_count++; 3772dd3e67bSChris Mason 3782dd3e67bSChris Mason if (root->fs_info->total_ref_cache_size > 1 * 1024 * 1024 && 3792dd3e67bSChris Mason harder_count < 2) 3802dd3e67bSChris Mason goto harder; 3812dd3e67bSChris Mason 3822dd3e67bSChris Mason if (root->fs_info->total_ref_cache_size > 5 * 1024 * 1024 && 3832dd3e67bSChris Mason harder_count < 10) 3842dd3e67bSChris Mason goto harder; 3852dd3e67bSChris Mason 3862dd3e67bSChris Mason if (root->fs_info->total_ref_cache_size > 10 * 1024 * 1024 && 3872dd3e67bSChris Mason harder_count < 20) 3882dd3e67bSChris Mason goto harder; 389ab78c84dSChris Mason } 390ab78c84dSChris Mason } 3915d4f98a2SYan Zheng #endif 392ab78c84dSChris Mason 39337d1aeeeSChris Mason void btrfs_throttle(struct btrfs_root *root) 39437d1aeeeSChris Mason { 39537d1aeeeSChris Mason mutex_lock(&root->fs_info->trans_mutex); 3969ca9ee09SSage Weil if (!root->fs_info->open_ioctl_trans) 39737d1aeeeSChris Mason wait_current_trans(root); 39837d1aeeeSChris Mason mutex_unlock(&root->fs_info->trans_mutex); 39937d1aeeeSChris Mason } 40037d1aeeeSChris Mason 4018929ecfaSYan, Zheng static int should_end_transaction(struct btrfs_trans_handle *trans, 4028929ecfaSYan, Zheng struct btrfs_root *root) 4038929ecfaSYan, Zheng { 4048929ecfaSYan, Zheng int ret; 4058929ecfaSYan, Zheng ret = btrfs_block_rsv_check(trans, root, 4068929ecfaSYan, Zheng &root->fs_info->global_block_rsv, 0, 5); 4078929ecfaSYan, Zheng return ret ? 1 : 0; 4088929ecfaSYan, Zheng } 4098929ecfaSYan, Zheng 4108929ecfaSYan, Zheng int btrfs_should_end_transaction(struct btrfs_trans_handle *trans, 4118929ecfaSYan, Zheng struct btrfs_root *root) 4128929ecfaSYan, Zheng { 4138929ecfaSYan, Zheng struct btrfs_transaction *cur_trans = trans->transaction; 4148929ecfaSYan, Zheng int updates; 4158929ecfaSYan, Zheng 4168929ecfaSYan, Zheng if (cur_trans->blocked || cur_trans->delayed_refs.flushing) 4178929ecfaSYan, Zheng return 1; 4188929ecfaSYan, Zheng 4198929ecfaSYan, Zheng updates = trans->delayed_ref_updates; 4208929ecfaSYan, Zheng trans->delayed_ref_updates = 0; 4218929ecfaSYan, Zheng if (updates) 4228929ecfaSYan, Zheng btrfs_run_delayed_refs(trans, root, updates); 4238929ecfaSYan, Zheng 4248929ecfaSYan, Zheng return should_end_transaction(trans, root); 4258929ecfaSYan, Zheng } 4268929ecfaSYan, Zheng 42789ce8a63SChris Mason static int __btrfs_end_transaction(struct btrfs_trans_handle *trans, 4280af3d00bSJosef Bacik struct btrfs_root *root, int throttle, int lock) 42979154b1bSChris Mason { 4308929ecfaSYan, Zheng struct btrfs_transaction *cur_trans = trans->transaction; 431ab78c84dSChris Mason struct btrfs_fs_info *info = root->fs_info; 432c3e69d58SChris Mason int count = 0; 433d6e4a428SChris Mason 434c3e69d58SChris Mason while (count < 4) { 435c3e69d58SChris Mason unsigned long cur = trans->delayed_ref_updates; 436c3e69d58SChris Mason trans->delayed_ref_updates = 0; 437c3e69d58SChris Mason if (cur && 438c3e69d58SChris Mason trans->transaction->delayed_refs.num_heads_ready > 64) { 439c3e69d58SChris Mason trans->delayed_ref_updates = 0; 440b7ec40d7SChris Mason 441b7ec40d7SChris Mason /* 442b7ec40d7SChris Mason * do a full flush if the transaction is trying 443b7ec40d7SChris Mason * to close 444b7ec40d7SChris Mason */ 445b7ec40d7SChris Mason if (trans->transaction->delayed_refs.flushing) 446b7ec40d7SChris Mason cur = 0; 447c3e69d58SChris Mason btrfs_run_delayed_refs(trans, root, cur); 448c3e69d58SChris Mason } else { 449c3e69d58SChris Mason break; 450c3e69d58SChris Mason } 451c3e69d58SChris Mason count++; 45256bec294SChris Mason } 45356bec294SChris Mason 454a22285a6SYan, Zheng btrfs_trans_release_metadata(trans, root); 455a22285a6SYan, Zheng 4560af3d00bSJosef Bacik if (lock && !root->fs_info->open_ioctl_trans && 4578929ecfaSYan, Zheng should_end_transaction(trans, root)) 4588929ecfaSYan, Zheng trans->transaction->blocked = 1; 4598929ecfaSYan, Zheng 4600af3d00bSJosef Bacik if (lock && cur_trans->blocked && !cur_trans->in_commit) { 4618929ecfaSYan, Zheng if (throttle) 4628929ecfaSYan, Zheng return btrfs_commit_transaction(trans, root); 4638929ecfaSYan, Zheng else 4648929ecfaSYan, Zheng wake_up_process(info->transaction_kthread); 4658929ecfaSYan, Zheng } 4668929ecfaSYan, Zheng 4678929ecfaSYan, Zheng WARN_ON(cur_trans != info->running_transaction); 46813c5a93eSJosef Bacik WARN_ON(atomic_read(&cur_trans->num_writers) < 1); 46913c5a93eSJosef Bacik atomic_dec(&cur_trans->num_writers); 47089ce8a63SChris Mason 47199d16cbcSSage Weil smp_mb(); 47279154b1bSChris Mason if (waitqueue_active(&cur_trans->writer_wait)) 47379154b1bSChris Mason wake_up(&cur_trans->writer_wait); 47479154b1bSChris Mason put_transaction(cur_trans); 4759ed74f2dSJosef Bacik 4769ed74f2dSJosef Bacik if (current->journal_info == trans) 4779ed74f2dSJosef Bacik current->journal_info = NULL; 478d6025579SChris Mason memset(trans, 0, sizeof(*trans)); 4792c90e5d6SChris Mason kmem_cache_free(btrfs_trans_handle_cachep, trans); 480ab78c84dSChris Mason 48124bbcf04SYan, Zheng if (throttle) 48224bbcf04SYan, Zheng btrfs_run_delayed_iputs(root); 48324bbcf04SYan, Zheng 48479154b1bSChris Mason return 0; 48579154b1bSChris Mason } 48679154b1bSChris Mason 48789ce8a63SChris Mason int btrfs_end_transaction(struct btrfs_trans_handle *trans, 48889ce8a63SChris Mason struct btrfs_root *root) 48989ce8a63SChris Mason { 49016cdcec7SMiao Xie int ret; 49116cdcec7SMiao Xie 49216cdcec7SMiao Xie ret = __btrfs_end_transaction(trans, root, 0, 1); 49316cdcec7SMiao Xie if (ret) 49416cdcec7SMiao Xie return ret; 49516cdcec7SMiao Xie return 0; 49689ce8a63SChris Mason } 49789ce8a63SChris Mason 49889ce8a63SChris Mason int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans, 49989ce8a63SChris Mason struct btrfs_root *root) 50089ce8a63SChris Mason { 50116cdcec7SMiao Xie int ret; 50216cdcec7SMiao Xie 50316cdcec7SMiao Xie ret = __btrfs_end_transaction(trans, root, 1, 1); 50416cdcec7SMiao Xie if (ret) 50516cdcec7SMiao Xie return ret; 50616cdcec7SMiao Xie return 0; 5070af3d00bSJosef Bacik } 5080af3d00bSJosef Bacik 5090af3d00bSJosef Bacik int btrfs_end_transaction_nolock(struct btrfs_trans_handle *trans, 5100af3d00bSJosef Bacik struct btrfs_root *root) 5110af3d00bSJosef Bacik { 51216cdcec7SMiao Xie int ret; 51316cdcec7SMiao Xie 51416cdcec7SMiao Xie ret = __btrfs_end_transaction(trans, root, 0, 0); 51516cdcec7SMiao Xie if (ret) 51616cdcec7SMiao Xie return ret; 51716cdcec7SMiao Xie return 0; 51816cdcec7SMiao Xie } 51916cdcec7SMiao Xie 52016cdcec7SMiao Xie int btrfs_end_transaction_dmeta(struct btrfs_trans_handle *trans, 52116cdcec7SMiao Xie struct btrfs_root *root) 52216cdcec7SMiao Xie { 52316cdcec7SMiao Xie return __btrfs_end_transaction(trans, root, 1, 1); 52489ce8a63SChris Mason } 52589ce8a63SChris Mason 526d352ac68SChris Mason /* 527d352ac68SChris Mason * when btree blocks are allocated, they have some corresponding bits set for 528d352ac68SChris Mason * them in one of two extent_io trees. This is used to make sure all of 529690587d1SChris Mason * those extents are sent to disk but does not wait on them 530d352ac68SChris Mason */ 531690587d1SChris Mason int btrfs_write_marked_extents(struct btrfs_root *root, 5328cef4e16SYan, Zheng struct extent_io_tree *dirty_pages, int mark) 53379154b1bSChris Mason { 5347c4452b9SChris Mason int ret; 535777e6bd7SChris Mason int err = 0; 5367c4452b9SChris Mason int werr = 0; 5377c4452b9SChris Mason struct page *page; 5387c4452b9SChris Mason struct inode *btree_inode = root->fs_info->btree_inode; 539777e6bd7SChris Mason u64 start = 0; 5405f39d397SChris Mason u64 end; 5415f39d397SChris Mason unsigned long index; 5427c4452b9SChris Mason 5437c4452b9SChris Mason while (1) { 544777e6bd7SChris Mason ret = find_first_extent_bit(dirty_pages, start, &start, &end, 5458cef4e16SYan, Zheng mark); 5465f39d397SChris Mason if (ret) 5477c4452b9SChris Mason break; 5485f39d397SChris Mason while (start <= end) { 549777e6bd7SChris Mason cond_resched(); 550777e6bd7SChris Mason 5515f39d397SChris Mason index = start >> PAGE_CACHE_SHIFT; 55235ebb934SChris Mason start = (u64)(index + 1) << PAGE_CACHE_SHIFT; 5534bef0848SChris Mason page = find_get_page(btree_inode->i_mapping, index); 5547c4452b9SChris Mason if (!page) 5557c4452b9SChris Mason continue; 5564bef0848SChris Mason 5574bef0848SChris Mason btree_lock_page_hook(page); 5584bef0848SChris Mason if (!page->mapping) { 5594bef0848SChris Mason unlock_page(page); 5604bef0848SChris Mason page_cache_release(page); 5614bef0848SChris Mason continue; 5624bef0848SChris Mason } 5634bef0848SChris Mason 5646702ed49SChris Mason if (PageWriteback(page)) { 5656702ed49SChris Mason if (PageDirty(page)) 5666702ed49SChris Mason wait_on_page_writeback(page); 5676702ed49SChris Mason else { 5686702ed49SChris Mason unlock_page(page); 5696702ed49SChris Mason page_cache_release(page); 5706702ed49SChris Mason continue; 5716702ed49SChris Mason } 5726702ed49SChris Mason } 5737c4452b9SChris Mason err = write_one_page(page, 0); 5747c4452b9SChris Mason if (err) 5757c4452b9SChris Mason werr = err; 5767c4452b9SChris Mason page_cache_release(page); 5777c4452b9SChris Mason } 5787c4452b9SChris Mason } 579690587d1SChris Mason if (err) 580690587d1SChris Mason werr = err; 581690587d1SChris Mason return werr; 582690587d1SChris Mason } 583690587d1SChris Mason 584690587d1SChris Mason /* 585690587d1SChris Mason * when btree blocks are allocated, they have some corresponding bits set for 586690587d1SChris Mason * them in one of two extent_io trees. This is used to make sure all of 587690587d1SChris Mason * those extents are on disk for transaction or log commit. We wait 588690587d1SChris Mason * on all the pages and clear them from the dirty pages state tree 589690587d1SChris Mason */ 590690587d1SChris Mason int btrfs_wait_marked_extents(struct btrfs_root *root, 5918cef4e16SYan, Zheng struct extent_io_tree *dirty_pages, int mark) 592690587d1SChris Mason { 593690587d1SChris Mason int ret; 594690587d1SChris Mason int err = 0; 595690587d1SChris Mason int werr = 0; 596690587d1SChris Mason struct page *page; 597690587d1SChris Mason struct inode *btree_inode = root->fs_info->btree_inode; 598690587d1SChris Mason u64 start = 0; 599690587d1SChris Mason u64 end; 600690587d1SChris Mason unsigned long index; 601690587d1SChris Mason 602777e6bd7SChris Mason while (1) { 6038cef4e16SYan, Zheng ret = find_first_extent_bit(dirty_pages, start, &start, &end, 6048cef4e16SYan, Zheng mark); 605777e6bd7SChris Mason if (ret) 606777e6bd7SChris Mason break; 607777e6bd7SChris Mason 6088cef4e16SYan, Zheng clear_extent_bits(dirty_pages, start, end, mark, GFP_NOFS); 609777e6bd7SChris Mason while (start <= end) { 610777e6bd7SChris Mason index = start >> PAGE_CACHE_SHIFT; 611777e6bd7SChris Mason start = (u64)(index + 1) << PAGE_CACHE_SHIFT; 612777e6bd7SChris Mason page = find_get_page(btree_inode->i_mapping, index); 613777e6bd7SChris Mason if (!page) 614777e6bd7SChris Mason continue; 615777e6bd7SChris Mason if (PageDirty(page)) { 6164bef0848SChris Mason btree_lock_page_hook(page); 6174bef0848SChris Mason wait_on_page_writeback(page); 618777e6bd7SChris Mason err = write_one_page(page, 0); 619777e6bd7SChris Mason if (err) 620777e6bd7SChris Mason werr = err; 621777e6bd7SChris Mason } 622777e6bd7SChris Mason wait_on_page_writeback(page); 623777e6bd7SChris Mason page_cache_release(page); 624777e6bd7SChris Mason cond_resched(); 625777e6bd7SChris Mason } 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); 645690587d1SChris Mason return ret || ret2; 646690587d1SChris Mason } 647690587d1SChris Mason 648d0c803c4SChris Mason int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans, 649d0c803c4SChris Mason struct btrfs_root *root) 650d0c803c4SChris Mason { 651d0c803c4SChris Mason if (!trans || !trans->transaction) { 652d0c803c4SChris Mason struct inode *btree_inode; 653d0c803c4SChris Mason btree_inode = root->fs_info->btree_inode; 654d0c803c4SChris Mason return filemap_write_and_wait(btree_inode->i_mapping); 655d0c803c4SChris Mason } 656d0c803c4SChris Mason return btrfs_write_and_wait_marked_extents(root, 6578cef4e16SYan, Zheng &trans->transaction->dirty_pages, 6588cef4e16SYan, Zheng EXTENT_DIRTY); 659d0c803c4SChris Mason } 660d0c803c4SChris Mason 661d352ac68SChris Mason /* 662d352ac68SChris Mason * this is used to update the root pointer in the tree of tree roots. 663d352ac68SChris Mason * 664d352ac68SChris Mason * But, in the case of the extent allocation tree, updating the root 665d352ac68SChris Mason * pointer may allocate blocks which may change the root of the extent 666d352ac68SChris Mason * allocation tree. 667d352ac68SChris Mason * 668d352ac68SChris Mason * So, this loops and repeats and makes sure the cowonly root didn't 669d352ac68SChris Mason * change while the root pointer was being updated in the metadata. 670d352ac68SChris Mason */ 6710b86a832SChris Mason static int update_cowonly_root(struct btrfs_trans_handle *trans, 67279154b1bSChris Mason struct btrfs_root *root) 67379154b1bSChris Mason { 67479154b1bSChris Mason int ret; 6750b86a832SChris Mason u64 old_root_bytenr; 67686b9f2ecSYan, Zheng u64 old_root_used; 6770b86a832SChris Mason struct btrfs_root *tree_root = root->fs_info->tree_root; 67879154b1bSChris Mason 67986b9f2ecSYan, Zheng old_root_used = btrfs_root_used(&root->root_item); 6800b86a832SChris Mason btrfs_write_dirty_block_groups(trans, root); 68156bec294SChris Mason 68279154b1bSChris Mason while (1) { 6830b86a832SChris Mason old_root_bytenr = btrfs_root_bytenr(&root->root_item); 68486b9f2ecSYan, Zheng if (old_root_bytenr == root->node->start && 68586b9f2ecSYan, Zheng old_root_used == btrfs_root_used(&root->root_item)) 68679154b1bSChris Mason break; 68787ef2bb4SChris Mason 6885d4f98a2SYan Zheng btrfs_set_root_node(&root->root_item, root->node); 68979154b1bSChris Mason ret = btrfs_update_root(trans, tree_root, 6900b86a832SChris Mason &root->root_key, 6910b86a832SChris Mason &root->root_item); 69279154b1bSChris Mason BUG_ON(ret); 69356bec294SChris Mason 69486b9f2ecSYan, Zheng old_root_used = btrfs_root_used(&root->root_item); 6954a8c9a62SYan Zheng ret = btrfs_write_dirty_block_groups(trans, root); 69656bec294SChris Mason BUG_ON(ret); 6970b86a832SChris Mason } 698276e680dSYan Zheng 699276e680dSYan Zheng if (root != root->fs_info->extent_root) 700817d52f8SJosef Bacik switch_commit_root(root); 701276e680dSYan Zheng 7020b86a832SChris Mason return 0; 7030b86a832SChris Mason } 7040b86a832SChris Mason 705d352ac68SChris Mason /* 706d352ac68SChris Mason * update all the cowonly tree roots on disk 707d352ac68SChris Mason */ 7085d4f98a2SYan Zheng static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans, 7090b86a832SChris Mason struct btrfs_root *root) 7100b86a832SChris Mason { 7110b86a832SChris Mason struct btrfs_fs_info *fs_info = root->fs_info; 7120b86a832SChris Mason struct list_head *next; 71384234f3aSYan Zheng struct extent_buffer *eb; 71456bec294SChris Mason int ret; 71584234f3aSYan Zheng 71656bec294SChris Mason ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); 71756bec294SChris Mason BUG_ON(ret); 71887ef2bb4SChris Mason 71984234f3aSYan Zheng eb = btrfs_lock_root_node(fs_info->tree_root); 7209fa8cfe7SChris Mason btrfs_cow_block(trans, fs_info->tree_root, eb, NULL, 0, &eb); 72184234f3aSYan Zheng btrfs_tree_unlock(eb); 72284234f3aSYan Zheng free_extent_buffer(eb); 7230b86a832SChris Mason 72456bec294SChris Mason ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); 72556bec294SChris Mason BUG_ON(ret); 72687ef2bb4SChris Mason 7270b86a832SChris Mason while (!list_empty(&fs_info->dirty_cowonly_roots)) { 7280b86a832SChris Mason next = fs_info->dirty_cowonly_roots.next; 7290b86a832SChris Mason list_del_init(next); 7300b86a832SChris Mason root = list_entry(next, struct btrfs_root, dirty_list); 73187ef2bb4SChris Mason 7320b86a832SChris Mason update_cowonly_root(trans, root); 73379154b1bSChris Mason } 734276e680dSYan Zheng 735276e680dSYan Zheng down_write(&fs_info->extent_commit_sem); 736276e680dSYan Zheng switch_commit_root(fs_info->extent_root); 737276e680dSYan Zheng up_write(&fs_info->extent_commit_sem); 738276e680dSYan Zheng 73979154b1bSChris Mason return 0; 74079154b1bSChris Mason } 74179154b1bSChris Mason 742d352ac68SChris Mason /* 743d352ac68SChris Mason * dead roots are old snapshots that need to be deleted. This allocates 744d352ac68SChris Mason * a dirty root struct and adds it into the list of dead roots that need to 745d352ac68SChris Mason * be deleted 746d352ac68SChris Mason */ 7475d4f98a2SYan Zheng int btrfs_add_dead_root(struct btrfs_root *root) 7485eda7b5eSChris Mason { 749b48652c1SYan Zheng mutex_lock(&root->fs_info->trans_mutex); 7505d4f98a2SYan Zheng list_add(&root->root_list, &root->fs_info->dead_roots); 751b48652c1SYan Zheng mutex_unlock(&root->fs_info->trans_mutex); 7525eda7b5eSChris Mason return 0; 7535eda7b5eSChris Mason } 7545eda7b5eSChris Mason 755d352ac68SChris Mason /* 7565d4f98a2SYan Zheng * update all the cowonly tree roots on disk 757d352ac68SChris Mason */ 7585d4f98a2SYan Zheng static noinline int commit_fs_roots(struct btrfs_trans_handle *trans, 7595d4f98a2SYan Zheng struct btrfs_root *root) 7600f7d52f4SChris Mason { 7610f7d52f4SChris Mason struct btrfs_root *gang[8]; 7625d4f98a2SYan Zheng struct btrfs_fs_info *fs_info = root->fs_info; 7630f7d52f4SChris Mason int i; 7640f7d52f4SChris Mason int ret; 76554aa1f4dSChris Mason int err = 0; 76654aa1f4dSChris Mason 7670f7d52f4SChris Mason while (1) { 7685d4f98a2SYan Zheng ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix, 7695d4f98a2SYan Zheng (void **)gang, 0, 7700f7d52f4SChris Mason ARRAY_SIZE(gang), 7710f7d52f4SChris Mason BTRFS_ROOT_TRANS_TAG); 7720f7d52f4SChris Mason if (ret == 0) 7730f7d52f4SChris Mason break; 7740f7d52f4SChris Mason for (i = 0; i < ret; i++) { 7750f7d52f4SChris Mason root = gang[i]; 7765d4f98a2SYan Zheng radix_tree_tag_clear(&fs_info->fs_roots_radix, 7772619ba1fSChris Mason (unsigned long)root->root_key.objectid, 7780f7d52f4SChris Mason BTRFS_ROOT_TRANS_TAG); 77931153d81SYan Zheng 780e02119d5SChris Mason btrfs_free_log(trans, root); 7815d4f98a2SYan Zheng btrfs_update_reloc_root(trans, root); 782d68fc57bSYan, Zheng btrfs_orphan_commit_root(trans, root); 783e02119d5SChris Mason 784978d910dSYan Zheng if (root->commit_root != root->node) { 785817d52f8SJosef Bacik switch_commit_root(root); 786978d910dSYan Zheng btrfs_set_root_node(&root->root_item, 787978d910dSYan Zheng root->node); 788978d910dSYan Zheng } 78931153d81SYan Zheng 7905d4f98a2SYan Zheng err = btrfs_update_root(trans, fs_info->tree_root, 7910f7d52f4SChris Mason &root->root_key, 7920f7d52f4SChris Mason &root->root_item); 79354aa1f4dSChris Mason if (err) 79454aa1f4dSChris Mason break; 7950f7d52f4SChris Mason } 7969f3a7427SChris Mason } 79754aa1f4dSChris Mason return err; 7980f7d52f4SChris Mason } 7990f7d52f4SChris Mason 800d352ac68SChris Mason /* 801d352ac68SChris Mason * defrag a given btree. If cacheonly == 1, this won't read from the disk, 802d352ac68SChris Mason * otherwise every leaf in the btree is read and defragged. 803d352ac68SChris Mason */ 804e9d0b13bSChris Mason int btrfs_defrag_root(struct btrfs_root *root, int cacheonly) 805e9d0b13bSChris Mason { 806e9d0b13bSChris Mason struct btrfs_fs_info *info = root->fs_info; 807e9d0b13bSChris Mason struct btrfs_trans_handle *trans; 8088929ecfaSYan, Zheng int ret; 809d3c2fdcfSChris Mason unsigned long nr; 810e9d0b13bSChris Mason 8118929ecfaSYan, Zheng if (xchg(&root->defrag_running, 1)) 812e9d0b13bSChris Mason return 0; 8138929ecfaSYan, Zheng 8146b80053dSChris Mason while (1) { 8158929ecfaSYan, Zheng trans = btrfs_start_transaction(root, 0); 8168929ecfaSYan, Zheng if (IS_ERR(trans)) 8178929ecfaSYan, Zheng return PTR_ERR(trans); 8188929ecfaSYan, Zheng 819e9d0b13bSChris Mason ret = btrfs_defrag_leaves(trans, root, cacheonly); 8208929ecfaSYan, Zheng 821d3c2fdcfSChris Mason nr = trans->blocks_used; 822e9d0b13bSChris Mason btrfs_end_transaction(trans, root); 823d3c2fdcfSChris Mason btrfs_btree_balance_dirty(info->tree_root, nr); 824e9d0b13bSChris Mason cond_resched(); 825e9d0b13bSChris Mason 8263f157a2fSChris Mason if (root->fs_info->closing || ret != -EAGAIN) 827e9d0b13bSChris Mason break; 828e9d0b13bSChris Mason } 829e9d0b13bSChris Mason root->defrag_running = 0; 8308929ecfaSYan, Zheng return ret; 831e9d0b13bSChris Mason } 832e9d0b13bSChris Mason 8332c47e605SYan Zheng #if 0 834d352ac68SChris Mason /* 835b7ec40d7SChris Mason * when dropping snapshots, we generate a ton of delayed refs, and it makes 836b7ec40d7SChris Mason * sense not to join the transaction while it is trying to flush the current 837b7ec40d7SChris Mason * queue of delayed refs out. 838b7ec40d7SChris Mason * 839b7ec40d7SChris Mason * This is used by the drop snapshot code only 840b7ec40d7SChris Mason */ 841b7ec40d7SChris Mason static noinline int wait_transaction_pre_flush(struct btrfs_fs_info *info) 842b7ec40d7SChris Mason { 843b7ec40d7SChris Mason DEFINE_WAIT(wait); 844b7ec40d7SChris Mason 845b7ec40d7SChris Mason mutex_lock(&info->trans_mutex); 846b7ec40d7SChris Mason while (info->running_transaction && 847b7ec40d7SChris Mason info->running_transaction->delayed_refs.flushing) { 848b7ec40d7SChris Mason prepare_to_wait(&info->transaction_wait, &wait, 849b7ec40d7SChris Mason TASK_UNINTERRUPTIBLE); 850b7ec40d7SChris Mason mutex_unlock(&info->trans_mutex); 85159bc5c75SChris Mason 852b7ec40d7SChris Mason schedule(); 85359bc5c75SChris Mason 854b7ec40d7SChris Mason mutex_lock(&info->trans_mutex); 855b7ec40d7SChris Mason finish_wait(&info->transaction_wait, &wait); 856b7ec40d7SChris Mason } 857b7ec40d7SChris Mason mutex_unlock(&info->trans_mutex); 858b7ec40d7SChris Mason return 0; 859b7ec40d7SChris Mason } 860b7ec40d7SChris Mason 861b7ec40d7SChris Mason /* 862d352ac68SChris Mason * Given a list of roots that need to be deleted, call btrfs_drop_snapshot on 863d352ac68SChris Mason * all of them 864d352ac68SChris Mason */ 8655d4f98a2SYan Zheng int btrfs_drop_dead_root(struct btrfs_root *root) 8660f7d52f4SChris Mason { 8670f7d52f4SChris Mason struct btrfs_trans_handle *trans; 8685d4f98a2SYan Zheng struct btrfs_root *tree_root = root->fs_info->tree_root; 869d3c2fdcfSChris Mason unsigned long nr; 8705d4f98a2SYan Zheng int ret; 87158176a96SJosef Bacik 8729f3a7427SChris Mason while (1) { 873b7ec40d7SChris Mason /* 874b7ec40d7SChris Mason * we don't want to jump in and create a bunch of 875b7ec40d7SChris Mason * delayed refs if the transaction is starting to close 876b7ec40d7SChris Mason */ 877b7ec40d7SChris Mason wait_transaction_pre_flush(tree_root->fs_info); 8780f7d52f4SChris Mason trans = btrfs_start_transaction(tree_root, 1); 879b7ec40d7SChris Mason 880b7ec40d7SChris Mason /* 881b7ec40d7SChris Mason * we've joined a transaction, make sure it isn't 882b7ec40d7SChris Mason * closing right now 883b7ec40d7SChris Mason */ 884b7ec40d7SChris Mason if (trans->transaction->delayed_refs.flushing) { 885b7ec40d7SChris Mason btrfs_end_transaction(trans, tree_root); 886b7ec40d7SChris Mason continue; 887b7ec40d7SChris Mason } 888b7ec40d7SChris Mason 8895d4f98a2SYan Zheng ret = btrfs_drop_snapshot(trans, root); 890d397712bSChris Mason if (ret != -EAGAIN) 8919f3a7427SChris Mason break; 89258176a96SJosef Bacik 8935d4f98a2SYan Zheng ret = btrfs_update_root(trans, tree_root, 8945d4f98a2SYan Zheng &root->root_key, 8955d4f98a2SYan Zheng &root->root_item); 8965d4f98a2SYan Zheng if (ret) 89754aa1f4dSChris Mason break; 898bcc63abbSYan 899d3c2fdcfSChris Mason nr = trans->blocks_used; 9000f7d52f4SChris Mason ret = btrfs_end_transaction(trans, tree_root); 9010f7d52f4SChris Mason BUG_ON(ret); 9025eda7b5eSChris Mason 903d3c2fdcfSChris Mason btrfs_btree_balance_dirty(tree_root, nr); 9044dc11904SChris Mason cond_resched(); 9050f7d52f4SChris Mason } 9065d4f98a2SYan Zheng BUG_ON(ret); 9075d4f98a2SYan Zheng 9085d4f98a2SYan Zheng ret = btrfs_del_root(trans, tree_root, &root->root_key); 9095d4f98a2SYan Zheng BUG_ON(ret); 9105d4f98a2SYan Zheng 9115d4f98a2SYan Zheng nr = trans->blocks_used; 9125d4f98a2SYan Zheng ret = btrfs_end_transaction(trans, tree_root); 9135d4f98a2SYan Zheng BUG_ON(ret); 9145d4f98a2SYan Zheng 9155d4f98a2SYan Zheng free_extent_buffer(root->node); 9165d4f98a2SYan Zheng free_extent_buffer(root->commit_root); 9175d4f98a2SYan Zheng kfree(root); 9185d4f98a2SYan Zheng 9195d4f98a2SYan Zheng btrfs_btree_balance_dirty(tree_root, nr); 92054aa1f4dSChris Mason return ret; 9210f7d52f4SChris Mason } 9222c47e605SYan Zheng #endif 9230f7d52f4SChris Mason 924d352ac68SChris Mason /* 925d352ac68SChris Mason * new snapshots need to be created at a very specific time in the 926d352ac68SChris Mason * transaction commit. This does the actual creation 927d352ac68SChris Mason */ 92880b6794dSChris Mason static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans, 9293063d29fSChris Mason struct btrfs_fs_info *fs_info, 9303063d29fSChris Mason struct btrfs_pending_snapshot *pending) 9313063d29fSChris Mason { 9323063d29fSChris Mason struct btrfs_key key; 93380b6794dSChris Mason struct btrfs_root_item *new_root_item; 9343063d29fSChris Mason struct btrfs_root *tree_root = fs_info->tree_root; 9353063d29fSChris Mason struct btrfs_root *root = pending->root; 9366bdb72deSSage Weil struct btrfs_root *parent_root; 9376bdb72deSSage Weil struct inode *parent_inode; 9386a912213SJosef Bacik struct dentry *parent; 939a22285a6SYan, Zheng struct dentry *dentry; 9403063d29fSChris Mason struct extent_buffer *tmp; 941925baeddSChris Mason struct extent_buffer *old; 9423063d29fSChris Mason int ret; 943d68fc57bSYan, Zheng u64 to_reserve = 0; 9446bdb72deSSage Weil u64 index = 0; 945a22285a6SYan, Zheng u64 objectid; 946b83cc969SLi Zefan u64 root_flags; 9473063d29fSChris Mason 94880b6794dSChris Mason new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS); 94980b6794dSChris Mason if (!new_root_item) { 950a22285a6SYan, Zheng pending->error = -ENOMEM; 95180b6794dSChris Mason goto fail; 95280b6794dSChris Mason } 953a22285a6SYan, Zheng 9543063d29fSChris Mason ret = btrfs_find_free_objectid(trans, tree_root, 0, &objectid); 955a22285a6SYan, Zheng if (ret) { 956a22285a6SYan, Zheng pending->error = ret; 9573063d29fSChris Mason goto fail; 958a22285a6SYan, Zheng } 9593063d29fSChris Mason 9603fd0a558SYan, Zheng btrfs_reloc_pre_snapshot(trans, pending, &to_reserve); 961d68fc57bSYan, Zheng btrfs_orphan_pre_snapshot(trans, pending, &to_reserve); 962d68fc57bSYan, Zheng 963d68fc57bSYan, Zheng if (to_reserve > 0) { 964d68fc57bSYan, Zheng ret = btrfs_block_rsv_add(trans, root, &pending->block_rsv, 9658bb8ab2eSJosef Bacik to_reserve); 966d68fc57bSYan, Zheng if (ret) { 967d68fc57bSYan, Zheng pending->error = ret; 968d68fc57bSYan, Zheng goto fail; 969d68fc57bSYan, Zheng } 970d68fc57bSYan, Zheng } 971d68fc57bSYan, Zheng 9723063d29fSChris Mason key.objectid = objectid; 973a22285a6SYan, Zheng key.offset = (u64)-1; 974a22285a6SYan, Zheng key.type = BTRFS_ROOT_ITEM_KEY; 9753063d29fSChris Mason 976a22285a6SYan, Zheng trans->block_rsv = &pending->block_rsv; 9776bdb72deSSage Weil 978a22285a6SYan, Zheng dentry = pending->dentry; 9796a912213SJosef Bacik parent = dget_parent(dentry); 9806a912213SJosef Bacik parent_inode = parent->d_inode; 981a22285a6SYan, Zheng parent_root = BTRFS_I(parent_inode)->root; 9826bdb72deSSage Weil record_root_in_trans(trans, parent_root); 983a22285a6SYan, Zheng 9846bdb72deSSage Weil /* 9856bdb72deSSage Weil * insert the directory item 9866bdb72deSSage Weil */ 9876bdb72deSSage Weil ret = btrfs_set_inode_index(parent_inode, &index); 9886bdb72deSSage Weil BUG_ON(ret); 9896bdb72deSSage Weil ret = btrfs_insert_dir_item(trans, parent_root, 990a22285a6SYan, Zheng dentry->d_name.name, dentry->d_name.len, 99116cdcec7SMiao Xie parent_inode, &key, 992a22285a6SYan, Zheng BTRFS_FT_DIR, index); 9936bdb72deSSage Weil BUG_ON(ret); 9946bdb72deSSage Weil 995a22285a6SYan, Zheng btrfs_i_size_write(parent_inode, parent_inode->i_size + 996a22285a6SYan, Zheng dentry->d_name.len * 2); 9976bdb72deSSage Weil ret = btrfs_update_inode(trans, parent_root, parent_inode); 9986bdb72deSSage Weil BUG_ON(ret); 9996bdb72deSSage Weil 10006bdb72deSSage Weil record_root_in_trans(trans, root); 10016bdb72deSSage Weil btrfs_set_root_last_snapshot(&root->root_item, trans->transid); 10026bdb72deSSage Weil memcpy(new_root_item, &root->root_item, sizeof(*new_root_item)); 100308fe4db1SLi Zefan btrfs_check_and_init_root_item(new_root_item); 10046bdb72deSSage Weil 1005b83cc969SLi Zefan root_flags = btrfs_root_flags(new_root_item); 1006b83cc969SLi Zefan if (pending->readonly) 1007b83cc969SLi Zefan root_flags |= BTRFS_ROOT_SUBVOL_RDONLY; 1008b83cc969SLi Zefan else 1009b83cc969SLi Zefan root_flags &= ~BTRFS_ROOT_SUBVOL_RDONLY; 1010b83cc969SLi Zefan btrfs_set_root_flags(new_root_item, root_flags); 1011b83cc969SLi Zefan 1012925baeddSChris Mason old = btrfs_lock_root_node(root); 10139fa8cfe7SChris Mason btrfs_cow_block(trans, root, old, NULL, 0, &old); 10145d4f98a2SYan Zheng btrfs_set_lock_blocking(old); 10153063d29fSChris Mason 1016925baeddSChris Mason btrfs_copy_root(trans, root, old, &tmp, objectid); 1017925baeddSChris Mason btrfs_tree_unlock(old); 1018925baeddSChris Mason free_extent_buffer(old); 10193063d29fSChris Mason 10205d4f98a2SYan Zheng btrfs_set_root_node(new_root_item, tmp); 1021a22285a6SYan, Zheng /* record when the snapshot was created in key.offset */ 1022a22285a6SYan, Zheng key.offset = trans->transid; 1023a22285a6SYan, Zheng ret = btrfs_insert_root(trans, tree_root, &key, new_root_item); 1024925baeddSChris Mason btrfs_tree_unlock(tmp); 10253063d29fSChris Mason free_extent_buffer(tmp); 10260660b5afSChris Mason BUG_ON(ret); 10270660b5afSChris Mason 1028a22285a6SYan, Zheng /* 1029a22285a6SYan, Zheng * insert root back/forward references 1030a22285a6SYan, Zheng */ 1031a22285a6SYan, Zheng ret = btrfs_add_root_ref(trans, tree_root, objectid, 1032a22285a6SYan, Zheng parent_root->root_key.objectid, 1033a22285a6SYan, Zheng parent_inode->i_ino, index, 1034a22285a6SYan, Zheng dentry->d_name.name, dentry->d_name.len); 1035a22285a6SYan, Zheng BUG_ON(ret); 10366a912213SJosef Bacik dput(parent); 1037a22285a6SYan, Zheng 1038a22285a6SYan, Zheng key.offset = (u64)-1; 1039a22285a6SYan, Zheng pending->snap = btrfs_read_fs_root_no_name(root->fs_info, &key); 1040a22285a6SYan, Zheng BUG_ON(IS_ERR(pending->snap)); 1041d68fc57bSYan, Zheng 10423fd0a558SYan, Zheng btrfs_reloc_post_snapshot(trans, pending); 1043d68fc57bSYan, Zheng btrfs_orphan_post_snapshot(trans, pending); 10443063d29fSChris Mason fail: 10456bdb72deSSage Weil kfree(new_root_item); 1046a22285a6SYan, Zheng btrfs_block_rsv_release(root, &pending->block_rsv, (u64)-1); 1047a22285a6SYan, Zheng return 0; 10483063d29fSChris Mason } 10493063d29fSChris Mason 1050d352ac68SChris Mason /* 1051d352ac68SChris Mason * create all the snapshots we've scheduled for creation 1052d352ac68SChris Mason */ 105380b6794dSChris Mason static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans, 10543063d29fSChris Mason struct btrfs_fs_info *fs_info) 10553063d29fSChris Mason { 10563063d29fSChris Mason struct btrfs_pending_snapshot *pending; 10573063d29fSChris Mason struct list_head *head = &trans->transaction->pending_snapshots; 10583de4586cSChris Mason int ret; 10593de4586cSChris Mason 1060c6e30871SQinghuang Feng list_for_each_entry(pending, head, list) { 106116cdcec7SMiao Xie /* 106216cdcec7SMiao Xie * We must deal with the delayed items before creating 106316cdcec7SMiao Xie * snapshots, or we will create a snapthot with inconsistent 106416cdcec7SMiao Xie * information. 106516cdcec7SMiao Xie */ 106616cdcec7SMiao Xie ret = btrfs_run_delayed_items(trans, fs_info->fs_root); 106716cdcec7SMiao Xie BUG_ON(ret); 106816cdcec7SMiao Xie 10693de4586cSChris Mason ret = create_pending_snapshot(trans, fs_info, pending); 10703de4586cSChris Mason BUG_ON(ret); 10713de4586cSChris Mason } 10723de4586cSChris Mason return 0; 10733de4586cSChris Mason } 10743de4586cSChris Mason 10755d4f98a2SYan Zheng static void update_super_roots(struct btrfs_root *root) 10765d4f98a2SYan Zheng { 10775d4f98a2SYan Zheng struct btrfs_root_item *root_item; 10785d4f98a2SYan Zheng struct btrfs_super_block *super; 10795d4f98a2SYan Zheng 10805d4f98a2SYan Zheng super = &root->fs_info->super_copy; 10815d4f98a2SYan Zheng 10825d4f98a2SYan Zheng root_item = &root->fs_info->chunk_root->root_item; 10835d4f98a2SYan Zheng super->chunk_root = root_item->bytenr; 10845d4f98a2SYan Zheng super->chunk_root_generation = root_item->generation; 10855d4f98a2SYan Zheng super->chunk_root_level = root_item->level; 10865d4f98a2SYan Zheng 10875d4f98a2SYan Zheng root_item = &root->fs_info->tree_root->root_item; 10885d4f98a2SYan Zheng super->root = root_item->bytenr; 10895d4f98a2SYan Zheng super->generation = root_item->generation; 10905d4f98a2SYan Zheng super->root_level = root_item->level; 10910af3d00bSJosef Bacik if (super->cache_generation != 0 || btrfs_test_opt(root, SPACE_CACHE)) 10920af3d00bSJosef Bacik super->cache_generation = root_item->generation; 10935d4f98a2SYan Zheng } 10945d4f98a2SYan Zheng 1095f36f3042SChris Mason int btrfs_transaction_in_commit(struct btrfs_fs_info *info) 1096f36f3042SChris Mason { 1097f36f3042SChris Mason int ret = 0; 1098f36f3042SChris Mason spin_lock(&info->new_trans_lock); 1099f36f3042SChris Mason if (info->running_transaction) 1100f36f3042SChris Mason ret = info->running_transaction->in_commit; 1101f36f3042SChris Mason spin_unlock(&info->new_trans_lock); 1102f36f3042SChris Mason return ret; 1103f36f3042SChris Mason } 1104f36f3042SChris Mason 11058929ecfaSYan, Zheng int btrfs_transaction_blocked(struct btrfs_fs_info *info) 11068929ecfaSYan, Zheng { 11078929ecfaSYan, Zheng int ret = 0; 11088929ecfaSYan, Zheng spin_lock(&info->new_trans_lock); 11098929ecfaSYan, Zheng if (info->running_transaction) 11108929ecfaSYan, Zheng ret = info->running_transaction->blocked; 11118929ecfaSYan, Zheng spin_unlock(&info->new_trans_lock); 11128929ecfaSYan, Zheng return ret; 11138929ecfaSYan, Zheng } 11148929ecfaSYan, Zheng 1115bb9c12c9SSage Weil /* 1116bb9c12c9SSage Weil * wait for the current transaction commit to start and block subsequent 1117bb9c12c9SSage Weil * transaction joins 1118bb9c12c9SSage Weil */ 1119bb9c12c9SSage Weil static void wait_current_trans_commit_start(struct btrfs_root *root, 1120bb9c12c9SSage Weil struct btrfs_transaction *trans) 1121bb9c12c9SSage Weil { 1122bb9c12c9SSage Weil DEFINE_WAIT(wait); 1123bb9c12c9SSage Weil 1124bb9c12c9SSage Weil if (trans->in_commit) 1125bb9c12c9SSage Weil return; 1126bb9c12c9SSage Weil 1127bb9c12c9SSage Weil while (1) { 1128bb9c12c9SSage Weil prepare_to_wait(&root->fs_info->transaction_blocked_wait, &wait, 1129bb9c12c9SSage Weil TASK_UNINTERRUPTIBLE); 1130bb9c12c9SSage Weil if (trans->in_commit) { 1131bb9c12c9SSage Weil finish_wait(&root->fs_info->transaction_blocked_wait, 1132bb9c12c9SSage Weil &wait); 1133bb9c12c9SSage Weil break; 1134bb9c12c9SSage Weil } 1135bb9c12c9SSage Weil mutex_unlock(&root->fs_info->trans_mutex); 1136bb9c12c9SSage Weil schedule(); 1137bb9c12c9SSage Weil mutex_lock(&root->fs_info->trans_mutex); 1138bb9c12c9SSage Weil finish_wait(&root->fs_info->transaction_blocked_wait, &wait); 1139bb9c12c9SSage Weil } 1140bb9c12c9SSage Weil } 1141bb9c12c9SSage Weil 1142bb9c12c9SSage Weil /* 1143bb9c12c9SSage Weil * wait for the current transaction to start and then become unblocked. 1144bb9c12c9SSage Weil * caller holds ref. 1145bb9c12c9SSage Weil */ 1146bb9c12c9SSage Weil static void wait_current_trans_commit_start_and_unblock(struct btrfs_root *root, 1147bb9c12c9SSage Weil struct btrfs_transaction *trans) 1148bb9c12c9SSage Weil { 1149bb9c12c9SSage Weil DEFINE_WAIT(wait); 1150bb9c12c9SSage Weil 1151bb9c12c9SSage Weil if (trans->commit_done || (trans->in_commit && !trans->blocked)) 1152bb9c12c9SSage Weil return; 1153bb9c12c9SSage Weil 1154bb9c12c9SSage Weil while (1) { 1155bb9c12c9SSage Weil prepare_to_wait(&root->fs_info->transaction_wait, &wait, 1156bb9c12c9SSage Weil TASK_UNINTERRUPTIBLE); 1157bb9c12c9SSage Weil if (trans->commit_done || 1158bb9c12c9SSage Weil (trans->in_commit && !trans->blocked)) { 1159bb9c12c9SSage Weil finish_wait(&root->fs_info->transaction_wait, 1160bb9c12c9SSage Weil &wait); 1161bb9c12c9SSage Weil break; 1162bb9c12c9SSage Weil } 1163bb9c12c9SSage Weil mutex_unlock(&root->fs_info->trans_mutex); 1164bb9c12c9SSage Weil schedule(); 1165bb9c12c9SSage Weil mutex_lock(&root->fs_info->trans_mutex); 1166bb9c12c9SSage Weil finish_wait(&root->fs_info->transaction_wait, 1167bb9c12c9SSage Weil &wait); 1168bb9c12c9SSage Weil } 1169bb9c12c9SSage Weil } 1170bb9c12c9SSage Weil 1171bb9c12c9SSage Weil /* 1172bb9c12c9SSage Weil * commit transactions asynchronously. once btrfs_commit_transaction_async 1173bb9c12c9SSage Weil * returns, any subsequent transaction will not be allowed to join. 1174bb9c12c9SSage Weil */ 1175bb9c12c9SSage Weil struct btrfs_async_commit { 1176bb9c12c9SSage Weil struct btrfs_trans_handle *newtrans; 1177bb9c12c9SSage Weil struct btrfs_root *root; 1178bb9c12c9SSage Weil struct delayed_work work; 1179bb9c12c9SSage Weil }; 1180bb9c12c9SSage Weil 1181bb9c12c9SSage Weil static void do_async_commit(struct work_struct *work) 1182bb9c12c9SSage Weil { 1183bb9c12c9SSage Weil struct btrfs_async_commit *ac = 1184bb9c12c9SSage Weil container_of(work, struct btrfs_async_commit, work.work); 1185bb9c12c9SSage Weil 1186bb9c12c9SSage Weil btrfs_commit_transaction(ac->newtrans, ac->root); 1187bb9c12c9SSage Weil kfree(ac); 1188bb9c12c9SSage Weil } 1189bb9c12c9SSage Weil 1190bb9c12c9SSage Weil int btrfs_commit_transaction_async(struct btrfs_trans_handle *trans, 1191bb9c12c9SSage Weil struct btrfs_root *root, 1192bb9c12c9SSage Weil int wait_for_unblock) 1193bb9c12c9SSage Weil { 1194bb9c12c9SSage Weil struct btrfs_async_commit *ac; 1195bb9c12c9SSage Weil struct btrfs_transaction *cur_trans; 1196bb9c12c9SSage Weil 1197bb9c12c9SSage Weil ac = kmalloc(sizeof(*ac), GFP_NOFS); 1198db5b493aSTsutomu Itoh if (!ac) 1199db5b493aSTsutomu Itoh return -ENOMEM; 1200bb9c12c9SSage Weil 1201bb9c12c9SSage Weil INIT_DELAYED_WORK(&ac->work, do_async_commit); 1202bb9c12c9SSage Weil ac->root = root; 1203bb9c12c9SSage Weil ac->newtrans = btrfs_join_transaction(root, 0); 12043612b495STsutomu Itoh if (IS_ERR(ac->newtrans)) { 12053612b495STsutomu Itoh int err = PTR_ERR(ac->newtrans); 12063612b495STsutomu Itoh kfree(ac); 12073612b495STsutomu Itoh return err; 12083612b495STsutomu Itoh } 1209bb9c12c9SSage Weil 1210bb9c12c9SSage Weil /* take transaction reference */ 1211bb9c12c9SSage Weil mutex_lock(&root->fs_info->trans_mutex); 1212bb9c12c9SSage Weil cur_trans = trans->transaction; 121313c5a93eSJosef Bacik atomic_inc(&cur_trans->use_count); 1214bb9c12c9SSage Weil mutex_unlock(&root->fs_info->trans_mutex); 1215bb9c12c9SSage Weil 1216bb9c12c9SSage Weil btrfs_end_transaction(trans, root); 1217bb9c12c9SSage Weil schedule_delayed_work(&ac->work, 0); 1218bb9c12c9SSage Weil 1219bb9c12c9SSage Weil /* wait for transaction to start and unblock */ 1220bb9c12c9SSage Weil mutex_lock(&root->fs_info->trans_mutex); 1221bb9c12c9SSage Weil if (wait_for_unblock) 1222bb9c12c9SSage Weil wait_current_trans_commit_start_and_unblock(root, cur_trans); 1223bb9c12c9SSage Weil else 1224bb9c12c9SSage Weil wait_current_trans_commit_start(root, cur_trans); 1225bb9c12c9SSage Weil put_transaction(cur_trans); 1226bb9c12c9SSage Weil mutex_unlock(&root->fs_info->trans_mutex); 1227bb9c12c9SSage Weil 1228bb9c12c9SSage Weil return 0; 1229bb9c12c9SSage Weil } 1230bb9c12c9SSage Weil 1231bb9c12c9SSage Weil /* 1232bb9c12c9SSage Weil * btrfs_transaction state sequence: 1233bb9c12c9SSage Weil * in_commit = 0, blocked = 0 (initial) 1234bb9c12c9SSage Weil * in_commit = 1, blocked = 1 1235bb9c12c9SSage Weil * blocked = 0 1236bb9c12c9SSage Weil * commit_done = 1 1237bb9c12c9SSage Weil */ 123879154b1bSChris Mason int btrfs_commit_transaction(struct btrfs_trans_handle *trans, 123979154b1bSChris Mason struct btrfs_root *root) 124079154b1bSChris Mason { 124115ee9bc7SJosef Bacik unsigned long joined = 0; 124279154b1bSChris Mason struct btrfs_transaction *cur_trans; 12438fd17795SChris Mason struct btrfs_transaction *prev_trans = NULL; 124479154b1bSChris Mason DEFINE_WAIT(wait); 124515ee9bc7SJosef Bacik int ret; 124689573b9cSChris Mason int should_grow = 0; 124789573b9cSChris Mason unsigned long now = get_seconds(); 1248dccae999SSage Weil int flush_on_commit = btrfs_test_opt(root, FLUSHONCOMMIT); 124979154b1bSChris Mason 12505a3f23d5SChris Mason btrfs_run_ordered_operations(root, 0); 12515a3f23d5SChris Mason 125256bec294SChris Mason /* make a pass through all the delayed refs we have so far 125356bec294SChris Mason * any runnings procs may add more while we are here 125456bec294SChris Mason */ 125556bec294SChris Mason ret = btrfs_run_delayed_refs(trans, root, 0); 125656bec294SChris Mason BUG_ON(ret); 125756bec294SChris Mason 1258a22285a6SYan, Zheng btrfs_trans_release_metadata(trans, root); 1259a22285a6SYan, Zheng 1260b7ec40d7SChris Mason cur_trans = trans->transaction; 126156bec294SChris Mason /* 126256bec294SChris Mason * set the flushing flag so procs in this transaction have to 126356bec294SChris Mason * start sending their work down. 126456bec294SChris Mason */ 1265b7ec40d7SChris Mason cur_trans->delayed_refs.flushing = 1; 126656bec294SChris Mason 1267c3e69d58SChris Mason ret = btrfs_run_delayed_refs(trans, root, 0); 126856bec294SChris Mason BUG_ON(ret); 126956bec294SChris Mason 127079154b1bSChris Mason mutex_lock(&root->fs_info->trans_mutex); 1271b7ec40d7SChris Mason if (cur_trans->in_commit) { 127213c5a93eSJosef Bacik atomic_inc(&cur_trans->use_count); 1273ccd467d6SChris Mason mutex_unlock(&root->fs_info->trans_mutex); 127479154b1bSChris Mason btrfs_end_transaction(trans, root); 1275ccd467d6SChris Mason 127679154b1bSChris Mason ret = wait_for_commit(root, cur_trans); 127779154b1bSChris Mason BUG_ON(ret); 127815ee9bc7SJosef Bacik 127915ee9bc7SJosef Bacik mutex_lock(&root->fs_info->trans_mutex); 128079154b1bSChris Mason put_transaction(cur_trans); 128115ee9bc7SJosef Bacik mutex_unlock(&root->fs_info->trans_mutex); 128215ee9bc7SJosef Bacik 128379154b1bSChris Mason return 0; 128479154b1bSChris Mason } 12854313b399SChris Mason 12862c90e5d6SChris Mason trans->transaction->in_commit = 1; 1287f9295749SChris Mason trans->transaction->blocked = 1; 1288bb9c12c9SSage Weil wake_up(&root->fs_info->transaction_blocked_wait); 1289bb9c12c9SSage Weil 1290ccd467d6SChris Mason if (cur_trans->list.prev != &root->fs_info->trans_list) { 1291ccd467d6SChris Mason prev_trans = list_entry(cur_trans->list.prev, 1292ccd467d6SChris Mason struct btrfs_transaction, list); 1293ccd467d6SChris Mason if (!prev_trans->commit_done) { 129413c5a93eSJosef Bacik atomic_inc(&prev_trans->use_count); 1295ccd467d6SChris Mason mutex_unlock(&root->fs_info->trans_mutex); 1296ccd467d6SChris Mason 1297ccd467d6SChris Mason wait_for_commit(root, prev_trans); 1298ccd467d6SChris Mason 1299ccd467d6SChris Mason mutex_lock(&root->fs_info->trans_mutex); 130015ee9bc7SJosef Bacik put_transaction(prev_trans); 1301ccd467d6SChris Mason } 1302ccd467d6SChris Mason } 130315ee9bc7SJosef Bacik 130489573b9cSChris Mason if (now < cur_trans->start_time || now - cur_trans->start_time < 1) 130589573b9cSChris Mason should_grow = 1; 130689573b9cSChris Mason 130715ee9bc7SJosef Bacik do { 13087ea394f1SYan Zheng int snap_pending = 0; 130915ee9bc7SJosef Bacik joined = cur_trans->num_joined; 13107ea394f1SYan Zheng if (!list_empty(&trans->transaction->pending_snapshots)) 13117ea394f1SYan Zheng snap_pending = 1; 13127ea394f1SYan Zheng 13132c90e5d6SChris Mason WARN_ON(cur_trans != trans->transaction); 131479154b1bSChris Mason mutex_unlock(&root->fs_info->trans_mutex); 131515ee9bc7SJosef Bacik 13160bdb1db2SSage Weil if (flush_on_commit || snap_pending) { 131724bbcf04SYan, Zheng btrfs_start_delalloc_inodes(root, 1); 131824bbcf04SYan, Zheng ret = btrfs_wait_ordered_extents(root, 0, 1); 1319ebecd3d9SSage Weil BUG_ON(ret); 13207ea394f1SYan Zheng } 13217ea394f1SYan Zheng 132216cdcec7SMiao Xie ret = btrfs_run_delayed_items(trans, root); 132316cdcec7SMiao Xie BUG_ON(ret); 132416cdcec7SMiao Xie 13255a3f23d5SChris Mason /* 13265a3f23d5SChris Mason * rename don't use btrfs_join_transaction, so, once we 13275a3f23d5SChris Mason * set the transaction to blocked above, we aren't going 13285a3f23d5SChris Mason * to get any new ordered operations. We can safely run 13295a3f23d5SChris Mason * it here and no for sure that nothing new will be added 13305a3f23d5SChris Mason * to the list 13315a3f23d5SChris Mason */ 13325a3f23d5SChris Mason btrfs_run_ordered_operations(root, 1); 13335a3f23d5SChris Mason 1334ed3b3d31SChris Mason prepare_to_wait(&cur_trans->writer_wait, &wait, 1335ed3b3d31SChris Mason TASK_UNINTERRUPTIBLE); 1336ed3b3d31SChris Mason 133789573b9cSChris Mason smp_mb(); 133813c5a93eSJosef Bacik if (atomic_read(&cur_trans->num_writers) > 1) 133999d16cbcSSage Weil schedule_timeout(MAX_SCHEDULE_TIMEOUT); 134099d16cbcSSage Weil else if (should_grow) 134199d16cbcSSage Weil schedule_timeout(1); 134215ee9bc7SJosef Bacik 134379154b1bSChris Mason mutex_lock(&root->fs_info->trans_mutex); 134415ee9bc7SJosef Bacik finish_wait(&cur_trans->writer_wait, &wait); 134513c5a93eSJosef Bacik } while (atomic_read(&cur_trans->num_writers) > 1 || 134689573b9cSChris Mason (should_grow && cur_trans->num_joined != joined)); 134715ee9bc7SJosef Bacik 13483063d29fSChris Mason ret = create_pending_snapshots(trans, root->fs_info); 13493063d29fSChris Mason BUG_ON(ret); 13503063d29fSChris Mason 135116cdcec7SMiao Xie ret = btrfs_run_delayed_items(trans, root); 135216cdcec7SMiao Xie BUG_ON(ret); 135316cdcec7SMiao Xie 135456bec294SChris Mason ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); 135556bec294SChris Mason BUG_ON(ret); 135656bec294SChris Mason 13572c90e5d6SChris Mason WARN_ON(cur_trans != trans->transaction); 1358dc17ff8fSChris Mason 1359e02119d5SChris Mason /* btrfs_commit_tree_roots is responsible for getting the 1360e02119d5SChris Mason * various roots consistent with each other. Every pointer 1361e02119d5SChris Mason * in the tree of tree roots has to point to the most up to date 1362e02119d5SChris Mason * root for every subvolume and other tree. So, we have to keep 1363e02119d5SChris Mason * the tree logging code from jumping in and changing any 1364e02119d5SChris Mason * of the trees. 1365e02119d5SChris Mason * 1366e02119d5SChris Mason * At this point in the commit, there can't be any tree-log 1367e02119d5SChris Mason * writers, but a little lower down we drop the trans mutex 1368e02119d5SChris Mason * and let new people in. By holding the tree_log_mutex 1369e02119d5SChris Mason * from now until after the super is written, we avoid races 1370e02119d5SChris Mason * with the tree-log code. 1371e02119d5SChris Mason */ 1372e02119d5SChris Mason mutex_lock(&root->fs_info->tree_log_mutex); 13731a40e23bSZheng Yan 13745d4f98a2SYan Zheng ret = commit_fs_roots(trans, root); 137554aa1f4dSChris Mason BUG_ON(ret); 137654aa1f4dSChris Mason 13775d4f98a2SYan Zheng /* commit_fs_roots gets rid of all the tree log roots, it is now 1378e02119d5SChris Mason * safe to free the root of tree log roots 1379e02119d5SChris Mason */ 1380e02119d5SChris Mason btrfs_free_log_root_tree(trans, root->fs_info); 1381e02119d5SChris Mason 13825d4f98a2SYan Zheng ret = commit_cowonly_roots(trans, root); 138379154b1bSChris Mason BUG_ON(ret); 138454aa1f4dSChris Mason 138511833d66SYan Zheng btrfs_prepare_extent_commit(trans, root); 138611833d66SYan Zheng 138778fae27eSChris Mason cur_trans = root->fs_info->running_transaction; 1388cee36a03SChris Mason spin_lock(&root->fs_info->new_trans_lock); 138978fae27eSChris Mason root->fs_info->running_transaction = NULL; 1390cee36a03SChris Mason spin_unlock(&root->fs_info->new_trans_lock); 13915f39d397SChris Mason 13925d4f98a2SYan Zheng btrfs_set_root_node(&root->fs_info->tree_root->root_item, 13935d4f98a2SYan Zheng root->fs_info->tree_root->node); 1394817d52f8SJosef Bacik switch_commit_root(root->fs_info->tree_root); 13955d4f98a2SYan Zheng 13965d4f98a2SYan Zheng btrfs_set_root_node(&root->fs_info->chunk_root->root_item, 13975d4f98a2SYan Zheng root->fs_info->chunk_root->node); 1398817d52f8SJosef Bacik switch_commit_root(root->fs_info->chunk_root); 13995d4f98a2SYan Zheng 14005d4f98a2SYan Zheng update_super_roots(root); 1401e02119d5SChris Mason 1402e02119d5SChris Mason if (!root->fs_info->log_root_recovering) { 1403e02119d5SChris Mason btrfs_set_super_log_root(&root->fs_info->super_copy, 0); 1404e02119d5SChris Mason btrfs_set_super_log_root_level(&root->fs_info->super_copy, 0); 1405e02119d5SChris Mason } 1406e02119d5SChris Mason 1407a061fc8dSChris Mason memcpy(&root->fs_info->super_for_commit, &root->fs_info->super_copy, 14084b52dff6SChris Mason sizeof(root->fs_info->super_copy)); 1409ccd467d6SChris Mason 1410f9295749SChris Mason trans->transaction->blocked = 0; 1411b7ec40d7SChris Mason 1412f9295749SChris Mason wake_up(&root->fs_info->transaction_wait); 1413e6dcd2dcSChris Mason 141478fae27eSChris Mason mutex_unlock(&root->fs_info->trans_mutex); 141579154b1bSChris Mason ret = btrfs_write_and_wait_transaction(trans, root); 141679154b1bSChris Mason BUG_ON(ret); 1417a512bbf8SYan Zheng write_ctree_super(trans, root, 0); 14184313b399SChris Mason 1419e02119d5SChris Mason /* 1420e02119d5SChris Mason * the super is written, we can safely allow the tree-loggers 1421e02119d5SChris Mason * to go about their business 1422e02119d5SChris Mason */ 1423e02119d5SChris Mason mutex_unlock(&root->fs_info->tree_log_mutex); 1424e02119d5SChris Mason 142511833d66SYan Zheng btrfs_finish_extent_commit(trans, root); 14264313b399SChris Mason 14271a40e23bSZheng Yan mutex_lock(&root->fs_info->trans_mutex); 14281a40e23bSZheng Yan 14292c90e5d6SChris Mason cur_trans->commit_done = 1; 1430b7ec40d7SChris Mason 143115ee9bc7SJosef Bacik root->fs_info->last_trans_committed = cur_trans->transid; 1432817d52f8SJosef Bacik 14332c90e5d6SChris Mason wake_up(&cur_trans->commit_wait); 14343de4586cSChris Mason 143513c5a93eSJosef Bacik list_del_init(&cur_trans->list); 143679154b1bSChris Mason put_transaction(cur_trans); 143778fae27eSChris Mason put_transaction(cur_trans); 143858176a96SJosef Bacik 14391abe9b8aSliubo trace_btrfs_transaction_commit(root); 14401abe9b8aSliubo 144178fae27eSChris Mason mutex_unlock(&root->fs_info->trans_mutex); 14423de4586cSChris Mason 14439ed74f2dSJosef Bacik if (current->journal_info == trans) 14449ed74f2dSJosef Bacik current->journal_info = NULL; 14459ed74f2dSJosef Bacik 14462c90e5d6SChris Mason kmem_cache_free(btrfs_trans_handle_cachep, trans); 144724bbcf04SYan, Zheng 144824bbcf04SYan, Zheng if (current != root->fs_info->transaction_kthread) 144924bbcf04SYan, Zheng btrfs_run_delayed_iputs(root); 145024bbcf04SYan, Zheng 145179154b1bSChris Mason return ret; 145279154b1bSChris Mason } 145379154b1bSChris Mason 1454d352ac68SChris Mason /* 1455d352ac68SChris Mason * interface function to delete all the snapshots we have scheduled for deletion 1456d352ac68SChris Mason */ 1457e9d0b13bSChris Mason int btrfs_clean_old_snapshots(struct btrfs_root *root) 1458e9d0b13bSChris Mason { 14595d4f98a2SYan Zheng LIST_HEAD(list); 14605d4f98a2SYan Zheng struct btrfs_fs_info *fs_info = root->fs_info; 1461e9d0b13bSChris Mason 14625d4f98a2SYan Zheng mutex_lock(&fs_info->trans_mutex); 14635d4f98a2SYan Zheng list_splice_init(&fs_info->dead_roots, &list); 14645d4f98a2SYan Zheng mutex_unlock(&fs_info->trans_mutex); 14655d4f98a2SYan Zheng 14665d4f98a2SYan Zheng while (!list_empty(&list)) { 14675d4f98a2SYan Zheng root = list_entry(list.next, struct btrfs_root, root_list); 146876dda93cSYan, Zheng list_del(&root->root_list); 146976dda93cSYan, Zheng 147016cdcec7SMiao Xie btrfs_kill_all_delayed_nodes(root); 147116cdcec7SMiao Xie 147276dda93cSYan, Zheng if (btrfs_header_backref_rev(root->node) < 147376dda93cSYan, Zheng BTRFS_MIXED_BACKREF_REV) 14743fd0a558SYan, Zheng btrfs_drop_snapshot(root, NULL, 0); 147576dda93cSYan, Zheng else 14763fd0a558SYan, Zheng btrfs_drop_snapshot(root, NULL, 1); 1477e9d0b13bSChris Mason } 1478e9d0b13bSChris Mason return 0; 1479e9d0b13bSChris Mason } 1480