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

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

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

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

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

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

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

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

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

193 194
#endif

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

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

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

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

241 242
out:
	return em;
243 244
}

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

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

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

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

294 295 296
	btrfs_csum_final(crc, result);

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

302
			read_extent_buffer(buf, &val, 0, csum_size);
303 304 305 306 307
			printk_ratelimited(KERN_INFO
				"BTRFS: %s checksum verify failed on %llu wanted %X found %X "
				"level %d\n",
				root->fs_info->sb->s_id, buf->start,
				val, found, btrfs_header_level(buf));
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
		       "found %llu\n",
348
		       eb->start, parent_transid, btrfs_header_generation(eb));
349
	ret = 1;
350
	clear_extent_buffer_uptodate(eb);
C
Chris Mason 已提交
351
out:
352 353
	unlock_extent_cached(io_tree, eb->start, eb->start + eb->len - 1,
			     &cached_state, GFP_NOFS);
354 355 356
	return ret;
}

D
David Sterba 已提交
357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383
/*
 * Return 0 if the superblock checksum type matches the checksum value of that
 * algorithm. Pass the raw disk superblock data.
 */
static int btrfs_check_super_csum(char *raw_disk_sb)
{
	struct btrfs_super_block *disk_sb =
		(struct btrfs_super_block *)raw_disk_sb;
	u16 csum_type = btrfs_super_csum_type(disk_sb);
	int ret = 0;

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

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

		if (memcmp(raw_disk_sb, result, csum_size))
			ret = 1;
384 385

		if (ret && btrfs_super_generation(disk_sb) < 10) {
386 387
			printk(KERN_WARNING
				"BTRFS: super block crcs don't match, older mkfs detected\n");
388 389
			ret = 0;
		}
D
David Sterba 已提交
390 391 392
	}

	if (csum_type >= ARRAY_SIZE(btrfs_csum_sizes)) {
393
		printk(KERN_ERR "BTRFS: unsupported checksum algorithm %u\n",
D
David Sterba 已提交
394 395 396 397 398 399 400
				csum_type);
		ret = 1;
	}

	return ret;
}

C
Chris Mason 已提交
401 402 403 404
/*
 * helper to read a given tree block, doing retries as required when
 * the checksums don't match and we have alternate mirrors to try.
 */
405 406
static int btree_read_extent_buffer_pages(struct btrfs_root *root,
					  struct extent_buffer *eb,
407
					  u64 start, u64 parent_transid)
408 409
{
	struct extent_io_tree *io_tree;
410
	int failed = 0;
411 412 413
	int ret;
	int num_copies = 0;
	int mirror_num = 0;
414
	int failed_mirror = 0;
415

416
	clear_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags);
417 418
	io_tree = &BTRFS_I(root->fs_info->btree_inode)->io_tree;
	while (1) {
419 420
		ret = read_extent_buffer_pages(io_tree, eb, start,
					       WAIT_COMPLETE,
421
					       btree_get_extent, mirror_num);
422 423
		if (!ret) {
			if (!verify_parent_transid(io_tree, eb,
424
						   parent_transid, 0))
425 426 427 428
				break;
			else
				ret = -EIO;
		}
C
Chris Mason 已提交
429

430 431 432 433 434 435
		/*
		 * 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))
436 437
			break;

438
		num_copies = btrfs_num_copies(root->fs_info,
439
					      eb->start, eb->len);
C
Chris Mason 已提交
440
		if (num_copies == 1)
441
			break;
C
Chris Mason 已提交
442

443 444 445 446 447
		if (!failed_mirror) {
			failed = 1;
			failed_mirror = eb->read_mirror;
		}

448
		mirror_num++;
449 450 451
		if (mirror_num == failed_mirror)
			mirror_num++;

C
Chris Mason 已提交
452
		if (mirror_num > num_copies)
453
			break;
454
	}
455

456
	if (failed && !ret && failed_mirror)
457 458 459
		repair_eb_io_failure(root, eb, failed_mirror);

	return ret;
460
}
461

C
Chris Mason 已提交
462
/*
C
Chris Mason 已提交
463 464
 * 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 已提交
465
 */
C
Chris Mason 已提交
466

467
static int csum_dirty_buffer(struct btrfs_root *root, struct page *page)
468
{
M
Miao Xie 已提交
469
	u64 start = page_offset(page);
470 471
	u64 found_start;
	struct extent_buffer *eb;
472

J
Josef Bacik 已提交
473 474 475
	eb = (struct extent_buffer *)page->private;
	if (page != eb->pages[0])
		return 0;
476
	found_start = btrfs_header_bytenr(eb);
477
	if (WARN_ON(found_start != start || !PageUptodate(page)))
J
Josef Bacik 已提交
478
		return 0;
479 480 481 482
	csum_tree_block(root, eb, 0);
	return 0;
}

Y
Yan Zheng 已提交
483 484 485 486 487 488 489
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;

490
	read_extent_buffer(eb, fsid, btrfs_header_fsid(), BTRFS_FSID_SIZE);
Y
Yan Zheng 已提交
491 492 493 494 495 496 497 498 499 500
	while (fs_devices) {
		if (!memcmp(fsid, fs_devices->fsid, BTRFS_FSID_SIZE)) {
			ret = 0;
			break;
		}
		fs_devices = fs_devices->seed;
	}
	return ret;
}

501
#define CORRUPT(reason, eb, root, slot)				\
502 503
	btrfs_crit(root->fs_info, "corrupt leaf, %s: block=%llu,"	\
		   "root=%llu, slot=%d", reason,			\
504
	       btrfs_header_bytenr(eb),	root->objectid, slot)
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 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

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

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

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

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

583 584 585 586 587 588
	/* the pending IO might have been the only thing that kept this buffer
	 * in memory.  Make sure we have a ref for all this other checks
	 */
	extent_buffer_get(eb);

	reads_done = atomic_dec_and_test(&eb->io_pages);
589 590
	if (!reads_done)
		goto err;
591

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

598
	found_start = btrfs_header_bytenr(eb);
599
	if (found_start != eb->start) {
600
		printk_ratelimited(KERN_INFO "BTRFS: bad tree block start "
C
Chris Mason 已提交
601
			       "%llu %llu\n",
602
			       found_start, eb->start);
603
		ret = -EIO;
604 605
		goto err;
	}
Y
Yan Zheng 已提交
606
	if (check_tree_block_fsid(root, eb)) {
607
		printk_ratelimited(KERN_INFO "BTRFS: bad fsid on block %llu\n",
608
			       eb->start);
609 610 611
		ret = -EIO;
		goto err;
	}
612
	found_level = btrfs_header_level(eb);
613
	if (found_level >= BTRFS_MAX_LEVEL) {
614
		btrfs_info(root->fs_info, "bad tree block level %d",
615 616 617 618
			   (int)btrfs_header_level(eb));
		ret = -EIO;
		goto err;
	}
619

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:
642 643
	if (reads_done &&
	    test_and_clear_bit(EXTENT_BUFFER_READAHEAD, &eb->bflags))
A
Arne Jansen 已提交
644 645
		btree_readahead_hook(root, eb, eb->start, ret);

D
David Woodhouse 已提交
646 647 648 649 650 651 652
	if (ret) {
		/*
		 * our io error hook is going to dec the io pages
		 * again, we have to make sure it has something
		 * to decrement
		 */
		atomic_inc(&eb->io_pages);
653
		clear_extent_buffer_uptodate(eb);
D
David Woodhouse 已提交
654
	}
655
	free_extent_buffer(eb);
656
out:
657
	return ret;
658 659
}

660
static int btree_io_failed_hook(struct page *page, int failed_mirror)
A
Arne Jansen 已提交
661 662 663 664
{
	struct extent_buffer *eb;
	struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;

J
Josef Bacik 已提交
665
	eb = (struct extent_buffer *)page->private;
666
	set_bit(EXTENT_BUFFER_IOERR, &eb->bflags);
667
	eb->read_mirror = failed_mirror;
D
David Woodhouse 已提交
668
	atomic_dec(&eb->io_pages);
669
	if (test_and_clear_bit(EXTENT_BUFFER_READAHEAD, &eb->bflags))
A
Arne Jansen 已提交
670 671 672 673
		btree_readahead_hook(root, eb, eb->start, -EIO);
	return -EIO;	/* we fixed nothing */
}

674 675 676 677 678 679 680
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;
681 682
	end_io_wq->work.func = end_workqueue_fn;
	end_io_wq->work.flags = 0;
683

684
	if (bio->bi_rw & REQ_WRITE) {
D
David Woodhouse 已提交
685
		if (end_io_wq->metadata == BTRFS_WQ_ENDIO_METADATA)
686 687
			btrfs_queue_worker(&fs_info->endio_meta_write_workers,
					   &end_io_wq->work);
D
David Woodhouse 已提交
688
		else if (end_io_wq->metadata == BTRFS_WQ_ENDIO_FREE_SPACE)
J
Josef Bacik 已提交
689 690
			btrfs_queue_worker(&fs_info->endio_freespace_worker,
					   &end_io_wq->work);
D
David Woodhouse 已提交
691 692 693
		else if (end_io_wq->metadata == BTRFS_WQ_ENDIO_RAID56)
			btrfs_queue_worker(&fs_info->endio_raid56_workers,
					   &end_io_wq->work);
694 695 696
		else
			btrfs_queue_worker(&fs_info->endio_write_workers,
					   &end_io_wq->work);
697
	} else {
D
David Woodhouse 已提交
698 699 700 701
		if (end_io_wq->metadata == BTRFS_WQ_ENDIO_RAID56)
			btrfs_queue_worker(&fs_info->endio_raid56_workers,
					   &end_io_wq->work);
		else if (end_io_wq->metadata)
702 703 704 705 706 707
			btrfs_queue_worker(&fs_info->endio_meta_workers,
					   &end_io_wq->work);
		else
			btrfs_queue_worker(&fs_info->endio_workers,
					   &end_io_wq->work);
	}
708 709
}

J
Josef Bacik 已提交
710 711 712 713 714 715
/*
 * For the metadata arg you want
 *
 * 0 - if data
 * 1 - if normal metadta
 * 2 - if writing to the free space cache area
D
David Woodhouse 已提交
716
 * 3 - raid parity work
J
Josef Bacik 已提交
717
 */
718 719
int btrfs_bio_wq_end_io(struct btrfs_fs_info *info, struct bio *bio,
			int metadata)
720
{
721 722 723 724 725 726 727
	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;
728
	end_io_wq->info = info;
729 730
	end_io_wq->error = 0;
	end_io_wq->bio = bio;
731
	end_io_wq->metadata = metadata;
732 733 734

	bio->bi_private = end_io_wq;
	bio->bi_end_io = end_workqueue_bio;
735 736 737
	return 0;
}

738
unsigned long btrfs_async_submit_limit(struct btrfs_fs_info *info)
739
{
740 741 742 743 744
	unsigned long limit = min_t(unsigned long,
				    info->workers.max_workers,
				    info->fs_devices->open_devices);
	return 256 * limit;
}
745

C
Chris Mason 已提交
746 747 748
static void run_one_async_start(struct btrfs_work *work)
{
	struct async_submit_bio *async;
749
	int ret;
C
Chris Mason 已提交
750 751

	async = container_of(work, struct  async_submit_bio, work);
752 753 754 755 756
	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 已提交
757 758 759
}

static void run_one_async_done(struct btrfs_work *work)
760 761 762
{
	struct btrfs_fs_info *fs_info;
	struct async_submit_bio *async;
763
	int limit;
764 765 766

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

768
	limit = btrfs_async_submit_limit(fs_info);
769 770
	limit = limit * 2 / 3;

771
	if (atomic_dec_return(&fs_info->nr_async_submits) < limit &&
772
	    waitqueue_active(&fs_info->async_submit_wait))
773 774
		wake_up(&fs_info->async_submit_wait);

775 776 777 778 779 780
	/* 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 已提交
781
	async->submit_bio_done(async->inode, async->rw, async->bio,
782 783
			       async->mirror_num, async->bio_flags,
			       async->bio_offset);
C
Chris Mason 已提交
784 785 786 787 788 789 790
}

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

	async = container_of(work, struct  async_submit_bio, work);
791 792 793
	kfree(async);
}

794 795
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 已提交
796
			unsigned long bio_flags,
797
			u64 bio_offset,
C
Chris Mason 已提交
798 799
			extent_submit_bio_hook_t *submit_bio_start,
			extent_submit_bio_hook_t *submit_bio_done)
800 801 802 803 804 805 806 807 808 809 810
{
	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 已提交
811 812 813 814 815 816 817
	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;

818
	async->work.flags = 0;
C
Chris Mason 已提交
819
	async->bio_flags = bio_flags;
820
	async->bio_offset = bio_offset;
821

822 823
	async->error = 0;

824
	atomic_inc(&fs_info->nr_async_submits);
825

826
	if (rw & REQ_SYNC)
827 828
		btrfs_set_work_high_prio(&async->work);

829
	btrfs_queue_worker(&fs_info->workers, &async->work);
830

C
Chris Mason 已提交
831
	while (atomic_read(&fs_info->async_submit_draining) &&
832 833 834 835 836
	      atomic_read(&fs_info->nr_async_submits)) {
		wait_event(fs_info->async_submit_wait,
			   (atomic_read(&fs_info->nr_async_submits) == 0));
	}

837 838 839
	return 0;
}

840 841 842 843 844
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;
845
	int ret = 0;
846 847

	WARN_ON(bio->bi_vcnt <= 0);
C
Chris Mason 已提交
848
	while (bio_index < bio->bi_vcnt) {
849
		root = BTRFS_I(bvec->bv_page->mapping->host)->root;
850 851 852
		ret = csum_dirty_buffer(root, bvec->bv_page);
		if (ret)
			break;
853 854 855
		bio_index++;
		bvec++;
	}
856
	return ret;
857 858
}

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

C
Chris Mason 已提交
871
static int __btree_submit_bio_done(struct inode *inode, int rw, struct bio *bio,
872 873
				 int mirror_num, unsigned long bio_flags,
				 u64 bio_offset)
C
Chris Mason 已提交
874
{
875 876
	int ret;

877
	/*
C
Chris Mason 已提交
878 879
	 * when we're called for a write, we're already in the async
	 * submission context.  Just jump into btrfs_map_bio
880
	 */
881 882 883 884
	ret = btrfs_map_bio(BTRFS_I(inode)->root, rw, bio, mirror_num, 1);
	if (ret)
		bio_endio(bio, ret);
	return ret;
885 886
}

887 888 889 890 891 892 893 894 895 896 897
static int check_async_write(struct inode *inode, unsigned long bio_flags)
{
	if (bio_flags & EXTENT_BIO_TREE_LOG)
		return 0;
#ifdef CONFIG_X86
	if (cpu_has_xmm4_2)
		return 0;
#endif
	return 1;
}

898
static int btree_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
899 900
				 int mirror_num, unsigned long bio_flags,
				 u64 bio_offset)
901
{
902
	int async = check_async_write(inode, bio_flags);
903 904
	int ret;

905
	if (!(rw & REQ_WRITE)) {
C
Chris Mason 已提交
906 907 908 909
		/*
		 * called for a read, do the setup so that checksum validation
		 * can happen in the async kernel threads
		 */
910 911
		ret = btrfs_bio_wq_end_io(BTRFS_I(inode)->root->fs_info,
					  bio, 1);
912
		if (ret)
913 914 915
			goto out_w_error;
		ret = btrfs_map_bio(BTRFS_I(inode)->root, rw, bio,
				    mirror_num, 0);
916 917 918
	} else if (!async) {
		ret = btree_csum_one_bio(bio);
		if (ret)
919 920 921 922 923 924 925 926 927 928 929 930 931
			goto out_w_error;
		ret = btrfs_map_bio(BTRFS_I(inode)->root, rw, bio,
				    mirror_num, 0);
	} else {
		/*
		 * kthread helpers are used to submit writes so that
		 * checksumming can happen in parallel across all CPUs
		 */
		ret = btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,
					  inode, rw, bio, mirror_num, 0,
					  bio_offset,
					  __btree_submit_bio_start,
					  __btree_submit_bio_done);
932
	}
933

934 935 936 937 938
	if (ret) {
out_w_error:
		bio_endio(bio, ret);
	}
	return ret;
939 940
}

J
Jan Beulich 已提交
941
#ifdef CONFIG_MIGRATION
942
static int btree_migratepage(struct address_space *mapping,
943 944
			struct page *newpage, struct page *page,
			enum migrate_mode mode)
945 946 947 948 949 950 951 952 953 954 955 956 957 958
{
	/*
	 * 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;
959
	return migrate_page(mapping, newpage, page, mode);
960
}
J
Jan Beulich 已提交
961
#endif
962

963 964 965 966

static int btree_writepages(struct address_space *mapping,
			    struct writeback_control *wbc)
{
967 968 969
	struct btrfs_fs_info *fs_info;
	int ret;

970
	if (wbc->sync_mode == WB_SYNC_NONE) {
971 972 973 974

		if (wbc->for_kupdate)
			return 0;

975
		fs_info = BTRFS_I(mapping->host)->root->fs_info;
976
		/* this is a bit racy, but that's ok */
977 978 979
		ret = percpu_counter_compare(&fs_info->dirty_metadata_bytes,
					     BTRFS_DIRTY_METADATA_THRESH);
		if (ret < 0)
980 981
			return 0;
	}
982
	return btree_write_cache_pages(mapping, wbc);
983 984
}

985
static int btree_readpage(struct file *file, struct page *page)
986
{
987 988
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
989
	return extent_read_full_page(tree, page, btree_get_extent, 0);
990
}
C
Chris Mason 已提交
991

992
static int btree_releasepage(struct page *page, gfp_t gfp_flags)
993
{
994
	if (PageWriteback(page) || PageDirty(page))
C
Chris Mason 已提交
995
		return 0;
996

997
	return try_release_extent_buffer(page);
998 999
}

1000 1001
static void btree_invalidatepage(struct page *page, unsigned int offset,
				 unsigned int length)
1002
{
1003 1004
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
1005 1006
	extent_invalidatepage(tree, page, offset);
	btree_releasepage(page, GFP_NOFS);
1007
	if (PagePrivate(page)) {
1008 1009 1010
		btrfs_warn(BTRFS_I(page->mapping->host)->root->fs_info,
			   "page private not zero on page %llu",
			   (unsigned long long)page_offset(page));
1011 1012 1013 1014
		ClearPagePrivate(page);
		set_page_private(page, 0);
		page_cache_release(page);
	}
1015 1016
}

1017 1018
static int btree_set_page_dirty(struct page *page)
{
1019
#ifdef DEBUG
1020 1021 1022 1023 1024 1025 1026 1027
	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);
1028
#endif
1029 1030 1031
	return __set_page_dirty_nobuffers(page);
}

1032
static const struct address_space_operations btree_aops = {
1033
	.readpage	= btree_readpage,
1034
	.writepages	= btree_writepages,
1035 1036
	.releasepage	= btree_releasepage,
	.invalidatepage = btree_invalidatepage,
1037
#ifdef CONFIG_MIGRATION
1038
	.migratepage	= btree_migratepage,
1039
#endif
1040
	.set_page_dirty = btree_set_page_dirty,
1041 1042
};

1043 1044
int readahead_tree_block(struct btrfs_root *root, u64 bytenr, u32 blocksize,
			 u64 parent_transid)
C
Chris Mason 已提交
1045
{
1046 1047
	struct extent_buffer *buf = NULL;
	struct inode *btree_inode = root->fs_info->btree_inode;
1048
	int ret = 0;
C
Chris Mason 已提交
1049

1050
	buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
1051
	if (!buf)
C
Chris Mason 已提交
1052
		return 0;
1053
	read_extent_buffer_pages(&BTRFS_I(btree_inode)->io_tree,
1054
				 buf, 0, WAIT_NONE, btree_get_extent, 0);
1055
	free_extent_buffer(buf);
1056
	return ret;
C
Chris Mason 已提交
1057 1058
}

1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082
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;
1083
	} else if (extent_buffer_uptodate(buf)) {
1084 1085 1086 1087 1088 1089 1090
		*eb = buf;
	} else {
		free_extent_buffer(buf);
	}
	return 0;
}

1091 1092 1093
struct extent_buffer *btrfs_find_tree_block(struct btrfs_root *root,
					    u64 bytenr, u32 blocksize)
{
1094
	return find_extent_buffer(root->fs_info, bytenr);
1095 1096 1097 1098 1099
}

struct extent_buffer *btrfs_find_create_tree_block(struct btrfs_root *root,
						 u64 bytenr, u32 blocksize)
{
1100
	return alloc_extent_buffer(root->fs_info, bytenr, blocksize);
1101 1102 1103
}


1104 1105
int btrfs_write_tree_block(struct extent_buffer *buf)
{
1106
	return filemap_fdatawrite_range(buf->pages[0]->mapping, buf->start,
1107
					buf->start + buf->len - 1);
1108 1109 1110 1111
}

int btrfs_wait_tree_block_writeback(struct extent_buffer *buf)
{
1112
	return filemap_fdatawait_range(buf->pages[0]->mapping,
1113
				       buf->start, buf->start + buf->len - 1);
1114 1115
}

1116
struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 bytenr,
1117
				      u32 blocksize, u64 parent_transid)
1118 1119 1120 1121 1122 1123 1124 1125
{
	struct extent_buffer *buf = NULL;
	int ret;

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

1126
	ret = btree_read_extent_buffer_pages(root, buf, 0, parent_transid);
1127 1128 1129 1130
	if (ret) {
		free_extent_buffer(buf);
		return NULL;
	}
1131
	return buf;
1132

1133 1134
}

1135 1136
void clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
		      struct extent_buffer *buf)
1137
{
1138 1139
	struct btrfs_fs_info *fs_info = root->fs_info;

1140
	if (btrfs_header_generation(buf) ==
1141
	    fs_info->running_transaction->transid) {
1142
		btrfs_assert_tree_locked(buf);
1143

1144
		if (test_and_clear_bit(EXTENT_BUFFER_DIRTY, &buf->bflags)) {
1145 1146 1147
			__percpu_counter_add(&fs_info->dirty_metadata_bytes,
					     -buf->len,
					     fs_info->dirty_metadata_batch);
1148 1149 1150 1151
			/* ugh, clear_extent_buffer_dirty needs to lock the page */
			btrfs_set_lock_blocking(buf);
			clear_extent_buffer_dirty(buf);
		}
1152
	}
1153 1154
}

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

1172 1173
	root->objectid = objectid;
	root->last_trans = 0;
1174
	root->highest_objectid = 0;
1175
	root->nr_delalloc_inodes = 0;
1176
	root->nr_ordered_extents = 0;
1177
	root->name = NULL;
1178
	root->inode_tree = RB_ROOT;
1179
	INIT_RADIX_TREE(&root->delayed_nodes_tree, GFP_ATOMIC);
1180
	root->block_rsv = NULL;
1181
	root->orphan_block_rsv = NULL;
1182 1183

	INIT_LIST_HEAD(&root->dirty_list);
1184
	INIT_LIST_HEAD(&root->root_list);
1185 1186
	INIT_LIST_HEAD(&root->delalloc_inodes);
	INIT_LIST_HEAD(&root->delalloc_root);
1187 1188
	INIT_LIST_HEAD(&root->ordered_extents);
	INIT_LIST_HEAD(&root->ordered_root);
1189 1190
	INIT_LIST_HEAD(&root->logged_list[0]);
	INIT_LIST_HEAD(&root->logged_list[1]);
1191
	spin_lock_init(&root->orphan_lock);
1192
	spin_lock_init(&root->inode_lock);
1193
	spin_lock_init(&root->delalloc_lock);
1194
	spin_lock_init(&root->ordered_extent_lock);
1195
	spin_lock_init(&root->accounting_lock);
1196 1197
	spin_lock_init(&root->log_extents_lock[0]);
	spin_lock_init(&root->log_extents_lock[1]);
1198
	mutex_init(&root->objectid_mutex);
1199
	mutex_init(&root->log_mutex);
Y
Yan Zheng 已提交
1200 1201 1202
	init_waitqueue_head(&root->log_writer_wait);
	init_waitqueue_head(&root->log_commit_wait[0]);
	init_waitqueue_head(&root->log_commit_wait[1]);
1203 1204
	INIT_LIST_HEAD(&root->log_ctxs[0]);
	INIT_LIST_HEAD(&root->log_ctxs[1]);
Y
Yan Zheng 已提交
1205 1206 1207
	atomic_set(&root->log_commit[0], 0);
	atomic_set(&root->log_commit[1], 0);
	atomic_set(&root->log_writers, 0);
M
Miao Xie 已提交
1208
	atomic_set(&root->log_batch, 0);
1209
	atomic_set(&root->orphan_inodes, 0);
1210
	atomic_set(&root->refs, 1);
Y
Yan Zheng 已提交
1211
	root->log_transid = 0;
1212
	root->last_log_commit = 0;
1213 1214 1215
	if (fs_info)
		extent_io_tree_init(&root->dirty_log_pages,
				     fs_info->btree_inode->i_mapping);
C
Chris Mason 已提交
1216

1217 1218
	memset(&root->root_key, 0, sizeof(root->root_key));
	memset(&root->root_item, 0, sizeof(root->root_item));
1219
	memset(&root->defrag_progress, 0, sizeof(root->defrag_progress));
1220
	memset(&root->root_kobj, 0, sizeof(root->root_kobj));
1221 1222 1223 1224
	if (fs_info)
		root->defrag_trans_start = fs_info->generation;
	else
		root->defrag_trans_start = 0;
1225
	init_completion(&root->kobj_unregister);
1226
	root->defrag_running = 0;
1227
	root->root_key.objectid = objectid;
1228
	root->anon_dev = 0;
1229

1230
	spin_lock_init(&root->root_item_lock);
1231 1232
}

1233
static struct btrfs_root *btrfs_alloc_root(struct btrfs_fs_info *fs_info)
A
Al Viro 已提交
1234 1235 1236 1237 1238 1239 1240
{
	struct btrfs_root *root = kzalloc(sizeof(*root), GFP_NOFS);
	if (root)
		root->fs_info = fs_info;
	return root;
}

1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256
#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
/* Should only be used by the testing infrastructure */
struct btrfs_root *btrfs_alloc_dummy_root(void)
{
	struct btrfs_root *root;

	root = btrfs_alloc_root(NULL);
	if (!root)
		return ERR_PTR(-ENOMEM);
	__setup_root(4096, 4096, 4096, 4096, root, NULL, 1);
	root->dummy_root = 1;

	return root;
}
#endif

1257 1258 1259 1260 1261 1262 1263 1264 1265
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;
1266
	uuid_le uuid;
1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282

	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);
1283
		leaf = NULL;
1284 1285 1286 1287 1288 1289 1290 1291 1292 1293
		goto fail;
	}

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

1294
	write_extent_buffer(leaf, fs_info->fsid, btrfs_header_fsid(),
1295 1296
			    BTRFS_FSID_SIZE);
	write_extent_buffer(leaf, fs_info->chunk_tree_uuid,
1297
			    btrfs_header_chunk_tree_uuid(leaf),
1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313
			    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);
1314 1315
	uuid_le_gen(&uuid);
	memcpy(root->root_item.uuid, uuid.b, BTRFS_UUID_SIZE);
1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326
	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);

1327 1328
	return root;

1329
fail:
1330 1331 1332 1333 1334
	if (leaf) {
		btrfs_tree_unlock(leaf);
		free_extent_buffer(leaf);
	}
	kfree(root);
1335

1336
	return ERR_PTR(ret);
1337 1338
}

Y
Yan Zheng 已提交
1339 1340
static struct btrfs_root *alloc_log_tree(struct btrfs_trans_handle *trans,
					 struct btrfs_fs_info *fs_info)
1341 1342 1343
{
	struct btrfs_root *root;
	struct btrfs_root *tree_root = fs_info->tree_root;
Y
Yan Zheng 已提交
1344
	struct extent_buffer *leaf;
1345

A
Al Viro 已提交
1346
	root = btrfs_alloc_root(fs_info);
1347
	if (!root)
Y
Yan Zheng 已提交
1348
		return ERR_PTR(-ENOMEM);
1349 1350 1351 1352 1353 1354 1355 1356

	__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 已提交
1357 1358 1359 1360 1361 1362
	/*
	 * 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).
	 */
1363 1364
	root->ref_cows = 0;

1365
	leaf = btrfs_alloc_free_block(trans, root, root->leafsize, 0,
A
Arne Jansen 已提交
1366
				      BTRFS_TREE_LOG_OBJECTID, NULL,
1367
				      0, 0, 0);
Y
Yan Zheng 已提交
1368 1369 1370 1371
	if (IS_ERR(leaf)) {
		kfree(root);
		return ERR_CAST(leaf);
	}
1372

1373 1374 1375 1376 1377
	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 已提交
1378
	root->node = leaf;
1379 1380

	write_extent_buffer(root->node, root->fs_info->fsid,
1381
			    btrfs_header_fsid(), BTRFS_FSID_SIZE);
1382 1383
	btrfs_mark_buffer_dirty(root->node);
	btrfs_tree_unlock(root->node);
Y
Yan Zheng 已提交
1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413
	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;
1414 1415 1416 1417 1418
	btrfs_set_stack_inode_generation(inode_item, 1);
	btrfs_set_stack_inode_size(inode_item, 3);
	btrfs_set_stack_inode_nlink(inode_item, 1);
	btrfs_set_stack_inode_nbytes(inode_item, root->leafsize);
	btrfs_set_stack_inode_mode(inode_item, S_IFDIR | 0755);
Y
Yan Zheng 已提交
1419

1420
	btrfs_set_root_node(&log_root->root_item, log_root->node);
Y
Yan Zheng 已提交
1421 1422 1423 1424

	WARN_ON(root->log_root);
	root->log_root = log_root;
	root->log_transid = 0;
1425
	root->last_log_commit = 0;
1426 1427 1428
	return 0;
}

1429 1430
static struct btrfs_root *btrfs_read_tree_root(struct btrfs_root *tree_root,
					       struct btrfs_key *key)
1431 1432 1433
{
	struct btrfs_root *root;
	struct btrfs_fs_info *fs_info = tree_root->fs_info;
1434
	struct btrfs_path *path;
1435
	u64 generation;
1436
	u32 blocksize;
1437
	int ret;
1438

1439 1440
	path = btrfs_alloc_path();
	if (!path)
1441
		return ERR_PTR(-ENOMEM);
1442 1443 1444 1445 1446

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

1449
	__setup_root(tree_root->nodesize, tree_root->leafsize,
1450
		     tree_root->sectorsize, tree_root->stripesize,
1451
		     root, fs_info, key->objectid);
1452

1453 1454
	ret = btrfs_find_root(tree_root, key, path,
			      &root->root_item, &root->root_key);
1455
	if (ret) {
1456 1457
		if (ret > 0)
			ret = -ENOENT;
1458
		goto find_fail;
1459
	}
1460

1461
	generation = btrfs_root_generation(&root->root_item);
1462 1463
	blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
	root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
1464
				     blocksize, generation);
1465 1466 1467 1468 1469 1470
	if (!root->node) {
		ret = -ENOMEM;
		goto find_fail;
	} else if (!btrfs_buffer_uptodate(root->node, generation, 0)) {
		ret = -EIO;
		goto read_fail;
1471
	}
1472
	root->commit_root = btrfs_root_node(root);
1473
out:
1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495
	btrfs_free_path(path);
	return root;

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

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

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

	if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) {
1496
		root->ref_cows = 1;
1497 1498
		btrfs_check_and_init_root_item(&root->root_item);
	}
1499

1500 1501 1502
	return root;
}

1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529
int btrfs_init_fs_root(struct btrfs_root *root)
{
	int ret;

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

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

	ret = get_anon_bdev(&root->anon_dev);
	if (ret)
		goto fail;
	return 0;
fail:
	kfree(root->free_ino_ctl);
	kfree(root->free_ino_pinned);
	return ret;
}

1530 1531
static struct btrfs_root *btrfs_lookup_fs_root(struct btrfs_fs_info *fs_info,
					       u64 root_id)
1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562
{
	struct btrfs_root *root;

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

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

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

	spin_lock(&fs_info->fs_roots_radix_lock);
	ret = radix_tree_insert(&fs_info->fs_roots_radix,
				(unsigned long)root->root_key.objectid,
				root);
	if (ret == 0)
		root->in_radix = 1;
	spin_unlock(&fs_info->fs_roots_radix_lock);
	radix_tree_preload_end();

	return ret;
}

1563 1564 1565
struct btrfs_root *btrfs_get_fs_root(struct btrfs_fs_info *fs_info,
				     struct btrfs_key *location,
				     bool check_ref)
1566 1567 1568 1569
{
	struct btrfs_root *root;
	int ret;

1570 1571 1572 1573
	if (location->objectid == BTRFS_ROOT_TREE_OBJECTID)
		return fs_info->tree_root;
	if (location->objectid == BTRFS_EXTENT_TREE_OBJECTID)
		return fs_info->extent_root;
1574 1575 1576 1577
	if (location->objectid == BTRFS_CHUNK_TREE_OBJECTID)
		return fs_info->chunk_root;
	if (location->objectid == BTRFS_DEV_TREE_OBJECTID)
		return fs_info->dev_root;
1578 1579
	if (location->objectid == BTRFS_CSUM_TREE_OBJECTID)
		return fs_info->csum_root;
1580 1581 1582
	if (location->objectid == BTRFS_QUOTA_TREE_OBJECTID)
		return fs_info->quota_root ? fs_info->quota_root :
					     ERR_PTR(-ENOENT);
1583 1584 1585
	if (location->objectid == BTRFS_UUID_TREE_OBJECTID)
		return fs_info->uuid_root ? fs_info->uuid_root :
					    ERR_PTR(-ENOENT);
1586
again:
1587
	root = btrfs_lookup_fs_root(fs_info, location->objectid);
1588
	if (root) {
1589
		if (check_ref && btrfs_root_refs(&root->root_item) == 0)
1590
			return ERR_PTR(-ENOENT);
1591
		return root;
1592
	}
1593

1594
	root = btrfs_read_fs_root(fs_info->tree_root, location);
1595 1596
	if (IS_ERR(root))
		return root;
1597

1598
	if (check_ref && btrfs_root_refs(&root->root_item) == 0) {
1599
		ret = -ENOENT;
1600
		goto fail;
1601
	}
1602

1603
	ret = btrfs_init_fs_root(root);
1604 1605
	if (ret)
		goto fail;
1606

1607 1608
	ret = btrfs_find_item(fs_info->tree_root, NULL, BTRFS_ORPHAN_OBJECTID,
			location->objectid, BTRFS_ORPHAN_ITEM_KEY, NULL);
1609 1610 1611 1612 1613
	if (ret < 0)
		goto fail;
	if (ret == 0)
		root->orphan_item_inserted = 1;

1614
	ret = btrfs_insert_fs_root(fs_info, root);
1615
	if (ret) {
1616 1617 1618 1619 1620
		if (ret == -EEXIST) {
			free_fs_root(root);
			goto again;
		}
		goto fail;
1621
	}
1622
	return root;
1623 1624 1625
fail:
	free_fs_root(root);
	return ERR_PTR(ret);
1626 1627
}

C
Chris Mason 已提交
1628 1629 1630 1631 1632 1633
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 已提交
1634

1635 1636
	rcu_read_lock();
	list_for_each_entry_rcu(device, &info->fs_devices->devices, dev_list) {
1637 1638
		if (!device->bdev)
			continue;
C
Chris Mason 已提交
1639 1640 1641 1642 1643 1644
		bdi = blk_get_backing_dev_info(device->bdev);
		if (bdi && bdi_congested(bdi, bdi_bits)) {
			ret = 1;
			break;
		}
	}
1645
	rcu_read_unlock();
C
Chris Mason 已提交
1646 1647 1648
	return ret;
}

1649 1650 1651 1652
/*
 * If this fails, caller must call bdi_destroy() to get rid of the
 * bdi again.
 */
C
Chris Mason 已提交
1653 1654
static int setup_bdi(struct btrfs_fs_info *info, struct backing_dev_info *bdi)
{
1655 1656 1657
	int err;

	bdi->capabilities = BDI_CAP_MAP_COPY;
1658
	err = bdi_setup_and_register(bdi, "btrfs", BDI_CAP_MAP_COPY);
1659 1660 1661
	if (err)
		return err;

1662
	bdi->ra_pages	= default_backing_dev_info.ra_pages;
C
Chris Mason 已提交
1663 1664 1665 1666 1667
	bdi->congested_fn	= btrfs_congested_fn;
	bdi->congested_data	= info;
	return 0;
}

1668 1669 1670 1671 1672
/*
 * 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)
1673 1674
{
	struct bio *bio;
1675
	struct end_io_wq *end_io_wq;
1676 1677
	int error;

1678 1679
	end_io_wq = container_of(work, struct end_io_wq, work);
	bio = end_io_wq->bio;
1680

1681 1682 1683 1684 1685
	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);
1686 1687
}

1688 1689 1690
static int cleaner_kthread(void *arg)
{
	struct btrfs_root *root = arg;
1691
	int again;
1692 1693

	do {
1694
		again = 0;
1695

1696
		/* Make the cleaner go to sleep early. */
1697
		if (btrfs_need_cleaner_sleep(root))
1698 1699 1700 1701 1702
			goto sleep;

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

1703 1704 1705 1706
		/*
		 * Avoid the problem that we change the status of the fs
		 * during the above check and trylock.
		 */
1707
		if (btrfs_need_cleaner_sleep(root)) {
1708 1709
			mutex_unlock(&root->fs_info->cleaner_mutex);
			goto sleep;
1710
		}
1711

1712 1713 1714 1715 1716
		btrfs_run_delayed_iputs(root);
		again = btrfs_clean_one_deleted_snapshot(root);
		mutex_unlock(&root->fs_info->cleaner_mutex);

		/*
1717 1718
		 * The defragger has dealt with the R/O remount and umount,
		 * needn't do anything special here.
1719 1720 1721
		 */
		btrfs_run_defrag_inodes(root->fs_info);
sleep:
D
David Sterba 已提交
1722
		if (!try_to_freeze() && !again) {
1723
			set_current_state(TASK_INTERRUPTIBLE);
1724 1725
			if (!kthread_should_stop())
				schedule();
1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736
			__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;
1737
	u64 transid;
1738 1739
	unsigned long now;
	unsigned long delay;
1740
	bool cannot_commit;
1741 1742

	do {
1743
		cannot_commit = false;
1744
		delay = HZ * root->fs_info->commit_interval;
1745 1746
		mutex_lock(&root->fs_info->transaction_kthread_mutex);

J
Josef Bacik 已提交
1747
		spin_lock(&root->fs_info->trans_lock);
1748 1749
		cur = root->fs_info->running_transaction;
		if (!cur) {
J
Josef Bacik 已提交
1750
			spin_unlock(&root->fs_info->trans_lock);
1751 1752
			goto sleep;
		}
Y
Yan Zheng 已提交
1753

1754
		now = get_seconds();
1755
		if (cur->state < TRANS_STATE_BLOCKED &&
1756 1757
		    (now < cur->start_time ||
		     now - cur->start_time < root->fs_info->commit_interval)) {
J
Josef Bacik 已提交
1758
			spin_unlock(&root->fs_info->trans_lock);
1759 1760 1761
			delay = HZ * 5;
			goto sleep;
		}
1762
		transid = cur->transid;
J
Josef Bacik 已提交
1763
		spin_unlock(&root->fs_info->trans_lock);
1764

1765
		/* If the file system is aborted, this will always fail. */
1766
		trans = btrfs_attach_transaction(root);
1767
		if (IS_ERR(trans)) {
1768 1769
			if (PTR_ERR(trans) != -ENOENT)
				cannot_commit = true;
1770
			goto sleep;
1771
		}
1772
		if (transid == trans->transid) {
1773
			btrfs_commit_transaction(trans, root);
1774 1775 1776
		} else {
			btrfs_end_transaction(trans, root);
		}
1777 1778 1779 1780
sleep:
		wake_up_process(root->fs_info->cleaner_kthread);
		mutex_unlock(&root->fs_info->transaction_kthread_mutex);

J
Josef Bacik 已提交
1781 1782 1783
		if (unlikely(test_bit(BTRFS_FS_STATE_ERROR,
				      &root->fs_info->fs_state)))
			btrfs_cleanup_transaction(root);
1784
		if (!try_to_freeze()) {
1785
			set_current_state(TASK_INTERRUPTIBLE);
1786
			if (!kthread_should_stop() &&
1787 1788
			    (!btrfs_transaction_blocked(root->fs_info) ||
			     cannot_commit))
1789
				schedule_timeout(delay);
1790 1791 1792 1793 1794 1795
			__set_current_state(TASK_RUNNING);
		}
	} while (!kthread_should_stop());
	return 0;
}

C
Chris Mason 已提交
1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 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
/*
 * 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));

1902 1903 1904 1905 1906 1907 1908 1909
	/*
	 * 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 已提交
1910
			       btrfs_header_generation(info->fs_root->node));
1911
		btrfs_set_backup_fs_root_level(root_backup,
C
Chris Mason 已提交
1912
			       btrfs_header_level(info->fs_root->node));
1913
	}
C
Chris Mason 已提交
1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994

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

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

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

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

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

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

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

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

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

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

L
Liu Bo 已提交
1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013
/* helper to cleanup workers */
static void btrfs_stop_all_workers(struct btrfs_fs_info *fs_info)
{
	btrfs_stop_workers(&fs_info->generic_worker);
	btrfs_stop_workers(&fs_info->fixup_workers);
	btrfs_stop_workers(&fs_info->delalloc_workers);
	btrfs_stop_workers(&fs_info->workers);
	btrfs_stop_workers(&fs_info->endio_workers);
	btrfs_stop_workers(&fs_info->endio_meta_workers);
	btrfs_stop_workers(&fs_info->endio_raid56_workers);
	btrfs_stop_workers(&fs_info->rmw_workers);
	btrfs_stop_workers(&fs_info->endio_meta_write_workers);
	btrfs_stop_workers(&fs_info->endio_write_workers);
	btrfs_stop_workers(&fs_info->endio_freespace_worker);
	btrfs_stop_workers(&fs_info->submit_workers);
	btrfs_stop_workers(&fs_info->delayed_workers);
	btrfs_stop_workers(&fs_info->caching_workers);
	btrfs_stop_workers(&fs_info->readahead_workers);
	btrfs_stop_workers(&fs_info->flush_workers);
J
Jan Schmidt 已提交
2014
	btrfs_stop_workers(&fs_info->qgroup_rescan_workers);
L
Liu Bo 已提交
2015 2016
}

2017 2018 2019 2020 2021 2022 2023 2024 2025 2026
static void free_root_extent_buffers(struct btrfs_root *root)
{
	if (root) {
		free_extent_buffer(root->node);
		free_extent_buffer(root->commit_root);
		root->node = NULL;
		root->commit_root = NULL;
	}
}

C
Chris Mason 已提交
2027 2028 2029
/* helper to cleanup tree roots */
static void free_root_pointers(struct btrfs_fs_info *info, int chunk_root)
{
2030
	free_root_extent_buffers(info->tree_root);
2031

2032 2033 2034 2035 2036 2037 2038
	free_root_extent_buffers(info->dev_root);
	free_root_extent_buffers(info->extent_root);
	free_root_extent_buffers(info->csum_root);
	free_root_extent_buffers(info->quota_root);
	free_root_extent_buffers(info->uuid_root);
	if (chunk_root)
		free_root_extent_buffers(info->chunk_root);
C
Chris Mason 已提交
2039 2040
}

2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052
static void del_fs_roots(struct btrfs_fs_info *fs_info)
{
	int ret;
	struct btrfs_root *gang[8];
	int i;

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

		if (gang[0]->in_radix) {
2053
			btrfs_drop_and_free_fs_root(fs_info, gang[0]);
2054 2055 2056
		} else {
			free_extent_buffer(gang[0]->node);
			free_extent_buffer(gang[0]->commit_root);
2057
			btrfs_put_fs_root(gang[0]);
2058 2059 2060 2061 2062 2063 2064 2065 2066 2067
		}
	}

	while (1) {
		ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
					     (void **)gang, 0,
					     ARRAY_SIZE(gang));
		if (!ret)
			break;
		for (i = 0; i < ret; i++)
2068
			btrfs_drop_and_free_fs_root(fs_info, gang[i]);
2069
	}
2070 2071 2072 2073 2074 2075

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

A
Al Viro 已提交
2078 2079 2080
int open_ctree(struct super_block *sb,
	       struct btrfs_fs_devices *fs_devices,
	       char *options)
2081
{
2082 2083 2084 2085
	u32 sectorsize;
	u32 nodesize;
	u32 leafsize;
	u32 blocksize;
2086
	u32 stripesize;
2087
	u64 generation;
2088
	u64 features;
2089
	struct btrfs_key location;
2090
	struct buffer_head *bh;
2091
	struct btrfs_super_block *disk_super;
2092
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
2093
	struct btrfs_root *tree_root;
2094 2095 2096 2097
	struct btrfs_root *extent_root;
	struct btrfs_root *csum_root;
	struct btrfs_root *chunk_root;
	struct btrfs_root *dev_root;
2098
	struct btrfs_root *quota_root;
2099
	struct btrfs_root *uuid_root;
2100
	struct btrfs_root *log_tree_root;
2101
	int ret;
2102
	int err = -EINVAL;
C
Chris Mason 已提交
2103 2104
	int num_backups_tried = 0;
	int backup_index = 0;
2105 2106
	bool create_uuid_tree;
	bool check_uuid_tree;
2107

2108
	tree_root = fs_info->tree_root = btrfs_alloc_root(fs_info);
A
Al Viro 已提交
2109
	chunk_root = fs_info->chunk_root = btrfs_alloc_root(fs_info);
2110
	if (!tree_root || !chunk_root) {
C
Chris Mason 已提交
2111 2112 2113
		err = -ENOMEM;
		goto fail;
	}
2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126

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

2127 2128 2129 2130 2131 2132 2133 2134
	ret = percpu_counter_init(&fs_info->dirty_metadata_bytes, 0);
	if (ret) {
		err = ret;
		goto fail_bdi;
	}
	fs_info->dirty_metadata_batch = PAGE_CACHE_SIZE *
					(1 + ilog2(nr_cpu_ids));

2135 2136 2137 2138 2139 2140
	ret = percpu_counter_init(&fs_info->delalloc_bytes, 0);
	if (ret) {
		err = ret;
		goto fail_dirty_metadata_bytes;
	}

2141 2142 2143 2144 2145 2146
	ret = percpu_counter_init(&fs_info->bio_counter, 0);
	if (ret) {
		err = ret;
		goto fail_delalloc_bytes;
	}

2147 2148 2149
	fs_info->btree_inode = new_inode(sb);
	if (!fs_info->btree_inode) {
		err = -ENOMEM;
2150
		goto fail_bio_counter;
2151 2152
	}

2153
	mapping_set_gfp_mask(fs_info->btree_inode->i_mapping, GFP_NOFS);
2154

2155
	INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_ATOMIC);
2156
	INIT_RADIX_TREE(&fs_info->buffer_radix, GFP_ATOMIC);
C
Chris Mason 已提交
2157
	INIT_LIST_HEAD(&fs_info->trans_list);
2158
	INIT_LIST_HEAD(&fs_info->dead_roots);
Y
Yan, Zheng 已提交
2159
	INIT_LIST_HEAD(&fs_info->delayed_iputs);
2160
	INIT_LIST_HEAD(&fs_info->delalloc_roots);
2161
	INIT_LIST_HEAD(&fs_info->caching_block_groups);
2162
	spin_lock_init(&fs_info->delalloc_root_lock);
J
Josef Bacik 已提交
2163
	spin_lock_init(&fs_info->trans_lock);
2164
	spin_lock_init(&fs_info->fs_roots_radix_lock);
Y
Yan, Zheng 已提交
2165
	spin_lock_init(&fs_info->delayed_iput_lock);
C
Chris Mason 已提交
2166
	spin_lock_init(&fs_info->defrag_inodes_lock);
2167
	spin_lock_init(&fs_info->free_chunk_lock);
J
Jan Schmidt 已提交
2168
	spin_lock_init(&fs_info->tree_mod_seq_lock);
2169
	spin_lock_init(&fs_info->super_lock);
2170
	spin_lock_init(&fs_info->buffer_lock);
J
Jan Schmidt 已提交
2171
	rwlock_init(&fs_info->tree_mod_log_lock);
C
Chris Mason 已提交
2172
	mutex_init(&fs_info->reloc_mutex);
2173
	seqlock_init(&fs_info->profiles_lock);
2174

2175
	init_completion(&fs_info->kobj_unregister);
2176
	INIT_LIST_HEAD(&fs_info->dirty_cowonly_roots);
2177
	INIT_LIST_HEAD(&fs_info->space_info);
J
Jan Schmidt 已提交
2178
	INIT_LIST_HEAD(&fs_info->tree_mod_seq_list);
2179
	btrfs_mapping_init(&fs_info->mapping_tree);
2180 2181 2182 2183 2184 2185 2186 2187 2188
	btrfs_init_block_rsv(&fs_info->global_block_rsv,
			     BTRFS_BLOCK_RSV_GLOBAL);
	btrfs_init_block_rsv(&fs_info->delalloc_block_rsv,
			     BTRFS_BLOCK_RSV_DELALLOC);
	btrfs_init_block_rsv(&fs_info->trans_block_rsv, BTRFS_BLOCK_RSV_TRANS);
	btrfs_init_block_rsv(&fs_info->chunk_block_rsv, BTRFS_BLOCK_RSV_CHUNK);
	btrfs_init_block_rsv(&fs_info->empty_block_rsv, BTRFS_BLOCK_RSV_EMPTY);
	btrfs_init_block_rsv(&fs_info->delayed_block_rsv,
			     BTRFS_BLOCK_RSV_DELOPS);
2189
	atomic_set(&fs_info->nr_async_submits, 0);
2190
	atomic_set(&fs_info->async_delalloc_pages, 0);
2191
	atomic_set(&fs_info->async_submit_draining, 0);
2192
	atomic_set(&fs_info->nr_async_bios, 0);
C
Chris Mason 已提交
2193
	atomic_set(&fs_info->defrag_running, 0);
2194
	atomic64_set(&fs_info->tree_mod_seq, 0);
C
Chris Mason 已提交
2195
	fs_info->sb = sb;
2196
	fs_info->max_inline = 8192 * 1024;
J
Josef Bacik 已提交
2197
	fs_info->metadata_ratio = 0;
C
Chris Mason 已提交
2198
	fs_info->defrag_inodes = RB_ROOT;
2199
	fs_info->free_chunk_space = 0;
J
Jan Schmidt 已提交
2200
	fs_info->tree_mod_log = RB_ROOT;
2201
	fs_info->commit_interval = BTRFS_DEFAULT_COMMIT_INTERVAL;
2202
	fs_info->avg_delayed_ref_runtime = div64_u64(NSEC_PER_SEC, 64);
2203 2204 2205
	/* readahead state */
	INIT_RADIX_TREE(&fs_info->reada_tree, GFP_NOFS & ~__GFP_WAIT);
	spin_lock_init(&fs_info->reada_lock);
C
Chris Mason 已提交
2206

2207 2208
	fs_info->thread_pool_size = min_t(unsigned long,
					  num_online_cpus() + 2, 8);
2209

2210 2211
	INIT_LIST_HEAD(&fs_info->ordered_roots);
	spin_lock_init(&fs_info->ordered_root_lock);
2212 2213 2214 2215 2216 2217 2218
	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);
2219

A
Arne Jansen 已提交
2220 2221 2222 2223 2224
	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);
2225
	init_waitqueue_head(&fs_info->replace_wait);
A
Arne Jansen 已提交
2226 2227
	init_waitqueue_head(&fs_info->scrub_pause_wait);
	fs_info->scrub_workers_refcnt = 0;
2228 2229 2230
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
	fs_info->check_integrity_print_mask = 0;
#endif
A
Arne Jansen 已提交
2231

2232 2233
	spin_lock_init(&fs_info->balance_lock);
	mutex_init(&fs_info->balance_mutex);
2234 2235
	atomic_set(&fs_info->balance_running, 0);
	atomic_set(&fs_info->balance_pause_req, 0);
2236
	atomic_set(&fs_info->balance_cancel_req, 0);
2237
	fs_info->balance_ctl = NULL;
2238
	init_waitqueue_head(&fs_info->balance_wait_q);
A
Arne Jansen 已提交
2239

2240 2241
	sb->s_blocksize = 4096;
	sb->s_blocksize_bits = blksize_bits(4096);
J
Jens Axboe 已提交
2242
	sb->s_bdi = &fs_info->bdi;
2243

2244
	fs_info->btree_inode->i_ino = BTRFS_BTREE_INODE_OBJECTID;
M
Miklos Szeredi 已提交
2245
	set_nlink(fs_info->btree_inode, 1);
2246 2247 2248 2249 2250 2251
	/*
	 * 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;
2252
	fs_info->btree_inode->i_mapping->a_ops = &btree_aops;
C
Chris Mason 已提交
2253 2254
	fs_info->btree_inode->i_mapping->backing_dev_info = &fs_info->bdi;

2255
	RB_CLEAR_NODE(&BTRFS_I(fs_info->btree_inode)->rb_node);
2256
	extent_io_tree_init(&BTRFS_I(fs_info->btree_inode)->io_tree,
2257
			     fs_info->btree_inode->i_mapping);
2258
	BTRFS_I(fs_info->btree_inode)->io_tree.track_uptodate = 0;
2259
	extent_map_tree_init(&BTRFS_I(fs_info->btree_inode)->extent_tree);
2260 2261

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

2263 2264 2265
	BTRFS_I(fs_info->btree_inode)->root = tree_root;
	memset(&BTRFS_I(fs_info->btree_inode)->location, 0,
	       sizeof(struct btrfs_key));
2266 2267
	set_bit(BTRFS_INODE_DUMMY,
		&BTRFS_I(fs_info->btree_inode)->runtime_flags);
2268
	btrfs_insert_inode_hash(fs_info->btree_inode);
2269

J
Josef Bacik 已提交
2270
	spin_lock_init(&fs_info->block_group_cache_lock);
2271
	fs_info->block_group_cache_tree = RB_ROOT;
2272
	fs_info->first_logical_byte = (u64)-1;
J
Josef Bacik 已提交
2273

2274
	extent_io_tree_init(&fs_info->freed_extents[0],
2275
			     fs_info->btree_inode->i_mapping);
2276
	extent_io_tree_init(&fs_info->freed_extents[1],
2277
			     fs_info->btree_inode->i_mapping);
2278
	fs_info->pinned_extents = &fs_info->freed_extents[0];
2279
	fs_info->do_barriers = 1;
2280

C
Chris Mason 已提交
2281

2282
	mutex_init(&fs_info->ordered_operations_mutex);
2283
	mutex_init(&fs_info->ordered_extent_flush_mutex);
2284
	mutex_init(&fs_info->tree_log_mutex);
2285
	mutex_init(&fs_info->chunk_mutex);
2286 2287
	mutex_init(&fs_info->transaction_kthread_mutex);
	mutex_init(&fs_info->cleaner_mutex);
2288
	mutex_init(&fs_info->volume_mutex);
2289
	init_rwsem(&fs_info->extent_commit_sem);
2290
	init_rwsem(&fs_info->cleanup_work_sem);
2291
	init_rwsem(&fs_info->subvol_sem);
S
Stefan Behrens 已提交
2292
	sema_init(&fs_info->uuid_tree_rescan_sem, 1);
2293 2294 2295 2296 2297
	fs_info->dev_replace.lock_owner = 0;
	atomic_set(&fs_info->dev_replace.nesting_level, 0);
	mutex_init(&fs_info->dev_replace.lock_finishing_cancel_unmount);
	mutex_init(&fs_info->dev_replace.lock_management_lock);
	mutex_init(&fs_info->dev_replace.lock);
2298

2299
	spin_lock_init(&fs_info->qgroup_lock);
2300
	mutex_init(&fs_info->qgroup_ioctl_lock);
2301 2302 2303 2304 2305
	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;
2306
	fs_info->qgroup_ulist = NULL;
J
Jan Schmidt 已提交
2307
	mutex_init(&fs_info->qgroup_rescan_lock);
2308

2309 2310 2311
	btrfs_init_free_cluster(&fs_info->meta_alloc_cluster);
	btrfs_init_free_cluster(&fs_info->data_alloc_cluster);

2312
	init_waitqueue_head(&fs_info->transaction_throttle);
2313
	init_waitqueue_head(&fs_info->transaction_wait);
S
Sage Weil 已提交
2314
	init_waitqueue_head(&fs_info->transaction_blocked_wait);
2315
	init_waitqueue_head(&fs_info->async_submit_wait);
2316

D
David Woodhouse 已提交
2317 2318
	ret = btrfs_alloc_stripe_hash_table(fs_info);
	if (ret) {
2319
		err = ret;
D
David Woodhouse 已提交
2320 2321 2322
		goto fail_alloc;
	}

2323
	__setup_root(4096, 4096, 4096, 4096, tree_root,
C
Chris Mason 已提交
2324
		     fs_info, BTRFS_ROOT_TREE_OBJECTID);
2325

2326
	invalidate_bdev(fs_devices->latest_bdev);
D
David Sterba 已提交
2327 2328 2329 2330

	/*
	 * Read super block and check the signature bytes only
	 */
Y
Yan Zheng 已提交
2331
	bh = btrfs_read_dev_super(fs_devices->latest_bdev);
2332 2333
	if (!bh) {
		err = -EINVAL;
2334
		goto fail_alloc;
2335
	}
C
Chris Mason 已提交
2336

D
David Sterba 已提交
2337 2338 2339 2340 2341
	/*
	 * We want to check superblock checksum, the type is stored inside.
	 * Pass the whole disk block of size BTRFS_SUPER_INFO_SIZE (4k).
	 */
	if (btrfs_check_super_csum(bh->b_data)) {
2342
		printk(KERN_ERR "BTRFS: superblock checksum mismatch\n");
D
David Sterba 已提交
2343 2344 2345 2346 2347 2348 2349 2350 2351
		err = -EINVAL;
		goto fail_alloc;
	}

	/*
	 * super_copy is zeroed at allocation time and we never touch the
	 * following bytes up to INFO_SIZE, the checksum is calculated from
	 * the whole block of INFO_SIZE
	 */
2352 2353 2354
	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));
2355
	brelse(bh);
2356

2357
	memcpy(fs_info->fsid, fs_info->super_copy->fsid, BTRFS_FSID_SIZE);
2358

D
David Sterba 已提交
2359 2360
	ret = btrfs_check_super_valid(fs_info, sb->s_flags & MS_RDONLY);
	if (ret) {
2361
		printk(KERN_ERR "BTRFS: superblock contains fatal errors\n");
D
David Sterba 已提交
2362 2363 2364 2365
		err = -EINVAL;
		goto fail_alloc;
	}

2366
	disk_super = fs_info->super_copy;
2367
	if (!btrfs_super_root(disk_super))
2368
		goto fail_alloc;
2369

L
liubo 已提交
2370
	/* check FS state, whether FS is broken. */
2371 2372
	if (btrfs_super_flags(disk_super) & BTRFS_SUPER_FLAG_ERROR)
		set_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state);
L
liubo 已提交
2373

C
Chris Mason 已提交
2374 2375 2376 2377 2378 2379 2380
	/*
	 * 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);

2381 2382 2383 2384 2385 2386
	/*
	 * 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 已提交
2387 2388 2389
	ret = btrfs_parse_options(tree_root, options);
	if (ret) {
		err = ret;
2390
		goto fail_alloc;
Y
Yan Zheng 已提交
2391
	}
2392

2393 2394 2395 2396 2397
	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",
2398
		       features);
2399
		err = -EINVAL;
2400
		goto fail_alloc;
2401 2402
	}

2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419
	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;
	}

2420
	features = btrfs_super_incompat_flags(disk_super);
L
Li Zefan 已提交
2421
	features |= BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF;
L
Li Zefan 已提交
2422
	if (tree_root->fs_info->compress_type == BTRFS_COMPRESS_LZO)
L
Li Zefan 已提交
2423
		features |= BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO;
2424

2425
	if (features & BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA)
2426
		printk(KERN_ERR "BTRFS: has skinny extents\n");
2427

2428 2429 2430 2431 2432 2433
	/*
	 * 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))
2434
			printk(KERN_INFO "BTRFS: flagging fs with big metadata feature\n");
2435 2436 2437
		features |= BTRFS_FEATURE_INCOMPAT_BIG_METADATA;
	}

2438 2439 2440 2441
	nodesize = btrfs_super_nodesize(disk_super);
	leafsize = btrfs_super_leafsize(disk_super);
	sectorsize = btrfs_super_sectorsize(disk_super);
	stripesize = btrfs_super_stripesize(disk_super);
2442
	fs_info->dirty_metadata_batch = leafsize * (1 + ilog2(nr_cpu_ids));
2443
	fs_info->delalloc_batch = sectorsize * 512 * (1 + ilog2(nr_cpu_ids));
2444 2445 2446 2447 2448 2449 2450

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

2457 2458 2459 2460
	/*
	 * Needn't use the lock because there is no other task which will
	 * update the flag.
	 */
L
Li Zefan 已提交
2461
	btrfs_set_super_incompat_flags(disk_super, features);
2462

2463 2464 2465 2466 2467
	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",
2468
		       features);
2469
		err = -EINVAL;
2470
		goto fail_alloc;
2471
	}
2472 2473 2474 2475

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

2476
	btrfs_init_workers(&fs_info->workers, "worker",
2477 2478
			   fs_info->thread_pool_size,
			   &fs_info->generic_worker);
C
Chris Mason 已提交
2479

2480
	btrfs_init_workers(&fs_info->delalloc_workers, "delalloc",
2481
			   fs_info->thread_pool_size, NULL);
2482

2483
	btrfs_init_workers(&fs_info->flush_workers, "flush_delalloc",
2484
			   fs_info->thread_pool_size, NULL);
2485

2486
	btrfs_init_workers(&fs_info->submit_workers, "submit",
2487
			   min_t(u64, fs_devices->num_devices,
2488
			   fs_info->thread_pool_size), NULL);
2489

2490
	btrfs_init_workers(&fs_info->caching_workers, "cache",
2491
			   fs_info->thread_pool_size, NULL);
2492

2493 2494 2495 2496 2497
	/* 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;
2498

2499
	fs_info->workers.idle_thresh = 16;
C
Chris Mason 已提交
2500
	fs_info->workers.ordered = 1;
2501

2502 2503 2504
	fs_info->delalloc_workers.idle_thresh = 2;
	fs_info->delalloc_workers.ordered = 1;

2505 2506
	btrfs_init_workers(&fs_info->fixup_workers, "fixup", 1,
			   &fs_info->generic_worker);
2507
	btrfs_init_workers(&fs_info->endio_workers, "endio",
2508 2509
			   fs_info->thread_pool_size,
			   &fs_info->generic_worker);
2510
	btrfs_init_workers(&fs_info->endio_meta_workers, "endio-meta",
2511 2512
			   fs_info->thread_pool_size,
			   &fs_info->generic_worker);
2513
	btrfs_init_workers(&fs_info->endio_meta_write_workers,
2514 2515
			   "endio-meta-write", fs_info->thread_pool_size,
			   &fs_info->generic_worker);
D
David Woodhouse 已提交
2516 2517 2518 2519 2520 2521
	btrfs_init_workers(&fs_info->endio_raid56_workers,
			   "endio-raid56", fs_info->thread_pool_size,
			   &fs_info->generic_worker);
	btrfs_init_workers(&fs_info->rmw_workers,
			   "rmw", fs_info->thread_pool_size,
			   &fs_info->generic_worker);
2522
	btrfs_init_workers(&fs_info->endio_write_workers, "endio-write",
2523 2524
			   fs_info->thread_pool_size,
			   &fs_info->generic_worker);
J
Josef Bacik 已提交
2525 2526
	btrfs_init_workers(&fs_info->endio_freespace_worker, "freespace-write",
			   1, &fs_info->generic_worker);
2527 2528 2529
	btrfs_init_workers(&fs_info->delayed_workers, "delayed-meta",
			   fs_info->thread_pool_size,
			   &fs_info->generic_worker);
2530 2531 2532
	btrfs_init_workers(&fs_info->readahead_workers, "readahead",
			   fs_info->thread_pool_size,
			   &fs_info->generic_worker);
J
Jan Schmidt 已提交
2533 2534
	btrfs_init_workers(&fs_info->qgroup_rescan_workers, "qgroup-rescan", 1,
			   &fs_info->generic_worker);
2535 2536 2537 2538 2539 2540

	/*
	 * endios are largely parallel and should have a very
	 * low idle thresh
	 */
	fs_info->endio_workers.idle_thresh = 4;
2541
	fs_info->endio_meta_workers.idle_thresh = 4;
D
David Woodhouse 已提交
2542 2543
	fs_info->endio_raid56_workers.idle_thresh = 4;
	fs_info->rmw_workers.idle_thresh = 2;
2544

2545 2546
	fs_info->endio_write_workers.idle_thresh = 2;
	fs_info->endio_meta_write_workers.idle_thresh = 2;
2547
	fs_info->readahead_workers.idle_thresh = 2;
2548

2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559
	/*
	 * 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);
D
David Woodhouse 已提交
2560 2561
	ret |= btrfs_start_workers(&fs_info->rmw_workers);
	ret |= btrfs_start_workers(&fs_info->endio_raid56_workers);
2562 2563 2564 2565 2566 2567
	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);
2568
	ret |= btrfs_start_workers(&fs_info->flush_workers);
J
Jan Schmidt 已提交
2569
	ret |= btrfs_start_workers(&fs_info->qgroup_rescan_workers);
2570
	if (ret) {
2571
		err = -ENOMEM;
2572 2573
		goto fail_sb_buffer;
	}
2574

2575
	fs_info->bdi.ra_pages *= btrfs_super_num_devices(disk_super);
C
Chris Mason 已提交
2576 2577
	fs_info->bdi.ra_pages = max(fs_info->bdi.ra_pages,
				    4 * 1024 * 1024 / PAGE_CACHE_SIZE);
2578

2579 2580 2581
	tree_root->nodesize = nodesize;
	tree_root->leafsize = leafsize;
	tree_root->sectorsize = sectorsize;
2582
	tree_root->stripesize = stripesize;
2583 2584 2585

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

2587
	if (btrfs_super_magic(disk_super) != BTRFS_MAGIC) {
2588
		printk(KERN_INFO "BTRFS: valid FS not found on %s\n", sb->s_id);
C
Chris Mason 已提交
2589 2590
		goto fail_sb_buffer;
	}
2591

2592
	if (sectorsize != PAGE_SIZE) {
2593
		printk(KERN_WARNING "BTRFS: Incompatible sector size(%lu) "
2594
		       "found on %s\n", (unsigned long)sectorsize, sb->s_id);
2595 2596 2597
		goto fail_sb_buffer;
	}

2598
	mutex_lock(&fs_info->chunk_mutex);
Y
Yan Zheng 已提交
2599
	ret = btrfs_read_sys_array(tree_root);
2600
	mutex_unlock(&fs_info->chunk_mutex);
2601
	if (ret) {
2602
		printk(KERN_WARNING "BTRFS: failed to read the system "
C
Chris Mason 已提交
2603
		       "array on %s\n", sb->s_id);
2604
		goto fail_sb_buffer;
2605
	}
2606 2607 2608

	blocksize = btrfs_level_size(tree_root,
				     btrfs_super_chunk_root_level(disk_super));
2609
	generation = btrfs_super_chunk_root_generation(disk_super);
2610 2611 2612 2613 2614 2615

	__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),
2616
					   blocksize, generation);
2617 2618
	if (!chunk_root->node ||
	    !test_bit(EXTENT_BUFFER_UPTODATE, &chunk_root->node->bflags)) {
2619
		printk(KERN_WARNING "BTRFS: failed to read chunk root on %s\n",
2620
		       sb->s_id);
C
Chris Mason 已提交
2621
		goto fail_tree_roots;
2622
	}
2623 2624
	btrfs_set_root_node(&chunk_root->root_item, chunk_root->node);
	chunk_root->commit_root = btrfs_root_node(chunk_root);
2625

2626
	read_extent_buffer(chunk_root->node, fs_info->chunk_tree_uuid,
2627
	   btrfs_header_chunk_tree_uuid(chunk_root->node), BTRFS_UUID_SIZE);
2628

2629
	ret = btrfs_read_chunk_tree(chunk_root);
Y
Yan Zheng 已提交
2630
	if (ret) {
2631
		printk(KERN_WARNING "BTRFS: failed to read chunk tree on %s\n",
C
Chris Mason 已提交
2632
		       sb->s_id);
C
Chris Mason 已提交
2633
		goto fail_tree_roots;
Y
Yan Zheng 已提交
2634
	}
2635

2636 2637 2638 2639 2640
	/*
	 * keep the device that is marked to be the target device for the
	 * dev_replace procedure
	 */
	btrfs_close_extra_devices(fs_info, fs_devices, 0);
2641

2642
	if (!fs_devices->latest_bdev) {
2643
		printk(KERN_CRIT "BTRFS: failed to read devices on %s\n",
2644 2645 2646 2647
		       sb->s_id);
		goto fail_tree_roots;
	}

C
Chris Mason 已提交
2648
retry_root_backup:
2649 2650
	blocksize = btrfs_level_size(tree_root,
				     btrfs_super_root_level(disk_super));
2651
	generation = btrfs_super_generation(disk_super);
2652

C
Chris Mason 已提交
2653
	tree_root->node = read_tree_block(tree_root,
2654
					  btrfs_super_root(disk_super),
2655
					  blocksize, generation);
C
Chris Mason 已提交
2656 2657
	if (!tree_root->node ||
	    !test_bit(EXTENT_BUFFER_UPTODATE, &tree_root->node->bflags)) {
2658
		printk(KERN_WARNING "BTRFS: failed to read tree root on %s\n",
2659
		       sb->s_id);
C
Chris Mason 已提交
2660 2661

		goto recovery_tree_root;
2662
	}
C
Chris Mason 已提交
2663

2664 2665
	btrfs_set_root_node(&tree_root->root_item, tree_root->node);
	tree_root->commit_root = btrfs_root_node(tree_root);
2666
	btrfs_set_root_refs(&tree_root->root_item, 1);
2667

2668 2669 2670 2671 2672 2673 2674
	location.objectid = BTRFS_EXTENT_TREE_OBJECTID;
	location.type = BTRFS_ROOT_ITEM_KEY;
	location.offset = 0;

	extent_root = btrfs_read_tree_root(tree_root, &location);
	if (IS_ERR(extent_root)) {
		ret = PTR_ERR(extent_root);
C
Chris Mason 已提交
2675
		goto recovery_tree_root;
2676
	}
2677
	extent_root->track_dirty = 1;
2678
	fs_info->extent_root = extent_root;
2679

2680 2681 2682 2683
	location.objectid = BTRFS_DEV_TREE_OBJECTID;
	dev_root = btrfs_read_tree_root(tree_root, &location);
	if (IS_ERR(dev_root)) {
		ret = PTR_ERR(dev_root);
C
Chris Mason 已提交
2684
		goto recovery_tree_root;
2685
	}
2686
	dev_root->track_dirty = 1;
2687 2688
	fs_info->dev_root = dev_root;
	btrfs_init_devices_late(fs_info);
2689

2690 2691 2692 2693
	location.objectid = BTRFS_CSUM_TREE_OBJECTID;
	csum_root = btrfs_read_tree_root(tree_root, &location);
	if (IS_ERR(csum_root)) {
		ret = PTR_ERR(csum_root);
C
Chris Mason 已提交
2694
		goto recovery_tree_root;
2695
	}
2696
	csum_root->track_dirty = 1;
2697
	fs_info->csum_root = csum_root;
2698

2699 2700 2701
	location.objectid = BTRFS_QUOTA_TREE_OBJECTID;
	quota_root = btrfs_read_tree_root(tree_root, &location);
	if (!IS_ERR(quota_root)) {
2702 2703 2704
		quota_root->track_dirty = 1;
		fs_info->quota_enabled = 1;
		fs_info->pending_quota_state = 1;
2705
		fs_info->quota_root = quota_root;
2706 2707
	}

2708 2709 2710 2711 2712 2713 2714
	location.objectid = BTRFS_UUID_TREE_OBJECTID;
	uuid_root = btrfs_read_tree_root(tree_root, &location);
	if (IS_ERR(uuid_root)) {
		ret = PTR_ERR(uuid_root);
		if (ret != -ENOENT)
			goto recovery_tree_root;
		create_uuid_tree = true;
2715
		check_uuid_tree = false;
2716 2717 2718
	} else {
		uuid_root->track_dirty = 1;
		fs_info->uuid_root = uuid_root;
2719 2720 2721
		create_uuid_tree = false;
		check_uuid_tree =
		    generation != btrfs_super_uuid_tree_generation(disk_super);
2722 2723
	}

2724 2725 2726
	fs_info->generation = generation;
	fs_info->last_trans_committed = generation;

2727 2728
	ret = btrfs_recover_balance(fs_info);
	if (ret) {
2729
		printk(KERN_WARNING "BTRFS: failed to recover balance\n");
2730 2731 2732
		goto fail_block_groups;
	}

2733 2734
	ret = btrfs_init_dev_stats(fs_info);
	if (ret) {
2735
		printk(KERN_ERR "BTRFS: failed to init dev_stats: %d\n",
2736 2737 2738 2739
		       ret);
		goto fail_block_groups;
	}

2740 2741
	ret = btrfs_init_dev_replace(fs_info);
	if (ret) {
2742
		pr_err("BTRFS: failed to init dev_replace: %d\n", ret);
2743 2744 2745 2746 2747
		goto fail_block_groups;
	}

	btrfs_close_extra_devices(fs_info, fs_devices, 1);

2748 2749
	ret = btrfs_sysfs_add_one(fs_info);
	if (ret) {
2750
		pr_err("BTRFS: failed to init sysfs interface: %d\n", ret);
2751 2752 2753
		goto fail_block_groups;
	}

2754 2755
	ret = btrfs_init_space_info(fs_info);
	if (ret) {
2756
		printk(KERN_ERR "BTRFS: Failed to initial space info: %d\n", ret);
2757
		goto fail_sysfs;
2758 2759
	}

2760 2761
	ret = btrfs_read_block_groups(extent_root);
	if (ret) {
2762
		printk(KERN_ERR "BTRFS: Failed to read block groups: %d\n", ret);
2763
		goto fail_sysfs;
2764
	}
2765 2766
	fs_info->num_tolerated_disk_barrier_failures =
		btrfs_calc_num_tolerated_disk_barrier_failures(fs_info);
2767 2768 2769
	if (fs_info->fs_devices->missing_devices >
	     fs_info->num_tolerated_disk_barrier_failures &&
	    !(sb->s_flags & MS_RDONLY)) {
2770 2771
		printk(KERN_WARNING "BTRFS: "
			"too many missing devices, writeable mount is not allowed\n");
2772
		goto fail_sysfs;
2773
	}
C
Chris Mason 已提交
2774

2775 2776
	fs_info->cleaner_kthread = kthread_run(cleaner_kthread, tree_root,
					       "btrfs-cleaner");
2777
	if (IS_ERR(fs_info->cleaner_kthread))
2778
		goto fail_sysfs;
2779 2780 2781 2782

	fs_info->transaction_kthread = kthread_run(transaction_kthread,
						   tree_root,
						   "btrfs-transaction");
2783
	if (IS_ERR(fs_info->transaction_kthread))
2784
		goto fail_cleaner;
2785

C
Chris Mason 已提交
2786 2787 2788
	if (!btrfs_test_opt(tree_root, SSD) &&
	    !btrfs_test_opt(tree_root, NOSSD) &&
	    !fs_info->fs_devices->rotating) {
2789
		printk(KERN_INFO "BTRFS: detected SSD devices, enabling SSD "
C
Chris Mason 已提交
2790 2791 2792 2793
		       "mode\n");
		btrfs_set_opt(fs_info->mount_opt, SSD);
	}

2794 2795 2796 2797
	/* Set the real inode map cache flag */
	if (btrfs_test_opt(tree_root, CHANGE_INODE_CACHE))
		btrfs_set_opt(tree_root->fs_info->mount_opt, INODE_MAP_CACHE);

2798 2799 2800 2801 2802 2803 2804 2805
#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)
2806
			printk(KERN_WARNING "BTRFS: failed to initialize"
2807 2808 2809
			       " integrity check module %s\n", sb->s_id);
	}
#endif
2810 2811 2812
	ret = btrfs_read_qgroup_config(fs_info);
	if (ret)
		goto fail_trans_kthread;
2813

L
liubo 已提交
2814
	/* do not make disk changes in broken FS */
2815
	if (btrfs_super_log_root(disk_super) != 0) {
2816 2817
		u64 bytenr = btrfs_super_log_root(disk_super);

2818
		if (fs_devices->rw_devices == 0) {
2819
			printk(KERN_WARNING "BTRFS: log replay required "
C
Chris Mason 已提交
2820
			       "on RO media\n");
2821
			err = -EIO;
2822
			goto fail_qgroup;
2823
		}
2824 2825 2826
		blocksize =
		     btrfs_level_size(tree_root,
				      btrfs_super_log_root_level(disk_super));
C
Chris Mason 已提交
2827

A
Al Viro 已提交
2828
		log_tree_root = btrfs_alloc_root(fs_info);
2829 2830
		if (!log_tree_root) {
			err = -ENOMEM;
2831
			goto fail_qgroup;
2832
		}
2833 2834 2835 2836 2837

		__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,
2838 2839
						      blocksize,
						      generation + 1);
2840 2841
		if (!log_tree_root->node ||
		    !extent_buffer_uptodate(log_tree_root->node)) {
2842
			printk(KERN_ERR "BTRFS: failed to read log tree\n");
2843 2844 2845 2846
			free_extent_buffer(log_tree_root->node);
			kfree(log_tree_root);
			goto fail_trans_kthread;
		}
2847
		/* returns with log_tree_root freed on success */
2848
		ret = btrfs_recover_log_trees(log_tree_root);
2849 2850 2851 2852 2853 2854 2855
		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;
		}
2856 2857

		if (sb->s_flags & MS_RDONLY) {
2858 2859 2860
			ret = btrfs_commit_super(tree_root);
			if (ret)
				goto fail_trans_kthread;
2861
		}
2862
	}
Z
Zheng Yan 已提交
2863

2864
	ret = btrfs_find_orphan_roots(tree_root);
2865 2866
	if (ret)
		goto fail_trans_kthread;
2867

2868
	if (!(sb->s_flags & MS_RDONLY)) {
2869
		ret = btrfs_cleanup_fs_roots(fs_info);
2870 2871
		if (ret)
			goto fail_trans_kthread;
2872

2873
		ret = btrfs_recover_relocation(tree_root);
2874 2875
		if (ret < 0) {
			printk(KERN_WARNING
2876
			       "BTRFS: failed to recover relocation\n");
2877
			err = -EINVAL;
2878
			goto fail_qgroup;
2879
		}
2880
	}
Z
Zheng Yan 已提交
2881

2882 2883
	location.objectid = BTRFS_FS_TREE_OBJECTID;
	location.type = BTRFS_ROOT_ITEM_KEY;
2884
	location.offset = 0;
2885 2886

	fs_info->fs_root = btrfs_read_fs_root_no_name(fs_info, &location);
2887 2888
	if (IS_ERR(fs_info->fs_root)) {
		err = PTR_ERR(fs_info->fs_root);
2889
		goto fail_qgroup;
2890
	}
C
Chris Mason 已提交
2891

2892 2893
	if (sb->s_flags & MS_RDONLY)
		return 0;
I
Ilya Dryomov 已提交
2894

2895 2896 2897
	down_read(&fs_info->cleanup_work_sem);
	if ((ret = btrfs_orphan_cleanup(fs_info->fs_root)) ||
	    (ret = btrfs_orphan_cleanup(fs_info->tree_root))) {
2898
		up_read(&fs_info->cleanup_work_sem);
2899 2900 2901 2902
		close_ctree(tree_root);
		return ret;
	}
	up_read(&fs_info->cleanup_work_sem);
I
Ilya Dryomov 已提交
2903

2904 2905
	ret = btrfs_resume_balance_async(fs_info);
	if (ret) {
2906
		printk(KERN_WARNING "BTRFS: failed to resume balance\n");
2907 2908
		close_ctree(tree_root);
		return ret;
2909 2910
	}

2911 2912
	ret = btrfs_resume_dev_replace_async(fs_info);
	if (ret) {
2913
		pr_warn("BTRFS: failed to resume dev_replace\n");
2914 2915 2916 2917
		close_ctree(tree_root);
		return ret;
	}

2918 2919
	btrfs_qgroup_rescan_resume(fs_info);

2920
	if (create_uuid_tree) {
2921
		pr_info("BTRFS: creating UUID tree\n");
2922 2923
		ret = btrfs_create_uuid_tree(fs_info);
		if (ret) {
2924
			pr_warn("BTRFS: failed to create the UUID tree %d\n",
2925 2926 2927 2928
				ret);
			close_ctree(tree_root);
			return ret;
		}
2929 2930
	} else if (check_uuid_tree ||
		   btrfs_test_opt(tree_root, RESCAN_UUID_TREE)) {
2931
		pr_info("BTRFS: checking UUID tree\n");
2932 2933
		ret = btrfs_check_uuid_tree(fs_info);
		if (ret) {
2934
			pr_warn("BTRFS: failed to check the UUID tree %d\n",
2935 2936 2937 2938 2939 2940
				ret);
			close_ctree(tree_root);
			return ret;
		}
	} else {
		fs_info->update_uuid_tree_gen = 1;
2941 2942
	}

A
Al Viro 已提交
2943
	return 0;
C
Chris Mason 已提交
2944

2945 2946
fail_qgroup:
	btrfs_free_qgroup_config(fs_info);
2947 2948
fail_trans_kthread:
	kthread_stop(fs_info->transaction_kthread);
J
Josef Bacik 已提交
2949
	btrfs_cleanup_transaction(fs_info->tree_root);
2950
	del_fs_roots(fs_info);
2951
fail_cleaner:
2952
	kthread_stop(fs_info->cleaner_kthread);
2953 2954 2955 2956 2957 2958 2959

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

2960 2961 2962
fail_sysfs:
	btrfs_sysfs_remove_one(fs_info);

2963
fail_block_groups:
J
Josef Bacik 已提交
2964
	btrfs_put_block_group_cache(fs_info);
2965
	btrfs_free_block_groups(fs_info);
C
Chris Mason 已提交
2966 2967 2968

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

C
Chris Mason 已提交
2971
fail_sb_buffer:
L
Liu Bo 已提交
2972
	btrfs_stop_all_workers(fs_info);
2973
fail_alloc:
2974
fail_iput:
2975 2976
	btrfs_mapping_tree_free(&fs_info->mapping_tree);

2977
	iput(fs_info->btree_inode);
2978 2979
fail_bio_counter:
	percpu_counter_destroy(&fs_info->bio_counter);
2980 2981
fail_delalloc_bytes:
	percpu_counter_destroy(&fs_info->delalloc_bytes);
2982 2983
fail_dirty_metadata_bytes:
	percpu_counter_destroy(&fs_info->dirty_metadata_bytes);
2984
fail_bdi:
2985
	bdi_destroy(&fs_info->bdi);
2986 2987
fail_srcu:
	cleanup_srcu_struct(&fs_info->subvol_srcu);
2988
fail:
D
David Woodhouse 已提交
2989
	btrfs_free_stripe_hash_table(fs_info);
2990
	btrfs_close_devices(fs_info->fs_devices);
A
Al Viro 已提交
2991
	return err;
C
Chris Mason 已提交
2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009

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

3012 3013 3014 3015 3016
static void btrfs_end_buffer_write_sync(struct buffer_head *bh, int uptodate)
{
	if (uptodate) {
		set_buffer_uptodate(bh);
	} else {
3017 3018 3019
		struct btrfs_device *device = (struct btrfs_device *)
			bh->b_private;

3020
		printk_ratelimited_in_rcu(KERN_WARNING "BTRFS: lost page write due to "
3021 3022
					  "I/O error on %s\n",
					  rcu_str_deref(device->name));
3023 3024 3025
		/* note, we dont' set_buffer_write_io_error because we have
		 * our own ways of dealing with the IO errors
		 */
3026
		clear_buffer_uptodate(bh);
3027
		btrfs_dev_stat_inc_and_print(device, BTRFS_DEV_STAT_WRITE_ERRS);
3028 3029 3030 3031 3032
	}
	unlock_buffer(bh);
	put_bh(bh);
}

Y
Yan Zheng 已提交
3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048
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);
3049 3050
		if (bytenr + BTRFS_SUPER_INFO_SIZE >=
					i_size_read(bdev->bd_inode))
Y
Yan Zheng 已提交
3051
			break;
3052 3053
		bh = __bread(bdev, bytenr / 4096,
					BTRFS_SUPER_INFO_SIZE);
Y
Yan Zheng 已提交
3054 3055 3056 3057 3058
		if (!bh)
			continue;

		super = (struct btrfs_super_block *)bh->b_data;
		if (btrfs_super_bytenr(super) != bytenr ||
3059
		    btrfs_super_magic(super) != BTRFS_MAGIC) {
Y
Yan Zheng 已提交
3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074
			brelse(bh);
			continue;
		}

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

3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085
/*
 * 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 已提交
3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107
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);
3108 3109 3110 3111
			if (!bh) {
				errors++;
				continue;
			}
Y
Yan Zheng 已提交
3112
			wait_on_buffer(bh);
3113 3114 3115 3116 3117 3118 3119 3120 3121
			if (!buffer_uptodate(bh))
				errors++;

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

			/* drop the reference from the wait == 0 run */
			brelse(bh);
			continue;
Y
Yan Zheng 已提交
3122 3123 3124 3125
		} else {
			btrfs_set_super_bytenr(sb, bytenr);

			crc = ~(u32)0;
3126
			crc = btrfs_csum_data((char *)sb +
Y
Yan Zheng 已提交
3127 3128 3129 3130 3131
					      BTRFS_CSUM_SIZE, crc,
					      BTRFS_SUPER_INFO_SIZE -
					      BTRFS_CSUM_SIZE);
			btrfs_csum_final(crc, sb->csum);

3132 3133 3134 3135
			/*
			 * one reference for us, and we leave it for the
			 * caller
			 */
Y
Yan Zheng 已提交
3136 3137
			bh = __getblk(device->bdev, bytenr / 4096,
				      BTRFS_SUPER_INFO_SIZE);
3138
			if (!bh) {
3139
				printk(KERN_ERR "BTRFS: couldn't get super "
3140 3141 3142 3143 3144
				       "buffer head for bytenr %Lu\n", bytenr);
				errors++;
				continue;
			}

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

3147
			/* one reference for submit_bh */
Y
Yan Zheng 已提交
3148
			get_bh(bh);
3149 3150

			set_buffer_uptodate(bh);
Y
Yan Zheng 已提交
3151 3152
			lock_buffer(bh);
			bh->b_end_io = btrfs_end_buffer_write_sync;
3153
			bh->b_private = device;
Y
Yan Zheng 已提交
3154 3155
		}

C
Chris Mason 已提交
3156 3157 3158 3159
		/*
		 * we fua the first super.  The others we allow
		 * to go down lazy.
		 */
3160 3161 3162 3163
		if (i == 0)
			ret = btrfsic_submit_bh(WRITE_FUA, bh);
		else
			ret = btrfsic_submit_bh(WRITE_SYNC, bh);
3164
		if (ret)
Y
Yan Zheng 已提交
3165 3166 3167 3168 3169
			errors++;
	}
	return errors < i ? 0 : -1;
}

C
Chris Mason 已提交
3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208
/*
 * 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)) {
3209
			printk_in_rcu("BTRFS: disabling barriers on dev %s\n",
3210
				      rcu_str_deref(device->name));
C
Chris Mason 已提交
3211
			device->nobarriers = 1;
3212
		} else if (!bio_flagged(bio, BIO_UPTODATE)) {
C
Chris Mason 已提交
3213
			ret = -EIO;
3214 3215
			btrfs_dev_stat_inc_and_print(device,
				BTRFS_DEV_STAT_FLUSH_ERRS);
C
Chris Mason 已提交
3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228
		}

		/* 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
	 */
3229
	device->flush_bio = NULL;
3230
	bio = btrfs_io_bio_alloc(GFP_NOFS, 0);
C
Chris Mason 已提交
3231 3232 3233 3234 3235 3236 3237 3238 3239 3240
	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);
3241
	btrfsic_submit_bio(WRITE_FLUSH, bio);
C
Chris Mason 已提交
3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253

	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;
3254 3255
	int errors_send = 0;
	int errors_wait = 0;
C
Chris Mason 已提交
3256 3257 3258 3259 3260
	int ret;

	/* send down all the barriers */
	head = &info->fs_devices->devices;
	list_for_each_entry_rcu(dev, head, dev_list) {
3261 3262
		if (dev->missing)
			continue;
C
Chris Mason 已提交
3263
		if (!dev->bdev) {
3264
			errors_send++;
C
Chris Mason 已提交
3265 3266 3267 3268 3269 3270 3271
			continue;
		}
		if (!dev->in_fs_metadata || !dev->writeable)
			continue;

		ret = write_dev_flush(dev, 0);
		if (ret)
3272
			errors_send++;
C
Chris Mason 已提交
3273 3274 3275 3276
	}

	/* wait for all the barriers */
	list_for_each_entry_rcu(dev, head, dev_list) {
3277 3278
		if (dev->missing)
			continue;
C
Chris Mason 已提交
3279
		if (!dev->bdev) {
3280
			errors_wait++;
C
Chris Mason 已提交
3281 3282 3283 3284 3285 3286 3287
			continue;
		}
		if (!dev->in_fs_metadata || !dev->writeable)
			continue;

		ret = write_dev_flush(dev, 1);
		if (ret)
3288
			errors_wait++;
C
Chris Mason 已提交
3289
	}
3290 3291
	if (errors_send > info->num_tolerated_disk_barrier_failures ||
	    errors_wait > info->num_tolerated_disk_barrier_failures)
C
Chris Mason 已提交
3292 3293 3294 3295
		return -EIO;
	return 0;
}

3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355
int btrfs_calc_num_tolerated_disk_barrier_failures(
	struct btrfs_fs_info *fs_info)
{
	struct btrfs_ioctl_space_info space;
	struct btrfs_space_info *sinfo;
	u64 types[] = {BTRFS_BLOCK_GROUP_DATA,
		       BTRFS_BLOCK_GROUP_SYSTEM,
		       BTRFS_BLOCK_GROUP_METADATA,
		       BTRFS_BLOCK_GROUP_DATA | BTRFS_BLOCK_GROUP_METADATA};
	int num_types = 4;
	int i;
	int c;
	int num_tolerated_disk_barrier_failures =
		(int)fs_info->fs_devices->num_devices;

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

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

		if (!sinfo)
			continue;

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

				btrfs_get_block_group_info(
					&sinfo->block_groups[c], &space);
				if (space.total_bytes == 0 ||
				    space.used_bytes == 0)
					continue;
				flags = space.flags;
				/*
				 * return
				 * 0: if dup, single or RAID0 is configured for
				 *    any of metadata, system or data, else
				 * 1: if RAID5 is configured, or if RAID1 or
				 *    RAID10 is configured and only two mirrors
				 *    are used, else
				 * 2: if RAID6 is configured, else
				 * num_mirrors - 1: if RAID1 or RAID10 is
				 *                  configured and more than
				 *                  2 mirrors are used.
				 */
				if (num_tolerated_disk_barrier_failures > 0 &&
				    ((flags & (BTRFS_BLOCK_GROUP_DUP |
					       BTRFS_BLOCK_GROUP_RAID0)) ||
				     ((flags & BTRFS_BLOCK_GROUP_PROFILE_MASK)
				      == 0)))
					num_tolerated_disk_barrier_failures = 0;
D
David Woodhouse 已提交
3356 3357 3358 3359 3360 3361
				else if (num_tolerated_disk_barrier_failures > 1) {
					if (flags & (BTRFS_BLOCK_GROUP_RAID1 |
					    BTRFS_BLOCK_GROUP_RAID5 |
					    BTRFS_BLOCK_GROUP_RAID10)) {
						num_tolerated_disk_barrier_failures = 1;
					} else if (flags &
3362
						   BTRFS_BLOCK_GROUP_RAID6) {
D
David Woodhouse 已提交
3363 3364 3365
						num_tolerated_disk_barrier_failures = 2;
					}
				}
3366 3367 3368 3369 3370 3371 3372 3373
			}
		}
		up_read(&sinfo->groups_sem);
	}

	return num_tolerated_disk_barrier_failures;
}

3374
static int write_all_supers(struct btrfs_root *root, int max_mirrors)
3375
{
3376
	struct list_head *head;
3377
	struct btrfs_device *dev;
3378
	struct btrfs_super_block *sb;
3379 3380 3381
	struct btrfs_dev_item *dev_item;
	int ret;
	int do_barriers;
3382 3383
	int max_errors;
	int total_errors = 0;
3384
	u64 flags;
3385 3386

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

3389
	sb = root->fs_info->super_for_commit;
3390
	dev_item = &sb->dev_item;
3391

3392
	mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
3393
	head = &root->fs_info->fs_devices->devices;
3394
	max_errors = btrfs_super_num_devices(root->fs_info->super_copy) - 1;
C
Chris Mason 已提交
3395

3396 3397 3398 3399 3400 3401 3402 3403 3404 3405
	if (do_barriers) {
		ret = barrier_all_devices(root->fs_info);
		if (ret) {
			mutex_unlock(
				&root->fs_info->fs_devices->device_list_mutex);
			btrfs_error(root->fs_info, ret,
				    "errors while submitting device barriers.");
			return ret;
		}
	}
C
Chris Mason 已提交
3406

3407
	list_for_each_entry_rcu(dev, head, dev_list) {
3408 3409 3410 3411
		if (!dev->bdev) {
			total_errors++;
			continue;
		}
Y
Yan Zheng 已提交
3412
		if (!dev->in_fs_metadata || !dev->writeable)
3413 3414
			continue;

Y
Yan Zheng 已提交
3415
		btrfs_set_stack_device_generation(dev_item, 0);
3416 3417 3418 3419 3420 3421 3422 3423
		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 已提交
3424
		memcpy(dev_item->fsid, dev->fs_devices->fsid, BTRFS_UUID_SIZE);
Y
Yan Zheng 已提交
3425

3426 3427 3428
		flags = btrfs_super_flags(sb);
		btrfs_set_super_flags(sb, flags | BTRFS_HEADER_FLAG_WRITTEN);

Y
Yan Zheng 已提交
3429
		ret = write_dev_supers(dev, sb, do_barriers, 0, max_mirrors);
3430 3431
		if (ret)
			total_errors++;
3432
	}
3433
	if (total_errors > max_errors) {
3434
		btrfs_err(root->fs_info, "%d errors while writing supers",
C
Chris Mason 已提交
3435
		       total_errors);
3436
		mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
3437

3438 3439 3440 3441
		/* FUA is masked off if unsupported and can't be the reason */
		btrfs_error(root->fs_info, -EIO,
			    "%d errors while writing supers", total_errors);
		return -EIO;
3442
	}
3443

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

Y
Yan Zheng 已提交
3451 3452 3453
		ret = write_dev_supers(dev, sb, do_barriers, 1, max_mirrors);
		if (ret)
			total_errors++;
3454
	}
3455
	mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
3456
	if (total_errors > max_errors) {
3457 3458 3459
		btrfs_error(root->fs_info, -EIO,
			    "%d errors while writing supers", total_errors);
		return -EIO;
3460
	}
3461 3462 3463
	return 0;
}

Y
Yan Zheng 已提交
3464 3465
int write_ctree_super(struct btrfs_trans_handle *trans,
		      struct btrfs_root *root, int max_mirrors)
3466
{
3467
	return write_all_supers(root, max_mirrors);
C
Chris Mason 已提交
3468 3469
}

3470 3471 3472
/* Drop a fs root from the radix tree and free it. */
void btrfs_drop_and_free_fs_root(struct btrfs_fs_info *fs_info,
				  struct btrfs_root *root)
C
Chris Mason 已提交
3473
{
3474
	spin_lock(&fs_info->fs_roots_radix_lock);
C
Chris Mason 已提交
3475 3476
	radix_tree_delete(&fs_info->fs_roots_radix,
			  (unsigned long)root->root_key.objectid);
3477
	spin_unlock(&fs_info->fs_roots_radix_lock);
3478 3479 3480 3481

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

3482
	if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state))
L
Liu Bo 已提交
3483 3484
		btrfs_free_log(NULL, root);

3485 3486
	__btrfs_remove_free_space_cache(root->free_ino_pinned);
	__btrfs_remove_free_space_cache(root->free_ino_ctl);
3487 3488 3489 3490 3491
	free_fs_root(root);
}

static void free_fs_root(struct btrfs_root *root)
{
3492
	iput(root->cache_inode);
3493
	WARN_ON(!RB_EMPTY_ROOT(&root->inode_tree));
3494 3495
	btrfs_free_block_rsv(root, root->orphan_block_rsv);
	root->orphan_block_rsv = NULL;
3496 3497
	if (root->anon_dev)
		free_anon_bdev(root->anon_dev);
3498 3499
	free_extent_buffer(root->node);
	free_extent_buffer(root->commit_root);
3500 3501
	kfree(root->free_ino_ctl);
	kfree(root->free_ino_pinned);
C
Chris Mason 已提交
3502
	kfree(root->name);
3503
	btrfs_put_fs_root(root);
C
Chris Mason 已提交
3504 3505
}

3506 3507 3508
void btrfs_free_fs_root(struct btrfs_root *root)
{
	free_fs_root(root);
C
Chris Mason 已提交
3509 3510
}

Y
Yan Zheng 已提交
3511
int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info)
C
Chris Mason 已提交
3512
{
Y
Yan Zheng 已提交
3513 3514 3515
	u64 root_objectid = 0;
	struct btrfs_root *gang[8];
	int i;
3516
	int ret;
3517

Y
Yan Zheng 已提交
3518 3519 3520 3521 3522 3523
	while (1) {
		ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
					     (void **)gang, root_objectid,
					     ARRAY_SIZE(gang));
		if (!ret)
			break;
3524 3525

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

Y
Yan Zheng 已提交
3529
			root_objectid = gang[i]->root_key.objectid;
3530 3531 3532
			err = btrfs_orphan_cleanup(gang[i]);
			if (err)
				return err;
Y
Yan Zheng 已提交
3533 3534 3535 3536 3537
		}
		root_objectid++;
	}
	return 0;
}
3538

Y
Yan Zheng 已提交
3539 3540 3541
int btrfs_commit_super(struct btrfs_root *root)
{
	struct btrfs_trans_handle *trans;
3542

Y
Yan Zheng 已提交
3543
	mutex_lock(&root->fs_info->cleaner_mutex);
Y
Yan, Zheng 已提交
3544
	btrfs_run_delayed_iputs(root);
Y
Yan Zheng 已提交
3545
	mutex_unlock(&root->fs_info->cleaner_mutex);
D
David Sterba 已提交
3546
	wake_up_process(root->fs_info->cleaner_kthread);
3547 3548 3549 3550 3551

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

3552
	trans = btrfs_join_transaction(root);
3553 3554
	if (IS_ERR(trans))
		return PTR_ERR(trans);
3555
	return btrfs_commit_transaction(trans, root);
Y
Yan Zheng 已提交
3556 3557 3558 3559 3560 3561 3562 3563 3564 3565
}

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

	fs_info->closing = 1;
	smp_mb();

S
Stefan Behrens 已提交
3566 3567 3568 3569 3570
	/* wait for the uuid_scan task to finish */
	down(&fs_info->uuid_tree_rescan_sem);
	/* avoid complains from lockdep et al., set sem back to initial state */
	up(&fs_info->uuid_tree_rescan_sem);

3571
	/* pause restriper - we want to resume on mount */
3572
	btrfs_pause_balance(fs_info);
3573

3574 3575
	btrfs_dev_replace_suspend_for_unmount(fs_info);

3576
	btrfs_scrub_cancel(fs_info);
C
Chris Mason 已提交
3577 3578 3579 3580 3581 3582

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

Y
Yan Zheng 已提交
3585
	if (!(fs_info->sb->s_flags & MS_RDONLY)) {
L
liubo 已提交
3586 3587
		ret = btrfs_commit_super(root);
		if (ret)
3588
			btrfs_err(root->fs_info, "commit super ret %d", ret);
L
liubo 已提交
3589 3590
	}

3591
	if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state))
3592
		btrfs_error_commit_super(root);
3593

A
Al Viro 已提交
3594 3595
	kthread_stop(fs_info->transaction_kthread);
	kthread_stop(fs_info->cleaner_kthread);
3596

3597 3598 3599
	fs_info->closing = 2;
	smp_mb();

3600 3601
	btrfs_free_qgroup_config(root->fs_info);

3602
	if (percpu_counter_sum(&fs_info->delalloc_bytes)) {
3603
		btrfs_info(root->fs_info, "at unmount delalloc count %lld",
3604
		       percpu_counter_sum(&fs_info->delalloc_bytes));
C
Chris Mason 已提交
3605
	}
3606

3607 3608
	btrfs_sysfs_remove_one(fs_info);

Y
Yan Zheng 已提交
3609
	del_fs_roots(fs_info);
3610

3611 3612
	btrfs_put_block_group_cache(fs_info);

3613 3614
	btrfs_free_block_groups(fs_info);

3615 3616
	btrfs_stop_all_workers(fs_info);

3617
	free_root_pointers(fs_info, 1);
3618

3619
	iput(fs_info->btree_inode);
3620

3621 3622 3623 3624 3625
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
	if (btrfs_test_opt(root, CHECK_INTEGRITY))
		btrfsic_unmount(root, fs_info->fs_devices);
#endif

3626
	btrfs_close_devices(fs_info->fs_devices);
3627
	btrfs_mapping_tree_free(&fs_info->mapping_tree);
3628

3629
	percpu_counter_destroy(&fs_info->dirty_metadata_bytes);
3630
	percpu_counter_destroy(&fs_info->delalloc_bytes);
3631
	percpu_counter_destroy(&fs_info->bio_counter);
C
Chris Mason 已提交
3632
	bdi_destroy(&fs_info->bdi);
3633
	cleanup_srcu_struct(&fs_info->subvol_srcu);
3634

D
David Woodhouse 已提交
3635 3636
	btrfs_free_stripe_hash_table(fs_info);

3637 3638 3639
	btrfs_free_block_rsv(root, root->orphan_block_rsv);
	root->orphan_block_rsv = NULL;

3640 3641 3642
	return 0;
}

3643 3644
int btrfs_buffer_uptodate(struct extent_buffer *buf, u64 parent_transid,
			  int atomic)
3645
{
3646
	int ret;
3647
	struct inode *btree_inode = buf->pages[0]->mapping->host;
3648

3649
	ret = extent_buffer_uptodate(buf);
3650 3651 3652 3653
	if (!ret)
		return ret;

	ret = verify_parent_transid(&BTRFS_I(btree_inode)->io_tree, buf,
3654 3655 3656
				    parent_transid, atomic);
	if (ret == -EAGAIN)
		return ret;
3657
	return !ret;
3658 3659 3660
}

int btrfs_set_buffer_uptodate(struct extent_buffer *buf)
C
Chris Mason 已提交
3661
{
3662
	return set_extent_buffer_uptodate(buf);
3663
}
3664

3665 3666
void btrfs_mark_buffer_dirty(struct extent_buffer *buf)
{
3667
	struct btrfs_root *root;
3668
	u64 transid = btrfs_header_generation(buf);
3669
	int was_dirty;
3670

3671 3672 3673 3674 3675 3676 3677 3678 3679 3680
#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
	/*
	 * This is a fast path so only do this check if we have sanity tests
	 * enabled.  Normal people shouldn't be marking dummy buffers as dirty
	 * outside of the sanity tests.
	 */
	if (unlikely(test_bit(EXTENT_BUFFER_DUMMY, &buf->bflags)))
		return;
#endif
	root = BTRFS_I(buf->pages[0]->mapping->host)->root;
3681
	btrfs_assert_tree_locked(buf);
J
Julia Lawall 已提交
3682 3683
	if (transid != root->fs_info->generation)
		WARN(1, KERN_CRIT "btrfs transid mismatch buffer %llu, "
C
Chris Mason 已提交
3684
		       "found %llu running %llu\n",
3685
			buf->start, transid, root->fs_info->generation);
3686
	was_dirty = set_extent_buffer_dirty(buf);
3687 3688 3689 3690
	if (!was_dirty)
		__percpu_counter_add(&root->fs_info->dirty_metadata_bytes,
				     buf->len,
				     root->fs_info->dirty_metadata_batch);
3691 3692
}

3693 3694
static void __btrfs_btree_balance_dirty(struct btrfs_root *root,
					int flush_delayed)
3695 3696 3697 3698 3699
{
	/*
	 * looks as though older kernels can get into trouble with
	 * this code, they end up stuck in balance_dirty_pages forever
	 */
3700
	int ret;
3701 3702 3703 3704

	if (current->flags & PF_MEMALLOC)
		return;

3705 3706
	if (flush_delayed)
		btrfs_balance_delayed_items(root);
3707

3708 3709 3710
	ret = percpu_counter_compare(&root->fs_info->dirty_metadata_bytes,
				     BTRFS_DIRTY_METADATA_THRESH);
	if (ret > 0) {
3711 3712
		balance_dirty_pages_ratelimited(
				   root->fs_info->btree_inode->i_mapping);
3713 3714 3715 3716
	}
	return;
}

3717
void btrfs_btree_balance_dirty(struct btrfs_root *root)
C
Chris Mason 已提交
3718
{
3719 3720
	__btrfs_btree_balance_dirty(root, 1);
}
3721

3722 3723 3724
void btrfs_btree_balance_dirty_nodelay(struct btrfs_root *root)
{
	__btrfs_btree_balance_dirty(root, 0);
C
Chris Mason 已提交
3725
}
3726

3727
int btrfs_read_buffer(struct extent_buffer *buf, u64 parent_transid)
3728
{
3729
	struct btrfs_root *root = BTRFS_I(buf->pages[0]->mapping->host)->root;
3730
	return btree_read_extent_buffer_pages(root, buf, 0, parent_transid);
3731
}
3732

3733
static int btrfs_check_super_valid(struct btrfs_fs_info *fs_info,
L
liubo 已提交
3734 3735
			      int read_only)
{
D
David Sterba 已提交
3736 3737 3738
	/*
	 * Placeholder for checks
	 */
3739
	return 0;
L
liubo 已提交
3740 3741
}

3742
static void btrfs_error_commit_super(struct btrfs_root *root)
L
liubo 已提交
3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754
{
	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);
}

3755 3756
static void btrfs_destroy_ordered_operations(struct btrfs_transaction *t,
					     struct btrfs_root *root)
L
liubo 已提交
3757 3758 3759 3760 3761 3762 3763
{
	struct btrfs_inode *btrfs_inode;
	struct list_head splice;

	INIT_LIST_HEAD(&splice);

	mutex_lock(&root->fs_info->ordered_operations_mutex);
3764
	spin_lock(&root->fs_info->ordered_root_lock);
L
liubo 已提交
3765

3766
	list_splice_init(&t->ordered_operations, &splice);
L
liubo 已提交
3767 3768 3769 3770 3771
	while (!list_empty(&splice)) {
		btrfs_inode = list_entry(splice.next, struct btrfs_inode,
					 ordered_operations);

		list_del_init(&btrfs_inode->ordered_operations);
3772
		spin_unlock(&root->fs_info->ordered_root_lock);
L
liubo 已提交
3773 3774

		btrfs_invalidate_inodes(btrfs_inode->root);
3775

3776
		spin_lock(&root->fs_info->ordered_root_lock);
L
liubo 已提交
3777 3778
	}

3779
	spin_unlock(&root->fs_info->ordered_root_lock);
L
liubo 已提交
3780 3781 3782
	mutex_unlock(&root->fs_info->ordered_operations_mutex);
}

3783
static void btrfs_destroy_ordered_extents(struct btrfs_root *root)
L
liubo 已提交
3784 3785 3786
{
	struct btrfs_ordered_extent *ordered;

3787
	spin_lock(&root->ordered_extent_lock);
3788 3789 3790 3791
	/*
	 * This will just short circuit the ordered completion stuff which will
	 * make sure the ordered extent gets properly cleaned up.
	 */
3792
	list_for_each_entry(ordered, &root->ordered_extents,
3793 3794
			    root_extent_list)
		set_bit(BTRFS_ORDERED_IOERR, &ordered->flags);
3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809
	spin_unlock(&root->ordered_extent_lock);
}

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

	INIT_LIST_HEAD(&splice);

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

3813
		spin_unlock(&fs_info->ordered_root_lock);
3814 3815
		btrfs_destroy_ordered_extents(root);

3816 3817
		cond_resched();
		spin_lock(&fs_info->ordered_root_lock);
3818 3819
	}
	spin_unlock(&fs_info->ordered_root_lock);
L
liubo 已提交
3820 3821
}

3822 3823
static int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans,
				      struct btrfs_root *root)
L
liubo 已提交
3824 3825 3826 3827 3828 3829 3830 3831 3832
{
	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);
3833
	if (atomic_read(&delayed_refs->num_entries) == 0) {
3834
		spin_unlock(&delayed_refs->lock);
3835
		btrfs_info(root->fs_info, "delayed_refs has NO entry");
L
liubo 已提交
3836 3837 3838
		return ret;
	}

3839 3840
	while ((node = rb_first(&delayed_refs->href_root)) != NULL) {
		struct btrfs_delayed_ref_head *head;
3841
		bool pin_bytes = false;
L
liubo 已提交
3842

3843 3844 3845 3846 3847
		head = rb_entry(node, struct btrfs_delayed_ref_head,
				href_node);
		if (!mutex_trylock(&head->mutex)) {
			atomic_inc(&head->node.refs);
			spin_unlock(&delayed_refs->lock);
L
liubo 已提交
3848

3849
			mutex_lock(&head->mutex);
3850
			mutex_unlock(&head->mutex);
3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862
			btrfs_put_delayed_ref(&head->node);
			spin_lock(&delayed_refs->lock);
			continue;
		}
		spin_lock(&head->lock);
		while ((node = rb_first(&head->ref_root)) != NULL) {
			ref = rb_entry(node, struct btrfs_delayed_ref_node,
				       rb_node);
			ref->in_tree = 0;
			rb_erase(&ref->rb_node, &head->ref_root);
			atomic_dec(&delayed_refs->num_entries);
			btrfs_put_delayed_ref(ref);
3863
		}
3864 3865 3866 3867 3868 3869 3870 3871 3872 3873 3874 3875
		if (head->must_insert_reserved)
			pin_bytes = true;
		btrfs_free_delayed_extent_op(head->extent_op);
		delayed_refs->num_heads--;
		if (head->processing == 0)
			delayed_refs->num_heads_ready--;
		atomic_dec(&delayed_refs->num_entries);
		head->node.in_tree = 0;
		rb_erase(&head->href_node, &delayed_refs->href_root);
		spin_unlock(&head->lock);
		spin_unlock(&delayed_refs->lock);
		mutex_unlock(&head->mutex);
L
liubo 已提交
3876

3877 3878 3879 3880
		if (pin_bytes)
			btrfs_pin_extent(root, head->node.bytenr,
					 head->node.num_bytes, 1);
		btrfs_put_delayed_ref(&head->node);
L
liubo 已提交
3881 3882 3883 3884 3885 3886 3887 3888 3889
		cond_resched();
		spin_lock(&delayed_refs->lock);
	}

	spin_unlock(&delayed_refs->lock);

	return ret;
}

3890
static void btrfs_destroy_delalloc_inodes(struct btrfs_root *root)
L
liubo 已提交
3891 3892 3893 3894 3895 3896
{
	struct btrfs_inode *btrfs_inode;
	struct list_head splice;

	INIT_LIST_HEAD(&splice);

3897 3898
	spin_lock(&root->delalloc_lock);
	list_splice_init(&root->delalloc_inodes, &splice);
L
liubo 已提交
3899 3900

	while (!list_empty(&splice)) {
3901 3902
		btrfs_inode = list_first_entry(&splice, struct btrfs_inode,
					       delalloc_inodes);
L
liubo 已提交
3903 3904

		list_del_init(&btrfs_inode->delalloc_inodes);
3905 3906
		clear_bit(BTRFS_INODE_IN_DELALLOC_LIST,
			  &btrfs_inode->runtime_flags);
3907
		spin_unlock(&root->delalloc_lock);
L
liubo 已提交
3908 3909

		btrfs_invalidate_inodes(btrfs_inode->root);
3910

3911
		spin_lock(&root->delalloc_lock);
L
liubo 已提交
3912 3913
	}

3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939
	spin_unlock(&root->delalloc_lock);
}

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

	INIT_LIST_HEAD(&splice);

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

		btrfs_destroy_delalloc_inodes(root);
		btrfs_put_fs_root(root);

		spin_lock(&fs_info->delalloc_root_lock);
	}
	spin_unlock(&fs_info->delalloc_root_lock);
L
liubo 已提交
3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952
}

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

	while (1) {
		ret = find_first_extent_bit(dirty_pages, start, &start, &end,
3953
					    mark, NULL);
L
liubo 已提交
3954 3955 3956 3957 3958
		if (ret)
			break;

		clear_extent_bits(dirty_pages, start, end, mark, GFP_NOFS);
		while (start <= end) {
3959 3960
			eb = btrfs_find_tree_block(root, start,
						   root->leafsize);
3961
			start += root->leafsize;
3962
			if (!eb)
L
liubo 已提交
3963
				continue;
3964
			wait_on_extent_buffer_writeback(eb);
L
liubo 已提交
3965

3966 3967 3968 3969
			if (test_and_clear_bit(EXTENT_BUFFER_DIRTY,
					       &eb->bflags))
				clear_extent_buffer_dirty(eb);
			free_extent_buffer_stale(eb);
L
liubo 已提交
3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982
		}
	}

	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;
3983
	bool loop = true;
L
liubo 已提交
3984 3985

	unpin = pinned_extents;
3986
again:
L
liubo 已提交
3987 3988
	while (1) {
		ret = find_first_extent_bit(unpin, 0, &start, &end,
3989
					    EXTENT_DIRTY, NULL);
L
liubo 已提交
3990 3991 3992 3993
		if (ret)
			break;

		/* opt_discard */
3994 3995 3996 3997
		if (btrfs_test_opt(root, DISCARD))
			ret = btrfs_error_discard_extent(root, start,
							 end + 1 - start,
							 NULL);
L
liubo 已提交
3998 3999 4000 4001 4002 4003

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

4004 4005 4006 4007 4008 4009 4010 4011 4012
	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 已提交
4013 4014 4015
	return 0;
}

4016 4017 4018
void btrfs_cleanup_one_transaction(struct btrfs_transaction *cur_trans,
				   struct btrfs_root *root)
{
4019 4020
	btrfs_destroy_ordered_operations(cur_trans, root);

4021 4022
	btrfs_destroy_delayed_refs(cur_trans, root);

4023
	cur_trans->state = TRANS_STATE_COMMIT_START;
4024
	wake_up(&root->fs_info->transaction_blocked_wait);
4025

4026
	cur_trans->state = TRANS_STATE_UNBLOCKED;
4027
	wake_up(&root->fs_info->transaction_wait);
4028

4029 4030
	btrfs_destroy_delayed_inodes(root);
	btrfs_assert_delayed_root_empty(root);
4031 4032 4033

	btrfs_destroy_marked_extents(root, &cur_trans->dirty_pages,
				     EXTENT_DIRTY);
4034 4035
	btrfs_destroy_pinned_extent(root,
				    root->fs_info->pinned_extents);
4036

4037 4038 4039
	cur_trans->state =TRANS_STATE_COMPLETED;
	wake_up(&cur_trans->commit_wait);

4040 4041 4042 4043 4044 4045
	/*
	memset(cur_trans, 0, sizeof(*cur_trans));
	kmem_cache_free(btrfs_transaction_cachep, cur_trans);
	*/
}

4046
static int btrfs_cleanup_transaction(struct btrfs_root *root)
L
liubo 已提交
4047 4048 4049 4050 4051
{
	struct btrfs_transaction *t;

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

J
Josef Bacik 已提交
4052
	spin_lock(&root->fs_info->trans_lock);
4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074 4075 4076
	while (!list_empty(&root->fs_info->trans_list)) {
		t = list_first_entry(&root->fs_info->trans_list,
				     struct btrfs_transaction, list);
		if (t->state >= TRANS_STATE_COMMIT_START) {
			atomic_inc(&t->use_count);
			spin_unlock(&root->fs_info->trans_lock);
			btrfs_wait_for_commit(root, t->transid);
			btrfs_put_transaction(t);
			spin_lock(&root->fs_info->trans_lock);
			continue;
		}
		if (t == root->fs_info->running_transaction) {
			t->state = TRANS_STATE_COMMIT_DOING;
			spin_unlock(&root->fs_info->trans_lock);
			/*
			 * We wait for 0 num_writers since we don't hold a trans
			 * handle open currently for this transaction.
			 */
			wait_event(t->writer_wait,
				   atomic_read(&t->num_writers) == 0);
		} else {
			spin_unlock(&root->fs_info->trans_lock);
		}
		btrfs_cleanup_one_transaction(t, root);
4077

4078 4079 4080
		spin_lock(&root->fs_info->trans_lock);
		if (t == root->fs_info->running_transaction)
			root->fs_info->running_transaction = NULL;
L
liubo 已提交
4081
		list_del_init(&t->list);
4082
		spin_unlock(&root->fs_info->trans_lock);
L
liubo 已提交
4083

4084 4085 4086 4087 4088 4089 4090 4091 4092 4093
		btrfs_put_transaction(t);
		trace_btrfs_transaction_commit(root);
		spin_lock(&root->fs_info->trans_lock);
	}
	spin_unlock(&root->fs_info->trans_lock);
	btrfs_destroy_all_ordered_extents(root->fs_info);
	btrfs_destroy_delayed_inodes(root);
	btrfs_assert_delayed_root_empty(root);
	btrfs_destroy_pinned_extent(root, root->fs_info->pinned_extents);
	btrfs_destroy_all_delalloc_inodes(root->fs_info);
L
liubo 已提交
4094 4095 4096 4097 4098
	mutex_unlock(&root->fs_info->transaction_kthread_mutex);

	return 0;
}

4099
static struct extent_io_ops btree_extent_io_ops = {
4100
	.readpage_end_io_hook = btree_readpage_end_io_hook,
A
Arne Jansen 已提交
4101
	.readpage_io_failed_hook = btree_io_failed_hook,
4102
	.submit_bio_hook = btree_submit_bio_hook,
4103 4104
	/* note we're sharing with inode.c for the merge bio hook */
	.merge_bio_hook = btrfs_merge_bio_hook,
4105
};