transaction.c 42.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>
25
#include <linux/uuid.h>
C
Chris Mason 已提交
26 27 28
#include "ctree.h"
#include "disk-io.h"
#include "transaction.h"
29
#include "locking.h"
30
#include "tree-log.h"
31
#include "inode-map.h"
32
#include "volumes.h"
C
Chris Mason 已提交
33

34 35
#define BTRFS_ROOT_TRANS_TAG 0

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

J
Josef Bacik 已提交
47 48 49 50 51 52
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 已提交
53 54 55
/*
 * either allocate a new transaction or hop into the existing one
 */
J
Josef Bacik 已提交
56
static noinline int join_transaction(struct btrfs_root *root, int nofail)
C
Chris Mason 已提交
57 58
{
	struct btrfs_transaction *cur_trans;
59
	struct btrfs_fs_info *fs_info = root->fs_info;
J
Josef Bacik 已提交
60

61
	spin_lock(&fs_info->trans_lock);
62
loop:
63
	/* The file system has been taken offline. No new transactions. */
64 65
	if (fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) {
		spin_unlock(&fs_info->trans_lock);
66 67 68
		return -EROFS;
	}

69
	if (fs_info->trans_no_join) {
J
Josef Bacik 已提交
70
		if (!nofail) {
71
			spin_unlock(&fs_info->trans_lock);
J
Josef Bacik 已提交
72 73 74 75
			return -EBUSY;
		}
	}

76
	cur_trans = fs_info->running_transaction;
J
Josef Bacik 已提交
77
	if (cur_trans) {
78
		if (cur_trans->aborted) {
79
			spin_unlock(&fs_info->trans_lock);
80
			return cur_trans->aborted;
81
		}
J
Josef Bacik 已提交
82
		atomic_inc(&cur_trans->use_count);
83
		atomic_inc(&cur_trans->num_writers);
84
		cur_trans->num_joined++;
85
		spin_unlock(&fs_info->trans_lock);
J
Josef Bacik 已提交
86
		return 0;
C
Chris Mason 已提交
87
	}
88
	spin_unlock(&fs_info->trans_lock);
J
Josef Bacik 已提交
89 90 91 92

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

94 95
	spin_lock(&fs_info->trans_lock);
	if (fs_info->running_transaction) {
96 97 98 99
		/*
		 * someone started a transaction after we unlocked.  Make sure
		 * to redo the trans_no_join checks above
		 */
J
Josef Bacik 已提交
100
		kmem_cache_free(btrfs_transaction_cachep, cur_trans);
101
		cur_trans = fs_info->running_transaction;
102
		goto loop;
103 104
	} else if (fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) {
		spin_unlock(&fs_info->trans_lock);
105 106
		kmem_cache_free(btrfs_transaction_cachep, cur_trans);
		return -EROFS;
C
Chris Mason 已提交
107
	}
108

J
Josef Bacik 已提交
109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128
	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;
129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146

	/*
	 * although the tree mod log is per file system and not per transaction,
	 * the log must never go across transaction boundaries.
	 */
	smp_mb();
	if (!list_empty(&fs_info->tree_mod_seq_list)) {
		printk(KERN_ERR "btrfs: tree_mod_seq_list not empty when "
			"creating a fresh transaction\n");
		WARN_ON(1);
	}
	if (!RB_EMPTY_ROOT(&fs_info->tree_mod_log)) {
		printk(KERN_ERR "btrfs: tree_mod_log rb tree not empty when "
			"creating a fresh transaction\n");
		WARN_ON(1);
	}
	atomic_set(&fs_info->tree_mod_seq, 0);

J
Josef Bacik 已提交
147 148 149 150
	spin_lock_init(&cur_trans->commit_lock);
	spin_lock_init(&cur_trans->delayed_refs.lock);

	INIT_LIST_HEAD(&cur_trans->pending_snapshots);
151
	list_add_tail(&cur_trans->list, &fs_info->trans_list);
J
Josef Bacik 已提交
152
	extent_io_tree_init(&cur_trans->dirty_pages,
153 154 155 156
			     fs_info->btree_inode->i_mapping);
	fs_info->generation++;
	cur_trans->transid = fs_info->generation;
	fs_info->running_transaction = cur_trans;
157
	cur_trans->aborted = 0;
158
	spin_unlock(&fs_info->trans_lock);
159

C
Chris Mason 已提交
160 161 162
	return 0;
}

C
Chris Mason 已提交
163
/*
C
Chris Mason 已提交
164 165 166 167
 * 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 已提交
168
 */
C
Chris Mason 已提交
169
static int record_root_in_trans(struct btrfs_trans_handle *trans,
J
Josef Bacik 已提交
170
			       struct btrfs_root *root)
171
{
172
	if (root->ref_cows && root->last_trans < trans->transid) {
173
		WARN_ON(root == root->fs_info->extent_root);
174 175
		WARN_ON(root->commit_root != root->node);

C
Chris Mason 已提交
176 177 178 179 180 181 182 183 184 185 186 187
		/*
		 * 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 已提交
188 189 190 191 192
		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;
		}
193 194 195
		radix_tree_tag_set(&root->fs_info->fs_roots_radix,
			   (unsigned long)root->root_key.objectid,
			   BTRFS_ROOT_TRANS_TAG);
J
Josef Bacik 已提交
196
		spin_unlock(&root->fs_info->fs_roots_radix_lock);
C
Chris Mason 已提交
197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217
		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
		 */
218
		btrfs_init_reloc_root(trans, root);
C
Chris Mason 已提交
219 220
		smp_wmb();
		root->in_trans_setup = 0;
221 222 223
	}
	return 0;
}
224

C
Chris Mason 已提交
225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247

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 已提交
248 249 250 251
/* 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 已提交
252
static void wait_current_trans(struct btrfs_root *root)
C
Chris Mason 已提交
253
{
254
	struct btrfs_transaction *cur_trans;
C
Chris Mason 已提交
255

J
Josef Bacik 已提交
256
	spin_lock(&root->fs_info->trans_lock);
257
	cur_trans = root->fs_info->running_transaction;
C
Chris Mason 已提交
258
	if (cur_trans && cur_trans->blocked) {
259
		atomic_inc(&cur_trans->use_count);
J
Josef Bacik 已提交
260
		spin_unlock(&root->fs_info->trans_lock);
L
Li Zefan 已提交
261 262 263

		wait_event(root->fs_info->transaction_wait,
			   !cur_trans->blocked);
264
		put_transaction(cur_trans);
J
Josef Bacik 已提交
265 266
	} else {
		spin_unlock(&root->fs_info->trans_lock);
267
	}
C
Chris Mason 已提交
268 269
}

270 271 272 273
enum btrfs_trans_type {
	TRANS_START,
	TRANS_JOIN,
	TRANS_USERSPACE,
274
	TRANS_JOIN_NOLOCK,
275 276
};

277 278
static int may_wait_transaction(struct btrfs_root *root, int type)
{
J
Josef Bacik 已提交
279 280 281 282 283 284 285 286
	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))
287
		return 1;
J
Josef Bacik 已提交
288

289 290 291
	return 0;
}

292
static struct btrfs_trans_handle *start_transaction(struct btrfs_root *root,
293
						    u64 num_items, int type)
C
Chris Mason 已提交
294
{
295 296
	struct btrfs_trans_handle *h;
	struct btrfs_transaction *cur_trans;
297
	u64 num_bytes = 0;
C
Chris Mason 已提交
298
	int ret;
299
	u64 qgroup_reserved = 0;
L
liubo 已提交
300 301 302

	if (root->fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR)
		return ERR_PTR(-EROFS);
303 304 305 306 307 308 309 310 311

	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;
	}
312 313 314 315 316 317

	/*
	 * 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) {
318 319 320 321 322 323 324 325
		if (root->fs_info->quota_enabled &&
		    is_fstree(root->root_key.objectid)) {
			qgroup_reserved = num_items * root->leafsize;
			ret = btrfs_qgroup_reserve(root, qgroup_reserved);
			if (ret)
				return ERR_PTR(ret);
		}

326
		num_bytes = btrfs_calc_trans_metadata_size(root, num_items);
327
		ret = btrfs_block_rsv_add(root,
328 329 330 331 332
					  &root->fs_info->trans_block_rsv,
					  num_bytes);
		if (ret)
			return ERR_PTR(ret);
	}
333 334 335 336
again:
	h = kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS);
	if (!h)
		return ERR_PTR(-ENOMEM);
C
Chris Mason 已提交
337

338 339
	sb_start_intwrite(root->fs_info->sb);

340
	if (may_wait_transaction(root, type))
C
Chris Mason 已提交
341
		wait_current_trans(root);
342

J
Josef Bacik 已提交
343 344 345 346 347 348
	do {
		ret = join_transaction(root, type == TRANS_JOIN_NOLOCK);
		if (ret == -EBUSY)
			wait_current_trans(root);
	} while (ret == -EBUSY);

T
Tsutomu Itoh 已提交
349
	if (ret < 0) {
350
		sb_end_intwrite(root->fs_info->sb);
351
		kmem_cache_free(btrfs_trans_handle_cachep, h);
T
Tsutomu Itoh 已提交
352 353
		return ERR_PTR(ret);
	}
354

355 356 357 358
	cur_trans = root->fs_info->running_transaction;

	h->transid = cur_trans->transid;
	h->transaction = cur_trans;
C
Chris Mason 已提交
359
	h->blocks_used = 0;
360
	h->bytes_reserved = 0;
361
	h->root = root;
362
	h->delayed_ref_updates = 0;
363
	h->use_count = 1;
364
	h->adding_csums = 0;
365
	h->block_rsv = NULL;
366
	h->orig_rsv = NULL;
367
	h->aborted = 0;
368
	h->qgroup_reserved = qgroup_reserved;
369 370
	h->delayed_ref_elem.seq = 0;
	INIT_LIST_HEAD(&h->qgroup_ref_list);
371

372 373 374 375 376 377
	smp_mb();
	if (cur_trans->blocked && may_wait_transaction(root, type)) {
		btrfs_commit_transaction(h, root);
		goto again;
	}

378
	if (num_bytes) {
J
Josef Bacik 已提交
379
		trace_btrfs_space_reservation(root->fs_info, "transaction",
380
					      h->transid, num_bytes, 1);
381 382
		h->block_rsv = &root->fs_info->trans_block_rsv;
		h->bytes_reserved = num_bytes;
383
	}
J
Josef Bacik 已提交
384

385
got_it:
J
Josef Bacik 已提交
386
	btrfs_record_root_in_trans(h, root);
387 388 389

	if (!current->journal_info && type != TRANS_USERSPACE)
		current->journal_info = h;
C
Chris Mason 已提交
390 391 392
	return h;
}

393
struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
394
						   int num_items)
395
{
396
	return start_transaction(root, num_items, TRANS_START);
397
}
398
struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root)
399
{
400
	return start_transaction(root, 0, TRANS_JOIN);
401 402
}

403
struct btrfs_trans_handle *btrfs_join_transaction_nolock(struct btrfs_root *root)
404 405 406 407
{
	return start_transaction(root, 0, TRANS_JOIN_NOLOCK);
}

408
struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *root)
409
{
410
	return start_transaction(root, 0, TRANS_USERSPACE);
411 412
}

C
Chris Mason 已提交
413
/* wait for a transaction commit to be fully complete */
414
static noinline void wait_for_commit(struct btrfs_root *root,
415 416
				    struct btrfs_transaction *commit)
{
L
Li Zefan 已提交
417
	wait_event(commit->commit_wait, commit->commit_done);
418 419
}

420 421 422 423 424 425 426 427
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 已提交
428
			goto out;
429 430

		/* find specified transaction */
J
Josef Bacik 已提交
431
		spin_lock(&root->fs_info->trans_lock);
432 433 434
		list_for_each_entry(t, &root->fs_info->trans_list, list) {
			if (t->transid == transid) {
				cur_trans = t;
J
Josef Bacik 已提交
435
				atomic_inc(&cur_trans->use_count);
436 437 438 439 440
				break;
			}
			if (t->transid > transid)
				break;
		}
J
Josef Bacik 已提交
441
		spin_unlock(&root->fs_info->trans_lock);
442 443
		ret = -EINVAL;
		if (!cur_trans)
J
Josef Bacik 已提交
444
			goto out;  /* bad transid */
445 446
	} else {
		/* find newest transaction that is committing | committed */
J
Josef Bacik 已提交
447
		spin_lock(&root->fs_info->trans_lock);
448 449 450 451
		list_for_each_entry_reverse(t, &root->fs_info->trans_list,
					    list) {
			if (t->in_commit) {
				if (t->commit_done)
452
					break;
453
				cur_trans = t;
J
Josef Bacik 已提交
454
				atomic_inc(&cur_trans->use_count);
455 456 457
				break;
			}
		}
J
Josef Bacik 已提交
458
		spin_unlock(&root->fs_info->trans_lock);
459
		if (!cur_trans)
J
Josef Bacik 已提交
460
			goto out;  /* nothing committing|committed */
461 462 463 464 465 466
	}

	wait_for_commit(root, cur_trans);

	put_transaction(cur_trans);
	ret = 0;
J
Josef Bacik 已提交
467
out:
468 469 470
	return ret;
}

C
Chris Mason 已提交
471 472
void btrfs_throttle(struct btrfs_root *root)
{
J
Josef Bacik 已提交
473
	if (!atomic_read(&root->fs_info->open_ioctl_trans))
474
		wait_current_trans(root);
C
Chris Mason 已提交
475 476
}

477 478 479 480
static int should_end_transaction(struct btrfs_trans_handle *trans,
				  struct btrfs_root *root)
{
	int ret;
481 482

	ret = btrfs_block_rsv_check(root, &root->fs_info->global_block_rsv, 5);
483 484 485 486 487 488 489 490
	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;
491
	int err;
492

J
Josef Bacik 已提交
493
	smp_mb();
494 495 496 497 498
	if (cur_trans->blocked || cur_trans->delayed_refs.flushing)
		return 1;

	updates = trans->delayed_ref_updates;
	trans->delayed_ref_updates = 0;
499 500 501 502 503
	if (updates) {
		err = btrfs_run_delayed_refs(trans, root, updates);
		if (err) /* Error code will also eval true */
			return err;
	}
504 505 506 507

	return should_end_transaction(trans, root);
}

508
static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
509
			  struct btrfs_root *root, int throttle, int lock)
C
Chris Mason 已提交
510
{
511
	struct btrfs_transaction *cur_trans = trans->transaction;
512
	struct btrfs_fs_info *info = root->fs_info;
513
	int count = 0;
514
	int err = 0;
515

516 517 518 519 520
	if (--trans->use_count) {
		trans->block_rsv = trans->orig_rsv;
		return 0;
	}

521 522 523 524 525
	/*
	 * do the qgroup accounting as early as possible
	 */
	err = btrfs_delayed_refs_qgroup_accounting(trans, info);

526
	btrfs_trans_release_metadata(trans, root);
527
	trans->block_rsv = NULL;
528 529 530 531 532
	/*
	 * the same root has to be passed to start_transaction and
	 * end_transaction. Subvolume quota depends on this.
	 */
	WARN_ON(trans->root != root);
533 534 535 536 537 538

	if (trans->qgroup_reserved) {
		btrfs_qgroup_free(root, trans->qgroup_reserved);
		trans->qgroup_reserved = 0;
	}

539
	while (count < 2) {
540 541 542 543 544 545 546 547 548 549
		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;
			btrfs_run_delayed_refs(trans, root, cur);
		} else {
			break;
		}
		count++;
550
	}
551 552
	btrfs_trans_release_metadata(trans, root);
	trans->block_rsv = NULL;
553

554 555
	sb_end_intwrite(root->fs_info->sb);

J
Josef Bacik 已提交
556 557
	if (lock && !atomic_read(&root->fs_info->open_ioctl_trans) &&
	    should_end_transaction(trans, root)) {
558
		trans->transaction->blocked = 1;
J
Josef Bacik 已提交
559 560
		smp_wmb();
	}
561

562
	if (lock && cur_trans->blocked && !cur_trans->in_commit) {
563 564 565 566 567 568 569
		if (throttle) {
			/*
			 * We may race with somebody else here so end up having
			 * to call end_transaction on ourselves again, so inc
			 * our use_count.
			 */
			trans->use_count++;
570
			return btrfs_commit_transaction(trans, root);
571
		} else {
572
			wake_up_process(info->transaction_kthread);
573
		}
574 575 576
	}

	WARN_ON(cur_trans != info->running_transaction);
577 578
	WARN_ON(atomic_read(&cur_trans->num_writers) < 1);
	atomic_dec(&cur_trans->num_writers);
579

580
	smp_mb();
C
Chris Mason 已提交
581 582 583
	if (waitqueue_active(&cur_trans->writer_wait))
		wake_up(&cur_trans->writer_wait);
	put_transaction(cur_trans);
J
Josef Bacik 已提交
584 585 586

	if (current->journal_info == trans)
		current->journal_info = NULL;
587

Y
Yan, Zheng 已提交
588 589 590
	if (throttle)
		btrfs_run_delayed_iputs(root);

591 592
	if (trans->aborted ||
	    root->fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) {
593
		err = -EIO;
594
	}
595
	assert_qgroups_uptodate(trans);
596

597 598 599
	memset(trans, 0, sizeof(*trans));
	kmem_cache_free(btrfs_trans_handle_cachep, trans);
	return err;
C
Chris Mason 已提交
600 601
}

602 603 604
int btrfs_end_transaction(struct btrfs_trans_handle *trans,
			  struct btrfs_root *root)
{
605 606 607 608 609 610
	int ret;

	ret = __btrfs_end_transaction(trans, root, 0, 1);
	if (ret)
		return ret;
	return 0;
611 612 613 614 615
}

int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans,
				   struct btrfs_root *root)
{
616 617 618 619 620 621
	int ret;

	ret = __btrfs_end_transaction(trans, root, 1, 1);
	if (ret)
		return ret;
	return 0;
622 623 624 625 626
}

int btrfs_end_transaction_nolock(struct btrfs_trans_handle *trans,
				 struct btrfs_root *root)
{
627 628 629 630 631 632 633 634 635 636 637 638
	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);
639 640
}

C
Chris Mason 已提交
641 642 643
/*
 * 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
644
 * those extents are sent to disk but does not wait on them
C
Chris Mason 已提交
645
 */
646
int btrfs_write_marked_extents(struct btrfs_root *root,
647
			       struct extent_io_tree *dirty_pages, int mark)
C
Chris Mason 已提交
648
{
649
	int err = 0;
650
	int werr = 0;
J
Josef Bacik 已提交
651
	struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
652
	u64 start = 0;
653
	u64 end;
654

J
Josef Bacik 已提交
655 656 657 658 659 660 661 662 663
	while (!find_first_extent_bit(dirty_pages, start, &start, &end,
				      mark)) {
		convert_extent_bit(dirty_pages, start, end, EXTENT_NEED_WAIT, mark,
				   GFP_NOFS);
		err = filemap_fdatawrite_range(mapping, start, end);
		if (err)
			werr = err;
		cond_resched();
		start = end + 1;
664
	}
665 666 667 668 669 670 671 672 673 674 675 676
	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,
677
			      struct extent_io_tree *dirty_pages, int mark)
678 679 680
{
	int err = 0;
	int werr = 0;
J
Josef Bacik 已提交
681
	struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
682 683
	u64 start = 0;
	u64 end;
684

J
Josef Bacik 已提交
685 686 687 688 689 690 691 692
	while (!find_first_extent_bit(dirty_pages, start, &start, &end,
				      EXTENT_NEED_WAIT)) {
		clear_extent_bits(dirty_pages, start, end, EXTENT_NEED_WAIT, GFP_NOFS);
		err = filemap_fdatawait_range(mapping, start, end);
		if (err)
			werr = err;
		cond_resched();
		start = end + 1;
693
	}
694 695 696
	if (err)
		werr = err;
	return werr;
C
Chris Mason 已提交
697 698
}

699 700 701 702 703 704
/*
 * 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,
705
				struct extent_io_tree *dirty_pages, int mark)
706 707 708 709
{
	int ret;
	int ret2;

710 711
	ret = btrfs_write_marked_extents(root, dirty_pages, mark);
	ret2 = btrfs_wait_marked_extents(root, dirty_pages, mark);
712 713 714 715 716 717

	if (ret)
		return ret;
	if (ret2)
		return ret2;
	return 0;
718 719
}

720 721 722 723 724 725 726 727 728
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,
729 730
					   &trans->transaction->dirty_pages,
					   EXTENT_DIRTY);
731 732
}

C
Chris Mason 已提交
733 734 735 736 737 738 739 740 741 742
/*
 * 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.
 */
743 744
static int update_cowonly_root(struct btrfs_trans_handle *trans,
			       struct btrfs_root *root)
C
Chris Mason 已提交
745 746
{
	int ret;
747
	u64 old_root_bytenr;
748
	u64 old_root_used;
749
	struct btrfs_root *tree_root = root->fs_info->tree_root;
C
Chris Mason 已提交
750

751
	old_root_used = btrfs_root_used(&root->root_item);
752
	btrfs_write_dirty_block_groups(trans, root);
753

C
Chris Mason 已提交
754
	while (1) {
755
		old_root_bytenr = btrfs_root_bytenr(&root->root_item);
756 757
		if (old_root_bytenr == root->node->start &&
		    old_root_used == btrfs_root_used(&root->root_item))
C
Chris Mason 已提交
758
			break;
759

760
		btrfs_set_root_node(&root->root_item, root->node);
C
Chris Mason 已提交
761
		ret = btrfs_update_root(trans, tree_root,
762 763
					&root->root_key,
					&root->root_item);
764 765
		if (ret)
			return ret;
766

767
		old_root_used = btrfs_root_used(&root->root_item);
768
		ret = btrfs_write_dirty_block_groups(trans, root);
769 770
		if (ret)
			return ret;
771
	}
772 773 774 775

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

776 777 778
	return 0;
}

C
Chris Mason 已提交
779 780
/*
 * update all the cowonly tree roots on disk
781 782 783 784
 *
 * The error handling in this function may not be obvious. Any of the
 * failures will cause the file system to go offline. We still need
 * to clean up the delayed refs.
C
Chris Mason 已提交
785
 */
786 787
static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans,
					 struct btrfs_root *root)
788 789 790
{
	struct btrfs_fs_info *fs_info = root->fs_info;
	struct list_head *next;
791
	struct extent_buffer *eb;
792
	int ret;
793

794
	ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
795 796
	if (ret)
		return ret;
797

798
	eb = btrfs_lock_root_node(fs_info->tree_root);
799 800
	ret = btrfs_cow_block(trans, fs_info->tree_root, eb, NULL,
			      0, &eb);
801 802
	btrfs_tree_unlock(eb);
	free_extent_buffer(eb);
803

804 805 806
	if (ret)
		return ret;

807
	ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
808 809
	if (ret)
		return ret;
810

811 812 813
	ret = btrfs_run_dev_stats(trans, root->fs_info);
	BUG_ON(ret);

814 815 816 817 818 819 820
	ret = btrfs_run_qgroups(trans, root->fs_info);
	BUG_ON(ret);

	/* run_qgroups might have added some more refs */
	ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
	BUG_ON(ret);

C
Chris Mason 已提交
821
	while (!list_empty(&fs_info->dirty_cowonly_roots)) {
822 823 824
		next = fs_info->dirty_cowonly_roots.next;
		list_del_init(next);
		root = list_entry(next, struct btrfs_root, dirty_list);
825

826 827 828
		ret = update_cowonly_root(trans, root);
		if (ret)
			return ret;
C
Chris Mason 已提交
829
	}
830 831 832 833 834

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

C
Chris Mason 已提交
835 836 837
	return 0;
}

C
Chris Mason 已提交
838 839 840 841 842
/*
 * 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
 */
843
int btrfs_add_dead_root(struct btrfs_root *root)
844
{
J
Josef Bacik 已提交
845
	spin_lock(&root->fs_info->trans_lock);
846
	list_add(&root->root_list, &root->fs_info->dead_roots);
J
Josef Bacik 已提交
847
	spin_unlock(&root->fs_info->trans_lock);
848 849 850
	return 0;
}

C
Chris Mason 已提交
851
/*
852
 * update all the cowonly tree roots on disk
C
Chris Mason 已提交
853
 */
854 855
static noinline int commit_fs_roots(struct btrfs_trans_handle *trans,
				    struct btrfs_root *root)
856 857
{
	struct btrfs_root *gang[8];
858
	struct btrfs_fs_info *fs_info = root->fs_info;
859 860
	int i;
	int ret;
861 862
	int err = 0;

J
Josef Bacik 已提交
863
	spin_lock(&fs_info->fs_roots_radix_lock);
C
Chris Mason 已提交
864
	while (1) {
865 866
		ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix,
						 (void **)gang, 0,
867 868 869 870 871 872
						 ARRAY_SIZE(gang),
						 BTRFS_ROOT_TRANS_TAG);
		if (ret == 0)
			break;
		for (i = 0; i < ret; i++) {
			root = gang[i];
873 874 875
			radix_tree_tag_clear(&fs_info->fs_roots_radix,
					(unsigned long)root->root_key.objectid,
					BTRFS_ROOT_TRANS_TAG);
J
Josef Bacik 已提交
876
			spin_unlock(&fs_info->fs_roots_radix_lock);
Y
Yan Zheng 已提交
877

878
			btrfs_free_log(trans, root);
879
			btrfs_update_reloc_root(trans, root);
880
			btrfs_orphan_commit_root(trans, root);
881

882 883
			btrfs_save_ino_cache(root, trans);

884 885 886 887
			/* see comments in should_cow_block() */
			root->force_cow = 0;
			smp_wmb();

888
			if (root->commit_root != root->node) {
889
				mutex_lock(&root->fs_commit_mutex);
J
Josef Bacik 已提交
890
				switch_commit_root(root);
891 892 893
				btrfs_unpin_free_ino(root);
				mutex_unlock(&root->fs_commit_mutex);

894 895 896
				btrfs_set_root_node(&root->root_item,
						    root->node);
			}
897 898

			err = btrfs_update_root(trans, fs_info->tree_root,
899 900
						&root->root_key,
						&root->root_item);
J
Josef Bacik 已提交
901
			spin_lock(&fs_info->fs_roots_radix_lock);
902 903
			if (err)
				break;
904 905
		}
	}
J
Josef Bacik 已提交
906
	spin_unlock(&fs_info->fs_roots_radix_lock);
907
	return err;
908 909
}

C
Chris Mason 已提交
910 911 912 913
/*
 * defrag a given btree.  If cacheonly == 1, this won't read from the disk,
 * otherwise every leaf in the btree is read and defragged.
 */
914 915 916 917
int btrfs_defrag_root(struct btrfs_root *root, int cacheonly)
{
	struct btrfs_fs_info *info = root->fs_info;
	struct btrfs_trans_handle *trans;
918
	int ret;
919
	unsigned long nr;
920

921
	if (xchg(&root->defrag_running, 1))
922
		return 0;
923

924
	while (1) {
925 926 927 928
		trans = btrfs_start_transaction(root, 0);
		if (IS_ERR(trans))
			return PTR_ERR(trans);

929
		ret = btrfs_defrag_leaves(trans, root, cacheonly);
930

931
		nr = trans->blocks_used;
932
		btrfs_end_transaction(trans, root);
933
		btrfs_btree_balance_dirty(info->tree_root, nr);
934 935
		cond_resched();

936
		if (btrfs_fs_closing(root->fs_info) || ret != -EAGAIN)
937 938 939
			break;
	}
	root->defrag_running = 0;
940
	return ret;
941 942
}

C
Chris Mason 已提交
943 944 945 946
/*
 * new snapshots need to be created at a very specific time in the
 * transaction commit.  This does the actual creation
 */
947
static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
948 949 950 951
				   struct btrfs_fs_info *fs_info,
				   struct btrfs_pending_snapshot *pending)
{
	struct btrfs_key key;
952
	struct btrfs_root_item *new_root_item;
953 954
	struct btrfs_root *tree_root = fs_info->tree_root;
	struct btrfs_root *root = pending->root;
955
	struct btrfs_root *parent_root;
L
Liu Bo 已提交
956
	struct btrfs_block_rsv *rsv;
957
	struct inode *parent_inode;
958
	struct dentry *parent;
959
	struct dentry *dentry;
960
	struct extent_buffer *tmp;
961
	struct extent_buffer *old;
962
	struct timespec cur_time = CURRENT_TIME;
963
	int ret;
964
	u64 to_reserve = 0;
965
	u64 index = 0;
966
	u64 objectid;
L
Li Zefan 已提交
967
	u64 root_flags;
968
	uuid_le new_uuid;
969

L
Liu Bo 已提交
970 971
	rsv = trans->block_rsv;

972 973
	new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS);
	if (!new_root_item) {
974
		ret = pending->error = -ENOMEM;
975 976
		goto fail;
	}
977

978
	ret = btrfs_find_free_objectid(tree_root, &objectid);
979 980
	if (ret) {
		pending->error = ret;
981
		goto fail;
982
	}
983

984
	btrfs_reloc_pre_snapshot(trans, pending, &to_reserve);
985 986

	if (to_reserve > 0) {
987 988
		ret = btrfs_block_rsv_add_noflush(root, &pending->block_rsv,
						  to_reserve);
989 990 991 992 993 994
		if (ret) {
			pending->error = ret;
			goto fail;
		}
	}

A
Arne Jansen 已提交
995 996 997 998 999 1000 1001 1002
	ret = btrfs_qgroup_inherit(trans, fs_info, root->root_key.objectid,
				   objectid, pending->inherit);
	kfree(pending->inherit);
	if (ret) {
		pending->error = ret;
		goto fail;
	}

1003
	key.objectid = objectid;
1004 1005
	key.offset = (u64)-1;
	key.type = BTRFS_ROOT_ITEM_KEY;
1006

1007
	trans->block_rsv = &pending->block_rsv;
1008

1009
	dentry = pending->dentry;
1010 1011
	parent = dget_parent(dentry);
	parent_inode = parent->d_inode;
1012
	parent_root = BTRFS_I(parent_inode)->root;
C
Chris Mason 已提交
1013
	record_root_in_trans(trans, parent_root);
1014

1015 1016 1017
	/*
	 * insert the directory item
	 */
1018
	ret = btrfs_set_inode_index(parent_inode, &index);
1019
	BUG_ON(ret); /* -ENOMEM */
1020
	ret = btrfs_insert_dir_item(trans, parent_root,
1021
				dentry->d_name.name, dentry->d_name.len,
1022
				parent_inode, &key,
1023
				BTRFS_FT_DIR, index);
1024
	if (ret == -EEXIST) {
1025 1026 1027
		pending->error = -EEXIST;
		dput(parent);
		goto fail;
1028 1029 1030
	} else if (ret) {
		goto abort_trans_dput;
	}
1031

1032 1033
	btrfs_i_size_write(parent_inode, parent_inode->i_size +
					 dentry->d_name.len * 2);
1034
	parent_inode->i_mtime = parent_inode->i_ctime = CURRENT_TIME;
1035
	ret = btrfs_update_inode(trans, parent_root, parent_inode);
1036
	if (ret)
1037
		goto abort_trans_dput;
1038

1039 1040 1041 1042 1043 1044 1045
	/*
	 * 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);
1046 1047
	if (ret) { /* Transaction aborted */
		dput(parent);
1048
		goto fail;
1049
	}
1050

C
Chris Mason 已提交
1051
	record_root_in_trans(trans, root);
1052 1053
	btrfs_set_root_last_snapshot(&root->root_item, trans->transid);
	memcpy(new_root_item, &root->root_item, sizeof(*new_root_item));
1054
	btrfs_check_and_init_root_item(new_root_item);
1055

L
Li Zefan 已提交
1056 1057 1058 1059 1060 1061 1062
	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);

1063 1064 1065 1066 1067 1068 1069
	btrfs_set_root_generation_v2(new_root_item,
			trans->transid);
	uuid_le_gen(&new_uuid);
	memcpy(new_root_item->uuid, new_uuid.b, BTRFS_UUID_SIZE);
	memcpy(new_root_item->parent_uuid, root->root_item.uuid,
			BTRFS_UUID_SIZE);
	new_root_item->otime.sec = cpu_to_le64(cur_time.tv_sec);
1070
	new_root_item->otime.nsec = cpu_to_le32(cur_time.tv_nsec);
1071 1072 1073 1074 1075 1076
	btrfs_set_root_otransid(new_root_item, trans->transid);
	memset(&new_root_item->stime, 0, sizeof(new_root_item->stime));
	memset(&new_root_item->rtime, 0, sizeof(new_root_item->rtime));
	btrfs_set_root_stransid(new_root_item, 0);
	btrfs_set_root_rtransid(new_root_item, 0);

1077
	old = btrfs_lock_root_node(root);
1078
	ret = btrfs_cow_block(trans, root, old, NULL, 0, &old);
1079 1080 1081 1082 1083
	if (ret) {
		btrfs_tree_unlock(old);
		free_extent_buffer(old);
		goto abort_trans_dput;
	}
1084

1085 1086
	btrfs_set_lock_blocking(old);

1087
	ret = btrfs_copy_root(trans, root, old, &tmp, objectid);
1088
	/* clean up in any case */
1089 1090
	btrfs_tree_unlock(old);
	free_extent_buffer(old);
1091 1092
	if (ret)
		goto abort_trans_dput;
1093

1094 1095 1096 1097
	/* see comments in should_cow_block() */
	root->force_cow = 1;
	smp_wmb();

1098
	btrfs_set_root_node(new_root_item, tmp);
1099 1100 1101
	/* record when the snapshot was created in key.offset */
	key.offset = trans->transid;
	ret = btrfs_insert_root(trans, tree_root, &key, new_root_item);
1102 1103
	btrfs_tree_unlock(tmp);
	free_extent_buffer(tmp);
1104
	if (ret)
1105
		goto abort_trans_dput;
1106

1107 1108 1109 1110
	/*
	 * insert root back/forward references
	 */
	ret = btrfs_add_root_ref(trans, tree_root, objectid,
1111
				 parent_root->root_key.objectid,
L
Li Zefan 已提交
1112
				 btrfs_ino(parent_inode), index,
1113
				 dentry->d_name.name, dentry->d_name.len);
1114
	dput(parent);
1115 1116
	if (ret)
		goto fail;
1117

1118 1119
	key.offset = (u64)-1;
	pending->snap = btrfs_read_fs_root_no_name(root->fs_info, &key);
1120 1121
	if (IS_ERR(pending->snap)) {
		ret = PTR_ERR(pending->snap);
1122
		goto abort_trans;
1123
	}
1124

1125 1126 1127 1128
	ret = btrfs_reloc_post_snapshot(trans, pending);
	if (ret)
		goto abort_trans;
	ret = 0;
1129
fail:
1130
	kfree(new_root_item);
L
Liu Bo 已提交
1131
	trans->block_rsv = rsv;
1132
	btrfs_block_rsv_release(root, &pending->block_rsv, (u64)-1);
1133 1134
	return ret;

1135 1136
abort_trans_dput:
	dput(parent);
1137 1138 1139
abort_trans:
	btrfs_abort_transaction(trans, root, ret);
	goto fail;
1140 1141
}

C
Chris Mason 已提交
1142 1143 1144
/*
 * create all the snapshots we've scheduled for creation
 */
1145 1146
static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans,
					     struct btrfs_fs_info *fs_info)
1147 1148 1149 1150
{
	struct btrfs_pending_snapshot *pending;
	struct list_head *head = &trans->transaction->pending_snapshots;

1151 1152
	list_for_each_entry(pending, head, list)
		create_pending_snapshot(trans, fs_info, pending);
1153 1154 1155
	return 0;
}

1156 1157 1158 1159 1160
static void update_super_roots(struct btrfs_root *root)
{
	struct btrfs_root_item *root_item;
	struct btrfs_super_block *super;

1161
	super = root->fs_info->super_copy;
1162 1163 1164 1165 1166 1167 1168 1169 1170 1171

	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;
1172
	if (btrfs_test_opt(root, SPACE_CACHE))
1173
		super->cache_generation = root_item->generation;
1174 1175
}

1176 1177 1178
int btrfs_transaction_in_commit(struct btrfs_fs_info *info)
{
	int ret = 0;
J
Josef Bacik 已提交
1179
	spin_lock(&info->trans_lock);
1180 1181
	if (info->running_transaction)
		ret = info->running_transaction->in_commit;
J
Josef Bacik 已提交
1182
	spin_unlock(&info->trans_lock);
1183 1184 1185
	return ret;
}

1186 1187 1188
int btrfs_transaction_blocked(struct btrfs_fs_info *info)
{
	int ret = 0;
J
Josef Bacik 已提交
1189
	spin_lock(&info->trans_lock);
1190 1191
	if (info->running_transaction)
		ret = info->running_transaction->blocked;
J
Josef Bacik 已提交
1192
	spin_unlock(&info->trans_lock);
1193 1194 1195
	return ret;
}

S
Sage Weil 已提交
1196 1197 1198 1199 1200 1201 1202
/*
 * wait for the current transaction commit to start and block subsequent
 * transaction joins
 */
static void wait_current_trans_commit_start(struct btrfs_root *root,
					    struct btrfs_transaction *trans)
{
L
Li Zefan 已提交
1203
	wait_event(root->fs_info->transaction_blocked_wait, trans->in_commit);
S
Sage Weil 已提交
1204 1205 1206 1207 1208 1209 1210 1211 1212
}

/*
 * wait for the current transaction to start and then become unblocked.
 * caller holds ref.
 */
static void wait_current_trans_commit_start_and_unblock(struct btrfs_root *root,
					 struct btrfs_transaction *trans)
{
L
Li Zefan 已提交
1213 1214
	wait_event(root->fs_info->transaction_wait,
		   trans->commit_done || (trans->in_commit && !trans->blocked));
S
Sage Weil 已提交
1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243
}

/*
 * 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 已提交
1244 1245
	if (!ac)
		return -ENOMEM;
S
Sage Weil 已提交
1246 1247 1248

	INIT_DELAYED_WORK(&ac->work, do_async_commit);
	ac->root = root;
1249
	ac->newtrans = btrfs_join_transaction(root);
1250 1251 1252 1253 1254
	if (IS_ERR(ac->newtrans)) {
		int err = PTR_ERR(ac->newtrans);
		kfree(ac);
		return err;
	}
S
Sage Weil 已提交
1255 1256 1257

	/* take transaction reference */
	cur_trans = trans->transaction;
1258
	atomic_inc(&cur_trans->use_count);
S
Sage Weil 已提交
1259 1260 1261 1262 1263 1264 1265 1266 1267 1268

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

1269 1270 1271 1272
	if (current->journal_info == trans)
		current->journal_info = NULL;

	put_transaction(cur_trans);
S
Sage Weil 已提交
1273 1274 1275
	return 0;
}

1276 1277

static void cleanup_transaction(struct btrfs_trans_handle *trans,
1278
				struct btrfs_root *root, int err)
1279 1280 1281 1282 1283
{
	struct btrfs_transaction *cur_trans = trans->transaction;

	WARN_ON(trans->use_count > 1);

1284 1285
	btrfs_abort_transaction(trans, root, err);

1286 1287
	spin_lock(&root->fs_info->trans_lock);
	list_del_init(&cur_trans->list);
1288 1289 1290 1291
	if (cur_trans == root->fs_info->running_transaction) {
		root->fs_info->running_transaction = NULL;
		root->fs_info->trans_no_join = 0;
	}
1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308
	spin_unlock(&root->fs_info->trans_lock);

	btrfs_cleanup_one_transaction(trans->transaction, root);

	put_transaction(cur_trans);
	put_transaction(cur_trans);

	trace_btrfs_transaction_commit(root);

	btrfs_scrub_continue(root);

	if (current->journal_info == trans)
		current->journal_info = NULL;

	kmem_cache_free(btrfs_trans_handle_cachep, trans);
}

S
Sage Weil 已提交
1309 1310 1311 1312 1313 1314 1315
/*
 * btrfs_transaction state sequence:
 *    in_commit = 0, blocked = 0  (initial)
 *    in_commit = 1, blocked = 1
 *    blocked = 0
 *    commit_done = 1
 */
C
Chris Mason 已提交
1316 1317 1318
int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
			     struct btrfs_root *root)
{
1319
	unsigned long joined = 0;
1320
	struct btrfs_transaction *cur_trans = trans->transaction;
C
Chris Mason 已提交
1321
	struct btrfs_transaction *prev_trans = NULL;
C
Chris Mason 已提交
1322
	DEFINE_WAIT(wait);
1323
	int ret = -EIO;
1324 1325
	int should_grow = 0;
	unsigned long now = get_seconds();
1326
	int flush_on_commit = btrfs_test_opt(root, FLUSHONCOMMIT);
C
Chris Mason 已提交
1327

1328 1329
	btrfs_run_ordered_operations(root, 0);

1330 1331 1332
	if (cur_trans->aborted)
		goto cleanup_transaction;

1333 1334 1335 1336
	/* 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);
1337 1338
	if (ret)
		goto cleanup_transaction;
1339

1340 1341 1342
	btrfs_trans_release_metadata(trans, root);
	trans->block_rsv = NULL;

1343
	cur_trans = trans->transaction;
1344

1345 1346 1347 1348
	/*
	 * set the flushing flag so procs in this transaction have to
	 * start sending their work down.
	 */
1349
	cur_trans->delayed_refs.flushing = 1;
1350

1351
	ret = btrfs_run_delayed_refs(trans, root, 0);
1352 1353
	if (ret)
		goto cleanup_transaction;
1354

J
Josef Bacik 已提交
1355
	spin_lock(&cur_trans->commit_lock);
1356
	if (cur_trans->in_commit) {
J
Josef Bacik 已提交
1357
		spin_unlock(&cur_trans->commit_lock);
1358
		atomic_inc(&cur_trans->use_count);
1359
		ret = btrfs_end_transaction(trans, root);
C
Chris Mason 已提交
1360

1361
		wait_for_commit(root, cur_trans);
1362

C
Chris Mason 已提交
1363
		put_transaction(cur_trans);
1364

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

C
Chris Mason 已提交
1368
	trans->transaction->in_commit = 1;
1369
	trans->transaction->blocked = 1;
J
Josef Bacik 已提交
1370
	spin_unlock(&cur_trans->commit_lock);
S
Sage Weil 已提交
1371 1372
	wake_up(&root->fs_info->transaction_blocked_wait);

J
Josef Bacik 已提交
1373
	spin_lock(&root->fs_info->trans_lock);
C
Chris Mason 已提交
1374 1375 1376 1377
	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) {
1378
			atomic_inc(&prev_trans->use_count);
J
Josef Bacik 已提交
1379
			spin_unlock(&root->fs_info->trans_lock);
C
Chris Mason 已提交
1380 1381 1382

			wait_for_commit(root, prev_trans);

1383
			put_transaction(prev_trans);
J
Josef Bacik 已提交
1384 1385
		} else {
			spin_unlock(&root->fs_info->trans_lock);
C
Chris Mason 已提交
1386
		}
J
Josef Bacik 已提交
1387 1388
	} else {
		spin_unlock(&root->fs_info->trans_lock);
C
Chris Mason 已提交
1389
	}
1390

1391 1392
	if (!btrfs_test_opt(root, SSD) &&
	    (now < cur_trans->start_time || now - cur_trans->start_time < 1))
1393 1394
		should_grow = 1;

1395
	do {
1396
		int snap_pending = 0;
J
Josef Bacik 已提交
1397

1398
		joined = cur_trans->num_joined;
1399 1400 1401
		if (!list_empty(&trans->transaction->pending_snapshots))
			snap_pending = 1;

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

1404
		if (flush_on_commit || snap_pending) {
Y
Yan, Zheng 已提交
1405
			btrfs_start_delalloc_inodes(root, 1);
1406
			btrfs_wait_ordered_extents(root, 0, 1);
1407 1408
		}

1409
		ret = btrfs_run_delayed_items(trans, root);
1410 1411
		if (ret)
			goto cleanup_transaction;
1412

1413 1414 1415 1416 1417 1418 1419
		/*
		 * running the delayed items may have added new refs. account
		 * them now so that they hinder processing of more delayed refs
		 * as little as possible.
		 */
		btrfs_delayed_refs_qgroup_accounting(trans, root->fs_info);

1420 1421 1422 1423 1424 1425 1426 1427 1428
		/*
		 * 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);

1429 1430 1431
		prepare_to_wait(&cur_trans->writer_wait, &wait,
				TASK_UNINTERRUPTIBLE);

1432
		if (atomic_read(&cur_trans->num_writers) > 1)
1433 1434 1435
			schedule_timeout(MAX_SCHEDULE_TIMEOUT);
		else if (should_grow)
			schedule_timeout(1);
1436 1437

		finish_wait(&cur_trans->writer_wait, &wait);
1438
	} while (atomic_read(&cur_trans->num_writers) > 1 ||
1439
		 (should_grow && cur_trans->num_joined != joined));
1440

1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451
	/*
	 * 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 已提交
1452 1453 1454 1455 1456 1457 1458
	/*
	 * 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);

1459
	ret = btrfs_run_delayed_items(trans, root);
1460 1461 1462 1463
	if (ret) {
		mutex_unlock(&root->fs_info->reloc_mutex);
		goto cleanup_transaction;
	}
1464

1465
	ret = create_pending_snapshots(trans, root->fs_info);
1466 1467 1468 1469
	if (ret) {
		mutex_unlock(&root->fs_info->reloc_mutex);
		goto cleanup_transaction;
	}
1470

1471
	ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
1472 1473 1474 1475
	if (ret) {
		mutex_unlock(&root->fs_info->reloc_mutex);
		goto cleanup_transaction;
	}
1476

1477 1478 1479 1480 1481 1482
	/*
	 * make sure none of the code above managed to slip in a
	 * delayed item
	 */
	btrfs_assert_delayed_root_empty(root);

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

A
Arne Jansen 已提交
1485
	btrfs_scrub_pause(root);
1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500
	/* 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);

1501
	ret = commit_fs_roots(trans, root);
1502 1503
	if (ret) {
		mutex_unlock(&root->fs_info->tree_log_mutex);
1504
		mutex_unlock(&root->fs_info->reloc_mutex);
1505 1506
		goto cleanup_transaction;
	}
1507

1508
	/* commit_fs_roots gets rid of all the tree log roots, it is now
1509 1510 1511 1512
	 * safe to free the root of tree log roots
	 */
	btrfs_free_log_root_tree(trans, root->fs_info);

1513
	ret = commit_cowonly_roots(trans, root);
1514 1515
	if (ret) {
		mutex_unlock(&root->fs_info->tree_log_mutex);
1516
		mutex_unlock(&root->fs_info->reloc_mutex);
1517 1518
		goto cleanup_transaction;
	}
1519

1520 1521
	btrfs_prepare_extent_commit(trans, root);

C
Chris Mason 已提交
1522
	cur_trans = root->fs_info->running_transaction;
1523 1524 1525

	btrfs_set_root_node(&root->fs_info->tree_root->root_item,
			    root->fs_info->tree_root->node);
J
Josef Bacik 已提交
1526
	switch_commit_root(root->fs_info->tree_root);
1527 1528 1529

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

1532
	assert_qgroups_uptodate(trans);
1533
	update_super_roots(root);
1534 1535

	if (!root->fs_info->log_root_recovering) {
1536 1537
		btrfs_set_super_log_root(root->fs_info->super_copy, 0);
		btrfs_set_super_log_root_level(root->fs_info->super_copy, 0);
1538 1539
	}

1540 1541
	memcpy(root->fs_info->super_for_commit, root->fs_info->super_copy,
	       sizeof(*root->fs_info->super_copy));
C
Chris Mason 已提交
1542

1543
	trans->transaction->blocked = 0;
J
Josef Bacik 已提交
1544 1545 1546 1547
	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 已提交
1548
	mutex_unlock(&root->fs_info->reloc_mutex);
1549

1550
	wake_up(&root->fs_info->transaction_wait);
1551

C
Chris Mason 已提交
1552
	ret = btrfs_write_and_wait_transaction(trans, root);
1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564
	if (ret) {
		btrfs_error(root->fs_info, ret,
			    "Error while writing out transaction.");
		mutex_unlock(&root->fs_info->tree_log_mutex);
		goto cleanup_transaction;
	}

	ret = write_ctree_super(trans, root, 0);
	if (ret) {
		mutex_unlock(&root->fs_info->tree_log_mutex);
		goto cleanup_transaction;
	}
1565

1566 1567 1568 1569 1570 1571
	/*
	 * the super is written, we can safely allow the tree-loggers
	 * to go about their business
	 */
	mutex_unlock(&root->fs_info->tree_log_mutex);

1572
	btrfs_finish_extent_commit(trans, root);
1573

C
Chris Mason 已提交
1574
	cur_trans->commit_done = 1;
1575

1576
	root->fs_info->last_trans_committed = cur_trans->transid;
J
Josef Bacik 已提交
1577

C
Chris Mason 已提交
1578
	wake_up(&cur_trans->commit_wait);
1579

J
Josef Bacik 已提交
1580
	spin_lock(&root->fs_info->trans_lock);
1581
	list_del_init(&cur_trans->list);
J
Josef Bacik 已提交
1582 1583
	spin_unlock(&root->fs_info->trans_lock);

C
Chris Mason 已提交
1584
	put_transaction(cur_trans);
C
Chris Mason 已提交
1585
	put_transaction(cur_trans);
1586

1587 1588
	sb_end_intwrite(root->fs_info->sb);

1589 1590
	trace_btrfs_transaction_commit(root);

A
Arne Jansen 已提交
1591 1592
	btrfs_scrub_continue(root);

J
Josef Bacik 已提交
1593 1594 1595
	if (current->journal_info == trans)
		current->journal_info = NULL;

C
Chris Mason 已提交
1596
	kmem_cache_free(btrfs_trans_handle_cachep, trans);
Y
Yan, Zheng 已提交
1597 1598 1599 1600

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

C
Chris Mason 已提交
1601
	return ret;
1602 1603

cleanup_transaction:
1604 1605
	btrfs_trans_release_metadata(trans, root);
	trans->block_rsv = NULL;
1606 1607 1608 1609
	btrfs_printk(root->fs_info, "Skipping commit of aborted transaction.\n");
//	WARN_ON(1);
	if (current->journal_info == trans)
		current->journal_info = NULL;
1610
	cleanup_transaction(trans, root, ret);
1611 1612

	return ret;
C
Chris Mason 已提交
1613 1614
}

C
Chris Mason 已提交
1615 1616 1617
/*
 * interface function to delete all the snapshots we have scheduled for deletion
 */
1618 1619
int btrfs_clean_old_snapshots(struct btrfs_root *root)
{
1620 1621 1622
	LIST_HEAD(list);
	struct btrfs_fs_info *fs_info = root->fs_info;

J
Josef Bacik 已提交
1623
	spin_lock(&fs_info->trans_lock);
1624
	list_splice_init(&fs_info->dead_roots, &list);
J
Josef Bacik 已提交
1625
	spin_unlock(&fs_info->trans_lock);
1626

1627
	while (!list_empty(&list)) {
1628 1629
		int ret;

1630
		root = list_entry(list.next, struct btrfs_root, root_list);
1631 1632
		list_del(&root->root_list);

1633 1634
		btrfs_kill_all_delayed_nodes(root);

1635 1636
		if (btrfs_header_backref_rev(root->node) <
		    BTRFS_MIXED_BACKREF_REV)
1637
			ret = btrfs_drop_snapshot(root, NULL, 0, 0);
1638
		else
1639 1640
			ret =btrfs_drop_snapshot(root, NULL, 1, 0);
		BUG_ON(ret < 0);
1641 1642 1643
	}
	return 0;
}