transaction.c 37.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"
C
Chris Mason 已提交
30

31 32
#define BTRFS_ROOT_TRANS_TAG 0

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

J
Josef Bacik 已提交
42 43 44 45 46 47
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 已提交
48 49 50
/*
 * either allocate a new transaction or hop into the existing one
 */
51
static noinline int join_transaction(struct btrfs_root *root)
C
Chris Mason 已提交
52 53 54 55
{
	struct btrfs_transaction *cur_trans;
	cur_trans = root->fs_info->running_transaction;
	if (!cur_trans) {
C
Chris Mason 已提交
56 57
		cur_trans = kmem_cache_alloc(btrfs_transaction_cachep,
					     GFP_NOFS);
T
Tsutomu Itoh 已提交
58 59
		if (!cur_trans)
			return -ENOMEM;
60
		root->fs_info->generation++;
61
		atomic_set(&cur_trans->num_writers, 1);
62
		cur_trans->num_joined = 0;
63
		cur_trans->transid = root->fs_info->generation;
C
Chris Mason 已提交
64 65 66
		init_waitqueue_head(&cur_trans->writer_wait);
		init_waitqueue_head(&cur_trans->commit_wait);
		cur_trans->in_commit = 0;
67
		cur_trans->blocked = 0;
68
		atomic_set(&cur_trans->use_count, 1);
C
Chris Mason 已提交
69
		cur_trans->commit_done = 0;
C
Chris Mason 已提交
70
		cur_trans->start_time = get_seconds();
71

72
		cur_trans->delayed_refs.root = RB_ROOT;
73
		cur_trans->delayed_refs.num_entries = 0;
74 75
		cur_trans->delayed_refs.num_heads_ready = 0;
		cur_trans->delayed_refs.num_heads = 0;
76
		cur_trans->delayed_refs.flushing = 0;
77
		cur_trans->delayed_refs.run_delayed_start = 0;
78 79
		spin_lock_init(&cur_trans->delayed_refs.lock);

80
		INIT_LIST_HEAD(&cur_trans->pending_snapshots);
C
Chris Mason 已提交
81
		list_add_tail(&cur_trans->list, &root->fs_info->trans_list);
82
		extent_io_tree_init(&cur_trans->dirty_pages,
83 84
				     root->fs_info->btree_inode->i_mapping,
				     GFP_NOFS);
85 86 87
		spin_lock(&root->fs_info->new_trans_lock);
		root->fs_info->running_transaction = cur_trans;
		spin_unlock(&root->fs_info->new_trans_lock);
88
	} else {
89
		atomic_inc(&cur_trans->num_writers);
90
		cur_trans->num_joined++;
C
Chris Mason 已提交
91
	}
92

C
Chris Mason 已提交
93 94 95
	return 0;
}

C
Chris Mason 已提交
96
/*
C
Chris Mason 已提交
97 98 99 100
 * 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 已提交
101
 */
102 103
static noinline int record_root_in_trans(struct btrfs_trans_handle *trans,
					 struct btrfs_root *root)
104
{
105
	if (root->ref_cows && root->last_trans < trans->transid) {
106
		WARN_ON(root == root->fs_info->extent_root);
107 108 109 110 111 112 113 114 115 116
		WARN_ON(root->commit_root != root->node);

		radix_tree_tag_set(&root->fs_info->fs_roots_radix,
			   (unsigned long)root->root_key.objectid,
			   BTRFS_ROOT_TRANS_TAG);
		root->last_trans = trans->transid;
		btrfs_init_reloc_root(trans, root);
	}
	return 0;
}
117

118 119 120 121 122
int btrfs_record_root_in_trans(struct btrfs_trans_handle *trans,
			       struct btrfs_root *root)
{
	if (!root->ref_cows)
		return 0;
123

124 125 126 127
	mutex_lock(&root->fs_info->trans_mutex);
	if (root->last_trans == trans->transid) {
		mutex_unlock(&root->fs_info->trans_mutex);
		return 0;
128
	}
129 130 131

	record_root_in_trans(trans, root);
	mutex_unlock(&root->fs_info->trans_mutex);
132 133 134
	return 0;
}

C
Chris Mason 已提交
135 136 137 138
/* 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 已提交
139
static void wait_current_trans(struct btrfs_root *root)
C
Chris Mason 已提交
140
{
141
	struct btrfs_transaction *cur_trans;
C
Chris Mason 已提交
142

143
	cur_trans = root->fs_info->running_transaction;
C
Chris Mason 已提交
144
	if (cur_trans && cur_trans->blocked) {
145
		DEFINE_WAIT(wait);
146
		atomic_inc(&cur_trans->use_count);
C
Chris Mason 已提交
147
		while (1) {
148 149
			prepare_to_wait(&root->fs_info->transaction_wait, &wait,
					TASK_UNINTERRUPTIBLE);
150
			if (!cur_trans->blocked)
151
				break;
152 153 154
			mutex_unlock(&root->fs_info->trans_mutex);
			schedule();
			mutex_lock(&root->fs_info->trans_mutex);
155
		}
156
		finish_wait(&root->fs_info->transaction_wait, &wait);
157 158
		put_transaction(cur_trans);
	}
C
Chris Mason 已提交
159 160
}

161 162 163 164
enum btrfs_trans_type {
	TRANS_START,
	TRANS_JOIN,
	TRANS_USERSPACE,
165
	TRANS_JOIN_NOLOCK,
166 167
};

168 169 170 171 172 173 174 175 176
static int may_wait_transaction(struct btrfs_root *root, int type)
{
	if (!root->fs_info->log_root_recovering &&
	    ((type == TRANS_START && !root->fs_info->open_ioctl_trans) ||
	     type == TRANS_USERSPACE))
		return 1;
	return 0;
}

177
static struct btrfs_trans_handle *start_transaction(struct btrfs_root *root,
178
						    u64 num_items, int type)
C
Chris Mason 已提交
179
{
180 181
	struct btrfs_trans_handle *h;
	struct btrfs_transaction *cur_trans;
182
	int retries = 0;
C
Chris Mason 已提交
183
	int ret;
L
liubo 已提交
184 185 186

	if (root->fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR)
		return ERR_PTR(-EROFS);
187 188 189 190
again:
	h = kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS);
	if (!h)
		return ERR_PTR(-ENOMEM);
C
Chris Mason 已提交
191

192 193
	if (type != TRANS_JOIN_NOLOCK)
		mutex_lock(&root->fs_info->trans_mutex);
194
	if (may_wait_transaction(root, type))
C
Chris Mason 已提交
195
		wait_current_trans(root);
196

C
Chris Mason 已提交
197
	ret = join_transaction(root);
T
Tsutomu Itoh 已提交
198
	if (ret < 0) {
199
		kmem_cache_free(btrfs_trans_handle_cachep, h);
T
Tsutomu Itoh 已提交
200 201 202 203
		if (type != TRANS_JOIN_NOLOCK)
			mutex_unlock(&root->fs_info->trans_mutex);
		return ERR_PTR(ret);
	}
204

205
	cur_trans = root->fs_info->running_transaction;
206
	atomic_inc(&cur_trans->use_count);
207 208
	if (type != TRANS_JOIN_NOLOCK)
		mutex_unlock(&root->fs_info->trans_mutex);
209 210 211

	h->transid = cur_trans->transid;
	h->transaction = cur_trans;
C
Chris Mason 已提交
212
	h->blocks_used = 0;
213
	h->block_group = 0;
214
	h->bytes_reserved = 0;
215
	h->delayed_ref_updates = 0;
216
	h->block_rsv = NULL;
217

218 219 220 221 222 223 224
	smp_mb();
	if (cur_trans->blocked && may_wait_transaction(root, type)) {
		btrfs_commit_transaction(h, root);
		goto again;
	}

	if (num_items > 0) {
225
		ret = btrfs_trans_reserve_metadata(h, root, num_items);
226 227
		if (ret == -EAGAIN && !retries) {
			retries++;
228 229
			btrfs_commit_transaction(h, root);
			goto again;
230 231 232 233 234 235
		} 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;
236
		}
237

238 239 240 241 242
		if (ret < 0) {
			btrfs_end_transaction(h, root);
			return ERR_PTR(ret);
		}
	}
J
Josef Bacik 已提交
243

244 245
	if (type != TRANS_JOIN_NOLOCK)
		mutex_lock(&root->fs_info->trans_mutex);
246
	record_root_in_trans(h, root);
247 248
	if (type != TRANS_JOIN_NOLOCK)
		mutex_unlock(&root->fs_info->trans_mutex);
249 250 251

	if (!current->journal_info && type != TRANS_USERSPACE)
		current->journal_info = h;
C
Chris Mason 已提交
252 253 254
	return h;
}

255
struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
256
						   int num_items)
257
{
258
	return start_transaction(root, num_items, TRANS_START);
259
}
260
struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root)
261
{
262
	return start_transaction(root, 0, TRANS_JOIN);
263 264
}

265
struct btrfs_trans_handle *btrfs_join_transaction_nolock(struct btrfs_root *root)
266 267 268 269
{
	return start_transaction(root, 0, TRANS_JOIN_NOLOCK);
}

270
struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *root)
271
{
272
	return start_transaction(root, 0, TRANS_USERSPACE);
273 274
}

C
Chris Mason 已提交
275
/* wait for a transaction commit to be fully complete */
276 277 278 279 280
static noinline int wait_for_commit(struct btrfs_root *root,
				    struct btrfs_transaction *commit)
{
	DEFINE_WAIT(wait);
	mutex_lock(&root->fs_info->trans_mutex);
C
Chris Mason 已提交
281
	while (!commit->commit_done) {
282 283 284 285 286 287 288 289 290 291 292 293 294
		prepare_to_wait(&commit->commit_wait, &wait,
				TASK_UNINTERRUPTIBLE);
		if (commit->commit_done)
			break;
		mutex_unlock(&root->fs_info->trans_mutex);
		schedule();
		mutex_lock(&root->fs_info->trans_mutex);
	}
	mutex_unlock(&root->fs_info->trans_mutex);
	finish_wait(&commit->commit_wait, &wait);
	return 0;
}

295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333
int btrfs_wait_for_commit(struct btrfs_root *root, u64 transid)
{
	struct btrfs_transaction *cur_trans = NULL, *t;
	int ret;

	mutex_lock(&root->fs_info->trans_mutex);

	ret = 0;
	if (transid) {
		if (transid <= root->fs_info->last_trans_committed)
			goto out_unlock;

		/* find specified transaction */
		list_for_each_entry(t, &root->fs_info->trans_list, list) {
			if (t->transid == transid) {
				cur_trans = t;
				break;
			}
			if (t->transid > transid)
				break;
		}
		ret = -EINVAL;
		if (!cur_trans)
			goto out_unlock;  /* bad transid */
	} else {
		/* find newest transaction that is committing | committed */
		list_for_each_entry_reverse(t, &root->fs_info->trans_list,
					    list) {
			if (t->in_commit) {
				if (t->commit_done)
					goto out_unlock;
				cur_trans = t;
				break;
			}
		}
		if (!cur_trans)
			goto out_unlock;  /* nothing committing|committed */
	}

334
	atomic_inc(&cur_trans->use_count);
335 336 337 338 339 340 341 342 343 344 345 346
	mutex_unlock(&root->fs_info->trans_mutex);

	wait_for_commit(root, cur_trans);

	mutex_lock(&root->fs_info->trans_mutex);
	put_transaction(cur_trans);
	ret = 0;
out_unlock:
	mutex_unlock(&root->fs_info->trans_mutex);
	return ret;
}

347
#if 0
C
Chris Mason 已提交
348
/*
C
Chris Mason 已提交
349 350
 * rate limit against the drop_snapshot code.  This helps to slow down new
 * operations if the drop_snapshot code isn't able to keep up.
C
Chris Mason 已提交
351
 */
C
Chris Mason 已提交
352
static void throttle_on_drops(struct btrfs_root *root)
353 354
{
	struct btrfs_fs_info *info = root->fs_info;
C
Chris Mason 已提交
355
	int harder_count = 0;
356

C
Chris Mason 已提交
357
harder:
358 359 360 361 362 363 364 365 366 367 368 369 370 371 372
	if (atomic_read(&info->throttles)) {
		DEFINE_WAIT(wait);
		int thr;
		thr = atomic_read(&info->throttle_gen);

		do {
			prepare_to_wait(&info->transaction_throttle,
					&wait, TASK_UNINTERRUPTIBLE);
			if (!atomic_read(&info->throttles)) {
				finish_wait(&info->transaction_throttle, &wait);
				break;
			}
			schedule();
			finish_wait(&info->transaction_throttle, &wait);
		} while (thr == atomic_read(&info->throttle_gen));
C
Chris Mason 已提交
373 374 375 376 377 378 379 380 381 382 383 384 385
		harder_count++;

		if (root->fs_info->total_ref_cache_size > 1 * 1024 * 1024 &&
		    harder_count < 2)
			goto harder;

		if (root->fs_info->total_ref_cache_size > 5 * 1024 * 1024 &&
		    harder_count < 10)
			goto harder;

		if (root->fs_info->total_ref_cache_size > 10 * 1024 * 1024 &&
		    harder_count < 20)
			goto harder;
386 387
	}
}
388
#endif
389

C
Chris Mason 已提交
390 391 392
void btrfs_throttle(struct btrfs_root *root)
{
	mutex_lock(&root->fs_info->trans_mutex);
393 394
	if (!root->fs_info->open_ioctl_trans)
		wait_current_trans(root);
C
Chris Mason 已提交
395 396 397
	mutex_unlock(&root->fs_info->trans_mutex);
}

398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423
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;

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

424
static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
425
			  struct btrfs_root *root, int throttle, int lock)
C
Chris Mason 已提交
426
{
427
	struct btrfs_transaction *cur_trans = trans->transaction;
428
	struct btrfs_fs_info *info = root->fs_info;
429 430 431 432 433 434 435 436
	int count = 0;

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

			/*
			 * do a full flush if the transaction is trying
			 * to close
			 */
			if (trans->transaction->delayed_refs.flushing)
				cur = 0;
444 445 446 447 448
			btrfs_run_delayed_refs(trans, root, cur);
		} else {
			break;
		}
		count++;
449 450
	}

451 452
	btrfs_trans_release_metadata(trans, root);

453
	if (lock && !root->fs_info->open_ioctl_trans &&
454 455 456
	    should_end_transaction(trans, root))
		trans->transaction->blocked = 1;

457
	if (lock && cur_trans->blocked && !cur_trans->in_commit) {
458 459 460 461 462 463 464
		if (throttle)
			return btrfs_commit_transaction(trans, root);
		else
			wake_up_process(info->transaction_kthread);
	}

	WARN_ON(cur_trans != info->running_transaction);
465 466
	WARN_ON(atomic_read(&cur_trans->num_writers) < 1);
	atomic_dec(&cur_trans->num_writers);
467

468
	smp_mb();
C
Chris Mason 已提交
469 470 471
	if (waitqueue_active(&cur_trans->writer_wait))
		wake_up(&cur_trans->writer_wait);
	put_transaction(cur_trans);
J
Josef Bacik 已提交
472 473 474

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

Y
Yan, Zheng 已提交
478 479 480
	if (throttle)
		btrfs_run_delayed_iputs(root);

C
Chris Mason 已提交
481 482 483
	return 0;
}

484 485 486
int btrfs_end_transaction(struct btrfs_trans_handle *trans,
			  struct btrfs_root *root)
{
487
	return __btrfs_end_transaction(trans, root, 0, 1);
488 489 490 491 492
}

int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans,
				   struct btrfs_root *root)
{
493 494 495 496 497 498 499
	return __btrfs_end_transaction(trans, root, 1, 1);
}

int btrfs_end_transaction_nolock(struct btrfs_trans_handle *trans,
				 struct btrfs_root *root)
{
	return __btrfs_end_transaction(trans, root, 0, 0);
500 501
}

C
Chris Mason 已提交
502 503 504
/*
 * 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
505
 * those extents are sent to disk but does not wait on them
C
Chris Mason 已提交
506
 */
507
int btrfs_write_marked_extents(struct btrfs_root *root,
508
			       struct extent_io_tree *dirty_pages, int mark)
C
Chris Mason 已提交
509
{
510
	int ret;
511
	int err = 0;
512 513 514
	int werr = 0;
	struct page *page;
	struct inode *btree_inode = root->fs_info->btree_inode;
515
	u64 start = 0;
516 517
	u64 end;
	unsigned long index;
518

C
Chris Mason 已提交
519
	while (1) {
520
		ret = find_first_extent_bit(dirty_pages, start, &start, &end,
521
					    mark);
522
		if (ret)
523
			break;
C
Chris Mason 已提交
524
		while (start <= end) {
525 526
			cond_resched();

527
			index = start >> PAGE_CACHE_SHIFT;
528
			start = (u64)(index + 1) << PAGE_CACHE_SHIFT;
C
Chris Mason 已提交
529
			page = find_get_page(btree_inode->i_mapping, index);
530 531
			if (!page)
				continue;
C
Chris Mason 已提交
532 533 534 535 536 537 538 539

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

540 541 542 543 544 545 546 547 548
			if (PageWriteback(page)) {
				if (PageDirty(page))
					wait_on_page_writeback(page);
				else {
					unlock_page(page);
					page_cache_release(page);
					continue;
				}
			}
549 550 551 552 553 554
			err = write_one_page(page, 0);
			if (err)
				werr = err;
			page_cache_release(page);
		}
	}
555 556 557 558 559 560 561 562 563 564 565 566
	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,
567
			      struct extent_io_tree *dirty_pages, int mark)
568 569 570 571 572 573 574 575 576 577
{
	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 已提交
578
	while (1) {
579 580
		ret = find_first_extent_bit(dirty_pages, start, &start, &end,
					    mark);
581 582 583
		if (ret)
			break;

584
		clear_extent_bits(dirty_pages, start, end, mark, GFP_NOFS);
C
Chris Mason 已提交
585
		while (start <= end) {
586 587 588 589 590 591
			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 已提交
592 593
				btree_lock_page_hook(page);
				wait_on_page_writeback(page);
594 595 596 597
				err = write_one_page(page, 0);
				if (err)
					werr = err;
			}
598
			wait_on_page_writeback(page);
599 600 601 602
			page_cache_release(page);
			cond_resched();
		}
	}
603 604 605
	if (err)
		werr = err;
	return werr;
C
Chris Mason 已提交
606 607
}

608 609 610 611 612 613
/*
 * 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,
614
				struct extent_io_tree *dirty_pages, int mark)
615 616 617 618
{
	int ret;
	int ret2;

619 620
	ret = btrfs_write_marked_extents(root, dirty_pages, mark);
	ret2 = btrfs_wait_marked_extents(root, dirty_pages, mark);
621 622 623
	return ret || ret2;
}

624 625 626 627 628 629 630 631 632
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,
633 634
					   &trans->transaction->dirty_pages,
					   EXTENT_DIRTY);
635 636
}

C
Chris Mason 已提交
637 638 639 640 641 642 643 644 645 646
/*
 * 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.
 */
647 648
static int update_cowonly_root(struct btrfs_trans_handle *trans,
			       struct btrfs_root *root)
C
Chris Mason 已提交
649 650
{
	int ret;
651
	u64 old_root_bytenr;
652
	u64 old_root_used;
653
	struct btrfs_root *tree_root = root->fs_info->tree_root;
C
Chris Mason 已提交
654

655
	old_root_used = btrfs_root_used(&root->root_item);
656
	btrfs_write_dirty_block_groups(trans, root);
657

C
Chris Mason 已提交
658
	while (1) {
659
		old_root_bytenr = btrfs_root_bytenr(&root->root_item);
660 661
		if (old_root_bytenr == root->node->start &&
		    old_root_used == btrfs_root_used(&root->root_item))
C
Chris Mason 已提交
662
			break;
663

664
		btrfs_set_root_node(&root->root_item, root->node);
C
Chris Mason 已提交
665
		ret = btrfs_update_root(trans, tree_root,
666 667
					&root->root_key,
					&root->root_item);
C
Chris Mason 已提交
668
		BUG_ON(ret);
669

670
		old_root_used = btrfs_root_used(&root->root_item);
671
		ret = btrfs_write_dirty_block_groups(trans, root);
672
		BUG_ON(ret);
673
	}
674 675 676 677

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

678 679 680
	return 0;
}

C
Chris Mason 已提交
681 682 683
/*
 * update all the cowonly tree roots on disk
 */
684 685
static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans,
					 struct btrfs_root *root)
686 687 688
{
	struct btrfs_fs_info *fs_info = root->fs_info;
	struct list_head *next;
689
	struct extent_buffer *eb;
690
	int ret;
691

692 693
	ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
	BUG_ON(ret);
694

695
	eb = btrfs_lock_root_node(fs_info->tree_root);
696
	btrfs_cow_block(trans, fs_info->tree_root, eb, NULL, 0, &eb);
697 698
	btrfs_tree_unlock(eb);
	free_extent_buffer(eb);
699

700 701
	ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
	BUG_ON(ret);
702

C
Chris Mason 已提交
703
	while (!list_empty(&fs_info->dirty_cowonly_roots)) {
704 705 706
		next = fs_info->dirty_cowonly_roots.next;
		list_del_init(next);
		root = list_entry(next, struct btrfs_root, dirty_list);
707

708
		update_cowonly_root(trans, root);
C
Chris Mason 已提交
709
	}
710 711 712 713 714

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

C
Chris Mason 已提交
715 716 717
	return 0;
}

C
Chris Mason 已提交
718 719 720 721 722
/*
 * 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
 */
723
int btrfs_add_dead_root(struct btrfs_root *root)
724
{
Y
Yan Zheng 已提交
725
	mutex_lock(&root->fs_info->trans_mutex);
726
	list_add(&root->root_list, &root->fs_info->dead_roots);
Y
Yan Zheng 已提交
727
	mutex_unlock(&root->fs_info->trans_mutex);
728 729 730
	return 0;
}

C
Chris Mason 已提交
731
/*
732
 * update all the cowonly tree roots on disk
C
Chris Mason 已提交
733
 */
734 735
static noinline int commit_fs_roots(struct btrfs_trans_handle *trans,
				    struct btrfs_root *root)
736 737
{
	struct btrfs_root *gang[8];
738
	struct btrfs_fs_info *fs_info = root->fs_info;
739 740
	int i;
	int ret;
741 742
	int err = 0;

C
Chris Mason 已提交
743
	while (1) {
744 745
		ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix,
						 (void **)gang, 0,
746 747 748 749 750 751
						 ARRAY_SIZE(gang),
						 BTRFS_ROOT_TRANS_TAG);
		if (ret == 0)
			break;
		for (i = 0; i < ret; i++) {
			root = gang[i];
752 753 754
			radix_tree_tag_clear(&fs_info->fs_roots_radix,
					(unsigned long)root->root_key.objectid,
					BTRFS_ROOT_TRANS_TAG);
Y
Yan Zheng 已提交
755

756
			btrfs_free_log(trans, root);
757
			btrfs_update_reloc_root(trans, root);
758
			btrfs_orphan_commit_root(trans, root);
759

760
			if (root->commit_root != root->node) {
J
Josef Bacik 已提交
761
				switch_commit_root(root);
762 763 764
				btrfs_set_root_node(&root->root_item,
						    root->node);
			}
765 766

			err = btrfs_update_root(trans, fs_info->tree_root,
767 768
						&root->root_key,
						&root->root_item);
769 770
			if (err)
				break;
771 772
		}
	}
773
	return err;
774 775
}

C
Chris Mason 已提交
776 777 778 779
/*
 * defrag a given btree.  If cacheonly == 1, this won't read from the disk,
 * otherwise every leaf in the btree is read and defragged.
 */
780 781 782 783
int btrfs_defrag_root(struct btrfs_root *root, int cacheonly)
{
	struct btrfs_fs_info *info = root->fs_info;
	struct btrfs_trans_handle *trans;
784
	int ret;
785
	unsigned long nr;
786

787
	if (xchg(&root->defrag_running, 1))
788
		return 0;
789

790
	while (1) {
791 792 793 794
		trans = btrfs_start_transaction(root, 0);
		if (IS_ERR(trans))
			return PTR_ERR(trans);

795
		ret = btrfs_defrag_leaves(trans, root, cacheonly);
796

797
		nr = trans->blocks_used;
798
		btrfs_end_transaction(trans, root);
799
		btrfs_btree_balance_dirty(info->tree_root, nr);
800 801
		cond_resched();

802
		if (root->fs_info->closing || ret != -EAGAIN)
803 804 805
			break;
	}
	root->defrag_running = 0;
806
	return ret;
807 808
}

809
#if 0
810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826
/*
 * when dropping snapshots, we generate a ton of delayed refs, and it makes
 * sense not to join the transaction while it is trying to flush the current
 * queue of delayed refs out.
 *
 * This is used by the drop snapshot code only
 */
static noinline int wait_transaction_pre_flush(struct btrfs_fs_info *info)
{
	DEFINE_WAIT(wait);

	mutex_lock(&info->trans_mutex);
	while (info->running_transaction &&
	       info->running_transaction->delayed_refs.flushing) {
		prepare_to_wait(&info->transaction_wait, &wait,
				TASK_UNINTERRUPTIBLE);
		mutex_unlock(&info->trans_mutex);
827

828
		schedule();
829

830 831 832 833 834 835 836
		mutex_lock(&info->trans_mutex);
		finish_wait(&info->transaction_wait, &wait);
	}
	mutex_unlock(&info->trans_mutex);
	return 0;
}

C
Chris Mason 已提交
837 838 839 840
/*
 * Given a list of roots that need to be deleted, call btrfs_drop_snapshot on
 * all of them
 */
841
int btrfs_drop_dead_root(struct btrfs_root *root)
842 843
{
	struct btrfs_trans_handle *trans;
844
	struct btrfs_root *tree_root = root->fs_info->tree_root;
845
	unsigned long nr;
846
	int ret;
847

848 849 850 851 852 853 854
	while (1) {
		/*
		 * we don't want to jump in and create a bunch of
		 * delayed refs if the transaction is starting to close
		 */
		wait_transaction_pre_flush(tree_root->fs_info);
		trans = btrfs_start_transaction(tree_root, 1);
855

856 857 858 859 860 861 862
		/*
		 * we've joined a transaction, make sure it isn't
		 * closing right now
		 */
		if (trans->transaction->delayed_refs.flushing) {
			btrfs_end_transaction(trans, tree_root);
			continue;
863
		}
864

865 866 867
		ret = btrfs_drop_snapshot(trans, root);
		if (ret != -EAGAIN)
			break;
868

869 870 871 872
		ret = btrfs_update_root(trans, tree_root,
					&root->root_key,
					&root->root_item);
		if (ret)
873
			break;
874

875
		nr = trans->blocks_used;
876 877
		ret = btrfs_end_transaction(trans, tree_root);
		BUG_ON(ret);
878

879
		btrfs_btree_balance_dirty(tree_root, nr);
880
		cond_resched();
881
	}
882 883 884 885 886 887 888 889 890 891 892 893 894 895
	BUG_ON(ret);

	ret = btrfs_del_root(trans, tree_root, &root->root_key);
	BUG_ON(ret);

	nr = trans->blocks_used;
	ret = btrfs_end_transaction(trans, tree_root);
	BUG_ON(ret);

	free_extent_buffer(root->node);
	free_extent_buffer(root->commit_root);
	kfree(root);

	btrfs_btree_balance_dirty(tree_root, nr);
896
	return ret;
897
}
898
#endif
899

C
Chris Mason 已提交
900 901 902 903
/*
 * new snapshots need to be created at a very specific time in the
 * transaction commit.  This does the actual creation
 */
904
static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
905 906 907 908
				   struct btrfs_fs_info *fs_info,
				   struct btrfs_pending_snapshot *pending)
{
	struct btrfs_key key;
909
	struct btrfs_root_item *new_root_item;
910 911
	struct btrfs_root *tree_root = fs_info->tree_root;
	struct btrfs_root *root = pending->root;
912 913
	struct btrfs_root *parent_root;
	struct inode *parent_inode;
914
	struct dentry *parent;
915
	struct dentry *dentry;
916
	struct extent_buffer *tmp;
917
	struct extent_buffer *old;
918
	int ret;
919
	u64 to_reserve = 0;
920
	u64 index = 0;
921
	u64 objectid;
L
Li Zefan 已提交
922
	u64 root_flags;
923

924 925
	new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS);
	if (!new_root_item) {
926
		pending->error = -ENOMEM;
927 928
		goto fail;
	}
929

930
	ret = btrfs_find_free_objectid(trans, tree_root, 0, &objectid);
931 932
	if (ret) {
		pending->error = ret;
933
		goto fail;
934
	}
935

936
	btrfs_reloc_pre_snapshot(trans, pending, &to_reserve);
937 938 939 940
	btrfs_orphan_pre_snapshot(trans, pending, &to_reserve);

	if (to_reserve > 0) {
		ret = btrfs_block_rsv_add(trans, root, &pending->block_rsv,
941
					  to_reserve);
942 943 944 945 946 947
		if (ret) {
			pending->error = ret;
			goto fail;
		}
	}

948
	key.objectid = objectid;
949 950
	key.offset = (u64)-1;
	key.type = BTRFS_ROOT_ITEM_KEY;
951

952
	trans->block_rsv = &pending->block_rsv;
953

954
	dentry = pending->dentry;
955 956
	parent = dget_parent(dentry);
	parent_inode = parent->d_inode;
957
	parent_root = BTRFS_I(parent_inode)->root;
958
	record_root_in_trans(trans, parent_root);
959

960 961 962
	/*
	 * insert the directory item
	 */
963
	ret = btrfs_set_inode_index(parent_inode, &index);
964
	BUG_ON(ret);
965
	ret = btrfs_insert_dir_item(trans, parent_root,
966 967 968
				dentry->d_name.name, dentry->d_name.len,
				parent_inode->i_ino, &key,
				BTRFS_FT_DIR, index);
969
	BUG_ON(ret);
970

971 972
	btrfs_i_size_write(parent_inode, parent_inode->i_size +
					 dentry->d_name.len * 2);
973 974 975
	ret = btrfs_update_inode(trans, parent_root, parent_inode);
	BUG_ON(ret);

976 977 978
	record_root_in_trans(trans, root);
	btrfs_set_root_last_snapshot(&root->root_item, trans->transid);
	memcpy(new_root_item, &root->root_item, sizeof(*new_root_item));
979
	btrfs_check_and_init_root_item(new_root_item);
980

L
Li Zefan 已提交
981 982 983 984 985 986 987
	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);

988 989 990 991 992 993 994 995 996
	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);
997 998 999
	/* record when the snapshot was created in key.offset */
	key.offset = trans->transid;
	ret = btrfs_insert_root(trans, tree_root, &key, new_root_item);
1000 1001
	btrfs_tree_unlock(tmp);
	free_extent_buffer(tmp);
1002
	BUG_ON(ret);
1003

1004 1005 1006 1007
	/*
	 * insert root back/forward references
	 */
	ret = btrfs_add_root_ref(trans, tree_root, objectid,
1008
				 parent_root->root_key.objectid,
1009 1010
				 parent_inode->i_ino, index,
				 dentry->d_name.name, dentry->d_name.len);
1011
	BUG_ON(ret);
1012
	dput(parent);
1013

1014 1015 1016
	key.offset = (u64)-1;
	pending->snap = btrfs_read_fs_root_no_name(root->fs_info, &key);
	BUG_ON(IS_ERR(pending->snap));
1017

1018
	btrfs_reloc_post_snapshot(trans, pending);
1019
	btrfs_orphan_post_snapshot(trans, pending);
1020
fail:
1021
	kfree(new_root_item);
1022 1023
	btrfs_block_rsv_release(root, &pending->block_rsv, (u64)-1);
	return 0;
1024 1025
}

C
Chris Mason 已提交
1026 1027 1028
/*
 * create all the snapshots we've scheduled for creation
 */
1029 1030
static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans,
					     struct btrfs_fs_info *fs_info)
1031 1032 1033 1034 1035
{
	struct btrfs_pending_snapshot *pending;
	struct list_head *head = &trans->transaction->pending_snapshots;
	int ret;

Q
Qinghuang Feng 已提交
1036
	list_for_each_entry(pending, head, list) {
1037 1038 1039 1040 1041 1042
		ret = create_pending_snapshot(trans, fs_info, pending);
		BUG_ON(ret);
	}
	return 0;
}

1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058
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;
1059 1060
	if (super->cache_generation != 0 || btrfs_test_opt(root, SPACE_CACHE))
		super->cache_generation = root_item->generation;
1061 1062
}

1063 1064 1065 1066 1067 1068 1069 1070 1071 1072
int btrfs_transaction_in_commit(struct btrfs_fs_info *info)
{
	int ret = 0;
	spin_lock(&info->new_trans_lock);
	if (info->running_transaction)
		ret = info->running_transaction->in_commit;
	spin_unlock(&info->new_trans_lock);
	return ret;
}

1073 1074 1075 1076 1077 1078 1079 1080 1081 1082
int btrfs_transaction_blocked(struct btrfs_fs_info *info)
{
	int ret = 0;
	spin_lock(&info->new_trans_lock);
	if (info->running_transaction)
		ret = info->running_transaction->blocked;
	spin_unlock(&info->new_trans_lock);
	return ret;
}

S
Sage Weil 已提交
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 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165
/*
 * 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;
		}
		mutex_unlock(&root->fs_info->trans_mutex);
		schedule();
		mutex_lock(&root->fs_info->trans_mutex);
		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;
		}
		mutex_unlock(&root->fs_info->trans_mutex);
		schedule();
		mutex_lock(&root->fs_info->trans_mutex);
		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 已提交
1166 1167
	if (!ac)
		return -ENOMEM;
S
Sage Weil 已提交
1168 1169 1170

	INIT_DELAYED_WORK(&ac->work, do_async_commit);
	ac->root = root;
1171
	ac->newtrans = btrfs_join_transaction(root);
1172 1173 1174 1175 1176
	if (IS_ERR(ac->newtrans)) {
		int err = PTR_ERR(ac->newtrans);
		kfree(ac);
		return err;
	}
S
Sage Weil 已提交
1177 1178 1179 1180

	/* take transaction reference */
	mutex_lock(&root->fs_info->trans_mutex);
	cur_trans = trans->transaction;
1181
	atomic_inc(&cur_trans->use_count);
S
Sage Weil 已提交
1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205
	mutex_unlock(&root->fs_info->trans_mutex);

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

	/* wait for transaction to start and unblock */
	mutex_lock(&root->fs_info->trans_mutex);
	if (wait_for_unblock)
		wait_current_trans_commit_start_and_unblock(root, cur_trans);
	else
		wait_current_trans_commit_start(root, cur_trans);
	put_transaction(cur_trans);
	mutex_unlock(&root->fs_info->trans_mutex);

	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 已提交
1206 1207 1208
int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
			     struct btrfs_root *root)
{
1209
	unsigned long joined = 0;
C
Chris Mason 已提交
1210
	struct btrfs_transaction *cur_trans;
C
Chris Mason 已提交
1211
	struct btrfs_transaction *prev_trans = NULL;
C
Chris Mason 已提交
1212
	DEFINE_WAIT(wait);
1213
	int ret;
1214 1215
	int should_grow = 0;
	unsigned long now = get_seconds();
1216
	int flush_on_commit = btrfs_test_opt(root, FLUSHONCOMMIT);
C
Chris Mason 已提交
1217

1218 1219
	btrfs_run_ordered_operations(root, 0);

1220 1221 1222 1223 1224 1225
	/* 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);

1226 1227
	btrfs_trans_release_metadata(trans, root);

1228
	cur_trans = trans->transaction;
1229 1230 1231 1232
	/*
	 * set the flushing flag so procs in this transaction have to
	 * start sending their work down.
	 */
1233
	cur_trans->delayed_refs.flushing = 1;
1234

1235
	ret = btrfs_run_delayed_refs(trans, root, 0);
1236 1237
	BUG_ON(ret);

C
Chris Mason 已提交
1238
	mutex_lock(&root->fs_info->trans_mutex);
1239
	if (cur_trans->in_commit) {
1240
		atomic_inc(&cur_trans->use_count);
C
Chris Mason 已提交
1241
		mutex_unlock(&root->fs_info->trans_mutex);
C
Chris Mason 已提交
1242
		btrfs_end_transaction(trans, root);
C
Chris Mason 已提交
1243

C
Chris Mason 已提交
1244 1245
		ret = wait_for_commit(root, cur_trans);
		BUG_ON(ret);
1246 1247

		mutex_lock(&root->fs_info->trans_mutex);
C
Chris Mason 已提交
1248
		put_transaction(cur_trans);
1249 1250
		mutex_unlock(&root->fs_info->trans_mutex);

C
Chris Mason 已提交
1251 1252
		return 0;
	}
1253

C
Chris Mason 已提交
1254
	trans->transaction->in_commit = 1;
1255
	trans->transaction->blocked = 1;
S
Sage Weil 已提交
1256 1257
	wake_up(&root->fs_info->transaction_blocked_wait);

C
Chris Mason 已提交
1258 1259 1260 1261
	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) {
1262
			atomic_inc(&prev_trans->use_count);
C
Chris Mason 已提交
1263 1264 1265 1266 1267
			mutex_unlock(&root->fs_info->trans_mutex);

			wait_for_commit(root, prev_trans);

			mutex_lock(&root->fs_info->trans_mutex);
1268
			put_transaction(prev_trans);
C
Chris Mason 已提交
1269 1270
		}
	}
1271

1272 1273 1274
	if (now < cur_trans->start_time || now - cur_trans->start_time < 1)
		should_grow = 1;

1275
	do {
1276
		int snap_pending = 0;
1277
		joined = cur_trans->num_joined;
1278 1279 1280
		if (!list_empty(&trans->transaction->pending_snapshots))
			snap_pending = 1;

C
Chris Mason 已提交
1281
		WARN_ON(cur_trans != trans->transaction);
C
Chris Mason 已提交
1282
		mutex_unlock(&root->fs_info->trans_mutex);
1283

1284
		if (flush_on_commit || snap_pending) {
Y
Yan, Zheng 已提交
1285 1286
			btrfs_start_delalloc_inodes(root, 1);
			ret = btrfs_wait_ordered_extents(root, 0, 1);
1287
			BUG_ON(ret);
1288 1289
		}

1290 1291 1292 1293 1294 1295 1296 1297 1298
		/*
		 * 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);

1299 1300 1301
		prepare_to_wait(&cur_trans->writer_wait, &wait,
				TASK_UNINTERRUPTIBLE);

1302
		smp_mb();
1303
		if (atomic_read(&cur_trans->num_writers) > 1)
1304 1305 1306
			schedule_timeout(MAX_SCHEDULE_TIMEOUT);
		else if (should_grow)
			schedule_timeout(1);
1307

C
Chris Mason 已提交
1308
		mutex_lock(&root->fs_info->trans_mutex);
1309
		finish_wait(&cur_trans->writer_wait, &wait);
1310
	} while (atomic_read(&cur_trans->num_writers) > 1 ||
1311
		 (should_grow && cur_trans->num_joined != joined));
1312

1313 1314 1315
	ret = create_pending_snapshots(trans, root->fs_info);
	BUG_ON(ret);

1316 1317 1318
	ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
	BUG_ON(ret);

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

1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335
	/* 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);

1336
	ret = commit_fs_roots(trans, root);
1337 1338
	BUG_ON(ret);

1339
	/* commit_fs_roots gets rid of all the tree log roots, it is now
1340 1341 1342 1343
	 * safe to free the root of tree log roots
	 */
	btrfs_free_log_root_tree(trans, root->fs_info);

1344
	ret = commit_cowonly_roots(trans, root);
C
Chris Mason 已提交
1345
	BUG_ON(ret);
1346

1347 1348
	btrfs_prepare_extent_commit(trans, root);

C
Chris Mason 已提交
1349
	cur_trans = root->fs_info->running_transaction;
1350
	spin_lock(&root->fs_info->new_trans_lock);
C
Chris Mason 已提交
1351
	root->fs_info->running_transaction = NULL;
1352
	spin_unlock(&root->fs_info->new_trans_lock);
1353 1354 1355

	btrfs_set_root_node(&root->fs_info->tree_root->root_item,
			    root->fs_info->tree_root->node);
J
Josef Bacik 已提交
1356
	switch_commit_root(root->fs_info->tree_root);
1357 1358 1359

	btrfs_set_root_node(&root->fs_info->chunk_root->root_item,
			    root->fs_info->chunk_root->node);
J
Josef Bacik 已提交
1360
	switch_commit_root(root->fs_info->chunk_root);
1361 1362

	update_super_roots(root);
1363 1364 1365 1366 1367 1368

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

1369 1370
	memcpy(&root->fs_info->super_for_commit, &root->fs_info->super_copy,
	       sizeof(root->fs_info->super_copy));
C
Chris Mason 已提交
1371

1372
	trans->transaction->blocked = 0;
1373

1374
	wake_up(&root->fs_info->transaction_wait);
1375

C
Chris Mason 已提交
1376
	mutex_unlock(&root->fs_info->trans_mutex);
C
Chris Mason 已提交
1377 1378
	ret = btrfs_write_and_wait_transaction(trans, root);
	BUG_ON(ret);
Y
Yan Zheng 已提交
1379
	write_ctree_super(trans, root, 0);
1380

1381 1382 1383 1384 1385 1386
	/*
	 * the super is written, we can safely allow the tree-loggers
	 * to go about their business
	 */
	mutex_unlock(&root->fs_info->tree_log_mutex);

1387
	btrfs_finish_extent_commit(trans, root);
1388

Z
Zheng Yan 已提交
1389 1390
	mutex_lock(&root->fs_info->trans_mutex);

C
Chris Mason 已提交
1391
	cur_trans->commit_done = 1;
1392

1393
	root->fs_info->last_trans_committed = cur_trans->transid;
J
Josef Bacik 已提交
1394

C
Chris Mason 已提交
1395
	wake_up(&cur_trans->commit_wait);
1396

1397
	list_del_init(&cur_trans->list);
C
Chris Mason 已提交
1398
	put_transaction(cur_trans);
C
Chris Mason 已提交
1399
	put_transaction(cur_trans);
1400

1401 1402
	trace_btrfs_transaction_commit(root);

C
Chris Mason 已提交
1403
	mutex_unlock(&root->fs_info->trans_mutex);
1404

J
Josef Bacik 已提交
1405 1406 1407
	if (current->journal_info == trans)
		current->journal_info = NULL;

C
Chris Mason 已提交
1408
	kmem_cache_free(btrfs_trans_handle_cachep, trans);
Y
Yan, Zheng 已提交
1409 1410 1411 1412

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

C
Chris Mason 已提交
1413 1414 1415
	return ret;
}

C
Chris Mason 已提交
1416 1417 1418
/*
 * interface function to delete all the snapshots we have scheduled for deletion
 */
1419 1420
int btrfs_clean_old_snapshots(struct btrfs_root *root)
{
1421 1422 1423 1424 1425 1426
	LIST_HEAD(list);
	struct btrfs_fs_info *fs_info = root->fs_info;

	mutex_lock(&fs_info->trans_mutex);
	list_splice_init(&fs_info->dead_roots, &list);
	mutex_unlock(&fs_info->trans_mutex);
1427

1428 1429
	while (!list_empty(&list)) {
		root = list_entry(list.next, struct btrfs_root, root_list);
1430 1431 1432 1433
		list_del(&root->root_list);

		if (btrfs_header_backref_rev(root->node) <
		    BTRFS_MIXED_BACKREF_REV)
1434
			btrfs_drop_snapshot(root, NULL, 0);
1435
		else
1436
			btrfs_drop_snapshot(root, NULL, 1);
1437 1438 1439
	}
	return 0;
}