transaction.c 46.8 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
 */
56
static noinline int join_transaction(struct btrfs_root *root, int type)
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) {
70 71 72 73 74 75 76
		/* 
		 * If we are JOIN_NOLOCK we're already committing a current
		 * transaction, we just need a handle to deal with something
		 * when committing the transaction, such as inode cache and
		 * space cache. It is a special case.
		 */
		if (type != TRANS_JOIN_NOLOCK) {
77
			spin_unlock(&fs_info->trans_lock);
J
Josef Bacik 已提交
78 79 80 81
			return -EBUSY;
		}
	}

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

96 97 98 99 100 101 102
	/*
	 * If we are ATTACH, we just want to catch the current transaction,
	 * and commit it. If there is no transaction, just return ENOENT.
	 */
	if (type == TRANS_ATTACH)
		return -ENOENT;

J
Josef Bacik 已提交
103 104 105
	cur_trans = kmem_cache_alloc(btrfs_transaction_cachep, GFP_NOFS);
	if (!cur_trans)
		return -ENOMEM;
106

107 108
	spin_lock(&fs_info->trans_lock);
	if (fs_info->running_transaction) {
109 110 111 112
		/*
		 * someone started a transaction after we unlocked.  Make sure
		 * to redo the trans_no_join checks above
		 */
J
Josef Bacik 已提交
113
		kmem_cache_free(btrfs_transaction_cachep, cur_trans);
114
		cur_trans = fs_info->running_transaction;
115
		goto loop;
116 117
	} else if (fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) {
		spin_unlock(&fs_info->trans_lock);
118 119
		kmem_cache_free(btrfs_transaction_cachep, cur_trans);
		return -EROFS;
C
Chris Mason 已提交
120
	}
121

J
Josef Bacik 已提交
122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141
	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;
142 143 144 145 146 147

	/*
	 * although the tree mod log is per file system and not per transaction,
	 * the log must never go across transaction boundaries.
	 */
	smp_mb();
J
Julia Lawall 已提交
148 149
	if (!list_empty(&fs_info->tree_mod_seq_list))
		WARN(1, KERN_ERR "btrfs: tree_mod_seq_list not empty when "
150
			"creating a fresh transaction\n");
J
Julia Lawall 已提交
151 152
	if (!RB_EMPTY_ROOT(&fs_info->tree_mod_log))
		WARN(1, KERN_ERR "btrfs: tree_mod_log rb tree not empty when "
153 154 155
			"creating a fresh transaction\n");
	atomic_set(&fs_info->tree_mod_seq, 0);

J
Josef Bacik 已提交
156 157 158 159
	spin_lock_init(&cur_trans->commit_lock);
	spin_lock_init(&cur_trans->delayed_refs.lock);

	INIT_LIST_HEAD(&cur_trans->pending_snapshots);
160
	list_add_tail(&cur_trans->list, &fs_info->trans_list);
J
Josef Bacik 已提交
161
	extent_io_tree_init(&cur_trans->dirty_pages,
162 163 164 165
			     fs_info->btree_inode->i_mapping);
	fs_info->generation++;
	cur_trans->transid = fs_info->generation;
	fs_info->running_transaction = cur_trans;
166
	cur_trans->aborted = 0;
167
	spin_unlock(&fs_info->trans_lock);
168

C
Chris Mason 已提交
169 170 171
	return 0;
}

C
Chris Mason 已提交
172
/*
C
Chris Mason 已提交
173 174 175 176
 * 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 已提交
177
 */
C
Chris Mason 已提交
178
static int record_root_in_trans(struct btrfs_trans_handle *trans,
J
Josef Bacik 已提交
179
			       struct btrfs_root *root)
180
{
181
	if (root->ref_cows && root->last_trans < trans->transid) {
182
		WARN_ON(root == root->fs_info->extent_root);
183 184
		WARN_ON(root->commit_root != root->node);

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

C
Chris Mason 已提交
234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256

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 已提交
257 258 259 260
/* 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 已提交
261
static void wait_current_trans(struct btrfs_root *root)
C
Chris Mason 已提交
262
{
263
	struct btrfs_transaction *cur_trans;
C
Chris Mason 已提交
264

J
Josef Bacik 已提交
265
	spin_lock(&root->fs_info->trans_lock);
266
	cur_trans = root->fs_info->running_transaction;
C
Chris Mason 已提交
267
	if (cur_trans && cur_trans->blocked) {
268
		atomic_inc(&cur_trans->use_count);
J
Josef Bacik 已提交
269
		spin_unlock(&root->fs_info->trans_lock);
L
Li Zefan 已提交
270 271 272

		wait_event(root->fs_info->transaction_wait,
			   !cur_trans->blocked);
273
		put_transaction(cur_trans);
J
Josef Bacik 已提交
274 275
	} else {
		spin_unlock(&root->fs_info->trans_lock);
276
	}
C
Chris Mason 已提交
277 278
}

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

291 292 293
	return 0;
}

M
Miao Xie 已提交
294 295 296
static struct btrfs_trans_handle *
start_transaction(struct btrfs_root *root, u64 num_items, int type,
		  enum btrfs_reserve_flush_enum flush)
C
Chris Mason 已提交
297
{
298 299
	struct btrfs_trans_handle *h;
	struct btrfs_transaction *cur_trans;
300
	u64 num_bytes = 0;
C
Chris Mason 已提交
301
	int ret;
302
	u64 qgroup_reserved = 0;
L
liubo 已提交
303 304 305

	if (root->fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR)
		return ERR_PTR(-EROFS);
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++;
311
		WARN_ON(h->use_count > 2);
312 313 314 315
		h->orig_rsv = h->block_rsv;
		h->block_rsv = NULL;
		goto got_it;
	}
316 317 318 319 320 321

	/*
	 * 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) {
322 323 324 325 326 327 328 329
		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);
		}

330
		num_bytes = btrfs_calc_trans_metadata_size(root, num_items);
M
Miao Xie 已提交
331 332 333
		ret = btrfs_block_rsv_add(root,
					  &root->fs_info->trans_block_rsv,
					  num_bytes, flush);
334 335 336
		if (ret)
			return ERR_PTR(ret);
	}
337 338 339 340
again:
	h = kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS);
	if (!h)
		return ERR_PTR(-ENOMEM);
C
Chris Mason 已提交
341

342 343 344 345 346 347
	/*
	 * If we are JOIN_NOLOCK we're already committing a transaction and
	 * waiting on this guy, so we don't need to do the sb_start_intwrite
	 * because we're already holding a ref.  We need this because we could
	 * have raced in and did an fsync() on a file which can kick a commit
	 * and then we deadlock with somebody doing a freeze.
348 349 350
	 *
	 * If we are ATTACH, it means we just want to catch the current
	 * transaction and commit it, so we needn't do sb_start_intwrite(). 
351
	 */
352
	if (type < TRANS_JOIN_NOLOCK)
353
		sb_start_intwrite(root->fs_info->sb);
354

355
	if (may_wait_transaction(root, type))
C
Chris Mason 已提交
356
		wait_current_trans(root);
357

J
Josef Bacik 已提交
358
	do {
359
		ret = join_transaction(root, type);
J
Josef Bacik 已提交
360 361 362 363
		if (ret == -EBUSY)
			wait_current_trans(root);
	} while (ret == -EBUSY);

T
Tsutomu Itoh 已提交
364
	if (ret < 0) {
365 366 367 368 369
		/* We must get the transaction if we are JOIN_NOLOCK. */
		BUG_ON(type == TRANS_JOIN_NOLOCK);

		if (type < TRANS_JOIN_NOLOCK)
			sb_end_intwrite(root->fs_info->sb);
370
		kmem_cache_free(btrfs_trans_handle_cachep, h);
T
Tsutomu Itoh 已提交
371 372
		return ERR_PTR(ret);
	}
373

374 375 376 377
	cur_trans = root->fs_info->running_transaction;

	h->transid = cur_trans->transid;
	h->transaction = cur_trans;
C
Chris Mason 已提交
378
	h->blocks_used = 0;
379
	h->bytes_reserved = 0;
380
	h->root = root;
381
	h->delayed_ref_updates = 0;
382
	h->use_count = 1;
383
	h->adding_csums = 0;
384
	h->block_rsv = NULL;
385
	h->orig_rsv = NULL;
386
	h->aborted = 0;
387
	h->qgroup_reserved = qgroup_reserved;
388
	h->delayed_ref_elem.seq = 0;
389
	h->type = type;
390
	INIT_LIST_HEAD(&h->qgroup_ref_list);
391
	INIT_LIST_HEAD(&h->new_bgs);
392

393 394 395 396 397 398
	smp_mb();
	if (cur_trans->blocked && may_wait_transaction(root, type)) {
		btrfs_commit_transaction(h, root);
		goto again;
	}

399
	if (num_bytes) {
J
Josef Bacik 已提交
400
		trace_btrfs_space_reservation(root->fs_info, "transaction",
401
					      h->transid, num_bytes, 1);
402 403
		h->block_rsv = &root->fs_info->trans_block_rsv;
		h->bytes_reserved = num_bytes;
404
	}
J
Josef Bacik 已提交
405

406
got_it:
J
Josef Bacik 已提交
407
	btrfs_record_root_in_trans(h, root);
408 409 410

	if (!current->journal_info && type != TRANS_USERSPACE)
		current->journal_info = h;
C
Chris Mason 已提交
411 412 413
	return h;
}

414
struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
415
						   int num_items)
416
{
M
Miao Xie 已提交
417 418
	return start_transaction(root, num_items, TRANS_START,
				 BTRFS_RESERVE_FLUSH_ALL);
419
}
420

M
Miao Xie 已提交
421
struct btrfs_trans_handle *btrfs_start_transaction_lflush(
422 423
					struct btrfs_root *root, int num_items)
{
M
Miao Xie 已提交
424 425
	return start_transaction(root, num_items, TRANS_START,
				 BTRFS_RESERVE_FLUSH_LIMIT);
426 427
}

428
struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root)
429
{
430
	return start_transaction(root, 0, TRANS_JOIN, 0);
431 432
}

433
struct btrfs_trans_handle *btrfs_join_transaction_nolock(struct btrfs_root *root)
434
{
435
	return start_transaction(root, 0, TRANS_JOIN_NOLOCK, 0);
436 437
}

438
struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *root)
439
{
440
	return start_transaction(root, 0, TRANS_USERSPACE, 0);
441 442
}

443
struct btrfs_trans_handle *btrfs_attach_transaction(struct btrfs_root *root)
444
{
445
	return start_transaction(root, 0, TRANS_ATTACH, 0);
446 447
}

C
Chris Mason 已提交
448
/* wait for a transaction commit to be fully complete */
449
static noinline void wait_for_commit(struct btrfs_root *root,
450 451
				    struct btrfs_transaction *commit)
{
L
Li Zefan 已提交
452
	wait_event(commit->commit_wait, commit->commit_done);
453 454
}

455 456 457 458 459 460 461 462
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 已提交
463
			goto out;
464 465

		/* find specified transaction */
J
Josef Bacik 已提交
466
		spin_lock(&root->fs_info->trans_lock);
467 468 469
		list_for_each_entry(t, &root->fs_info->trans_list, list) {
			if (t->transid == transid) {
				cur_trans = t;
J
Josef Bacik 已提交
470
				atomic_inc(&cur_trans->use_count);
471 472 473 474 475
				break;
			}
			if (t->transid > transid)
				break;
		}
J
Josef Bacik 已提交
476
		spin_unlock(&root->fs_info->trans_lock);
477 478
		ret = -EINVAL;
		if (!cur_trans)
J
Josef Bacik 已提交
479
			goto out;  /* bad transid */
480 481
	} else {
		/* find newest transaction that is committing | committed */
J
Josef Bacik 已提交
482
		spin_lock(&root->fs_info->trans_lock);
483 484 485 486
		list_for_each_entry_reverse(t, &root->fs_info->trans_list,
					    list) {
			if (t->in_commit) {
				if (t->commit_done)
487
					break;
488
				cur_trans = t;
J
Josef Bacik 已提交
489
				atomic_inc(&cur_trans->use_count);
490 491 492
				break;
			}
		}
J
Josef Bacik 已提交
493
		spin_unlock(&root->fs_info->trans_lock);
494
		if (!cur_trans)
J
Josef Bacik 已提交
495
			goto out;  /* nothing committing|committed */
496 497 498 499 500 501
	}

	wait_for_commit(root, cur_trans);

	put_transaction(cur_trans);
	ret = 0;
J
Josef Bacik 已提交
502
out:
503 504 505
	return ret;
}

C
Chris Mason 已提交
506 507
void btrfs_throttle(struct btrfs_root *root)
{
J
Josef Bacik 已提交
508
	if (!atomic_read(&root->fs_info->open_ioctl_trans))
509
		wait_current_trans(root);
C
Chris Mason 已提交
510 511
}

512 513 514 515
static int should_end_transaction(struct btrfs_trans_handle *trans,
				  struct btrfs_root *root)
{
	int ret;
516 517

	ret = btrfs_block_rsv_check(root, &root->fs_info->global_block_rsv, 5);
518 519 520 521 522 523 524 525
	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;
526
	int err;
527

J
Josef Bacik 已提交
528
	smp_mb();
529 530 531 532 533
	if (cur_trans->blocked || cur_trans->delayed_refs.flushing)
		return 1;

	updates = trans->delayed_ref_updates;
	trans->delayed_ref_updates = 0;
534 535 536 537 538
	if (updates) {
		err = btrfs_run_delayed_refs(trans, root, updates);
		if (err) /* Error code will also eval true */
			return err;
	}
539 540 541 542

	return should_end_transaction(trans, root);
}

543
static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
544
			  struct btrfs_root *root, int throttle)
C
Chris Mason 已提交
545
{
546
	struct btrfs_transaction *cur_trans = trans->transaction;
547
	struct btrfs_fs_info *info = root->fs_info;
548
	int count = 0;
549
	int lock = (trans->type != TRANS_JOIN_NOLOCK);
550
	int err = 0;
551

552 553 554 555 556
	if (--trans->use_count) {
		trans->block_rsv = trans->orig_rsv;
		return 0;
	}

557 558 559 560 561
	/*
	 * do the qgroup accounting as early as possible
	 */
	err = btrfs_delayed_refs_qgroup_accounting(trans, info);

562
	btrfs_trans_release_metadata(trans, root);
563
	trans->block_rsv = NULL;
564 565 566 567 568
	/*
	 * the same root has to be passed to start_transaction and
	 * end_transaction. Subvolume quota depends on this.
	 */
	WARN_ON(trans->root != root);
569 570 571 572 573 574

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

575 576 577
	if (!list_empty(&trans->new_bgs))
		btrfs_create_pending_block_groups(trans, root);

578
	while (count < 2) {
579 580 581 582 583 584 585 586 587 588
		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++;
589
	}
590 591
	btrfs_trans_release_metadata(trans, root);
	trans->block_rsv = NULL;
592

593 594 595
	if (!list_empty(&trans->new_bgs))
		btrfs_create_pending_block_groups(trans, root);

J
Josef Bacik 已提交
596 597
	if (lock && !atomic_read(&root->fs_info->open_ioctl_trans) &&
	    should_end_transaction(trans, root)) {
598
		trans->transaction->blocked = 1;
J
Josef Bacik 已提交
599 600
		smp_wmb();
	}
601

602
	if (lock && cur_trans->blocked && !cur_trans->in_commit) {
603 604 605 606 607 608 609
		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++;
610
			return btrfs_commit_transaction(trans, root);
611
		} else {
612
			wake_up_process(info->transaction_kthread);
613
		}
614 615
	}

616
	if (trans->type < TRANS_JOIN_NOLOCK)
617
		sb_end_intwrite(root->fs_info->sb);
618

619
	WARN_ON(cur_trans != info->running_transaction);
620 621
	WARN_ON(atomic_read(&cur_trans->num_writers) < 1);
	atomic_dec(&cur_trans->num_writers);
622

623
	smp_mb();
C
Chris Mason 已提交
624 625 626
	if (waitqueue_active(&cur_trans->writer_wait))
		wake_up(&cur_trans->writer_wait);
	put_transaction(cur_trans);
J
Josef Bacik 已提交
627 628 629

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

Y
Yan, Zheng 已提交
631 632 633
	if (throttle)
		btrfs_run_delayed_iputs(root);

634 635
	if (trans->aborted ||
	    root->fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) {
636
		err = -EIO;
637
	}
638
	assert_qgroups_uptodate(trans);
639

640 641 642
	memset(trans, 0, sizeof(*trans));
	kmem_cache_free(btrfs_trans_handle_cachep, trans);
	return err;
C
Chris Mason 已提交
643 644
}

645 646 647
int btrfs_end_transaction(struct btrfs_trans_handle *trans,
			  struct btrfs_root *root)
{
648 649
	int ret;

650
	ret = __btrfs_end_transaction(trans, root, 0);
651 652 653
	if (ret)
		return ret;
	return 0;
654 655 656 657 658
}

int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans,
				   struct btrfs_root *root)
{
659 660
	int ret;

661
	ret = __btrfs_end_transaction(trans, root, 1);
662 663 664 665 666 667 668 669
	if (ret)
		return ret;
	return 0;
}

int btrfs_end_transaction_dmeta(struct btrfs_trans_handle *trans,
				struct btrfs_root *root)
{
670
	return __btrfs_end_transaction(trans, root, 1);
671 672
}

C
Chris Mason 已提交
673 674 675
/*
 * 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
676
 * those extents are sent to disk but does not wait on them
C
Chris Mason 已提交
677
 */
678
int btrfs_write_marked_extents(struct btrfs_root *root,
679
			       struct extent_io_tree *dirty_pages, int mark)
C
Chris Mason 已提交
680
{
681
	int err = 0;
682
	int werr = 0;
J
Josef Bacik 已提交
683
	struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
684
	struct extent_state *cached_state = NULL;
685
	u64 start = 0;
686
	u64 end;
687

J
Josef Bacik 已提交
688
	while (!find_first_extent_bit(dirty_pages, start, &start, &end,
689 690 691 692
				      mark, &cached_state)) {
		convert_extent_bit(dirty_pages, start, end, EXTENT_NEED_WAIT,
				   mark, &cached_state, GFP_NOFS);
		cached_state = NULL;
J
Josef Bacik 已提交
693 694 695 696 697
		err = filemap_fdatawrite_range(mapping, start, end);
		if (err)
			werr = err;
		cond_resched();
		start = end + 1;
698
	}
699 700 701 702 703 704 705 706 707 708 709 710
	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,
711
			      struct extent_io_tree *dirty_pages, int mark)
712 713 714
{
	int err = 0;
	int werr = 0;
J
Josef Bacik 已提交
715
	struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
716
	struct extent_state *cached_state = NULL;
717 718
	u64 start = 0;
	u64 end;
719

J
Josef Bacik 已提交
720
	while (!find_first_extent_bit(dirty_pages, start, &start, &end,
721 722 723
				      EXTENT_NEED_WAIT, &cached_state)) {
		clear_extent_bit(dirty_pages, start, end, EXTENT_NEED_WAIT,
				 0, 0, &cached_state, GFP_NOFS);
J
Josef Bacik 已提交
724 725 726 727 728
		err = filemap_fdatawait_range(mapping, start, end);
		if (err)
			werr = err;
		cond_resched();
		start = end + 1;
729
	}
730 731 732
	if (err)
		werr = err;
	return werr;
C
Chris Mason 已提交
733 734
}

735 736 737 738 739 740
/*
 * 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,
741
				struct extent_io_tree *dirty_pages, int mark)
742 743 744 745
{
	int ret;
	int ret2;

746 747
	ret = btrfs_write_marked_extents(root, dirty_pages, mark);
	ret2 = btrfs_wait_marked_extents(root, dirty_pages, mark);
748 749 750 751 752 753

	if (ret)
		return ret;
	if (ret2)
		return ret2;
	return 0;
754 755
}

756 757 758 759 760 761 762 763 764
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,
765 766
					   &trans->transaction->dirty_pages,
					   EXTENT_DIRTY);
767 768
}

C
Chris Mason 已提交
769 770 771 772 773 774 775 776 777 778
/*
 * 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.
 */
779 780
static int update_cowonly_root(struct btrfs_trans_handle *trans,
			       struct btrfs_root *root)
C
Chris Mason 已提交
781 782
{
	int ret;
783
	u64 old_root_bytenr;
784
	u64 old_root_used;
785
	struct btrfs_root *tree_root = root->fs_info->tree_root;
C
Chris Mason 已提交
786

787
	old_root_used = btrfs_root_used(&root->root_item);
788
	btrfs_write_dirty_block_groups(trans, root);
789

C
Chris Mason 已提交
790
	while (1) {
791
		old_root_bytenr = btrfs_root_bytenr(&root->root_item);
792 793
		if (old_root_bytenr == root->node->start &&
		    old_root_used == btrfs_root_used(&root->root_item))
C
Chris Mason 已提交
794
			break;
795

796
		btrfs_set_root_node(&root->root_item, root->node);
C
Chris Mason 已提交
797
		ret = btrfs_update_root(trans, tree_root,
798 799
					&root->root_key,
					&root->root_item);
800 801
		if (ret)
			return ret;
802

803
		old_root_used = btrfs_root_used(&root->root_item);
804
		ret = btrfs_write_dirty_block_groups(trans, root);
805 806
		if (ret)
			return ret;
807
	}
808 809 810 811

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

812 813 814
	return 0;
}

C
Chris Mason 已提交
815 816
/*
 * update all the cowonly tree roots on disk
817 818 819 820
 *
 * 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 已提交
821
 */
822 823
static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans,
					 struct btrfs_root *root)
824 825 826
{
	struct btrfs_fs_info *fs_info = root->fs_info;
	struct list_head *next;
827
	struct extent_buffer *eb;
828
	int ret;
829

830
	ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
831 832
	if (ret)
		return ret;
833

834
	eb = btrfs_lock_root_node(fs_info->tree_root);
835 836
	ret = btrfs_cow_block(trans, fs_info->tree_root, eb, NULL,
			      0, &eb);
837 838
	btrfs_tree_unlock(eb);
	free_extent_buffer(eb);
839

840 841 842
	if (ret)
		return ret;

843
	ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
844 845
	if (ret)
		return ret;
846

847 848 849
	ret = btrfs_run_dev_stats(trans, root->fs_info);
	BUG_ON(ret);

850 851 852 853 854 855 856
	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 已提交
857
	while (!list_empty(&fs_info->dirty_cowonly_roots)) {
858 859 860
		next = fs_info->dirty_cowonly_roots.next;
		list_del_init(next);
		root = list_entry(next, struct btrfs_root, dirty_list);
861

862 863 864
		ret = update_cowonly_root(trans, root);
		if (ret)
			return ret;
C
Chris Mason 已提交
865
	}
866 867 868 869 870

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

C
Chris Mason 已提交
871 872 873
	return 0;
}

C
Chris Mason 已提交
874 875 876 877 878
/*
 * 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
 */
879
int btrfs_add_dead_root(struct btrfs_root *root)
880
{
J
Josef Bacik 已提交
881
	spin_lock(&root->fs_info->trans_lock);
882
	list_add(&root->root_list, &root->fs_info->dead_roots);
J
Josef Bacik 已提交
883
	spin_unlock(&root->fs_info->trans_lock);
884 885 886
	return 0;
}

C
Chris Mason 已提交
887
/*
888
 * update all the cowonly tree roots on disk
C
Chris Mason 已提交
889
 */
890 891
static noinline int commit_fs_roots(struct btrfs_trans_handle *trans,
				    struct btrfs_root *root)
892 893
{
	struct btrfs_root *gang[8];
894
	struct btrfs_fs_info *fs_info = root->fs_info;
895 896
	int i;
	int ret;
897 898
	int err = 0;

J
Josef Bacik 已提交
899
	spin_lock(&fs_info->fs_roots_radix_lock);
C
Chris Mason 已提交
900
	while (1) {
901 902
		ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix,
						 (void **)gang, 0,
903 904 905 906 907 908
						 ARRAY_SIZE(gang),
						 BTRFS_ROOT_TRANS_TAG);
		if (ret == 0)
			break;
		for (i = 0; i < ret; i++) {
			root = gang[i];
909 910 911
			radix_tree_tag_clear(&fs_info->fs_roots_radix,
					(unsigned long)root->root_key.objectid,
					BTRFS_ROOT_TRANS_TAG);
J
Josef Bacik 已提交
912
			spin_unlock(&fs_info->fs_roots_radix_lock);
Y
Yan Zheng 已提交
913

914
			btrfs_free_log(trans, root);
915
			btrfs_update_reloc_root(trans, root);
916
			btrfs_orphan_commit_root(trans, root);
917

918 919
			btrfs_save_ino_cache(root, trans);

920 921 922 923
			/* see comments in should_cow_block() */
			root->force_cow = 0;
			smp_wmb();

924
			if (root->commit_root != root->node) {
925
				mutex_lock(&root->fs_commit_mutex);
J
Josef Bacik 已提交
926
				switch_commit_root(root);
927 928 929
				btrfs_unpin_free_ino(root);
				mutex_unlock(&root->fs_commit_mutex);

930 931 932
				btrfs_set_root_node(&root->root_item,
						    root->node);
			}
933 934

			err = btrfs_update_root(trans, fs_info->tree_root,
935 936
						&root->root_key,
						&root->root_item);
J
Josef Bacik 已提交
937
			spin_lock(&fs_info->fs_roots_radix_lock);
938 939
			if (err)
				break;
940 941
		}
	}
J
Josef Bacik 已提交
942
	spin_unlock(&fs_info->fs_roots_radix_lock);
943
	return err;
944 945
}

C
Chris Mason 已提交
946 947 948 949
/*
 * defrag a given btree.  If cacheonly == 1, this won't read from the disk,
 * otherwise every leaf in the btree is read and defragged.
 */
950 951 952 953
int btrfs_defrag_root(struct btrfs_root *root, int cacheonly)
{
	struct btrfs_fs_info *info = root->fs_info;
	struct btrfs_trans_handle *trans;
954
	int ret;
955

956
	if (xchg(&root->defrag_running, 1))
957
		return 0;
958

959
	while (1) {
960 961 962 963
		trans = btrfs_start_transaction(root, 0);
		if (IS_ERR(trans))
			return PTR_ERR(trans);

964
		ret = btrfs_defrag_leaves(trans, root, cacheonly);
965

966
		btrfs_end_transaction(trans, root);
967
		btrfs_btree_balance_dirty(info->tree_root);
968 969
		cond_resched();

970
		if (btrfs_fs_closing(root->fs_info) || ret != -EAGAIN)
971 972 973
			break;
	}
	root->defrag_running = 0;
974
	return ret;
975 976
}

C
Chris Mason 已提交
977 978 979 980
/*
 * new snapshots need to be created at a very specific time in the
 * transaction commit.  This does the actual creation
 */
981
static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
982 983 984 985
				   struct btrfs_fs_info *fs_info,
				   struct btrfs_pending_snapshot *pending)
{
	struct btrfs_key key;
986
	struct btrfs_root_item *new_root_item;
987 988
	struct btrfs_root *tree_root = fs_info->tree_root;
	struct btrfs_root *root = pending->root;
989
	struct btrfs_root *parent_root;
L
Liu Bo 已提交
990
	struct btrfs_block_rsv *rsv;
991
	struct inode *parent_inode;
992 993
	struct btrfs_path *path;
	struct btrfs_dir_item *dir_item;
994
	struct dentry *parent;
995
	struct dentry *dentry;
996
	struct extent_buffer *tmp;
997
	struct extent_buffer *old;
998
	struct timespec cur_time = CURRENT_TIME;
999
	int ret;
1000
	u64 to_reserve = 0;
1001
	u64 index = 0;
1002
	u64 objectid;
L
Li Zefan 已提交
1003
	u64 root_flags;
1004
	uuid_le new_uuid;
1005

1006 1007 1008 1009 1010 1011
	path = btrfs_alloc_path();
	if (!path) {
		ret = pending->error = -ENOMEM;
		goto path_alloc_fail;
	}

1012 1013
	new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS);
	if (!new_root_item) {
1014
		ret = pending->error = -ENOMEM;
1015
		goto root_item_alloc_fail;
1016
	}
1017

1018
	ret = btrfs_find_free_objectid(tree_root, &objectid);
1019 1020
	if (ret) {
		pending->error = ret;
1021
		goto no_free_objectid;
1022
	}
1023

1024
	btrfs_reloc_pre_snapshot(trans, pending, &to_reserve);
1025 1026

	if (to_reserve > 0) {
M
Miao Xie 已提交
1027 1028 1029
		ret = btrfs_block_rsv_add(root, &pending->block_rsv,
					  to_reserve,
					  BTRFS_RESERVE_NO_FLUSH);
1030 1031
		if (ret) {
			pending->error = ret;
1032
			goto no_free_objectid;
1033 1034 1035
		}
	}

A
Arne Jansen 已提交
1036 1037 1038 1039
	ret = btrfs_qgroup_inherit(trans, fs_info, root->root_key.objectid,
				   objectid, pending->inherit);
	if (ret) {
		pending->error = ret;
1040
		goto no_free_objectid;
A
Arne Jansen 已提交
1041 1042
	}

1043
	key.objectid = objectid;
1044 1045
	key.offset = (u64)-1;
	key.type = BTRFS_ROOT_ITEM_KEY;
1046

1047
	rsv = trans->block_rsv;
1048
	trans->block_rsv = &pending->block_rsv;
1049

1050
	dentry = pending->dentry;
1051 1052
	parent = dget_parent(dentry);
	parent_inode = parent->d_inode;
1053
	parent_root = BTRFS_I(parent_inode)->root;
C
Chris Mason 已提交
1054
	record_root_in_trans(trans, parent_root);
1055

1056 1057 1058
	/*
	 * insert the directory item
	 */
1059
	ret = btrfs_set_inode_index(parent_inode, &index);
1060
	BUG_ON(ret); /* -ENOMEM */
1061 1062 1063 1064 1065 1066 1067

	/* check if there is a file/dir which has the same name. */
	dir_item = btrfs_lookup_dir_item(NULL, parent_root, path,
					 btrfs_ino(parent_inode),
					 dentry->d_name.name,
					 dentry->d_name.len, 0);
	if (dir_item != NULL && !IS_ERR(dir_item)) {
1068 1069
		pending->error = -EEXIST;
		goto fail;
1070 1071
	} else if (IS_ERR(dir_item)) {
		ret = PTR_ERR(dir_item);
1072 1073
		btrfs_abort_transaction(trans, root, ret);
		goto fail;
1074
	}
1075
	btrfs_release_path(path);
1076

1077 1078 1079 1080 1081 1082 1083
	/*
	 * 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);
1084 1085 1086 1087
	if (ret) {	/* Transaction aborted */
		btrfs_abort_transaction(trans, root, ret);
		goto fail;
	}
1088

C
Chris Mason 已提交
1089
	record_root_in_trans(trans, root);
1090 1091
	btrfs_set_root_last_snapshot(&root->root_item, trans->transid);
	memcpy(new_root_item, &root->root_item, sizeof(*new_root_item));
1092
	btrfs_check_and_init_root_item(new_root_item);
1093

L
Li Zefan 已提交
1094 1095 1096 1097 1098 1099 1100
	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);

1101 1102 1103 1104 1105 1106 1107
	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);
1108
	new_root_item->otime.nsec = cpu_to_le32(cur_time.tv_nsec);
1109 1110 1111 1112 1113 1114
	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);

1115
	old = btrfs_lock_root_node(root);
1116
	ret = btrfs_cow_block(trans, root, old, NULL, 0, &old);
1117 1118 1119
	if (ret) {
		btrfs_tree_unlock(old);
		free_extent_buffer(old);
1120 1121
		btrfs_abort_transaction(trans, root, ret);
		goto fail;
1122
	}
1123

1124 1125
	btrfs_set_lock_blocking(old);

1126
	ret = btrfs_copy_root(trans, root, old, &tmp, objectid);
1127
	/* clean up in any case */
1128 1129
	btrfs_tree_unlock(old);
	free_extent_buffer(old);
1130 1131 1132 1133
	if (ret) {
		btrfs_abort_transaction(trans, root, ret);
		goto fail;
	}
1134

1135 1136 1137 1138
	/* see comments in should_cow_block() */
	root->force_cow = 1;
	smp_wmb();

1139
	btrfs_set_root_node(new_root_item, tmp);
1140 1141 1142
	/* record when the snapshot was created in key.offset */
	key.offset = trans->transid;
	ret = btrfs_insert_root(trans, tree_root, &key, new_root_item);
1143 1144
	btrfs_tree_unlock(tmp);
	free_extent_buffer(tmp);
1145 1146 1147 1148
	if (ret) {
		btrfs_abort_transaction(trans, root, ret);
		goto fail;
	}
1149

1150 1151 1152 1153
	/*
	 * insert root back/forward references
	 */
	ret = btrfs_add_root_ref(trans, tree_root, objectid,
1154
				 parent_root->root_key.objectid,
L
Li Zefan 已提交
1155
				 btrfs_ino(parent_inode), index,
1156
				 dentry->d_name.name, dentry->d_name.len);
1157 1158 1159 1160
	if (ret) {
		btrfs_abort_transaction(trans, root, ret);
		goto fail;
	}
1161

1162 1163
	key.offset = (u64)-1;
	pending->snap = btrfs_read_fs_root_no_name(root->fs_info, &key);
1164 1165
	if (IS_ERR(pending->snap)) {
		ret = PTR_ERR(pending->snap);
1166 1167
		btrfs_abort_transaction(trans, root, ret);
		goto fail;
1168
	}
1169

1170
	ret = btrfs_reloc_post_snapshot(trans, pending);
1171 1172 1173 1174
	if (ret) {
		btrfs_abort_transaction(trans, root, ret);
		goto fail;
	}
1175 1176

	ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
1177 1178 1179 1180
	if (ret) {
		btrfs_abort_transaction(trans, root, ret);
		goto fail;
	}
1181 1182 1183 1184 1185 1186 1187

	ret = btrfs_insert_dir_item(trans, parent_root,
				    dentry->d_name.name, dentry->d_name.len,
				    parent_inode, &key,
				    BTRFS_FT_DIR, index);
	/* We have check then name at the beginning, so it is impossible. */
	BUG_ON(ret == -EEXIST);
1188 1189 1190 1191
	if (ret) {
		btrfs_abort_transaction(trans, root, ret);
		goto fail;
	}
1192 1193 1194 1195

	btrfs_i_size_write(parent_inode, parent_inode->i_size +
					 dentry->d_name.len * 2);
	parent_inode->i_mtime = parent_inode->i_ctime = CURRENT_TIME;
1196
	ret = btrfs_update_inode_fallback(trans, parent_root, parent_inode);
1197
	if (ret)
1198
		btrfs_abort_transaction(trans, root, ret);
1199
fail:
1200
	dput(parent);
L
Liu Bo 已提交
1201
	trans->block_rsv = rsv;
1202 1203 1204
no_free_objectid:
	kfree(new_root_item);
root_item_alloc_fail:
1205 1206
	btrfs_free_path(path);
path_alloc_fail:
1207
	btrfs_block_rsv_release(root, &pending->block_rsv, (u64)-1);
1208
	return ret;
1209 1210
}

C
Chris Mason 已提交
1211 1212 1213
/*
 * create all the snapshots we've scheduled for creation
 */
1214 1215
static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans,
					     struct btrfs_fs_info *fs_info)
1216 1217 1218 1219
{
	struct btrfs_pending_snapshot *pending;
	struct list_head *head = &trans->transaction->pending_snapshots;

1220 1221
	list_for_each_entry(pending, head, list)
		create_pending_snapshot(trans, fs_info, pending);
1222 1223 1224
	return 0;
}

1225 1226 1227 1228 1229
static void update_super_roots(struct btrfs_root *root)
{
	struct btrfs_root_item *root_item;
	struct btrfs_super_block *super;

1230
	super = root->fs_info->super_copy;
1231 1232 1233 1234 1235 1236 1237 1238 1239 1240

	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;
1241
	if (btrfs_test_opt(root, SPACE_CACHE))
1242
		super->cache_generation = root_item->generation;
1243 1244
}

1245 1246 1247
int btrfs_transaction_in_commit(struct btrfs_fs_info *info)
{
	int ret = 0;
J
Josef Bacik 已提交
1248
	spin_lock(&info->trans_lock);
1249 1250
	if (info->running_transaction)
		ret = info->running_transaction->in_commit;
J
Josef Bacik 已提交
1251
	spin_unlock(&info->trans_lock);
1252 1253 1254
	return ret;
}

1255 1256 1257
int btrfs_transaction_blocked(struct btrfs_fs_info *info)
{
	int ret = 0;
J
Josef Bacik 已提交
1258
	spin_lock(&info->trans_lock);
1259 1260
	if (info->running_transaction)
		ret = info->running_transaction->blocked;
J
Josef Bacik 已提交
1261
	spin_unlock(&info->trans_lock);
1262 1263 1264
	return ret;
}

S
Sage Weil 已提交
1265 1266 1267 1268 1269 1270 1271
/*
 * 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 已提交
1272
	wait_event(root->fs_info->transaction_blocked_wait, trans->in_commit);
S
Sage Weil 已提交
1273 1274 1275 1276 1277 1278 1279 1280 1281
}

/*
 * 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 已提交
1282 1283
	wait_event(root->fs_info->transaction_wait,
		   trans->commit_done || (trans->in_commit && !trans->blocked));
S
Sage Weil 已提交
1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300
}

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

1301 1302 1303 1304 1305 1306 1307 1308
	/*
	 * We've got freeze protection passed with the transaction.
	 * Tell lockdep about it.
	 */
	rwsem_acquire_read(
		&ac->root->fs_info->sb->s_writers.lock_map[SB_FREEZE_FS-1],
		0, 1, _THIS_IP_);

1309 1310
	current->journal_info = ac->newtrans;

S
Sage Weil 已提交
1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322
	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 已提交
1323 1324
	if (!ac)
		return -ENOMEM;
S
Sage Weil 已提交
1325 1326 1327

	INIT_DELAYED_WORK(&ac->work, do_async_commit);
	ac->root = root;
1328
	ac->newtrans = btrfs_join_transaction(root);
1329 1330 1331 1332 1333
	if (IS_ERR(ac->newtrans)) {
		int err = PTR_ERR(ac->newtrans);
		kfree(ac);
		return err;
	}
S
Sage Weil 已提交
1334 1335 1336

	/* take transaction reference */
	cur_trans = trans->transaction;
1337
	atomic_inc(&cur_trans->use_count);
S
Sage Weil 已提交
1338 1339

	btrfs_end_transaction(trans, root);
1340 1341 1342 1343 1344 1345 1346 1347

	/*
	 * Tell lockdep we've released the freeze rwsem, since the
	 * async commit thread will be the one to unlock it.
	 */
	rwsem_release(&root->fs_info->sb->s_writers.lock_map[SB_FREEZE_FS-1],
		      1, _THIS_IP_);

S
Sage Weil 已提交
1348 1349 1350 1351 1352 1353 1354 1355
	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);

1356 1357 1358 1359
	if (current->journal_info == trans)
		current->journal_info = NULL;

	put_transaction(cur_trans);
S
Sage Weil 已提交
1360 1361 1362
	return 0;
}

1363 1364

static void cleanup_transaction(struct btrfs_trans_handle *trans,
1365
				struct btrfs_root *root, int err)
1366 1367 1368 1369 1370
{
	struct btrfs_transaction *cur_trans = trans->transaction;

	WARN_ON(trans->use_count > 1);

1371 1372
	btrfs_abort_transaction(trans, root, err);

1373 1374
	spin_lock(&root->fs_info->trans_lock);
	list_del_init(&cur_trans->list);
1375 1376 1377 1378
	if (cur_trans == root->fs_info->running_transaction) {
		root->fs_info->running_transaction = NULL;
		root->fs_info->trans_no_join = 0;
	}
1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395
	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);
}

1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437
static int btrfs_flush_all_pending_stuffs(struct btrfs_trans_handle *trans,
					  struct btrfs_root *root)
{
	int flush_on_commit = btrfs_test_opt(root, FLUSHONCOMMIT);
	int snap_pending = 0;
	int ret;

	if (!flush_on_commit) {
		spin_lock(&root->fs_info->trans_lock);
		if (!list_empty(&trans->transaction->pending_snapshots))
			snap_pending = 1;
		spin_unlock(&root->fs_info->trans_lock);
	}

	if (flush_on_commit || snap_pending) {
		btrfs_start_delalloc_inodes(root, 1);
		btrfs_wait_ordered_extents(root, 1);
	}

	ret = btrfs_run_delayed_items(trans, root);
	if (ret)
		return ret;

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

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

	return 0;
}

S
Sage Weil 已提交
1438 1439 1440 1441 1442 1443 1444
/*
 * btrfs_transaction state sequence:
 *    in_commit = 0, blocked = 0  (initial)
 *    in_commit = 1, blocked = 1
 *    blocked = 0
 *    commit_done = 1
 */
C
Chris Mason 已提交
1445 1446 1447
int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
			     struct btrfs_root *root)
{
1448
	unsigned long joined = 0;
1449
	struct btrfs_transaction *cur_trans = trans->transaction;
C
Chris Mason 已提交
1450
	struct btrfs_transaction *prev_trans = NULL;
C
Chris Mason 已提交
1451
	DEFINE_WAIT(wait);
1452
	int ret;
1453 1454
	int should_grow = 0;
	unsigned long now = get_seconds();
C
Chris Mason 已提交
1455

1456 1457 1458 1459 1460
	ret = btrfs_run_ordered_operations(root, 0);
	if (ret) {
		btrfs_abort_transaction(trans, root, ret);
		goto cleanup_transaction;
	}
1461

1462 1463
	if (cur_trans->aborted) {
		ret = cur_trans->aborted;
1464
		goto cleanup_transaction;
1465
	}
1466

1467 1468 1469 1470
	/* 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);
1471 1472
	if (ret)
		goto cleanup_transaction;
1473

1474 1475 1476
	btrfs_trans_release_metadata(trans, root);
	trans->block_rsv = NULL;

1477
	cur_trans = trans->transaction;
1478

1479 1480 1481 1482
	/*
	 * set the flushing flag so procs in this transaction have to
	 * start sending their work down.
	 */
1483
	cur_trans->delayed_refs.flushing = 1;
1484

1485 1486 1487
	if (!list_empty(&trans->new_bgs))
		btrfs_create_pending_block_groups(trans, root);

1488
	ret = btrfs_run_delayed_refs(trans, root, 0);
1489 1490
	if (ret)
		goto cleanup_transaction;
1491

J
Josef Bacik 已提交
1492
	spin_lock(&cur_trans->commit_lock);
1493
	if (cur_trans->in_commit) {
J
Josef Bacik 已提交
1494
		spin_unlock(&cur_trans->commit_lock);
1495
		atomic_inc(&cur_trans->use_count);
1496
		ret = btrfs_end_transaction(trans, root);
C
Chris Mason 已提交
1497

1498
		wait_for_commit(root, cur_trans);
1499

C
Chris Mason 已提交
1500
		put_transaction(cur_trans);
1501

1502
		return ret;
C
Chris Mason 已提交
1503
	}
1504

C
Chris Mason 已提交
1505
	trans->transaction->in_commit = 1;
1506
	trans->transaction->blocked = 1;
J
Josef Bacik 已提交
1507
	spin_unlock(&cur_trans->commit_lock);
S
Sage Weil 已提交
1508 1509
	wake_up(&root->fs_info->transaction_blocked_wait);

J
Josef Bacik 已提交
1510
	spin_lock(&root->fs_info->trans_lock);
C
Chris Mason 已提交
1511 1512 1513 1514
	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) {
1515
			atomic_inc(&prev_trans->use_count);
J
Josef Bacik 已提交
1516
			spin_unlock(&root->fs_info->trans_lock);
C
Chris Mason 已提交
1517 1518 1519

			wait_for_commit(root, prev_trans);

1520
			put_transaction(prev_trans);
J
Josef Bacik 已提交
1521 1522
		} else {
			spin_unlock(&root->fs_info->trans_lock);
C
Chris Mason 已提交
1523
		}
J
Josef Bacik 已提交
1524 1525
	} else {
		spin_unlock(&root->fs_info->trans_lock);
C
Chris Mason 已提交
1526
	}
1527

1528 1529
	if (!btrfs_test_opt(root, SSD) &&
	    (now < cur_trans->start_time || now - cur_trans->start_time < 1))
1530 1531
		should_grow = 1;

1532 1533
	do {
		joined = cur_trans->num_joined;
1534

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

1537
		ret = btrfs_flush_all_pending_stuffs(trans, root);
1538 1539
		if (ret)
			goto cleanup_transaction;
1540

1541 1542 1543
		prepare_to_wait(&cur_trans->writer_wait, &wait,
				TASK_UNINTERRUPTIBLE);

1544
		if (atomic_read(&cur_trans->num_writers) > 1)
1545 1546 1547
			schedule_timeout(MAX_SCHEDULE_TIMEOUT);
		else if (should_grow)
			schedule_timeout(1);
1548 1549

		finish_wait(&cur_trans->writer_wait, &wait);
1550
	} while (atomic_read(&cur_trans->num_writers) > 1 ||
1551
		 (should_grow && cur_trans->num_joined != joined));
1552

1553 1554 1555 1556
	ret = btrfs_flush_all_pending_stuffs(trans, root);
	if (ret)
		goto cleanup_transaction;

1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567
	/*
	 * 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 已提交
1568 1569 1570 1571 1572 1573 1574
	/*
	 * 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);

1575 1576 1577 1578 1579 1580
	/*
	 * We needn't worry about the delayed items because we will
	 * deal with them in create_pending_snapshot(), which is the
	 * core function of the snapshot creation.
	 */
	ret = create_pending_snapshots(trans, root->fs_info);
1581 1582 1583 1584
	if (ret) {
		mutex_unlock(&root->fs_info->reloc_mutex);
		goto cleanup_transaction;
	}
1585

1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596
	/*
	 * We insert the dir indexes of the snapshots and update the inode
	 * of the snapshots' parents after the snapshot creation, so there
	 * are some delayed items which are not dealt with. Now deal with
	 * them.
	 *
	 * We needn't worry that this operation will corrupt the snapshots,
	 * because all the tree which are snapshoted will be forced to COW
	 * the nodes and leaves.
	 */
	ret = btrfs_run_delayed_items(trans, root);
1597 1598 1599 1600
	if (ret) {
		mutex_unlock(&root->fs_info->reloc_mutex);
		goto cleanup_transaction;
	}
1601

1602
	ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
1603 1604 1605 1606
	if (ret) {
		mutex_unlock(&root->fs_info->reloc_mutex);
		goto cleanup_transaction;
	}
1607

1608 1609 1610 1611 1612 1613
	/*
	 * make sure none of the code above managed to slip in a
	 * delayed item
	 */
	btrfs_assert_delayed_root_empty(root);

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

A
Arne Jansen 已提交
1616
	btrfs_scrub_pause(root);
1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631
	/* 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);

1632
	ret = commit_fs_roots(trans, root);
1633 1634
	if (ret) {
		mutex_unlock(&root->fs_info->tree_log_mutex);
1635
		mutex_unlock(&root->fs_info->reloc_mutex);
1636 1637
		goto cleanup_transaction;
	}
1638

1639
	/* commit_fs_roots gets rid of all the tree log roots, it is now
1640 1641 1642 1643
	 * safe to free the root of tree log roots
	 */
	btrfs_free_log_root_tree(trans, root->fs_info);

1644
	ret = commit_cowonly_roots(trans, root);
1645 1646
	if (ret) {
		mutex_unlock(&root->fs_info->tree_log_mutex);
1647
		mutex_unlock(&root->fs_info->reloc_mutex);
1648 1649
		goto cleanup_transaction;
	}
1650

1651 1652
	btrfs_prepare_extent_commit(trans, root);

C
Chris Mason 已提交
1653
	cur_trans = root->fs_info->running_transaction;
1654 1655 1656

	btrfs_set_root_node(&root->fs_info->tree_root->root_item,
			    root->fs_info->tree_root->node);
J
Josef Bacik 已提交
1657
	switch_commit_root(root->fs_info->tree_root);
1658 1659 1660

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

1663
	assert_qgroups_uptodate(trans);
1664
	update_super_roots(root);
1665 1666

	if (!root->fs_info->log_root_recovering) {
1667 1668
		btrfs_set_super_log_root(root->fs_info->super_copy, 0);
		btrfs_set_super_log_root_level(root->fs_info->super_copy, 0);
1669 1670
	}

1671 1672
	memcpy(root->fs_info->super_for_commit, root->fs_info->super_copy,
	       sizeof(*root->fs_info->super_copy));
C
Chris Mason 已提交
1673

1674
	trans->transaction->blocked = 0;
J
Josef Bacik 已提交
1675 1676 1677 1678
	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 已提交
1679
	mutex_unlock(&root->fs_info->reloc_mutex);
1680

1681
	wake_up(&root->fs_info->transaction_wait);
1682

C
Chris Mason 已提交
1683
	ret = btrfs_write_and_wait_transaction(trans, root);
1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695
	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;
	}
1696

1697 1698 1699 1700 1701 1702
	/*
	 * the super is written, we can safely allow the tree-loggers
	 * to go about their business
	 */
	mutex_unlock(&root->fs_info->tree_log_mutex);

1703
	btrfs_finish_extent_commit(trans, root);
1704

C
Chris Mason 已提交
1705
	cur_trans->commit_done = 1;
1706

1707
	root->fs_info->last_trans_committed = cur_trans->transid;
J
Josef Bacik 已提交
1708

C
Chris Mason 已提交
1709
	wake_up(&cur_trans->commit_wait);
1710

J
Josef Bacik 已提交
1711
	spin_lock(&root->fs_info->trans_lock);
1712
	list_del_init(&cur_trans->list);
J
Josef Bacik 已提交
1713 1714
	spin_unlock(&root->fs_info->trans_lock);

C
Chris Mason 已提交
1715
	put_transaction(cur_trans);
C
Chris Mason 已提交
1716
	put_transaction(cur_trans);
1717

1718 1719
	if (trans->type < TRANS_JOIN_NOLOCK)
		sb_end_intwrite(root->fs_info->sb);
1720

1721 1722
	trace_btrfs_transaction_commit(root);

A
Arne Jansen 已提交
1723 1724
	btrfs_scrub_continue(root);

J
Josef Bacik 已提交
1725 1726 1727
	if (current->journal_info == trans)
		current->journal_info = NULL;

C
Chris Mason 已提交
1728
	kmem_cache_free(btrfs_trans_handle_cachep, trans);
Y
Yan, Zheng 已提交
1729 1730 1731 1732

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

C
Chris Mason 已提交
1733
	return ret;
1734 1735

cleanup_transaction:
1736 1737
	btrfs_trans_release_metadata(trans, root);
	trans->block_rsv = NULL;
1738 1739 1740 1741
	btrfs_printk(root->fs_info, "Skipping commit of aborted transaction.\n");
//	WARN_ON(1);
	if (current->journal_info == trans)
		current->journal_info = NULL;
1742
	cleanup_transaction(trans, root, ret);
1743 1744

	return ret;
C
Chris Mason 已提交
1745 1746
}

C
Chris Mason 已提交
1747 1748 1749
/*
 * interface function to delete all the snapshots we have scheduled for deletion
 */
1750 1751
int btrfs_clean_old_snapshots(struct btrfs_root *root)
{
1752 1753 1754
	LIST_HEAD(list);
	struct btrfs_fs_info *fs_info = root->fs_info;

J
Josef Bacik 已提交
1755
	spin_lock(&fs_info->trans_lock);
1756
	list_splice_init(&fs_info->dead_roots, &list);
J
Josef Bacik 已提交
1757
	spin_unlock(&fs_info->trans_lock);
1758

1759
	while (!list_empty(&list)) {
1760 1761
		int ret;

1762
		root = list_entry(list.next, struct btrfs_root, root_list);
1763 1764
		list_del(&root->root_list);

1765 1766
		btrfs_kill_all_delayed_nodes(root);

1767 1768
		if (btrfs_header_backref_rev(root->node) <
		    BTRFS_MIXED_BACKREF_REV)
1769
			ret = btrfs_drop_snapshot(root, NULL, 0, 0);
1770
		else
1771 1772
			ret =btrfs_drop_snapshot(root, NULL, 1, 0);
		BUG_ON(ret < 0);
1773 1774 1775
	}
	return 0;
}