transaction.c 53.1 KB
Newer Older
Chris Mason's avatar
Chris Mason committed
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.
 */

Chris Mason's avatar
Chris Mason committed
19
#include <linux/fs.h>
20
#include <linux/slab.h>
Chris Mason's avatar
Chris Mason committed
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>
Chris Mason's avatar
Chris Mason committed
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"
33
#include "dev-replace.h"
Chris Mason's avatar
Chris Mason committed
34

35 36
#define BTRFS_ROOT_TRANS_TAG 0

37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59
static unsigned int btrfs_blocked_trans_types[TRANS_STATE_MAX] = {
	[TRANS_STATE_RUNNING]		= 0U,
	[TRANS_STATE_BLOCKED]		= (__TRANS_USERSPACE |
					   __TRANS_START),
	[TRANS_STATE_COMMIT_START]	= (__TRANS_USERSPACE |
					   __TRANS_START |
					   __TRANS_ATTACH),
	[TRANS_STATE_COMMIT_DOING]	= (__TRANS_USERSPACE |
					   __TRANS_START |
					   __TRANS_ATTACH |
					   __TRANS_JOIN),
	[TRANS_STATE_UNBLOCKED]		= (__TRANS_USERSPACE |
					   __TRANS_START |
					   __TRANS_ATTACH |
					   __TRANS_JOIN |
					   __TRANS_JOIN_NOLOCK),
	[TRANS_STATE_COMPLETED]		= (__TRANS_USERSPACE |
					   __TRANS_START |
					   __TRANS_ATTACH |
					   __TRANS_JOIN |
					   __TRANS_JOIN_NOLOCK),
};

60
static void put_transaction(struct btrfs_transaction *transaction)
Chris Mason's avatar
Chris Mason committed
61
{
62 63
	WARN_ON(atomic_read(&transaction->use_count) == 0);
	if (atomic_dec_and_test(&transaction->use_count)) {
Josef Bacik's avatar
Josef Bacik committed
64
		BUG_ON(!list_empty(&transaction->list));
65
		WARN_ON(transaction->delayed_refs.root.rb_node);
66 67 68 69 70 71 72 73
		while (!list_empty(&transaction->pending_chunks)) {
			struct extent_map *em;

			em = list_first_entry(&transaction->pending_chunks,
					      struct extent_map, list);
			list_del_init(&em->list);
			free_extent_map(em);
		}
74
		kmem_cache_free(btrfs_transaction_cachep, transaction);
75
	}
Chris Mason's avatar
Chris Mason committed
76 77
}

78 79 80 81 82 83
static noinline void switch_commit_root(struct btrfs_root *root)
{
	free_extent_buffer(root->commit_root);
	root->commit_root = btrfs_root_node(root);
}

84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106
static inline void extwriter_counter_inc(struct btrfs_transaction *trans,
					 unsigned int type)
{
	if (type & TRANS_EXTWRITERS)
		atomic_inc(&trans->num_extwriters);
}

static inline void extwriter_counter_dec(struct btrfs_transaction *trans,
					 unsigned int type)
{
	if (type & TRANS_EXTWRITERS)
		atomic_dec(&trans->num_extwriters);
}

static inline void extwriter_counter_init(struct btrfs_transaction *trans,
					  unsigned int type)
{
	atomic_set(&trans->num_extwriters, ((type & TRANS_EXTWRITERS) ? 1 : 0));
}

static inline int extwriter_counter_read(struct btrfs_transaction *trans)
{
	return atomic_read(&trans->num_extwriters);
107 108
}

109 110 111
/*
 * either allocate a new transaction or hop into the existing one
 */
112
static noinline int join_transaction(struct btrfs_root *root, unsigned int type)
Chris Mason's avatar
Chris Mason committed
113 114
{
	struct btrfs_transaction *cur_trans;
115
	struct btrfs_fs_info *fs_info = root->fs_info;
Josef Bacik's avatar
Josef Bacik committed
116

117
	spin_lock(&fs_info->trans_lock);
118
loop:
119
	/* The file system has been taken offline. No new transactions. */
120
	if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
121
		spin_unlock(&fs_info->trans_lock);
122 123 124
		return -EROFS;
	}

125
	cur_trans = fs_info->running_transaction;
Josef Bacik's avatar
Josef Bacik committed
126
	if (cur_trans) {
127
		if (cur_trans->aborted) {
128
			spin_unlock(&fs_info->trans_lock);
129
			return cur_trans->aborted;
130
		}
131
		if (btrfs_blocked_trans_types[cur_trans->state] & type) {
132 133 134
			spin_unlock(&fs_info->trans_lock);
			return -EBUSY;
		}
Josef Bacik's avatar
Josef Bacik committed
135
		atomic_inc(&cur_trans->use_count);
136
		atomic_inc(&cur_trans->num_writers);
137
		extwriter_counter_inc(cur_trans, type);
138
		spin_unlock(&fs_info->trans_lock);
Josef Bacik's avatar
Josef Bacik committed
139
		return 0;
Chris Mason's avatar
Chris Mason committed
140
	}
141
	spin_unlock(&fs_info->trans_lock);
Josef Bacik's avatar
Josef Bacik committed
142

143 144 145 146 147 148 149
	/*
	 * 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;

150 151 152 153 154 155
	/*
	 * JOIN_NOLOCK only happens during the transaction commit, so
	 * it is impossible that ->running_transaction is NULL
	 */
	BUG_ON(type == TRANS_JOIN_NOLOCK);

Josef Bacik's avatar
Josef Bacik committed
156 157 158
	cur_trans = kmem_cache_alloc(btrfs_transaction_cachep, GFP_NOFS);
	if (!cur_trans)
		return -ENOMEM;
159

160 161
	spin_lock(&fs_info->trans_lock);
	if (fs_info->running_transaction) {
162 163
		/*
		 * someone started a transaction after we unlocked.  Make sure
164
		 * to redo the checks above
165
		 */
Josef Bacik's avatar
Josef Bacik committed
166
		kmem_cache_free(btrfs_transaction_cachep, cur_trans);
167
		goto loop;
168
	} else if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
169
		spin_unlock(&fs_info->trans_lock);
170 171
		kmem_cache_free(btrfs_transaction_cachep, cur_trans);
		return -EROFS;
Chris Mason's avatar
Chris Mason committed
172
	}
173

Josef Bacik's avatar
Josef Bacik committed
174
	atomic_set(&cur_trans->num_writers, 1);
175
	extwriter_counter_init(cur_trans, type);
Josef Bacik's avatar
Josef Bacik committed
176 177
	init_waitqueue_head(&cur_trans->writer_wait);
	init_waitqueue_head(&cur_trans->commit_wait);
178
	cur_trans->state = TRANS_STATE_RUNNING;
Josef Bacik's avatar
Josef Bacik committed
179 180 181 182 183 184 185 186 187 188 189 190 191
	/*
	 * 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->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;
192 193 194 195 196 197

	/*
	 * although the tree mod log is per file system and not per transaction,
	 * the log must never go across transaction boundaries.
	 */
	smp_mb();
Julia Lawall's avatar
Julia Lawall committed
198 199
	if (!list_empty(&fs_info->tree_mod_seq_list))
		WARN(1, KERN_ERR "btrfs: tree_mod_seq_list not empty when "
200
			"creating a fresh transaction\n");
Julia Lawall's avatar
Julia Lawall committed
201 202
	if (!RB_EMPTY_ROOT(&fs_info->tree_mod_log))
		WARN(1, KERN_ERR "btrfs: tree_mod_log rb tree not empty when "
203
			"creating a fresh transaction\n");
204
	atomic64_set(&fs_info->tree_mod_seq, 0);
205

Josef Bacik's avatar
Josef Bacik committed
206
	spin_lock_init(&cur_trans->delayed_refs.lock);
207 208 209
	atomic_set(&cur_trans->delayed_refs.procs_running_refs, 0);
	atomic_set(&cur_trans->delayed_refs.ref_seq, 0);
	init_waitqueue_head(&cur_trans->delayed_refs.wait);
Josef Bacik's avatar
Josef Bacik committed
210 211

	INIT_LIST_HEAD(&cur_trans->pending_snapshots);
212
	INIT_LIST_HEAD(&cur_trans->ordered_operations);
213
	INIT_LIST_HEAD(&cur_trans->pending_chunks);
214
	list_add_tail(&cur_trans->list, &fs_info->trans_list);
Josef Bacik's avatar
Josef Bacik committed
215
	extent_io_tree_init(&cur_trans->dirty_pages,
216 217 218 219
			     fs_info->btree_inode->i_mapping);
	fs_info->generation++;
	cur_trans->transid = fs_info->generation;
	fs_info->running_transaction = cur_trans;
220
	cur_trans->aborted = 0;
221
	spin_unlock(&fs_info->trans_lock);
222

Chris Mason's avatar
Chris Mason committed
223 224 225
	return 0;
}

226
/*
227 228 229 230
 * 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
231
 */
Chris Mason's avatar
Chris Mason committed
232
static int record_root_in_trans(struct btrfs_trans_handle *trans,
Josef Bacik's avatar
Josef Bacik committed
233
			       struct btrfs_root *root)
234
{
235
	if (root->ref_cows && root->last_trans < trans->transid) {
236
		WARN_ON(root == root->fs_info->extent_root);
237 238
		WARN_ON(root->commit_root != root->node);

Chris Mason's avatar
Chris Mason committed
239 240 241 242 243 244 245 246 247 248 249 250
		/*
		 * 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();

Josef Bacik's avatar
Josef Bacik committed
251 252 253 254 255
		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;
		}
256 257 258
		radix_tree_tag_set(&root->fs_info->fs_roots_radix,
			   (unsigned long)root->root_key.objectid,
			   BTRFS_ROOT_TRANS_TAG);
Josef Bacik's avatar
Josef Bacik committed
259
		spin_unlock(&root->fs_info->fs_roots_radix_lock);
Chris Mason's avatar
Chris Mason committed
260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280
		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
		 */
281
		btrfs_init_reloc_root(trans, root);
Chris Mason's avatar
Chris Mason committed
282 283
		smp_wmb();
		root->in_trans_setup = 0;
284 285 286
	}
	return 0;
}
287

Chris Mason's avatar
Chris Mason committed
288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310

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

311 312 313
static inline int is_transaction_blocked(struct btrfs_transaction *trans)
{
	return (trans->state >= TRANS_STATE_BLOCKED &&
314 315
		trans->state < TRANS_STATE_UNBLOCKED &&
		!trans->aborted);
316 317
}

318 319 320 321
/* 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.
 */
Chris Mason's avatar
Chris Mason committed
322
static void wait_current_trans(struct btrfs_root *root)
Chris Mason's avatar
Chris Mason committed
323
{
324
	struct btrfs_transaction *cur_trans;
Chris Mason's avatar
Chris Mason committed
325

Josef Bacik's avatar
Josef Bacik committed
326
	spin_lock(&root->fs_info->trans_lock);
327
	cur_trans = root->fs_info->running_transaction;
328
	if (cur_trans && is_transaction_blocked(cur_trans)) {
329
		atomic_inc(&cur_trans->use_count);
Josef Bacik's avatar
Josef Bacik committed
330
		spin_unlock(&root->fs_info->trans_lock);
Li Zefan's avatar
Li Zefan committed
331 332

		wait_event(root->fs_info->transaction_wait,
333 334
			   cur_trans->state >= TRANS_STATE_UNBLOCKED ||
			   cur_trans->aborted);
335
		put_transaction(cur_trans);
Josef Bacik's avatar
Josef Bacik committed
336 337
	} else {
		spin_unlock(&root->fs_info->trans_lock);
338
	}
Chris Mason's avatar
Chris Mason committed
339 340
}

341 342
static int may_wait_transaction(struct btrfs_root *root, int type)
{
Josef Bacik's avatar
Josef Bacik committed
343 344 345 346 347 348 349 350
	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))
351
		return 1;
Josef Bacik's avatar
Josef Bacik committed
352

353 354 355
	return 0;
}

356
static struct btrfs_trans_handle *
357
start_transaction(struct btrfs_root *root, u64 num_items, unsigned int type,
358
		  enum btrfs_reserve_flush_enum flush)
Chris Mason's avatar
Chris Mason committed
359
{
360 361
	struct btrfs_trans_handle *h;
	struct btrfs_transaction *cur_trans;
362
	u64 num_bytes = 0;
Chris Mason's avatar
Chris Mason committed
363
	int ret;
364
	u64 qgroup_reserved = 0;
365

366
	if (test_bit(BTRFS_FS_STATE_ERROR, &root->fs_info->fs_state))
367
		return ERR_PTR(-EROFS);
368 369

	if (current->journal_info) {
370
		WARN_ON(type & TRANS_EXTWRITERS);
371 372
		h = current->journal_info;
		h->use_count++;
373
		WARN_ON(h->use_count > 2);
374 375 376 377
		h->orig_rsv = h->block_rsv;
		h->block_rsv = NULL;
		goto got_it;
	}
378 379 380 381 382 383

	/*
	 * 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) {
384 385 386 387 388 389 390 391
		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);
		}

392
		num_bytes = btrfs_calc_trans_metadata_size(root, num_items);
393 394 395
		ret = btrfs_block_rsv_add(root,
					  &root->fs_info->trans_block_rsv,
					  num_bytes, flush);
396
		if (ret)
397
			goto reserve_fail;
398
	}
399 400
again:
	h = kmem_cache_alloc(btrfs_trans_handle_cachep, GFP_NOFS);
401 402 403 404
	if (!h) {
		ret = -ENOMEM;
		goto alloc_fail;
	}
Chris Mason's avatar
Chris Mason committed
405

406 407 408 409 410 411
	/*
	 * 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.
412 413 414
	 *
	 * 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(). 
415
	 */
416
	if (type & __TRANS_FREEZABLE)
417
		sb_start_intwrite(root->fs_info->sb);
418

419
	if (may_wait_transaction(root, type))
Chris Mason's avatar
Chris Mason committed
420
		wait_current_trans(root);
421

Josef Bacik's avatar
Josef Bacik committed
422
	do {
423
		ret = join_transaction(root, type);
424
		if (ret == -EBUSY) {
Josef Bacik's avatar
Josef Bacik committed
425
			wait_current_trans(root);
426 427 428
			if (unlikely(type == TRANS_ATTACH))
				ret = -ENOENT;
		}
Josef Bacik's avatar
Josef Bacik committed
429 430
	} while (ret == -EBUSY);

Tsutomu Itoh's avatar
Tsutomu Itoh committed
431
	if (ret < 0) {
432 433
		/* We must get the transaction if we are JOIN_NOLOCK. */
		BUG_ON(type == TRANS_JOIN_NOLOCK);
434
		goto join_fail;
Tsutomu Itoh's avatar
Tsutomu Itoh committed
435
	}
436

437 438 439 440
	cur_trans = root->fs_info->running_transaction;

	h->transid = cur_trans->transid;
	h->transaction = cur_trans;
Chris Mason's avatar
Chris Mason committed
441
	h->blocks_used = 0;
442
	h->bytes_reserved = 0;
443
	h->root = root;
444
	h->delayed_ref_updates = 0;
445
	h->use_count = 1;
446
	h->adding_csums = 0;
447
	h->block_rsv = NULL;
448
	h->orig_rsv = NULL;
449
	h->aborted = 0;
450
	h->qgroup_reserved = 0;
451
	h->delayed_ref_elem.seq = 0;
452
	h->type = type;
453
	h->allocating_chunk = false;
454
	INIT_LIST_HEAD(&h->qgroup_ref_list);
455
	INIT_LIST_HEAD(&h->new_bgs);
456

457
	smp_mb();
458 459
	if (cur_trans->state >= TRANS_STATE_BLOCKED &&
	    may_wait_transaction(root, type)) {
460 461 462 463
		btrfs_commit_transaction(h, root);
		goto again;
	}

464
	if (num_bytes) {
Josef Bacik's avatar
Josef Bacik committed
465
		trace_btrfs_space_reservation(root->fs_info, "transaction",
466
					      h->transid, num_bytes, 1);
467 468
		h->block_rsv = &root->fs_info->trans_block_rsv;
		h->bytes_reserved = num_bytes;
469
	}
470
	h->qgroup_reserved = qgroup_reserved;
Josef Bacik's avatar
Josef Bacik committed
471

472
got_it:
Josef Bacik's avatar
Josef Bacik committed
473
	btrfs_record_root_in_trans(h, root);
474 475 476

	if (!current->journal_info && type != TRANS_USERSPACE)
		current->journal_info = h;
Chris Mason's avatar
Chris Mason committed
477
	return h;
478 479

join_fail:
480
	if (type & __TRANS_FREEZABLE)
481 482 483 484 485 486 487 488 489 490
		sb_end_intwrite(root->fs_info->sb);
	kmem_cache_free(btrfs_trans_handle_cachep, h);
alloc_fail:
	if (num_bytes)
		btrfs_block_rsv_release(root, &root->fs_info->trans_block_rsv,
					num_bytes);
reserve_fail:
	if (qgroup_reserved)
		btrfs_qgroup_free(root, qgroup_reserved);
	return ERR_PTR(ret);
Chris Mason's avatar
Chris Mason committed
491 492
}

493
struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
494
						   int num_items)
495
{
496 497
	return start_transaction(root, num_items, TRANS_START,
				 BTRFS_RESERVE_FLUSH_ALL);
498
}
499

500
struct btrfs_trans_handle *btrfs_start_transaction_lflush(
501 502
					struct btrfs_root *root, int num_items)
{
503 504
	return start_transaction(root, num_items, TRANS_START,
				 BTRFS_RESERVE_FLUSH_LIMIT);
505 506
}

507
struct btrfs_trans_handle *btrfs_join_transaction(struct btrfs_root *root)
508
{
509
	return start_transaction(root, 0, TRANS_JOIN, 0);
510 511
}

512
struct btrfs_trans_handle *btrfs_join_transaction_nolock(struct btrfs_root *root)
513
{
514
	return start_transaction(root, 0, TRANS_JOIN_NOLOCK, 0);
515 516
}

517
struct btrfs_trans_handle *btrfs_start_ioctl_transaction(struct btrfs_root *root)
518
{
519
	return start_transaction(root, 0, TRANS_USERSPACE, 0);
520 521
}

522 523 524 525 526 527 528 529 530 531 532 533 534
/*
 * btrfs_attach_transaction() - catch the running transaction
 *
 * It is used when we want to commit the current the transaction, but
 * don't want to start a new one.
 *
 * Note: If this function return -ENOENT, it just means there is no
 * running transaction. But it is possible that the inactive transaction
 * is still in the memory, not fully on disk. If you hope there is no
 * inactive transaction in the fs when -ENOENT is returned, you should
 * invoke
 *     btrfs_attach_transaction_barrier()
 */
535
struct btrfs_trans_handle *btrfs_attach_transaction(struct btrfs_root *root)
536
{
537
	return start_transaction(root, 0, TRANS_ATTACH, 0);
538 539
}

540
/*
541
 * btrfs_attach_transaction_barrier() - catch the running transaction
542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558
 *
 * It is similar to the above function, the differentia is this one
 * will wait for all the inactive transactions until they fully
 * complete.
 */
struct btrfs_trans_handle *
btrfs_attach_transaction_barrier(struct btrfs_root *root)
{
	struct btrfs_trans_handle *trans;

	trans = start_transaction(root, 0, TRANS_ATTACH, 0);
	if (IS_ERR(trans) && PTR_ERR(trans) == -ENOENT)
		btrfs_wait_for_commit(root, 0);

	return trans;
}

559
/* wait for a transaction commit to be fully complete */
560
static noinline void wait_for_commit(struct btrfs_root *root,
561 562
				    struct btrfs_transaction *commit)
{
563
	wait_event(commit->commit_wait, commit->state == TRANS_STATE_COMPLETED);
564 565
}

566 567 568
int btrfs_wait_for_commit(struct btrfs_root *root, u64 transid)
{
	struct btrfs_transaction *cur_trans = NULL, *t;
569
	int ret = 0;
570 571 572

	if (transid) {
		if (transid <= root->fs_info->last_trans_committed)
Josef Bacik's avatar
Josef Bacik committed
573
			goto out;
574

575
		ret = -EINVAL;
576
		/* find specified transaction */
Josef Bacik's avatar
Josef Bacik committed
577
		spin_lock(&root->fs_info->trans_lock);
578 579 580
		list_for_each_entry(t, &root->fs_info->trans_list, list) {
			if (t->transid == transid) {
				cur_trans = t;
Josef Bacik's avatar
Josef Bacik committed
581
				atomic_inc(&cur_trans->use_count);
582
				ret = 0;
583 584
				break;
			}
585 586
			if (t->transid > transid) {
				ret = 0;
587
				break;
588
			}
589
		}
Josef Bacik's avatar
Josef Bacik committed
590
		spin_unlock(&root->fs_info->trans_lock);
591
		/* The specified transaction doesn't exist */
592
		if (!cur_trans)
593
			goto out;
594 595
	} else {
		/* find newest transaction that is committing | committed */
Josef Bacik's avatar
Josef Bacik committed
596
		spin_lock(&root->fs_info->trans_lock);
597 598
		list_for_each_entry_reverse(t, &root->fs_info->trans_list,
					    list) {
599 600
			if (t->state >= TRANS_STATE_COMMIT_START) {
				if (t->state == TRANS_STATE_COMPLETED)
601
					break;
602
				cur_trans = t;
Josef Bacik's avatar
Josef Bacik committed
603
				atomic_inc(&cur_trans->use_count);
604 605 606
				break;
			}
		}
Josef Bacik's avatar
Josef Bacik committed
607
		spin_unlock(&root->fs_info->trans_lock);
608
		if (!cur_trans)
Josef Bacik's avatar
Josef Bacik committed
609
			goto out;  /* nothing committing|committed */
610 611 612 613
	}

	wait_for_commit(root, cur_trans);
	put_transaction(cur_trans);
Josef Bacik's avatar
Josef Bacik committed
614
out:
615 616 617
	return ret;
}

Chris Mason's avatar
Chris Mason committed
618 619
void btrfs_throttle(struct btrfs_root *root)
{
Josef Bacik's avatar
Josef Bacik committed
620
	if (!atomic_read(&root->fs_info->open_ioctl_trans))
621
		wait_current_trans(root);
Chris Mason's avatar
Chris Mason committed
622 623
}

624 625 626
static int should_end_transaction(struct btrfs_trans_handle *trans,
				  struct btrfs_root *root)
{
627 628 629
	if (root->fs_info->global_block_rsv.space_info->full &&
	    btrfs_should_throttle_delayed_refs(trans, root))
		return 1;
630

631
	return !!btrfs_block_rsv_check(root, &root->fs_info->global_block_rsv, 5);
632 633 634 635 636 637 638
}

int btrfs_should_end_transaction(struct btrfs_trans_handle *trans,
				 struct btrfs_root *root)
{
	struct btrfs_transaction *cur_trans = trans->transaction;
	int updates;
639
	int err;
640

Josef Bacik's avatar
Josef Bacik committed
641
	smp_mb();
642 643
	if (cur_trans->state >= TRANS_STATE_BLOCKED ||
	    cur_trans->delayed_refs.flushing)
644 645 646 647
		return 1;

	updates = trans->delayed_ref_updates;
	trans->delayed_ref_updates = 0;
648 649 650 651 652
	if (updates) {
		err = btrfs_run_delayed_refs(trans, root, updates);
		if (err) /* Error code will also eval true */
			return err;
	}
653 654 655 656

	return should_end_transaction(trans, root);
}

657
static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
658
			  struct btrfs_root *root, int throttle)
Chris Mason's avatar
Chris Mason committed
659
{
660
	struct btrfs_transaction *cur_trans = trans->transaction;
661
	struct btrfs_fs_info *info = root->fs_info;
662
	unsigned long cur = trans->delayed_ref_updates;
663
	int lock = (trans->type != TRANS_JOIN_NOLOCK);
664
	int err = 0;
665

666 667
	if (trans->use_count > 1) {
		trans->use_count--;
668 669 670 671
		trans->block_rsv = trans->orig_rsv;
		return 0;
	}

672 673 674 675 676
	/*
	 * do the qgroup accounting as early as possible
	 */
	err = btrfs_delayed_refs_qgroup_accounting(trans, info);

677
	btrfs_trans_release_metadata(trans, root);
678
	trans->block_rsv = NULL;
679 680

	if (trans->qgroup_reserved) {
681 682 683 684 685
		/*
		 * the same root has to be passed here between start_transaction
		 * and end_transaction. Subvolume quota depends on this.
		 */
		btrfs_qgroup_free(trans->root, trans->qgroup_reserved);
686 687 688
		trans->qgroup_reserved = 0;
	}

689 690 691
	if (!list_empty(&trans->new_bgs))
		btrfs_create_pending_block_groups(trans, root);

692 693 694
	trans->delayed_ref_updates = 0;
	if (btrfs_should_throttle_delayed_refs(trans, root)) {
		cur = max_t(unsigned long, cur, 1);
695
		trans->delayed_ref_updates = 0;
696
		btrfs_run_delayed_refs(trans, root, cur);
697
	}
698

699 700
	btrfs_trans_release_metadata(trans, root);
	trans->block_rsv = NULL;
701

702 703 704
	if (!list_empty(&trans->new_bgs))
		btrfs_create_pending_block_groups(trans, root);

Josef Bacik's avatar
Josef Bacik committed
705
	if (lock && !atomic_read(&root->fs_info->open_ioctl_trans) &&
706 707 708 709 710 711
	    should_end_transaction(trans, root) &&
	    ACCESS_ONCE(cur_trans->state) == TRANS_STATE_RUNNING) {
		spin_lock(&info->trans_lock);
		if (cur_trans->state == TRANS_STATE_RUNNING)
			cur_trans->state = TRANS_STATE_BLOCKED;
		spin_unlock(&info->trans_lock);
Josef Bacik's avatar
Josef Bacik committed
712
	}
713

714
	if (lock && ACCESS_ONCE(cur_trans->state) == TRANS_STATE_BLOCKED) {
715
		if (throttle)
716
			return btrfs_commit_transaction(trans, root);
717
		else
718 719 720
			wake_up_process(info->transaction_kthread);
	}

721
	if (trans->type & __TRANS_FREEZABLE)
722
		sb_end_intwrite(root->fs_info->sb);
723

724
	WARN_ON(cur_trans != info->running_transaction);
725 726
	WARN_ON(atomic_read(&cur_trans->num_writers) < 1);
	atomic_dec(&cur_trans->num_writers);
727
	extwriter_counter_dec(cur_trans, trans->type);
728

729
	smp_mb();
Chris Mason's avatar
Chris Mason committed
730 731 732
	if (waitqueue_active(&cur_trans->writer_wait))
		wake_up(&cur_trans->writer_wait);
	put_transaction(cur_trans);
Josef Bacik's avatar
Josef Bacik committed
733 734 735

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

Yan, Zheng's avatar
Yan, Zheng committed
737 738 739
	if (throttle)
		btrfs_run_delayed_iputs(root);

740
	if (trans->aborted ||
741
	    test_bit(BTRFS_FS_STATE_ERROR, &root->fs_info->fs_state))
742
		err = -EIO;
743
	assert_qgroups_uptodate(trans);
744

745 746
	kmem_cache_free(btrfs_trans_handle_cachep, trans);
	return err;
Chris Mason's avatar
Chris Mason committed
747 748
}

749 750 751
int btrfs_end_transaction(struct btrfs_trans_handle *trans,
			  struct btrfs_root *root)
{
752
	return __btrfs_end_transaction(trans, root, 0);
753 754 755 756 757
}

int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans,
				   struct btrfs_root *root)
{
758
	return __btrfs_end_transaction(trans, root, 1);
759 760 761 762 763
}

int btrfs_end_transaction_dmeta(struct btrfs_trans_handle *trans,
				struct btrfs_root *root)
{
764
	return __btrfs_end_transaction(trans, root, 1);
765 766
}

767 768 769
/*
 * 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
770
 * those extents are sent to disk but does not wait on them
771
 */
772
int btrfs_write_marked_extents(struct btrfs_root *root,
773
			       struct extent_io_tree *dirty_pages, int mark)
Chris Mason's avatar
Chris Mason committed
774
{
775
	int err = 0;
776
	int werr = 0;
777
	struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
778
	struct extent_state *cached_state = NULL;
779
	u64 start = 0;
780
	u64 end;
781

782
	while (!find_first_extent_bit(dirty_pages, start, &start, &end,
783 784 785 786
				      mark, &cached_state)) {
		convert_extent_bit(dirty_pages, start, end, EXTENT_NEED_WAIT,
				   mark, &cached_state, GFP_NOFS);
		cached_state = NULL;
787 788 789 790 791
		err = filemap_fdatawrite_range(mapping, start, end);
		if (err)
			werr = err;
		cond_resched();
		start = end + 1;
792
	}
793 794 795 796 797 798 799 800 801 802 803 804
	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,
805
			      struct extent_io_tree *dirty_pages, int mark)
806 807 808
{
	int err = 0;
	int werr = 0;
809
	struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
810
	struct extent_state *cached_state = NULL;
811 812
	u64 start = 0;
	u64 end;
813

814
	while (!find_first_extent_bit(dirty_pages, start, &start, &end,
815 816 817
				      EXTENT_NEED_WAIT, &cached_state)) {
		clear_extent_bit(dirty_pages, start, end, EXTENT_NEED_WAIT,
				 0, 0, &cached_state, GFP_NOFS);
818 819 820 821 822
		err = filemap_fdatawait_range(mapping, start, end);
		if (err)
			werr = err;
		cond_resched();
		start = end + 1;
823
	}
824 825 826
	if (err)
		werr = err;
	return werr;
Chris Mason's avatar
Chris Mason committed
827 828
}

829 830 831 832 833
/*
 * 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
 */
834
static int btrfs_write_and_wait_marked_extents(struct btrfs_root *root,
835
				struct extent_io_tree *dirty_pages, int mark)
836 837 838
{
	int ret;
	int ret2;
839
	struct blk_plug plug;
840

841
	blk_start_plug(&plug);
842
	ret = btrfs_write_marked_extents(root, dirty_pages, mark);
843
	blk_finish_plug(&plug);
844
	ret2 = btrfs_wait_marked_extents(root, dirty_pages, mark);
845 846 847 848 849 850

	if (ret)
		return ret;
	if (ret2)
		return ret2;
	return 0;
851 852
}

853 854 855 856 857 858 859 860 861
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,
862 863
					   &trans->transaction->dirty_pages,
					   EXTENT_DIRTY);
864 865
}

866 867 868 869 870 871 872 873 874 875
/*
 * 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.
 */
876 877
static int update_cowonly_root(struct btrfs_trans_handle *trans,
			       struct btrfs_root *root)
Chris Mason's avatar
Chris Mason committed
878 879
{
	int ret;
880
	u64 old_root_bytenr;
881
	u64 old_root_used;
882
	struct btrfs_root *tree_root = root->fs_info->tree_root;
Chris Mason's avatar
Chris Mason committed
883

884
	old_root_used = btrfs_root_used(&root->root_item);
885
	btrfs_write_dirty_block_groups(trans, root);
886

887
	while (1) {
888
		old_root_bytenr = btrfs_root_bytenr(&root->root_item);
889 890
		if (old_root_bytenr == root->node->start &&
		    old_root_used == btrfs_root_used(&root->root_item))
Chris Mason's avatar
Chris Mason committed
891
			break;
892

893
		btrfs_set_root_node(&root->root_item, root->node);
Chris Mason's avatar
Chris Mason committed
894
		ret = btrfs_update_root(trans, tree_root,
895 896
					&root->root_key,
					&root->root_item);
897 898
		if (ret)
			return ret;
899

900
		old_root_used = btrfs_root_used(&root->root_item);
901
		ret = btrfs_write_dirty_block_groups(trans, root);
902 903
		if (ret)
			return ret;
904
	}
905 906 907 908

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

909 910 911
	return 0;
}

912 913
/*
 * update all the cowonly tree roots on disk
914 915 916 917
 *
 * 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.
918
 */
919 920
static noinline int commit_cowonly_roots(struct btrfs_trans_handle *trans,
					 struct btrfs_root *root)
921 922 923
{
	struct btrfs_fs_info *fs_info = root->fs_info;
	struct list_head *next;
924
	struct extent_buffer *eb;
925
	int ret;
926

927
	ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
928 929
	if (ret)
		return ret;
930

931
	eb = btrfs_lock_root_node(fs_info->tree_root);
932 933
	ret = btrfs_cow_block(trans, fs_info->tree_root, eb, NULL,
			      0, &eb);
934 935
	btrfs_tree_unlock(eb);
	free_extent_buffer(eb);
936

937 938 939
	if (ret)
		return ret;

940
	ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
941 942
	if (ret)
		return ret;
943

944
	ret = btrfs_run_dev_stats(trans, root->fs_info);
945 946 947
	WARN_ON(ret);
	ret = btrfs_run_dev_replace(trans, root->fs_info);
	WARN_ON(ret);
948

949 950 951 952 953 954 955
	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);

956
	while (!list_empty(&fs_info->dirty_cowonly_roots)) {
957 958 959
		next = fs_info->dirty_cowonly_roots.next;
		list_del_init(next);
		root = list_entry(next, struct btrfs_root, dirty_list);
960

961 962 963
		ret = update_cowonly_root(trans, root);
		if (ret)
			return ret;
Chris Mason's avatar
Chris Mason committed
964
	}
965 966 967 968 969

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

970 971
	btrfs_after_dev_replace_commit(fs_info);

Chris Mason's avatar
Chris Mason committed
972 973 974
	return 0;
}

975 976 977 978 979
/*
 * 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
 */
980
void btrfs_add_dead_root(struct btrfs_root *root)
981
{
Josef Bacik's avatar
Josef Bacik committed
982
	spin_lock(&root->fs_info->trans_lock);
983 984
	if (list_empty(&root->root_list))
		list_add_tail(&root->root_list, &root->fs_info->dead_roots);
Josef Bacik's avatar
Josef Bacik committed
985
	spin_unlock(&root->fs_info->trans_lock);
986 987
}

988
/*
989
 * update all the cowonly tree roots on disk
990
 */
991 992
static noinline int commit_fs_roots(struct btrfs_trans_handle *trans,
				    struct btrfs_root *root)
993 994
{
	struct btrfs_root *gang[8];
995
	struct btrfs_fs_info *fs_info = root->fs_info;
996 997
	int i;
	int ret;
998 999
	int err = 0;

Josef Bacik's avatar
Josef Bacik committed
1000
	spin_lock(&fs_info->fs_roots_radix_lock);
1001
	while (1) {
1002 1003
		ret = radix_tree_gang_lookup_tag(&fs_info->fs_roots_radix,
						 (void **)gang, 0,
1004 1005 1006 1007 1008 1009
						 ARRAY_SIZE(gang),
						 BTRFS_ROOT_TRANS_TAG);
		if (ret == 0)
			break;
		for (i = 0; i < ret; i++) {
			root = gang[i];
1010 1011 1012
			radix_tree_tag_clear(&fs_info->fs_roots_radix,
					(unsigned long)root->root_key.objectid,
					BTRFS_ROOT_TRANS_TAG);
Josef Bacik's avatar
Josef Bacik committed
1013
			spin_unlock(&fs_info->fs_roots_radix_lock);
1014

1015
			btrfs_free_log(trans, root);
1016
			btrfs_update_reloc_root(trans, root);
1017
			btrfs_orphan_commit_root(trans, root);
1018

1019 1020
			btrfs_save_ino_cache(root, trans);

1021 1022 1023 1024
			/* see comments in should_cow_block() */
			root->force_cow = 0;
			smp_wmb();

1025
			if (root->commit_root != root->node) {
1026
				mutex_lock(&root->fs_commit_mutex);
1027
				switch_commit_root(root);
1028 1029 1030
				btrfs_unpin_free_ino(root);
				mutex_unlock(&root->fs_commit_mutex);

1031 1032 1033
				btrfs_set_root_node(&root->root_item,
						    root->node);
			}
1034 1035

			err = btrfs_update_root(trans, fs_info->tree_root,
1036 1037
						&root->root_key,
						&root->root_item);
Josef Bacik's avatar
Josef Bacik committed
1038
			spin_lock(&fs_info->fs_roots_radix_lock);
1039 1040
			if (err)
				break;
1041 1042
		}
	}
Josef Bacik's avatar
Josef Bacik committed
1043
	spin_unlock(&fs_info->fs_roots_radix_lock);
1044
	return err;
1045 1046
}

1047
/*
1048 1049
 * defrag a given btree.
 * Every leaf in the btree is read and defragged.
1050
 */
1051
int btrfs_defrag_root(struct btrfs_root *root)
1052 1053 1054
{
	struct btrfs_fs_info *info = root->fs_info;
	struct btrfs_trans_handle *trans;
1055
	int ret;
1056

1057
	if (xchg(&root->defrag_running, 1))
1058
		return 0;
1059

1060
	while (1) {
1061 1062 1063 1064
		trans = btrfs_start_transaction(root, 0);
		if (IS_ERR(trans))
			return PTR_ERR(trans);

1065
		ret = btrfs_defrag_leaves(trans, root);
1066

1067
		btrfs_end_transaction(trans, root);
1068
		btrfs_btree_balance_dirty(info->tree_root);
1069 1070
		cond_resched();

1071
		if (btrfs_fs_closing(root->fs_info) || ret != -EAGAIN)
1072
			break;
1073 1074 1075 1076 1077 1078

		if (btrfs_defrag_cancelled(root->fs_info)) {
			printk(KERN_DEBUG "btrfs: defrag_root cancelled\n");
			ret = -EAGAIN;
			break;
		}
1079 1080
	}
	root->defrag_running = 0;
1081
	return ret;
1082 1083
}

1084 1085
/*
 * new snapshots need to be created at a very specific time in the
1086 1087 1088 1089 1090 1091
 * transaction commit.  This does the actual creation.
 *
 * Note:
 * If the error which may affect the commitment of the current transaction
 * happens, we should return the error number. If the error which just affect
 * the creation of the pending snapshots, just return 0.
1092
 */
1093
static noinline int create_pending_snapshot(struct btrfs_trans_handle *trans,
1094 1095 1096 1097
				   struct btrfs_fs_info *fs_info,
				   struct btrfs_pending_snapshot *pending)
{
	struct btrfs_key key;
1098
	struct btrfs_root_item *new_root_item;
1099 1100
	struct btrfs_root *tree_root = fs_info->tree_root;
	struct btrfs_root *root = pending->root;
1101
	struct btrfs_root *parent_root;
1102
	struct btrfs_block_rsv *rsv;
1103
	struct inode *parent_inode;
1104 1105
	struct btrfs_path *path;
	struct btrfs_dir_item *dir_item;
1106
	struct dentry *dentry;
1107
	struct extent_buffer *tmp;
1108
	struct extent_buffer *old;
1109
	struct timespec cur_time = CURRENT_TIME;
1110
	int ret = 0;
1111
	u64 to_reserve = 0;
1112
	u64 index = 0;
1113
	u64 objectid;
1114
	u64 root_flags;
1115
	uuid_le new_uuid;
1116

1117 1118
	path = btrfs_alloc_path();
	if (!path) {
1119 1120
		pending->error = -ENOMEM;
		return 0;
1121 1122
	}

1123 1124
	new_root_item = kmalloc(sizeof(*new_root_item), GFP_NOFS);
	if (!new_root_item) {
1125
		pending->error = -ENOMEM;
1126
		goto root_item_alloc_fail;
1127
	}
1128

1129 1130
	pending->error = btrfs_find_free_objectid(tree_root, &objectid);
	if (pending->error)
1131
		goto no_free_objectid;
1132

1133
	btrfs_reloc_pre_snapshot(trans, pending, &to_reserve);
1134 1135

	if (to_reserve > 0) {
1136 1137 1138 1139 1140
		pending->error = btrfs_block_rsv_add(root,
						     &pending->block_rsv,
						     to_reserve,
						     BTRFS_RESERVE_NO_FLUSH);
		if (pending->error)
1141
			goto no_free_objectid;
1142 1143
	}

1144 1145 1146 1147
	pending->error = btrfs_qgroup_inherit(trans, fs_info,
					      root->root_key.objectid,
					      objectid, pending->inherit);
	if (pending->error)
1148
		goto no_free_objectid;
Arne Jansen's avatar
Arne Jansen committed
1149

1150
	key.objectid = objectid;
1151 1152
	key.offset = (u64)-1;
	key.type = BTRFS_ROOT_ITEM_KEY;
1153

1154
	rsv = trans->block_rsv;
1155
	trans->block_rsv = &pending->block_rsv;
1156
	trans->bytes_reserved = trans->block_rsv->reserved;
1157

1158
	dentry = pending->dentry;
1159
	parent_inode = pending->dir;
1160
	parent_root = BTRFS_I(parent_inode)->root;
Chris Mason's avatar
Chris Mason committed
1161
	record_root_in_trans(trans, parent_root);
1162

1163 1164 1165
	/*
	 * insert the directory item
	 */
1166
	ret = btrfs_set_inode_index(parent_inode, &index);
1167
	BUG_ON(ret); /* -ENOMEM */
1168 1169 1170 1171 1172 1173 1174

	/* 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)) {
1175
		pending->error = -EEXIST;
1176
		goto dir_item_existed;
1177 1178
	} else if (IS_ERR(dir_item)) {
		ret = PTR_ERR(dir_item);
1179 1180
		btrfs_abort_transaction(trans, root, ret);
		goto fail;
1181
	}
1182
	btrfs_release_path(path);
1183

1184 1185 1186 1187 1188 1189 1190
	/*
	 * 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);
1191 1192 1193 1194
	if (ret) {	/* Transaction aborted */
		btrfs_abort_transaction(trans, root, ret);
		goto fail;
	}
1195

Chris Mason's avatar
Chris Mason committed
1196
	record_root_in_trans(trans, root);
1197 1198
	btrfs_set_root_last_snapshot(&root->root_item, trans->transid);
	memcpy(new_root_item, &root->root_item, sizeof(*new_root_item));
1199
	btrfs_check_and_init_root_item(new_root_item);
1200

1201 1202 1203 1204 1205 1206 1207
	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);

1208 1209 1210 1211 1212 1213
	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);
1214 1215 1216 1217 1218 1219 1220 1221
	if (!(root_flags & BTRFS_ROOT_SUBVOL_RDONLY)) {
		memset(new_root_item->received_uuid, 0,
		       sizeof(new_root_item->received_uuid));
		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);
	}
1222 1223
	btrfs_set_stack_timespec_sec(&new_root_item->otime, cur_time.tv_sec);
	btrfs_set_stack_timespec_nsec(&new_root_item->otime, cur_time.tv_nsec);
1224 1225
	btrfs_set_root_otransid(new_root_item, trans->transid);

1226
	old = btrfs_lock_root_node(root);
1227
	ret = btrfs_cow_block(trans, root, old, NULL, 0, &old);
1228 1229 1230
	if (ret) {
		btrfs_tree_unlock(old);
		free_extent_buffer(old);
1231 1232
		btrfs_abort_transaction(trans, root, ret);
		goto fail;
1233
	}
1234

1235 1236
	btrfs_set_lock_blocking(old);

1237
	ret = btrfs_copy_root(trans, root, old, &tmp, objectid);
1238
	/* clean up in any case */
1239 1240
	btrfs_tree_unlock(old);
	free_extent_buffer(old);
1241 1242 1243 1244
	if (ret) {
		btrfs_abort_transaction(trans, root, ret);
		goto fail;
	}
1245

1246 1247 1248 1249
	/* see comments in should_cow_block() */
	root->force_cow = 1;
	smp_wmb();

1250
	btrfs_set_root_node(new_root_item, tmp);
1251 1252 1253
	/* record when the snapshot was created in key.offset */
	key.offset = trans->transid;
	ret = btrfs_insert_root(trans, tree_root, &key, new_root_item);
1254 1255
	btrfs_tree_unlock(tmp);
	free_extent_buffer(tmp);
1256 1257 1258 1259
	if (ret) {
		btrfs_abort_transaction(trans, root, ret);
		goto fail;
	}
1260

1261 1262 1263 1264
	/*
	 * insert root back/forward references
	 */
	ret = btrfs_add_root_ref(trans, tree_root, objectid,
1265
				 parent_root->root_key.objectid,
1266
				 btrfs_ino(parent_inode), index,
1267
				 dentry->d_name.name, dentry->d_name.len);
1268 1269 1270 1271
	if (ret) {
		btrfs_abort_transaction(trans, root, ret);
		goto fail;
	}
1272

1273 1274
	key.offset = (u64)-1;
	pending->snap = btrfs_read_fs_root_no_name(root->fs_info, &key);
1275 1276
	if (IS_ERR(pending->snap)) {
		ret = PTR_ERR(pending->snap);
1277 1278
		btrfs_abort_transaction(trans, root, ret);
		goto fail;
1279
	}
1280

1281
	ret = btrfs_reloc_post_snapshot(trans, pending);
1282 1283 1284 1285
	if (ret) {
		btrfs_abort_transaction(trans, root, ret);
		goto fail;
	}
1286 1287

	ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
1288 1289 1290 1291
	if (ret) {
		btrfs_abort_transaction(trans, root, ret);
		goto fail;
	}
1292 1293 1294 1295 1296 1297

	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. */
1298
	BUG_ON(ret == -EEXIST || ret == -EOVERFLOW);
1299 1300 1301 1302
	if (ret) {
		btrfs_abort_transaction(trans, root, ret);
		goto fail;
	}
1303 1304 1305 1306

	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;
1307
	ret = btrfs_update_inode_fallback(trans, parent_root, parent_inode);
1308 1309 1310 1311 1312 1313 1314
	if (ret) {
		btrfs_abort_transaction(trans, root, ret);
		goto fail;
	}
	ret = btrfs_uuid_tree_add(trans, fs_info->uuid_root, new_uuid.b,
				  BTRFS_UUID_KEY_SUBVOL, objectid);
	if (ret) {
1315
		btrfs_abort_transaction(trans, root, ret);
1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327
		goto fail;
	}
	if (!btrfs_is_empty_uuid(new_root_item->received_uuid)) {
		ret = btrfs_uuid_tree_add(trans, fs_info->uuid_root,
					  new_root_item->received_uuid,
					  BTRFS_UUID_KEY_RECEIVED_SUBVOL,
					  objectid);
		if (ret && ret != -EEXIST) {
			btrfs_abort_transaction(trans, root, ret);
			goto fail;
		}
	}
1328
fail:
1329 1330
	pending->error = ret;
dir_item_existed:
1331
	trans->block_rsv = rsv;
1332
	trans->bytes_reserved = 0;
1333 1334 1335
no_free_objectid:
	kfree(new_root_item);
root_item_alloc_fail:
1336
	btrfs_free_path(path);
1337
	return ret;
1338 1339
}

1340 1341 1342
/*
 * create all the snapshots we've scheduled for creation
 */
1343 1344
static noinline int create_pending_snapshots(struct btrfs_trans_handle *trans,
					     struct btrfs_fs_info *fs_info)
1345
{
1346
	struct btrfs_pending_snapshot *pending, *next;
1347
	struct list_head *head = &trans->transaction->pending_snapshots;
1348
	int ret = 0;
1349

1350 1351 1352 1353 1354 1355 1356
	list_for_each_entry_safe(pending, next, head, list) {
		list_del(&pending->list);
		ret = create_pending_snapshot(trans, fs_info, pending);
		if (ret)
			break;
	}
	return ret;
1357 1358
}

1359 1360 1361 1362 1363
static void update_super_roots(struct btrfs_root *root)
{
	struct btrfs_root_item *root_item;
	struct btrfs_super_block *super;

1364
	super = root->fs_info->super_copy;
1365 1366 1367 1368 1369 1370 1371 1372 1373 1374

	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;
1375
	if (btrfs_test_opt(root, SPACE_CACHE))
1376
		super->cache_generation = root_item->generation;
1377 1378
	if (root->fs_info->update_uuid_tree_gen)
		super->uuid_tree_generation = root_item->generation;
1379 1380
}

1381 1382
int btrfs_transaction_in_commit(struct btrfs_fs_info *info)
{
1383
	struct btrfs_transaction *trans;
1384
	int ret = 0;
1385

Josef Bacik's avatar
Josef Bacik committed
1386
	spin_lock(&info->trans_lock);
1387 1388 1389
	trans = info->running_transaction;
	if (trans)
		ret = (trans->state >= TRANS_STATE_COMMIT_START);
Josef Bacik's avatar
Josef Bacik committed
1390
	spin_unlock(&info->trans_lock);
1391 1392 1393
	return ret;
}

1394 1395
int btrfs_transaction_blocked(struct btrfs_fs_info *info)
{
1396
	struct btrfs_transaction *trans;
1397
	int ret = 0;
1398

Josef Bacik's avatar
Josef Bacik committed
1399
	spin_lock(&info->trans_lock);
1400 1401 1402
	trans = info->running_transaction;
	if (trans)
		ret = is_transaction_blocked(trans);
Josef Bacik's avatar
Josef Bacik committed
1403
	spin_unlock(&info->trans_lock);
1404 1405 1406
	return ret;
}

Sage Weil's avatar
Sage Weil committed
1407 1408 1409 1410 1411 1412 1413
/*
 * 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)
{
1414
	wait_event(root->fs_info->transaction_blocked_wait,
1415 1416
		   trans->state >= TRANS_STATE_COMMIT_START ||
		   trans->aborted);
Sage Weil's avatar
Sage Weil committed
1417 1418 1419 1420 1421 1422 1423 1424 1425
}

/*
 * 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)
{
Li Zefan's avatar
Li Zefan committed
1426
	wait_event(root->fs_info->transaction_wait,
1427 1428
		   trans->state >= TRANS_STATE_UNBLOCKED ||
		   trans->aborted);
Sage Weil's avatar
Sage Weil committed
1429 1430 1431 1432 1433 1434 1435 1436 1437
}

/*
 * 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;
1438
	struct work_struct work;
Sage Weil's avatar
Sage Weil committed
1439 1440 1441 1442 1443
};

static void do_async_commit(struct work_struct *work)
{
	struct btrfs_async_commit *ac =
1444
		container_of(work, struct btrfs_async_commit, work);
Sage Weil's avatar
Sage Weil committed
1445

1446 1447 1448 1449
	/*
	 * We've got freeze protection passed with the transaction.
	 * Tell lockdep about it.
	 */
1450
	if (ac->newtrans->type & __TRANS_FREEZABLE)
1451 1452 1453
		rwsem_acquire_read(
		     &ac->root->fs_info->sb->s_writers.lock_map[SB_FREEZE_FS-1],
		     0, 1, _THIS_IP_);
1454

1455 1456
	current->journal_info = ac->newtrans;

Sage Weil's avatar
Sage Weil committed
1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468
	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);
Tsutomu Itoh's avatar
Tsutomu Itoh committed
1469 1470
	if (!ac)
		return -ENOMEM;
Sage Weil's avatar
Sage Weil committed
1471

1472
	INIT_WORK(&ac->work, do_async_commit);
Sage Weil's avatar
Sage Weil committed
1473
	ac->root = root;
1474
	ac->newtrans = btrfs_join_transaction(root);
1475 1476 1477 1478 1479
	if (IS_ERR(ac->newtrans)) {
		int err = PTR_ERR(ac->newtrans);
		kfree(ac);
		return err;
	}
Sage Weil's avatar
Sage Weil committed
1480 1481 1482

	/* take transaction reference */
	cur_trans = trans->transaction;
1483
	atomic_inc(&cur_trans->use_count);
Sage Weil's avatar
Sage Weil committed
1484 1485

	btrfs_end_transaction(trans, root);
1486 1487 1488 1489 1490

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

1496
	schedule_work(&ac->work);
Sage Weil's avatar
Sage Weil committed
1497 1498 1499 1500 1501 1502 1503

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

1504 1505 1506 1507
	if (current->journal_info == trans)
		current->journal_info = NULL;

	put_transaction(cur_trans);
Sage Weil's avatar
Sage Weil committed
1508 1509 1510
	return 0;
}

1511 1512

static void cleanup_transaction(struct btrfs_trans_handle *trans,
1513
				struct btrfs_root *root, int err)
1514 1515
{
	struct btrfs_transaction *cur_trans = trans->transaction;
1516
	DEFINE_WAIT(wait);
1517 1518 1519

	WARN_ON(trans->use_count > 1);

1520 1521
	btrfs_abort_transaction(trans, root, err);

1522
	spin_lock(&root->fs_info->trans_lock);
1523

1524 1525 1526 1527 1528 1529
	/*
	 * If the transaction is removed from the list, it means this
	 * transaction has been committed successfully, so it is impossible
	 * to call the cleanup function.
	 */
	BUG_ON(list_empty(&cur_trans->list));
1530

1531
	list_del_init(&cur_trans->list);
1532
	if (cur_trans == root->fs_info->running_transaction) {
1533
		cur_trans->state = TRANS_STATE_COMMIT_DOING;
1534 1535 1536 1537 1538
		spin_unlock(&root->fs_info->trans_lock);
		wait_event(cur_trans->writer_wait,
			   atomic_read(&cur_trans->num_writers) == 1);

		spin_lock(&root->fs_info->trans_lock);
1539
	}
1540 1541 1542 1543
	spin_unlock(&root->fs_info->trans_lock);

	btrfs_cleanup_one_transaction(trans->transaction, root);

1544 1545 1546 1547 1548
	spin_lock(&root->fs_info->trans_lock);
	if (cur_trans == root->fs_info->running_transaction)
		root->fs_info->running_transaction = NULL;
	spin_unlock(&root->fs_info->trans_lock);

1549 1550
	if (trans->type & __TRANS_FREEZABLE)
		sb_end_intwrite(root->fs_info->sb);
1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563
	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);
}

1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586
static int btrfs_flush_all_pending_stuffs(struct btrfs_trans_handle *trans,
					  struct btrfs_root *root)
{
	int ret;

	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
	 */
1587
	ret = btrfs_run_ordered_operations(trans, root, 1);
1588

1589
	return ret;
1590 1591
}

1592 1593 1594 1595 1596 1597 1598 1599 1600 1601
static inline int btrfs_start_delalloc_flush(struct btrfs_fs_info *fs_info)
{
	if (btrfs_test_opt(fs_info->tree_root, FLUSHONCOMMIT))
		return btrfs_start_all_delalloc_inodes(fs_info, 1);
	return 0;
}

static inline void btrfs_wait_delalloc_flush(struct btrfs_fs_info *fs_info)
{
	if (btrfs_test_opt(fs_info->tree_root, FLUSHONCOMMIT))
1602
		btrfs_wait_all_ordered_extents(fs_info);
1603 1604
}

Chris Mason's avatar
Chris Mason committed
1605 1606 1607
int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
			     struct btrfs_root *root)
{
1608
	struct btrfs_transaction *cur_trans = trans->transaction;
Chris Mason's avatar
Chris Mason committed
1609
	struct btrfs_transaction *prev_trans = NULL;
1610
	int ret;
Chris Mason's avatar
Chris Mason committed
1611

1612
	ret = btrfs_run_ordered_operations(trans, root, 0);
1613 1614
	if (ret) {
		btrfs_abort_transaction(trans, root, ret);
1615 1616
		btrfs_end_transaction(trans, root);
		return ret;
1617
	}
1618

1619 1620
	/* Stop the commit early if ->aborted is set */
	if (unlikely(ACCESS_ONCE(cur_trans->aborted))) {
1621
		ret = cur_trans->aborted;
1622 1623
		btrfs_end_transaction(trans, root);
		return ret;
1624
	}
1625

1626 1627 1628 1629
	/* 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);
1630 1631 1632 1633
	if (ret) {
		btrfs_end_transaction(trans, root);
		return ret;
	}
1634

1635 1636
	btrfs_trans_release_metadata(trans, root);
	trans->block_rsv = NULL;
1637 1638 1639 1640
	if (trans->qgroup_reserved) {
		btrfs_qgroup_free(root, trans->qgroup_reserved);
		trans->qgroup_reserved = 0;
	}
1641

1642
	cur_trans = trans->transaction;
1643

1644 1645 1646 1647
	/*
	 * set the flushing flag so procs in this transaction have to
	 * start sending their work down.
	 */
1648
	cur_trans->delayed_refs.flushing = 1;
1649
	smp_wmb();
1650

1651 1652 1653
	if (!list_empty(&trans->new_bgs))
		btrfs_create_pending_block_groups(trans, root);

1654
	ret = btrfs_run_delayed_refs(trans, root, 0);
1655 1656 1657 1658
	if (ret) {
		btrfs_end_transaction(trans, root);
		return ret;
	}
1659

1660 1661 1662
	spin_lock(&root->fs_info->trans_lock);
	if (cur_trans->state >= TRANS_STATE_COMMIT_START) {
		spin_unlock(&root->fs_info->trans_lock);
1663
		atomic_inc(&cur_trans->use_count);
1664
		ret = btrfs_end_transaction(trans, root);
Chris Mason's avatar
Chris Mason committed
1665

1666
		wait_for_commit(root, cur_trans);
1667

Chris Mason's avatar
Chris Mason committed
1668
		put_transaction(cur_trans);
1669

1670
		return ret;
Chris Mason's avatar
Chris Mason committed
1671
	}
1672

1673
	cur_trans->state = TRANS_STATE_COMMIT_START;
Sage Weil's avatar
Sage Weil committed
1674 1675
	wake_up(&root->fs_info->transaction_blocked_wait);

Chris Mason's avatar
Chris Mason committed
1676 1677 1678
	if (cur_trans->list.prev != &root->fs_info->trans_list) {
		prev_trans = list_entry(cur_trans->list.prev,
					struct btrfs_transaction, list);
1679
		if (prev_trans->state != TRANS_STATE_COMPLETED) {
1680
			atomic_inc(&prev_trans->use_count);
Josef Bacik's avatar
Josef Bacik committed
1681
			spin_unlock(&root->fs_info->trans_lock);
Chris Mason's avatar
Chris Mason committed
1682 1683 1684

			wait_for_commit(root, prev_trans);

1685
			put_transaction(prev_trans);
Josef Bacik's avatar
Josef Bacik committed
1686 1687
		} else {
			spin_unlock(&root->fs_info->trans_lock);
Chris Mason's avatar
Chris Mason committed
1688
		}
Josef Bacik's avatar
Josef Bacik committed
1689 1690
	} else {
		spin_unlock(&root->fs_info->trans_lock);
Chris Mason's avatar
Chris Mason committed
1691
	}
1692

1693 1694
	extwriter_counter_dec(cur_trans, trans->type);

1695 1696 1697 1698
	ret = btrfs_start_delalloc_flush(root->fs_info);
	if (ret)
		goto cleanup_transaction;

1699 1700 1701
	ret = btrfs_flush_all_pending_stuffs(trans, root);
	if (ret)
		goto cleanup_transaction;
1702

1703 1704
	wait_event(cur_trans->writer_wait,
		   extwriter_counter_read(cur_trans) == 0);
1705

1706
	/* some pending stuffs might be added after the previous flush. */
1707 1708 1709 1710
	ret = btrfs_flush_all_pending_stuffs(trans, root);
	if (ret)
		goto cleanup_transaction;

1711
	btrfs_wait_delalloc_flush(root->fs_info);
1712 1713 1714
	/*
	 * 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
1715
	 * COMMIT_DOING so make sure to wait for num_writers to == 1 again.
1716 1717
	 */
	spin_lock(&root->fs_info->trans_lock);
1718
	cur_trans->state = TRANS_STATE_COMMIT_DOING;
1719 1720 1721 1722
	spin_unlock(&root->fs_info->trans_lock);
	wait_event(cur_trans->writer_wait,
		   atomic_read(&cur_trans->num_writers) == 1);

1723 1724 1725 1726 1727
	/* ->aborted might be set after the previous check, so check it */
	if (unlikely(ACCESS_ONCE(cur_trans->aborted))) {
		ret = cur_trans->aborted;
		goto cleanup_transaction;
	}
Chris Mason's avatar
Chris Mason committed
1728 1729 1730 1731 1732 1733 1734
	/*
	 * 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);

1735 1736 1737 1738 1739 1740
	/*
	 * 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);
1741 1742 1743 1744
	if (ret) {
		mutex_unlock(&root->fs_info->reloc_mutex);
		goto cleanup_transaction;
	}
1745

1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756
	/*
	 * 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);
1757 1758 1759 1760
	if (ret) {
		mutex_unlock(&root->fs_info->reloc_mutex);
		goto cleanup_transaction;
	}
1761

1762
	ret = btrfs_run_delayed_refs(trans, root, (unsigned long)-1);
1763 1764 1765 1766
	if (ret) {
		mutex_unlock(&root->fs_info->reloc_mutex);
		goto cleanup_transaction;
	}
1767

1768 1769 1770 1771 1772 1773
	/*
	 * make sure none of the code above managed to slip in a
	 * delayed item
	 */
	btrfs_assert_delayed_root_empty(root);

1774
	WARN_ON(cur_trans != trans->transaction);
1775

Arne Jansen's avatar
Arne Jansen committed
1776
	btrfs_scrub_pause(root);
1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791
	/* 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);

1792
	ret = commit_fs_roots(trans, root);
1793 1794
	if (ret) {
		mutex_unlock(&root->fs_info->tree_log_mutex);
1795
		mutex_unlock(&root->fs_info->reloc_mutex);
1796 1797
		goto cleanup_transaction;
	}
1798

1799
	/* commit_fs_roots gets rid of all the tree log roots, it is now
1800 1801 1802 1803
	 * safe to free the root of tree log roots
	 */
	btrfs_free_log_root_tree(trans, root->fs_info);

1804
	ret = commit_cowonly_roots(trans, root);
1805 1806
	if (ret) {
		mutex_unlock(&root->fs_info->tree_log_mutex);
1807
		mutex_unlock(&root->fs_info->reloc_mutex);
1808 1809
		goto cleanup_transaction;
	}
1810

1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821
	/*
	 * The tasks which save the space cache and inode cache may also
	 * update ->aborted, check it.
	 */
	if (unlikely(ACCESS_ONCE(cur_trans->aborted))) {
		ret = cur_trans->aborted;
		mutex_unlock(&root->fs_info->tree_log_mutex);
		mutex_unlock(&root->fs_info->reloc_mutex);
		goto cleanup_transaction;
	}

1822 1823
	btrfs_prepare_extent_commit(trans, root);

1824
	cur_trans = root->fs_info->running_transaction;
1825 1826 1827

	btrfs_set_root_node(&root->fs_info->tree_root->root_item,
			    root->fs_info->tree_root->node);
1828
	switch_commit_root(root->fs_info->tree_root);
1829 1830 1831

	btrfs_set_root_node(&root->fs_info->chunk_root->root_item,
			    root->fs_info->chunk_root->node);
1832
	switch_commit_root(root->fs_info->chunk_root);
1833

1834
	assert_qgroups_uptodate(trans);
1835
	update_super_roots(root);
1836

1837 1838
	btrfs_set_super_log_root(root->fs_info->super_copy, 0);
	btrfs_set_super_log_root_level(root->fs_info->super_copy, 0);
1839 1840
	memcpy(root->fs_info->super_for_commit, root->fs_info->super_copy,
	       sizeof(*root->fs_info->super_copy));
Chris Mason's avatar
Chris Mason committed
1841

Josef Bacik's avatar
Josef Bacik committed
1842
	spin_lock(&root->fs_info->trans_lock);
1843
	cur_trans->state = TRANS_STATE_UNBLOCKED;
Josef Bacik's avatar
Josef Bacik committed
1844 1845
	root->fs_info->running_transaction = NULL;
	spin_unlock(&root->fs_info->trans_lock);
Chris Mason's avatar
Chris Mason committed
1846
	mutex_unlock(&root->fs_info->reloc_mutex);
1847

1848
	wake_up(&root->fs_info->transaction_wait);
1849

Chris Mason's avatar
Chris Mason committed
1850
	ret = btrfs_write_and_wait_transaction(trans, root);
1851 1852
	if (ret) {
		btrfs_error(root->fs_info, ret,
1853
			    "Error while writing out transaction");
1854 1855 1856 1857 1858 1859 1860 1861 1862
		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;
	}
1863

1864 1865 1866 1867 1868 1869
	/*
	 * the super is written, we can safely allow the tree-loggers
	 * to go about their business
	 */
	mutex_unlock(&root->fs_info->tree_log_mutex);

1870
	btrfs_finish_extent_commit(trans, root);
1871

1872
	root->fs_info->last_trans_committed = cur_trans->transid;
1873 1874 1875 1876 1877
	/*
	 * We needn't acquire the lock here because there is no other task
	 * which can change it.
	 */
	cur_trans->state = TRANS_STATE_COMPLETED;
1878
	wake_up(&cur_trans->commit_wait);
1879

Josef Bacik's avatar
Josef Bacik committed
1880
	spin_lock(&root->fs_info->trans_lock);
1881
	list_del_init(&cur_trans->list);
Josef Bacik's avatar
Josef Bacik committed
1882 1883
	spin_unlock(&root->fs_info->trans_lock);

1884
	put_transaction(cur_trans);
Chris Mason's avatar
Chris Mason committed
1885
	put_transaction(cur_trans);
1886

1887
	if (trans->type & __TRANS_FREEZABLE)
1888
		sb_end_intwrite(root->fs_info->sb);
1889

1890 1891
	trace_btrfs_transaction_commit(root);

Arne Jansen's avatar
Arne Jansen committed
1892 1893
	btrfs_scrub_continue(root);

Josef Bacik's avatar
Josef Bacik committed
1894 1895 1896
	if (current->journal_info == trans)
		current->journal_info = NULL;

1897
	kmem_cache_free(btrfs_trans_handle_cachep, trans);
Yan, Zheng's avatar
Yan, Zheng committed
1898 1899 1900 1901

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

Chris Mason's avatar
Chris Mason committed
1902
	return ret;
1903 1904

cleanup_transaction:
1905 1906
	btrfs_trans_release_metadata(trans, root);
	trans->block_rsv = NULL;
1907 1908 1909 1910
	if (trans->qgroup_reserved) {
		btrfs_qgroup_free(root, trans->qgroup_reserved);
		trans->qgroup_reserved = 0;
	}
1911
	btrfs_warn(root->fs_info, "Skipping commit of aborted transaction.");
1912 1913
	if (current->journal_info == trans)
		current->journal_info = NULL;
1914
	cleanup_transaction(trans, root, ret);
1915 1916

	return ret;
Chris Mason's avatar
Chris Mason committed
1917 1918
}

1919
/*
1920 1921 1922 1923 1924 1925 1926 1927
 * return < 0 if error
 * 0 if there are no more dead_roots at the time of call
 * 1 there are more to be processed, call me again
 *
 * The return value indicates there are certainly more snapshots to delete, but
 * if there comes a new one during processing, it may return 0. We don't mind,
 * because btrfs_commit_super will poke cleaner thread and it will process it a
 * few seconds later.
1928
 */
1929
int btrfs_clean_one_deleted_snapshot(struct btrfs_root *root)
1930
{
1931
	int ret;
1932 1933
	struct btrfs_fs_info *fs_info = root->fs_info;

Josef Bacik's avatar
Josef Bacik committed
1934
	spin_lock(&fs_info->trans_lock);
1935 1936 1937 1938 1939 1940
	if (list_empty(&fs_info->dead_roots)) {
		spin_unlock(&fs_info->trans_lock);
		return 0;
	}
	root = list_first_entry(&fs_info->dead_roots,
			struct btrfs_root, root_list);
1941
	list_del_init(&root->root_list);
Josef Bacik's avatar
Josef Bacik committed
1942
	spin_unlock(&fs_info->trans_lock);
1943

1944
	pr_debug("btrfs: cleaner removing %llu\n", root->objectid);
1945

1946
	btrfs_kill_all_delayed_nodes(root);
1947

1948 1949 1950 1951 1952 1953 1954 1955 1956
	if (btrfs_header_backref_rev(root->node) <
			BTRFS_MIXED_BACKREF_REV)
		ret = btrfs_drop_snapshot(root, NULL, 0, 0);
	else
		ret = btrfs_drop_snapshot(root, NULL, 1, 0);
	/*
	 * If we encounter a transaction abort during snapshot cleaning, we
	 * don't want to crash here
	 */
1957
	return (ret < 0) ? 0 : 1;
1958
}