transaction.c 41.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"
31
#include "volumes.h"
C
Chris Mason 已提交
32

33 34
#define BTRFS_ROOT_TRANS_TAG 0

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

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

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

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

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

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

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

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

	/*
	 * 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 已提交
146 147 148 149
	spin_lock_init(&cur_trans->commit_lock);
	spin_lock_init(&cur_trans->delayed_refs.lock);

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

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

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

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

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

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

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

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

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

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

288 289 290
	return 0;
}

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

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

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

	/*
	 * 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) {
317 318 319 320 321 322 323 324
		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);
		}

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

337
	if (may_wait_transaction(root, type))
C
Chris Mason 已提交
338
		wait_current_trans(root);
339

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

T
Tsutomu Itoh 已提交
346
	if (ret < 0) {
347
		kmem_cache_free(btrfs_trans_handle_cachep, h);
T
Tsutomu Itoh 已提交
348 349
		return ERR_PTR(ret);
	}
350

351 352 353 354
	cur_trans = root->fs_info->running_transaction;

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

367 368 369 370 371 372
	smp_mb();
	if (cur_trans->blocked && may_wait_transaction(root, type)) {
		btrfs_commit_transaction(h, root);
		goto again;
	}

373
	if (num_bytes) {
J
Josef Bacik 已提交
374
		trace_btrfs_space_reservation(root->fs_info, "transaction",
375
					      h->transid, num_bytes, 1);
376 377
		h->block_rsv = &root->fs_info->trans_block_rsv;
		h->bytes_reserved = num_bytes;
378
	}
J
Josef Bacik 已提交
379

380
got_it:
J
Josef Bacik 已提交
381
	btrfs_record_root_in_trans(h, root);
382 383 384

	if (!current->journal_info && type != TRANS_USERSPACE)
		current->journal_info = h;
C
Chris Mason 已提交
385 386 387
	return h;
}

388
struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
389
						   int num_items)
390
{
391
	return start_transaction(root, num_items, TRANS_START);
392
}
393
struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root)
394
{
395
	return start_transaction(root, 0, TRANS_JOIN);
396 397
}

398
struct btrfs_trans_handle *btrfs_join_transaction_nolock(struct btrfs_root *root)
399 400 401 402
{
	return start_transaction(root, 0, TRANS_JOIN_NOLOCK);
}

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

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

415 416 417 418 419 420 421 422
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 已提交
423
			goto out;
424 425

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

	wait_for_commit(root, cur_trans);

	put_transaction(cur_trans);
	ret = 0;
J
Josef Bacik 已提交
462
out:
463 464 465
	return ret;
}

C
Chris Mason 已提交
466 467
void btrfs_throttle(struct btrfs_root *root)
{
J
Josef Bacik 已提交
468
	if (!atomic_read(&root->fs_info->open_ioctl_trans))
469
		wait_current_trans(root);
C
Chris Mason 已提交
470 471
}

472 473 474 475
static int should_end_transaction(struct btrfs_trans_handle *trans,
				  struct btrfs_root *root)
{
	int ret;
476 477

	ret = btrfs_block_rsv_check(root, &root->fs_info->global_block_rsv, 5);
478 479 480 481 482 483 484
	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;
485
	struct btrfs_block_rsv *rsv = trans->block_rsv;
486
	int updates;
487
	int err;
488

J
Josef Bacik 已提交
489
	smp_mb();
490 491 492
	if (cur_trans->blocked || cur_trans->delayed_refs.flushing)
		return 1;

493 494 495 496 497 498
	/*
	 * We need to do this in case we're deleting csums so the global block
	 * rsv get's used instead of the csum block rsv.
	 */
	trans->block_rsv = NULL;

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

507 508
	trans->block_rsv = rsv;

509 510 511
	return should_end_transaction(trans, root);
}

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

520 521 522 523 524
	if (--trans->use_count) {
		trans->block_rsv = trans->orig_rsv;
		return 0;
	}

525 526 527 528 529
	/*
	 * do the qgroup accounting as early as possible
	 */
	err = btrfs_delayed_refs_qgroup_accounting(trans, info);

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

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

543
	while (count < 2) {
544 545 546 547 548 549 550 551 552 553
		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++;
554 555
	}

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
	int ret;
963
	u64 to_reserve = 0;
964
	u64 index = 0;
965
	u64 objectid;
L
Li Zefan 已提交
966
	u64 root_flags;
967

L
Liu Bo 已提交
968 969
	rsv = trans->block_rsv;

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

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

982
	btrfs_reloc_pre_snapshot(trans, pending, &to_reserve);
983 984

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

993
	key.objectid = objectid;
994 995
	key.offset = (u64)-1;
	key.type = BTRFS_ROOT_ITEM_KEY;
996

997
	trans->block_rsv = &pending->block_rsv;
998

999
	dentry = pending->dentry;
1000 1001
	parent = dget_parent(dentry);
	parent_inode = parent->d_inode;
1002
	parent_root = BTRFS_I(parent_inode)->root;
C
Chris Mason 已提交
1003
	record_root_in_trans(trans, parent_root);
1004

1005 1006 1007
	/*
	 * insert the directory item
	 */
1008
	ret = btrfs_set_inode_index(parent_inode, &index);
1009
	BUG_ON(ret); /* -ENOMEM */
1010
	ret = btrfs_insert_dir_item(trans, parent_root,
1011
				dentry->d_name.name, dentry->d_name.len,
1012
				parent_inode, &key,
1013
				BTRFS_FT_DIR, index);
1014
	if (ret == -EEXIST) {
1015 1016 1017
		pending->error = -EEXIST;
		dput(parent);
		goto fail;
1018 1019 1020
	} else if (ret) {
		goto abort_trans_dput;
	}
1021

1022 1023
	btrfs_i_size_write(parent_inode, parent_inode->i_size +
					 dentry->d_name.len * 2);
1024
	ret = btrfs_update_inode(trans, parent_root, parent_inode);
1025
	if (ret)
1026
		goto abort_trans_dput;
1027

1028 1029 1030 1031 1032 1033 1034
	/*
	 * 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);
1035 1036
	if (ret) { /* Transaction aborted */
		dput(parent);
1037
		goto fail;
1038
	}
1039

C
Chris Mason 已提交
1040
	record_root_in_trans(trans, root);
1041 1042
	btrfs_set_root_last_snapshot(&root->root_item, trans->transid);
	memcpy(new_root_item, &root->root_item, sizeof(*new_root_item));
1043
	btrfs_check_and_init_root_item(new_root_item);
1044

L
Li Zefan 已提交
1045 1046 1047 1048 1049 1050 1051
	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);

1052
	old = btrfs_lock_root_node(root);
1053
	ret = btrfs_cow_block(trans, root, old, NULL, 0, &old);
1054 1055 1056 1057 1058
	if (ret) {
		btrfs_tree_unlock(old);
		free_extent_buffer(old);
		goto abort_trans_dput;
	}
1059

1060 1061
	btrfs_set_lock_blocking(old);

1062
	ret = btrfs_copy_root(trans, root, old, &tmp, objectid);
1063
	/* clean up in any case */
1064 1065
	btrfs_tree_unlock(old);
	free_extent_buffer(old);
1066 1067
	if (ret)
		goto abort_trans_dput;
1068

1069 1070 1071 1072
	/* see comments in should_cow_block() */
	root->force_cow = 1;
	smp_wmb();

1073
	btrfs_set_root_node(new_root_item, tmp);
1074 1075 1076
	/* record when the snapshot was created in key.offset */
	key.offset = trans->transid;
	ret = btrfs_insert_root(trans, tree_root, &key, new_root_item);
1077 1078
	btrfs_tree_unlock(tmp);
	free_extent_buffer(tmp);
1079
	if (ret)
1080
		goto abort_trans_dput;
1081

1082 1083 1084 1085
	/*
	 * insert root back/forward references
	 */
	ret = btrfs_add_root_ref(trans, tree_root, objectid,
1086
				 parent_root->root_key.objectid,
L
Li Zefan 已提交
1087
				 btrfs_ino(parent_inode), index,
1088
				 dentry->d_name.name, dentry->d_name.len);
1089
	dput(parent);
1090 1091
	if (ret)
		goto fail;
1092

1093 1094
	key.offset = (u64)-1;
	pending->snap = btrfs_read_fs_root_no_name(root->fs_info, &key);
1095 1096
	if (IS_ERR(pending->snap)) {
		ret = PTR_ERR(pending->snap);
1097
		goto abort_trans;
1098
	}
1099

1100 1101 1102 1103
	ret = btrfs_reloc_post_snapshot(trans, pending);
	if (ret)
		goto abort_trans;
	ret = 0;
1104
fail:
1105
	kfree(new_root_item);
L
Liu Bo 已提交
1106
	trans->block_rsv = rsv;
1107
	btrfs_block_rsv_release(root, &pending->block_rsv, (u64)-1);
1108 1109
	return ret;

1110 1111
abort_trans_dput:
	dput(parent);
1112 1113 1114
abort_trans:
	btrfs_abort_transaction(trans, root, ret);
	goto fail;
1115 1116
}

C
Chris Mason 已提交
1117 1118 1119
/*
 * create all the snapshots we've scheduled for creation
 */
1120 1121
static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans,
					     struct btrfs_fs_info *fs_info)
1122 1123 1124 1125
{
	struct btrfs_pending_snapshot *pending;
	struct list_head *head = &trans->transaction->pending_snapshots;

1126 1127
	list_for_each_entry(pending, head, list)
		create_pending_snapshot(trans, fs_info, pending);
1128 1129 1130
	return 0;
}

1131 1132 1133 1134 1135
static void update_super_roots(struct btrfs_root *root)
{
	struct btrfs_root_item *root_item;
	struct btrfs_super_block *super;

1136
	super = root->fs_info->super_copy;
1137 1138 1139 1140 1141 1142 1143 1144 1145 1146

	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;
1147
	if (btrfs_test_opt(root, SPACE_CACHE))
1148
		super->cache_generation = root_item->generation;
1149 1150
}

1151 1152 1153
int btrfs_transaction_in_commit(struct btrfs_fs_info *info)
{
	int ret = 0;
J
Josef Bacik 已提交
1154
	spin_lock(&info->trans_lock);
1155 1156
	if (info->running_transaction)
		ret = info->running_transaction->in_commit;
J
Josef Bacik 已提交
1157
	spin_unlock(&info->trans_lock);
1158 1159 1160
	return ret;
}

1161 1162 1163
int btrfs_transaction_blocked(struct btrfs_fs_info *info)
{
	int ret = 0;
J
Josef Bacik 已提交
1164
	spin_lock(&info->trans_lock);
1165 1166
	if (info->running_transaction)
		ret = info->running_transaction->blocked;
J
Josef Bacik 已提交
1167
	spin_unlock(&info->trans_lock);
1168 1169 1170
	return ret;
}

S
Sage Weil 已提交
1171 1172 1173 1174 1175 1176 1177
/*
 * 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 已提交
1178
	wait_event(root->fs_info->transaction_blocked_wait, trans->in_commit);
S
Sage Weil 已提交
1179 1180 1181 1182 1183 1184 1185 1186 1187
}

/*
 * 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 已提交
1188 1189
	wait_event(root->fs_info->transaction_wait,
		   trans->commit_done || (trans->in_commit && !trans->blocked));
S
Sage Weil 已提交
1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218
}

/*
 * 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 已提交
1219 1220
	if (!ac)
		return -ENOMEM;
S
Sage Weil 已提交
1221 1222 1223

	INIT_DELAYED_WORK(&ac->work, do_async_commit);
	ac->root = root;
1224
	ac->newtrans = btrfs_join_transaction(root);
1225 1226 1227 1228 1229
	if (IS_ERR(ac->newtrans)) {
		int err = PTR_ERR(ac->newtrans);
		kfree(ac);
		return err;
	}
S
Sage Weil 已提交
1230 1231 1232

	/* take transaction reference */
	cur_trans = trans->transaction;
1233
	atomic_inc(&cur_trans->use_count);
S
Sage Weil 已提交
1234 1235 1236 1237 1238 1239 1240 1241 1242 1243

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

1244 1245 1246 1247
	if (current->journal_info == trans)
		current->journal_info = NULL;

	put_transaction(cur_trans);
S
Sage Weil 已提交
1248 1249 1250
	return 0;
}

1251 1252

static void cleanup_transaction(struct btrfs_trans_handle *trans,
1253
				struct btrfs_root *root, int err)
1254 1255 1256 1257 1258
{
	struct btrfs_transaction *cur_trans = trans->transaction;

	WARN_ON(trans->use_count > 1);

1259 1260
	btrfs_abort_transaction(trans, root, err);

1261 1262
	spin_lock(&root->fs_info->trans_lock);
	list_del_init(&cur_trans->list);
1263 1264 1265 1266
	if (cur_trans == root->fs_info->running_transaction) {
		root->fs_info->running_transaction = NULL;
		root->fs_info->trans_no_join = 0;
	}
1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283
	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 已提交
1284 1285 1286 1287 1288 1289 1290
/*
 * btrfs_transaction state sequence:
 *    in_commit = 0, blocked = 0  (initial)
 *    in_commit = 1, blocked = 1
 *    blocked = 0
 *    commit_done = 1
 */
C
Chris Mason 已提交
1291 1292 1293
int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
			     struct btrfs_root *root)
{
1294
	unsigned long joined = 0;
1295
	struct btrfs_transaction *cur_trans = trans->transaction;
C
Chris Mason 已提交
1296
	struct btrfs_transaction *prev_trans = NULL;
C
Chris Mason 已提交
1297
	DEFINE_WAIT(wait);
1298
	int ret = -EIO;
1299 1300
	int should_grow = 0;
	unsigned long now = get_seconds();
1301
	int flush_on_commit = btrfs_test_opt(root, FLUSHONCOMMIT);
C
Chris Mason 已提交
1302

1303 1304
	btrfs_run_ordered_operations(root, 0);

1305
	btrfs_trans_release_metadata(trans, root);
1306 1307
	trans->block_rsv = NULL;

1308 1309 1310
	if (cur_trans->aborted)
		goto cleanup_transaction;

1311 1312 1313 1314
	/* 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);
1315 1316
	if (ret)
		goto cleanup_transaction;
1317

1318
	cur_trans = trans->transaction;
1319

1320 1321 1322 1323
	/*
	 * set the flushing flag so procs in this transaction have to
	 * start sending their work down.
	 */
1324
	cur_trans->delayed_refs.flushing = 1;
1325

1326
	ret = btrfs_run_delayed_refs(trans, root, 0);
1327 1328
	if (ret)
		goto cleanup_transaction;
1329

J
Josef Bacik 已提交
1330
	spin_lock(&cur_trans->commit_lock);
1331
	if (cur_trans->in_commit) {
J
Josef Bacik 已提交
1332
		spin_unlock(&cur_trans->commit_lock);
1333
		atomic_inc(&cur_trans->use_count);
1334
		ret = btrfs_end_transaction(trans, root);
C
Chris Mason 已提交
1335

1336
		wait_for_commit(root, cur_trans);
1337

C
Chris Mason 已提交
1338
		put_transaction(cur_trans);
1339

1340
		return ret;
C
Chris Mason 已提交
1341
	}
1342

C
Chris Mason 已提交
1343
	trans->transaction->in_commit = 1;
1344
	trans->transaction->blocked = 1;
J
Josef Bacik 已提交
1345
	spin_unlock(&cur_trans->commit_lock);
S
Sage Weil 已提交
1346 1347
	wake_up(&root->fs_info->transaction_blocked_wait);

J
Josef Bacik 已提交
1348
	spin_lock(&root->fs_info->trans_lock);
C
Chris Mason 已提交
1349 1350 1351 1352
	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) {
1353
			atomic_inc(&prev_trans->use_count);
J
Josef Bacik 已提交
1354
			spin_unlock(&root->fs_info->trans_lock);
C
Chris Mason 已提交
1355 1356 1357

			wait_for_commit(root, prev_trans);

1358
			put_transaction(prev_trans);
J
Josef Bacik 已提交
1359 1360
		} else {
			spin_unlock(&root->fs_info->trans_lock);
C
Chris Mason 已提交
1361
		}
J
Josef Bacik 已提交
1362 1363
	} else {
		spin_unlock(&root->fs_info->trans_lock);
C
Chris Mason 已提交
1364
	}
1365

1366 1367 1368
	if (now < cur_trans->start_time || now - cur_trans->start_time < 1)
		should_grow = 1;

1369
	do {
1370
		int snap_pending = 0;
J
Josef Bacik 已提交
1371

1372
		joined = cur_trans->num_joined;
1373 1374 1375
		if (!list_empty(&trans->transaction->pending_snapshots))
			snap_pending = 1;

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

1378
		if (flush_on_commit || snap_pending) {
Y
Yan, Zheng 已提交
1379
			btrfs_start_delalloc_inodes(root, 1);
1380
			btrfs_wait_ordered_extents(root, 0, 1);
1381 1382
		}

1383
		ret = btrfs_run_delayed_items(trans, root);
1384 1385
		if (ret)
			goto cleanup_transaction;
1386

1387 1388 1389 1390 1391 1392 1393
		/*
		 * 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);

1394 1395 1396 1397 1398 1399 1400 1401 1402
		/*
		 * 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);

1403 1404 1405
		prepare_to_wait(&cur_trans->writer_wait, &wait,
				TASK_UNINTERRUPTIBLE);

1406
		if (atomic_read(&cur_trans->num_writers) > 1)
1407 1408 1409
			schedule_timeout(MAX_SCHEDULE_TIMEOUT);
		else if (should_grow)
			schedule_timeout(1);
1410 1411

		finish_wait(&cur_trans->writer_wait, &wait);
1412
	} while (atomic_read(&cur_trans->num_writers) > 1 ||
1413
		 (should_grow && cur_trans->num_joined != joined));
1414

1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425
	/*
	 * 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 已提交
1426 1427 1428 1429 1430 1431 1432
	/*
	 * 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);

1433
	ret = btrfs_run_delayed_items(trans, root);
1434 1435 1436 1437
	if (ret) {
		mutex_unlock(&root->fs_info->reloc_mutex);
		goto cleanup_transaction;
	}
1438

1439
	ret = create_pending_snapshots(trans, root->fs_info);
1440 1441 1442 1443
	if (ret) {
		mutex_unlock(&root->fs_info->reloc_mutex);
		goto cleanup_transaction;
	}
1444

1445
	ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
1446 1447 1448 1449
	if (ret) {
		mutex_unlock(&root->fs_info->reloc_mutex);
		goto cleanup_transaction;
	}
1450

1451 1452 1453 1454 1455 1456
	/*
	 * make sure none of the code above managed to slip in a
	 * delayed item
	 */
	btrfs_assert_delayed_root_empty(root);

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

A
Arne Jansen 已提交
1459
	btrfs_scrub_pause(root);
1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474
	/* 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);

1475
	ret = commit_fs_roots(trans, root);
1476 1477
	if (ret) {
		mutex_unlock(&root->fs_info->tree_log_mutex);
1478
		mutex_unlock(&root->fs_info->reloc_mutex);
1479 1480
		goto cleanup_transaction;
	}
1481

1482
	/* commit_fs_roots gets rid of all the tree log roots, it is now
1483 1484 1485 1486
	 * safe to free the root of tree log roots
	 */
	btrfs_free_log_root_tree(trans, root->fs_info);

1487
	ret = commit_cowonly_roots(trans, root);
1488 1489
	if (ret) {
		mutex_unlock(&root->fs_info->tree_log_mutex);
1490
		mutex_unlock(&root->fs_info->reloc_mutex);
1491 1492
		goto cleanup_transaction;
	}
1493

1494 1495
	btrfs_prepare_extent_commit(trans, root);

C
Chris Mason 已提交
1496
	cur_trans = root->fs_info->running_transaction;
1497 1498 1499

	btrfs_set_root_node(&root->fs_info->tree_root->root_item,
			    root->fs_info->tree_root->node);
J
Josef Bacik 已提交
1500
	switch_commit_root(root->fs_info->tree_root);
1501 1502 1503

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

1506
	assert_qgroups_uptodate(trans);
1507
	update_super_roots(root);
1508 1509

	if (!root->fs_info->log_root_recovering) {
1510 1511
		btrfs_set_super_log_root(root->fs_info->super_copy, 0);
		btrfs_set_super_log_root_level(root->fs_info->super_copy, 0);
1512 1513
	}

1514 1515
	memcpy(root->fs_info->super_for_commit, root->fs_info->super_copy,
	       sizeof(*root->fs_info->super_copy));
C
Chris Mason 已提交
1516

1517
	trans->transaction->blocked = 0;
J
Josef Bacik 已提交
1518 1519 1520 1521
	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 已提交
1522
	mutex_unlock(&root->fs_info->reloc_mutex);
1523

1524
	wake_up(&root->fs_info->transaction_wait);
1525

C
Chris Mason 已提交
1526
	ret = btrfs_write_and_wait_transaction(trans, root);
1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538
	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;
	}
1539

1540 1541 1542 1543 1544 1545
	/*
	 * the super is written, we can safely allow the tree-loggers
	 * to go about their business
	 */
	mutex_unlock(&root->fs_info->tree_log_mutex);

1546
	btrfs_finish_extent_commit(trans, root);
1547

C
Chris Mason 已提交
1548
	cur_trans->commit_done = 1;
1549

1550
	root->fs_info->last_trans_committed = cur_trans->transid;
J
Josef Bacik 已提交
1551

C
Chris Mason 已提交
1552
	wake_up(&cur_trans->commit_wait);
1553

J
Josef Bacik 已提交
1554
	spin_lock(&root->fs_info->trans_lock);
1555
	list_del_init(&cur_trans->list);
J
Josef Bacik 已提交
1556 1557
	spin_unlock(&root->fs_info->trans_lock);

C
Chris Mason 已提交
1558
	put_transaction(cur_trans);
C
Chris Mason 已提交
1559
	put_transaction(cur_trans);
1560

1561 1562
	trace_btrfs_transaction_commit(root);

A
Arne Jansen 已提交
1563 1564
	btrfs_scrub_continue(root);

J
Josef Bacik 已提交
1565 1566 1567
	if (current->journal_info == trans)
		current->journal_info = NULL;

C
Chris Mason 已提交
1568
	kmem_cache_free(btrfs_trans_handle_cachep, trans);
Y
Yan, Zheng 已提交
1569 1570 1571 1572

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

C
Chris Mason 已提交
1573
	return ret;
1574 1575 1576 1577 1578 1579

cleanup_transaction:
	btrfs_printk(root->fs_info, "Skipping commit of aborted transaction.\n");
//	WARN_ON(1);
	if (current->journal_info == trans)
		current->journal_info = NULL;
1580
	cleanup_transaction(trans, root, ret);
1581 1582

	return ret;
C
Chris Mason 已提交
1583 1584
}

C
Chris Mason 已提交
1585 1586 1587
/*
 * interface function to delete all the snapshots we have scheduled for deletion
 */
1588 1589
int btrfs_clean_old_snapshots(struct btrfs_root *root)
{
1590 1591 1592
	LIST_HEAD(list);
	struct btrfs_fs_info *fs_info = root->fs_info;

J
Josef Bacik 已提交
1593
	spin_lock(&fs_info->trans_lock);
1594
	list_splice_init(&fs_info->dead_roots, &list);
J
Josef Bacik 已提交
1595
	spin_unlock(&fs_info->trans_lock);
1596

1597
	while (!list_empty(&list)) {
1598 1599
		int ret;

1600
		root = list_entry(list.next, struct btrfs_root, root_list);
1601 1602
		list_del(&root->root_list);

1603 1604
		btrfs_kill_all_delayed_nodes(root);

1605 1606
		if (btrfs_header_backref_rev(root->node) <
		    BTRFS_MIXED_BACKREF_REV)
1607
			ret = btrfs_drop_snapshot(root, NULL, 0, 0);
1608
		else
1609 1610
			ret =btrfs_drop_snapshot(root, NULL, 1, 0);
		BUG_ON(ret < 0);
1611 1612 1613
	}
	return 0;
}