disk-io.c 103.6 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

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

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

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

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

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"	},
150
};
151 152 153 154 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

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

182 183
#endif

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

196
	read_lock(&em_tree->lock);
197
	em = lookup_extent_mapping(em_tree, start, len);
198 199 200
	if (em) {
		em->bdev =
			BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev;
201
		read_unlock(&em_tree->lock);
202
		goto out;
203
	}
204
	read_unlock(&em_tree->lock);
205

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

217
	write_lock(&em_tree->lock);
218 219
	ret = add_extent_mapping(em_tree, em);
	if (ret == -EEXIST) {
220 221 222
		u64 failed_start = em->start;
		u64 failed_len = em->len;

223
		free_extent_map(em);
224
		em = lookup_extent_mapping(em_tree, start, len);
225
		if (em) {
226
			ret = 0;
227 228 229
		} else {
			em = lookup_extent_mapping(em_tree, failed_start,
						   failed_len);
230
			ret = -EIO;
231
		}
232
	} else if (ret) {
233 234
		free_extent_map(em);
		em = NULL;
235
	}
236
	write_unlock(&em_tree->lock);
237 238 239

	if (ret)
		em = ERR_PTR(ret);
240 241
out:
	return em;
242 243
}

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

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

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

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

293 294 295
	btrfs_csum_final(crc, result);

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

301
			read_extent_buffer(buf, &val, 0, csum_size);
302
			printk_ratelimited(KERN_INFO "btrfs: %s checksum verify "
C
Chris Mason 已提交
303 304 305 306 307
				       "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));
308 309
			if (result != (char *)&inline_result)
				kfree(result);
310 311 312
			return 1;
		}
	} else {
313
		write_extent_buffer(buf, result, 0, csum_size);
314
	}
315 316
	if (result != (char *)&inline_result)
		kfree(result);
317 318 319
	return 0;
}

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

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

336 337 338
	if (atomic)
		return -EAGAIN;

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

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

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

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

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

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

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

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

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

	return ret;
414
}
415

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

421
static int csum_dirty_buffer(struct btrfs_root *root, struct page *page)
422
{
423
	struct extent_io_tree *tree;
424
	u64 start = (u64)page->index << PAGE_CACHE_SHIFT;
425 426
	u64 found_start;
	struct extent_buffer *eb;
427

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

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

Y
Yan Zheng 已提交
450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468
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;
}

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 531 532 533 534 535
#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;
}

536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570
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;
}

571
static int btree_readpage_end_io_hook(struct page *page, u64 start, u64 end,
572
			       struct extent_state *state, int mirror)
573 574 575 576 577 578
{
	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;
579
	int ret = 0;
580
	int reads_done;
581 582 583

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

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

588 589 590 591 592 593
	/* 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);
594 595
	if (!reads_done)
		goto err;
596

597
	eb->read_mirror = mirror;
598 599 600 601 602
	if (test_bit(EXTENT_BUFFER_IOERR, &eb->bflags)) {
		ret = -EIO;
		goto err;
	}

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

620 621
	btrfs_set_buffer_lockdep_class(btrfs_header_owner(eb),
				       eb, found_level);
622

623
	ret = csum_tree_block(root, eb, 1);
624
	if (ret) {
625
		ret = -EIO;
626 627 628 629 630 631 632 633 634 635 636 637
		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;
	}
638

639 640
	if (!ret)
		set_extent_buffer_uptodate(eb);
641
err:
A
Arne Jansen 已提交
642 643 644 645 646
	if (test_bit(EXTENT_BUFFER_READAHEAD, &eb->bflags)) {
		clear_bit(EXTENT_BUFFER_READAHEAD, &eb->bflags);
		btree_readahead_hook(root, eb, eb->start, ret);
	}

647 648 649
	if (ret)
		clear_extent_buffer_uptodate(eb);
	free_extent_buffer(eb);
650
out:
651
	return ret;
652 653
}

654
static int btree_io_failed_hook(struct page *page, int failed_mirror)
A
Arne Jansen 已提交
655 656 657 658
{
	struct extent_buffer *eb;
	struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;

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

667 668 669 670 671 672 673
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;
674 675
	end_io_wq->work.func = end_workqueue_fn;
	end_io_wq->work.flags = 0;
676

677
	if (bio->bi_rw & REQ_WRITE) {
J
Josef Bacik 已提交
678
		if (end_io_wq->metadata == 1)
679 680
			btrfs_queue_worker(&fs_info->endio_meta_write_workers,
					   &end_io_wq->work);
J
Josef Bacik 已提交
681 682 683
		else if (end_io_wq->metadata == 2)
			btrfs_queue_worker(&fs_info->endio_freespace_worker,
					   &end_io_wq->work);
684 685 686
		else
			btrfs_queue_worker(&fs_info->endio_write_workers,
					   &end_io_wq->work);
687 688 689 690 691 692 693 694
	} 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);
	}
695 696
}

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

	bio->bi_private = end_io_wq;
	bio->bi_end_io = end_workqueue_bio;
721 722 723
	return 0;
}

724
unsigned long btrfs_async_submit_limit(struct btrfs_fs_info *info)
725
{
726 727 728 729 730
	unsigned long limit = min_t(unsigned long,
				    info->workers.max_workers,
				    info->fs_devices->open_devices);
	return 256 * limit;
}
731

C
Chris Mason 已提交
732 733 734
static void run_one_async_start(struct btrfs_work *work)
{
	struct async_submit_bio *async;
735
	int ret;
C
Chris Mason 已提交
736 737

	async = container_of(work, struct  async_submit_bio, work);
738 739 740 741 742
	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 已提交
743 744 745
}

static void run_one_async_done(struct btrfs_work *work)
746 747 748
{
	struct btrfs_fs_info *fs_info;
	struct async_submit_bio *async;
749
	int limit;
750 751 752

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

754
	limit = btrfs_async_submit_limit(fs_info);
755 756
	limit = limit * 2 / 3;

757
	atomic_dec(&fs_info->nr_async_submits);
758

759 760
	if (atomic_read(&fs_info->nr_async_submits) < limit &&
	    waitqueue_active(&fs_info->async_submit_wait))
761 762
		wake_up(&fs_info->async_submit_wait);

763 764 765 766 767 768
	/* 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 已提交
769
	async->submit_bio_done(async->inode, async->rw, async->bio,
770 771
			       async->mirror_num, async->bio_flags,
			       async->bio_offset);
C
Chris Mason 已提交
772 773 774 775 776 777 778
}

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

	async = container_of(work, struct  async_submit_bio, work);
779 780 781
	kfree(async);
}

782 783
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 已提交
784
			unsigned long bio_flags,
785
			u64 bio_offset,
C
Chris Mason 已提交
786 787
			extent_submit_bio_hook_t *submit_bio_start,
			extent_submit_bio_hook_t *submit_bio_done)
788 789 790 791 792 793 794 795 796 797 798
{
	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 已提交
799 800 801 802 803 804 805
	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;

806
	async->work.flags = 0;
C
Chris Mason 已提交
807
	async->bio_flags = bio_flags;
808
	async->bio_offset = bio_offset;
809

810 811
	async->error = 0;

812
	atomic_inc(&fs_info->nr_async_submits);
813

814
	if (rw & REQ_SYNC)
815 816
		btrfs_set_work_high_prio(&async->work);

817
	btrfs_queue_worker(&fs_info->workers, &async->work);
818

C
Chris Mason 已提交
819
	while (atomic_read(&fs_info->async_submit_draining) &&
820 821 822 823 824
	      atomic_read(&fs_info->nr_async_submits)) {
		wait_event(fs_info->async_submit_wait,
			   (atomic_read(&fs_info->nr_async_submits) == 0));
	}

825 826 827
	return 0;
}

828 829 830 831 832
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;
833
	int ret = 0;
834 835

	WARN_ON(bio->bi_vcnt <= 0);
C
Chris Mason 已提交
836
	while (bio_index < bio->bi_vcnt) {
837
		root = BTRFS_I(bvec->bv_page->mapping->host)->root;
838 839 840
		ret = csum_dirty_buffer(root, bvec->bv_page);
		if (ret)
			break;
841 842 843
		bio_index++;
		bvec++;
	}
844
	return ret;
845 846
}

C
Chris Mason 已提交
847 848
static int __btree_submit_bio_start(struct inode *inode, int rw,
				    struct bio *bio, int mirror_num,
849 850
				    unsigned long bio_flags,
				    u64 bio_offset)
851
{
852 853
	/*
	 * when we're called for a write, we're already in the async
854
	 * submission context.  Just jump into btrfs_map_bio
855
	 */
856
	return btree_csum_one_bio(bio);
C
Chris Mason 已提交
857
}
858

C
Chris Mason 已提交
859
static int __btree_submit_bio_done(struct inode *inode, int rw, struct bio *bio,
860 861
				 int mirror_num, unsigned long bio_flags,
				 u64 bio_offset)
C
Chris Mason 已提交
862
{
863
	/*
C
Chris Mason 已提交
864 865
	 * when we're called for a write, we're already in the async
	 * submission context.  Just jump into btrfs_map_bio
866 867
	 */
	return btrfs_map_bio(BTRFS_I(inode)->root, rw, bio, mirror_num, 1);
868 869
}

870
static int btree_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
871 872
				 int mirror_num, unsigned long bio_flags,
				 u64 bio_offset)
873
{
874 875
	int ret;

876
	if (!(rw & REQ_WRITE)) {
877

C
Chris Mason 已提交
878 879 880 881
		/*
		 * called for a read, do the setup so that checksum validation
		 * can happen in the async kernel threads
		 */
882 883
		ret = btrfs_bio_wq_end_io(BTRFS_I(inode)->root->fs_info,
					  bio, 1);
884 885
		if (ret)
			return ret;
C
Chris Mason 已提交
886
		return btrfs_map_bio(BTRFS_I(inode)->root, rw, bio,
887
				     mirror_num, 0);
888
	}
889

890 891 892 893
	/*
	 * kthread helpers are used to submit writes so that checksumming
	 * can happen in parallel across all CPUs
	 */
894
	return btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,
C
Chris Mason 已提交
895
				   inode, rw, bio, mirror_num, 0,
896
				   bio_offset,
C
Chris Mason 已提交
897 898
				   __btree_submit_bio_start,
				   __btree_submit_bio_done);
899 900
}

J
Jan Beulich 已提交
901
#ifdef CONFIG_MIGRATION
902
static int btree_migratepage(struct address_space *mapping,
903 904
			struct page *newpage, struct page *page,
			enum migrate_mode mode)
905 906 907 908 909 910 911 912 913 914 915 916 917 918
{
	/*
	 * 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;
919
	return migrate_page(mapping, newpage, page, mode);
920
}
J
Jan Beulich 已提交
921
#endif
922

923 924 925 926

static int btree_writepages(struct address_space *mapping,
			    struct writeback_control *wbc)
{
927 928
	struct extent_io_tree *tree;
	tree = &BTRFS_I(mapping->host)->io_tree;
929
	if (wbc->sync_mode == WB_SYNC_NONE) {
930
		struct btrfs_root *root = BTRFS_I(mapping->host)->root;
931
		u64 num_dirty;
932
		unsigned long thresh = 32 * 1024 * 1024;
933 934 935 936

		if (wbc->for_kupdate)
			return 0;

937 938
		/* this is a bit racy, but that's ok */
		num_dirty = root->fs_info->dirty_metadata_bytes;
C
Chris Mason 已提交
939
		if (num_dirty < thresh)
940 941
			return 0;
	}
942
	return btree_write_cache_pages(mapping, wbc);
943 944
}

945
static int btree_readpage(struct file *file, struct page *page)
946
{
947 948
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
949
	return extent_read_full_page(tree, page, btree_get_extent, 0);
950
}
C
Chris Mason 已提交
951

952
static int btree_releasepage(struct page *page, gfp_t gfp_flags)
953
{
954
	if (PageWriteback(page) || PageDirty(page))
C
Chris Mason 已提交
955
		return 0;
956 957 958 959 960 961 962
	/*
	 * 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;

963
	return try_release_extent_buffer(page, gfp_flags);
964 965
}

966
static void btree_invalidatepage(struct page *page, unsigned long offset)
967
{
968 969
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
970 971
	extent_invalidatepage(tree, page, offset);
	btree_releasepage(page, GFP_NOFS);
972
	if (PagePrivate(page)) {
C
Chris Mason 已提交
973 974
		printk(KERN_WARNING "btrfs warning page private not zero "
		       "on page %llu\n", (unsigned long long)page_offset(page));
975 976 977 978
		ClearPagePrivate(page);
		set_page_private(page, 0);
		page_cache_release(page);
	}
979 980
}

981 982 983 984 985 986 987 988 989 990 991 992 993
static int btree_set_page_dirty(struct page *page)
{
	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);
	return __set_page_dirty_nobuffers(page);
}

994
static const struct address_space_operations btree_aops = {
995
	.readpage	= btree_readpage,
996
	.writepages	= btree_writepages,
997 998
	.releasepage	= btree_releasepage,
	.invalidatepage = btree_invalidatepage,
999
#ifdef CONFIG_MIGRATION
1000
	.migratepage	= btree_migratepage,
1001
#endif
1002
	.set_page_dirty = btree_set_page_dirty,
1003 1004
};

1005 1006
int readahead_tree_block(struct btrfs_root *root, u64 bytenr, u32 blocksize,
			 u64 parent_transid)
C
Chris Mason 已提交
1007
{
1008 1009
	struct extent_buffer *buf = NULL;
	struct inode *btree_inode = root->fs_info->btree_inode;
1010
	int ret = 0;
C
Chris Mason 已提交
1011

1012
	buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
1013
	if (!buf)
C
Chris Mason 已提交
1014
		return 0;
1015
	read_extent_buffer_pages(&BTRFS_I(btree_inode)->io_tree,
1016
				 buf, 0, WAIT_NONE, btree_get_extent, 0);
1017
	free_extent_buffer(buf);
1018
	return ret;
C
Chris Mason 已提交
1019 1020
}

1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044
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;
1045
	} else if (extent_buffer_uptodate(buf)) {
1046 1047 1048 1049 1050 1051 1052
		*eb = buf;
	} else {
		free_extent_buffer(buf);
	}
	return 0;
}

1053 1054 1055 1056 1057 1058
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,
1059
				bytenr, blocksize);
1060 1061 1062 1063 1064 1065 1066 1067 1068 1069
	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,
1070
				 bytenr, blocksize);
1071 1072 1073 1074
	return eb;
}


1075 1076
int btrfs_write_tree_block(struct extent_buffer *buf)
{
1077
	return filemap_fdatawrite_range(buf->pages[0]->mapping, buf->start,
1078
					buf->start + buf->len - 1);
1079 1080 1081 1082
}

int btrfs_wait_tree_block_writeback(struct extent_buffer *buf)
{
1083
	return filemap_fdatawait_range(buf->pages[0]->mapping,
1084
				       buf->start, buf->start + buf->len - 1);
1085 1086
}

1087
struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 bytenr,
1088
				      u32 blocksize, u64 parent_transid)
1089 1090 1091 1092 1093 1094 1095 1096
{
	struct extent_buffer *buf = NULL;
	int ret;

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

1097
	ret = btree_read_extent_buffer_pages(root, buf, 0, parent_transid);
1098
	return buf;
1099

1100 1101
}

1102 1103
void clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
		      struct extent_buffer *buf)
1104
{
1105
	if (btrfs_header_generation(buf) ==
1106
	    root->fs_info->running_transaction->transid) {
1107
		btrfs_assert_tree_locked(buf);
1108

1109 1110 1111 1112
		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;
1113 1114 1115 1116 1117 1118 1119 1120
			else {
				spin_unlock(&root->fs_info->delalloc_lock);
				btrfs_panic(root->fs_info, -EOVERFLOW,
					  "Can't clear %lu bytes from "
					  " dirty_mdatadata_bytes (%lu)",
					  buf->len,
					  root->fs_info->dirty_metadata_bytes);
			}
1121 1122
			spin_unlock(&root->fs_info->delalloc_lock);
		}
1123

1124 1125
		/* ugh, clear_extent_buffer_dirty needs to lock the page */
		btrfs_set_lock_blocking(buf);
1126
		clear_extent_buffer_dirty(buf);
1127
	}
1128 1129
}

1130 1131 1132 1133
static void __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize,
			 u32 stripesize, struct btrfs_root *root,
			 struct btrfs_fs_info *fs_info,
			 u64 objectid)
1134
{
C
Chris Mason 已提交
1135
	root->node = NULL;
1136
	root->commit_root = NULL;
1137 1138 1139
	root->sectorsize = sectorsize;
	root->nodesize = nodesize;
	root->leafsize = leafsize;
1140
	root->stripesize = stripesize;
C
Chris Mason 已提交
1141
	root->ref_cows = 0;
1142
	root->track_dirty = 0;
1143
	root->in_radix = 0;
1144 1145
	root->orphan_item_inserted = 0;
	root->orphan_cleanup_state = 0;
1146

1147 1148
	root->objectid = objectid;
	root->last_trans = 0;
1149
	root->highest_objectid = 0;
1150
	root->name = NULL;
1151
	root->inode_tree = RB_ROOT;
1152
	INIT_RADIX_TREE(&root->delayed_nodes_tree, GFP_ATOMIC);
1153
	root->block_rsv = NULL;
1154
	root->orphan_block_rsv = NULL;
1155 1156

	INIT_LIST_HEAD(&root->dirty_list);
1157
	INIT_LIST_HEAD(&root->root_list);
1158
	spin_lock_init(&root->orphan_lock);
1159
	spin_lock_init(&root->inode_lock);
1160
	spin_lock_init(&root->accounting_lock);
1161
	mutex_init(&root->objectid_mutex);
1162
	mutex_init(&root->log_mutex);
Y
Yan Zheng 已提交
1163 1164 1165 1166 1167 1168
	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);
1169
	atomic_set(&root->orphan_inodes, 0);
Y
Yan Zheng 已提交
1170 1171
	root->log_batch = 0;
	root->log_transid = 0;
1172
	root->last_log_commit = 0;
1173
	extent_io_tree_init(&root->dirty_log_pages,
1174
			     fs_info->btree_inode->i_mapping);
C
Chris Mason 已提交
1175

1176 1177
	memset(&root->root_key, 0, sizeof(root->root_key));
	memset(&root->root_item, 0, sizeof(root->root_item));
1178
	memset(&root->defrag_progress, 0, sizeof(root->defrag_progress));
1179
	memset(&root->root_kobj, 0, sizeof(root->root_kobj));
1180
	root->defrag_trans_start = fs_info->generation;
1181
	init_completion(&root->kobj_unregister);
1182
	root->defrag_running = 0;
1183
	root->root_key.objectid = objectid;
1184
	root->anon_dev = 0;
1185 1186

	spin_lock_init(&root->root_times_lock);
1187 1188
}

1189 1190 1191 1192
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)
1193 1194
{
	int ret;
1195
	u32 blocksize;
1196
	u64 generation;
1197

1198
	__setup_root(tree_root->nodesize, tree_root->leafsize,
1199 1200
		     tree_root->sectorsize, tree_root->stripesize,
		     root, fs_info, objectid);
1201 1202
	ret = btrfs_find_last_root(tree_root, objectid,
				   &root->root_item, &root->root_key);
1203 1204
	if (ret > 0)
		return -ENOENT;
1205 1206
	else if (ret < 0)
		return ret;
1207

1208
	generation = btrfs_root_generation(&root->root_item);
1209
	blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
C
Chris Mason 已提交
1210
	root->commit_root = NULL;
1211
	root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
1212
				     blocksize, generation);
1213
	if (!root->node || !btrfs_buffer_uptodate(root->node, generation, 0)) {
1214
		free_extent_buffer(root->node);
C
Chris Mason 已提交
1215
		root->node = NULL;
1216 1217
		return -EIO;
	}
1218
	root->commit_root = btrfs_root_node(root);
1219 1220 1221
	return 0;
}

1222
static struct btrfs_root *btrfs_alloc_root(struct btrfs_fs_info *fs_info)
A
Al Viro 已提交
1223 1224 1225 1226 1227 1228 1229
{
	struct btrfs_root *root = kzalloc(sizeof(*root), GFP_NOFS);
	if (root)
		root->fs_info = fs_info;
	return root;
}

1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 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
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 已提交
1306 1307
static struct btrfs_root *alloc_log_tree(struct btrfs_trans_handle *trans,
					 struct btrfs_fs_info *fs_info)
1308 1309 1310
{
	struct btrfs_root *root;
	struct btrfs_root *tree_root = fs_info->tree_root;
Y
Yan Zheng 已提交
1311
	struct extent_buffer *leaf;
1312

A
Al Viro 已提交
1313
	root = btrfs_alloc_root(fs_info);
1314
	if (!root)
Y
Yan Zheng 已提交
1315
		return ERR_PTR(-ENOMEM);
1316 1317 1318 1319 1320 1321 1322 1323

	__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 已提交
1324 1325 1326 1327 1328 1329
	/*
	 * 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).
	 */
1330 1331
	root->ref_cows = 0;

1332
	leaf = btrfs_alloc_free_block(trans, root, root->leafsize, 0,
A
Arne Jansen 已提交
1333
				      BTRFS_TREE_LOG_OBJECTID, NULL,
1334
				      0, 0, 0);
Y
Yan Zheng 已提交
1335 1336 1337 1338
	if (IS_ERR(leaf)) {
		kfree(root);
		return ERR_CAST(leaf);
	}
1339

1340 1341 1342 1343 1344
	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 已提交
1345
	root->node = leaf;
1346 1347 1348 1349 1350 1351

	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 已提交
1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387
	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);

1388
	btrfs_set_root_node(&log_root->root_item, log_root->node);
Y
Yan Zheng 已提交
1389 1390 1391 1392

	WARN_ON(root->log_root);
	root->log_root = log_root;
	root->log_transid = 0;
1393
	root->last_log_commit = 0;
1394 1395 1396 1397 1398 1399 1400 1401
	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;
1402
	struct btrfs_path *path;
1403
	struct extent_buffer *l;
1404
	u64 generation;
1405
	u32 blocksize;
1406
	int ret = 0;
1407
	int slot;
1408

A
Al Viro 已提交
1409
	root = btrfs_alloc_root(fs_info);
C
Chris Mason 已提交
1410
	if (!root)
1411 1412
		return ERR_PTR(-ENOMEM);
	if (location->offset == (u64)-1) {
1413
		ret = find_and_setup_root(tree_root, fs_info,
1414 1415 1416 1417 1418
					  location->objectid, root);
		if (ret) {
			kfree(root);
			return ERR_PTR(ret);
		}
1419
		goto out;
1420 1421
	}

1422
	__setup_root(tree_root->nodesize, tree_root->leafsize,
1423 1424
		     tree_root->sectorsize, tree_root->stripesize,
		     root, fs_info, location->objectid);
1425 1426

	path = btrfs_alloc_path();
T
Tsutomu Itoh 已提交
1427 1428 1429 1430
	if (!path) {
		kfree(root);
		return ERR_PTR(-ENOMEM);
	}
1431
	ret = btrfs_search_slot(NULL, tree_root, location, path, 0, 0);
1432 1433
	if (ret == 0) {
		l = path->nodes[0];
1434 1435
		slot = path->slots[0];
		btrfs_read_root_item(tree_root, l, slot, &root->root_item);
1436
		memcpy(&root->root_key, location, sizeof(*location));
1437 1438 1439
	}
	btrfs_free_path(path);
	if (ret) {
1440
		kfree(root);
1441 1442
		if (ret > 0)
			ret = -ENOENT;
1443 1444
		return ERR_PTR(ret);
	}
1445

1446
	generation = btrfs_root_generation(&root->root_item);
1447 1448
	blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
	root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
1449
				     blocksize, generation);
1450
	root->commit_root = btrfs_root_node(root);
1451
	BUG_ON(!root->node); /* -ENOMEM */
1452
out:
1453
	if (location->objectid != BTRFS_TREE_LOG_OBJECTID) {
1454
		root->ref_cows = 1;
1455 1456
		btrfs_check_and_init_root_item(&root->root_item);
	}
1457

1458 1459 1460
	return root;
}

1461 1462
struct btrfs_root *btrfs_read_fs_root_no_name(struct btrfs_fs_info *fs_info,
					      struct btrfs_key *location)
1463 1464 1465 1466
{
	struct btrfs_root *root;
	int ret;

1467 1468 1469 1470
	if (location->objectid == BTRFS_ROOT_TREE_OBJECTID)
		return fs_info->tree_root;
	if (location->objectid == BTRFS_EXTENT_TREE_OBJECTID)
		return fs_info->extent_root;
1471 1472 1473 1474
	if (location->objectid == BTRFS_CHUNK_TREE_OBJECTID)
		return fs_info->chunk_root;
	if (location->objectid == BTRFS_DEV_TREE_OBJECTID)
		return fs_info->dev_root;
1475 1476
	if (location->objectid == BTRFS_CSUM_TREE_OBJECTID)
		return fs_info->csum_root;
1477 1478 1479
	if (location->objectid == BTRFS_QUOTA_TREE_OBJECTID)
		return fs_info->quota_root ? fs_info->quota_root :
					     ERR_PTR(-ENOENT);
1480 1481
again:
	spin_lock(&fs_info->fs_roots_radix_lock);
1482 1483
	root = radix_tree_lookup(&fs_info->fs_roots_radix,
				 (unsigned long)location->objectid);
1484
	spin_unlock(&fs_info->fs_roots_radix_lock);
1485 1486 1487
	if (root)
		return root;

1488
	root = btrfs_read_fs_root_no_radix(fs_info->tree_root, location);
1489 1490
	if (IS_ERR(root))
		return root;
1491

1492 1493 1494
	root->free_ino_ctl = kzalloc(sizeof(*root->free_ino_ctl), GFP_NOFS);
	root->free_ino_pinned = kzalloc(sizeof(*root->free_ino_pinned),
					GFP_NOFS);
1495 1496
	if (!root->free_ino_pinned || !root->free_ino_ctl) {
		ret = -ENOMEM;
1497
		goto fail;
1498
	}
1499 1500 1501 1502 1503 1504

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

1505
	ret = get_anon_bdev(&root->anon_dev);
1506 1507
	if (ret)
		goto fail;
1508

1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519
	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;

1520 1521 1522 1523 1524
	ret = radix_tree_preload(GFP_NOFS & ~__GFP_HIGHMEM);
	if (ret)
		goto fail;

	spin_lock(&fs_info->fs_roots_radix_lock);
C
Chris Mason 已提交
1525 1526
	ret = radix_tree_insert(&fs_info->fs_roots_radix,
				(unsigned long)root->root_key.objectid,
1527
				root);
1528
	if (ret == 0)
1529
		root->in_radix = 1;
1530

1531 1532
	spin_unlock(&fs_info->fs_roots_radix_lock);
	radix_tree_preload_end();
1533
	if (ret) {
1534 1535 1536 1537 1538
		if (ret == -EEXIST) {
			free_fs_root(root);
			goto again;
		}
		goto fail;
1539
	}
1540 1541 1542 1543

	ret = btrfs_find_dead_roots(fs_info->tree_root,
				    root->root_key.objectid);
	WARN_ON(ret);
1544
	return root;
1545 1546 1547
fail:
	free_fs_root(root);
	return ERR_PTR(ret);
1548 1549
}

C
Chris Mason 已提交
1550 1551 1552 1553 1554 1555
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 已提交
1556

1557 1558
	rcu_read_lock();
	list_for_each_entry_rcu(device, &info->fs_devices->devices, dev_list) {
1559 1560
		if (!device->bdev)
			continue;
C
Chris Mason 已提交
1561 1562 1563 1564 1565 1566
		bdi = blk_get_backing_dev_info(device->bdev);
		if (bdi && bdi_congested(bdi, bdi_bits)) {
			ret = 1;
			break;
		}
	}
1567
	rcu_read_unlock();
C
Chris Mason 已提交
1568 1569 1570
	return ret;
}

1571 1572 1573 1574
/*
 * If this fails, caller must call bdi_destroy() to get rid of the
 * bdi again.
 */
C
Chris Mason 已提交
1575 1576
static int setup_bdi(struct btrfs_fs_info *info, struct backing_dev_info *bdi)
{
1577 1578 1579
	int err;

	bdi->capabilities = BDI_CAP_MAP_COPY;
1580
	err = bdi_setup_and_register(bdi, "btrfs", BDI_CAP_MAP_COPY);
1581 1582 1583
	if (err)
		return err;

1584
	bdi->ra_pages	= default_backing_dev_info.ra_pages;
C
Chris Mason 已提交
1585 1586 1587 1588 1589
	bdi->congested_fn	= btrfs_congested_fn;
	bdi->congested_data	= info;
	return 0;
}

1590 1591 1592 1593 1594
/*
 * 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)
1595 1596
{
	struct bio *bio;
1597 1598
	struct end_io_wq *end_io_wq;
	struct btrfs_fs_info *fs_info;
1599 1600
	int error;

1601 1602 1603
	end_io_wq = container_of(work, struct end_io_wq, work);
	bio = end_io_wq->bio;
	fs_info = end_io_wq->info;
1604

1605 1606 1607 1608 1609
	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);
1610 1611
}

1612 1613 1614 1615 1616 1617
static int cleaner_kthread(void *arg)
{
	struct btrfs_root *root = arg;

	do {
		vfs_check_frozen(root->fs_info->sb, SB_FREEZE_WRITE);
1618 1619 1620

		if (!(root->fs_info->sb->s_flags & MS_RDONLY) &&
		    mutex_trylock(&root->fs_info->cleaner_mutex)) {
Y
Yan, Zheng 已提交
1621
			btrfs_run_delayed_iputs(root);
1622 1623
			btrfs_clean_old_snapshots(root);
			mutex_unlock(&root->fs_info->cleaner_mutex);
C
Chris Mason 已提交
1624
			btrfs_run_defrag_inodes(root->fs_info);
1625
		}
1626

1627
		if (!try_to_freeze()) {
1628
			set_current_state(TASK_INTERRUPTIBLE);
1629 1630
			if (!kthread_should_stop())
				schedule();
1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641
			__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;
1642
	u64 transid;
1643 1644
	unsigned long now;
	unsigned long delay;
1645
	bool cannot_commit;
1646 1647

	do {
1648
		cannot_commit = false;
1649 1650 1651 1652
		delay = HZ * 30;
		vfs_check_frozen(root->fs_info->sb, SB_FREEZE_WRITE);
		mutex_lock(&root->fs_info->transaction_kthread_mutex);

J
Josef Bacik 已提交
1653
		spin_lock(&root->fs_info->trans_lock);
1654 1655
		cur = root->fs_info->running_transaction;
		if (!cur) {
J
Josef Bacik 已提交
1656
			spin_unlock(&root->fs_info->trans_lock);
1657 1658
			goto sleep;
		}
Y
Yan Zheng 已提交
1659

1660
		now = get_seconds();
1661 1662
		if (!cur->blocked &&
		    (now < cur->start_time || now - cur->start_time < 30)) {
J
Josef Bacik 已提交
1663
			spin_unlock(&root->fs_info->trans_lock);
1664 1665 1666
			delay = HZ * 5;
			goto sleep;
		}
1667
		transid = cur->transid;
J
Josef Bacik 已提交
1668
		spin_unlock(&root->fs_info->trans_lock);
1669

1670
		/* If the file system is aborted, this will always fail. */
1671
		trans = btrfs_join_transaction(root);
1672 1673
		if (IS_ERR(trans)) {
			cannot_commit = true;
1674
			goto sleep;
1675
		}
1676
		if (transid == trans->transid) {
1677
			btrfs_commit_transaction(trans, root);
1678 1679 1680
		} else {
			btrfs_end_transaction(trans, root);
		}
1681 1682 1683 1684
sleep:
		wake_up_process(root->fs_info->cleaner_kthread);
		mutex_unlock(&root->fs_info->transaction_kthread_mutex);

1685
		if (!try_to_freeze()) {
1686
			set_current_state(TASK_INTERRUPTIBLE);
1687
			if (!kthread_should_stop() &&
1688 1689
			    (!btrfs_transaction_blocked(root->fs_info) ||
			     cannot_commit))
1690
				schedule_timeout(delay);
1691 1692 1693 1694 1695 1696
			__set_current_state(TASK_RUNNING);
		}
	} while (!kthread_should_stop());
	return 0;
}

C
Chris Mason 已提交
1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 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
/*
 * 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));

1803 1804 1805 1806 1807 1808 1809 1810
	/*
	 * 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 已提交
1811
			       btrfs_header_generation(info->fs_root->node));
1812
		btrfs_set_backup_fs_root_level(root_backup,
C
Chris Mason 已提交
1813
			       btrfs_header_level(info->fs_root->node));
1814
	}
C
Chris Mason 已提交
1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 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

	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);
1907 1908 1909 1910
	if (info->quota_root) {
		free_extent_buffer(info->quota_root->node);
		free_extent_buffer(info->quota_root->commit_root);
	}
C
Chris Mason 已提交
1911 1912 1913 1914 1915 1916 1917 1918 1919

	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;
1920 1921 1922 1923
	if (info->quota_root) {
		info->quota_root->node = NULL;
		info->quota_root->commit_root = NULL;
	}
C
Chris Mason 已提交
1924 1925 1926 1927 1928 1929 1930 1931 1932 1933

	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 已提交
1934 1935 1936
int open_ctree(struct super_block *sb,
	       struct btrfs_fs_devices *fs_devices,
	       char *options)
1937
{
1938 1939 1940 1941
	u32 sectorsize;
	u32 nodesize;
	u32 leafsize;
	u32 blocksize;
1942
	u32 stripesize;
1943
	u64 generation;
1944
	u64 features;
1945
	struct btrfs_key location;
1946
	struct buffer_head *bh;
1947
	struct btrfs_super_block *disk_super;
1948
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
1949
	struct btrfs_root *tree_root;
1950 1951 1952 1953
	struct btrfs_root *extent_root;
	struct btrfs_root *csum_root;
	struct btrfs_root *chunk_root;
	struct btrfs_root *dev_root;
1954
	struct btrfs_root *quota_root;
1955
	struct btrfs_root *log_tree_root;
1956
	int ret;
1957
	int err = -EINVAL;
C
Chris Mason 已提交
1958 1959
	int num_backups_tried = 0;
	int backup_index = 0;
1960

1961
	tree_root = fs_info->tree_root = btrfs_alloc_root(fs_info);
A
Al Viro 已提交
1962 1963 1964 1965
	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);
1966
	quota_root = fs_info->quota_root = btrfs_alloc_root(fs_info);
1967

1968
	if (!tree_root || !extent_root || !csum_root ||
1969
	    !chunk_root || !dev_root || !quota_root) {
C
Chris Mason 已提交
1970 1971 1972
		err = -ENOMEM;
		goto fail;
	}
1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991

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

1992
	mapping_set_gfp_mask(fs_info->btree_inode->i_mapping, GFP_NOFS);
1993

1994
	INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_ATOMIC);
C
Chris Mason 已提交
1995
	INIT_LIST_HEAD(&fs_info->trans_list);
1996
	INIT_LIST_HEAD(&fs_info->dead_roots);
Y
Yan, Zheng 已提交
1997
	INIT_LIST_HEAD(&fs_info->delayed_iputs);
1998
	INIT_LIST_HEAD(&fs_info->hashers);
1999
	INIT_LIST_HEAD(&fs_info->delalloc_inodes);
2000
	INIT_LIST_HEAD(&fs_info->ordered_operations);
2001
	INIT_LIST_HEAD(&fs_info->caching_block_groups);
2002
	spin_lock_init(&fs_info->delalloc_lock);
J
Josef Bacik 已提交
2003
	spin_lock_init(&fs_info->trans_lock);
Y
Yan Zheng 已提交
2004
	spin_lock_init(&fs_info->ref_cache_lock);
2005
	spin_lock_init(&fs_info->fs_roots_radix_lock);
Y
Yan, Zheng 已提交
2006
	spin_lock_init(&fs_info->delayed_iput_lock);
C
Chris Mason 已提交
2007
	spin_lock_init(&fs_info->defrag_inodes_lock);
2008
	spin_lock_init(&fs_info->free_chunk_lock);
J
Jan Schmidt 已提交
2009 2010
	spin_lock_init(&fs_info->tree_mod_seq_lock);
	rwlock_init(&fs_info->tree_mod_log_lock);
C
Chris Mason 已提交
2011
	mutex_init(&fs_info->reloc_mutex);
2012

2013
	init_completion(&fs_info->kobj_unregister);
2014
	INIT_LIST_HEAD(&fs_info->dirty_cowonly_roots);
2015
	INIT_LIST_HEAD(&fs_info->space_info);
J
Jan Schmidt 已提交
2016
	INIT_LIST_HEAD(&fs_info->tree_mod_seq_list);
2017
	btrfs_mapping_init(&fs_info->mapping_tree);
2018 2019 2020 2021 2022
	btrfs_init_block_rsv(&fs_info->global_block_rsv);
	btrfs_init_block_rsv(&fs_info->delalloc_block_rsv);
	btrfs_init_block_rsv(&fs_info->trans_block_rsv);
	btrfs_init_block_rsv(&fs_info->chunk_block_rsv);
	btrfs_init_block_rsv(&fs_info->empty_block_rsv);
2023
	btrfs_init_block_rsv(&fs_info->delayed_block_rsv);
2024
	atomic_set(&fs_info->nr_async_submits, 0);
2025
	atomic_set(&fs_info->async_delalloc_pages, 0);
2026
	atomic_set(&fs_info->async_submit_draining, 0);
2027
	atomic_set(&fs_info->nr_async_bios, 0);
C
Chris Mason 已提交
2028
	atomic_set(&fs_info->defrag_running, 0);
J
Jan Schmidt 已提交
2029
	atomic_set(&fs_info->tree_mod_seq, 0);
C
Chris Mason 已提交
2030
	fs_info->sb = sb;
2031
	fs_info->max_inline = 8192 * 1024;
J
Josef Bacik 已提交
2032
	fs_info->metadata_ratio = 0;
C
Chris Mason 已提交
2033
	fs_info->defrag_inodes = RB_ROOT;
J
Josef Bacik 已提交
2034
	fs_info->trans_no_join = 0;
2035
	fs_info->free_chunk_space = 0;
J
Jan Schmidt 已提交
2036
	fs_info->tree_mod_log = RB_ROOT;
C
Chris Mason 已提交
2037

2038 2039 2040
	/* readahead state */
	INIT_RADIX_TREE(&fs_info->reada_tree, GFP_NOFS & ~__GFP_WAIT);
	spin_lock_init(&fs_info->reada_lock);
C
Chris Mason 已提交
2041

2042 2043
	fs_info->thread_pool_size = min_t(unsigned long,
					  num_online_cpus() + 2, 8);
2044

2045 2046
	INIT_LIST_HEAD(&fs_info->ordered_extents);
	spin_lock_init(&fs_info->ordered_extent_lock);
2047 2048 2049 2050 2051 2052 2053
	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);
2054

A
Arne Jansen 已提交
2055 2056 2057 2058 2059 2060 2061 2062
	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;
2063 2064 2065
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
	fs_info->check_integrity_print_mask = 0;
#endif
A
Arne Jansen 已提交
2066

2067 2068
	spin_lock_init(&fs_info->balance_lock);
	mutex_init(&fs_info->balance_mutex);
2069 2070
	atomic_set(&fs_info->balance_running, 0);
	atomic_set(&fs_info->balance_pause_req, 0);
2071
	atomic_set(&fs_info->balance_cancel_req, 0);
2072
	fs_info->balance_ctl = NULL;
2073
	init_waitqueue_head(&fs_info->balance_wait_q);
A
Arne Jansen 已提交
2074

2075 2076
	sb->s_blocksize = 4096;
	sb->s_blocksize_bits = blksize_bits(4096);
J
Jens Axboe 已提交
2077
	sb->s_bdi = &fs_info->bdi;
2078

2079
	fs_info->btree_inode->i_ino = BTRFS_BTREE_INODE_OBJECTID;
M
Miklos Szeredi 已提交
2080
	set_nlink(fs_info->btree_inode, 1);
2081 2082 2083 2084 2085 2086
	/*
	 * 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;
2087
	fs_info->btree_inode->i_mapping->a_ops = &btree_aops;
C
Chris Mason 已提交
2088 2089
	fs_info->btree_inode->i_mapping->backing_dev_info = &fs_info->bdi;

2090
	RB_CLEAR_NODE(&BTRFS_I(fs_info->btree_inode)->rb_node);
2091
	extent_io_tree_init(&BTRFS_I(fs_info->btree_inode)->io_tree,
2092
			     fs_info->btree_inode->i_mapping);
2093
	BTRFS_I(fs_info->btree_inode)->io_tree.track_uptodate = 0;
2094
	extent_map_tree_init(&BTRFS_I(fs_info->btree_inode)->extent_tree);
2095 2096

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

2098 2099 2100
	BTRFS_I(fs_info->btree_inode)->root = tree_root;
	memset(&BTRFS_I(fs_info->btree_inode)->location, 0,
	       sizeof(struct btrfs_key));
2101 2102
	set_bit(BTRFS_INODE_DUMMY,
		&BTRFS_I(fs_info->btree_inode)->runtime_flags);
2103
	insert_inode_hash(fs_info->btree_inode);
2104

J
Josef Bacik 已提交
2105
	spin_lock_init(&fs_info->block_group_cache_lock);
2106
	fs_info->block_group_cache_tree = RB_ROOT;
J
Josef Bacik 已提交
2107

2108
	extent_io_tree_init(&fs_info->freed_extents[0],
2109
			     fs_info->btree_inode->i_mapping);
2110
	extent_io_tree_init(&fs_info->freed_extents[1],
2111
			     fs_info->btree_inode->i_mapping);
2112
	fs_info->pinned_extents = &fs_info->freed_extents[0];
2113
	fs_info->do_barriers = 1;
2114

C
Chris Mason 已提交
2115

2116
	mutex_init(&fs_info->ordered_operations_mutex);
2117
	mutex_init(&fs_info->tree_log_mutex);
2118
	mutex_init(&fs_info->chunk_mutex);
2119 2120
	mutex_init(&fs_info->transaction_kthread_mutex);
	mutex_init(&fs_info->cleaner_mutex);
2121
	mutex_init(&fs_info->volume_mutex);
2122
	init_rwsem(&fs_info->extent_commit_sem);
2123
	init_rwsem(&fs_info->cleanup_work_sem);
2124
	init_rwsem(&fs_info->subvol_sem);
2125

2126 2127 2128 2129 2130 2131 2132
	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;

2133 2134 2135
	btrfs_init_free_cluster(&fs_info->meta_alloc_cluster);
	btrfs_init_free_cluster(&fs_info->data_alloc_cluster);

2136
	init_waitqueue_head(&fs_info->transaction_throttle);
2137
	init_waitqueue_head(&fs_info->transaction_wait);
S
Sage Weil 已提交
2138
	init_waitqueue_head(&fs_info->transaction_blocked_wait);
2139
	init_waitqueue_head(&fs_info->async_submit_wait);
2140

2141
	__setup_root(4096, 4096, 4096, 4096, tree_root,
C
Chris Mason 已提交
2142
		     fs_info, BTRFS_ROOT_TREE_OBJECTID);
2143

2144
	invalidate_bdev(fs_devices->latest_bdev);
Y
Yan Zheng 已提交
2145
	bh = btrfs_read_dev_super(fs_devices->latest_bdev);
2146 2147
	if (!bh) {
		err = -EINVAL;
2148
		goto fail_alloc;
2149
	}
C
Chris Mason 已提交
2150

2151 2152 2153
	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));
2154
	brelse(bh);
2155

2156
	memcpy(fs_info->fsid, fs_info->super_copy->fsid, BTRFS_FSID_SIZE);
2157

2158
	disk_super = fs_info->super_copy;
2159
	if (!btrfs_super_root(disk_super))
2160
		goto fail_alloc;
2161

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

2165 2166 2167 2168 2169 2170
	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 已提交
2171

C
Chris Mason 已提交
2172 2173 2174 2175 2176 2177 2178
	/*
	 * 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);

2179 2180 2181 2182 2183 2184
	/*
	 * 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 已提交
2185 2186 2187
	ret = btrfs_parse_options(tree_root, options);
	if (ret) {
		err = ret;
2188
		goto fail_alloc;
Y
Yan Zheng 已提交
2189
	}
2190

2191 2192 2193 2194 2195
	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",
2196
		       (unsigned long long)features);
2197
		err = -EINVAL;
2198
		goto fail_alloc;
2199 2200
	}

2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217
	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;
	}

2218
	features = btrfs_super_incompat_flags(disk_super);
L
Li Zefan 已提交
2219
	features |= BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF;
L
Li Zefan 已提交
2220
	if (tree_root->fs_info->compress_type == BTRFS_COMPRESS_LZO)
L
Li Zefan 已提交
2221
		features |= BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO;
2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232

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

2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249
	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 已提交
2250
	btrfs_set_super_incompat_flags(disk_super, features);
2251

2252 2253 2254 2255 2256
	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",
2257
		       (unsigned long long)features);
2258
		err = -EINVAL;
2259
		goto fail_alloc;
2260
	}
2261 2262 2263 2264

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

2265
	btrfs_init_workers(&fs_info->workers, "worker",
2266 2267
			   fs_info->thread_pool_size,
			   &fs_info->generic_worker);
C
Chris Mason 已提交
2268

2269
	btrfs_init_workers(&fs_info->delalloc_workers, "delalloc",
2270 2271
			   fs_info->thread_pool_size,
			   &fs_info->generic_worker);
2272

2273
	btrfs_init_workers(&fs_info->submit_workers, "submit",
2274
			   min_t(u64, fs_devices->num_devices,
2275 2276
			   fs_info->thread_pool_size),
			   &fs_info->generic_worker);
2277

2278 2279 2280
	btrfs_init_workers(&fs_info->caching_workers, "cache",
			   2, &fs_info->generic_worker);

2281 2282 2283 2284 2285
	/* 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;
2286

2287
	fs_info->workers.idle_thresh = 16;
C
Chris Mason 已提交
2288
	fs_info->workers.ordered = 1;
2289

2290 2291 2292
	fs_info->delalloc_workers.idle_thresh = 2;
	fs_info->delalloc_workers.ordered = 1;

2293 2294
	btrfs_init_workers(&fs_info->fixup_workers, "fixup", 1,
			   &fs_info->generic_worker);
2295
	btrfs_init_workers(&fs_info->endio_workers, "endio",
2296 2297
			   fs_info->thread_pool_size,
			   &fs_info->generic_worker);
2298
	btrfs_init_workers(&fs_info->endio_meta_workers, "endio-meta",
2299 2300
			   fs_info->thread_pool_size,
			   &fs_info->generic_worker);
2301
	btrfs_init_workers(&fs_info->endio_meta_write_workers,
2302 2303
			   "endio-meta-write", fs_info->thread_pool_size,
			   &fs_info->generic_worker);
2304
	btrfs_init_workers(&fs_info->endio_write_workers, "endio-write",
2305 2306
			   fs_info->thread_pool_size,
			   &fs_info->generic_worker);
J
Josef Bacik 已提交
2307 2308
	btrfs_init_workers(&fs_info->endio_freespace_worker, "freespace-write",
			   1, &fs_info->generic_worker);
2309 2310 2311
	btrfs_init_workers(&fs_info->delayed_workers, "delayed-meta",
			   fs_info->thread_pool_size,
			   &fs_info->generic_worker);
2312 2313 2314
	btrfs_init_workers(&fs_info->readahead_workers, "readahead",
			   fs_info->thread_pool_size,
			   &fs_info->generic_worker);
2315 2316 2317 2318 2319 2320

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

2323 2324
	fs_info->endio_write_workers.idle_thresh = 2;
	fs_info->endio_meta_write_workers.idle_thresh = 2;
2325
	fs_info->readahead_workers.idle_thresh = 2;
2326

2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344
	/*
	 * 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);
	if (ret) {
2345
		err = -ENOMEM;
2346 2347
		goto fail_sb_buffer;
	}
2348

2349
	fs_info->bdi.ra_pages *= btrfs_super_num_devices(disk_super);
C
Chris Mason 已提交
2350 2351
	fs_info->bdi.ra_pages = max(fs_info->bdi.ra_pages,
				    4 * 1024 * 1024 / PAGE_CACHE_SIZE);
2352

2353 2354 2355
	tree_root->nodesize = nodesize;
	tree_root->leafsize = leafsize;
	tree_root->sectorsize = sectorsize;
2356
	tree_root->stripesize = stripesize;
2357 2358 2359

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

C
Chris Mason 已提交
2361 2362
	if (strncmp((char *)(&disk_super->magic), BTRFS_MAGIC,
		    sizeof(disk_super->magic))) {
C
Chris Mason 已提交
2363
		printk(KERN_INFO "btrfs: valid FS not found on %s\n", sb->s_id);
C
Chris Mason 已提交
2364 2365
		goto fail_sb_buffer;
	}
2366

2367 2368 2369
	if (sectorsize != PAGE_SIZE) {
		printk(KERN_WARNING "btrfs: Incompatible sector size(%lu) "
		       "found on %s\n", (unsigned long)sectorsize, sb->s_id);
2370 2371 2372
		goto fail_sb_buffer;
	}

2373
	mutex_lock(&fs_info->chunk_mutex);
Y
Yan Zheng 已提交
2374
	ret = btrfs_read_sys_array(tree_root);
2375
	mutex_unlock(&fs_info->chunk_mutex);
2376
	if (ret) {
C
Chris Mason 已提交
2377 2378
		printk(KERN_WARNING "btrfs: failed to read the system "
		       "array on %s\n", sb->s_id);
2379
		goto fail_sb_buffer;
2380
	}
2381 2382 2383

	blocksize = btrfs_level_size(tree_root,
				     btrfs_super_chunk_root_level(disk_super));
2384
	generation = btrfs_super_chunk_root_generation(disk_super);
2385 2386 2387 2388 2389 2390

	__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),
2391
					   blocksize, generation);
2392
	BUG_ON(!chunk_root->node); /* -ENOMEM */
2393 2394 2395
	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 已提交
2396
		goto fail_tree_roots;
2397
	}
2398 2399
	btrfs_set_root_node(&chunk_root->root_item, chunk_root->node);
	chunk_root->commit_root = btrfs_root_node(chunk_root);
2400

2401
	read_extent_buffer(chunk_root->node, fs_info->chunk_tree_uuid,
C
Chris Mason 已提交
2402 2403
	   (unsigned long)btrfs_header_chunk_tree_uuid(chunk_root->node),
	   BTRFS_UUID_SIZE);
2404

2405
	ret = btrfs_read_chunk_tree(chunk_root);
Y
Yan Zheng 已提交
2406
	if (ret) {
C
Chris Mason 已提交
2407 2408
		printk(KERN_WARNING "btrfs: failed to read chunk tree on %s\n",
		       sb->s_id);
C
Chris Mason 已提交
2409
		goto fail_tree_roots;
Y
Yan Zheng 已提交
2410
	}
2411

2412 2413
	btrfs_close_extra_devices(fs_devices);

2414 2415 2416 2417 2418 2419
	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 已提交
2420
retry_root_backup:
2421 2422
	blocksize = btrfs_level_size(tree_root,
				     btrfs_super_root_level(disk_super));
2423
	generation = btrfs_super_generation(disk_super);
2424

C
Chris Mason 已提交
2425
	tree_root->node = read_tree_block(tree_root,
2426
					  btrfs_super_root(disk_super),
2427
					  blocksize, generation);
C
Chris Mason 已提交
2428 2429
	if (!tree_root->node ||
	    !test_bit(EXTENT_BUFFER_UPTODATE, &tree_root->node->bflags)) {
2430 2431
		printk(KERN_WARNING "btrfs: failed to read tree root on %s\n",
		       sb->s_id);
C
Chris Mason 已提交
2432 2433

		goto recovery_tree_root;
2434
	}
C
Chris Mason 已提交
2435

2436 2437
	btrfs_set_root_node(&tree_root->root_item, tree_root->node);
	tree_root->commit_root = btrfs_root_node(tree_root);
2438 2439

	ret = find_and_setup_root(tree_root, fs_info,
C
Chris Mason 已提交
2440
				  BTRFS_EXTENT_TREE_OBJECTID, extent_root);
2441
	if (ret)
C
Chris Mason 已提交
2442
		goto recovery_tree_root;
2443 2444 2445 2446 2447
	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 已提交
2448
		goto recovery_tree_root;
2449
	dev_root->track_dirty = 1;
2450

2451 2452 2453
	ret = find_and_setup_root(tree_root, fs_info,
				  BTRFS_CSUM_TREE_OBJECTID, csum_root);
	if (ret)
C
Chris Mason 已提交
2454
		goto recovery_tree_root;
2455 2456
	csum_root->track_dirty = 1;

2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467
	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;
	}

2468 2469 2470
	fs_info->generation = generation;
	fs_info->last_trans_committed = generation;

2471 2472 2473 2474 2475 2476
	ret = btrfs_recover_balance(fs_info);
	if (ret) {
		printk(KERN_WARNING "btrfs: failed to recover balance\n");
		goto fail_block_groups;
	}

2477 2478 2479 2480 2481 2482 2483
	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;
	}

2484 2485 2486 2487 2488 2489
	ret = btrfs_init_space_info(fs_info);
	if (ret) {
		printk(KERN_ERR "Failed to initial space info: %d\n", ret);
		goto fail_block_groups;
	}

2490 2491 2492 2493 2494
	ret = btrfs_read_block_groups(extent_root);
	if (ret) {
		printk(KERN_ERR "Failed to read block groups: %d\n", ret);
		goto fail_block_groups;
	}
C
Chris Mason 已提交
2495

2496 2497
	fs_info->cleaner_kthread = kthread_run(cleaner_kthread, tree_root,
					       "btrfs-cleaner");
2498
	if (IS_ERR(fs_info->cleaner_kthread))
2499
		goto fail_block_groups;
2500 2501 2502 2503

	fs_info->transaction_kthread = kthread_run(transaction_kthread,
						   tree_root,
						   "btrfs-transaction");
2504
	if (IS_ERR(fs_info->transaction_kthread))
2505
		goto fail_cleaner;
2506

C
Chris Mason 已提交
2507 2508 2509 2510 2511 2512 2513 2514
	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);
	}

2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526
#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
2527 2528 2529
	ret = btrfs_read_qgroup_config(fs_info);
	if (ret)
		goto fail_trans_kthread;
2530

L
liubo 已提交
2531 2532 2533
	/* do not make disk changes in broken FS */
	if (btrfs_super_log_root(disk_super) != 0 &&
	    !(fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR)) {
2534 2535
		u64 bytenr = btrfs_super_log_root(disk_super);

2536
		if (fs_devices->rw_devices == 0) {
C
Chris Mason 已提交
2537 2538
			printk(KERN_WARNING "Btrfs log replay required "
			       "on RO media\n");
2539
			err = -EIO;
2540
			goto fail_qgroup;
2541
		}
2542 2543 2544
		blocksize =
		     btrfs_level_size(tree_root,
				      btrfs_super_log_root_level(disk_super));
C
Chris Mason 已提交
2545

A
Al Viro 已提交
2546
		log_tree_root = btrfs_alloc_root(fs_info);
2547 2548
		if (!log_tree_root) {
			err = -ENOMEM;
2549
			goto fail_qgroup;
2550
		}
2551 2552 2553 2554 2555

		__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,
2556 2557
						      blocksize,
						      generation + 1);
2558
		/* returns with log_tree_root freed on success */
2559
		ret = btrfs_recover_log_trees(log_tree_root);
2560 2561 2562 2563 2564 2565 2566
		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;
		}
2567 2568

		if (sb->s_flags & MS_RDONLY) {
2569 2570 2571
			ret = btrfs_commit_super(tree_root);
			if (ret)
				goto fail_trans_kthread;
2572
		}
2573
	}
Z
Zheng Yan 已提交
2574

2575
	ret = btrfs_find_orphan_roots(tree_root);
2576 2577
	if (ret)
		goto fail_trans_kthread;
2578

2579
	if (!(sb->s_flags & MS_RDONLY)) {
2580
		ret = btrfs_cleanup_fs_roots(fs_info);
2581 2582
		if (ret)
			goto fail_trans_kthread;
2583

2584
		ret = btrfs_recover_relocation(tree_root);
2585 2586 2587 2588
		if (ret < 0) {
			printk(KERN_WARNING
			       "btrfs: failed to recover relocation\n");
			err = -EINVAL;
2589
			goto fail_qgroup;
2590
		}
2591
	}
Z
Zheng Yan 已提交
2592

2593 2594 2595 2596 2597 2598
	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)
2599
		goto fail_qgroup;
2600 2601
	if (IS_ERR(fs_info->fs_root)) {
		err = PTR_ERR(fs_info->fs_root);
2602
		goto fail_qgroup;
2603
	}
C
Chris Mason 已提交
2604

2605 2606
	if (sb->s_flags & MS_RDONLY)
		return 0;
I
Ilya Dryomov 已提交
2607

2608 2609 2610
	down_read(&fs_info->cleanup_work_sem);
	if ((ret = btrfs_orphan_cleanup(fs_info->fs_root)) ||
	    (ret = btrfs_orphan_cleanup(fs_info->tree_root))) {
2611
		up_read(&fs_info->cleanup_work_sem);
2612 2613 2614 2615
		close_ctree(tree_root);
		return ret;
	}
	up_read(&fs_info->cleanup_work_sem);
I
Ilya Dryomov 已提交
2616

2617 2618 2619 2620 2621
	ret = btrfs_resume_balance_async(fs_info);
	if (ret) {
		printk(KERN_WARNING "btrfs: failed to resume balance\n");
		close_ctree(tree_root);
		return ret;
2622 2623
	}

A
Al Viro 已提交
2624
	return 0;
C
Chris Mason 已提交
2625

2626 2627
fail_qgroup:
	btrfs_free_qgroup_config(fs_info);
2628 2629
fail_trans_kthread:
	kthread_stop(fs_info->transaction_kthread);
2630
fail_cleaner:
2631
	kthread_stop(fs_info->cleaner_kthread);
2632 2633 2634 2635 2636 2637 2638 2639

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

2640 2641
fail_block_groups:
	btrfs_free_block_groups(fs_info);
C
Chris Mason 已提交
2642 2643 2644 2645

fail_tree_roots:
	free_root_pointers(fs_info, 1);

C
Chris Mason 已提交
2646
fail_sb_buffer:
2647
	btrfs_stop_workers(&fs_info->generic_worker);
2648
	btrfs_stop_workers(&fs_info->readahead_workers);
2649
	btrfs_stop_workers(&fs_info->fixup_workers);
2650
	btrfs_stop_workers(&fs_info->delalloc_workers);
2651 2652
	btrfs_stop_workers(&fs_info->workers);
	btrfs_stop_workers(&fs_info->endio_workers);
2653
	btrfs_stop_workers(&fs_info->endio_meta_workers);
2654
	btrfs_stop_workers(&fs_info->endio_meta_write_workers);
2655
	btrfs_stop_workers(&fs_info->endio_write_workers);
J
Josef Bacik 已提交
2656
	btrfs_stop_workers(&fs_info->endio_freespace_worker);
2657
	btrfs_stop_workers(&fs_info->submit_workers);
2658
	btrfs_stop_workers(&fs_info->delayed_workers);
2659
	btrfs_stop_workers(&fs_info->caching_workers);
2660
fail_alloc:
2661
fail_iput:
2662 2663
	btrfs_mapping_tree_free(&fs_info->mapping_tree);

2664
	invalidate_inode_pages2(fs_info->btree_inode->i_mapping);
2665
	iput(fs_info->btree_inode);
2666
fail_bdi:
2667
	bdi_destroy(&fs_info->bdi);
2668 2669
fail_srcu:
	cleanup_srcu_struct(&fs_info->subvol_srcu);
2670
fail:
2671
	btrfs_close_devices(fs_info->fs_devices);
A
Al Viro 已提交
2672
	return err;
C
Chris Mason 已提交
2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690

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

2693 2694 2695 2696 2697
static void btrfs_end_buffer_write_sync(struct buffer_head *bh, int uptodate)
{
	if (uptodate) {
		set_buffer_uptodate(bh);
	} else {
2698 2699 2700
		struct btrfs_device *device = (struct btrfs_device *)
			bh->b_private;

2701 2702 2703
		printk_ratelimited_in_rcu(KERN_WARNING "lost page write due to "
					  "I/O error on %s\n",
					  rcu_str_deref(device->name));
2704 2705 2706
		/* note, we dont' set_buffer_write_io_error because we have
		 * our own ways of dealing with the IO errors
		 */
2707
		clear_buffer_uptodate(bh);
2708
		btrfs_dev_stat_inc_and_print(device, BTRFS_DEV_STAT_WRITE_ERRS);
2709 2710 2711 2712 2713
	}
	unlock_buffer(bh);
	put_bh(bh);
}

Y
Yan Zheng 已提交
2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754
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;
}

2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765
/*
 * 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 已提交
2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789
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);
2790 2791 2792 2793 2794 2795 2796 2797 2798
			if (!buffer_uptodate(bh))
				errors++;

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

			/* drop the reference from the wait == 0 run */
			brelse(bh);
			continue;
Y
Yan Zheng 已提交
2799 2800 2801 2802 2803 2804 2805 2806 2807 2808
		} 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);

2809 2810 2811 2812
			/*
			 * one reference for us, and we leave it for the
			 * caller
			 */
Y
Yan Zheng 已提交
2813 2814 2815 2816
			bh = __getblk(device->bdev, bytenr / 4096,
				      BTRFS_SUPER_INFO_SIZE);
			memcpy(bh->b_data, sb, BTRFS_SUPER_INFO_SIZE);

2817
			/* one reference for submit_bh */
Y
Yan Zheng 已提交
2818
			get_bh(bh);
2819 2820

			set_buffer_uptodate(bh);
Y
Yan Zheng 已提交
2821 2822
			lock_buffer(bh);
			bh->b_end_io = btrfs_end_buffer_write_sync;
2823
			bh->b_private = device;
Y
Yan Zheng 已提交
2824 2825
		}

C
Chris Mason 已提交
2826 2827 2828 2829
		/*
		 * we fua the first super.  The others we allow
		 * to go down lazy.
		 */
2830
		ret = btrfsic_submit_bh(WRITE_FUA, bh);
2831
		if (ret)
Y
Yan Zheng 已提交
2832 2833 2834 2835 2836
			errors++;
	}
	return errors < i ? 0 : -1;
}

C
Chris Mason 已提交
2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875
/*
 * 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)) {
2876 2877
			printk_in_rcu("btrfs: disabling barriers on dev %s\n",
				      rcu_str_deref(device->name));
C
Chris Mason 已提交
2878 2879 2880 2881
			device->nobarriers = 1;
		}
		if (!bio_flagged(bio, BIO_UPTODATE)) {
			ret = -EIO;
2882 2883 2884
			if (!bio_flagged(bio, BIO_EOPNOTSUPP))
				btrfs_dev_stat_inc_and_print(device,
					BTRFS_DEV_STAT_FLUSH_ERRS);
C
Chris Mason 已提交
2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897
		}

		/* 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
	 */
2898
	device->flush_bio = NULL;
C
Chris Mason 已提交
2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909
	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);
2910
	btrfsic_submit_bio(WRITE_FLUSH, bio);
C
Chris Mason 已提交
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 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958

	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;
	int errors = 0;
	int ret;

	/* send down all the barriers */
	head = &info->fs_devices->devices;
	list_for_each_entry_rcu(dev, head, dev_list) {
		if (!dev->bdev) {
			errors++;
			continue;
		}
		if (!dev->in_fs_metadata || !dev->writeable)
			continue;

		ret = write_dev_flush(dev, 0);
		if (ret)
			errors++;
	}

	/* wait for all the barriers */
	list_for_each_entry_rcu(dev, head, dev_list) {
		if (!dev->bdev) {
			errors++;
			continue;
		}
		if (!dev->in_fs_metadata || !dev->writeable)
			continue;

		ret = write_dev_flush(dev, 1);
		if (ret)
			errors++;
	}
	if (errors)
		return -EIO;
	return 0;
}

Y
Yan Zheng 已提交
2959
int write_all_supers(struct btrfs_root *root, int max_mirrors)
2960
{
2961
	struct list_head *head;
2962
	struct btrfs_device *dev;
2963
	struct btrfs_super_block *sb;
2964 2965 2966
	struct btrfs_dev_item *dev_item;
	int ret;
	int do_barriers;
2967 2968
	int max_errors;
	int total_errors = 0;
2969
	u64 flags;
2970

2971
	max_errors = btrfs_super_num_devices(root->fs_info->super_copy) - 1;
2972
	do_barriers = !btrfs_test_opt(root, NOBARRIER);
C
Chris Mason 已提交
2973
	backup_super_roots(root->fs_info);
2974

2975
	sb = root->fs_info->super_for_commit;
2976
	dev_item = &sb->dev_item;
2977

2978
	mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
2979
	head = &root->fs_info->fs_devices->devices;
C
Chris Mason 已提交
2980 2981 2982 2983

	if (do_barriers)
		barrier_all_devices(root->fs_info);

2984
	list_for_each_entry_rcu(dev, head, dev_list) {
2985 2986 2987 2988
		if (!dev->bdev) {
			total_errors++;
			continue;
		}
Y
Yan Zheng 已提交
2989
		if (!dev->in_fs_metadata || !dev->writeable)
2990 2991
			continue;

Y
Yan Zheng 已提交
2992
		btrfs_set_stack_device_generation(dev_item, 0);
2993 2994 2995 2996 2997 2998 2999 3000
		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 已提交
3001
		memcpy(dev_item->fsid, dev->fs_devices->fsid, BTRFS_UUID_SIZE);
Y
Yan Zheng 已提交
3002

3003 3004 3005
		flags = btrfs_super_flags(sb);
		btrfs_set_super_flags(sb, flags | BTRFS_HEADER_FLAG_WRITTEN);

Y
Yan Zheng 已提交
3006
		ret = write_dev_supers(dev, sb, do_barriers, 0, max_mirrors);
3007 3008
		if (ret)
			total_errors++;
3009
	}
3010
	if (total_errors > max_errors) {
C
Chris Mason 已提交
3011 3012
		printk(KERN_ERR "btrfs: %d errors while writing supers\n",
		       total_errors);
3013 3014

		/* This shouldn't happen. FUA is masked off if unsupported */
3015 3016
		BUG();
	}
3017

Y
Yan Zheng 已提交
3018
	total_errors = 0;
3019
	list_for_each_entry_rcu(dev, head, dev_list) {
3020 3021
		if (!dev->bdev)
			continue;
Y
Yan Zheng 已提交
3022
		if (!dev->in_fs_metadata || !dev->writeable)
3023 3024
			continue;

Y
Yan Zheng 已提交
3025 3026 3027
		ret = write_dev_supers(dev, sb, do_barriers, 1, max_mirrors);
		if (ret)
			total_errors++;
3028
	}
3029
	mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
3030
	if (total_errors > max_errors) {
3031 3032 3033
		btrfs_error(root->fs_info, -EIO,
			    "%d errors while writing supers", total_errors);
		return -EIO;
3034
	}
3035 3036 3037
	return 0;
}

Y
Yan Zheng 已提交
3038 3039
int write_ctree_super(struct btrfs_trans_handle *trans,
		      struct btrfs_root *root, int max_mirrors)
3040
{
3041
	int ret;
3042

Y
Yan Zheng 已提交
3043
	ret = write_all_supers(root, max_mirrors);
3044
	return ret;
C
Chris Mason 已提交
3045 3046
}

3047
void btrfs_free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root)
C
Chris Mason 已提交
3048
{
3049
	spin_lock(&fs_info->fs_roots_radix_lock);
C
Chris Mason 已提交
3050 3051
	radix_tree_delete(&fs_info->fs_roots_radix,
			  (unsigned long)root->root_key.objectid);
3052
	spin_unlock(&fs_info->fs_roots_radix_lock);
3053 3054 3055 3056

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

3057 3058
	__btrfs_remove_free_space_cache(root->free_ino_pinned);
	__btrfs_remove_free_space_cache(root->free_ino_ctl);
3059 3060 3061 3062 3063
	free_fs_root(root);
}

static void free_fs_root(struct btrfs_root *root)
{
3064
	iput(root->cache_inode);
3065
	WARN_ON(!RB_EMPTY_ROOT(&root->inode_tree));
3066 3067
	if (root->anon_dev)
		free_anon_bdev(root->anon_dev);
3068 3069
	free_extent_buffer(root->node);
	free_extent_buffer(root->commit_root);
3070 3071
	kfree(root->free_ino_ctl);
	kfree(root->free_ino_pinned);
C
Chris Mason 已提交
3072
	kfree(root->name);
C
Chris Mason 已提交
3073 3074 3075
	kfree(root);
}

3076
static void del_fs_roots(struct btrfs_fs_info *fs_info)
3077 3078 3079 3080 3081
{
	int ret;
	struct btrfs_root *gang[8];
	int i;

3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095
	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 已提交
3096
	while (1) {
3097 3098 3099 3100 3101
		ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
					     (void **)gang, 0,
					     ARRAY_SIZE(gang));
		if (!ret)
			break;
C
Chris Mason 已提交
3102
		for (i = 0; i < ret; i++)
3103
			btrfs_free_fs_root(fs_info, gang[i]);
3104 3105
	}
}
3106

Y
Yan Zheng 已提交
3107
int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info)
C
Chris Mason 已提交
3108
{
Y
Yan Zheng 已提交
3109 3110 3111
	u64 root_objectid = 0;
	struct btrfs_root *gang[8];
	int i;
3112
	int ret;
3113

Y
Yan Zheng 已提交
3114 3115 3116 3117 3118 3119
	while (1) {
		ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
					     (void **)gang, root_objectid,
					     ARRAY_SIZE(gang));
		if (!ret)
			break;
3120 3121

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

Y
Yan Zheng 已提交
3125
			root_objectid = gang[i]->root_key.objectid;
3126 3127 3128
			err = btrfs_orphan_cleanup(gang[i]);
			if (err)
				return err;
Y
Yan Zheng 已提交
3129 3130 3131 3132 3133
		}
		root_objectid++;
	}
	return 0;
}
3134

Y
Yan Zheng 已提交
3135 3136 3137 3138
int btrfs_commit_super(struct btrfs_root *root)
{
	struct btrfs_trans_handle *trans;
	int ret;
3139

Y
Yan Zheng 已提交
3140
	mutex_lock(&root->fs_info->cleaner_mutex);
Y
Yan, Zheng 已提交
3141
	btrfs_run_delayed_iputs(root);
3142
	btrfs_clean_old_snapshots(root);
Y
Yan Zheng 已提交
3143
	mutex_unlock(&root->fs_info->cleaner_mutex);
3144 3145 3146 3147 3148

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

3149
	trans = btrfs_join_transaction(root);
3150 3151
	if (IS_ERR(trans))
		return PTR_ERR(trans);
3152
	ret = btrfs_commit_transaction(trans, root);
3153 3154
	if (ret)
		return ret;
Y
Yan Zheng 已提交
3155
	/* run commit again to drop the original snapshot */
3156
	trans = btrfs_join_transaction(root);
3157 3158
	if (IS_ERR(trans))
		return PTR_ERR(trans);
3159 3160 3161
	ret = btrfs_commit_transaction(trans, root);
	if (ret)
		return ret;
C
Chris Mason 已提交
3162
	ret = btrfs_write_and_wait_transaction(NULL, root);
3163 3164 3165 3166 3167
	if (ret) {
		btrfs_error(root->fs_info, ret,
			    "Failed to sync btree inode to disk.");
		return ret;
	}
3168

Y
Yan Zheng 已提交
3169
	ret = write_ctree_super(NULL, root, 0);
Y
Yan Zheng 已提交
3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180
	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();

3181 3182 3183
	/* pause restriper - we want to resume on mount */
	btrfs_pause_balance(root->fs_info);

A
Arne Jansen 已提交
3184
	btrfs_scrub_cancel(root);
C
Chris Mason 已提交
3185 3186 3187 3188 3189 3190

	/* 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 */
A
Al Viro 已提交
3191
	btrfs_run_defrag_inodes(fs_info);
C
Chris Mason 已提交
3192

L
liubo 已提交
3193 3194 3195 3196 3197 3198 3199 3200 3201
	/*
	 * Here come 2 situations when btrfs is broken to flip readonly:
	 *
	 * 1. when btrfs flips readonly somewhere else before
	 * btrfs_commit_super, sb->s_flags has MS_RDONLY flag,
	 * and btrfs will skip to write sb directly to keep
	 * ERROR state on disk.
	 *
	 * 2. when btrfs flips readonly just in btrfs_commit_super,
3202
	 * and in such case, btrfs cannot write sb via btrfs_commit_super,
L
liubo 已提交
3203 3204 3205
	 * and since fs_state has been set BTRFS_SUPER_FLAG_ERROR flag,
	 * btrfs will cleanup all FS resources first and write sb then.
	 */
Y
Yan Zheng 已提交
3206
	if (!(fs_info->sb->s_flags & MS_RDONLY)) {
L
liubo 已提交
3207 3208 3209 3210 3211 3212 3213
		ret = btrfs_commit_super(root);
		if (ret)
			printk(KERN_ERR "btrfs: commit super ret %d\n", ret);
	}

	if (fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) {
		ret = btrfs_error_commit_super(root);
C
Chris Mason 已提交
3214 3215
		if (ret)
			printk(KERN_ERR "btrfs: commit super ret %d\n", ret);
Y
Yan Zheng 已提交
3216
	}
3217

3218 3219
	btrfs_put_block_group_cache(fs_info);

A
Al Viro 已提交
3220 3221
	kthread_stop(fs_info->transaction_kthread);
	kthread_stop(fs_info->cleaner_kthread);
3222

3223 3224 3225
	fs_info->closing = 2;
	smp_mb();

3226 3227
	btrfs_free_qgroup_config(root->fs_info);

C
Chris Mason 已提交
3228
	if (fs_info->delalloc_bytes) {
C
Chris Mason 已提交
3229
		printk(KERN_INFO "btrfs: at unmount delalloc count %llu\n",
3230
		       (unsigned long long)fs_info->delalloc_bytes);
C
Chris Mason 已提交
3231
	}
Y
Yan Zheng 已提交
3232
	if (fs_info->total_ref_cache_size) {
C
Chris Mason 已提交
3233 3234
		printk(KERN_INFO "btrfs: at umount reference cache size %llu\n",
		       (unsigned long long)fs_info->total_ref_cache_size);
Y
Yan Zheng 已提交
3235
	}
3236

3237 3238 3239 3240
	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 已提交
3241 3242 3243 3244 3245 3246
	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);
3247 3248 3249 3250
	if (fs_info->quota_root) {
		free_extent_buffer(fs_info->quota_root->node);
		free_extent_buffer(fs_info->quota_root->commit_root);
	}
3251

A
Al Viro 已提交
3252
	btrfs_free_block_groups(fs_info);
3253

Y
Yan Zheng 已提交
3254
	del_fs_roots(fs_info);
3255

Y
Yan Zheng 已提交
3256
	iput(fs_info->btree_inode);
3257

3258
	btrfs_stop_workers(&fs_info->generic_worker);
3259
	btrfs_stop_workers(&fs_info->fixup_workers);
3260
	btrfs_stop_workers(&fs_info->delalloc_workers);
3261 3262
	btrfs_stop_workers(&fs_info->workers);
	btrfs_stop_workers(&fs_info->endio_workers);
3263
	btrfs_stop_workers(&fs_info->endio_meta_workers);
3264
	btrfs_stop_workers(&fs_info->endio_meta_write_workers);
3265
	btrfs_stop_workers(&fs_info->endio_write_workers);
J
Josef Bacik 已提交
3266
	btrfs_stop_workers(&fs_info->endio_freespace_worker);
3267
	btrfs_stop_workers(&fs_info->submit_workers);
3268
	btrfs_stop_workers(&fs_info->delayed_workers);
3269
	btrfs_stop_workers(&fs_info->caching_workers);
3270
	btrfs_stop_workers(&fs_info->readahead_workers);
3271

3272 3273 3274 3275 3276
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
	if (btrfs_test_opt(root, CHECK_INTEGRITY))
		btrfsic_unmount(root, fs_info->fs_devices);
#endif

3277
	btrfs_close_devices(fs_info->fs_devices);
3278
	btrfs_mapping_tree_free(&fs_info->mapping_tree);
3279

C
Chris Mason 已提交
3280
	bdi_destroy(&fs_info->bdi);
3281
	cleanup_srcu_struct(&fs_info->subvol_srcu);
3282

3283 3284 3285
	return 0;
}

3286 3287
int btrfs_buffer_uptodate(struct extent_buffer *buf, u64 parent_transid,
			  int atomic)
3288
{
3289
	int ret;
3290
	struct inode *btree_inode = buf->pages[0]->mapping->host;
3291

3292
	ret = extent_buffer_uptodate(buf);
3293 3294 3295 3296
	if (!ret)
		return ret;

	ret = verify_parent_transid(&BTRFS_I(btree_inode)->io_tree, buf,
3297 3298 3299
				    parent_transid, atomic);
	if (ret == -EAGAIN)
		return ret;
3300
	return !ret;
3301 3302 3303
}

int btrfs_set_buffer_uptodate(struct extent_buffer *buf)
C
Chris Mason 已提交
3304
{
3305
	return set_extent_buffer_uptodate(buf);
3306
}
3307

3308 3309
void btrfs_mark_buffer_dirty(struct extent_buffer *buf)
{
3310
	struct btrfs_root *root = BTRFS_I(buf->pages[0]->mapping->host)->root;
3311
	u64 transid = btrfs_header_generation(buf);
3312
	int was_dirty;
3313

3314
	btrfs_assert_tree_locked(buf);
C
Chris Mason 已提交
3315
	if (transid != root->fs_info->generation) {
C
Chris Mason 已提交
3316 3317
		printk(KERN_CRIT "btrfs transid mismatch buffer %llu, "
		       "found %llu running %llu\n",
3318
			(unsigned long long)buf->start,
C
Chris Mason 已提交
3319 3320
			(unsigned long long)transid,
			(unsigned long long)root->fs_info->generation);
C
Chris Mason 已提交
3321 3322
		WARN_ON(1);
	}
3323
	was_dirty = set_extent_buffer_dirty(buf);
3324 3325 3326 3327 3328
	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);
	}
3329 3330
}

3331
void btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr)
3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354
{
	/*
	 * 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;

	btrfs_balance_delayed_items(root);

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

void __btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr)
C
Chris Mason 已提交
3355
{
3356 3357 3358 3359
	/*
	 * looks as though older kernels can get into trouble with
	 * this code, they end up stuck in balance_dirty_pages forever
	 */
3360
	u64 num_dirty;
3361
	unsigned long thresh = 32 * 1024 * 1024;
3362

3363
	if (current->flags & PF_MEMALLOC)
3364 3365
		return;

3366 3367
	num_dirty = root->fs_info->dirty_metadata_bytes;

3368 3369
	if (num_dirty > thresh) {
		balance_dirty_pages_ratelimited_nr(
C
Chris Mason 已提交
3370
				   root->fs_info->btree_inode->i_mapping, 1);
3371
	}
3372
	return;
C
Chris Mason 已提交
3373
}
3374

3375
int btrfs_read_buffer(struct extent_buffer *buf, u64 parent_transid)
3376
{
3377
	struct btrfs_root *root = BTRFS_I(buf->pages[0]->mapping->host)->root;
3378
	return btree_read_extent_buffer_pages(root, buf, 0, parent_transid);
3379
}
3380

3381
int btree_lock_page_hook(struct page *page, void *data,
3382
				void (*flush_fn)(void *))
C
Chris Mason 已提交
3383 3384
{
	struct inode *inode = page->mapping->host;
3385
	struct btrfs_root *root = BTRFS_I(inode)->root;
C
Chris Mason 已提交
3386 3387
	struct extent_buffer *eb;

J
Josef Bacik 已提交
3388 3389 3390 3391 3392
	/*
	 * We culled this eb but the page is still hanging out on the mapping,
	 * carry on.
	 */
	if (!PagePrivate(page))
C
Chris Mason 已提交
3393 3394
		goto out;

J
Josef Bacik 已提交
3395 3396 3397 3398 3399 3400
	eb = (struct extent_buffer *)page->private;
	if (!eb) {
		WARN_ON(1);
		goto out;
	}
	if (page != eb->pages[0])
C
Chris Mason 已提交
3401 3402
		goto out;

3403 3404 3405 3406
	if (!btrfs_try_tree_write_lock(eb)) {
		flush_fn(data);
		btrfs_tree_lock(eb);
	}
C
Chris Mason 已提交
3407
	btrfs_set_header_flag(eb, BTRFS_HEADER_FLAG_WRITTEN);
3408 3409 3410 3411 3412 3413 3414 3415 3416 3417

	if (test_and_clear_bit(EXTENT_BUFFER_DIRTY, &eb->bflags)) {
		spin_lock(&root->fs_info->delalloc_lock);
		if (root->fs_info->dirty_metadata_bytes >= eb->len)
			root->fs_info->dirty_metadata_bytes -= eb->len;
		else
			WARN_ON(1);
		spin_unlock(&root->fs_info->delalloc_lock);
	}

C
Chris Mason 已提交
3418 3419
	btrfs_tree_unlock(eb);
out:
3420 3421 3422 3423
	if (!trylock_page(page)) {
		flush_fn(data);
		lock_page(page);
	}
C
Chris Mason 已提交
3424 3425 3426
	return 0;
}

3427
static int btrfs_check_super_valid(struct btrfs_fs_info *fs_info,
L
liubo 已提交
3428 3429
			      int read_only)
{
3430 3431 3432 3433 3434
	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 已提交
3435
	if (read_only)
3436
		return 0;
L
liubo 已提交
3437

3438
	if (fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) {
L
liubo 已提交
3439 3440
		printk(KERN_WARNING "warning: mount fs with errors, "
		       "running btrfsck is recommended\n");
3441 3442 3443
	}

	return 0;
L
liubo 已提交
3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464
}

int btrfs_error_commit_super(struct btrfs_root *root)
{
	int ret;

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

	ret = write_ctree_super(NULL, root, 0);

	return ret;
}

3465
static void btrfs_destroy_ordered_operations(struct btrfs_root *root)
L
liubo 已提交
3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488
{
	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);
}

3489
static void btrfs_destroy_ordered_extents(struct btrfs_root *root)
L
liubo 已提交
3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522
{
	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);
}

3523 3524
int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans,
			       struct btrfs_root *root)
L
liubo 已提交
3525 3526 3527 3528 3529 3530 3531 3532 3533 3534
{
	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) {
3535
		spin_unlock(&delayed_refs->lock);
L
liubo 已提交
3536 3537 3538 3539
		printk(KERN_INFO "delayed_refs has NO entry\n");
		return ret;
	}

3540
	while ((node = rb_first(&delayed_refs->root)) != NULL) {
L
liubo 已提交
3541 3542 3543 3544 3545 3546 3547
		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);
3548 3549 3550 3551 3552 3553 3554 3555 3556
			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 已提交
3557
				spin_lock(&delayed_refs->lock);
3558 3559 3560
				continue;
			}

L
liubo 已提交
3561 3562 3563 3564 3565 3566
			kfree(head->extent_op);
			delayed_refs->num_heads--;
			if (list_empty(&head->cluster))
				delayed_refs->num_heads_ready--;
			list_del_init(&head->cluster);
		}
3567 3568 3569 3570
		ref->in_tree = 0;
		rb_erase(&ref->rb_node, &delayed_refs->root);
		delayed_refs->num_entries--;

L
liubo 已提交
3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582
		spin_unlock(&delayed_refs->lock);
		btrfs_put_delayed_ref(ref);

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

	spin_unlock(&delayed_refs->lock);

	return ret;
}

3583
static void btrfs_destroy_pending_snapshots(struct btrfs_transaction *t)
L
liubo 已提交
3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602
{
	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);
	}
}

3603
static void btrfs_destroy_delalloc_inodes(struct btrfs_root *root)
L
liubo 已提交
3604 3605 3606 3607 3608 3609 3610
{
	struct btrfs_inode *btrfs_inode;
	struct list_head splice;

	INIT_LIST_HEAD(&splice);

	spin_lock(&root->fs_info->delalloc_lock);
3611
	list_splice_init(&root->fs_info->delalloc_inodes, &splice);
L
liubo 已提交
3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657

	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,
					    mark);
		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);
3658
			if (eb)
L
liubo 已提交
3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674
				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);
3675
			page_cache_release(page);
L
liubo 已提交
3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688
		}
	}

	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;
3689
	bool loop = true;
L
liubo 已提交
3690 3691

	unpin = pinned_extents;
3692
again:
L
liubo 已提交
3693 3694 3695 3696 3697 3698 3699
	while (1) {
		ret = find_first_extent_bit(unpin, 0, &start, &end,
					    EXTENT_DIRTY);
		if (ret)
			break;

		/* opt_discard */
3700 3701 3702 3703
		if (btrfs_test_opt(root, DISCARD))
			ret = btrfs_error_discard_extent(root, start,
							 end + 1 - start,
							 NULL);
L
liubo 已提交
3704 3705 3706 3707 3708 3709

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

3710 3711 3712 3713 3714 3715 3716 3717 3718
	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 已提交
3719 3720 3721
	return 0;
}

3722 3723 3724 3725 3726 3727 3728 3729 3730 3731
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;
3732
	wake_up(&root->fs_info->transaction_blocked_wait);
3733 3734

	cur_trans->blocked = 0;
3735
	wake_up(&root->fs_info->transaction_wait);
3736 3737

	cur_trans->commit_done = 1;
3738
	wake_up(&cur_trans->commit_wait);
3739

3740 3741
	btrfs_destroy_delayed_inodes(root);
	btrfs_assert_delayed_root_empty(root);
3742 3743 3744 3745 3746

	btrfs_destroy_pending_snapshots(cur_trans);

	btrfs_destroy_marked_extents(root, &cur_trans->dirty_pages,
				     EXTENT_DIRTY);
3747 3748
	btrfs_destroy_pinned_extent(root,
				    root->fs_info->pinned_extents);
3749 3750 3751 3752 3753 3754 3755 3756

	/*
	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 已提交
3757 3758 3759 3760 3761 3762
{
	struct btrfs_transaction *t;
	LIST_HEAD(list);

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

J
Josef Bacik 已提交
3763
	spin_lock(&root->fs_info->trans_lock);
L
liubo 已提交
3764
	list_splice_init(&root->fs_info->trans_list, &list);
J
Josef Bacik 已提交
3765 3766 3767
	root->fs_info->trans_no_join = 1;
	spin_unlock(&root->fs_info->trans_lock);

L
liubo 已提交
3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796
	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;
		if (waitqueue_active(&root->fs_info->transaction_blocked_wait))
			wake_up(&root->fs_info->transaction_blocked_wait);

		t->blocked = 0;
		if (waitqueue_active(&root->fs_info->transaction_wait))
			wake_up(&root->fs_info->transaction_wait);

		t->commit_done = 1;
		if (waitqueue_active(&t->commit_wait))
			wake_up(&t->commit_wait);

3797 3798 3799
		btrfs_destroy_delayed_inodes(root);
		btrfs_assert_delayed_root_empty(root);

L
liubo 已提交
3800 3801 3802 3803
		btrfs_destroy_pending_snapshots(t);

		btrfs_destroy_delalloc_inodes(root);

J
Josef Bacik 已提交
3804
		spin_lock(&root->fs_info->trans_lock);
L
liubo 已提交
3805
		root->fs_info->running_transaction = NULL;
J
Josef Bacik 已提交
3806
		spin_unlock(&root->fs_info->trans_lock);
L
liubo 已提交
3807 3808 3809 3810 3811 3812 3813

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

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

3814
		atomic_set(&t->use_count, 0);
L
liubo 已提交
3815 3816 3817 3818 3819
		list_del_init(&t->list);
		memset(t, 0, sizeof(*t));
		kmem_cache_free(btrfs_transaction_cachep, t);
	}

J
Josef Bacik 已提交
3820 3821 3822
	spin_lock(&root->fs_info->trans_lock);
	root->fs_info->trans_no_join = 0;
	spin_unlock(&root->fs_info->trans_lock);
L
liubo 已提交
3823 3824 3825 3826 3827
	mutex_unlock(&root->fs_info->transaction_kthread_mutex);

	return 0;
}

3828
static struct extent_io_ops btree_extent_io_ops = {
C
Chris Mason 已提交
3829
	.write_cache_pages_lock_hook = btree_lock_page_hook,
3830
	.readpage_end_io_hook = btree_readpage_end_io_hook,
A
Arne Jansen 已提交
3831
	.readpage_io_failed_hook = btree_io_failed_hook,
3832
	.submit_bio_hook = btree_submit_bio_hook,
3833 3834
	/* note we're sharing with inode.c for the merge bio hook */
	.merge_bio_hook = btrfs_merge_bio_hook,
3835
};