disk-io.c 105.4 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/crc32c.h>
30
#include <linux/slab.h>
31
#include <linux/migrate.h>
32
#include <linux/ratelimit.h>
33
#include <asm/unaligned.h>
C
Chris Mason 已提交
34
#include "compat.h"
35 36
#include "ctree.h"
#include "disk-io.h"
37
#include "transaction.h"
38
#include "btrfs_inode.h"
39
#include "volumes.h"
40
#include "print-tree.h"
41
#include "async-thread.h"
42
#include "locking.h"
43
#include "tree-log.h"
44
#include "free-space-cache.h"
45
#include "inode-map.h"
46
#include "check-integrity.h"
47
#include "rcu-string.h"
48
#include "dev-replace.h"
49

50 51 52 53
#ifdef CONFIG_X86
#include <asm/cpufeature.h>
#endif

54
static struct extent_io_ops btree_extent_io_ops;
55
static void end_workqueue_fn(struct btrfs_work *work);
56
static void free_fs_root(struct btrfs_root *root);
57
static int btrfs_check_super_valid(struct btrfs_fs_info *fs_info,
L
liubo 已提交
58
				    int read_only);
59 60
static void btrfs_destroy_ordered_operations(struct btrfs_root *root);
static void btrfs_destroy_ordered_extents(struct btrfs_root *root);
L
liubo 已提交
61 62
static int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans,
				      struct btrfs_root *root);
63 64
static void btrfs_destroy_pending_snapshots(struct btrfs_transaction *t);
static void btrfs_destroy_delalloc_inodes(struct btrfs_root *root);
L
liubo 已提交
65 66 67 68 69
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);
70

C
Chris Mason 已提交
71 72 73 74 75
/*
 * 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.
 */
76 77 78 79 80 81
struct end_io_wq {
	struct bio *bio;
	bio_end_io_t *end_io;
	void *private;
	struct btrfs_fs_info *info;
	int error;
82
	int metadata;
83
	struct list_head list;
84
	struct btrfs_work work;
85
};
86

C
Chris Mason 已提交
87 88 89 90 91
/*
 * 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.
 */
92 93 94 95
struct async_submit_bio {
	struct inode *inode;
	struct bio *bio;
	struct list_head list;
C
Chris Mason 已提交
96 97
	extent_submit_bio_hook_t *submit_bio_start;
	extent_submit_bio_hook_t *submit_bio_done;
98 99
	int rw;
	int mirror_num;
C
Chris Mason 已提交
100
	unsigned long bio_flags;
101 102 103 104 105
	/*
	 * 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;
106
	struct btrfs_work work;
107
	int error;
108 109
};

110 111 112 113 114 115 116 117 118 119
/*
 * 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.
120
 *
121 122 123
 * 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.
124
 *
125 126 127
 * 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.
128
 *
129 130 131
 * 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.
132 133 134 135 136
 */
#ifdef CONFIG_DEBUG_LOCK_ALLOC
# if BTRFS_MAX_LEVEL != 8
#  error
# endif
137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154

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"	},
	{ .id = BTRFS_ORPHAN_OBJECTID,		.name_stem = "orphan"	},
	{ .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"	},
	{ .id = 0,				.name_stem = "tree"	},
155
};
156 157 158 159 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

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

187 188
#endif

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

201
	read_lock(&em_tree->lock);
202
	em = lookup_extent_mapping(em_tree, start, len);
203 204 205
	if (em) {
		em->bdev =
			BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev;
206
		read_unlock(&em_tree->lock);
207
		goto out;
208
	}
209
	read_unlock(&em_tree->lock);
210

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

222
	write_lock(&em_tree->lock);
223 224 225
	ret = add_extent_mapping(em_tree, em);
	if (ret == -EEXIST) {
		free_extent_map(em);
226
		em = lookup_extent_mapping(em_tree, start, len);
227
		if (!em)
228
			em = ERR_PTR(-EIO);
229
	} else if (ret) {
230
		free_extent_map(em);
231
		em = ERR_PTR(ret);
232
	}
233
	write_unlock(&em_tree->lock);
234

235 236
out:
	return em;
237 238
}

239 240
u32 btrfs_csum_data(struct btrfs_root *root, char *data, u32 seed, size_t len)
{
241
	return crc32c(seed, data, len);
242 243 244 245
}

void btrfs_csum_final(u32 crc, char *result)
{
246
	put_unaligned_le32(~crc, result);
247 248
}

C
Chris Mason 已提交
249 250 251 252
/*
 * compute the csum for a btree block, and either verify it or write it
 * into the csum field of the block.
 */
253 254 255
static int csum_tree_block(struct btrfs_root *root, struct extent_buffer *buf,
			   int verify)
{
256
	u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
257
	char *result = NULL;
258 259 260 261 262 263 264 265
	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;
266
	unsigned long inline_result;
267 268

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

288 289 290
	btrfs_csum_final(crc, result);

	if (verify) {
291
		if (memcmp_extent_buffer(buf, result, 0, csum_size)) {
292 293
			u32 val;
			u32 found = 0;
294
			memcpy(&found, result, csum_size);
295

296
			read_extent_buffer(buf, &val, 0, csum_size);
297
			printk_ratelimited(KERN_INFO "btrfs: %s checksum verify "
C
Chris Mason 已提交
298 299 300 301 302
				       "failed on %llu wanted %X found %X "
				       "level %d\n",
				       root->fs_info->sb->s_id,
				       (unsigned long long)buf->start, val, found,
				       btrfs_header_level(buf));
303 304
			if (result != (char *)&inline_result)
				kfree(result);
305 306 307
			return 1;
		}
	} else {
308
		write_extent_buffer(buf, result, 0, csum_size);
309
	}
310 311
	if (result != (char *)&inline_result)
		kfree(result);
312 313 314
	return 0;
}

C
Chris Mason 已提交
315 316 317 318 319 320
/*
 * 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.
 */
321
static int verify_parent_transid(struct extent_io_tree *io_tree,
322 323
				 struct extent_buffer *eb, u64 parent_transid,
				 int atomic)
324
{
325
	struct extent_state *cached_state = NULL;
326 327 328 329 330
	int ret;

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

331 332 333
	if (atomic)
		return -EAGAIN;

334
	lock_extent_bits(io_tree, eb->start, eb->start + eb->len - 1,
335
			 0, &cached_state);
336
	if (extent_buffer_uptodate(eb) &&
337 338 339 340
	    btrfs_header_generation(eb) == parent_transid) {
		ret = 0;
		goto out;
	}
341
	printk_ratelimited("parent transid verify failed on %llu wanted %llu "
C
Chris Mason 已提交
342 343 344 345
		       "found %llu\n",
		       (unsigned long long)eb->start,
		       (unsigned long long)parent_transid,
		       (unsigned long long)btrfs_header_generation(eb));
346
	ret = 1;
347
	clear_extent_buffer_uptodate(eb);
C
Chris Mason 已提交
348
out:
349 350
	unlock_extent_cached(io_tree, eb->start, eb->start + eb->len - 1,
			     &cached_state, GFP_NOFS);
351 352 353
	return ret;
}

C
Chris Mason 已提交
354 355 356 357
/*
 * helper to read a given tree block, doing retries as required when
 * the checksums don't match and we have alternate mirrors to try.
 */
358 359
static int btree_read_extent_buffer_pages(struct btrfs_root *root,
					  struct extent_buffer *eb,
360
					  u64 start, u64 parent_transid)
361 362
{
	struct extent_io_tree *io_tree;
363
	int failed = 0;
364 365 366
	int ret;
	int num_copies = 0;
	int mirror_num = 0;
367
	int failed_mirror = 0;
368

369
	clear_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags);
370 371
	io_tree = &BTRFS_I(root->fs_info->btree_inode)->io_tree;
	while (1) {
372 373
		ret = read_extent_buffer_pages(io_tree, eb, start,
					       WAIT_COMPLETE,
374
					       btree_get_extent, mirror_num);
375 376
		if (!ret) {
			if (!verify_parent_transid(io_tree, eb,
377
						   parent_transid, 0))
378 379 380 381
				break;
			else
				ret = -EIO;
		}
C
Chris Mason 已提交
382

383 384 385 386 387 388
		/*
		 * 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))
389 390
			break;

391
		num_copies = btrfs_num_copies(root->fs_info,
392
					      eb->start, eb->len);
C
Chris Mason 已提交
393
		if (num_copies == 1)
394
			break;
C
Chris Mason 已提交
395

396 397 398 399 400
		if (!failed_mirror) {
			failed = 1;
			failed_mirror = eb->read_mirror;
		}

401
		mirror_num++;
402 403 404
		if (mirror_num == failed_mirror)
			mirror_num++;

C
Chris Mason 已提交
405
		if (mirror_num > num_copies)
406
			break;
407
	}
408

409
	if (failed && !ret && failed_mirror)
410 411 412
		repair_eb_io_failure(root, eb, failed_mirror);

	return ret;
413
}
414

C
Chris Mason 已提交
415
/*
C
Chris Mason 已提交
416 417
 * 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 已提交
418
 */
C
Chris Mason 已提交
419

420
static int csum_dirty_buffer(struct btrfs_root *root, struct page *page)
421
{
422
	struct extent_io_tree *tree;
M
Miao Xie 已提交
423
	u64 start = page_offset(page);
424 425
	u64 found_start;
	struct extent_buffer *eb;
426

427
	tree = &BTRFS_I(page->mapping->host)->io_tree;
428

J
Josef Bacik 已提交
429 430 431
	eb = (struct extent_buffer *)page->private;
	if (page != eb->pages[0])
		return 0;
432 433
	found_start = btrfs_header_bytenr(eb);
	if (found_start != start) {
434
		WARN_ON(1);
J
Josef Bacik 已提交
435
		return 0;
436 437 438
	}
	if (!PageUptodate(page)) {
		WARN_ON(1);
J
Josef Bacik 已提交
439
		return 0;
440 441 442 443 444
	}
	csum_tree_block(root, eb, 0);
	return 0;
}

Y
Yan Zheng 已提交
445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463
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;

	read_extent_buffer(eb, fsid, (unsigned long)btrfs_header_fsid(eb),
			   BTRFS_FSID_SIZE);
	while (fs_devices) {
		if (!memcmp(fsid, fs_devices->fsid, BTRFS_FSID_SIZE)) {
			ret = 0;
			break;
		}
		fs_devices = fs_devices->seed;
	}
	return ret;
}

464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530
#define CORRUPT(reason, eb, root, slot)				\
	printk(KERN_CRIT "btrfs: corrupt leaf, %s: block=%llu,"	\
	       "root=%llu, slot=%d\n", reason,			\
	       (unsigned long long)btrfs_header_bytenr(eb),	\
	       (unsigned long long)root->objectid, slot)

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

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
struct extent_buffer *find_eb_for_page(struct extent_io_tree *tree,
				       struct page *page, int max_walk)
{
	struct extent_buffer *eb;
	u64 start = page_offset(page);
	u64 target = start;
	u64 min_start;

	if (start < max_walk)
		min_start = 0;
	else
		min_start = start - max_walk;

	while (start >= min_start) {
		eb = find_extent_buffer(tree, start, 0);
		if (eb) {
			/*
			 * we found an extent buffer and it contains our page
			 * horray!
			 */
			if (eb->start <= target &&
			    eb->start + eb->len > target)
				return eb;

			/* we found an extent buffer that wasn't for us */
			free_extent_buffer(eb);
			return NULL;
		}
		if (start == 0)
			break;
		start -= PAGE_CACHE_SIZE;
	}
	return NULL;
}

566
static int btree_readpage_end_io_hook(struct page *page, u64 start, u64 end,
567
			       struct extent_state *state, int mirror)
568 569 570 571 572 573
{
	struct extent_io_tree *tree;
	u64 found_start;
	int found_level;
	struct extent_buffer *eb;
	struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
574
	int ret = 0;
575
	int reads_done;
576 577 578

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

580
	tree = &BTRFS_I(page->mapping->host)->io_tree;
J
Josef Bacik 已提交
581
	eb = (struct extent_buffer *)page->private;
C
Chris Mason 已提交
582

583 584 585 586 587 588
	/* 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);
589 590
	if (!reads_done)
		goto err;
591

592
	eb->read_mirror = mirror;
593 594 595 596 597
	if (test_bit(EXTENT_BUFFER_IOERR, &eb->bflags)) {
		ret = -EIO;
		goto err;
	}

598
	found_start = btrfs_header_bytenr(eb);
599
	if (found_start != eb->start) {
600
		printk_ratelimited(KERN_INFO "btrfs bad tree block start "
C
Chris Mason 已提交
601 602 603
			       "%llu %llu\n",
			       (unsigned long long)found_start,
			       (unsigned long long)eb->start);
604
		ret = -EIO;
605 606
		goto err;
	}
Y
Yan Zheng 已提交
607
	if (check_tree_block_fsid(root, eb)) {
608
		printk_ratelimited(KERN_INFO "btrfs bad fsid on block %llu\n",
C
Chris Mason 已提交
609
			       (unsigned long long)eb->start);
610 611 612
		ret = -EIO;
		goto err;
	}
613 614
	found_level = btrfs_header_level(eb);

615 616
	btrfs_set_buffer_lockdep_class(btrfs_header_owner(eb),
				       eb, found_level);
617

618
	ret = csum_tree_block(root, eb, 1);
619
	if (ret) {
620
		ret = -EIO;
621 622 623 624 625 626 627 628 629 630 631 632
		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;
	}
633

634 635
	if (!ret)
		set_extent_buffer_uptodate(eb);
636
err:
A
Arne Jansen 已提交
637 638 639 640 641
	if (test_bit(EXTENT_BUFFER_READAHEAD, &eb->bflags)) {
		clear_bit(EXTENT_BUFFER_READAHEAD, &eb->bflags);
		btree_readahead_hook(root, eb, eb->start, ret);
	}

642 643 644
	if (ret)
		clear_extent_buffer_uptodate(eb);
	free_extent_buffer(eb);
645
out:
646
	return ret;
647 648
}

649
static int btree_io_failed_hook(struct page *page, int failed_mirror)
A
Arne Jansen 已提交
650 651 652 653
{
	struct extent_buffer *eb;
	struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;

J
Josef Bacik 已提交
654
	eb = (struct extent_buffer *)page->private;
655
	set_bit(EXTENT_BUFFER_IOERR, &eb->bflags);
656
	eb->read_mirror = failed_mirror;
657
	if (test_and_clear_bit(EXTENT_BUFFER_READAHEAD, &eb->bflags))
A
Arne Jansen 已提交
658 659 660 661
		btree_readahead_hook(root, eb, eb->start, -EIO);
	return -EIO;	/* we fixed nothing */
}

662 663 664 665 666 667 668
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;
669 670
	end_io_wq->work.func = end_workqueue_fn;
	end_io_wq->work.flags = 0;
671

672
	if (bio->bi_rw & REQ_WRITE) {
J
Josef Bacik 已提交
673
		if (end_io_wq->metadata == 1)
674 675
			btrfs_queue_worker(&fs_info->endio_meta_write_workers,
					   &end_io_wq->work);
J
Josef Bacik 已提交
676 677 678
		else if (end_io_wq->metadata == 2)
			btrfs_queue_worker(&fs_info->endio_freespace_worker,
					   &end_io_wq->work);
679 680 681
		else
			btrfs_queue_worker(&fs_info->endio_write_workers,
					   &end_io_wq->work);
682 683 684 685 686 687 688 689
	} else {
		if (end_io_wq->metadata)
			btrfs_queue_worker(&fs_info->endio_meta_workers,
					   &end_io_wq->work);
		else
			btrfs_queue_worker(&fs_info->endio_workers,
					   &end_io_wq->work);
	}
690 691
}

J
Josef Bacik 已提交
692 693 694 695 696 697 698
/*
 * For the metadata arg you want
 *
 * 0 - if data
 * 1 - if normal metadta
 * 2 - if writing to the free space cache area
 */
699 700
int btrfs_bio_wq_end_io(struct btrfs_fs_info *info, struct bio *bio,
			int metadata)
701
{
702 703 704 705 706 707 708
	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;
709
	end_io_wq->info = info;
710 711
	end_io_wq->error = 0;
	end_io_wq->bio = bio;
712
	end_io_wq->metadata = metadata;
713 714 715

	bio->bi_private = end_io_wq;
	bio->bi_end_io = end_workqueue_bio;
716 717 718
	return 0;
}

719
unsigned long btrfs_async_submit_limit(struct btrfs_fs_info *info)
720
{
721 722 723 724 725
	unsigned long limit = min_t(unsigned long,
				    info->workers.max_workers,
				    info->fs_devices->open_devices);
	return 256 * limit;
}
726

C
Chris Mason 已提交
727 728 729
static void run_one_async_start(struct btrfs_work *work)
{
	struct async_submit_bio *async;
730
	int ret;
C
Chris Mason 已提交
731 732

	async = container_of(work, struct  async_submit_bio, work);
733 734 735 736 737
	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 已提交
738 739 740
}

static void run_one_async_done(struct btrfs_work *work)
741 742 743
{
	struct btrfs_fs_info *fs_info;
	struct async_submit_bio *async;
744
	int limit;
745 746 747

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

749
	limit = btrfs_async_submit_limit(fs_info);
750 751
	limit = limit * 2 / 3;

752
	if (atomic_dec_return(&fs_info->nr_async_submits) < limit &&
753
	    waitqueue_active(&fs_info->async_submit_wait))
754 755
		wake_up(&fs_info->async_submit_wait);

756 757 758 759 760 761
	/* 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 已提交
762
	async->submit_bio_done(async->inode, async->rw, async->bio,
763 764
			       async->mirror_num, async->bio_flags,
			       async->bio_offset);
C
Chris Mason 已提交
765 766 767 768 769 770 771
}

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

	async = container_of(work, struct  async_submit_bio, work);
772 773 774
	kfree(async);
}

775 776
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 已提交
777
			unsigned long bio_flags,
778
			u64 bio_offset,
C
Chris Mason 已提交
779 780
			extent_submit_bio_hook_t *submit_bio_start,
			extent_submit_bio_hook_t *submit_bio_done)
781 782 783 784 785 786 787 788 789 790 791
{
	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 已提交
792 793 794 795 796 797 798
	async->submit_bio_start = submit_bio_start;
	async->submit_bio_done = submit_bio_done;

	async->work.func = run_one_async_start;
	async->work.ordered_func = run_one_async_done;
	async->work.ordered_free = run_one_async_free;

799
	async->work.flags = 0;
C
Chris Mason 已提交
800
	async->bio_flags = bio_flags;
801
	async->bio_offset = bio_offset;
802

803 804
	async->error = 0;

805
	atomic_inc(&fs_info->nr_async_submits);
806

807
	if (rw & REQ_SYNC)
808 809
		btrfs_set_work_high_prio(&async->work);

810
	btrfs_queue_worker(&fs_info->workers, &async->work);
811

C
Chris Mason 已提交
812
	while (atomic_read(&fs_info->async_submit_draining) &&
813 814 815 816 817
	      atomic_read(&fs_info->nr_async_submits)) {
		wait_event(fs_info->async_submit_wait,
			   (atomic_read(&fs_info->nr_async_submits) == 0));
	}

818 819 820
	return 0;
}

821 822 823 824 825
static int btree_csum_one_bio(struct bio *bio)
{
	struct bio_vec *bvec = bio->bi_io_vec;
	int bio_index = 0;
	struct btrfs_root *root;
826
	int ret = 0;
827 828

	WARN_ON(bio->bi_vcnt <= 0);
C
Chris Mason 已提交
829
	while (bio_index < bio->bi_vcnt) {
830
		root = BTRFS_I(bvec->bv_page->mapping->host)->root;
831 832 833
		ret = csum_dirty_buffer(root, bvec->bv_page);
		if (ret)
			break;
834 835 836
		bio_index++;
		bvec++;
	}
837
	return ret;
838 839
}

C
Chris Mason 已提交
840 841
static int __btree_submit_bio_start(struct inode *inode, int rw,
				    struct bio *bio, int mirror_num,
842 843
				    unsigned long bio_flags,
				    u64 bio_offset)
844
{
845 846
	/*
	 * when we're called for a write, we're already in the async
847
	 * submission context.  Just jump into btrfs_map_bio
848
	 */
849
	return btree_csum_one_bio(bio);
C
Chris Mason 已提交
850
}
851

C
Chris Mason 已提交
852
static int __btree_submit_bio_done(struct inode *inode, int rw, struct bio *bio,
853 854
				 int mirror_num, unsigned long bio_flags,
				 u64 bio_offset)
C
Chris Mason 已提交
855
{
856 857
	int ret;

858
	/*
C
Chris Mason 已提交
859 860
	 * when we're called for a write, we're already in the async
	 * submission context.  Just jump into btrfs_map_bio
861
	 */
862 863 864 865
	ret = btrfs_map_bio(BTRFS_I(inode)->root, rw, bio, mirror_num, 1);
	if (ret)
		bio_endio(bio, ret);
	return ret;
866 867
}

868 869 870 871 872 873 874 875 876 877 878
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;
}

879
static int btree_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
880 881
				 int mirror_num, unsigned long bio_flags,
				 u64 bio_offset)
882
{
883
	int async = check_async_write(inode, bio_flags);
884 885
	int ret;

886
	if (!(rw & REQ_WRITE)) {
C
Chris Mason 已提交
887 888 889 890
		/*
		 * called for a read, do the setup so that checksum validation
		 * can happen in the async kernel threads
		 */
891 892
		ret = btrfs_bio_wq_end_io(BTRFS_I(inode)->root->fs_info,
					  bio, 1);
893
		if (ret)
894 895 896
			goto out_w_error;
		ret = btrfs_map_bio(BTRFS_I(inode)->root, rw, bio,
				    mirror_num, 0);
897 898 899
	} else if (!async) {
		ret = btree_csum_one_bio(bio);
		if (ret)
900 901 902 903 904 905 906 907 908 909 910 911 912
			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);
913
	}
914

915 916 917 918 919
	if (ret) {
out_w_error:
		bio_endio(bio, ret);
	}
	return ret;
920 921
}

J
Jan Beulich 已提交
922
#ifdef CONFIG_MIGRATION
923
static int btree_migratepage(struct address_space *mapping,
924 925
			struct page *newpage, struct page *page,
			enum migrate_mode mode)
926 927 928 929 930 931 932 933 934 935 936 937 938 939
{
	/*
	 * 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;
940
	return migrate_page(mapping, newpage, page, mode);
941
}
J
Jan Beulich 已提交
942
#endif
943

944 945 946 947

static int btree_writepages(struct address_space *mapping,
			    struct writeback_control *wbc)
{
948 949
	struct extent_io_tree *tree;
	tree = &BTRFS_I(mapping->host)->io_tree;
950
	if (wbc->sync_mode == WB_SYNC_NONE) {
951
		struct btrfs_root *root = BTRFS_I(mapping->host)->root;
952
		u64 num_dirty;
953
		unsigned long thresh = 32 * 1024 * 1024;
954 955 956 957

		if (wbc->for_kupdate)
			return 0;

958 959
		/* this is a bit racy, but that's ok */
		num_dirty = root->fs_info->dirty_metadata_bytes;
C
Chris Mason 已提交
960
		if (num_dirty < thresh)
961 962
			return 0;
	}
963
	return btree_write_cache_pages(mapping, wbc);
964 965
}

966
static int btree_readpage(struct file *file, struct page *page)
967
{
968 969
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
970
	return extent_read_full_page(tree, page, btree_get_extent, 0);
971
}
C
Chris Mason 已提交
972

973
static int btree_releasepage(struct page *page, gfp_t gfp_flags)
974
{
975
	if (PageWriteback(page) || PageDirty(page))
C
Chris Mason 已提交
976
		return 0;
977 978 979 980 981 982 983
	/*
	 * We need to mask out eg. __GFP_HIGHMEM and __GFP_DMA32 as we're doing
	 * slab allocation from alloc_extent_state down the callchain where
	 * it'd hit a BUG_ON as those flags are not allowed.
	 */
	gfp_flags &= ~GFP_SLAB_BUG_MASK;

984
	return try_release_extent_buffer(page, gfp_flags);
985 986
}

987
static void btree_invalidatepage(struct page *page, unsigned long offset)
988
{
989 990
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
991 992
	extent_invalidatepage(tree, page, offset);
	btree_releasepage(page, GFP_NOFS);
993
	if (PagePrivate(page)) {
C
Chris Mason 已提交
994 995
		printk(KERN_WARNING "btrfs warning page private not zero "
		       "on page %llu\n", (unsigned long long)page_offset(page));
996 997 998 999
		ClearPagePrivate(page);
		set_page_private(page, 0);
		page_cache_release(page);
	}
1000 1001
}

1002 1003
static int btree_set_page_dirty(struct page *page)
{
1004
#ifdef DEBUG
1005 1006 1007 1008 1009 1010 1011 1012
	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);
1013
#endif
1014 1015 1016
	return __set_page_dirty_nobuffers(page);
}

1017
static const struct address_space_operations btree_aops = {
1018
	.readpage	= btree_readpage,
1019
	.writepages	= btree_writepages,
1020 1021
	.releasepage	= btree_releasepage,
	.invalidatepage = btree_invalidatepage,
1022
#ifdef CONFIG_MIGRATION
1023
	.migratepage	= btree_migratepage,
1024
#endif
1025
	.set_page_dirty = btree_set_page_dirty,
1026 1027
};

1028 1029
int readahead_tree_block(struct btrfs_root *root, u64 bytenr, u32 blocksize,
			 u64 parent_transid)
C
Chris Mason 已提交
1030
{
1031 1032
	struct extent_buffer *buf = NULL;
	struct inode *btree_inode = root->fs_info->btree_inode;
1033
	int ret = 0;
C
Chris Mason 已提交
1034

1035
	buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
1036
	if (!buf)
C
Chris Mason 已提交
1037
		return 0;
1038
	read_extent_buffer_pages(&BTRFS_I(btree_inode)->io_tree,
1039
				 buf, 0, WAIT_NONE, btree_get_extent, 0);
1040
	free_extent_buffer(buf);
1041
	return ret;
C
Chris Mason 已提交
1042 1043
}

1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067
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;
1068
	} else if (extent_buffer_uptodate(buf)) {
1069 1070 1071 1072 1073 1074 1075
		*eb = buf;
	} else {
		free_extent_buffer(buf);
	}
	return 0;
}

1076 1077 1078 1079 1080 1081
struct extent_buffer *btrfs_find_tree_block(struct btrfs_root *root,
					    u64 bytenr, u32 blocksize)
{
	struct inode *btree_inode = root->fs_info->btree_inode;
	struct extent_buffer *eb;
	eb = find_extent_buffer(&BTRFS_I(btree_inode)->io_tree,
1082
				bytenr, blocksize);
1083 1084 1085 1086 1087 1088 1089 1090 1091 1092
	return eb;
}

struct extent_buffer *btrfs_find_create_tree_block(struct btrfs_root *root,
						 u64 bytenr, u32 blocksize)
{
	struct inode *btree_inode = root->fs_info->btree_inode;
	struct extent_buffer *eb;

	eb = alloc_extent_buffer(&BTRFS_I(btree_inode)->io_tree,
1093
				 bytenr, blocksize);
1094 1095 1096 1097
	return eb;
}


1098 1099
int btrfs_write_tree_block(struct extent_buffer *buf)
{
1100
	return filemap_fdatawrite_range(buf->pages[0]->mapping, buf->start,
1101
					buf->start + buf->len - 1);
1102 1103 1104 1105
}

int btrfs_wait_tree_block_writeback(struct extent_buffer *buf)
{
1106
	return filemap_fdatawait_range(buf->pages[0]->mapping,
1107
				       buf->start, buf->start + buf->len - 1);
1108 1109
}

1110
struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 bytenr,
1111
				      u32 blocksize, u64 parent_transid)
1112 1113 1114 1115 1116 1117 1118 1119
{
	struct extent_buffer *buf = NULL;
	int ret;

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

1120
	ret = btree_read_extent_buffer_pages(root, buf, 0, parent_transid);
1121
	return buf;
1122

1123 1124
}

1125 1126
void clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
		      struct extent_buffer *buf)
1127
{
1128
	if (btrfs_header_generation(buf) ==
1129
	    root->fs_info->running_transaction->transid) {
1130
		btrfs_assert_tree_locked(buf);
1131

1132 1133 1134 1135
		if (test_and_clear_bit(EXTENT_BUFFER_DIRTY, &buf->bflags)) {
			spin_lock(&root->fs_info->delalloc_lock);
			if (root->fs_info->dirty_metadata_bytes >= buf->len)
				root->fs_info->dirty_metadata_bytes -= buf->len;
1136 1137 1138 1139
			else {
				spin_unlock(&root->fs_info->delalloc_lock);
				btrfs_panic(root->fs_info, -EOVERFLOW,
					  "Can't clear %lu bytes from "
1140
					  " dirty_mdatadata_bytes (%llu)",
1141 1142 1143
					  buf->len,
					  root->fs_info->dirty_metadata_bytes);
			}
1144
			spin_unlock(&root->fs_info->delalloc_lock);
1145

1146 1147 1148 1149
			/* ugh, clear_extent_buffer_dirty needs to lock the page */
			btrfs_set_lock_blocking(buf);
			clear_extent_buffer_dirty(buf);
		}
1150
	}
1151 1152
}

1153 1154 1155 1156
static void __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize,
			 u32 stripesize, struct btrfs_root *root,
			 struct btrfs_fs_info *fs_info,
			 u64 objectid)
1157
{
C
Chris Mason 已提交
1158
	root->node = NULL;
1159
	root->commit_root = NULL;
1160 1161 1162
	root->sectorsize = sectorsize;
	root->nodesize = nodesize;
	root->leafsize = leafsize;
1163
	root->stripesize = stripesize;
C
Chris Mason 已提交
1164
	root->ref_cows = 0;
1165
	root->track_dirty = 0;
1166
	root->in_radix = 0;
1167 1168
	root->orphan_item_inserted = 0;
	root->orphan_cleanup_state = 0;
1169

1170 1171
	root->objectid = objectid;
	root->last_trans = 0;
1172
	root->highest_objectid = 0;
1173
	root->name = NULL;
1174
	root->inode_tree = RB_ROOT;
1175
	INIT_RADIX_TREE(&root->delayed_nodes_tree, GFP_ATOMIC);
1176
	root->block_rsv = NULL;
1177
	root->orphan_block_rsv = NULL;
1178 1179

	INIT_LIST_HEAD(&root->dirty_list);
1180
	INIT_LIST_HEAD(&root->root_list);
1181
	spin_lock_init(&root->orphan_lock);
1182
	spin_lock_init(&root->inode_lock);
1183
	spin_lock_init(&root->accounting_lock);
1184
	mutex_init(&root->objectid_mutex);
1185
	mutex_init(&root->log_mutex);
Y
Yan Zheng 已提交
1186 1187 1188 1189 1190 1191
	init_waitqueue_head(&root->log_writer_wait);
	init_waitqueue_head(&root->log_commit_wait[0]);
	init_waitqueue_head(&root->log_commit_wait[1]);
	atomic_set(&root->log_commit[0], 0);
	atomic_set(&root->log_commit[1], 0);
	atomic_set(&root->log_writers, 0);
M
Miao Xie 已提交
1192
	atomic_set(&root->log_batch, 0);
1193
	atomic_set(&root->orphan_inodes, 0);
Y
Yan Zheng 已提交
1194
	root->log_transid = 0;
1195
	root->last_log_commit = 0;
1196
	extent_io_tree_init(&root->dirty_log_pages,
1197
			     fs_info->btree_inode->i_mapping);
C
Chris Mason 已提交
1198

1199 1200
	memset(&root->root_key, 0, sizeof(root->root_key));
	memset(&root->root_item, 0, sizeof(root->root_item));
1201
	memset(&root->defrag_progress, 0, sizeof(root->defrag_progress));
1202
	memset(&root->root_kobj, 0, sizeof(root->root_kobj));
1203
	root->defrag_trans_start = fs_info->generation;
1204
	init_completion(&root->kobj_unregister);
1205
	root->defrag_running = 0;
1206
	root->root_key.objectid = objectid;
1207
	root->anon_dev = 0;
1208

1209
	spin_lock_init(&root->root_item_lock);
1210 1211
}

1212 1213 1214 1215
static int __must_check find_and_setup_root(struct btrfs_root *tree_root,
					    struct btrfs_fs_info *fs_info,
					    u64 objectid,
					    struct btrfs_root *root)
1216 1217
{
	int ret;
1218
	u32 blocksize;
1219
	u64 generation;
1220

1221
	__setup_root(tree_root->nodesize, tree_root->leafsize,
1222 1223
		     tree_root->sectorsize, tree_root->stripesize,
		     root, fs_info, objectid);
1224 1225
	ret = btrfs_find_last_root(tree_root, objectid,
				   &root->root_item, &root->root_key);
1226 1227
	if (ret > 0)
		return -ENOENT;
1228 1229
	else if (ret < 0)
		return ret;
1230

1231
	generation = btrfs_root_generation(&root->root_item);
1232
	blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
C
Chris Mason 已提交
1233
	root->commit_root = NULL;
1234
	root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
1235
				     blocksize, generation);
1236
	if (!root->node || !btrfs_buffer_uptodate(root->node, generation, 0)) {
1237
		free_extent_buffer(root->node);
C
Chris Mason 已提交
1238
		root->node = NULL;
1239 1240
		return -EIO;
	}
1241
	root->commit_root = btrfs_root_node(root);
1242 1243 1244
	return 0;
}

1245
static struct btrfs_root *btrfs_alloc_root(struct btrfs_fs_info *fs_info)
A
Al Viro 已提交
1246 1247 1248 1249 1250 1251 1252
{
	struct btrfs_root *root = kzalloc(sizeof(*root), GFP_NOFS);
	if (root)
		root->fs_info = fs_info;
	return root;
}

1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328
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;
	u64 bytenr;

	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);
		goto fail;
	}

	bytenr = leaf->start;
	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;

	write_extent_buffer(leaf, fs_info->fsid,
			    (unsigned long)btrfs_header_fsid(leaf),
			    BTRFS_FSID_SIZE);
	write_extent_buffer(leaf, fs_info->chunk_tree_uuid,
			    (unsigned long)btrfs_header_chunk_tree_uuid(leaf),
			    BTRFS_UUID_SIZE);
	btrfs_mark_buffer_dirty(leaf);

	root->commit_root = btrfs_root_node(root);
	root->track_dirty = 1;


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

fail:
	if (ret)
		return ERR_PTR(ret);

	return root;
}

Y
Yan Zheng 已提交
1329 1330
static struct btrfs_root *alloc_log_tree(struct btrfs_trans_handle *trans,
					 struct btrfs_fs_info *fs_info)
1331 1332 1333
{
	struct btrfs_root *root;
	struct btrfs_root *tree_root = fs_info->tree_root;
Y
Yan Zheng 已提交
1334
	struct extent_buffer *leaf;
1335

A
Al Viro 已提交
1336
	root = btrfs_alloc_root(fs_info);
1337
	if (!root)
Y
Yan Zheng 已提交
1338
		return ERR_PTR(-ENOMEM);
1339 1340 1341 1342 1343 1344 1345 1346

	__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;
Y
Yan Zheng 已提交
1347 1348 1349 1350 1351 1352
	/*
	 * 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).
	 */
1353 1354
	root->ref_cows = 0;

1355
	leaf = btrfs_alloc_free_block(trans, root, root->leafsize, 0,
A
Arne Jansen 已提交
1356
				      BTRFS_TREE_LOG_OBJECTID, NULL,
1357
				      0, 0, 0);
Y
Yan Zheng 已提交
1358 1359 1360 1361
	if (IS_ERR(leaf)) {
		kfree(root);
		return ERR_CAST(leaf);
	}
1362

1363 1364 1365 1366 1367
	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 已提交
1368
	root->node = leaf;
1369 1370 1371 1372 1373 1374

	write_extent_buffer(root->node, root->fs_info->fsid,
			    (unsigned long)btrfs_header_fsid(root->node),
			    BTRFS_FSID_SIZE);
	btrfs_mark_buffer_dirty(root->node);
	btrfs_tree_unlock(root->node);
Y
Yan Zheng 已提交
1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410
	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;
	inode_item->generation = cpu_to_le64(1);
	inode_item->size = cpu_to_le64(3);
	inode_item->nlink = cpu_to_le32(1);
	inode_item->nbytes = cpu_to_le64(root->leafsize);
	inode_item->mode = cpu_to_le32(S_IFDIR | 0755);

1411
	btrfs_set_root_node(&log_root->root_item, log_root->node);
Y
Yan Zheng 已提交
1412 1413 1414 1415

	WARN_ON(root->log_root);
	root->log_root = log_root;
	root->log_transid = 0;
1416
	root->last_log_commit = 0;
1417 1418 1419 1420 1421 1422 1423 1424
	return 0;
}

struct btrfs_root *btrfs_read_fs_root_no_radix(struct btrfs_root *tree_root,
					       struct btrfs_key *location)
{
	struct btrfs_root *root;
	struct btrfs_fs_info *fs_info = tree_root->fs_info;
1425
	struct btrfs_path *path;
1426
	struct extent_buffer *l;
1427
	u64 generation;
1428
	u32 blocksize;
1429
	int ret = 0;
1430
	int slot;
1431

A
Al Viro 已提交
1432
	root = btrfs_alloc_root(fs_info);
C
Chris Mason 已提交
1433
	if (!root)
1434 1435
		return ERR_PTR(-ENOMEM);
	if (location->offset == (u64)-1) {
1436
		ret = find_and_setup_root(tree_root, fs_info,
1437 1438 1439 1440 1441
					  location->objectid, root);
		if (ret) {
			kfree(root);
			return ERR_PTR(ret);
		}
1442
		goto out;
1443 1444
	}

1445
	__setup_root(tree_root->nodesize, tree_root->leafsize,
1446 1447
		     tree_root->sectorsize, tree_root->stripesize,
		     root, fs_info, location->objectid);
1448 1449

	path = btrfs_alloc_path();
T
Tsutomu Itoh 已提交
1450 1451 1452 1453
	if (!path) {
		kfree(root);
		return ERR_PTR(-ENOMEM);
	}
1454
	ret = btrfs_search_slot(NULL, tree_root, location, path, 0, 0);
1455 1456
	if (ret == 0) {
		l = path->nodes[0];
1457 1458
		slot = path->slots[0];
		btrfs_read_root_item(tree_root, l, slot, &root->root_item);
1459
		memcpy(&root->root_key, location, sizeof(*location));
1460 1461 1462
	}
	btrfs_free_path(path);
	if (ret) {
1463
		kfree(root);
1464 1465
		if (ret > 0)
			ret = -ENOENT;
1466 1467
		return ERR_PTR(ret);
	}
1468

1469
	generation = btrfs_root_generation(&root->root_item);
1470 1471
	blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
	root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
1472
				     blocksize, generation);
1473
	root->commit_root = btrfs_root_node(root);
1474
	BUG_ON(!root->node); /* -ENOMEM */
1475
out:
1476
	if (location->objectid != BTRFS_TREE_LOG_OBJECTID) {
1477
		root->ref_cows = 1;
1478 1479
		btrfs_check_and_init_root_item(&root->root_item);
	}
1480

1481 1482 1483
	return root;
}

1484 1485
struct btrfs_root *btrfs_read_fs_root_no_name(struct btrfs_fs_info *fs_info,
					      struct btrfs_key *location)
1486 1487 1488 1489
{
	struct btrfs_root *root;
	int ret;

1490 1491 1492 1493
	if (location->objectid == BTRFS_ROOT_TREE_OBJECTID)
		return fs_info->tree_root;
	if (location->objectid == BTRFS_EXTENT_TREE_OBJECTID)
		return fs_info->extent_root;
1494 1495 1496 1497
	if (location->objectid == BTRFS_CHUNK_TREE_OBJECTID)
		return fs_info->chunk_root;
	if (location->objectid == BTRFS_DEV_TREE_OBJECTID)
		return fs_info->dev_root;
1498 1499
	if (location->objectid == BTRFS_CSUM_TREE_OBJECTID)
		return fs_info->csum_root;
1500 1501 1502
	if (location->objectid == BTRFS_QUOTA_TREE_OBJECTID)
		return fs_info->quota_root ? fs_info->quota_root :
					     ERR_PTR(-ENOENT);
1503 1504
again:
	spin_lock(&fs_info->fs_roots_radix_lock);
1505 1506
	root = radix_tree_lookup(&fs_info->fs_roots_radix,
				 (unsigned long)location->objectid);
1507
	spin_unlock(&fs_info->fs_roots_radix_lock);
1508 1509 1510
	if (root)
		return root;

1511
	root = btrfs_read_fs_root_no_radix(fs_info->tree_root, location);
1512 1513
	if (IS_ERR(root))
		return root;
1514

1515 1516 1517
	root->free_ino_ctl = kzalloc(sizeof(*root->free_ino_ctl), GFP_NOFS);
	root->free_ino_pinned = kzalloc(sizeof(*root->free_ino_pinned),
					GFP_NOFS);
1518 1519
	if (!root->free_ino_pinned || !root->free_ino_ctl) {
		ret = -ENOMEM;
1520
		goto fail;
1521
	}
1522 1523 1524 1525 1526 1527

	btrfs_init_free_ino_ctl(root);
	mutex_init(&root->fs_commit_mutex);
	spin_lock_init(&root->cache_lock);
	init_waitqueue_head(&root->cache_wait);

1528
	ret = get_anon_bdev(&root->anon_dev);
1529 1530
	if (ret)
		goto fail;
1531

1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542
	if (btrfs_root_refs(&root->root_item) == 0) {
		ret = -ENOENT;
		goto fail;
	}

	ret = btrfs_find_orphan_item(fs_info->tree_root, location->objectid);
	if (ret < 0)
		goto fail;
	if (ret == 0)
		root->orphan_item_inserted = 1;

1543 1544 1545 1546 1547
	ret = radix_tree_preload(GFP_NOFS & ~__GFP_HIGHMEM);
	if (ret)
		goto fail;

	spin_lock(&fs_info->fs_roots_radix_lock);
C
Chris Mason 已提交
1548 1549
	ret = radix_tree_insert(&fs_info->fs_roots_radix,
				(unsigned long)root->root_key.objectid,
1550
				root);
1551
	if (ret == 0)
1552
		root->in_radix = 1;
1553

1554 1555
	spin_unlock(&fs_info->fs_roots_radix_lock);
	radix_tree_preload_end();
1556
	if (ret) {
1557 1558 1559 1560 1561
		if (ret == -EEXIST) {
			free_fs_root(root);
			goto again;
		}
		goto fail;
1562
	}
1563 1564 1565 1566

	ret = btrfs_find_dead_roots(fs_info->tree_root,
				    root->root_key.objectid);
	WARN_ON(ret);
1567
	return root;
1568 1569 1570
fail:
	free_fs_root(root);
	return ERR_PTR(ret);
1571 1572
}

C
Chris Mason 已提交
1573 1574 1575 1576 1577 1578
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 已提交
1579

1580 1581
	rcu_read_lock();
	list_for_each_entry_rcu(device, &info->fs_devices->devices, dev_list) {
1582 1583
		if (!device->bdev)
			continue;
C
Chris Mason 已提交
1584 1585 1586 1587 1588 1589
		bdi = blk_get_backing_dev_info(device->bdev);
		if (bdi && bdi_congested(bdi, bdi_bits)) {
			ret = 1;
			break;
		}
	}
1590
	rcu_read_unlock();
C
Chris Mason 已提交
1591 1592 1593
	return ret;
}

1594 1595 1596 1597
/*
 * If this fails, caller must call bdi_destroy() to get rid of the
 * bdi again.
 */
C
Chris Mason 已提交
1598 1599
static int setup_bdi(struct btrfs_fs_info *info, struct backing_dev_info *bdi)
{
1600 1601 1602
	int err;

	bdi->capabilities = BDI_CAP_MAP_COPY;
1603
	err = bdi_setup_and_register(bdi, "btrfs", BDI_CAP_MAP_COPY);
1604 1605 1606
	if (err)
		return err;

1607
	bdi->ra_pages	= default_backing_dev_info.ra_pages;
C
Chris Mason 已提交
1608 1609 1610 1611 1612
	bdi->congested_fn	= btrfs_congested_fn;
	bdi->congested_data	= info;
	return 0;
}

1613 1614 1615 1616 1617
/*
 * 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)
1618 1619
{
	struct bio *bio;
1620 1621
	struct end_io_wq *end_io_wq;
	struct btrfs_fs_info *fs_info;
1622 1623
	int error;

1624 1625 1626
	end_io_wq = container_of(work, struct end_io_wq, work);
	bio = end_io_wq->bio;
	fs_info = end_io_wq->info;
1627

1628 1629 1630 1631 1632
	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);
	bio_endio(bio, error);
1633 1634
}

1635 1636 1637 1638 1639
static int cleaner_kthread(void *arg)
{
	struct btrfs_root *root = arg;

	do {
1640 1641
		if (!(root->fs_info->sb->s_flags & MS_RDONLY) &&
		    mutex_trylock(&root->fs_info->cleaner_mutex)) {
Y
Yan, Zheng 已提交
1642
			btrfs_run_delayed_iputs(root);
1643 1644
			btrfs_clean_old_snapshots(root);
			mutex_unlock(&root->fs_info->cleaner_mutex);
C
Chris Mason 已提交
1645
			btrfs_run_defrag_inodes(root->fs_info);
1646
		}
1647

1648
		if (!try_to_freeze()) {
1649
			set_current_state(TASK_INTERRUPTIBLE);
1650 1651
			if (!kthread_should_stop())
				schedule();
1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662
			__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;
1663
	u64 transid;
1664 1665
	unsigned long now;
	unsigned long delay;
1666
	bool cannot_commit;
1667 1668

	do {
1669
		cannot_commit = false;
1670 1671 1672
		delay = HZ * 30;
		mutex_lock(&root->fs_info->transaction_kthread_mutex);

J
Josef Bacik 已提交
1673
		spin_lock(&root->fs_info->trans_lock);
1674 1675
		cur = root->fs_info->running_transaction;
		if (!cur) {
J
Josef Bacik 已提交
1676
			spin_unlock(&root->fs_info->trans_lock);
1677 1678
			goto sleep;
		}
Y
Yan Zheng 已提交
1679

1680
		now = get_seconds();
1681 1682
		if (!cur->blocked &&
		    (now < cur->start_time || now - cur->start_time < 30)) {
J
Josef Bacik 已提交
1683
			spin_unlock(&root->fs_info->trans_lock);
1684 1685 1686
			delay = HZ * 5;
			goto sleep;
		}
1687
		transid = cur->transid;
J
Josef Bacik 已提交
1688
		spin_unlock(&root->fs_info->trans_lock);
1689

1690
		/* If the file system is aborted, this will always fail. */
1691
		trans = btrfs_attach_transaction(root);
1692
		if (IS_ERR(trans)) {
1693 1694
			if (PTR_ERR(trans) != -ENOENT)
				cannot_commit = true;
1695
			goto sleep;
1696
		}
1697
		if (transid == trans->transid) {
1698
			btrfs_commit_transaction(trans, root);
1699 1700 1701
		} else {
			btrfs_end_transaction(trans, root);
		}
1702 1703 1704 1705
sleep:
		wake_up_process(root->fs_info->cleaner_kthread);
		mutex_unlock(&root->fs_info->transaction_kthread_mutex);

1706
		if (!try_to_freeze()) {
1707
			set_current_state(TASK_INTERRUPTIBLE);
1708
			if (!kthread_should_stop() &&
1709 1710
			    (!btrfs_transaction_blocked(root->fs_info) ||
			     cannot_commit))
1711
				schedule_timeout(delay);
1712 1713 1714 1715 1716 1717
			__set_current_state(TASK_RUNNING);
		}
	} while (!kthread_should_stop());
	return 0;
}

C
Chris Mason 已提交
1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823
/*
 * 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));

1824 1825 1826 1827 1828 1829 1830 1831
	/*
	 * 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 已提交
1832
			       btrfs_header_generation(info->fs_root->node));
1833
		btrfs_set_backup_fs_root_level(root_backup,
C
Chris Mason 已提交
1834
			       btrfs_header_level(info->fs_root->node));
1835
	}
C
Chris Mason 已提交
1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 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

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

/* helper to cleanup tree roots */
static void free_root_pointers(struct btrfs_fs_info *info, int chunk_root)
{
	free_extent_buffer(info->tree_root->node);
	free_extent_buffer(info->tree_root->commit_root);
	free_extent_buffer(info->dev_root->node);
	free_extent_buffer(info->dev_root->commit_root);
	free_extent_buffer(info->extent_root->node);
	free_extent_buffer(info->extent_root->commit_root);
	free_extent_buffer(info->csum_root->node);
	free_extent_buffer(info->csum_root->commit_root);
1928 1929 1930 1931
	if (info->quota_root) {
		free_extent_buffer(info->quota_root->node);
		free_extent_buffer(info->quota_root->commit_root);
	}
C
Chris Mason 已提交
1932 1933 1934 1935 1936 1937 1938 1939 1940

	info->tree_root->node = NULL;
	info->tree_root->commit_root = NULL;
	info->dev_root->node = NULL;
	info->dev_root->commit_root = NULL;
	info->extent_root->node = NULL;
	info->extent_root->commit_root = NULL;
	info->csum_root->node = NULL;
	info->csum_root->commit_root = NULL;
1941 1942 1943 1944
	if (info->quota_root) {
		info->quota_root->node = NULL;
		info->quota_root->commit_root = NULL;
	}
C
Chris Mason 已提交
1945 1946 1947 1948 1949 1950 1951 1952 1953 1954

	if (chunk_root) {
		free_extent_buffer(info->chunk_root->node);
		free_extent_buffer(info->chunk_root->commit_root);
		info->chunk_root->node = NULL;
		info->chunk_root->commit_root = NULL;
	}
}


A
Al Viro 已提交
1955 1956 1957
int open_ctree(struct super_block *sb,
	       struct btrfs_fs_devices *fs_devices,
	       char *options)
1958
{
1959 1960 1961 1962
	u32 sectorsize;
	u32 nodesize;
	u32 leafsize;
	u32 blocksize;
1963
	u32 stripesize;
1964
	u64 generation;
1965
	u64 features;
1966
	struct btrfs_key location;
1967
	struct buffer_head *bh;
1968
	struct btrfs_super_block *disk_super;
1969
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
1970
	struct btrfs_root *tree_root;
1971 1972 1973 1974
	struct btrfs_root *extent_root;
	struct btrfs_root *csum_root;
	struct btrfs_root *chunk_root;
	struct btrfs_root *dev_root;
1975
	struct btrfs_root *quota_root;
1976
	struct btrfs_root *log_tree_root;
1977
	int ret;
1978
	int err = -EINVAL;
C
Chris Mason 已提交
1979 1980
	int num_backups_tried = 0;
	int backup_index = 0;
1981

1982
	tree_root = fs_info->tree_root = btrfs_alloc_root(fs_info);
A
Al Viro 已提交
1983 1984 1985 1986
	extent_root = fs_info->extent_root = btrfs_alloc_root(fs_info);
	csum_root = fs_info->csum_root = btrfs_alloc_root(fs_info);
	chunk_root = fs_info->chunk_root = btrfs_alloc_root(fs_info);
	dev_root = fs_info->dev_root = btrfs_alloc_root(fs_info);
1987
	quota_root = fs_info->quota_root = btrfs_alloc_root(fs_info);
1988

1989
	if (!tree_root || !extent_root || !csum_root ||
1990
	    !chunk_root || !dev_root || !quota_root) {
C
Chris Mason 已提交
1991 1992 1993
		err = -ENOMEM;
		goto fail;
	}
1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012

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

	fs_info->btree_inode = new_inode(sb);
	if (!fs_info->btree_inode) {
		err = -ENOMEM;
		goto fail_bdi;
	}

2013
	mapping_set_gfp_mask(fs_info->btree_inode->i_mapping, GFP_NOFS);
2014

2015
	INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_ATOMIC);
C
Chris Mason 已提交
2016
	INIT_LIST_HEAD(&fs_info->trans_list);
2017
	INIT_LIST_HEAD(&fs_info->dead_roots);
Y
Yan, Zheng 已提交
2018
	INIT_LIST_HEAD(&fs_info->delayed_iputs);
2019
	INIT_LIST_HEAD(&fs_info->delalloc_inodes);
2020
	INIT_LIST_HEAD(&fs_info->ordered_operations);
2021
	INIT_LIST_HEAD(&fs_info->caching_block_groups);
2022
	spin_lock_init(&fs_info->delalloc_lock);
J
Josef Bacik 已提交
2023
	spin_lock_init(&fs_info->trans_lock);
2024
	spin_lock_init(&fs_info->fs_roots_radix_lock);
Y
Yan, Zheng 已提交
2025
	spin_lock_init(&fs_info->delayed_iput_lock);
C
Chris Mason 已提交
2026
	spin_lock_init(&fs_info->defrag_inodes_lock);
2027
	spin_lock_init(&fs_info->free_chunk_lock);
J
Jan Schmidt 已提交
2028 2029
	spin_lock_init(&fs_info->tree_mod_seq_lock);
	rwlock_init(&fs_info->tree_mod_log_lock);
C
Chris Mason 已提交
2030
	mutex_init(&fs_info->reloc_mutex);
2031

2032
	init_completion(&fs_info->kobj_unregister);
2033
	INIT_LIST_HEAD(&fs_info->dirty_cowonly_roots);
2034
	INIT_LIST_HEAD(&fs_info->space_info);
J
Jan Schmidt 已提交
2035
	INIT_LIST_HEAD(&fs_info->tree_mod_seq_list);
2036
	btrfs_mapping_init(&fs_info->mapping_tree);
2037 2038 2039 2040 2041 2042 2043 2044 2045
	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);
2046
	atomic_set(&fs_info->nr_async_submits, 0);
2047
	atomic_set(&fs_info->async_delalloc_pages, 0);
2048
	atomic_set(&fs_info->async_submit_draining, 0);
2049
	atomic_set(&fs_info->nr_async_bios, 0);
C
Chris Mason 已提交
2050
	atomic_set(&fs_info->defrag_running, 0);
J
Jan Schmidt 已提交
2051
	atomic_set(&fs_info->tree_mod_seq, 0);
C
Chris Mason 已提交
2052
	fs_info->sb = sb;
2053
	fs_info->max_inline = 8192 * 1024;
J
Josef Bacik 已提交
2054
	fs_info->metadata_ratio = 0;
C
Chris Mason 已提交
2055
	fs_info->defrag_inodes = RB_ROOT;
J
Josef Bacik 已提交
2056
	fs_info->trans_no_join = 0;
2057
	fs_info->free_chunk_space = 0;
J
Jan Schmidt 已提交
2058
	fs_info->tree_mod_log = RB_ROOT;
C
Chris Mason 已提交
2059

2060 2061 2062
	/* readahead state */
	INIT_RADIX_TREE(&fs_info->reada_tree, GFP_NOFS & ~__GFP_WAIT);
	spin_lock_init(&fs_info->reada_lock);
C
Chris Mason 已提交
2063

2064 2065
	fs_info->thread_pool_size = min_t(unsigned long,
					  num_online_cpus() + 2, 8);
2066

2067 2068
	INIT_LIST_HEAD(&fs_info->ordered_extents);
	spin_lock_init(&fs_info->ordered_extent_lock);
2069 2070 2071 2072 2073 2074 2075
	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);
2076

A
Arne Jansen 已提交
2077 2078 2079 2080 2081 2082 2083 2084
	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);
	init_waitqueue_head(&fs_info->scrub_pause_wait);
	init_rwsem(&fs_info->scrub_super_lock);
	fs_info->scrub_workers_refcnt = 0;
2085 2086 2087
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
	fs_info->check_integrity_print_mask = 0;
#endif
A
Arne Jansen 已提交
2088

2089 2090
	spin_lock_init(&fs_info->balance_lock);
	mutex_init(&fs_info->balance_mutex);
2091 2092
	atomic_set(&fs_info->balance_running, 0);
	atomic_set(&fs_info->balance_pause_req, 0);
2093
	atomic_set(&fs_info->balance_cancel_req, 0);
2094
	fs_info->balance_ctl = NULL;
2095
	init_waitqueue_head(&fs_info->balance_wait_q);
A
Arne Jansen 已提交
2096

2097 2098
	sb->s_blocksize = 4096;
	sb->s_blocksize_bits = blksize_bits(4096);
J
Jens Axboe 已提交
2099
	sb->s_bdi = &fs_info->bdi;
2100

2101
	fs_info->btree_inode->i_ino = BTRFS_BTREE_INODE_OBJECTID;
M
Miklos Szeredi 已提交
2102
	set_nlink(fs_info->btree_inode, 1);
2103 2104 2105 2106 2107 2108
	/*
	 * 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;
2109
	fs_info->btree_inode->i_mapping->a_ops = &btree_aops;
C
Chris Mason 已提交
2110 2111
	fs_info->btree_inode->i_mapping->backing_dev_info = &fs_info->bdi;

2112
	RB_CLEAR_NODE(&BTRFS_I(fs_info->btree_inode)->rb_node);
2113
	extent_io_tree_init(&BTRFS_I(fs_info->btree_inode)->io_tree,
2114
			     fs_info->btree_inode->i_mapping);
2115
	BTRFS_I(fs_info->btree_inode)->io_tree.track_uptodate = 0;
2116
	extent_map_tree_init(&BTRFS_I(fs_info->btree_inode)->extent_tree);
2117 2118

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

2120 2121 2122
	BTRFS_I(fs_info->btree_inode)->root = tree_root;
	memset(&BTRFS_I(fs_info->btree_inode)->location, 0,
	       sizeof(struct btrfs_key));
2123 2124
	set_bit(BTRFS_INODE_DUMMY,
		&BTRFS_I(fs_info->btree_inode)->runtime_flags);
2125
	insert_inode_hash(fs_info->btree_inode);
2126

J
Josef Bacik 已提交
2127
	spin_lock_init(&fs_info->block_group_cache_lock);
2128
	fs_info->block_group_cache_tree = RB_ROOT;
J
Josef Bacik 已提交
2129

2130
	extent_io_tree_init(&fs_info->freed_extents[0],
2131
			     fs_info->btree_inode->i_mapping);
2132
	extent_io_tree_init(&fs_info->freed_extents[1],
2133
			     fs_info->btree_inode->i_mapping);
2134
	fs_info->pinned_extents = &fs_info->freed_extents[0];
2135
	fs_info->do_barriers = 1;
2136

C
Chris Mason 已提交
2137

2138
	mutex_init(&fs_info->ordered_operations_mutex);
2139
	mutex_init(&fs_info->tree_log_mutex);
2140
	mutex_init(&fs_info->chunk_mutex);
2141 2142
	mutex_init(&fs_info->transaction_kthread_mutex);
	mutex_init(&fs_info->cleaner_mutex);
2143
	mutex_init(&fs_info->volume_mutex);
2144
	init_rwsem(&fs_info->extent_commit_sem);
2145
	init_rwsem(&fs_info->cleanup_work_sem);
2146
	init_rwsem(&fs_info->subvol_sem);
2147 2148 2149 2150 2151
	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);
2152

2153 2154 2155 2156 2157 2158 2159
	spin_lock_init(&fs_info->qgroup_lock);
	fs_info->qgroup_tree = RB_ROOT;
	INIT_LIST_HEAD(&fs_info->dirty_qgroups);
	fs_info->qgroup_seq = 1;
	fs_info->quota_enabled = 0;
	fs_info->pending_quota_state = 0;

2160 2161 2162
	btrfs_init_free_cluster(&fs_info->meta_alloc_cluster);
	btrfs_init_free_cluster(&fs_info->data_alloc_cluster);

2163
	init_waitqueue_head(&fs_info->transaction_throttle);
2164
	init_waitqueue_head(&fs_info->transaction_wait);
S
Sage Weil 已提交
2165
	init_waitqueue_head(&fs_info->transaction_blocked_wait);
2166
	init_waitqueue_head(&fs_info->async_submit_wait);
2167

2168
	__setup_root(4096, 4096, 4096, 4096, tree_root,
C
Chris Mason 已提交
2169
		     fs_info, BTRFS_ROOT_TREE_OBJECTID);
2170

2171
	invalidate_bdev(fs_devices->latest_bdev);
Y
Yan Zheng 已提交
2172
	bh = btrfs_read_dev_super(fs_devices->latest_bdev);
2173 2174
	if (!bh) {
		err = -EINVAL;
2175
		goto fail_alloc;
2176
	}
C
Chris Mason 已提交
2177

2178 2179 2180
	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));
2181
	brelse(bh);
2182

2183
	memcpy(fs_info->fsid, fs_info->super_copy->fsid, BTRFS_FSID_SIZE);
2184

2185
	disk_super = fs_info->super_copy;
2186
	if (!btrfs_super_root(disk_super))
2187
		goto fail_alloc;
2188

L
liubo 已提交
2189 2190 2191
	/* check FS state, whether FS is broken. */
	fs_info->fs_state |= btrfs_super_flags(disk_super);

2192 2193 2194 2195 2196 2197
	ret = btrfs_check_super_valid(fs_info, sb->s_flags & MS_RDONLY);
	if (ret) {
		printk(KERN_ERR "btrfs: superblock contains fatal errors\n");
		err = ret;
		goto fail_alloc;
	}
L
liubo 已提交
2198

C
Chris Mason 已提交
2199 2200 2201 2202 2203 2204 2205
	/*
	 * 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);

2206 2207 2208 2209 2210 2211
	/*
	 * 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 已提交
2212 2213 2214
	ret = btrfs_parse_options(tree_root, options);
	if (ret) {
		err = ret;
2215
		goto fail_alloc;
Y
Yan Zheng 已提交
2216
	}
2217

2218 2219 2220 2221 2222
	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",
2223
		       (unsigned long long)features);
2224
		err = -EINVAL;
2225
		goto fail_alloc;
2226 2227
	}

2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244
	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;
	}

2245
	features = btrfs_super_incompat_flags(disk_super);
L
Li Zefan 已提交
2246
	features |= BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF;
L
Li Zefan 已提交
2247
	if (tree_root->fs_info->compress_type == BTRFS_COMPRESS_LZO)
L
Li Zefan 已提交
2248
		features |= BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO;
2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259

	/*
	 * 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))
			printk(KERN_INFO "btrfs flagging fs with big metadata feature\n");
		features |= BTRFS_FEATURE_INCOMPAT_BIG_METADATA;
	}

2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276
	nodesize = btrfs_super_nodesize(disk_super);
	leafsize = btrfs_super_leafsize(disk_super);
	sectorsize = btrfs_super_sectorsize(disk_super);
	stripesize = btrfs_super_stripesize(disk_super);

	/*
	 * 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)) {
		printk(KERN_WARNING "btrfs: unequal leaf/node/sector sizes "
				"are not allowed for mixed block groups on %s\n",
				sb->s_id);
		goto fail_alloc;
	}

L
Li Zefan 已提交
2277
	btrfs_set_super_incompat_flags(disk_super, features);
2278

2279 2280 2281 2282 2283
	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",
2284
		       (unsigned long long)features);
2285
		err = -EINVAL;
2286
		goto fail_alloc;
2287
	}
2288 2289 2290 2291

	btrfs_init_workers(&fs_info->generic_worker,
			   "genwork", 1, NULL);

2292
	btrfs_init_workers(&fs_info->workers, "worker",
2293 2294
			   fs_info->thread_pool_size,
			   &fs_info->generic_worker);
C
Chris Mason 已提交
2295

2296
	btrfs_init_workers(&fs_info->delalloc_workers, "delalloc",
2297 2298
			   fs_info->thread_pool_size,
			   &fs_info->generic_worker);
2299

2300 2301 2302 2303
	btrfs_init_workers(&fs_info->flush_workers, "flush_delalloc",
			   fs_info->thread_pool_size,
			   &fs_info->generic_worker);

2304
	btrfs_init_workers(&fs_info->submit_workers, "submit",
2305
			   min_t(u64, fs_devices->num_devices,
2306 2307
			   fs_info->thread_pool_size),
			   &fs_info->generic_worker);
2308

2309 2310 2311
	btrfs_init_workers(&fs_info->caching_workers, "cache",
			   2, &fs_info->generic_worker);

2312 2313 2314 2315 2316
	/* a higher idle thresh on the submit workers makes it much more
	 * likely that bios will be send down in a sane order to the
	 * devices
	 */
	fs_info->submit_workers.idle_thresh = 64;
2317

2318
	fs_info->workers.idle_thresh = 16;
C
Chris Mason 已提交
2319
	fs_info->workers.ordered = 1;
2320

2321 2322 2323
	fs_info->delalloc_workers.idle_thresh = 2;
	fs_info->delalloc_workers.ordered = 1;

2324 2325
	btrfs_init_workers(&fs_info->fixup_workers, "fixup", 1,
			   &fs_info->generic_worker);
2326
	btrfs_init_workers(&fs_info->endio_workers, "endio",
2327 2328
			   fs_info->thread_pool_size,
			   &fs_info->generic_worker);
2329
	btrfs_init_workers(&fs_info->endio_meta_workers, "endio-meta",
2330 2331
			   fs_info->thread_pool_size,
			   &fs_info->generic_worker);
2332
	btrfs_init_workers(&fs_info->endio_meta_write_workers,
2333 2334
			   "endio-meta-write", fs_info->thread_pool_size,
			   &fs_info->generic_worker);
2335
	btrfs_init_workers(&fs_info->endio_write_workers, "endio-write",
2336 2337
			   fs_info->thread_pool_size,
			   &fs_info->generic_worker);
J
Josef Bacik 已提交
2338 2339
	btrfs_init_workers(&fs_info->endio_freespace_worker, "freespace-write",
			   1, &fs_info->generic_worker);
2340 2341 2342
	btrfs_init_workers(&fs_info->delayed_workers, "delayed-meta",
			   fs_info->thread_pool_size,
			   &fs_info->generic_worker);
2343 2344 2345
	btrfs_init_workers(&fs_info->readahead_workers, "readahead",
			   fs_info->thread_pool_size,
			   &fs_info->generic_worker);
2346 2347 2348 2349 2350 2351

	/*
	 * endios are largely parallel and should have a very
	 * low idle thresh
	 */
	fs_info->endio_workers.idle_thresh = 4;
2352 2353
	fs_info->endio_meta_workers.idle_thresh = 4;

2354 2355
	fs_info->endio_write_workers.idle_thresh = 2;
	fs_info->endio_meta_write_workers.idle_thresh = 2;
2356
	fs_info->readahead_workers.idle_thresh = 2;
2357

2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374
	/*
	 * btrfs_start_workers can really only fail because of ENOMEM so just
	 * return -ENOMEM if any of these fail.
	 */
	ret = btrfs_start_workers(&fs_info->workers);
	ret |= btrfs_start_workers(&fs_info->generic_worker);
	ret |= btrfs_start_workers(&fs_info->submit_workers);
	ret |= btrfs_start_workers(&fs_info->delalloc_workers);
	ret |= btrfs_start_workers(&fs_info->fixup_workers);
	ret |= btrfs_start_workers(&fs_info->endio_workers);
	ret |= btrfs_start_workers(&fs_info->endio_meta_workers);
	ret |= btrfs_start_workers(&fs_info->endio_meta_write_workers);
	ret |= btrfs_start_workers(&fs_info->endio_write_workers);
	ret |= btrfs_start_workers(&fs_info->endio_freespace_worker);
	ret |= btrfs_start_workers(&fs_info->delayed_workers);
	ret |= btrfs_start_workers(&fs_info->caching_workers);
	ret |= btrfs_start_workers(&fs_info->readahead_workers);
2375
	ret |= btrfs_start_workers(&fs_info->flush_workers);
2376
	if (ret) {
2377
		err = -ENOMEM;
2378 2379
		goto fail_sb_buffer;
	}
2380

2381
	fs_info->bdi.ra_pages *= btrfs_super_num_devices(disk_super);
C
Chris Mason 已提交
2382 2383
	fs_info->bdi.ra_pages = max(fs_info->bdi.ra_pages,
				    4 * 1024 * 1024 / PAGE_CACHE_SIZE);
2384

2385 2386 2387
	tree_root->nodesize = nodesize;
	tree_root->leafsize = leafsize;
	tree_root->sectorsize = sectorsize;
2388
	tree_root->stripesize = stripesize;
2389 2390 2391

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

C
Chris Mason 已提交
2393 2394
	if (strncmp((char *)(&disk_super->magic), BTRFS_MAGIC,
		    sizeof(disk_super->magic))) {
C
Chris Mason 已提交
2395
		printk(KERN_INFO "btrfs: valid FS not found on %s\n", sb->s_id);
C
Chris Mason 已提交
2396 2397
		goto fail_sb_buffer;
	}
2398

2399 2400 2401
	if (sectorsize != PAGE_SIZE) {
		printk(KERN_WARNING "btrfs: Incompatible sector size(%lu) "
		       "found on %s\n", (unsigned long)sectorsize, sb->s_id);
2402 2403 2404
		goto fail_sb_buffer;
	}

2405
	mutex_lock(&fs_info->chunk_mutex);
Y
Yan Zheng 已提交
2406
	ret = btrfs_read_sys_array(tree_root);
2407
	mutex_unlock(&fs_info->chunk_mutex);
2408
	if (ret) {
C
Chris Mason 已提交
2409 2410
		printk(KERN_WARNING "btrfs: failed to read the system "
		       "array on %s\n", sb->s_id);
2411
		goto fail_sb_buffer;
2412
	}
2413 2414 2415

	blocksize = btrfs_level_size(tree_root,
				     btrfs_super_chunk_root_level(disk_super));
2416
	generation = btrfs_super_chunk_root_generation(disk_super);
2417 2418 2419 2420 2421 2422

	__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),
2423
					   blocksize, generation);
2424
	BUG_ON(!chunk_root->node); /* -ENOMEM */
2425 2426 2427
	if (!test_bit(EXTENT_BUFFER_UPTODATE, &chunk_root->node->bflags)) {
		printk(KERN_WARNING "btrfs: failed to read chunk root on %s\n",
		       sb->s_id);
C
Chris Mason 已提交
2428
		goto fail_tree_roots;
2429
	}
2430 2431
	btrfs_set_root_node(&chunk_root->root_item, chunk_root->node);
	chunk_root->commit_root = btrfs_root_node(chunk_root);
2432

2433
	read_extent_buffer(chunk_root->node, fs_info->chunk_tree_uuid,
C
Chris Mason 已提交
2434 2435
	   (unsigned long)btrfs_header_chunk_tree_uuid(chunk_root->node),
	   BTRFS_UUID_SIZE);
2436

2437
	ret = btrfs_read_chunk_tree(chunk_root);
Y
Yan Zheng 已提交
2438
	if (ret) {
C
Chris Mason 已提交
2439 2440
		printk(KERN_WARNING "btrfs: failed to read chunk tree on %s\n",
		       sb->s_id);
C
Chris Mason 已提交
2441
		goto fail_tree_roots;
Y
Yan Zheng 已提交
2442
	}
2443

2444 2445 2446 2447 2448
	/*
	 * 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);
2449

2450 2451 2452 2453 2454 2455
	if (!fs_devices->latest_bdev) {
		printk(KERN_CRIT "btrfs: failed to read devices on %s\n",
		       sb->s_id);
		goto fail_tree_roots;
	}

C
Chris Mason 已提交
2456
retry_root_backup:
2457 2458
	blocksize = btrfs_level_size(tree_root,
				     btrfs_super_root_level(disk_super));
2459
	generation = btrfs_super_generation(disk_super);
2460

C
Chris Mason 已提交
2461
	tree_root->node = read_tree_block(tree_root,
2462
					  btrfs_super_root(disk_super),
2463
					  blocksize, generation);
C
Chris Mason 已提交
2464 2465
	if (!tree_root->node ||
	    !test_bit(EXTENT_BUFFER_UPTODATE, &tree_root->node->bflags)) {
2466 2467
		printk(KERN_WARNING "btrfs: failed to read tree root on %s\n",
		       sb->s_id);
C
Chris Mason 已提交
2468 2469

		goto recovery_tree_root;
2470
	}
C
Chris Mason 已提交
2471

2472 2473
	btrfs_set_root_node(&tree_root->root_item, tree_root->node);
	tree_root->commit_root = btrfs_root_node(tree_root);
2474 2475

	ret = find_and_setup_root(tree_root, fs_info,
C
Chris Mason 已提交
2476
				  BTRFS_EXTENT_TREE_OBJECTID, extent_root);
2477
	if (ret)
C
Chris Mason 已提交
2478
		goto recovery_tree_root;
2479 2480 2481 2482 2483
	extent_root->track_dirty = 1;

	ret = find_and_setup_root(tree_root, fs_info,
				  BTRFS_DEV_TREE_OBJECTID, dev_root);
	if (ret)
C
Chris Mason 已提交
2484
		goto recovery_tree_root;
2485
	dev_root->track_dirty = 1;
2486

2487 2488 2489
	ret = find_and_setup_root(tree_root, fs_info,
				  BTRFS_CSUM_TREE_OBJECTID, csum_root);
	if (ret)
C
Chris Mason 已提交
2490
		goto recovery_tree_root;
2491 2492
	csum_root->track_dirty = 1;

2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503
	ret = find_and_setup_root(tree_root, fs_info,
				  BTRFS_QUOTA_TREE_OBJECTID, quota_root);
	if (ret) {
		kfree(quota_root);
		quota_root = fs_info->quota_root = NULL;
	} else {
		quota_root->track_dirty = 1;
		fs_info->quota_enabled = 1;
		fs_info->pending_quota_state = 1;
	}

2504 2505 2506
	fs_info->generation = generation;
	fs_info->last_trans_committed = generation;

2507 2508 2509 2510 2511 2512
	ret = btrfs_recover_balance(fs_info);
	if (ret) {
		printk(KERN_WARNING "btrfs: failed to recover balance\n");
		goto fail_block_groups;
	}

2513 2514 2515 2516 2517 2518 2519
	ret = btrfs_init_dev_stats(fs_info);
	if (ret) {
		printk(KERN_ERR "btrfs: failed to init dev_stats: %d\n",
		       ret);
		goto fail_block_groups;
	}

2520 2521 2522 2523 2524 2525 2526 2527
	ret = btrfs_init_dev_replace(fs_info);
	if (ret) {
		pr_err("btrfs: failed to init dev_replace: %d\n", ret);
		goto fail_block_groups;
	}

	btrfs_close_extra_devices(fs_info, fs_devices, 1);

2528 2529 2530 2531 2532 2533
	ret = btrfs_init_space_info(fs_info);
	if (ret) {
		printk(KERN_ERR "Failed to initial space info: %d\n", ret);
		goto fail_block_groups;
	}

2534 2535 2536 2537 2538
	ret = btrfs_read_block_groups(extent_root);
	if (ret) {
		printk(KERN_ERR "Failed to read block groups: %d\n", ret);
		goto fail_block_groups;
	}
2539 2540
	fs_info->num_tolerated_disk_barrier_failures =
		btrfs_calc_num_tolerated_disk_barrier_failures(fs_info);
2541 2542 2543 2544 2545 2546 2547
	if (fs_info->fs_devices->missing_devices >
	     fs_info->num_tolerated_disk_barrier_failures &&
	    !(sb->s_flags & MS_RDONLY)) {
		printk(KERN_WARNING
		       "Btrfs: too many missing devices, writeable mount is not allowed\n");
		goto fail_block_groups;
	}
C
Chris Mason 已提交
2548

2549 2550
	fs_info->cleaner_kthread = kthread_run(cleaner_kthread, tree_root,
					       "btrfs-cleaner");
2551
	if (IS_ERR(fs_info->cleaner_kthread))
2552
		goto fail_block_groups;
2553 2554 2555 2556

	fs_info->transaction_kthread = kthread_run(transaction_kthread,
						   tree_root,
						   "btrfs-transaction");
2557
	if (IS_ERR(fs_info->transaction_kthread))
2558
		goto fail_cleaner;
2559

C
Chris Mason 已提交
2560 2561 2562 2563 2564 2565 2566 2567
	if (!btrfs_test_opt(tree_root, SSD) &&
	    !btrfs_test_opt(tree_root, NOSSD) &&
	    !fs_info->fs_devices->rotating) {
		printk(KERN_INFO "Btrfs detected SSD devices, enabling SSD "
		       "mode\n");
		btrfs_set_opt(fs_info->mount_opt, SSD);
	}

2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579
#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)
			printk(KERN_WARNING "btrfs: failed to initialize"
			       " integrity check module %s\n", sb->s_id);
	}
#endif
2580 2581 2582
	ret = btrfs_read_qgroup_config(fs_info);
	if (ret)
		goto fail_trans_kthread;
2583

L
liubo 已提交
2584
	/* do not make disk changes in broken FS */
2585
	if (btrfs_super_log_root(disk_super) != 0) {
2586 2587
		u64 bytenr = btrfs_super_log_root(disk_super);

2588
		if (fs_devices->rw_devices == 0) {
C
Chris Mason 已提交
2589 2590
			printk(KERN_WARNING "Btrfs log replay required "
			       "on RO media\n");
2591
			err = -EIO;
2592
			goto fail_qgroup;
2593
		}
2594 2595 2596
		blocksize =
		     btrfs_level_size(tree_root,
				      btrfs_super_log_root_level(disk_super));
C
Chris Mason 已提交
2597

A
Al Viro 已提交
2598
		log_tree_root = btrfs_alloc_root(fs_info);
2599 2600
		if (!log_tree_root) {
			err = -ENOMEM;
2601
			goto fail_qgroup;
2602
		}
2603 2604 2605 2606 2607

		__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,
2608 2609
						      blocksize,
						      generation + 1);
2610
		/* returns with log_tree_root freed on success */
2611
		ret = btrfs_recover_log_trees(log_tree_root);
2612 2613 2614 2615 2616 2617 2618
		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);
			goto fail_trans_kthread;
		}
2619 2620

		if (sb->s_flags & MS_RDONLY) {
2621 2622 2623
			ret = btrfs_commit_super(tree_root);
			if (ret)
				goto fail_trans_kthread;
2624
		}
2625
	}
Z
Zheng Yan 已提交
2626

2627
	ret = btrfs_find_orphan_roots(tree_root);
2628 2629
	if (ret)
		goto fail_trans_kthread;
2630

2631
	if (!(sb->s_flags & MS_RDONLY)) {
2632
		ret = btrfs_cleanup_fs_roots(fs_info);
2633 2634
		if (ret)
			goto fail_trans_kthread;
2635

2636
		ret = btrfs_recover_relocation(tree_root);
2637 2638 2639 2640
		if (ret < 0) {
			printk(KERN_WARNING
			       "btrfs: failed to recover relocation\n");
			err = -EINVAL;
2641
			goto fail_qgroup;
2642
		}
2643
	}
Z
Zheng Yan 已提交
2644

2645 2646 2647 2648 2649 2650
	location.objectid = BTRFS_FS_TREE_OBJECTID;
	location.type = BTRFS_ROOT_ITEM_KEY;
	location.offset = (u64)-1;

	fs_info->fs_root = btrfs_read_fs_root_no_name(fs_info, &location);
	if (!fs_info->fs_root)
2651
		goto fail_qgroup;
2652 2653
	if (IS_ERR(fs_info->fs_root)) {
		err = PTR_ERR(fs_info->fs_root);
2654
		goto fail_qgroup;
2655
	}
C
Chris Mason 已提交
2656

2657 2658
	if (sb->s_flags & MS_RDONLY)
		return 0;
I
Ilya Dryomov 已提交
2659

2660 2661 2662
	down_read(&fs_info->cleanup_work_sem);
	if ((ret = btrfs_orphan_cleanup(fs_info->fs_root)) ||
	    (ret = btrfs_orphan_cleanup(fs_info->tree_root))) {
2663
		up_read(&fs_info->cleanup_work_sem);
2664 2665 2666 2667
		close_ctree(tree_root);
		return ret;
	}
	up_read(&fs_info->cleanup_work_sem);
I
Ilya Dryomov 已提交
2668

2669 2670 2671 2672 2673
	ret = btrfs_resume_balance_async(fs_info);
	if (ret) {
		printk(KERN_WARNING "btrfs: failed to resume balance\n");
		close_ctree(tree_root);
		return ret;
2674 2675
	}

2676 2677 2678 2679 2680 2681 2682
	ret = btrfs_resume_dev_replace_async(fs_info);
	if (ret) {
		pr_warn("btrfs: failed to resume dev_replace\n");
		close_ctree(tree_root);
		return ret;
	}

A
Al Viro 已提交
2683
	return 0;
C
Chris Mason 已提交
2684

2685 2686
fail_qgroup:
	btrfs_free_qgroup_config(fs_info);
2687 2688
fail_trans_kthread:
	kthread_stop(fs_info->transaction_kthread);
2689
fail_cleaner:
2690
	kthread_stop(fs_info->cleaner_kthread);
2691 2692 2693 2694 2695 2696 2697 2698

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

2699 2700
fail_block_groups:
	btrfs_free_block_groups(fs_info);
C
Chris Mason 已提交
2701 2702 2703 2704

fail_tree_roots:
	free_root_pointers(fs_info, 1);

C
Chris Mason 已提交
2705
fail_sb_buffer:
2706
	btrfs_stop_workers(&fs_info->generic_worker);
2707
	btrfs_stop_workers(&fs_info->readahead_workers);
2708
	btrfs_stop_workers(&fs_info->fixup_workers);
2709
	btrfs_stop_workers(&fs_info->delalloc_workers);
2710 2711
	btrfs_stop_workers(&fs_info->workers);
	btrfs_stop_workers(&fs_info->endio_workers);
2712
	btrfs_stop_workers(&fs_info->endio_meta_workers);
2713
	btrfs_stop_workers(&fs_info->endio_meta_write_workers);
2714
	btrfs_stop_workers(&fs_info->endio_write_workers);
J
Josef Bacik 已提交
2715
	btrfs_stop_workers(&fs_info->endio_freespace_worker);
2716
	btrfs_stop_workers(&fs_info->submit_workers);
2717
	btrfs_stop_workers(&fs_info->delayed_workers);
2718
	btrfs_stop_workers(&fs_info->caching_workers);
2719
	btrfs_stop_workers(&fs_info->flush_workers);
2720
fail_alloc:
2721
fail_iput:
2722 2723
	btrfs_mapping_tree_free(&fs_info->mapping_tree);

2724
	invalidate_inode_pages2(fs_info->btree_inode->i_mapping);
2725
	iput(fs_info->btree_inode);
2726
fail_bdi:
2727
	bdi_destroy(&fs_info->bdi);
2728 2729
fail_srcu:
	cleanup_srcu_struct(&fs_info->subvol_srcu);
2730
fail:
2731
	btrfs_close_devices(fs_info->fs_devices);
A
Al Viro 已提交
2732
	return err;
C
Chris Mason 已提交
2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750

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

2753 2754 2755 2756 2757
static void btrfs_end_buffer_write_sync(struct buffer_head *bh, int uptodate)
{
	if (uptodate) {
		set_buffer_uptodate(bh);
	} else {
2758 2759 2760
		struct btrfs_device *device = (struct btrfs_device *)
			bh->b_private;

2761 2762 2763
		printk_ratelimited_in_rcu(KERN_WARNING "lost page write due to "
					  "I/O error on %s\n",
					  rcu_str_deref(device->name));
2764 2765 2766
		/* note, we dont' set_buffer_write_io_error because we have
		 * our own ways of dealing with the IO errors
		 */
2767
		clear_buffer_uptodate(bh);
2768
		btrfs_dev_stat_inc_and_print(device, BTRFS_DEV_STAT_WRITE_ERRS);
2769 2770 2771 2772 2773
	}
	unlock_buffer(bh);
	put_bh(bh);
}

Y
Yan Zheng 已提交
2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814
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);
		if (bytenr + 4096 >= i_size_read(bdev->bd_inode))
			break;
		bh = __bread(bdev, bytenr / 4096, 4096);
		if (!bh)
			continue;

		super = (struct btrfs_super_block *)bh->b_data;
		if (btrfs_super_bytenr(super) != bytenr ||
		    strncmp((char *)(&super->magic), BTRFS_MAGIC,
			    sizeof(super->magic))) {
			brelse(bh);
			continue;
		}

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

2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825
/*
 * 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 已提交
2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849
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);
			BUG_ON(!bh);
			wait_on_buffer(bh);
2850 2851 2852 2853 2854 2855 2856 2857 2858
			if (!buffer_uptodate(bh))
				errors++;

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

			/* drop the reference from the wait == 0 run */
			brelse(bh);
			continue;
Y
Yan Zheng 已提交
2859 2860 2861 2862 2863 2864 2865 2866 2867 2868
		} else {
			btrfs_set_super_bytenr(sb, bytenr);

			crc = ~(u32)0;
			crc = btrfs_csum_data(NULL, (char *)sb +
					      BTRFS_CSUM_SIZE, crc,
					      BTRFS_SUPER_INFO_SIZE -
					      BTRFS_CSUM_SIZE);
			btrfs_csum_final(crc, sb->csum);

2869 2870 2871 2872
			/*
			 * one reference for us, and we leave it for the
			 * caller
			 */
Y
Yan Zheng 已提交
2873 2874 2875 2876
			bh = __getblk(device->bdev, bytenr / 4096,
				      BTRFS_SUPER_INFO_SIZE);
			memcpy(bh->b_data, sb, BTRFS_SUPER_INFO_SIZE);

2877
			/* one reference for submit_bh */
Y
Yan Zheng 已提交
2878
			get_bh(bh);
2879 2880

			set_buffer_uptodate(bh);
Y
Yan Zheng 已提交
2881 2882
			lock_buffer(bh);
			bh->b_end_io = btrfs_end_buffer_write_sync;
2883
			bh->b_private = device;
Y
Yan Zheng 已提交
2884 2885
		}

C
Chris Mason 已提交
2886 2887 2888 2889
		/*
		 * we fua the first super.  The others we allow
		 * to go down lazy.
		 */
2890
		ret = btrfsic_submit_bh(WRITE_FUA, bh);
2891
		if (ret)
Y
Yan Zheng 已提交
2892 2893 2894 2895 2896
			errors++;
	}
	return errors < i ? 0 : -1;
}

C
Chris Mason 已提交
2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935
/*
 * 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)) {
2936 2937
			printk_in_rcu("btrfs: disabling barriers on dev %s\n",
				      rcu_str_deref(device->name));
C
Chris Mason 已提交
2938
			device->nobarriers = 1;
2939
		} else if (!bio_flagged(bio, BIO_UPTODATE)) {
C
Chris Mason 已提交
2940
			ret = -EIO;
2941 2942
			btrfs_dev_stat_inc_and_print(device,
				BTRFS_DEV_STAT_FLUSH_ERRS);
C
Chris Mason 已提交
2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955
		}

		/* 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
	 */
2956
	device->flush_bio = NULL;
C
Chris Mason 已提交
2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967
	bio = bio_alloc(GFP_NOFS, 0);
	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);
2968
	btrfsic_submit_bio(WRITE_FLUSH, bio);
C
Chris Mason 已提交
2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980

	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;
2981 2982
	int errors_send = 0;
	int errors_wait = 0;
C
Chris Mason 已提交
2983 2984 2985 2986 2987 2988
	int ret;

	/* send down all the barriers */
	head = &info->fs_devices->devices;
	list_for_each_entry_rcu(dev, head, dev_list) {
		if (!dev->bdev) {
2989
			errors_send++;
C
Chris Mason 已提交
2990 2991 2992 2993 2994 2995 2996
			continue;
		}
		if (!dev->in_fs_metadata || !dev->writeable)
			continue;

		ret = write_dev_flush(dev, 0);
		if (ret)
2997
			errors_send++;
C
Chris Mason 已提交
2998 2999 3000 3001 3002
	}

	/* wait for all the barriers */
	list_for_each_entry_rcu(dev, head, dev_list) {
		if (!dev->bdev) {
3003
			errors_wait++;
C
Chris Mason 已提交
3004 3005 3006 3007 3008 3009 3010
			continue;
		}
		if (!dev->in_fs_metadata || !dev->writeable)
			continue;

		ret = write_dev_flush(dev, 1);
		if (ret)
3011
			errors_wait++;
C
Chris Mason 已提交
3012
	}
3013 3014
	if (errors_send > info->num_tolerated_disk_barrier_failures ||
	    errors_wait > info->num_tolerated_disk_barrier_failures)
C
Chris Mason 已提交
3015 3016 3017 3018
		return -EIO;
	return 0;
}

3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091
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;
				else if (num_tolerated_disk_barrier_failures > 1
					 &&
					 (flags & (BTRFS_BLOCK_GROUP_RAID1 |
						   BTRFS_BLOCK_GROUP_RAID10)))
					num_tolerated_disk_barrier_failures = 1;
			}
		}
		up_read(&sinfo->groups_sem);
	}

	return num_tolerated_disk_barrier_failures;
}

Y
Yan Zheng 已提交
3092
int write_all_supers(struct btrfs_root *root, int max_mirrors)
3093
{
3094
	struct list_head *head;
3095
	struct btrfs_device *dev;
3096
	struct btrfs_super_block *sb;
3097 3098 3099
	struct btrfs_dev_item *dev_item;
	int ret;
	int do_barriers;
3100 3101
	int max_errors;
	int total_errors = 0;
3102
	u64 flags;
3103

3104
	max_errors = btrfs_super_num_devices(root->fs_info->super_copy) - 1;
3105
	do_barriers = !btrfs_test_opt(root, NOBARRIER);
C
Chris Mason 已提交
3106
	backup_super_roots(root->fs_info);
3107

3108
	sb = root->fs_info->super_for_commit;
3109
	dev_item = &sb->dev_item;
3110

3111
	mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
3112
	head = &root->fs_info->fs_devices->devices;
C
Chris Mason 已提交
3113

3114 3115 3116 3117 3118 3119 3120 3121 3122 3123
	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 已提交
3124

3125
	list_for_each_entry_rcu(dev, head, dev_list) {
3126 3127 3128 3129
		if (!dev->bdev) {
			total_errors++;
			continue;
		}
Y
Yan Zheng 已提交
3130
		if (!dev->in_fs_metadata || !dev->writeable)
3131 3132
			continue;

Y
Yan Zheng 已提交
3133
		btrfs_set_stack_device_generation(dev_item, 0);
3134 3135 3136 3137 3138 3139 3140 3141
		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 已提交
3142
		memcpy(dev_item->fsid, dev->fs_devices->fsid, BTRFS_UUID_SIZE);
Y
Yan Zheng 已提交
3143

3144 3145 3146
		flags = btrfs_super_flags(sb);
		btrfs_set_super_flags(sb, flags | BTRFS_HEADER_FLAG_WRITTEN);

Y
Yan Zheng 已提交
3147
		ret = write_dev_supers(dev, sb, do_barriers, 0, max_mirrors);
3148 3149
		if (ret)
			total_errors++;
3150
	}
3151
	if (total_errors > max_errors) {
C
Chris Mason 已提交
3152 3153
		printk(KERN_ERR "btrfs: %d errors while writing supers\n",
		       total_errors);
3154 3155

		/* This shouldn't happen. FUA is masked off if unsupported */
3156 3157
		BUG();
	}
3158

Y
Yan Zheng 已提交
3159
	total_errors = 0;
3160
	list_for_each_entry_rcu(dev, head, dev_list) {
3161 3162
		if (!dev->bdev)
			continue;
Y
Yan Zheng 已提交
3163
		if (!dev->in_fs_metadata || !dev->writeable)
3164 3165
			continue;

Y
Yan Zheng 已提交
3166 3167 3168
		ret = write_dev_supers(dev, sb, do_barriers, 1, max_mirrors);
		if (ret)
			total_errors++;
3169
	}
3170
	mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
3171
	if (total_errors > max_errors) {
3172 3173 3174
		btrfs_error(root->fs_info, -EIO,
			    "%d errors while writing supers", total_errors);
		return -EIO;
3175
	}
3176 3177 3178
	return 0;
}

Y
Yan Zheng 已提交
3179 3180
int write_ctree_super(struct btrfs_trans_handle *trans,
		      struct btrfs_root *root, int max_mirrors)
3181
{
3182
	int ret;
3183

Y
Yan Zheng 已提交
3184
	ret = write_all_supers(root, max_mirrors);
3185
	return ret;
C
Chris Mason 已提交
3186 3187
}

3188
void btrfs_free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root)
C
Chris Mason 已提交
3189
{
3190
	spin_lock(&fs_info->fs_roots_radix_lock);
C
Chris Mason 已提交
3191 3192
	radix_tree_delete(&fs_info->fs_roots_radix,
			  (unsigned long)root->root_key.objectid);
3193
	spin_unlock(&fs_info->fs_roots_radix_lock);
3194 3195 3196 3197

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

3198 3199
	__btrfs_remove_free_space_cache(root->free_ino_pinned);
	__btrfs_remove_free_space_cache(root->free_ino_ctl);
3200 3201 3202 3203 3204
	free_fs_root(root);
}

static void free_fs_root(struct btrfs_root *root)
{
3205
	iput(root->cache_inode);
3206
	WARN_ON(!RB_EMPTY_ROOT(&root->inode_tree));
3207 3208
	if (root->anon_dev)
		free_anon_bdev(root->anon_dev);
3209 3210
	free_extent_buffer(root->node);
	free_extent_buffer(root->commit_root);
3211 3212
	kfree(root->free_ino_ctl);
	kfree(root->free_ino_pinned);
C
Chris Mason 已提交
3213
	kfree(root->name);
C
Chris Mason 已提交
3214 3215 3216
	kfree(root);
}

3217
static void del_fs_roots(struct btrfs_fs_info *fs_info)
3218 3219 3220 3221 3222
{
	int ret;
	struct btrfs_root *gang[8];
	int i;

3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236
	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);

		if (gang[0]->in_radix) {
			btrfs_free_fs_root(fs_info, gang[0]);
		} else {
			free_extent_buffer(gang[0]->node);
			free_extent_buffer(gang[0]->commit_root);
			kfree(gang[0]);
		}
	}

C
Chris Mason 已提交
3237
	while (1) {
3238 3239 3240 3241 3242
		ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
					     (void **)gang, 0,
					     ARRAY_SIZE(gang));
		if (!ret)
			break;
C
Chris Mason 已提交
3243
		for (i = 0; i < ret; i++)
3244
			btrfs_free_fs_root(fs_info, gang[i]);
3245 3246
	}
}
3247

Y
Yan Zheng 已提交
3248
int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info)
C
Chris Mason 已提交
3249
{
Y
Yan Zheng 已提交
3250 3251 3252
	u64 root_objectid = 0;
	struct btrfs_root *gang[8];
	int i;
3253
	int ret;
3254

Y
Yan Zheng 已提交
3255 3256 3257 3258 3259 3260
	while (1) {
		ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
					     (void **)gang, root_objectid,
					     ARRAY_SIZE(gang));
		if (!ret)
			break;
3261 3262

		root_objectid = gang[ret - 1]->root_key.objectid + 1;
Y
Yan Zheng 已提交
3263
		for (i = 0; i < ret; i++) {
3264 3265
			int err;

Y
Yan Zheng 已提交
3266
			root_objectid = gang[i]->root_key.objectid;
3267 3268 3269
			err = btrfs_orphan_cleanup(gang[i]);
			if (err)
				return err;
Y
Yan Zheng 已提交
3270 3271 3272 3273 3274
		}
		root_objectid++;
	}
	return 0;
}
3275

Y
Yan Zheng 已提交
3276 3277 3278 3279
int btrfs_commit_super(struct btrfs_root *root)
{
	struct btrfs_trans_handle *trans;
	int ret;
3280

Y
Yan Zheng 已提交
3281
	mutex_lock(&root->fs_info->cleaner_mutex);
Y
Yan, Zheng 已提交
3282
	btrfs_run_delayed_iputs(root);
3283
	btrfs_clean_old_snapshots(root);
Y
Yan Zheng 已提交
3284
	mutex_unlock(&root->fs_info->cleaner_mutex);
3285 3286 3287 3288 3289

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

3290
	trans = btrfs_join_transaction(root);
3291 3292
	if (IS_ERR(trans))
		return PTR_ERR(trans);
3293
	ret = btrfs_commit_transaction(trans, root);
3294 3295
	if (ret)
		return ret;
Y
Yan Zheng 已提交
3296
	/* run commit again to drop the original snapshot */
3297
	trans = btrfs_join_transaction(root);
3298 3299
	if (IS_ERR(trans))
		return PTR_ERR(trans);
3300 3301 3302
	ret = btrfs_commit_transaction(trans, root);
	if (ret)
		return ret;
C
Chris Mason 已提交
3303
	ret = btrfs_write_and_wait_transaction(NULL, root);
3304 3305 3306 3307 3308
	if (ret) {
		btrfs_error(root->fs_info, ret,
			    "Failed to sync btree inode to disk.");
		return ret;
	}
3309

Y
Yan Zheng 已提交
3310
	ret = write_ctree_super(NULL, root, 0);
Y
Yan Zheng 已提交
3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321
	return ret;
}

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

	fs_info->closing = 1;
	smp_mb();

3322
	/* pause restriper - we want to resume on mount */
3323
	btrfs_pause_balance(fs_info);
3324

3325 3326
	btrfs_dev_replace_suspend_for_unmount(fs_info);

3327
	btrfs_scrub_cancel(fs_info);
C
Chris Mason 已提交
3328 3329 3330 3331 3332 3333

	/* 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 */
3334
	btrfs_cleanup_defrag_inodes(fs_info);
C
Chris Mason 已提交
3335

Y
Yan Zheng 已提交
3336
	if (!(fs_info->sb->s_flags & MS_RDONLY)) {
L
liubo 已提交
3337 3338 3339 3340 3341
		ret = btrfs_commit_super(root);
		if (ret)
			printk(KERN_ERR "btrfs: commit super ret %d\n", ret);
	}

3342 3343
	if (fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR)
		btrfs_error_commit_super(root);
3344

3345 3346
	btrfs_put_block_group_cache(fs_info);

A
Al Viro 已提交
3347 3348
	kthread_stop(fs_info->transaction_kthread);
	kthread_stop(fs_info->cleaner_kthread);
3349

3350 3351 3352
	fs_info->closing = 2;
	smp_mb();

3353 3354
	btrfs_free_qgroup_config(root->fs_info);

C
Chris Mason 已提交
3355
	if (fs_info->delalloc_bytes) {
C
Chris Mason 已提交
3356
		printk(KERN_INFO "btrfs: at unmount delalloc count %llu\n",
3357
		       (unsigned long long)fs_info->delalloc_bytes);
C
Chris Mason 已提交
3358
	}
3359

3360 3361 3362 3363
	free_extent_buffer(fs_info->extent_root->node);
	free_extent_buffer(fs_info->extent_root->commit_root);
	free_extent_buffer(fs_info->tree_root->node);
	free_extent_buffer(fs_info->tree_root->commit_root);
A
Al Viro 已提交
3364 3365 3366 3367 3368 3369
	free_extent_buffer(fs_info->chunk_root->node);
	free_extent_buffer(fs_info->chunk_root->commit_root);
	free_extent_buffer(fs_info->dev_root->node);
	free_extent_buffer(fs_info->dev_root->commit_root);
	free_extent_buffer(fs_info->csum_root->node);
	free_extent_buffer(fs_info->csum_root->commit_root);
3370 3371 3372 3373
	if (fs_info->quota_root) {
		free_extent_buffer(fs_info->quota_root->node);
		free_extent_buffer(fs_info->quota_root->commit_root);
	}
3374

A
Al Viro 已提交
3375
	btrfs_free_block_groups(fs_info);
3376

Y
Yan Zheng 已提交
3377
	del_fs_roots(fs_info);
3378

Y
Yan Zheng 已提交
3379
	iput(fs_info->btree_inode);
3380

3381
	btrfs_stop_workers(&fs_info->generic_worker);
3382
	btrfs_stop_workers(&fs_info->fixup_workers);
3383
	btrfs_stop_workers(&fs_info->delalloc_workers);
3384 3385
	btrfs_stop_workers(&fs_info->workers);
	btrfs_stop_workers(&fs_info->endio_workers);
3386
	btrfs_stop_workers(&fs_info->endio_meta_workers);
3387
	btrfs_stop_workers(&fs_info->endio_meta_write_workers);
3388
	btrfs_stop_workers(&fs_info->endio_write_workers);
J
Josef Bacik 已提交
3389
	btrfs_stop_workers(&fs_info->endio_freespace_worker);
3390
	btrfs_stop_workers(&fs_info->submit_workers);
3391
	btrfs_stop_workers(&fs_info->delayed_workers);
3392
	btrfs_stop_workers(&fs_info->caching_workers);
3393
	btrfs_stop_workers(&fs_info->readahead_workers);
3394
	btrfs_stop_workers(&fs_info->flush_workers);
3395

3396 3397 3398 3399 3400
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
	if (btrfs_test_opt(root, CHECK_INTEGRITY))
		btrfsic_unmount(root, fs_info->fs_devices);
#endif

3401
	btrfs_close_devices(fs_info->fs_devices);
3402
	btrfs_mapping_tree_free(&fs_info->mapping_tree);
3403

C
Chris Mason 已提交
3404
	bdi_destroy(&fs_info->bdi);
3405
	cleanup_srcu_struct(&fs_info->subvol_srcu);
3406

3407 3408 3409
	return 0;
}

3410 3411
int btrfs_buffer_uptodate(struct extent_buffer *buf, u64 parent_transid,
			  int atomic)
3412
{
3413
	int ret;
3414
	struct inode *btree_inode = buf->pages[0]->mapping->host;
3415

3416
	ret = extent_buffer_uptodate(buf);
3417 3418 3419 3420
	if (!ret)
		return ret;

	ret = verify_parent_transid(&BTRFS_I(btree_inode)->io_tree, buf,
3421 3422 3423
				    parent_transid, atomic);
	if (ret == -EAGAIN)
		return ret;
3424
	return !ret;
3425 3426 3427
}

int btrfs_set_buffer_uptodate(struct extent_buffer *buf)
C
Chris Mason 已提交
3428
{
3429
	return set_extent_buffer_uptodate(buf);
3430
}
3431

3432 3433
void btrfs_mark_buffer_dirty(struct extent_buffer *buf)
{
3434
	struct btrfs_root *root = BTRFS_I(buf->pages[0]->mapping->host)->root;
3435
	u64 transid = btrfs_header_generation(buf);
3436
	int was_dirty;
3437

3438
	btrfs_assert_tree_locked(buf);
J
Julia Lawall 已提交
3439 3440
	if (transid != root->fs_info->generation)
		WARN(1, KERN_CRIT "btrfs transid mismatch buffer %llu, "
C
Chris Mason 已提交
3441
		       "found %llu running %llu\n",
3442
			(unsigned long long)buf->start,
C
Chris Mason 已提交
3443 3444
			(unsigned long long)transid,
			(unsigned long long)root->fs_info->generation);
3445
	was_dirty = set_extent_buffer_dirty(buf);
3446 3447 3448 3449 3450
	if (!was_dirty) {
		spin_lock(&root->fs_info->delalloc_lock);
		root->fs_info->dirty_metadata_bytes += buf->len;
		spin_unlock(&root->fs_info->delalloc_lock);
	}
3451 3452
}

3453 3454
static void __btrfs_btree_balance_dirty(struct btrfs_root *root,
					int flush_delayed)
3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465
{
	/*
	 * looks as though older kernels can get into trouble with
	 * this code, they end up stuck in balance_dirty_pages forever
	 */
	u64 num_dirty;
	unsigned long thresh = 32 * 1024 * 1024;

	if (current->flags & PF_MEMALLOC)
		return;

3466 3467
	if (flush_delayed)
		btrfs_balance_delayed_items(root);
3468 3469 3470 3471 3472 3473 3474 3475 3476 3477

	num_dirty = root->fs_info->dirty_metadata_bytes;

	if (num_dirty > thresh) {
		balance_dirty_pages_ratelimited_nr(
				   root->fs_info->btree_inode->i_mapping, 1);
	}
	return;
}

3478
void btrfs_btree_balance_dirty(struct btrfs_root *root)
C
Chris Mason 已提交
3479
{
3480 3481
	__btrfs_btree_balance_dirty(root, 1);
}
3482

3483 3484 3485
void btrfs_btree_balance_dirty_nodelay(struct btrfs_root *root)
{
	__btrfs_btree_balance_dirty(root, 0);
C
Chris Mason 已提交
3486
}
3487

3488
int btrfs_read_buffer(struct extent_buffer *buf, u64 parent_transid)
3489
{
3490
	struct btrfs_root *root = BTRFS_I(buf->pages[0]->mapping->host)->root;
3491
	return btree_read_extent_buffer_pages(root, buf, 0, parent_transid);
3492
}
3493

3494
static int btrfs_check_super_valid(struct btrfs_fs_info *fs_info,
L
liubo 已提交
3495 3496
			      int read_only)
{
3497 3498 3499 3500 3501
	if (btrfs_super_csum_type(fs_info->super_copy) >= ARRAY_SIZE(btrfs_csum_sizes)) {
		printk(KERN_ERR "btrfs: unsupported checksum algorithm\n");
		return -EINVAL;
	}

L
liubo 已提交
3502
	if (read_only)
3503
		return 0;
L
liubo 已提交
3504

3505
	return 0;
L
liubo 已提交
3506 3507
}

3508
void btrfs_error_commit_super(struct btrfs_root *root)
L
liubo 已提交
3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520
{
	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);
}

3521
static void btrfs_destroy_ordered_operations(struct btrfs_root *root)
L
liubo 已提交
3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544
{
	struct btrfs_inode *btrfs_inode;
	struct list_head splice;

	INIT_LIST_HEAD(&splice);

	mutex_lock(&root->fs_info->ordered_operations_mutex);
	spin_lock(&root->fs_info->ordered_extent_lock);

	list_splice_init(&root->fs_info->ordered_operations, &splice);
	while (!list_empty(&splice)) {
		btrfs_inode = list_entry(splice.next, struct btrfs_inode,
					 ordered_operations);

		list_del_init(&btrfs_inode->ordered_operations);

		btrfs_invalidate_inodes(btrfs_inode->root);
	}

	spin_unlock(&root->fs_info->ordered_extent_lock);
	mutex_unlock(&root->fs_info->ordered_operations_mutex);
}

3545
static void btrfs_destroy_ordered_extents(struct btrfs_root *root)
L
liubo 已提交
3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578
{
	struct list_head splice;
	struct btrfs_ordered_extent *ordered;
	struct inode *inode;

	INIT_LIST_HEAD(&splice);

	spin_lock(&root->fs_info->ordered_extent_lock);

	list_splice_init(&root->fs_info->ordered_extents, &splice);
	while (!list_empty(&splice)) {
		ordered = list_entry(splice.next, struct btrfs_ordered_extent,
				     root_extent_list);

		list_del_init(&ordered->root_extent_list);
		atomic_inc(&ordered->refs);

		/* the inode may be getting freed (in sys_unlink path). */
		inode = igrab(ordered->inode);

		spin_unlock(&root->fs_info->ordered_extent_lock);
		if (inode)
			iput(inode);

		atomic_set(&ordered->refs, 1);
		btrfs_put_ordered_extent(ordered);

		spin_lock(&root->fs_info->ordered_extent_lock);
	}

	spin_unlock(&root->fs_info->ordered_extent_lock);
}

3579 3580
int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans,
			       struct btrfs_root *root)
L
liubo 已提交
3581 3582 3583 3584 3585 3586 3587 3588 3589 3590
{
	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);
	if (delayed_refs->num_entries == 0) {
3591
		spin_unlock(&delayed_refs->lock);
L
liubo 已提交
3592 3593 3594 3595
		printk(KERN_INFO "delayed_refs has NO entry\n");
		return ret;
	}

3596
	while ((node = rb_first(&delayed_refs->root)) != NULL) {
L
liubo 已提交
3597 3598 3599 3600 3601 3602 3603
		ref = rb_entry(node, struct btrfs_delayed_ref_node, rb_node);

		atomic_set(&ref->refs, 1);
		if (btrfs_delayed_ref_is_head(ref)) {
			struct btrfs_delayed_ref_head *head;

			head = btrfs_delayed_node_to_head(ref);
3604 3605 3606 3607 3608 3609 3610 3611 3612
			if (!mutex_trylock(&head->mutex)) {
				atomic_inc(&ref->refs);
				spin_unlock(&delayed_refs->lock);

				/* Need to wait for the delayed ref to run */
				mutex_lock(&head->mutex);
				mutex_unlock(&head->mutex);
				btrfs_put_delayed_ref(ref);

J
Josef Bacik 已提交
3613
				spin_lock(&delayed_refs->lock);
3614 3615 3616
				continue;
			}

3617
			btrfs_free_delayed_extent_op(head->extent_op);
L
liubo 已提交
3618 3619 3620 3621 3622
			delayed_refs->num_heads--;
			if (list_empty(&head->cluster))
				delayed_refs->num_heads_ready--;
			list_del_init(&head->cluster);
		}
3623 3624 3625 3626
		ref->in_tree = 0;
		rb_erase(&ref->rb_node, &delayed_refs->root);
		delayed_refs->num_entries--;

L
liubo 已提交
3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638
		spin_unlock(&delayed_refs->lock);
		btrfs_put_delayed_ref(ref);

		cond_resched();
		spin_lock(&delayed_refs->lock);
	}

	spin_unlock(&delayed_refs->lock);

	return ret;
}

3639
static void btrfs_destroy_pending_snapshots(struct btrfs_transaction *t)
L
liubo 已提交
3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658
{
	struct btrfs_pending_snapshot *snapshot;
	struct list_head splice;

	INIT_LIST_HEAD(&splice);

	list_splice_init(&t->pending_snapshots, &splice);

	while (!list_empty(&splice)) {
		snapshot = list_entry(splice.next,
				      struct btrfs_pending_snapshot,
				      list);

		list_del_init(&snapshot->list);

		kfree(snapshot);
	}
}

3659
static void btrfs_destroy_delalloc_inodes(struct btrfs_root *root)
L
liubo 已提交
3660 3661 3662 3663 3664 3665 3666
{
	struct btrfs_inode *btrfs_inode;
	struct list_head splice;

	INIT_LIST_HEAD(&splice);

	spin_lock(&root->fs_info->delalloc_lock);
3667
	list_splice_init(&root->fs_info->delalloc_inodes, &splice);
L
liubo 已提交
3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695

	while (!list_empty(&splice)) {
		btrfs_inode = list_entry(splice.next, struct btrfs_inode,
				    delalloc_inodes);

		list_del_init(&btrfs_inode->delalloc_inodes);

		btrfs_invalidate_inodes(btrfs_inode->root);
	}

	spin_unlock(&root->fs_info->delalloc_lock);
}

static int btrfs_destroy_marked_extents(struct btrfs_root *root,
					struct extent_io_tree *dirty_pages,
					int mark)
{
	int ret;
	struct page *page;
	struct inode *btree_inode = root->fs_info->btree_inode;
	struct extent_buffer *eb;
	u64 start = 0;
	u64 end;
	u64 offset;
	unsigned long index;

	while (1) {
		ret = find_first_extent_bit(dirty_pages, start, &start, &end,
3696
					    mark, NULL);
L
liubo 已提交
3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713
		if (ret)
			break;

		clear_extent_bits(dirty_pages, start, end, mark, GFP_NOFS);
		while (start <= end) {
			index = start >> PAGE_CACHE_SHIFT;
			start = (u64)(index + 1) << PAGE_CACHE_SHIFT;
			page = find_get_page(btree_inode->i_mapping, index);
			if (!page)
				continue;
			offset = page_offset(page);

			spin_lock(&dirty_pages->buffer_lock);
			eb = radix_tree_lookup(
			     &(&BTRFS_I(page->mapping->host)->io_tree)->buffer,
					       offset >> PAGE_CACHE_SHIFT);
			spin_unlock(&dirty_pages->buffer_lock);
3714
			if (eb)
L
liubo 已提交
3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730
				ret = test_and_clear_bit(EXTENT_BUFFER_DIRTY,
							 &eb->bflags);
			if (PageWriteback(page))
				end_page_writeback(page);

			lock_page(page);
			if (PageDirty(page)) {
				clear_page_dirty_for_io(page);
				spin_lock_irq(&page->mapping->tree_lock);
				radix_tree_tag_clear(&page->mapping->page_tree,
							page_index(page),
							PAGECACHE_TAG_DIRTY);
				spin_unlock_irq(&page->mapping->tree_lock);
			}

			unlock_page(page);
3731
			page_cache_release(page);
L
liubo 已提交
3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744
		}
	}

	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;
3745
	bool loop = true;
L
liubo 已提交
3746 3747

	unpin = pinned_extents;
3748
again:
L
liubo 已提交
3749 3750
	while (1) {
		ret = find_first_extent_bit(unpin, 0, &start, &end,
3751
					    EXTENT_DIRTY, NULL);
L
liubo 已提交
3752 3753 3754 3755
		if (ret)
			break;

		/* opt_discard */
3756 3757 3758 3759
		if (btrfs_test_opt(root, DISCARD))
			ret = btrfs_error_discard_extent(root, start,
							 end + 1 - start,
							 NULL);
L
liubo 已提交
3760 3761 3762 3763 3764 3765

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

3766 3767 3768 3769 3770 3771 3772 3773 3774
	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 已提交
3775 3776 3777
	return 0;
}

3778 3779 3780 3781 3782 3783 3784 3785 3786 3787
void btrfs_cleanup_one_transaction(struct btrfs_transaction *cur_trans,
				   struct btrfs_root *root)
{
	btrfs_destroy_delayed_refs(cur_trans, root);
	btrfs_block_rsv_release(root, &root->fs_info->trans_block_rsv,
				cur_trans->dirty_pages.dirty_bytes);

	/* FIXME: cleanup wait for commit */
	cur_trans->in_commit = 1;
	cur_trans->blocked = 1;
3788
	wake_up(&root->fs_info->transaction_blocked_wait);
3789 3790

	cur_trans->blocked = 0;
3791
	wake_up(&root->fs_info->transaction_wait);
3792 3793

	cur_trans->commit_done = 1;
3794
	wake_up(&cur_trans->commit_wait);
3795

3796 3797
	btrfs_destroy_delayed_inodes(root);
	btrfs_assert_delayed_root_empty(root);
3798 3799 3800 3801 3802

	btrfs_destroy_pending_snapshots(cur_trans);

	btrfs_destroy_marked_extents(root, &cur_trans->dirty_pages,
				     EXTENT_DIRTY);
3803 3804
	btrfs_destroy_pinned_extent(root,
				    root->fs_info->pinned_extents);
3805 3806 3807 3808 3809 3810 3811 3812

	/*
	memset(cur_trans, 0, sizeof(*cur_trans));
	kmem_cache_free(btrfs_transaction_cachep, cur_trans);
	*/
}

int btrfs_cleanup_transaction(struct btrfs_root *root)
L
liubo 已提交
3813 3814 3815 3816 3817 3818
{
	struct btrfs_transaction *t;
	LIST_HEAD(list);

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

J
Josef Bacik 已提交
3819
	spin_lock(&root->fs_info->trans_lock);
L
liubo 已提交
3820
	list_splice_init(&root->fs_info->trans_list, &list);
J
Josef Bacik 已提交
3821 3822 3823
	root->fs_info->trans_no_join = 1;
	spin_unlock(&root->fs_info->trans_lock);

L
liubo 已提交
3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840 3841
	while (!list_empty(&list)) {
		t = list_entry(list.next, struct btrfs_transaction, list);
		if (!t)
			break;

		btrfs_destroy_ordered_operations(root);

		btrfs_destroy_ordered_extents(root);

		btrfs_destroy_delayed_refs(t, root);

		btrfs_block_rsv_release(root,
					&root->fs_info->trans_block_rsv,
					t->dirty_pages.dirty_bytes);

		/* FIXME: cleanup wait for commit */
		t->in_commit = 1;
		t->blocked = 1;
3842
		smp_mb();
L
liubo 已提交
3843 3844 3845 3846
		if (waitqueue_active(&root->fs_info->transaction_blocked_wait))
			wake_up(&root->fs_info->transaction_blocked_wait);

		t->blocked = 0;
3847
		smp_mb();
L
liubo 已提交
3848 3849 3850 3851
		if (waitqueue_active(&root->fs_info->transaction_wait))
			wake_up(&root->fs_info->transaction_wait);

		t->commit_done = 1;
3852
		smp_mb();
L
liubo 已提交
3853 3854 3855
		if (waitqueue_active(&t->commit_wait))
			wake_up(&t->commit_wait);

3856 3857 3858
		btrfs_destroy_delayed_inodes(root);
		btrfs_assert_delayed_root_empty(root);

L
liubo 已提交
3859 3860 3861 3862
		btrfs_destroy_pending_snapshots(t);

		btrfs_destroy_delalloc_inodes(root);

J
Josef Bacik 已提交
3863
		spin_lock(&root->fs_info->trans_lock);
L
liubo 已提交
3864
		root->fs_info->running_transaction = NULL;
J
Josef Bacik 已提交
3865
		spin_unlock(&root->fs_info->trans_lock);
L
liubo 已提交
3866 3867 3868 3869 3870 3871 3872

		btrfs_destroy_marked_extents(root, &t->dirty_pages,
					     EXTENT_DIRTY);

		btrfs_destroy_pinned_extent(root,
					    root->fs_info->pinned_extents);

3873
		atomic_set(&t->use_count, 0);
L
liubo 已提交
3874 3875 3876 3877 3878
		list_del_init(&t->list);
		memset(t, 0, sizeof(*t));
		kmem_cache_free(btrfs_transaction_cachep, t);
	}

J
Josef Bacik 已提交
3879 3880 3881
	spin_lock(&root->fs_info->trans_lock);
	root->fs_info->trans_no_join = 0;
	spin_unlock(&root->fs_info->trans_lock);
L
liubo 已提交
3882 3883 3884 3885 3886
	mutex_unlock(&root->fs_info->transaction_kthread_mutex);

	return 0;
}

3887
static struct extent_io_ops btree_extent_io_ops = {
3888
	.readpage_end_io_hook = btree_readpage_end_io_hook,
A
Arne Jansen 已提交
3889
	.readpage_io_failed_hook = btree_io_failed_hook,
3890
	.submit_bio_hook = btree_submit_bio_hook,
3891 3892
	/* note we're sharing with inode.c for the merge bio hook */
	.merge_bio_hook = btrfs_merge_bio_hook,
3893
};