disk-io.c 112.5 KB
Newer Older
C
Chris Mason 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
/*
 * Copyright (C) 2007 Oracle.  All rights reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public
 * License v2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public
 * License along with this program; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 021110-1307, USA.
 */

C
Chris Mason 已提交
19
#include <linux/fs.h>
20
#include <linux/blkdev.h>
C
Chris Mason 已提交
21
#include <linux/scatterlist.h>
C
Chris Mason 已提交
22
#include <linux/swap.h>
23
#include <linux/radix-tree.h>
C
Chris Mason 已提交
24
#include <linux/writeback.h>
C
Chris Mason 已提交
25
#include <linux/buffer_head.h>
26
#include <linux/workqueue.h>
27
#include <linux/kthread.h>
C
Chris Mason 已提交
28
#include <linux/freezer.h>
29
#include <linux/slab.h>
30
#include <linux/migrate.h>
31
#include <linux/ratelimit.h>
32
#include <linux/uuid.h>
S
Stefan Behrens 已提交
33
#include <linux/semaphore.h>
34
#include <asm/unaligned.h>
35 36
#include "ctree.h"
#include "disk-io.h"
37
#include "hash.h"
38
#include "transaction.h"
39
#include "btrfs_inode.h"
40
#include "volumes.h"
41
#include "print-tree.h"
42
#include "async-thread.h"
43
#include "locking.h"
44
#include "tree-log.h"
45
#include "free-space-cache.h"
46
#include "inode-map.h"
47
#include "check-integrity.h"
48
#include "rcu-string.h"
49
#include "dev-replace.h"
D
David Woodhouse 已提交
50
#include "raid56.h"
51
#include "sysfs.h"
J
Josef Bacik 已提交
52
#include "qgroup.h"
53

54 55 56 57
#ifdef CONFIG_X86
#include <asm/cpufeature.h>
#endif

58
static struct extent_io_ops btree_extent_io_ops;
59
static void end_workqueue_fn(struct btrfs_work *work);
60
static void free_fs_root(struct btrfs_root *root);
61
static int btrfs_check_super_valid(struct btrfs_fs_info *fs_info,
L
liubo 已提交
62
				    int read_only);
63
static void btrfs_destroy_ordered_extents(struct btrfs_root *root);
L
liubo 已提交
64 65
static int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans,
				      struct btrfs_root *root);
66
static void btrfs_destroy_delalloc_inodes(struct btrfs_root *root);
L
liubo 已提交
67 68 69 70 71
static int btrfs_destroy_marked_extents(struct btrfs_root *root,
					struct extent_io_tree *dirty_pages,
					int mark);
static int btrfs_destroy_pinned_extent(struct btrfs_root *root,
				       struct extent_io_tree *pinned_extents);
72 73
static int btrfs_cleanup_transaction(struct btrfs_root *root);
static void btrfs_error_commit_super(struct btrfs_root *root);
74

C
Chris Mason 已提交
75 76 77 78 79
/*
 * end_io_wq structs are used to do processing in task context when an IO is
 * complete.  This is used during reads to verify checksums, and it is used
 * by writes to insert metadata for new file extents after IO is complete.
 */
80 81 82 83 84 85
struct end_io_wq {
	struct bio *bio;
	bio_end_io_t *end_io;
	void *private;
	struct btrfs_fs_info *info;
	int error;
86
	int metadata;
87
	struct list_head list;
88
	struct btrfs_work work;
89
};
90

C
Chris Mason 已提交
91 92 93 94 95
/*
 * async submit bios are used to offload expensive checksumming
 * onto the worker threads.  They checksum file and metadata bios
 * just before they are sent down the IO stack.
 */
96 97 98 99
struct async_submit_bio {
	struct inode *inode;
	struct bio *bio;
	struct list_head list;
C
Chris Mason 已提交
100 101
	extent_submit_bio_hook_t *submit_bio_start;
	extent_submit_bio_hook_t *submit_bio_done;
102 103
	int rw;
	int mirror_num;
C
Chris Mason 已提交
104
	unsigned long bio_flags;
105 106 107 108 109
	/*
	 * bio_offset is optional, can be used if the pages in the bio
	 * can't tell us where in the file the bio should go
	 */
	u64 bio_offset;
110
	struct btrfs_work work;
111
	int error;
112 113
};

114 115 116 117 118 119 120 121 122 123
/*
 * Lockdep class keys for extent_buffer->lock's in this root.  For a given
 * eb, the lockdep key is determined by the btrfs_root it belongs to and
 * the level the eb occupies in the tree.
 *
 * Different roots are used for different purposes and may nest inside each
 * other and they require separate keysets.  As lockdep keys should be
 * static, assign keysets according to the purpose of the root as indicated
 * by btrfs_root->objectid.  This ensures that all special purpose roots
 * have separate keysets.
124
 *
125 126 127
 * Lock-nesting across peer nodes is always done with the immediate parent
 * node locked thus preventing deadlock.  As lockdep doesn't know this, use
 * subclass to avoid triggering lockdep warning in such cases.
128
 *
129 130 131
 * The key is set by the readpage_end_io_hook after the buffer has passed
 * csum validation but before the pages are unlocked.  It is also set by
 * btrfs_init_new_buffer on freshly allocated blocks.
132
 *
133 134 135
 * We also add a check to make sure the highest level of the tree is the
 * same as our lockdep setup here.  If BTRFS_MAX_LEVEL changes, this code
 * needs update as well.
136 137 138 139 140
 */
#ifdef CONFIG_DEBUG_LOCK_ALLOC
# if BTRFS_MAX_LEVEL != 8
#  error
# endif
141 142 143 144 145 146 147 148 149 150 151 152 153

static struct btrfs_lockdep_keyset {
	u64			id;		/* root objectid */
	const char		*name_stem;	/* lock name stem */
	char			names[BTRFS_MAX_LEVEL + 1][20];
	struct lock_class_key	keys[BTRFS_MAX_LEVEL + 1];
} btrfs_lockdep_keysets[] = {
	{ .id = BTRFS_ROOT_TREE_OBJECTID,	.name_stem = "root"	},
	{ .id = BTRFS_EXTENT_TREE_OBJECTID,	.name_stem = "extent"	},
	{ .id = BTRFS_CHUNK_TREE_OBJECTID,	.name_stem = "chunk"	},
	{ .id = BTRFS_DEV_TREE_OBJECTID,	.name_stem = "dev"	},
	{ .id = BTRFS_FS_TREE_OBJECTID,		.name_stem = "fs"	},
	{ .id = BTRFS_CSUM_TREE_OBJECTID,	.name_stem = "csum"	},
154
	{ .id = BTRFS_QUOTA_TREE_OBJECTID,	.name_stem = "quota"	},
155 156 157
	{ .id = BTRFS_TREE_LOG_OBJECTID,	.name_stem = "log"	},
	{ .id = BTRFS_TREE_RELOC_OBJECTID,	.name_stem = "treloc"	},
	{ .id = BTRFS_DATA_RELOC_TREE_OBJECTID,	.name_stem = "dreloc"	},
158
	{ .id = BTRFS_UUID_TREE_OBJECTID,	.name_stem = "uuid"	},
159
	{ .id = 0,				.name_stem = "tree"	},
160
};
161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191

void __init btrfs_init_lockdep(void)
{
	int i, j;

	/* initialize lockdep class names */
	for (i = 0; i < ARRAY_SIZE(btrfs_lockdep_keysets); i++) {
		struct btrfs_lockdep_keyset *ks = &btrfs_lockdep_keysets[i];

		for (j = 0; j < ARRAY_SIZE(ks->names); j++)
			snprintf(ks->names[j], sizeof(ks->names[j]),
				 "btrfs-%s-%02d", ks->name_stem, j);
	}
}

void btrfs_set_buffer_lockdep_class(u64 objectid, struct extent_buffer *eb,
				    int level)
{
	struct btrfs_lockdep_keyset *ks;

	BUG_ON(level >= ARRAY_SIZE(ks->keys));

	/* find the matching keyset, id 0 is the default entry */
	for (ks = btrfs_lockdep_keysets; ks->id; ks++)
		if (ks->id == objectid)
			break;

	lockdep_set_class_and_name(&eb->lock,
				   &ks->keys[level], ks->names[level]);
}

192 193
#endif

C
Chris Mason 已提交
194 195 196 197
/*
 * extents on the btree inode are pretty simple, there's one extent
 * that covers the entire device
 */
198
static struct extent_map *btree_get_extent(struct inode *inode,
199
		struct page *page, size_t pg_offset, u64 start, u64 len,
200
		int create)
201
{
202 203 204 205
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
	struct extent_map *em;
	int ret;

206
	read_lock(&em_tree->lock);
207
	em = lookup_extent_mapping(em_tree, start, len);
208 209 210
	if (em) {
		em->bdev =
			BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev;
211
		read_unlock(&em_tree->lock);
212
		goto out;
213
	}
214
	read_unlock(&em_tree->lock);
215

216
	em = alloc_extent_map();
217 218 219 220 221
	if (!em) {
		em = ERR_PTR(-ENOMEM);
		goto out;
	}
	em->start = 0;
222
	em->len = (u64)-1;
C
Chris Mason 已提交
223
	em->block_len = (u64)-1;
224
	em->block_start = 0;
225
	em->bdev = BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev;
226

227
	write_lock(&em_tree->lock);
J
Josef Bacik 已提交
228
	ret = add_extent_mapping(em_tree, em, 0);
229 230
	if (ret == -EEXIST) {
		free_extent_map(em);
231
		em = lookup_extent_mapping(em_tree, start, len);
232
		if (!em)
233
			em = ERR_PTR(-EIO);
234
	} else if (ret) {
235
		free_extent_map(em);
236
		em = ERR_PTR(ret);
237
	}
238
	write_unlock(&em_tree->lock);
239

240 241
out:
	return em;
242 243
}

244
u32 btrfs_csum_data(char *data, u32 seed, size_t len)
245
{
246
	return btrfs_crc32c(seed, data, len);
247 248 249 250
}

void btrfs_csum_final(u32 crc, char *result)
{
251
	put_unaligned_le32(~crc, result);
252 253
}

C
Chris Mason 已提交
254 255 256 257
/*
 * compute the csum for a btree block, and either verify it or write it
 * into the csum field of the block.
 */
258 259 260
static int csum_tree_block(struct btrfs_root *root, struct extent_buffer *buf,
			   int verify)
{
261
	u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
262
	char *result = NULL;
263 264 265 266 267 268 269 270
	unsigned long len;
	unsigned long cur_len;
	unsigned long offset = BTRFS_CSUM_SIZE;
	char *kaddr;
	unsigned long map_start;
	unsigned long map_len;
	int err;
	u32 crc = ~(u32)0;
271
	unsigned long inline_result;
272 273

	len = buf->len - offset;
C
Chris Mason 已提交
274
	while (len > 0) {
275
		err = map_private_extent_buffer(buf, offset, 32,
276
					&kaddr, &map_start, &map_len);
C
Chris Mason 已提交
277
		if (err)
278 279
			return 1;
		cur_len = min(len, map_len - (offset - map_start));
280
		crc = btrfs_csum_data(kaddr + offset - map_start,
281 282 283 284
				      crc, cur_len);
		len -= cur_len;
		offset += cur_len;
	}
285 286 287 288 289 290 291 292
	if (csum_size > sizeof(inline_result)) {
		result = kzalloc(csum_size * sizeof(char), GFP_NOFS);
		if (!result)
			return 1;
	} else {
		result = (char *)&inline_result;
	}

293 294 295
	btrfs_csum_final(crc, result);

	if (verify) {
296
		if (memcmp_extent_buffer(buf, result, 0, csum_size)) {
297 298
			u32 val;
			u32 found = 0;
299
			memcpy(&found, result, csum_size);
300

301
			read_extent_buffer(buf, &val, 0, csum_size);
302 303 304 305 306
			printk_ratelimited(KERN_INFO
				"BTRFS: %s checksum verify failed on %llu wanted %X found %X "
				"level %d\n",
				root->fs_info->sb->s_id, buf->start,
				val, found, btrfs_header_level(buf));
307 308
			if (result != (char *)&inline_result)
				kfree(result);
309 310 311
			return 1;
		}
	} else {
312
		write_extent_buffer(buf, result, 0, csum_size);
313
	}
314 315
	if (result != (char *)&inline_result)
		kfree(result);
316 317 318
	return 0;
}

C
Chris Mason 已提交
319 320 321 322 323 324
/*
 * we can't consider a given block up to date unless the transid of the
 * block matches the transid in the parent node's pointer.  This is how we
 * detect blocks that either didn't get written at all or got written
 * in the wrong place.
 */
325
static int verify_parent_transid(struct extent_io_tree *io_tree,
326 327
				 struct extent_buffer *eb, u64 parent_transid,
				 int atomic)
328
{
329
	struct extent_state *cached_state = NULL;
330
	int ret;
331 332
	bool need_lock = (current->journal_info ==
			  (void *)BTRFS_SEND_TRANS_STUB);
333 334 335 336

	if (!parent_transid || btrfs_header_generation(eb) == parent_transid)
		return 0;

337 338 339
	if (atomic)
		return -EAGAIN;

340 341 342 343 344
	if (need_lock) {
		btrfs_tree_read_lock(eb);
		btrfs_set_lock_blocking_rw(eb, BTRFS_READ_LOCK);
	}

345
	lock_extent_bits(io_tree, eb->start, eb->start + eb->len - 1,
346
			 0, &cached_state);
347
	if (extent_buffer_uptodate(eb) &&
348 349 350 351
	    btrfs_header_generation(eb) == parent_transid) {
		ret = 0;
		goto out;
	}
352
	printk_ratelimited("parent transid verify failed on %llu wanted %llu "
C
Chris Mason 已提交
353
		       "found %llu\n",
354
		       eb->start, parent_transid, btrfs_header_generation(eb));
355
	ret = 1;
356 357 358 359 360 361 362 363 364 365 366

	/*
	 * Things reading via commit roots that don't have normal protection,
	 * like send, can have a really old block in cache that may point at a
	 * block that has been free'd and re-allocated.  So don't clear uptodate
	 * if we find an eb that is under IO (dirty/writeback) because we could
	 * end up reading in the stale data and then writing it back out and
	 * making everybody very sad.
	 */
	if (!extent_buffer_under_io(eb))
		clear_extent_buffer_uptodate(eb);
C
Chris Mason 已提交
367
out:
368 369
	unlock_extent_cached(io_tree, eb->start, eb->start + eb->len - 1,
			     &cached_state, GFP_NOFS);
370 371
	if (need_lock)
		btrfs_tree_read_unlock_blocking(eb);
372 373 374
	return ret;
}

D
David Sterba 已提交
375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401
/*
 * Return 0 if the superblock checksum type matches the checksum value of that
 * algorithm. Pass the raw disk superblock data.
 */
static int btrfs_check_super_csum(char *raw_disk_sb)
{
	struct btrfs_super_block *disk_sb =
		(struct btrfs_super_block *)raw_disk_sb;
	u16 csum_type = btrfs_super_csum_type(disk_sb);
	int ret = 0;

	if (csum_type == BTRFS_CSUM_TYPE_CRC32) {
		u32 crc = ~(u32)0;
		const int csum_size = sizeof(crc);
		char result[csum_size];

		/*
		 * The super_block structure does not span the whole
		 * BTRFS_SUPER_INFO_SIZE range, we expect that the unused space
		 * is filled with zeros and is included in the checkum.
		 */
		crc = btrfs_csum_data(raw_disk_sb + BTRFS_CSUM_SIZE,
				crc, BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE);
		btrfs_csum_final(crc, result);

		if (memcmp(raw_disk_sb, result, csum_size))
			ret = 1;
402 403

		if (ret && btrfs_super_generation(disk_sb) < 10) {
404 405
			printk(KERN_WARNING
				"BTRFS: super block crcs don't match, older mkfs detected\n");
406 407
			ret = 0;
		}
D
David Sterba 已提交
408 409 410
	}

	if (csum_type >= ARRAY_SIZE(btrfs_csum_sizes)) {
411
		printk(KERN_ERR "BTRFS: unsupported checksum algorithm %u\n",
D
David Sterba 已提交
412 413 414 415 416 417 418
				csum_type);
		ret = 1;
	}

	return ret;
}

C
Chris Mason 已提交
419 420 421 422
/*
 * helper to read a given tree block, doing retries as required when
 * the checksums don't match and we have alternate mirrors to try.
 */
423 424
static int btree_read_extent_buffer_pages(struct btrfs_root *root,
					  struct extent_buffer *eb,
425
					  u64 start, u64 parent_transid)
426 427
{
	struct extent_io_tree *io_tree;
428
	int failed = 0;
429 430 431
	int ret;
	int num_copies = 0;
	int mirror_num = 0;
432
	int failed_mirror = 0;
433

434
	clear_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags);
435 436
	io_tree = &BTRFS_I(root->fs_info->btree_inode)->io_tree;
	while (1) {
437 438
		ret = read_extent_buffer_pages(io_tree, eb, start,
					       WAIT_COMPLETE,
439
					       btree_get_extent, mirror_num);
440 441
		if (!ret) {
			if (!verify_parent_transid(io_tree, eb,
442
						   parent_transid, 0))
443 444 445 446
				break;
			else
				ret = -EIO;
		}
C
Chris Mason 已提交
447

448 449 450 451 452 453
		/*
		 * This buffer's crc is fine, but its contents are corrupted, so
		 * there is no reason to read the other copies, they won't be
		 * any less wrong.
		 */
		if (test_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags))
454 455
			break;

456
		num_copies = btrfs_num_copies(root->fs_info,
457
					      eb->start, eb->len);
C
Chris Mason 已提交
458
		if (num_copies == 1)
459
			break;
C
Chris Mason 已提交
460

461 462 463 464 465
		if (!failed_mirror) {
			failed = 1;
			failed_mirror = eb->read_mirror;
		}

466
		mirror_num++;
467 468 469
		if (mirror_num == failed_mirror)
			mirror_num++;

C
Chris Mason 已提交
470
		if (mirror_num > num_copies)
471
			break;
472
	}
473

474
	if (failed && !ret && failed_mirror)
475 476 477
		repair_eb_io_failure(root, eb, failed_mirror);

	return ret;
478
}
479

C
Chris Mason 已提交
480
/*
C
Chris Mason 已提交
481 482
 * checksum a dirty tree block before IO.  This has extra checks to make sure
 * we only fill in the checksum field in the first page of a multi-page block
C
Chris Mason 已提交
483
 */
C
Chris Mason 已提交
484

485
static int csum_dirty_buffer(struct btrfs_root *root, struct page *page)
486
{
M
Miao Xie 已提交
487
	u64 start = page_offset(page);
488 489
	u64 found_start;
	struct extent_buffer *eb;
490

J
Josef Bacik 已提交
491 492 493
	eb = (struct extent_buffer *)page->private;
	if (page != eb->pages[0])
		return 0;
494
	found_start = btrfs_header_bytenr(eb);
495
	if (WARN_ON(found_start != start || !PageUptodate(page)))
J
Josef Bacik 已提交
496
		return 0;
497 498 499 500
	csum_tree_block(root, eb, 0);
	return 0;
}

Y
Yan Zheng 已提交
501 502 503 504 505 506 507
static int check_tree_block_fsid(struct btrfs_root *root,
				 struct extent_buffer *eb)
{
	struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
	u8 fsid[BTRFS_UUID_SIZE];
	int ret = 1;

508
	read_extent_buffer(eb, fsid, btrfs_header_fsid(), BTRFS_FSID_SIZE);
Y
Yan Zheng 已提交
509 510 511 512 513 514 515 516 517 518
	while (fs_devices) {
		if (!memcmp(fsid, fs_devices->fsid, BTRFS_FSID_SIZE)) {
			ret = 0;
			break;
		}
		fs_devices = fs_devices->seed;
	}
	return ret;
}

519
#define CORRUPT(reason, eb, root, slot)				\
520 521
	btrfs_crit(root->fs_info, "corrupt leaf, %s: block=%llu,"	\
		   "root=%llu, slot=%d", reason,			\
522
	       btrfs_header_bytenr(eb),	root->objectid, slot)
523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584

static noinline int check_leaf(struct btrfs_root *root,
			       struct extent_buffer *leaf)
{
	struct btrfs_key key;
	struct btrfs_key leaf_key;
	u32 nritems = btrfs_header_nritems(leaf);
	int slot;

	if (nritems == 0)
		return 0;

	/* Check the 0 item */
	if (btrfs_item_offset_nr(leaf, 0) + btrfs_item_size_nr(leaf, 0) !=
	    BTRFS_LEAF_DATA_SIZE(root)) {
		CORRUPT("invalid item offset size pair", leaf, root, 0);
		return -EIO;
	}

	/*
	 * Check to make sure each items keys are in the correct order and their
	 * offsets make sense.  We only have to loop through nritems-1 because
	 * we check the current slot against the next slot, which verifies the
	 * next slot's offset+size makes sense and that the current's slot
	 * offset is correct.
	 */
	for (slot = 0; slot < nritems - 1; slot++) {
		btrfs_item_key_to_cpu(leaf, &leaf_key, slot);
		btrfs_item_key_to_cpu(leaf, &key, slot + 1);

		/* Make sure the keys are in the right order */
		if (btrfs_comp_cpu_keys(&leaf_key, &key) >= 0) {
			CORRUPT("bad key order", leaf, root, slot);
			return -EIO;
		}

		/*
		 * Make sure the offset and ends are right, remember that the
		 * item data starts at the end of the leaf and grows towards the
		 * front.
		 */
		if (btrfs_item_offset_nr(leaf, slot) !=
			btrfs_item_end_nr(leaf, slot + 1)) {
			CORRUPT("slot offset bad", leaf, root, slot);
			return -EIO;
		}

		/*
		 * Check to make sure that we don't point outside of the leaf,
		 * just incase all the items are consistent to eachother, but
		 * all point outside of the leaf.
		 */
		if (btrfs_item_end_nr(leaf, slot) >
		    BTRFS_LEAF_DATA_SIZE(root)) {
			CORRUPT("slot end outside of leaf", leaf, root, slot);
			return -EIO;
		}
	}

	return 0;
}

585 586 587
static int btree_readpage_end_io_hook(struct btrfs_io_bio *io_bio,
				      u64 phy_offset, struct page *page,
				      u64 start, u64 end, int mirror)
588 589 590 591 592
{
	u64 found_start;
	int found_level;
	struct extent_buffer *eb;
	struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
593
	int ret = 0;
594
	int reads_done;
595 596 597

	if (!page->private)
		goto out;
C
Chris Mason 已提交
598

J
Josef Bacik 已提交
599
	eb = (struct extent_buffer *)page->private;
C
Chris Mason 已提交
600

601 602 603 604 605 606
	/* the pending IO might have been the only thing that kept this buffer
	 * in memory.  Make sure we have a ref for all this other checks
	 */
	extent_buffer_get(eb);

	reads_done = atomic_dec_and_test(&eb->io_pages);
607 608
	if (!reads_done)
		goto err;
609

610
	eb->read_mirror = mirror;
611 612 613 614 615
	if (test_bit(EXTENT_BUFFER_IOERR, &eb->bflags)) {
		ret = -EIO;
		goto err;
	}

616
	found_start = btrfs_header_bytenr(eb);
617
	if (found_start != eb->start) {
618
		printk_ratelimited(KERN_INFO "BTRFS: bad tree block start "
C
Chris Mason 已提交
619
			       "%llu %llu\n",
620
			       found_start, eb->start);
621
		ret = -EIO;
622 623
		goto err;
	}
Y
Yan Zheng 已提交
624
	if (check_tree_block_fsid(root, eb)) {
625
		printk_ratelimited(KERN_INFO "BTRFS: bad fsid on block %llu\n",
626
			       eb->start);
627 628 629
		ret = -EIO;
		goto err;
	}
630
	found_level = btrfs_header_level(eb);
631
	if (found_level >= BTRFS_MAX_LEVEL) {
632
		btrfs_info(root->fs_info, "bad tree block level %d",
633 634 635 636
			   (int)btrfs_header_level(eb));
		ret = -EIO;
		goto err;
	}
637

638 639
	btrfs_set_buffer_lockdep_class(btrfs_header_owner(eb),
				       eb, found_level);
640

641
	ret = csum_tree_block(root, eb, 1);
642
	if (ret) {
643
		ret = -EIO;
644 645 646 647 648 649 650 651 652 653 654 655
		goto err;
	}

	/*
	 * If this is a leaf block and it is corrupt, set the corrupt bit so
	 * that we don't try and read the other copies of this block, just
	 * return -EIO.
	 */
	if (found_level == 0 && check_leaf(root, eb)) {
		set_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags);
		ret = -EIO;
	}
656

657 658
	if (!ret)
		set_extent_buffer_uptodate(eb);
659
err:
660 661
	if (reads_done &&
	    test_and_clear_bit(EXTENT_BUFFER_READAHEAD, &eb->bflags))
A
Arne Jansen 已提交
662 663
		btree_readahead_hook(root, eb, eb->start, ret);

D
David Woodhouse 已提交
664 665 666 667 668 669 670
	if (ret) {
		/*
		 * our io error hook is going to dec the io pages
		 * again, we have to make sure it has something
		 * to decrement
		 */
		atomic_inc(&eb->io_pages);
671
		clear_extent_buffer_uptodate(eb);
D
David Woodhouse 已提交
672
	}
673
	free_extent_buffer(eb);
674
out:
675
	return ret;
676 677
}

678
static int btree_io_failed_hook(struct page *page, int failed_mirror)
A
Arne Jansen 已提交
679 680 681 682
{
	struct extent_buffer *eb;
	struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;

J
Josef Bacik 已提交
683
	eb = (struct extent_buffer *)page->private;
684
	set_bit(EXTENT_BUFFER_IOERR, &eb->bflags);
685
	eb->read_mirror = failed_mirror;
D
David Woodhouse 已提交
686
	atomic_dec(&eb->io_pages);
687
	if (test_and_clear_bit(EXTENT_BUFFER_READAHEAD, &eb->bflags))
A
Arne Jansen 已提交
688 689 690 691
		btree_readahead_hook(root, eb, eb->start, -EIO);
	return -EIO;	/* we fixed nothing */
}

692 693 694 695 696 697 698
static void end_workqueue_bio(struct bio *bio, int err)
{
	struct end_io_wq *end_io_wq = bio->bi_private;
	struct btrfs_fs_info *fs_info;

	fs_info = end_io_wq->info;
	end_io_wq->error = err;
699
	btrfs_init_work(&end_io_wq->work, end_workqueue_fn, NULL, NULL);
700

701
	if (bio->bi_rw & REQ_WRITE) {
D
David Woodhouse 已提交
702
		if (end_io_wq->metadata == BTRFS_WQ_ENDIO_METADATA)
703 704
			btrfs_queue_work(fs_info->endio_meta_write_workers,
					 &end_io_wq->work);
D
David Woodhouse 已提交
705
		else if (end_io_wq->metadata == BTRFS_WQ_ENDIO_FREE_SPACE)
706 707
			btrfs_queue_work(fs_info->endio_freespace_worker,
					 &end_io_wq->work);
D
David Woodhouse 已提交
708
		else if (end_io_wq->metadata == BTRFS_WQ_ENDIO_RAID56)
709 710
			btrfs_queue_work(fs_info->endio_raid56_workers,
					 &end_io_wq->work);
711
		else
712 713
			btrfs_queue_work(fs_info->endio_write_workers,
					 &end_io_wq->work);
714
	} else {
D
David Woodhouse 已提交
715
		if (end_io_wq->metadata == BTRFS_WQ_ENDIO_RAID56)
716 717
			btrfs_queue_work(fs_info->endio_raid56_workers,
					 &end_io_wq->work);
D
David Woodhouse 已提交
718
		else if (end_io_wq->metadata)
719 720
			btrfs_queue_work(fs_info->endio_meta_workers,
					 &end_io_wq->work);
721
		else
722 723
			btrfs_queue_work(fs_info->endio_workers,
					 &end_io_wq->work);
724
	}
725 726
}

J
Josef Bacik 已提交
727 728 729 730 731 732
/*
 * For the metadata arg you want
 *
 * 0 - if data
 * 1 - if normal metadta
 * 2 - if writing to the free space cache area
D
David Woodhouse 已提交
733
 * 3 - raid parity work
J
Josef Bacik 已提交
734
 */
735 736
int btrfs_bio_wq_end_io(struct btrfs_fs_info *info, struct bio *bio,
			int metadata)
737
{
738 739 740 741 742 743 744
	struct end_io_wq *end_io_wq;
	end_io_wq = kmalloc(sizeof(*end_io_wq), GFP_NOFS);
	if (!end_io_wq)
		return -ENOMEM;

	end_io_wq->private = bio->bi_private;
	end_io_wq->end_io = bio->bi_end_io;
745
	end_io_wq->info = info;
746 747
	end_io_wq->error = 0;
	end_io_wq->bio = bio;
748
	end_io_wq->metadata = metadata;
749 750 751

	bio->bi_private = end_io_wq;
	bio->bi_end_io = end_workqueue_bio;
752 753 754
	return 0;
}

755
unsigned long btrfs_async_submit_limit(struct btrfs_fs_info *info)
756
{
757
	unsigned long limit = min_t(unsigned long,
758
				    info->thread_pool_size,
759 760 761
				    info->fs_devices->open_devices);
	return 256 * limit;
}
762

C
Chris Mason 已提交
763 764 765
static void run_one_async_start(struct btrfs_work *work)
{
	struct async_submit_bio *async;
766
	int ret;
C
Chris Mason 已提交
767 768

	async = container_of(work, struct  async_submit_bio, work);
769 770 771 772 773
	ret = async->submit_bio_start(async->inode, async->rw, async->bio,
				      async->mirror_num, async->bio_flags,
				      async->bio_offset);
	if (ret)
		async->error = ret;
C
Chris Mason 已提交
774 775 776
}

static void run_one_async_done(struct btrfs_work *work)
777 778 779
{
	struct btrfs_fs_info *fs_info;
	struct async_submit_bio *async;
780
	int limit;
781 782 783

	async = container_of(work, struct  async_submit_bio, work);
	fs_info = BTRFS_I(async->inode)->root->fs_info;
784

785
	limit = btrfs_async_submit_limit(fs_info);
786 787
	limit = limit * 2 / 3;

788
	if (atomic_dec_return(&fs_info->nr_async_submits) < limit &&
789
	    waitqueue_active(&fs_info->async_submit_wait))
790 791
		wake_up(&fs_info->async_submit_wait);

792 793 794 795 796 797
	/* If an error occured we just want to clean up the bio and move on */
	if (async->error) {
		bio_endio(async->bio, async->error);
		return;
	}

C
Chris Mason 已提交
798
	async->submit_bio_done(async->inode, async->rw, async->bio,
799 800
			       async->mirror_num, async->bio_flags,
			       async->bio_offset);
C
Chris Mason 已提交
801 802 803 804 805 806 807
}

static void run_one_async_free(struct btrfs_work *work)
{
	struct async_submit_bio *async;

	async = container_of(work, struct  async_submit_bio, work);
808 809 810
	kfree(async);
}

811 812
int btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info, struct inode *inode,
			int rw, struct bio *bio, int mirror_num,
C
Chris Mason 已提交
813
			unsigned long bio_flags,
814
			u64 bio_offset,
C
Chris Mason 已提交
815 816
			extent_submit_bio_hook_t *submit_bio_start,
			extent_submit_bio_hook_t *submit_bio_done)
817 818 819 820 821 822 823 824 825 826 827
{
	struct async_submit_bio *async;

	async = kmalloc(sizeof(*async), GFP_NOFS);
	if (!async)
		return -ENOMEM;

	async->inode = inode;
	async->rw = rw;
	async->bio = bio;
	async->mirror_num = mirror_num;
C
Chris Mason 已提交
828 829 830
	async->submit_bio_start = submit_bio_start;
	async->submit_bio_done = submit_bio_done;

831 832
	btrfs_init_work(&async->work, run_one_async_start,
			run_one_async_done, run_one_async_free);
C
Chris Mason 已提交
833

C
Chris Mason 已提交
834
	async->bio_flags = bio_flags;
835
	async->bio_offset = bio_offset;
836

837 838
	async->error = 0;

839
	atomic_inc(&fs_info->nr_async_submits);
840

841
	if (rw & REQ_SYNC)
842
		btrfs_set_work_high_priority(&async->work);
843

844
	btrfs_queue_work(fs_info->workers, &async->work);
845

C
Chris Mason 已提交
846
	while (atomic_read(&fs_info->async_submit_draining) &&
847 848 849 850 851
	      atomic_read(&fs_info->nr_async_submits)) {
		wait_event(fs_info->async_submit_wait,
			   (atomic_read(&fs_info->nr_async_submits) == 0));
	}

852 853 854
	return 0;
}

855 856
static int btree_csum_one_bio(struct bio *bio)
{
857
	struct bio_vec *bvec;
858
	struct btrfs_root *root;
859
	int i, ret = 0;
860

861
	bio_for_each_segment_all(bvec, bio, i) {
862
		root = BTRFS_I(bvec->bv_page->mapping->host)->root;
863 864 865
		ret = csum_dirty_buffer(root, bvec->bv_page);
		if (ret)
			break;
866
	}
867

868
	return ret;
869 870
}

C
Chris Mason 已提交
871 872
static int __btree_submit_bio_start(struct inode *inode, int rw,
				    struct bio *bio, int mirror_num,
873 874
				    unsigned long bio_flags,
				    u64 bio_offset)
875
{
876 877
	/*
	 * when we're called for a write, we're already in the async
878
	 * submission context.  Just jump into btrfs_map_bio
879
	 */
880
	return btree_csum_one_bio(bio);
C
Chris Mason 已提交
881
}
882

C
Chris Mason 已提交
883
static int __btree_submit_bio_done(struct inode *inode, int rw, struct bio *bio,
884 885
				 int mirror_num, unsigned long bio_flags,
				 u64 bio_offset)
C
Chris Mason 已提交
886
{
887 888
	int ret;

889
	/*
C
Chris Mason 已提交
890 891
	 * when we're called for a write, we're already in the async
	 * submission context.  Just jump into btrfs_map_bio
892
	 */
893 894 895 896
	ret = btrfs_map_bio(BTRFS_I(inode)->root, rw, bio, mirror_num, 1);
	if (ret)
		bio_endio(bio, ret);
	return ret;
897 898
}

899 900 901 902 903 904 905 906 907 908 909
static int check_async_write(struct inode *inode, unsigned long bio_flags)
{
	if (bio_flags & EXTENT_BIO_TREE_LOG)
		return 0;
#ifdef CONFIG_X86
	if (cpu_has_xmm4_2)
		return 0;
#endif
	return 1;
}

910
static int btree_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
911 912
				 int mirror_num, unsigned long bio_flags,
				 u64 bio_offset)
913
{
914
	int async = check_async_write(inode, bio_flags);
915 916
	int ret;

917
	if (!(rw & REQ_WRITE)) {
C
Chris Mason 已提交
918 919 920 921
		/*
		 * called for a read, do the setup so that checksum validation
		 * can happen in the async kernel threads
		 */
922 923
		ret = btrfs_bio_wq_end_io(BTRFS_I(inode)->root->fs_info,
					  bio, 1);
924
		if (ret)
925 926 927
			goto out_w_error;
		ret = btrfs_map_bio(BTRFS_I(inode)->root, rw, bio,
				    mirror_num, 0);
928 929 930
	} else if (!async) {
		ret = btree_csum_one_bio(bio);
		if (ret)
931 932 933 934 935 936 937 938 939 940 941 942 943
			goto out_w_error;
		ret = btrfs_map_bio(BTRFS_I(inode)->root, rw, bio,
				    mirror_num, 0);
	} else {
		/*
		 * kthread helpers are used to submit writes so that
		 * checksumming can happen in parallel across all CPUs
		 */
		ret = btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,
					  inode, rw, bio, mirror_num, 0,
					  bio_offset,
					  __btree_submit_bio_start,
					  __btree_submit_bio_done);
944
	}
945

946 947 948 949 950
	if (ret) {
out_w_error:
		bio_endio(bio, ret);
	}
	return ret;
951 952
}

J
Jan Beulich 已提交
953
#ifdef CONFIG_MIGRATION
954
static int btree_migratepage(struct address_space *mapping,
955 956
			struct page *newpage, struct page *page,
			enum migrate_mode mode)
957 958 959 960 961 962 963 964 965 966 967 968 969 970
{
	/*
	 * we can't safely write a btree page from here,
	 * we haven't done the locking hook
	 */
	if (PageDirty(page))
		return -EAGAIN;
	/*
	 * Buffers may be managed in a filesystem specific way.
	 * We must have no buffers or drop them.
	 */
	if (page_has_private(page) &&
	    !try_to_release_page(page, GFP_KERNEL))
		return -EAGAIN;
971
	return migrate_page(mapping, newpage, page, mode);
972
}
J
Jan Beulich 已提交
973
#endif
974

975 976 977 978

static int btree_writepages(struct address_space *mapping,
			    struct writeback_control *wbc)
{
979 980 981
	struct btrfs_fs_info *fs_info;
	int ret;

982
	if (wbc->sync_mode == WB_SYNC_NONE) {
983 984 985 986

		if (wbc->for_kupdate)
			return 0;

987
		fs_info = BTRFS_I(mapping->host)->root->fs_info;
988
		/* this is a bit racy, but that's ok */
989 990 991
		ret = percpu_counter_compare(&fs_info->dirty_metadata_bytes,
					     BTRFS_DIRTY_METADATA_THRESH);
		if (ret < 0)
992 993
			return 0;
	}
994
	return btree_write_cache_pages(mapping, wbc);
995 996
}

997
static int btree_readpage(struct file *file, struct page *page)
998
{
999 1000
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
1001
	return extent_read_full_page(tree, page, btree_get_extent, 0);
1002
}
C
Chris Mason 已提交
1003

1004
static int btree_releasepage(struct page *page, gfp_t gfp_flags)
1005
{
1006
	if (PageWriteback(page) || PageDirty(page))
C
Chris Mason 已提交
1007
		return 0;
1008

1009
	return try_release_extent_buffer(page);
1010 1011
}

1012 1013
static void btree_invalidatepage(struct page *page, unsigned int offset,
				 unsigned int length)
1014
{
1015 1016
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
1017 1018
	extent_invalidatepage(tree, page, offset);
	btree_releasepage(page, GFP_NOFS);
1019
	if (PagePrivate(page)) {
1020 1021 1022
		btrfs_warn(BTRFS_I(page->mapping->host)->root->fs_info,
			   "page private not zero on page %llu",
			   (unsigned long long)page_offset(page));
1023 1024 1025 1026
		ClearPagePrivate(page);
		set_page_private(page, 0);
		page_cache_release(page);
	}
1027 1028
}

1029 1030
static int btree_set_page_dirty(struct page *page)
{
1031
#ifdef DEBUG
1032 1033 1034 1035 1036 1037 1038 1039
	struct extent_buffer *eb;

	BUG_ON(!PagePrivate(page));
	eb = (struct extent_buffer *)page->private;
	BUG_ON(!eb);
	BUG_ON(!test_bit(EXTENT_BUFFER_DIRTY, &eb->bflags));
	BUG_ON(!atomic_read(&eb->refs));
	btrfs_assert_tree_locked(eb);
1040
#endif
1041 1042 1043
	return __set_page_dirty_nobuffers(page);
}

1044
static const struct address_space_operations btree_aops = {
1045
	.readpage	= btree_readpage,
1046
	.writepages	= btree_writepages,
1047 1048
	.releasepage	= btree_releasepage,
	.invalidatepage = btree_invalidatepage,
1049
#ifdef CONFIG_MIGRATION
1050
	.migratepage	= btree_migratepage,
1051
#endif
1052
	.set_page_dirty = btree_set_page_dirty,
1053 1054
};

1055 1056
int readahead_tree_block(struct btrfs_root *root, u64 bytenr, u32 blocksize,
			 u64 parent_transid)
C
Chris Mason 已提交
1057
{
1058 1059
	struct extent_buffer *buf = NULL;
	struct inode *btree_inode = root->fs_info->btree_inode;
1060
	int ret = 0;
C
Chris Mason 已提交
1061

1062
	buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
1063
	if (!buf)
C
Chris Mason 已提交
1064
		return 0;
1065
	read_extent_buffer_pages(&BTRFS_I(btree_inode)->io_tree,
1066
				 buf, 0, WAIT_NONE, btree_get_extent, 0);
1067
	free_extent_buffer(buf);
1068
	return ret;
C
Chris Mason 已提交
1069 1070
}

1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094
int reada_tree_block_flagged(struct btrfs_root *root, u64 bytenr, u32 blocksize,
			 int mirror_num, struct extent_buffer **eb)
{
	struct extent_buffer *buf = NULL;
	struct inode *btree_inode = root->fs_info->btree_inode;
	struct extent_io_tree *io_tree = &BTRFS_I(btree_inode)->io_tree;
	int ret;

	buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
	if (!buf)
		return 0;

	set_bit(EXTENT_BUFFER_READAHEAD, &buf->bflags);

	ret = read_extent_buffer_pages(io_tree, buf, 0, WAIT_PAGE_LOCK,
				       btree_get_extent, mirror_num);
	if (ret) {
		free_extent_buffer(buf);
		return ret;
	}

	if (test_bit(EXTENT_BUFFER_CORRUPT, &buf->bflags)) {
		free_extent_buffer(buf);
		return -EIO;
1095
	} else if (extent_buffer_uptodate(buf)) {
1096 1097 1098 1099 1100 1101 1102
		*eb = buf;
	} else {
		free_extent_buffer(buf);
	}
	return 0;
}

1103 1104 1105
struct extent_buffer *btrfs_find_tree_block(struct btrfs_root *root,
					    u64 bytenr, u32 blocksize)
{
1106
	return find_extent_buffer(root->fs_info, bytenr);
1107 1108 1109 1110 1111
}

struct extent_buffer *btrfs_find_create_tree_block(struct btrfs_root *root,
						 u64 bytenr, u32 blocksize)
{
1112 1113 1114 1115 1116
#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
	if (unlikely(test_bit(BTRFS_ROOT_DUMMY_ROOT, &root->state)))
		return alloc_test_extent_buffer(root->fs_info, bytenr,
						blocksize);
#endif
1117
	return alloc_extent_buffer(root->fs_info, bytenr, blocksize);
1118 1119 1120
}


1121 1122
int btrfs_write_tree_block(struct extent_buffer *buf)
{
1123
	return filemap_fdatawrite_range(buf->pages[0]->mapping, buf->start,
1124
					buf->start + buf->len - 1);
1125 1126 1127 1128
}

int btrfs_wait_tree_block_writeback(struct extent_buffer *buf)
{
1129
	return filemap_fdatawait_range(buf->pages[0]->mapping,
1130
				       buf->start, buf->start + buf->len - 1);
1131 1132
}

1133
struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 bytenr,
1134
				      u32 blocksize, u64 parent_transid)
1135 1136 1137 1138 1139 1140 1141 1142
{
	struct extent_buffer *buf = NULL;
	int ret;

	buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
	if (!buf)
		return NULL;

1143
	ret = btree_read_extent_buffer_pages(root, buf, 0, parent_transid);
1144 1145 1146 1147
	if (ret) {
		free_extent_buffer(buf);
		return NULL;
	}
1148
	return buf;
1149

1150 1151
}

1152 1153
void clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
		      struct extent_buffer *buf)
1154
{
1155 1156
	struct btrfs_fs_info *fs_info = root->fs_info;

1157
	if (btrfs_header_generation(buf) ==
1158
	    fs_info->running_transaction->transid) {
1159
		btrfs_assert_tree_locked(buf);
1160

1161
		if (test_and_clear_bit(EXTENT_BUFFER_DIRTY, &buf->bflags)) {
1162 1163 1164
			__percpu_counter_add(&fs_info->dirty_metadata_bytes,
					     -buf->len,
					     fs_info->dirty_metadata_batch);
1165 1166 1167 1168
			/* ugh, clear_extent_buffer_dirty needs to lock the page */
			btrfs_set_lock_blocking(buf);
			clear_extent_buffer_dirty(buf);
		}
1169
	}
1170 1171
}

1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197
static struct btrfs_subvolume_writers *btrfs_alloc_subvolume_writers(void)
{
	struct btrfs_subvolume_writers *writers;
	int ret;

	writers = kmalloc(sizeof(*writers), GFP_NOFS);
	if (!writers)
		return ERR_PTR(-ENOMEM);

	ret = percpu_counter_init(&writers->counter, 0);
	if (ret < 0) {
		kfree(writers);
		return ERR_PTR(ret);
	}

	init_waitqueue_head(&writers->wait);
	return writers;
}

static void
btrfs_free_subvolume_writers(struct btrfs_subvolume_writers *writers)
{
	percpu_counter_destroy(&writers->counter);
	kfree(writers);
}

1198 1199 1200 1201
static void __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize,
			 u32 stripesize, struct btrfs_root *root,
			 struct btrfs_fs_info *fs_info,
			 u64 objectid)
1202
{
C
Chris Mason 已提交
1203
	root->node = NULL;
1204
	root->commit_root = NULL;
1205 1206 1207
	root->sectorsize = sectorsize;
	root->nodesize = nodesize;
	root->leafsize = leafsize;
1208
	root->stripesize = stripesize;
1209
	root->state = 0;
1210
	root->orphan_cleanup_state = 0;
1211

1212 1213
	root->objectid = objectid;
	root->last_trans = 0;
1214
	root->highest_objectid = 0;
1215
	root->nr_delalloc_inodes = 0;
1216
	root->nr_ordered_extents = 0;
1217
	root->name = NULL;
1218
	root->inode_tree = RB_ROOT;
1219
	INIT_RADIX_TREE(&root->delayed_nodes_tree, GFP_ATOMIC);
1220
	root->block_rsv = NULL;
1221
	root->orphan_block_rsv = NULL;
1222 1223

	INIT_LIST_HEAD(&root->dirty_list);
1224
	INIT_LIST_HEAD(&root->root_list);
1225 1226
	INIT_LIST_HEAD(&root->delalloc_inodes);
	INIT_LIST_HEAD(&root->delalloc_root);
1227 1228
	INIT_LIST_HEAD(&root->ordered_extents);
	INIT_LIST_HEAD(&root->ordered_root);
1229 1230
	INIT_LIST_HEAD(&root->logged_list[0]);
	INIT_LIST_HEAD(&root->logged_list[1]);
1231
	spin_lock_init(&root->orphan_lock);
1232
	spin_lock_init(&root->inode_lock);
1233
	spin_lock_init(&root->delalloc_lock);
1234
	spin_lock_init(&root->ordered_extent_lock);
1235
	spin_lock_init(&root->accounting_lock);
1236 1237
	spin_lock_init(&root->log_extents_lock[0]);
	spin_lock_init(&root->log_extents_lock[1]);
1238
	mutex_init(&root->objectid_mutex);
1239
	mutex_init(&root->log_mutex);
1240
	mutex_init(&root->ordered_extent_mutex);
1241
	mutex_init(&root->delalloc_mutex);
Y
Yan Zheng 已提交
1242 1243 1244
	init_waitqueue_head(&root->log_writer_wait);
	init_waitqueue_head(&root->log_commit_wait[0]);
	init_waitqueue_head(&root->log_commit_wait[1]);
1245 1246
	INIT_LIST_HEAD(&root->log_ctxs[0]);
	INIT_LIST_HEAD(&root->log_ctxs[1]);
Y
Yan Zheng 已提交
1247 1248 1249
	atomic_set(&root->log_commit[0], 0);
	atomic_set(&root->log_commit[1], 0);
	atomic_set(&root->log_writers, 0);
M
Miao Xie 已提交
1250
	atomic_set(&root->log_batch, 0);
1251
	atomic_set(&root->orphan_inodes, 0);
1252
	atomic_set(&root->refs, 1);
1253
	atomic_set(&root->will_be_snapshoted, 0);
Y
Yan Zheng 已提交
1254
	root->log_transid = 0;
1255
	root->log_transid_committed = -1;
1256
	root->last_log_commit = 0;
1257 1258 1259
	if (fs_info)
		extent_io_tree_init(&root->dirty_log_pages,
				     fs_info->btree_inode->i_mapping);
C
Chris Mason 已提交
1260

1261 1262
	memset(&root->root_key, 0, sizeof(root->root_key));
	memset(&root->root_item, 0, sizeof(root->root_item));
1263
	memset(&root->defrag_progress, 0, sizeof(root->defrag_progress));
1264
	memset(&root->root_kobj, 0, sizeof(root->root_kobj));
1265 1266 1267 1268
	if (fs_info)
		root->defrag_trans_start = fs_info->generation;
	else
		root->defrag_trans_start = 0;
1269
	init_completion(&root->kobj_unregister);
1270
	root->root_key.objectid = objectid;
1271
	root->anon_dev = 0;
1272

1273
	spin_lock_init(&root->root_item_lock);
1274 1275
}

1276
static struct btrfs_root *btrfs_alloc_root(struct btrfs_fs_info *fs_info)
A
Al Viro 已提交
1277 1278 1279 1280 1281 1282 1283
{
	struct btrfs_root *root = kzalloc(sizeof(*root), GFP_NOFS);
	if (root)
		root->fs_info = fs_info;
	return root;
}

1284 1285 1286 1287 1288 1289 1290 1291 1292 1293
#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
/* Should only be used by the testing infrastructure */
struct btrfs_root *btrfs_alloc_dummy_root(void)
{
	struct btrfs_root *root;

	root = btrfs_alloc_root(NULL);
	if (!root)
		return ERR_PTR(-ENOMEM);
	__setup_root(4096, 4096, 4096, 4096, root, NULL, 1);
1294
	set_bit(BTRFS_ROOT_DUMMY_ROOT, &root->state);
1295
	root->alloc_bytenr = 0;
1296 1297 1298 1299 1300

	return root;
}
#endif

1301 1302 1303 1304 1305 1306 1307 1308 1309
struct btrfs_root *btrfs_create_tree(struct btrfs_trans_handle *trans,
				     struct btrfs_fs_info *fs_info,
				     u64 objectid)
{
	struct extent_buffer *leaf;
	struct btrfs_root *tree_root = fs_info->tree_root;
	struct btrfs_root *root;
	struct btrfs_key key;
	int ret = 0;
1310
	uuid_le uuid;
1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326

	root = btrfs_alloc_root(fs_info);
	if (!root)
		return ERR_PTR(-ENOMEM);

	__setup_root(tree_root->nodesize, tree_root->leafsize,
		     tree_root->sectorsize, tree_root->stripesize,
		     root, fs_info, objectid);
	root->root_key.objectid = objectid;
	root->root_key.type = BTRFS_ROOT_ITEM_KEY;
	root->root_key.offset = 0;

	leaf = btrfs_alloc_free_block(trans, root, root->leafsize,
				      0, objectid, NULL, 0, 0, 0);
	if (IS_ERR(leaf)) {
		ret = PTR_ERR(leaf);
1327
		leaf = NULL;
1328 1329 1330 1331 1332 1333 1334 1335 1336 1337
		goto fail;
	}

	memset_extent_buffer(leaf, 0, 0, sizeof(struct btrfs_header));
	btrfs_set_header_bytenr(leaf, leaf->start);
	btrfs_set_header_generation(leaf, trans->transid);
	btrfs_set_header_backref_rev(leaf, BTRFS_MIXED_BACKREF_REV);
	btrfs_set_header_owner(leaf, objectid);
	root->node = leaf;

1338
	write_extent_buffer(leaf, fs_info->fsid, btrfs_header_fsid(),
1339 1340
			    BTRFS_FSID_SIZE);
	write_extent_buffer(leaf, fs_info->chunk_tree_uuid,
1341
			    btrfs_header_chunk_tree_uuid(leaf),
1342 1343 1344 1345
			    BTRFS_UUID_SIZE);
	btrfs_mark_buffer_dirty(leaf);

	root->commit_root = btrfs_root_node(root);
1346
	set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
1347 1348 1349 1350 1351 1352 1353 1354 1355 1356

	root->root_item.flags = 0;
	root->root_item.byte_limit = 0;
	btrfs_set_root_bytenr(&root->root_item, leaf->start);
	btrfs_set_root_generation(&root->root_item, trans->transid);
	btrfs_set_root_level(&root->root_item, 0);
	btrfs_set_root_refs(&root->root_item, 1);
	btrfs_set_root_used(&root->root_item, leaf->len);
	btrfs_set_root_last_snapshot(&root->root_item, 0);
	btrfs_set_root_dirid(&root->root_item, 0);
1357 1358
	uuid_le_gen(&uuid);
	memcpy(root->root_item.uuid, uuid.b, BTRFS_UUID_SIZE);
1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369
	root->root_item.drop_level = 0;

	key.objectid = objectid;
	key.type = BTRFS_ROOT_ITEM_KEY;
	key.offset = 0;
	ret = btrfs_insert_root(trans, tree_root, &key, &root->root_item);
	if (ret)
		goto fail;

	btrfs_tree_unlock(leaf);

1370 1371
	return root;

1372
fail:
1373 1374
	if (leaf) {
		btrfs_tree_unlock(leaf);
1375
		free_extent_buffer(root->commit_root);
1376 1377 1378
		free_extent_buffer(leaf);
	}
	kfree(root);
1379

1380
	return ERR_PTR(ret);
1381 1382
}

Y
Yan Zheng 已提交
1383 1384
static struct btrfs_root *alloc_log_tree(struct btrfs_trans_handle *trans,
					 struct btrfs_fs_info *fs_info)
1385 1386 1387
{
	struct btrfs_root *root;
	struct btrfs_root *tree_root = fs_info->tree_root;
Y
Yan Zheng 已提交
1388
	struct extent_buffer *leaf;
1389

A
Al Viro 已提交
1390
	root = btrfs_alloc_root(fs_info);
1391
	if (!root)
Y
Yan Zheng 已提交
1392
		return ERR_PTR(-ENOMEM);
1393 1394 1395 1396 1397 1398 1399 1400

	__setup_root(tree_root->nodesize, tree_root->leafsize,
		     tree_root->sectorsize, tree_root->stripesize,
		     root, fs_info, BTRFS_TREE_LOG_OBJECTID);

	root->root_key.objectid = BTRFS_TREE_LOG_OBJECTID;
	root->root_key.type = BTRFS_ROOT_ITEM_KEY;
	root->root_key.offset = BTRFS_TREE_LOG_OBJECTID;
1401

Y
Yan Zheng 已提交
1402
	/*
1403 1404
	 * DON'T set REF_COWS for log trees
	 *
Y
Yan Zheng 已提交
1405 1406 1407 1408 1409
	 * log trees do not get reference counted because they go away
	 * before a real commit is actually done.  They do store pointers
	 * to file data extents, and those reference counts still get
	 * updated (along with back refs to the log tree).
	 */
1410

1411
	leaf = btrfs_alloc_free_block(trans, root, root->leafsize, 0,
A
Arne Jansen 已提交
1412
				      BTRFS_TREE_LOG_OBJECTID, NULL,
1413
				      0, 0, 0);
Y
Yan Zheng 已提交
1414 1415 1416 1417
	if (IS_ERR(leaf)) {
		kfree(root);
		return ERR_CAST(leaf);
	}
1418

1419 1420 1421 1422 1423
	memset_extent_buffer(leaf, 0, 0, sizeof(struct btrfs_header));
	btrfs_set_header_bytenr(leaf, leaf->start);
	btrfs_set_header_generation(leaf, trans->transid);
	btrfs_set_header_backref_rev(leaf, BTRFS_MIXED_BACKREF_REV);
	btrfs_set_header_owner(leaf, BTRFS_TREE_LOG_OBJECTID);
Y
Yan Zheng 已提交
1424
	root->node = leaf;
1425 1426

	write_extent_buffer(root->node, root->fs_info->fsid,
1427
			    btrfs_header_fsid(), BTRFS_FSID_SIZE);
1428 1429
	btrfs_mark_buffer_dirty(root->node);
	btrfs_tree_unlock(root->node);
Y
Yan Zheng 已提交
1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459
	return root;
}

int btrfs_init_log_root_tree(struct btrfs_trans_handle *trans,
			     struct btrfs_fs_info *fs_info)
{
	struct btrfs_root *log_root;

	log_root = alloc_log_tree(trans, fs_info);
	if (IS_ERR(log_root))
		return PTR_ERR(log_root);
	WARN_ON(fs_info->log_root_tree);
	fs_info->log_root_tree = log_root;
	return 0;
}

int btrfs_add_log_tree(struct btrfs_trans_handle *trans,
		       struct btrfs_root *root)
{
	struct btrfs_root *log_root;
	struct btrfs_inode_item *inode_item;

	log_root = alloc_log_tree(trans, root->fs_info);
	if (IS_ERR(log_root))
		return PTR_ERR(log_root);

	log_root->last_trans = trans->transid;
	log_root->root_key.offset = root->root_key.objectid;

	inode_item = &log_root->root_item.inode;
1460 1461 1462 1463 1464
	btrfs_set_stack_inode_generation(inode_item, 1);
	btrfs_set_stack_inode_size(inode_item, 3);
	btrfs_set_stack_inode_nlink(inode_item, 1);
	btrfs_set_stack_inode_nbytes(inode_item, root->leafsize);
	btrfs_set_stack_inode_mode(inode_item, S_IFDIR | 0755);
Y
Yan Zheng 已提交
1465

1466
	btrfs_set_root_node(&log_root->root_item, log_root->node);
Y
Yan Zheng 已提交
1467 1468 1469 1470

	WARN_ON(root->log_root);
	root->log_root = log_root;
	root->log_transid = 0;
1471
	root->log_transid_committed = -1;
1472
	root->last_log_commit = 0;
1473 1474 1475
	return 0;
}

1476 1477
static struct btrfs_root *btrfs_read_tree_root(struct btrfs_root *tree_root,
					       struct btrfs_key *key)
1478 1479 1480
{
	struct btrfs_root *root;
	struct btrfs_fs_info *fs_info = tree_root->fs_info;
1481
	struct btrfs_path *path;
1482
	u64 generation;
1483
	u32 blocksize;
1484
	int ret;
1485

1486 1487
	path = btrfs_alloc_path();
	if (!path)
1488
		return ERR_PTR(-ENOMEM);
1489 1490 1491 1492 1493

	root = btrfs_alloc_root(fs_info);
	if (!root) {
		ret = -ENOMEM;
		goto alloc_fail;
1494 1495
	}

1496
	__setup_root(tree_root->nodesize, tree_root->leafsize,
1497
		     tree_root->sectorsize, tree_root->stripesize,
1498
		     root, fs_info, key->objectid);
1499

1500 1501
	ret = btrfs_find_root(tree_root, key, path,
			      &root->root_item, &root->root_key);
1502
	if (ret) {
1503 1504
		if (ret > 0)
			ret = -ENOENT;
1505
		goto find_fail;
1506
	}
1507

1508
	generation = btrfs_root_generation(&root->root_item);
1509 1510
	blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
	root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
1511
				     blocksize, generation);
1512 1513 1514 1515 1516 1517
	if (!root->node) {
		ret = -ENOMEM;
		goto find_fail;
	} else if (!btrfs_buffer_uptodate(root->node, generation, 0)) {
		ret = -EIO;
		goto read_fail;
1518
	}
1519
	root->commit_root = btrfs_root_node(root);
1520
out:
1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542
	btrfs_free_path(path);
	return root;

read_fail:
	free_extent_buffer(root->node);
find_fail:
	kfree(root);
alloc_fail:
	root = ERR_PTR(ret);
	goto out;
}

struct btrfs_root *btrfs_read_fs_root(struct btrfs_root *tree_root,
				      struct btrfs_key *location)
{
	struct btrfs_root *root;

	root = btrfs_read_tree_root(tree_root, location);
	if (IS_ERR(root))
		return root;

	if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) {
1543
		set_bit(BTRFS_ROOT_REF_COWS, &root->state);
1544 1545
		btrfs_check_and_init_root_item(&root->root_item);
	}
1546

1547 1548 1549
	return root;
}

1550 1551 1552
int btrfs_init_fs_root(struct btrfs_root *root)
{
	int ret;
1553
	struct btrfs_subvolume_writers *writers;
1554 1555 1556 1557 1558 1559 1560 1561 1562

	root->free_ino_ctl = kzalloc(sizeof(*root->free_ino_ctl), GFP_NOFS);
	root->free_ino_pinned = kzalloc(sizeof(*root->free_ino_pinned),
					GFP_NOFS);
	if (!root->free_ino_pinned || !root->free_ino_ctl) {
		ret = -ENOMEM;
		goto fail;
	}

1563 1564 1565 1566 1567 1568 1569
	writers = btrfs_alloc_subvolume_writers();
	if (IS_ERR(writers)) {
		ret = PTR_ERR(writers);
		goto fail;
	}
	root->subv_writers = writers;

1570 1571 1572 1573 1574 1575
	btrfs_init_free_ino_ctl(root);
	spin_lock_init(&root->cache_lock);
	init_waitqueue_head(&root->cache_wait);

	ret = get_anon_bdev(&root->anon_dev);
	if (ret)
1576
		goto free_writers;
1577
	return 0;
1578 1579 1580

free_writers:
	btrfs_free_subvolume_writers(root->subv_writers);
1581 1582 1583 1584 1585 1586
fail:
	kfree(root->free_ino_ctl);
	kfree(root->free_ino_pinned);
	return ret;
}

1587 1588
static struct btrfs_root *btrfs_lookup_fs_root(struct btrfs_fs_info *fs_info,
					       u64 root_id)
1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612
{
	struct btrfs_root *root;

	spin_lock(&fs_info->fs_roots_radix_lock);
	root = radix_tree_lookup(&fs_info->fs_roots_radix,
				 (unsigned long)root_id);
	spin_unlock(&fs_info->fs_roots_radix_lock);
	return root;
}

int btrfs_insert_fs_root(struct btrfs_fs_info *fs_info,
			 struct btrfs_root *root)
{
	int ret;

	ret = radix_tree_preload(GFP_NOFS & ~__GFP_HIGHMEM);
	if (ret)
		return ret;

	spin_lock(&fs_info->fs_roots_radix_lock);
	ret = radix_tree_insert(&fs_info->fs_roots_radix,
				(unsigned long)root->root_key.objectid,
				root);
	if (ret == 0)
1613
		set_bit(BTRFS_ROOT_IN_RADIX, &root->state);
1614 1615 1616 1617 1618 1619
	spin_unlock(&fs_info->fs_roots_radix_lock);
	radix_tree_preload_end();

	return ret;
}

1620 1621 1622
struct btrfs_root *btrfs_get_fs_root(struct btrfs_fs_info *fs_info,
				     struct btrfs_key *location,
				     bool check_ref)
1623 1624 1625 1626
{
	struct btrfs_root *root;
	int ret;

1627 1628 1629 1630
	if (location->objectid == BTRFS_ROOT_TREE_OBJECTID)
		return fs_info->tree_root;
	if (location->objectid == BTRFS_EXTENT_TREE_OBJECTID)
		return fs_info->extent_root;
1631 1632 1633 1634
	if (location->objectid == BTRFS_CHUNK_TREE_OBJECTID)
		return fs_info->chunk_root;
	if (location->objectid == BTRFS_DEV_TREE_OBJECTID)
		return fs_info->dev_root;
1635 1636
	if (location->objectid == BTRFS_CSUM_TREE_OBJECTID)
		return fs_info->csum_root;
1637 1638 1639
	if (location->objectid == BTRFS_QUOTA_TREE_OBJECTID)
		return fs_info->quota_root ? fs_info->quota_root :
					     ERR_PTR(-ENOENT);
1640 1641 1642
	if (location->objectid == BTRFS_UUID_TREE_OBJECTID)
		return fs_info->uuid_root ? fs_info->uuid_root :
					    ERR_PTR(-ENOENT);
1643
again:
1644
	root = btrfs_lookup_fs_root(fs_info, location->objectid);
1645
	if (root) {
1646
		if (check_ref && btrfs_root_refs(&root->root_item) == 0)
1647
			return ERR_PTR(-ENOENT);
1648
		return root;
1649
	}
1650

1651
	root = btrfs_read_fs_root(fs_info->tree_root, location);
1652 1653
	if (IS_ERR(root))
		return root;
1654

1655
	if (check_ref && btrfs_root_refs(&root->root_item) == 0) {
1656
		ret = -ENOENT;
1657
		goto fail;
1658
	}
1659

1660
	ret = btrfs_init_fs_root(root);
1661 1662
	if (ret)
		goto fail;
1663

1664 1665
	ret = btrfs_find_item(fs_info->tree_root, NULL, BTRFS_ORPHAN_OBJECTID,
			location->objectid, BTRFS_ORPHAN_ITEM_KEY, NULL);
1666 1667 1668
	if (ret < 0)
		goto fail;
	if (ret == 0)
1669
		set_bit(BTRFS_ROOT_ORPHAN_ITEM_INSERTED, &root->state);
1670

1671
	ret = btrfs_insert_fs_root(fs_info, root);
1672
	if (ret) {
1673 1674 1675 1676 1677
		if (ret == -EEXIST) {
			free_fs_root(root);
			goto again;
		}
		goto fail;
1678
	}
1679
	return root;
1680 1681 1682
fail:
	free_fs_root(root);
	return ERR_PTR(ret);
1683 1684
}

C
Chris Mason 已提交
1685 1686 1687 1688 1689 1690
static int btrfs_congested_fn(void *congested_data, int bdi_bits)
{
	struct btrfs_fs_info *info = (struct btrfs_fs_info *)congested_data;
	int ret = 0;
	struct btrfs_device *device;
	struct backing_dev_info *bdi;
C
Chris Mason 已提交
1691

1692 1693
	rcu_read_lock();
	list_for_each_entry_rcu(device, &info->fs_devices->devices, dev_list) {
1694 1695
		if (!device->bdev)
			continue;
C
Chris Mason 已提交
1696 1697 1698 1699 1700 1701
		bdi = blk_get_backing_dev_info(device->bdev);
		if (bdi && bdi_congested(bdi, bdi_bits)) {
			ret = 1;
			break;
		}
	}
1702
	rcu_read_unlock();
C
Chris Mason 已提交
1703 1704 1705
	return ret;
}

1706 1707 1708 1709
/*
 * If this fails, caller must call bdi_destroy() to get rid of the
 * bdi again.
 */
C
Chris Mason 已提交
1710 1711
static int setup_bdi(struct btrfs_fs_info *info, struct backing_dev_info *bdi)
{
1712 1713 1714
	int err;

	bdi->capabilities = BDI_CAP_MAP_COPY;
1715
	err = bdi_setup_and_register(bdi, "btrfs", BDI_CAP_MAP_COPY);
1716 1717 1718
	if (err)
		return err;

1719
	bdi->ra_pages	= default_backing_dev_info.ra_pages;
C
Chris Mason 已提交
1720 1721 1722 1723 1724
	bdi->congested_fn	= btrfs_congested_fn;
	bdi->congested_data	= info;
	return 0;
}

1725 1726 1727 1728 1729
/*
 * called by the kthread helper functions to finally call the bio end_io
 * functions.  This is where read checksum verification actually happens
 */
static void end_workqueue_fn(struct btrfs_work *work)
1730 1731
{
	struct bio *bio;
1732
	struct end_io_wq *end_io_wq;
1733 1734
	int error;

1735 1736
	end_io_wq = container_of(work, struct end_io_wq, work);
	bio = end_io_wq->bio;
1737

1738 1739 1740 1741
	error = end_io_wq->error;
	bio->bi_private = end_io_wq->private;
	bio->bi_end_io = end_io_wq->end_io;
	kfree(end_io_wq);
1742
	bio_endio_nodec(bio, error);
1743 1744
}

1745 1746 1747
static int cleaner_kthread(void *arg)
{
	struct btrfs_root *root = arg;
1748
	int again;
1749 1750

	do {
1751
		again = 0;
1752

1753
		/* Make the cleaner go to sleep early. */
1754
		if (btrfs_need_cleaner_sleep(root))
1755 1756 1757 1758 1759
			goto sleep;

		if (!mutex_trylock(&root->fs_info->cleaner_mutex))
			goto sleep;

1760 1761 1762 1763
		/*
		 * Avoid the problem that we change the status of the fs
		 * during the above check and trylock.
		 */
1764
		if (btrfs_need_cleaner_sleep(root)) {
1765 1766
			mutex_unlock(&root->fs_info->cleaner_mutex);
			goto sleep;
1767
		}
1768

1769 1770 1771 1772 1773
		btrfs_run_delayed_iputs(root);
		again = btrfs_clean_one_deleted_snapshot(root);
		mutex_unlock(&root->fs_info->cleaner_mutex);

		/*
1774 1775
		 * The defragger has dealt with the R/O remount and umount,
		 * needn't do anything special here.
1776 1777 1778
		 */
		btrfs_run_defrag_inodes(root->fs_info);
sleep:
D
David Sterba 已提交
1779
		if (!try_to_freeze() && !again) {
1780
			set_current_state(TASK_INTERRUPTIBLE);
1781 1782
			if (!kthread_should_stop())
				schedule();
1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793
			__set_current_state(TASK_RUNNING);
		}
	} while (!kthread_should_stop());
	return 0;
}

static int transaction_kthread(void *arg)
{
	struct btrfs_root *root = arg;
	struct btrfs_trans_handle *trans;
	struct btrfs_transaction *cur;
1794
	u64 transid;
1795 1796
	unsigned long now;
	unsigned long delay;
1797
	bool cannot_commit;
1798 1799

	do {
1800
		cannot_commit = false;
1801
		delay = HZ * root->fs_info->commit_interval;
1802 1803
		mutex_lock(&root->fs_info->transaction_kthread_mutex);

J
Josef Bacik 已提交
1804
		spin_lock(&root->fs_info->trans_lock);
1805 1806
		cur = root->fs_info->running_transaction;
		if (!cur) {
J
Josef Bacik 已提交
1807
			spin_unlock(&root->fs_info->trans_lock);
1808 1809
			goto sleep;
		}
Y
Yan Zheng 已提交
1810

1811
		now = get_seconds();
1812
		if (cur->state < TRANS_STATE_BLOCKED &&
1813 1814
		    (now < cur->start_time ||
		     now - cur->start_time < root->fs_info->commit_interval)) {
J
Josef Bacik 已提交
1815
			spin_unlock(&root->fs_info->trans_lock);
1816 1817 1818
			delay = HZ * 5;
			goto sleep;
		}
1819
		transid = cur->transid;
J
Josef Bacik 已提交
1820
		spin_unlock(&root->fs_info->trans_lock);
1821

1822
		/* If the file system is aborted, this will always fail. */
1823
		trans = btrfs_attach_transaction(root);
1824
		if (IS_ERR(trans)) {
1825 1826
			if (PTR_ERR(trans) != -ENOENT)
				cannot_commit = true;
1827
			goto sleep;
1828
		}
1829
		if (transid == trans->transid) {
1830
			btrfs_commit_transaction(trans, root);
1831 1832 1833
		} else {
			btrfs_end_transaction(trans, root);
		}
1834 1835 1836 1837
sleep:
		wake_up_process(root->fs_info->cleaner_kthread);
		mutex_unlock(&root->fs_info->transaction_kthread_mutex);

J
Josef Bacik 已提交
1838 1839 1840
		if (unlikely(test_bit(BTRFS_FS_STATE_ERROR,
				      &root->fs_info->fs_state)))
			btrfs_cleanup_transaction(root);
1841
		if (!try_to_freeze()) {
1842
			set_current_state(TASK_INTERRUPTIBLE);
1843
			if (!kthread_should_stop() &&
1844 1845
			    (!btrfs_transaction_blocked(root->fs_info) ||
			     cannot_commit))
1846
				schedule_timeout(delay);
1847 1848 1849 1850 1851 1852
			__set_current_state(TASK_RUNNING);
		}
	} while (!kthread_should_stop());
	return 0;
}

C
Chris Mason 已提交
1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958
/*
 * this will find the highest generation in the array of
 * root backups.  The index of the highest array is returned,
 * or -1 if we can't find anything.
 *
 * We check to make sure the array is valid by comparing the
 * generation of the latest  root in the array with the generation
 * in the super block.  If they don't match we pitch it.
 */
static int find_newest_super_backup(struct btrfs_fs_info *info, u64 newest_gen)
{
	u64 cur;
	int newest_index = -1;
	struct btrfs_root_backup *root_backup;
	int i;

	for (i = 0; i < BTRFS_NUM_BACKUP_ROOTS; i++) {
		root_backup = info->super_copy->super_roots + i;
		cur = btrfs_backup_tree_root_gen(root_backup);
		if (cur == newest_gen)
			newest_index = i;
	}

	/* check to see if we actually wrapped around */
	if (newest_index == BTRFS_NUM_BACKUP_ROOTS - 1) {
		root_backup = info->super_copy->super_roots;
		cur = btrfs_backup_tree_root_gen(root_backup);
		if (cur == newest_gen)
			newest_index = 0;
	}
	return newest_index;
}


/*
 * find the oldest backup so we know where to store new entries
 * in the backup array.  This will set the backup_root_index
 * field in the fs_info struct
 */
static void find_oldest_super_backup(struct btrfs_fs_info *info,
				     u64 newest_gen)
{
	int newest_index = -1;

	newest_index = find_newest_super_backup(info, newest_gen);
	/* if there was garbage in there, just move along */
	if (newest_index == -1) {
		info->backup_root_index = 0;
	} else {
		info->backup_root_index = (newest_index + 1) % BTRFS_NUM_BACKUP_ROOTS;
	}
}

/*
 * copy all the root pointers into the super backup array.
 * this will bump the backup pointer by one when it is
 * done
 */
static void backup_super_roots(struct btrfs_fs_info *info)
{
	int next_backup;
	struct btrfs_root_backup *root_backup;
	int last_backup;

	next_backup = info->backup_root_index;
	last_backup = (next_backup + BTRFS_NUM_BACKUP_ROOTS - 1) %
		BTRFS_NUM_BACKUP_ROOTS;

	/*
	 * just overwrite the last backup if we're at the same generation
	 * this happens only at umount
	 */
	root_backup = info->super_for_commit->super_roots + last_backup;
	if (btrfs_backup_tree_root_gen(root_backup) ==
	    btrfs_header_generation(info->tree_root->node))
		next_backup = last_backup;

	root_backup = info->super_for_commit->super_roots + next_backup;

	/*
	 * make sure all of our padding and empty slots get zero filled
	 * regardless of which ones we use today
	 */
	memset(root_backup, 0, sizeof(*root_backup));

	info->backup_root_index = (next_backup + 1) % BTRFS_NUM_BACKUP_ROOTS;

	btrfs_set_backup_tree_root(root_backup, info->tree_root->node->start);
	btrfs_set_backup_tree_root_gen(root_backup,
			       btrfs_header_generation(info->tree_root->node));

	btrfs_set_backup_tree_root_level(root_backup,
			       btrfs_header_level(info->tree_root->node));

	btrfs_set_backup_chunk_root(root_backup, info->chunk_root->node->start);
	btrfs_set_backup_chunk_root_gen(root_backup,
			       btrfs_header_generation(info->chunk_root->node));
	btrfs_set_backup_chunk_root_level(root_backup,
			       btrfs_header_level(info->chunk_root->node));

	btrfs_set_backup_extent_root(root_backup, info->extent_root->node->start);
	btrfs_set_backup_extent_root_gen(root_backup,
			       btrfs_header_generation(info->extent_root->node));
	btrfs_set_backup_extent_root_level(root_backup,
			       btrfs_header_level(info->extent_root->node));

1959 1960 1961 1962 1963 1964 1965 1966
	/*
	 * we might commit during log recovery, which happens before we set
	 * the fs_root.  Make sure it is valid before we fill it in.
	 */
	if (info->fs_root && info->fs_root->node) {
		btrfs_set_backup_fs_root(root_backup,
					 info->fs_root->node->start);
		btrfs_set_backup_fs_root_gen(root_backup,
C
Chris Mason 已提交
1967
			       btrfs_header_generation(info->fs_root->node));
1968
		btrfs_set_backup_fs_root_level(root_backup,
C
Chris Mason 已提交
1969
			       btrfs_header_level(info->fs_root->node));
1970
	}
C
Chris Mason 已提交
1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051

	btrfs_set_backup_dev_root(root_backup, info->dev_root->node->start);
	btrfs_set_backup_dev_root_gen(root_backup,
			       btrfs_header_generation(info->dev_root->node));
	btrfs_set_backup_dev_root_level(root_backup,
				       btrfs_header_level(info->dev_root->node));

	btrfs_set_backup_csum_root(root_backup, info->csum_root->node->start);
	btrfs_set_backup_csum_root_gen(root_backup,
			       btrfs_header_generation(info->csum_root->node));
	btrfs_set_backup_csum_root_level(root_backup,
			       btrfs_header_level(info->csum_root->node));

	btrfs_set_backup_total_bytes(root_backup,
			     btrfs_super_total_bytes(info->super_copy));
	btrfs_set_backup_bytes_used(root_backup,
			     btrfs_super_bytes_used(info->super_copy));
	btrfs_set_backup_num_devices(root_backup,
			     btrfs_super_num_devices(info->super_copy));

	/*
	 * if we don't copy this out to the super_copy, it won't get remembered
	 * for the next commit
	 */
	memcpy(&info->super_copy->super_roots,
	       &info->super_for_commit->super_roots,
	       sizeof(*root_backup) * BTRFS_NUM_BACKUP_ROOTS);
}

/*
 * this copies info out of the root backup array and back into
 * the in-memory super block.  It is meant to help iterate through
 * the array, so you send it the number of backups you've already
 * tried and the last backup index you used.
 *
 * this returns -1 when it has tried all the backups
 */
static noinline int next_root_backup(struct btrfs_fs_info *info,
				     struct btrfs_super_block *super,
				     int *num_backups_tried, int *backup_index)
{
	struct btrfs_root_backup *root_backup;
	int newest = *backup_index;

	if (*num_backups_tried == 0) {
		u64 gen = btrfs_super_generation(super);

		newest = find_newest_super_backup(info, gen);
		if (newest == -1)
			return -1;

		*backup_index = newest;
		*num_backups_tried = 1;
	} else if (*num_backups_tried == BTRFS_NUM_BACKUP_ROOTS) {
		/* we've tried all the backups, all done */
		return -1;
	} else {
		/* jump to the next oldest backup */
		newest = (*backup_index + BTRFS_NUM_BACKUP_ROOTS - 1) %
			BTRFS_NUM_BACKUP_ROOTS;
		*backup_index = newest;
		*num_backups_tried += 1;
	}
	root_backup = super->super_roots + newest;

	btrfs_set_super_generation(super,
				   btrfs_backup_tree_root_gen(root_backup));
	btrfs_set_super_root(super, btrfs_backup_tree_root(root_backup));
	btrfs_set_super_root_level(super,
				   btrfs_backup_tree_root_level(root_backup));
	btrfs_set_super_bytes_used(super, btrfs_backup_bytes_used(root_backup));

	/*
	 * fixme: the total bytes and num_devices need to match or we should
	 * need a fsck
	 */
	btrfs_set_super_total_bytes(super, btrfs_backup_total_bytes(root_backup));
	btrfs_set_super_num_devices(super, btrfs_backup_num_devices(root_backup));
	return 0;
}

L
Liu Bo 已提交
2052 2053 2054
/* helper to cleanup workers */
static void btrfs_stop_all_workers(struct btrfs_fs_info *fs_info)
{
2055
	btrfs_destroy_workqueue(fs_info->fixup_workers);
2056
	btrfs_destroy_workqueue(fs_info->delalloc_workers);
2057
	btrfs_destroy_workqueue(fs_info->workers);
2058 2059 2060
	btrfs_destroy_workqueue(fs_info->endio_workers);
	btrfs_destroy_workqueue(fs_info->endio_meta_workers);
	btrfs_destroy_workqueue(fs_info->endio_raid56_workers);
2061
	btrfs_destroy_workqueue(fs_info->rmw_workers);
2062 2063 2064
	btrfs_destroy_workqueue(fs_info->endio_meta_write_workers);
	btrfs_destroy_workqueue(fs_info->endio_write_workers);
	btrfs_destroy_workqueue(fs_info->endio_freespace_worker);
2065
	btrfs_destroy_workqueue(fs_info->submit_workers);
2066
	btrfs_destroy_workqueue(fs_info->delayed_workers);
2067
	btrfs_destroy_workqueue(fs_info->caching_workers);
2068
	btrfs_destroy_workqueue(fs_info->readahead_workers);
2069
	btrfs_destroy_workqueue(fs_info->flush_workers);
2070
	btrfs_destroy_workqueue(fs_info->qgroup_rescan_workers);
C
Chris Mason 已提交
2071
	btrfs_destroy_workqueue(fs_info->extent_workers);
L
Liu Bo 已提交
2072 2073
}

2074 2075 2076 2077 2078 2079 2080 2081 2082 2083
static void free_root_extent_buffers(struct btrfs_root *root)
{
	if (root) {
		free_extent_buffer(root->node);
		free_extent_buffer(root->commit_root);
		root->node = NULL;
		root->commit_root = NULL;
	}
}

C
Chris Mason 已提交
2084 2085 2086
/* helper to cleanup tree roots */
static void free_root_pointers(struct btrfs_fs_info *info, int chunk_root)
{
2087
	free_root_extent_buffers(info->tree_root);
2088

2089 2090 2091 2092 2093 2094 2095
	free_root_extent_buffers(info->dev_root);
	free_root_extent_buffers(info->extent_root);
	free_root_extent_buffers(info->csum_root);
	free_root_extent_buffers(info->quota_root);
	free_root_extent_buffers(info->uuid_root);
	if (chunk_root)
		free_root_extent_buffers(info->chunk_root);
C
Chris Mason 已提交
2096 2097
}

2098
void btrfs_free_fs_roots(struct btrfs_fs_info *fs_info)
2099 2100 2101 2102 2103 2104 2105 2106 2107 2108
{
	int ret;
	struct btrfs_root *gang[8];
	int i;

	while (!list_empty(&fs_info->dead_roots)) {
		gang[0] = list_entry(fs_info->dead_roots.next,
				     struct btrfs_root, root_list);
		list_del(&gang[0]->root_list);

2109
		if (test_bit(BTRFS_ROOT_IN_RADIX, &gang[0]->state)) {
2110
			btrfs_drop_and_free_fs_root(fs_info, gang[0]);
2111 2112 2113
		} else {
			free_extent_buffer(gang[0]->node);
			free_extent_buffer(gang[0]->commit_root);
2114
			btrfs_put_fs_root(gang[0]);
2115 2116 2117 2118 2119 2120 2121 2122 2123 2124
		}
	}

	while (1) {
		ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
					     (void **)gang, 0,
					     ARRAY_SIZE(gang));
		if (!ret)
			break;
		for (i = 0; i < ret; i++)
2125
			btrfs_drop_and_free_fs_root(fs_info, gang[i]);
2126
	}
2127 2128 2129 2130 2131 2132

	if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
		btrfs_free_log_root_tree(NULL, fs_info);
		btrfs_destroy_pinned_extent(fs_info->tree_root,
					    fs_info->pinned_extents);
	}
2133
}
C
Chris Mason 已提交
2134

A
Al Viro 已提交
2135 2136 2137
int open_ctree(struct super_block *sb,
	       struct btrfs_fs_devices *fs_devices,
	       char *options)
2138
{
2139 2140 2141 2142
	u32 sectorsize;
	u32 nodesize;
	u32 leafsize;
	u32 blocksize;
2143
	u32 stripesize;
2144
	u64 generation;
2145
	u64 features;
2146
	struct btrfs_key location;
2147
	struct buffer_head *bh;
2148
	struct btrfs_super_block *disk_super;
2149
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
2150
	struct btrfs_root *tree_root;
2151 2152 2153 2154
	struct btrfs_root *extent_root;
	struct btrfs_root *csum_root;
	struct btrfs_root *chunk_root;
	struct btrfs_root *dev_root;
2155
	struct btrfs_root *quota_root;
2156
	struct btrfs_root *uuid_root;
2157
	struct btrfs_root *log_tree_root;
2158
	int ret;
2159
	int err = -EINVAL;
C
Chris Mason 已提交
2160 2161
	int num_backups_tried = 0;
	int backup_index = 0;
2162 2163
	int max_active;
	int flags = WQ_MEM_RECLAIM | WQ_FREEZABLE | WQ_UNBOUND;
2164 2165
	bool create_uuid_tree;
	bool check_uuid_tree;
2166

2167
	tree_root = fs_info->tree_root = btrfs_alloc_root(fs_info);
A
Al Viro 已提交
2168
	chunk_root = fs_info->chunk_root = btrfs_alloc_root(fs_info);
2169
	if (!tree_root || !chunk_root) {
C
Chris Mason 已提交
2170 2171 2172
		err = -ENOMEM;
		goto fail;
	}
2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185

	ret = init_srcu_struct(&fs_info->subvol_srcu);
	if (ret) {
		err = ret;
		goto fail;
	}

	ret = setup_bdi(fs_info, &fs_info->bdi);
	if (ret) {
		err = ret;
		goto fail_srcu;
	}

2186 2187 2188 2189 2190 2191 2192 2193
	ret = percpu_counter_init(&fs_info->dirty_metadata_bytes, 0);
	if (ret) {
		err = ret;
		goto fail_bdi;
	}
	fs_info->dirty_metadata_batch = PAGE_CACHE_SIZE *
					(1 + ilog2(nr_cpu_ids));

2194 2195 2196 2197 2198 2199
	ret = percpu_counter_init(&fs_info->delalloc_bytes, 0);
	if (ret) {
		err = ret;
		goto fail_dirty_metadata_bytes;
	}

2200 2201 2202 2203 2204 2205
	ret = percpu_counter_init(&fs_info->bio_counter, 0);
	if (ret) {
		err = ret;
		goto fail_delalloc_bytes;
	}

2206 2207 2208
	fs_info->btree_inode = new_inode(sb);
	if (!fs_info->btree_inode) {
		err = -ENOMEM;
2209
		goto fail_bio_counter;
2210 2211
	}

2212
	mapping_set_gfp_mask(fs_info->btree_inode->i_mapping, GFP_NOFS);
2213

2214
	INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_ATOMIC);
2215
	INIT_RADIX_TREE(&fs_info->buffer_radix, GFP_ATOMIC);
C
Chris Mason 已提交
2216
	INIT_LIST_HEAD(&fs_info->trans_list);
2217
	INIT_LIST_HEAD(&fs_info->dead_roots);
Y
Yan, Zheng 已提交
2218
	INIT_LIST_HEAD(&fs_info->delayed_iputs);
2219
	INIT_LIST_HEAD(&fs_info->delalloc_roots);
2220
	INIT_LIST_HEAD(&fs_info->caching_block_groups);
2221
	spin_lock_init(&fs_info->delalloc_root_lock);
J
Josef Bacik 已提交
2222
	spin_lock_init(&fs_info->trans_lock);
2223
	spin_lock_init(&fs_info->fs_roots_radix_lock);
Y
Yan, Zheng 已提交
2224
	spin_lock_init(&fs_info->delayed_iput_lock);
C
Chris Mason 已提交
2225
	spin_lock_init(&fs_info->defrag_inodes_lock);
2226
	spin_lock_init(&fs_info->free_chunk_lock);
J
Jan Schmidt 已提交
2227
	spin_lock_init(&fs_info->tree_mod_seq_lock);
2228
	spin_lock_init(&fs_info->super_lock);
J
Josef Bacik 已提交
2229
	spin_lock_init(&fs_info->qgroup_op_lock);
2230
	spin_lock_init(&fs_info->buffer_lock);
J
Jan Schmidt 已提交
2231
	rwlock_init(&fs_info->tree_mod_log_lock);
C
Chris Mason 已提交
2232
	mutex_init(&fs_info->reloc_mutex);
2233
	mutex_init(&fs_info->delalloc_root_mutex);
2234
	seqlock_init(&fs_info->profiles_lock);
2235

2236
	init_completion(&fs_info->kobj_unregister);
2237
	INIT_LIST_HEAD(&fs_info->dirty_cowonly_roots);
2238
	INIT_LIST_HEAD(&fs_info->space_info);
J
Jan Schmidt 已提交
2239
	INIT_LIST_HEAD(&fs_info->tree_mod_seq_list);
2240
	btrfs_mapping_init(&fs_info->mapping_tree);
2241 2242 2243 2244 2245 2246 2247 2248 2249
	btrfs_init_block_rsv(&fs_info->global_block_rsv,
			     BTRFS_BLOCK_RSV_GLOBAL);
	btrfs_init_block_rsv(&fs_info->delalloc_block_rsv,
			     BTRFS_BLOCK_RSV_DELALLOC);
	btrfs_init_block_rsv(&fs_info->trans_block_rsv, BTRFS_BLOCK_RSV_TRANS);
	btrfs_init_block_rsv(&fs_info->chunk_block_rsv, BTRFS_BLOCK_RSV_CHUNK);
	btrfs_init_block_rsv(&fs_info->empty_block_rsv, BTRFS_BLOCK_RSV_EMPTY);
	btrfs_init_block_rsv(&fs_info->delayed_block_rsv,
			     BTRFS_BLOCK_RSV_DELOPS);
2250
	atomic_set(&fs_info->nr_async_submits, 0);
2251
	atomic_set(&fs_info->async_delalloc_pages, 0);
2252
	atomic_set(&fs_info->async_submit_draining, 0);
2253
	atomic_set(&fs_info->nr_async_bios, 0);
C
Chris Mason 已提交
2254
	atomic_set(&fs_info->defrag_running, 0);
J
Josef Bacik 已提交
2255
	atomic_set(&fs_info->qgroup_op_seq, 0);
2256
	atomic64_set(&fs_info->tree_mod_seq, 0);
C
Chris Mason 已提交
2257
	fs_info->sb = sb;
2258
	fs_info->max_inline = 8192 * 1024;
J
Josef Bacik 已提交
2259
	fs_info->metadata_ratio = 0;
C
Chris Mason 已提交
2260
	fs_info->defrag_inodes = RB_ROOT;
2261
	fs_info->free_chunk_space = 0;
J
Jan Schmidt 已提交
2262
	fs_info->tree_mod_log = RB_ROOT;
2263
	fs_info->commit_interval = BTRFS_DEFAULT_COMMIT_INTERVAL;
2264
	fs_info->avg_delayed_ref_runtime = div64_u64(NSEC_PER_SEC, 64);
2265 2266 2267
	/* readahead state */
	INIT_RADIX_TREE(&fs_info->reada_tree, GFP_NOFS & ~__GFP_WAIT);
	spin_lock_init(&fs_info->reada_lock);
C
Chris Mason 已提交
2268

2269 2270
	fs_info->thread_pool_size = min_t(unsigned long,
					  num_online_cpus() + 2, 8);
2271

2272 2273
	INIT_LIST_HEAD(&fs_info->ordered_roots);
	spin_lock_init(&fs_info->ordered_root_lock);
2274 2275 2276 2277 2278 2279 2280
	fs_info->delayed_root = kmalloc(sizeof(struct btrfs_delayed_root),
					GFP_NOFS);
	if (!fs_info->delayed_root) {
		err = -ENOMEM;
		goto fail_iput;
	}
	btrfs_init_delayed_root(fs_info->delayed_root);
2281

A
Arne Jansen 已提交
2282 2283 2284 2285 2286
	mutex_init(&fs_info->scrub_lock);
	atomic_set(&fs_info->scrubs_running, 0);
	atomic_set(&fs_info->scrub_pause_req, 0);
	atomic_set(&fs_info->scrubs_paused, 0);
	atomic_set(&fs_info->scrub_cancel_req, 0);
2287
	init_waitqueue_head(&fs_info->replace_wait);
A
Arne Jansen 已提交
2288 2289
	init_waitqueue_head(&fs_info->scrub_pause_wait);
	fs_info->scrub_workers_refcnt = 0;
2290 2291 2292
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
	fs_info->check_integrity_print_mask = 0;
#endif
A
Arne Jansen 已提交
2293

2294 2295
	spin_lock_init(&fs_info->balance_lock);
	mutex_init(&fs_info->balance_mutex);
2296 2297
	atomic_set(&fs_info->balance_running, 0);
	atomic_set(&fs_info->balance_pause_req, 0);
2298
	atomic_set(&fs_info->balance_cancel_req, 0);
2299
	fs_info->balance_ctl = NULL;
2300
	init_waitqueue_head(&fs_info->balance_wait_q);
2301
	btrfs_init_async_reclaim_work(&fs_info->async_reclaim_work);
A
Arne Jansen 已提交
2302

2303 2304
	sb->s_blocksize = 4096;
	sb->s_blocksize_bits = blksize_bits(4096);
J
Jens Axboe 已提交
2305
	sb->s_bdi = &fs_info->bdi;
2306

2307
	fs_info->btree_inode->i_ino = BTRFS_BTREE_INODE_OBJECTID;
M
Miklos Szeredi 已提交
2308
	set_nlink(fs_info->btree_inode, 1);
2309 2310 2311 2312 2313 2314
	/*
	 * we set the i_size on the btree inode to the max possible int.
	 * the real end of the address space is determined by all of
	 * the devices in the system
	 */
	fs_info->btree_inode->i_size = OFFSET_MAX;
2315
	fs_info->btree_inode->i_mapping->a_ops = &btree_aops;
C
Chris Mason 已提交
2316 2317
	fs_info->btree_inode->i_mapping->backing_dev_info = &fs_info->bdi;

2318
	RB_CLEAR_NODE(&BTRFS_I(fs_info->btree_inode)->rb_node);
2319
	extent_io_tree_init(&BTRFS_I(fs_info->btree_inode)->io_tree,
2320
			     fs_info->btree_inode->i_mapping);
2321
	BTRFS_I(fs_info->btree_inode)->io_tree.track_uptodate = 0;
2322
	extent_map_tree_init(&BTRFS_I(fs_info->btree_inode)->extent_tree);
2323 2324

	BTRFS_I(fs_info->btree_inode)->io_tree.ops = &btree_extent_io_ops;
2325

2326 2327 2328
	BTRFS_I(fs_info->btree_inode)->root = tree_root;
	memset(&BTRFS_I(fs_info->btree_inode)->location, 0,
	       sizeof(struct btrfs_key));
2329 2330
	set_bit(BTRFS_INODE_DUMMY,
		&BTRFS_I(fs_info->btree_inode)->runtime_flags);
2331
	btrfs_insert_inode_hash(fs_info->btree_inode);
2332

J
Josef Bacik 已提交
2333
	spin_lock_init(&fs_info->block_group_cache_lock);
2334
	fs_info->block_group_cache_tree = RB_ROOT;
2335
	fs_info->first_logical_byte = (u64)-1;
J
Josef Bacik 已提交
2336

2337
	extent_io_tree_init(&fs_info->freed_extents[0],
2338
			     fs_info->btree_inode->i_mapping);
2339
	extent_io_tree_init(&fs_info->freed_extents[1],
2340
			     fs_info->btree_inode->i_mapping);
2341
	fs_info->pinned_extents = &fs_info->freed_extents[0];
2342
	fs_info->do_barriers = 1;
2343

C
Chris Mason 已提交
2344

2345
	mutex_init(&fs_info->ordered_operations_mutex);
2346
	mutex_init(&fs_info->ordered_extent_flush_mutex);
2347
	mutex_init(&fs_info->tree_log_mutex);
2348
	mutex_init(&fs_info->chunk_mutex);
2349 2350
	mutex_init(&fs_info->transaction_kthread_mutex);
	mutex_init(&fs_info->cleaner_mutex);
2351
	mutex_init(&fs_info->volume_mutex);
2352
	init_rwsem(&fs_info->commit_root_sem);
2353
	init_rwsem(&fs_info->cleanup_work_sem);
2354
	init_rwsem(&fs_info->subvol_sem);
S
Stefan Behrens 已提交
2355
	sema_init(&fs_info->uuid_tree_rescan_sem, 1);
2356 2357 2358 2359 2360
	fs_info->dev_replace.lock_owner = 0;
	atomic_set(&fs_info->dev_replace.nesting_level, 0);
	mutex_init(&fs_info->dev_replace.lock_finishing_cancel_unmount);
	mutex_init(&fs_info->dev_replace.lock_management_lock);
	mutex_init(&fs_info->dev_replace.lock);
2361

2362
	spin_lock_init(&fs_info->qgroup_lock);
2363
	mutex_init(&fs_info->qgroup_ioctl_lock);
2364
	fs_info->qgroup_tree = RB_ROOT;
J
Josef Bacik 已提交
2365
	fs_info->qgroup_op_tree = RB_ROOT;
2366 2367 2368 2369
	INIT_LIST_HEAD(&fs_info->dirty_qgroups);
	fs_info->qgroup_seq = 1;
	fs_info->quota_enabled = 0;
	fs_info->pending_quota_state = 0;
2370
	fs_info->qgroup_ulist = NULL;
J
Jan Schmidt 已提交
2371
	mutex_init(&fs_info->qgroup_rescan_lock);
2372

2373 2374 2375
	btrfs_init_free_cluster(&fs_info->meta_alloc_cluster);
	btrfs_init_free_cluster(&fs_info->data_alloc_cluster);

2376
	init_waitqueue_head(&fs_info->transaction_throttle);
2377
	init_waitqueue_head(&fs_info->transaction_wait);
S
Sage Weil 已提交
2378
	init_waitqueue_head(&fs_info->transaction_blocked_wait);
2379
	init_waitqueue_head(&fs_info->async_submit_wait);
2380

D
David Woodhouse 已提交
2381 2382
	ret = btrfs_alloc_stripe_hash_table(fs_info);
	if (ret) {
2383
		err = ret;
D
David Woodhouse 已提交
2384 2385 2386
		goto fail_alloc;
	}

2387
	__setup_root(4096, 4096, 4096, 4096, tree_root,
C
Chris Mason 已提交
2388
		     fs_info, BTRFS_ROOT_TREE_OBJECTID);
2389

2390
	invalidate_bdev(fs_devices->latest_bdev);
D
David Sterba 已提交
2391 2392 2393 2394

	/*
	 * Read super block and check the signature bytes only
	 */
Y
Yan Zheng 已提交
2395
	bh = btrfs_read_dev_super(fs_devices->latest_bdev);
2396 2397
	if (!bh) {
		err = -EINVAL;
2398
		goto fail_alloc;
2399
	}
C
Chris Mason 已提交
2400

D
David Sterba 已提交
2401 2402 2403 2404 2405
	/*
	 * We want to check superblock checksum, the type is stored inside.
	 * Pass the whole disk block of size BTRFS_SUPER_INFO_SIZE (4k).
	 */
	if (btrfs_check_super_csum(bh->b_data)) {
2406
		printk(KERN_ERR "BTRFS: superblock checksum mismatch\n");
D
David Sterba 已提交
2407 2408 2409 2410 2411 2412 2413 2414 2415
		err = -EINVAL;
		goto fail_alloc;
	}

	/*
	 * super_copy is zeroed at allocation time and we never touch the
	 * following bytes up to INFO_SIZE, the checksum is calculated from
	 * the whole block of INFO_SIZE
	 */
2416 2417 2418
	memcpy(fs_info->super_copy, bh->b_data, sizeof(*fs_info->super_copy));
	memcpy(fs_info->super_for_commit, fs_info->super_copy,
	       sizeof(*fs_info->super_for_commit));
2419
	brelse(bh);
2420

2421
	memcpy(fs_info->fsid, fs_info->super_copy->fsid, BTRFS_FSID_SIZE);
2422

D
David Sterba 已提交
2423 2424
	ret = btrfs_check_super_valid(fs_info, sb->s_flags & MS_RDONLY);
	if (ret) {
2425
		printk(KERN_ERR "BTRFS: superblock contains fatal errors\n");
D
David Sterba 已提交
2426 2427 2428 2429
		err = -EINVAL;
		goto fail_alloc;
	}

2430
	disk_super = fs_info->super_copy;
2431
	if (!btrfs_super_root(disk_super))
2432
		goto fail_alloc;
2433

L
liubo 已提交
2434
	/* check FS state, whether FS is broken. */
2435 2436
	if (btrfs_super_flags(disk_super) & BTRFS_SUPER_FLAG_ERROR)
		set_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state);
L
liubo 已提交
2437

C
Chris Mason 已提交
2438 2439 2440 2441 2442 2443 2444
	/*
	 * run through our array of backup supers and setup
	 * our ring pointer to the oldest one
	 */
	generation = btrfs_super_generation(disk_super);
	find_oldest_super_backup(fs_info, generation);

2445 2446 2447 2448 2449 2450
	/*
	 * In the long term, we'll store the compression type in the super
	 * block, and it'll be used for per file compression control.
	 */
	fs_info->compress_type = BTRFS_COMPRESS_ZLIB;

Y
Yan Zheng 已提交
2451 2452 2453
	ret = btrfs_parse_options(tree_root, options);
	if (ret) {
		err = ret;
2454
		goto fail_alloc;
Y
Yan Zheng 已提交
2455
	}
2456

2457 2458 2459 2460 2461
	features = btrfs_super_incompat_flags(disk_super) &
		~BTRFS_FEATURE_INCOMPAT_SUPP;
	if (features) {
		printk(KERN_ERR "BTRFS: couldn't mount because of "
		       "unsupported optional features (%Lx).\n",
2462
		       features);
2463
		err = -EINVAL;
2464
		goto fail_alloc;
2465 2466
	}

2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483
	if (btrfs_super_leafsize(disk_super) !=
	    btrfs_super_nodesize(disk_super)) {
		printk(KERN_ERR "BTRFS: couldn't mount because metadata "
		       "blocksizes don't match.  node %d leaf %d\n",
		       btrfs_super_nodesize(disk_super),
		       btrfs_super_leafsize(disk_super));
		err = -EINVAL;
		goto fail_alloc;
	}
	if (btrfs_super_leafsize(disk_super) > BTRFS_MAX_METADATA_BLOCKSIZE) {
		printk(KERN_ERR "BTRFS: couldn't mount because metadata "
		       "blocksize (%d) was too large\n",
		       btrfs_super_leafsize(disk_super));
		err = -EINVAL;
		goto fail_alloc;
	}

2484
	features = btrfs_super_incompat_flags(disk_super);
L
Li Zefan 已提交
2485
	features |= BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF;
L
Li Zefan 已提交
2486
	if (tree_root->fs_info->compress_type == BTRFS_COMPRESS_LZO)
L
Li Zefan 已提交
2487
		features |= BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO;
2488

2489
	if (features & BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA)
2490
		printk(KERN_ERR "BTRFS: has skinny extents\n");
2491

2492 2493 2494 2495 2496 2497
	/*
	 * flag our filesystem as having big metadata blocks if
	 * they are bigger than the page size
	 */
	if (btrfs_super_leafsize(disk_super) > PAGE_CACHE_SIZE) {
		if (!(features & BTRFS_FEATURE_INCOMPAT_BIG_METADATA))
2498
			printk(KERN_INFO "BTRFS: flagging fs with big metadata feature\n");
2499 2500 2501
		features |= BTRFS_FEATURE_INCOMPAT_BIG_METADATA;
	}

2502 2503 2504 2505
	nodesize = btrfs_super_nodesize(disk_super);
	leafsize = btrfs_super_leafsize(disk_super);
	sectorsize = btrfs_super_sectorsize(disk_super);
	stripesize = btrfs_super_stripesize(disk_super);
2506
	fs_info->dirty_metadata_batch = leafsize * (1 + ilog2(nr_cpu_ids));
2507
	fs_info->delalloc_batch = sectorsize * 512 * (1 + ilog2(nr_cpu_ids));
2508 2509 2510 2511 2512 2513 2514

	/*
	 * mixed block groups end up with duplicate but slightly offset
	 * extent buffers for the same range.  It leads to corruptions
	 */
	if ((features & BTRFS_FEATURE_INCOMPAT_MIXED_GROUPS) &&
	    (sectorsize != leafsize)) {
2515
		printk(KERN_WARNING "BTRFS: unequal leaf/node/sector sizes "
2516 2517 2518 2519 2520
				"are not allowed for mixed block groups on %s\n",
				sb->s_id);
		goto fail_alloc;
	}

2521 2522 2523 2524
	/*
	 * Needn't use the lock because there is no other task which will
	 * update the flag.
	 */
L
Li Zefan 已提交
2525
	btrfs_set_super_incompat_flags(disk_super, features);
2526

2527 2528 2529 2530 2531
	features = btrfs_super_compat_ro_flags(disk_super) &
		~BTRFS_FEATURE_COMPAT_RO_SUPP;
	if (!(sb->s_flags & MS_RDONLY) && features) {
		printk(KERN_ERR "BTRFS: couldn't mount RDWR because of "
		       "unsupported option features (%Lx).\n",
2532
		       features);
2533
		err = -EINVAL;
2534
		goto fail_alloc;
2535
	}
2536

2537
	max_active = fs_info->thread_pool_size;
2538

2539 2540 2541
	fs_info->workers =
		btrfs_alloc_workqueue("worker", flags | WQ_HIGHPRI,
				      max_active, 16);
C
Chris Mason 已提交
2542

2543 2544
	fs_info->delalloc_workers =
		btrfs_alloc_workqueue("delalloc", flags, max_active, 2);
2545

2546 2547
	fs_info->flush_workers =
		btrfs_alloc_workqueue("flush_delalloc", flags, max_active, 0);
2548

2549 2550
	fs_info->caching_workers =
		btrfs_alloc_workqueue("cache", flags, max_active, 0);
2551

2552 2553
	/*
	 * a higher idle thresh on the submit workers makes it much more
2554 2555 2556
	 * likely that bios will be send down in a sane order to the
	 * devices
	 */
2557 2558 2559 2560
	fs_info->submit_workers =
		btrfs_alloc_workqueue("submit", flags,
				      min_t(u64, fs_devices->num_devices,
					    max_active), 64);
2561

2562 2563
	fs_info->fixup_workers =
		btrfs_alloc_workqueue("fixup", flags, 1, 0);
2564 2565 2566 2567 2568

	/*
	 * endios are largely parallel and should have a very
	 * low idle thresh
	 */
2569 2570 2571 2572 2573 2574 2575 2576
	fs_info->endio_workers =
		btrfs_alloc_workqueue("endio", flags, max_active, 4);
	fs_info->endio_meta_workers =
		btrfs_alloc_workqueue("endio-meta", flags, max_active, 4);
	fs_info->endio_meta_write_workers =
		btrfs_alloc_workqueue("endio-meta-write", flags, max_active, 2);
	fs_info->endio_raid56_workers =
		btrfs_alloc_workqueue("endio-raid56", flags, max_active, 4);
2577 2578
	fs_info->rmw_workers =
		btrfs_alloc_workqueue("rmw", flags, max_active, 2);
2579 2580 2581 2582
	fs_info->endio_write_workers =
		btrfs_alloc_workqueue("endio-write", flags, max_active, 2);
	fs_info->endio_freespace_worker =
		btrfs_alloc_workqueue("freespace-write", flags, max_active, 0);
2583 2584
	fs_info->delayed_workers =
		btrfs_alloc_workqueue("delayed-meta", flags, max_active, 0);
2585 2586
	fs_info->readahead_workers =
		btrfs_alloc_workqueue("readahead", flags, max_active, 2);
2587 2588
	fs_info->qgroup_rescan_workers =
		btrfs_alloc_workqueue("qgroup-rescan", flags, 1, 0);
C
Chris Mason 已提交
2589 2590 2591 2592
	fs_info->extent_workers =
		btrfs_alloc_workqueue("extent-refs", flags,
				      min_t(u64, fs_devices->num_devices,
					    max_active), 8);
2593

2594
	if (!(fs_info->workers && fs_info->delalloc_workers &&
2595 2596 2597 2598
	      fs_info->submit_workers && fs_info->flush_workers &&
	      fs_info->endio_workers && fs_info->endio_meta_workers &&
	      fs_info->endio_meta_write_workers &&
	      fs_info->endio_write_workers && fs_info->endio_raid56_workers &&
2599
	      fs_info->endio_freespace_worker && fs_info->rmw_workers &&
2600
	      fs_info->caching_workers && fs_info->readahead_workers &&
2601
	      fs_info->fixup_workers && fs_info->delayed_workers &&
C
Chris Mason 已提交
2602
	      fs_info->fixup_workers && fs_info->extent_workers &&
2603
	      fs_info->qgroup_rescan_workers)) {
2604
		err = -ENOMEM;
2605 2606
		goto fail_sb_buffer;
	}
2607

2608
	fs_info->bdi.ra_pages *= btrfs_super_num_devices(disk_super);
C
Chris Mason 已提交
2609 2610
	fs_info->bdi.ra_pages = max(fs_info->bdi.ra_pages,
				    4 * 1024 * 1024 / PAGE_CACHE_SIZE);
2611

2612 2613 2614
	tree_root->nodesize = nodesize;
	tree_root->leafsize = leafsize;
	tree_root->sectorsize = sectorsize;
2615
	tree_root->stripesize = stripesize;
2616 2617 2618

	sb->s_blocksize = sectorsize;
	sb->s_blocksize_bits = blksize_bits(sectorsize);
2619

2620
	if (btrfs_super_magic(disk_super) != BTRFS_MAGIC) {
2621
		printk(KERN_INFO "BTRFS: valid FS not found on %s\n", sb->s_id);
C
Chris Mason 已提交
2622 2623
		goto fail_sb_buffer;
	}
2624

2625
	if (sectorsize != PAGE_SIZE) {
2626
		printk(KERN_WARNING "BTRFS: Incompatible sector size(%lu) "
2627
		       "found on %s\n", (unsigned long)sectorsize, sb->s_id);
2628 2629 2630
		goto fail_sb_buffer;
	}

2631
	mutex_lock(&fs_info->chunk_mutex);
Y
Yan Zheng 已提交
2632
	ret = btrfs_read_sys_array(tree_root);
2633
	mutex_unlock(&fs_info->chunk_mutex);
2634
	if (ret) {
2635
		printk(KERN_WARNING "BTRFS: failed to read the system "
C
Chris Mason 已提交
2636
		       "array on %s\n", sb->s_id);
2637
		goto fail_sb_buffer;
2638
	}
2639 2640 2641

	blocksize = btrfs_level_size(tree_root,
				     btrfs_super_chunk_root_level(disk_super));
2642
	generation = btrfs_super_chunk_root_generation(disk_super);
2643 2644 2645 2646 2647 2648

	__setup_root(nodesize, leafsize, sectorsize, stripesize,
		     chunk_root, fs_info, BTRFS_CHUNK_TREE_OBJECTID);

	chunk_root->node = read_tree_block(chunk_root,
					   btrfs_super_chunk_root(disk_super),
2649
					   blocksize, generation);
2650 2651
	if (!chunk_root->node ||
	    !test_bit(EXTENT_BUFFER_UPTODATE, &chunk_root->node->bflags)) {
2652
		printk(KERN_WARNING "BTRFS: failed to read chunk root on %s\n",
2653
		       sb->s_id);
C
Chris Mason 已提交
2654
		goto fail_tree_roots;
2655
	}
2656 2657
	btrfs_set_root_node(&chunk_root->root_item, chunk_root->node);
	chunk_root->commit_root = btrfs_root_node(chunk_root);
2658

2659
	read_extent_buffer(chunk_root->node, fs_info->chunk_tree_uuid,
2660
	   btrfs_header_chunk_tree_uuid(chunk_root->node), BTRFS_UUID_SIZE);
2661

2662
	ret = btrfs_read_chunk_tree(chunk_root);
Y
Yan Zheng 已提交
2663
	if (ret) {
2664
		printk(KERN_WARNING "BTRFS: failed to read chunk tree on %s\n",
C
Chris Mason 已提交
2665
		       sb->s_id);
C
Chris Mason 已提交
2666
		goto fail_tree_roots;
Y
Yan Zheng 已提交
2667
	}
2668

2669 2670 2671 2672 2673
	/*
	 * keep the device that is marked to be the target device for the
	 * dev_replace procedure
	 */
	btrfs_close_extra_devices(fs_info, fs_devices, 0);
2674

2675
	if (!fs_devices->latest_bdev) {
2676
		printk(KERN_CRIT "BTRFS: failed to read devices on %s\n",
2677 2678 2679 2680
		       sb->s_id);
		goto fail_tree_roots;
	}

C
Chris Mason 已提交
2681
retry_root_backup:
2682 2683
	blocksize = btrfs_level_size(tree_root,
				     btrfs_super_root_level(disk_super));
2684
	generation = btrfs_super_generation(disk_super);
2685

C
Chris Mason 已提交
2686
	tree_root->node = read_tree_block(tree_root,
2687
					  btrfs_super_root(disk_super),
2688
					  blocksize, generation);
C
Chris Mason 已提交
2689 2690
	if (!tree_root->node ||
	    !test_bit(EXTENT_BUFFER_UPTODATE, &tree_root->node->bflags)) {
2691
		printk(KERN_WARNING "BTRFS: failed to read tree root on %s\n",
2692
		       sb->s_id);
C
Chris Mason 已提交
2693 2694

		goto recovery_tree_root;
2695
	}
C
Chris Mason 已提交
2696

2697 2698
	btrfs_set_root_node(&tree_root->root_item, tree_root->node);
	tree_root->commit_root = btrfs_root_node(tree_root);
2699
	btrfs_set_root_refs(&tree_root->root_item, 1);
2700

2701 2702 2703 2704 2705 2706 2707
	location.objectid = BTRFS_EXTENT_TREE_OBJECTID;
	location.type = BTRFS_ROOT_ITEM_KEY;
	location.offset = 0;

	extent_root = btrfs_read_tree_root(tree_root, &location);
	if (IS_ERR(extent_root)) {
		ret = PTR_ERR(extent_root);
C
Chris Mason 已提交
2708
		goto recovery_tree_root;
2709
	}
2710
	set_bit(BTRFS_ROOT_TRACK_DIRTY, &extent_root->state);
2711
	fs_info->extent_root = extent_root;
2712

2713 2714 2715 2716
	location.objectid = BTRFS_DEV_TREE_OBJECTID;
	dev_root = btrfs_read_tree_root(tree_root, &location);
	if (IS_ERR(dev_root)) {
		ret = PTR_ERR(dev_root);
C
Chris Mason 已提交
2717
		goto recovery_tree_root;
2718
	}
2719
	set_bit(BTRFS_ROOT_TRACK_DIRTY, &dev_root->state);
2720 2721
	fs_info->dev_root = dev_root;
	btrfs_init_devices_late(fs_info);
2722

2723 2724 2725 2726
	location.objectid = BTRFS_CSUM_TREE_OBJECTID;
	csum_root = btrfs_read_tree_root(tree_root, &location);
	if (IS_ERR(csum_root)) {
		ret = PTR_ERR(csum_root);
C
Chris Mason 已提交
2727
		goto recovery_tree_root;
2728
	}
2729
	set_bit(BTRFS_ROOT_TRACK_DIRTY, &csum_root->state);
2730
	fs_info->csum_root = csum_root;
2731

2732 2733 2734
	location.objectid = BTRFS_QUOTA_TREE_OBJECTID;
	quota_root = btrfs_read_tree_root(tree_root, &location);
	if (!IS_ERR(quota_root)) {
2735
		set_bit(BTRFS_ROOT_TRACK_DIRTY, &quota_root->state);
2736 2737
		fs_info->quota_enabled = 1;
		fs_info->pending_quota_state = 1;
2738
		fs_info->quota_root = quota_root;
2739 2740
	}

2741 2742 2743 2744 2745 2746 2747
	location.objectid = BTRFS_UUID_TREE_OBJECTID;
	uuid_root = btrfs_read_tree_root(tree_root, &location);
	if (IS_ERR(uuid_root)) {
		ret = PTR_ERR(uuid_root);
		if (ret != -ENOENT)
			goto recovery_tree_root;
		create_uuid_tree = true;
2748
		check_uuid_tree = false;
2749
	} else {
2750
		set_bit(BTRFS_ROOT_TRACK_DIRTY, &uuid_root->state);
2751
		fs_info->uuid_root = uuid_root;
2752 2753 2754
		create_uuid_tree = false;
		check_uuid_tree =
		    generation != btrfs_super_uuid_tree_generation(disk_super);
2755 2756
	}

2757 2758 2759
	fs_info->generation = generation;
	fs_info->last_trans_committed = generation;

2760 2761
	ret = btrfs_recover_balance(fs_info);
	if (ret) {
2762
		printk(KERN_WARNING "BTRFS: failed to recover balance\n");
2763 2764 2765
		goto fail_block_groups;
	}

2766 2767
	ret = btrfs_init_dev_stats(fs_info);
	if (ret) {
2768
		printk(KERN_ERR "BTRFS: failed to init dev_stats: %d\n",
2769 2770 2771 2772
		       ret);
		goto fail_block_groups;
	}

2773 2774
	ret = btrfs_init_dev_replace(fs_info);
	if (ret) {
2775
		pr_err("BTRFS: failed to init dev_replace: %d\n", ret);
2776 2777 2778 2779 2780
		goto fail_block_groups;
	}

	btrfs_close_extra_devices(fs_info, fs_devices, 1);

2781
	ret = btrfs_sysfs_add_one(fs_info);
2782
	if (ret) {
2783
		pr_err("BTRFS: failed to init sysfs interface: %d\n", ret);
2784 2785 2786 2787 2788
		goto fail_block_groups;
	}

	ret = btrfs_init_space_info(fs_info);
	if (ret) {
2789
		printk(KERN_ERR "BTRFS: Failed to initial space info: %d\n", ret);
2790
		goto fail_sysfs;
2791 2792
	}

2793 2794
	ret = btrfs_read_block_groups(extent_root);
	if (ret) {
2795
		printk(KERN_ERR "BTRFS: Failed to read block groups: %d\n", ret);
2796
		goto fail_sysfs;
2797
	}
2798 2799
	fs_info->num_tolerated_disk_barrier_failures =
		btrfs_calc_num_tolerated_disk_barrier_failures(fs_info);
2800 2801 2802
	if (fs_info->fs_devices->missing_devices >
	     fs_info->num_tolerated_disk_barrier_failures &&
	    !(sb->s_flags & MS_RDONLY)) {
2803 2804
		printk(KERN_WARNING "BTRFS: "
			"too many missing devices, writeable mount is not allowed\n");
2805
		goto fail_sysfs;
2806
	}
C
Chris Mason 已提交
2807

2808 2809
	fs_info->cleaner_kthread = kthread_run(cleaner_kthread, tree_root,
					       "btrfs-cleaner");
2810
	if (IS_ERR(fs_info->cleaner_kthread))
2811
		goto fail_sysfs;
2812 2813 2814 2815

	fs_info->transaction_kthread = kthread_run(transaction_kthread,
						   tree_root,
						   "btrfs-transaction");
2816
	if (IS_ERR(fs_info->transaction_kthread))
2817
		goto fail_cleaner;
2818

C
Chris Mason 已提交
2819 2820 2821
	if (!btrfs_test_opt(tree_root, SSD) &&
	    !btrfs_test_opt(tree_root, NOSSD) &&
	    !fs_info->fs_devices->rotating) {
2822
		printk(KERN_INFO "BTRFS: detected SSD devices, enabling SSD "
C
Chris Mason 已提交
2823 2824 2825 2826
		       "mode\n");
		btrfs_set_opt(fs_info->mount_opt, SSD);
	}

2827 2828 2829 2830
	/* Set the real inode map cache flag */
	if (btrfs_test_opt(tree_root, CHANGE_INODE_CACHE))
		btrfs_set_opt(tree_root->fs_info->mount_opt, INODE_MAP_CACHE);

2831 2832 2833 2834 2835 2836 2837 2838
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
	if (btrfs_test_opt(tree_root, CHECK_INTEGRITY)) {
		ret = btrfsic_mount(tree_root, fs_devices,
				    btrfs_test_opt(tree_root,
					CHECK_INTEGRITY_INCLUDING_EXTENT_DATA) ?
				    1 : 0,
				    fs_info->check_integrity_print_mask);
		if (ret)
2839
			printk(KERN_WARNING "BTRFS: failed to initialize"
2840 2841 2842
			       " integrity check module %s\n", sb->s_id);
	}
#endif
2843 2844 2845
	ret = btrfs_read_qgroup_config(fs_info);
	if (ret)
		goto fail_trans_kthread;
2846

L
liubo 已提交
2847
	/* do not make disk changes in broken FS */
2848
	if (btrfs_super_log_root(disk_super) != 0) {
2849 2850
		u64 bytenr = btrfs_super_log_root(disk_super);

2851
		if (fs_devices->rw_devices == 0) {
2852
			printk(KERN_WARNING "BTRFS: log replay required "
C
Chris Mason 已提交
2853
			       "on RO media\n");
2854
			err = -EIO;
2855
			goto fail_qgroup;
2856
		}
2857 2858 2859
		blocksize =
		     btrfs_level_size(tree_root,
				      btrfs_super_log_root_level(disk_super));
C
Chris Mason 已提交
2860

A
Al Viro 已提交
2861
		log_tree_root = btrfs_alloc_root(fs_info);
2862 2863
		if (!log_tree_root) {
			err = -ENOMEM;
2864
			goto fail_qgroup;
2865
		}
2866 2867 2868 2869 2870

		__setup_root(nodesize, leafsize, sectorsize, stripesize,
			     log_tree_root, fs_info, BTRFS_TREE_LOG_OBJECTID);

		log_tree_root->node = read_tree_block(tree_root, bytenr,
2871 2872
						      blocksize,
						      generation + 1);
2873 2874
		if (!log_tree_root->node ||
		    !extent_buffer_uptodate(log_tree_root->node)) {
2875
			printk(KERN_ERR "BTRFS: failed to read log tree\n");
2876 2877
			free_extent_buffer(log_tree_root->node);
			kfree(log_tree_root);
2878
			goto fail_qgroup;
2879
		}
2880
		/* returns with log_tree_root freed on success */
2881
		ret = btrfs_recover_log_trees(log_tree_root);
2882 2883 2884 2885 2886
		if (ret) {
			btrfs_error(tree_root->fs_info, ret,
				    "Failed to recover log tree");
			free_extent_buffer(log_tree_root->node);
			kfree(log_tree_root);
2887
			goto fail_qgroup;
2888
		}
2889 2890

		if (sb->s_flags & MS_RDONLY) {
2891 2892
			ret = btrfs_commit_super(tree_root);
			if (ret)
2893
				goto fail_qgroup;
2894
		}
2895
	}
Z
Zheng Yan 已提交
2896

2897
	ret = btrfs_find_orphan_roots(tree_root);
2898
	if (ret)
2899
		goto fail_qgroup;
2900

2901
	if (!(sb->s_flags & MS_RDONLY)) {
2902
		ret = btrfs_cleanup_fs_roots(fs_info);
2903
		if (ret)
2904
			goto fail_qgroup;
2905

2906
		mutex_lock(&fs_info->cleaner_mutex);
2907
		ret = btrfs_recover_relocation(tree_root);
2908
		mutex_unlock(&fs_info->cleaner_mutex);
2909 2910
		if (ret < 0) {
			printk(KERN_WARNING
2911
			       "BTRFS: failed to recover relocation\n");
2912
			err = -EINVAL;
2913
			goto fail_qgroup;
2914
		}
2915
	}
Z
Zheng Yan 已提交
2916

2917 2918
	location.objectid = BTRFS_FS_TREE_OBJECTID;
	location.type = BTRFS_ROOT_ITEM_KEY;
2919
	location.offset = 0;
2920 2921

	fs_info->fs_root = btrfs_read_fs_root_no_name(fs_info, &location);
2922 2923
	if (IS_ERR(fs_info->fs_root)) {
		err = PTR_ERR(fs_info->fs_root);
2924
		goto fail_qgroup;
2925
	}
C
Chris Mason 已提交
2926

2927 2928
	if (sb->s_flags & MS_RDONLY)
		return 0;
I
Ilya Dryomov 已提交
2929

2930 2931 2932
	down_read(&fs_info->cleanup_work_sem);
	if ((ret = btrfs_orphan_cleanup(fs_info->fs_root)) ||
	    (ret = btrfs_orphan_cleanup(fs_info->tree_root))) {
2933
		up_read(&fs_info->cleanup_work_sem);
2934 2935 2936 2937
		close_ctree(tree_root);
		return ret;
	}
	up_read(&fs_info->cleanup_work_sem);
I
Ilya Dryomov 已提交
2938

2939 2940
	ret = btrfs_resume_balance_async(fs_info);
	if (ret) {
2941
		printk(KERN_WARNING "BTRFS: failed to resume balance\n");
2942 2943
		close_ctree(tree_root);
		return ret;
2944 2945
	}

2946 2947
	ret = btrfs_resume_dev_replace_async(fs_info);
	if (ret) {
2948
		pr_warn("BTRFS: failed to resume dev_replace\n");
2949 2950 2951 2952
		close_ctree(tree_root);
		return ret;
	}

2953 2954
	btrfs_qgroup_rescan_resume(fs_info);

2955
	if (create_uuid_tree) {
2956
		pr_info("BTRFS: creating UUID tree\n");
2957 2958
		ret = btrfs_create_uuid_tree(fs_info);
		if (ret) {
2959
			pr_warn("BTRFS: failed to create the UUID tree %d\n",
2960 2961 2962 2963
				ret);
			close_ctree(tree_root);
			return ret;
		}
2964 2965
	} else if (check_uuid_tree ||
		   btrfs_test_opt(tree_root, RESCAN_UUID_TREE)) {
2966
		pr_info("BTRFS: checking UUID tree\n");
2967 2968
		ret = btrfs_check_uuid_tree(fs_info);
		if (ret) {
2969
			pr_warn("BTRFS: failed to check the UUID tree %d\n",
2970 2971 2972 2973 2974 2975
				ret);
			close_ctree(tree_root);
			return ret;
		}
	} else {
		fs_info->update_uuid_tree_gen = 1;
2976 2977
	}

A
Al Viro 已提交
2978
	return 0;
C
Chris Mason 已提交
2979

2980 2981
fail_qgroup:
	btrfs_free_qgroup_config(fs_info);
2982 2983
fail_trans_kthread:
	kthread_stop(fs_info->transaction_kthread);
J
Josef Bacik 已提交
2984
	btrfs_cleanup_transaction(fs_info->tree_root);
2985
	btrfs_free_fs_roots(fs_info);
2986
fail_cleaner:
2987
	kthread_stop(fs_info->cleaner_kthread);
2988 2989 2990 2991 2992 2993 2994

	/*
	 * make sure we're done with the btree inode before we stop our
	 * kthreads
	 */
	filemap_write_and_wait(fs_info->btree_inode->i_mapping);

2995 2996 2997
fail_sysfs:
	btrfs_sysfs_remove_one(fs_info);

2998
fail_block_groups:
J
Josef Bacik 已提交
2999
	btrfs_put_block_group_cache(fs_info);
3000
	btrfs_free_block_groups(fs_info);
C
Chris Mason 已提交
3001 3002 3003

fail_tree_roots:
	free_root_pointers(fs_info, 1);
3004
	invalidate_inode_pages2(fs_info->btree_inode->i_mapping);
C
Chris Mason 已提交
3005

C
Chris Mason 已提交
3006
fail_sb_buffer:
L
Liu Bo 已提交
3007
	btrfs_stop_all_workers(fs_info);
3008
fail_alloc:
3009
fail_iput:
3010 3011
	btrfs_mapping_tree_free(&fs_info->mapping_tree);

3012
	iput(fs_info->btree_inode);
3013 3014
fail_bio_counter:
	percpu_counter_destroy(&fs_info->bio_counter);
3015 3016
fail_delalloc_bytes:
	percpu_counter_destroy(&fs_info->delalloc_bytes);
3017 3018
fail_dirty_metadata_bytes:
	percpu_counter_destroy(&fs_info->dirty_metadata_bytes);
3019
fail_bdi:
3020
	bdi_destroy(&fs_info->bdi);
3021 3022
fail_srcu:
	cleanup_srcu_struct(&fs_info->subvol_srcu);
3023
fail:
D
David Woodhouse 已提交
3024
	btrfs_free_stripe_hash_table(fs_info);
3025
	btrfs_close_devices(fs_info->fs_devices);
A
Al Viro 已提交
3026
	return err;
C
Chris Mason 已提交
3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044

recovery_tree_root:
	if (!btrfs_test_opt(tree_root, RECOVERY))
		goto fail_tree_roots;

	free_root_pointers(fs_info, 0);

	/* don't use the log in recovery mode, it won't be valid */
	btrfs_set_super_log_root(disk_super, 0);

	/* we can't trust the free space cache either */
	btrfs_set_opt(fs_info->mount_opt, CLEAR_CACHE);

	ret = next_root_backup(fs_info, fs_info->super_copy,
			       &num_backups_tried, &backup_index);
	if (ret == -1)
		goto fail_block_groups;
	goto retry_root_backup;
3045 3046
}

3047 3048 3049 3050 3051
static void btrfs_end_buffer_write_sync(struct buffer_head *bh, int uptodate)
{
	if (uptodate) {
		set_buffer_uptodate(bh);
	} else {
3052 3053 3054
		struct btrfs_device *device = (struct btrfs_device *)
			bh->b_private;

3055
		printk_ratelimited_in_rcu(KERN_WARNING "BTRFS: lost page write due to "
3056 3057
					  "I/O error on %s\n",
					  rcu_str_deref(device->name));
3058 3059 3060
		/* note, we dont' set_buffer_write_io_error because we have
		 * our own ways of dealing with the IO errors
		 */
3061
		clear_buffer_uptodate(bh);
3062
		btrfs_dev_stat_inc_and_print(device, BTRFS_DEV_STAT_WRITE_ERRS);
3063 3064 3065 3066 3067
	}
	unlock_buffer(bh);
	put_bh(bh);
}

Y
Yan Zheng 已提交
3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083
struct buffer_head *btrfs_read_dev_super(struct block_device *bdev)
{
	struct buffer_head *bh;
	struct buffer_head *latest = NULL;
	struct btrfs_super_block *super;
	int i;
	u64 transid = 0;
	u64 bytenr;

	/* we would like to check all the supers, but that would make
	 * a btrfs mount succeed after a mkfs from a different FS.
	 * So, we need to add a special mount option to scan for
	 * later supers, using BTRFS_SUPER_MIRROR_MAX instead
	 */
	for (i = 0; i < 1; i++) {
		bytenr = btrfs_sb_offset(i);
3084 3085
		if (bytenr + BTRFS_SUPER_INFO_SIZE >=
					i_size_read(bdev->bd_inode))
Y
Yan Zheng 已提交
3086
			break;
3087 3088
		bh = __bread(bdev, bytenr / 4096,
					BTRFS_SUPER_INFO_SIZE);
Y
Yan Zheng 已提交
3089 3090 3091 3092 3093
		if (!bh)
			continue;

		super = (struct btrfs_super_block *)bh->b_data;
		if (btrfs_super_bytenr(super) != bytenr ||
3094
		    btrfs_super_magic(super) != BTRFS_MAGIC) {
Y
Yan Zheng 已提交
3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109
			brelse(bh);
			continue;
		}

		if (!latest || btrfs_super_generation(super) > transid) {
			brelse(latest);
			latest = bh;
			transid = btrfs_super_generation(super);
		} else {
			brelse(bh);
		}
	}
	return latest;
}

3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120
/*
 * this should be called twice, once with wait == 0 and
 * once with wait == 1.  When wait == 0 is done, all the buffer heads
 * we write are pinned.
 *
 * They are released when wait == 1 is done.
 * max_mirrors must be the same for both runs, and it indicates how
 * many supers on this one device should be written.
 *
 * max_mirrors == 0 means to write them all.
 */
Y
Yan Zheng 已提交
3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142
static int write_dev_supers(struct btrfs_device *device,
			    struct btrfs_super_block *sb,
			    int do_barriers, int wait, int max_mirrors)
{
	struct buffer_head *bh;
	int i;
	int ret;
	int errors = 0;
	u32 crc;
	u64 bytenr;

	if (max_mirrors == 0)
		max_mirrors = BTRFS_SUPER_MIRROR_MAX;

	for (i = 0; i < max_mirrors; i++) {
		bytenr = btrfs_sb_offset(i);
		if (bytenr + BTRFS_SUPER_INFO_SIZE >= device->total_bytes)
			break;

		if (wait) {
			bh = __find_get_block(device->bdev, bytenr / 4096,
					      BTRFS_SUPER_INFO_SIZE);
3143 3144 3145 3146
			if (!bh) {
				errors++;
				continue;
			}
Y
Yan Zheng 已提交
3147
			wait_on_buffer(bh);
3148 3149 3150 3151 3152 3153 3154 3155 3156
			if (!buffer_uptodate(bh))
				errors++;

			/* drop our reference */
			brelse(bh);

			/* drop the reference from the wait == 0 run */
			brelse(bh);
			continue;
Y
Yan Zheng 已提交
3157 3158 3159 3160
		} else {
			btrfs_set_super_bytenr(sb, bytenr);

			crc = ~(u32)0;
3161
			crc = btrfs_csum_data((char *)sb +
Y
Yan Zheng 已提交
3162 3163 3164 3165 3166
					      BTRFS_CSUM_SIZE, crc,
					      BTRFS_SUPER_INFO_SIZE -
					      BTRFS_CSUM_SIZE);
			btrfs_csum_final(crc, sb->csum);

3167 3168 3169 3170
			/*
			 * one reference for us, and we leave it for the
			 * caller
			 */
Y
Yan Zheng 已提交
3171 3172
			bh = __getblk(device->bdev, bytenr / 4096,
				      BTRFS_SUPER_INFO_SIZE);
3173
			if (!bh) {
3174
				printk(KERN_ERR "BTRFS: couldn't get super "
3175 3176 3177 3178 3179
				       "buffer head for bytenr %Lu\n", bytenr);
				errors++;
				continue;
			}

Y
Yan Zheng 已提交
3180 3181
			memcpy(bh->b_data, sb, BTRFS_SUPER_INFO_SIZE);

3182
			/* one reference for submit_bh */
Y
Yan Zheng 已提交
3183
			get_bh(bh);
3184 3185

			set_buffer_uptodate(bh);
Y
Yan Zheng 已提交
3186 3187
			lock_buffer(bh);
			bh->b_end_io = btrfs_end_buffer_write_sync;
3188
			bh->b_private = device;
Y
Yan Zheng 已提交
3189 3190
		}

C
Chris Mason 已提交
3191 3192 3193 3194
		/*
		 * we fua the first super.  The others we allow
		 * to go down lazy.
		 */
3195 3196 3197 3198
		if (i == 0)
			ret = btrfsic_submit_bh(WRITE_FUA, bh);
		else
			ret = btrfsic_submit_bh(WRITE_SYNC, bh);
3199
		if (ret)
Y
Yan Zheng 已提交
3200 3201 3202 3203 3204
			errors++;
	}
	return errors < i ? 0 : -1;
}

C
Chris Mason 已提交
3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243
/*
 * endio for the write_dev_flush, this will wake anyone waiting
 * for the barrier when it is done
 */
static void btrfs_end_empty_barrier(struct bio *bio, int err)
{
	if (err) {
		if (err == -EOPNOTSUPP)
			set_bit(BIO_EOPNOTSUPP, &bio->bi_flags);
		clear_bit(BIO_UPTODATE, &bio->bi_flags);
	}
	if (bio->bi_private)
		complete(bio->bi_private);
	bio_put(bio);
}

/*
 * trigger flushes for one the devices.  If you pass wait == 0, the flushes are
 * sent down.  With wait == 1, it waits for the previous flush.
 *
 * any device where the flush fails with eopnotsupp are flagged as not-barrier
 * capable
 */
static int write_dev_flush(struct btrfs_device *device, int wait)
{
	struct bio *bio;
	int ret = 0;

	if (device->nobarriers)
		return 0;

	if (wait) {
		bio = device->flush_bio;
		if (!bio)
			return 0;

		wait_for_completion(&device->flush_wait);

		if (bio_flagged(bio, BIO_EOPNOTSUPP)) {
3244
			printk_in_rcu("BTRFS: disabling barriers on dev %s\n",
3245
				      rcu_str_deref(device->name));
C
Chris Mason 已提交
3246
			device->nobarriers = 1;
3247
		} else if (!bio_flagged(bio, BIO_UPTODATE)) {
C
Chris Mason 已提交
3248
			ret = -EIO;
3249 3250
			btrfs_dev_stat_inc_and_print(device,
				BTRFS_DEV_STAT_FLUSH_ERRS);
C
Chris Mason 已提交
3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263
		}

		/* drop the reference from the wait == 0 run */
		bio_put(bio);
		device->flush_bio = NULL;

		return ret;
	}

	/*
	 * one reference for us, and we leave it for the
	 * caller
	 */
3264
	device->flush_bio = NULL;
3265
	bio = btrfs_io_bio_alloc(GFP_NOFS, 0);
C
Chris Mason 已提交
3266 3267 3268 3269 3270 3271 3272 3273 3274 3275
	if (!bio)
		return -ENOMEM;

	bio->bi_end_io = btrfs_end_empty_barrier;
	bio->bi_bdev = device->bdev;
	init_completion(&device->flush_wait);
	bio->bi_private = &device->flush_wait;
	device->flush_bio = bio;

	bio_get(bio);
3276
	btrfsic_submit_bio(WRITE_FLUSH, bio);
C
Chris Mason 已提交
3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288

	return 0;
}

/*
 * send an empty flush down to each device in parallel,
 * then wait for them
 */
static int barrier_all_devices(struct btrfs_fs_info *info)
{
	struct list_head *head;
	struct btrfs_device *dev;
3289 3290
	int errors_send = 0;
	int errors_wait = 0;
C
Chris Mason 已提交
3291 3292 3293 3294 3295
	int ret;

	/* send down all the barriers */
	head = &info->fs_devices->devices;
	list_for_each_entry_rcu(dev, head, dev_list) {
3296 3297
		if (dev->missing)
			continue;
C
Chris Mason 已提交
3298
		if (!dev->bdev) {
3299
			errors_send++;
C
Chris Mason 已提交
3300 3301 3302 3303 3304 3305 3306
			continue;
		}
		if (!dev->in_fs_metadata || !dev->writeable)
			continue;

		ret = write_dev_flush(dev, 0);
		if (ret)
3307
			errors_send++;
C
Chris Mason 已提交
3308 3309 3310 3311
	}

	/* wait for all the barriers */
	list_for_each_entry_rcu(dev, head, dev_list) {
3312 3313
		if (dev->missing)
			continue;
C
Chris Mason 已提交
3314
		if (!dev->bdev) {
3315
			errors_wait++;
C
Chris Mason 已提交
3316 3317 3318 3319 3320 3321 3322
			continue;
		}
		if (!dev->in_fs_metadata || !dev->writeable)
			continue;

		ret = write_dev_flush(dev, 1);
		if (ret)
3323
			errors_wait++;
C
Chris Mason 已提交
3324
	}
3325 3326
	if (errors_send > info->num_tolerated_disk_barrier_failures ||
	    errors_wait > info->num_tolerated_disk_barrier_failures)
C
Chris Mason 已提交
3327 3328 3329 3330
		return -EIO;
	return 0;
}

3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390
int btrfs_calc_num_tolerated_disk_barrier_failures(
	struct btrfs_fs_info *fs_info)
{
	struct btrfs_ioctl_space_info space;
	struct btrfs_space_info *sinfo;
	u64 types[] = {BTRFS_BLOCK_GROUP_DATA,
		       BTRFS_BLOCK_GROUP_SYSTEM,
		       BTRFS_BLOCK_GROUP_METADATA,
		       BTRFS_BLOCK_GROUP_DATA | BTRFS_BLOCK_GROUP_METADATA};
	int num_types = 4;
	int i;
	int c;
	int num_tolerated_disk_barrier_failures =
		(int)fs_info->fs_devices->num_devices;

	for (i = 0; i < num_types; i++) {
		struct btrfs_space_info *tmp;

		sinfo = NULL;
		rcu_read_lock();
		list_for_each_entry_rcu(tmp, &fs_info->space_info, list) {
			if (tmp->flags == types[i]) {
				sinfo = tmp;
				break;
			}
		}
		rcu_read_unlock();

		if (!sinfo)
			continue;

		down_read(&sinfo->groups_sem);
		for (c = 0; c < BTRFS_NR_RAID_TYPES; c++) {
			if (!list_empty(&sinfo->block_groups[c])) {
				u64 flags;

				btrfs_get_block_group_info(
					&sinfo->block_groups[c], &space);
				if (space.total_bytes == 0 ||
				    space.used_bytes == 0)
					continue;
				flags = space.flags;
				/*
				 * return
				 * 0: if dup, single or RAID0 is configured for
				 *    any of metadata, system or data, else
				 * 1: if RAID5 is configured, or if RAID1 or
				 *    RAID10 is configured and only two mirrors
				 *    are used, else
				 * 2: if RAID6 is configured, else
				 * num_mirrors - 1: if RAID1 or RAID10 is
				 *                  configured and more than
				 *                  2 mirrors are used.
				 */
				if (num_tolerated_disk_barrier_failures > 0 &&
				    ((flags & (BTRFS_BLOCK_GROUP_DUP |
					       BTRFS_BLOCK_GROUP_RAID0)) ||
				     ((flags & BTRFS_BLOCK_GROUP_PROFILE_MASK)
				      == 0)))
					num_tolerated_disk_barrier_failures = 0;
D
David Woodhouse 已提交
3391 3392 3393 3394 3395 3396
				else if (num_tolerated_disk_barrier_failures > 1) {
					if (flags & (BTRFS_BLOCK_GROUP_RAID1 |
					    BTRFS_BLOCK_GROUP_RAID5 |
					    BTRFS_BLOCK_GROUP_RAID10)) {
						num_tolerated_disk_barrier_failures = 1;
					} else if (flags &
3397
						   BTRFS_BLOCK_GROUP_RAID6) {
D
David Woodhouse 已提交
3398 3399 3400
						num_tolerated_disk_barrier_failures = 2;
					}
				}
3401 3402 3403 3404 3405 3406 3407 3408
			}
		}
		up_read(&sinfo->groups_sem);
	}

	return num_tolerated_disk_barrier_failures;
}

3409
static int write_all_supers(struct btrfs_root *root, int max_mirrors)
3410
{
3411
	struct list_head *head;
3412
	struct btrfs_device *dev;
3413
	struct btrfs_super_block *sb;
3414 3415 3416
	struct btrfs_dev_item *dev_item;
	int ret;
	int do_barriers;
3417 3418
	int max_errors;
	int total_errors = 0;
3419
	u64 flags;
3420 3421

	do_barriers = !btrfs_test_opt(root, NOBARRIER);
C
Chris Mason 已提交
3422
	backup_super_roots(root->fs_info);
3423

3424
	sb = root->fs_info->super_for_commit;
3425
	dev_item = &sb->dev_item;
3426

3427
	mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
3428
	head = &root->fs_info->fs_devices->devices;
3429
	max_errors = btrfs_super_num_devices(root->fs_info->super_copy) - 1;
C
Chris Mason 已提交
3430

3431 3432 3433 3434 3435 3436 3437 3438 3439 3440
	if (do_barriers) {
		ret = barrier_all_devices(root->fs_info);
		if (ret) {
			mutex_unlock(
				&root->fs_info->fs_devices->device_list_mutex);
			btrfs_error(root->fs_info, ret,
				    "errors while submitting device barriers.");
			return ret;
		}
	}
C
Chris Mason 已提交
3441

3442
	list_for_each_entry_rcu(dev, head, dev_list) {
3443 3444 3445 3446
		if (!dev->bdev) {
			total_errors++;
			continue;
		}
Y
Yan Zheng 已提交
3447
		if (!dev->in_fs_metadata || !dev->writeable)
3448 3449
			continue;

Y
Yan Zheng 已提交
3450
		btrfs_set_stack_device_generation(dev_item, 0);
3451 3452 3453 3454 3455 3456 3457 3458
		btrfs_set_stack_device_type(dev_item, dev->type);
		btrfs_set_stack_device_id(dev_item, dev->devid);
		btrfs_set_stack_device_total_bytes(dev_item, dev->total_bytes);
		btrfs_set_stack_device_bytes_used(dev_item, dev->bytes_used);
		btrfs_set_stack_device_io_align(dev_item, dev->io_align);
		btrfs_set_stack_device_io_width(dev_item, dev->io_width);
		btrfs_set_stack_device_sector_size(dev_item, dev->sector_size);
		memcpy(dev_item->uuid, dev->uuid, BTRFS_UUID_SIZE);
Y
Yan Zheng 已提交
3459
		memcpy(dev_item->fsid, dev->fs_devices->fsid, BTRFS_UUID_SIZE);
Y
Yan Zheng 已提交
3460

3461 3462 3463
		flags = btrfs_super_flags(sb);
		btrfs_set_super_flags(sb, flags | BTRFS_HEADER_FLAG_WRITTEN);

Y
Yan Zheng 已提交
3464
		ret = write_dev_supers(dev, sb, do_barriers, 0, max_mirrors);
3465 3466
		if (ret)
			total_errors++;
3467
	}
3468
	if (total_errors > max_errors) {
3469
		btrfs_err(root->fs_info, "%d errors while writing supers",
C
Chris Mason 已提交
3470
		       total_errors);
3471
		mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
3472

3473 3474 3475 3476
		/* FUA is masked off if unsupported and can't be the reason */
		btrfs_error(root->fs_info, -EIO,
			    "%d errors while writing supers", total_errors);
		return -EIO;
3477
	}
3478

Y
Yan Zheng 已提交
3479
	total_errors = 0;
3480
	list_for_each_entry_rcu(dev, head, dev_list) {
3481 3482
		if (!dev->bdev)
			continue;
Y
Yan Zheng 已提交
3483
		if (!dev->in_fs_metadata || !dev->writeable)
3484 3485
			continue;

Y
Yan Zheng 已提交
3486 3487 3488
		ret = write_dev_supers(dev, sb, do_barriers, 1, max_mirrors);
		if (ret)
			total_errors++;
3489
	}
3490
	mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
3491
	if (total_errors > max_errors) {
3492 3493 3494
		btrfs_error(root->fs_info, -EIO,
			    "%d errors while writing supers", total_errors);
		return -EIO;
3495
	}
3496 3497 3498
	return 0;
}

Y
Yan Zheng 已提交
3499 3500
int write_ctree_super(struct btrfs_trans_handle *trans,
		      struct btrfs_root *root, int max_mirrors)
3501
{
3502
	return write_all_supers(root, max_mirrors);
C
Chris Mason 已提交
3503 3504
}

3505 3506 3507
/* Drop a fs root from the radix tree and free it. */
void btrfs_drop_and_free_fs_root(struct btrfs_fs_info *fs_info,
				  struct btrfs_root *root)
C
Chris Mason 已提交
3508
{
3509
	spin_lock(&fs_info->fs_roots_radix_lock);
C
Chris Mason 已提交
3510 3511
	radix_tree_delete(&fs_info->fs_roots_radix,
			  (unsigned long)root->root_key.objectid);
3512
	spin_unlock(&fs_info->fs_roots_radix_lock);
3513 3514 3515 3516

	if (btrfs_root_refs(&root->root_item) == 0)
		synchronize_srcu(&fs_info->subvol_srcu);

3517
	if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state))
L
Liu Bo 已提交
3518 3519
		btrfs_free_log(NULL, root);

3520 3521 3522 3523
	if (root->free_ino_pinned)
		__btrfs_remove_free_space_cache(root->free_ino_pinned);
	if (root->free_ino_ctl)
		__btrfs_remove_free_space_cache(root->free_ino_ctl);
3524 3525 3526 3527 3528
	free_fs_root(root);
}

static void free_fs_root(struct btrfs_root *root)
{
3529
	iput(root->cache_inode);
3530
	WARN_ON(!RB_EMPTY_ROOT(&root->inode_tree));
3531 3532
	btrfs_free_block_rsv(root, root->orphan_block_rsv);
	root->orphan_block_rsv = NULL;
3533 3534
	if (root->anon_dev)
		free_anon_bdev(root->anon_dev);
3535 3536
	if (root->subv_writers)
		btrfs_free_subvolume_writers(root->subv_writers);
3537 3538
	free_extent_buffer(root->node);
	free_extent_buffer(root->commit_root);
3539 3540
	kfree(root->free_ino_ctl);
	kfree(root->free_ino_pinned);
C
Chris Mason 已提交
3541
	kfree(root->name);
3542
	btrfs_put_fs_root(root);
C
Chris Mason 已提交
3543 3544
}

3545 3546 3547
void btrfs_free_fs_root(struct btrfs_root *root)
{
	free_fs_root(root);
C
Chris Mason 已提交
3548 3549
}

Y
Yan Zheng 已提交
3550
int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info)
C
Chris Mason 已提交
3551
{
Y
Yan Zheng 已提交
3552 3553
	u64 root_objectid = 0;
	struct btrfs_root *gang[8];
3554 3555 3556 3557
	int i = 0;
	int err = 0;
	unsigned int ret = 0;
	int index;
3558

Y
Yan Zheng 已提交
3559
	while (1) {
3560
		index = srcu_read_lock(&fs_info->subvol_srcu);
Y
Yan Zheng 已提交
3561 3562 3563
		ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
					     (void **)gang, root_objectid,
					     ARRAY_SIZE(gang));
3564 3565
		if (!ret) {
			srcu_read_unlock(&fs_info->subvol_srcu, index);
Y
Yan Zheng 已提交
3566
			break;
3567
		}
3568
		root_objectid = gang[ret - 1]->root_key.objectid + 1;
3569

Y
Yan Zheng 已提交
3570
		for (i = 0; i < ret; i++) {
3571 3572 3573 3574 3575 3576 3577 3578 3579
			/* Avoid to grab roots in dead_roots */
			if (btrfs_root_refs(&gang[i]->root_item) == 0) {
				gang[i] = NULL;
				continue;
			}
			/* grab all the search result for later use */
			gang[i] = btrfs_grab_fs_root(gang[i]);
		}
		srcu_read_unlock(&fs_info->subvol_srcu, index);
3580

3581 3582 3583
		for (i = 0; i < ret; i++) {
			if (!gang[i])
				continue;
Y
Yan Zheng 已提交
3584
			root_objectid = gang[i]->root_key.objectid;
3585 3586
			err = btrfs_orphan_cleanup(gang[i]);
			if (err)
3587 3588
				break;
			btrfs_put_fs_root(gang[i]);
Y
Yan Zheng 已提交
3589 3590 3591
		}
		root_objectid++;
	}
3592 3593 3594 3595 3596 3597 3598

	/* release the uncleaned roots due to error */
	for (; i < ret; i++) {
		if (gang[i])
			btrfs_put_fs_root(gang[i]);
	}
	return err;
Y
Yan Zheng 已提交
3599
}
3600

Y
Yan Zheng 已提交
3601 3602 3603
int btrfs_commit_super(struct btrfs_root *root)
{
	struct btrfs_trans_handle *trans;
3604

Y
Yan Zheng 已提交
3605
	mutex_lock(&root->fs_info->cleaner_mutex);
Y
Yan, Zheng 已提交
3606
	btrfs_run_delayed_iputs(root);
Y
Yan Zheng 已提交
3607
	mutex_unlock(&root->fs_info->cleaner_mutex);
D
David Sterba 已提交
3608
	wake_up_process(root->fs_info->cleaner_kthread);
3609 3610 3611 3612 3613

	/* wait until ongoing cleanup work done */
	down_write(&root->fs_info->cleanup_work_sem);
	up_write(&root->fs_info->cleanup_work_sem);

3614
	trans = btrfs_join_transaction(root);
3615 3616
	if (IS_ERR(trans))
		return PTR_ERR(trans);
3617
	return btrfs_commit_transaction(trans, root);
Y
Yan Zheng 已提交
3618 3619 3620 3621 3622 3623 3624 3625 3626 3627
}

int close_ctree(struct btrfs_root *root)
{
	struct btrfs_fs_info *fs_info = root->fs_info;
	int ret;

	fs_info->closing = 1;
	smp_mb();

S
Stefan Behrens 已提交
3628 3629 3630 3631 3632
	/* wait for the uuid_scan task to finish */
	down(&fs_info->uuid_tree_rescan_sem);
	/* avoid complains from lockdep et al., set sem back to initial state */
	up(&fs_info->uuid_tree_rescan_sem);

3633
	/* pause restriper - we want to resume on mount */
3634
	btrfs_pause_balance(fs_info);
3635

3636 3637
	btrfs_dev_replace_suspend_for_unmount(fs_info);

3638
	btrfs_scrub_cancel(fs_info);
C
Chris Mason 已提交
3639 3640 3641 3642 3643 3644

	/* wait for any defraggers to finish */
	wait_event(fs_info->transaction_wait,
		   (atomic_read(&fs_info->defrag_running) == 0));

	/* clear out the rbtree of defraggable inodes */
3645
	btrfs_cleanup_defrag_inodes(fs_info);
C
Chris Mason 已提交
3646

3647 3648
	cancel_work_sync(&fs_info->async_reclaim_work);

Y
Yan Zheng 已提交
3649
	if (!(fs_info->sb->s_flags & MS_RDONLY)) {
L
liubo 已提交
3650 3651
		ret = btrfs_commit_super(root);
		if (ret)
3652
			btrfs_err(root->fs_info, "commit super ret %d", ret);
L
liubo 已提交
3653 3654
	}

3655
	if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state))
3656
		btrfs_error_commit_super(root);
3657

A
Al Viro 已提交
3658 3659
	kthread_stop(fs_info->transaction_kthread);
	kthread_stop(fs_info->cleaner_kthread);
3660

3661 3662 3663
	fs_info->closing = 2;
	smp_mb();

3664 3665
	btrfs_free_qgroup_config(root->fs_info);

3666
	if (percpu_counter_sum(&fs_info->delalloc_bytes)) {
3667
		btrfs_info(root->fs_info, "at unmount delalloc count %lld",
3668
		       percpu_counter_sum(&fs_info->delalloc_bytes));
C
Chris Mason 已提交
3669
	}
3670

3671 3672
	btrfs_sysfs_remove_one(fs_info);

3673
	btrfs_free_fs_roots(fs_info);
3674

3675 3676
	btrfs_put_block_group_cache(fs_info);

3677 3678
	btrfs_free_block_groups(fs_info);

3679 3680 3681 3682 3683
	/*
	 * we must make sure there is not any read request to
	 * submit after we stopping all workers.
	 */
	invalidate_inode_pages2(fs_info->btree_inode->i_mapping);
3684 3685
	btrfs_stop_all_workers(fs_info);

3686
	free_root_pointers(fs_info, 1);
3687

3688
	iput(fs_info->btree_inode);
3689

3690 3691 3692 3693 3694
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
	if (btrfs_test_opt(root, CHECK_INTEGRITY))
		btrfsic_unmount(root, fs_info->fs_devices);
#endif

3695
	btrfs_close_devices(fs_info->fs_devices);
3696
	btrfs_mapping_tree_free(&fs_info->mapping_tree);
3697

3698
	percpu_counter_destroy(&fs_info->dirty_metadata_bytes);
3699
	percpu_counter_destroy(&fs_info->delalloc_bytes);
3700
	percpu_counter_destroy(&fs_info->bio_counter);
C
Chris Mason 已提交
3701
	bdi_destroy(&fs_info->bdi);
3702
	cleanup_srcu_struct(&fs_info->subvol_srcu);
3703

D
David Woodhouse 已提交
3704 3705
	btrfs_free_stripe_hash_table(fs_info);

3706 3707 3708
	btrfs_free_block_rsv(root, root->orphan_block_rsv);
	root->orphan_block_rsv = NULL;

3709 3710 3711
	return 0;
}

3712 3713
int btrfs_buffer_uptodate(struct extent_buffer *buf, u64 parent_transid,
			  int atomic)
3714
{
3715
	int ret;
3716
	struct inode *btree_inode = buf->pages[0]->mapping->host;
3717

3718
	ret = extent_buffer_uptodate(buf);
3719 3720 3721 3722
	if (!ret)
		return ret;

	ret = verify_parent_transid(&BTRFS_I(btree_inode)->io_tree, buf,
3723 3724 3725
				    parent_transid, atomic);
	if (ret == -EAGAIN)
		return ret;
3726
	return !ret;
3727 3728 3729
}

int btrfs_set_buffer_uptodate(struct extent_buffer *buf)
C
Chris Mason 已提交
3730
{
3731
	return set_extent_buffer_uptodate(buf);
3732
}
3733

3734 3735
void btrfs_mark_buffer_dirty(struct extent_buffer *buf)
{
3736
	struct btrfs_root *root;
3737
	u64 transid = btrfs_header_generation(buf);
3738
	int was_dirty;
3739

3740 3741 3742 3743 3744 3745 3746 3747 3748 3749
#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
	/*
	 * This is a fast path so only do this check if we have sanity tests
	 * enabled.  Normal people shouldn't be marking dummy buffers as dirty
	 * outside of the sanity tests.
	 */
	if (unlikely(test_bit(EXTENT_BUFFER_DUMMY, &buf->bflags)))
		return;
#endif
	root = BTRFS_I(buf->pages[0]->mapping->host)->root;
3750
	btrfs_assert_tree_locked(buf);
J
Julia Lawall 已提交
3751 3752
	if (transid != root->fs_info->generation)
		WARN(1, KERN_CRIT "btrfs transid mismatch buffer %llu, "
C
Chris Mason 已提交
3753
		       "found %llu running %llu\n",
3754
			buf->start, transid, root->fs_info->generation);
3755
	was_dirty = set_extent_buffer_dirty(buf);
3756 3757 3758 3759
	if (!was_dirty)
		__percpu_counter_add(&root->fs_info->dirty_metadata_bytes,
				     buf->len,
				     root->fs_info->dirty_metadata_batch);
3760 3761 3762 3763 3764 3765
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
	if (btrfs_header_level(buf) == 0 && check_leaf(root, buf)) {
		btrfs_print_leaf(root, buf);
		ASSERT(0);
	}
#endif
3766 3767
}

3768 3769
static void __btrfs_btree_balance_dirty(struct btrfs_root *root,
					int flush_delayed)
3770 3771 3772 3773 3774
{
	/*
	 * looks as though older kernels can get into trouble with
	 * this code, they end up stuck in balance_dirty_pages forever
	 */
3775
	int ret;
3776 3777 3778 3779

	if (current->flags & PF_MEMALLOC)
		return;

3780 3781
	if (flush_delayed)
		btrfs_balance_delayed_items(root);
3782

3783 3784 3785
	ret = percpu_counter_compare(&root->fs_info->dirty_metadata_bytes,
				     BTRFS_DIRTY_METADATA_THRESH);
	if (ret > 0) {
3786 3787
		balance_dirty_pages_ratelimited(
				   root->fs_info->btree_inode->i_mapping);
3788 3789 3790 3791
	}
	return;
}

3792
void btrfs_btree_balance_dirty(struct btrfs_root *root)
C
Chris Mason 已提交
3793
{
3794 3795
	__btrfs_btree_balance_dirty(root, 1);
}
3796

3797 3798 3799
void btrfs_btree_balance_dirty_nodelay(struct btrfs_root *root)
{
	__btrfs_btree_balance_dirty(root, 0);
C
Chris Mason 已提交
3800
}
3801

3802
int btrfs_read_buffer(struct extent_buffer *buf, u64 parent_transid)
3803
{
3804
	struct btrfs_root *root = BTRFS_I(buf->pages[0]->mapping->host)->root;
3805
	return btree_read_extent_buffer_pages(root, buf, 0, parent_transid);
3806
}
3807

3808
static int btrfs_check_super_valid(struct btrfs_fs_info *fs_info,
L
liubo 已提交
3809 3810
			      int read_only)
{
D
David Sterba 已提交
3811 3812 3813
	/*
	 * Placeholder for checks
	 */
3814
	return 0;
L
liubo 已提交
3815 3816
}

3817
static void btrfs_error_commit_super(struct btrfs_root *root)
L
liubo 已提交
3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829
{
	mutex_lock(&root->fs_info->cleaner_mutex);
	btrfs_run_delayed_iputs(root);
	mutex_unlock(&root->fs_info->cleaner_mutex);

	down_write(&root->fs_info->cleanup_work_sem);
	up_write(&root->fs_info->cleanup_work_sem);

	/* cleanup FS via transaction */
	btrfs_cleanup_transaction(root);
}

3830
static void btrfs_destroy_ordered_extents(struct btrfs_root *root)
L
liubo 已提交
3831 3832 3833
{
	struct btrfs_ordered_extent *ordered;

3834
	spin_lock(&root->ordered_extent_lock);
3835 3836 3837 3838
	/*
	 * This will just short circuit the ordered completion stuff which will
	 * make sure the ordered extent gets properly cleaned up.
	 */
3839
	list_for_each_entry(ordered, &root->ordered_extents,
3840 3841
			    root_extent_list)
		set_bit(BTRFS_ORDERED_IOERR, &ordered->flags);
3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856
	spin_unlock(&root->ordered_extent_lock);
}

static void btrfs_destroy_all_ordered_extents(struct btrfs_fs_info *fs_info)
{
	struct btrfs_root *root;
	struct list_head splice;

	INIT_LIST_HEAD(&splice);

	spin_lock(&fs_info->ordered_root_lock);
	list_splice_init(&fs_info->ordered_roots, &splice);
	while (!list_empty(&splice)) {
		root = list_first_entry(&splice, struct btrfs_root,
					ordered_root);
3857 3858
		list_move_tail(&root->ordered_root,
			       &fs_info->ordered_roots);
3859

3860
		spin_unlock(&fs_info->ordered_root_lock);
3861 3862
		btrfs_destroy_ordered_extents(root);

3863 3864
		cond_resched();
		spin_lock(&fs_info->ordered_root_lock);
3865 3866
	}
	spin_unlock(&fs_info->ordered_root_lock);
L
liubo 已提交
3867 3868
}

3869 3870
static int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans,
				      struct btrfs_root *root)
L
liubo 已提交
3871 3872 3873 3874 3875 3876 3877 3878 3879
{
	struct rb_node *node;
	struct btrfs_delayed_ref_root *delayed_refs;
	struct btrfs_delayed_ref_node *ref;
	int ret = 0;

	delayed_refs = &trans->delayed_refs;

	spin_lock(&delayed_refs->lock);
3880
	if (atomic_read(&delayed_refs->num_entries) == 0) {
3881
		spin_unlock(&delayed_refs->lock);
3882
		btrfs_info(root->fs_info, "delayed_refs has NO entry");
L
liubo 已提交
3883 3884 3885
		return ret;
	}

3886 3887
	while ((node = rb_first(&delayed_refs->href_root)) != NULL) {
		struct btrfs_delayed_ref_head *head;
3888
		bool pin_bytes = false;
L
liubo 已提交
3889

3890 3891 3892 3893 3894
		head = rb_entry(node, struct btrfs_delayed_ref_head,
				href_node);
		if (!mutex_trylock(&head->mutex)) {
			atomic_inc(&head->node.refs);
			spin_unlock(&delayed_refs->lock);
3895

3896
			mutex_lock(&head->mutex);
3897
			mutex_unlock(&head->mutex);
3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909
			btrfs_put_delayed_ref(&head->node);
			spin_lock(&delayed_refs->lock);
			continue;
		}
		spin_lock(&head->lock);
		while ((node = rb_first(&head->ref_root)) != NULL) {
			ref = rb_entry(node, struct btrfs_delayed_ref_node,
				       rb_node);
			ref->in_tree = 0;
			rb_erase(&ref->rb_node, &head->ref_root);
			atomic_dec(&delayed_refs->num_entries);
			btrfs_put_delayed_ref(ref);
3910
		}
3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922
		if (head->must_insert_reserved)
			pin_bytes = true;
		btrfs_free_delayed_extent_op(head->extent_op);
		delayed_refs->num_heads--;
		if (head->processing == 0)
			delayed_refs->num_heads_ready--;
		atomic_dec(&delayed_refs->num_entries);
		head->node.in_tree = 0;
		rb_erase(&head->href_node, &delayed_refs->href_root);
		spin_unlock(&head->lock);
		spin_unlock(&delayed_refs->lock);
		mutex_unlock(&head->mutex);
L
liubo 已提交
3923

3924 3925 3926 3927
		if (pin_bytes)
			btrfs_pin_extent(root, head->node.bytenr,
					 head->node.num_bytes, 1);
		btrfs_put_delayed_ref(&head->node);
L
liubo 已提交
3928 3929 3930 3931 3932 3933 3934 3935 3936
		cond_resched();
		spin_lock(&delayed_refs->lock);
	}

	spin_unlock(&delayed_refs->lock);

	return ret;
}

3937
static void btrfs_destroy_delalloc_inodes(struct btrfs_root *root)
L
liubo 已提交
3938 3939 3940 3941 3942 3943
{
	struct btrfs_inode *btrfs_inode;
	struct list_head splice;

	INIT_LIST_HEAD(&splice);

3944 3945
	spin_lock(&root->delalloc_lock);
	list_splice_init(&root->delalloc_inodes, &splice);
L
liubo 已提交
3946 3947

	while (!list_empty(&splice)) {
3948 3949
		btrfs_inode = list_first_entry(&splice, struct btrfs_inode,
					       delalloc_inodes);
L
liubo 已提交
3950 3951

		list_del_init(&btrfs_inode->delalloc_inodes);
3952 3953
		clear_bit(BTRFS_INODE_IN_DELALLOC_LIST,
			  &btrfs_inode->runtime_flags);
3954
		spin_unlock(&root->delalloc_lock);
L
liubo 已提交
3955 3956

		btrfs_invalidate_inodes(btrfs_inode->root);
3957

3958
		spin_lock(&root->delalloc_lock);
L
liubo 已提交
3959 3960
	}

3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986
	spin_unlock(&root->delalloc_lock);
}

static void btrfs_destroy_all_delalloc_inodes(struct btrfs_fs_info *fs_info)
{
	struct btrfs_root *root;
	struct list_head splice;

	INIT_LIST_HEAD(&splice);

	spin_lock(&fs_info->delalloc_root_lock);
	list_splice_init(&fs_info->delalloc_roots, &splice);
	while (!list_empty(&splice)) {
		root = list_first_entry(&splice, struct btrfs_root,
					 delalloc_root);
		list_del_init(&root->delalloc_root);
		root = btrfs_grab_fs_root(root);
		BUG_ON(!root);
		spin_unlock(&fs_info->delalloc_root_lock);

		btrfs_destroy_delalloc_inodes(root);
		btrfs_put_fs_root(root);

		spin_lock(&fs_info->delalloc_root_lock);
	}
	spin_unlock(&fs_info->delalloc_root_lock);
L
liubo 已提交
3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999
}

static int btrfs_destroy_marked_extents(struct btrfs_root *root,
					struct extent_io_tree *dirty_pages,
					int mark)
{
	int ret;
	struct extent_buffer *eb;
	u64 start = 0;
	u64 end;

	while (1) {
		ret = find_first_extent_bit(dirty_pages, start, &start, &end,
4000
					    mark, NULL);
L
liubo 已提交
4001 4002 4003 4004 4005
		if (ret)
			break;

		clear_extent_bits(dirty_pages, start, end, mark, GFP_NOFS);
		while (start <= end) {
4006 4007
			eb = btrfs_find_tree_block(root, start,
						   root->leafsize);
4008
			start += root->leafsize;
4009
			if (!eb)
L
liubo 已提交
4010
				continue;
4011
			wait_on_extent_buffer_writeback(eb);
L
liubo 已提交
4012

4013 4014 4015 4016
			if (test_and_clear_bit(EXTENT_BUFFER_DIRTY,
					       &eb->bflags))
				clear_extent_buffer_dirty(eb);
			free_extent_buffer_stale(eb);
L
liubo 已提交
4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029
		}
	}

	return ret;
}

static int btrfs_destroy_pinned_extent(struct btrfs_root *root,
				       struct extent_io_tree *pinned_extents)
{
	struct extent_io_tree *unpin;
	u64 start;
	u64 end;
	int ret;
4030
	bool loop = true;
L
liubo 已提交
4031 4032

	unpin = pinned_extents;
4033
again:
L
liubo 已提交
4034 4035
	while (1) {
		ret = find_first_extent_bit(unpin, 0, &start, &end,
4036
					    EXTENT_DIRTY, NULL);
L
liubo 已提交
4037 4038 4039 4040
		if (ret)
			break;

		/* opt_discard */
4041 4042 4043 4044
		if (btrfs_test_opt(root, DISCARD))
			ret = btrfs_error_discard_extent(root, start,
							 end + 1 - start,
							 NULL);
L
liubo 已提交
4045 4046 4047 4048 4049 4050

		clear_extent_dirty(unpin, start, end, GFP_NOFS);
		btrfs_error_unpin_extent_range(root, start, end);
		cond_resched();
	}

4051 4052 4053 4054 4055 4056 4057 4058 4059
	if (loop) {
		if (unpin == &root->fs_info->freed_extents[0])
			unpin = &root->fs_info->freed_extents[1];
		else
			unpin = &root->fs_info->freed_extents[0];
		loop = false;
		goto again;
	}

L
liubo 已提交
4060 4061 4062
	return 0;
}

4063 4064 4065 4066 4067
void btrfs_cleanup_one_transaction(struct btrfs_transaction *cur_trans,
				   struct btrfs_root *root)
{
	btrfs_destroy_delayed_refs(cur_trans, root);

4068
	cur_trans->state = TRANS_STATE_COMMIT_START;
4069
	wake_up(&root->fs_info->transaction_blocked_wait);
4070

4071
	cur_trans->state = TRANS_STATE_UNBLOCKED;
4072
	wake_up(&root->fs_info->transaction_wait);
4073

4074 4075
	btrfs_destroy_delayed_inodes(root);
	btrfs_assert_delayed_root_empty(root);
4076 4077 4078

	btrfs_destroy_marked_extents(root, &cur_trans->dirty_pages,
				     EXTENT_DIRTY);
4079 4080
	btrfs_destroy_pinned_extent(root,
				    root->fs_info->pinned_extents);
4081

4082 4083 4084
	cur_trans->state =TRANS_STATE_COMPLETED;
	wake_up(&cur_trans->commit_wait);

4085 4086 4087 4088 4089 4090
	/*
	memset(cur_trans, 0, sizeof(*cur_trans));
	kmem_cache_free(btrfs_transaction_cachep, cur_trans);
	*/
}

4091
static int btrfs_cleanup_transaction(struct btrfs_root *root)
L
liubo 已提交
4092 4093 4094 4095 4096
{
	struct btrfs_transaction *t;

	mutex_lock(&root->fs_info->transaction_kthread_mutex);

J
Josef Bacik 已提交
4097
	spin_lock(&root->fs_info->trans_lock);
4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121
	while (!list_empty(&root->fs_info->trans_list)) {
		t = list_first_entry(&root->fs_info->trans_list,
				     struct btrfs_transaction, list);
		if (t->state >= TRANS_STATE_COMMIT_START) {
			atomic_inc(&t->use_count);
			spin_unlock(&root->fs_info->trans_lock);
			btrfs_wait_for_commit(root, t->transid);
			btrfs_put_transaction(t);
			spin_lock(&root->fs_info->trans_lock);
			continue;
		}
		if (t == root->fs_info->running_transaction) {
			t->state = TRANS_STATE_COMMIT_DOING;
			spin_unlock(&root->fs_info->trans_lock);
			/*
			 * We wait for 0 num_writers since we don't hold a trans
			 * handle open currently for this transaction.
			 */
			wait_event(t->writer_wait,
				   atomic_read(&t->num_writers) == 0);
		} else {
			spin_unlock(&root->fs_info->trans_lock);
		}
		btrfs_cleanup_one_transaction(t, root);
4122

4123 4124 4125
		spin_lock(&root->fs_info->trans_lock);
		if (t == root->fs_info->running_transaction)
			root->fs_info->running_transaction = NULL;
L
liubo 已提交
4126
		list_del_init(&t->list);
4127
		spin_unlock(&root->fs_info->trans_lock);
L
liubo 已提交
4128

4129 4130 4131 4132 4133 4134 4135 4136 4137 4138
		btrfs_put_transaction(t);
		trace_btrfs_transaction_commit(root);
		spin_lock(&root->fs_info->trans_lock);
	}
	spin_unlock(&root->fs_info->trans_lock);
	btrfs_destroy_all_ordered_extents(root->fs_info);
	btrfs_destroy_delayed_inodes(root);
	btrfs_assert_delayed_root_empty(root);
	btrfs_destroy_pinned_extent(root, root->fs_info->pinned_extents);
	btrfs_destroy_all_delalloc_inodes(root->fs_info);
L
liubo 已提交
4139 4140 4141 4142 4143
	mutex_unlock(&root->fs_info->transaction_kthread_mutex);

	return 0;
}

4144
static struct extent_io_ops btree_extent_io_ops = {
4145
	.readpage_end_io_hook = btree_readpage_end_io_hook,
A
Arne Jansen 已提交
4146
	.readpage_io_failed_hook = btree_io_failed_hook,
4147
	.submit_bio_hook = btree_submit_bio_hook,
4148 4149
	/* note we're sharing with inode.c for the merge bio hook */
	.merge_bio_hook = btrfs_merge_bio_hook,
4150
};