xref: /openbmc/linux/fs/btrfs/transaction.c (revision 86b9f2ec)
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>
2034088780SChris Mason #include <linux/sched.h>
21d3c2fdcfSChris Mason #include <linux/writeback.h>
225f39d397SChris Mason #include <linux/pagemap.h>
235f2cc086SChris Mason #include <linux/blkdev.h>
2479154b1bSChris Mason #include "ctree.h"
2579154b1bSChris Mason #include "disk-io.h"
2679154b1bSChris Mason #include "transaction.h"
27925baeddSChris Mason #include "locking.h"
28e02119d5SChris Mason #include "tree-log.h"
2979154b1bSChris Mason 
300f7d52f4SChris Mason #define BTRFS_ROOT_TRANS_TAG 0
310f7d52f4SChris Mason 
3280b6794dSChris Mason static noinline void put_transaction(struct btrfs_transaction *transaction)
3379154b1bSChris Mason {
342c90e5d6SChris Mason 	WARN_ON(transaction->use_count == 0);
3579154b1bSChris Mason 	transaction->use_count--;
3678fae27eSChris Mason 	if (transaction->use_count == 0) {
378fd17795SChris Mason 		list_del_init(&transaction->list);
382c90e5d6SChris Mason 		memset(transaction, 0, sizeof(*transaction));
392c90e5d6SChris Mason 		kmem_cache_free(btrfs_transaction_cachep, transaction);
4079154b1bSChris Mason 	}
4178fae27eSChris Mason }
4279154b1bSChris Mason 
43817d52f8SJosef Bacik static noinline void switch_commit_root(struct btrfs_root *root)
44817d52f8SJosef Bacik {
45817d52f8SJosef Bacik 	free_extent_buffer(root->commit_root);
46817d52f8SJosef Bacik 	root->commit_root = btrfs_root_node(root);
47817d52f8SJosef Bacik }
48817d52f8SJosef Bacik 
49d352ac68SChris Mason /*
50d352ac68SChris Mason  * either allocate a new transaction or hop into the existing one
51d352ac68SChris Mason  */
5280b6794dSChris Mason static noinline int join_transaction(struct btrfs_root *root)
5379154b1bSChris Mason {
5479154b1bSChris Mason 	struct btrfs_transaction *cur_trans;
5579154b1bSChris Mason 	cur_trans = root->fs_info->running_transaction;
5679154b1bSChris Mason 	if (!cur_trans) {
572c90e5d6SChris Mason 		cur_trans = kmem_cache_alloc(btrfs_transaction_cachep,
582c90e5d6SChris Mason 					     GFP_NOFS);
5979154b1bSChris Mason 		BUG_ON(!cur_trans);
600f7d52f4SChris Mason 		root->fs_info->generation++;
6115ee9bc7SJosef Bacik 		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;
68d5719762SChris Mason 		cur_trans->use_count = 1;
6979154b1bSChris Mason 		cur_trans->commit_done = 0;
7008607c1bSChris Mason 		cur_trans->start_time = get_seconds();
7156bec294SChris Mason 
7256bec294SChris Mason 		cur_trans->delayed_refs.root.rb_node = NULL;
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 {
8979154b1bSChris Mason 		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);
146f9295749SChris Mason 		cur_trans->use_count++;
147f9295749SChris Mason 		while (1) {
148f9295749SChris Mason 			prepare_to_wait(&root->fs_info->transaction_wait, &wait,
149f9295749SChris Mason 					TASK_UNINTERRUPTIBLE);
150f9295749SChris Mason 			if (cur_trans->blocked) {
151f9295749SChris Mason 				mutex_unlock(&root->fs_info->trans_mutex);
152f9295749SChris Mason 				schedule();
153f9295749SChris Mason 				mutex_lock(&root->fs_info->trans_mutex);
154f9295749SChris Mason 				finish_wait(&root->fs_info->transaction_wait,
155f9295749SChris Mason 					    &wait);
156f9295749SChris Mason 			} else {
157f9295749SChris Mason 				finish_wait(&root->fs_info->transaction_wait,
158f9295749SChris Mason 					    &wait);
159f9295749SChris Mason 				break;
160f9295749SChris Mason 			}
161f9295749SChris Mason 		}
162f9295749SChris Mason 		put_transaction(cur_trans);
163f9295749SChris Mason 	}
16437d1aeeeSChris Mason }
16537d1aeeeSChris Mason 
166249ac1e5SJosef Bacik enum btrfs_trans_type {
167249ac1e5SJosef Bacik 	TRANS_START,
168249ac1e5SJosef Bacik 	TRANS_JOIN,
169249ac1e5SJosef Bacik 	TRANS_USERSPACE,
170249ac1e5SJosef Bacik };
171249ac1e5SJosef Bacik 
172e02119d5SChris Mason static struct btrfs_trans_handle *start_transaction(struct btrfs_root *root,
173249ac1e5SJosef Bacik 					     int num_blocks, int type)
17437d1aeeeSChris Mason {
17537d1aeeeSChris Mason 	struct btrfs_trans_handle *h =
17637d1aeeeSChris Mason 		kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS);
17737d1aeeeSChris Mason 	int ret;
17837d1aeeeSChris Mason 
17937d1aeeeSChris Mason 	mutex_lock(&root->fs_info->trans_mutex);
1804bef0848SChris Mason 	if (!root->fs_info->log_root_recovering &&
181249ac1e5SJosef Bacik 	    ((type == TRANS_START && !root->fs_info->open_ioctl_trans) ||
182249ac1e5SJosef Bacik 	     type == TRANS_USERSPACE))
18337d1aeeeSChris Mason 		wait_current_trans(root);
18479154b1bSChris Mason 	ret = join_transaction(root);
18579154b1bSChris Mason 	BUG_ON(ret);
1860f7d52f4SChris Mason 
1876702ed49SChris Mason 	h->transid = root->fs_info->running_transaction->transid;
18879154b1bSChris Mason 	h->transaction = root->fs_info->running_transaction;
18979154b1bSChris Mason 	h->blocks_reserved = num_blocks;
19079154b1bSChris Mason 	h->blocks_used = 0;
191d2fb3437SYan Zheng 	h->block_group = 0;
19226b8003fSChris Mason 	h->alloc_exclude_nr = 0;
19326b8003fSChris Mason 	h->alloc_exclude_start = 0;
19456bec294SChris Mason 	h->delayed_ref_updates = 0;
195b7ec40d7SChris Mason 
196249ac1e5SJosef Bacik 	if (!current->journal_info && type != TRANS_USERSPACE)
1979ed74f2dSJosef Bacik 		current->journal_info = h;
1989ed74f2dSJosef Bacik 
19979154b1bSChris Mason 	root->fs_info->running_transaction->use_count++;
2005d4f98a2SYan Zheng 	record_root_in_trans(h, root);
20179154b1bSChris Mason 	mutex_unlock(&root->fs_info->trans_mutex);
20279154b1bSChris Mason 	return h;
20379154b1bSChris Mason }
20479154b1bSChris Mason 
205f9295749SChris Mason struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
206f9295749SChris Mason 						   int num_blocks)
207f9295749SChris Mason {
208249ac1e5SJosef Bacik 	return start_transaction(root, num_blocks, TRANS_START);
209f9295749SChris Mason }
210f9295749SChris Mason struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root,
211f9295749SChris Mason 						   int num_blocks)
212f9295749SChris Mason {
213249ac1e5SJosef Bacik 	return start_transaction(root, num_blocks, TRANS_JOIN);
214f9295749SChris Mason }
215f9295749SChris Mason 
2169ca9ee09SSage Weil struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *r,
2179ca9ee09SSage Weil 							 int num_blocks)
2189ca9ee09SSage Weil {
219249ac1e5SJosef Bacik 	return start_transaction(r, num_blocks, TRANS_USERSPACE);
2209ca9ee09SSage Weil }
2219ca9ee09SSage Weil 
222d352ac68SChris Mason /* wait for a transaction commit to be fully complete */
22389ce8a63SChris Mason static noinline int wait_for_commit(struct btrfs_root *root,
22489ce8a63SChris Mason 				    struct btrfs_transaction *commit)
22589ce8a63SChris Mason {
22689ce8a63SChris Mason 	DEFINE_WAIT(wait);
22789ce8a63SChris Mason 	mutex_lock(&root->fs_info->trans_mutex);
22889ce8a63SChris Mason 	while (!commit->commit_done) {
22989ce8a63SChris Mason 		prepare_to_wait(&commit->commit_wait, &wait,
23089ce8a63SChris Mason 				TASK_UNINTERRUPTIBLE);
23189ce8a63SChris Mason 		if (commit->commit_done)
23289ce8a63SChris Mason 			break;
23389ce8a63SChris Mason 		mutex_unlock(&root->fs_info->trans_mutex);
23489ce8a63SChris Mason 		schedule();
23589ce8a63SChris Mason 		mutex_lock(&root->fs_info->trans_mutex);
23689ce8a63SChris Mason 	}
23789ce8a63SChris Mason 	mutex_unlock(&root->fs_info->trans_mutex);
23889ce8a63SChris Mason 	finish_wait(&commit->commit_wait, &wait);
23989ce8a63SChris Mason 	return 0;
24089ce8a63SChris Mason }
24189ce8a63SChris Mason 
2425d4f98a2SYan Zheng #if 0
243d352ac68SChris Mason /*
244d397712bSChris Mason  * rate limit against the drop_snapshot code.  This helps to slow down new
245d397712bSChris Mason  * operations if the drop_snapshot code isn't able to keep up.
246d352ac68SChris Mason  */
24737d1aeeeSChris Mason static void throttle_on_drops(struct btrfs_root *root)
248ab78c84dSChris Mason {
249ab78c84dSChris Mason 	struct btrfs_fs_info *info = root->fs_info;
2502dd3e67bSChris Mason 	int harder_count = 0;
251ab78c84dSChris Mason 
2522dd3e67bSChris Mason harder:
253ab78c84dSChris Mason 	if (atomic_read(&info->throttles)) {
254ab78c84dSChris Mason 		DEFINE_WAIT(wait);
255ab78c84dSChris Mason 		int thr;
256ab78c84dSChris Mason 		thr = atomic_read(&info->throttle_gen);
257ab78c84dSChris Mason 
258ab78c84dSChris Mason 		do {
259ab78c84dSChris Mason 			prepare_to_wait(&info->transaction_throttle,
260ab78c84dSChris Mason 					&wait, TASK_UNINTERRUPTIBLE);
261ab78c84dSChris Mason 			if (!atomic_read(&info->throttles)) {
262ab78c84dSChris Mason 				finish_wait(&info->transaction_throttle, &wait);
263ab78c84dSChris Mason 				break;
264ab78c84dSChris Mason 			}
265ab78c84dSChris Mason 			schedule();
266ab78c84dSChris Mason 			finish_wait(&info->transaction_throttle, &wait);
267ab78c84dSChris Mason 		} while (thr == atomic_read(&info->throttle_gen));
2682dd3e67bSChris Mason 		harder_count++;
2692dd3e67bSChris Mason 
2702dd3e67bSChris Mason 		if (root->fs_info->total_ref_cache_size > 1 * 1024 * 1024 &&
2712dd3e67bSChris Mason 		    harder_count < 2)
2722dd3e67bSChris Mason 			goto harder;
2732dd3e67bSChris Mason 
2742dd3e67bSChris Mason 		if (root->fs_info->total_ref_cache_size > 5 * 1024 * 1024 &&
2752dd3e67bSChris Mason 		    harder_count < 10)
2762dd3e67bSChris Mason 			goto harder;
2772dd3e67bSChris Mason 
2782dd3e67bSChris Mason 		if (root->fs_info->total_ref_cache_size > 10 * 1024 * 1024 &&
2792dd3e67bSChris Mason 		    harder_count < 20)
2802dd3e67bSChris Mason 			goto harder;
281ab78c84dSChris Mason 	}
282ab78c84dSChris Mason }
2835d4f98a2SYan Zheng #endif
284ab78c84dSChris Mason 
28537d1aeeeSChris Mason void btrfs_throttle(struct btrfs_root *root)
28637d1aeeeSChris Mason {
28737d1aeeeSChris Mason 	mutex_lock(&root->fs_info->trans_mutex);
2889ca9ee09SSage Weil 	if (!root->fs_info->open_ioctl_trans)
28937d1aeeeSChris Mason 		wait_current_trans(root);
29037d1aeeeSChris Mason 	mutex_unlock(&root->fs_info->trans_mutex);
29137d1aeeeSChris Mason }
29237d1aeeeSChris Mason 
29389ce8a63SChris Mason static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
29489ce8a63SChris Mason 			  struct btrfs_root *root, int throttle)
29579154b1bSChris Mason {
29679154b1bSChris Mason 	struct btrfs_transaction *cur_trans;
297ab78c84dSChris Mason 	struct btrfs_fs_info *info = root->fs_info;
298c3e69d58SChris Mason 	int count = 0;
299d6e4a428SChris Mason 
300c3e69d58SChris Mason 	while (count < 4) {
301c3e69d58SChris Mason 		unsigned long cur = trans->delayed_ref_updates;
302c3e69d58SChris Mason 		trans->delayed_ref_updates = 0;
303c3e69d58SChris Mason 		if (cur &&
304c3e69d58SChris Mason 		    trans->transaction->delayed_refs.num_heads_ready > 64) {
305c3e69d58SChris Mason 			trans->delayed_ref_updates = 0;
306b7ec40d7SChris Mason 
307b7ec40d7SChris Mason 			/*
308b7ec40d7SChris Mason 			 * do a full flush if the transaction is trying
309b7ec40d7SChris Mason 			 * to close
310b7ec40d7SChris Mason 			 */
311b7ec40d7SChris Mason 			if (trans->transaction->delayed_refs.flushing)
312b7ec40d7SChris Mason 				cur = 0;
313c3e69d58SChris Mason 			btrfs_run_delayed_refs(trans, root, cur);
314c3e69d58SChris Mason 		} else {
315c3e69d58SChris Mason 			break;
316c3e69d58SChris Mason 		}
317c3e69d58SChris Mason 		count++;
31856bec294SChris Mason 	}
31956bec294SChris Mason 
320ab78c84dSChris Mason 	mutex_lock(&info->trans_mutex);
321ab78c84dSChris Mason 	cur_trans = info->running_transaction;
322ccd467d6SChris Mason 	WARN_ON(cur_trans != trans->transaction);
323d5719762SChris Mason 	WARN_ON(cur_trans->num_writers < 1);
324ccd467d6SChris Mason 	cur_trans->num_writers--;
32589ce8a63SChris Mason 
32679154b1bSChris Mason 	if (waitqueue_active(&cur_trans->writer_wait))
32779154b1bSChris Mason 		wake_up(&cur_trans->writer_wait);
32879154b1bSChris Mason 	put_transaction(cur_trans);
329ab78c84dSChris Mason 	mutex_unlock(&info->trans_mutex);
3309ed74f2dSJosef Bacik 
3319ed74f2dSJosef Bacik 	if (current->journal_info == trans)
3329ed74f2dSJosef Bacik 		current->journal_info = NULL;
333d6025579SChris Mason 	memset(trans, 0, sizeof(*trans));
3342c90e5d6SChris Mason 	kmem_cache_free(btrfs_trans_handle_cachep, trans);
335ab78c84dSChris Mason 
33624bbcf04SYan, Zheng 	if (throttle)
33724bbcf04SYan, Zheng 		btrfs_run_delayed_iputs(root);
33824bbcf04SYan, Zheng 
33979154b1bSChris Mason 	return 0;
34079154b1bSChris Mason }
34179154b1bSChris Mason 
34289ce8a63SChris Mason int btrfs_end_transaction(struct btrfs_trans_handle *trans,
34389ce8a63SChris Mason 			  struct btrfs_root *root)
34489ce8a63SChris Mason {
34589ce8a63SChris Mason 	return __btrfs_end_transaction(trans, root, 0);
34689ce8a63SChris Mason }
34789ce8a63SChris Mason 
34889ce8a63SChris Mason int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans,
34989ce8a63SChris Mason 				   struct btrfs_root *root)
35089ce8a63SChris Mason {
35189ce8a63SChris Mason 	return __btrfs_end_transaction(trans, root, 1);
35289ce8a63SChris Mason }
35389ce8a63SChris Mason 
354d352ac68SChris Mason /*
355d352ac68SChris Mason  * when btree blocks are allocated, they have some corresponding bits set for
356d352ac68SChris Mason  * them in one of two extent_io trees.  This is used to make sure all of
357690587d1SChris Mason  * those extents are sent to disk but does not wait on them
358d352ac68SChris Mason  */
359690587d1SChris Mason int btrfs_write_marked_extents(struct btrfs_root *root,
3608cef4e16SYan, Zheng 			       struct extent_io_tree *dirty_pages, int mark)
36179154b1bSChris Mason {
3627c4452b9SChris Mason 	int ret;
363777e6bd7SChris Mason 	int err = 0;
3647c4452b9SChris Mason 	int werr = 0;
3657c4452b9SChris Mason 	struct page *page;
3667c4452b9SChris Mason 	struct inode *btree_inode = root->fs_info->btree_inode;
367777e6bd7SChris Mason 	u64 start = 0;
3685f39d397SChris Mason 	u64 end;
3695f39d397SChris Mason 	unsigned long index;
3707c4452b9SChris Mason 
3717c4452b9SChris Mason 	while (1) {
372777e6bd7SChris Mason 		ret = find_first_extent_bit(dirty_pages, start, &start, &end,
3738cef4e16SYan, Zheng 					    mark);
3745f39d397SChris Mason 		if (ret)
3757c4452b9SChris Mason 			break;
3765f39d397SChris Mason 		while (start <= end) {
377777e6bd7SChris Mason 			cond_resched();
378777e6bd7SChris Mason 
3795f39d397SChris Mason 			index = start >> PAGE_CACHE_SHIFT;
38035ebb934SChris Mason 			start = (u64)(index + 1) << PAGE_CACHE_SHIFT;
3814bef0848SChris Mason 			page = find_get_page(btree_inode->i_mapping, index);
3827c4452b9SChris Mason 			if (!page)
3837c4452b9SChris Mason 				continue;
3844bef0848SChris Mason 
3854bef0848SChris Mason 			btree_lock_page_hook(page);
3864bef0848SChris Mason 			if (!page->mapping) {
3874bef0848SChris Mason 				unlock_page(page);
3884bef0848SChris Mason 				page_cache_release(page);
3894bef0848SChris Mason 				continue;
3904bef0848SChris Mason 			}
3914bef0848SChris Mason 
3926702ed49SChris Mason 			if (PageWriteback(page)) {
3936702ed49SChris Mason 				if (PageDirty(page))
3946702ed49SChris Mason 					wait_on_page_writeback(page);
3956702ed49SChris Mason 				else {
3966702ed49SChris Mason 					unlock_page(page);
3976702ed49SChris Mason 					page_cache_release(page);
3986702ed49SChris Mason 					continue;
3996702ed49SChris Mason 				}
4006702ed49SChris Mason 			}
4017c4452b9SChris Mason 			err = write_one_page(page, 0);
4027c4452b9SChris Mason 			if (err)
4037c4452b9SChris Mason 				werr = err;
4047c4452b9SChris Mason 			page_cache_release(page);
4057c4452b9SChris Mason 		}
4067c4452b9SChris Mason 	}
407690587d1SChris Mason 	if (err)
408690587d1SChris Mason 		werr = err;
409690587d1SChris Mason 	return werr;
410690587d1SChris Mason }
411690587d1SChris Mason 
412690587d1SChris Mason /*
413690587d1SChris Mason  * when btree blocks are allocated, they have some corresponding bits set for
414690587d1SChris Mason  * them in one of two extent_io trees.  This is used to make sure all of
415690587d1SChris Mason  * those extents are on disk for transaction or log commit.  We wait
416690587d1SChris Mason  * on all the pages and clear them from the dirty pages state tree
417690587d1SChris Mason  */
418690587d1SChris Mason int btrfs_wait_marked_extents(struct btrfs_root *root,
4198cef4e16SYan, Zheng 			      struct extent_io_tree *dirty_pages, int mark)
420690587d1SChris Mason {
421690587d1SChris Mason 	int ret;
422690587d1SChris Mason 	int err = 0;
423690587d1SChris Mason 	int werr = 0;
424690587d1SChris Mason 	struct page *page;
425690587d1SChris Mason 	struct inode *btree_inode = root->fs_info->btree_inode;
426690587d1SChris Mason 	u64 start = 0;
427690587d1SChris Mason 	u64 end;
428690587d1SChris Mason 	unsigned long index;
429690587d1SChris Mason 
430777e6bd7SChris Mason 	while (1) {
4318cef4e16SYan, Zheng 		ret = find_first_extent_bit(dirty_pages, start, &start, &end,
4328cef4e16SYan, Zheng 					    mark);
433777e6bd7SChris Mason 		if (ret)
434777e6bd7SChris Mason 			break;
435777e6bd7SChris Mason 
4368cef4e16SYan, Zheng 		clear_extent_bits(dirty_pages, start, end, mark, GFP_NOFS);
437777e6bd7SChris Mason 		while (start <= end) {
438777e6bd7SChris Mason 			index = start >> PAGE_CACHE_SHIFT;
439777e6bd7SChris Mason 			start = (u64)(index + 1) << PAGE_CACHE_SHIFT;
440777e6bd7SChris Mason 			page = find_get_page(btree_inode->i_mapping, index);
441777e6bd7SChris Mason 			if (!page)
442777e6bd7SChris Mason 				continue;
443777e6bd7SChris Mason 			if (PageDirty(page)) {
4444bef0848SChris Mason 				btree_lock_page_hook(page);
4454bef0848SChris Mason 				wait_on_page_writeback(page);
446777e6bd7SChris Mason 				err = write_one_page(page, 0);
447777e6bd7SChris Mason 				if (err)
448777e6bd7SChris Mason 					werr = err;
449777e6bd7SChris Mason 			}
450777e6bd7SChris Mason 			wait_on_page_writeback(page);
451777e6bd7SChris Mason 			page_cache_release(page);
452777e6bd7SChris Mason 			cond_resched();
453777e6bd7SChris Mason 		}
454777e6bd7SChris Mason 	}
4557c4452b9SChris Mason 	if (err)
4567c4452b9SChris Mason 		werr = err;
4577c4452b9SChris Mason 	return werr;
45879154b1bSChris Mason }
45979154b1bSChris Mason 
460690587d1SChris Mason /*
461690587d1SChris Mason  * when btree blocks are allocated, they have some corresponding bits set for
462690587d1SChris Mason  * them in one of two extent_io trees.  This is used to make sure all of
463690587d1SChris Mason  * those extents are on disk for transaction or log commit
464690587d1SChris Mason  */
465690587d1SChris Mason int btrfs_write_and_wait_marked_extents(struct btrfs_root *root,
4668cef4e16SYan, Zheng 				struct extent_io_tree *dirty_pages, int mark)
467690587d1SChris Mason {
468690587d1SChris Mason 	int ret;
469690587d1SChris Mason 	int ret2;
470690587d1SChris Mason 
4718cef4e16SYan, Zheng 	ret = btrfs_write_marked_extents(root, dirty_pages, mark);
4728cef4e16SYan, Zheng 	ret2 = btrfs_wait_marked_extents(root, dirty_pages, mark);
473690587d1SChris Mason 	return ret || ret2;
474690587d1SChris Mason }
475690587d1SChris Mason 
476d0c803c4SChris Mason int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans,
477d0c803c4SChris Mason 				     struct btrfs_root *root)
478d0c803c4SChris Mason {
479d0c803c4SChris Mason 	if (!trans || !trans->transaction) {
480d0c803c4SChris Mason 		struct inode *btree_inode;
481d0c803c4SChris Mason 		btree_inode = root->fs_info->btree_inode;
482d0c803c4SChris Mason 		return filemap_write_and_wait(btree_inode->i_mapping);
483d0c803c4SChris Mason 	}
484d0c803c4SChris Mason 	return btrfs_write_and_wait_marked_extents(root,
4858cef4e16SYan, Zheng 					   &trans->transaction->dirty_pages,
4868cef4e16SYan, Zheng 					   EXTENT_DIRTY);
487d0c803c4SChris Mason }
488d0c803c4SChris Mason 
489d352ac68SChris Mason /*
490d352ac68SChris Mason  * this is used to update the root pointer in the tree of tree roots.
491d352ac68SChris Mason  *
492d352ac68SChris Mason  * But, in the case of the extent allocation tree, updating the root
493d352ac68SChris Mason  * pointer may allocate blocks which may change the root of the extent
494d352ac68SChris Mason  * allocation tree.
495d352ac68SChris Mason  *
496d352ac68SChris Mason  * So, this loops and repeats and makes sure the cowonly root didn't
497d352ac68SChris Mason  * change while the root pointer was being updated in the metadata.
498d352ac68SChris Mason  */
4990b86a832SChris Mason static int update_cowonly_root(struct btrfs_trans_handle *trans,
50079154b1bSChris Mason 			       struct btrfs_root *root)
50179154b1bSChris Mason {
50279154b1bSChris Mason 	int ret;
5030b86a832SChris Mason 	u64 old_root_bytenr;
50486b9f2ecSYan, Zheng 	u64 old_root_used;
5050b86a832SChris Mason 	struct btrfs_root *tree_root = root->fs_info->tree_root;
50679154b1bSChris Mason 
50786b9f2ecSYan, Zheng 	old_root_used = btrfs_root_used(&root->root_item);
5080b86a832SChris Mason 	btrfs_write_dirty_block_groups(trans, root);
50956bec294SChris Mason 
51079154b1bSChris Mason 	while (1) {
5110b86a832SChris Mason 		old_root_bytenr = btrfs_root_bytenr(&root->root_item);
51286b9f2ecSYan, Zheng 		if (old_root_bytenr == root->node->start &&
51386b9f2ecSYan, Zheng 		    old_root_used == btrfs_root_used(&root->root_item))
51479154b1bSChris Mason 			break;
51587ef2bb4SChris Mason 
5165d4f98a2SYan Zheng 		btrfs_set_root_node(&root->root_item, root->node);
51779154b1bSChris Mason 		ret = btrfs_update_root(trans, tree_root,
5180b86a832SChris Mason 					&root->root_key,
5190b86a832SChris Mason 					&root->root_item);
52079154b1bSChris Mason 		BUG_ON(ret);
52156bec294SChris Mason 
52286b9f2ecSYan, Zheng 		old_root_used = btrfs_root_used(&root->root_item);
5234a8c9a62SYan Zheng 		ret = btrfs_write_dirty_block_groups(trans, root);
52456bec294SChris Mason 		BUG_ON(ret);
5250b86a832SChris Mason 	}
526276e680dSYan Zheng 
527276e680dSYan Zheng 	if (root != root->fs_info->extent_root)
528817d52f8SJosef Bacik 		switch_commit_root(root);
529276e680dSYan Zheng 
5300b86a832SChris Mason 	return 0;
5310b86a832SChris Mason }
5320b86a832SChris Mason 
533d352ac68SChris Mason /*
534d352ac68SChris Mason  * update all the cowonly tree roots on disk
535d352ac68SChris Mason  */
5365d4f98a2SYan Zheng static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans,
5370b86a832SChris Mason 					 struct btrfs_root *root)
5380b86a832SChris Mason {
5390b86a832SChris Mason 	struct btrfs_fs_info *fs_info = root->fs_info;
5400b86a832SChris Mason 	struct list_head *next;
54184234f3aSYan Zheng 	struct extent_buffer *eb;
54256bec294SChris Mason 	int ret;
54384234f3aSYan Zheng 
54456bec294SChris Mason 	ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
54556bec294SChris Mason 	BUG_ON(ret);
54687ef2bb4SChris Mason 
54784234f3aSYan Zheng 	eb = btrfs_lock_root_node(fs_info->tree_root);
5489fa8cfe7SChris Mason 	btrfs_cow_block(trans, fs_info->tree_root, eb, NULL, 0, &eb);
54984234f3aSYan Zheng 	btrfs_tree_unlock(eb);
55084234f3aSYan Zheng 	free_extent_buffer(eb);
5510b86a832SChris Mason 
55256bec294SChris Mason 	ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
55356bec294SChris Mason 	BUG_ON(ret);
55487ef2bb4SChris Mason 
5550b86a832SChris Mason 	while (!list_empty(&fs_info->dirty_cowonly_roots)) {
5560b86a832SChris Mason 		next = fs_info->dirty_cowonly_roots.next;
5570b86a832SChris Mason 		list_del_init(next);
5580b86a832SChris Mason 		root = list_entry(next, struct btrfs_root, dirty_list);
55987ef2bb4SChris Mason 
5600b86a832SChris Mason 		update_cowonly_root(trans, root);
56179154b1bSChris Mason 	}
562276e680dSYan Zheng 
563276e680dSYan Zheng 	down_write(&fs_info->extent_commit_sem);
564276e680dSYan Zheng 	switch_commit_root(fs_info->extent_root);
565276e680dSYan Zheng 	up_write(&fs_info->extent_commit_sem);
566276e680dSYan Zheng 
56779154b1bSChris Mason 	return 0;
56879154b1bSChris Mason }
56979154b1bSChris Mason 
570d352ac68SChris Mason /*
571d352ac68SChris Mason  * dead roots are old snapshots that need to be deleted.  This allocates
572d352ac68SChris Mason  * a dirty root struct and adds it into the list of dead roots that need to
573d352ac68SChris Mason  * be deleted
574d352ac68SChris Mason  */
5755d4f98a2SYan Zheng int btrfs_add_dead_root(struct btrfs_root *root)
5765eda7b5eSChris Mason {
577b48652c1SYan Zheng 	mutex_lock(&root->fs_info->trans_mutex);
5785d4f98a2SYan Zheng 	list_add(&root->root_list, &root->fs_info->dead_roots);
579b48652c1SYan Zheng 	mutex_unlock(&root->fs_info->trans_mutex);
5805eda7b5eSChris Mason 	return 0;
5815eda7b5eSChris Mason }
5825eda7b5eSChris Mason 
583d352ac68SChris Mason /*
5845d4f98a2SYan Zheng  * update all the cowonly tree roots on disk
585d352ac68SChris Mason  */
5865d4f98a2SYan Zheng static noinline int commit_fs_roots(struct btrfs_trans_handle *trans,
5875d4f98a2SYan Zheng 				    struct btrfs_root *root)
5880f7d52f4SChris Mason {
5890f7d52f4SChris Mason 	struct btrfs_root *gang[8];
5905d4f98a2SYan Zheng 	struct btrfs_fs_info *fs_info = root->fs_info;
5910f7d52f4SChris Mason 	int i;
5920f7d52f4SChris Mason 	int ret;
59354aa1f4dSChris Mason 	int err = 0;
59454aa1f4dSChris Mason 
5950f7d52f4SChris Mason 	while (1) {
5965d4f98a2SYan Zheng 		ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix,
5975d4f98a2SYan Zheng 						 (void **)gang, 0,
5980f7d52f4SChris Mason 						 ARRAY_SIZE(gang),
5990f7d52f4SChris Mason 						 BTRFS_ROOT_TRANS_TAG);
6000f7d52f4SChris Mason 		if (ret == 0)
6010f7d52f4SChris Mason 			break;
6020f7d52f4SChris Mason 		for (i = 0; i < ret; i++) {
6030f7d52f4SChris Mason 			root = gang[i];
6045d4f98a2SYan Zheng 			radix_tree_tag_clear(&fs_info->fs_roots_radix,
6052619ba1fSChris Mason 					(unsigned long)root->root_key.objectid,
6060f7d52f4SChris Mason 					BTRFS_ROOT_TRANS_TAG);
60731153d81SYan Zheng 
608e02119d5SChris Mason 			btrfs_free_log(trans, root);
6095d4f98a2SYan Zheng 			btrfs_update_reloc_root(trans, root);
610e02119d5SChris Mason 
611978d910dSYan Zheng 			if (root->commit_root != root->node) {
612817d52f8SJosef Bacik 				switch_commit_root(root);
613978d910dSYan Zheng 				btrfs_set_root_node(&root->root_item,
614978d910dSYan Zheng 						    root->node);
615978d910dSYan Zheng 			}
61631153d81SYan Zheng 
6175d4f98a2SYan Zheng 			err = btrfs_update_root(trans, fs_info->tree_root,
6180f7d52f4SChris Mason 						&root->root_key,
6190f7d52f4SChris Mason 						&root->root_item);
62054aa1f4dSChris Mason 			if (err)
62154aa1f4dSChris Mason 				break;
6220f7d52f4SChris Mason 		}
6239f3a7427SChris Mason 	}
62454aa1f4dSChris Mason 	return err;
6250f7d52f4SChris Mason }
6260f7d52f4SChris Mason 
627d352ac68SChris Mason /*
628d352ac68SChris Mason  * defrag a given btree.  If cacheonly == 1, this won't read from the disk,
629d352ac68SChris Mason  * otherwise every leaf in the btree is read and defragged.
630d352ac68SChris Mason  */
631e9d0b13bSChris Mason int btrfs_defrag_root(struct btrfs_root *root, int cacheonly)
632e9d0b13bSChris Mason {
633e9d0b13bSChris Mason 	struct btrfs_fs_info *info = root->fs_info;
634e9d0b13bSChris Mason 	int ret;
635e9d0b13bSChris Mason 	struct btrfs_trans_handle *trans;
636d3c2fdcfSChris Mason 	unsigned long nr;
637e9d0b13bSChris Mason 
638a2135011SChris Mason 	smp_mb();
639e9d0b13bSChris Mason 	if (root->defrag_running)
640e9d0b13bSChris Mason 		return 0;
641e9d0b13bSChris Mason 	trans = btrfs_start_transaction(root, 1);
6426b80053dSChris Mason 	while (1) {
643e9d0b13bSChris Mason 		root->defrag_running = 1;
644e9d0b13bSChris Mason 		ret = btrfs_defrag_leaves(trans, root, cacheonly);
645d3c2fdcfSChris Mason 		nr = trans->blocks_used;
646e9d0b13bSChris Mason 		btrfs_end_transaction(trans, root);
647d3c2fdcfSChris Mason 		btrfs_btree_balance_dirty(info->tree_root, nr);
648e9d0b13bSChris Mason 		cond_resched();
649e9d0b13bSChris Mason 
650e9d0b13bSChris Mason 		trans = btrfs_start_transaction(root, 1);
6513f157a2fSChris Mason 		if (root->fs_info->closing || ret != -EAGAIN)
652e9d0b13bSChris Mason 			break;
653e9d0b13bSChris Mason 	}
654e9d0b13bSChris Mason 	root->defrag_running = 0;
655a2135011SChris Mason 	smp_mb();
656e9d0b13bSChris Mason 	btrfs_end_transaction(trans, root);
657e9d0b13bSChris Mason 	return 0;
658e9d0b13bSChris Mason }
659e9d0b13bSChris Mason 
6602c47e605SYan Zheng #if 0
661d352ac68SChris Mason /*
662b7ec40d7SChris Mason  * when dropping snapshots, we generate a ton of delayed refs, and it makes
663b7ec40d7SChris Mason  * sense not to join the transaction while it is trying to flush the current
664b7ec40d7SChris Mason  * queue of delayed refs out.
665b7ec40d7SChris Mason  *
666b7ec40d7SChris Mason  * This is used by the drop snapshot code only
667b7ec40d7SChris Mason  */
668b7ec40d7SChris Mason static noinline int wait_transaction_pre_flush(struct btrfs_fs_info *info)
669b7ec40d7SChris Mason {
670b7ec40d7SChris Mason 	DEFINE_WAIT(wait);
671b7ec40d7SChris Mason 
672b7ec40d7SChris Mason 	mutex_lock(&info->trans_mutex);
673b7ec40d7SChris Mason 	while (info->running_transaction &&
674b7ec40d7SChris Mason 	       info->running_transaction->delayed_refs.flushing) {
675b7ec40d7SChris Mason 		prepare_to_wait(&info->transaction_wait, &wait,
676b7ec40d7SChris Mason 				TASK_UNINTERRUPTIBLE);
677b7ec40d7SChris Mason 		mutex_unlock(&info->trans_mutex);
67859bc5c75SChris Mason 
679b7ec40d7SChris Mason 		schedule();
68059bc5c75SChris Mason 
681b7ec40d7SChris Mason 		mutex_lock(&info->trans_mutex);
682b7ec40d7SChris Mason 		finish_wait(&info->transaction_wait, &wait);
683b7ec40d7SChris Mason 	}
684b7ec40d7SChris Mason 	mutex_unlock(&info->trans_mutex);
685b7ec40d7SChris Mason 	return 0;
686b7ec40d7SChris Mason }
687b7ec40d7SChris Mason 
688b7ec40d7SChris Mason /*
689d352ac68SChris Mason  * Given a list of roots that need to be deleted, call btrfs_drop_snapshot on
690d352ac68SChris Mason  * all of them
691d352ac68SChris Mason  */
6925d4f98a2SYan Zheng int btrfs_drop_dead_root(struct btrfs_root *root)
6930f7d52f4SChris Mason {
6940f7d52f4SChris Mason 	struct btrfs_trans_handle *trans;
6955d4f98a2SYan Zheng 	struct btrfs_root *tree_root = root->fs_info->tree_root;
696d3c2fdcfSChris Mason 	unsigned long nr;
6975d4f98a2SYan Zheng 	int ret;
69858176a96SJosef Bacik 
6999f3a7427SChris Mason 	while (1) {
700b7ec40d7SChris Mason 		/*
701b7ec40d7SChris Mason 		 * we don't want to jump in and create a bunch of
702b7ec40d7SChris Mason 		 * delayed refs if the transaction is starting to close
703b7ec40d7SChris Mason 		 */
704b7ec40d7SChris Mason 		wait_transaction_pre_flush(tree_root->fs_info);
7050f7d52f4SChris Mason 		trans = btrfs_start_transaction(tree_root, 1);
706b7ec40d7SChris Mason 
707b7ec40d7SChris Mason 		/*
708b7ec40d7SChris Mason 		 * we've joined a transaction, make sure it isn't
709b7ec40d7SChris Mason 		 * closing right now
710b7ec40d7SChris Mason 		 */
711b7ec40d7SChris Mason 		if (trans->transaction->delayed_refs.flushing) {
712b7ec40d7SChris Mason 			btrfs_end_transaction(trans, tree_root);
713b7ec40d7SChris Mason 			continue;
714b7ec40d7SChris Mason 		}
715b7ec40d7SChris Mason 
7165d4f98a2SYan Zheng 		ret = btrfs_drop_snapshot(trans, root);
717d397712bSChris Mason 		if (ret != -EAGAIN)
7189f3a7427SChris Mason 			break;
71958176a96SJosef Bacik 
7205d4f98a2SYan Zheng 		ret = btrfs_update_root(trans, tree_root,
7215d4f98a2SYan Zheng 					&root->root_key,
7225d4f98a2SYan Zheng 					&root->root_item);
7235d4f98a2SYan Zheng 		if (ret)
72454aa1f4dSChris Mason 			break;
725bcc63abbSYan 
726d3c2fdcfSChris Mason 		nr = trans->blocks_used;
7270f7d52f4SChris Mason 		ret = btrfs_end_transaction(trans, tree_root);
7280f7d52f4SChris Mason 		BUG_ON(ret);
7295eda7b5eSChris Mason 
730d3c2fdcfSChris Mason 		btrfs_btree_balance_dirty(tree_root, nr);
7314dc11904SChris Mason 		cond_resched();
7320f7d52f4SChris Mason 	}
7335d4f98a2SYan Zheng 	BUG_ON(ret);
7345d4f98a2SYan Zheng 
7355d4f98a2SYan Zheng 	ret = btrfs_del_root(trans, tree_root, &root->root_key);
7365d4f98a2SYan Zheng 	BUG_ON(ret);
7375d4f98a2SYan Zheng 
7385d4f98a2SYan Zheng 	nr = trans->blocks_used;
7395d4f98a2SYan Zheng 	ret = btrfs_end_transaction(trans, tree_root);
7405d4f98a2SYan Zheng 	BUG_ON(ret);
7415d4f98a2SYan Zheng 
7425d4f98a2SYan Zheng 	free_extent_buffer(root->node);
7435d4f98a2SYan Zheng 	free_extent_buffer(root->commit_root);
7445d4f98a2SYan Zheng 	kfree(root);
7455d4f98a2SYan Zheng 
7465d4f98a2SYan Zheng 	btrfs_btree_balance_dirty(tree_root, nr);
74754aa1f4dSChris Mason 	return ret;
7480f7d52f4SChris Mason }
7492c47e605SYan Zheng #endif
7500f7d52f4SChris Mason 
751d352ac68SChris Mason /*
752d352ac68SChris Mason  * new snapshots need to be created at a very specific time in the
753d352ac68SChris Mason  * transaction commit.  This does the actual creation
754d352ac68SChris Mason  */
75580b6794dSChris Mason static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
7563063d29fSChris Mason 				   struct btrfs_fs_info *fs_info,
7573063d29fSChris Mason 				   struct btrfs_pending_snapshot *pending)
7583063d29fSChris Mason {
7593063d29fSChris Mason 	struct btrfs_key key;
76080b6794dSChris Mason 	struct btrfs_root_item *new_root_item;
7613063d29fSChris Mason 	struct btrfs_root *tree_root = fs_info->tree_root;
7623063d29fSChris Mason 	struct btrfs_root *root = pending->root;
7633063d29fSChris Mason 	struct extent_buffer *tmp;
764925baeddSChris Mason 	struct extent_buffer *old;
7653063d29fSChris Mason 	int ret;
7663063d29fSChris Mason 	u64 objectid;
7673063d29fSChris Mason 
76880b6794dSChris Mason 	new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS);
76980b6794dSChris Mason 	if (!new_root_item) {
77080b6794dSChris Mason 		ret = -ENOMEM;
77180b6794dSChris Mason 		goto fail;
77280b6794dSChris Mason 	}
7733063d29fSChris Mason 	ret = btrfs_find_free_objectid(trans, tree_root, 0, &objectid);
7743063d29fSChris Mason 	if (ret)
7753063d29fSChris Mason 		goto fail;
7763063d29fSChris Mason 
7775d4f98a2SYan Zheng 	record_root_in_trans(trans, root);
77880ff3856SYan Zheng 	btrfs_set_root_last_snapshot(&root->root_item, trans->transid);
77980b6794dSChris Mason 	memcpy(new_root_item, &root->root_item, sizeof(*new_root_item));
7803063d29fSChris Mason 
7813063d29fSChris Mason 	key.objectid = objectid;
7821c4850e2SYan, Zheng 	/* record when the snapshot was created in key.offset */
7831c4850e2SYan, Zheng 	key.offset = trans->transid;
7843063d29fSChris Mason 	btrfs_set_key_type(&key, BTRFS_ROOT_ITEM_KEY);
7853063d29fSChris Mason 
786925baeddSChris Mason 	old = btrfs_lock_root_node(root);
7879fa8cfe7SChris Mason 	btrfs_cow_block(trans, root, old, NULL, 0, &old);
7885d4f98a2SYan Zheng 	btrfs_set_lock_blocking(old);
7893063d29fSChris Mason 
790925baeddSChris Mason 	btrfs_copy_root(trans, root, old, &tmp, objectid);
791925baeddSChris Mason 	btrfs_tree_unlock(old);
792925baeddSChris Mason 	free_extent_buffer(old);
7933063d29fSChris Mason 
7945d4f98a2SYan Zheng 	btrfs_set_root_node(new_root_item, tmp);
7953063d29fSChris Mason 	ret = btrfs_insert_root(trans, root->fs_info->tree_root, &key,
79680b6794dSChris Mason 				new_root_item);
797925baeddSChris Mason 	btrfs_tree_unlock(tmp);
7983063d29fSChris Mason 	free_extent_buffer(tmp);
7993063d29fSChris Mason 	if (ret)
8003063d29fSChris Mason 		goto fail;
8013063d29fSChris Mason 
8023de4586cSChris Mason 	key.offset = (u64)-1;
8033de4586cSChris Mason 	memcpy(&pending->root_key, &key, sizeof(key));
8043de4586cSChris Mason fail:
8053de4586cSChris Mason 	kfree(new_root_item);
8063de4586cSChris Mason 	return ret;
8073de4586cSChris Mason }
8083de4586cSChris Mason 
8093de4586cSChris Mason static noinline int finish_pending_snapshot(struct btrfs_fs_info *fs_info,
8103de4586cSChris Mason 				   struct btrfs_pending_snapshot *pending)
8113de4586cSChris Mason {
8123de4586cSChris Mason 	int ret;
8133de4586cSChris Mason 	int namelen;
8143de4586cSChris Mason 	u64 index = 0;
8153de4586cSChris Mason 	struct btrfs_trans_handle *trans;
8163de4586cSChris Mason 	struct inode *parent_inode;
8170660b5afSChris Mason 	struct btrfs_root *parent_root;
8183de4586cSChris Mason 
8193394e160SChris Mason 	parent_inode = pending->dentry->d_parent->d_inode;
8200660b5afSChris Mason 	parent_root = BTRFS_I(parent_inode)->root;
821180591bcSYan Zheng 	trans = btrfs_join_transaction(parent_root, 1);
8223de4586cSChris Mason 
8233063d29fSChris Mason 	/*
8243063d29fSChris Mason 	 * insert the directory item
8253063d29fSChris Mason 	 */
8263b96362cSSven Wegener 	namelen = strlen(pending->name);
8273de4586cSChris Mason 	ret = btrfs_set_inode_index(parent_inode, &index);
8280660b5afSChris Mason 	ret = btrfs_insert_dir_item(trans, parent_root,
8293b96362cSSven Wegener 			    pending->name, namelen,
8303de4586cSChris Mason 			    parent_inode->i_ino,
8313de4586cSChris Mason 			    &pending->root_key, BTRFS_FT_DIR, index);
8323063d29fSChris Mason 
8333063d29fSChris Mason 	if (ret)
8343063d29fSChris Mason 		goto fail;
8350660b5afSChris Mason 
83652c26179SYan Zheng 	btrfs_i_size_write(parent_inode, parent_inode->i_size + namelen * 2);
83752c26179SYan Zheng 	ret = btrfs_update_inode(trans, parent_root, parent_inode);
83852c26179SYan Zheng 	BUG_ON(ret);
83952c26179SYan Zheng 
8400660b5afSChris Mason 	ret = btrfs_add_root_ref(trans, parent_root->fs_info->tree_root,
8410660b5afSChris Mason 				 pending->root_key.objectid,
8420660b5afSChris Mason 				 parent_root->root_key.objectid,
8430660b5afSChris Mason 				 parent_inode->i_ino, index, pending->name,
8440660b5afSChris Mason 				 namelen);
8450660b5afSChris Mason 
8460660b5afSChris Mason 	BUG_ON(ret);
8470660b5afSChris Mason 
8483063d29fSChris Mason fail:
8493de4586cSChris Mason 	btrfs_end_transaction(trans, fs_info->fs_root);
8503063d29fSChris Mason 	return ret;
8513063d29fSChris Mason }
8523063d29fSChris Mason 
853d352ac68SChris Mason /*
854d352ac68SChris Mason  * create all the snapshots we've scheduled for creation
855d352ac68SChris Mason  */
85680b6794dSChris Mason static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans,
8573063d29fSChris Mason 					     struct btrfs_fs_info *fs_info)
8583063d29fSChris Mason {
8593063d29fSChris Mason 	struct btrfs_pending_snapshot *pending;
8603063d29fSChris Mason 	struct list_head *head = &trans->transaction->pending_snapshots;
8613de4586cSChris Mason 	int ret;
8623de4586cSChris Mason 
863c6e30871SQinghuang Feng 	list_for_each_entry(pending, head, list) {
8643de4586cSChris Mason 		ret = create_pending_snapshot(trans, fs_info, pending);
8653de4586cSChris Mason 		BUG_ON(ret);
8663de4586cSChris Mason 	}
8673de4586cSChris Mason 	return 0;
8683de4586cSChris Mason }
8693de4586cSChris Mason 
8703de4586cSChris Mason static noinline int finish_pending_snapshots(struct btrfs_trans_handle *trans,
8713de4586cSChris Mason 					     struct btrfs_fs_info *fs_info)
8723de4586cSChris Mason {
8733de4586cSChris Mason 	struct btrfs_pending_snapshot *pending;
8743de4586cSChris Mason 	struct list_head *head = &trans->transaction->pending_snapshots;
8753063d29fSChris Mason 	int ret;
8763063d29fSChris Mason 
8773063d29fSChris Mason 	while (!list_empty(head)) {
8783063d29fSChris Mason 		pending = list_entry(head->next,
8793063d29fSChris Mason 				     struct btrfs_pending_snapshot, list);
8803de4586cSChris Mason 		ret = finish_pending_snapshot(fs_info, pending);
8813063d29fSChris Mason 		BUG_ON(ret);
8823063d29fSChris Mason 		list_del(&pending->list);
8833063d29fSChris Mason 		kfree(pending->name);
8843063d29fSChris Mason 		kfree(pending);
8853063d29fSChris Mason 	}
886dc17ff8fSChris Mason 	return 0;
887dc17ff8fSChris Mason }
888dc17ff8fSChris Mason 
8895d4f98a2SYan Zheng static void update_super_roots(struct btrfs_root *root)
8905d4f98a2SYan Zheng {
8915d4f98a2SYan Zheng 	struct btrfs_root_item *root_item;
8925d4f98a2SYan Zheng 	struct btrfs_super_block *super;
8935d4f98a2SYan Zheng 
8945d4f98a2SYan Zheng 	super = &root->fs_info->super_copy;
8955d4f98a2SYan Zheng 
8965d4f98a2SYan Zheng 	root_item = &root->fs_info->chunk_root->root_item;
8975d4f98a2SYan Zheng 	super->chunk_root = root_item->bytenr;
8985d4f98a2SYan Zheng 	super->chunk_root_generation = root_item->generation;
8995d4f98a2SYan Zheng 	super->chunk_root_level = root_item->level;
9005d4f98a2SYan Zheng 
9015d4f98a2SYan Zheng 	root_item = &root->fs_info->tree_root->root_item;
9025d4f98a2SYan Zheng 	super->root = root_item->bytenr;
9035d4f98a2SYan Zheng 	super->generation = root_item->generation;
9045d4f98a2SYan Zheng 	super->root_level = root_item->level;
9055d4f98a2SYan Zheng }
9065d4f98a2SYan Zheng 
907f36f3042SChris Mason int btrfs_transaction_in_commit(struct btrfs_fs_info *info)
908f36f3042SChris Mason {
909f36f3042SChris Mason 	int ret = 0;
910f36f3042SChris Mason 	spin_lock(&info->new_trans_lock);
911f36f3042SChris Mason 	if (info->running_transaction)
912f36f3042SChris Mason 		ret = info->running_transaction->in_commit;
913f36f3042SChris Mason 	spin_unlock(&info->new_trans_lock);
914f36f3042SChris Mason 	return ret;
915f36f3042SChris Mason }
916f36f3042SChris Mason 
91779154b1bSChris Mason int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
91879154b1bSChris Mason 			     struct btrfs_root *root)
91979154b1bSChris Mason {
92015ee9bc7SJosef Bacik 	unsigned long joined = 0;
92115ee9bc7SJosef Bacik 	unsigned long timeout = 1;
92279154b1bSChris Mason 	struct btrfs_transaction *cur_trans;
9238fd17795SChris Mason 	struct btrfs_transaction *prev_trans = NULL;
92479154b1bSChris Mason 	DEFINE_WAIT(wait);
92515ee9bc7SJosef Bacik 	int ret;
92689573b9cSChris Mason 	int should_grow = 0;
92789573b9cSChris Mason 	unsigned long now = get_seconds();
928dccae999SSage Weil 	int flush_on_commit = btrfs_test_opt(root, FLUSHONCOMMIT);
92979154b1bSChris Mason 
9305a3f23d5SChris Mason 	btrfs_run_ordered_operations(root, 0);
9315a3f23d5SChris Mason 
93256bec294SChris Mason 	/* make a pass through all the delayed refs we have so far
93356bec294SChris Mason 	 * any runnings procs may add more while we are here
93456bec294SChris Mason 	 */
93556bec294SChris Mason 	ret = btrfs_run_delayed_refs(trans, root, 0);
93656bec294SChris Mason 	BUG_ON(ret);
93756bec294SChris Mason 
938b7ec40d7SChris Mason 	cur_trans = trans->transaction;
93956bec294SChris Mason 	/*
94056bec294SChris Mason 	 * set the flushing flag so procs in this transaction have to
94156bec294SChris Mason 	 * start sending their work down.
94256bec294SChris Mason 	 */
943b7ec40d7SChris Mason 	cur_trans->delayed_refs.flushing = 1;
94456bec294SChris Mason 
945c3e69d58SChris Mason 	ret = btrfs_run_delayed_refs(trans, root, 0);
94656bec294SChris Mason 	BUG_ON(ret);
94756bec294SChris Mason 
94879154b1bSChris Mason 	mutex_lock(&root->fs_info->trans_mutex);
949b7ec40d7SChris Mason 	if (cur_trans->in_commit) {
950b7ec40d7SChris Mason 		cur_trans->use_count++;
951ccd467d6SChris Mason 		mutex_unlock(&root->fs_info->trans_mutex);
95279154b1bSChris Mason 		btrfs_end_transaction(trans, root);
953ccd467d6SChris Mason 
95479154b1bSChris Mason 		ret = wait_for_commit(root, cur_trans);
95579154b1bSChris Mason 		BUG_ON(ret);
95615ee9bc7SJosef Bacik 
95715ee9bc7SJosef Bacik 		mutex_lock(&root->fs_info->trans_mutex);
95879154b1bSChris Mason 		put_transaction(cur_trans);
95915ee9bc7SJosef Bacik 		mutex_unlock(&root->fs_info->trans_mutex);
96015ee9bc7SJosef Bacik 
96179154b1bSChris Mason 		return 0;
96279154b1bSChris Mason 	}
9634313b399SChris Mason 
9642c90e5d6SChris Mason 	trans->transaction->in_commit = 1;
965f9295749SChris Mason 	trans->transaction->blocked = 1;
966ccd467d6SChris Mason 	if (cur_trans->list.prev != &root->fs_info->trans_list) {
967ccd467d6SChris Mason 		prev_trans = list_entry(cur_trans->list.prev,
968ccd467d6SChris Mason 					struct btrfs_transaction, list);
969ccd467d6SChris Mason 		if (!prev_trans->commit_done) {
970ccd467d6SChris Mason 			prev_trans->use_count++;
971ccd467d6SChris Mason 			mutex_unlock(&root->fs_info->trans_mutex);
972ccd467d6SChris Mason 
973ccd467d6SChris Mason 			wait_for_commit(root, prev_trans);
974ccd467d6SChris Mason 
975ccd467d6SChris Mason 			mutex_lock(&root->fs_info->trans_mutex);
97615ee9bc7SJosef Bacik 			put_transaction(prev_trans);
977ccd467d6SChris Mason 		}
978ccd467d6SChris Mason 	}
97915ee9bc7SJosef Bacik 
98089573b9cSChris Mason 	if (now < cur_trans->start_time || now - cur_trans->start_time < 1)
98189573b9cSChris Mason 		should_grow = 1;
98289573b9cSChris Mason 
98315ee9bc7SJosef Bacik 	do {
9847ea394f1SYan Zheng 		int snap_pending = 0;
98515ee9bc7SJosef Bacik 		joined = cur_trans->num_joined;
9867ea394f1SYan Zheng 		if (!list_empty(&trans->transaction->pending_snapshots))
9877ea394f1SYan Zheng 			snap_pending = 1;
9887ea394f1SYan Zheng 
9892c90e5d6SChris Mason 		WARN_ON(cur_trans != trans->transaction);
99015ee9bc7SJosef Bacik 		prepare_to_wait(&cur_trans->writer_wait, &wait,
99179154b1bSChris Mason 				TASK_UNINTERRUPTIBLE);
99215ee9bc7SJosef Bacik 
99315ee9bc7SJosef Bacik 		if (cur_trans->num_writers > 1)
99415ee9bc7SJosef Bacik 			timeout = MAX_SCHEDULE_TIMEOUT;
99589573b9cSChris Mason 		else if (should_grow)
99615ee9bc7SJosef Bacik 			timeout = 1;
99715ee9bc7SJosef Bacik 
99879154b1bSChris Mason 		mutex_unlock(&root->fs_info->trans_mutex);
99915ee9bc7SJosef Bacik 
1000ebecd3d9SSage Weil 		if (flush_on_commit) {
100124bbcf04SYan, Zheng 			btrfs_start_delalloc_inodes(root, 1);
100224bbcf04SYan, Zheng 			ret = btrfs_wait_ordered_extents(root, 0, 1);
1003ebecd3d9SSage Weil 			BUG_ON(ret);
1004ebecd3d9SSage Weil 		} else if (snap_pending) {
100524bbcf04SYan, Zheng 			ret = btrfs_wait_ordered_extents(root, 0, 1);
10067ea394f1SYan Zheng 			BUG_ON(ret);
10077ea394f1SYan Zheng 		}
10087ea394f1SYan Zheng 
10095a3f23d5SChris Mason 		/*
10105a3f23d5SChris Mason 		 * rename don't use btrfs_join_transaction, so, once we
10115a3f23d5SChris Mason 		 * set the transaction to blocked above, we aren't going
10125a3f23d5SChris Mason 		 * to get any new ordered operations.  We can safely run
10135a3f23d5SChris Mason 		 * it here and no for sure that nothing new will be added
10145a3f23d5SChris Mason 		 * to the list
10155a3f23d5SChris Mason 		 */
10165a3f23d5SChris Mason 		btrfs_run_ordered_operations(root, 1);
10175a3f23d5SChris Mason 
101889573b9cSChris Mason 		smp_mb();
101989573b9cSChris Mason 		if (cur_trans->num_writers > 1 || should_grow)
102015ee9bc7SJosef Bacik 			schedule_timeout(timeout);
102115ee9bc7SJosef Bacik 
102279154b1bSChris Mason 		mutex_lock(&root->fs_info->trans_mutex);
102315ee9bc7SJosef Bacik 		finish_wait(&cur_trans->writer_wait, &wait);
102415ee9bc7SJosef Bacik 	} while (cur_trans->num_writers > 1 ||
102589573b9cSChris Mason 		 (should_grow && cur_trans->num_joined != joined));
102615ee9bc7SJosef Bacik 
10273063d29fSChris Mason 	ret = create_pending_snapshots(trans, root->fs_info);
10283063d29fSChris Mason 	BUG_ON(ret);
10293063d29fSChris Mason 
103056bec294SChris Mason 	ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
103156bec294SChris Mason 	BUG_ON(ret);
103256bec294SChris Mason 
10332c90e5d6SChris Mason 	WARN_ON(cur_trans != trans->transaction);
1034dc17ff8fSChris Mason 
1035e02119d5SChris Mason 	/* btrfs_commit_tree_roots is responsible for getting the
1036e02119d5SChris Mason 	 * various roots consistent with each other.  Every pointer
1037e02119d5SChris Mason 	 * in the tree of tree roots has to point to the most up to date
1038e02119d5SChris Mason 	 * root for every subvolume and other tree.  So, we have to keep
1039e02119d5SChris Mason 	 * the tree logging code from jumping in and changing any
1040e02119d5SChris Mason 	 * of the trees.
1041e02119d5SChris Mason 	 *
1042e02119d5SChris Mason 	 * At this point in the commit, there can't be any tree-log
1043e02119d5SChris Mason 	 * writers, but a little lower down we drop the trans mutex
1044e02119d5SChris Mason 	 * and let new people in.  By holding the tree_log_mutex
1045e02119d5SChris Mason 	 * from now until after the super is written, we avoid races
1046e02119d5SChris Mason 	 * with the tree-log code.
1047e02119d5SChris Mason 	 */
1048e02119d5SChris Mason 	mutex_lock(&root->fs_info->tree_log_mutex);
10491a40e23bSZheng Yan 
10505d4f98a2SYan Zheng 	ret = commit_fs_roots(trans, root);
105154aa1f4dSChris Mason 	BUG_ON(ret);
105254aa1f4dSChris Mason 
10535d4f98a2SYan Zheng 	/* commit_fs_roots gets rid of all the tree log roots, it is now
1054e02119d5SChris Mason 	 * safe to free the root of tree log roots
1055e02119d5SChris Mason 	 */
1056e02119d5SChris Mason 	btrfs_free_log_root_tree(trans, root->fs_info);
1057e02119d5SChris Mason 
10585d4f98a2SYan Zheng 	ret = commit_cowonly_roots(trans, root);
105979154b1bSChris Mason 	BUG_ON(ret);
106054aa1f4dSChris Mason 
106111833d66SYan Zheng 	btrfs_prepare_extent_commit(trans, root);
106211833d66SYan Zheng 
106378fae27eSChris Mason 	cur_trans = root->fs_info->running_transaction;
1064cee36a03SChris Mason 	spin_lock(&root->fs_info->new_trans_lock);
106578fae27eSChris Mason 	root->fs_info->running_transaction = NULL;
1066cee36a03SChris Mason 	spin_unlock(&root->fs_info->new_trans_lock);
10675f39d397SChris Mason 
10685d4f98a2SYan Zheng 	btrfs_set_root_node(&root->fs_info->tree_root->root_item,
10695d4f98a2SYan Zheng 			    root->fs_info->tree_root->node);
1070817d52f8SJosef Bacik 	switch_commit_root(root->fs_info->tree_root);
10715d4f98a2SYan Zheng 
10725d4f98a2SYan Zheng 	btrfs_set_root_node(&root->fs_info->chunk_root->root_item,
10735d4f98a2SYan Zheng 			    root->fs_info->chunk_root->node);
1074817d52f8SJosef Bacik 	switch_commit_root(root->fs_info->chunk_root);
10755d4f98a2SYan Zheng 
10765d4f98a2SYan Zheng 	update_super_roots(root);
1077e02119d5SChris Mason 
1078e02119d5SChris Mason 	if (!root->fs_info->log_root_recovering) {
1079e02119d5SChris Mason 		btrfs_set_super_log_root(&root->fs_info->super_copy, 0);
1080e02119d5SChris Mason 		btrfs_set_super_log_root_level(&root->fs_info->super_copy, 0);
1081e02119d5SChris Mason 	}
1082e02119d5SChris Mason 
1083a061fc8dSChris Mason 	memcpy(&root->fs_info->super_for_commit, &root->fs_info->super_copy,
10844b52dff6SChris Mason 	       sizeof(root->fs_info->super_copy));
1085ccd467d6SChris Mason 
1086f9295749SChris Mason 	trans->transaction->blocked = 0;
1087b7ec40d7SChris Mason 
1088f9295749SChris Mason 	wake_up(&root->fs_info->transaction_wait);
1089e6dcd2dcSChris Mason 
109078fae27eSChris Mason 	mutex_unlock(&root->fs_info->trans_mutex);
109179154b1bSChris Mason 	ret = btrfs_write_and_wait_transaction(trans, root);
109279154b1bSChris Mason 	BUG_ON(ret);
1093a512bbf8SYan Zheng 	write_ctree_super(trans, root, 0);
10944313b399SChris Mason 
1095e02119d5SChris Mason 	/*
1096e02119d5SChris Mason 	 * the super is written, we can safely allow the tree-loggers
1097e02119d5SChris Mason 	 * to go about their business
1098e02119d5SChris Mason 	 */
1099e02119d5SChris Mason 	mutex_unlock(&root->fs_info->tree_log_mutex);
1100e02119d5SChris Mason 
110111833d66SYan Zheng 	btrfs_finish_extent_commit(trans, root);
11024313b399SChris Mason 
11033de4586cSChris Mason 	/* do the directory inserts of any pending snapshot creations */
11043de4586cSChris Mason 	finish_pending_snapshots(trans, root->fs_info);
11053de4586cSChris Mason 
11061a40e23bSZheng Yan 	mutex_lock(&root->fs_info->trans_mutex);
11071a40e23bSZheng Yan 
11082c90e5d6SChris Mason 	cur_trans->commit_done = 1;
1109b7ec40d7SChris Mason 
111015ee9bc7SJosef Bacik 	root->fs_info->last_trans_committed = cur_trans->transid;
1111817d52f8SJosef Bacik 
11122c90e5d6SChris Mason 	wake_up(&cur_trans->commit_wait);
11133de4586cSChris Mason 
111479154b1bSChris Mason 	put_transaction(cur_trans);
111578fae27eSChris Mason 	put_transaction(cur_trans);
111658176a96SJosef Bacik 
111778fae27eSChris Mason 	mutex_unlock(&root->fs_info->trans_mutex);
11183de4586cSChris Mason 
11199ed74f2dSJosef Bacik 	if (current->journal_info == trans)
11209ed74f2dSJosef Bacik 		current->journal_info = NULL;
11219ed74f2dSJosef Bacik 
11222c90e5d6SChris Mason 	kmem_cache_free(btrfs_trans_handle_cachep, trans);
112324bbcf04SYan, Zheng 
112424bbcf04SYan, Zheng 	if (current != root->fs_info->transaction_kthread)
112524bbcf04SYan, Zheng 		btrfs_run_delayed_iputs(root);
112624bbcf04SYan, Zheng 
112779154b1bSChris Mason 	return ret;
112879154b1bSChris Mason }
112979154b1bSChris Mason 
1130d352ac68SChris Mason /*
1131d352ac68SChris Mason  * interface function to delete all the snapshots we have scheduled for deletion
1132d352ac68SChris Mason  */
1133e9d0b13bSChris Mason int btrfs_clean_old_snapshots(struct btrfs_root *root)
1134e9d0b13bSChris Mason {
11355d4f98a2SYan Zheng 	LIST_HEAD(list);
11365d4f98a2SYan Zheng 	struct btrfs_fs_info *fs_info = root->fs_info;
1137e9d0b13bSChris Mason 
11385d4f98a2SYan Zheng 	mutex_lock(&fs_info->trans_mutex);
11395d4f98a2SYan Zheng 	list_splice_init(&fs_info->dead_roots, &list);
11405d4f98a2SYan Zheng 	mutex_unlock(&fs_info->trans_mutex);
11415d4f98a2SYan Zheng 
11425d4f98a2SYan Zheng 	while (!list_empty(&list)) {
11435d4f98a2SYan Zheng 		root = list_entry(list.next, struct btrfs_root, root_list);
114476dda93cSYan, Zheng 		list_del(&root->root_list);
114576dda93cSYan, Zheng 
114676dda93cSYan, Zheng 		if (btrfs_header_backref_rev(root->node) <
114776dda93cSYan, Zheng 		    BTRFS_MIXED_BACKREF_REV)
11482c47e605SYan Zheng 			btrfs_drop_snapshot(root, 0);
114976dda93cSYan, Zheng 		else
115076dda93cSYan, Zheng 			btrfs_drop_snapshot(root, 1);
1151e9d0b13bSChris Mason 	}
1152e9d0b13bSChris Mason 	return 0;
1153e9d0b13bSChris Mason }
1154