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 { 352c90e5d6SChris Mason WARN_ON(transaction->use_count == 0); 3679154b1bSChris Mason transaction->use_count--; 3778fae27eSChris Mason if (transaction->use_count == 0) { 388fd17795SChris Mason list_del_init(&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 */ 5380b6794dSChris Mason static noinline int join_transaction(struct btrfs_root *root) 5479154b1bSChris Mason { 5579154b1bSChris Mason struct btrfs_transaction *cur_trans; 5679154b1bSChris Mason cur_trans = root->fs_info->running_transaction; 5779154b1bSChris Mason if (!cur_trans) { 582c90e5d6SChris Mason cur_trans = kmem_cache_alloc(btrfs_transaction_cachep, 592c90e5d6SChris Mason GFP_NOFS); 60db5b493aSTsutomu Itoh if (!cur_trans) 61db5b493aSTsutomu Itoh return -ENOMEM; 620f7d52f4SChris Mason root->fs_info->generation++; 6315ee9bc7SJosef Bacik cur_trans->num_writers = 1; 6415ee9bc7SJosef Bacik cur_trans->num_joined = 0; 650f7d52f4SChris Mason cur_trans->transid = root->fs_info->generation; 6679154b1bSChris Mason init_waitqueue_head(&cur_trans->writer_wait); 6779154b1bSChris Mason init_waitqueue_head(&cur_trans->commit_wait); 6879154b1bSChris Mason cur_trans->in_commit = 0; 69f9295749SChris Mason cur_trans->blocked = 0; 70d5719762SChris Mason cur_trans->use_count = 1; 7179154b1bSChris Mason cur_trans->commit_done = 0; 7208607c1bSChris Mason cur_trans->start_time = get_seconds(); 7356bec294SChris Mason 746bef4d31SEric Paris cur_trans->delayed_refs.root = RB_ROOT; 7556bec294SChris Mason cur_trans->delayed_refs.num_entries = 0; 76c3e69d58SChris Mason cur_trans->delayed_refs.num_heads_ready = 0; 77c3e69d58SChris Mason cur_trans->delayed_refs.num_heads = 0; 7856bec294SChris Mason cur_trans->delayed_refs.flushing = 0; 79c3e69d58SChris Mason cur_trans->delayed_refs.run_delayed_start = 0; 8056bec294SChris Mason spin_lock_init(&cur_trans->delayed_refs.lock); 8156bec294SChris Mason 823063d29fSChris Mason INIT_LIST_HEAD(&cur_trans->pending_snapshots); 838fd17795SChris Mason list_add_tail(&cur_trans->list, &root->fs_info->trans_list); 84d1310b2eSChris Mason extent_io_tree_init(&cur_trans->dirty_pages, 855f39d397SChris Mason root->fs_info->btree_inode->i_mapping, 865f39d397SChris Mason GFP_NOFS); 8748ec2cf8SChris Mason spin_lock(&root->fs_info->new_trans_lock); 8848ec2cf8SChris Mason root->fs_info->running_transaction = cur_trans; 8948ec2cf8SChris Mason spin_unlock(&root->fs_info->new_trans_lock); 9015ee9bc7SJosef Bacik } else { 9179154b1bSChris Mason cur_trans->num_writers++; 9215ee9bc7SJosef Bacik cur_trans->num_joined++; 9315ee9bc7SJosef Bacik } 9415ee9bc7SJosef Bacik 9579154b1bSChris Mason return 0; 9679154b1bSChris Mason } 9779154b1bSChris Mason 98d352ac68SChris Mason /* 99d397712bSChris Mason * this does all the record keeping required to make sure that a reference 100d397712bSChris Mason * counted root is properly recorded in a given transaction. This is required 101d397712bSChris Mason * to make sure the old root from before we joined the transaction is deleted 102d397712bSChris Mason * when the transaction commits 103d352ac68SChris Mason */ 1045d4f98a2SYan Zheng static noinline int record_root_in_trans(struct btrfs_trans_handle *trans, 1055d4f98a2SYan Zheng struct btrfs_root *root) 1066702ed49SChris Mason { 1075d4f98a2SYan Zheng if (root->ref_cows && root->last_trans < trans->transid) { 1086702ed49SChris Mason WARN_ON(root == root->fs_info->extent_root); 1095d4f98a2SYan Zheng WARN_ON(root->commit_root != root->node); 1105d4f98a2SYan Zheng 1116702ed49SChris Mason radix_tree_tag_set(&root->fs_info->fs_roots_radix, 1126702ed49SChris Mason (unsigned long)root->root_key.objectid, 1136702ed49SChris Mason BTRFS_ROOT_TRANS_TAG); 1145d4f98a2SYan Zheng root->last_trans = trans->transid; 1155d4f98a2SYan Zheng btrfs_init_reloc_root(trans, root); 1166702ed49SChris Mason } 1175d4f98a2SYan Zheng return 0; 1186702ed49SChris Mason } 1195d4f98a2SYan Zheng 1205d4f98a2SYan Zheng int btrfs_record_root_in_trans(struct btrfs_trans_handle *trans, 1215d4f98a2SYan Zheng struct btrfs_root *root) 1225d4f98a2SYan Zheng { 1235d4f98a2SYan Zheng if (!root->ref_cows) 1245d4f98a2SYan Zheng return 0; 1255d4f98a2SYan Zheng 1265d4f98a2SYan Zheng mutex_lock(&root->fs_info->trans_mutex); 1275d4f98a2SYan Zheng if (root->last_trans == trans->transid) { 1285d4f98a2SYan Zheng mutex_unlock(&root->fs_info->trans_mutex); 1295d4f98a2SYan Zheng return 0; 1305d4f98a2SYan Zheng } 1315d4f98a2SYan Zheng 1325d4f98a2SYan Zheng record_root_in_trans(trans, root); 1335d4f98a2SYan Zheng mutex_unlock(&root->fs_info->trans_mutex); 1346702ed49SChris Mason return 0; 1356702ed49SChris Mason } 1366702ed49SChris Mason 137d352ac68SChris Mason /* wait for commit against the current transaction to become unblocked 138d352ac68SChris Mason * when this is done, it is safe to start a new transaction, but the current 139d352ac68SChris Mason * transaction might not be fully on disk. 140d352ac68SChris Mason */ 14137d1aeeeSChris Mason static void wait_current_trans(struct btrfs_root *root) 14279154b1bSChris Mason { 143f9295749SChris Mason struct btrfs_transaction *cur_trans; 14479154b1bSChris Mason 145f9295749SChris Mason cur_trans = root->fs_info->running_transaction; 14637d1aeeeSChris Mason if (cur_trans && cur_trans->blocked) { 147f9295749SChris Mason DEFINE_WAIT(wait); 148f9295749SChris Mason cur_trans->use_count++; 149f9295749SChris Mason while (1) { 150f9295749SChris Mason prepare_to_wait(&root->fs_info->transaction_wait, &wait, 151f9295749SChris Mason TASK_UNINTERRUPTIBLE); 152471fa17dSZhao Lei if (!cur_trans->blocked) 153471fa17dSZhao Lei break; 154f9295749SChris Mason mutex_unlock(&root->fs_info->trans_mutex); 155f9295749SChris Mason schedule(); 156f9295749SChris Mason mutex_lock(&root->fs_info->trans_mutex); 157f9295749SChris Mason } 158471fa17dSZhao Lei finish_wait(&root->fs_info->transaction_wait, &wait); 159f9295749SChris Mason put_transaction(cur_trans); 160f9295749SChris Mason } 16137d1aeeeSChris Mason } 16237d1aeeeSChris Mason 163249ac1e5SJosef Bacik enum btrfs_trans_type { 164249ac1e5SJosef Bacik TRANS_START, 165249ac1e5SJosef Bacik TRANS_JOIN, 166249ac1e5SJosef Bacik TRANS_USERSPACE, 1670af3d00bSJosef Bacik TRANS_JOIN_NOLOCK, 168249ac1e5SJosef Bacik }; 169249ac1e5SJosef Bacik 170a22285a6SYan, Zheng static int may_wait_transaction(struct btrfs_root *root, int type) 17137d1aeeeSChris Mason { 1724bef0848SChris Mason if (!root->fs_info->log_root_recovering && 173249ac1e5SJosef Bacik ((type == TRANS_START && !root->fs_info->open_ioctl_trans) || 174249ac1e5SJosef Bacik type == TRANS_USERSPACE)) 175a22285a6SYan, Zheng return 1; 176a22285a6SYan, Zheng return 0; 177a22285a6SYan, Zheng } 178a22285a6SYan, Zheng 179a22285a6SYan, Zheng static struct btrfs_trans_handle *start_transaction(struct btrfs_root *root, 180a22285a6SYan, Zheng u64 num_items, int type) 181a22285a6SYan, Zheng { 182a22285a6SYan, Zheng struct btrfs_trans_handle *h; 183a22285a6SYan, Zheng struct btrfs_transaction *cur_trans; 184a22285a6SYan, Zheng int ret; 185acce952bSliubo 186acce952bSliubo if (root->fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) 187acce952bSliubo return ERR_PTR(-EROFS); 188a22285a6SYan, Zheng again: 189a22285a6SYan, Zheng h = kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS); 190a22285a6SYan, Zheng if (!h) 191a22285a6SYan, Zheng return ERR_PTR(-ENOMEM); 192a22285a6SYan, Zheng 1930af3d00bSJosef Bacik if (type != TRANS_JOIN_NOLOCK) 194a22285a6SYan, Zheng mutex_lock(&root->fs_info->trans_mutex); 195a22285a6SYan, Zheng if (may_wait_transaction(root, type)) 19637d1aeeeSChris Mason wait_current_trans(root); 197a22285a6SYan, Zheng 19879154b1bSChris Mason ret = join_transaction(root); 199db5b493aSTsutomu Itoh if (ret < 0) { 2006e8df2aeSYoshinori Sano kmem_cache_free(btrfs_trans_handle_cachep, h); 201db5b493aSTsutomu Itoh if (type != TRANS_JOIN_NOLOCK) 202db5b493aSTsutomu Itoh mutex_unlock(&root->fs_info->trans_mutex); 203db5b493aSTsutomu Itoh return ERR_PTR(ret); 204db5b493aSTsutomu Itoh } 2050f7d52f4SChris Mason 206a22285a6SYan, Zheng cur_trans = root->fs_info->running_transaction; 207a22285a6SYan, Zheng cur_trans->use_count++; 2080af3d00bSJosef Bacik if (type != TRANS_JOIN_NOLOCK) 209a22285a6SYan, Zheng mutex_unlock(&root->fs_info->trans_mutex); 210a22285a6SYan, Zheng 211a22285a6SYan, Zheng h->transid = cur_trans->transid; 212a22285a6SYan, Zheng h->transaction = cur_trans; 21379154b1bSChris Mason h->blocks_used = 0; 214d2fb3437SYan Zheng h->block_group = 0; 215a22285a6SYan, Zheng h->bytes_reserved = 0; 21656bec294SChris Mason h->delayed_ref_updates = 0; 217f0486c68SYan, Zheng h->block_rsv = NULL; 218b7ec40d7SChris Mason 219a22285a6SYan, Zheng smp_mb(); 220a22285a6SYan, Zheng if (cur_trans->blocked && may_wait_transaction(root, type)) { 221a22285a6SYan, Zheng btrfs_commit_transaction(h, root); 222a22285a6SYan, Zheng goto again; 223a22285a6SYan, Zheng } 2249ed74f2dSJosef Bacik 225a22285a6SYan, Zheng if (num_items > 0) { 2268bb8ab2eSJosef Bacik ret = btrfs_trans_reserve_metadata(h, root, num_items); 227a22285a6SYan, Zheng if (ret == -EAGAIN) { 228a22285a6SYan, Zheng btrfs_commit_transaction(h, root); 229a22285a6SYan, Zheng goto again; 230a22285a6SYan, Zheng } 231a22285a6SYan, Zheng if (ret < 0) { 232a22285a6SYan, Zheng btrfs_end_transaction(h, root); 233a22285a6SYan, Zheng return ERR_PTR(ret); 234a22285a6SYan, Zheng } 235a22285a6SYan, Zheng } 236a22285a6SYan, Zheng 2370af3d00bSJosef Bacik if (type != TRANS_JOIN_NOLOCK) 238a22285a6SYan, Zheng mutex_lock(&root->fs_info->trans_mutex); 2395d4f98a2SYan Zheng record_root_in_trans(h, root); 2400af3d00bSJosef Bacik if (type != TRANS_JOIN_NOLOCK) 24179154b1bSChris Mason mutex_unlock(&root->fs_info->trans_mutex); 242a22285a6SYan, Zheng 243a22285a6SYan, Zheng if (!current->journal_info && type != TRANS_USERSPACE) 244a22285a6SYan, Zheng current->journal_info = h; 24579154b1bSChris Mason return h; 24679154b1bSChris Mason } 24779154b1bSChris Mason 248f9295749SChris Mason struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root, 249a22285a6SYan, Zheng int num_items) 250f9295749SChris Mason { 251a22285a6SYan, Zheng return start_transaction(root, num_items, TRANS_START); 252f9295749SChris Mason } 253f9295749SChris Mason struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root, 254f9295749SChris Mason int num_blocks) 255f9295749SChris Mason { 256a22285a6SYan, Zheng return start_transaction(root, 0, TRANS_JOIN); 257f9295749SChris Mason } 258f9295749SChris Mason 2590af3d00bSJosef Bacik struct btrfs_trans_handle *btrfs_join_transaction_nolock(struct btrfs_root *root, 2600af3d00bSJosef Bacik int num_blocks) 2610af3d00bSJosef Bacik { 2620af3d00bSJosef Bacik return start_transaction(root, 0, TRANS_JOIN_NOLOCK); 2630af3d00bSJosef Bacik } 2640af3d00bSJosef Bacik 2659ca9ee09SSage Weil struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *r, 2669ca9ee09SSage Weil int num_blocks) 2679ca9ee09SSage Weil { 268a22285a6SYan, Zheng return start_transaction(r, 0, TRANS_USERSPACE); 2699ca9ee09SSage Weil } 2709ca9ee09SSage Weil 271d352ac68SChris Mason /* wait for a transaction commit to be fully complete */ 27289ce8a63SChris Mason static noinline int wait_for_commit(struct btrfs_root *root, 27389ce8a63SChris Mason struct btrfs_transaction *commit) 27489ce8a63SChris Mason { 27589ce8a63SChris Mason DEFINE_WAIT(wait); 27689ce8a63SChris Mason mutex_lock(&root->fs_info->trans_mutex); 27789ce8a63SChris Mason while (!commit->commit_done) { 27889ce8a63SChris Mason prepare_to_wait(&commit->commit_wait, &wait, 27989ce8a63SChris Mason TASK_UNINTERRUPTIBLE); 28089ce8a63SChris Mason if (commit->commit_done) 28189ce8a63SChris Mason break; 28289ce8a63SChris Mason mutex_unlock(&root->fs_info->trans_mutex); 28389ce8a63SChris Mason schedule(); 28489ce8a63SChris Mason mutex_lock(&root->fs_info->trans_mutex); 28589ce8a63SChris Mason } 28689ce8a63SChris Mason mutex_unlock(&root->fs_info->trans_mutex); 28789ce8a63SChris Mason finish_wait(&commit->commit_wait, &wait); 28889ce8a63SChris Mason return 0; 28989ce8a63SChris Mason } 29089ce8a63SChris Mason 29146204592SSage Weil int btrfs_wait_for_commit(struct btrfs_root *root, u64 transid) 29246204592SSage Weil { 29346204592SSage Weil struct btrfs_transaction *cur_trans = NULL, *t; 29446204592SSage Weil int ret; 29546204592SSage Weil 29646204592SSage Weil mutex_lock(&root->fs_info->trans_mutex); 29746204592SSage Weil 29846204592SSage Weil ret = 0; 29946204592SSage Weil if (transid) { 30046204592SSage Weil if (transid <= root->fs_info->last_trans_committed) 30146204592SSage Weil goto out_unlock; 30246204592SSage Weil 30346204592SSage Weil /* find specified transaction */ 30446204592SSage Weil list_for_each_entry(t, &root->fs_info->trans_list, list) { 30546204592SSage Weil if (t->transid == transid) { 30646204592SSage Weil cur_trans = t; 30746204592SSage Weil break; 30846204592SSage Weil } 30946204592SSage Weil if (t->transid > transid) 31046204592SSage Weil break; 31146204592SSage Weil } 31246204592SSage Weil ret = -EINVAL; 31346204592SSage Weil if (!cur_trans) 31446204592SSage Weil goto out_unlock; /* bad transid */ 31546204592SSage Weil } else { 31646204592SSage Weil /* find newest transaction that is committing | committed */ 31746204592SSage Weil list_for_each_entry_reverse(t, &root->fs_info->trans_list, 31846204592SSage Weil list) { 31946204592SSage Weil if (t->in_commit) { 32046204592SSage Weil if (t->commit_done) 32146204592SSage Weil goto out_unlock; 32246204592SSage Weil cur_trans = t; 32346204592SSage Weil break; 32446204592SSage Weil } 32546204592SSage Weil } 32646204592SSage Weil if (!cur_trans) 32746204592SSage Weil goto out_unlock; /* nothing committing|committed */ 32846204592SSage Weil } 32946204592SSage Weil 33046204592SSage Weil cur_trans->use_count++; 33146204592SSage Weil mutex_unlock(&root->fs_info->trans_mutex); 33246204592SSage Weil 33346204592SSage Weil wait_for_commit(root, cur_trans); 33446204592SSage Weil 33546204592SSage Weil mutex_lock(&root->fs_info->trans_mutex); 33646204592SSage Weil put_transaction(cur_trans); 33746204592SSage Weil ret = 0; 33846204592SSage Weil out_unlock: 33946204592SSage Weil mutex_unlock(&root->fs_info->trans_mutex); 34046204592SSage Weil return ret; 34146204592SSage Weil } 34246204592SSage Weil 3435d4f98a2SYan Zheng #if 0 344d352ac68SChris Mason /* 345d397712bSChris Mason * rate limit against the drop_snapshot code. This helps to slow down new 346d397712bSChris Mason * operations if the drop_snapshot code isn't able to keep up. 347d352ac68SChris Mason */ 34837d1aeeeSChris Mason static void throttle_on_drops(struct btrfs_root *root) 349ab78c84dSChris Mason { 350ab78c84dSChris Mason struct btrfs_fs_info *info = root->fs_info; 3512dd3e67bSChris Mason int harder_count = 0; 352ab78c84dSChris Mason 3532dd3e67bSChris Mason harder: 354ab78c84dSChris Mason if (atomic_read(&info->throttles)) { 355ab78c84dSChris Mason DEFINE_WAIT(wait); 356ab78c84dSChris Mason int thr; 357ab78c84dSChris Mason thr = atomic_read(&info->throttle_gen); 358ab78c84dSChris Mason 359ab78c84dSChris Mason do { 360ab78c84dSChris Mason prepare_to_wait(&info->transaction_throttle, 361ab78c84dSChris Mason &wait, TASK_UNINTERRUPTIBLE); 362ab78c84dSChris Mason if (!atomic_read(&info->throttles)) { 363ab78c84dSChris Mason finish_wait(&info->transaction_throttle, &wait); 364ab78c84dSChris Mason break; 365ab78c84dSChris Mason } 366ab78c84dSChris Mason schedule(); 367ab78c84dSChris Mason finish_wait(&info->transaction_throttle, &wait); 368ab78c84dSChris Mason } while (thr == atomic_read(&info->throttle_gen)); 3692dd3e67bSChris Mason harder_count++; 3702dd3e67bSChris Mason 3712dd3e67bSChris Mason if (root->fs_info->total_ref_cache_size > 1 * 1024 * 1024 && 3722dd3e67bSChris Mason harder_count < 2) 3732dd3e67bSChris Mason goto harder; 3742dd3e67bSChris Mason 3752dd3e67bSChris Mason if (root->fs_info->total_ref_cache_size > 5 * 1024 * 1024 && 3762dd3e67bSChris Mason harder_count < 10) 3772dd3e67bSChris Mason goto harder; 3782dd3e67bSChris Mason 3792dd3e67bSChris Mason if (root->fs_info->total_ref_cache_size > 10 * 1024 * 1024 && 3802dd3e67bSChris Mason harder_count < 20) 3812dd3e67bSChris Mason goto harder; 382ab78c84dSChris Mason } 383ab78c84dSChris Mason } 3845d4f98a2SYan Zheng #endif 385ab78c84dSChris Mason 38637d1aeeeSChris Mason void btrfs_throttle(struct btrfs_root *root) 38737d1aeeeSChris Mason { 38837d1aeeeSChris Mason mutex_lock(&root->fs_info->trans_mutex); 3899ca9ee09SSage Weil if (!root->fs_info->open_ioctl_trans) 39037d1aeeeSChris Mason wait_current_trans(root); 39137d1aeeeSChris Mason mutex_unlock(&root->fs_info->trans_mutex); 39237d1aeeeSChris Mason } 39337d1aeeeSChris Mason 3948929ecfaSYan, Zheng static int should_end_transaction(struct btrfs_trans_handle *trans, 3958929ecfaSYan, Zheng struct btrfs_root *root) 3968929ecfaSYan, Zheng { 3978929ecfaSYan, Zheng int ret; 3988929ecfaSYan, Zheng ret = btrfs_block_rsv_check(trans, root, 3998929ecfaSYan, Zheng &root->fs_info->global_block_rsv, 0, 5); 4008929ecfaSYan, Zheng return ret ? 1 : 0; 4018929ecfaSYan, Zheng } 4028929ecfaSYan, Zheng 4038929ecfaSYan, Zheng int btrfs_should_end_transaction(struct btrfs_trans_handle *trans, 4048929ecfaSYan, Zheng struct btrfs_root *root) 4058929ecfaSYan, Zheng { 4068929ecfaSYan, Zheng struct btrfs_transaction *cur_trans = trans->transaction; 4078929ecfaSYan, Zheng int updates; 4088929ecfaSYan, Zheng 4098929ecfaSYan, Zheng if (cur_trans->blocked || cur_trans->delayed_refs.flushing) 4108929ecfaSYan, Zheng return 1; 4118929ecfaSYan, Zheng 4128929ecfaSYan, Zheng updates = trans->delayed_ref_updates; 4138929ecfaSYan, Zheng trans->delayed_ref_updates = 0; 4148929ecfaSYan, Zheng if (updates) 4158929ecfaSYan, Zheng btrfs_run_delayed_refs(trans, root, updates); 4168929ecfaSYan, Zheng 4178929ecfaSYan, Zheng return should_end_transaction(trans, root); 4188929ecfaSYan, Zheng } 4198929ecfaSYan, Zheng 42089ce8a63SChris Mason static int __btrfs_end_transaction(struct btrfs_trans_handle *trans, 4210af3d00bSJosef Bacik struct btrfs_root *root, int throttle, int lock) 42279154b1bSChris Mason { 4238929ecfaSYan, Zheng struct btrfs_transaction *cur_trans = trans->transaction; 424ab78c84dSChris Mason struct btrfs_fs_info *info = root->fs_info; 425c3e69d58SChris Mason int count = 0; 426d6e4a428SChris Mason 427c3e69d58SChris Mason while (count < 4) { 428c3e69d58SChris Mason unsigned long cur = trans->delayed_ref_updates; 429c3e69d58SChris Mason trans->delayed_ref_updates = 0; 430c3e69d58SChris Mason if (cur && 431c3e69d58SChris Mason trans->transaction->delayed_refs.num_heads_ready > 64) { 432c3e69d58SChris Mason trans->delayed_ref_updates = 0; 433b7ec40d7SChris Mason 434b7ec40d7SChris Mason /* 435b7ec40d7SChris Mason * do a full flush if the transaction is trying 436b7ec40d7SChris Mason * to close 437b7ec40d7SChris Mason */ 438b7ec40d7SChris Mason if (trans->transaction->delayed_refs.flushing) 439b7ec40d7SChris Mason cur = 0; 440c3e69d58SChris Mason btrfs_run_delayed_refs(trans, root, cur); 441c3e69d58SChris Mason } else { 442c3e69d58SChris Mason break; 443c3e69d58SChris Mason } 444c3e69d58SChris Mason count++; 44556bec294SChris Mason } 44656bec294SChris Mason 447a22285a6SYan, Zheng btrfs_trans_release_metadata(trans, root); 448a22285a6SYan, Zheng 4490af3d00bSJosef Bacik if (lock && !root->fs_info->open_ioctl_trans && 4508929ecfaSYan, Zheng should_end_transaction(trans, root)) 4518929ecfaSYan, Zheng trans->transaction->blocked = 1; 4528929ecfaSYan, Zheng 4530af3d00bSJosef Bacik if (lock && cur_trans->blocked && !cur_trans->in_commit) { 4548929ecfaSYan, Zheng if (throttle) 4558929ecfaSYan, Zheng return btrfs_commit_transaction(trans, root); 4568929ecfaSYan, Zheng else 4578929ecfaSYan, Zheng wake_up_process(info->transaction_kthread); 4588929ecfaSYan, Zheng } 4598929ecfaSYan, Zheng 4600af3d00bSJosef Bacik if (lock) 461ab78c84dSChris Mason mutex_lock(&info->trans_mutex); 4628929ecfaSYan, Zheng WARN_ON(cur_trans != info->running_transaction); 463d5719762SChris Mason WARN_ON(cur_trans->num_writers < 1); 464ccd467d6SChris Mason cur_trans->num_writers--; 46589ce8a63SChris Mason 46699d16cbcSSage Weil smp_mb(); 46779154b1bSChris Mason if (waitqueue_active(&cur_trans->writer_wait)) 46879154b1bSChris Mason wake_up(&cur_trans->writer_wait); 46979154b1bSChris Mason put_transaction(cur_trans); 4700af3d00bSJosef Bacik if (lock) 471ab78c84dSChris Mason mutex_unlock(&info->trans_mutex); 4729ed74f2dSJosef Bacik 4739ed74f2dSJosef Bacik if (current->journal_info == trans) 4749ed74f2dSJosef Bacik current->journal_info = NULL; 475d6025579SChris Mason memset(trans, 0, sizeof(*trans)); 4762c90e5d6SChris Mason kmem_cache_free(btrfs_trans_handle_cachep, trans); 477ab78c84dSChris Mason 47824bbcf04SYan, Zheng if (throttle) 47924bbcf04SYan, Zheng btrfs_run_delayed_iputs(root); 48024bbcf04SYan, Zheng 48179154b1bSChris Mason return 0; 48279154b1bSChris Mason } 48379154b1bSChris Mason 48489ce8a63SChris Mason int btrfs_end_transaction(struct btrfs_trans_handle *trans, 48589ce8a63SChris Mason struct btrfs_root *root) 48689ce8a63SChris Mason { 4870af3d00bSJosef Bacik return __btrfs_end_transaction(trans, root, 0, 1); 48889ce8a63SChris Mason } 48989ce8a63SChris Mason 49089ce8a63SChris Mason int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans, 49189ce8a63SChris Mason struct btrfs_root *root) 49289ce8a63SChris Mason { 4930af3d00bSJosef Bacik return __btrfs_end_transaction(trans, root, 1, 1); 4940af3d00bSJosef Bacik } 4950af3d00bSJosef Bacik 4960af3d00bSJosef Bacik int btrfs_end_transaction_nolock(struct btrfs_trans_handle *trans, 4970af3d00bSJosef Bacik struct btrfs_root *root) 4980af3d00bSJosef Bacik { 4990af3d00bSJosef Bacik return __btrfs_end_transaction(trans, root, 0, 0); 50089ce8a63SChris Mason } 50189ce8a63SChris Mason 502d352ac68SChris Mason /* 503d352ac68SChris Mason * when btree blocks are allocated, they have some corresponding bits set for 504d352ac68SChris Mason * them in one of two extent_io trees. This is used to make sure all of 505690587d1SChris Mason * those extents are sent to disk but does not wait on them 506d352ac68SChris Mason */ 507690587d1SChris Mason int btrfs_write_marked_extents(struct btrfs_root *root, 5088cef4e16SYan, Zheng struct extent_io_tree *dirty_pages, int mark) 50979154b1bSChris Mason { 5107c4452b9SChris Mason int ret; 511777e6bd7SChris Mason int err = 0; 5127c4452b9SChris Mason int werr = 0; 5137c4452b9SChris Mason struct page *page; 5147c4452b9SChris Mason struct inode *btree_inode = root->fs_info->btree_inode; 515777e6bd7SChris Mason u64 start = 0; 5165f39d397SChris Mason u64 end; 5175f39d397SChris Mason unsigned long index; 5187c4452b9SChris Mason 5197c4452b9SChris Mason while (1) { 520777e6bd7SChris Mason ret = find_first_extent_bit(dirty_pages, start, &start, &end, 5218cef4e16SYan, Zheng mark); 5225f39d397SChris Mason if (ret) 5237c4452b9SChris Mason break; 5245f39d397SChris Mason while (start <= end) { 525777e6bd7SChris Mason cond_resched(); 526777e6bd7SChris Mason 5275f39d397SChris Mason index = start >> PAGE_CACHE_SHIFT; 52835ebb934SChris Mason start = (u64)(index + 1) << PAGE_CACHE_SHIFT; 5294bef0848SChris Mason page = find_get_page(btree_inode->i_mapping, index); 5307c4452b9SChris Mason if (!page) 5317c4452b9SChris Mason continue; 5324bef0848SChris Mason 5334bef0848SChris Mason btree_lock_page_hook(page); 5344bef0848SChris Mason if (!page->mapping) { 5354bef0848SChris Mason unlock_page(page); 5364bef0848SChris Mason page_cache_release(page); 5374bef0848SChris Mason continue; 5384bef0848SChris Mason } 5394bef0848SChris Mason 5406702ed49SChris Mason if (PageWriteback(page)) { 5416702ed49SChris Mason if (PageDirty(page)) 5426702ed49SChris Mason wait_on_page_writeback(page); 5436702ed49SChris Mason else { 5446702ed49SChris Mason unlock_page(page); 5456702ed49SChris Mason page_cache_release(page); 5466702ed49SChris Mason continue; 5476702ed49SChris Mason } 5486702ed49SChris Mason } 5497c4452b9SChris Mason err = write_one_page(page, 0); 5507c4452b9SChris Mason if (err) 5517c4452b9SChris Mason werr = err; 5527c4452b9SChris Mason page_cache_release(page); 5537c4452b9SChris Mason } 5547c4452b9SChris Mason } 555690587d1SChris Mason if (err) 556690587d1SChris Mason werr = err; 557690587d1SChris Mason return werr; 558690587d1SChris Mason } 559690587d1SChris Mason 560690587d1SChris Mason /* 561690587d1SChris Mason * when btree blocks are allocated, they have some corresponding bits set for 562690587d1SChris Mason * them in one of two extent_io trees. This is used to make sure all of 563690587d1SChris Mason * those extents are on disk for transaction or log commit. We wait 564690587d1SChris Mason * on all the pages and clear them from the dirty pages state tree 565690587d1SChris Mason */ 566690587d1SChris Mason int btrfs_wait_marked_extents(struct btrfs_root *root, 5678cef4e16SYan, Zheng struct extent_io_tree *dirty_pages, int mark) 568690587d1SChris Mason { 569690587d1SChris Mason int ret; 570690587d1SChris Mason int err = 0; 571690587d1SChris Mason int werr = 0; 572690587d1SChris Mason struct page *page; 573690587d1SChris Mason struct inode *btree_inode = root->fs_info->btree_inode; 574690587d1SChris Mason u64 start = 0; 575690587d1SChris Mason u64 end; 576690587d1SChris Mason unsigned long index; 577690587d1SChris Mason 578777e6bd7SChris Mason while (1) { 5798cef4e16SYan, Zheng ret = find_first_extent_bit(dirty_pages, start, &start, &end, 5808cef4e16SYan, Zheng mark); 581777e6bd7SChris Mason if (ret) 582777e6bd7SChris Mason break; 583777e6bd7SChris Mason 5848cef4e16SYan, Zheng clear_extent_bits(dirty_pages, start, end, mark, GFP_NOFS); 585777e6bd7SChris Mason while (start <= end) { 586777e6bd7SChris Mason index = start >> PAGE_CACHE_SHIFT; 587777e6bd7SChris Mason start = (u64)(index + 1) << PAGE_CACHE_SHIFT; 588777e6bd7SChris Mason page = find_get_page(btree_inode->i_mapping, index); 589777e6bd7SChris Mason if (!page) 590777e6bd7SChris Mason continue; 591777e6bd7SChris Mason if (PageDirty(page)) { 5924bef0848SChris Mason btree_lock_page_hook(page); 5934bef0848SChris Mason wait_on_page_writeback(page); 594777e6bd7SChris Mason err = write_one_page(page, 0); 595777e6bd7SChris Mason if (err) 596777e6bd7SChris Mason werr = err; 597777e6bd7SChris Mason } 598777e6bd7SChris Mason wait_on_page_writeback(page); 599777e6bd7SChris Mason page_cache_release(page); 600777e6bd7SChris Mason cond_resched(); 601777e6bd7SChris Mason } 602777e6bd7SChris Mason } 6037c4452b9SChris Mason if (err) 6047c4452b9SChris Mason werr = err; 6057c4452b9SChris Mason return werr; 60679154b1bSChris Mason } 60779154b1bSChris Mason 608690587d1SChris Mason /* 609690587d1SChris Mason * when btree blocks are allocated, they have some corresponding bits set for 610690587d1SChris Mason * them in one of two extent_io trees. This is used to make sure all of 611690587d1SChris Mason * those extents are on disk for transaction or log commit 612690587d1SChris Mason */ 613690587d1SChris Mason int btrfs_write_and_wait_marked_extents(struct btrfs_root *root, 6148cef4e16SYan, Zheng struct extent_io_tree *dirty_pages, int mark) 615690587d1SChris Mason { 616690587d1SChris Mason int ret; 617690587d1SChris Mason int ret2; 618690587d1SChris Mason 6198cef4e16SYan, Zheng ret = btrfs_write_marked_extents(root, dirty_pages, mark); 6208cef4e16SYan, Zheng ret2 = btrfs_wait_marked_extents(root, dirty_pages, mark); 621690587d1SChris Mason return ret || ret2; 622690587d1SChris Mason } 623690587d1SChris Mason 624d0c803c4SChris Mason int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans, 625d0c803c4SChris Mason struct btrfs_root *root) 626d0c803c4SChris Mason { 627d0c803c4SChris Mason if (!trans || !trans->transaction) { 628d0c803c4SChris Mason struct inode *btree_inode; 629d0c803c4SChris Mason btree_inode = root->fs_info->btree_inode; 630d0c803c4SChris Mason return filemap_write_and_wait(btree_inode->i_mapping); 631d0c803c4SChris Mason } 632d0c803c4SChris Mason return btrfs_write_and_wait_marked_extents(root, 6338cef4e16SYan, Zheng &trans->transaction->dirty_pages, 6348cef4e16SYan, Zheng EXTENT_DIRTY); 635d0c803c4SChris Mason } 636d0c803c4SChris Mason 637d352ac68SChris Mason /* 638d352ac68SChris Mason * this is used to update the root pointer in the tree of tree roots. 639d352ac68SChris Mason * 640d352ac68SChris Mason * But, in the case of the extent allocation tree, updating the root 641d352ac68SChris Mason * pointer may allocate blocks which may change the root of the extent 642d352ac68SChris Mason * allocation tree. 643d352ac68SChris Mason * 644d352ac68SChris Mason * So, this loops and repeats and makes sure the cowonly root didn't 645d352ac68SChris Mason * change while the root pointer was being updated in the metadata. 646d352ac68SChris Mason */ 6470b86a832SChris Mason static int update_cowonly_root(struct btrfs_trans_handle *trans, 64879154b1bSChris Mason struct btrfs_root *root) 64979154b1bSChris Mason { 65079154b1bSChris Mason int ret; 6510b86a832SChris Mason u64 old_root_bytenr; 65286b9f2ecSYan, Zheng u64 old_root_used; 6530b86a832SChris Mason struct btrfs_root *tree_root = root->fs_info->tree_root; 65479154b1bSChris Mason 65586b9f2ecSYan, Zheng old_root_used = btrfs_root_used(&root->root_item); 6560b86a832SChris Mason btrfs_write_dirty_block_groups(trans, root); 65756bec294SChris Mason 65879154b1bSChris Mason while (1) { 6590b86a832SChris Mason old_root_bytenr = btrfs_root_bytenr(&root->root_item); 66086b9f2ecSYan, Zheng if (old_root_bytenr == root->node->start && 66186b9f2ecSYan, Zheng old_root_used == btrfs_root_used(&root->root_item)) 66279154b1bSChris Mason break; 66387ef2bb4SChris Mason 6645d4f98a2SYan Zheng btrfs_set_root_node(&root->root_item, root->node); 66579154b1bSChris Mason ret = btrfs_update_root(trans, tree_root, 6660b86a832SChris Mason &root->root_key, 6670b86a832SChris Mason &root->root_item); 66879154b1bSChris Mason BUG_ON(ret); 66956bec294SChris Mason 67086b9f2ecSYan, Zheng old_root_used = btrfs_root_used(&root->root_item); 6714a8c9a62SYan Zheng ret = btrfs_write_dirty_block_groups(trans, root); 67256bec294SChris Mason BUG_ON(ret); 6730b86a832SChris Mason } 674276e680dSYan Zheng 675276e680dSYan Zheng if (root != root->fs_info->extent_root) 676817d52f8SJosef Bacik switch_commit_root(root); 677276e680dSYan Zheng 6780b86a832SChris Mason return 0; 6790b86a832SChris Mason } 6800b86a832SChris Mason 681d352ac68SChris Mason /* 682d352ac68SChris Mason * update all the cowonly tree roots on disk 683d352ac68SChris Mason */ 6845d4f98a2SYan Zheng static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans, 6850b86a832SChris Mason struct btrfs_root *root) 6860b86a832SChris Mason { 6870b86a832SChris Mason struct btrfs_fs_info *fs_info = root->fs_info; 6880b86a832SChris Mason struct list_head *next; 68984234f3aSYan Zheng struct extent_buffer *eb; 69056bec294SChris Mason int ret; 69184234f3aSYan Zheng 69256bec294SChris Mason ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); 69356bec294SChris Mason BUG_ON(ret); 69487ef2bb4SChris Mason 69584234f3aSYan Zheng eb = btrfs_lock_root_node(fs_info->tree_root); 6969fa8cfe7SChris Mason btrfs_cow_block(trans, fs_info->tree_root, eb, NULL, 0, &eb); 69784234f3aSYan Zheng btrfs_tree_unlock(eb); 69884234f3aSYan Zheng free_extent_buffer(eb); 6990b86a832SChris Mason 70056bec294SChris Mason ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); 70156bec294SChris Mason BUG_ON(ret); 70287ef2bb4SChris Mason 7030b86a832SChris Mason while (!list_empty(&fs_info->dirty_cowonly_roots)) { 7040b86a832SChris Mason next = fs_info->dirty_cowonly_roots.next; 7050b86a832SChris Mason list_del_init(next); 7060b86a832SChris Mason root = list_entry(next, struct btrfs_root, dirty_list); 70787ef2bb4SChris Mason 7080b86a832SChris Mason update_cowonly_root(trans, root); 70979154b1bSChris Mason } 710276e680dSYan Zheng 711276e680dSYan Zheng down_write(&fs_info->extent_commit_sem); 712276e680dSYan Zheng switch_commit_root(fs_info->extent_root); 713276e680dSYan Zheng up_write(&fs_info->extent_commit_sem); 714276e680dSYan Zheng 71579154b1bSChris Mason return 0; 71679154b1bSChris Mason } 71779154b1bSChris Mason 718d352ac68SChris Mason /* 719d352ac68SChris Mason * dead roots are old snapshots that need to be deleted. This allocates 720d352ac68SChris Mason * a dirty root struct and adds it into the list of dead roots that need to 721d352ac68SChris Mason * be deleted 722d352ac68SChris Mason */ 7235d4f98a2SYan Zheng int btrfs_add_dead_root(struct btrfs_root *root) 7245eda7b5eSChris Mason { 725b48652c1SYan Zheng mutex_lock(&root->fs_info->trans_mutex); 7265d4f98a2SYan Zheng list_add(&root->root_list, &root->fs_info->dead_roots); 727b48652c1SYan Zheng mutex_unlock(&root->fs_info->trans_mutex); 7285eda7b5eSChris Mason return 0; 7295eda7b5eSChris Mason } 7305eda7b5eSChris Mason 731d352ac68SChris Mason /* 7325d4f98a2SYan Zheng * update all the cowonly tree roots on disk 733d352ac68SChris Mason */ 7345d4f98a2SYan Zheng static noinline int commit_fs_roots(struct btrfs_trans_handle *trans, 7355d4f98a2SYan Zheng struct btrfs_root *root) 7360f7d52f4SChris Mason { 7370f7d52f4SChris Mason struct btrfs_root *gang[8]; 7385d4f98a2SYan Zheng struct btrfs_fs_info *fs_info = root->fs_info; 7390f7d52f4SChris Mason int i; 7400f7d52f4SChris Mason int ret; 74154aa1f4dSChris Mason int err = 0; 74254aa1f4dSChris Mason 7430f7d52f4SChris Mason while (1) { 7445d4f98a2SYan Zheng ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix, 7455d4f98a2SYan Zheng (void **)gang, 0, 7460f7d52f4SChris Mason ARRAY_SIZE(gang), 7470f7d52f4SChris Mason BTRFS_ROOT_TRANS_TAG); 7480f7d52f4SChris Mason if (ret == 0) 7490f7d52f4SChris Mason break; 7500f7d52f4SChris Mason for (i = 0; i < ret; i++) { 7510f7d52f4SChris Mason root = gang[i]; 7525d4f98a2SYan Zheng radix_tree_tag_clear(&fs_info->fs_roots_radix, 7532619ba1fSChris Mason (unsigned long)root->root_key.objectid, 7540f7d52f4SChris Mason BTRFS_ROOT_TRANS_TAG); 75531153d81SYan Zheng 756e02119d5SChris Mason btrfs_free_log(trans, root); 7575d4f98a2SYan Zheng btrfs_update_reloc_root(trans, root); 758d68fc57bSYan, Zheng btrfs_orphan_commit_root(trans, root); 759e02119d5SChris Mason 760978d910dSYan Zheng if (root->commit_root != root->node) { 761817d52f8SJosef Bacik switch_commit_root(root); 762978d910dSYan Zheng btrfs_set_root_node(&root->root_item, 763978d910dSYan Zheng root->node); 764978d910dSYan Zheng } 76531153d81SYan Zheng 7665d4f98a2SYan Zheng err = btrfs_update_root(trans, fs_info->tree_root, 7670f7d52f4SChris Mason &root->root_key, 7680f7d52f4SChris Mason &root->root_item); 76954aa1f4dSChris Mason if (err) 77054aa1f4dSChris Mason break; 7710f7d52f4SChris Mason } 7729f3a7427SChris Mason } 77354aa1f4dSChris Mason return err; 7740f7d52f4SChris Mason } 7750f7d52f4SChris Mason 776d352ac68SChris Mason /* 777d352ac68SChris Mason * defrag a given btree. If cacheonly == 1, this won't read from the disk, 778d352ac68SChris Mason * otherwise every leaf in the btree is read and defragged. 779d352ac68SChris Mason */ 780e9d0b13bSChris Mason int btrfs_defrag_root(struct btrfs_root *root, int cacheonly) 781e9d0b13bSChris Mason { 782e9d0b13bSChris Mason struct btrfs_fs_info *info = root->fs_info; 783e9d0b13bSChris Mason struct btrfs_trans_handle *trans; 7848929ecfaSYan, Zheng int ret; 785d3c2fdcfSChris Mason unsigned long nr; 786e9d0b13bSChris Mason 7878929ecfaSYan, Zheng if (xchg(&root->defrag_running, 1)) 788e9d0b13bSChris Mason return 0; 7898929ecfaSYan, Zheng 7906b80053dSChris Mason while (1) { 7918929ecfaSYan, Zheng trans = btrfs_start_transaction(root, 0); 7928929ecfaSYan, Zheng if (IS_ERR(trans)) 7938929ecfaSYan, Zheng return PTR_ERR(trans); 7948929ecfaSYan, Zheng 795e9d0b13bSChris Mason ret = btrfs_defrag_leaves(trans, root, cacheonly); 7968929ecfaSYan, Zheng 797d3c2fdcfSChris Mason nr = trans->blocks_used; 798e9d0b13bSChris Mason btrfs_end_transaction(trans, root); 799d3c2fdcfSChris Mason btrfs_btree_balance_dirty(info->tree_root, nr); 800e9d0b13bSChris Mason cond_resched(); 801e9d0b13bSChris Mason 8023f157a2fSChris Mason if (root->fs_info->closing || ret != -EAGAIN) 803e9d0b13bSChris Mason break; 804e9d0b13bSChris Mason } 805e9d0b13bSChris Mason root->defrag_running = 0; 8068929ecfaSYan, Zheng return ret; 807e9d0b13bSChris Mason } 808e9d0b13bSChris Mason 8092c47e605SYan Zheng #if 0 810d352ac68SChris Mason /* 811b7ec40d7SChris Mason * when dropping snapshots, we generate a ton of delayed refs, and it makes 812b7ec40d7SChris Mason * sense not to join the transaction while it is trying to flush the current 813b7ec40d7SChris Mason * queue of delayed refs out. 814b7ec40d7SChris Mason * 815b7ec40d7SChris Mason * This is used by the drop snapshot code only 816b7ec40d7SChris Mason */ 817b7ec40d7SChris Mason static noinline int wait_transaction_pre_flush(struct btrfs_fs_info *info) 818b7ec40d7SChris Mason { 819b7ec40d7SChris Mason DEFINE_WAIT(wait); 820b7ec40d7SChris Mason 821b7ec40d7SChris Mason mutex_lock(&info->trans_mutex); 822b7ec40d7SChris Mason while (info->running_transaction && 823b7ec40d7SChris Mason info->running_transaction->delayed_refs.flushing) { 824b7ec40d7SChris Mason prepare_to_wait(&info->transaction_wait, &wait, 825b7ec40d7SChris Mason TASK_UNINTERRUPTIBLE); 826b7ec40d7SChris Mason mutex_unlock(&info->trans_mutex); 82759bc5c75SChris Mason 828b7ec40d7SChris Mason schedule(); 82959bc5c75SChris Mason 830b7ec40d7SChris Mason mutex_lock(&info->trans_mutex); 831b7ec40d7SChris Mason finish_wait(&info->transaction_wait, &wait); 832b7ec40d7SChris Mason } 833b7ec40d7SChris Mason mutex_unlock(&info->trans_mutex); 834b7ec40d7SChris Mason return 0; 835b7ec40d7SChris Mason } 836b7ec40d7SChris Mason 837b7ec40d7SChris Mason /* 838d352ac68SChris Mason * Given a list of roots that need to be deleted, call btrfs_drop_snapshot on 839d352ac68SChris Mason * all of them 840d352ac68SChris Mason */ 8415d4f98a2SYan Zheng int btrfs_drop_dead_root(struct btrfs_root *root) 8420f7d52f4SChris Mason { 8430f7d52f4SChris Mason struct btrfs_trans_handle *trans; 8445d4f98a2SYan Zheng struct btrfs_root *tree_root = root->fs_info->tree_root; 845d3c2fdcfSChris Mason unsigned long nr; 8465d4f98a2SYan Zheng int ret; 84758176a96SJosef Bacik 8489f3a7427SChris Mason while (1) { 849b7ec40d7SChris Mason /* 850b7ec40d7SChris Mason * we don't want to jump in and create a bunch of 851b7ec40d7SChris Mason * delayed refs if the transaction is starting to close 852b7ec40d7SChris Mason */ 853b7ec40d7SChris Mason wait_transaction_pre_flush(tree_root->fs_info); 8540f7d52f4SChris Mason trans = btrfs_start_transaction(tree_root, 1); 855b7ec40d7SChris Mason 856b7ec40d7SChris Mason /* 857b7ec40d7SChris Mason * we've joined a transaction, make sure it isn't 858b7ec40d7SChris Mason * closing right now 859b7ec40d7SChris Mason */ 860b7ec40d7SChris Mason if (trans->transaction->delayed_refs.flushing) { 861b7ec40d7SChris Mason btrfs_end_transaction(trans, tree_root); 862b7ec40d7SChris Mason continue; 863b7ec40d7SChris Mason } 864b7ec40d7SChris Mason 8655d4f98a2SYan Zheng ret = btrfs_drop_snapshot(trans, root); 866d397712bSChris Mason if (ret != -EAGAIN) 8679f3a7427SChris Mason break; 86858176a96SJosef Bacik 8695d4f98a2SYan Zheng ret = btrfs_update_root(trans, tree_root, 8705d4f98a2SYan Zheng &root->root_key, 8715d4f98a2SYan Zheng &root->root_item); 8725d4f98a2SYan Zheng if (ret) 87354aa1f4dSChris Mason break; 874bcc63abbSYan 875d3c2fdcfSChris Mason nr = trans->blocks_used; 8760f7d52f4SChris Mason ret = btrfs_end_transaction(trans, tree_root); 8770f7d52f4SChris Mason BUG_ON(ret); 8785eda7b5eSChris Mason 879d3c2fdcfSChris Mason btrfs_btree_balance_dirty(tree_root, nr); 8804dc11904SChris Mason cond_resched(); 8810f7d52f4SChris Mason } 8825d4f98a2SYan Zheng BUG_ON(ret); 8835d4f98a2SYan Zheng 8845d4f98a2SYan Zheng ret = btrfs_del_root(trans, tree_root, &root->root_key); 8855d4f98a2SYan Zheng BUG_ON(ret); 8865d4f98a2SYan Zheng 8875d4f98a2SYan Zheng nr = trans->blocks_used; 8885d4f98a2SYan Zheng ret = btrfs_end_transaction(trans, tree_root); 8895d4f98a2SYan Zheng BUG_ON(ret); 8905d4f98a2SYan Zheng 8915d4f98a2SYan Zheng free_extent_buffer(root->node); 8925d4f98a2SYan Zheng free_extent_buffer(root->commit_root); 8935d4f98a2SYan Zheng kfree(root); 8945d4f98a2SYan Zheng 8955d4f98a2SYan Zheng btrfs_btree_balance_dirty(tree_root, nr); 89654aa1f4dSChris Mason return ret; 8970f7d52f4SChris Mason } 8982c47e605SYan Zheng #endif 8990f7d52f4SChris Mason 900d352ac68SChris Mason /* 901d352ac68SChris Mason * new snapshots need to be created at a very specific time in the 902d352ac68SChris Mason * transaction commit. This does the actual creation 903d352ac68SChris Mason */ 90480b6794dSChris Mason static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans, 9053063d29fSChris Mason struct btrfs_fs_info *fs_info, 9063063d29fSChris Mason struct btrfs_pending_snapshot *pending) 9073063d29fSChris Mason { 9083063d29fSChris Mason struct btrfs_key key; 90980b6794dSChris Mason struct btrfs_root_item *new_root_item; 9103063d29fSChris Mason struct btrfs_root *tree_root = fs_info->tree_root; 9113063d29fSChris Mason struct btrfs_root *root = pending->root; 9126bdb72deSSage Weil struct btrfs_root *parent_root; 9136bdb72deSSage Weil struct inode *parent_inode; 9146a912213SJosef Bacik struct dentry *parent; 915a22285a6SYan, Zheng struct dentry *dentry; 9163063d29fSChris Mason struct extent_buffer *tmp; 917925baeddSChris Mason struct extent_buffer *old; 9183063d29fSChris Mason int ret; 919d68fc57bSYan, Zheng u64 to_reserve = 0; 9206bdb72deSSage Weil u64 index = 0; 921a22285a6SYan, Zheng u64 objectid; 922b83cc969SLi Zefan u64 root_flags; 9233063d29fSChris Mason 92480b6794dSChris Mason new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS); 92580b6794dSChris Mason if (!new_root_item) { 926a22285a6SYan, Zheng pending->error = -ENOMEM; 92780b6794dSChris Mason goto fail; 92880b6794dSChris Mason } 929a22285a6SYan, Zheng 9303063d29fSChris Mason ret = btrfs_find_free_objectid(trans, tree_root, 0, &objectid); 931a22285a6SYan, Zheng if (ret) { 932a22285a6SYan, Zheng pending->error = ret; 9333063d29fSChris Mason goto fail; 934a22285a6SYan, Zheng } 9353063d29fSChris Mason 9363fd0a558SYan, Zheng btrfs_reloc_pre_snapshot(trans, pending, &to_reserve); 937d68fc57bSYan, Zheng btrfs_orphan_pre_snapshot(trans, pending, &to_reserve); 938d68fc57bSYan, Zheng 939d68fc57bSYan, Zheng if (to_reserve > 0) { 940d68fc57bSYan, Zheng ret = btrfs_block_rsv_add(trans, root, &pending->block_rsv, 9418bb8ab2eSJosef Bacik to_reserve); 942d68fc57bSYan, Zheng if (ret) { 943d68fc57bSYan, Zheng pending->error = ret; 944d68fc57bSYan, Zheng goto fail; 945d68fc57bSYan, Zheng } 946d68fc57bSYan, Zheng } 947d68fc57bSYan, Zheng 9483063d29fSChris Mason key.objectid = objectid; 949a22285a6SYan, Zheng key.offset = (u64)-1; 950a22285a6SYan, Zheng key.type = BTRFS_ROOT_ITEM_KEY; 9513063d29fSChris Mason 952a22285a6SYan, Zheng trans->block_rsv = &pending->block_rsv; 9536bdb72deSSage Weil 954a22285a6SYan, Zheng dentry = pending->dentry; 9556a912213SJosef Bacik parent = dget_parent(dentry); 9566a912213SJosef Bacik parent_inode = parent->d_inode; 957a22285a6SYan, Zheng parent_root = BTRFS_I(parent_inode)->root; 9586bdb72deSSage Weil record_root_in_trans(trans, parent_root); 959a22285a6SYan, Zheng 9606bdb72deSSage Weil /* 9616bdb72deSSage Weil * insert the directory item 9626bdb72deSSage Weil */ 9636bdb72deSSage Weil ret = btrfs_set_inode_index(parent_inode, &index); 9646bdb72deSSage Weil BUG_ON(ret); 9656bdb72deSSage Weil ret = btrfs_insert_dir_item(trans, parent_root, 966a22285a6SYan, Zheng dentry->d_name.name, dentry->d_name.len, 967a22285a6SYan, Zheng parent_inode->i_ino, &key, 968a22285a6SYan, Zheng BTRFS_FT_DIR, index); 9696bdb72deSSage Weil BUG_ON(ret); 9706bdb72deSSage Weil 971a22285a6SYan, Zheng btrfs_i_size_write(parent_inode, parent_inode->i_size + 972a22285a6SYan, Zheng dentry->d_name.len * 2); 9736bdb72deSSage Weil ret = btrfs_update_inode(trans, parent_root, parent_inode); 9746bdb72deSSage Weil BUG_ON(ret); 9756bdb72deSSage Weil 9766bdb72deSSage Weil record_root_in_trans(trans, root); 9776bdb72deSSage Weil btrfs_set_root_last_snapshot(&root->root_item, trans->transid); 9786bdb72deSSage Weil memcpy(new_root_item, &root->root_item, sizeof(*new_root_item)); 9796bdb72deSSage Weil 980b83cc969SLi Zefan root_flags = btrfs_root_flags(new_root_item); 981b83cc969SLi Zefan if (pending->readonly) 982b83cc969SLi Zefan root_flags |= BTRFS_ROOT_SUBVOL_RDONLY; 983b83cc969SLi Zefan else 984b83cc969SLi Zefan root_flags &= ~BTRFS_ROOT_SUBVOL_RDONLY; 985b83cc969SLi Zefan btrfs_set_root_flags(new_root_item, root_flags); 986b83cc969SLi Zefan 987925baeddSChris Mason old = btrfs_lock_root_node(root); 9889fa8cfe7SChris Mason btrfs_cow_block(trans, root, old, NULL, 0, &old); 9895d4f98a2SYan Zheng btrfs_set_lock_blocking(old); 9903063d29fSChris Mason 991925baeddSChris Mason btrfs_copy_root(trans, root, old, &tmp, objectid); 992925baeddSChris Mason btrfs_tree_unlock(old); 993925baeddSChris Mason free_extent_buffer(old); 9943063d29fSChris Mason 9955d4f98a2SYan Zheng btrfs_set_root_node(new_root_item, tmp); 996a22285a6SYan, Zheng /* record when the snapshot was created in key.offset */ 997a22285a6SYan, Zheng key.offset = trans->transid; 998a22285a6SYan, Zheng ret = btrfs_insert_root(trans, tree_root, &key, new_root_item); 999925baeddSChris Mason btrfs_tree_unlock(tmp); 10003063d29fSChris Mason free_extent_buffer(tmp); 10010660b5afSChris Mason BUG_ON(ret); 10020660b5afSChris Mason 1003a22285a6SYan, Zheng /* 1004a22285a6SYan, Zheng * insert root back/forward references 1005a22285a6SYan, Zheng */ 1006a22285a6SYan, Zheng ret = btrfs_add_root_ref(trans, tree_root, objectid, 1007a22285a6SYan, Zheng parent_root->root_key.objectid, 1008a22285a6SYan, Zheng parent_inode->i_ino, index, 1009a22285a6SYan, Zheng dentry->d_name.name, dentry->d_name.len); 1010a22285a6SYan, Zheng BUG_ON(ret); 10116a912213SJosef Bacik dput(parent); 1012a22285a6SYan, Zheng 1013a22285a6SYan, Zheng key.offset = (u64)-1; 1014a22285a6SYan, Zheng pending->snap = btrfs_read_fs_root_no_name(root->fs_info, &key); 1015a22285a6SYan, Zheng BUG_ON(IS_ERR(pending->snap)); 1016d68fc57bSYan, Zheng 10173fd0a558SYan, Zheng btrfs_reloc_post_snapshot(trans, pending); 1018d68fc57bSYan, Zheng btrfs_orphan_post_snapshot(trans, pending); 10193063d29fSChris Mason fail: 10206bdb72deSSage Weil kfree(new_root_item); 1021a22285a6SYan, Zheng btrfs_block_rsv_release(root, &pending->block_rsv, (u64)-1); 1022a22285a6SYan, Zheng return 0; 10233063d29fSChris Mason } 10243063d29fSChris Mason 1025d352ac68SChris Mason /* 1026d352ac68SChris Mason * create all the snapshots we've scheduled for creation 1027d352ac68SChris Mason */ 102880b6794dSChris Mason static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans, 10293063d29fSChris Mason struct btrfs_fs_info *fs_info) 10303063d29fSChris Mason { 10313063d29fSChris Mason struct btrfs_pending_snapshot *pending; 10323063d29fSChris Mason struct list_head *head = &trans->transaction->pending_snapshots; 10333de4586cSChris Mason int ret; 10343de4586cSChris Mason 1035c6e30871SQinghuang Feng list_for_each_entry(pending, head, list) { 10363de4586cSChris Mason ret = create_pending_snapshot(trans, fs_info, pending); 10373de4586cSChris Mason BUG_ON(ret); 10383de4586cSChris Mason } 10393de4586cSChris Mason return 0; 10403de4586cSChris Mason } 10413de4586cSChris Mason 10425d4f98a2SYan Zheng static void update_super_roots(struct btrfs_root *root) 10435d4f98a2SYan Zheng { 10445d4f98a2SYan Zheng struct btrfs_root_item *root_item; 10455d4f98a2SYan Zheng struct btrfs_super_block *super; 10465d4f98a2SYan Zheng 10475d4f98a2SYan Zheng super = &root->fs_info->super_copy; 10485d4f98a2SYan Zheng 10495d4f98a2SYan Zheng root_item = &root->fs_info->chunk_root->root_item; 10505d4f98a2SYan Zheng super->chunk_root = root_item->bytenr; 10515d4f98a2SYan Zheng super->chunk_root_generation = root_item->generation; 10525d4f98a2SYan Zheng super->chunk_root_level = root_item->level; 10535d4f98a2SYan Zheng 10545d4f98a2SYan Zheng root_item = &root->fs_info->tree_root->root_item; 10555d4f98a2SYan Zheng super->root = root_item->bytenr; 10565d4f98a2SYan Zheng super->generation = root_item->generation; 10575d4f98a2SYan Zheng super->root_level = root_item->level; 10580af3d00bSJosef Bacik if (super->cache_generation != 0 || btrfs_test_opt(root, SPACE_CACHE)) 10590af3d00bSJosef Bacik super->cache_generation = root_item->generation; 10605d4f98a2SYan Zheng } 10615d4f98a2SYan Zheng 1062f36f3042SChris Mason int btrfs_transaction_in_commit(struct btrfs_fs_info *info) 1063f36f3042SChris Mason { 1064f36f3042SChris Mason int ret = 0; 1065f36f3042SChris Mason spin_lock(&info->new_trans_lock); 1066f36f3042SChris Mason if (info->running_transaction) 1067f36f3042SChris Mason ret = info->running_transaction->in_commit; 1068f36f3042SChris Mason spin_unlock(&info->new_trans_lock); 1069f36f3042SChris Mason return ret; 1070f36f3042SChris Mason } 1071f36f3042SChris Mason 10728929ecfaSYan, Zheng int btrfs_transaction_blocked(struct btrfs_fs_info *info) 10738929ecfaSYan, Zheng { 10748929ecfaSYan, Zheng int ret = 0; 10758929ecfaSYan, Zheng spin_lock(&info->new_trans_lock); 10768929ecfaSYan, Zheng if (info->running_transaction) 10778929ecfaSYan, Zheng ret = info->running_transaction->blocked; 10788929ecfaSYan, Zheng spin_unlock(&info->new_trans_lock); 10798929ecfaSYan, Zheng return ret; 10808929ecfaSYan, Zheng } 10818929ecfaSYan, Zheng 1082bb9c12c9SSage Weil /* 1083bb9c12c9SSage Weil * wait for the current transaction commit to start and block subsequent 1084bb9c12c9SSage Weil * transaction joins 1085bb9c12c9SSage Weil */ 1086bb9c12c9SSage Weil static void wait_current_trans_commit_start(struct btrfs_root *root, 1087bb9c12c9SSage Weil struct btrfs_transaction *trans) 1088bb9c12c9SSage Weil { 1089bb9c12c9SSage Weil DEFINE_WAIT(wait); 1090bb9c12c9SSage Weil 1091bb9c12c9SSage Weil if (trans->in_commit) 1092bb9c12c9SSage Weil return; 1093bb9c12c9SSage Weil 1094bb9c12c9SSage Weil while (1) { 1095bb9c12c9SSage Weil prepare_to_wait(&root->fs_info->transaction_blocked_wait, &wait, 1096bb9c12c9SSage Weil TASK_UNINTERRUPTIBLE); 1097bb9c12c9SSage Weil if (trans->in_commit) { 1098bb9c12c9SSage Weil finish_wait(&root->fs_info->transaction_blocked_wait, 1099bb9c12c9SSage Weil &wait); 1100bb9c12c9SSage Weil break; 1101bb9c12c9SSage Weil } 1102bb9c12c9SSage Weil mutex_unlock(&root->fs_info->trans_mutex); 1103bb9c12c9SSage Weil schedule(); 1104bb9c12c9SSage Weil mutex_lock(&root->fs_info->trans_mutex); 1105bb9c12c9SSage Weil finish_wait(&root->fs_info->transaction_blocked_wait, &wait); 1106bb9c12c9SSage Weil } 1107bb9c12c9SSage Weil } 1108bb9c12c9SSage Weil 1109bb9c12c9SSage Weil /* 1110bb9c12c9SSage Weil * wait for the current transaction to start and then become unblocked. 1111bb9c12c9SSage Weil * caller holds ref. 1112bb9c12c9SSage Weil */ 1113bb9c12c9SSage Weil static void wait_current_trans_commit_start_and_unblock(struct btrfs_root *root, 1114bb9c12c9SSage Weil struct btrfs_transaction *trans) 1115bb9c12c9SSage Weil { 1116bb9c12c9SSage Weil DEFINE_WAIT(wait); 1117bb9c12c9SSage Weil 1118bb9c12c9SSage Weil if (trans->commit_done || (trans->in_commit && !trans->blocked)) 1119bb9c12c9SSage Weil return; 1120bb9c12c9SSage Weil 1121bb9c12c9SSage Weil while (1) { 1122bb9c12c9SSage Weil prepare_to_wait(&root->fs_info->transaction_wait, &wait, 1123bb9c12c9SSage Weil TASK_UNINTERRUPTIBLE); 1124bb9c12c9SSage Weil if (trans->commit_done || 1125bb9c12c9SSage Weil (trans->in_commit && !trans->blocked)) { 1126bb9c12c9SSage Weil finish_wait(&root->fs_info->transaction_wait, 1127bb9c12c9SSage Weil &wait); 1128bb9c12c9SSage Weil break; 1129bb9c12c9SSage Weil } 1130bb9c12c9SSage Weil mutex_unlock(&root->fs_info->trans_mutex); 1131bb9c12c9SSage Weil schedule(); 1132bb9c12c9SSage Weil mutex_lock(&root->fs_info->trans_mutex); 1133bb9c12c9SSage Weil finish_wait(&root->fs_info->transaction_wait, 1134bb9c12c9SSage Weil &wait); 1135bb9c12c9SSage Weil } 1136bb9c12c9SSage Weil } 1137bb9c12c9SSage Weil 1138bb9c12c9SSage Weil /* 1139bb9c12c9SSage Weil * commit transactions asynchronously. once btrfs_commit_transaction_async 1140bb9c12c9SSage Weil * returns, any subsequent transaction will not be allowed to join. 1141bb9c12c9SSage Weil */ 1142bb9c12c9SSage Weil struct btrfs_async_commit { 1143bb9c12c9SSage Weil struct btrfs_trans_handle *newtrans; 1144bb9c12c9SSage Weil struct btrfs_root *root; 1145bb9c12c9SSage Weil struct delayed_work work; 1146bb9c12c9SSage Weil }; 1147bb9c12c9SSage Weil 1148bb9c12c9SSage Weil static void do_async_commit(struct work_struct *work) 1149bb9c12c9SSage Weil { 1150bb9c12c9SSage Weil struct btrfs_async_commit *ac = 1151bb9c12c9SSage Weil container_of(work, struct btrfs_async_commit, work.work); 1152bb9c12c9SSage Weil 1153bb9c12c9SSage Weil btrfs_commit_transaction(ac->newtrans, ac->root); 1154bb9c12c9SSage Weil kfree(ac); 1155bb9c12c9SSage Weil } 1156bb9c12c9SSage Weil 1157bb9c12c9SSage Weil int btrfs_commit_transaction_async(struct btrfs_trans_handle *trans, 1158bb9c12c9SSage Weil struct btrfs_root *root, 1159bb9c12c9SSage Weil int wait_for_unblock) 1160bb9c12c9SSage Weil { 1161bb9c12c9SSage Weil struct btrfs_async_commit *ac; 1162bb9c12c9SSage Weil struct btrfs_transaction *cur_trans; 1163bb9c12c9SSage Weil 1164bb9c12c9SSage Weil ac = kmalloc(sizeof(*ac), GFP_NOFS); 1165db5b493aSTsutomu Itoh if (!ac) 1166db5b493aSTsutomu Itoh return -ENOMEM; 1167bb9c12c9SSage Weil 1168bb9c12c9SSage Weil INIT_DELAYED_WORK(&ac->work, do_async_commit); 1169bb9c12c9SSage Weil ac->root = root; 1170bb9c12c9SSage Weil ac->newtrans = btrfs_join_transaction(root, 0); 11713612b495STsutomu Itoh if (IS_ERR(ac->newtrans)) { 11723612b495STsutomu Itoh int err = PTR_ERR(ac->newtrans); 11733612b495STsutomu Itoh kfree(ac); 11743612b495STsutomu Itoh return err; 11753612b495STsutomu Itoh } 1176bb9c12c9SSage Weil 1177bb9c12c9SSage Weil /* take transaction reference */ 1178bb9c12c9SSage Weil mutex_lock(&root->fs_info->trans_mutex); 1179bb9c12c9SSage Weil cur_trans = trans->transaction; 1180bb9c12c9SSage Weil cur_trans->use_count++; 1181bb9c12c9SSage Weil mutex_unlock(&root->fs_info->trans_mutex); 1182bb9c12c9SSage Weil 1183bb9c12c9SSage Weil btrfs_end_transaction(trans, root); 1184bb9c12c9SSage Weil schedule_delayed_work(&ac->work, 0); 1185bb9c12c9SSage Weil 1186bb9c12c9SSage Weil /* wait for transaction to start and unblock */ 1187bb9c12c9SSage Weil mutex_lock(&root->fs_info->trans_mutex); 1188bb9c12c9SSage Weil if (wait_for_unblock) 1189bb9c12c9SSage Weil wait_current_trans_commit_start_and_unblock(root, cur_trans); 1190bb9c12c9SSage Weil else 1191bb9c12c9SSage Weil wait_current_trans_commit_start(root, cur_trans); 1192bb9c12c9SSage Weil put_transaction(cur_trans); 1193bb9c12c9SSage Weil mutex_unlock(&root->fs_info->trans_mutex); 1194bb9c12c9SSage Weil 1195bb9c12c9SSage Weil return 0; 1196bb9c12c9SSage Weil } 1197bb9c12c9SSage Weil 1198bb9c12c9SSage Weil /* 1199bb9c12c9SSage Weil * btrfs_transaction state sequence: 1200bb9c12c9SSage Weil * in_commit = 0, blocked = 0 (initial) 1201bb9c12c9SSage Weil * in_commit = 1, blocked = 1 1202bb9c12c9SSage Weil * blocked = 0 1203bb9c12c9SSage Weil * commit_done = 1 1204bb9c12c9SSage Weil */ 120579154b1bSChris Mason int btrfs_commit_transaction(struct btrfs_trans_handle *trans, 120679154b1bSChris Mason struct btrfs_root *root) 120779154b1bSChris Mason { 120815ee9bc7SJosef Bacik unsigned long joined = 0; 120979154b1bSChris Mason struct btrfs_transaction *cur_trans; 12108fd17795SChris Mason struct btrfs_transaction *prev_trans = NULL; 121179154b1bSChris Mason DEFINE_WAIT(wait); 121215ee9bc7SJosef Bacik int ret; 121389573b9cSChris Mason int should_grow = 0; 121489573b9cSChris Mason unsigned long now = get_seconds(); 1215dccae999SSage Weil int flush_on_commit = btrfs_test_opt(root, FLUSHONCOMMIT); 121679154b1bSChris Mason 12175a3f23d5SChris Mason btrfs_run_ordered_operations(root, 0); 12185a3f23d5SChris Mason 121956bec294SChris Mason /* make a pass through all the delayed refs we have so far 122056bec294SChris Mason * any runnings procs may add more while we are here 122156bec294SChris Mason */ 122256bec294SChris Mason ret = btrfs_run_delayed_refs(trans, root, 0); 122356bec294SChris Mason BUG_ON(ret); 122456bec294SChris Mason 1225a22285a6SYan, Zheng btrfs_trans_release_metadata(trans, root); 1226a22285a6SYan, Zheng 1227b7ec40d7SChris Mason cur_trans = trans->transaction; 122856bec294SChris Mason /* 122956bec294SChris Mason * set the flushing flag so procs in this transaction have to 123056bec294SChris Mason * start sending their work down. 123156bec294SChris Mason */ 1232b7ec40d7SChris Mason cur_trans->delayed_refs.flushing = 1; 123356bec294SChris Mason 1234c3e69d58SChris Mason ret = btrfs_run_delayed_refs(trans, root, 0); 123556bec294SChris Mason BUG_ON(ret); 123656bec294SChris Mason 123779154b1bSChris Mason mutex_lock(&root->fs_info->trans_mutex); 1238b7ec40d7SChris Mason if (cur_trans->in_commit) { 1239b7ec40d7SChris Mason cur_trans->use_count++; 1240ccd467d6SChris Mason mutex_unlock(&root->fs_info->trans_mutex); 124179154b1bSChris Mason btrfs_end_transaction(trans, root); 1242ccd467d6SChris Mason 124379154b1bSChris Mason ret = wait_for_commit(root, cur_trans); 124479154b1bSChris Mason BUG_ON(ret); 124515ee9bc7SJosef Bacik 124615ee9bc7SJosef Bacik mutex_lock(&root->fs_info->trans_mutex); 124779154b1bSChris Mason put_transaction(cur_trans); 124815ee9bc7SJosef Bacik mutex_unlock(&root->fs_info->trans_mutex); 124915ee9bc7SJosef Bacik 125079154b1bSChris Mason return 0; 125179154b1bSChris Mason } 12524313b399SChris Mason 12532c90e5d6SChris Mason trans->transaction->in_commit = 1; 1254f9295749SChris Mason trans->transaction->blocked = 1; 1255bb9c12c9SSage Weil wake_up(&root->fs_info->transaction_blocked_wait); 1256bb9c12c9SSage Weil 1257ccd467d6SChris Mason if (cur_trans->list.prev != &root->fs_info->trans_list) { 1258ccd467d6SChris Mason prev_trans = list_entry(cur_trans->list.prev, 1259ccd467d6SChris Mason struct btrfs_transaction, list); 1260ccd467d6SChris Mason if (!prev_trans->commit_done) { 1261ccd467d6SChris Mason prev_trans->use_count++; 1262ccd467d6SChris Mason mutex_unlock(&root->fs_info->trans_mutex); 1263ccd467d6SChris Mason 1264ccd467d6SChris Mason wait_for_commit(root, prev_trans); 1265ccd467d6SChris Mason 1266ccd467d6SChris Mason mutex_lock(&root->fs_info->trans_mutex); 126715ee9bc7SJosef Bacik put_transaction(prev_trans); 1268ccd467d6SChris Mason } 1269ccd467d6SChris Mason } 127015ee9bc7SJosef Bacik 127189573b9cSChris Mason if (now < cur_trans->start_time || now - cur_trans->start_time < 1) 127289573b9cSChris Mason should_grow = 1; 127389573b9cSChris Mason 127415ee9bc7SJosef Bacik do { 12757ea394f1SYan Zheng int snap_pending = 0; 127615ee9bc7SJosef Bacik joined = cur_trans->num_joined; 12777ea394f1SYan Zheng if (!list_empty(&trans->transaction->pending_snapshots)) 12787ea394f1SYan Zheng snap_pending = 1; 12797ea394f1SYan Zheng 12802c90e5d6SChris Mason WARN_ON(cur_trans != trans->transaction); 128179154b1bSChris Mason mutex_unlock(&root->fs_info->trans_mutex); 128215ee9bc7SJosef Bacik 12830bdb1db2SSage Weil if (flush_on_commit || snap_pending) { 128424bbcf04SYan, Zheng btrfs_start_delalloc_inodes(root, 1); 128524bbcf04SYan, Zheng ret = btrfs_wait_ordered_extents(root, 0, 1); 1286ebecd3d9SSage Weil BUG_ON(ret); 12877ea394f1SYan Zheng } 12887ea394f1SYan Zheng 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 130189573b9cSChris Mason smp_mb(); 130299d16cbcSSage Weil if (cur_trans->num_writers > 1) 130399d16cbcSSage Weil schedule_timeout(MAX_SCHEDULE_TIMEOUT); 130499d16cbcSSage Weil else if (should_grow) 130599d16cbcSSage Weil schedule_timeout(1); 130615ee9bc7SJosef Bacik 130779154b1bSChris Mason mutex_lock(&root->fs_info->trans_mutex); 130815ee9bc7SJosef Bacik finish_wait(&cur_trans->writer_wait, &wait); 130915ee9bc7SJosef Bacik } while (cur_trans->num_writers > 1 || 131089573b9cSChris Mason (should_grow && cur_trans->num_joined != joined)); 131115ee9bc7SJosef Bacik 13123063d29fSChris Mason ret = create_pending_snapshots(trans, root->fs_info); 13133063d29fSChris Mason BUG_ON(ret); 13143063d29fSChris Mason 131556bec294SChris Mason ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1); 131656bec294SChris Mason BUG_ON(ret); 131756bec294SChris Mason 13182c90e5d6SChris Mason WARN_ON(cur_trans != trans->transaction); 1319dc17ff8fSChris Mason 1320e02119d5SChris Mason /* btrfs_commit_tree_roots is responsible for getting the 1321e02119d5SChris Mason * various roots consistent with each other. Every pointer 1322e02119d5SChris Mason * in the tree of tree roots has to point to the most up to date 1323e02119d5SChris Mason * root for every subvolume and other tree. So, we have to keep 1324e02119d5SChris Mason * the tree logging code from jumping in and changing any 1325e02119d5SChris Mason * of the trees. 1326e02119d5SChris Mason * 1327e02119d5SChris Mason * At this point in the commit, there can't be any tree-log 1328e02119d5SChris Mason * writers, but a little lower down we drop the trans mutex 1329e02119d5SChris Mason * and let new people in. By holding the tree_log_mutex 1330e02119d5SChris Mason * from now until after the super is written, we avoid races 1331e02119d5SChris Mason * with the tree-log code. 1332e02119d5SChris Mason */ 1333e02119d5SChris Mason mutex_lock(&root->fs_info->tree_log_mutex); 13341a40e23bSZheng Yan 13355d4f98a2SYan Zheng ret = commit_fs_roots(trans, root); 133654aa1f4dSChris Mason BUG_ON(ret); 133754aa1f4dSChris Mason 13385d4f98a2SYan Zheng /* commit_fs_roots gets rid of all the tree log roots, it is now 1339e02119d5SChris Mason * safe to free the root of tree log roots 1340e02119d5SChris Mason */ 1341e02119d5SChris Mason btrfs_free_log_root_tree(trans, root->fs_info); 1342e02119d5SChris Mason 13435d4f98a2SYan Zheng ret = commit_cowonly_roots(trans, root); 134479154b1bSChris Mason BUG_ON(ret); 134554aa1f4dSChris Mason 134611833d66SYan Zheng btrfs_prepare_extent_commit(trans, root); 134711833d66SYan Zheng 134878fae27eSChris Mason cur_trans = root->fs_info->running_transaction; 1349cee36a03SChris Mason spin_lock(&root->fs_info->new_trans_lock); 135078fae27eSChris Mason root->fs_info->running_transaction = NULL; 1351cee36a03SChris Mason spin_unlock(&root->fs_info->new_trans_lock); 13525f39d397SChris Mason 13535d4f98a2SYan Zheng btrfs_set_root_node(&root->fs_info->tree_root->root_item, 13545d4f98a2SYan Zheng root->fs_info->tree_root->node); 1355817d52f8SJosef Bacik switch_commit_root(root->fs_info->tree_root); 13565d4f98a2SYan Zheng 13575d4f98a2SYan Zheng btrfs_set_root_node(&root->fs_info->chunk_root->root_item, 13585d4f98a2SYan Zheng root->fs_info->chunk_root->node); 1359817d52f8SJosef Bacik switch_commit_root(root->fs_info->chunk_root); 13605d4f98a2SYan Zheng 13615d4f98a2SYan Zheng update_super_roots(root); 1362e02119d5SChris Mason 1363e02119d5SChris Mason if (!root->fs_info->log_root_recovering) { 1364e02119d5SChris Mason btrfs_set_super_log_root(&root->fs_info->super_copy, 0); 1365e02119d5SChris Mason btrfs_set_super_log_root_level(&root->fs_info->super_copy, 0); 1366e02119d5SChris Mason } 1367e02119d5SChris Mason 1368a061fc8dSChris Mason memcpy(&root->fs_info->super_for_commit, &root->fs_info->super_copy, 13694b52dff6SChris Mason sizeof(root->fs_info->super_copy)); 1370ccd467d6SChris Mason 1371f9295749SChris Mason trans->transaction->blocked = 0; 1372b7ec40d7SChris Mason 1373f9295749SChris Mason wake_up(&root->fs_info->transaction_wait); 1374e6dcd2dcSChris Mason 137578fae27eSChris Mason mutex_unlock(&root->fs_info->trans_mutex); 137679154b1bSChris Mason ret = btrfs_write_and_wait_transaction(trans, root); 137779154b1bSChris Mason BUG_ON(ret); 1378a512bbf8SYan Zheng write_ctree_super(trans, root, 0); 13794313b399SChris Mason 1380e02119d5SChris Mason /* 1381e02119d5SChris Mason * the super is written, we can safely allow the tree-loggers 1382e02119d5SChris Mason * to go about their business 1383e02119d5SChris Mason */ 1384e02119d5SChris Mason mutex_unlock(&root->fs_info->tree_log_mutex); 1385e02119d5SChris Mason 138611833d66SYan Zheng btrfs_finish_extent_commit(trans, root); 13874313b399SChris Mason 13881a40e23bSZheng Yan mutex_lock(&root->fs_info->trans_mutex); 13891a40e23bSZheng Yan 13902c90e5d6SChris Mason cur_trans->commit_done = 1; 1391b7ec40d7SChris Mason 139215ee9bc7SJosef Bacik root->fs_info->last_trans_committed = cur_trans->transid; 1393817d52f8SJosef Bacik 13942c90e5d6SChris Mason wake_up(&cur_trans->commit_wait); 13953de4586cSChris Mason 139679154b1bSChris Mason put_transaction(cur_trans); 139778fae27eSChris Mason put_transaction(cur_trans); 139858176a96SJosef Bacik 13991abe9b8aSliubo trace_btrfs_transaction_commit(root); 14001abe9b8aSliubo 140178fae27eSChris Mason mutex_unlock(&root->fs_info->trans_mutex); 14023de4586cSChris Mason 14039ed74f2dSJosef Bacik if (current->journal_info == trans) 14049ed74f2dSJosef Bacik current->journal_info = NULL; 14059ed74f2dSJosef Bacik 14062c90e5d6SChris Mason kmem_cache_free(btrfs_trans_handle_cachep, trans); 140724bbcf04SYan, Zheng 140824bbcf04SYan, Zheng if (current != root->fs_info->transaction_kthread) 140924bbcf04SYan, Zheng btrfs_run_delayed_iputs(root); 141024bbcf04SYan, Zheng 141179154b1bSChris Mason return ret; 141279154b1bSChris Mason } 141379154b1bSChris Mason 1414d352ac68SChris Mason /* 1415d352ac68SChris Mason * interface function to delete all the snapshots we have scheduled for deletion 1416d352ac68SChris Mason */ 1417e9d0b13bSChris Mason int btrfs_clean_old_snapshots(struct btrfs_root *root) 1418e9d0b13bSChris Mason { 14195d4f98a2SYan Zheng LIST_HEAD(list); 14205d4f98a2SYan Zheng struct btrfs_fs_info *fs_info = root->fs_info; 1421e9d0b13bSChris Mason 14225d4f98a2SYan Zheng mutex_lock(&fs_info->trans_mutex); 14235d4f98a2SYan Zheng list_splice_init(&fs_info->dead_roots, &list); 14245d4f98a2SYan Zheng mutex_unlock(&fs_info->trans_mutex); 14255d4f98a2SYan Zheng 14265d4f98a2SYan Zheng while (!list_empty(&list)) { 14275d4f98a2SYan Zheng root = list_entry(list.next, struct btrfs_root, root_list); 142876dda93cSYan, Zheng list_del(&root->root_list); 142976dda93cSYan, Zheng 143076dda93cSYan, Zheng if (btrfs_header_backref_rev(root->node) < 143176dda93cSYan, Zheng BTRFS_MIXED_BACKREF_REV) 14323fd0a558SYan, Zheng btrfs_drop_snapshot(root, NULL, 0); 143376dda93cSYan, Zheng else 14343fd0a558SYan, Zheng btrfs_drop_snapshot(root, NULL, 1); 1435e9d0b13bSChris Mason } 1436e9d0b13bSChris Mason return 0; 1437e9d0b13bSChris Mason } 1438