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
	u64 num_bytes = 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 281 282 283 284 285 286 287 288 289

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

295
	if (may_wait_transaction(root, type))
C
Chris Mason 已提交
296
		wait_current_trans(root);
297

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

T
Tsutomu Itoh 已提交
304
	if (ret < 0) {
305
		kmem_cache_free(btrfs_trans_handle_cachep, h);
T
Tsutomu Itoh 已提交
306 307
		return ERR_PTR(ret);
	}
308

309 310 311 312
	cur_trans = root->fs_info->running_transaction;

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

320 321 322 323 324 325
	smp_mb();
	if (cur_trans->blocked && may_wait_transaction(root, type)) {
		btrfs_commit_transaction(h, root);
		goto again;
	}

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

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

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

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

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

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

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

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

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

	wait_for_commit(root, cur_trans);

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

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

432 433 434 435 436 437 438 439 440 441 442 443 444 445 446
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 已提交
447
	smp_mb();
448 449 450 451 452 453 454 455 456 457 458
	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);
}

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

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

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

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

491 492
	btrfs_trans_release_metadata(trans, root);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

603 604 605 606 607 608 609 610 611
			if (PageWriteback(page)) {
				if (PageDirty(page))
					wait_on_page_writeback(page);
				else {
					unlock_page(page);
					page_cache_release(page);
					continue;
				}
			}
612 613 614 615 616 617
			err = write_one_page(page, 0);
			if (err)
				werr = err;
			page_cache_release(page);
		}
	}
618 619 620 621 622 623 624 625 626 627 628 629
	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,
630
			      struct extent_io_tree *dirty_pages, int mark)
631 632 633 634 635 636 637 638 639 640
{
	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 已提交
641
	while (1) {
642 643
		ret = find_first_extent_bit(dirty_pages, start, &start, &end,
					    mark);
644 645 646
		if (ret)
			break;

647
		clear_extent_bits(dirty_pages, start, end, mark, GFP_NOFS);
C
Chris Mason 已提交
648
		while (start <= end) {
649 650 651 652 653 654
			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 已提交
655 656
				btree_lock_page_hook(page);
				wait_on_page_writeback(page);
657 658 659 660
				err = write_one_page(page, 0);
				if (err)
					werr = err;
			}
661
			wait_on_page_writeback(page);
662 663 664 665
			page_cache_release(page);
			cond_resched();
		}
	}
666 667 668
	if (err)
		werr = err;
	return werr;
C
Chris Mason 已提交
669 670
}

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

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

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

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

718
	old_root_used = btrfs_root_used(&root->root_item);
719
	btrfs_write_dirty_block_groups(trans, root);
720

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

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

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

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

741 742 743
	return 0;
}

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

755 756
	ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
	BUG_ON(ret);
757

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

763 764
	ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
	BUG_ON(ret);
765

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

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

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

C
Chris Mason 已提交
778 779 780
	return 0;
}

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

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

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

821
			btrfs_free_log(trans, root);
822
			btrfs_update_reloc_root(trans, root);
823
			btrfs_orphan_commit_root(trans, root);
824

825 826
			btrfs_save_ino_cache(root, trans);

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

833 834 835
				btrfs_set_root_node(&root->root_item,
						    root->node);
			}
836 837

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

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

860
	if (xchg(&root->defrag_running, 1))
861
		return 0;
862

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

868
		ret = btrfs_defrag_leaves(trans, root, cacheonly);
869

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

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

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

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

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

918
	btrfs_reloc_pre_snapshot(trans, pending, &to_reserve);
919 920 921 922
	btrfs_orphan_pre_snapshot(trans, pending, &to_reserve);

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

930
	key.objectid = objectid;
931 932
	key.offset = (u64)-1;
	key.type = BTRFS_ROOT_ITEM_KEY;
933

934
	trans->block_rsv = &pending->block_rsv;
935

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1178 1179 1180 1181
	if (current->journal_info == trans)
		current->journal_info = NULL;

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

1204 1205
	btrfs_run_ordered_operations(root, 0);

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

1212 1213
	btrfs_trans_release_metadata(trans, root);

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

1221
	ret = btrfs_run_delayed_refs(trans, root, 0);
1222 1223
	BUG_ON(ret);

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

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

C
Chris Mason 已提交
1233
		put_transaction(cur_trans);
1234

C
Chris Mason 已提交
1235 1236
		return 0;
	}
1237

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

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

			wait_for_commit(root, prev_trans);

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

1261 1262 1263
	if (now < cur_trans->start_time || now - cur_trans->start_time < 1)
		should_grow = 1;

1264
	do {
1265
		int snap_pending = 0;
J
Josef Bacik 已提交
1266

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

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

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

1279 1280 1281
		ret = btrfs_run_delayed_items(trans, root);
		BUG_ON(ret);

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

1291 1292 1293
		prepare_to_wait(&cur_trans->writer_wait, &wait,
				TASK_UNINTERRUPTIBLE);

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

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

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

1321
	ret = btrfs_run_delayed_items(trans, root);
1322 1323
	BUG_ON(ret);

1324
	ret = create_pending_snapshots(trans, root->fs_info);
1325 1326
	BUG_ON(ret);

1327 1328 1329
	ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
	BUG_ON(ret);

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

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

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

1354
	ret = commit_fs_roots(trans, root);
1355 1356
	BUG_ON(ret);

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

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

1365 1366
	btrfs_prepare_extent_commit(trans, root);

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

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

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

	update_super_roots(root);
1378 1379 1380 1381 1382 1383

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

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

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

1394
	wake_up(&root->fs_info->transaction_wait);
1395

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

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

1406
	btrfs_finish_extent_commit(trans, root);
1407

C
Chris Mason 已提交
1408
	cur_trans->commit_done = 1;
1409

1410
	root->fs_info->last_trans_committed = cur_trans->transid;
J
Josef Bacik 已提交
1411

C
Chris Mason 已提交
1412
	wake_up(&cur_trans->commit_wait);
1413

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

C
Chris Mason 已提交
1418
	put_transaction(cur_trans);
C
Chris Mason 已提交
1419
	put_transaction(cur_trans);
1420

1421 1422
	trace_btrfs_transaction_commit(root);

A
Arne Jansen 已提交
1423 1424
	btrfs_scrub_continue(root);

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

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

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

C
Chris Mason 已提交
1433 1434 1435
	return ret;
}

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

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

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

1452 1453
		btrfs_kill_all_delayed_nodes(root);

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