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 58 59 60 61 62 63 64

	spin_lock(&root->fs_info->trans_lock);
	if (root->fs_info->trans_no_join) {
		if (!nofail) {
			spin_unlock(&root->fs_info->trans_lock);
			return -EBUSY;
		}
	}

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

	cur_trans = kmem_cache_alloc(btrfs_transaction_cachep, GFP_NOFS);
	if (!cur_trans)
		return -ENOMEM;
	spin_lock(&root->fs_info->trans_lock);
	if (root->fs_info->running_transaction) {
		kmem_cache_free(btrfs_transaction_cachep, cur_trans);
		cur_trans = root->fs_info->running_transaction;
		atomic_inc(&cur_trans->use_count);
83
		atomic_inc(&cur_trans->num_writers);
84
		cur_trans->num_joined++;
J
Josef Bacik 已提交
85 86
		spin_unlock(&root->fs_info->trans_lock);
		return 0;
C
Chris Mason 已提交
87
	}
J
Josef Bacik 已提交
88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113
	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 已提交
114
			     root->fs_info->btree_inode->i_mapping);
J
Josef Bacik 已提交
115 116 117 118
	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);
119

C
Chris Mason 已提交
120 121 122
	return 0;
}

C
Chris Mason 已提交
123
/*
C
Chris Mason 已提交
124 125 126 127
 * 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 已提交
128
 */
C
Chris Mason 已提交
129
static int record_root_in_trans(struct btrfs_trans_handle *trans,
J
Josef Bacik 已提交
130
			       struct btrfs_root *root)
131
{
132
	if (root->ref_cows && root->last_trans < trans->transid) {
133
		WARN_ON(root == root->fs_info->extent_root);
134 135
		WARN_ON(root->commit_root != root->node);

C
Chris Mason 已提交
136 137 138 139 140 141 142 143 144 145 146 147
		/*
		 * 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 已提交
148 149 150 151 152
		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;
		}
153 154 155
		radix_tree_tag_set(&root->fs_info->fs_roots_radix,
			   (unsigned long)root->root_key.objectid,
			   BTRFS_ROOT_TRANS_TAG);
J
Josef Bacik 已提交
156
		spin_unlock(&root->fs_info->fs_roots_radix_lock);
C
Chris Mason 已提交
157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177
		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
		 */
178
		btrfs_init_reloc_root(trans, root);
C
Chris Mason 已提交
179 180
		smp_wmb();
		root->in_trans_setup = 0;
181 182 183
	}
	return 0;
}
184

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

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 已提交
208 209 210 211
/* 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 已提交
212
static void wait_current_trans(struct btrfs_root *root)
C
Chris Mason 已提交
213
{
214
	struct btrfs_transaction *cur_trans;
C
Chris Mason 已提交
215

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

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

230 231 232 233
enum btrfs_trans_type {
	TRANS_START,
	TRANS_JOIN,
	TRANS_USERSPACE,
234
	TRANS_JOIN_NOLOCK,
235 236
};

237 238
static int may_wait_transaction(struct btrfs_root *root, int type)
{
J
Josef Bacik 已提交
239 240 241 242 243 244 245 246
	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))
247
		return 1;
J
Josef Bacik 已提交
248

249 250 251
	return 0;
}

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

	if (root->fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR)
		return ERR_PTR(-EROFS);
262 263 264 265 266 267 268 269 270

	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;
	}
271 272 273 274 275 276 277

	/*
	 * 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);
278
		ret = btrfs_block_rsv_add(root,
279 280 281 282 283
					  &root->fs_info->trans_block_rsv,
					  num_bytes);
		if (ret)
			return ERR_PTR(ret);
	}
284 285 286 287
again:
	h = kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS);
	if (!h)
		return ERR_PTR(-ENOMEM);
C
Chris Mason 已提交
288

289
	if (may_wait_transaction(root, type))
C
Chris Mason 已提交
290
		wait_current_trans(root);
291

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

T
Tsutomu Itoh 已提交
298
	if (ret < 0) {
299
		kmem_cache_free(btrfs_trans_handle_cachep, h);
T
Tsutomu Itoh 已提交
300 301
		return ERR_PTR(ret);
	}
302

303 304 305 306
	cur_trans = root->fs_info->running_transaction;

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

314 315 316 317 318 319
	smp_mb();
	if (cur_trans->blocked && may_wait_transaction(root, type)) {
		btrfs_commit_transaction(h, root);
		goto again;
	}

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

325
got_it:
J
Josef Bacik 已提交
326
	btrfs_record_root_in_trans(h, root);
327 328 329

	if (!current->journal_info && type != TRANS_USERSPACE)
		current->journal_info = h;
C
Chris Mason 已提交
330 331 332
	return h;
}

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

343
struct btrfs_trans_handle *btrfs_join_transaction_nolock(struct btrfs_root *root)
344 345 346 347
{
	return start_transaction(root, 0, TRANS_JOIN_NOLOCK);
}

348
struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *root)
349
{
350
	return start_transaction(root, 0, TRANS_USERSPACE);
351 352
}

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

360 361 362 363 364 365 366 367
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 已提交
368
			goto out;
369 370

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

	wait_for_commit(root, cur_trans);

	put_transaction(cur_trans);
	ret = 0;
J
Josef Bacik 已提交
407
out:
408 409 410
	return ret;
}

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

417 418 419 420
static int should_end_transaction(struct btrfs_trans_handle *trans,
				  struct btrfs_root *root)
{
	int ret;
421 422
	ret = btrfs_block_rsv_check(root, &root->fs_info->global_block_rsv, 0,
				    5, 0);
423 424 425 426 427 428 429
	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;
430
	struct btrfs_block_rsv *rsv = trans->block_rsv;
431 432
	int updates;

J
Josef Bacik 已提交
433
	smp_mb();
434 435 436
	if (cur_trans->blocked || cur_trans->delayed_refs.flushing)
		return 1;

437 438 439 440 441 442
	/*
	 * 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;

443 444 445 446 447
	updates = trans->delayed_ref_updates;
	trans->delayed_ref_updates = 0;
	if (updates)
		btrfs_run_delayed_refs(trans, root, updates);

448 449
	trans->block_rsv = rsv;

450 451 452
	return should_end_transaction(trans, root);
}

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

460 461 462 463 464
	if (--trans->use_count) {
		trans->block_rsv = trans->orig_rsv;
		return 0;
	}

465
	btrfs_trans_release_metadata(trans, root);
466
	trans->block_rsv = NULL;
467 468 469 470 471 472
	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;
473 474 475 476 477 478 479

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

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

493
	if (lock && cur_trans->blocked && !cur_trans->in_commit) {
494 495 496 497 498 499 500
		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++;
501
			return btrfs_commit_transaction(trans, root);
502
		} else {
503
			wake_up_process(info->transaction_kthread);
504
		}
505 506 507
	}

	WARN_ON(cur_trans != info->running_transaction);
508 509
	WARN_ON(atomic_read(&cur_trans->num_writers) < 1);
	atomic_dec(&cur_trans->num_writers);
510

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

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

Y
Yan, Zheng 已提交
521 522 523
	if (throttle)
		btrfs_run_delayed_iputs(root);

C
Chris Mason 已提交
524 525 526
	return 0;
}

527 528 529
int btrfs_end_transaction(struct btrfs_trans_handle *trans,
			  struct btrfs_root *root)
{
530 531 532 533 534 535
	int ret;

	ret = __btrfs_end_transaction(trans, root, 0, 1);
	if (ret)
		return ret;
	return 0;
536 537 538 539 540
}

int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans,
				   struct btrfs_root *root)
{
541 542 543 544 545 546
	int ret;

	ret = __btrfs_end_transaction(trans, root, 1, 1);
	if (ret)
		return ret;
	return 0;
547 548 549 550 551
}

int btrfs_end_transaction_nolock(struct btrfs_trans_handle *trans,
				 struct btrfs_root *root)
{
552 553 554 555 556 557 558 559 560 561 562 563
	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);
564 565
}

C
Chris Mason 已提交
566 567 568
/*
 * 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
569
 * those extents are sent to disk but does not wait on them
C
Chris Mason 已提交
570
 */
571
int btrfs_write_marked_extents(struct btrfs_root *root,
572
			       struct extent_io_tree *dirty_pages, int mark)
C
Chris Mason 已提交
573
{
574
	int err = 0;
575
	int werr = 0;
J
Josef Bacik 已提交
576
	struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
577
	u64 start = 0;
578
	u64 end;
579

J
Josef Bacik 已提交
580 581 582 583 584 585 586 587 588
	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;
589
	}
590 591 592 593 594 595 596 597 598 599 600 601
	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,
602
			      struct extent_io_tree *dirty_pages, int mark)
603 604 605
{
	int err = 0;
	int werr = 0;
J
Josef Bacik 已提交
606
	struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
607 608
	u64 start = 0;
	u64 end;
609

J
Josef Bacik 已提交
610 611 612 613 614 615 616 617
	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;
618
	}
619 620 621
	if (err)
		werr = err;
	return werr;
C
Chris Mason 已提交
622 623
}

624 625 626 627 628 629
/*
 * 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,
630
				struct extent_io_tree *dirty_pages, int mark)
631 632 633 634
{
	int ret;
	int ret2;

635 636
	ret = btrfs_write_marked_extents(root, dirty_pages, mark);
	ret2 = btrfs_wait_marked_extents(root, dirty_pages, mark);
637 638 639
	return ret || ret2;
}

640 641 642 643 644 645 646 647 648
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,
649 650
					   &trans->transaction->dirty_pages,
					   EXTENT_DIRTY);
651 652
}

C
Chris Mason 已提交
653 654 655 656 657 658 659 660 661 662
/*
 * 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.
 */
663 664
static int update_cowonly_root(struct btrfs_trans_handle *trans,
			       struct btrfs_root *root)
C
Chris Mason 已提交
665 666
{
	int ret;
667
	u64 old_root_bytenr;
668
	u64 old_root_used;
669
	struct btrfs_root *tree_root = root->fs_info->tree_root;
C
Chris Mason 已提交
670

671
	old_root_used = btrfs_root_used(&root->root_item);
672
	btrfs_write_dirty_block_groups(trans, root);
673

C
Chris Mason 已提交
674
	while (1) {
675
		old_root_bytenr = btrfs_root_bytenr(&root->root_item);
676 677
		if (old_root_bytenr == root->node->start &&
		    old_root_used == btrfs_root_used(&root->root_item))
C
Chris Mason 已提交
678
			break;
679

680
		btrfs_set_root_node(&root->root_item, root->node);
C
Chris Mason 已提交
681
		ret = btrfs_update_root(trans, tree_root,
682 683
					&root->root_key,
					&root->root_item);
C
Chris Mason 已提交
684
		BUG_ON(ret);
685

686
		old_root_used = btrfs_root_used(&root->root_item);
687
		ret = btrfs_write_dirty_block_groups(trans, root);
688
		BUG_ON(ret);
689
	}
690 691 692 693

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

694 695 696
	return 0;
}

C
Chris Mason 已提交
697 698 699
/*
 * update all the cowonly tree roots on disk
 */
700 701
static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans,
					 struct btrfs_root *root)
702 703 704
{
	struct btrfs_fs_info *fs_info = root->fs_info;
	struct list_head *next;
705
	struct extent_buffer *eb;
706
	int ret;
707

708 709
	ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
	BUG_ON(ret);
710

711
	eb = btrfs_lock_root_node(fs_info->tree_root);
712
	btrfs_cow_block(trans, fs_info->tree_root, eb, NULL, 0, &eb);
713 714
	btrfs_tree_unlock(eb);
	free_extent_buffer(eb);
715

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

C
Chris Mason 已提交
719
	while (!list_empty(&fs_info->dirty_cowonly_roots)) {
720 721 722
		next = fs_info->dirty_cowonly_roots.next;
		list_del_init(next);
		root = list_entry(next, struct btrfs_root, dirty_list);
723

724
		update_cowonly_root(trans, root);
C
Chris Mason 已提交
725
	}
726 727 728 729 730

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

C
Chris Mason 已提交
731 732 733
	return 0;
}

C
Chris Mason 已提交
734 735 736 737 738
/*
 * 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
 */
739
int btrfs_add_dead_root(struct btrfs_root *root)
740
{
J
Josef Bacik 已提交
741
	spin_lock(&root->fs_info->trans_lock);
742
	list_add(&root->root_list, &root->fs_info->dead_roots);
J
Josef Bacik 已提交
743
	spin_unlock(&root->fs_info->trans_lock);
744 745 746
	return 0;
}

C
Chris Mason 已提交
747
/*
748
 * update all the cowonly tree roots on disk
C
Chris Mason 已提交
749
 */
750 751
static noinline int commit_fs_roots(struct btrfs_trans_handle *trans,
				    struct btrfs_root *root)
752 753
{
	struct btrfs_root *gang[8];
754
	struct btrfs_fs_info *fs_info = root->fs_info;
755 756
	int i;
	int ret;
757 758
	int err = 0;

J
Josef Bacik 已提交
759
	spin_lock(&fs_info->fs_roots_radix_lock);
C
Chris Mason 已提交
760
	while (1) {
761 762
		ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix,
						 (void **)gang, 0,
763 764 765 766 767 768
						 ARRAY_SIZE(gang),
						 BTRFS_ROOT_TRANS_TAG);
		if (ret == 0)
			break;
		for (i = 0; i < ret; i++) {
			root = gang[i];
769 770 771
			radix_tree_tag_clear(&fs_info->fs_roots_radix,
					(unsigned long)root->root_key.objectid,
					BTRFS_ROOT_TRANS_TAG);
J
Josef Bacik 已提交
772
			spin_unlock(&fs_info->fs_roots_radix_lock);
Y
Yan Zheng 已提交
773

774
			btrfs_free_log(trans, root);
775
			btrfs_update_reloc_root(trans, root);
776
			btrfs_orphan_commit_root(trans, root);
777

778 779
			btrfs_save_ino_cache(root, trans);

780
			if (root->commit_root != root->node) {
781
				mutex_lock(&root->fs_commit_mutex);
J
Josef Bacik 已提交
782
				switch_commit_root(root);
783 784 785
				btrfs_unpin_free_ino(root);
				mutex_unlock(&root->fs_commit_mutex);

786 787 788
				btrfs_set_root_node(&root->root_item,
						    root->node);
			}
789 790

			err = btrfs_update_root(trans, fs_info->tree_root,
791 792
						&root->root_key,
						&root->root_item);
J
Josef Bacik 已提交
793
			spin_lock(&fs_info->fs_roots_radix_lock);
794 795
			if (err)
				break;
796 797
		}
	}
J
Josef Bacik 已提交
798
	spin_unlock(&fs_info->fs_roots_radix_lock);
799
	return err;
800 801
}

C
Chris Mason 已提交
802 803 804 805
/*
 * defrag a given btree.  If cacheonly == 1, this won't read from the disk,
 * otherwise every leaf in the btree is read and defragged.
 */
806 807 808 809
int btrfs_defrag_root(struct btrfs_root *root, int cacheonly)
{
	struct btrfs_fs_info *info = root->fs_info;
	struct btrfs_trans_handle *trans;
810
	int ret;
811
	unsigned long nr;
812

813
	if (xchg(&root->defrag_running, 1))
814
		return 0;
815

816
	while (1) {
817 818 819 820
		trans = btrfs_start_transaction(root, 0);
		if (IS_ERR(trans))
			return PTR_ERR(trans);

821
		ret = btrfs_defrag_leaves(trans, root, cacheonly);
822

823
		nr = trans->blocks_used;
824
		btrfs_end_transaction(trans, root);
825
		btrfs_btree_balance_dirty(info->tree_root, nr);
826 827
		cond_resched();

828
		if (btrfs_fs_closing(root->fs_info) || ret != -EAGAIN)
829 830 831
			break;
	}
	root->defrag_running = 0;
832
	return ret;
833 834
}

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

L
Liu Bo 已提交
860 861
	rsv = trans->block_rsv;

862 863
	new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS);
	if (!new_root_item) {
864
		pending->error = -ENOMEM;
865 866
		goto fail;
	}
867

868
	ret = btrfs_find_free_objectid(tree_root, &objectid);
869 870
	if (ret) {
		pending->error = ret;
871
		goto fail;
872
	}
873

874
	btrfs_reloc_pre_snapshot(trans, pending, &to_reserve);
875 876

	if (to_reserve > 0) {
877
		ret = btrfs_block_rsv_add(root, &pending->block_rsv,
878
					  to_reserve);
879 880 881 882 883 884
		if (ret) {
			pending->error = ret;
			goto fail;
		}
	}

885
	key.objectid = objectid;
886 887
	key.offset = (u64)-1;
	key.type = BTRFS_ROOT_ITEM_KEY;
888

889
	trans->block_rsv = &pending->block_rsv;
890

891
	dentry = pending->dentry;
892 893
	parent = dget_parent(dentry);
	parent_inode = parent->d_inode;
894
	parent_root = BTRFS_I(parent_inode)->root;
C
Chris Mason 已提交
895
	record_root_in_trans(trans, parent_root);
896

897 898 899
	/*
	 * insert the directory item
	 */
900
	ret = btrfs_set_inode_index(parent_inode, &index);
901
	BUG_ON(ret);
902
	ret = btrfs_insert_dir_item(trans, parent_root,
903
				dentry->d_name.name, dentry->d_name.len,
904
				parent_inode, &key,
905
				BTRFS_FT_DIR, index);
906
	BUG_ON(ret);
907

908 909
	btrfs_i_size_write(parent_inode, parent_inode->i_size +
					 dentry->d_name.len * 2);
910 911 912
	ret = btrfs_update_inode(trans, parent_root, parent_inode);
	BUG_ON(ret);

913 914 915 916 917 918 919 920 921
	/*
	 * 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 已提交
922
	record_root_in_trans(trans, root);
923 924
	btrfs_set_root_last_snapshot(&root->root_item, trans->transid);
	memcpy(new_root_item, &root->root_item, sizeof(*new_root_item));
925
	btrfs_check_and_init_root_item(new_root_item);
926

L
Li Zefan 已提交
927 928 929 930 931 932 933
	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);

934 935 936 937 938 939 940 941 942
	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);
943 944 945
	/* record when the snapshot was created in key.offset */
	key.offset = trans->transid;
	ret = btrfs_insert_root(trans, tree_root, &key, new_root_item);
946 947
	btrfs_tree_unlock(tmp);
	free_extent_buffer(tmp);
948
	BUG_ON(ret);
949

950 951 952 953
	/*
	 * insert root back/forward references
	 */
	ret = btrfs_add_root_ref(trans, tree_root, objectid,
954
				 parent_root->root_key.objectid,
L
Li Zefan 已提交
955
				 btrfs_ino(parent_inode), index,
956
				 dentry->d_name.name, dentry->d_name.len);
957
	BUG_ON(ret);
958
	dput(parent);
959

960 961 962
	key.offset = (u64)-1;
	pending->snap = btrfs_read_fs_root_no_name(root->fs_info, &key);
	BUG_ON(IS_ERR(pending->snap));
963

964
	btrfs_reloc_post_snapshot(trans, pending);
965
fail:
966
	kfree(new_root_item);
L
Liu Bo 已提交
967
	trans->block_rsv = rsv;
968 969
	btrfs_block_rsv_release(root, &pending->block_rsv, (u64)-1);
	return 0;
970 971
}

C
Chris Mason 已提交
972 973 974
/*
 * create all the snapshots we've scheduled for creation
 */
975 976
static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans,
					     struct btrfs_fs_info *fs_info)
977 978 979 980 981
{
	struct btrfs_pending_snapshot *pending;
	struct list_head *head = &trans->transaction->pending_snapshots;
	int ret;

Q
Qinghuang Feng 已提交
982
	list_for_each_entry(pending, head, list) {
983 984 985 986 987 988
		ret = create_pending_snapshot(trans, fs_info, pending);
		BUG_ON(ret);
	}
	return 0;
}

989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004
static void update_super_roots(struct btrfs_root *root)
{
	struct btrfs_root_item *root_item;
	struct btrfs_super_block *super;

	super = &root->fs_info->super_copy;

	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;
1005
	if (btrfs_test_opt(root, SPACE_CACHE))
1006
		super->cache_generation = root_item->generation;
1007 1008
}

1009 1010 1011
int btrfs_transaction_in_commit(struct btrfs_fs_info *info)
{
	int ret = 0;
J
Josef Bacik 已提交
1012
	spin_lock(&info->trans_lock);
1013 1014
	if (info->running_transaction)
		ret = info->running_transaction->in_commit;
J
Josef Bacik 已提交
1015
	spin_unlock(&info->trans_lock);
1016 1017 1018
	return ret;
}

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

S
Sage Weil 已提交
1029 1030 1031 1032 1033 1034 1035
/*
 * 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 已提交
1036
	wait_event(root->fs_info->transaction_blocked_wait, trans->in_commit);
S
Sage Weil 已提交
1037 1038 1039 1040 1041 1042 1043 1044 1045
}

/*
 * 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 已提交
1046 1047
	wait_event(root->fs_info->transaction_wait,
		   trans->commit_done || (trans->in_commit && !trans->blocked));
S
Sage Weil 已提交
1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076
}

/*
 * 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 已提交
1077 1078
	if (!ac)
		return -ENOMEM;
S
Sage Weil 已提交
1079 1080 1081

	INIT_DELAYED_WORK(&ac->work, do_async_commit);
	ac->root = root;
1082
	ac->newtrans = btrfs_join_transaction(root);
1083 1084 1085 1086 1087
	if (IS_ERR(ac->newtrans)) {
		int err = PTR_ERR(ac->newtrans);
		kfree(ac);
		return err;
	}
S
Sage Weil 已提交
1088 1089 1090

	/* take transaction reference */
	cur_trans = trans->transaction;
1091
	atomic_inc(&cur_trans->use_count);
S
Sage Weil 已提交
1092 1093 1094 1095 1096 1097 1098 1099 1100 1101

	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);

1102 1103 1104 1105
	if (current->journal_info == trans)
		current->journal_info = NULL;

	put_transaction(cur_trans);
S
Sage Weil 已提交
1106 1107 1108 1109 1110 1111 1112 1113 1114 1115
	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 已提交
1116 1117 1118
int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
			     struct btrfs_root *root)
{
1119
	unsigned long joined = 0;
C
Chris Mason 已提交
1120
	struct btrfs_transaction *cur_trans;
C
Chris Mason 已提交
1121
	struct btrfs_transaction *prev_trans = NULL;
C
Chris Mason 已提交
1122
	DEFINE_WAIT(wait);
1123
	int ret;
1124 1125
	int should_grow = 0;
	unsigned long now = get_seconds();
1126
	int flush_on_commit = btrfs_test_opt(root, FLUSHONCOMMIT);
C
Chris Mason 已提交
1127

1128 1129
	btrfs_run_ordered_operations(root, 0);

1130
	btrfs_trans_release_metadata(trans, root);
1131 1132
	trans->block_rsv = NULL;

1133 1134 1135 1136 1137 1138
	/* 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);

1139
	cur_trans = trans->transaction;
1140 1141 1142 1143
	/*
	 * set the flushing flag so procs in this transaction have to
	 * start sending their work down.
	 */
1144
	cur_trans->delayed_refs.flushing = 1;
1145

1146
	ret = btrfs_run_delayed_refs(trans, root, 0);
1147 1148
	BUG_ON(ret);

J
Josef Bacik 已提交
1149
	spin_lock(&cur_trans->commit_lock);
1150
	if (cur_trans->in_commit) {
J
Josef Bacik 已提交
1151
		spin_unlock(&cur_trans->commit_lock);
1152
		atomic_inc(&cur_trans->use_count);
C
Chris Mason 已提交
1153
		btrfs_end_transaction(trans, root);
C
Chris Mason 已提交
1154

1155
		wait_for_commit(root, cur_trans);
1156

C
Chris Mason 已提交
1157
		put_transaction(cur_trans);
1158

C
Chris Mason 已提交
1159 1160
		return 0;
	}
1161

C
Chris Mason 已提交
1162
	trans->transaction->in_commit = 1;
1163
	trans->transaction->blocked = 1;
J
Josef Bacik 已提交
1164
	spin_unlock(&cur_trans->commit_lock);
S
Sage Weil 已提交
1165 1166
	wake_up(&root->fs_info->transaction_blocked_wait);

J
Josef Bacik 已提交
1167
	spin_lock(&root->fs_info->trans_lock);
C
Chris Mason 已提交
1168 1169 1170 1171
	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) {
1172
			atomic_inc(&prev_trans->use_count);
J
Josef Bacik 已提交
1173
			spin_unlock(&root->fs_info->trans_lock);
C
Chris Mason 已提交
1174 1175 1176

			wait_for_commit(root, prev_trans);

1177
			put_transaction(prev_trans);
J
Josef Bacik 已提交
1178 1179
		} else {
			spin_unlock(&root->fs_info->trans_lock);
C
Chris Mason 已提交
1180
		}
J
Josef Bacik 已提交
1181 1182
	} else {
		spin_unlock(&root->fs_info->trans_lock);
C
Chris Mason 已提交
1183
	}
1184

1185 1186 1187
	if (now < cur_trans->start_time || now - cur_trans->start_time < 1)
		should_grow = 1;

1188
	do {
1189
		int snap_pending = 0;
J
Josef Bacik 已提交
1190

1191
		joined = cur_trans->num_joined;
1192 1193 1194
		if (!list_empty(&trans->transaction->pending_snapshots))
			snap_pending = 1;

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

1197
		if (flush_on_commit || snap_pending) {
Y
Yan, Zheng 已提交
1198 1199
			btrfs_start_delalloc_inodes(root, 1);
			ret = btrfs_wait_ordered_extents(root, 0, 1);
1200
			BUG_ON(ret);
1201 1202
		}

1203 1204 1205
		ret = btrfs_run_delayed_items(trans, root);
		BUG_ON(ret);

1206 1207 1208 1209 1210 1211 1212 1213 1214
		/*
		 * 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);

1215 1216 1217
		prepare_to_wait(&cur_trans->writer_wait, &wait,
				TASK_UNINTERRUPTIBLE);

1218
		if (atomic_read(&cur_trans->num_writers) > 1)
1219 1220 1221
			schedule_timeout(MAX_SCHEDULE_TIMEOUT);
		else if (should_grow)
			schedule_timeout(1);
1222 1223

		finish_wait(&cur_trans->writer_wait, &wait);
1224
	} while (atomic_read(&cur_trans->num_writers) > 1 ||
1225
		 (should_grow && cur_trans->num_joined != joined));
1226

1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237
	/*
	 * 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 已提交
1238 1239 1240 1241 1242 1243 1244
	/*
	 * 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);

1245
	ret = btrfs_run_delayed_items(trans, root);
1246 1247
	BUG_ON(ret);

1248
	ret = create_pending_snapshots(trans, root->fs_info);
1249 1250
	BUG_ON(ret);

1251 1252 1253
	ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
	BUG_ON(ret);

1254 1255 1256 1257 1258 1259
	/*
	 * make sure none of the code above managed to slip in a
	 * delayed item
	 */
	btrfs_assert_delayed_root_empty(root);

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

A
Arne Jansen 已提交
1262
	btrfs_scrub_pause(root);
1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277
	/* 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);

1278
	ret = commit_fs_roots(trans, root);
1279 1280
	BUG_ON(ret);

1281
	/* commit_fs_roots gets rid of all the tree log roots, it is now
1282 1283 1284 1285
	 * safe to free the root of tree log roots
	 */
	btrfs_free_log_root_tree(trans, root->fs_info);

1286
	ret = commit_cowonly_roots(trans, root);
C
Chris Mason 已提交
1287
	BUG_ON(ret);
1288

1289 1290
	btrfs_prepare_extent_commit(trans, root);

C
Chris Mason 已提交
1291
	cur_trans = root->fs_info->running_transaction;
1292 1293 1294

	btrfs_set_root_node(&root->fs_info->tree_root->root_item,
			    root->fs_info->tree_root->node);
J
Josef Bacik 已提交
1295
	switch_commit_root(root->fs_info->tree_root);
1296 1297 1298

	btrfs_set_root_node(&root->fs_info->chunk_root->root_item,
			    root->fs_info->chunk_root->node);
J
Josef Bacik 已提交
1299
	switch_commit_root(root->fs_info->chunk_root);
1300 1301

	update_super_roots(root);
1302 1303 1304 1305 1306 1307

	if (!root->fs_info->log_root_recovering) {
		btrfs_set_super_log_root(&root->fs_info->super_copy, 0);
		btrfs_set_super_log_root_level(&root->fs_info->super_copy, 0);
	}

1308 1309
	memcpy(&root->fs_info->super_for_commit, &root->fs_info->super_copy,
	       sizeof(root->fs_info->super_copy));
C
Chris Mason 已提交
1310

1311
	trans->transaction->blocked = 0;
J
Josef Bacik 已提交
1312 1313 1314 1315
	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 已提交
1316
	mutex_unlock(&root->fs_info->reloc_mutex);
1317

1318
	wake_up(&root->fs_info->transaction_wait);
1319

C
Chris Mason 已提交
1320 1321
	ret = btrfs_write_and_wait_transaction(trans, root);
	BUG_ON(ret);
Y
Yan Zheng 已提交
1322
	write_ctree_super(trans, root, 0);
1323

1324 1325 1326 1327 1328 1329
	/*
	 * the super is written, we can safely allow the tree-loggers
	 * to go about their business
	 */
	mutex_unlock(&root->fs_info->tree_log_mutex);

1330
	btrfs_finish_extent_commit(trans, root);
1331

C
Chris Mason 已提交
1332
	cur_trans->commit_done = 1;
1333

1334
	root->fs_info->last_trans_committed = cur_trans->transid;
J
Josef Bacik 已提交
1335

C
Chris Mason 已提交
1336
	wake_up(&cur_trans->commit_wait);
1337

J
Josef Bacik 已提交
1338
	spin_lock(&root->fs_info->trans_lock);
1339
	list_del_init(&cur_trans->list);
J
Josef Bacik 已提交
1340 1341
	spin_unlock(&root->fs_info->trans_lock);

C
Chris Mason 已提交
1342
	put_transaction(cur_trans);
C
Chris Mason 已提交
1343
	put_transaction(cur_trans);
1344

1345 1346
	trace_btrfs_transaction_commit(root);

A
Arne Jansen 已提交
1347 1348
	btrfs_scrub_continue(root);

J
Josef Bacik 已提交
1349 1350 1351
	if (current->journal_info == trans)
		current->journal_info = NULL;

C
Chris Mason 已提交
1352
	kmem_cache_free(btrfs_trans_handle_cachep, trans);
Y
Yan, Zheng 已提交
1353 1354 1355 1356

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

C
Chris Mason 已提交
1357 1358 1359
	return ret;
}

C
Chris Mason 已提交
1360 1361 1362
/*
 * interface function to delete all the snapshots we have scheduled for deletion
 */
1363 1364
int btrfs_clean_old_snapshots(struct btrfs_root *root)
{
1365 1366 1367
	LIST_HEAD(list);
	struct btrfs_fs_info *fs_info = root->fs_info;

J
Josef Bacik 已提交
1368
	spin_lock(&fs_info->trans_lock);
1369
	list_splice_init(&fs_info->dead_roots, &list);
J
Josef Bacik 已提交
1370
	spin_unlock(&fs_info->trans_lock);
1371

1372 1373
	while (!list_empty(&list)) {
		root = list_entry(list.next, struct btrfs_root, root_list);
1374 1375
		list_del(&root->root_list);

1376 1377
		btrfs_kill_all_delayed_nodes(root);

1378 1379
		if (btrfs_header_backref_rev(root->node) <
		    BTRFS_MIXED_BACKREF_REV)
1380
			btrfs_drop_snapshot(root, NULL, 0);
1381
		else
1382
			btrfs_drop_snapshot(root, NULL, 1);
1383 1384 1385
	}
	return 0;
}