transaction.c 36.1 KB
Newer Older
C
Chris Mason 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
/*
 * Copyright (C) 2007 Oracle.  All rights reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License v2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 021110-1307, USA.
 */

C
Chris Mason 已提交
19
#include <linux/fs.h>
20
#include <linux/slab.h>
C
Chris Mason 已提交
21
#include <linux/sched.h>
22
#include <linux/writeback.h>
23
#include <linux/pagemap.h>
24
#include <linux/blkdev.h>
C
Chris Mason 已提交
25 26 27
#include "ctree.h"
#include "disk-io.h"
#include "transaction.h"
28
#include "locking.h"
29
#include "tree-log.h"
30
#include "inode-map.h"
C
Chris Mason 已提交
31

32 33
#define BTRFS_ROOT_TRANS_TAG 0

34
static noinline void put_transaction(struct btrfs_transaction *transaction)
C
Chris Mason 已提交
35
{
36 37
	WARN_ON(atomic_read(&transaction->use_count) == 0);
	if (atomic_dec_and_test(&transaction->use_count)) {
J
Josef Bacik 已提交
38
		BUG_ON(!list_empty(&transaction->list));
C
Chris Mason 已提交
39 40
		memset(transaction, 0, sizeof(*transaction));
		kmem_cache_free(btrfs_transaction_cachep, transaction);
C
Chris Mason 已提交
41
	}
C
Chris Mason 已提交
42 43
}

J
Josef Bacik 已提交
44 45 46 47 48 49
static noinline void switch_commit_root(struct btrfs_root *root)
{
	free_extent_buffer(root->commit_root);
	root->commit_root = btrfs_root_node(root);
}

C
Chris Mason 已提交
50 51 52
/*
 * either allocate a new transaction or hop into the existing one
 */
J
Josef Bacik 已提交
53
static noinline int join_transaction(struct btrfs_root *root, int nofail)
C
Chris Mason 已提交
54 55
{
	struct btrfs_transaction *cur_trans;
J
Josef Bacik 已提交
56 57

	spin_lock(&root->fs_info->trans_lock);
58
loop:
J
Josef Bacik 已提交
59 60 61 62 63 64 65
	if (root->fs_info->trans_no_join) {
		if (!nofail) {
			spin_unlock(&root->fs_info->trans_lock);
			return -EBUSY;
		}
	}

C
Chris Mason 已提交
66
	cur_trans = root->fs_info->running_transaction;
J
Josef Bacik 已提交
67 68
	if (cur_trans) {
		atomic_inc(&cur_trans->use_count);
69
		atomic_inc(&cur_trans->num_writers);
70
		cur_trans->num_joined++;
J
Josef Bacik 已提交
71 72
		spin_unlock(&root->fs_info->trans_lock);
		return 0;
C
Chris Mason 已提交
73
	}
J
Josef Bacik 已提交
74 75 76 77 78
	spin_unlock(&root->fs_info->trans_lock);

	cur_trans = kmem_cache_alloc(btrfs_transaction_cachep, GFP_NOFS);
	if (!cur_trans)
		return -ENOMEM;
79

J
Josef Bacik 已提交
80 81
	spin_lock(&root->fs_info->trans_lock);
	if (root->fs_info->running_transaction) {
82 83 84 85
		/*
		 * someone started a transaction after we unlocked.  Make sure
		 * to redo the trans_no_join checks above
		 */
J
Josef Bacik 已提交
86 87
		kmem_cache_free(btrfs_transaction_cachep, cur_trans);
		cur_trans = root->fs_info->running_transaction;
88
		goto loop;
C
Chris Mason 已提交
89
	}
90

J
Josef Bacik 已提交
91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116
	atomic_set(&cur_trans->num_writers, 1);
	cur_trans->num_joined = 0;
	init_waitqueue_head(&cur_trans->writer_wait);
	init_waitqueue_head(&cur_trans->commit_wait);
	cur_trans->in_commit = 0;
	cur_trans->blocked = 0;
	/*
	 * One for this trans handle, one so it will live on until we
	 * commit the transaction.
	 */
	atomic_set(&cur_trans->use_count, 2);
	cur_trans->commit_done = 0;
	cur_trans->start_time = get_seconds();

	cur_trans->delayed_refs.root = RB_ROOT;
	cur_trans->delayed_refs.num_entries = 0;
	cur_trans->delayed_refs.num_heads_ready = 0;
	cur_trans->delayed_refs.num_heads = 0;
	cur_trans->delayed_refs.flushing = 0;
	cur_trans->delayed_refs.run_delayed_start = 0;
	spin_lock_init(&cur_trans->commit_lock);
	spin_lock_init(&cur_trans->delayed_refs.lock);

	INIT_LIST_HEAD(&cur_trans->pending_snapshots);
	list_add_tail(&cur_trans->list, &root->fs_info->trans_list);
	extent_io_tree_init(&cur_trans->dirty_pages,
C
Chris Mason 已提交
117
			     root->fs_info->btree_inode->i_mapping);
J
Josef Bacik 已提交
118 119 120 121
	root->fs_info->generation++;
	cur_trans->transid = root->fs_info->generation;
	root->fs_info->running_transaction = cur_trans;
	spin_unlock(&root->fs_info->trans_lock);
122

C
Chris Mason 已提交
123 124 125
	return 0;
}

C
Chris Mason 已提交
126
/*
C
Chris Mason 已提交
127 128 129 130
 * this does all the record keeping required to make sure that a reference
 * counted root is properly recorded in a given transaction.  This is required
 * to make sure the old root from before we joined the transaction is deleted
 * when the transaction commits
C
Chris Mason 已提交
131
 */
C
Chris Mason 已提交
132
static int record_root_in_trans(struct btrfs_trans_handle *trans,
J
Josef Bacik 已提交
133
			       struct btrfs_root *root)
134
{
135
	if (root->ref_cows && root->last_trans < trans->transid) {
136
		WARN_ON(root == root->fs_info->extent_root);
137 138
		WARN_ON(root->commit_root != root->node);

C
Chris Mason 已提交
139 140 141 142 143 144 145 146 147 148 149 150
		/*
		 * see below for in_trans_setup usage rules
		 * we have the reloc mutex held now, so there
		 * is only one writer in this function
		 */
		root->in_trans_setup = 1;

		/* make sure readers find in_trans_setup before
		 * they find our root->last_trans update
		 */
		smp_wmb();

J
Josef Bacik 已提交
151 152 153 154 155
		spin_lock(&root->fs_info->fs_roots_radix_lock);
		if (root->last_trans == trans->transid) {
			spin_unlock(&root->fs_info->fs_roots_radix_lock);
			return 0;
		}
156 157 158
		radix_tree_tag_set(&root->fs_info->fs_roots_radix,
			   (unsigned long)root->root_key.objectid,
			   BTRFS_ROOT_TRANS_TAG);
J
Josef Bacik 已提交
159
		spin_unlock(&root->fs_info->fs_roots_radix_lock);
C
Chris Mason 已提交
160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180
		root->last_trans = trans->transid;

		/* this is pretty tricky.  We don't want to
		 * take the relocation lock in btrfs_record_root_in_trans
		 * unless we're really doing the first setup for this root in
		 * this transaction.
		 *
		 * Normally we'd use root->last_trans as a flag to decide
		 * if we want to take the expensive mutex.
		 *
		 * But, we have to set root->last_trans before we
		 * init the relocation root, otherwise, we trip over warnings
		 * in ctree.c.  The solution used here is to flag ourselves
		 * with root->in_trans_setup.  When this is 1, we're still
		 * fixing up the reloc trees and everyone must wait.
		 *
		 * When this is zero, they can trust root->last_trans and fly
		 * through btrfs_record_root_in_trans without having to take the
		 * lock.  smp_wmb() makes sure that all the writes above are
		 * done before we pop in the zero below
		 */
181
		btrfs_init_reloc_root(trans, root);
C
Chris Mason 已提交
182 183
		smp_wmb();
		root->in_trans_setup = 0;
184 185 186
	}
	return 0;
}
187

C
Chris Mason 已提交
188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210

int btrfs_record_root_in_trans(struct btrfs_trans_handle *trans,
			       struct btrfs_root *root)
{
	if (!root->ref_cows)
		return 0;

	/*
	 * see record_root_in_trans for comments about in_trans_setup usage
	 * and barriers
	 */
	smp_rmb();
	if (root->last_trans == trans->transid &&
	    !root->in_trans_setup)
		return 0;

	mutex_lock(&root->fs_info->reloc_mutex);
	record_root_in_trans(trans, root);
	mutex_unlock(&root->fs_info->reloc_mutex);

	return 0;
}

C
Chris Mason 已提交
211 212 213 214
/* wait for commit against the current transaction to become unblocked
 * when this is done, it is safe to start a new transaction, but the current
 * transaction might not be fully on disk.
 */
C
Chris Mason 已提交
215
static void wait_current_trans(struct btrfs_root *root)
C
Chris Mason 已提交
216
{
217
	struct btrfs_transaction *cur_trans;
C
Chris Mason 已提交
218

J
Josef Bacik 已提交
219
	spin_lock(&root->fs_info->trans_lock);
220
	cur_trans = root->fs_info->running_transaction;
C
Chris Mason 已提交
221
	if (cur_trans && cur_trans->blocked) {
222
		atomic_inc(&cur_trans->use_count);
J
Josef Bacik 已提交
223
		spin_unlock(&root->fs_info->trans_lock);
L
Li Zefan 已提交
224 225 226

		wait_event(root->fs_info->transaction_wait,
			   !cur_trans->blocked);
227
		put_transaction(cur_trans);
J
Josef Bacik 已提交
228 229
	} else {
		spin_unlock(&root->fs_info->trans_lock);
230
	}
C
Chris Mason 已提交
231 232
}

233 234 235 236
enum btrfs_trans_type {
	TRANS_START,
	TRANS_JOIN,
	TRANS_USERSPACE,
237
	TRANS_JOIN_NOLOCK,
238 239
};

240 241
static int may_wait_transaction(struct btrfs_root *root, int type)
{
J
Josef Bacik 已提交
242 243 244 245 246 247 248 249
	if (root->fs_info->log_root_recovering)
		return 0;

	if (type == TRANS_USERSPACE)
		return 1;

	if (type == TRANS_START &&
	    !atomic_read(&root->fs_info->open_ioctl_trans))
250
		return 1;
J
Josef Bacik 已提交
251

252 253 254
	return 0;
}

255
static struct btrfs_trans_handle *start_transaction(struct btrfs_root *root,
256
						    u64 num_items, int type)
C
Chris Mason 已提交
257
{
258 259
	struct btrfs_trans_handle *h;
	struct btrfs_transaction *cur_trans;
260
	u64 num_bytes = 0;
C
Chris Mason 已提交
261
	int ret;
L
liubo 已提交
262 263 264

	if (root->fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR)
		return ERR_PTR(-EROFS);
265 266 267 268 269 270 271 272 273

	if (current->journal_info) {
		WARN_ON(type != TRANS_JOIN && type != TRANS_JOIN_NOLOCK);
		h = current->journal_info;
		h->use_count++;
		h->orig_rsv = h->block_rsv;
		h->block_rsv = NULL;
		goto got_it;
	}
274 275 276 277 278 279 280

	/*
	 * Do the reservation before we join the transaction so we can do all
	 * the appropriate flushing if need be.
	 */
	if (num_items > 0 && root != root->fs_info->chunk_root) {
		num_bytes = btrfs_calc_trans_metadata_size(root, num_items);
281
		ret = btrfs_block_rsv_add(root,
282 283 284 285 286
					  &root->fs_info->trans_block_rsv,
					  num_bytes);
		if (ret)
			return ERR_PTR(ret);
	}
287 288 289 290
again:
	h = kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS);
	if (!h)
		return ERR_PTR(-ENOMEM);
C
Chris Mason 已提交
291

292
	if (may_wait_transaction(root, type))
C
Chris Mason 已提交
293
		wait_current_trans(root);
294

J
Josef Bacik 已提交
295 296 297 298 299 300
	do {
		ret = join_transaction(root, type == TRANS_JOIN_NOLOCK);
		if (ret == -EBUSY)
			wait_current_trans(root);
	} while (ret == -EBUSY);

T
Tsutomu Itoh 已提交
301
	if (ret < 0) {
302
		kmem_cache_free(btrfs_trans_handle_cachep, h);
T
Tsutomu Itoh 已提交
303 304
		return ERR_PTR(ret);
	}
305

306 307 308 309
	cur_trans = root->fs_info->running_transaction;

	h->transid = cur_trans->transid;
	h->transaction = cur_trans;
C
Chris Mason 已提交
310
	h->blocks_used = 0;
311
	h->bytes_reserved = 0;
312
	h->delayed_ref_updates = 0;
313
	h->use_count = 1;
314
	h->block_rsv = NULL;
315
	h->orig_rsv = NULL;
316

317 318 319 320 321 322
	smp_mb();
	if (cur_trans->blocked && may_wait_transaction(root, type)) {
		btrfs_commit_transaction(h, root);
		goto again;
	}

323 324 325
	if (num_bytes) {
		h->block_rsv = &root->fs_info->trans_block_rsv;
		h->bytes_reserved = num_bytes;
326
	}
J
Josef Bacik 已提交
327

328
got_it:
J
Josef Bacik 已提交
329
	btrfs_record_root_in_trans(h, root);
330 331 332

	if (!current->journal_info && type != TRANS_USERSPACE)
		current->journal_info = h;
C
Chris Mason 已提交
333 334 335
	return h;
}

336
struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
337
						   int num_items)
338
{
339
	return start_transaction(root, num_items, TRANS_START);
340
}
341
struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root)
342
{
343
	return start_transaction(root, 0, TRANS_JOIN);
344 345
}

346
struct btrfs_trans_handle *btrfs_join_transaction_nolock(struct btrfs_root *root)
347 348 349 350
{
	return start_transaction(root, 0, TRANS_JOIN_NOLOCK);
}

351
struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *root)
352
{
353
	return start_transaction(root, 0, TRANS_USERSPACE);
354 355
}

C
Chris Mason 已提交
356
/* wait for a transaction commit to be fully complete */
357
static noinline void wait_for_commit(struct btrfs_root *root,
358 359
				    struct btrfs_transaction *commit)
{
L
Li Zefan 已提交
360
	wait_event(commit->commit_wait, commit->commit_done);
361 362
}

363 364 365 366 367 368 369 370
int btrfs_wait_for_commit(struct btrfs_root *root, u64 transid)
{
	struct btrfs_transaction *cur_trans = NULL, *t;
	int ret;

	ret = 0;
	if (transid) {
		if (transid <= root->fs_info->last_trans_committed)
J
Josef Bacik 已提交
371
			goto out;
372 373

		/* find specified transaction */
J
Josef Bacik 已提交
374
		spin_lock(&root->fs_info->trans_lock);
375 376 377
		list_for_each_entry(t, &root->fs_info->trans_list, list) {
			if (t->transid == transid) {
				cur_trans = t;
J
Josef Bacik 已提交
378
				atomic_inc(&cur_trans->use_count);
379 380 381 382 383
				break;
			}
			if (t->transid > transid)
				break;
		}
J
Josef Bacik 已提交
384
		spin_unlock(&root->fs_info->trans_lock);
385 386
		ret = -EINVAL;
		if (!cur_trans)
J
Josef Bacik 已提交
387
			goto out;  /* bad transid */
388 389
	} else {
		/* find newest transaction that is committing | committed */
J
Josef Bacik 已提交
390
		spin_lock(&root->fs_info->trans_lock);
391 392 393 394
		list_for_each_entry_reverse(t, &root->fs_info->trans_list,
					    list) {
			if (t->in_commit) {
				if (t->commit_done)
395
					break;
396
				cur_trans = t;
J
Josef Bacik 已提交
397
				atomic_inc(&cur_trans->use_count);
398 399 400
				break;
			}
		}
J
Josef Bacik 已提交
401
		spin_unlock(&root->fs_info->trans_lock);
402
		if (!cur_trans)
J
Josef Bacik 已提交
403
			goto out;  /* nothing committing|committed */
404 405 406 407 408 409
	}

	wait_for_commit(root, cur_trans);

	put_transaction(cur_trans);
	ret = 0;
J
Josef Bacik 已提交
410
out:
411 412 413
	return ret;
}

C
Chris Mason 已提交
414 415
void btrfs_throttle(struct btrfs_root *root)
{
J
Josef Bacik 已提交
416
	if (!atomic_read(&root->fs_info->open_ioctl_trans))
417
		wait_current_trans(root);
C
Chris Mason 已提交
418 419
}

420 421 422 423
static int should_end_transaction(struct btrfs_trans_handle *trans,
				  struct btrfs_root *root)
{
	int ret;
424 425

	ret = btrfs_block_rsv_check(root, &root->fs_info->global_block_rsv, 5);
426 427 428 429 430 431 432
	return ret ? 1 : 0;
}

int btrfs_should_end_transaction(struct btrfs_trans_handle *trans,
				 struct btrfs_root *root)
{
	struct btrfs_transaction *cur_trans = trans->transaction;
433
	struct btrfs_block_rsv *rsv = trans->block_rsv;
434 435
	int updates;

J
Josef Bacik 已提交
436
	smp_mb();
437 438 439
	if (cur_trans->blocked || cur_trans->delayed_refs.flushing)
		return 1;

440 441 442 443 444 445
	/*
	 * We need to do this in case we're deleting csums so the global block
	 * rsv get's used instead of the csum block rsv.
	 */
	trans->block_rsv = NULL;

446 447 448 449 450
	updates = trans->delayed_ref_updates;
	trans->delayed_ref_updates = 0;
	if (updates)
		btrfs_run_delayed_refs(trans, root, updates);

451 452
	trans->block_rsv = rsv;

453 454 455
	return should_end_transaction(trans, root);
}

456
static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
457
			  struct btrfs_root *root, int throttle, int lock)
C
Chris Mason 已提交
458
{
459
	struct btrfs_transaction *cur_trans = trans->transaction;
460
	struct btrfs_fs_info *info = root->fs_info;
461 462
	int count = 0;

463 464 465 466 467
	if (--trans->use_count) {
		trans->block_rsv = trans->orig_rsv;
		return 0;
	}

468
	btrfs_trans_release_metadata(trans, root);
469
	trans->block_rsv = NULL;
470 471 472 473 474 475
	while (count < 4) {
		unsigned long cur = trans->delayed_ref_updates;
		trans->delayed_ref_updates = 0;
		if (cur &&
		    trans->transaction->delayed_refs.num_heads_ready > 64) {
			trans->delayed_ref_updates = 0;
476 477 478 479 480 481 482

			/*
			 * do a full flush if the transaction is trying
			 * to close
			 */
			if (trans->transaction->delayed_refs.flushing)
				cur = 0;
483 484 485 486 487
			btrfs_run_delayed_refs(trans, root, cur);
		} else {
			break;
		}
		count++;
488 489
	}

J
Josef Bacik 已提交
490 491
	if (lock && !atomic_read(&root->fs_info->open_ioctl_trans) &&
	    should_end_transaction(trans, root)) {
492
		trans->transaction->blocked = 1;
J
Josef Bacik 已提交
493 494
		smp_wmb();
	}
495

496
	if (lock && cur_trans->blocked && !cur_trans->in_commit) {
497 498 499 500 501 502 503
		if (throttle) {
			/*
			 * We may race with somebody else here so end up having
			 * to call end_transaction on ourselves again, so inc
			 * our use_count.
			 */
			trans->use_count++;
504
			return btrfs_commit_transaction(trans, root);
505
		} else {
506
			wake_up_process(info->transaction_kthread);
507
		}
508 509 510
	}

	WARN_ON(cur_trans != info->running_transaction);
511 512
	WARN_ON(atomic_read(&cur_trans->num_writers) < 1);
	atomic_dec(&cur_trans->num_writers);
513

514
	smp_mb();
C
Chris Mason 已提交
515 516 517
	if (waitqueue_active(&cur_trans->writer_wait))
		wake_up(&cur_trans->writer_wait);
	put_transaction(cur_trans);
J
Josef Bacik 已提交
518 519 520

	if (current->journal_info == trans)
		current->journal_info = NULL;
C
Chris Mason 已提交
521
	memset(trans, 0, sizeof(*trans));
C
Chris Mason 已提交
522
	kmem_cache_free(btrfs_trans_handle_cachep, trans);
523

Y
Yan, Zheng 已提交
524 525 526
	if (throttle)
		btrfs_run_delayed_iputs(root);

C
Chris Mason 已提交
527 528 529
	return 0;
}

530 531 532
int btrfs_end_transaction(struct btrfs_trans_handle *trans,
			  struct btrfs_root *root)
{
533 534 535 536 537 538
	int ret;

	ret = __btrfs_end_transaction(trans, root, 0, 1);
	if (ret)
		return ret;
	return 0;
539 540 541 542 543
}

int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans,
				   struct btrfs_root *root)
{
544 545 546 547 548 549
	int ret;

	ret = __btrfs_end_transaction(trans, root, 1, 1);
	if (ret)
		return ret;
	return 0;
550 551 552 553 554
}

int btrfs_end_transaction_nolock(struct btrfs_trans_handle *trans,
				 struct btrfs_root *root)
{
555 556 557 558 559 560 561 562 563 564 565 566
	int ret;

	ret = __btrfs_end_transaction(trans, root, 0, 0);
	if (ret)
		return ret;
	return 0;
}

int btrfs_end_transaction_dmeta(struct btrfs_trans_handle *trans,
				struct btrfs_root *root)
{
	return __btrfs_end_transaction(trans, root, 1, 1);
567 568
}

C
Chris Mason 已提交
569 570 571
/*
 * when btree blocks are allocated, they have some corresponding bits set for
 * them in one of two extent_io trees.  This is used to make sure all of
572
 * those extents are sent to disk but does not wait on them
C
Chris Mason 已提交
573
 */
574
int btrfs_write_marked_extents(struct btrfs_root *root,
575
			       struct extent_io_tree *dirty_pages, int mark)
C
Chris Mason 已提交
576
{
577
	int err = 0;
578
	int werr = 0;
J
Josef Bacik 已提交
579
	struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
580
	u64 start = 0;
581
	u64 end;
582

J
Josef Bacik 已提交
583 584 585 586 587 588 589 590 591
	while (!find_first_extent_bit(dirty_pages, start, &start, &end,
				      mark)) {
		convert_extent_bit(dirty_pages, start, end, EXTENT_NEED_WAIT, mark,
				   GFP_NOFS);
		err = filemap_fdatawrite_range(mapping, start, end);
		if (err)
			werr = err;
		cond_resched();
		start = end + 1;
592
	}
593 594 595 596 597 598 599 600 601 602 603 604
	if (err)
		werr = err;
	return werr;
}

/*
 * when btree blocks are allocated, they have some corresponding bits set for
 * them in one of two extent_io trees.  This is used to make sure all of
 * those extents are on disk for transaction or log commit.  We wait
 * on all the pages and clear them from the dirty pages state tree
 */
int btrfs_wait_marked_extents(struct btrfs_root *root,
605
			      struct extent_io_tree *dirty_pages, int mark)
606 607 608
{
	int err = 0;
	int werr = 0;
J
Josef Bacik 已提交
609
	struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
610 611
	u64 start = 0;
	u64 end;
612

J
Josef Bacik 已提交
613 614 615 616 617 618 619 620
	while (!find_first_extent_bit(dirty_pages, start, &start, &end,
				      EXTENT_NEED_WAIT)) {
		clear_extent_bits(dirty_pages, start, end, EXTENT_NEED_WAIT, GFP_NOFS);
		err = filemap_fdatawait_range(mapping, start, end);
		if (err)
			werr = err;
		cond_resched();
		start = end + 1;
621
	}
622 623 624
	if (err)
		werr = err;
	return werr;
C
Chris Mason 已提交
625 626
}

627 628 629 630 631 632
/*
 * when btree blocks are allocated, they have some corresponding bits set for
 * them in one of two extent_io trees.  This is used to make sure all of
 * those extents are on disk for transaction or log commit
 */
int btrfs_write_and_wait_marked_extents(struct btrfs_root *root,
633
				struct extent_io_tree *dirty_pages, int mark)
634 635 636 637
{
	int ret;
	int ret2;

638 639
	ret = btrfs_write_marked_extents(root, dirty_pages, mark);
	ret2 = btrfs_wait_marked_extents(root, dirty_pages, mark);
640 641 642 643 644 645

	if (ret)
		return ret;
	if (ret2)
		return ret2;
	return 0;
646 647
}

648 649 650 651 652 653 654 655 656
int btrfs_write_and_wait_transaction(struct btrfs_trans_handle *trans,
				     struct btrfs_root *root)
{
	if (!trans || !trans->transaction) {
		struct inode *btree_inode;
		btree_inode = root->fs_info->btree_inode;
		return filemap_write_and_wait(btree_inode->i_mapping);
	}
	return btrfs_write_and_wait_marked_extents(root,
657 658
					   &trans->transaction->dirty_pages,
					   EXTENT_DIRTY);
659 660
}

C
Chris Mason 已提交
661 662 663 664 665 666 667 668 669 670
/*
 * this is used to update the root pointer in the tree of tree roots.
 *
 * But, in the case of the extent allocation tree, updating the root
 * pointer may allocate blocks which may change the root of the extent
 * allocation tree.
 *
 * So, this loops and repeats and makes sure the cowonly root didn't
 * change while the root pointer was being updated in the metadata.
 */
671 672
static int update_cowonly_root(struct btrfs_trans_handle *trans,
			       struct btrfs_root *root)
C
Chris Mason 已提交
673 674
{
	int ret;
675
	u64 old_root_bytenr;
676
	u64 old_root_used;
677
	struct btrfs_root *tree_root = root->fs_info->tree_root;
C
Chris Mason 已提交
678

679
	old_root_used = btrfs_root_used(&root->root_item);
680
	btrfs_write_dirty_block_groups(trans, root);
681

C
Chris Mason 已提交
682
	while (1) {
683
		old_root_bytenr = btrfs_root_bytenr(&root->root_item);
684 685
		if (old_root_bytenr == root->node->start &&
		    old_root_used == btrfs_root_used(&root->root_item))
C
Chris Mason 已提交
686
			break;
687

688
		btrfs_set_root_node(&root->root_item, root->node);
C
Chris Mason 已提交
689
		ret = btrfs_update_root(trans, tree_root,
690 691
					&root->root_key,
					&root->root_item);
C
Chris Mason 已提交
692
		BUG_ON(ret);
693

694
		old_root_used = btrfs_root_used(&root->root_item);
695
		ret = btrfs_write_dirty_block_groups(trans, root);
696
		BUG_ON(ret);
697
	}
698 699 700 701

	if (root != root->fs_info->extent_root)
		switch_commit_root(root);

702 703 704
	return 0;
}

C
Chris Mason 已提交
705 706 707
/*
 * update all the cowonly tree roots on disk
 */
708 709
static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans,
					 struct btrfs_root *root)
710 711 712
{
	struct btrfs_fs_info *fs_info = root->fs_info;
	struct list_head *next;
713
	struct extent_buffer *eb;
714
	int ret;
715

716 717
	ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
	BUG_ON(ret);
718

719
	eb = btrfs_lock_root_node(fs_info->tree_root);
720
	btrfs_cow_block(trans, fs_info->tree_root, eb, NULL, 0, &eb);
721 722
	btrfs_tree_unlock(eb);
	free_extent_buffer(eb);
723

724 725
	ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
	BUG_ON(ret);
726

C
Chris Mason 已提交
727
	while (!list_empty(&fs_info->dirty_cowonly_roots)) {
728 729 730
		next = fs_info->dirty_cowonly_roots.next;
		list_del_init(next);
		root = list_entry(next, struct btrfs_root, dirty_list);
731

732
		update_cowonly_root(trans, root);
C
Chris Mason 已提交
733
	}
734 735 736 737 738

	down_write(&fs_info->extent_commit_sem);
	switch_commit_root(fs_info->extent_root);
	up_write(&fs_info->extent_commit_sem);

C
Chris Mason 已提交
739 740 741
	return 0;
}

C
Chris Mason 已提交
742 743 744 745 746
/*
 * dead roots are old snapshots that need to be deleted.  This allocates
 * a dirty root struct and adds it into the list of dead roots that need to
 * be deleted
 */
747
int btrfs_add_dead_root(struct btrfs_root *root)
748
{
J
Josef Bacik 已提交
749
	spin_lock(&root->fs_info->trans_lock);
750
	list_add(&root->root_list, &root->fs_info->dead_roots);
J
Josef Bacik 已提交
751
	spin_unlock(&root->fs_info->trans_lock);
752 753 754
	return 0;
}

C
Chris Mason 已提交
755
/*
756
 * update all the cowonly tree roots on disk
C
Chris Mason 已提交
757
 */
758 759
static noinline int commit_fs_roots(struct btrfs_trans_handle *trans,
				    struct btrfs_root *root)
760 761
{
	struct btrfs_root *gang[8];
762
	struct btrfs_fs_info *fs_info = root->fs_info;
763 764
	int i;
	int ret;
765 766
	int err = 0;

J
Josef Bacik 已提交
767
	spin_lock(&fs_info->fs_roots_radix_lock);
C
Chris Mason 已提交
768
	while (1) {
769 770
		ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix,
						 (void **)gang, 0,
771 772 773 774 775 776
						 ARRAY_SIZE(gang),
						 BTRFS_ROOT_TRANS_TAG);
		if (ret == 0)
			break;
		for (i = 0; i < ret; i++) {
			root = gang[i];
777 778 779
			radix_tree_tag_clear(&fs_info->fs_roots_radix,
					(unsigned long)root->root_key.objectid,
					BTRFS_ROOT_TRANS_TAG);
J
Josef Bacik 已提交
780
			spin_unlock(&fs_info->fs_roots_radix_lock);
Y
Yan Zheng 已提交
781

782
			btrfs_free_log(trans, root);
783
			btrfs_update_reloc_root(trans, root);
784
			btrfs_orphan_commit_root(trans, root);
785

786 787
			btrfs_save_ino_cache(root, trans);

788
			if (root->commit_root != root->node) {
789
				mutex_lock(&root->fs_commit_mutex);
J
Josef Bacik 已提交
790
				switch_commit_root(root);
791 792 793
				btrfs_unpin_free_ino(root);
				mutex_unlock(&root->fs_commit_mutex);

794 795 796
				btrfs_set_root_node(&root->root_item,
						    root->node);
			}
797 798

			err = btrfs_update_root(trans, fs_info->tree_root,
799 800
						&root->root_key,
						&root->root_item);
J
Josef Bacik 已提交
801
			spin_lock(&fs_info->fs_roots_radix_lock);
802 803
			if (err)
				break;
804 805
		}
	}
J
Josef Bacik 已提交
806
	spin_unlock(&fs_info->fs_roots_radix_lock);
807
	return err;
808 809
}

C
Chris Mason 已提交
810 811 812 813
/*
 * defrag a given btree.  If cacheonly == 1, this won't read from the disk,
 * otherwise every leaf in the btree is read and defragged.
 */
814 815 816 817
int btrfs_defrag_root(struct btrfs_root *root, int cacheonly)
{
	struct btrfs_fs_info *info = root->fs_info;
	struct btrfs_trans_handle *trans;
818
	int ret;
819
	unsigned long nr;
820

821
	if (xchg(&root->defrag_running, 1))
822
		return 0;
823

824
	while (1) {
825 826 827 828
		trans = btrfs_start_transaction(root, 0);
		if (IS_ERR(trans))
			return PTR_ERR(trans);

829
		ret = btrfs_defrag_leaves(trans, root, cacheonly);
830

831
		nr = trans->blocks_used;
832
		btrfs_end_transaction(trans, root);
833
		btrfs_btree_balance_dirty(info->tree_root, nr);
834 835
		cond_resched();

836
		if (btrfs_fs_closing(root->fs_info) || ret != -EAGAIN)
837 838 839
			break;
	}
	root->defrag_running = 0;
840
	return ret;
841 842
}

C
Chris Mason 已提交
843 844 845 846
/*
 * new snapshots need to be created at a very specific time in the
 * transaction commit.  This does the actual creation
 */
847
static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
848 849 850 851
				   struct btrfs_fs_info *fs_info,
				   struct btrfs_pending_snapshot *pending)
{
	struct btrfs_key key;
852
	struct btrfs_root_item *new_root_item;
853 854
	struct btrfs_root *tree_root = fs_info->tree_root;
	struct btrfs_root *root = pending->root;
855
	struct btrfs_root *parent_root;
L
Liu Bo 已提交
856
	struct btrfs_block_rsv *rsv;
857
	struct inode *parent_inode;
858
	struct dentry *parent;
859
	struct dentry *dentry;
860
	struct extent_buffer *tmp;
861
	struct extent_buffer *old;
862
	int ret;
863
	u64 to_reserve = 0;
864
	u64 index = 0;
865
	u64 objectid;
L
Li Zefan 已提交
866
	u64 root_flags;
867

L
Liu Bo 已提交
868 869
	rsv = trans->block_rsv;

870 871
	new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS);
	if (!new_root_item) {
872
		pending->error = -ENOMEM;
873 874
		goto fail;
	}
875

876
	ret = btrfs_find_free_objectid(tree_root, &objectid);
877 878
	if (ret) {
		pending->error = ret;
879
		goto fail;
880
	}
881

882
	btrfs_reloc_pre_snapshot(trans, pending, &to_reserve);
883 884

	if (to_reserve > 0) {
885
		ret = btrfs_block_rsv_add(root, &pending->block_rsv,
886
					  to_reserve);
887 888 889 890 891 892
		if (ret) {
			pending->error = ret;
			goto fail;
		}
	}

893
	key.objectid = objectid;
894 895
	key.offset = (u64)-1;
	key.type = BTRFS_ROOT_ITEM_KEY;
896

897
	trans->block_rsv = &pending->block_rsv;
898

899
	dentry = pending->dentry;
900 901
	parent = dget_parent(dentry);
	parent_inode = parent->d_inode;
902
	parent_root = BTRFS_I(parent_inode)->root;
C
Chris Mason 已提交
903
	record_root_in_trans(trans, parent_root);
904

905 906 907
	/*
	 * insert the directory item
	 */
908
	ret = btrfs_set_inode_index(parent_inode, &index);
909
	BUG_ON(ret);
910
	ret = btrfs_insert_dir_item(trans, parent_root,
911
				dentry->d_name.name, dentry->d_name.len,
912
				parent_inode, &key,
913
				BTRFS_FT_DIR, index);
914
	BUG_ON(ret);
915

916 917
	btrfs_i_size_write(parent_inode, parent_inode->i_size +
					 dentry->d_name.len * 2);
918 919 920
	ret = btrfs_update_inode(trans, parent_root, parent_inode);
	BUG_ON(ret);

921 922 923 924 925 926 927 928 929
	/*
	 * pull in the delayed directory update
	 * and the delayed inode item
	 * otherwise we corrupt the FS during
	 * snapshot
	 */
	ret = btrfs_run_delayed_items(trans, root);
	BUG_ON(ret);

C
Chris Mason 已提交
930
	record_root_in_trans(trans, root);
931 932
	btrfs_set_root_last_snapshot(&root->root_item, trans->transid);
	memcpy(new_root_item, &root->root_item, sizeof(*new_root_item));
933
	btrfs_check_and_init_root_item(new_root_item);
934

L
Li Zefan 已提交
935 936 937 938 939 940 941
	root_flags = btrfs_root_flags(new_root_item);
	if (pending->readonly)
		root_flags |= BTRFS_ROOT_SUBVOL_RDONLY;
	else
		root_flags &= ~BTRFS_ROOT_SUBVOL_RDONLY;
	btrfs_set_root_flags(new_root_item, root_flags);

942 943 944 945 946 947 948 949 950
	old = btrfs_lock_root_node(root);
	btrfs_cow_block(trans, root, old, NULL, 0, &old);
	btrfs_set_lock_blocking(old);

	btrfs_copy_root(trans, root, old, &tmp, objectid);
	btrfs_tree_unlock(old);
	free_extent_buffer(old);

	btrfs_set_root_node(new_root_item, tmp);
951 952 953
	/* record when the snapshot was created in key.offset */
	key.offset = trans->transid;
	ret = btrfs_insert_root(trans, tree_root, &key, new_root_item);
954 955
	btrfs_tree_unlock(tmp);
	free_extent_buffer(tmp);
956
	BUG_ON(ret);
957

958 959 960 961
	/*
	 * insert root back/forward references
	 */
	ret = btrfs_add_root_ref(trans, tree_root, objectid,
962
				 parent_root->root_key.objectid,
L
Li Zefan 已提交
963
				 btrfs_ino(parent_inode), index,
964
				 dentry->d_name.name, dentry->d_name.len);
965
	BUG_ON(ret);
966
	dput(parent);
967

968 969 970
	key.offset = (u64)-1;
	pending->snap = btrfs_read_fs_root_no_name(root->fs_info, &key);
	BUG_ON(IS_ERR(pending->snap));
971

972
	btrfs_reloc_post_snapshot(trans, pending);
973
fail:
974
	kfree(new_root_item);
L
Liu Bo 已提交
975
	trans->block_rsv = rsv;
976 977
	btrfs_block_rsv_release(root, &pending->block_rsv, (u64)-1);
	return 0;
978 979
}

C
Chris Mason 已提交
980 981 982
/*
 * create all the snapshots we've scheduled for creation
 */
983 984
static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans,
					     struct btrfs_fs_info *fs_info)
985 986 987 988 989
{
	struct btrfs_pending_snapshot *pending;
	struct list_head *head = &trans->transaction->pending_snapshots;
	int ret;

Q
Qinghuang Feng 已提交
990
	list_for_each_entry(pending, head, list) {
991 992 993 994 995 996
		ret = create_pending_snapshot(trans, fs_info, pending);
		BUG_ON(ret);
	}
	return 0;
}

997 998 999 1000 1001
static void update_super_roots(struct btrfs_root *root)
{
	struct btrfs_root_item *root_item;
	struct btrfs_super_block *super;

1002
	super = root->fs_info->super_copy;
1003 1004 1005 1006 1007 1008 1009 1010 1011 1012

	root_item = &root->fs_info->chunk_root->root_item;
	super->chunk_root = root_item->bytenr;
	super->chunk_root_generation = root_item->generation;
	super->chunk_root_level = root_item->level;

	root_item = &root->fs_info->tree_root->root_item;
	super->root = root_item->bytenr;
	super->generation = root_item->generation;
	super->root_level = root_item->level;
1013
	if (btrfs_test_opt(root, SPACE_CACHE))
1014
		super->cache_generation = root_item->generation;
1015 1016
}

1017 1018 1019
int btrfs_transaction_in_commit(struct btrfs_fs_info *info)
{
	int ret = 0;
J
Josef Bacik 已提交
1020
	spin_lock(&info->trans_lock);
1021 1022
	if (info->running_transaction)
		ret = info->running_transaction->in_commit;
J
Josef Bacik 已提交
1023
	spin_unlock(&info->trans_lock);
1024 1025 1026
	return ret;
}

1027 1028 1029
int btrfs_transaction_blocked(struct btrfs_fs_info *info)
{
	int ret = 0;
J
Josef Bacik 已提交
1030
	spin_lock(&info->trans_lock);
1031 1032
	if (info->running_transaction)
		ret = info->running_transaction->blocked;
J
Josef Bacik 已提交
1033
	spin_unlock(&info->trans_lock);
1034 1035 1036
	return ret;
}

S
Sage Weil 已提交
1037 1038 1039 1040 1041 1042 1043
/*
 * wait for the current transaction commit to start and block subsequent
 * transaction joins
 */
static void wait_current_trans_commit_start(struct btrfs_root *root,
					    struct btrfs_transaction *trans)
{
L
Li Zefan 已提交
1044
	wait_event(root->fs_info->transaction_blocked_wait, trans->in_commit);
S
Sage Weil 已提交
1045 1046 1047 1048 1049 1050 1051 1052 1053
}

/*
 * wait for the current transaction to start and then become unblocked.
 * caller holds ref.
 */
static void wait_current_trans_commit_start_and_unblock(struct btrfs_root *root,
					 struct btrfs_transaction *trans)
{
L
Li Zefan 已提交
1054 1055
	wait_event(root->fs_info->transaction_wait,
		   trans->commit_done || (trans->in_commit && !trans->blocked));
S
Sage Weil 已提交
1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084
}

/*
 * commit transactions asynchronously. once btrfs_commit_transaction_async
 * returns, any subsequent transaction will not be allowed to join.
 */
struct btrfs_async_commit {
	struct btrfs_trans_handle *newtrans;
	struct btrfs_root *root;
	struct delayed_work work;
};

static void do_async_commit(struct work_struct *work)
{
	struct btrfs_async_commit *ac =
		container_of(work, struct btrfs_async_commit, work.work);

	btrfs_commit_transaction(ac->newtrans, ac->root);
	kfree(ac);
}

int btrfs_commit_transaction_async(struct btrfs_trans_handle *trans,
				   struct btrfs_root *root,
				   int wait_for_unblock)
{
	struct btrfs_async_commit *ac;
	struct btrfs_transaction *cur_trans;

	ac = kmalloc(sizeof(*ac), GFP_NOFS);
T
Tsutomu Itoh 已提交
1085 1086
	if (!ac)
		return -ENOMEM;
S
Sage Weil 已提交
1087 1088 1089

	INIT_DELAYED_WORK(&ac->work, do_async_commit);
	ac->root = root;
1090
	ac->newtrans = btrfs_join_transaction(root);
1091 1092 1093 1094 1095
	if (IS_ERR(ac->newtrans)) {
		int err = PTR_ERR(ac->newtrans);
		kfree(ac);
		return err;
	}
S
Sage Weil 已提交
1096 1097 1098

	/* take transaction reference */
	cur_trans = trans->transaction;
1099
	atomic_inc(&cur_trans->use_count);
S
Sage Weil 已提交
1100 1101 1102 1103 1104 1105 1106 1107 1108 1109

	btrfs_end_transaction(trans, root);
	schedule_delayed_work(&ac->work, 0);

	/* wait for transaction to start and unblock */
	if (wait_for_unblock)
		wait_current_trans_commit_start_and_unblock(root, cur_trans);
	else
		wait_current_trans_commit_start(root, cur_trans);

1110 1111 1112 1113
	if (current->journal_info == trans)
		current->journal_info = NULL;

	put_transaction(cur_trans);
S
Sage Weil 已提交
1114 1115 1116 1117 1118 1119 1120 1121 1122 1123
	return 0;
}

/*
 * btrfs_transaction state sequence:
 *    in_commit = 0, blocked = 0  (initial)
 *    in_commit = 1, blocked = 1
 *    blocked = 0
 *    commit_done = 1
 */
C
Chris Mason 已提交
1124 1125 1126
int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
			     struct btrfs_root *root)
{
1127
	unsigned long joined = 0;
C
Chris Mason 已提交
1128
	struct btrfs_transaction *cur_trans;
C
Chris Mason 已提交
1129
	struct btrfs_transaction *prev_trans = NULL;
C
Chris Mason 已提交
1130
	DEFINE_WAIT(wait);
1131
	int ret;
1132 1133
	int should_grow = 0;
	unsigned long now = get_seconds();
1134
	int flush_on_commit = btrfs_test_opt(root, FLUSHONCOMMIT);
C
Chris Mason 已提交
1135

1136 1137
	btrfs_run_ordered_operations(root, 0);

1138
	btrfs_trans_release_metadata(trans, root);
1139 1140
	trans->block_rsv = NULL;

1141 1142 1143 1144 1145 1146
	/* make a pass through all the delayed refs we have so far
	 * any runnings procs may add more while we are here
	 */
	ret = btrfs_run_delayed_refs(trans, root, 0);
	BUG_ON(ret);

1147
	cur_trans = trans->transaction;
1148 1149 1150 1151
	/*
	 * set the flushing flag so procs in this transaction have to
	 * start sending their work down.
	 */
1152
	cur_trans->delayed_refs.flushing = 1;
1153

1154
	ret = btrfs_run_delayed_refs(trans, root, 0);
1155 1156
	BUG_ON(ret);

J
Josef Bacik 已提交
1157
	spin_lock(&cur_trans->commit_lock);
1158
	if (cur_trans->in_commit) {
J
Josef Bacik 已提交
1159
		spin_unlock(&cur_trans->commit_lock);
1160
		atomic_inc(&cur_trans->use_count);
C
Chris Mason 已提交
1161
		btrfs_end_transaction(trans, root);
C
Chris Mason 已提交
1162

1163
		wait_for_commit(root, cur_trans);
1164

C
Chris Mason 已提交
1165
		put_transaction(cur_trans);
1166

C
Chris Mason 已提交
1167 1168
		return 0;
	}
1169

C
Chris Mason 已提交
1170
	trans->transaction->in_commit = 1;
1171
	trans->transaction->blocked = 1;
J
Josef Bacik 已提交
1172
	spin_unlock(&cur_trans->commit_lock);
S
Sage Weil 已提交
1173 1174
	wake_up(&root->fs_info->transaction_blocked_wait);

J
Josef Bacik 已提交
1175
	spin_lock(&root->fs_info->trans_lock);
C
Chris Mason 已提交
1176 1177 1178 1179
	if (cur_trans->list.prev != &root->fs_info->trans_list) {
		prev_trans = list_entry(cur_trans->list.prev,
					struct btrfs_transaction, list);
		if (!prev_trans->commit_done) {
1180
			atomic_inc(&prev_trans->use_count);
J
Josef Bacik 已提交
1181
			spin_unlock(&root->fs_info->trans_lock);
C
Chris Mason 已提交
1182 1183 1184

			wait_for_commit(root, prev_trans);

1185
			put_transaction(prev_trans);
J
Josef Bacik 已提交
1186 1187
		} else {
			spin_unlock(&root->fs_info->trans_lock);
C
Chris Mason 已提交
1188
		}
J
Josef Bacik 已提交
1189 1190
	} else {
		spin_unlock(&root->fs_info->trans_lock);
C
Chris Mason 已提交
1191
	}
1192

1193 1194 1195
	if (now < cur_trans->start_time || now - cur_trans->start_time < 1)
		should_grow = 1;

1196
	do {
1197
		int snap_pending = 0;
J
Josef Bacik 已提交
1198

1199
		joined = cur_trans->num_joined;
1200 1201 1202
		if (!list_empty(&trans->transaction->pending_snapshots))
			snap_pending = 1;

C
Chris Mason 已提交
1203
		WARN_ON(cur_trans != trans->transaction);
1204

1205
		if (flush_on_commit || snap_pending) {
Y
Yan, Zheng 已提交
1206 1207
			btrfs_start_delalloc_inodes(root, 1);
			ret = btrfs_wait_ordered_extents(root, 0, 1);
1208
			BUG_ON(ret);
1209 1210
		}

1211 1212 1213
		ret = btrfs_run_delayed_items(trans, root);
		BUG_ON(ret);

1214 1215 1216 1217 1218 1219 1220 1221 1222
		/*
		 * rename don't use btrfs_join_transaction, so, once we
		 * set the transaction to blocked above, we aren't going
		 * to get any new ordered operations.  We can safely run
		 * it here and no for sure that nothing new will be added
		 * to the list
		 */
		btrfs_run_ordered_operations(root, 1);

1223 1224 1225
		prepare_to_wait(&cur_trans->writer_wait, &wait,
				TASK_UNINTERRUPTIBLE);

1226
		if (atomic_read(&cur_trans->num_writers) > 1)
1227 1228 1229
			schedule_timeout(MAX_SCHEDULE_TIMEOUT);
		else if (should_grow)
			schedule_timeout(1);
1230 1231

		finish_wait(&cur_trans->writer_wait, &wait);
1232
	} while (atomic_read(&cur_trans->num_writers) > 1 ||
1233
		 (should_grow && cur_trans->num_joined != joined));
1234

1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245
	/*
	 * Ok now we need to make sure to block out any other joins while we
	 * commit the transaction.  We could have started a join before setting
	 * no_join so make sure to wait for num_writers to == 1 again.
	 */
	spin_lock(&root->fs_info->trans_lock);
	root->fs_info->trans_no_join = 1;
	spin_unlock(&root->fs_info->trans_lock);
	wait_event(cur_trans->writer_wait,
		   atomic_read(&cur_trans->num_writers) == 1);

C
Chris Mason 已提交
1246 1247 1248 1249 1250 1251 1252
	/*
	 * the reloc mutex makes sure that we stop
	 * the balancing code from coming in and moving
	 * extents around in the middle of the commit
	 */
	mutex_lock(&root->fs_info->reloc_mutex);

1253
	ret = btrfs_run_delayed_items(trans, root);
1254 1255
	BUG_ON(ret);

1256
	ret = create_pending_snapshots(trans, root->fs_info);
1257 1258
	BUG_ON(ret);

1259 1260 1261
	ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
	BUG_ON(ret);

1262 1263 1264 1265 1266 1267
	/*
	 * make sure none of the code above managed to slip in a
	 * delayed item
	 */
	btrfs_assert_delayed_root_empty(root);

C
Chris Mason 已提交
1268
	WARN_ON(cur_trans != trans->transaction);
C
Chris Mason 已提交
1269

A
Arne Jansen 已提交
1270
	btrfs_scrub_pause(root);
1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285
	/* btrfs_commit_tree_roots is responsible for getting the
	 * various roots consistent with each other.  Every pointer
	 * in the tree of tree roots has to point to the most up to date
	 * root for every subvolume and other tree.  So, we have to keep
	 * the tree logging code from jumping in and changing any
	 * of the trees.
	 *
	 * At this point in the commit, there can't be any tree-log
	 * writers, but a little lower down we drop the trans mutex
	 * and let new people in.  By holding the tree_log_mutex
	 * from now until after the super is written, we avoid races
	 * with the tree-log code.
	 */
	mutex_lock(&root->fs_info->tree_log_mutex);

1286
	ret = commit_fs_roots(trans, root);
1287 1288
	BUG_ON(ret);

1289
	/* commit_fs_roots gets rid of all the tree log roots, it is now
1290 1291 1292 1293
	 * safe to free the root of tree log roots
	 */
	btrfs_free_log_root_tree(trans, root->fs_info);

1294
	ret = commit_cowonly_roots(trans, root);
C
Chris Mason 已提交
1295
	BUG_ON(ret);
1296

1297 1298
	btrfs_prepare_extent_commit(trans, root);

C
Chris Mason 已提交
1299
	cur_trans = root->fs_info->running_transaction;
1300 1301 1302

	btrfs_set_root_node(&root->fs_info->tree_root->root_item,
			    root->fs_info->tree_root->node);
J
Josef Bacik 已提交
1303
	switch_commit_root(root->fs_info->tree_root);
1304 1305 1306

	btrfs_set_root_node(&root->fs_info->chunk_root->root_item,
			    root->fs_info->chunk_root->node);
J
Josef Bacik 已提交
1307
	switch_commit_root(root->fs_info->chunk_root);
1308 1309

	update_super_roots(root);
1310 1311

	if (!root->fs_info->log_root_recovering) {
1312 1313
		btrfs_set_super_log_root(root->fs_info->super_copy, 0);
		btrfs_set_super_log_root_level(root->fs_info->super_copy, 0);
1314 1315
	}

1316 1317
	memcpy(root->fs_info->super_for_commit, root->fs_info->super_copy,
	       sizeof(*root->fs_info->super_copy));
C
Chris Mason 已提交
1318

1319
	trans->transaction->blocked = 0;
J
Josef Bacik 已提交
1320 1321 1322 1323
	spin_lock(&root->fs_info->trans_lock);
	root->fs_info->running_transaction = NULL;
	root->fs_info->trans_no_join = 0;
	spin_unlock(&root->fs_info->trans_lock);
C
Chris Mason 已提交
1324
	mutex_unlock(&root->fs_info->reloc_mutex);
1325

1326
	wake_up(&root->fs_info->transaction_wait);
1327

C
Chris Mason 已提交
1328 1329
	ret = btrfs_write_and_wait_transaction(trans, root);
	BUG_ON(ret);
Y
Yan Zheng 已提交
1330
	write_ctree_super(trans, root, 0);
1331

1332 1333 1334 1335 1336 1337
	/*
	 * the super is written, we can safely allow the tree-loggers
	 * to go about their business
	 */
	mutex_unlock(&root->fs_info->tree_log_mutex);

1338
	btrfs_finish_extent_commit(trans, root);
1339

C
Chris Mason 已提交
1340
	cur_trans->commit_done = 1;
1341

1342
	root->fs_info->last_trans_committed = cur_trans->transid;
J
Josef Bacik 已提交
1343

C
Chris Mason 已提交
1344
	wake_up(&cur_trans->commit_wait);
1345

J
Josef Bacik 已提交
1346
	spin_lock(&root->fs_info->trans_lock);
1347
	list_del_init(&cur_trans->list);
J
Josef Bacik 已提交
1348 1349
	spin_unlock(&root->fs_info->trans_lock);

C
Chris Mason 已提交
1350
	put_transaction(cur_trans);
C
Chris Mason 已提交
1351
	put_transaction(cur_trans);
1352

1353 1354
	trace_btrfs_transaction_commit(root);

A
Arne Jansen 已提交
1355 1356
	btrfs_scrub_continue(root);

J
Josef Bacik 已提交
1357 1358 1359
	if (current->journal_info == trans)
		current->journal_info = NULL;

C
Chris Mason 已提交
1360
	kmem_cache_free(btrfs_trans_handle_cachep, trans);
Y
Yan, Zheng 已提交
1361 1362 1363 1364

	if (current != root->fs_info->transaction_kthread)
		btrfs_run_delayed_iputs(root);

C
Chris Mason 已提交
1365 1366 1367
	return ret;
}

C
Chris Mason 已提交
1368 1369 1370
/*
 * interface function to delete all the snapshots we have scheduled for deletion
 */
1371 1372
int btrfs_clean_old_snapshots(struct btrfs_root *root)
{
1373 1374 1375
	LIST_HEAD(list);
	struct btrfs_fs_info *fs_info = root->fs_info;

J
Josef Bacik 已提交
1376
	spin_lock(&fs_info->trans_lock);
1377
	list_splice_init(&fs_info->dead_roots, &list);
J
Josef Bacik 已提交
1378
	spin_unlock(&fs_info->trans_lock);
1379

1380 1381
	while (!list_empty(&list)) {
		root = list_entry(list.next, struct btrfs_root, root_list);
1382 1383
		list_del(&root->root_list);

1384 1385
		btrfs_kill_all_delayed_nodes(root);

1386 1387
		if (btrfs_header_backref_rev(root->node) <
		    BTRFS_MIXED_BACKREF_REV)
1388
			btrfs_drop_snapshot(root, NULL, 0);
1389
		else
1390
			btrfs_drop_snapshot(root, NULL, 1);
1391 1392 1393
	}
	return 0;
}