disk-io.c 121.1 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>
28
#include <linux/slab.h>
29
#include <linux/migrate.h>
30
#include <linux/ratelimit.h>
31
#include <linux/uuid.h>
S
Stefan Behrens 已提交
32
#include <linux/semaphore.h>
33
#include <asm/unaligned.h>
34 35
#include "ctree.h"
#include "disk-io.h"
36
#include "hash.h"
37
#include "transaction.h"
38
#include "btrfs_inode.h"
39
#include "volumes.h"
40
#include "print-tree.h"
41
#include "locking.h"
42
#include "tree-log.h"
43
#include "free-space-cache.h"
44
#include "free-space-tree.h"
45
#include "inode-map.h"
46
#include "check-integrity.h"
47
#include "rcu-string.h"
48
#include "dev-replace.h"
D
David Woodhouse 已提交
49
#include "raid56.h"
50
#include "sysfs.h"
J
Josef Bacik 已提交
51
#include "qgroup.h"
52
#include "compression.h"
53
#include "tree-checker.h"
J
Josef Bacik 已提交
54
#include "ref-verify.h"
55

56 57 58 59
#ifdef CONFIG_X86
#include <asm/cpufeature.h>
#endif

60 61 62 63 64 65
#define BTRFS_SUPER_FLAG_SUPP	(BTRFS_HEADER_FLAG_WRITTEN |\
				 BTRFS_HEADER_FLAG_RELOC |\
				 BTRFS_SUPER_FLAG_ERROR |\
				 BTRFS_SUPER_FLAG_SEEDING |\
				 BTRFS_SUPER_FLAG_METADUMP)

66
static const struct extent_io_ops btree_extent_io_ops;
67
static void end_workqueue_fn(struct btrfs_work *work);
68
static void free_fs_root(struct btrfs_root *root);
69
static int btrfs_check_super_valid(struct btrfs_fs_info *fs_info);
70
static void btrfs_destroy_ordered_extents(struct btrfs_root *root);
L
liubo 已提交
71
static int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans,
72
				      struct btrfs_fs_info *fs_info);
73
static void btrfs_destroy_delalloc_inodes(struct btrfs_root *root);
74
static int btrfs_destroy_marked_extents(struct btrfs_fs_info *fs_info,
L
liubo 已提交
75 76
					struct extent_io_tree *dirty_pages,
					int mark);
77
static int btrfs_destroy_pinned_extent(struct btrfs_fs_info *fs_info,
L
liubo 已提交
78
				       struct extent_io_tree *pinned_extents);
79 80
static int btrfs_cleanup_transaction(struct btrfs_fs_info *fs_info);
static void btrfs_error_commit_super(struct btrfs_fs_info *fs_info);
81

C
Chris Mason 已提交
82
/*
83 84
 * btrfs_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
C
Chris Mason 已提交
85 86
 * by writes to insert metadata for new file extents after IO is complete.
 */
87
struct btrfs_end_io_wq {
88 89 90 91
	struct bio *bio;
	bio_end_io_t *end_io;
	void *private;
	struct btrfs_fs_info *info;
92
	blk_status_t status;
93
	enum btrfs_wq_endio_type metadata;
94
	struct btrfs_work work;
95
};
96

97 98 99 100 101 102 103
static struct kmem_cache *btrfs_end_io_wq_cache;

int __init btrfs_end_io_wq_init(void)
{
	btrfs_end_io_wq_cache = kmem_cache_create("btrfs_end_io_wq",
					sizeof(struct btrfs_end_io_wq),
					0,
104
					SLAB_MEM_SPREAD,
105 106 107 108 109 110 111 112
					NULL);
	if (!btrfs_end_io_wq_cache)
		return -ENOMEM;
	return 0;
}

void btrfs_end_io_wq_exit(void)
{
113
	kmem_cache_destroy(btrfs_end_io_wq_cache);
114 115
}

C
Chris Mason 已提交
116 117 118 119 120
/*
 * 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.
 */
121
struct async_submit_bio {
122 123
	void *private_data;
	struct btrfs_fs_info *fs_info;
124
	struct bio *bio;
C
Chris Mason 已提交
125 126
	extent_submit_bio_hook_t *submit_bio_start;
	extent_submit_bio_hook_t *submit_bio_done;
127
	int mirror_num;
C
Chris Mason 已提交
128
	unsigned long bio_flags;
129 130 131 132 133
	/*
	 * 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;
134
	struct btrfs_work work;
135
	blk_status_t status;
136 137
};

138 139 140 141 142 143 144 145 146 147
/*
 * 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.
148
 *
149 150 151
 * 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.
152
 *
153 154 155
 * 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.
156
 *
157 158 159
 * 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.
160 161 162 163 164
 */
#ifdef CONFIG_DEBUG_LOCK_ALLOC
# if BTRFS_MAX_LEVEL != 8
#  error
# endif
165 166 167 168 169 170 171 172 173 174 175 176 177

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"	},
178
	{ .id = BTRFS_QUOTA_TREE_OBJECTID,	.name_stem = "quota"	},
179 180 181
	{ .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"	},
182
	{ .id = BTRFS_UUID_TREE_OBJECTID,	.name_stem = "uuid"	},
183
	{ .id = BTRFS_FREE_SPACE_TREE_OBJECTID,	.name_stem = "free-space" },
184
	{ .id = 0,				.name_stem = "tree"	},
185
};
186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216

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

217 218
#endif

C
Chris Mason 已提交
219 220 221 222
/*
 * extents on the btree inode are pretty simple, there's one extent
 * that covers the entire device
 */
223
struct extent_map *btree_get_extent(struct btrfs_inode *inode,
224
		struct page *page, size_t pg_offset, u64 start, u64 len,
225
		int create)
226
{
227 228
	struct btrfs_fs_info *fs_info = btrfs_sb(inode->vfs_inode.i_sb);
	struct extent_map_tree *em_tree = &inode->extent_tree;
229 230 231
	struct extent_map *em;
	int ret;

232
	read_lock(&em_tree->lock);
233
	em = lookup_extent_mapping(em_tree, start, len);
234
	if (em) {
235
		em->bdev = fs_info->fs_devices->latest_bdev;
236
		read_unlock(&em_tree->lock);
237
		goto out;
238
	}
239
	read_unlock(&em_tree->lock);
240

241
	em = alloc_extent_map();
242 243 244 245 246
	if (!em) {
		em = ERR_PTR(-ENOMEM);
		goto out;
	}
	em->start = 0;
247
	em->len = (u64)-1;
C
Chris Mason 已提交
248
	em->block_len = (u64)-1;
249
	em->block_start = 0;
250
	em->bdev = fs_info->fs_devices->latest_bdev;
251

252
	write_lock(&em_tree->lock);
J
Josef Bacik 已提交
253
	ret = add_extent_mapping(em_tree, em, 0);
254 255
	if (ret == -EEXIST) {
		free_extent_map(em);
256
		em = lookup_extent_mapping(em_tree, start, len);
257
		if (!em)
258
			em = ERR_PTR(-EIO);
259
	} else if (ret) {
260
		free_extent_map(em);
261
		em = ERR_PTR(ret);
262
	}
263
	write_unlock(&em_tree->lock);
264

265 266
out:
	return em;
267 268
}

269
u32 btrfs_csum_data(const char *data, u32 seed, size_t len)
270
{
271
	return btrfs_crc32c(seed, data, len);
272 273
}

274
void btrfs_csum_final(u32 crc, u8 *result)
275
{
276
	put_unaligned_le32(~crc, result);
277 278
}

C
Chris Mason 已提交
279 280 281 282
/*
 * compute the csum for a btree block, and either verify it or write it
 * into the csum field of the block.
 */
283 284
static int csum_tree_block(struct btrfs_fs_info *fs_info,
			   struct extent_buffer *buf,
285 286
			   int verify)
{
287
	u16 csum_size = btrfs_super_csum_size(fs_info->super_copy);
288
	char result[BTRFS_CSUM_SIZE];
289 290 291 292 293 294 295 296 297 298
	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;

	len = buf->len - offset;
C
Chris Mason 已提交
299
	while (len > 0) {
300
		err = map_private_extent_buffer(buf, offset, 32,
301
					&kaddr, &map_start, &map_len);
C
Chris Mason 已提交
302
		if (err)
303
			return err;
304
		cur_len = min(len, map_len - (offset - map_start));
305
		crc = btrfs_csum_data(kaddr + offset - map_start,
306 307 308 309
				      crc, cur_len);
		len -= cur_len;
		offset += cur_len;
	}
310
	memset(result, 0, BTRFS_CSUM_SIZE);
311

312 313 314
	btrfs_csum_final(crc, result);

	if (verify) {
315
		if (memcmp_extent_buffer(buf, result, 0, csum_size)) {
316 317
			u32 val;
			u32 found = 0;
318
			memcpy(&found, result, csum_size);
319

320
			read_extent_buffer(buf, &val, 0, csum_size);
321
			btrfs_warn_rl(fs_info,
J
Jeff Mahoney 已提交
322
				"%s checksum verify failed on %llu wanted %X found %X level %d",
323
				fs_info->sb->s_id, buf->start,
324
				val, found, btrfs_header_level(buf));
325
			return -EUCLEAN;
326 327
		}
	} else {
328
		write_extent_buffer(buf, result, 0, csum_size);
329
	}
330

331 332 333
	return 0;
}

C
Chris Mason 已提交
334 335 336 337 338 339
/*
 * 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.
 */
340
static int verify_parent_transid(struct extent_io_tree *io_tree,
341 342
				 struct extent_buffer *eb, u64 parent_transid,
				 int atomic)
343
{
344
	struct extent_state *cached_state = NULL;
345
	int ret;
346
	bool need_lock = (current->journal_info == BTRFS_SEND_TRANS_STUB);
347 348 349 350

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

351 352 353
	if (atomic)
		return -EAGAIN;

354 355 356 357 358
	if (need_lock) {
		btrfs_tree_read_lock(eb);
		btrfs_set_lock_blocking_rw(eb, BTRFS_READ_LOCK);
	}

359
	lock_extent_bits(io_tree, eb->start, eb->start + eb->len - 1,
360
			 &cached_state);
361
	if (extent_buffer_uptodate(eb) &&
362 363 364 365
	    btrfs_header_generation(eb) == parent_transid) {
		ret = 0;
		goto out;
	}
366 367 368
	btrfs_err_rl(eb->fs_info,
		"parent transid verify failed on %llu wanted %llu found %llu",
			eb->start,
369
			parent_transid, btrfs_header_generation(eb));
370
	ret = 1;
371 372 373 374

	/*
	 * Things reading via commit roots that don't have normal protection,
	 * like send, can have a really old block in cache that may point at a
375
	 * block that has been freed and re-allocated.  So don't clear uptodate
376 377 378 379 380 381
	 * if we find an eb that is under IO (dirty/writeback) because we could
	 * end up reading in the stale data and then writing it back out and
	 * making everybody very sad.
	 */
	if (!extent_buffer_under_io(eb))
		clear_extent_buffer_uptodate(eb);
C
Chris Mason 已提交
382
out:
383
	unlock_extent_cached(io_tree, eb->start, eb->start + eb->len - 1,
384
			     &cached_state);
385 386
	if (need_lock)
		btrfs_tree_read_unlock_blocking(eb);
387 388 389
	return ret;
}

D
David Sterba 已提交
390 391 392 393
/*
 * Return 0 if the superblock checksum type matches the checksum value of that
 * algorithm. Pass the raw disk superblock data.
 */
394 395
static int btrfs_check_super_csum(struct btrfs_fs_info *fs_info,
				  char *raw_disk_sb)
D
David Sterba 已提交
396 397 398 399 400 401 402 403 404 405 406 407 408 409
{
	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
410
		 * is filled with zeros and is included in the checksum.
D
David Sterba 已提交
411 412 413 414 415 416 417 418 419 420
		 */
		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;
	}

	if (csum_type >= ARRAY_SIZE(btrfs_csum_sizes)) {
421
		btrfs_err(fs_info, "unsupported checksum algorithm %u",
D
David Sterba 已提交
422 423 424 425 426 427 428
				csum_type);
		ret = 1;
	}

	return ret;
}

C
Chris Mason 已提交
429 430 431 432
/*
 * helper to read a given tree block, doing retries as required when
 * the checksums don't match and we have alternate mirrors to try.
 */
433
static int btree_read_extent_buffer_pages(struct btrfs_fs_info *fs_info,
434
					  struct extent_buffer *eb,
435
					  u64 parent_transid)
436 437
{
	struct extent_io_tree *io_tree;
438
	int failed = 0;
439 440 441
	int ret;
	int num_copies = 0;
	int mirror_num = 0;
442
	int failed_mirror = 0;
443

444
	clear_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags);
445
	io_tree = &BTRFS_I(fs_info->btree_inode)->io_tree;
446
	while (1) {
447
		ret = read_extent_buffer_pages(io_tree, eb, WAIT_COMPLETE,
448
					       mirror_num);
449 450
		if (!ret) {
			if (!verify_parent_transid(io_tree, eb,
451
						   parent_transid, 0))
452 453 454 455
				break;
			else
				ret = -EIO;
		}
C
Chris Mason 已提交
456

457 458 459 460 461 462
		/*
		 * 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))
463 464
			break;

465
		num_copies = btrfs_num_copies(fs_info,
466
					      eb->start, eb->len);
C
Chris Mason 已提交
467
		if (num_copies == 1)
468
			break;
C
Chris Mason 已提交
469

470 471 472 473 474
		if (!failed_mirror) {
			failed = 1;
			failed_mirror = eb->read_mirror;
		}

475
		mirror_num++;
476 477 478
		if (mirror_num == failed_mirror)
			mirror_num++;

C
Chris Mason 已提交
479
		if (mirror_num > num_copies)
480
			break;
481
	}
482

483
	if (failed && !ret && failed_mirror)
484
		repair_eb_io_failure(fs_info, eb, failed_mirror);
485 486

	return ret;
487
}
488

C
Chris Mason 已提交
489
/*
C
Chris Mason 已提交
490 491
 * 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 已提交
492
 */
C
Chris Mason 已提交
493

494
static int csum_dirty_buffer(struct btrfs_fs_info *fs_info, struct page *page)
495
{
M
Miao Xie 已提交
496
	u64 start = page_offset(page);
497 498
	u64 found_start;
	struct extent_buffer *eb;
499

J
Josef Bacik 已提交
500 501 502
	eb = (struct extent_buffer *)page->private;
	if (page != eb->pages[0])
		return 0;
503

504
	found_start = btrfs_header_bytenr(eb);
505 506 507 508 509 510 511 512 513 514 515 516
	/*
	 * Please do not consolidate these warnings into a single if.
	 * It is useful to know what went wrong.
	 */
	if (WARN_ON(found_start != start))
		return -EUCLEAN;
	if (WARN_ON(!PageUptodate(page)))
		return -EUCLEAN;

	ASSERT(memcmp_extent_buffer(eb, fs_info->fsid,
			btrfs_header_fsid(), BTRFS_FSID_SIZE) == 0);

517
	return csum_tree_block(fs_info, eb, 0);
518 519
}

520
static int check_tree_block_fsid(struct btrfs_fs_info *fs_info,
Y
Yan Zheng 已提交
521 522
				 struct extent_buffer *eb)
{
523
	struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
524
	u8 fsid[BTRFS_FSID_SIZE];
Y
Yan Zheng 已提交
525 526
	int ret = 1;

527
	read_extent_buffer(eb, fsid, btrfs_header_fsid(), BTRFS_FSID_SIZE);
Y
Yan Zheng 已提交
528 529 530 531 532 533 534 535 536 537
	while (fs_devices) {
		if (!memcmp(fsid, fs_devices->fsid, BTRFS_FSID_SIZE)) {
			ret = 0;
			break;
		}
		fs_devices = fs_devices->seed;
	}
	return ret;
}

538 539 540
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)
541 542 543 544 545
{
	u64 found_start;
	int found_level;
	struct extent_buffer *eb;
	struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
546
	struct btrfs_fs_info *fs_info = root->fs_info;
547
	int ret = 0;
548
	int reads_done;
549 550 551

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

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

555 556 557 558 559 560
	/* 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);
561 562
	if (!reads_done)
		goto err;
563

564
	eb->read_mirror = mirror;
565
	if (test_bit(EXTENT_BUFFER_READ_ERR, &eb->bflags)) {
566 567 568 569
		ret = -EIO;
		goto err;
	}

570
	found_start = btrfs_header_bytenr(eb);
571
	if (found_start != eb->start) {
572 573
		btrfs_err_rl(fs_info, "bad tree block start %llu %llu",
			     found_start, eb->start);
574
		ret = -EIO;
575 576
		goto err;
	}
577 578 579
	if (check_tree_block_fsid(fs_info, eb)) {
		btrfs_err_rl(fs_info, "bad fsid on block %llu",
			     eb->start);
580 581 582
		ret = -EIO;
		goto err;
	}
583
	found_level = btrfs_header_level(eb);
584
	if (found_level >= BTRFS_MAX_LEVEL) {
585 586
		btrfs_err(fs_info, "bad tree block level %d",
			  (int)btrfs_header_level(eb));
587 588 589
		ret = -EIO;
		goto err;
	}
590

591 592
	btrfs_set_buffer_lockdep_class(btrfs_header_owner(eb),
				       eb, found_level);
593

594
	ret = csum_tree_block(fs_info, eb, 1);
595
	if (ret)
596 597 598 599 600 601 602
		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.
	 */
603
	if (found_level == 0 && btrfs_check_leaf_full(root, eb)) {
604 605 606
		set_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags);
		ret = -EIO;
	}
607

608
	if (found_level > 0 && btrfs_check_node(root, eb))
L
Liu Bo 已提交
609 610
		ret = -EIO;

611 612
	if (!ret)
		set_extent_buffer_uptodate(eb);
613
err:
614 615
	if (reads_done &&
	    test_and_clear_bit(EXTENT_BUFFER_READAHEAD, &eb->bflags))
616
		btree_readahead_hook(eb, ret);
A
Arne Jansen 已提交
617

D
David Woodhouse 已提交
618 619 620 621 622 623 624
	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);
625
		clear_extent_buffer_uptodate(eb);
D
David Woodhouse 已提交
626
	}
627
	free_extent_buffer(eb);
628
out:
629
	return ret;
630 631
}

632
static int btree_io_failed_hook(struct page *page, int failed_mirror)
A
Arne Jansen 已提交
633 634 635
{
	struct extent_buffer *eb;

J
Josef Bacik 已提交
636
	eb = (struct extent_buffer *)page->private;
637
	set_bit(EXTENT_BUFFER_READ_ERR, &eb->bflags);
638
	eb->read_mirror = failed_mirror;
D
David Woodhouse 已提交
639
	atomic_dec(&eb->io_pages);
640
	if (test_and_clear_bit(EXTENT_BUFFER_READAHEAD, &eb->bflags))
641
		btree_readahead_hook(eb, -EIO);
A
Arne Jansen 已提交
642 643 644
	return -EIO;	/* we fixed nothing */
}

645
static void end_workqueue_bio(struct bio *bio)
646
{
647
	struct btrfs_end_io_wq *end_io_wq = bio->bi_private;
648
	struct btrfs_fs_info *fs_info;
649 650
	struct btrfs_workqueue *wq;
	btrfs_work_func_t func;
651 652

	fs_info = end_io_wq->info;
653
	end_io_wq->status = bio->bi_status;
654

M
Mike Christie 已提交
655
	if (bio_op(bio) == REQ_OP_WRITE) {
656 657 658 659 660 661 662 663 664 665 666 667 668
		if (end_io_wq->metadata == BTRFS_WQ_ENDIO_METADATA) {
			wq = fs_info->endio_meta_write_workers;
			func = btrfs_endio_meta_write_helper;
		} else if (end_io_wq->metadata == BTRFS_WQ_ENDIO_FREE_SPACE) {
			wq = fs_info->endio_freespace_worker;
			func = btrfs_freespace_write_helper;
		} else if (end_io_wq->metadata == BTRFS_WQ_ENDIO_RAID56) {
			wq = fs_info->endio_raid56_workers;
			func = btrfs_endio_raid56_helper;
		} else {
			wq = fs_info->endio_write_workers;
			func = btrfs_endio_write_helper;
		}
669
	} else {
670 671 672 673 674
		if (unlikely(end_io_wq->metadata ==
			     BTRFS_WQ_ENDIO_DIO_REPAIR)) {
			wq = fs_info->endio_repair_workers;
			func = btrfs_endio_repair_helper;
		} else if (end_io_wq->metadata == BTRFS_WQ_ENDIO_RAID56) {
675 676 677 678 679 680 681 682 683
			wq = fs_info->endio_raid56_workers;
			func = btrfs_endio_raid56_helper;
		} else if (end_io_wq->metadata) {
			wq = fs_info->endio_meta_workers;
			func = btrfs_endio_meta_helper;
		} else {
			wq = fs_info->endio_workers;
			func = btrfs_endio_helper;
		}
684
	}
685 686 687

	btrfs_init_work(&end_io_wq->work, func, end_workqueue_fn, NULL, NULL);
	btrfs_queue_work(wq, &end_io_wq->work);
688 689
}

690
blk_status_t btrfs_bio_wq_end_io(struct btrfs_fs_info *info, struct bio *bio,
691
			enum btrfs_wq_endio_type metadata)
692
{
693
	struct btrfs_end_io_wq *end_io_wq;
694

695
	end_io_wq = kmem_cache_alloc(btrfs_end_io_wq_cache, GFP_NOFS);
696
	if (!end_io_wq)
697
		return BLK_STS_RESOURCE;
698 699 700

	end_io_wq->private = bio->bi_private;
	end_io_wq->end_io = bio->bi_end_io;
701
	end_io_wq->info = info;
702
	end_io_wq->status = 0;
703
	end_io_wq->bio = bio;
704
	end_io_wq->metadata = metadata;
705 706 707

	bio->bi_private = end_io_wq;
	bio->bi_end_io = end_workqueue_bio;
708 709 710
	return 0;
}

711
unsigned long btrfs_async_submit_limit(struct btrfs_fs_info *info)
712
{
713
	unsigned long limit = min_t(unsigned long,
714
				    info->thread_pool_size,
715 716 717
				    info->fs_devices->open_devices);
	return 256 * limit;
}
718

C
Chris Mason 已提交
719 720 721
static void run_one_async_start(struct btrfs_work *work)
{
	struct async_submit_bio *async;
722
	blk_status_t ret;
C
Chris Mason 已提交
723 724

	async = container_of(work, struct  async_submit_bio, work);
725
	ret = async->submit_bio_start(async->private_data, async->bio,
726 727 728
				      async->mirror_num, async->bio_flags,
				      async->bio_offset);
	if (ret)
729
		async->status = ret;
C
Chris Mason 已提交
730 731 732
}

static void run_one_async_done(struct btrfs_work *work)
733 734 735 736
{
	struct async_submit_bio *async;

	async = container_of(work, struct  async_submit_bio, work);
737

738
	/* If an error occurred we just want to clean up the bio and move on */
739 740
	if (async->status) {
		async->bio->bi_status = async->status;
741
		bio_endio(async->bio);
742 743 744
		return;
	}

745
	async->submit_bio_done(async->private_data, async->bio, async->mirror_num,
746
			       async->bio_flags, async->bio_offset);
C
Chris Mason 已提交
747 748 749 750 751 752 753
}

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

	async = container_of(work, struct  async_submit_bio, work);
754 755 756
	kfree(async);
}

757 758 759 760 761
blk_status_t btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info, struct bio *bio,
				 int mirror_num, unsigned long bio_flags,
				 u64 bio_offset, void *private_data,
				 extent_submit_bio_hook_t *submit_bio_start,
				 extent_submit_bio_hook_t *submit_bio_done)
762 763 764 765 766
{
	struct async_submit_bio *async;

	async = kmalloc(sizeof(*async), GFP_NOFS);
	if (!async)
767
		return BLK_STS_RESOURCE;
768

769 770
	async->private_data = private_data;
	async->fs_info = fs_info;
771 772
	async->bio = bio;
	async->mirror_num = mirror_num;
C
Chris Mason 已提交
773 774 775
	async->submit_bio_start = submit_bio_start;
	async->submit_bio_done = submit_bio_done;

776
	btrfs_init_work(&async->work, btrfs_worker_helper, run_one_async_start,
777
			run_one_async_done, run_one_async_free);
C
Chris Mason 已提交
778

C
Chris Mason 已提交
779
	async->bio_flags = bio_flags;
780
	async->bio_offset = bio_offset;
781

782
	async->status = 0;
783

784
	if (op_is_sync(bio->bi_opf))
785
		btrfs_set_work_high_priority(&async->work);
786

787
	btrfs_queue_work(fs_info->workers, &async->work);
788 789 790
	return 0;
}

791
static blk_status_t btree_csum_one_bio(struct bio *bio)
792
{
793
	struct bio_vec *bvec;
794
	struct btrfs_root *root;
795
	int i, ret = 0;
796

797
	ASSERT(!bio_flagged(bio, BIO_CLONED));
798
	bio_for_each_segment_all(bvec, bio, i) {
799
		root = BTRFS_I(bvec->bv_page->mapping->host)->root;
800
		ret = csum_dirty_buffer(root->fs_info, bvec->bv_page);
801 802
		if (ret)
			break;
803
	}
804

805
	return errno_to_blk_status(ret);
806 807
}

808 809 810
static blk_status_t __btree_submit_bio_start(void *private_data, struct bio *bio,
					     int mirror_num, unsigned long bio_flags,
					     u64 bio_offset)
811
{
812 813
	/*
	 * when we're called for a write, we're already in the async
814
	 * submission context.  Just jump into btrfs_map_bio
815
	 */
816
	return btree_csum_one_bio(bio);
C
Chris Mason 已提交
817
}
818

819 820 821
static blk_status_t __btree_submit_bio_done(void *private_data, struct bio *bio,
					    int mirror_num, unsigned long bio_flags,
					    u64 bio_offset)
C
Chris Mason 已提交
822
{
823
	struct inode *inode = private_data;
824
	blk_status_t ret;
825

826
	/*
C
Chris Mason 已提交
827 828
	 * when we're called for a write, we're already in the async
	 * submission context.  Just jump into btrfs_map_bio
829
	 */
830
	ret = btrfs_map_bio(btrfs_sb(inode->i_sb), bio, mirror_num, 1);
831
	if (ret) {
832
		bio->bi_status = ret;
833 834
		bio_endio(bio);
	}
835
	return ret;
836 837
}

838
static int check_async_write(struct btrfs_inode *bi)
839
{
840 841
	if (atomic_read(&bi->sync_writers))
		return 0;
842
#ifdef CONFIG_X86
843
	if (static_cpu_has(X86_FEATURE_XMM4_2))
844 845 846 847 848
		return 0;
#endif
	return 1;
}

849 850 851
static blk_status_t btree_submit_bio_hook(void *private_data, struct bio *bio,
					  int mirror_num, unsigned long bio_flags,
					  u64 bio_offset)
852
{
853
	struct inode *inode = private_data;
854
	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
855
	int async = check_async_write(BTRFS_I(inode));
856
	blk_status_t ret;
857

M
Mike Christie 已提交
858
	if (bio_op(bio) != REQ_OP_WRITE) {
C
Chris Mason 已提交
859 860 861 862
		/*
		 * called for a read, do the setup so that checksum validation
		 * can happen in the async kernel threads
		 */
863 864
		ret = btrfs_bio_wq_end_io(fs_info, bio,
					  BTRFS_WQ_ENDIO_METADATA);
865
		if (ret)
866
			goto out_w_error;
867
		ret = btrfs_map_bio(fs_info, bio, mirror_num, 0);
868 869 870
	} else if (!async) {
		ret = btree_csum_one_bio(bio);
		if (ret)
871
			goto out_w_error;
872
		ret = btrfs_map_bio(fs_info, bio, mirror_num, 0);
873 874 875 876 877
	} else {
		/*
		 * kthread helpers are used to submit writes so that
		 * checksumming can happen in parallel across all CPUs
		 */
878 879
		ret = btrfs_wq_submit_bio(fs_info, bio, mirror_num, 0,
					  bio_offset, private_data,
880 881
					  __btree_submit_bio_start,
					  __btree_submit_bio_done);
882
	}
883

884 885 886 887
	if (ret)
		goto out_w_error;
	return 0;

888
out_w_error:
889
	bio->bi_status = ret;
890
	bio_endio(bio);
891
	return ret;
892 893
}

J
Jan Beulich 已提交
894
#ifdef CONFIG_MIGRATION
895
static int btree_migratepage(struct address_space *mapping,
896 897
			struct page *newpage, struct page *page,
			enum migrate_mode mode)
898 899 900 901 902 903 904 905 906 907 908 909 910 911
{
	/*
	 * 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;
912
	return migrate_page(mapping, newpage, page, mode);
913
}
J
Jan Beulich 已提交
914
#endif
915

916 917 918 919

static int btree_writepages(struct address_space *mapping,
			    struct writeback_control *wbc)
{
920 921 922
	struct btrfs_fs_info *fs_info;
	int ret;

923
	if (wbc->sync_mode == WB_SYNC_NONE) {
924 925 926 927

		if (wbc->for_kupdate)
			return 0;

928
		fs_info = BTRFS_I(mapping->host)->root->fs_info;
929
		/* this is a bit racy, but that's ok */
930 931 932
		ret = percpu_counter_compare(&fs_info->dirty_metadata_bytes,
					     BTRFS_DIRTY_METADATA_THRESH);
		if (ret < 0)
933 934
			return 0;
	}
935
	return btree_write_cache_pages(mapping, wbc);
936 937
}

938
static int btree_readpage(struct file *file, struct page *page)
939
{
940 941
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
942
	return extent_read_full_page(tree, page, btree_get_extent, 0);
943
}
C
Chris Mason 已提交
944

945
static int btree_releasepage(struct page *page, gfp_t gfp_flags)
946
{
947
	if (PageWriteback(page) || PageDirty(page))
C
Chris Mason 已提交
948
		return 0;
949

950
	return try_release_extent_buffer(page);
951 952
}

953 954
static void btree_invalidatepage(struct page *page, unsigned int offset,
				 unsigned int length)
955
{
956 957
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
958 959
	extent_invalidatepage(tree, page, offset);
	btree_releasepage(page, GFP_NOFS);
960
	if (PagePrivate(page)) {
961 962 963
		btrfs_warn(BTRFS_I(page->mapping->host)->root->fs_info,
			   "page private not zero on page %llu",
			   (unsigned long long)page_offset(page));
964 965
		ClearPagePrivate(page);
		set_page_private(page, 0);
966
		put_page(page);
967
	}
968 969
}

970 971
static int btree_set_page_dirty(struct page *page)
{
972
#ifdef DEBUG
973 974 975 976 977 978 979 980
	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);
981
#endif
982 983 984
	return __set_page_dirty_nobuffers(page);
}

985
static const struct address_space_operations btree_aops = {
986
	.readpage	= btree_readpage,
987
	.writepages	= btree_writepages,
988 989
	.releasepage	= btree_releasepage,
	.invalidatepage = btree_invalidatepage,
990
#ifdef CONFIG_MIGRATION
991
	.migratepage	= btree_migratepage,
992
#endif
993
	.set_page_dirty = btree_set_page_dirty,
994 995
};

996
void readahead_tree_block(struct btrfs_fs_info *fs_info, u64 bytenr)
C
Chris Mason 已提交
997
{
998
	struct extent_buffer *buf = NULL;
999
	struct inode *btree_inode = fs_info->btree_inode;
C
Chris Mason 已提交
1000

1001
	buf = btrfs_find_create_tree_block(fs_info, bytenr);
1002
	if (IS_ERR(buf))
1003
		return;
1004
	read_extent_buffer_pages(&BTRFS_I(btree_inode)->io_tree,
1005
				 buf, WAIT_NONE, 0);
1006
	free_extent_buffer(buf);
C
Chris Mason 已提交
1007 1008
}

1009
int reada_tree_block_flagged(struct btrfs_fs_info *fs_info, u64 bytenr,
1010 1011 1012
			 int mirror_num, struct extent_buffer **eb)
{
	struct extent_buffer *buf = NULL;
1013
	struct inode *btree_inode = fs_info->btree_inode;
1014 1015 1016
	struct extent_io_tree *io_tree = &BTRFS_I(btree_inode)->io_tree;
	int ret;

1017
	buf = btrfs_find_create_tree_block(fs_info, bytenr);
1018
	if (IS_ERR(buf))
1019 1020 1021 1022
		return 0;

	set_bit(EXTENT_BUFFER_READAHEAD, &buf->bflags);

1023
	ret = read_extent_buffer_pages(io_tree, buf, WAIT_PAGE_LOCK,
1024
				       mirror_num);
1025 1026 1027 1028 1029 1030 1031 1032
	if (ret) {
		free_extent_buffer(buf);
		return ret;
	}

	if (test_bit(EXTENT_BUFFER_CORRUPT, &buf->bflags)) {
		free_extent_buffer(buf);
		return -EIO;
1033
	} else if (extent_buffer_uptodate(buf)) {
1034 1035 1036 1037 1038 1039 1040
		*eb = buf;
	} else {
		free_extent_buffer(buf);
	}
	return 0;
}

1041 1042 1043
struct extent_buffer *btrfs_find_create_tree_block(
						struct btrfs_fs_info *fs_info,
						u64 bytenr)
1044
{
1045 1046 1047
	if (btrfs_is_testing(fs_info))
		return alloc_test_extent_buffer(fs_info, bytenr);
	return alloc_extent_buffer(fs_info, bytenr);
1048 1049 1050
}


1051 1052
int btrfs_write_tree_block(struct extent_buffer *buf)
{
1053
	return filemap_fdatawrite_range(buf->pages[0]->mapping, buf->start,
1054
					buf->start + buf->len - 1);
1055 1056
}

1057
void btrfs_wait_tree_block_writeback(struct extent_buffer *buf)
1058
{
1059 1060
	filemap_fdatawait_range(buf->pages[0]->mapping,
			        buf->start, buf->start + buf->len - 1);
1061 1062
}

1063
struct extent_buffer *read_tree_block(struct btrfs_fs_info *fs_info, u64 bytenr,
1064
				      u64 parent_transid)
1065 1066 1067 1068
{
	struct extent_buffer *buf = NULL;
	int ret;

1069
	buf = btrfs_find_create_tree_block(fs_info, bytenr);
1070 1071
	if (IS_ERR(buf))
		return buf;
1072

1073
	ret = btree_read_extent_buffer_pages(fs_info, buf, parent_transid);
1074 1075
	if (ret) {
		free_extent_buffer(buf);
1076
		return ERR_PTR(ret);
1077
	}
1078
	return buf;
1079

1080 1081
}

1082
void clean_tree_block(struct btrfs_fs_info *fs_info,
1083
		      struct extent_buffer *buf)
1084
{
1085
	if (btrfs_header_generation(buf) ==
1086
	    fs_info->running_transaction->transid) {
1087
		btrfs_assert_tree_locked(buf);
1088

1089
		if (test_and_clear_bit(EXTENT_BUFFER_DIRTY, &buf->bflags)) {
1090 1091 1092
			percpu_counter_add_batch(&fs_info->dirty_metadata_bytes,
						 -buf->len,
						 fs_info->dirty_metadata_batch);
1093 1094 1095 1096
			/* ugh, clear_extent_buffer_dirty needs to lock the page */
			btrfs_set_lock_blocking(buf);
			clear_extent_buffer_dirty(buf);
		}
1097
	}
1098 1099
}

1100 1101 1102 1103 1104 1105 1106 1107 1108
static struct btrfs_subvolume_writers *btrfs_alloc_subvolume_writers(void)
{
	struct btrfs_subvolume_writers *writers;
	int ret;

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

1109
	ret = percpu_counter_init(&writers->counter, 0, GFP_KERNEL);
1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125
	if (ret < 0) {
		kfree(writers);
		return ERR_PTR(ret);
	}

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

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

1126
static void __setup_root(struct btrfs_root *root, struct btrfs_fs_info *fs_info,
1127
			 u64 objectid)
1128
{
1129
	bool dummy = test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &fs_info->fs_state);
C
Chris Mason 已提交
1130
	root->node = NULL;
1131
	root->commit_root = NULL;
1132
	root->state = 0;
1133
	root->orphan_cleanup_state = 0;
1134

1135 1136
	root->objectid = objectid;
	root->last_trans = 0;
1137
	root->highest_objectid = 0;
1138
	root->nr_delalloc_inodes = 0;
1139
	root->nr_ordered_extents = 0;
1140
	root->name = NULL;
1141
	root->inode_tree = RB_ROOT;
1142
	INIT_RADIX_TREE(&root->delayed_nodes_tree, GFP_ATOMIC);
1143
	root->block_rsv = NULL;
1144
	root->orphan_block_rsv = NULL;
1145 1146

	INIT_LIST_HEAD(&root->dirty_list);
1147
	INIT_LIST_HEAD(&root->root_list);
1148 1149
	INIT_LIST_HEAD(&root->delalloc_inodes);
	INIT_LIST_HEAD(&root->delalloc_root);
1150 1151
	INIT_LIST_HEAD(&root->ordered_extents);
	INIT_LIST_HEAD(&root->ordered_root);
1152 1153
	INIT_LIST_HEAD(&root->logged_list[0]);
	INIT_LIST_HEAD(&root->logged_list[1]);
1154
	spin_lock_init(&root->orphan_lock);
1155
	spin_lock_init(&root->inode_lock);
1156
	spin_lock_init(&root->delalloc_lock);
1157
	spin_lock_init(&root->ordered_extent_lock);
1158
	spin_lock_init(&root->accounting_lock);
1159 1160
	spin_lock_init(&root->log_extents_lock[0]);
	spin_lock_init(&root->log_extents_lock[1]);
1161
	mutex_init(&root->objectid_mutex);
1162
	mutex_init(&root->log_mutex);
1163
	mutex_init(&root->ordered_extent_mutex);
1164
	mutex_init(&root->delalloc_mutex);
Y
Yan Zheng 已提交
1165 1166 1167
	init_waitqueue_head(&root->log_writer_wait);
	init_waitqueue_head(&root->log_commit_wait[0]);
	init_waitqueue_head(&root->log_commit_wait[1]);
1168 1169
	INIT_LIST_HEAD(&root->log_ctxs[0]);
	INIT_LIST_HEAD(&root->log_ctxs[1]);
Y
Yan Zheng 已提交
1170 1171 1172
	atomic_set(&root->log_commit[0], 0);
	atomic_set(&root->log_commit[1], 0);
	atomic_set(&root->log_writers, 0);
M
Miao Xie 已提交
1173
	atomic_set(&root->log_batch, 0);
1174
	atomic_set(&root->orphan_inodes, 0);
1175
	refcount_set(&root->refs, 1);
1176
	atomic_set(&root->will_be_snapshotted, 0);
1177
	atomic64_set(&root->qgroup_meta_rsv, 0);
Y
Yan Zheng 已提交
1178
	root->log_transid = 0;
1179
	root->log_transid_committed = -1;
1180
	root->last_log_commit = 0;
1181
	if (!dummy)
1182
		extent_io_tree_init(&root->dirty_log_pages, NULL);
C
Chris Mason 已提交
1183

1184 1185
	memset(&root->root_key, 0, sizeof(root->root_key));
	memset(&root->root_item, 0, sizeof(root->root_item));
1186
	memset(&root->defrag_progress, 0, sizeof(root->defrag_progress));
1187
	if (!dummy)
1188 1189 1190
		root->defrag_trans_start = fs_info->generation;
	else
		root->defrag_trans_start = 0;
1191
	root->root_key.objectid = objectid;
1192
	root->anon_dev = 0;
1193

1194
	spin_lock_init(&root->root_item_lock);
1195 1196
}

1197 1198
static struct btrfs_root *btrfs_alloc_root(struct btrfs_fs_info *fs_info,
		gfp_t flags)
A
Al Viro 已提交
1199
{
1200
	struct btrfs_root *root = kzalloc(sizeof(*root), flags);
A
Al Viro 已提交
1201 1202 1203 1204 1205
	if (root)
		root->fs_info = fs_info;
	return root;
}

1206 1207
#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
/* Should only be used by the testing infrastructure */
1208
struct btrfs_root *btrfs_alloc_dummy_root(struct btrfs_fs_info *fs_info)
1209 1210 1211
{
	struct btrfs_root *root;

1212 1213 1214 1215
	if (!fs_info)
		return ERR_PTR(-EINVAL);

	root = btrfs_alloc_root(fs_info, GFP_KERNEL);
1216 1217
	if (!root)
		return ERR_PTR(-ENOMEM);
1218

1219
	/* We don't use the stripesize in selftest, set it as sectorsize */
1220
	__setup_root(root, fs_info, BTRFS_ROOT_TREE_OBJECTID);
1221
	root->alloc_bytenr = 0;
1222 1223 1224 1225 1226

	return root;
}
#endif

1227 1228 1229 1230 1231 1232 1233 1234 1235
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;
1236
	uuid_le uuid = NULL_UUID_LE;
1237

1238
	root = btrfs_alloc_root(fs_info, GFP_KERNEL);
1239 1240 1241
	if (!root)
		return ERR_PTR(-ENOMEM);

1242
	__setup_root(root, fs_info, objectid);
1243 1244 1245 1246
	root->root_key.objectid = objectid;
	root->root_key.type = BTRFS_ROOT_ITEM_KEY;
	root->root_key.offset = 0;

1247
	leaf = btrfs_alloc_tree_block(trans, root, 0, objectid, NULL, 0, 0, 0);
1248 1249
	if (IS_ERR(leaf)) {
		ret = PTR_ERR(leaf);
1250
		leaf = NULL;
1251 1252 1253
		goto fail;
	}

1254
	memzero_extent_buffer(leaf, 0, sizeof(struct btrfs_header));
1255 1256 1257 1258 1259 1260
	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;

1261 1262
	write_extent_buffer_fsid(leaf, fs_info->fsid);
	write_extent_buffer_chunk_tree_uuid(leaf, fs_info->chunk_tree_uuid);
1263 1264 1265
	btrfs_mark_buffer_dirty(leaf);

	root->commit_root = btrfs_root_node(root);
1266
	set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
1267 1268 1269 1270 1271 1272 1273 1274 1275 1276

	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);
1277 1278
	if (is_fstree(objectid))
		uuid_le_gen(&uuid);
1279
	memcpy(root->root_item.uuid, uuid.b, BTRFS_UUID_SIZE);
1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290
	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);

1291 1292
	return root;

1293
fail:
1294 1295
	if (leaf) {
		btrfs_tree_unlock(leaf);
1296
		free_extent_buffer(root->commit_root);
1297 1298 1299
		free_extent_buffer(leaf);
	}
	kfree(root);
1300

1301
	return ERR_PTR(ret);
1302 1303
}

Y
Yan Zheng 已提交
1304 1305
static struct btrfs_root *alloc_log_tree(struct btrfs_trans_handle *trans,
					 struct btrfs_fs_info *fs_info)
1306 1307
{
	struct btrfs_root *root;
Y
Yan Zheng 已提交
1308
	struct extent_buffer *leaf;
1309

1310
	root = btrfs_alloc_root(fs_info, GFP_NOFS);
1311
	if (!root)
Y
Yan Zheng 已提交
1312
		return ERR_PTR(-ENOMEM);
1313

1314
	__setup_root(root, fs_info, BTRFS_TREE_LOG_OBJECTID);
1315 1316 1317 1318

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

Y
Yan Zheng 已提交
1320
	/*
1321 1322
	 * DON'T set REF_COWS for log trees
	 *
Y
Yan Zheng 已提交
1323 1324 1325 1326 1327
	 * 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).
	 */
1328

1329 1330
	leaf = btrfs_alloc_tree_block(trans, root, 0, BTRFS_TREE_LOG_OBJECTID,
			NULL, 0, 0, 0);
Y
Yan Zheng 已提交
1331 1332 1333 1334
	if (IS_ERR(leaf)) {
		kfree(root);
		return ERR_CAST(leaf);
	}
1335

1336
	memzero_extent_buffer(leaf, 0, sizeof(struct btrfs_header));
1337 1338 1339 1340
	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 已提交
1341
	root->node = leaf;
1342

1343
	write_extent_buffer_fsid(root->node, fs_info->fsid);
1344 1345
	btrfs_mark_buffer_dirty(root->node);
	btrfs_tree_unlock(root->node);
Y
Yan Zheng 已提交
1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364
	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)
{
1365
	struct btrfs_fs_info *fs_info = root->fs_info;
Y
Yan Zheng 已提交
1366 1367 1368
	struct btrfs_root *log_root;
	struct btrfs_inode_item *inode_item;

1369
	log_root = alloc_log_tree(trans, fs_info);
Y
Yan Zheng 已提交
1370 1371 1372 1373 1374 1375 1376
	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;
1377 1378 1379
	btrfs_set_stack_inode_generation(inode_item, 1);
	btrfs_set_stack_inode_size(inode_item, 3);
	btrfs_set_stack_inode_nlink(inode_item, 1);
1380
	btrfs_set_stack_inode_nbytes(inode_item,
1381
				     fs_info->nodesize);
1382
	btrfs_set_stack_inode_mode(inode_item, S_IFDIR | 0755);
Y
Yan Zheng 已提交
1383

1384
	btrfs_set_root_node(&log_root->root_item, log_root->node);
Y
Yan Zheng 已提交
1385 1386 1387 1388

	WARN_ON(root->log_root);
	root->log_root = log_root;
	root->log_transid = 0;
1389
	root->log_transid_committed = -1;
1390
	root->last_log_commit = 0;
1391 1392 1393
	return 0;
}

1394 1395
static struct btrfs_root *btrfs_read_tree_root(struct btrfs_root *tree_root,
					       struct btrfs_key *key)
1396 1397 1398
{
	struct btrfs_root *root;
	struct btrfs_fs_info *fs_info = tree_root->fs_info;
1399
	struct btrfs_path *path;
1400
	u64 generation;
1401
	int ret;
1402

1403 1404
	path = btrfs_alloc_path();
	if (!path)
1405
		return ERR_PTR(-ENOMEM);
1406

1407
	root = btrfs_alloc_root(fs_info, GFP_NOFS);
1408 1409 1410
	if (!root) {
		ret = -ENOMEM;
		goto alloc_fail;
1411 1412
	}

1413
	__setup_root(root, fs_info, key->objectid);
1414

1415 1416
	ret = btrfs_find_root(tree_root, key, path,
			      &root->root_item, &root->root_key);
1417
	if (ret) {
1418 1419
		if (ret > 0)
			ret = -ENOENT;
1420
		goto find_fail;
1421
	}
1422

1423
	generation = btrfs_root_generation(&root->root_item);
1424 1425
	root->node = read_tree_block(fs_info,
				     btrfs_root_bytenr(&root->root_item),
1426
				     generation);
1427 1428
	if (IS_ERR(root->node)) {
		ret = PTR_ERR(root->node);
1429 1430 1431
		goto find_fail;
	} else if (!btrfs_buffer_uptodate(root->node, generation, 0)) {
		ret = -EIO;
1432 1433
		free_extent_buffer(root->node);
		goto find_fail;
1434
	}
1435
	root->commit_root = btrfs_root_node(root);
1436
out:
1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456
	btrfs_free_path(path);
	return root;

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) {
1457
		set_bit(BTRFS_ROOT_REF_COWS, &root->state);
1458 1459
		btrfs_check_and_init_root_item(&root->root_item);
	}
1460

1461 1462 1463
	return root;
}

1464 1465 1466
int btrfs_init_fs_root(struct btrfs_root *root)
{
	int ret;
1467
	struct btrfs_subvolume_writers *writers;
1468 1469 1470 1471 1472 1473 1474 1475 1476

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

1477 1478 1479 1480 1481 1482 1483
	writers = btrfs_alloc_subvolume_writers();
	if (IS_ERR(writers)) {
		ret = PTR_ERR(writers);
		goto fail;
	}
	root->subv_writers = writers;

1484
	btrfs_init_free_ino_ctl(root);
1485 1486
	spin_lock_init(&root->ino_cache_lock);
	init_waitqueue_head(&root->ino_cache_wait);
1487 1488 1489

	ret = get_anon_bdev(&root->anon_dev);
	if (ret)
L
Liu Bo 已提交
1490
		goto fail;
1491 1492 1493 1494 1495 1496

	mutex_lock(&root->objectid_mutex);
	ret = btrfs_find_highest_objectid(root,
					&root->highest_objectid);
	if (ret) {
		mutex_unlock(&root->objectid_mutex);
L
Liu Bo 已提交
1497
		goto fail;
1498 1499 1500 1501 1502 1503
	}

	ASSERT(root->highest_objectid <= BTRFS_LAST_FREE_OBJECTID);

	mutex_unlock(&root->objectid_mutex);

1504 1505
	return 0;
fail:
L
Liu Bo 已提交
1506
	/* the caller is responsible to call free_fs_root */
1507 1508 1509
	return ret;
}

1510 1511
struct btrfs_root *btrfs_lookup_fs_root(struct btrfs_fs_info *fs_info,
					u64 root_id)
1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526
{
	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;

1527
	ret = radix_tree_preload(GFP_NOFS);
1528 1529 1530 1531 1532 1533 1534 1535
	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)
1536
		set_bit(BTRFS_ROOT_IN_RADIX, &root->state);
1537 1538 1539 1540 1541 1542
	spin_unlock(&fs_info->fs_roots_radix_lock);
	radix_tree_preload_end();

	return ret;
}

1543 1544 1545
struct btrfs_root *btrfs_get_fs_root(struct btrfs_fs_info *fs_info,
				     struct btrfs_key *location,
				     bool check_ref)
1546 1547
{
	struct btrfs_root *root;
1548
	struct btrfs_path *path;
1549
	struct btrfs_key key;
1550 1551
	int ret;

1552 1553 1554 1555
	if (location->objectid == BTRFS_ROOT_TREE_OBJECTID)
		return fs_info->tree_root;
	if (location->objectid == BTRFS_EXTENT_TREE_OBJECTID)
		return fs_info->extent_root;
1556 1557 1558 1559
	if (location->objectid == BTRFS_CHUNK_TREE_OBJECTID)
		return fs_info->chunk_root;
	if (location->objectid == BTRFS_DEV_TREE_OBJECTID)
		return fs_info->dev_root;
1560 1561
	if (location->objectid == BTRFS_CSUM_TREE_OBJECTID)
		return fs_info->csum_root;
1562 1563 1564
	if (location->objectid == BTRFS_QUOTA_TREE_OBJECTID)
		return fs_info->quota_root ? fs_info->quota_root :
					     ERR_PTR(-ENOENT);
1565 1566 1567
	if (location->objectid == BTRFS_UUID_TREE_OBJECTID)
		return fs_info->uuid_root ? fs_info->uuid_root :
					    ERR_PTR(-ENOENT);
1568 1569 1570
	if (location->objectid == BTRFS_FREE_SPACE_TREE_OBJECTID)
		return fs_info->free_space_root ? fs_info->free_space_root :
						  ERR_PTR(-ENOENT);
1571
again:
1572
	root = btrfs_lookup_fs_root(fs_info, location->objectid);
1573
	if (root) {
1574
		if (check_ref && btrfs_root_refs(&root->root_item) == 0)
1575
			return ERR_PTR(-ENOENT);
1576
		return root;
1577
	}
1578

1579
	root = btrfs_read_fs_root(fs_info->tree_root, location);
1580 1581
	if (IS_ERR(root))
		return root;
1582

1583
	if (check_ref && btrfs_root_refs(&root->root_item) == 0) {
1584
		ret = -ENOENT;
1585
		goto fail;
1586
	}
1587

1588
	ret = btrfs_init_fs_root(root);
1589 1590
	if (ret)
		goto fail;
1591

1592 1593 1594 1595 1596
	path = btrfs_alloc_path();
	if (!path) {
		ret = -ENOMEM;
		goto fail;
	}
1597 1598 1599 1600 1601
	key.objectid = BTRFS_ORPHAN_OBJECTID;
	key.type = BTRFS_ORPHAN_ITEM_KEY;
	key.offset = location->objectid;

	ret = btrfs_search_slot(NULL, fs_info->tree_root, &key, path, 0, 0);
1602
	btrfs_free_path(path);
1603 1604 1605
	if (ret < 0)
		goto fail;
	if (ret == 0)
1606
		set_bit(BTRFS_ROOT_ORPHAN_ITEM_INSERTED, &root->state);
1607

1608
	ret = btrfs_insert_fs_root(fs_info, root);
1609
	if (ret) {
1610 1611 1612 1613 1614
		if (ret == -EEXIST) {
			free_fs_root(root);
			goto again;
		}
		goto fail;
1615
	}
1616
	return root;
1617 1618 1619
fail:
	free_fs_root(root);
	return ERR_PTR(ret);
1620 1621
}

C
Chris Mason 已提交
1622 1623 1624 1625 1626 1627
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 已提交
1628

1629 1630
	rcu_read_lock();
	list_for_each_entry_rcu(device, &info->fs_devices->devices, dev_list) {
1631 1632
		if (!device->bdev)
			continue;
1633
		bdi = device->bdev->bd_bdi;
1634
		if (bdi_congested(bdi, bdi_bits)) {
C
Chris Mason 已提交
1635 1636 1637 1638
			ret = 1;
			break;
		}
	}
1639
	rcu_read_unlock();
C
Chris Mason 已提交
1640 1641 1642
	return ret;
}

1643 1644 1645 1646 1647
/*
 * 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)
1648 1649
{
	struct bio *bio;
1650
	struct btrfs_end_io_wq *end_io_wq;
1651

1652
	end_io_wq = container_of(work, struct btrfs_end_io_wq, work);
1653
	bio = end_io_wq->bio;
1654

1655
	bio->bi_status = end_io_wq->status;
1656 1657
	bio->bi_private = end_io_wq->private;
	bio->bi_end_io = end_io_wq->end_io;
1658
	kmem_cache_free(btrfs_end_io_wq_cache, end_io_wq);
1659
	bio_endio(bio);
1660 1661
}

1662 1663 1664
static int cleaner_kthread(void *arg)
{
	struct btrfs_root *root = arg;
1665
	struct btrfs_fs_info *fs_info = root->fs_info;
1666
	int again;
1667
	struct btrfs_trans_handle *trans;
1668 1669

	do {
1670
		again = 0;
1671

1672
		/* Make the cleaner go to sleep early. */
1673
		if (btrfs_need_cleaner_sleep(fs_info))
1674 1675
			goto sleep;

1676 1677 1678 1679
		/*
		 * Do not do anything if we might cause open_ctree() to block
		 * before we have finished mounting the filesystem.
		 */
1680
		if (!test_bit(BTRFS_FS_OPEN, &fs_info->flags))
1681 1682
			goto sleep;

1683
		if (!mutex_trylock(&fs_info->cleaner_mutex))
1684 1685
			goto sleep;

1686 1687 1688 1689
		/*
		 * Avoid the problem that we change the status of the fs
		 * during the above check and trylock.
		 */
1690
		if (btrfs_need_cleaner_sleep(fs_info)) {
1691
			mutex_unlock(&fs_info->cleaner_mutex);
1692
			goto sleep;
1693
		}
1694

1695
		mutex_lock(&fs_info->cleaner_delayed_iput_mutex);
1696
		btrfs_run_delayed_iputs(fs_info);
1697
		mutex_unlock(&fs_info->cleaner_delayed_iput_mutex);
1698

1699
		again = btrfs_clean_one_deleted_snapshot(root);
1700
		mutex_unlock(&fs_info->cleaner_mutex);
1701 1702

		/*
1703 1704
		 * The defragger has dealt with the R/O remount and umount,
		 * needn't do anything special here.
1705
		 */
1706
		btrfs_run_defrag_inodes(fs_info);
1707 1708 1709 1710 1711 1712 1713 1714 1715

		/*
		 * Acquires fs_info->delete_unused_bgs_mutex to avoid racing
		 * with relocation (btrfs_relocate_chunk) and relocation
		 * acquires fs_info->cleaner_mutex (btrfs_relocate_block_group)
		 * after acquiring fs_info->delete_unused_bgs_mutex. So we
		 * can't hold, nor need to, fs_info->cleaner_mutex when deleting
		 * unused block groups.
		 */
1716
		btrfs_delete_unused_bgs(fs_info);
1717
sleep:
1718
		if (!again) {
1719
			set_current_state(TASK_INTERRUPTIBLE);
1720 1721
			if (!kthread_should_stop())
				schedule();
1722 1723 1724
			__set_current_state(TASK_RUNNING);
		}
	} while (!kthread_should_stop());
1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739

	/*
	 * Transaction kthread is stopped before us and wakes us up.
	 * However we might have started a new transaction and COWed some
	 * tree blocks when deleting unused block groups for example. So
	 * make sure we commit the transaction we started to have a clean
	 * shutdown when evicting the btree inode - if it has dirty pages
	 * when we do the final iput() on it, eviction will trigger a
	 * writeback for it which will fail with null pointer dereferences
	 * since work queues and other resources were already released and
	 * destroyed by the time the iput/eviction/writeback is made.
	 */
	trans = btrfs_attach_transaction(root);
	if (IS_ERR(trans)) {
		if (PTR_ERR(trans) != -ENOENT)
1740
			btrfs_err(fs_info,
1741 1742 1743 1744 1745
				  "cleaner transaction attach returned %ld",
				  PTR_ERR(trans));
	} else {
		int ret;

1746
		ret = btrfs_commit_transaction(trans);
1747
		if (ret)
1748
			btrfs_err(fs_info,
1749 1750 1751 1752
				  "cleaner open transaction commit returned %d",
				  ret);
	}

1753 1754 1755 1756 1757 1758
	return 0;
}

static int transaction_kthread(void *arg)
{
	struct btrfs_root *root = arg;
1759
	struct btrfs_fs_info *fs_info = root->fs_info;
1760 1761
	struct btrfs_trans_handle *trans;
	struct btrfs_transaction *cur;
1762
	u64 transid;
1763 1764
	unsigned long now;
	unsigned long delay;
1765
	bool cannot_commit;
1766 1767

	do {
1768
		cannot_commit = false;
1769 1770
		delay = HZ * fs_info->commit_interval;
		mutex_lock(&fs_info->transaction_kthread_mutex);
1771

1772 1773
		spin_lock(&fs_info->trans_lock);
		cur = fs_info->running_transaction;
1774
		if (!cur) {
1775
			spin_unlock(&fs_info->trans_lock);
1776 1777
			goto sleep;
		}
Y
Yan Zheng 已提交
1778

1779
		now = get_seconds();
1780
		if (cur->state < TRANS_STATE_BLOCKED &&
1781
		    (now < cur->start_time ||
1782 1783
		     now - cur->start_time < fs_info->commit_interval)) {
			spin_unlock(&fs_info->trans_lock);
1784 1785 1786
			delay = HZ * 5;
			goto sleep;
		}
1787
		transid = cur->transid;
1788
		spin_unlock(&fs_info->trans_lock);
1789

1790
		/* If the file system is aborted, this will always fail. */
1791
		trans = btrfs_attach_transaction(root);
1792
		if (IS_ERR(trans)) {
1793 1794
			if (PTR_ERR(trans) != -ENOENT)
				cannot_commit = true;
1795
			goto sleep;
1796
		}
1797
		if (transid == trans->transid) {
1798
			btrfs_commit_transaction(trans);
1799
		} else {
1800
			btrfs_end_transaction(trans);
1801
		}
1802
sleep:
1803 1804
		wake_up_process(fs_info->cleaner_kthread);
		mutex_unlock(&fs_info->transaction_kthread_mutex);
1805

J
Josef Bacik 已提交
1806
		if (unlikely(test_bit(BTRFS_FS_STATE_ERROR,
1807
				      &fs_info->fs_state)))
1808
			btrfs_cleanup_transaction(fs_info);
1809 1810
		set_current_state(TASK_INTERRUPTIBLE);
		if (!kthread_should_stop() &&
1811
				(!btrfs_transaction_blocked(fs_info) ||
1812 1813 1814
				 cannot_commit))
			schedule_timeout(delay);
		__set_current_state(TASK_RUNNING);
1815 1816 1817 1818
	} while (!kthread_should_stop());
	return 0;
}

C
Chris Mason 已提交
1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924
/*
 * 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));

1925 1926 1927 1928 1929 1930 1931 1932
	/*
	 * 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 已提交
1933
			       btrfs_header_generation(info->fs_root->node));
1934
		btrfs_set_backup_fs_root_level(root_backup,
C
Chris Mason 已提交
1935
			       btrfs_header_level(info->fs_root->node));
1936
	}
C
Chris Mason 已提交
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 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017

	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 已提交
2018 2019 2020
/* helper to cleanup workers */
static void btrfs_stop_all_workers(struct btrfs_fs_info *fs_info)
{
2021
	btrfs_destroy_workqueue(fs_info->fixup_workers);
2022
	btrfs_destroy_workqueue(fs_info->delalloc_workers);
2023
	btrfs_destroy_workqueue(fs_info->workers);
2024 2025
	btrfs_destroy_workqueue(fs_info->endio_workers);
	btrfs_destroy_workqueue(fs_info->endio_raid56_workers);
2026
	btrfs_destroy_workqueue(fs_info->endio_repair_workers);
2027
	btrfs_destroy_workqueue(fs_info->rmw_workers);
2028 2029
	btrfs_destroy_workqueue(fs_info->endio_write_workers);
	btrfs_destroy_workqueue(fs_info->endio_freespace_worker);
2030
	btrfs_destroy_workqueue(fs_info->submit_workers);
2031
	btrfs_destroy_workqueue(fs_info->delayed_workers);
2032
	btrfs_destroy_workqueue(fs_info->caching_workers);
2033
	btrfs_destroy_workqueue(fs_info->readahead_workers);
2034
	btrfs_destroy_workqueue(fs_info->flush_workers);
2035
	btrfs_destroy_workqueue(fs_info->qgroup_rescan_workers);
C
Chris Mason 已提交
2036
	btrfs_destroy_workqueue(fs_info->extent_workers);
2037 2038 2039 2040 2041 2042 2043
	/*
	 * Now that all other work queues are destroyed, we can safely destroy
	 * the queues used for metadata I/O, since tasks from those other work
	 * queues can do metadata I/O operations.
	 */
	btrfs_destroy_workqueue(fs_info->endio_meta_workers);
	btrfs_destroy_workqueue(fs_info->endio_meta_write_workers);
L
Liu Bo 已提交
2044 2045
}

2046 2047 2048 2049 2050 2051 2052 2053 2054 2055
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 已提交
2056 2057 2058
/* helper to cleanup tree roots */
static void free_root_pointers(struct btrfs_fs_info *info, int chunk_root)
{
2059
	free_root_extent_buffers(info->tree_root);
2060

2061 2062 2063 2064 2065 2066 2067
	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);
2068
	free_root_extent_buffers(info->free_space_root);
C
Chris Mason 已提交
2069 2070
}

2071
void btrfs_free_fs_roots(struct btrfs_fs_info *fs_info)
2072 2073 2074 2075 2076 2077 2078 2079 2080 2081
{
	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);

2082
		if (test_bit(BTRFS_ROOT_IN_RADIX, &gang[0]->state)) {
2083
			btrfs_drop_and_free_fs_root(fs_info, gang[0]);
2084 2085 2086
		} else {
			free_extent_buffer(gang[0]->node);
			free_extent_buffer(gang[0]->commit_root);
2087
			btrfs_put_fs_root(gang[0]);
2088 2089 2090 2091 2092 2093 2094 2095 2096 2097
		}
	}

	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++)
2098
			btrfs_drop_and_free_fs_root(fs_info, gang[i]);
2099
	}
2100 2101 2102

	if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
		btrfs_free_log_root_tree(NULL, fs_info);
2103
		btrfs_destroy_pinned_extent(fs_info, fs_info->pinned_extents);
2104
	}
2105
}
C
Chris Mason 已提交
2106

2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117
static void btrfs_init_scrub(struct btrfs_fs_info *fs_info)
{
	mutex_init(&fs_info->scrub_lock);
	atomic_set(&fs_info->scrubs_running, 0);
	atomic_set(&fs_info->scrub_pause_req, 0);
	atomic_set(&fs_info->scrubs_paused, 0);
	atomic_set(&fs_info->scrub_cancel_req, 0);
	init_waitqueue_head(&fs_info->scrub_pause_wait);
	fs_info->scrub_workers_refcnt = 0;
}

2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128
static void btrfs_init_balance(struct btrfs_fs_info *fs_info)
{
	spin_lock_init(&fs_info->balance_lock);
	mutex_init(&fs_info->balance_mutex);
	atomic_set(&fs_info->balance_running, 0);
	atomic_set(&fs_info->balance_pause_req, 0);
	atomic_set(&fs_info->balance_cancel_req, 0);
	fs_info->balance_ctl = NULL;
	init_waitqueue_head(&fs_info->balance_wait_q);
}

2129
static void btrfs_init_btree_inode(struct btrfs_fs_info *fs_info)
2130
{
2131 2132 2133 2134
	struct inode *inode = fs_info->btree_inode;

	inode->i_ino = BTRFS_BTREE_INODE_OBJECTID;
	set_nlink(inode, 1);
2135 2136 2137 2138 2139
	/*
	 * 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
	 */
2140 2141
	inode->i_size = OFFSET_MAX;
	inode->i_mapping->a_ops = &btree_aops;
2142

2143
	RB_CLEAR_NODE(&BTRFS_I(inode)->rb_node);
2144
	extent_io_tree_init(&BTRFS_I(inode)->io_tree, inode);
2145 2146
	BTRFS_I(inode)->io_tree.track_uptodate = 0;
	extent_map_tree_init(&BTRFS_I(inode)->extent_tree);
2147

2148
	BTRFS_I(inode)->io_tree.ops = &btree_extent_io_ops;
2149

2150 2151 2152 2153
	BTRFS_I(inode)->root = fs_info->tree_root;
	memset(&BTRFS_I(inode)->location, 0, sizeof(struct btrfs_key));
	set_bit(BTRFS_INODE_DUMMY, &BTRFS_I(inode)->runtime_flags);
	btrfs_insert_inode_hash(inode);
2154 2155
}

2156 2157 2158 2159 2160
static void btrfs_init_dev_replace_locks(struct btrfs_fs_info *fs_info)
{
	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);
2161 2162 2163
	rwlock_init(&fs_info->dev_replace.lock);
	atomic_set(&fs_info->dev_replace.read_locks, 0);
	atomic_set(&fs_info->dev_replace.blocking_readers, 0);
2164
	init_waitqueue_head(&fs_info->replace_wait);
2165
	init_waitqueue_head(&fs_info->dev_replace.read_lock_wq);
2166 2167
}

2168 2169 2170 2171 2172 2173 2174 2175 2176
static void btrfs_init_qgroup(struct btrfs_fs_info *fs_info)
{
	spin_lock_init(&fs_info->qgroup_lock);
	mutex_init(&fs_info->qgroup_ioctl_lock);
	fs_info->qgroup_tree = RB_ROOT;
	fs_info->qgroup_op_tree = RB_ROOT;
	INIT_LIST_HEAD(&fs_info->dirty_qgroups);
	fs_info->qgroup_seq = 1;
	fs_info->qgroup_ulist = NULL;
2177
	fs_info->qgroup_rescan_running = false;
2178 2179 2180
	mutex_init(&fs_info->qgroup_rescan_lock);
}

2181 2182 2183 2184
static int btrfs_init_workqueues(struct btrfs_fs_info *fs_info,
		struct btrfs_fs_devices *fs_devices)
{
	int max_active = fs_info->thread_pool_size;
2185
	unsigned int flags = WQ_MEM_RECLAIM | WQ_FREEZABLE | WQ_UNBOUND;
2186 2187

	fs_info->workers =
2188 2189
		btrfs_alloc_workqueue(fs_info, "worker",
				      flags | WQ_HIGHPRI, max_active, 16);
2190 2191

	fs_info->delalloc_workers =
2192 2193
		btrfs_alloc_workqueue(fs_info, "delalloc",
				      flags, max_active, 2);
2194 2195

	fs_info->flush_workers =
2196 2197
		btrfs_alloc_workqueue(fs_info, "flush_delalloc",
				      flags, max_active, 0);
2198 2199

	fs_info->caching_workers =
2200
		btrfs_alloc_workqueue(fs_info, "cache", flags, max_active, 0);
2201 2202 2203 2204 2205 2206 2207

	/*
	 * 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 =
2208
		btrfs_alloc_workqueue(fs_info, "submit", flags,
2209 2210 2211 2212
				      min_t(u64, fs_devices->num_devices,
					    max_active), 64);

	fs_info->fixup_workers =
2213
		btrfs_alloc_workqueue(fs_info, "fixup", flags, 1, 0);
2214 2215 2216 2217 2218 2219

	/*
	 * endios are largely parallel and should have a very
	 * low idle thresh
	 */
	fs_info->endio_workers =
2220
		btrfs_alloc_workqueue(fs_info, "endio", flags, max_active, 4);
2221
	fs_info->endio_meta_workers =
2222 2223
		btrfs_alloc_workqueue(fs_info, "endio-meta", flags,
				      max_active, 4);
2224
	fs_info->endio_meta_write_workers =
2225 2226
		btrfs_alloc_workqueue(fs_info, "endio-meta-write", flags,
				      max_active, 2);
2227
	fs_info->endio_raid56_workers =
2228 2229
		btrfs_alloc_workqueue(fs_info, "endio-raid56", flags,
				      max_active, 4);
2230
	fs_info->endio_repair_workers =
2231
		btrfs_alloc_workqueue(fs_info, "endio-repair", flags, 1, 0);
2232
	fs_info->rmw_workers =
2233
		btrfs_alloc_workqueue(fs_info, "rmw", flags, max_active, 2);
2234
	fs_info->endio_write_workers =
2235 2236
		btrfs_alloc_workqueue(fs_info, "endio-write", flags,
				      max_active, 2);
2237
	fs_info->endio_freespace_worker =
2238 2239
		btrfs_alloc_workqueue(fs_info, "freespace-write", flags,
				      max_active, 0);
2240
	fs_info->delayed_workers =
2241 2242
		btrfs_alloc_workqueue(fs_info, "delayed-meta", flags,
				      max_active, 0);
2243
	fs_info->readahead_workers =
2244 2245
		btrfs_alloc_workqueue(fs_info, "readahead", flags,
				      max_active, 2);
2246
	fs_info->qgroup_rescan_workers =
2247
		btrfs_alloc_workqueue(fs_info, "qgroup-rescan", flags, 1, 0);
2248
	fs_info->extent_workers =
2249
		btrfs_alloc_workqueue(fs_info, "extent-refs", flags,
2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269
				      min_t(u64, fs_devices->num_devices,
					    max_active), 8);

	if (!(fs_info->workers && fs_info->delalloc_workers &&
	      fs_info->submit_workers && fs_info->flush_workers &&
	      fs_info->endio_workers && fs_info->endio_meta_workers &&
	      fs_info->endio_meta_write_workers &&
	      fs_info->endio_repair_workers &&
	      fs_info->endio_write_workers && fs_info->endio_raid56_workers &&
	      fs_info->endio_freespace_worker && fs_info->rmw_workers &&
	      fs_info->caching_workers && fs_info->readahead_workers &&
	      fs_info->fixup_workers && fs_info->delayed_workers &&
	      fs_info->extent_workers &&
	      fs_info->qgroup_rescan_workers)) {
		return -ENOMEM;
	}

	return 0;
}

2270 2271 2272 2273 2274 2275 2276 2277 2278
static int btrfs_replay_log(struct btrfs_fs_info *fs_info,
			    struct btrfs_fs_devices *fs_devices)
{
	int ret;
	struct btrfs_root *log_tree_root;
	struct btrfs_super_block *disk_super = fs_info->super_copy;
	u64 bytenr = btrfs_super_log_root(disk_super);

	if (fs_devices->rw_devices == 0) {
2279
		btrfs_warn(fs_info, "log replay required on RO media");
2280 2281 2282
		return -EIO;
	}

2283
	log_tree_root = btrfs_alloc_root(fs_info, GFP_KERNEL);
2284 2285 2286
	if (!log_tree_root)
		return -ENOMEM;

2287
	__setup_root(log_tree_root, fs_info, BTRFS_TREE_LOG_OBJECTID);
2288

2289 2290
	log_tree_root->node = read_tree_block(fs_info, bytenr,
					      fs_info->generation + 1);
2291
	if (IS_ERR(log_tree_root->node)) {
2292
		btrfs_warn(fs_info, "failed to read log tree");
2293
		ret = PTR_ERR(log_tree_root->node);
2294
		kfree(log_tree_root);
2295
		return ret;
2296
	} else if (!extent_buffer_uptodate(log_tree_root->node)) {
2297
		btrfs_err(fs_info, "failed to read log tree");
2298 2299 2300 2301 2302 2303 2304
		free_extent_buffer(log_tree_root->node);
		kfree(log_tree_root);
		return -EIO;
	}
	/* returns with log_tree_root freed on success */
	ret = btrfs_recover_log_trees(log_tree_root);
	if (ret) {
2305 2306
		btrfs_handle_fs_error(fs_info, ret,
				      "Failed to recover log tree");
2307 2308 2309 2310 2311
		free_extent_buffer(log_tree_root->node);
		kfree(log_tree_root);
		return ret;
	}

2312
	if (sb_rdonly(fs_info->sb)) {
2313
		ret = btrfs_commit_super(fs_info);
2314 2315 2316 2317 2318 2319 2320
		if (ret)
			return ret;
	}

	return 0;
}

2321
static int btrfs_read_roots(struct btrfs_fs_info *fs_info)
2322
{
2323
	struct btrfs_root *tree_root = fs_info->tree_root;
2324
	struct btrfs_root *root;
2325 2326 2327
	struct btrfs_key location;
	int ret;

2328 2329
	BUG_ON(!fs_info->tree_root);

2330 2331 2332 2333
	location.objectid = BTRFS_EXTENT_TREE_OBJECTID;
	location.type = BTRFS_ROOT_ITEM_KEY;
	location.offset = 0;

2334 2335 2336 2337 2338
	root = btrfs_read_tree_root(tree_root, &location);
	if (IS_ERR(root))
		return PTR_ERR(root);
	set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
	fs_info->extent_root = root;
2339 2340

	location.objectid = BTRFS_DEV_TREE_OBJECTID;
2341 2342 2343 2344 2345
	root = btrfs_read_tree_root(tree_root, &location);
	if (IS_ERR(root))
		return PTR_ERR(root);
	set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
	fs_info->dev_root = root;
2346 2347 2348
	btrfs_init_devices_late(fs_info);

	location.objectid = BTRFS_CSUM_TREE_OBJECTID;
2349 2350 2351 2352 2353
	root = btrfs_read_tree_root(tree_root, &location);
	if (IS_ERR(root))
		return PTR_ERR(root);
	set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
	fs_info->csum_root = root;
2354 2355

	location.objectid = BTRFS_QUOTA_TREE_OBJECTID;
2356 2357 2358
	root = btrfs_read_tree_root(tree_root, &location);
	if (!IS_ERR(root)) {
		set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
2359
		set_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags);
2360
		fs_info->quota_root = root;
2361 2362 2363
	}

	location.objectid = BTRFS_UUID_TREE_OBJECTID;
2364 2365 2366
	root = btrfs_read_tree_root(tree_root, &location);
	if (IS_ERR(root)) {
		ret = PTR_ERR(root);
2367 2368 2369
		if (ret != -ENOENT)
			return ret;
	} else {
2370 2371
		set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
		fs_info->uuid_root = root;
2372 2373
	}

2374 2375 2376 2377 2378 2379 2380 2381 2382
	if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) {
		location.objectid = BTRFS_FREE_SPACE_TREE_OBJECTID;
		root = btrfs_read_tree_root(tree_root, &location);
		if (IS_ERR(root))
			return PTR_ERR(root);
		set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
		fs_info->free_space_root = root;
	}

2383 2384 2385
	return 0;
}

A
Al Viro 已提交
2386 2387 2388
int open_ctree(struct super_block *sb,
	       struct btrfs_fs_devices *fs_devices,
	       char *options)
2389
{
2390 2391
	u32 sectorsize;
	u32 nodesize;
2392
	u32 stripesize;
2393
	u64 generation;
2394
	u64 features;
2395
	struct btrfs_key location;
2396
	struct buffer_head *bh;
2397
	struct btrfs_super_block *disk_super;
2398
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
2399
	struct btrfs_root *tree_root;
2400
	struct btrfs_root *chunk_root;
2401
	int ret;
2402
	int err = -EINVAL;
C
Chris Mason 已提交
2403 2404
	int num_backups_tried = 0;
	int backup_index = 0;
2405
	int max_active;
2406
	int clear_free_space_tree = 0;
2407

2408 2409
	tree_root = fs_info->tree_root = btrfs_alloc_root(fs_info, GFP_KERNEL);
	chunk_root = fs_info->chunk_root = btrfs_alloc_root(fs_info, GFP_KERNEL);
2410
	if (!tree_root || !chunk_root) {
C
Chris Mason 已提交
2411 2412 2413
		err = -ENOMEM;
		goto fail;
	}
2414 2415 2416 2417 2418 2419 2420

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

2421
	ret = percpu_counter_init(&fs_info->dirty_metadata_bytes, 0, GFP_KERNEL);
2422 2423
	if (ret) {
		err = ret;
2424
		goto fail_srcu;
2425
	}
2426
	fs_info->dirty_metadata_batch = PAGE_SIZE *
2427 2428
					(1 + ilog2(nr_cpu_ids));

2429
	ret = percpu_counter_init(&fs_info->delalloc_bytes, 0, GFP_KERNEL);
2430 2431 2432 2433 2434
	if (ret) {
		err = ret;
		goto fail_dirty_metadata_bytes;
	}

2435
	ret = percpu_counter_init(&fs_info->bio_counter, 0, GFP_KERNEL);
2436 2437 2438 2439 2440
	if (ret) {
		err = ret;
		goto fail_delalloc_bytes;
	}

2441
	INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_ATOMIC);
2442
	INIT_RADIX_TREE(&fs_info->buffer_radix, GFP_ATOMIC);
C
Chris Mason 已提交
2443
	INIT_LIST_HEAD(&fs_info->trans_list);
2444
	INIT_LIST_HEAD(&fs_info->dead_roots);
Y
Yan, Zheng 已提交
2445
	INIT_LIST_HEAD(&fs_info->delayed_iputs);
2446
	INIT_LIST_HEAD(&fs_info->delalloc_roots);
2447
	INIT_LIST_HEAD(&fs_info->caching_block_groups);
2448
	spin_lock_init(&fs_info->delalloc_root_lock);
J
Josef Bacik 已提交
2449
	spin_lock_init(&fs_info->trans_lock);
2450
	spin_lock_init(&fs_info->fs_roots_radix_lock);
Y
Yan, Zheng 已提交
2451
	spin_lock_init(&fs_info->delayed_iput_lock);
C
Chris Mason 已提交
2452
	spin_lock_init(&fs_info->defrag_inodes_lock);
J
Jan Schmidt 已提交
2453
	spin_lock_init(&fs_info->tree_mod_seq_lock);
2454
	spin_lock_init(&fs_info->super_lock);
J
Josef Bacik 已提交
2455
	spin_lock_init(&fs_info->qgroup_op_lock);
2456
	spin_lock_init(&fs_info->buffer_lock);
2457
	spin_lock_init(&fs_info->unused_bgs_lock);
J
Jan Schmidt 已提交
2458
	rwlock_init(&fs_info->tree_mod_log_lock);
2459
	mutex_init(&fs_info->unused_bg_unpin_mutex);
2460
	mutex_init(&fs_info->delete_unused_bgs_mutex);
C
Chris Mason 已提交
2461
	mutex_init(&fs_info->reloc_mutex);
2462
	mutex_init(&fs_info->delalloc_root_mutex);
2463
	mutex_init(&fs_info->cleaner_delayed_iput_mutex);
2464
	seqlock_init(&fs_info->profiles_lock);
2465

2466
	INIT_LIST_HEAD(&fs_info->dirty_cowonly_roots);
2467
	INIT_LIST_HEAD(&fs_info->space_info);
J
Jan Schmidt 已提交
2468
	INIT_LIST_HEAD(&fs_info->tree_mod_seq_list);
2469
	INIT_LIST_HEAD(&fs_info->unused_bgs);
2470
	btrfs_mapping_init(&fs_info->mapping_tree);
2471 2472 2473 2474 2475 2476 2477
	btrfs_init_block_rsv(&fs_info->global_block_rsv,
			     BTRFS_BLOCK_RSV_GLOBAL);
	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);
2478
	atomic_set(&fs_info->async_delalloc_pages, 0);
C
Chris Mason 已提交
2479
	atomic_set(&fs_info->defrag_running, 0);
J
Josef Bacik 已提交
2480
	atomic_set(&fs_info->qgroup_op_seq, 0);
Z
Zhao Lei 已提交
2481
	atomic_set(&fs_info->reada_works_cnt, 0);
2482
	atomic64_set(&fs_info->tree_mod_seq, 0);
C
Chris Mason 已提交
2483
	fs_info->sb = sb;
2484
	fs_info->max_inline = BTRFS_DEFAULT_MAX_INLINE;
J
Josef Bacik 已提交
2485
	fs_info->metadata_ratio = 0;
C
Chris Mason 已提交
2486
	fs_info->defrag_inodes = RB_ROOT;
2487
	atomic64_set(&fs_info->free_chunk_space, 0);
J
Jan Schmidt 已提交
2488
	fs_info->tree_mod_log = RB_ROOT;
2489
	fs_info->commit_interval = BTRFS_DEFAULT_COMMIT_INTERVAL;
2490
	fs_info->avg_delayed_ref_runtime = NSEC_PER_SEC >> 6; /* div by 64 */
2491
	/* readahead state */
2492
	INIT_RADIX_TREE(&fs_info->reada_tree, GFP_NOFS & ~__GFP_DIRECT_RECLAIM);
2493
	spin_lock_init(&fs_info->reada_lock);
J
Josef Bacik 已提交
2494
	btrfs_init_ref_verify(fs_info);
C
Chris Mason 已提交
2495

2496 2497
	fs_info->thread_pool_size = min_t(unsigned long,
					  num_online_cpus() + 2, 8);
2498

2499 2500
	INIT_LIST_HEAD(&fs_info->ordered_roots);
	spin_lock_init(&fs_info->ordered_root_lock);
2501 2502 2503 2504 2505 2506 2507 2508

	fs_info->btree_inode = new_inode(sb);
	if (!fs_info->btree_inode) {
		err = -ENOMEM;
		goto fail_bio_counter;
	}
	mapping_set_gfp_mask(fs_info->btree_inode->i_mapping, GFP_NOFS);

2509
	fs_info->delayed_root = kmalloc(sizeof(struct btrfs_delayed_root),
2510
					GFP_KERNEL);
2511 2512 2513 2514 2515
	if (!fs_info->delayed_root) {
		err = -ENOMEM;
		goto fail_iput;
	}
	btrfs_init_delayed_root(fs_info->delayed_root);
2516

2517
	btrfs_init_scrub(fs_info);
2518 2519 2520
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
	fs_info->check_integrity_print_mask = 0;
#endif
2521
	btrfs_init_balance(fs_info);
2522
	btrfs_init_async_reclaim_work(&fs_info->async_reclaim_work);
A
Arne Jansen 已提交
2523

2524 2525
	sb->s_blocksize = BTRFS_BDEV_BLOCKSIZE;
	sb->s_blocksize_bits = blksize_bits(BTRFS_BDEV_BLOCKSIZE);
2526

2527
	btrfs_init_btree_inode(fs_info);
2528

J
Josef Bacik 已提交
2529
	spin_lock_init(&fs_info->block_group_cache_lock);
2530
	fs_info->block_group_cache_tree = RB_ROOT;
2531
	fs_info->first_logical_byte = (u64)-1;
J
Josef Bacik 已提交
2532

2533 2534
	extent_io_tree_init(&fs_info->freed_extents[0], NULL);
	extent_io_tree_init(&fs_info->freed_extents[1], NULL);
2535
	fs_info->pinned_extents = &fs_info->freed_extents[0];
2536
	set_bit(BTRFS_FS_BARRIER, &fs_info->flags);
C
Chris Mason 已提交
2537

2538
	mutex_init(&fs_info->ordered_operations_mutex);
2539
	mutex_init(&fs_info->tree_log_mutex);
2540
	mutex_init(&fs_info->chunk_mutex);
2541 2542
	mutex_init(&fs_info->transaction_kthread_mutex);
	mutex_init(&fs_info->cleaner_mutex);
2543
	mutex_init(&fs_info->volume_mutex);
2544
	mutex_init(&fs_info->ro_block_group_mutex);
2545
	init_rwsem(&fs_info->commit_root_sem);
2546
	init_rwsem(&fs_info->cleanup_work_sem);
2547
	init_rwsem(&fs_info->subvol_sem);
S
Stefan Behrens 已提交
2548
	sema_init(&fs_info->uuid_tree_rescan_sem, 1);
2549

2550
	btrfs_init_dev_replace_locks(fs_info);
2551
	btrfs_init_qgroup(fs_info);
2552

2553 2554 2555
	btrfs_init_free_cluster(&fs_info->meta_alloc_cluster);
	btrfs_init_free_cluster(&fs_info->data_alloc_cluster);

2556
	init_waitqueue_head(&fs_info->transaction_throttle);
2557
	init_waitqueue_head(&fs_info->transaction_wait);
S
Sage Weil 已提交
2558
	init_waitqueue_head(&fs_info->transaction_blocked_wait);
2559
	init_waitqueue_head(&fs_info->async_submit_wait);
2560

2561 2562
	INIT_LIST_HEAD(&fs_info->pinned_chunks);

2563 2564 2565 2566 2567
	/* Usable values until the real ones are cached from the superblock */
	fs_info->nodesize = 4096;
	fs_info->sectorsize = 4096;
	fs_info->stripesize = 4096;

D
David Woodhouse 已提交
2568 2569
	ret = btrfs_alloc_stripe_hash_table(fs_info);
	if (ret) {
2570
		err = ret;
D
David Woodhouse 已提交
2571 2572 2573
		goto fail_alloc;
	}

2574
	__setup_root(tree_root, fs_info, BTRFS_ROOT_TREE_OBJECTID);
2575

2576
	invalidate_bdev(fs_devices->latest_bdev);
D
David Sterba 已提交
2577 2578 2579 2580

	/*
	 * Read super block and check the signature bytes only
	 */
Y
Yan Zheng 已提交
2581
	bh = btrfs_read_dev_super(fs_devices->latest_bdev);
2582 2583
	if (IS_ERR(bh)) {
		err = PTR_ERR(bh);
2584
		goto fail_alloc;
2585
	}
C
Chris Mason 已提交
2586

D
David Sterba 已提交
2587 2588 2589 2590
	/*
	 * We want to check superblock checksum, the type is stored inside.
	 * Pass the whole disk block of size BTRFS_SUPER_INFO_SIZE (4k).
	 */
2591
	if (btrfs_check_super_csum(fs_info, bh->b_data)) {
2592
		btrfs_err(fs_info, "superblock checksum mismatch");
D
David Sterba 已提交
2593
		err = -EINVAL;
2594
		brelse(bh);
D
David Sterba 已提交
2595 2596 2597 2598 2599 2600 2601 2602
		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
	 */
2603 2604 2605
	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));
2606
	brelse(bh);
2607

2608
	memcpy(fs_info->fsid, fs_info->super_copy->fsid, BTRFS_FSID_SIZE);
2609

2610
	ret = btrfs_check_super_valid(fs_info);
D
David Sterba 已提交
2611
	if (ret) {
2612
		btrfs_err(fs_info, "superblock contains fatal errors");
D
David Sterba 已提交
2613 2614 2615 2616
		err = -EINVAL;
		goto fail_alloc;
	}

2617
	disk_super = fs_info->super_copy;
2618
	if (!btrfs_super_root(disk_super))
2619
		goto fail_alloc;
2620

L
liubo 已提交
2621
	/* check FS state, whether FS is broken. */
2622 2623
	if (btrfs_super_flags(disk_super) & BTRFS_SUPER_FLAG_ERROR)
		set_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state);
L
liubo 已提交
2624

C
Chris Mason 已提交
2625 2626 2627 2628 2629 2630 2631
	/*
	 * 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);

2632 2633 2634 2635 2636 2637
	/*
	 * 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;

2638
	ret = btrfs_parse_options(fs_info, options, sb->s_flags);
Y
Yan Zheng 已提交
2639 2640
	if (ret) {
		err = ret;
2641
		goto fail_alloc;
Y
Yan Zheng 已提交
2642
	}
2643

2644 2645 2646
	features = btrfs_super_incompat_flags(disk_super) &
		~BTRFS_FEATURE_INCOMPAT_SUPP;
	if (features) {
2647 2648 2649
		btrfs_err(fs_info,
		    "cannot mount because of unsupported optional features (%llx)",
		    features);
2650
		err = -EINVAL;
2651
		goto fail_alloc;
2652 2653
	}

2654
	features = btrfs_super_incompat_flags(disk_super);
L
Li Zefan 已提交
2655
	features |= BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF;
2656
	if (fs_info->compress_type == BTRFS_COMPRESS_LZO)
L
Li Zefan 已提交
2657
		features |= BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO;
N
Nick Terrell 已提交
2658 2659
	else if (fs_info->compress_type == BTRFS_COMPRESS_ZSTD)
		features |= BTRFS_FEATURE_INCOMPAT_COMPRESS_ZSTD;
2660

2661
	if (features & BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA)
2662
		btrfs_info(fs_info, "has skinny extents");
2663

2664 2665 2666 2667
	/*
	 * flag our filesystem as having big metadata blocks if
	 * they are bigger than the page size
	 */
2668
	if (btrfs_super_nodesize(disk_super) > PAGE_SIZE) {
2669
		if (!(features & BTRFS_FEATURE_INCOMPAT_BIG_METADATA))
2670 2671
			btrfs_info(fs_info,
				"flagging fs with big metadata feature");
2672 2673 2674
		features |= BTRFS_FEATURE_INCOMPAT_BIG_METADATA;
	}

2675 2676
	nodesize = btrfs_super_nodesize(disk_super);
	sectorsize = btrfs_super_sectorsize(disk_super);
2677
	stripesize = sectorsize;
2678
	fs_info->dirty_metadata_batch = nodesize * (1 + ilog2(nr_cpu_ids));
2679
	fs_info->delalloc_batch = sectorsize * 512 * (1 + ilog2(nr_cpu_ids));
2680

2681 2682 2683 2684 2685
	/* Cache block sizes */
	fs_info->nodesize = nodesize;
	fs_info->sectorsize = sectorsize;
	fs_info->stripesize = stripesize;

2686 2687 2688 2689 2690
	/*
	 * 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) &&
2691
	    (sectorsize != nodesize)) {
2692 2693 2694
		btrfs_err(fs_info,
"unequal nodesize/sectorsize (%u != %u) are not allowed for mixed block groups",
			nodesize, sectorsize);
2695 2696 2697
		goto fail_alloc;
	}

2698 2699 2700 2701
	/*
	 * Needn't use the lock because there is no other task which will
	 * update the flag.
	 */
L
Li Zefan 已提交
2702
	btrfs_set_super_incompat_flags(disk_super, features);
2703

2704 2705
	features = btrfs_super_compat_ro_flags(disk_super) &
		~BTRFS_FEATURE_COMPAT_RO_SUPP;
2706
	if (!sb_rdonly(sb) && features) {
2707 2708
		btrfs_err(fs_info,
	"cannot mount read-write because of unsupported optional features (%llx)",
2709
		       features);
2710
		err = -EINVAL;
2711
		goto fail_alloc;
2712
	}
2713

2714
	max_active = fs_info->thread_pool_size;
2715

2716 2717 2718
	ret = btrfs_init_workqueues(fs_info, fs_devices);
	if (ret) {
		err = ret;
2719 2720
		goto fail_sb_buffer;
	}
2721

2722 2723 2724
	sb->s_bdi->congested_fn = btrfs_congested_fn;
	sb->s_bdi->congested_data = fs_info;
	sb->s_bdi->capabilities |= BDI_CAP_CGROUP_WRITEBACK;
2725
	sb->s_bdi->ra_pages = VM_MAX_READAHEAD * SZ_1K / PAGE_SIZE;
2726 2727
	sb->s_bdi->ra_pages *= btrfs_super_num_devices(disk_super);
	sb->s_bdi->ra_pages = max(sb->s_bdi->ra_pages, SZ_4M / PAGE_SIZE);
2728

2729 2730
	sb->s_blocksize = sectorsize;
	sb->s_blocksize_bits = blksize_bits(sectorsize);
2731
	memcpy(&sb->s_uuid, fs_info->fsid, BTRFS_FSID_SIZE);
2732

2733
	mutex_lock(&fs_info->chunk_mutex);
2734
	ret = btrfs_read_sys_array(fs_info);
2735
	mutex_unlock(&fs_info->chunk_mutex);
2736
	if (ret) {
2737
		btrfs_err(fs_info, "failed to read the system array: %d", ret);
2738
		goto fail_sb_buffer;
2739
	}
2740

2741
	generation = btrfs_super_chunk_root_generation(disk_super);
2742

2743
	__setup_root(chunk_root, fs_info, BTRFS_CHUNK_TREE_OBJECTID);
2744

2745
	chunk_root->node = read_tree_block(fs_info,
2746
					   btrfs_super_chunk_root(disk_super),
2747
					   generation);
2748 2749
	if (IS_ERR(chunk_root->node) ||
	    !extent_buffer_uptodate(chunk_root->node)) {
2750
		btrfs_err(fs_info, "failed to read chunk root");
2751 2752
		if (!IS_ERR(chunk_root->node))
			free_extent_buffer(chunk_root->node);
2753
		chunk_root->node = NULL;
C
Chris Mason 已提交
2754
		goto fail_tree_roots;
2755
	}
2756 2757
	btrfs_set_root_node(&chunk_root->root_item, chunk_root->node);
	chunk_root->commit_root = btrfs_root_node(chunk_root);
2758

2759
	read_extent_buffer(chunk_root->node, fs_info->chunk_tree_uuid,
2760
	   btrfs_header_chunk_tree_uuid(chunk_root->node), BTRFS_UUID_SIZE);
2761

2762
	ret = btrfs_read_chunk_tree(fs_info);
Y
Yan Zheng 已提交
2763
	if (ret) {
2764
		btrfs_err(fs_info, "failed to read chunk tree: %d", ret);
C
Chris Mason 已提交
2765
		goto fail_tree_roots;
Y
Yan Zheng 已提交
2766
	}
2767

2768 2769 2770 2771
	/*
	 * keep the device that is marked to be the target device for the
	 * dev_replace procedure
	 */
2772
	btrfs_close_extra_devices(fs_devices, 0);
2773

2774
	if (!fs_devices->latest_bdev) {
2775
		btrfs_err(fs_info, "failed to read devices");
2776 2777 2778
		goto fail_tree_roots;
	}

C
Chris Mason 已提交
2779
retry_root_backup:
2780
	generation = btrfs_super_generation(disk_super);
2781

2782
	tree_root->node = read_tree_block(fs_info,
2783
					  btrfs_super_root(disk_super),
2784
					  generation);
2785 2786
	if (IS_ERR(tree_root->node) ||
	    !extent_buffer_uptodate(tree_root->node)) {
2787
		btrfs_warn(fs_info, "failed to read tree root");
2788 2789
		if (!IS_ERR(tree_root->node))
			free_extent_buffer(tree_root->node);
2790
		tree_root->node = NULL;
C
Chris Mason 已提交
2791
		goto recovery_tree_root;
2792
	}
C
Chris Mason 已提交
2793

2794 2795
	btrfs_set_root_node(&tree_root->root_item, tree_root->node);
	tree_root->commit_root = btrfs_root_node(tree_root);
2796
	btrfs_set_root_refs(&tree_root->root_item, 1);
2797

2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809
	mutex_lock(&tree_root->objectid_mutex);
	ret = btrfs_find_highest_objectid(tree_root,
					&tree_root->highest_objectid);
	if (ret) {
		mutex_unlock(&tree_root->objectid_mutex);
		goto recovery_tree_root;
	}

	ASSERT(tree_root->highest_objectid <= BTRFS_LAST_FREE_OBJECTID);

	mutex_unlock(&tree_root->objectid_mutex);

2810
	ret = btrfs_read_roots(fs_info);
2811
	if (ret)
C
Chris Mason 已提交
2812
		goto recovery_tree_root;
2813

2814 2815 2816
	fs_info->generation = generation;
	fs_info->last_trans_committed = generation;

2817 2818
	ret = btrfs_recover_balance(fs_info);
	if (ret) {
2819
		btrfs_err(fs_info, "failed to recover balance: %d", ret);
2820 2821 2822
		goto fail_block_groups;
	}

2823 2824
	ret = btrfs_init_dev_stats(fs_info);
	if (ret) {
2825
		btrfs_err(fs_info, "failed to init dev_stats: %d", ret);
2826 2827 2828
		goto fail_block_groups;
	}

2829 2830
	ret = btrfs_init_dev_replace(fs_info);
	if (ret) {
2831
		btrfs_err(fs_info, "failed to init dev_replace: %d", ret);
2832 2833 2834
		goto fail_block_groups;
	}

2835
	btrfs_close_extra_devices(fs_devices, 1);
2836

2837 2838
	ret = btrfs_sysfs_add_fsid(fs_devices, NULL);
	if (ret) {
2839 2840
		btrfs_err(fs_info, "failed to init sysfs fsid interface: %d",
				ret);
2841 2842 2843 2844 2845
		goto fail_block_groups;
	}

	ret = btrfs_sysfs_add_device(fs_devices);
	if (ret) {
2846 2847
		btrfs_err(fs_info, "failed to init sysfs device interface: %d",
				ret);
2848 2849 2850
		goto fail_fsdev_sysfs;
	}

2851
	ret = btrfs_sysfs_add_mounted(fs_info);
2852
	if (ret) {
2853
		btrfs_err(fs_info, "failed to init sysfs interface: %d", ret);
2854
		goto fail_fsdev_sysfs;
2855 2856 2857 2858
	}

	ret = btrfs_init_space_info(fs_info);
	if (ret) {
2859
		btrfs_err(fs_info, "failed to initialize space info: %d", ret);
2860
		goto fail_sysfs;
2861 2862
	}

2863
	ret = btrfs_read_block_groups(fs_info);
2864
	if (ret) {
2865
		btrfs_err(fs_info, "failed to read block groups: %d", ret);
2866
		goto fail_sysfs;
2867
	}
2868

2869
	if (!sb_rdonly(sb) && !btrfs_check_rw_degradable(fs_info, NULL)) {
2870
		btrfs_warn(fs_info,
2871
		"writeable mount is not allowed due to too many missing devices");
2872
		goto fail_sysfs;
2873
	}
C
Chris Mason 已提交
2874

2875 2876
	fs_info->cleaner_kthread = kthread_run(cleaner_kthread, tree_root,
					       "btrfs-cleaner");
2877
	if (IS_ERR(fs_info->cleaner_kthread))
2878
		goto fail_sysfs;
2879 2880 2881 2882

	fs_info->transaction_kthread = kthread_run(transaction_kthread,
						   tree_root,
						   "btrfs-transaction");
2883
	if (IS_ERR(fs_info->transaction_kthread))
2884
		goto fail_cleaner;
2885

2886
	if (!btrfs_test_opt(fs_info, NOSSD) &&
C
Chris Mason 已提交
2887
	    !fs_info->fs_devices->rotating) {
2888
		btrfs_set_and_info(fs_info, SSD, "enabling ssd optimizations");
C
Chris Mason 已提交
2889 2890
	}

2891
	/*
2892
	 * Mount does not set all options immediately, we can do it now and do
2893 2894 2895
	 * not have to wait for transaction commit
	 */
	btrfs_apply_pending_changes(fs_info);
2896

2897
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
2898
	if (btrfs_test_opt(fs_info, CHECK_INTEGRITY)) {
2899
		ret = btrfsic_mount(fs_info, fs_devices,
2900
				    btrfs_test_opt(fs_info,
2901 2902 2903 2904
					CHECK_INTEGRITY_INCLUDING_EXTENT_DATA) ?
				    1 : 0,
				    fs_info->check_integrity_print_mask);
		if (ret)
2905 2906 2907
			btrfs_warn(fs_info,
				"failed to initialize integrity check module: %d",
				ret);
2908 2909
	}
#endif
2910 2911 2912
	ret = btrfs_read_qgroup_config(fs_info);
	if (ret)
		goto fail_trans_kthread;
2913

J
Josef Bacik 已提交
2914 2915 2916
	if (btrfs_build_ref_tree(fs_info))
		btrfs_err(fs_info, "couldn't build ref tree");

2917 2918
	/* do not make disk changes in broken FS or nologreplay is given */
	if (btrfs_super_log_root(disk_super) != 0 &&
2919
	    !btrfs_test_opt(fs_info, NOLOGREPLAY)) {
2920
		ret = btrfs_replay_log(fs_info, fs_devices);
2921
		if (ret) {
2922
			err = ret;
2923
			goto fail_qgroup;
2924
		}
2925
	}
Z
Zheng Yan 已提交
2926

2927
	ret = btrfs_find_orphan_roots(fs_info);
2928
	if (ret)
2929
		goto fail_qgroup;
2930

2931
	if (!sb_rdonly(sb)) {
2932
		ret = btrfs_cleanup_fs_roots(fs_info);
2933
		if (ret)
2934
			goto fail_qgroup;
2935 2936

		mutex_lock(&fs_info->cleaner_mutex);
2937
		ret = btrfs_recover_relocation(tree_root);
2938
		mutex_unlock(&fs_info->cleaner_mutex);
2939
		if (ret < 0) {
2940 2941
			btrfs_warn(fs_info, "failed to recover relocation: %d",
					ret);
2942
			err = -EINVAL;
2943
			goto fail_qgroup;
2944
		}
2945
	}
Z
Zheng Yan 已提交
2946

2947 2948
	location.objectid = BTRFS_FS_TREE_OBJECTID;
	location.type = BTRFS_ROOT_ITEM_KEY;
2949
	location.offset = 0;
2950 2951

	fs_info->fs_root = btrfs_read_fs_root_no_name(fs_info, &location);
2952 2953
	if (IS_ERR(fs_info->fs_root)) {
		err = PTR_ERR(fs_info->fs_root);
2954
		goto fail_qgroup;
2955
	}
C
Chris Mason 已提交
2956

2957
	if (sb_rdonly(sb))
2958
		return 0;
I
Ilya Dryomov 已提交
2959

2960 2961
	if (btrfs_test_opt(fs_info, CLEAR_CACHE) &&
	    btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) {
2962 2963 2964 2965 2966 2967 2968 2969
		clear_free_space_tree = 1;
	} else if (btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE) &&
		   !btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE_VALID)) {
		btrfs_warn(fs_info, "free space tree is invalid");
		clear_free_space_tree = 1;
	}

	if (clear_free_space_tree) {
2970 2971 2972 2973 2974
		btrfs_info(fs_info, "clearing free space tree");
		ret = btrfs_clear_free_space_tree(fs_info);
		if (ret) {
			btrfs_warn(fs_info,
				   "failed to clear free space tree: %d", ret);
2975
			close_ctree(fs_info);
2976 2977 2978 2979
			return ret;
		}
	}

2980
	if (btrfs_test_opt(fs_info, FREE_SPACE_TREE) &&
2981
	    !btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) {
2982
		btrfs_info(fs_info, "creating free space tree");
2983 2984
		ret = btrfs_create_free_space_tree(fs_info);
		if (ret) {
2985 2986
			btrfs_warn(fs_info,
				"failed to create free space tree: %d", ret);
2987
			close_ctree(fs_info);
2988 2989 2990 2991
			return ret;
		}
	}

2992 2993 2994
	down_read(&fs_info->cleanup_work_sem);
	if ((ret = btrfs_orphan_cleanup(fs_info->fs_root)) ||
	    (ret = btrfs_orphan_cleanup(fs_info->tree_root))) {
2995
		up_read(&fs_info->cleanup_work_sem);
2996
		close_ctree(fs_info);
2997 2998 2999
		return ret;
	}
	up_read(&fs_info->cleanup_work_sem);
I
Ilya Dryomov 已提交
3000

3001 3002
	ret = btrfs_resume_balance_async(fs_info);
	if (ret) {
3003
		btrfs_warn(fs_info, "failed to resume balance: %d", ret);
3004
		close_ctree(fs_info);
3005
		return ret;
3006 3007
	}

3008 3009
	ret = btrfs_resume_dev_replace_async(fs_info);
	if (ret) {
3010
		btrfs_warn(fs_info, "failed to resume device replace: %d", ret);
3011
		close_ctree(fs_info);
3012 3013 3014
		return ret;
	}

3015 3016
	btrfs_qgroup_rescan_resume(fs_info);

3017
	if (!fs_info->uuid_root) {
3018
		btrfs_info(fs_info, "creating UUID tree");
3019 3020
		ret = btrfs_create_uuid_tree(fs_info);
		if (ret) {
3021 3022
			btrfs_warn(fs_info,
				"failed to create the UUID tree: %d", ret);
3023
			close_ctree(fs_info);
3024 3025
			return ret;
		}
3026
	} else if (btrfs_test_opt(fs_info, RESCAN_UUID_TREE) ||
3027 3028
		   fs_info->generation !=
				btrfs_super_uuid_tree_generation(disk_super)) {
3029
		btrfs_info(fs_info, "checking UUID tree");
3030 3031
		ret = btrfs_check_uuid_tree(fs_info);
		if (ret) {
3032 3033
			btrfs_warn(fs_info,
				"failed to check the UUID tree: %d", ret);
3034
			close_ctree(fs_info);
3035 3036 3037
			return ret;
		}
	} else {
3038
		set_bit(BTRFS_FS_UPDATE_UUID_TREE_GEN, &fs_info->flags);
3039
	}
3040
	set_bit(BTRFS_FS_OPEN, &fs_info->flags);
3041

3042 3043 3044 3045 3046 3047
	/*
	 * backuproot only affect mount behavior, and if open_ctree succeeded,
	 * no need to keep the flag
	 */
	btrfs_clear_opt(fs_info->mount_opt, USEBACKUPROOT);

A
Al Viro 已提交
3048
	return 0;
C
Chris Mason 已提交
3049

3050 3051
fail_qgroup:
	btrfs_free_qgroup_config(fs_info);
3052 3053
fail_trans_kthread:
	kthread_stop(fs_info->transaction_kthread);
3054
	btrfs_cleanup_transaction(fs_info);
3055
	btrfs_free_fs_roots(fs_info);
3056
fail_cleaner:
3057
	kthread_stop(fs_info->cleaner_kthread);
3058 3059 3060 3061 3062 3063 3064

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

3065
fail_sysfs:
3066
	btrfs_sysfs_remove_mounted(fs_info);
3067

3068 3069 3070
fail_fsdev_sysfs:
	btrfs_sysfs_remove_fsid(fs_info->fs_devices);

3071
fail_block_groups:
J
Josef Bacik 已提交
3072
	btrfs_put_block_group_cache(fs_info);
C
Chris Mason 已提交
3073 3074 3075

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

C
Chris Mason 已提交
3078
fail_sb_buffer:
L
Liu Bo 已提交
3079
	btrfs_stop_all_workers(fs_info);
3080
	btrfs_free_block_groups(fs_info);
3081
fail_alloc:
3082
fail_iput:
3083 3084
	btrfs_mapping_tree_free(&fs_info->mapping_tree);

3085
	iput(fs_info->btree_inode);
3086 3087
fail_bio_counter:
	percpu_counter_destroy(&fs_info->bio_counter);
3088 3089
fail_delalloc_bytes:
	percpu_counter_destroy(&fs_info->delalloc_bytes);
3090 3091
fail_dirty_metadata_bytes:
	percpu_counter_destroy(&fs_info->dirty_metadata_bytes);
3092 3093
fail_srcu:
	cleanup_srcu_struct(&fs_info->subvol_srcu);
3094
fail:
D
David Woodhouse 已提交
3095
	btrfs_free_stripe_hash_table(fs_info);
3096
	btrfs_close_devices(fs_info->fs_devices);
A
Al Viro 已提交
3097
	return err;
C
Chris Mason 已提交
3098 3099

recovery_tree_root:
3100
	if (!btrfs_test_opt(fs_info, USEBACKUPROOT))
C
Chris Mason 已提交
3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115
		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;
3116 3117
}

3118 3119 3120 3121 3122
static void btrfs_end_buffer_write_sync(struct buffer_head *bh, int uptodate)
{
	if (uptodate) {
		set_buffer_uptodate(bh);
	} else {
3123 3124 3125
		struct btrfs_device *device = (struct btrfs_device *)
			bh->b_private;

3126
		btrfs_warn_rl_in_rcu(device->fs_info,
3127
				"lost page write due to IO error on %s",
3128
					  rcu_str_deref(device->name));
3129
		/* note, we don't set_buffer_write_io_error because we have
3130 3131
		 * our own ways of dealing with the IO errors
		 */
3132
		clear_buffer_uptodate(bh);
3133
		btrfs_dev_stat_inc_and_print(device, BTRFS_DEV_STAT_WRITE_ERRS);
3134 3135 3136 3137 3138
	}
	unlock_buffer(bh);
	put_bh(bh);
}

3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149
int btrfs_read_dev_one_super(struct block_device *bdev, int copy_num,
			struct buffer_head **bh_ret)
{
	struct buffer_head *bh;
	struct btrfs_super_block *super;
	u64 bytenr;

	bytenr = btrfs_sb_offset(copy_num);
	if (bytenr + BTRFS_SUPER_INFO_SIZE >= i_size_read(bdev->bd_inode))
		return -EINVAL;

3150
	bh = __bread(bdev, bytenr / BTRFS_BDEV_BLOCKSIZE, BTRFS_SUPER_INFO_SIZE);
3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169
	/*
	 * If we fail to read from the underlying devices, as of now
	 * the best option we have is to mark it EIO.
	 */
	if (!bh)
		return -EIO;

	super = (struct btrfs_super_block *)bh->b_data;
	if (btrfs_super_bytenr(super) != bytenr ||
		    btrfs_super_magic(super) != BTRFS_MAGIC) {
		brelse(bh);
		return -EINVAL;
	}

	*bh_ret = bh;
	return 0;
}


Y
Yan Zheng 已提交
3170 3171 3172 3173 3174 3175 3176
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;
3177
	int ret = -EINVAL;
Y
Yan Zheng 已提交
3178 3179 3180 3181 3182 3183 3184

	/* 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++) {
3185 3186
		ret = btrfs_read_dev_one_super(bdev, i, &bh);
		if (ret)
Y
Yan Zheng 已提交
3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198
			continue;

		super = (struct btrfs_super_block *)bh->b_data;

		if (!latest || btrfs_super_generation(super) > transid) {
			brelse(latest);
			latest = bh;
			transid = btrfs_super_generation(super);
		} else {
			brelse(bh);
		}
	}
3199 3200 3201 3202

	if (!latest)
		return ERR_PTR(ret);

Y
Yan Zheng 已提交
3203 3204 3205
	return latest;
}

3206
/*
3207 3208
 * Write superblock @sb to the @device. Do not wait for completion, all the
 * buffer heads we write are pinned.
3209
 *
3210 3211 3212
 * Write @max_mirrors copies of the superblock, where 0 means default that fit
 * the expected device size at commit time. Note that max_mirrors must be
 * same for write and wait phases.
3213
 *
3214
 * Return number of errors when buffer head is not found or submission fails.
3215
 */
Y
Yan Zheng 已提交
3216
static int write_dev_supers(struct btrfs_device *device,
3217
			    struct btrfs_super_block *sb, int max_mirrors)
Y
Yan Zheng 已提交
3218 3219 3220 3221 3222 3223 3224
{
	struct buffer_head *bh;
	int i;
	int ret;
	int errors = 0;
	u32 crc;
	u64 bytenr;
3225
	int op_flags;
Y
Yan Zheng 已提交
3226 3227 3228 3229 3230 3231

	if (max_mirrors == 0)
		max_mirrors = BTRFS_SUPER_MIRROR_MAX;

	for (i = 0; i < max_mirrors; i++) {
		bytenr = btrfs_sb_offset(i);
3232 3233
		if (bytenr + BTRFS_SUPER_INFO_SIZE >=
		    device->commit_total_bytes)
Y
Yan Zheng 已提交
3234 3235
			break;

3236
		btrfs_set_super_bytenr(sb, bytenr);
3237

3238 3239 3240 3241
		crc = ~(u32)0;
		crc = btrfs_csum_data((const char *)sb + BTRFS_CSUM_SIZE, crc,
				      BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE);
		btrfs_csum_final(crc, sb->csum);
3242

3243
		/* One reference for us, and we leave it for the caller */
3244
		bh = __getblk(device->bdev, bytenr / BTRFS_BDEV_BLOCKSIZE,
3245 3246 3247 3248 3249 3250
			      BTRFS_SUPER_INFO_SIZE);
		if (!bh) {
			btrfs_err(device->fs_info,
			    "couldn't get super buffer head for bytenr %llu",
			    bytenr);
			errors++;
3251
			continue;
3252
		}
3253

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

3256 3257
		/* one reference for submit_bh */
		get_bh(bh);
3258

3259 3260 3261 3262
		set_buffer_uptodate(bh);
		lock_buffer(bh);
		bh->b_end_io = btrfs_end_buffer_write_sync;
		bh->b_private = device;
Y
Yan Zheng 已提交
3263

C
Chris Mason 已提交
3264 3265 3266 3267
		/*
		 * we fua the first super.  The others we allow
		 * to go down lazy.
		 */
3268 3269 3270 3271
		op_flags = REQ_SYNC | REQ_META | REQ_PRIO;
		if (i == 0 && !btrfs_test_opt(device->fs_info, NOBARRIER))
			op_flags |= REQ_FUA;
		ret = btrfsic_submit_bh(REQ_OP_WRITE, op_flags, bh);
3272
		if (ret)
Y
Yan Zheng 已提交
3273 3274 3275 3276 3277
			errors++;
	}
	return errors < i ? 0 : -1;
}

3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300
/*
 * Wait for write completion of superblocks done by write_dev_supers,
 * @max_mirrors same for write and wait phases.
 *
 * Return number of errors when buffer head is not found or not marked up to
 * date.
 */
static int wait_dev_supers(struct btrfs_device *device, int max_mirrors)
{
	struct buffer_head *bh;
	int i;
	int errors = 0;
	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->commit_total_bytes)
			break;

3301 3302
		bh = __find_get_block(device->bdev,
				      bytenr / BTRFS_BDEV_BLOCKSIZE,
3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321
				      BTRFS_SUPER_INFO_SIZE);
		if (!bh) {
			errors++;
			continue;
		}
		wait_on_buffer(bh);
		if (!buffer_uptodate(bh))
			errors++;

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

		/* drop the reference from the writing run */
		brelse(bh);
	}

	return errors < i ? 0 : -1;
}

C
Chris Mason 已提交
3322 3323 3324 3325
/*
 * endio for the write_dev_flush, this will wake anyone waiting
 * for the barrier when it is done
 */
3326
static void btrfs_end_empty_barrier(struct bio *bio)
C
Chris Mason 已提交
3327
{
3328
	complete(bio->bi_private);
C
Chris Mason 已提交
3329 3330 3331
}

/*
3332 3333
 * Submit a flush request to the device if it supports it. Error handling is
 * done in the waiting counterpart.
C
Chris Mason 已提交
3334
 */
3335
static void write_dev_flush(struct btrfs_device *device)
C
Chris Mason 已提交
3336
{
3337
	struct request_queue *q = bdev_get_queue(device->bdev);
3338
	struct bio *bio = device->flush_bio;
C
Chris Mason 已提交
3339

3340
	if (!test_bit(QUEUE_FLAG_WC, &q->queue_flags))
3341
		return;
C
Chris Mason 已提交
3342

3343
	bio_reset(bio);
C
Chris Mason 已提交
3344
	bio->bi_end_io = btrfs_end_empty_barrier;
3345
	bio_set_dev(bio, device->bdev);
3346
	bio->bi_opf = REQ_OP_WRITE | REQ_SYNC | REQ_PREFLUSH;
C
Chris Mason 已提交
3347 3348 3349
	init_completion(&device->flush_wait);
	bio->bi_private = &device->flush_wait;

3350
	btrfsic_submit_bio(bio);
3351
	set_bit(BTRFS_DEV_STATE_FLUSH_SENT, &device->dev_state);
3352
}
C
Chris Mason 已提交
3353

3354 3355 3356
/*
 * If the flush bio has been submitted by write_dev_flush, wait for it.
 */
3357
static blk_status_t wait_dev_flush(struct btrfs_device *device)
3358 3359
{
	struct bio *bio = device->flush_bio;
C
Chris Mason 已提交
3360

3361
	if (!test_bit(BTRFS_DEV_STATE_FLUSH_SENT, &device->dev_state))
3362
		return BLK_STS_OK;
C
Chris Mason 已提交
3363

3364
	clear_bit(BTRFS_DEV_STATE_FLUSH_SENT, &device->dev_state);
3365
	wait_for_completion_io(&device->flush_wait);
C
Chris Mason 已提交
3366

3367
	return bio->bi_status;
C
Chris Mason 已提交
3368 3369
}

3370
static int check_barrier_error(struct btrfs_fs_info *fs_info)
3371
{
3372
	if (!btrfs_check_rw_degradable(fs_info, NULL))
3373
		return -EIO;
C
Chris Mason 已提交
3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384
	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;
3385
	int errors_wait = 0;
3386
	blk_status_t ret;
C
Chris Mason 已提交
3387

3388
	lockdep_assert_held(&info->fs_devices->device_list_mutex);
C
Chris Mason 已提交
3389 3390
	/* send down all the barriers */
	head = &info->fs_devices->devices;
3391
	list_for_each_entry(dev, head, dev_list) {
3392
		if (test_bit(BTRFS_DEV_STATE_MISSING, &dev->dev_state))
3393
			continue;
3394
		if (!dev->bdev)
C
Chris Mason 已提交
3395
			continue;
3396
		if (!test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &dev->dev_state) ||
3397
		    !test_bit(BTRFS_DEV_STATE_WRITEABLE, &dev->dev_state))
C
Chris Mason 已提交
3398 3399
			continue;

3400
		write_dev_flush(dev);
3401
		dev->last_flush_error = BLK_STS_OK;
C
Chris Mason 已提交
3402 3403 3404
	}

	/* wait for all the barriers */
3405
	list_for_each_entry(dev, head, dev_list) {
3406
		if (test_bit(BTRFS_DEV_STATE_MISSING, &dev->dev_state))
3407
			continue;
C
Chris Mason 已提交
3408
		if (!dev->bdev) {
3409
			errors_wait++;
C
Chris Mason 已提交
3410 3411
			continue;
		}
3412
		if (!test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &dev->dev_state) ||
3413
		    !test_bit(BTRFS_DEV_STATE_WRITEABLE, &dev->dev_state))
C
Chris Mason 已提交
3414 3415
			continue;

3416
		ret = wait_dev_flush(dev);
3417 3418
		if (ret) {
			dev->last_flush_error = ret;
3419 3420
			btrfs_dev_stat_inc_and_print(dev,
					BTRFS_DEV_STAT_FLUSH_ERRS);
3421
			errors_wait++;
3422 3423 3424
		}
	}

3425
	if (errors_wait) {
3426 3427 3428 3429 3430
		/*
		 * At some point we need the status of all disks
		 * to arrive at the volume status. So error checking
		 * is being pushed to a separate loop.
		 */
3431
		return check_barrier_error(info);
C
Chris Mason 已提交
3432 3433 3434 3435
	}
	return 0;
}

3436 3437
int btrfs_get_num_tolerated_disk_barrier_failures(u64 flags)
{
3438 3439
	int raid_type;
	int min_tolerated = INT_MAX;
3440

3441 3442 3443 3444 3445
	if ((flags & BTRFS_BLOCK_GROUP_PROFILE_MASK) == 0 ||
	    (flags & BTRFS_AVAIL_ALLOC_BIT_SINGLE))
		min_tolerated = min(min_tolerated,
				    btrfs_raid_array[BTRFS_RAID_SINGLE].
				    tolerated_failures);
3446

3447 3448 3449 3450 3451 3452 3453 3454 3455
	for (raid_type = 0; raid_type < BTRFS_NR_RAID_TYPES; raid_type++) {
		if (raid_type == BTRFS_RAID_SINGLE)
			continue;
		if (!(flags & btrfs_raid_group[raid_type]))
			continue;
		min_tolerated = min(min_tolerated,
				    btrfs_raid_array[raid_type].
				    tolerated_failures);
	}
3456

3457
	if (min_tolerated == INT_MAX) {
3458
		pr_warn("BTRFS: unknown raid flag: %llu", flags);
3459 3460 3461 3462
		min_tolerated = 0;
	}

	return min_tolerated;
3463 3464
}

3465
int write_all_supers(struct btrfs_fs_info *fs_info, int max_mirrors)
3466
{
3467
	struct list_head *head;
3468
	struct btrfs_device *dev;
3469
	struct btrfs_super_block *sb;
3470 3471 3472
	struct btrfs_dev_item *dev_item;
	int ret;
	int do_barriers;
3473 3474
	int max_errors;
	int total_errors = 0;
3475
	u64 flags;
3476

3477
	do_barriers = !btrfs_test_opt(fs_info, NOBARRIER);
3478 3479 3480 3481 3482 3483 3484 3485

	/*
	 * max_mirrors == 0 indicates we're from commit_transaction,
	 * not from fsync where the tree roots in fs_info have not
	 * been consistent on disk.
	 */
	if (max_mirrors == 0)
		backup_super_roots(fs_info);
3486

3487
	sb = fs_info->super_for_commit;
3488
	dev_item = &sb->dev_item;
3489

3490 3491 3492
	mutex_lock(&fs_info->fs_devices->device_list_mutex);
	head = &fs_info->fs_devices->devices;
	max_errors = btrfs_super_num_devices(fs_info->super_copy) - 1;
C
Chris Mason 已提交
3493

3494
	if (do_barriers) {
3495
		ret = barrier_all_devices(fs_info);
3496 3497
		if (ret) {
			mutex_unlock(
3498 3499 3500
				&fs_info->fs_devices->device_list_mutex);
			btrfs_handle_fs_error(fs_info, ret,
					      "errors while submitting device barriers.");
3501 3502 3503
			return ret;
		}
	}
C
Chris Mason 已提交
3504

3505
	list_for_each_entry(dev, head, dev_list) {
3506 3507 3508 3509
		if (!dev->bdev) {
			total_errors++;
			continue;
		}
3510
		if (!test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &dev->dev_state) ||
3511
		    !test_bit(BTRFS_DEV_STATE_WRITEABLE, &dev->dev_state))
3512 3513
			continue;

Y
Yan Zheng 已提交
3514
		btrfs_set_stack_device_generation(dev_item, 0);
3515 3516
		btrfs_set_stack_device_type(dev_item, dev->type);
		btrfs_set_stack_device_id(dev_item, dev->devid);
3517
		btrfs_set_stack_device_total_bytes(dev_item,
3518
						   dev->commit_total_bytes);
3519 3520
		btrfs_set_stack_device_bytes_used(dev_item,
						  dev->commit_bytes_used);
3521 3522 3523 3524
		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);
3525
		memcpy(dev_item->fsid, dev->fs_devices->fsid, BTRFS_FSID_SIZE);
Y
Yan Zheng 已提交
3526

3527 3528 3529
		flags = btrfs_super_flags(sb);
		btrfs_set_super_flags(sb, flags | BTRFS_HEADER_FLAG_WRITTEN);

3530
		ret = write_dev_supers(dev, sb, max_mirrors);
3531 3532
		if (ret)
			total_errors++;
3533
	}
3534
	if (total_errors > max_errors) {
3535 3536 3537
		btrfs_err(fs_info, "%d errors while writing supers",
			  total_errors);
		mutex_unlock(&fs_info->fs_devices->device_list_mutex);
3538

3539
		/* FUA is masked off if unsupported and can't be the reason */
3540 3541 3542
		btrfs_handle_fs_error(fs_info, -EIO,
				      "%d errors while writing supers",
				      total_errors);
3543
		return -EIO;
3544
	}
3545

Y
Yan Zheng 已提交
3546
	total_errors = 0;
3547
	list_for_each_entry(dev, head, dev_list) {
3548 3549
		if (!dev->bdev)
			continue;
3550
		if (!test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &dev->dev_state) ||
3551
		    !test_bit(BTRFS_DEV_STATE_WRITEABLE, &dev->dev_state))
3552 3553
			continue;

3554
		ret = wait_dev_supers(dev, max_mirrors);
Y
Yan Zheng 已提交
3555 3556
		if (ret)
			total_errors++;
3557
	}
3558
	mutex_unlock(&fs_info->fs_devices->device_list_mutex);
3559
	if (total_errors > max_errors) {
3560 3561 3562
		btrfs_handle_fs_error(fs_info, -EIO,
				      "%d errors while writing supers",
				      total_errors);
3563
		return -EIO;
3564
	}
3565 3566 3567
	return 0;
}

3568 3569 3570
/* 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 已提交
3571
{
3572
	spin_lock(&fs_info->fs_roots_radix_lock);
C
Chris Mason 已提交
3573 3574
	radix_tree_delete(&fs_info->fs_roots_radix,
			  (unsigned long)root->root_key.objectid);
3575
	spin_unlock(&fs_info->fs_roots_radix_lock);
3576 3577 3578 3579

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

L
Liu Bo 已提交
3580
	if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
L
Liu Bo 已提交
3581
		btrfs_free_log(NULL, root);
L
Liu Bo 已提交
3582 3583 3584 3585 3586 3587 3588
		if (root->reloc_root) {
			free_extent_buffer(root->reloc_root->node);
			free_extent_buffer(root->reloc_root->commit_root);
			btrfs_put_fs_root(root->reloc_root);
			root->reloc_root = NULL;
		}
	}
L
Liu Bo 已提交
3589

3590 3591 3592 3593
	if (root->free_ino_pinned)
		__btrfs_remove_free_space_cache(root->free_ino_pinned);
	if (root->free_ino_ctl)
		__btrfs_remove_free_space_cache(root->free_ino_ctl);
3594 3595 3596 3597 3598
	free_fs_root(root);
}

static void free_fs_root(struct btrfs_root *root)
{
3599
	iput(root->ino_cache_inode);
3600
	WARN_ON(!RB_EMPTY_ROOT(&root->inode_tree));
3601
	btrfs_free_block_rsv(root->fs_info, root->orphan_block_rsv);
3602
	root->orphan_block_rsv = NULL;
3603 3604
	if (root->anon_dev)
		free_anon_bdev(root->anon_dev);
3605 3606
	if (root->subv_writers)
		btrfs_free_subvolume_writers(root->subv_writers);
3607 3608
	free_extent_buffer(root->node);
	free_extent_buffer(root->commit_root);
3609 3610
	kfree(root->free_ino_ctl);
	kfree(root->free_ino_pinned);
C
Chris Mason 已提交
3611
	kfree(root->name);
3612
	btrfs_put_fs_root(root);
C
Chris Mason 已提交
3613 3614
}

3615 3616 3617
void btrfs_free_fs_root(struct btrfs_root *root)
{
	free_fs_root(root);
C
Chris Mason 已提交
3618 3619
}

Y
Yan Zheng 已提交
3620
int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info)
C
Chris Mason 已提交
3621
{
Y
Yan Zheng 已提交
3622 3623
	u64 root_objectid = 0;
	struct btrfs_root *gang[8];
3624 3625 3626 3627
	int i = 0;
	int err = 0;
	unsigned int ret = 0;
	int index;
3628

Y
Yan Zheng 已提交
3629
	while (1) {
3630
		index = srcu_read_lock(&fs_info->subvol_srcu);
Y
Yan Zheng 已提交
3631 3632 3633
		ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
					     (void **)gang, root_objectid,
					     ARRAY_SIZE(gang));
3634 3635
		if (!ret) {
			srcu_read_unlock(&fs_info->subvol_srcu, index);
Y
Yan Zheng 已提交
3636
			break;
3637
		}
3638
		root_objectid = gang[ret - 1]->root_key.objectid + 1;
3639

Y
Yan Zheng 已提交
3640
		for (i = 0; i < ret; i++) {
3641 3642 3643 3644 3645 3646 3647 3648 3649
			/* Avoid to grab roots in dead_roots */
			if (btrfs_root_refs(&gang[i]->root_item) == 0) {
				gang[i] = NULL;
				continue;
			}
			/* grab all the search result for later use */
			gang[i] = btrfs_grab_fs_root(gang[i]);
		}
		srcu_read_unlock(&fs_info->subvol_srcu, index);
3650

3651 3652 3653
		for (i = 0; i < ret; i++) {
			if (!gang[i])
				continue;
Y
Yan Zheng 已提交
3654
			root_objectid = gang[i]->root_key.objectid;
3655 3656
			err = btrfs_orphan_cleanup(gang[i]);
			if (err)
3657 3658
				break;
			btrfs_put_fs_root(gang[i]);
Y
Yan Zheng 已提交
3659 3660 3661
		}
		root_objectid++;
	}
3662 3663 3664 3665 3666 3667 3668

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

3671
int btrfs_commit_super(struct btrfs_fs_info *fs_info)
Y
Yan Zheng 已提交
3672
{
3673
	struct btrfs_root *root = fs_info->tree_root;
Y
Yan Zheng 已提交
3674
	struct btrfs_trans_handle *trans;
3675

3676
	mutex_lock(&fs_info->cleaner_mutex);
3677
	btrfs_run_delayed_iputs(fs_info);
3678 3679
	mutex_unlock(&fs_info->cleaner_mutex);
	wake_up_process(fs_info->cleaner_kthread);
3680 3681

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

3685
	trans = btrfs_join_transaction(root);
3686 3687
	if (IS_ERR(trans))
		return PTR_ERR(trans);
3688
	return btrfs_commit_transaction(trans);
Y
Yan Zheng 已提交
3689 3690
}

3691
void close_ctree(struct btrfs_fs_info *fs_info)
Y
Yan Zheng 已提交
3692
{
3693
	struct btrfs_root *root = fs_info->tree_root;
Y
Yan Zheng 已提交
3694 3695
	int ret;

3696
	set_bit(BTRFS_FS_CLOSING_START, &fs_info->flags);
Y
Yan Zheng 已提交
3697

3698
	/* wait for the qgroup rescan worker to stop */
3699
	btrfs_qgroup_wait_for_completion(fs_info, false);
3700

S
Stefan Behrens 已提交
3701 3702 3703 3704 3705
	/* 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);

3706
	/* pause restriper - we want to resume on mount */
3707
	btrfs_pause_balance(fs_info);
3708

3709 3710
	btrfs_dev_replace_suspend_for_unmount(fs_info);

3711
	btrfs_scrub_cancel(fs_info);
C
Chris Mason 已提交
3712 3713 3714 3715 3716 3717

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

3720 3721
	cancel_work_sync(&fs_info->async_reclaim_work);

3722
	if (!sb_rdonly(fs_info->sb)) {
3723 3724 3725 3726 3727
		/*
		 * If the cleaner thread is stopped and there are
		 * block groups queued for removal, the deletion will be
		 * skipped when we quit the cleaner thread.
		 */
3728
		btrfs_delete_unused_bgs(fs_info);
3729

3730
		ret = btrfs_commit_super(fs_info);
L
liubo 已提交
3731
		if (ret)
3732
			btrfs_err(fs_info, "commit super ret %d", ret);
L
liubo 已提交
3733 3734
	}

3735
	if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state))
3736
		btrfs_error_commit_super(fs_info);
3737

A
Al Viro 已提交
3738 3739
	kthread_stop(fs_info->transaction_kthread);
	kthread_stop(fs_info->cleaner_kthread);
3740

3741
	set_bit(BTRFS_FS_CLOSING_DONE, &fs_info->flags);
3742

3743
	btrfs_free_qgroup_config(fs_info);
3744

3745
	if (percpu_counter_sum(&fs_info->delalloc_bytes)) {
3746
		btrfs_info(fs_info, "at unmount delalloc count %lld",
3747
		       percpu_counter_sum(&fs_info->delalloc_bytes));
C
Chris Mason 已提交
3748
	}
3749

3750
	btrfs_sysfs_remove_mounted(fs_info);
3751
	btrfs_sysfs_remove_fsid(fs_info->fs_devices);
3752

3753
	btrfs_free_fs_roots(fs_info);
3754

3755 3756
	btrfs_put_block_group_cache(fs_info);

3757 3758 3759 3760 3761
	/*
	 * we must make sure there is not any read request to
	 * submit after we stopping all workers.
	 */
	invalidate_inode_pages2(fs_info->btree_inode->i_mapping);
3762 3763
	btrfs_stop_all_workers(fs_info);

3764 3765
	btrfs_free_block_groups(fs_info);

3766
	clear_bit(BTRFS_FS_OPEN, &fs_info->flags);
3767
	free_root_pointers(fs_info, 1);
3768

3769
	iput(fs_info->btree_inode);
3770

3771
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
3772
	if (btrfs_test_opt(fs_info, CHECK_INTEGRITY))
3773
		btrfsic_unmount(fs_info->fs_devices);
3774 3775
#endif

3776
	btrfs_close_devices(fs_info->fs_devices);
3777
	btrfs_mapping_tree_free(&fs_info->mapping_tree);
3778

3779
	percpu_counter_destroy(&fs_info->dirty_metadata_bytes);
3780
	percpu_counter_destroy(&fs_info->delalloc_bytes);
3781
	percpu_counter_destroy(&fs_info->bio_counter);
3782
	cleanup_srcu_struct(&fs_info->subvol_srcu);
3783

D
David Woodhouse 已提交
3784
	btrfs_free_stripe_hash_table(fs_info);
J
Josef Bacik 已提交
3785
	btrfs_free_ref_cache(fs_info);
D
David Woodhouse 已提交
3786

3787
	__btrfs_free_block_rsv(root->orphan_block_rsv);
3788
	root->orphan_block_rsv = NULL;
3789 3790 3791 3792 3793 3794 3795 3796 3797

	while (!list_empty(&fs_info->pinned_chunks)) {
		struct extent_map *em;

		em = list_first_entry(&fs_info->pinned_chunks,
				      struct extent_map, list);
		list_del_init(&em->list);
		free_extent_map(em);
	}
3798 3799
}

3800 3801
int btrfs_buffer_uptodate(struct extent_buffer *buf, u64 parent_transid,
			  int atomic)
3802
{
3803
	int ret;
3804
	struct inode *btree_inode = buf->pages[0]->mapping->host;
3805

3806
	ret = extent_buffer_uptodate(buf);
3807 3808 3809 3810
	if (!ret)
		return ret;

	ret = verify_parent_transid(&BTRFS_I(btree_inode)->io_tree, buf,
3811 3812 3813
				    parent_transid, atomic);
	if (ret == -EAGAIN)
		return ret;
3814
	return !ret;
3815 3816 3817 3818
}

void btrfs_mark_buffer_dirty(struct extent_buffer *buf)
{
3819
	struct btrfs_fs_info *fs_info;
3820
	struct btrfs_root *root;
3821
	u64 transid = btrfs_header_generation(buf);
3822
	int was_dirty;
3823

3824 3825 3826 3827 3828 3829 3830 3831 3832 3833
#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;
3834
	fs_info = root->fs_info;
3835
	btrfs_assert_tree_locked(buf);
3836
	if (transid != fs_info->generation)
J
Jeff Mahoney 已提交
3837
		WARN(1, KERN_CRIT "btrfs transid mismatch buffer %llu, found %llu running %llu\n",
3838
			buf->start, transid, fs_info->generation);
3839
	was_dirty = set_extent_buffer_dirty(buf);
3840
	if (!was_dirty)
3841 3842 3843
		percpu_counter_add_batch(&fs_info->dirty_metadata_bytes,
					 buf->len,
					 fs_info->dirty_metadata_batch);
3844
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
3845 3846 3847 3848 3849 3850 3851
	/*
	 * Since btrfs_mark_buffer_dirty() can be called with item pointer set
	 * but item data not updated.
	 * So here we should only check item pointers, not item data.
	 */
	if (btrfs_header_level(buf) == 0 &&
	    btrfs_check_leaf_relaxed(root, buf)) {
3852
		btrfs_print_leaf(buf);
3853 3854 3855
		ASSERT(0);
	}
#endif
3856 3857
}

3858
static void __btrfs_btree_balance_dirty(struct btrfs_fs_info *fs_info,
3859
					int flush_delayed)
3860 3861 3862 3863 3864
{
	/*
	 * looks as though older kernels can get into trouble with
	 * this code, they end up stuck in balance_dirty_pages forever
	 */
3865
	int ret;
3866 3867 3868 3869

	if (current->flags & PF_MEMALLOC)
		return;

3870
	if (flush_delayed)
3871
		btrfs_balance_delayed_items(fs_info);
3872

3873
	ret = percpu_counter_compare(&fs_info->dirty_metadata_bytes,
3874 3875
				     BTRFS_DIRTY_METADATA_THRESH);
	if (ret > 0) {
3876
		balance_dirty_pages_ratelimited(fs_info->btree_inode->i_mapping);
3877 3878 3879
	}
}

3880
void btrfs_btree_balance_dirty(struct btrfs_fs_info *fs_info)
C
Chris Mason 已提交
3881
{
3882
	__btrfs_btree_balance_dirty(fs_info, 1);
3883
}
3884

3885
void btrfs_btree_balance_dirty_nodelay(struct btrfs_fs_info *fs_info)
3886
{
3887
	__btrfs_btree_balance_dirty(fs_info, 0);
C
Chris Mason 已提交
3888
}
3889

3890
int btrfs_read_buffer(struct extent_buffer *buf, u64 parent_transid)
3891
{
3892
	struct btrfs_root *root = BTRFS_I(buf->pages[0]->mapping->host)->root;
3893 3894 3895
	struct btrfs_fs_info *fs_info = root->fs_info;

	return btree_read_extent_buffer_pages(fs_info, buf, parent_transid);
3896
}
3897

3898
static int btrfs_check_super_valid(struct btrfs_fs_info *fs_info)
L
liubo 已提交
3899
{
D
David Sterba 已提交
3900
	struct btrfs_super_block *sb = fs_info->super_copy;
3901 3902
	u64 nodesize = btrfs_super_nodesize(sb);
	u64 sectorsize = btrfs_super_sectorsize(sb);
D
David Sterba 已提交
3903 3904
	int ret = 0;

3905
	if (btrfs_super_magic(sb) != BTRFS_MAGIC) {
3906
		btrfs_err(fs_info, "no valid FS found");
3907 3908 3909
		ret = -EINVAL;
	}
	if (btrfs_super_flags(sb) & ~BTRFS_SUPER_FLAG_SUPP)
3910
		btrfs_warn(fs_info, "unrecognized super flag: %llu",
3911
				btrfs_super_flags(sb) & ~BTRFS_SUPER_FLAG_SUPP);
3912
	if (btrfs_super_root_level(sb) >= BTRFS_MAX_LEVEL) {
3913
		btrfs_err(fs_info, "tree_root level too big: %d >= %d",
3914
				btrfs_super_root_level(sb), BTRFS_MAX_LEVEL);
D
David Sterba 已提交
3915 3916
		ret = -EINVAL;
	}
3917
	if (btrfs_super_chunk_root_level(sb) >= BTRFS_MAX_LEVEL) {
3918
		btrfs_err(fs_info, "chunk_root level too big: %d >= %d",
3919
				btrfs_super_chunk_root_level(sb), BTRFS_MAX_LEVEL);
D
David Sterba 已提交
3920 3921
		ret = -EINVAL;
	}
3922
	if (btrfs_super_log_root_level(sb) >= BTRFS_MAX_LEVEL) {
3923
		btrfs_err(fs_info, "log_root level too big: %d >= %d",
3924
				btrfs_super_log_root_level(sb), BTRFS_MAX_LEVEL);
D
David Sterba 已提交
3925 3926 3927
		ret = -EINVAL;
	}

D
David Sterba 已提交
3928
	/*
3929 3930
	 * Check sectorsize and nodesize first, other check will need it.
	 * Check all possible sectorsize(4K, 8K, 16K, 32K, 64K) here.
D
David Sterba 已提交
3931
	 */
3932 3933
	if (!is_power_of_2(sectorsize) || sectorsize < 4096 ||
	    sectorsize > BTRFS_MAX_METADATA_BLOCKSIZE) {
3934
		btrfs_err(fs_info, "invalid sectorsize %llu", sectorsize);
3935 3936 3937
		ret = -EINVAL;
	}
	/* Only PAGE SIZE is supported yet */
3938
	if (sectorsize != PAGE_SIZE) {
3939 3940 3941
		btrfs_err(fs_info,
			"sectorsize %llu not supported yet, only support %lu",
			sectorsize, PAGE_SIZE);
3942 3943 3944 3945
		ret = -EINVAL;
	}
	if (!is_power_of_2(nodesize) || nodesize < sectorsize ||
	    nodesize > BTRFS_MAX_METADATA_BLOCKSIZE) {
3946
		btrfs_err(fs_info, "invalid nodesize %llu", nodesize);
3947 3948 3949
		ret = -EINVAL;
	}
	if (nodesize != le32_to_cpu(sb->__unused_leafsize)) {
3950 3951
		btrfs_err(fs_info, "invalid leafsize %u, should be %llu",
			  le32_to_cpu(sb->__unused_leafsize), nodesize);
3952 3953 3954 3955 3956
		ret = -EINVAL;
	}

	/* Root alignment check */
	if (!IS_ALIGNED(btrfs_super_root(sb), sectorsize)) {
3957 3958
		btrfs_warn(fs_info, "tree_root block unaligned: %llu",
			   btrfs_super_root(sb));
3959 3960 3961
		ret = -EINVAL;
	}
	if (!IS_ALIGNED(btrfs_super_chunk_root(sb), sectorsize)) {
3962 3963
		btrfs_warn(fs_info, "chunk_root block unaligned: %llu",
			   btrfs_super_chunk_root(sb));
3964 3965
		ret = -EINVAL;
	}
3966
	if (!IS_ALIGNED(btrfs_super_log_root(sb), sectorsize)) {
3967 3968
		btrfs_warn(fs_info, "log_root block unaligned: %llu",
			   btrfs_super_log_root(sb));
3969 3970 3971
		ret = -EINVAL;
	}

3972
	if (memcmp(fs_info->fsid, sb->dev_item.fsid, BTRFS_FSID_SIZE) != 0) {
3973 3974 3975
		btrfs_err(fs_info,
			   "dev_item UUID does not match fsid: %pU != %pU",
			   fs_info->fsid, sb->dev_item.fsid);
D
David Sterba 已提交
3976 3977 3978 3979 3980 3981 3982
		ret = -EINVAL;
	}

	/*
	 * Hint to catch really bogus numbers, bitflips or so, more exact checks are
	 * done later
	 */
3983 3984
	if (btrfs_super_bytes_used(sb) < 6 * btrfs_super_nodesize(sb)) {
		btrfs_err(fs_info, "bytes_used is too small %llu",
3985
			  btrfs_super_bytes_used(sb));
3986 3987
		ret = -EINVAL;
	}
3988
	if (!is_power_of_2(btrfs_super_stripesize(sb))) {
3989
		btrfs_err(fs_info, "invalid stripesize %u",
3990
			  btrfs_super_stripesize(sb));
3991 3992
		ret = -EINVAL;
	}
3993
	if (btrfs_super_num_devices(sb) > (1UL << 31))
3994 3995
		btrfs_warn(fs_info, "suspicious number of devices: %llu",
			   btrfs_super_num_devices(sb));
3996
	if (btrfs_super_num_devices(sb) == 0) {
3997
		btrfs_err(fs_info, "number of devices is 0");
3998 3999
		ret = -EINVAL;
	}
D
David Sterba 已提交
4000

4001
	if (btrfs_super_bytenr(sb) != BTRFS_SUPER_INFO_OFFSET) {
4002 4003
		btrfs_err(fs_info, "super offset mismatch %llu != %u",
			  btrfs_super_bytenr(sb), BTRFS_SUPER_INFO_OFFSET);
D
David Sterba 已提交
4004 4005 4006
		ret = -EINVAL;
	}

4007 4008 4009 4010 4011
	/*
	 * Obvious sys_chunk_array corruptions, it must hold at least one key
	 * and one chunk
	 */
	if (btrfs_super_sys_array_size(sb) > BTRFS_SYSTEM_CHUNK_ARRAY_SIZE) {
4012 4013 4014
		btrfs_err(fs_info, "system chunk array too big %u > %u",
			  btrfs_super_sys_array_size(sb),
			  BTRFS_SYSTEM_CHUNK_ARRAY_SIZE);
4015 4016 4017 4018
		ret = -EINVAL;
	}
	if (btrfs_super_sys_array_size(sb) < sizeof(struct btrfs_disk_key)
			+ sizeof(struct btrfs_chunk)) {
4019 4020 4021 4022
		btrfs_err(fs_info, "system chunk array too small %u < %zu",
			  btrfs_super_sys_array_size(sb),
			  sizeof(struct btrfs_disk_key)
			  + sizeof(struct btrfs_chunk));
4023 4024 4025
		ret = -EINVAL;
	}

D
David Sterba 已提交
4026 4027 4028 4029
	/*
	 * The generation is a global counter, we'll trust it more than the others
	 * but it's still possible that it's the one that's wrong.
	 */
4030
	if (btrfs_super_generation(sb) < btrfs_super_chunk_root_generation(sb))
4031 4032 4033 4034
		btrfs_warn(fs_info,
			"suspicious: generation < chunk_root_generation: %llu < %llu",
			btrfs_super_generation(sb),
			btrfs_super_chunk_root_generation(sb));
4035 4036
	if (btrfs_super_generation(sb) < btrfs_super_cache_generation(sb)
	    && btrfs_super_cache_generation(sb) != (u64)-1)
4037 4038 4039 4040
		btrfs_warn(fs_info,
			"suspicious: generation < cache_generation: %llu < %llu",
			btrfs_super_generation(sb),
			btrfs_super_cache_generation(sb));
D
David Sterba 已提交
4041 4042

	return ret;
L
liubo 已提交
4043 4044
}

4045
static void btrfs_error_commit_super(struct btrfs_fs_info *fs_info)
L
liubo 已提交
4046
{
4047
	mutex_lock(&fs_info->cleaner_mutex);
4048
	btrfs_run_delayed_iputs(fs_info);
4049
	mutex_unlock(&fs_info->cleaner_mutex);
L
liubo 已提交
4050

4051 4052
	down_write(&fs_info->cleanup_work_sem);
	up_write(&fs_info->cleanup_work_sem);
L
liubo 已提交
4053 4054

	/* cleanup FS via transaction */
4055
	btrfs_cleanup_transaction(fs_info);
L
liubo 已提交
4056 4057
}

4058
static void btrfs_destroy_ordered_extents(struct btrfs_root *root)
L
liubo 已提交
4059 4060 4061
{
	struct btrfs_ordered_extent *ordered;

4062
	spin_lock(&root->ordered_extent_lock);
4063 4064 4065 4066
	/*
	 * This will just short circuit the ordered completion stuff which will
	 * make sure the ordered extent gets properly cleaned up.
	 */
4067
	list_for_each_entry(ordered, &root->ordered_extents,
4068 4069
			    root_extent_list)
		set_bit(BTRFS_ORDERED_IOERR, &ordered->flags);
4070 4071 4072 4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084
	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);
4085 4086
		list_move_tail(&root->ordered_root,
			       &fs_info->ordered_roots);
4087

4088
		spin_unlock(&fs_info->ordered_root_lock);
4089 4090
		btrfs_destroy_ordered_extents(root);

4091 4092
		cond_resched();
		spin_lock(&fs_info->ordered_root_lock);
4093 4094
	}
	spin_unlock(&fs_info->ordered_root_lock);
L
liubo 已提交
4095 4096
}

4097
static int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans,
4098
				      struct btrfs_fs_info *fs_info)
L
liubo 已提交
4099 4100 4101 4102 4103 4104 4105 4106 4107
{
	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);
4108
	if (atomic_read(&delayed_refs->num_entries) == 0) {
4109
		spin_unlock(&delayed_refs->lock);
4110
		btrfs_info(fs_info, "delayed_refs has NO entry");
L
liubo 已提交
4111 4112 4113
		return ret;
	}

4114 4115
	while ((node = rb_first(&delayed_refs->href_root)) != NULL) {
		struct btrfs_delayed_ref_head *head;
4116
		struct rb_node *n;
4117
		bool pin_bytes = false;
L
liubo 已提交
4118

4119 4120 4121
		head = rb_entry(node, struct btrfs_delayed_ref_head,
				href_node);
		if (!mutex_trylock(&head->mutex)) {
4122
			refcount_inc(&head->refs);
4123
			spin_unlock(&delayed_refs->lock);
4124

4125
			mutex_lock(&head->mutex);
4126
			mutex_unlock(&head->mutex);
4127
			btrfs_put_delayed_ref_head(head);
4128 4129 4130 4131
			spin_lock(&delayed_refs->lock);
			continue;
		}
		spin_lock(&head->lock);
4132 4133 4134
		while ((n = rb_first(&head->ref_tree)) != NULL) {
			ref = rb_entry(n, struct btrfs_delayed_ref_node,
				       ref_node);
4135
			ref->in_tree = 0;
4136 4137
			rb_erase(&ref->ref_node, &head->ref_tree);
			RB_CLEAR_NODE(&ref->ref_node);
4138 4139
			if (!list_empty(&ref->add_list))
				list_del(&ref->add_list);
4140 4141
			atomic_dec(&delayed_refs->num_entries);
			btrfs_put_delayed_ref(ref);
4142
		}
4143 4144 4145 4146 4147 4148 4149 4150
		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);
		rb_erase(&head->href_node, &delayed_refs->href_root);
4151
		RB_CLEAR_NODE(&head->href_node);
4152 4153 4154
		spin_unlock(&head->lock);
		spin_unlock(&delayed_refs->lock);
		mutex_unlock(&head->mutex);
L
liubo 已提交
4155

4156
		if (pin_bytes)
4157 4158 4159
			btrfs_pin_extent(fs_info, head->bytenr,
					 head->num_bytes, 1);
		btrfs_put_delayed_ref_head(head);
L
liubo 已提交
4160 4161 4162 4163 4164 4165 4166 4167 4168
		cond_resched();
		spin_lock(&delayed_refs->lock);
	}

	spin_unlock(&delayed_refs->lock);

	return ret;
}

4169
static void btrfs_destroy_delalloc_inodes(struct btrfs_root *root)
L
liubo 已提交
4170 4171 4172 4173 4174 4175
{
	struct btrfs_inode *btrfs_inode;
	struct list_head splice;

	INIT_LIST_HEAD(&splice);

4176 4177
	spin_lock(&root->delalloc_lock);
	list_splice_init(&root->delalloc_inodes, &splice);
L
liubo 已提交
4178 4179

	while (!list_empty(&splice)) {
4180 4181
		btrfs_inode = list_first_entry(&splice, struct btrfs_inode,
					       delalloc_inodes);
L
liubo 已提交
4182 4183

		list_del_init(&btrfs_inode->delalloc_inodes);
4184 4185
		clear_bit(BTRFS_INODE_IN_DELALLOC_LIST,
			  &btrfs_inode->runtime_flags);
4186
		spin_unlock(&root->delalloc_lock);
L
liubo 已提交
4187 4188

		btrfs_invalidate_inodes(btrfs_inode->root);
4189

4190
		spin_lock(&root->delalloc_lock);
L
liubo 已提交
4191 4192
	}

4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218
	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 已提交
4219 4220
}

4221
static int btrfs_destroy_marked_extents(struct btrfs_fs_info *fs_info,
L
liubo 已提交
4222 4223 4224 4225 4226 4227 4228 4229 4230 4231
					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,
4232
					    mark, NULL);
L
liubo 已提交
4233 4234 4235
		if (ret)
			break;

4236
		clear_extent_bits(dirty_pages, start, end, mark);
L
liubo 已提交
4237
		while (start <= end) {
4238 4239
			eb = find_extent_buffer(fs_info, start);
			start += fs_info->nodesize;
4240
			if (!eb)
L
liubo 已提交
4241
				continue;
4242
			wait_on_extent_buffer_writeback(eb);
L
liubo 已提交
4243

4244 4245 4246 4247
			if (test_and_clear_bit(EXTENT_BUFFER_DIRTY,
					       &eb->bflags))
				clear_extent_buffer_dirty(eb);
			free_extent_buffer_stale(eb);
L
liubo 已提交
4248 4249 4250 4251 4252 4253
		}
	}

	return ret;
}

4254
static int btrfs_destroy_pinned_extent(struct btrfs_fs_info *fs_info,
L
liubo 已提交
4255 4256 4257 4258 4259 4260
				       struct extent_io_tree *pinned_extents)
{
	struct extent_io_tree *unpin;
	u64 start;
	u64 end;
	int ret;
4261
	bool loop = true;
L
liubo 已提交
4262 4263

	unpin = pinned_extents;
4264
again:
L
liubo 已提交
4265 4266
	while (1) {
		ret = find_first_extent_bit(unpin, 0, &start, &end,
4267
					    EXTENT_DIRTY, NULL);
L
liubo 已提交
4268 4269 4270
		if (ret)
			break;

4271
		clear_extent_dirty(unpin, start, end);
4272
		btrfs_error_unpin_extent_range(fs_info, start, end);
L
liubo 已提交
4273 4274 4275
		cond_resched();
	}

4276
	if (loop) {
4277 4278
		if (unpin == &fs_info->freed_extents[0])
			unpin = &fs_info->freed_extents[1];
4279
		else
4280
			unpin = &fs_info->freed_extents[0];
4281 4282 4283 4284
		loop = false;
		goto again;
	}

L
liubo 已提交
4285 4286 4287
	return 0;
}

4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302
static void btrfs_cleanup_bg_io(struct btrfs_block_group_cache *cache)
{
	struct inode *inode;

	inode = cache->io_ctl.inode;
	if (inode) {
		invalidate_inode_pages2(inode->i_mapping);
		BTRFS_I(inode)->generation = 0;
		cache->io_ctl.inode = NULL;
		iput(inode);
	}
	btrfs_put_block_group(cache);
}

void btrfs_cleanup_dirty_bgs(struct btrfs_transaction *cur_trans,
4303
			     struct btrfs_fs_info *fs_info)
4304 4305 4306 4307 4308 4309 4310 4311 4312
{
	struct btrfs_block_group_cache *cache;

	spin_lock(&cur_trans->dirty_bgs_lock);
	while (!list_empty(&cur_trans->dirty_bgs)) {
		cache = list_first_entry(&cur_trans->dirty_bgs,
					 struct btrfs_block_group_cache,
					 dirty_list);
		if (!cache) {
4313
			btrfs_err(fs_info, "orphan block group dirty_bgs list");
4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339 4340
			spin_unlock(&cur_trans->dirty_bgs_lock);
			return;
		}

		if (!list_empty(&cache->io_list)) {
			spin_unlock(&cur_trans->dirty_bgs_lock);
			list_del_init(&cache->io_list);
			btrfs_cleanup_bg_io(cache);
			spin_lock(&cur_trans->dirty_bgs_lock);
		}

		list_del_init(&cache->dirty_list);
		spin_lock(&cache->lock);
		cache->disk_cache_state = BTRFS_DC_ERROR;
		spin_unlock(&cache->lock);

		spin_unlock(&cur_trans->dirty_bgs_lock);
		btrfs_put_block_group(cache);
		spin_lock(&cur_trans->dirty_bgs_lock);
	}
	spin_unlock(&cur_trans->dirty_bgs_lock);

	while (!list_empty(&cur_trans->io_bgs)) {
		cache = list_first_entry(&cur_trans->io_bgs,
					 struct btrfs_block_group_cache,
					 io_list);
		if (!cache) {
4341
			btrfs_err(fs_info, "orphan block group on io_bgs list");
4342 4343 4344 4345 4346 4347 4348 4349 4350 4351 4352
			return;
		}

		list_del_init(&cache->io_list);
		spin_lock(&cache->lock);
		cache->disk_cache_state = BTRFS_DC_ERROR;
		spin_unlock(&cache->lock);
		btrfs_cleanup_bg_io(cache);
	}
}

4353
void btrfs_cleanup_one_transaction(struct btrfs_transaction *cur_trans,
4354
				   struct btrfs_fs_info *fs_info)
4355
{
4356
	btrfs_cleanup_dirty_bgs(cur_trans, fs_info);
4357 4358 4359
	ASSERT(list_empty(&cur_trans->dirty_bgs));
	ASSERT(list_empty(&cur_trans->io_bgs));

4360
	btrfs_destroy_delayed_refs(cur_trans, fs_info);
4361

4362
	cur_trans->state = TRANS_STATE_COMMIT_START;
4363
	wake_up(&fs_info->transaction_blocked_wait);
4364

4365
	cur_trans->state = TRANS_STATE_UNBLOCKED;
4366
	wake_up(&fs_info->transaction_wait);
4367

4368 4369
	btrfs_destroy_delayed_inodes(fs_info);
	btrfs_assert_delayed_root_empty(fs_info);
4370

4371
	btrfs_destroy_marked_extents(fs_info, &cur_trans->dirty_pages,
4372
				     EXTENT_DIRTY);
4373
	btrfs_destroy_pinned_extent(fs_info,
4374
				    fs_info->pinned_extents);
4375

4376 4377
	cur_trans->state =TRANS_STATE_COMPLETED;
	wake_up(&cur_trans->commit_wait);
4378 4379
}

4380
static int btrfs_cleanup_transaction(struct btrfs_fs_info *fs_info)
L
liubo 已提交
4381 4382 4383
{
	struct btrfs_transaction *t;

4384
	mutex_lock(&fs_info->transaction_kthread_mutex);
L
liubo 已提交
4385

4386 4387 4388
	spin_lock(&fs_info->trans_lock);
	while (!list_empty(&fs_info->trans_list)) {
		t = list_first_entry(&fs_info->trans_list,
4389 4390
				     struct btrfs_transaction, list);
		if (t->state >= TRANS_STATE_COMMIT_START) {
4391
			refcount_inc(&t->use_count);
4392
			spin_unlock(&fs_info->trans_lock);
4393
			btrfs_wait_for_commit(fs_info, t->transid);
4394
			btrfs_put_transaction(t);
4395
			spin_lock(&fs_info->trans_lock);
4396 4397
			continue;
		}
4398
		if (t == fs_info->running_transaction) {
4399
			t->state = TRANS_STATE_COMMIT_DOING;
4400
			spin_unlock(&fs_info->trans_lock);
4401 4402 4403 4404 4405 4406 4407
			/*
			 * 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 {
4408
			spin_unlock(&fs_info->trans_lock);
4409
		}
4410
		btrfs_cleanup_one_transaction(t, fs_info);
4411

4412 4413 4414
		spin_lock(&fs_info->trans_lock);
		if (t == fs_info->running_transaction)
			fs_info->running_transaction = NULL;
L
liubo 已提交
4415
		list_del_init(&t->list);
4416
		spin_unlock(&fs_info->trans_lock);
L
liubo 已提交
4417

4418
		btrfs_put_transaction(t);
4419
		trace_btrfs_transaction_commit(fs_info->tree_root);
4420
		spin_lock(&fs_info->trans_lock);
4421
	}
4422 4423
	spin_unlock(&fs_info->trans_lock);
	btrfs_destroy_all_ordered_extents(fs_info);
4424 4425
	btrfs_destroy_delayed_inodes(fs_info);
	btrfs_assert_delayed_root_empty(fs_info);
4426
	btrfs_destroy_pinned_extent(fs_info, fs_info->pinned_extents);
4427 4428
	btrfs_destroy_all_delalloc_inodes(fs_info);
	mutex_unlock(&fs_info->transaction_kthread_mutex);
L
liubo 已提交
4429 4430 4431 4432

	return 0;
}

4433 4434 4435 4436 4437 4438
static struct btrfs_fs_info *btree_fs_info(void *private_data)
{
	struct inode *inode = private_data;
	return btrfs_sb(inode->i_sb);
}

4439
static const struct extent_io_ops btree_extent_io_ops = {
4440
	/* mandatory callbacks */
4441
	.submit_bio_hook = btree_submit_bio_hook,
4442
	.readpage_end_io_hook = btree_readpage_end_io_hook,
4443 4444
	/* note we're sharing with inode.c for the merge bio hook */
	.merge_bio_hook = btrfs_merge_bio_hook,
4445
	.readpage_io_failed_hook = btree_io_failed_hook,
4446 4447
	.set_range_writeback = btrfs_set_range_writeback,
	.tree_fs_info = btree_fs_info,
4448 4449

	/* optional callbacks */
4450
};