transaction.c 37.5 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
		DEFINE_WAIT(wait);
220
		atomic_inc(&cur_trans->use_count);
J
Josef Bacik 已提交
221
		spin_unlock(&root->fs_info->trans_lock);
C
Chris Mason 已提交
222
		while (1) {
223 224
			prepare_to_wait(&root->fs_info->transaction_wait, &wait,
					TASK_UNINTERRUPTIBLE);
225
			if (!cur_trans->blocked)
226
				break;
227
			schedule();
228
		}
229
		finish_wait(&root->fs_info->transaction_wait, &wait);
230
		put_transaction(cur_trans);
J
Josef Bacik 已提交
231 232
	} else {
		spin_unlock(&root->fs_info->trans_lock);
233
	}
C
Chris Mason 已提交
234 235
}

236 237 238 239
enum btrfs_trans_type {
	TRANS_START,
	TRANS_JOIN,
	TRANS_USERSPACE,
240
	TRANS_JOIN_NOLOCK,
241 242
};

243 244
static int may_wait_transaction(struct btrfs_root *root, int type)
{
J
Josef Bacik 已提交
245 246 247 248 249 250 251 252
	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))
253
		return 1;
J
Josef Bacik 已提交
254

255 256 257
	return 0;
}

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

	if (root->fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR)
		return ERR_PTR(-EROFS);
268 269 270 271 272 273 274 275 276

	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;
	}
277 278 279 280
again:
	h = kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS);
	if (!h)
		return ERR_PTR(-ENOMEM);
C
Chris Mason 已提交
281

282
	if (may_wait_transaction(root, type))
C
Chris Mason 已提交
283
		wait_current_trans(root);
284

J
Josef Bacik 已提交
285 286 287 288 289 290
	do {
		ret = join_transaction(root, type == TRANS_JOIN_NOLOCK);
		if (ret == -EBUSY)
			wait_current_trans(root);
	} while (ret == -EBUSY);

T
Tsutomu Itoh 已提交
291
	if (ret < 0) {
292
		kmem_cache_free(btrfs_trans_handle_cachep, h);
T
Tsutomu Itoh 已提交
293 294
		return ERR_PTR(ret);
	}
295

296 297 298 299
	cur_trans = root->fs_info->running_transaction;

	h->transid = cur_trans->transid;
	h->transaction = cur_trans;
C
Chris Mason 已提交
300
	h->blocks_used = 0;
301
	h->bytes_reserved = 0;
302
	h->delayed_ref_updates = 0;
303
	h->use_count = 1;
304
	h->block_rsv = NULL;
305
	h->orig_rsv = NULL;
306

307 308 309 310 311 312 313
	smp_mb();
	if (cur_trans->blocked && may_wait_transaction(root, type)) {
		btrfs_commit_transaction(h, root);
		goto again;
	}

	if (num_items > 0) {
314
		ret = btrfs_trans_reserve_metadata(h, root, num_items);
315 316
		if (ret == -EAGAIN && !retries) {
			retries++;
317 318
			btrfs_commit_transaction(h, root);
			goto again;
319 320 321 322 323 324
		} else if (ret == -EAGAIN) {
			/*
			 * We have already retried and got EAGAIN, so really we
			 * don't have space, so set ret to -ENOSPC.
			 */
			ret = -ENOSPC;
325
		}
326

327 328 329 330 331
		if (ret < 0) {
			btrfs_end_transaction(h, root);
			return ERR_PTR(ret);
		}
	}
J
Josef Bacik 已提交
332

333
got_it:
J
Josef Bacik 已提交
334
	btrfs_record_root_in_trans(h, root);
335 336 337

	if (!current->journal_info && type != TRANS_USERSPACE)
		current->journal_info = h;
C
Chris Mason 已提交
338 339 340
	return h;
}

341
struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
342
						   int num_items)
343
{
344
	return start_transaction(root, num_items, TRANS_START);
345
}
346
struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root)
347
{
348
	return start_transaction(root, 0, TRANS_JOIN);
349 350
}

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

356
struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *root)
357
{
358
	return start_transaction(root, 0, TRANS_USERSPACE);
359 360
}

C
Chris Mason 已提交
361
/* wait for a transaction commit to be fully complete */
362 363 364 365
static noinline int wait_for_commit(struct btrfs_root *root,
				    struct btrfs_transaction *commit)
{
	DEFINE_WAIT(wait);
C
Chris Mason 已提交
366
	while (!commit->commit_done) {
367 368 369 370 371 372 373 374 375 376
		prepare_to_wait(&commit->commit_wait, &wait,
				TASK_UNINTERRUPTIBLE);
		if (commit->commit_done)
			break;
		schedule();
	}
	finish_wait(&commit->commit_wait, &wait);
	return 0;
}

377 378 379 380 381 382 383 384
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 已提交
385
			goto out;
386 387

		/* find specified transaction */
J
Josef Bacik 已提交
388
		spin_lock(&root->fs_info->trans_lock);
389 390 391
		list_for_each_entry(t, &root->fs_info->trans_list, list) {
			if (t->transid == transid) {
				cur_trans = t;
J
Josef Bacik 已提交
392
				atomic_inc(&cur_trans->use_count);
393 394 395 396 397
				break;
			}
			if (t->transid > transid)
				break;
		}
J
Josef Bacik 已提交
398
		spin_unlock(&root->fs_info->trans_lock);
399 400
		ret = -EINVAL;
		if (!cur_trans)
J
Josef Bacik 已提交
401
			goto out;  /* bad transid */
402 403
	} else {
		/* find newest transaction that is committing | committed */
J
Josef Bacik 已提交
404
		spin_lock(&root->fs_info->trans_lock);
405 406 407 408
		list_for_each_entry_reverse(t, &root->fs_info->trans_list,
					    list) {
			if (t->in_commit) {
				if (t->commit_done)
409
					break;
410
				cur_trans = t;
J
Josef Bacik 已提交
411
				atomic_inc(&cur_trans->use_count);
412 413 414
				break;
			}
		}
J
Josef Bacik 已提交
415
		spin_unlock(&root->fs_info->trans_lock);
416
		if (!cur_trans)
J
Josef Bacik 已提交
417
			goto out;  /* nothing committing|committed */
418 419 420 421 422 423
	}

	wait_for_commit(root, cur_trans);

	put_transaction(cur_trans);
	ret = 0;
J
Josef Bacik 已提交
424
out:
425 426 427
	return ret;
}

C
Chris Mason 已提交
428 429
void btrfs_throttle(struct btrfs_root *root)
{
J
Josef Bacik 已提交
430
	if (!atomic_read(&root->fs_info->open_ioctl_trans))
431
		wait_current_trans(root);
C
Chris Mason 已提交
432 433
}

434 435 436 437 438 439 440 441 442 443 444 445 446 447 448
static int should_end_transaction(struct btrfs_trans_handle *trans,
				  struct btrfs_root *root)
{
	int ret;
	ret = btrfs_block_rsv_check(trans, root,
				    &root->fs_info->global_block_rsv, 0, 5);
	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;
	int updates;

J
Josef Bacik 已提交
449
	smp_mb();
450 451 452 453 454 455 456 457 458 459 460
	if (cur_trans->blocked || cur_trans->delayed_refs.flushing)
		return 1;

	updates = trans->delayed_ref_updates;
	trans->delayed_ref_updates = 0;
	if (updates)
		btrfs_run_delayed_refs(trans, root, updates);

	return should_end_transaction(trans, root);
}

461
static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
462
			  struct btrfs_root *root, int throttle, int lock)
C
Chris Mason 已提交
463
{
464
	struct btrfs_transaction *cur_trans = trans->transaction;
465
	struct btrfs_fs_info *info = root->fs_info;
466 467
	int count = 0;

468 469 470 471 472
	if (--trans->use_count) {
		trans->block_rsv = trans->orig_rsv;
		return 0;
	}

473 474 475 476 477 478
	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;
479 480 481 482 483 484 485

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

493 494
	btrfs_trans_release_metadata(trans, root);

J
Josef Bacik 已提交
495 496
	if (lock && !atomic_read(&root->fs_info->open_ioctl_trans) &&
	    should_end_transaction(trans, root)) {
497
		trans->transaction->blocked = 1;
J
Josef Bacik 已提交
498 499
		smp_wmb();
	}
500

501
	if (lock && cur_trans->blocked && !cur_trans->in_commit) {
502 503 504 505 506 507 508
		if (throttle)
			return btrfs_commit_transaction(trans, root);
		else
			wake_up_process(info->transaction_kthread);
	}

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

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

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

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

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

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

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

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

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

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

C
Chris Mason 已提交
567 568 569
/*
 * 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
570
 * those extents are sent to disk but does not wait on them
C
Chris Mason 已提交
571
 */
572
int btrfs_write_marked_extents(struct btrfs_root *root,
573
			       struct extent_io_tree *dirty_pages, int mark)
C
Chris Mason 已提交
574
{
575
	int ret;
576
	int err = 0;
577 578 579
	int werr = 0;
	struct page *page;
	struct inode *btree_inode = root->fs_info->btree_inode;
580
	u64 start = 0;
581 582
	u64 end;
	unsigned long index;
583

C
Chris Mason 已提交
584
	while (1) {
585
		ret = find_first_extent_bit(dirty_pages, start, &start, &end,
586
					    mark);
587
		if (ret)
588
			break;
C
Chris Mason 已提交
589
		while (start <= end) {
590 591
			cond_resched();

592
			index = start >> PAGE_CACHE_SHIFT;
593
			start = (u64)(index + 1) << PAGE_CACHE_SHIFT;
C
Chris Mason 已提交
594
			page = find_get_page(btree_inode->i_mapping, index);
595 596
			if (!page)
				continue;
C
Chris Mason 已提交
597 598 599 600 601 602 603 604

			btree_lock_page_hook(page);
			if (!page->mapping) {
				unlock_page(page);
				page_cache_release(page);
				continue;
			}

605 606 607 608 609 610 611 612 613
			if (PageWriteback(page)) {
				if (PageDirty(page))
					wait_on_page_writeback(page);
				else {
					unlock_page(page);
					page_cache_release(page);
					continue;
				}
			}
614 615 616 617 618 619
			err = write_one_page(page, 0);
			if (err)
				werr = err;
			page_cache_release(page);
		}
	}
620 621 622 623 624 625 626 627 628 629 630 631
	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,
632
			      struct extent_io_tree *dirty_pages, int mark)
633 634 635 636 637 638 639 640 641 642
{
	int ret;
	int err = 0;
	int werr = 0;
	struct page *page;
	struct inode *btree_inode = root->fs_info->btree_inode;
	u64 start = 0;
	u64 end;
	unsigned long index;

C
Chris Mason 已提交
643
	while (1) {
644 645
		ret = find_first_extent_bit(dirty_pages, start, &start, &end,
					    mark);
646 647 648
		if (ret)
			break;

649
		clear_extent_bits(dirty_pages, start, end, mark, GFP_NOFS);
C
Chris Mason 已提交
650
		while (start <= end) {
651 652 653 654 655 656
			index = start >> PAGE_CACHE_SHIFT;
			start = (u64)(index + 1) << PAGE_CACHE_SHIFT;
			page = find_get_page(btree_inode->i_mapping, index);
			if (!page)
				continue;
			if (PageDirty(page)) {
C
Chris Mason 已提交
657 658
				btree_lock_page_hook(page);
				wait_on_page_writeback(page);
659 660 661 662
				err = write_one_page(page, 0);
				if (err)
					werr = err;
			}
663
			wait_on_page_writeback(page);
664 665 666 667
			page_cache_release(page);
			cond_resched();
		}
	}
668 669 670
	if (err)
		werr = err;
	return werr;
C
Chris Mason 已提交
671 672
}

673 674 675 676 677 678
/*
 * 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,
679
				struct extent_io_tree *dirty_pages, int mark)
680 681 682 683
{
	int ret;
	int ret2;

684 685
	ret = btrfs_write_marked_extents(root, dirty_pages, mark);
	ret2 = btrfs_wait_marked_extents(root, dirty_pages, mark);
686 687 688
	return ret || ret2;
}

689 690 691 692 693 694 695 696 697
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,
698 699
					   &trans->transaction->dirty_pages,
					   EXTENT_DIRTY);
700 701
}

C
Chris Mason 已提交
702 703 704 705 706 707 708 709 710 711
/*
 * 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.
 */
712 713
static int update_cowonly_root(struct btrfs_trans_handle *trans,
			       struct btrfs_root *root)
C
Chris Mason 已提交
714 715
{
	int ret;
716
	u64 old_root_bytenr;
717
	u64 old_root_used;
718
	struct btrfs_root *tree_root = root->fs_info->tree_root;
C
Chris Mason 已提交
719

720
	old_root_used = btrfs_root_used(&root->root_item);
721
	btrfs_write_dirty_block_groups(trans, root);
722

C
Chris Mason 已提交
723
	while (1) {
724
		old_root_bytenr = btrfs_root_bytenr(&root->root_item);
725 726
		if (old_root_bytenr == root->node->start &&
		    old_root_used == btrfs_root_used(&root->root_item))
C
Chris Mason 已提交
727
			break;
728

729
		btrfs_set_root_node(&root->root_item, root->node);
C
Chris Mason 已提交
730
		ret = btrfs_update_root(trans, tree_root,
731 732
					&root->root_key,
					&root->root_item);
C
Chris Mason 已提交
733
		BUG_ON(ret);
734

735
		old_root_used = btrfs_root_used(&root->root_item);
736
		ret = btrfs_write_dirty_block_groups(trans, root);
737
		BUG_ON(ret);
738
	}
739 740 741 742

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

743 744 745
	return 0;
}

C
Chris Mason 已提交
746 747 748
/*
 * update all the cowonly tree roots on disk
 */
749 750
static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans,
					 struct btrfs_root *root)
751 752 753
{
	struct btrfs_fs_info *fs_info = root->fs_info;
	struct list_head *next;
754
	struct extent_buffer *eb;
755
	int ret;
756

757 758
	ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
	BUG_ON(ret);
759

760
	eb = btrfs_lock_root_node(fs_info->tree_root);
761
	btrfs_cow_block(trans, fs_info->tree_root, eb, NULL, 0, &eb);
762 763
	btrfs_tree_unlock(eb);
	free_extent_buffer(eb);
764

765 766
	ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
	BUG_ON(ret);
767

C
Chris Mason 已提交
768
	while (!list_empty(&fs_info->dirty_cowonly_roots)) {
769 770 771
		next = fs_info->dirty_cowonly_roots.next;
		list_del_init(next);
		root = list_entry(next, struct btrfs_root, dirty_list);
772

773
		update_cowonly_root(trans, root);
C
Chris Mason 已提交
774
	}
775 776 777 778 779

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

C
Chris Mason 已提交
780 781 782
	return 0;
}

C
Chris Mason 已提交
783 784 785 786 787
/*
 * 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
 */
788
int btrfs_add_dead_root(struct btrfs_root *root)
789
{
J
Josef Bacik 已提交
790
	spin_lock(&root->fs_info->trans_lock);
791
	list_add(&root->root_list, &root->fs_info->dead_roots);
J
Josef Bacik 已提交
792
	spin_unlock(&root->fs_info->trans_lock);
793 794 795
	return 0;
}

C
Chris Mason 已提交
796
/*
797
 * update all the cowonly tree roots on disk
C
Chris Mason 已提交
798
 */
799 800
static noinline int commit_fs_roots(struct btrfs_trans_handle *trans,
				    struct btrfs_root *root)
801 802
{
	struct btrfs_root *gang[8];
803
	struct btrfs_fs_info *fs_info = root->fs_info;
804 805
	int i;
	int ret;
806 807
	int err = 0;

J
Josef Bacik 已提交
808
	spin_lock(&fs_info->fs_roots_radix_lock);
C
Chris Mason 已提交
809
	while (1) {
810 811
		ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix,
						 (void **)gang, 0,
812 813 814 815 816 817
						 ARRAY_SIZE(gang),
						 BTRFS_ROOT_TRANS_TAG);
		if (ret == 0)
			break;
		for (i = 0; i < ret; i++) {
			root = gang[i];
818 819 820
			radix_tree_tag_clear(&fs_info->fs_roots_radix,
					(unsigned long)root->root_key.objectid,
					BTRFS_ROOT_TRANS_TAG);
J
Josef Bacik 已提交
821
			spin_unlock(&fs_info->fs_roots_radix_lock);
Y
Yan Zheng 已提交
822

823
			btrfs_free_log(trans, root);
824
			btrfs_update_reloc_root(trans, root);
825
			btrfs_orphan_commit_root(trans, root);
826

827 828
			btrfs_save_ino_cache(root, trans);

829
			if (root->commit_root != root->node) {
830
				mutex_lock(&root->fs_commit_mutex);
J
Josef Bacik 已提交
831
				switch_commit_root(root);
832 833 834
				btrfs_unpin_free_ino(root);
				mutex_unlock(&root->fs_commit_mutex);

835 836 837
				btrfs_set_root_node(&root->root_item,
						    root->node);
			}
838 839

			err = btrfs_update_root(trans, fs_info->tree_root,
840 841
						&root->root_key,
						&root->root_item);
J
Josef Bacik 已提交
842
			spin_lock(&fs_info->fs_roots_radix_lock);
843 844
			if (err)
				break;
845 846
		}
	}
J
Josef Bacik 已提交
847
	spin_unlock(&fs_info->fs_roots_radix_lock);
848
	return err;
849 850
}

C
Chris Mason 已提交
851 852 853 854
/*
 * defrag a given btree.  If cacheonly == 1, this won't read from the disk,
 * otherwise every leaf in the btree is read and defragged.
 */
855 856 857 858
int btrfs_defrag_root(struct btrfs_root *root, int cacheonly)
{
	struct btrfs_fs_info *info = root->fs_info;
	struct btrfs_trans_handle *trans;
859
	int ret;
860
	unsigned long nr;
861

862
	if (xchg(&root->defrag_running, 1))
863
		return 0;
864

865
	while (1) {
866 867 868 869
		trans = btrfs_start_transaction(root, 0);
		if (IS_ERR(trans))
			return PTR_ERR(trans);

870
		ret = btrfs_defrag_leaves(trans, root, cacheonly);
871

872
		nr = trans->blocks_used;
873
		btrfs_end_transaction(trans, root);
874
		btrfs_btree_balance_dirty(info->tree_root, nr);
875 876
		cond_resched();

877
		if (btrfs_fs_closing(root->fs_info) || ret != -EAGAIN)
878 879 880
			break;
	}
	root->defrag_running = 0;
881
	return ret;
882 883
}

C
Chris Mason 已提交
884 885 886 887
/*
 * new snapshots need to be created at a very specific time in the
 * transaction commit.  This does the actual creation
 */
888
static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
889 890 891 892
				   struct btrfs_fs_info *fs_info,
				   struct btrfs_pending_snapshot *pending)
{
	struct btrfs_key key;
893
	struct btrfs_root_item *new_root_item;
894 895
	struct btrfs_root *tree_root = fs_info->tree_root;
	struct btrfs_root *root = pending->root;
896 897
	struct btrfs_root *parent_root;
	struct inode *parent_inode;
898
	struct dentry *parent;
899
	struct dentry *dentry;
900
	struct extent_buffer *tmp;
901
	struct extent_buffer *old;
902
	int ret;
903
	u64 to_reserve = 0;
904
	u64 index = 0;
905
	u64 objectid;
L
Li Zefan 已提交
906
	u64 root_flags;
907

908 909
	new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS);
	if (!new_root_item) {
910
		pending->error = -ENOMEM;
911 912
		goto fail;
	}
913

914
	ret = btrfs_find_free_objectid(tree_root, &objectid);
915 916
	if (ret) {
		pending->error = ret;
917
		goto fail;
918
	}
919

920
	btrfs_reloc_pre_snapshot(trans, pending, &to_reserve);
921 922 923 924
	btrfs_orphan_pre_snapshot(trans, pending, &to_reserve);

	if (to_reserve > 0) {
		ret = btrfs_block_rsv_add(trans, root, &pending->block_rsv,
925
					  to_reserve);
926 927 928 929 930 931
		if (ret) {
			pending->error = ret;
			goto fail;
		}
	}

932
	key.objectid = objectid;
933 934
	key.offset = (u64)-1;
	key.type = BTRFS_ROOT_ITEM_KEY;
935

936
	trans->block_rsv = &pending->block_rsv;
937

938
	dentry = pending->dentry;
939 940
	parent = dget_parent(dentry);
	parent_inode = parent->d_inode;
941
	parent_root = BTRFS_I(parent_inode)->root;
C
Chris Mason 已提交
942
	record_root_in_trans(trans, parent_root);
943

944 945 946
	/*
	 * insert the directory item
	 */
947
	ret = btrfs_set_inode_index(parent_inode, &index);
948
	BUG_ON(ret);
949
	ret = btrfs_insert_dir_item(trans, parent_root,
950
				dentry->d_name.name, dentry->d_name.len,
951
				parent_inode, &key,
952
				BTRFS_FT_DIR, index);
953
	BUG_ON(ret);
954

955 956
	btrfs_i_size_write(parent_inode, parent_inode->i_size +
					 dentry->d_name.len * 2);
957 958 959
	ret = btrfs_update_inode(trans, parent_root, parent_inode);
	BUG_ON(ret);

960 961 962 963 964 965 966 967 968
	/*
	 * 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 已提交
969
	record_root_in_trans(trans, root);
970 971
	btrfs_set_root_last_snapshot(&root->root_item, trans->transid);
	memcpy(new_root_item, &root->root_item, sizeof(*new_root_item));
972
	btrfs_check_and_init_root_item(new_root_item);
973

L
Li Zefan 已提交
974 975 976 977 978 979 980
	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);

981 982 983 984 985 986 987 988 989
	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);
990 991 992
	/* record when the snapshot was created in key.offset */
	key.offset = trans->transid;
	ret = btrfs_insert_root(trans, tree_root, &key, new_root_item);
993 994
	btrfs_tree_unlock(tmp);
	free_extent_buffer(tmp);
995
	BUG_ON(ret);
996

997 998 999 1000
	/*
	 * insert root back/forward references
	 */
	ret = btrfs_add_root_ref(trans, tree_root, objectid,
1001
				 parent_root->root_key.objectid,
L
Li Zefan 已提交
1002
				 btrfs_ino(parent_inode), index,
1003
				 dentry->d_name.name, dentry->d_name.len);
1004
	BUG_ON(ret);
1005
	dput(parent);
1006

1007 1008 1009
	key.offset = (u64)-1;
	pending->snap = btrfs_read_fs_root_no_name(root->fs_info, &key);
	BUG_ON(IS_ERR(pending->snap));
1010

1011
	btrfs_reloc_post_snapshot(trans, pending);
1012
	btrfs_orphan_post_snapshot(trans, pending);
1013
fail:
1014
	kfree(new_root_item);
1015 1016
	btrfs_block_rsv_release(root, &pending->block_rsv, (u64)-1);
	return 0;
1017 1018
}

C
Chris Mason 已提交
1019 1020 1021
/*
 * create all the snapshots we've scheduled for creation
 */
1022 1023
static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans,
					     struct btrfs_fs_info *fs_info)
1024 1025 1026 1027 1028
{
	struct btrfs_pending_snapshot *pending;
	struct list_head *head = &trans->transaction->pending_snapshots;
	int ret;

Q
Qinghuang Feng 已提交
1029
	list_for_each_entry(pending, head, list) {
1030 1031 1032 1033 1034 1035
		ret = create_pending_snapshot(trans, fs_info, pending);
		BUG_ON(ret);
	}
	return 0;
}

1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051
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;
1052 1053
	if (super->cache_generation != 0 || btrfs_test_opt(root, SPACE_CACHE))
		super->cache_generation = root_item->generation;
1054 1055
}

1056 1057 1058
int btrfs_transaction_in_commit(struct btrfs_fs_info *info)
{
	int ret = 0;
J
Josef Bacik 已提交
1059
	spin_lock(&info->trans_lock);
1060 1061
	if (info->running_transaction)
		ret = info->running_transaction->in_commit;
J
Josef Bacik 已提交
1062
	spin_unlock(&info->trans_lock);
1063 1064 1065
	return ret;
}

1066 1067 1068
int btrfs_transaction_blocked(struct btrfs_fs_info *info)
{
	int ret = 0;
J
Josef Bacik 已提交
1069
	spin_lock(&info->trans_lock);
1070 1071
	if (info->running_transaction)
		ret = info->running_transaction->blocked;
J
Josef Bacik 已提交
1072
	spin_unlock(&info->trans_lock);
1073 1074 1075
	return ret;
}

S
Sage Weil 已提交
1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154
/*
 * 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)
{
	DEFINE_WAIT(wait);

	if (trans->in_commit)
		return;

	while (1) {
		prepare_to_wait(&root->fs_info->transaction_blocked_wait, &wait,
				TASK_UNINTERRUPTIBLE);
		if (trans->in_commit) {
			finish_wait(&root->fs_info->transaction_blocked_wait,
				    &wait);
			break;
		}
		schedule();
		finish_wait(&root->fs_info->transaction_blocked_wait, &wait);
	}
}

/*
 * 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)
{
	DEFINE_WAIT(wait);

	if (trans->commit_done || (trans->in_commit && !trans->blocked))
		return;

	while (1) {
		prepare_to_wait(&root->fs_info->transaction_wait, &wait,
				TASK_UNINTERRUPTIBLE);
		if (trans->commit_done ||
		    (trans->in_commit && !trans->blocked)) {
			finish_wait(&root->fs_info->transaction_wait,
				    &wait);
			break;
		}
		schedule();
		finish_wait(&root->fs_info->transaction_wait,
			    &wait);
	}
}

/*
 * 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 已提交
1155 1156
	if (!ac)
		return -ENOMEM;
S
Sage Weil 已提交
1157 1158 1159

	INIT_DELAYED_WORK(&ac->work, do_async_commit);
	ac->root = root;
1160
	ac->newtrans = btrfs_join_transaction(root);
1161 1162 1163 1164 1165
	if (IS_ERR(ac->newtrans)) {
		int err = PTR_ERR(ac->newtrans);
		kfree(ac);
		return err;
	}
S
Sage Weil 已提交
1166 1167 1168

	/* take transaction reference */
	cur_trans = trans->transaction;
1169
	atomic_inc(&cur_trans->use_count);
S
Sage Weil 已提交
1170 1171 1172 1173 1174 1175 1176 1177 1178 1179

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

1180 1181 1182 1183
	if (current->journal_info == trans)
		current->journal_info = NULL;

	put_transaction(cur_trans);
S
Sage Weil 已提交
1184 1185 1186 1187 1188 1189 1190 1191 1192 1193
	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 已提交
1194 1195 1196
int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
			     struct btrfs_root *root)
{
1197
	unsigned long joined = 0;
C
Chris Mason 已提交
1198
	struct btrfs_transaction *cur_trans;
C
Chris Mason 已提交
1199
	struct btrfs_transaction *prev_trans = NULL;
C
Chris Mason 已提交
1200
	DEFINE_WAIT(wait);
1201
	int ret;
1202 1203
	int should_grow = 0;
	unsigned long now = get_seconds();
1204
	int flush_on_commit = btrfs_test_opt(root, FLUSHONCOMMIT);
C
Chris Mason 已提交
1205

1206 1207
	btrfs_run_ordered_operations(root, 0);

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

1214 1215
	btrfs_trans_release_metadata(trans, root);

1216
	cur_trans = trans->transaction;
1217 1218 1219 1220
	/*
	 * set the flushing flag so procs in this transaction have to
	 * start sending their work down.
	 */
1221
	cur_trans->delayed_refs.flushing = 1;
1222

1223
	ret = btrfs_run_delayed_refs(trans, root, 0);
1224 1225
	BUG_ON(ret);

J
Josef Bacik 已提交
1226
	spin_lock(&cur_trans->commit_lock);
1227
	if (cur_trans->in_commit) {
J
Josef Bacik 已提交
1228
		spin_unlock(&cur_trans->commit_lock);
1229
		atomic_inc(&cur_trans->use_count);
C
Chris Mason 已提交
1230
		btrfs_end_transaction(trans, root);
C
Chris Mason 已提交
1231

C
Chris Mason 已提交
1232 1233
		ret = wait_for_commit(root, cur_trans);
		BUG_ON(ret);
1234

C
Chris Mason 已提交
1235
		put_transaction(cur_trans);
1236

C
Chris Mason 已提交
1237 1238
		return 0;
	}
1239

C
Chris Mason 已提交
1240
	trans->transaction->in_commit = 1;
1241
	trans->transaction->blocked = 1;
J
Josef Bacik 已提交
1242
	spin_unlock(&cur_trans->commit_lock);
S
Sage Weil 已提交
1243 1244
	wake_up(&root->fs_info->transaction_blocked_wait);

J
Josef Bacik 已提交
1245
	spin_lock(&root->fs_info->trans_lock);
C
Chris Mason 已提交
1246 1247 1248 1249
	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) {
1250
			atomic_inc(&prev_trans->use_count);
J
Josef Bacik 已提交
1251
			spin_unlock(&root->fs_info->trans_lock);
C
Chris Mason 已提交
1252 1253 1254

			wait_for_commit(root, prev_trans);

1255
			put_transaction(prev_trans);
J
Josef Bacik 已提交
1256 1257
		} else {
			spin_unlock(&root->fs_info->trans_lock);
C
Chris Mason 已提交
1258
		}
J
Josef Bacik 已提交
1259 1260
	} else {
		spin_unlock(&root->fs_info->trans_lock);
C
Chris Mason 已提交
1261
	}
1262

1263 1264 1265
	if (now < cur_trans->start_time || now - cur_trans->start_time < 1)
		should_grow = 1;

1266
	do {
1267
		int snap_pending = 0;
J
Josef Bacik 已提交
1268

1269
		joined = cur_trans->num_joined;
1270 1271 1272
		if (!list_empty(&trans->transaction->pending_snapshots))
			snap_pending = 1;

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

1275
		if (flush_on_commit || snap_pending) {
Y
Yan, Zheng 已提交
1276 1277
			btrfs_start_delalloc_inodes(root, 1);
			ret = btrfs_wait_ordered_extents(root, 0, 1);
1278
			BUG_ON(ret);
1279 1280
		}

1281 1282 1283
		ret = btrfs_run_delayed_items(trans, root);
		BUG_ON(ret);

1284 1285 1286 1287 1288 1289 1290 1291 1292
		/*
		 * 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);

1293 1294 1295
		prepare_to_wait(&cur_trans->writer_wait, &wait,
				TASK_UNINTERRUPTIBLE);

1296
		if (atomic_read(&cur_trans->num_writers) > 1)
1297 1298 1299
			schedule_timeout(MAX_SCHEDULE_TIMEOUT);
		else if (should_grow)
			schedule_timeout(1);
1300 1301

		finish_wait(&cur_trans->writer_wait, &wait);
1302
	} while (atomic_read(&cur_trans->num_writers) > 1 ||
1303
		 (should_grow && cur_trans->num_joined != joined));
1304

1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315
	/*
	 * 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 已提交
1316 1317 1318 1319 1320 1321 1322
	/*
	 * 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);

1323
	ret = btrfs_run_delayed_items(trans, root);
1324 1325
	BUG_ON(ret);

1326
	ret = create_pending_snapshots(trans, root->fs_info);
1327 1328
	BUG_ON(ret);

1329 1330 1331
	ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
	BUG_ON(ret);

1332 1333 1334 1335 1336 1337
	/*
	 * make sure none of the code above managed to slip in a
	 * delayed item
	 */
	btrfs_assert_delayed_root_empty(root);

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

A
Arne Jansen 已提交
1340
	btrfs_scrub_pause(root);
1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355
	/* 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);

1356
	ret = commit_fs_roots(trans, root);
1357 1358
	BUG_ON(ret);

1359
	/* commit_fs_roots gets rid of all the tree log roots, it is now
1360 1361 1362 1363
	 * safe to free the root of tree log roots
	 */
	btrfs_free_log_root_tree(trans, root->fs_info);

1364
	ret = commit_cowonly_roots(trans, root);
C
Chris Mason 已提交
1365
	BUG_ON(ret);
1366

1367 1368
	btrfs_prepare_extent_commit(trans, root);

C
Chris Mason 已提交
1369
	cur_trans = root->fs_info->running_transaction;
1370 1371 1372

	btrfs_set_root_node(&root->fs_info->tree_root->root_item,
			    root->fs_info->tree_root->node);
J
Josef Bacik 已提交
1373
	switch_commit_root(root->fs_info->tree_root);
1374 1375 1376

	btrfs_set_root_node(&root->fs_info->chunk_root->root_item,
			    root->fs_info->chunk_root->node);
J
Josef Bacik 已提交
1377
	switch_commit_root(root->fs_info->chunk_root);
1378 1379

	update_super_roots(root);
1380 1381 1382 1383 1384 1385

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

1386 1387
	memcpy(&root->fs_info->super_for_commit, &root->fs_info->super_copy,
	       sizeof(root->fs_info->super_copy));
C
Chris Mason 已提交
1388

1389
	trans->transaction->blocked = 0;
J
Josef Bacik 已提交
1390 1391 1392 1393
	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 已提交
1394
	mutex_unlock(&root->fs_info->reloc_mutex);
1395

1396
	wake_up(&root->fs_info->transaction_wait);
1397

C
Chris Mason 已提交
1398 1399
	ret = btrfs_write_and_wait_transaction(trans, root);
	BUG_ON(ret);
Y
Yan Zheng 已提交
1400
	write_ctree_super(trans, root, 0);
1401

1402 1403 1404 1405 1406 1407
	/*
	 * the super is written, we can safely allow the tree-loggers
	 * to go about their business
	 */
	mutex_unlock(&root->fs_info->tree_log_mutex);

1408
	btrfs_finish_extent_commit(trans, root);
1409

C
Chris Mason 已提交
1410
	cur_trans->commit_done = 1;
1411

1412
	root->fs_info->last_trans_committed = cur_trans->transid;
J
Josef Bacik 已提交
1413

C
Chris Mason 已提交
1414
	wake_up(&cur_trans->commit_wait);
1415

J
Josef Bacik 已提交
1416
	spin_lock(&root->fs_info->trans_lock);
1417
	list_del_init(&cur_trans->list);
J
Josef Bacik 已提交
1418 1419
	spin_unlock(&root->fs_info->trans_lock);

C
Chris Mason 已提交
1420
	put_transaction(cur_trans);
C
Chris Mason 已提交
1421
	put_transaction(cur_trans);
1422

1423 1424
	trace_btrfs_transaction_commit(root);

A
Arne Jansen 已提交
1425 1426
	btrfs_scrub_continue(root);

J
Josef Bacik 已提交
1427 1428 1429
	if (current->journal_info == trans)
		current->journal_info = NULL;

C
Chris Mason 已提交
1430
	kmem_cache_free(btrfs_trans_handle_cachep, trans);
Y
Yan, Zheng 已提交
1431 1432 1433 1434

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

C
Chris Mason 已提交
1435 1436 1437
	return ret;
}

C
Chris Mason 已提交
1438 1439 1440
/*
 * interface function to delete all the snapshots we have scheduled for deletion
 */
1441 1442
int btrfs_clean_old_snapshots(struct btrfs_root *root)
{
1443 1444 1445
	LIST_HEAD(list);
	struct btrfs_fs_info *fs_info = root->fs_info;

J
Josef Bacik 已提交
1446
	spin_lock(&fs_info->trans_lock);
1447
	list_splice_init(&fs_info->dead_roots, &list);
J
Josef Bacik 已提交
1448
	spin_unlock(&fs_info->trans_lock);
1449

1450 1451
	while (!list_empty(&list)) {
		root = list_entry(list.next, struct btrfs_root, root_list);
1452 1453
		list_del(&root->root_list);

1454 1455
		btrfs_kill_all_delayed_nodes(root);

1456 1457
		if (btrfs_header_backref_rev(root->node) <
		    BTRFS_MIXED_BACKREF_REV)
1458
			btrfs_drop_snapshot(root, NULL, 0);
1459
		else
1460
			btrfs_drop_snapshot(root, NULL, 1);
1461 1462 1463
	}
	return 0;
}