disk-io.c 125.9 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0
C
Chris Mason 已提交
2 3 4 5
/*
 * Copyright (C) 2007 Oracle.  All rights reserved.
 */

C
Chris Mason 已提交
6
#include <linux/fs.h>
7
#include <linux/blkdev.h>
8
#include <linux/radix-tree.h>
C
Chris Mason 已提交
9
#include <linux/writeback.h>
C
Chris Mason 已提交
10
#include <linux/buffer_head.h>
11
#include <linux/workqueue.h>
12
#include <linux/kthread.h>
13
#include <linux/slab.h>
14
#include <linux/migrate.h>
15
#include <linux/ratelimit.h>
16
#include <linux/uuid.h>
S
Stefan Behrens 已提交
17
#include <linux/semaphore.h>
18
#include <linux/error-injection.h>
19
#include <linux/crc32c.h>
20
#include <linux/sched/mm.h>
21
#include <asm/unaligned.h>
22
#include <crypto/hash.h>
23 24
#include "ctree.h"
#include "disk-io.h"
25
#include "transaction.h"
26
#include "btrfs_inode.h"
27
#include "volumes.h"
28
#include "print-tree.h"
29
#include "locking.h"
30
#include "tree-log.h"
31
#include "free-space-cache.h"
32
#include "free-space-tree.h"
33
#include "inode-map.h"
34
#include "check-integrity.h"
35
#include "rcu-string.h"
36
#include "dev-replace.h"
D
David Woodhouse 已提交
37
#include "raid56.h"
38
#include "sysfs.h"
J
Josef Bacik 已提交
39
#include "qgroup.h"
40
#include "compression.h"
41
#include "tree-checker.h"
J
Josef Bacik 已提交
42
#include "ref-verify.h"
43
#include "block-group.h"
44
#include "discard.h"
45

46 47 48 49
#define BTRFS_SUPER_FLAG_SUPP	(BTRFS_HEADER_FLAG_WRITTEN |\
				 BTRFS_HEADER_FLAG_RELOC |\
				 BTRFS_SUPER_FLAG_ERROR |\
				 BTRFS_SUPER_FLAG_SEEDING |\
50 51
				 BTRFS_SUPER_FLAG_METADUMP |\
				 BTRFS_SUPER_FLAG_METADUMP_V2)
52

53
static const struct extent_io_ops btree_extent_io_ops;
54
static void end_workqueue_fn(struct btrfs_work *work);
55
static void btrfs_destroy_ordered_extents(struct btrfs_root *root);
L
liubo 已提交
56
static int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans,
57
				      struct btrfs_fs_info *fs_info);
58
static void btrfs_destroy_delalloc_inodes(struct btrfs_root *root);
59
static int btrfs_destroy_marked_extents(struct btrfs_fs_info *fs_info,
L
liubo 已提交
60 61
					struct extent_io_tree *dirty_pages,
					int mark);
62
static int btrfs_destroy_pinned_extent(struct btrfs_fs_info *fs_info,
L
liubo 已提交
63
				       struct extent_io_tree *pinned_extents);
64 65
static int btrfs_cleanup_transaction(struct btrfs_fs_info *fs_info);
static void btrfs_error_commit_super(struct btrfs_fs_info *fs_info);
66

C
Chris Mason 已提交
67
/*
68 69
 * 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 已提交
70 71
 * by writes to insert metadata for new file extents after IO is complete.
 */
72
struct btrfs_end_io_wq {
73 74 75 76
	struct bio *bio;
	bio_end_io_t *end_io;
	void *private;
	struct btrfs_fs_info *info;
77
	blk_status_t status;
78
	enum btrfs_wq_endio_type metadata;
79
	struct btrfs_work work;
80
};
81

82 83 84 85 86 87 88
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,
89
					SLAB_MEM_SPREAD,
90 91 92 93 94 95
					NULL);
	if (!btrfs_end_io_wq_cache)
		return -ENOMEM;
	return 0;
}

96
void __cold btrfs_end_io_wq_exit(void)
97
{
98
	kmem_cache_destroy(btrfs_end_io_wq_cache);
99 100
}

101 102 103 104 105 106
static void btrfs_free_csum_hash(struct btrfs_fs_info *fs_info)
{
	if (fs_info->csum_shash)
		crypto_free_shash(fs_info->csum_shash);
}

C
Chris Mason 已提交
107 108 109 110 111
/*
 * 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.
 */
112
struct async_submit_bio {
113
	void *private_data;
114
	struct bio *bio;
115
	extent_submit_bio_start_t *submit_bio_start;
116
	int mirror_num;
117 118 119 120 121
	/*
	 * 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;
122
	struct btrfs_work work;
123
	blk_status_t status;
124 125
};

126 127 128 129 130 131 132 133
/*
 * 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
134 135
 * by btrfs_root->root_key.objectid.  This ensures that all special purpose
 * roots have separate keysets.
136
 *
137 138 139
 * 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.
140
 *
141 142 143
 * 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.
144
 *
145 146 147
 * 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.
148 149 150 151 152
 */
#ifdef CONFIG_DEBUG_LOCK_ALLOC
# if BTRFS_MAX_LEVEL != 8
#  error
# endif
153 154 155 156 157 158 159 160 161 162 163 164 165

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"	},
166
	{ .id = BTRFS_QUOTA_TREE_OBJECTID,	.name_stem = "quota"	},
167 168 169
	{ .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"	},
170
	{ .id = BTRFS_UUID_TREE_OBJECTID,	.name_stem = "uuid"	},
171
	{ .id = BTRFS_FREE_SPACE_TREE_OBJECTID,	.name_stem = "free-space" },
172
	{ .id = 0,				.name_stem = "tree"	},
173
};
174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204

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

205 206
#endif

C
Chris Mason 已提交
207 208 209 210
/*
 * extents on the btree inode are pretty simple, there's one extent
 * that covers the entire device
 */
211
struct extent_map *btree_get_extent(struct btrfs_inode *inode,
212 213
				    struct page *page, size_t pg_offset,
				    u64 start, u64 len)
214
{
215
	struct extent_map_tree *em_tree = &inode->extent_tree;
216 217 218
	struct extent_map *em;
	int ret;

219
	read_lock(&em_tree->lock);
220
	em = lookup_extent_mapping(em_tree, start, len);
221
	if (em) {
222
		read_unlock(&em_tree->lock);
223
		goto out;
224
	}
225
	read_unlock(&em_tree->lock);
226

227
	em = alloc_extent_map();
228 229 230 231 232
	if (!em) {
		em = ERR_PTR(-ENOMEM);
		goto out;
	}
	em->start = 0;
233
	em->len = (u64)-1;
C
Chris Mason 已提交
234
	em->block_len = (u64)-1;
235
	em->block_start = 0;
236

237
	write_lock(&em_tree->lock);
J
Josef Bacik 已提交
238
	ret = add_extent_mapping(em_tree, em, 0);
239 240
	if (ret == -EEXIST) {
		free_extent_map(em);
241
		em = lookup_extent_mapping(em_tree, start, len);
242
		if (!em)
243
			em = ERR_PTR(-EIO);
244
	} else if (ret) {
245
		free_extent_map(em);
246
		em = ERR_PTR(ret);
247
	}
248
	write_unlock(&em_tree->lock);
249

250 251
out:
	return em;
252 253
}

C
Chris Mason 已提交
254
/*
255 256 257
 * Compute the csum of a btree block and store the result to provided buffer.
 *
 * Returns error if the extent buffer cannot be mapped.
C
Chris Mason 已提交
258
 */
259
static int csum_tree_block(struct extent_buffer *buf, u8 *result)
260
{
261 262
	struct btrfs_fs_info *fs_info = buf->fs_info;
	SHASH_DESC_ON_STACK(shash, fs_info->csum_shash);
263 264 265 266 267 268 269
	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;
270 271 272

	shash->tfm = fs_info->csum_shash;
	crypto_shash_init(shash);
273 274

	len = buf->len - offset;
275

C
Chris Mason 已提交
276
	while (len > 0) {
277 278 279 280 281 282
		/*
		 * Note: we don't need to check for the err == 1 case here, as
		 * with the given combination of 'start = BTRFS_CSUM_SIZE (32)'
		 * and 'min_len = 32' and the currently implemented mapping
		 * algorithm we cannot cross a page boundary.
		 */
283
		err = map_private_extent_buffer(buf, offset, 32,
284
					&kaddr, &map_start, &map_len);
285
		if (WARN_ON(err))
286
			return err;
287
		cur_len = min(len, map_len - (offset - map_start));
288
		crypto_shash_update(shash, kaddr + offset - map_start, cur_len);
289 290 291
		len -= cur_len;
		offset += cur_len;
	}
292
	memset(result, 0, BTRFS_CSUM_SIZE);
293

294
	crypto_shash_final(shash, result);
295 296 297 298

	return 0;
}

C
Chris Mason 已提交
299 300 301 302 303 304
/*
 * 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.
 */
305
static int verify_parent_transid(struct extent_io_tree *io_tree,
306 307
				 struct extent_buffer *eb, u64 parent_transid,
				 int atomic)
308
{
309
	struct extent_state *cached_state = NULL;
310
	int ret;
311
	bool need_lock = (current->journal_info == BTRFS_SEND_TRANS_STUB);
312 313 314 315

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

316 317 318
	if (atomic)
		return -EAGAIN;

319 320
	if (need_lock) {
		btrfs_tree_read_lock(eb);
321
		btrfs_set_lock_blocking_read(eb);
322 323
	}

324
	lock_extent_bits(io_tree, eb->start, eb->start + eb->len - 1,
325
			 &cached_state);
326
	if (extent_buffer_uptodate(eb) &&
327 328 329 330
	    btrfs_header_generation(eb) == parent_transid) {
		ret = 0;
		goto out;
	}
331 332 333
	btrfs_err_rl(eb->fs_info,
		"parent transid verify failed on %llu wanted %llu found %llu",
			eb->start,
334
			parent_transid, btrfs_header_generation(eb));
335
	ret = 1;
336 337 338 339

	/*
	 * 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
340
	 * block that has been freed and re-allocated.  So don't clear uptodate
341 342 343 344 345 346
	 * 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 已提交
347
out:
348
	unlock_extent_cached(io_tree, eb->start, eb->start + eb->len - 1,
349
			     &cached_state);
350 351
	if (need_lock)
		btrfs_tree_read_unlock_blocking(eb);
352 353 354
	return ret;
}

355 356 357 358
static bool btrfs_supported_super_csum(u16 csum_type)
{
	switch (csum_type) {
	case BTRFS_CSUM_TYPE_CRC32:
359
	case BTRFS_CSUM_TYPE_XXHASH:
360
	case BTRFS_CSUM_TYPE_SHA256:
361
	case BTRFS_CSUM_TYPE_BLAKE2:
362 363 364 365 366 367
		return true;
	default:
		return false;
	}
}

D
David Sterba 已提交
368 369 370 371
/*
 * Return 0 if the superblock checksum type matches the checksum value of that
 * algorithm. Pass the raw disk superblock data.
 */
372 373
static int btrfs_check_super_csum(struct btrfs_fs_info *fs_info,
				  char *raw_disk_sb)
D
David Sterba 已提交
374 375 376
{
	struct btrfs_super_block *disk_sb =
		(struct btrfs_super_block *)raw_disk_sb;
377
	char result[BTRFS_CSUM_SIZE];
378 379 380 381
	SHASH_DESC_ON_STACK(shash, fs_info->csum_shash);

	shash->tfm = fs_info->csum_shash;
	crypto_shash_init(shash);
D
David Sterba 已提交
382

383 384 385 386 387
	/*
	 * The super_block structure does not span the whole
	 * BTRFS_SUPER_INFO_SIZE range, we expect that the unused space is
	 * filled with zeros and is included in the checksum.
	 */
388 389 390
	crypto_shash_update(shash, raw_disk_sb + BTRFS_CSUM_SIZE,
			    BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE);
	crypto_shash_final(shash, result);
D
David Sterba 已提交
391

392 393
	if (memcmp(disk_sb->csum, result, btrfs_super_csum_size(disk_sb)))
		return 1;
D
David Sterba 已提交
394

395
	return 0;
D
David Sterba 已提交
396 397
}

398
int btrfs_verify_level_key(struct extent_buffer *eb, int level,
399
			   struct btrfs_key *first_key, u64 parent_transid)
400
{
401
	struct btrfs_fs_info *fs_info = eb->fs_info;
402 403 404 405 406 407
	int found_level;
	struct btrfs_key found_key;
	int ret;

	found_level = btrfs_header_level(eb);
	if (found_level != level) {
408 409
		WARN(IS_ENABLED(CONFIG_BTRFS_DEBUG),
		     KERN_ERR "BTRFS: tree level check failed\n");
410 411 412 413 414 415 416 417 418
		btrfs_err(fs_info,
"tree level mismatch detected, bytenr=%llu level expected=%u has=%u",
			  eb->start, level, found_level);
		return -EIO;
	}

	if (!first_key)
		return 0;

419 420 421 422 423 424 425 426
	/*
	 * For live tree block (new tree blocks in current transaction),
	 * we need proper lock context to avoid race, which is impossible here.
	 * So we only checks tree blocks which is read from disk, whose
	 * generation <= fs_info->last_trans_committed.
	 */
	if (btrfs_header_generation(eb) > fs_info->last_trans_committed)
		return 0;
427 428 429 430 431 432 433 434 435 436

	/* We have @first_key, so this @eb must have at least one item */
	if (btrfs_header_nritems(eb) == 0) {
		btrfs_err(fs_info,
		"invalid tree nritems, bytenr=%llu nritems=0 expect >0",
			  eb->start);
		WARN_ON(IS_ENABLED(CONFIG_BTRFS_DEBUG));
		return -EUCLEAN;
	}

437 438 439 440 441 442 443
	if (found_level)
		btrfs_node_key_to_cpu(eb, &found_key, 0);
	else
		btrfs_item_key_to_cpu(eb, &found_key, 0);
	ret = btrfs_comp_cpu_keys(first_key, &found_key);

	if (ret) {
444 445
		WARN(IS_ENABLED(CONFIG_BTRFS_DEBUG),
		     KERN_ERR "BTRFS: tree first key check failed\n");
446
		btrfs_err(fs_info,
447 448 449 450 451
"tree first key mismatch detected, bytenr=%llu parent_transid=%llu key expected=(%llu,%u,%llu) has=(%llu,%u,%llu)",
			  eb->start, parent_transid, first_key->objectid,
			  first_key->type, first_key->offset,
			  found_key.objectid, found_key.type,
			  found_key.offset);
452 453 454 455
	}
	return ret;
}

C
Chris Mason 已提交
456 457 458
/*
 * helper to read a given tree block, doing retries as required when
 * the checksums don't match and we have alternate mirrors to try.
459 460 461 462
 *
 * @parent_transid:	expected transid, skip check if 0
 * @level:		expected level, mandatory check
 * @first_key:		expected key of first slot, skip check if NULL
C
Chris Mason 已提交
463
 */
464
static int btree_read_extent_buffer_pages(struct extent_buffer *eb,
465 466
					  u64 parent_transid, int level,
					  struct btrfs_key *first_key)
467
{
468
	struct btrfs_fs_info *fs_info = eb->fs_info;
469
	struct extent_io_tree *io_tree;
470
	int failed = 0;
471 472 473
	int ret;
	int num_copies = 0;
	int mirror_num = 0;
474
	int failed_mirror = 0;
475

476
	io_tree = &BTRFS_I(fs_info->btree_inode)->io_tree;
477
	while (1) {
478
		clear_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags);
479
		ret = read_extent_buffer_pages(eb, WAIT_COMPLETE, mirror_num);
480
		if (!ret) {
481
			if (verify_parent_transid(io_tree, eb,
482
						   parent_transid, 0))
483
				ret = -EIO;
484
			else if (btrfs_verify_level_key(eb, level,
485
						first_key, parent_transid))
486 487 488
				ret = -EUCLEAN;
			else
				break;
489
		}
C
Chris Mason 已提交
490

491
		num_copies = btrfs_num_copies(fs_info,
492
					      eb->start, eb->len);
C
Chris Mason 已提交
493
		if (num_copies == 1)
494
			break;
C
Chris Mason 已提交
495

496 497 498 499 500
		if (!failed_mirror) {
			failed = 1;
			failed_mirror = eb->read_mirror;
		}

501
		mirror_num++;
502 503 504
		if (mirror_num == failed_mirror)
			mirror_num++;

C
Chris Mason 已提交
505
		if (mirror_num > num_copies)
506
			break;
507
	}
508

509
	if (failed && !ret && failed_mirror)
510
		btrfs_repair_eb_io_failure(eb, failed_mirror);
511 512

	return ret;
513
}
514

C
Chris Mason 已提交
515
/*
C
Chris Mason 已提交
516 517
 * 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 已提交
518
 */
C
Chris Mason 已提交
519

520
static int csum_dirty_buffer(struct btrfs_fs_info *fs_info, struct page *page)
521
{
M
Miao Xie 已提交
522
	u64 start = page_offset(page);
523
	u64 found_start;
524 525
	u8 result[BTRFS_CSUM_SIZE];
	u16 csum_size = btrfs_super_csum_size(fs_info->super_copy);
526
	struct extent_buffer *eb;
527
	int ret;
528

J
Josef Bacik 已提交
529 530 531
	eb = (struct extent_buffer *)page->private;
	if (page != eb->pages[0])
		return 0;
532

533
	found_start = btrfs_header_bytenr(eb);
534 535 536 537 538 539 540 541 542
	/*
	 * 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;

543
	ASSERT(memcmp_extent_buffer(eb, fs_info->fs_devices->metadata_uuid,
544 545
			btrfs_header_fsid(), BTRFS_FSID_SIZE) == 0);

546 547 548
	if (csum_tree_block(eb, result))
		return -EINVAL;

549 550 551 552 553 554
	if (btrfs_header_level(eb))
		ret = btrfs_check_node(eb);
	else
		ret = btrfs_check_leaf_full(eb);

	if (ret < 0) {
555
		btrfs_print_tree(eb, 0);
556 557 558
		btrfs_err(fs_info,
		"block=%llu write time tree block corruption detected",
			  eb->start);
559
		WARN_ON(IS_ENABLED(CONFIG_BTRFS_DEBUG));
560 561
		return ret;
	}
562
	write_extent_buffer(eb, result, 0, csum_size);
563

564
	return 0;
565 566
}

567
static int check_tree_block_fsid(struct extent_buffer *eb)
Y
Yan Zheng 已提交
568
{
569
	struct btrfs_fs_info *fs_info = eb->fs_info;
570
	struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
571
	u8 fsid[BTRFS_FSID_SIZE];
Y
Yan Zheng 已提交
572 573
	int ret = 1;

574
	read_extent_buffer(eb, fsid, btrfs_header_fsid(), BTRFS_FSID_SIZE);
Y
Yan Zheng 已提交
575
	while (fs_devices) {
576 577 578 579 580 581 582 583 584 585 586 587 588 589
		u8 *metadata_uuid;

		/*
		 * Checking the incompat flag is only valid for the current
		 * fs. For seed devices it's forbidden to have their uuid
		 * changed so reading ->fsid in this case is fine
		 */
		if (fs_devices == fs_info->fs_devices &&
		    btrfs_fs_incompat(fs_info, METADATA_UUID))
			metadata_uuid = fs_devices->metadata_uuid;
		else
			metadata_uuid = fs_devices->fsid;

		if (!memcmp(fsid, metadata_uuid, BTRFS_FSID_SIZE)) {
Y
Yan Zheng 已提交
590 591 592 593 594 595 596 597
			ret = 0;
			break;
		}
		fs_devices = fs_devices->seed;
	}
	return ret;
}

598 599 600
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)
601 602 603 604 605
{
	u64 found_start;
	int found_level;
	struct extent_buffer *eb;
	struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
606
	struct btrfs_fs_info *fs_info = root->fs_info;
607
	u16 csum_size = btrfs_super_csum_size(fs_info->super_copy);
608
	int ret = 0;
609
	u8 result[BTRFS_CSUM_SIZE];
610
	int reads_done;
611 612 613

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

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

617 618 619
	/* 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
	 */
D
David Sterba 已提交
620
	atomic_inc(&eb->refs);
621 622

	reads_done = atomic_dec_and_test(&eb->io_pages);
623 624
	if (!reads_done)
		goto err;
625

626
	eb->read_mirror = mirror;
627
	if (test_bit(EXTENT_BUFFER_READ_ERR, &eb->bflags)) {
628 629 630 631
		ret = -EIO;
		goto err;
	}

632
	found_start = btrfs_header_bytenr(eb);
633
	if (found_start != eb->start) {
634 635
		btrfs_err_rl(fs_info, "bad tree block start, want %llu have %llu",
			     eb->start, found_start);
636
		ret = -EIO;
637 638
		goto err;
	}
639
	if (check_tree_block_fsid(eb)) {
640 641
		btrfs_err_rl(fs_info, "bad fsid on block %llu",
			     eb->start);
642 643 644
		ret = -EIO;
		goto err;
	}
645
	found_level = btrfs_header_level(eb);
646
	if (found_level >= BTRFS_MAX_LEVEL) {
647 648
		btrfs_err(fs_info, "bad tree block level %d on %llu",
			  (int)btrfs_header_level(eb), eb->start);
649 650 651
		ret = -EIO;
		goto err;
	}
652

653 654
	btrfs_set_buffer_lockdep_class(btrfs_header_owner(eb),
				       eb, found_level);
655

656
	ret = csum_tree_block(eb, result);
657
	if (ret)
658 659
		goto err;

660 661 662 663 664 665 666 667 668 669 670 671 672 673 674
	if (memcmp_extent_buffer(eb, result, 0, csum_size)) {
		u32 val;
		u32 found = 0;

		memcpy(&found, result, csum_size);

		read_extent_buffer(eb, &val, 0, csum_size);
		btrfs_warn_rl(fs_info,
		"%s checksum verify failed on %llu wanted %x found %x level %d",
			      fs_info->sb->s_id, eb->start,
			      val, found, btrfs_header_level(eb));
		ret = -EUCLEAN;
		goto err;
	}

675 676 677 678 679
	/*
	 * 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.
	 */
680
	if (found_level == 0 && btrfs_check_leaf_full(eb)) {
681 682 683
		set_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags);
		ret = -EIO;
	}
684

685
	if (found_level > 0 && btrfs_check_node(eb))
L
Liu Bo 已提交
686 687
		ret = -EIO;

688 689
	if (!ret)
		set_extent_buffer_uptodate(eb);
690 691 692 693
	else
		btrfs_err(fs_info,
			  "block=%llu read time tree block corruption detected",
			  eb->start);
694
err:
695 696
	if (reads_done &&
	    test_and_clear_bit(EXTENT_BUFFER_READAHEAD, &eb->bflags))
697
		btree_readahead_hook(eb, ret);
A
Arne Jansen 已提交
698

D
David Woodhouse 已提交
699 700 701 702 703 704 705
	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);
706
		clear_extent_buffer_uptodate(eb);
D
David Woodhouse 已提交
707
	}
708
	free_extent_buffer(eb);
709
out:
710
	return ret;
711 712
}

713
static void end_workqueue_bio(struct bio *bio)
714
{
715
	struct btrfs_end_io_wq *end_io_wq = bio->bi_private;
716
	struct btrfs_fs_info *fs_info;
717
	struct btrfs_workqueue *wq;
718 719

	fs_info = end_io_wq->info;
720
	end_io_wq->status = bio->bi_status;
721

M
Mike Christie 已提交
722
	if (bio_op(bio) == REQ_OP_WRITE) {
723
		if (end_io_wq->metadata == BTRFS_WQ_ENDIO_METADATA)
724
			wq = fs_info->endio_meta_write_workers;
725
		else if (end_io_wq->metadata == BTRFS_WQ_ENDIO_FREE_SPACE)
726
			wq = fs_info->endio_freespace_worker;
727
		else if (end_io_wq->metadata == BTRFS_WQ_ENDIO_RAID56)
728
			wq = fs_info->endio_raid56_workers;
729
		else
730
			wq = fs_info->endio_write_workers;
731
	} else {
732
		if (unlikely(end_io_wq->metadata == BTRFS_WQ_ENDIO_DIO_REPAIR))
733
			wq = fs_info->endio_repair_workers;
734
		else if (end_io_wq->metadata == BTRFS_WQ_ENDIO_RAID56)
735
			wq = fs_info->endio_raid56_workers;
736
		else if (end_io_wq->metadata)
737
			wq = fs_info->endio_meta_workers;
738
		else
739
			wq = fs_info->endio_workers;
740
	}
741

742
	btrfs_init_work(&end_io_wq->work, end_workqueue_fn, NULL, NULL);
743
	btrfs_queue_work(wq, &end_io_wq->work);
744 745
}

746
blk_status_t btrfs_bio_wq_end_io(struct btrfs_fs_info *info, struct bio *bio,
747
			enum btrfs_wq_endio_type metadata)
748
{
749
	struct btrfs_end_io_wq *end_io_wq;
750

751
	end_io_wq = kmem_cache_alloc(btrfs_end_io_wq_cache, GFP_NOFS);
752
	if (!end_io_wq)
753
		return BLK_STS_RESOURCE;
754 755 756

	end_io_wq->private = bio->bi_private;
	end_io_wq->end_io = bio->bi_end_io;
757
	end_io_wq->info = info;
758
	end_io_wq->status = 0;
759
	end_io_wq->bio = bio;
760
	end_io_wq->metadata = metadata;
761 762 763

	bio->bi_private = end_io_wq;
	bio->bi_end_io = end_workqueue_bio;
764 765 766
	return 0;
}

C
Chris Mason 已提交
767 768 769
static void run_one_async_start(struct btrfs_work *work)
{
	struct async_submit_bio *async;
770
	blk_status_t ret;
C
Chris Mason 已提交
771 772

	async = container_of(work, struct  async_submit_bio, work);
773
	ret = async->submit_bio_start(async->private_data, async->bio,
774 775
				      async->bio_offset);
	if (ret)
776
		async->status = ret;
C
Chris Mason 已提交
777 778
}

779 780 781 782 783 784 785 786
/*
 * In order to insert checksums into the metadata in large chunks, we wait
 * until bio submission time.   All the pages in the bio are checksummed and
 * sums are attached onto the ordered extent record.
 *
 * At IO completion time the csums attached on the ordered extent record are
 * inserted into the tree.
 */
C
Chris Mason 已提交
787
static void run_one_async_done(struct btrfs_work *work)
788 789
{
	struct async_submit_bio *async;
790 791
	struct inode *inode;
	blk_status_t ret;
792 793

	async = container_of(work, struct  async_submit_bio, work);
794
	inode = async->private_data;
795

796
	/* If an error occurred we just want to clean up the bio and move on */
797 798
	if (async->status) {
		async->bio->bi_status = async->status;
799
		bio_endio(async->bio);
800 801 802
		return;
	}

803 804 805 806 807 808
	/*
	 * All of the bios that pass through here are from async helpers.
	 * Use REQ_CGROUP_PUNT to issue them from the owning cgroup's context.
	 * This changes nothing when cgroups aren't in use.
	 */
	async->bio->bi_opf |= REQ_CGROUP_PUNT;
809
	ret = btrfs_map_bio(btrfs_sb(inode->i_sb), async->bio, async->mirror_num);
810 811 812 813
	if (ret) {
		async->bio->bi_status = ret;
		bio_endio(async->bio);
	}
C
Chris Mason 已提交
814 815 816 817 818 819 820
}

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

	async = container_of(work, struct  async_submit_bio, work);
821 822 823
	kfree(async);
}

824 825 826
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,
827
				 extent_submit_bio_start_t *submit_bio_start)
828 829 830 831 832
{
	struct async_submit_bio *async;

	async = kmalloc(sizeof(*async), GFP_NOFS);
	if (!async)
833
		return BLK_STS_RESOURCE;
834

835
	async->private_data = private_data;
836 837
	async->bio = bio;
	async->mirror_num = mirror_num;
C
Chris Mason 已提交
838 839
	async->submit_bio_start = submit_bio_start;

840 841
	btrfs_init_work(&async->work, run_one_async_start, run_one_async_done,
			run_one_async_free);
C
Chris Mason 已提交
842

843
	async->bio_offset = bio_offset;
844

845
	async->status = 0;
846

847
	if (op_is_sync(bio->bi_opf))
848
		btrfs_set_work_high_priority(&async->work);
849

850
	btrfs_queue_work(fs_info->workers, &async->work);
851 852 853
	return 0;
}

854
static blk_status_t btree_csum_one_bio(struct bio *bio)
855
{
856
	struct bio_vec *bvec;
857
	struct btrfs_root *root;
858
	int ret = 0;
859
	struct bvec_iter_all iter_all;
860

861
	ASSERT(!bio_flagged(bio, BIO_CLONED));
862
	bio_for_each_segment_all(bvec, bio, iter_all) {
863
		root = BTRFS_I(bvec->bv_page->mapping->host)->root;
864
		ret = csum_dirty_buffer(root->fs_info, bvec->bv_page);
865 866
		if (ret)
			break;
867
	}
868

869
	return errno_to_blk_status(ret);
870 871
}

872
static blk_status_t btree_submit_bio_start(void *private_data, struct bio *bio,
873
					     u64 bio_offset)
874
{
875 876
	/*
	 * when we're called for a write, we're already in the async
877
	 * submission context.  Just jump into btrfs_map_bio
878
	 */
879
	return btree_csum_one_bio(bio);
C
Chris Mason 已提交
880
}
881

882 883
static int check_async_write(struct btrfs_fs_info *fs_info,
			     struct btrfs_inode *bi)
884
{
885 886
	if (atomic_read(&bi->sync_writers))
		return 0;
887
	if (test_bit(BTRFS_FS_CSUM_IMPL_FAST, &fs_info->flags))
888 889 890 891
		return 0;
	return 1;
}

892
static blk_status_t btree_submit_bio_hook(struct inode *inode, struct bio *bio,
893 894
					  int mirror_num,
					  unsigned long bio_flags)
895
{
896
	struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
897
	int async = check_async_write(fs_info, BTRFS_I(inode));
898
	blk_status_t ret;
899

M
Mike Christie 已提交
900
	if (bio_op(bio) != REQ_OP_WRITE) {
C
Chris Mason 已提交
901 902 903 904
		/*
		 * called for a read, do the setup so that checksum validation
		 * can happen in the async kernel threads
		 */
905 906
		ret = btrfs_bio_wq_end_io(fs_info, bio,
					  BTRFS_WQ_ENDIO_METADATA);
907
		if (ret)
908
			goto out_w_error;
909
		ret = btrfs_map_bio(fs_info, bio, mirror_num);
910 911 912
	} else if (!async) {
		ret = btree_csum_one_bio(bio);
		if (ret)
913
			goto out_w_error;
914
		ret = btrfs_map_bio(fs_info, bio, mirror_num);
915 916 917 918 919
	} else {
		/*
		 * kthread helpers are used to submit writes so that
		 * checksumming can happen in parallel across all CPUs
		 */
920
		ret = btrfs_wq_submit_bio(fs_info, bio, mirror_num, 0,
921
					  0, inode, btree_submit_bio_start);
922
	}
923

924 925 926 927
	if (ret)
		goto out_w_error;
	return 0;

928
out_w_error:
929
	bio->bi_status = ret;
930
	bio_endio(bio);
931
	return ret;
932 933
}

J
Jan Beulich 已提交
934
#ifdef CONFIG_MIGRATION
935
static int btree_migratepage(struct address_space *mapping,
936 937
			struct page *newpage, struct page *page,
			enum migrate_mode mode)
938 939 940 941 942 943 944 945 946 947 948 949 950 951
{
	/*
	 * 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;
952
	return migrate_page(mapping, newpage, page, mode);
953
}
J
Jan Beulich 已提交
954
#endif
955

956 957 958 959

static int btree_writepages(struct address_space *mapping,
			    struct writeback_control *wbc)
{
960 961 962
	struct btrfs_fs_info *fs_info;
	int ret;

963
	if (wbc->sync_mode == WB_SYNC_NONE) {
964 965 966 967

		if (wbc->for_kupdate)
			return 0;

968
		fs_info = BTRFS_I(mapping->host)->root->fs_info;
969
		/* this is a bit racy, but that's ok */
970 971 972
		ret = __percpu_counter_compare(&fs_info->dirty_metadata_bytes,
					     BTRFS_DIRTY_METADATA_THRESH,
					     fs_info->dirty_metadata_batch);
973
		if (ret < 0)
974 975
			return 0;
	}
976
	return btree_write_cache_pages(mapping, wbc);
977 978
}

979
static int btree_readpage(struct file *file, struct page *page)
980
{
981 982
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
983
	return extent_read_full_page(tree, page, btree_get_extent, 0);
984
}
C
Chris Mason 已提交
985

986
static int btree_releasepage(struct page *page, gfp_t gfp_flags)
987
{
988
	if (PageWriteback(page) || PageDirty(page))
C
Chris Mason 已提交
989
		return 0;
990

991
	return try_release_extent_buffer(page);
992 993
}

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

1011 1012
static int btree_set_page_dirty(struct page *page)
{
1013
#ifdef DEBUG
1014 1015 1016 1017 1018 1019 1020 1021
	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);
1022
#endif
1023 1024 1025
	return __set_page_dirty_nobuffers(page);
}

1026
static const struct address_space_operations btree_aops = {
1027
	.readpage	= btree_readpage,
1028
	.writepages	= btree_writepages,
1029 1030
	.releasepage	= btree_releasepage,
	.invalidatepage = btree_invalidatepage,
1031
#ifdef CONFIG_MIGRATION
1032
	.migratepage	= btree_migratepage,
1033
#endif
1034
	.set_page_dirty = btree_set_page_dirty,
1035 1036
};

1037
void readahead_tree_block(struct btrfs_fs_info *fs_info, u64 bytenr)
C
Chris Mason 已提交
1038
{
1039
	struct extent_buffer *buf = NULL;
1040
	int ret;
C
Chris Mason 已提交
1041

1042
	buf = btrfs_find_create_tree_block(fs_info, bytenr);
1043
	if (IS_ERR(buf))
1044
		return;
1045

1046
	ret = read_extent_buffer_pages(buf, WAIT_NONE, 0);
1047 1048 1049 1050
	if (ret < 0)
		free_extent_buffer_stale(buf);
	else
		free_extent_buffer(buf);
C
Chris Mason 已提交
1051 1052
}

1053 1054 1055
struct extent_buffer *btrfs_find_create_tree_block(
						struct btrfs_fs_info *fs_info,
						u64 bytenr)
1056
{
1057 1058 1059
	if (btrfs_is_testing(fs_info))
		return alloc_test_extent_buffer(fs_info, bytenr);
	return alloc_extent_buffer(fs_info, bytenr);
1060 1061
}

1062 1063 1064 1065 1066 1067 1068 1069
/*
 * Read tree block at logical address @bytenr and do variant basic but critical
 * verification.
 *
 * @parent_transid:	expected transid of this tree block, skip check if 0
 * @level:		expected level, mandatory check
 * @first_key:		expected key in slot 0, skip check if NULL
 */
1070
struct extent_buffer *read_tree_block(struct btrfs_fs_info *fs_info, u64 bytenr,
1071 1072
				      u64 parent_transid, int level,
				      struct btrfs_key *first_key)
1073 1074 1075 1076
{
	struct extent_buffer *buf = NULL;
	int ret;

1077
	buf = btrfs_find_create_tree_block(fs_info, bytenr);
1078 1079
	if (IS_ERR(buf))
		return buf;
1080

1081
	ret = btree_read_extent_buffer_pages(buf, parent_transid,
1082
					     level, first_key);
1083
	if (ret) {
1084
		free_extent_buffer_stale(buf);
1085
		return ERR_PTR(ret);
1086
	}
1087
	return buf;
1088

1089 1090
}

1091
void btrfs_clean_tree_block(struct extent_buffer *buf)
1092
{
1093
	struct btrfs_fs_info *fs_info = buf->fs_info;
1094
	if (btrfs_header_generation(buf) ==
1095
	    fs_info->running_transaction->transid) {
1096
		btrfs_assert_tree_locked(buf);
1097

1098
		if (test_and_clear_bit(EXTENT_BUFFER_DIRTY, &buf->bflags)) {
1099 1100 1101
			percpu_counter_add_batch(&fs_info->dirty_metadata_bytes,
						 -buf->len,
						 fs_info->dirty_metadata_batch);
1102
			/* ugh, clear_extent_buffer_dirty needs to lock the page */
1103
			btrfs_set_lock_blocking_write(buf);
1104 1105
			clear_extent_buffer_dirty(buf);
		}
1106
	}
1107 1108
}

1109 1110 1111 1112 1113 1114 1115 1116 1117
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);

1118
	ret = percpu_counter_init(&writers->counter, 0, GFP_NOFS);
1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134
	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);
}

1135
static void __setup_root(struct btrfs_root *root, struct btrfs_fs_info *fs_info,
1136
			 u64 objectid)
1137
{
1138
	bool dummy = test_bit(BTRFS_FS_STATE_DUMMY_FS_INFO, &fs_info->fs_state);
1139
	root->fs_info = fs_info;
C
Chris Mason 已提交
1140
	root->node = NULL;
1141
	root->commit_root = NULL;
1142
	root->state = 0;
1143
	root->orphan_cleanup_state = 0;
1144

1145
	root->last_trans = 0;
1146
	root->highest_objectid = 0;
1147
	root->nr_delalloc_inodes = 0;
1148
	root->nr_ordered_extents = 0;
1149
	root->inode_tree = RB_ROOT;
1150
	INIT_RADIX_TREE(&root->delayed_nodes_tree, GFP_ATOMIC);
1151
	root->block_rsv = NULL;
1152 1153

	INIT_LIST_HEAD(&root->dirty_list);
1154
	INIT_LIST_HEAD(&root->root_list);
1155 1156
	INIT_LIST_HEAD(&root->delalloc_inodes);
	INIT_LIST_HEAD(&root->delalloc_root);
1157 1158
	INIT_LIST_HEAD(&root->ordered_extents);
	INIT_LIST_HEAD(&root->ordered_root);
1159
	INIT_LIST_HEAD(&root->reloc_dirty_list);
1160 1161
	INIT_LIST_HEAD(&root->logged_list[0]);
	INIT_LIST_HEAD(&root->logged_list[1]);
1162
	spin_lock_init(&root->inode_lock);
1163
	spin_lock_init(&root->delalloc_lock);
1164
	spin_lock_init(&root->ordered_extent_lock);
1165
	spin_lock_init(&root->accounting_lock);
1166 1167
	spin_lock_init(&root->log_extents_lock[0]);
	spin_lock_init(&root->log_extents_lock[1]);
1168
	spin_lock_init(&root->qgroup_meta_rsv_lock);
1169
	mutex_init(&root->objectid_mutex);
1170
	mutex_init(&root->log_mutex);
1171
	mutex_init(&root->ordered_extent_mutex);
1172
	mutex_init(&root->delalloc_mutex);
Y
Yan Zheng 已提交
1173 1174 1175
	init_waitqueue_head(&root->log_writer_wait);
	init_waitqueue_head(&root->log_commit_wait[0]);
	init_waitqueue_head(&root->log_commit_wait[1]);
1176 1177
	INIT_LIST_HEAD(&root->log_ctxs[0]);
	INIT_LIST_HEAD(&root->log_ctxs[1]);
Y
Yan Zheng 已提交
1178 1179 1180
	atomic_set(&root->log_commit[0], 0);
	atomic_set(&root->log_commit[1], 0);
	atomic_set(&root->log_writers, 0);
M
Miao Xie 已提交
1181
	atomic_set(&root->log_batch, 0);
1182
	refcount_set(&root->refs, 1);
1183
	atomic_set(&root->will_be_snapshotted, 0);
1184
	atomic_set(&root->snapshot_force_cow, 0);
1185
	atomic_set(&root->nr_swapfiles, 0);
Y
Yan Zheng 已提交
1186
	root->log_transid = 0;
1187
	root->log_transid_committed = -1;
1188
	root->last_log_commit = 0;
1189
	if (!dummy)
1190 1191
		extent_io_tree_init(fs_info, &root->dirty_log_pages,
				    IO_TREE_ROOT_DIRTY_LOG_PAGES, NULL);
C
Chris Mason 已提交
1192

1193 1194
	memset(&root->root_key, 0, sizeof(root->root_key));
	memset(&root->root_item, 0, sizeof(root->root_item));
1195
	memset(&root->defrag_progress, 0, sizeof(root->defrag_progress));
1196
	if (!dummy)
1197 1198 1199
		root->defrag_trans_start = fs_info->generation;
	else
		root->defrag_trans_start = 0;
1200
	root->root_key.objectid = objectid;
1201
	root->anon_dev = 0;
1202

1203
	spin_lock_init(&root->root_item_lock);
1204
	btrfs_qgroup_init_swapped_blocks(&root->swapped_blocks);
J
Josef Bacik 已提交
1205 1206 1207 1208 1209 1210
#ifdef CONFIG_BTRFS_DEBUG
	INIT_LIST_HEAD(&root->leak_list);
	spin_lock(&fs_info->fs_roots_radix_lock);
	list_add_tail(&root->leak_list, &fs_info->allocated_roots);
	spin_unlock(&fs_info->fs_roots_radix_lock);
#endif
1211 1212
}

1213
static struct btrfs_root *btrfs_alloc_root(struct btrfs_fs_info *fs_info,
1214
					   u64 objectid, gfp_t flags)
A
Al Viro 已提交
1215
{
1216
	struct btrfs_root *root = kzalloc(sizeof(*root), flags);
A
Al Viro 已提交
1217
	if (root)
1218
		__setup_root(root, fs_info, objectid);
A
Al Viro 已提交
1219 1220 1221
	return root;
}

1222 1223
#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
/* Should only be used by the testing infrastructure */
1224
struct btrfs_root *btrfs_alloc_dummy_root(struct btrfs_fs_info *fs_info)
1225 1226 1227
{
	struct btrfs_root *root;

1228 1229 1230
	if (!fs_info)
		return ERR_PTR(-EINVAL);

1231
	root = btrfs_alloc_root(fs_info, BTRFS_ROOT_TREE_OBJECTID, GFP_KERNEL);
1232 1233
	if (!root)
		return ERR_PTR(-ENOMEM);
1234

1235
	/* We don't use the stripesize in selftest, set it as sectorsize */
1236
	root->alloc_bytenr = 0;
1237 1238 1239 1240 1241

	return root;
}
#endif

1242 1243 1244
struct btrfs_root *btrfs_create_tree(struct btrfs_trans_handle *trans,
				     u64 objectid)
{
1245
	struct btrfs_fs_info *fs_info = trans->fs_info;
1246 1247 1248 1249
	struct extent_buffer *leaf;
	struct btrfs_root *tree_root = fs_info->tree_root;
	struct btrfs_root *root;
	struct btrfs_key key;
1250
	unsigned int nofs_flag;
1251
	int ret = 0;
1252
	uuid_le uuid = NULL_UUID_LE;
1253

1254 1255 1256 1257 1258
	/*
	 * We're holding a transaction handle, so use a NOFS memory allocation
	 * context to avoid deadlock if reclaim happens.
	 */
	nofs_flag = memalloc_nofs_save();
1259
	root = btrfs_alloc_root(fs_info, objectid, GFP_KERNEL);
1260
	memalloc_nofs_restore(nofs_flag);
1261 1262 1263 1264 1265 1266 1267
	if (!root)
		return ERR_PTR(-ENOMEM);

	root->root_key.objectid = objectid;
	root->root_key.type = BTRFS_ROOT_ITEM_KEY;
	root->root_key.offset = 0;

1268
	leaf = btrfs_alloc_tree_block(trans, root, 0, objectid, NULL, 0, 0, 0);
1269 1270
	if (IS_ERR(leaf)) {
		ret = PTR_ERR(leaf);
1271
		leaf = NULL;
1272 1273 1274 1275 1276 1277 1278
		goto fail;
	}

	root->node = leaf;
	btrfs_mark_buffer_dirty(leaf);

	root->commit_root = btrfs_root_node(root);
1279
	set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
1280 1281 1282 1283 1284 1285 1286 1287 1288 1289

	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);
1290 1291
	if (is_fstree(objectid))
		uuid_le_gen(&uuid);
1292
	memcpy(root->root_item.uuid, uuid.b, BTRFS_UUID_SIZE);
1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303
	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);

1304 1305
	return root;

1306
fail:
1307 1308
	if (leaf) {
		btrfs_tree_unlock(leaf);
1309
		free_extent_buffer(root->commit_root);
1310 1311
		free_extent_buffer(leaf);
	}
1312
	btrfs_put_root(root);
1313

1314
	return ERR_PTR(ret);
1315 1316
}

Y
Yan Zheng 已提交
1317 1318
static struct btrfs_root *alloc_log_tree(struct btrfs_trans_handle *trans,
					 struct btrfs_fs_info *fs_info)
1319 1320
{
	struct btrfs_root *root;
Y
Yan Zheng 已提交
1321
	struct extent_buffer *leaf;
1322

1323
	root = btrfs_alloc_root(fs_info, BTRFS_TREE_LOG_OBJECTID, GFP_NOFS);
1324
	if (!root)
Y
Yan Zheng 已提交
1325
		return ERR_PTR(-ENOMEM);
1326 1327 1328 1329

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

Y
Yan Zheng 已提交
1331
	/*
1332 1333
	 * DON'T set REF_COWS for log trees
	 *
Y
Yan Zheng 已提交
1334 1335 1336 1337 1338
	 * 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).
	 */
1339

1340 1341
	leaf = btrfs_alloc_tree_block(trans, root, 0, BTRFS_TREE_LOG_OBJECTID,
			NULL, 0, 0, 0);
Y
Yan Zheng 已提交
1342
	if (IS_ERR(leaf)) {
1343
		btrfs_put_root(root);
Y
Yan Zheng 已提交
1344 1345
		return ERR_CAST(leaf);
	}
1346

Y
Yan Zheng 已提交
1347
	root->node = leaf;
1348 1349 1350

	btrfs_mark_buffer_dirty(root->node);
	btrfs_tree_unlock(root->node);
Y
Yan Zheng 已提交
1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369
	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)
{
1370
	struct btrfs_fs_info *fs_info = root->fs_info;
Y
Yan Zheng 已提交
1371 1372 1373
	struct btrfs_root *log_root;
	struct btrfs_inode_item *inode_item;

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

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

	WARN_ON(root->log_root);
	root->log_root = log_root;
	root->log_transid = 0;
1394
	root->log_transid_committed = -1;
1395
	root->last_log_commit = 0;
1396 1397 1398
	return 0;
}

1399 1400
struct btrfs_root *btrfs_read_tree_root(struct btrfs_root *tree_root,
					struct btrfs_key *key)
1401 1402 1403
{
	struct btrfs_root *root;
	struct btrfs_fs_info *fs_info = tree_root->fs_info;
1404
	struct btrfs_path *path;
1405
	u64 generation;
1406
	int ret;
1407
	int level;
1408

1409 1410
	path = btrfs_alloc_path();
	if (!path)
1411
		return ERR_PTR(-ENOMEM);
1412

1413
	root = btrfs_alloc_root(fs_info, key->objectid, GFP_NOFS);
1414 1415 1416
	if (!root) {
		ret = -ENOMEM;
		goto alloc_fail;
1417 1418
	}

1419 1420
	ret = btrfs_find_root(tree_root, key, path,
			      &root->root_item, &root->root_key);
1421
	if (ret) {
1422 1423
		if (ret > 0)
			ret = -ENOENT;
1424
		goto find_fail;
1425
	}
1426

1427
	generation = btrfs_root_generation(&root->root_item);
1428
	level = btrfs_root_level(&root->root_item);
1429 1430
	root->node = read_tree_block(fs_info,
				     btrfs_root_bytenr(&root->root_item),
1431
				     generation, level, NULL);
1432 1433
	if (IS_ERR(root->node)) {
		ret = PTR_ERR(root->node);
1434 1435 1436
		goto find_fail;
	} else if (!btrfs_buffer_uptodate(root->node, generation, 0)) {
		ret = -EIO;
1437 1438
		free_extent_buffer(root->node);
		goto find_fail;
1439
	}
1440
	root->commit_root = btrfs_root_node(root);
1441
out:
1442 1443 1444 1445
	btrfs_free_path(path);
	return root;

find_fail:
1446
	btrfs_put_root(root);
1447 1448 1449 1450 1451
alloc_fail:
	root = ERR_PTR(ret);
	goto out;
}

1452
static int btrfs_init_fs_root(struct btrfs_root *root)
1453 1454
{
	int ret;
1455
	struct btrfs_subvolume_writers *writers;
1456 1457 1458 1459 1460 1461 1462 1463 1464

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

1465 1466 1467 1468 1469 1470 1471
	writers = btrfs_alloc_subvolume_writers();
	if (IS_ERR(writers)) {
		ret = PTR_ERR(writers);
		goto fail;
	}
	root->subv_writers = writers;

1472 1473 1474 1475 1476
	if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) {
		set_bit(BTRFS_ROOT_REF_COWS, &root->state);
		btrfs_check_and_init_root_item(&root->root_item);
	}

1477
	btrfs_init_free_ino_ctl(root);
1478 1479
	spin_lock_init(&root->ino_cache_lock);
	init_waitqueue_head(&root->ino_cache_wait);
1480 1481 1482

	ret = get_anon_bdev(&root->anon_dev);
	if (ret)
L
Liu Bo 已提交
1483
		goto fail;
1484 1485 1486 1487 1488 1489

	mutex_lock(&root->objectid_mutex);
	ret = btrfs_find_highest_objectid(root,
					&root->highest_objectid);
	if (ret) {
		mutex_unlock(&root->objectid_mutex);
L
Liu Bo 已提交
1490
		goto fail;
1491 1492 1493 1494 1495 1496
	}

	ASSERT(root->highest_objectid <= BTRFS_LAST_FREE_OBJECTID);

	mutex_unlock(&root->objectid_mutex);

1497 1498
	return 0;
fail:
D
David Sterba 已提交
1499
	/* The caller is responsible to call btrfs_free_fs_root */
1500 1501 1502
	return ret;
}

1503 1504
static struct btrfs_root *btrfs_lookup_fs_root(struct btrfs_fs_info *fs_info,
					       u64 root_id)
1505 1506 1507 1508 1509 1510
{
	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);
1511
	if (root)
1512
		root = btrfs_grab_root(root);
1513 1514 1515 1516 1517 1518 1519 1520 1521
	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;

1522
	ret = radix_tree_preload(GFP_NOFS);
1523 1524 1525 1526 1527 1528 1529
	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);
1530
	if (ret == 0) {
1531
		btrfs_grab_root(root);
1532
		set_bit(BTRFS_ROOT_IN_RADIX, &root->state);
1533
	}
1534 1535 1536 1537 1538 1539
	spin_unlock(&fs_info->fs_roots_radix_lock);
	radix_tree_preload_end();

	return ret;
}

J
Josef Bacik 已提交
1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551
void btrfs_check_leaked_roots(struct btrfs_fs_info *fs_info)
{
#ifdef CONFIG_BTRFS_DEBUG
	struct btrfs_root *root;

	while (!list_empty(&fs_info->allocated_roots)) {
		root = list_first_entry(&fs_info->allocated_roots,
					struct btrfs_root, leak_list);
		btrfs_err(fs_info, "leaked root %llu-%llu refcount %d",
			  root->root_key.objectid, root->root_key.offset,
			  refcount_read(&root->refs));
		while (refcount_read(&root->refs) > 1)
1552 1553
			btrfs_put_root(root);
		btrfs_put_root(root);
J
Josef Bacik 已提交
1554 1555 1556 1557
	}
#endif
}

1558 1559
void btrfs_free_fs_info(struct btrfs_fs_info *fs_info)
{
1560 1561 1562 1563 1564 1565 1566
	percpu_counter_destroy(&fs_info->dirty_metadata_bytes);
	percpu_counter_destroy(&fs_info->delalloc_bytes);
	percpu_counter_destroy(&fs_info->dio_bytes);
	percpu_counter_destroy(&fs_info->dev_replace.bio_counter);
	btrfs_free_csum_hash(fs_info);
	btrfs_free_stripe_hash_table(fs_info);
	btrfs_free_ref_cache(fs_info);
1567 1568
	kfree(fs_info->balance_ctl);
	kfree(fs_info->delayed_root);
1569 1570 1571 1572 1573 1574 1575 1576 1577
	btrfs_put_root(fs_info->extent_root);
	btrfs_put_root(fs_info->tree_root);
	btrfs_put_root(fs_info->chunk_root);
	btrfs_put_root(fs_info->dev_root);
	btrfs_put_root(fs_info->csum_root);
	btrfs_put_root(fs_info->quota_root);
	btrfs_put_root(fs_info->uuid_root);
	btrfs_put_root(fs_info->free_space_root);
	btrfs_put_root(fs_info->fs_root);
J
Josef Bacik 已提交
1578
	btrfs_check_leaked_roots(fs_info);
1579 1580 1581 1582 1583 1584
	kfree(fs_info->super_copy);
	kfree(fs_info->super_for_commit);
	kvfree(fs_info);
}


1585 1586 1587
struct btrfs_root *btrfs_get_fs_root(struct btrfs_fs_info *fs_info,
				     struct btrfs_key *location,
				     bool check_ref)
1588 1589
{
	struct btrfs_root *root;
1590
	struct btrfs_path *path;
1591
	struct btrfs_key key;
1592 1593
	int ret;

1594
	if (location->objectid == BTRFS_ROOT_TREE_OBJECTID)
1595
		return btrfs_grab_root(fs_info->tree_root);
1596
	if (location->objectid == BTRFS_EXTENT_TREE_OBJECTID)
1597
		return btrfs_grab_root(fs_info->extent_root);
1598
	if (location->objectid == BTRFS_CHUNK_TREE_OBJECTID)
1599
		return btrfs_grab_root(fs_info->chunk_root);
1600
	if (location->objectid == BTRFS_DEV_TREE_OBJECTID)
1601
		return btrfs_grab_root(fs_info->dev_root);
1602
	if (location->objectid == BTRFS_CSUM_TREE_OBJECTID)
1603
		return btrfs_grab_root(fs_info->csum_root);
1604
	if (location->objectid == BTRFS_QUOTA_TREE_OBJECTID)
1605
		return btrfs_grab_root(fs_info->quota_root) ?
1606
			fs_info->quota_root : ERR_PTR(-ENOENT);
1607
	if (location->objectid == BTRFS_UUID_TREE_OBJECTID)
1608
		return btrfs_grab_root(fs_info->uuid_root) ?
1609
			fs_info->uuid_root : ERR_PTR(-ENOENT);
1610
	if (location->objectid == BTRFS_FREE_SPACE_TREE_OBJECTID)
1611
		return btrfs_grab_root(fs_info->free_space_root) ?
1612
			fs_info->free_space_root : ERR_PTR(-ENOENT);
1613
again:
1614
	root = btrfs_lookup_fs_root(fs_info, location->objectid);
1615
	if (root) {
1616
		if (check_ref && btrfs_root_refs(&root->root_item) == 0) {
1617
			btrfs_put_root(root);
1618
			return ERR_PTR(-ENOENT);
1619
		}
1620
		return root;
1621
	}
1622

1623
	root = btrfs_read_tree_root(fs_info->tree_root, location);
1624 1625
	if (IS_ERR(root))
		return root;
1626

1627
	if (check_ref && btrfs_root_refs(&root->root_item) == 0) {
1628
		ret = -ENOENT;
1629
		goto fail;
1630
	}
1631

1632
	ret = btrfs_init_fs_root(root);
1633 1634
	if (ret)
		goto fail;
1635

1636 1637 1638 1639 1640
	path = btrfs_alloc_path();
	if (!path) {
		ret = -ENOMEM;
		goto fail;
	}
1641 1642 1643 1644 1645
	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);
1646
	btrfs_free_path(path);
1647 1648 1649
	if (ret < 0)
		goto fail;
	if (ret == 0)
1650
		set_bit(BTRFS_ROOT_ORPHAN_ITEM_INSERTED, &root->state);
1651

1652 1653 1654 1655 1656 1657 1658 1659
	/*
	 * All roots have two refs on them at all times, one for the mounted fs,
	 * and one for being in the radix tree.  This way we only free the root
	 * when we are unmounting or deleting the subvolume.  We get one ref
	 * from __setup_root, one for inserting it into the radix tree, and then
	 * we have the third for returning it, and the caller will put it when
	 * it's done with the root.
	 */
1660
	btrfs_grab_root(root);
1661
	ret = btrfs_insert_fs_root(fs_info, root);
1662
	if (ret) {
1663
		btrfs_put_root(root);
1664
		if (ret == -EEXIST) {
D
David Sterba 已提交
1665
			btrfs_free_fs_root(root);
1666 1667 1668
			goto again;
		}
		goto fail;
1669
	}
1670
	return root;
1671
fail:
D
David Sterba 已提交
1672
	btrfs_free_fs_root(root);
1673
	return ERR_PTR(ret);
1674 1675
}

C
Chris Mason 已提交
1676 1677 1678 1679 1680 1681
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 已提交
1682

1683 1684
	rcu_read_lock();
	list_for_each_entry_rcu(device, &info->fs_devices->devices, dev_list) {
1685 1686
		if (!device->bdev)
			continue;
1687
		bdi = device->bdev->bd_bdi;
1688
		if (bdi_congested(bdi, bdi_bits)) {
C
Chris Mason 已提交
1689 1690 1691 1692
			ret = 1;
			break;
		}
	}
1693
	rcu_read_unlock();
C
Chris Mason 已提交
1694 1695 1696
	return ret;
}

1697 1698 1699 1700 1701
/*
 * 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)
1702 1703
{
	struct bio *bio;
1704
	struct btrfs_end_io_wq *end_io_wq;
1705

1706
	end_io_wq = container_of(work, struct btrfs_end_io_wq, work);
1707
	bio = end_io_wq->bio;
1708

1709
	bio->bi_status = end_io_wq->status;
1710 1711
	bio->bi_private = end_io_wq->private;
	bio->bi_end_io = end_io_wq->end_io;
1712
	bio_endio(bio);
1713
	kmem_cache_free(btrfs_end_io_wq_cache, end_io_wq);
1714 1715
}

1716 1717 1718
static int cleaner_kthread(void *arg)
{
	struct btrfs_root *root = arg;
1719
	struct btrfs_fs_info *fs_info = root->fs_info;
1720
	int again;
1721

1722
	while (1) {
1723
		again = 0;
1724

1725 1726
		set_bit(BTRFS_FS_CLEANER_RUNNING, &fs_info->flags);

1727
		/* Make the cleaner go to sleep early. */
1728
		if (btrfs_need_cleaner_sleep(fs_info))
1729 1730
			goto sleep;

1731 1732 1733 1734
		/*
		 * Do not do anything if we might cause open_ctree() to block
		 * before we have finished mounting the filesystem.
		 */
1735
		if (!test_bit(BTRFS_FS_OPEN, &fs_info->flags))
1736 1737
			goto sleep;

1738
		if (!mutex_trylock(&fs_info->cleaner_mutex))
1739 1740
			goto sleep;

1741 1742 1743 1744
		/*
		 * Avoid the problem that we change the status of the fs
		 * during the above check and trylock.
		 */
1745
		if (btrfs_need_cleaner_sleep(fs_info)) {
1746
			mutex_unlock(&fs_info->cleaner_mutex);
1747
			goto sleep;
1748
		}
1749

1750
		btrfs_run_delayed_iputs(fs_info);
1751

1752
		again = btrfs_clean_one_deleted_snapshot(root);
1753
		mutex_unlock(&fs_info->cleaner_mutex);
1754 1755

		/*
1756 1757
		 * The defragger has dealt with the R/O remount and umount,
		 * needn't do anything special here.
1758
		 */
1759
		btrfs_run_defrag_inodes(fs_info);
1760 1761 1762 1763 1764 1765 1766 1767 1768

		/*
		 * 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.
		 */
1769
		btrfs_delete_unused_bgs(fs_info);
1770
sleep:
1771
		clear_bit(BTRFS_FS_CLEANER_RUNNING, &fs_info->flags);
1772 1773 1774 1775
		if (kthread_should_park())
			kthread_parkme();
		if (kthread_should_stop())
			return 0;
1776
		if (!again) {
1777
			set_current_state(TASK_INTERRUPTIBLE);
1778
			schedule();
1779 1780
			__set_current_state(TASK_RUNNING);
		}
1781
	}
1782 1783 1784 1785 1786
}

static int transaction_kthread(void *arg)
{
	struct btrfs_root *root = arg;
1787
	struct btrfs_fs_info *fs_info = root->fs_info;
1788 1789
	struct btrfs_trans_handle *trans;
	struct btrfs_transaction *cur;
1790
	u64 transid;
1791
	time64_t now;
1792
	unsigned long delay;
1793
	bool cannot_commit;
1794 1795

	do {
1796
		cannot_commit = false;
1797 1798
		delay = HZ * fs_info->commit_interval;
		mutex_lock(&fs_info->transaction_kthread_mutex);
1799

1800 1801
		spin_lock(&fs_info->trans_lock);
		cur = fs_info->running_transaction;
1802
		if (!cur) {
1803
			spin_unlock(&fs_info->trans_lock);
1804 1805
			goto sleep;
		}
Y
Yan Zheng 已提交
1806

1807
		now = ktime_get_seconds();
1808
		if (cur->state < TRANS_STATE_COMMIT_START &&
1809
		    !test_bit(BTRFS_FS_NEED_ASYNC_COMMIT, &fs_info->flags) &&
1810
		    (now < cur->start_time ||
1811 1812
		     now - cur->start_time < fs_info->commit_interval)) {
			spin_unlock(&fs_info->trans_lock);
1813 1814 1815
			delay = HZ * 5;
			goto sleep;
		}
1816
		transid = cur->transid;
1817
		spin_unlock(&fs_info->trans_lock);
1818

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

J
Josef Bacik 已提交
1835
		if (unlikely(test_bit(BTRFS_FS_STATE_ERROR,
1836
				      &fs_info->fs_state)))
1837
			btrfs_cleanup_transaction(fs_info);
1838
		if (!kthread_should_stop() &&
1839
				(!btrfs_transaction_blocked(fs_info) ||
1840
				 cannot_commit))
1841
			schedule_timeout_interruptible(delay);
1842 1843 1844 1845
	} while (!kthread_should_stop());
	return 0;
}

C
Chris Mason 已提交
1846
/*
1847 1848 1849
 * This will find the highest generation in the array of root backups.  The
 * index of the highest array is returned, or -EINVAL if we can't find
 * anything.
C
Chris Mason 已提交
1850 1851 1852 1853 1854
 *
 * 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.
 */
1855
static int find_newest_super_backup(struct btrfs_fs_info *info)
C
Chris Mason 已提交
1856
{
1857
	const u64 newest_gen = btrfs_super_generation(info->super_copy);
C
Chris Mason 已提交
1858 1859 1860 1861 1862 1863 1864 1865
	u64 cur;
	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)
1866
			return i;
C
Chris Mason 已提交
1867 1868
	}

1869
	return -EINVAL;
C
Chris Mason 已提交
1870 1871 1872 1873 1874 1875 1876 1877 1878
}

/*
 * 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)
{
1879
	const int next_backup = info->backup_root_index;
C
Chris Mason 已提交
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
	struct btrfs_root_backup *root_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));

1911 1912 1913 1914 1915 1916 1917 1918
	/*
	 * 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 已提交
1919
			       btrfs_header_generation(info->fs_root->node));
1920
		btrfs_set_backup_fs_root_level(root_backup,
C
Chris Mason 已提交
1921
			       btrfs_header_level(info->fs_root->node));
1922
	}
C
Chris Mason 已提交
1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951

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

N
Nikolay Borisov 已提交
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
/*
 * read_backup_root - Reads a backup root based on the passed priority. Prio 0
 * is the newest, prio 1/2/3 are 2nd newest/3rd newest/4th (oldest) backup roots
 *
 * fs_info - filesystem whose backup roots need to be read
 * priority - priority of backup root required
 *
 * Returns backup root index on success and -EINVAL otherwise.
 */
static int read_backup_root(struct btrfs_fs_info *fs_info, u8 priority)
{
	int backup_index = find_newest_super_backup(fs_info);
	struct btrfs_super_block *super = fs_info->super_copy;
	struct btrfs_root_backup *root_backup;

	if (priority < BTRFS_NUM_BACKUP_ROOTS && backup_index >= 0) {
		if (priority == 0)
			return backup_index;

		backup_index = backup_index + BTRFS_NUM_BACKUP_ROOTS - priority;
		backup_index %= BTRFS_NUM_BACKUP_ROOTS;
	} else {
		return -EINVAL;
	}

	root_backup = super->super_roots + backup_index;

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

L
Liu Bo 已提交
1996 1997 1998
/* helper to cleanup workers */
static void btrfs_stop_all_workers(struct btrfs_fs_info *fs_info)
{
1999
	btrfs_destroy_workqueue(fs_info->fixup_workers);
2000
	btrfs_destroy_workqueue(fs_info->delalloc_workers);
2001
	btrfs_destroy_workqueue(fs_info->workers);
2002 2003
	btrfs_destroy_workqueue(fs_info->endio_workers);
	btrfs_destroy_workqueue(fs_info->endio_raid56_workers);
2004
	btrfs_destroy_workqueue(fs_info->endio_repair_workers);
2005
	btrfs_destroy_workqueue(fs_info->rmw_workers);
2006 2007
	btrfs_destroy_workqueue(fs_info->endio_write_workers);
	btrfs_destroy_workqueue(fs_info->endio_freespace_worker);
2008
	btrfs_destroy_workqueue(fs_info->delayed_workers);
2009
	btrfs_destroy_workqueue(fs_info->caching_workers);
2010
	btrfs_destroy_workqueue(fs_info->readahead_workers);
2011
	btrfs_destroy_workqueue(fs_info->flush_workers);
2012
	btrfs_destroy_workqueue(fs_info->qgroup_rescan_workers);
2013 2014
	if (fs_info->discard_ctl.discard_workers)
		destroy_workqueue(fs_info->discard_ctl.discard_workers);
2015 2016 2017 2018 2019 2020 2021
	/*
	 * 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 已提交
2022 2023
}

2024 2025 2026 2027 2028 2029 2030 2031 2032 2033
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 已提交
2034
/* helper to cleanup tree roots */
2035
static void free_root_pointers(struct btrfs_fs_info *info, bool free_chunk_root)
C
Chris Mason 已提交
2036
{
2037
	free_root_extent_buffers(info->tree_root);
2038

2039 2040 2041 2042 2043
	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);
2044
	if (free_chunk_root)
2045
		free_root_extent_buffers(info->chunk_root);
2046
	free_root_extent_buffers(info->free_space_root);
C
Chris Mason 已提交
2047 2048
}

2049
void btrfs_free_fs_roots(struct btrfs_fs_info *fs_info)
2050 2051 2052 2053 2054 2055 2056 2057 2058 2059
{
	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);

2060
		if (test_bit(BTRFS_ROOT_IN_RADIX, &gang[0]->state)) {
2061
			btrfs_drop_and_free_fs_root(fs_info, gang[0]);
2062 2063 2064
		} else {
			free_extent_buffer(gang[0]->node);
			free_extent_buffer(gang[0]->commit_root);
2065
			btrfs_put_root(gang[0]);
2066 2067 2068 2069 2070 2071 2072 2073 2074 2075
		}
	}

	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++)
2076
			btrfs_drop_and_free_fs_root(fs_info, gang[i]);
2077
	}
2078 2079 2080

	if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
		btrfs_free_log_root_tree(NULL, fs_info);
2081
		btrfs_destroy_pinned_extent(fs_info, fs_info->pinned_extents);
2082
	}
2083
}
C
Chris Mason 已提交
2084

2085 2086 2087 2088 2089 2090 2091 2092
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);
2093
	refcount_set(&fs_info->scrub_workers_refcnt, 0);
2094 2095
}

2096 2097 2098 2099 2100 2101 2102 2103 2104 2105
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_pause_req, 0);
	atomic_set(&fs_info->balance_cancel_req, 0);
	fs_info->balance_ctl = NULL;
	init_waitqueue_head(&fs_info->balance_wait_q);
}

2106
static void btrfs_init_btree_inode(struct btrfs_fs_info *fs_info)
2107
{
2108 2109 2110 2111
	struct inode *inode = fs_info->btree_inode;

	inode->i_ino = BTRFS_BTREE_INODE_OBJECTID;
	set_nlink(inode, 1);
2112 2113 2114 2115 2116
	/*
	 * 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
	 */
2117 2118
	inode->i_size = OFFSET_MAX;
	inode->i_mapping->a_ops = &btree_aops;
2119

2120
	RB_CLEAR_NODE(&BTRFS_I(inode)->rb_node);
2121 2122
	extent_io_tree_init(fs_info, &BTRFS_I(inode)->io_tree,
			    IO_TREE_INODE_IO, inode);
2123
	BTRFS_I(inode)->io_tree.track_uptodate = false;
2124
	extent_map_tree_init(&BTRFS_I(inode)->extent_tree);
2125

2126
	BTRFS_I(inode)->io_tree.ops = &btree_extent_io_ops;
2127

2128 2129 2130 2131
	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);
2132 2133
}

2134 2135 2136
static void btrfs_init_dev_replace_locks(struct btrfs_fs_info *fs_info)
{
	mutex_init(&fs_info->dev_replace.lock_finishing_cancel_unmount);
2137
	init_rwsem(&fs_info->dev_replace.rwsem);
2138
	init_waitqueue_head(&fs_info->dev_replace.replace_wait);
2139 2140
}

2141 2142 2143 2144 2145 2146 2147 2148
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;
	INIT_LIST_HEAD(&fs_info->dirty_qgroups);
	fs_info->qgroup_seq = 1;
	fs_info->qgroup_ulist = NULL;
2149
	fs_info->qgroup_rescan_running = false;
2150 2151 2152
	mutex_init(&fs_info->qgroup_rescan_lock);
}

2153 2154 2155
static int btrfs_init_workqueues(struct btrfs_fs_info *fs_info,
		struct btrfs_fs_devices *fs_devices)
{
2156
	u32 max_active = fs_info->thread_pool_size;
2157
	unsigned int flags = WQ_MEM_RECLAIM | WQ_FREEZABLE | WQ_UNBOUND;
2158 2159

	fs_info->workers =
2160 2161
		btrfs_alloc_workqueue(fs_info, "worker",
				      flags | WQ_HIGHPRI, max_active, 16);
2162 2163

	fs_info->delalloc_workers =
2164 2165
		btrfs_alloc_workqueue(fs_info, "delalloc",
				      flags, max_active, 2);
2166 2167

	fs_info->flush_workers =
2168 2169
		btrfs_alloc_workqueue(fs_info, "flush_delalloc",
				      flags, max_active, 0);
2170 2171

	fs_info->caching_workers =
2172
		btrfs_alloc_workqueue(fs_info, "cache", flags, max_active, 0);
2173 2174

	fs_info->fixup_workers =
2175
		btrfs_alloc_workqueue(fs_info, "fixup", flags, 1, 0);
2176 2177 2178 2179 2180 2181

	/*
	 * endios are largely parallel and should have a very
	 * low idle thresh
	 */
	fs_info->endio_workers =
2182
		btrfs_alloc_workqueue(fs_info, "endio", flags, max_active, 4);
2183
	fs_info->endio_meta_workers =
2184 2185
		btrfs_alloc_workqueue(fs_info, "endio-meta", flags,
				      max_active, 4);
2186
	fs_info->endio_meta_write_workers =
2187 2188
		btrfs_alloc_workqueue(fs_info, "endio-meta-write", flags,
				      max_active, 2);
2189
	fs_info->endio_raid56_workers =
2190 2191
		btrfs_alloc_workqueue(fs_info, "endio-raid56", flags,
				      max_active, 4);
2192
	fs_info->endio_repair_workers =
2193
		btrfs_alloc_workqueue(fs_info, "endio-repair", flags, 1, 0);
2194
	fs_info->rmw_workers =
2195
		btrfs_alloc_workqueue(fs_info, "rmw", flags, max_active, 2);
2196
	fs_info->endio_write_workers =
2197 2198
		btrfs_alloc_workqueue(fs_info, "endio-write", flags,
				      max_active, 2);
2199
	fs_info->endio_freespace_worker =
2200 2201
		btrfs_alloc_workqueue(fs_info, "freespace-write", flags,
				      max_active, 0);
2202
	fs_info->delayed_workers =
2203 2204
		btrfs_alloc_workqueue(fs_info, "delayed-meta", flags,
				      max_active, 0);
2205
	fs_info->readahead_workers =
2206 2207
		btrfs_alloc_workqueue(fs_info, "readahead", flags,
				      max_active, 2);
2208
	fs_info->qgroup_rescan_workers =
2209
		btrfs_alloc_workqueue(fs_info, "qgroup-rescan", flags, 1, 0);
2210 2211
	fs_info->discard_ctl.discard_workers =
		alloc_workqueue("btrfs_discard", WQ_UNBOUND | WQ_FREEZABLE, 1);
2212 2213

	if (!(fs_info->workers && fs_info->delalloc_workers &&
2214
	      fs_info->flush_workers &&
2215 2216 2217 2218 2219 2220 2221
	      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 &&
2222 2223
	      fs_info->qgroup_rescan_workers &&
	      fs_info->discard_ctl.discard_workers)) {
2224 2225 2226 2227 2228 2229
		return -ENOMEM;
	}

	return 0;
}

2230 2231 2232
static int btrfs_init_csum_hash(struct btrfs_fs_info *fs_info, u16 csum_type)
{
	struct crypto_shash *csum_shash;
2233
	const char *csum_driver = btrfs_super_csum_driver(csum_type);
2234

2235
	csum_shash = crypto_alloc_shash(csum_driver, 0, 0);
2236 2237 2238

	if (IS_ERR(csum_shash)) {
		btrfs_err(fs_info, "error allocating %s hash for checksum",
2239
			  csum_driver);
2240 2241 2242 2243 2244 2245 2246 2247
		return PTR_ERR(csum_shash);
	}

	fs_info->csum_shash = csum_shash;

	return 0;
}

2248 2249 2250 2251 2252 2253 2254
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);
2255
	int level = btrfs_super_log_root_level(disk_super);
2256 2257

	if (fs_devices->rw_devices == 0) {
2258
		btrfs_warn(fs_info, "log replay required on RO media");
2259 2260 2261
		return -EIO;
	}

2262 2263
	log_tree_root = btrfs_alloc_root(fs_info, BTRFS_TREE_LOG_OBJECTID,
					 GFP_KERNEL);
2264 2265 2266
	if (!log_tree_root)
		return -ENOMEM;

2267
	log_tree_root->node = read_tree_block(fs_info, bytenr,
2268 2269
					      fs_info->generation + 1,
					      level, NULL);
2270
	if (IS_ERR(log_tree_root->node)) {
2271
		btrfs_warn(fs_info, "failed to read log tree");
2272
		ret = PTR_ERR(log_tree_root->node);
2273
		btrfs_put_root(log_tree_root);
2274
		return ret;
2275
	} else if (!extent_buffer_uptodate(log_tree_root->node)) {
2276
		btrfs_err(fs_info, "failed to read log tree");
2277
		free_extent_buffer(log_tree_root->node);
2278
		btrfs_put_root(log_tree_root);
2279 2280 2281 2282 2283
		return -EIO;
	}
	/* returns with log_tree_root freed on success */
	ret = btrfs_recover_log_trees(log_tree_root);
	if (ret) {
2284 2285
		btrfs_handle_fs_error(fs_info, ret,
				      "Failed to recover log tree");
2286
		free_extent_buffer(log_tree_root->node);
2287
		btrfs_put_root(log_tree_root);
2288 2289 2290
		return ret;
	}

2291
	if (sb_rdonly(fs_info->sb)) {
2292
		ret = btrfs_commit_super(fs_info);
2293 2294 2295 2296 2297 2298 2299
		if (ret)
			return ret;
	}

	return 0;
}

2300
static int btrfs_read_roots(struct btrfs_fs_info *fs_info)
2301
{
2302
	struct btrfs_root *tree_root = fs_info->tree_root;
2303
	struct btrfs_root *root;
2304 2305 2306
	struct btrfs_key location;
	int ret;

2307 2308
	BUG_ON(!fs_info->tree_root);

2309 2310 2311 2312
	location.objectid = BTRFS_EXTENT_TREE_OBJECTID;
	location.type = BTRFS_ROOT_ITEM_KEY;
	location.offset = 0;

2313
	root = btrfs_read_tree_root(tree_root, &location);
2314 2315 2316 2317
	if (IS_ERR(root)) {
		ret = PTR_ERR(root);
		goto out;
	}
2318 2319
	set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
	fs_info->extent_root = root;
2320 2321

	location.objectid = BTRFS_DEV_TREE_OBJECTID;
2322
	root = btrfs_read_tree_root(tree_root, &location);
2323 2324 2325 2326
	if (IS_ERR(root)) {
		ret = PTR_ERR(root);
		goto out;
	}
2327 2328
	set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
	fs_info->dev_root = root;
2329 2330 2331
	btrfs_init_devices_late(fs_info);

	location.objectid = BTRFS_CSUM_TREE_OBJECTID;
2332
	root = btrfs_read_tree_root(tree_root, &location);
2333 2334 2335 2336
	if (IS_ERR(root)) {
		ret = PTR_ERR(root);
		goto out;
	}
2337 2338
	set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
	fs_info->csum_root = root;
2339 2340

	location.objectid = BTRFS_QUOTA_TREE_OBJECTID;
2341 2342 2343
	root = btrfs_read_tree_root(tree_root, &location);
	if (!IS_ERR(root)) {
		set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
2344
		set_bit(BTRFS_FS_QUOTA_ENABLED, &fs_info->flags);
2345
		fs_info->quota_root = root;
2346 2347 2348
	}

	location.objectid = BTRFS_UUID_TREE_OBJECTID;
2349 2350 2351
	root = btrfs_read_tree_root(tree_root, &location);
	if (IS_ERR(root)) {
		ret = PTR_ERR(root);
2352
		if (ret != -ENOENT)
2353
			goto out;
2354
	} else {
2355 2356
		set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
		fs_info->uuid_root = root;
2357 2358
	}

2359 2360 2361
	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);
2362 2363 2364 2365
		if (IS_ERR(root)) {
			ret = PTR_ERR(root);
			goto out;
		}
2366 2367 2368 2369
		set_bit(BTRFS_ROOT_TRACK_DIRTY, &root->state);
		fs_info->free_space_root = root;
	}

2370
	return 0;
2371 2372 2373 2374
out:
	btrfs_warn(fs_info, "failed to read root (objectid=%llu): %d",
		   location.objectid, ret);
	return ret;
2375 2376
}

2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388
/*
 * Real super block validation
 * NOTE: super csum type and incompat features will not be checked here.
 *
 * @sb:		super block to check
 * @mirror_num:	the super block number to check its bytenr:
 * 		0	the primary (1st) sb
 * 		1, 2	2nd and 3rd backup copy
 * 	       -1	skip bytenr check
 */
static int validate_super(struct btrfs_fs_info *fs_info,
			    struct btrfs_super_block *sb, int mirror_num)
2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462
{
	u64 nodesize = btrfs_super_nodesize(sb);
	u64 sectorsize = btrfs_super_sectorsize(sb);
	int ret = 0;

	if (btrfs_super_magic(sb) != BTRFS_MAGIC) {
		btrfs_err(fs_info, "no valid FS found");
		ret = -EINVAL;
	}
	if (btrfs_super_flags(sb) & ~BTRFS_SUPER_FLAG_SUPP) {
		btrfs_err(fs_info, "unrecognized or unsupported super flag: %llu",
				btrfs_super_flags(sb) & ~BTRFS_SUPER_FLAG_SUPP);
		ret = -EINVAL;
	}
	if (btrfs_super_root_level(sb) >= BTRFS_MAX_LEVEL) {
		btrfs_err(fs_info, "tree_root level too big: %d >= %d",
				btrfs_super_root_level(sb), BTRFS_MAX_LEVEL);
		ret = -EINVAL;
	}
	if (btrfs_super_chunk_root_level(sb) >= BTRFS_MAX_LEVEL) {
		btrfs_err(fs_info, "chunk_root level too big: %d >= %d",
				btrfs_super_chunk_root_level(sb), BTRFS_MAX_LEVEL);
		ret = -EINVAL;
	}
	if (btrfs_super_log_root_level(sb) >= BTRFS_MAX_LEVEL) {
		btrfs_err(fs_info, "log_root level too big: %d >= %d",
				btrfs_super_log_root_level(sb), BTRFS_MAX_LEVEL);
		ret = -EINVAL;
	}

	/*
	 * Check sectorsize and nodesize first, other check will need it.
	 * Check all possible sectorsize(4K, 8K, 16K, 32K, 64K) here.
	 */
	if (!is_power_of_2(sectorsize) || sectorsize < 4096 ||
	    sectorsize > BTRFS_MAX_METADATA_BLOCKSIZE) {
		btrfs_err(fs_info, "invalid sectorsize %llu", sectorsize);
		ret = -EINVAL;
	}
	/* Only PAGE SIZE is supported yet */
	if (sectorsize != PAGE_SIZE) {
		btrfs_err(fs_info,
			"sectorsize %llu not supported yet, only support %lu",
			sectorsize, PAGE_SIZE);
		ret = -EINVAL;
	}
	if (!is_power_of_2(nodesize) || nodesize < sectorsize ||
	    nodesize > BTRFS_MAX_METADATA_BLOCKSIZE) {
		btrfs_err(fs_info, "invalid nodesize %llu", nodesize);
		ret = -EINVAL;
	}
	if (nodesize != le32_to_cpu(sb->__unused_leafsize)) {
		btrfs_err(fs_info, "invalid leafsize %u, should be %llu",
			  le32_to_cpu(sb->__unused_leafsize), nodesize);
		ret = -EINVAL;
	}

	/* Root alignment check */
	if (!IS_ALIGNED(btrfs_super_root(sb), sectorsize)) {
		btrfs_warn(fs_info, "tree_root block unaligned: %llu",
			   btrfs_super_root(sb));
		ret = -EINVAL;
	}
	if (!IS_ALIGNED(btrfs_super_chunk_root(sb), sectorsize)) {
		btrfs_warn(fs_info, "chunk_root block unaligned: %llu",
			   btrfs_super_chunk_root(sb));
		ret = -EINVAL;
	}
	if (!IS_ALIGNED(btrfs_super_log_root(sb), sectorsize)) {
		btrfs_warn(fs_info, "log_root block unaligned: %llu",
			   btrfs_super_log_root(sb));
		ret = -EINVAL;
	}

2463
	if (memcmp(fs_info->fs_devices->metadata_uuid, sb->dev_item.fsid,
2464
		   BTRFS_FSID_SIZE) != 0) {
2465
		btrfs_err(fs_info,
2466
			"dev_item UUID does not match metadata fsid: %pU != %pU",
2467
			fs_info->fs_devices->metadata_uuid, sb->dev_item.fsid);
2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492
		ret = -EINVAL;
	}

	/*
	 * Hint to catch really bogus numbers, bitflips or so, more exact checks are
	 * done later
	 */
	if (btrfs_super_bytes_used(sb) < 6 * btrfs_super_nodesize(sb)) {
		btrfs_err(fs_info, "bytes_used is too small %llu",
			  btrfs_super_bytes_used(sb));
		ret = -EINVAL;
	}
	if (!is_power_of_2(btrfs_super_stripesize(sb))) {
		btrfs_err(fs_info, "invalid stripesize %u",
			  btrfs_super_stripesize(sb));
		ret = -EINVAL;
	}
	if (btrfs_super_num_devices(sb) > (1UL << 31))
		btrfs_warn(fs_info, "suspicious number of devices: %llu",
			   btrfs_super_num_devices(sb));
	if (btrfs_super_num_devices(sb) == 0) {
		btrfs_err(fs_info, "number of devices is 0");
		ret = -EINVAL;
	}

2493 2494
	if (mirror_num >= 0 &&
	    btrfs_super_bytenr(sb) != btrfs_sb_offset(mirror_num)) {
2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537
		btrfs_err(fs_info, "super offset mismatch %llu != %u",
			  btrfs_super_bytenr(sb), BTRFS_SUPER_INFO_OFFSET);
		ret = -EINVAL;
	}

	/*
	 * 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) {
		btrfs_err(fs_info, "system chunk array too big %u > %u",
			  btrfs_super_sys_array_size(sb),
			  BTRFS_SYSTEM_CHUNK_ARRAY_SIZE);
		ret = -EINVAL;
	}
	if (btrfs_super_sys_array_size(sb) < sizeof(struct btrfs_disk_key)
			+ sizeof(struct btrfs_chunk)) {
		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));
		ret = -EINVAL;
	}

	/*
	 * 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.
	 */
	if (btrfs_super_generation(sb) < btrfs_super_chunk_root_generation(sb))
		btrfs_warn(fs_info,
			"suspicious: generation < chunk_root_generation: %llu < %llu",
			btrfs_super_generation(sb),
			btrfs_super_chunk_root_generation(sb));
	if (btrfs_super_generation(sb) < btrfs_super_cache_generation(sb)
	    && btrfs_super_cache_generation(sb) != (u64)-1)
		btrfs_warn(fs_info,
			"suspicious: generation < cache_generation: %llu < %llu",
			btrfs_super_generation(sb),
			btrfs_super_cache_generation(sb));

	return ret;
}

2538 2539 2540 2541 2542 2543 2544 2545 2546 2547
/*
 * Validation of super block at mount time.
 * Some checks already done early at mount time, like csum type and incompat
 * flags will be skipped.
 */
static int btrfs_validate_mount_super(struct btrfs_fs_info *fs_info)
{
	return validate_super(fs_info, fs_info->super_copy, 0);
}

2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561
/*
 * Validation of super block at write time.
 * Some checks like bytenr check will be skipped as their values will be
 * overwritten soon.
 * Extra checks like csum type and incompat flags will be done here.
 */
static int btrfs_validate_write_super(struct btrfs_fs_info *fs_info,
				      struct btrfs_super_block *sb)
{
	int ret;

	ret = validate_super(fs_info, sb, -1);
	if (ret < 0)
		goto out;
2562
	if (!btrfs_supported_super_csum(btrfs_super_csum_type(sb))) {
2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582
		ret = -EUCLEAN;
		btrfs_err(fs_info, "invalid csum type, has %u want %u",
			  btrfs_super_csum_type(sb), BTRFS_CSUM_TYPE_CRC32);
		goto out;
	}
	if (btrfs_super_incompat_flags(sb) & ~BTRFS_FEATURE_INCOMPAT_SUPP) {
		ret = -EUCLEAN;
		btrfs_err(fs_info,
		"invalid incompat flags, has 0x%llx valid mask 0x%llx",
			  btrfs_super_incompat_flags(sb),
			  (unsigned long long)BTRFS_FEATURE_INCOMPAT_SUPP);
		goto out;
	}
out:
	if (ret < 0)
		btrfs_err(fs_info,
		"super block corruption detected before writing it to disk");
	return ret;
}

2583
static int __cold init_tree_roots(struct btrfs_fs_info *fs_info)
2584
{
2585
	int backup_index = find_newest_super_backup(fs_info);
2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615
	struct btrfs_super_block *sb = fs_info->super_copy;
	struct btrfs_root *tree_root = fs_info->tree_root;
	bool handle_error = false;
	int ret = 0;
	int i;

	for (i = 0; i < BTRFS_NUM_BACKUP_ROOTS; i++) {
		u64 generation;
		int level;

		if (handle_error) {
			if (!IS_ERR(tree_root->node))
				free_extent_buffer(tree_root->node);
			tree_root->node = NULL;

			if (!btrfs_test_opt(fs_info, USEBACKUPROOT))
				break;

			free_root_pointers(fs_info, 0);

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

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

			ret = read_backup_root(fs_info, i);
2616
			backup_index = ret;
2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640
			if (ret < 0)
				return ret;
		}
		generation = btrfs_super_generation(sb);
		level = btrfs_super_root_level(sb);
		tree_root->node = read_tree_block(fs_info, btrfs_super_root(sb),
						  generation, level, NULL);
		if (IS_ERR(tree_root->node) ||
		    !extent_buffer_uptodate(tree_root->node)) {
			handle_error = true;

			if (IS_ERR(tree_root->node))
				ret = PTR_ERR(tree_root->node);
			else if (!extent_buffer_uptodate(tree_root->node))
				ret = -EUCLEAN;

			btrfs_warn(fs_info, "failed to read tree root");
			continue;
		}

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

2641 2642 2643 2644
		/*
		 * No need to hold btrfs_root::objectid_mutex since the fs
		 * hasn't been fully initialised and we are the only user
		 */
2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662
		ret = btrfs_find_highest_objectid(tree_root,
						&tree_root->highest_objectid);
		if (ret < 0) {
			handle_error = true;
			continue;
		}

		ASSERT(tree_root->highest_objectid <= BTRFS_LAST_FREE_OBJECTID);

		ret = btrfs_read_roots(fs_info);
		if (ret < 0) {
			handle_error = true;
			continue;
		}

		/* All successful */
		fs_info->generation = generation;
		fs_info->last_trans_committed = generation;
2663 2664 2665 2666 2667 2668 2669 2670

		/* Always begin writing backup roots after the one being used */
		if (backup_index < 0) {
			fs_info->backup_root_index = 0;
		} else {
			fs_info->backup_root_index = backup_index + 1;
			fs_info->backup_root_index %= BTRFS_NUM_BACKUP_ROOTS;
		}
2671 2672 2673 2674 2675 2676
		break;
	}

	return ret;
}

2677
void btrfs_init_fs_info(struct btrfs_fs_info *fs_info)
2678
{
2679
	INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_ATOMIC);
2680
	INIT_RADIX_TREE(&fs_info->buffer_radix, GFP_ATOMIC);
C
Chris Mason 已提交
2681
	INIT_LIST_HEAD(&fs_info->trans_list);
2682
	INIT_LIST_HEAD(&fs_info->dead_roots);
Y
Yan, Zheng 已提交
2683
	INIT_LIST_HEAD(&fs_info->delayed_iputs);
2684
	INIT_LIST_HEAD(&fs_info->delalloc_roots);
2685
	INIT_LIST_HEAD(&fs_info->caching_block_groups);
2686
	spin_lock_init(&fs_info->delalloc_root_lock);
J
Josef Bacik 已提交
2687
	spin_lock_init(&fs_info->trans_lock);
2688
	spin_lock_init(&fs_info->fs_roots_radix_lock);
Y
Yan, Zheng 已提交
2689
	spin_lock_init(&fs_info->delayed_iput_lock);
C
Chris Mason 已提交
2690
	spin_lock_init(&fs_info->defrag_inodes_lock);
2691
	spin_lock_init(&fs_info->super_lock);
2692
	spin_lock_init(&fs_info->buffer_lock);
2693
	spin_lock_init(&fs_info->unused_bgs_lock);
J
Jan Schmidt 已提交
2694
	rwlock_init(&fs_info->tree_mod_log_lock);
2695
	mutex_init(&fs_info->unused_bg_unpin_mutex);
2696
	mutex_init(&fs_info->delete_unused_bgs_mutex);
C
Chris Mason 已提交
2697
	mutex_init(&fs_info->reloc_mutex);
2698
	mutex_init(&fs_info->delalloc_root_mutex);
2699
	seqlock_init(&fs_info->profiles_lock);
2700

2701
	INIT_LIST_HEAD(&fs_info->dirty_cowonly_roots);
2702
	INIT_LIST_HEAD(&fs_info->space_info);
J
Jan Schmidt 已提交
2703
	INIT_LIST_HEAD(&fs_info->tree_mod_seq_list);
2704
	INIT_LIST_HEAD(&fs_info->unused_bgs);
J
Josef Bacik 已提交
2705 2706 2707
#ifdef CONFIG_BTRFS_DEBUG
	INIT_LIST_HEAD(&fs_info->allocated_roots);
#endif
2708
	extent_map_tree_init(&fs_info->mapping_tree);
2709 2710 2711 2712 2713 2714 2715
	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);
J
Josef Bacik 已提交
2716 2717 2718
	btrfs_init_block_rsv(&fs_info->delayed_refs_rsv,
			     BTRFS_BLOCK_RSV_DELREFS);

2719
	atomic_set(&fs_info->async_delalloc_pages, 0);
C
Chris Mason 已提交
2720
	atomic_set(&fs_info->defrag_running, 0);
Z
Zhao Lei 已提交
2721
	atomic_set(&fs_info->reada_works_cnt, 0);
2722
	atomic_set(&fs_info->nr_delayed_iputs, 0);
2723
	atomic64_set(&fs_info->tree_mod_seq, 0);
2724
	fs_info->max_inline = BTRFS_DEFAULT_MAX_INLINE;
J
Josef Bacik 已提交
2725
	fs_info->metadata_ratio = 0;
C
Chris Mason 已提交
2726
	fs_info->defrag_inodes = RB_ROOT;
2727
	atomic64_set(&fs_info->free_chunk_space, 0);
J
Jan Schmidt 已提交
2728
	fs_info->tree_mod_log = RB_ROOT;
2729
	fs_info->commit_interval = BTRFS_DEFAULT_COMMIT_INTERVAL;
2730
	fs_info->avg_delayed_ref_runtime = NSEC_PER_SEC >> 6; /* div by 64 */
2731
	/* readahead state */
2732
	INIT_RADIX_TREE(&fs_info->reada_tree, GFP_NOFS & ~__GFP_DIRECT_RECLAIM);
2733
	spin_lock_init(&fs_info->reada_lock);
J
Josef Bacik 已提交
2734
	btrfs_init_ref_verify(fs_info);
C
Chris Mason 已提交
2735

2736 2737
	fs_info->thread_pool_size = min_t(unsigned long,
					  num_online_cpus() + 2, 8);
2738

2739 2740
	INIT_LIST_HEAD(&fs_info->ordered_roots);
	spin_lock_init(&fs_info->ordered_root_lock);
2741

2742
	btrfs_init_scrub(fs_info);
2743 2744 2745
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
	fs_info->check_integrity_print_mask = 0;
#endif
2746
	btrfs_init_balance(fs_info);
2747
	btrfs_init_async_reclaim_work(&fs_info->async_reclaim_work);
A
Arne Jansen 已提交
2748

J
Josef Bacik 已提交
2749
	spin_lock_init(&fs_info->block_group_cache_lock);
2750
	fs_info->block_group_cache_tree = RB_ROOT;
2751
	fs_info->first_logical_byte = (u64)-1;
J
Josef Bacik 已提交
2752

2753 2754 2755 2756
	extent_io_tree_init(fs_info, &fs_info->freed_extents[0],
			    IO_TREE_FS_INFO_FREED_EXTENTS0, NULL);
	extent_io_tree_init(fs_info, &fs_info->freed_extents[1],
			    IO_TREE_FS_INFO_FREED_EXTENTS1, NULL);
2757
	fs_info->pinned_extents = &fs_info->freed_extents[0];
2758
	set_bit(BTRFS_FS_BARRIER, &fs_info->flags);
C
Chris Mason 已提交
2759

2760
	mutex_init(&fs_info->ordered_operations_mutex);
2761
	mutex_init(&fs_info->tree_log_mutex);
2762
	mutex_init(&fs_info->chunk_mutex);
2763 2764
	mutex_init(&fs_info->transaction_kthread_mutex);
	mutex_init(&fs_info->cleaner_mutex);
2765
	mutex_init(&fs_info->ro_block_group_mutex);
2766
	init_rwsem(&fs_info->commit_root_sem);
2767
	init_rwsem(&fs_info->cleanup_work_sem);
2768
	init_rwsem(&fs_info->subvol_sem);
S
Stefan Behrens 已提交
2769
	sema_init(&fs_info->uuid_tree_rescan_sem, 1);
2770

2771
	btrfs_init_dev_replace_locks(fs_info);
2772
	btrfs_init_qgroup(fs_info);
2773
	btrfs_discard_init(fs_info);
2774

2775 2776 2777
	btrfs_init_free_cluster(&fs_info->meta_alloc_cluster);
	btrfs_init_free_cluster(&fs_info->data_alloc_cluster);

2778
	init_waitqueue_head(&fs_info->transaction_throttle);
2779
	init_waitqueue_head(&fs_info->transaction_wait);
S
Sage Weil 已提交
2780
	init_waitqueue_head(&fs_info->transaction_blocked_wait);
2781
	init_waitqueue_head(&fs_info->async_submit_wait);
2782
	init_waitqueue_head(&fs_info->delayed_iputs_wait);
2783

2784 2785 2786 2787 2788
	/* Usable values until the real ones are cached from the superblock */
	fs_info->nodesize = 4096;
	fs_info->sectorsize = 4096;
	fs_info->stripesize = 4096;

2789 2790 2791
	spin_lock_init(&fs_info->swapfile_pins_lock);
	fs_info->swapfile_pins = RB_ROOT;

2792
	fs_info->send_in_progress = 0;
2793 2794 2795 2796 2797 2798 2799 2800 2801
}

static int init_mount_fs_info(struct btrfs_fs_info *fs_info, struct super_block *sb)
{
	int ret;

	fs_info->sb = sb;
	sb->s_blocksize = BTRFS_BDEV_BLOCKSIZE;
	sb->s_blocksize_bits = blksize_bits(BTRFS_BDEV_BLOCKSIZE);
2802

2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834
	ret = init_srcu_struct(&fs_info->subvol_srcu);
	if (ret)
		return ret;

	ret = percpu_counter_init(&fs_info->dio_bytes, 0, GFP_KERNEL);
	if (ret)
		goto fail;

	ret = percpu_counter_init(&fs_info->dirty_metadata_bytes, 0, GFP_KERNEL);
	if (ret)
		goto fail;

	fs_info->dirty_metadata_batch = PAGE_SIZE *
					(1 + ilog2(nr_cpu_ids));

	ret = percpu_counter_init(&fs_info->delalloc_bytes, 0, GFP_KERNEL);
	if (ret)
		goto fail;

	ret = percpu_counter_init(&fs_info->dev_replace.bio_counter, 0,
			GFP_KERNEL);
	if (ret)
		goto fail;

	fs_info->delayed_root = kmalloc(sizeof(struct btrfs_delayed_root),
					GFP_KERNEL);
	if (!fs_info->delayed_root) {
		ret = -ENOMEM;
		goto fail;
	}
	btrfs_init_delayed_root(fs_info->delayed_root);

D
David Woodhouse 已提交
2835
	ret = btrfs_alloc_stripe_hash_table(fs_info);
2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864
	if (ret)
		goto fail;

	return 0;
fail:
	cleanup_srcu_struct(&fs_info->subvol_srcu);
	return ret;
}

int __cold open_ctree(struct super_block *sb, struct btrfs_fs_devices *fs_devices,
		      char *options)
{
	u32 sectorsize;
	u32 nodesize;
	u32 stripesize;
	u64 generation;
	u64 features;
	u16 csum_type;
	struct btrfs_key location;
	struct buffer_head *bh;
	struct btrfs_super_block *disk_super;
	struct btrfs_fs_info *fs_info = btrfs_sb(sb);
	struct btrfs_root *tree_root;
	struct btrfs_root *chunk_root;
	int ret;
	int err = -EINVAL;
	int clear_free_space_tree = 0;
	int level;

2865
	ret = init_mount_fs_info(fs_info, sb);
D
David Woodhouse 已提交
2866
	if (ret) {
2867
		err = ret;
2868
		goto fail;
D
David Woodhouse 已提交
2869 2870
	}

2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890
	/* These need to be init'ed before we start creating inodes and such. */
	tree_root = btrfs_alloc_root(fs_info, BTRFS_ROOT_TREE_OBJECTID,
				     GFP_KERNEL);
	fs_info->tree_root = tree_root;
	chunk_root = btrfs_alloc_root(fs_info, BTRFS_CHUNK_TREE_OBJECTID,
				      GFP_KERNEL);
	fs_info->chunk_root = chunk_root;
	if (!tree_root || !chunk_root) {
		err = -ENOMEM;
		goto fail_srcu;
	}

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

2891
	invalidate_bdev(fs_devices->latest_bdev);
D
David Sterba 已提交
2892 2893 2894 2895

	/*
	 * Read super block and check the signature bytes only
	 */
Y
Yan Zheng 已提交
2896
	bh = btrfs_read_dev_super(fs_devices->latest_bdev);
2897 2898
	if (IS_ERR(bh)) {
		err = PTR_ERR(bh);
2899
		goto fail_alloc;
2900
	}
C
Chris Mason 已提交
2901

2902 2903 2904 2905
	/*
	 * Verify the type first, if that or the the checksum value are
	 * corrupted, we'll find out
	 */
2906 2907
	csum_type = btrfs_super_csum_type((struct btrfs_super_block *)bh->b_data);
	if (!btrfs_supported_super_csum(csum_type)) {
2908
		btrfs_err(fs_info, "unsupported checksum algorithm: %u",
2909
			  csum_type);
2910 2911 2912 2913 2914
		err = -EINVAL;
		brelse(bh);
		goto fail_alloc;
	}

2915 2916 2917 2918 2919 2920
	ret = btrfs_init_csum_hash(fs_info, csum_type);
	if (ret) {
		err = ret;
		goto fail_alloc;
	}

D
David Sterba 已提交
2921 2922 2923 2924
	/*
	 * We want to check superblock checksum, the type is stored inside.
	 * Pass the whole disk block of size BTRFS_SUPER_INFO_SIZE (4k).
	 */
2925
	if (btrfs_check_super_csum(fs_info, bh->b_data)) {
2926
		btrfs_err(fs_info, "superblock checksum mismatch");
D
David Sterba 已提交
2927
		err = -EINVAL;
2928
		brelse(bh);
2929
		goto fail_alloc;
D
David Sterba 已提交
2930 2931 2932 2933 2934 2935 2936
	}

	/*
	 * 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
	 */
2937
	memcpy(fs_info->super_copy, bh->b_data, sizeof(*fs_info->super_copy));
2938
	brelse(bh);
2939

2940 2941
	disk_super = fs_info->super_copy;

2942 2943 2944
	ASSERT(!memcmp(fs_info->fs_devices->fsid, fs_info->super_copy->fsid,
		       BTRFS_FSID_SIZE));

2945
	if (btrfs_fs_incompat(fs_info, METADATA_UUID)) {
2946 2947 2948
		ASSERT(!memcmp(fs_info->fs_devices->metadata_uuid,
				fs_info->super_copy->metadata_uuid,
				BTRFS_FSID_SIZE));
2949
	}
2950

2951 2952 2953 2954 2955 2956 2957 2958 2959 2960
	features = btrfs_super_flags(disk_super);
	if (features & BTRFS_SUPER_FLAG_CHANGING_FSID_V2) {
		features &= ~BTRFS_SUPER_FLAG_CHANGING_FSID_V2;
		btrfs_set_super_flags(disk_super, features);
		btrfs_info(fs_info,
			"found metadata UUID change in progress flag, clearing");
	}

	memcpy(fs_info->super_for_commit, fs_info->super_copy,
	       sizeof(*fs_info->super_for_commit));
2961

2962
	ret = btrfs_validate_mount_super(fs_info);
D
David Sterba 已提交
2963
	if (ret) {
2964
		btrfs_err(fs_info, "superblock contains fatal errors");
D
David Sterba 已提交
2965
		err = -EINVAL;
2966
		goto fail_alloc;
D
David Sterba 已提交
2967 2968
	}

2969
	if (!btrfs_super_root(disk_super))
2970
		goto fail_alloc;
2971

L
liubo 已提交
2972
	/* check FS state, whether FS is broken. */
2973 2974
	if (btrfs_super_flags(disk_super) & BTRFS_SUPER_FLAG_ERROR)
		set_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state);
L
liubo 已提交
2975

2976 2977 2978 2979 2980 2981
	/*
	 * 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;

2982
	ret = btrfs_parse_options(fs_info, options, sb->s_flags);
Y
Yan Zheng 已提交
2983 2984
	if (ret) {
		err = ret;
2985
		goto fail_alloc;
Y
Yan Zheng 已提交
2986
	}
2987

2988 2989 2990
	features = btrfs_super_incompat_flags(disk_super) &
		~BTRFS_FEATURE_INCOMPAT_SUPP;
	if (features) {
2991 2992 2993
		btrfs_err(fs_info,
		    "cannot mount because of unsupported optional features (%llx)",
		    features);
2994
		err = -EINVAL;
2995
		goto fail_alloc;
2996 2997
	}

2998
	features = btrfs_super_incompat_flags(disk_super);
L
Li Zefan 已提交
2999
	features |= BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF;
3000
	if (fs_info->compress_type == BTRFS_COMPRESS_LZO)
L
Li Zefan 已提交
3001
		features |= BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO;
N
Nick Terrell 已提交
3002 3003
	else if (fs_info->compress_type == BTRFS_COMPRESS_ZSTD)
		features |= BTRFS_FEATURE_INCOMPAT_COMPRESS_ZSTD;
3004

3005
	if (features & BTRFS_FEATURE_INCOMPAT_SKINNY_METADATA)
3006
		btrfs_info(fs_info, "has skinny extents");
3007

3008 3009 3010 3011
	/*
	 * flag our filesystem as having big metadata blocks if
	 * they are bigger than the page size
	 */
3012
	if (btrfs_super_nodesize(disk_super) > PAGE_SIZE) {
3013
		if (!(features & BTRFS_FEATURE_INCOMPAT_BIG_METADATA))
3014 3015
			btrfs_info(fs_info,
				"flagging fs with big metadata feature");
3016 3017 3018
		features |= BTRFS_FEATURE_INCOMPAT_BIG_METADATA;
	}

3019 3020
	nodesize = btrfs_super_nodesize(disk_super);
	sectorsize = btrfs_super_sectorsize(disk_super);
3021
	stripesize = sectorsize;
3022
	fs_info->dirty_metadata_batch = nodesize * (1 + ilog2(nr_cpu_ids));
3023
	fs_info->delalloc_batch = sectorsize * 512 * (1 + ilog2(nr_cpu_ids));
3024

3025 3026 3027 3028 3029
	/* Cache block sizes */
	fs_info->nodesize = nodesize;
	fs_info->sectorsize = sectorsize;
	fs_info->stripesize = stripesize;

3030 3031 3032 3033 3034
	/*
	 * 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) &&
3035
	    (sectorsize != nodesize)) {
3036 3037 3038
		btrfs_err(fs_info,
"unequal nodesize/sectorsize (%u != %u) are not allowed for mixed block groups",
			nodesize, sectorsize);
3039
		goto fail_alloc;
3040 3041
	}

3042 3043 3044 3045
	/*
	 * Needn't use the lock because there is no other task which will
	 * update the flag.
	 */
L
Li Zefan 已提交
3046
	btrfs_set_super_incompat_flags(disk_super, features);
3047

3048 3049
	features = btrfs_super_compat_ro_flags(disk_super) &
		~BTRFS_FEATURE_COMPAT_RO_SUPP;
3050
	if (!sb_rdonly(sb) && features) {
3051 3052
		btrfs_err(fs_info,
	"cannot mount read-write because of unsupported optional features (%llx)",
3053
		       features);
3054
		err = -EINVAL;
3055
		goto fail_alloc;
3056
	}
3057

3058 3059 3060
	ret = btrfs_init_workqueues(fs_info, fs_devices);
	if (ret) {
		err = ret;
3061 3062
		goto fail_sb_buffer;
	}
3063

3064 3065 3066
	sb->s_bdi->congested_fn = btrfs_congested_fn;
	sb->s_bdi->congested_data = fs_info;
	sb->s_bdi->capabilities |= BDI_CAP_CGROUP_WRITEBACK;
3067
	sb->s_bdi->ra_pages = VM_READAHEAD_PAGES;
3068 3069
	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);
3070

3071 3072
	sb->s_blocksize = sectorsize;
	sb->s_blocksize_bits = blksize_bits(sectorsize);
3073
	memcpy(&sb->s_uuid, fs_info->fs_devices->fsid, BTRFS_FSID_SIZE);
3074

3075
	mutex_lock(&fs_info->chunk_mutex);
3076
	ret = btrfs_read_sys_array(fs_info);
3077
	mutex_unlock(&fs_info->chunk_mutex);
3078
	if (ret) {
3079
		btrfs_err(fs_info, "failed to read the system array: %d", ret);
3080
		goto fail_sb_buffer;
3081
	}
3082

3083
	generation = btrfs_super_chunk_root_generation(disk_super);
3084
	level = btrfs_super_chunk_root_level(disk_super);
3085

3086
	chunk_root->node = read_tree_block(fs_info,
3087
					   btrfs_super_chunk_root(disk_super),
3088
					   generation, level, NULL);
3089 3090
	if (IS_ERR(chunk_root->node) ||
	    !extent_buffer_uptodate(chunk_root->node)) {
3091
		btrfs_err(fs_info, "failed to read chunk root");
3092 3093
		if (!IS_ERR(chunk_root->node))
			free_extent_buffer(chunk_root->node);
3094
		chunk_root->node = NULL;
C
Chris Mason 已提交
3095
		goto fail_tree_roots;
3096
	}
3097 3098
	btrfs_set_root_node(&chunk_root->root_item, chunk_root->node);
	chunk_root->commit_root = btrfs_root_node(chunk_root);
3099

3100
	read_extent_buffer(chunk_root->node, fs_info->chunk_tree_uuid,
3101
	   btrfs_header_chunk_tree_uuid(chunk_root->node), BTRFS_UUID_SIZE);
3102

3103
	ret = btrfs_read_chunk_tree(fs_info);
Y
Yan Zheng 已提交
3104
	if (ret) {
3105
		btrfs_err(fs_info, "failed to read chunk tree: %d", ret);
C
Chris Mason 已提交
3106
		goto fail_tree_roots;
Y
Yan Zheng 已提交
3107
	}
3108

3109
	/*
3110 3111
	 * Keep the devid that is marked to be the target device for the
	 * device replace procedure
3112
	 */
3113
	btrfs_free_extra_devids(fs_devices, 0);
3114

3115
	if (!fs_devices->latest_bdev) {
3116
		btrfs_err(fs_info, "failed to read devices");
3117 3118 3119
		goto fail_tree_roots;
	}

3120
	ret = init_tree_roots(fs_info);
3121
	if (ret)
3122
		goto fail_tree_roots;
3123

3124 3125 3126 3127 3128 3129 3130
	ret = btrfs_verify_dev_extents(fs_info);
	if (ret) {
		btrfs_err(fs_info,
			  "failed to verify dev extents against chunks: %d",
			  ret);
		goto fail_block_groups;
	}
3131 3132
	ret = btrfs_recover_balance(fs_info);
	if (ret) {
3133
		btrfs_err(fs_info, "failed to recover balance: %d", ret);
3134 3135 3136
		goto fail_block_groups;
	}

3137 3138
	ret = btrfs_init_dev_stats(fs_info);
	if (ret) {
3139
		btrfs_err(fs_info, "failed to init dev_stats: %d", ret);
3140 3141 3142
		goto fail_block_groups;
	}

3143 3144
	ret = btrfs_init_dev_replace(fs_info);
	if (ret) {
3145
		btrfs_err(fs_info, "failed to init dev_replace: %d", ret);
3146 3147 3148
		goto fail_block_groups;
	}

3149
	btrfs_free_extra_devids(fs_devices, 1);
3150

3151
	ret = btrfs_sysfs_add_fsid(fs_devices);
3152
	if (ret) {
3153 3154
		btrfs_err(fs_info, "failed to init sysfs fsid interface: %d",
				ret);
3155 3156 3157
		goto fail_block_groups;
	}

3158
	ret = btrfs_sysfs_add_mounted(fs_info);
3159
	if (ret) {
3160
		btrfs_err(fs_info, "failed to init sysfs interface: %d", ret);
3161
		goto fail_fsdev_sysfs;
3162 3163 3164 3165
	}

	ret = btrfs_init_space_info(fs_info);
	if (ret) {
3166
		btrfs_err(fs_info, "failed to initialize space info: %d", ret);
3167
		goto fail_sysfs;
3168 3169
	}

3170
	ret = btrfs_read_block_groups(fs_info);
3171
	if (ret) {
3172
		btrfs_err(fs_info, "failed to read block groups: %d", ret);
3173
		goto fail_sysfs;
3174
	}
3175

3176
	if (!sb_rdonly(sb) && !btrfs_check_rw_degradable(fs_info, NULL)) {
3177
		btrfs_warn(fs_info,
3178
		"writable mount is not allowed due to too many missing devices");
3179
		goto fail_sysfs;
3180
	}
C
Chris Mason 已提交
3181

3182 3183
	fs_info->cleaner_kthread = kthread_run(cleaner_kthread, tree_root,
					       "btrfs-cleaner");
3184
	if (IS_ERR(fs_info->cleaner_kthread))
3185
		goto fail_sysfs;
3186 3187 3188 3189

	fs_info->transaction_kthread = kthread_run(transaction_kthread,
						   tree_root,
						   "btrfs-transaction");
3190
	if (IS_ERR(fs_info->transaction_kthread))
3191
		goto fail_cleaner;
3192

3193
	if (!btrfs_test_opt(fs_info, NOSSD) &&
C
Chris Mason 已提交
3194
	    !fs_info->fs_devices->rotating) {
3195
		btrfs_set_and_info(fs_info, SSD, "enabling ssd optimizations");
C
Chris Mason 已提交
3196 3197
	}

3198
	/*
3199
	 * Mount does not set all options immediately, we can do it now and do
3200 3201 3202
	 * not have to wait for transaction commit
	 */
	btrfs_apply_pending_changes(fs_info);
3203

3204
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
3205
	if (btrfs_test_opt(fs_info, CHECK_INTEGRITY)) {
3206
		ret = btrfsic_mount(fs_info, fs_devices,
3207
				    btrfs_test_opt(fs_info,
3208 3209 3210 3211
					CHECK_INTEGRITY_INCLUDING_EXTENT_DATA) ?
				    1 : 0,
				    fs_info->check_integrity_print_mask);
		if (ret)
3212 3213 3214
			btrfs_warn(fs_info,
				"failed to initialize integrity check module: %d",
				ret);
3215 3216
	}
#endif
3217 3218 3219
	ret = btrfs_read_qgroup_config(fs_info);
	if (ret)
		goto fail_trans_kthread;
3220

J
Josef Bacik 已提交
3221 3222 3223
	if (btrfs_build_ref_tree(fs_info))
		btrfs_err(fs_info, "couldn't build ref tree");

3224 3225
	/* do not make disk changes in broken FS or nologreplay is given */
	if (btrfs_super_log_root(disk_super) != 0 &&
3226
	    !btrfs_test_opt(fs_info, NOLOGREPLAY)) {
3227
		btrfs_info(fs_info, "start tree-log replay");
3228
		ret = btrfs_replay_log(fs_info, fs_devices);
3229
		if (ret) {
3230
			err = ret;
3231
			goto fail_qgroup;
3232
		}
3233
	}
Z
Zheng Yan 已提交
3234

3235
	ret = btrfs_find_orphan_roots(fs_info);
3236
	if (ret)
3237
		goto fail_qgroup;
3238

3239
	if (!sb_rdonly(sb)) {
3240
		ret = btrfs_cleanup_fs_roots(fs_info);
3241
		if (ret)
3242
			goto fail_qgroup;
3243 3244

		mutex_lock(&fs_info->cleaner_mutex);
3245
		ret = btrfs_recover_relocation(tree_root);
3246
		mutex_unlock(&fs_info->cleaner_mutex);
3247
		if (ret < 0) {
3248 3249
			btrfs_warn(fs_info, "failed to recover relocation: %d",
					ret);
3250
			err = -EINVAL;
3251
			goto fail_qgroup;
3252
		}
3253
	}
Z
Zheng Yan 已提交
3254

3255 3256
	location.objectid = BTRFS_FS_TREE_OBJECTID;
	location.type = BTRFS_ROOT_ITEM_KEY;
3257
	location.offset = 0;
3258

3259
	fs_info->fs_root = btrfs_get_fs_root(fs_info, &location, true);
3260 3261
	if (IS_ERR(fs_info->fs_root)) {
		err = PTR_ERR(fs_info->fs_root);
3262
		btrfs_warn(fs_info, "failed to read fs tree: %d", err);
3263
		fs_info->fs_root = NULL;
3264
		goto fail_qgroup;
3265
	}
C
Chris Mason 已提交
3266

3267
	if (sb_rdonly(sb))
3268
		return 0;
I
Ilya Dryomov 已提交
3269

3270 3271
	if (btrfs_test_opt(fs_info, CLEAR_CACHE) &&
	    btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) {
3272 3273 3274 3275 3276 3277 3278 3279
		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) {
3280 3281 3282 3283 3284
		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);
3285
			close_ctree(fs_info);
3286 3287 3288 3289
			return ret;
		}
	}

3290
	if (btrfs_test_opt(fs_info, FREE_SPACE_TREE) &&
3291
	    !btrfs_fs_compat_ro(fs_info, FREE_SPACE_TREE)) {
3292
		btrfs_info(fs_info, "creating free space tree");
3293 3294
		ret = btrfs_create_free_space_tree(fs_info);
		if (ret) {
3295 3296
			btrfs_warn(fs_info,
				"failed to create free space tree: %d", ret);
3297
			close_ctree(fs_info);
3298 3299 3300 3301
			return ret;
		}
	}

3302 3303 3304
	down_read(&fs_info->cleanup_work_sem);
	if ((ret = btrfs_orphan_cleanup(fs_info->fs_root)) ||
	    (ret = btrfs_orphan_cleanup(fs_info->tree_root))) {
3305
		up_read(&fs_info->cleanup_work_sem);
3306
		close_ctree(fs_info);
3307 3308 3309
		return ret;
	}
	up_read(&fs_info->cleanup_work_sem);
I
Ilya Dryomov 已提交
3310

3311 3312
	ret = btrfs_resume_balance_async(fs_info);
	if (ret) {
3313
		btrfs_warn(fs_info, "failed to resume balance: %d", ret);
3314
		close_ctree(fs_info);
3315
		return ret;
3316 3317
	}

3318 3319
	ret = btrfs_resume_dev_replace_async(fs_info);
	if (ret) {
3320
		btrfs_warn(fs_info, "failed to resume device replace: %d", ret);
3321
		close_ctree(fs_info);
3322 3323 3324
		return ret;
	}

3325
	btrfs_qgroup_rescan_resume(fs_info);
3326
	btrfs_discard_resume(fs_info);
3327

3328
	if (!fs_info->uuid_root) {
3329
		btrfs_info(fs_info, "creating UUID tree");
3330 3331
		ret = btrfs_create_uuid_tree(fs_info);
		if (ret) {
3332 3333
			btrfs_warn(fs_info,
				"failed to create the UUID tree: %d", ret);
3334
			close_ctree(fs_info);
3335 3336
			return ret;
		}
3337
	} else if (btrfs_test_opt(fs_info, RESCAN_UUID_TREE) ||
3338 3339
		   fs_info->generation !=
				btrfs_super_uuid_tree_generation(disk_super)) {
3340
		btrfs_info(fs_info, "checking UUID tree");
3341 3342
		ret = btrfs_check_uuid_tree(fs_info);
		if (ret) {
3343 3344
			btrfs_warn(fs_info,
				"failed to check the UUID tree: %d", ret);
3345
			close_ctree(fs_info);
3346 3347 3348
			return ret;
		}
	} else {
3349
		set_bit(BTRFS_FS_UPDATE_UUID_TREE_GEN, &fs_info->flags);
3350
	}
3351
	set_bit(BTRFS_FS_OPEN, &fs_info->flags);
3352

3353 3354 3355 3356 3357 3358
	/*
	 * 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 已提交
3359
	return 0;
C
Chris Mason 已提交
3360

3361 3362
fail_qgroup:
	btrfs_free_qgroup_config(fs_info);
3363 3364
fail_trans_kthread:
	kthread_stop(fs_info->transaction_kthread);
3365
	btrfs_cleanup_transaction(fs_info);
3366
	btrfs_free_fs_roots(fs_info);
3367
fail_cleaner:
3368
	kthread_stop(fs_info->cleaner_kthread);
3369 3370 3371 3372 3373 3374 3375

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

3376
fail_sysfs:
3377
	btrfs_sysfs_remove_mounted(fs_info);
3378

3379 3380 3381
fail_fsdev_sysfs:
	btrfs_sysfs_remove_fsid(fs_info->fs_devices);

3382
fail_block_groups:
J
Josef Bacik 已提交
3383
	btrfs_put_block_group_cache(fs_info);
C
Chris Mason 已提交
3384 3385

fail_tree_roots:
3386
	free_root_pointers(fs_info, true);
3387
	invalidate_inode_pages2(fs_info->btree_inode->i_mapping);
C
Chris Mason 已提交
3388

C
Chris Mason 已提交
3389
fail_sb_buffer:
L
Liu Bo 已提交
3390
	btrfs_stop_all_workers(fs_info);
3391
	btrfs_free_block_groups(fs_info);
3392
fail_alloc:
3393 3394
	btrfs_mapping_tree_free(&fs_info->mapping_tree);

3395
	iput(fs_info->btree_inode);
3396 3397
fail_srcu:
	cleanup_srcu_struct(&fs_info->subvol_srcu);
3398
fail:
3399
	btrfs_close_devices(fs_info->fs_devices);
A
Al Viro 已提交
3400
	return err;
3401
}
3402
ALLOW_ERROR_INJECTION(open_ctree, ERRNO);
3403

3404 3405 3406 3407 3408
static void btrfs_end_buffer_write_sync(struct buffer_head *bh, int uptodate)
{
	if (uptodate) {
		set_buffer_uptodate(bh);
	} else {
3409 3410 3411
		struct btrfs_device *device = (struct btrfs_device *)
			bh->b_private;

3412
		btrfs_warn_rl_in_rcu(device->fs_info,
3413
				"lost page write due to IO error on %s",
3414
					  rcu_str_deref(device->name));
3415
		/* note, we don't set_buffer_write_io_error because we have
3416 3417
		 * our own ways of dealing with the IO errors
		 */
3418
		clear_buffer_uptodate(bh);
3419
		btrfs_dev_stat_inc_and_print(device, BTRFS_DEV_STAT_WRITE_ERRS);
3420 3421 3422 3423 3424
	}
	unlock_buffer(bh);
	put_bh(bh);
}

3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435
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;

3436
	bh = __bread(bdev, bytenr / BTRFS_BDEV_BLOCKSIZE, BTRFS_SUPER_INFO_SIZE);
3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455
	/*
	 * 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 已提交
3456 3457 3458 3459 3460 3461 3462
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;
3463
	int ret = -EINVAL;
Y
Yan Zheng 已提交
3464 3465 3466 3467 3468 3469 3470

	/* 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++) {
3471 3472
		ret = btrfs_read_dev_one_super(bdev, i, &bh);
		if (ret)
Y
Yan Zheng 已提交
3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484
			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);
		}
	}
3485 3486 3487 3488

	if (!latest)
		return ERR_PTR(ret);

Y
Yan Zheng 已提交
3489 3490 3491
	return latest;
}

3492
/*
3493 3494
 * Write superblock @sb to the @device. Do not wait for completion, all the
 * buffer heads we write are pinned.
3495
 *
3496 3497 3498
 * 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.
3499
 *
3500
 * Return number of errors when buffer head is not found or submission fails.
3501
 */
Y
Yan Zheng 已提交
3502
static int write_dev_supers(struct btrfs_device *device,
3503
			    struct btrfs_super_block *sb, int max_mirrors)
Y
Yan Zheng 已提交
3504
{
3505 3506
	struct btrfs_fs_info *fs_info = device->fs_info;
	SHASH_DESC_ON_STACK(shash, fs_info->csum_shash);
Y
Yan Zheng 已提交
3507 3508 3509 3510 3511
	struct buffer_head *bh;
	int i;
	int ret;
	int errors = 0;
	u64 bytenr;
3512
	int op_flags;
Y
Yan Zheng 已提交
3513 3514 3515 3516

	if (max_mirrors == 0)
		max_mirrors = BTRFS_SUPER_MIRROR_MAX;

3517 3518
	shash->tfm = fs_info->csum_shash;

Y
Yan Zheng 已提交
3519 3520
	for (i = 0; i < max_mirrors; i++) {
		bytenr = btrfs_sb_offset(i);
3521 3522
		if (bytenr + BTRFS_SUPER_INFO_SIZE >=
		    device->commit_total_bytes)
Y
Yan Zheng 已提交
3523 3524
			break;

3525
		btrfs_set_super_bytenr(sb, bytenr);
3526

3527 3528 3529 3530
		crypto_shash_init(shash);
		crypto_shash_update(shash, (const char *)sb + BTRFS_CSUM_SIZE,
				    BTRFS_SUPER_INFO_SIZE - BTRFS_CSUM_SIZE);
		crypto_shash_final(shash, sb->csum);
3531

3532
		/* One reference for us, and we leave it for the caller */
3533
		bh = __getblk(device->bdev, bytenr / BTRFS_BDEV_BLOCKSIZE,
3534 3535 3536 3537 3538 3539
			      BTRFS_SUPER_INFO_SIZE);
		if (!bh) {
			btrfs_err(device->fs_info,
			    "couldn't get super buffer head for bytenr %llu",
			    bytenr);
			errors++;
3540
			continue;
3541
		}
3542

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

3545 3546
		/* one reference for submit_bh */
		get_bh(bh);
3547

3548 3549 3550 3551
		set_buffer_uptodate(bh);
		lock_buffer(bh);
		bh->b_end_io = btrfs_end_buffer_write_sync;
		bh->b_private = device;
Y
Yan Zheng 已提交
3552

C
Chris Mason 已提交
3553 3554 3555 3556
		/*
		 * we fua the first super.  The others we allow
		 * to go down lazy.
		 */
3557 3558 3559 3560
		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);
3561
		if (ret)
Y
Yan Zheng 已提交
3562 3563 3564 3565 3566
			errors++;
	}
	return errors < i ? 0 : -1;
}

3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578
/*
 * 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;
3579
	bool primary_failed = false;
3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590
	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;

3591 3592
		bh = __find_get_block(device->bdev,
				      bytenr / BTRFS_BDEV_BLOCKSIZE,
3593 3594 3595
				      BTRFS_SUPER_INFO_SIZE);
		if (!bh) {
			errors++;
3596 3597
			if (i == 0)
				primary_failed = true;
3598 3599 3600
			continue;
		}
		wait_on_buffer(bh);
3601
		if (!buffer_uptodate(bh)) {
3602
			errors++;
3603 3604 3605
			if (i == 0)
				primary_failed = true;
		}
3606 3607 3608 3609 3610 3611 3612 3613

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

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

3614 3615 3616 3617 3618 3619 3620
	/* log error, force error return */
	if (primary_failed) {
		btrfs_err(device->fs_info, "error writing primary super block to device %llu",
			  device->devid);
		return -1;
	}

3621 3622 3623
	return errors < i ? 0 : -1;
}

C
Chris Mason 已提交
3624 3625 3626 3627
/*
 * endio for the write_dev_flush, this will wake anyone waiting
 * for the barrier when it is done
 */
3628
static void btrfs_end_empty_barrier(struct bio *bio)
C
Chris Mason 已提交
3629
{
3630
	complete(bio->bi_private);
C
Chris Mason 已提交
3631 3632 3633
}

/*
3634 3635
 * Submit a flush request to the device if it supports it. Error handling is
 * done in the waiting counterpart.
C
Chris Mason 已提交
3636
 */
3637
static void write_dev_flush(struct btrfs_device *device)
C
Chris Mason 已提交
3638
{
3639
	struct request_queue *q = bdev_get_queue(device->bdev);
3640
	struct bio *bio = device->flush_bio;
C
Chris Mason 已提交
3641

3642
	if (!test_bit(QUEUE_FLAG_WC, &q->queue_flags))
3643
		return;
C
Chris Mason 已提交
3644

3645
	bio_reset(bio);
C
Chris Mason 已提交
3646
	bio->bi_end_io = btrfs_end_empty_barrier;
3647
	bio_set_dev(bio, device->bdev);
3648
	bio->bi_opf = REQ_OP_WRITE | REQ_SYNC | REQ_PREFLUSH;
C
Chris Mason 已提交
3649 3650 3651
	init_completion(&device->flush_wait);
	bio->bi_private = &device->flush_wait;

3652
	btrfsic_submit_bio(bio);
3653
	set_bit(BTRFS_DEV_STATE_FLUSH_SENT, &device->dev_state);
3654
}
C
Chris Mason 已提交
3655

3656 3657 3658
/*
 * If the flush bio has been submitted by write_dev_flush, wait for it.
 */
3659
static blk_status_t wait_dev_flush(struct btrfs_device *device)
3660 3661
{
	struct bio *bio = device->flush_bio;
C
Chris Mason 已提交
3662

3663
	if (!test_bit(BTRFS_DEV_STATE_FLUSH_SENT, &device->dev_state))
3664
		return BLK_STS_OK;
C
Chris Mason 已提交
3665

3666
	clear_bit(BTRFS_DEV_STATE_FLUSH_SENT, &device->dev_state);
3667
	wait_for_completion_io(&device->flush_wait);
C
Chris Mason 已提交
3668

3669
	return bio->bi_status;
C
Chris Mason 已提交
3670 3671
}

3672
static int check_barrier_error(struct btrfs_fs_info *fs_info)
3673
{
3674
	if (!btrfs_check_rw_degradable(fs_info, NULL))
3675
		return -EIO;
C
Chris Mason 已提交
3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686
	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;
3687
	int errors_wait = 0;
3688
	blk_status_t ret;
C
Chris Mason 已提交
3689

3690
	lockdep_assert_held(&info->fs_devices->device_list_mutex);
C
Chris Mason 已提交
3691 3692
	/* send down all the barriers */
	head = &info->fs_devices->devices;
3693
	list_for_each_entry(dev, head, dev_list) {
3694
		if (test_bit(BTRFS_DEV_STATE_MISSING, &dev->dev_state))
3695
			continue;
3696
		if (!dev->bdev)
C
Chris Mason 已提交
3697
			continue;
3698
		if (!test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &dev->dev_state) ||
3699
		    !test_bit(BTRFS_DEV_STATE_WRITEABLE, &dev->dev_state))
C
Chris Mason 已提交
3700 3701
			continue;

3702
		write_dev_flush(dev);
3703
		dev->last_flush_error = BLK_STS_OK;
C
Chris Mason 已提交
3704 3705 3706
	}

	/* wait for all the barriers */
3707
	list_for_each_entry(dev, head, dev_list) {
3708
		if (test_bit(BTRFS_DEV_STATE_MISSING, &dev->dev_state))
3709
			continue;
C
Chris Mason 已提交
3710
		if (!dev->bdev) {
3711
			errors_wait++;
C
Chris Mason 已提交
3712 3713
			continue;
		}
3714
		if (!test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &dev->dev_state) ||
3715
		    !test_bit(BTRFS_DEV_STATE_WRITEABLE, &dev->dev_state))
C
Chris Mason 已提交
3716 3717
			continue;

3718
		ret = wait_dev_flush(dev);
3719 3720
		if (ret) {
			dev->last_flush_error = ret;
3721 3722
			btrfs_dev_stat_inc_and_print(dev,
					BTRFS_DEV_STAT_FLUSH_ERRS);
3723
			errors_wait++;
3724 3725 3726
		}
	}

3727
	if (errors_wait) {
3728 3729 3730 3731 3732
		/*
		 * 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.
		 */
3733
		return check_barrier_error(info);
C
Chris Mason 已提交
3734 3735 3736 3737
	}
	return 0;
}

3738 3739
int btrfs_get_num_tolerated_disk_barrier_failures(u64 flags)
{
3740 3741
	int raid_type;
	int min_tolerated = INT_MAX;
3742

3743 3744
	if ((flags & BTRFS_BLOCK_GROUP_PROFILE_MASK) == 0 ||
	    (flags & BTRFS_AVAIL_ALLOC_BIT_SINGLE))
3745
		min_tolerated = min_t(int, min_tolerated,
3746 3747
				    btrfs_raid_array[BTRFS_RAID_SINGLE].
				    tolerated_failures);
3748

3749 3750 3751
	for (raid_type = 0; raid_type < BTRFS_NR_RAID_TYPES; raid_type++) {
		if (raid_type == BTRFS_RAID_SINGLE)
			continue;
3752
		if (!(flags & btrfs_raid_array[raid_type].bg_flag))
3753
			continue;
3754
		min_tolerated = min_t(int, min_tolerated,
3755 3756 3757
				    btrfs_raid_array[raid_type].
				    tolerated_failures);
	}
3758

3759
	if (min_tolerated == INT_MAX) {
3760
		pr_warn("BTRFS: unknown raid flag: %llu", flags);
3761 3762 3763 3764
		min_tolerated = 0;
	}

	return min_tolerated;
3765 3766
}

3767
int write_all_supers(struct btrfs_fs_info *fs_info, int max_mirrors)
3768
{
3769
	struct list_head *head;
3770
	struct btrfs_device *dev;
3771
	struct btrfs_super_block *sb;
3772 3773 3774
	struct btrfs_dev_item *dev_item;
	int ret;
	int do_barriers;
3775 3776
	int max_errors;
	int total_errors = 0;
3777
	u64 flags;
3778

3779
	do_barriers = !btrfs_test_opt(fs_info, NOBARRIER);
3780 3781 3782 3783 3784 3785 3786 3787

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

3789
	sb = fs_info->super_for_commit;
3790
	dev_item = &sb->dev_item;
3791

3792 3793 3794
	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 已提交
3795

3796
	if (do_barriers) {
3797
		ret = barrier_all_devices(fs_info);
3798 3799
		if (ret) {
			mutex_unlock(
3800 3801 3802
				&fs_info->fs_devices->device_list_mutex);
			btrfs_handle_fs_error(fs_info, ret,
					      "errors while submitting device barriers.");
3803 3804 3805
			return ret;
		}
	}
C
Chris Mason 已提交
3806

3807
	list_for_each_entry(dev, head, dev_list) {
3808 3809 3810 3811
		if (!dev->bdev) {
			total_errors++;
			continue;
		}
3812
		if (!test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &dev->dev_state) ||
3813
		    !test_bit(BTRFS_DEV_STATE_WRITEABLE, &dev->dev_state))
3814 3815
			continue;

Y
Yan Zheng 已提交
3816
		btrfs_set_stack_device_generation(dev_item, 0);
3817 3818
		btrfs_set_stack_device_type(dev_item, dev->type);
		btrfs_set_stack_device_id(dev_item, dev->devid);
3819
		btrfs_set_stack_device_total_bytes(dev_item,
3820
						   dev->commit_total_bytes);
3821 3822
		btrfs_set_stack_device_bytes_used(dev_item,
						  dev->commit_bytes_used);
3823 3824 3825 3826
		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);
3827 3828
		memcpy(dev_item->fsid, dev->fs_devices->metadata_uuid,
		       BTRFS_FSID_SIZE);
Y
Yan Zheng 已提交
3829

3830 3831 3832
		flags = btrfs_super_flags(sb);
		btrfs_set_super_flags(sb, flags | BTRFS_HEADER_FLAG_WRITTEN);

3833 3834 3835 3836 3837 3838 3839 3840
		ret = btrfs_validate_write_super(fs_info, sb);
		if (ret < 0) {
			mutex_unlock(&fs_info->fs_devices->device_list_mutex);
			btrfs_handle_fs_error(fs_info, -EUCLEAN,
				"unexpected superblock corruption detected");
			return -EUCLEAN;
		}

3841
		ret = write_dev_supers(dev, sb, max_mirrors);
3842 3843
		if (ret)
			total_errors++;
3844
	}
3845
	if (total_errors > max_errors) {
3846 3847 3848
		btrfs_err(fs_info, "%d errors while writing supers",
			  total_errors);
		mutex_unlock(&fs_info->fs_devices->device_list_mutex);
3849

3850
		/* FUA is masked off if unsupported and can't be the reason */
3851 3852 3853
		btrfs_handle_fs_error(fs_info, -EIO,
				      "%d errors while writing supers",
				      total_errors);
3854
		return -EIO;
3855
	}
3856

Y
Yan Zheng 已提交
3857
	total_errors = 0;
3858
	list_for_each_entry(dev, head, dev_list) {
3859 3860
		if (!dev->bdev)
			continue;
3861
		if (!test_bit(BTRFS_DEV_STATE_IN_FS_METADATA, &dev->dev_state) ||
3862
		    !test_bit(BTRFS_DEV_STATE_WRITEABLE, &dev->dev_state))
3863 3864
			continue;

3865
		ret = wait_dev_supers(dev, max_mirrors);
Y
Yan Zheng 已提交
3866 3867
		if (ret)
			total_errors++;
3868
	}
3869
	mutex_unlock(&fs_info->fs_devices->device_list_mutex);
3870
	if (total_errors > max_errors) {
3871 3872 3873
		btrfs_handle_fs_error(fs_info, -EIO,
				      "%d errors while writing supers",
				      total_errors);
3874
		return -EIO;
3875
	}
3876 3877 3878
	return 0;
}

3879 3880 3881
/* 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 已提交
3882
{
3883
	spin_lock(&fs_info->fs_roots_radix_lock);
C
Chris Mason 已提交
3884 3885
	radix_tree_delete(&fs_info->fs_roots_radix,
			  (unsigned long)root->root_key.objectid);
3886
	if (test_and_clear_bit(BTRFS_ROOT_IN_RADIX, &root->state))
3887
		btrfs_put_root(root);
3888
	spin_unlock(&fs_info->fs_roots_radix_lock);
3889 3890 3891 3892

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

L
Liu Bo 已提交
3893
	if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
L
Liu Bo 已提交
3894
		btrfs_free_log(NULL, root);
L
Liu Bo 已提交
3895 3896 3897
		if (root->reloc_root) {
			free_extent_buffer(root->reloc_root->node);
			free_extent_buffer(root->reloc_root->commit_root);
3898
			btrfs_put_root(root->reloc_root);
L
Liu Bo 已提交
3899 3900 3901
			root->reloc_root = NULL;
		}
	}
L
Liu Bo 已提交
3902

3903 3904 3905 3906
	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);
D
David Sterba 已提交
3907
	btrfs_free_fs_root(root);
3908 3909
}

D
David Sterba 已提交
3910
void btrfs_free_fs_root(struct btrfs_root *root)
3911
{
3912
	iput(root->ino_cache_inode);
3913
	WARN_ON(!RB_EMPTY_ROOT(&root->inode_tree));
3914 3915
	if (root->anon_dev)
		free_anon_bdev(root->anon_dev);
3916 3917
	if (root->subv_writers)
		btrfs_free_subvolume_writers(root->subv_writers);
3918 3919
	free_extent_buffer(root->node);
	free_extent_buffer(root->commit_root);
3920 3921
	kfree(root->free_ino_ctl);
	kfree(root->free_ino_pinned);
3922
	btrfs_put_root(root);
C
Chris Mason 已提交
3923 3924
}

Y
Yan Zheng 已提交
3925
int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info)
C
Chris Mason 已提交
3926
{
Y
Yan Zheng 已提交
3927 3928
	u64 root_objectid = 0;
	struct btrfs_root *gang[8];
3929 3930 3931 3932
	int i = 0;
	int err = 0;
	unsigned int ret = 0;
	int index;
3933

Y
Yan Zheng 已提交
3934
	while (1) {
3935
		index = srcu_read_lock(&fs_info->subvol_srcu);
Y
Yan Zheng 已提交
3936 3937 3938
		ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
					     (void **)gang, root_objectid,
					     ARRAY_SIZE(gang));
3939 3940
		if (!ret) {
			srcu_read_unlock(&fs_info->subvol_srcu, index);
Y
Yan Zheng 已提交
3941
			break;
3942
		}
3943
		root_objectid = gang[ret - 1]->root_key.objectid + 1;
3944

Y
Yan Zheng 已提交
3945
		for (i = 0; i < ret; i++) {
3946 3947 3948 3949 3950 3951
			/* 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 */
3952
			gang[i] = btrfs_grab_root(gang[i]);
3953 3954
		}
		srcu_read_unlock(&fs_info->subvol_srcu, index);
3955

3956 3957 3958
		for (i = 0; i < ret; i++) {
			if (!gang[i])
				continue;
Y
Yan Zheng 已提交
3959
			root_objectid = gang[i]->root_key.objectid;
3960 3961
			err = btrfs_orphan_cleanup(gang[i]);
			if (err)
3962
				break;
3963
			btrfs_put_root(gang[i]);
Y
Yan Zheng 已提交
3964 3965 3966
		}
		root_objectid++;
	}
3967 3968 3969 3970

	/* release the uncleaned roots due to error */
	for (; i < ret; i++) {
		if (gang[i])
3971
			btrfs_put_root(gang[i]);
3972 3973
	}
	return err;
Y
Yan Zheng 已提交
3974
}
3975

3976
int btrfs_commit_super(struct btrfs_fs_info *fs_info)
Y
Yan Zheng 已提交
3977
{
3978
	struct btrfs_root *root = fs_info->tree_root;
Y
Yan Zheng 已提交
3979
	struct btrfs_trans_handle *trans;
3980

3981
	mutex_lock(&fs_info->cleaner_mutex);
3982
	btrfs_run_delayed_iputs(fs_info);
3983 3984
	mutex_unlock(&fs_info->cleaner_mutex);
	wake_up_process(fs_info->cleaner_kthread);
3985 3986

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

3990
	trans = btrfs_join_transaction(root);
3991 3992
	if (IS_ERR(trans))
		return PTR_ERR(trans);
3993
	return btrfs_commit_transaction(trans);
Y
Yan Zheng 已提交
3994 3995
}

3996
void __cold close_ctree(struct btrfs_fs_info *fs_info)
Y
Yan Zheng 已提交
3997 3998 3999
{
	int ret;

4000
	set_bit(BTRFS_FS_CLOSING_START, &fs_info->flags);
4001 4002 4003 4004 4005 4006 4007
	/*
	 * We don't want the cleaner to start new transactions, add more delayed
	 * iputs, etc. while we're closing. We can't use kthread_stop() yet
	 * because that frees the task_struct, and the transaction kthread might
	 * still try to wake up the cleaner.
	 */
	kthread_park(fs_info->cleaner_kthread);
Y
Yan Zheng 已提交
4008

4009
	/* wait for the qgroup rescan worker to stop */
4010
	btrfs_qgroup_wait_for_completion(fs_info, false);
4011

S
Stefan Behrens 已提交
4012 4013 4014 4015 4016
	/* 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);

4017
	/* pause restriper - we want to resume on mount */
4018
	btrfs_pause_balance(fs_info);
4019

4020 4021
	btrfs_dev_replace_suspend_for_unmount(fs_info);

4022
	btrfs_scrub_cancel(fs_info);
C
Chris Mason 已提交
4023 4024 4025 4026 4027 4028

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

4031 4032
	cancel_work_sync(&fs_info->async_reclaim_work);

4033 4034 4035
	/* Cancel or finish ongoing discard work */
	btrfs_discard_cleanup(fs_info);

4036
	if (!sb_rdonly(fs_info->sb)) {
4037
		/*
4038 4039
		 * The cleaner kthread is stopped, so do one final pass over
		 * unused block groups.
4040
		 */
4041
		btrfs_delete_unused_bgs(fs_info);
4042

4043
		ret = btrfs_commit_super(fs_info);
L
liubo 已提交
4044
		if (ret)
4045
			btrfs_err(fs_info, "commit super ret %d", ret);
L
liubo 已提交
4046 4047
	}

4048 4049
	if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state) ||
	    test_bit(BTRFS_FS_STATE_TRANS_ABORTED, &fs_info->fs_state))
4050
		btrfs_error_commit_super(fs_info);
4051

A
Al Viro 已提交
4052 4053
	kthread_stop(fs_info->transaction_kthread);
	kthread_stop(fs_info->cleaner_kthread);
4054

4055
	ASSERT(list_empty(&fs_info->delayed_iputs));
4056
	set_bit(BTRFS_FS_CLOSING_DONE, &fs_info->flags);
4057

4058
	btrfs_free_qgroup_config(fs_info);
4059
	ASSERT(list_empty(&fs_info->delalloc_roots));
4060

4061
	if (percpu_counter_sum(&fs_info->delalloc_bytes)) {
4062
		btrfs_info(fs_info, "at unmount delalloc count %lld",
4063
		       percpu_counter_sum(&fs_info->delalloc_bytes));
C
Chris Mason 已提交
4064
	}
4065

J
Josef Bacik 已提交
4066 4067 4068 4069
	if (percpu_counter_sum(&fs_info->dio_bytes))
		btrfs_info(fs_info, "at unmount dio bytes count %lld",
			   percpu_counter_sum(&fs_info->dio_bytes));

4070
	btrfs_sysfs_remove_mounted(fs_info);
4071
	btrfs_sysfs_remove_fsid(fs_info->fs_devices);
4072

4073
	btrfs_free_fs_roots(fs_info);
4074

4075 4076
	btrfs_put_block_group_cache(fs_info);

4077 4078 4079 4080 4081
	/*
	 * 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);
4082 4083
	btrfs_stop_all_workers(fs_info);

4084
	clear_bit(BTRFS_FS_OPEN, &fs_info->flags);
4085
	free_root_pointers(fs_info, true);
4086

4087 4088 4089 4090 4091 4092 4093 4094 4095
	/*
	 * We must free the block groups after dropping the fs_roots as we could
	 * have had an IO error and have left over tree log blocks that aren't
	 * cleaned up until the fs roots are freed.  This makes the block group
	 * accounting appear to be wrong because there's pending reserved bytes,
	 * so make sure we do the block group cleanup afterwards.
	 */
	btrfs_free_block_groups(fs_info);

4096
	iput(fs_info->btree_inode);
4097

4098
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
4099
	if (btrfs_test_opt(fs_info, CHECK_INTEGRITY))
4100
		btrfsic_unmount(fs_info->fs_devices);
4101 4102
#endif

4103
	btrfs_mapping_tree_free(&fs_info->mapping_tree);
4104
	btrfs_close_devices(fs_info->fs_devices);
4105
	cleanup_srcu_struct(&fs_info->subvol_srcu);
4106 4107
}

4108 4109
int btrfs_buffer_uptodate(struct extent_buffer *buf, u64 parent_transid,
			  int atomic)
4110
{
4111
	int ret;
4112
	struct inode *btree_inode = buf->pages[0]->mapping->host;
4113

4114
	ret = extent_buffer_uptodate(buf);
4115 4116 4117 4118
	if (!ret)
		return ret;

	ret = verify_parent_transid(&BTRFS_I(btree_inode)->io_tree, buf,
4119 4120 4121
				    parent_transid, atomic);
	if (ret == -EAGAIN)
		return ret;
4122
	return !ret;
4123 4124 4125 4126
}

void btrfs_mark_buffer_dirty(struct extent_buffer *buf)
{
4127
	struct btrfs_fs_info *fs_info;
4128
	struct btrfs_root *root;
4129
	u64 transid = btrfs_header_generation(buf);
4130
	int was_dirty;
4131

4132 4133 4134
#ifdef CONFIG_BTRFS_FS_RUN_SANITY_TESTS
	/*
	 * This is a fast path so only do this check if we have sanity tests
4135
	 * enabled.  Normal people shouldn't be using unmapped buffers as dirty
4136 4137
	 * outside of the sanity tests.
	 */
4138
	if (unlikely(test_bit(EXTENT_BUFFER_UNMAPPED, &buf->bflags)))
4139 4140 4141
		return;
#endif
	root = BTRFS_I(buf->pages[0]->mapping->host)->root;
4142
	fs_info = root->fs_info;
4143
	btrfs_assert_tree_locked(buf);
4144
	if (transid != fs_info->generation)
J
Jeff Mahoney 已提交
4145
		WARN(1, KERN_CRIT "btrfs transid mismatch buffer %llu, found %llu running %llu\n",
4146
			buf->start, transid, fs_info->generation);
4147
	was_dirty = set_extent_buffer_dirty(buf);
4148
	if (!was_dirty)
4149 4150 4151
		percpu_counter_add_batch(&fs_info->dirty_metadata_bytes,
					 buf->len,
					 fs_info->dirty_metadata_batch);
4152
#ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
4153 4154 4155 4156 4157 4158
	/*
	 * 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 &&
4159
	    btrfs_check_leaf_relaxed(buf)) {
4160
		btrfs_print_leaf(buf);
4161 4162 4163
		ASSERT(0);
	}
#endif
4164 4165
}

4166
static void __btrfs_btree_balance_dirty(struct btrfs_fs_info *fs_info,
4167
					int flush_delayed)
4168 4169 4170 4171 4172
{
	/*
	 * looks as though older kernels can get into trouble with
	 * this code, they end up stuck in balance_dirty_pages forever
	 */
4173
	int ret;
4174 4175 4176 4177

	if (current->flags & PF_MEMALLOC)
		return;

4178
	if (flush_delayed)
4179
		btrfs_balance_delayed_items(fs_info);
4180

4181 4182 4183
	ret = __percpu_counter_compare(&fs_info->dirty_metadata_bytes,
				     BTRFS_DIRTY_METADATA_THRESH,
				     fs_info->dirty_metadata_batch);
4184
	if (ret > 0) {
4185
		balance_dirty_pages_ratelimited(fs_info->btree_inode->i_mapping);
4186 4187 4188
	}
}

4189
void btrfs_btree_balance_dirty(struct btrfs_fs_info *fs_info)
C
Chris Mason 已提交
4190
{
4191
	__btrfs_btree_balance_dirty(fs_info, 1);
4192
}
4193

4194
void btrfs_btree_balance_dirty_nodelay(struct btrfs_fs_info *fs_info)
4195
{
4196
	__btrfs_btree_balance_dirty(fs_info, 0);
C
Chris Mason 已提交
4197
}
4198

4199 4200
int btrfs_read_buffer(struct extent_buffer *buf, u64 parent_transid, int level,
		      struct btrfs_key *first_key)
4201
{
4202
	return btree_read_extent_buffer_pages(buf, parent_transid,
4203
					      level, first_key);
4204
}
4205

4206
static void btrfs_error_commit_super(struct btrfs_fs_info *fs_info)
L
liubo 已提交
4207
{
4208 4209 4210
	/* cleanup FS via transaction */
	btrfs_cleanup_transaction(fs_info);

4211
	mutex_lock(&fs_info->cleaner_mutex);
4212
	btrfs_run_delayed_iputs(fs_info);
4213
	mutex_unlock(&fs_info->cleaner_mutex);
L
liubo 已提交
4214

4215 4216
	down_write(&fs_info->cleanup_work_sem);
	up_write(&fs_info->cleanup_work_sem);
L
liubo 已提交
4217 4218
}

4219
static void btrfs_destroy_ordered_extents(struct btrfs_root *root)
L
liubo 已提交
4220 4221 4222
{
	struct btrfs_ordered_extent *ordered;

4223
	spin_lock(&root->ordered_extent_lock);
4224 4225 4226 4227
	/*
	 * This will just short circuit the ordered completion stuff which will
	 * make sure the ordered extent gets properly cleaned up.
	 */
4228
	list_for_each_entry(ordered, &root->ordered_extents,
4229 4230
			    root_extent_list)
		set_bit(BTRFS_ORDERED_IOERR, &ordered->flags);
4231 4232 4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245
	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);
4246 4247
		list_move_tail(&root->ordered_root,
			       &fs_info->ordered_roots);
4248

4249
		spin_unlock(&fs_info->ordered_root_lock);
4250 4251
		btrfs_destroy_ordered_extents(root);

4252 4253
		cond_resched();
		spin_lock(&fs_info->ordered_root_lock);
4254 4255
	}
	spin_unlock(&fs_info->ordered_root_lock);
4256 4257 4258 4259 4260 4261 4262 4263

	/*
	 * We need this here because if we've been flipped read-only we won't
	 * get sync() from the umount, so we need to make sure any ordered
	 * extents that haven't had their dirty pages IO start writeout yet
	 * actually get run and error out properly.
	 */
	btrfs_wait_ordered_roots(fs_info, U64_MAX, 0, (u64)-1);
L
liubo 已提交
4264 4265
}

4266
static int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans,
4267
				      struct btrfs_fs_info *fs_info)
L
liubo 已提交
4268 4269 4270 4271 4272 4273 4274 4275 4276
{
	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);
4277
	if (atomic_read(&delayed_refs->num_entries) == 0) {
4278
		spin_unlock(&delayed_refs->lock);
4279
		btrfs_info(fs_info, "delayed_refs has NO entry");
L
liubo 已提交
4280 4281 4282
		return ret;
	}

4283
	while ((node = rb_first_cached(&delayed_refs->href_root)) != NULL) {
4284
		struct btrfs_delayed_ref_head *head;
4285
		struct rb_node *n;
4286
		bool pin_bytes = false;
L
liubo 已提交
4287

4288 4289
		head = rb_entry(node, struct btrfs_delayed_ref_head,
				href_node);
4290
		if (btrfs_delayed_ref_lock(delayed_refs, head))
4291
			continue;
4292

4293
		spin_lock(&head->lock);
4294
		while ((n = rb_first_cached(&head->ref_tree)) != NULL) {
4295 4296
			ref = rb_entry(n, struct btrfs_delayed_ref_node,
				       ref_node);
4297
			ref->in_tree = 0;
4298
			rb_erase_cached(&ref->ref_node, &head->ref_tree);
4299
			RB_CLEAR_NODE(&ref->ref_node);
4300 4301
			if (!list_empty(&ref->add_list))
				list_del(&ref->add_list);
4302 4303
			atomic_dec(&delayed_refs->num_entries);
			btrfs_put_delayed_ref(ref);
4304
		}
4305 4306 4307
		if (head->must_insert_reserved)
			pin_bytes = true;
		btrfs_free_delayed_extent_op(head->extent_op);
4308
		btrfs_delete_ref_head(delayed_refs, head);
4309 4310 4311
		spin_unlock(&head->lock);
		spin_unlock(&delayed_refs->lock);
		mutex_unlock(&head->mutex);
L
liubo 已提交
4312

4313
		if (pin_bytes)
4314 4315
			btrfs_pin_extent(fs_info, head->bytenr,
					 head->num_bytes, 1);
4316
		btrfs_cleanup_ref_head_accounting(fs_info, delayed_refs, head);
4317
		btrfs_put_delayed_ref_head(head);
L
liubo 已提交
4318 4319 4320
		cond_resched();
		spin_lock(&delayed_refs->lock);
	}
4321
	btrfs_qgroup_destroy_extent_records(trans);
L
liubo 已提交
4322 4323 4324 4325 4326 4327

	spin_unlock(&delayed_refs->lock);

	return ret;
}

4328
static void btrfs_destroy_delalloc_inodes(struct btrfs_root *root)
L
liubo 已提交
4329 4330 4331 4332 4333 4334
{
	struct btrfs_inode *btrfs_inode;
	struct list_head splice;

	INIT_LIST_HEAD(&splice);

4335 4336
	spin_lock(&root->delalloc_lock);
	list_splice_init(&root->delalloc_inodes, &splice);
L
liubo 已提交
4337 4338

	while (!list_empty(&splice)) {
4339
		struct inode *inode = NULL;
4340 4341
		btrfs_inode = list_first_entry(&splice, struct btrfs_inode,
					       delalloc_inodes);
4342
		__btrfs_del_delalloc_inode(root, btrfs_inode);
4343
		spin_unlock(&root->delalloc_lock);
L
liubo 已提交
4344

4345 4346 4347 4348 4349 4350 4351 4352 4353
		/*
		 * Make sure we get a live inode and that it'll not disappear
		 * meanwhile.
		 */
		inode = igrab(&btrfs_inode->vfs_inode);
		if (inode) {
			invalidate_inode_pages2(inode->i_mapping);
			iput(inode);
		}
4354
		spin_lock(&root->delalloc_lock);
L
liubo 已提交
4355
	}
4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370
	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);
4371
		root = btrfs_grab_root(root);
4372 4373 4374 4375
		BUG_ON(!root);
		spin_unlock(&fs_info->delalloc_root_lock);

		btrfs_destroy_delalloc_inodes(root);
4376
		btrfs_put_root(root);
4377 4378 4379 4380

		spin_lock(&fs_info->delalloc_root_lock);
	}
	spin_unlock(&fs_info->delalloc_root_lock);
L
liubo 已提交
4381 4382
}

4383
static int btrfs_destroy_marked_extents(struct btrfs_fs_info *fs_info,
L
liubo 已提交
4384 4385 4386 4387 4388 4389 4390 4391 4392 4393
					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,
4394
					    mark, NULL);
L
liubo 已提交
4395 4396 4397
		if (ret)
			break;

4398
		clear_extent_bits(dirty_pages, start, end, mark);
L
liubo 已提交
4399
		while (start <= end) {
4400 4401
			eb = find_extent_buffer(fs_info, start);
			start += fs_info->nodesize;
4402
			if (!eb)
L
liubo 已提交
4403
				continue;
4404
			wait_on_extent_buffer_writeback(eb);
L
liubo 已提交
4405

4406 4407 4408 4409
			if (test_and_clear_bit(EXTENT_BUFFER_DIRTY,
					       &eb->bflags))
				clear_extent_buffer_dirty(eb);
			free_extent_buffer_stale(eb);
L
liubo 已提交
4410 4411 4412 4413 4414 4415
		}
	}

	return ret;
}

4416
static int btrfs_destroy_pinned_extent(struct btrfs_fs_info *fs_info,
L
liubo 已提交
4417 4418 4419 4420 4421 4422
				       struct extent_io_tree *pinned_extents)
{
	struct extent_io_tree *unpin;
	u64 start;
	u64 end;
	int ret;
4423
	bool loop = true;
L
liubo 已提交
4424 4425

	unpin = pinned_extents;
4426
again:
L
liubo 已提交
4427
	while (1) {
4428 4429
		struct extent_state *cached_state = NULL;

4430 4431 4432 4433 4434 4435 4436
		/*
		 * The btrfs_finish_extent_commit() may get the same range as
		 * ours between find_first_extent_bit and clear_extent_dirty.
		 * Hence, hold the unused_bg_unpin_mutex to avoid double unpin
		 * the same extent range.
		 */
		mutex_lock(&fs_info->unused_bg_unpin_mutex);
L
liubo 已提交
4437
		ret = find_first_extent_bit(unpin, 0, &start, &end,
4438
					    EXTENT_DIRTY, &cached_state);
4439 4440
		if (ret) {
			mutex_unlock(&fs_info->unused_bg_unpin_mutex);
L
liubo 已提交
4441
			break;
4442
		}
L
liubo 已提交
4443

4444 4445
		clear_extent_dirty(unpin, start, end, &cached_state);
		free_extent_state(cached_state);
4446
		btrfs_error_unpin_extent_range(fs_info, start, end);
4447
		mutex_unlock(&fs_info->unused_bg_unpin_mutex);
L
liubo 已提交
4448 4449 4450
		cond_resched();
	}

4451
	if (loop) {
4452 4453
		if (unpin == &fs_info->freed_extents[0])
			unpin = &fs_info->freed_extents[1];
4454
		else
4455
			unpin = &fs_info->freed_extents[0];
4456 4457 4458 4459
		loop = false;
		goto again;
	}

L
liubo 已提交
4460 4461 4462
	return 0;
}

4463
static void btrfs_cleanup_bg_io(struct btrfs_block_group *cache)
4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476 4477
{
	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,
4478
			     struct btrfs_fs_info *fs_info)
4479
{
4480
	struct btrfs_block_group *cache;
4481 4482 4483 4484

	spin_lock(&cur_trans->dirty_bgs_lock);
	while (!list_empty(&cur_trans->dirty_bgs)) {
		cache = list_first_entry(&cur_trans->dirty_bgs,
4485
					 struct btrfs_block_group,
4486 4487 4488 4489 4490 4491 4492 4493 4494 4495 4496 4497 4498 4499 4500 4501
					 dirty_list);

		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);
J
Josef Bacik 已提交
4502
		btrfs_delayed_refs_rsv_release(fs_info, 1);
4503 4504 4505 4506
		spin_lock(&cur_trans->dirty_bgs_lock);
	}
	spin_unlock(&cur_trans->dirty_bgs_lock);

4507 4508 4509 4510
	/*
	 * Refer to the definition of io_bgs member for details why it's safe
	 * to use it without any locking
	 */
4511 4512
	while (!list_empty(&cur_trans->io_bgs)) {
		cache = list_first_entry(&cur_trans->io_bgs,
4513
					 struct btrfs_block_group,
4514 4515 4516 4517 4518 4519 4520 4521 4522 4523
					 io_list);

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

4524
void btrfs_cleanup_one_transaction(struct btrfs_transaction *cur_trans,
4525
				   struct btrfs_fs_info *fs_info)
4526
{
4527 4528
	struct btrfs_device *dev, *tmp;

4529
	btrfs_cleanup_dirty_bgs(cur_trans, fs_info);
4530 4531 4532
	ASSERT(list_empty(&cur_trans->dirty_bgs));
	ASSERT(list_empty(&cur_trans->io_bgs));

4533 4534 4535 4536 4537
	list_for_each_entry_safe(dev, tmp, &cur_trans->dev_update_list,
				 post_commit_list) {
		list_del_init(&dev->post_commit_list);
	}

4538
	btrfs_destroy_delayed_refs(cur_trans, fs_info);
4539

4540
	cur_trans->state = TRANS_STATE_COMMIT_START;
4541
	wake_up(&fs_info->transaction_blocked_wait);
4542

4543
	cur_trans->state = TRANS_STATE_UNBLOCKED;
4544
	wake_up(&fs_info->transaction_wait);
4545

4546
	btrfs_destroy_delayed_inodes(fs_info);
4547

4548
	btrfs_destroy_marked_extents(fs_info, &cur_trans->dirty_pages,
4549
				     EXTENT_DIRTY);
4550
	btrfs_destroy_pinned_extent(fs_info,
4551
				    fs_info->pinned_extents);
4552

4553 4554
	cur_trans->state =TRANS_STATE_COMPLETED;
	wake_up(&cur_trans->commit_wait);
4555 4556
}

4557
static int btrfs_cleanup_transaction(struct btrfs_fs_info *fs_info)
L
liubo 已提交
4558 4559 4560
{
	struct btrfs_transaction *t;

4561
	mutex_lock(&fs_info->transaction_kthread_mutex);
L
liubo 已提交
4562

4563 4564 4565
	spin_lock(&fs_info->trans_lock);
	while (!list_empty(&fs_info->trans_list)) {
		t = list_first_entry(&fs_info->trans_list,
4566 4567
				     struct btrfs_transaction, list);
		if (t->state >= TRANS_STATE_COMMIT_START) {
4568
			refcount_inc(&t->use_count);
4569
			spin_unlock(&fs_info->trans_lock);
4570
			btrfs_wait_for_commit(fs_info, t->transid);
4571
			btrfs_put_transaction(t);
4572
			spin_lock(&fs_info->trans_lock);
4573 4574
			continue;
		}
4575
		if (t == fs_info->running_transaction) {
4576
			t->state = TRANS_STATE_COMMIT_DOING;
4577
			spin_unlock(&fs_info->trans_lock);
4578 4579 4580 4581 4582 4583 4584
			/*
			 * 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 {
4585
			spin_unlock(&fs_info->trans_lock);
4586
		}
4587
		btrfs_cleanup_one_transaction(t, fs_info);
4588

4589 4590 4591
		spin_lock(&fs_info->trans_lock);
		if (t == fs_info->running_transaction)
			fs_info->running_transaction = NULL;
L
liubo 已提交
4592
		list_del_init(&t->list);
4593
		spin_unlock(&fs_info->trans_lock);
L
liubo 已提交
4594

4595
		btrfs_put_transaction(t);
4596
		trace_btrfs_transaction_commit(fs_info->tree_root);
4597
		spin_lock(&fs_info->trans_lock);
4598
	}
4599 4600
	spin_unlock(&fs_info->trans_lock);
	btrfs_destroy_all_ordered_extents(fs_info);
4601 4602
	btrfs_destroy_delayed_inodes(fs_info);
	btrfs_assert_delayed_root_empty(fs_info);
4603
	btrfs_destroy_pinned_extent(fs_info, fs_info->pinned_extents);
4604 4605
	btrfs_destroy_all_delalloc_inodes(fs_info);
	mutex_unlock(&fs_info->transaction_kthread_mutex);
L
liubo 已提交
4606 4607 4608 4609

	return 0;
}

4610
static const struct extent_io_ops btree_extent_io_ops = {
4611
	/* mandatory callbacks */
4612
	.submit_bio_hook = btree_submit_bio_hook,
4613
	.readpage_end_io_hook = btree_readpage_end_io_hook,
4614
};