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

C
Chris Mason 已提交
19
#include <linux/fs.h>
20
#include <linux/blkdev.h>
C
Chris Mason 已提交
21
#include <linux/scatterlist.h>
C
Chris Mason 已提交
22
#include <linux/swap.h>
23
#include <linux/radix-tree.h>
C
Chris Mason 已提交
24
#include <linux/writeback.h>
C
Chris Mason 已提交
25
#include <linux/buffer_head.h>
26
#include <linux/workqueue.h>
27
#include <linux/kthread.h>
C
Chris Mason 已提交
28
#include <linux/freezer.h>
29
#include <linux/crc32c.h>
30
#include <linux/slab.h>
31
#include <linux/migrate.h>
32
#include <asm/unaligned.h>
C
Chris Mason 已提交
33
#include "compat.h"
34 35
#include "ctree.h"
#include "disk-io.h"
36
#include "transaction.h"
37
#include "btrfs_inode.h"
38
#include "volumes.h"
39
#include "print-tree.h"
40
#include "async-thread.h"
41
#include "locking.h"
42
#include "tree-log.h"
43
#include "free-space-cache.h"
44

45
static struct extent_io_ops btree_extent_io_ops;
46
static void end_workqueue_fn(struct btrfs_work *work);
47
static void free_fs_root(struct btrfs_root *root);
L
liubo 已提交
48 49 50 51 52 53 54 55 56 57 58 59 60 61
static void btrfs_check_super_valid(struct btrfs_fs_info *fs_info,
				    int read_only);
static int btrfs_destroy_ordered_operations(struct btrfs_root *root);
static int btrfs_destroy_ordered_extents(struct btrfs_root *root);
static int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans,
				      struct btrfs_root *root);
static int btrfs_destroy_pending_snapshots(struct btrfs_transaction *t);
static int btrfs_destroy_delalloc_inodes(struct btrfs_root *root);
static int btrfs_destroy_marked_extents(struct btrfs_root *root,
					struct extent_io_tree *dirty_pages,
					int mark);
static int btrfs_destroy_pinned_extent(struct btrfs_root *root,
				       struct extent_io_tree *pinned_extents);
static int btrfs_cleanup_transaction(struct btrfs_root *root);
62

C
Chris Mason 已提交
63 64 65 66 67
/*
 * end_io_wq structs are used to do processing in task context when an IO is
 * complete.  This is used during reads to verify checksums, and it is used
 * by writes to insert metadata for new file extents after IO is complete.
 */
68 69 70 71 72 73
struct end_io_wq {
	struct bio *bio;
	bio_end_io_t *end_io;
	void *private;
	struct btrfs_fs_info *info;
	int error;
74
	int metadata;
75
	struct list_head list;
76
	struct btrfs_work work;
77
};
78

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

101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134
/* These are used to set the lockdep class on the extent buffer locks.
 * The class is set by the readpage_end_io_hook after the buffer has
 * passed csum validation but before the pages are unlocked.
 *
 * The lockdep class is also set by btrfs_init_new_buffer on freshly
 * allocated blocks.
 *
 * The class is based on the level in the tree block, which allows lockdep
 * to know that lower nodes nest inside the locks of higher nodes.
 *
 * 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.
 */
#ifdef CONFIG_DEBUG_LOCK_ALLOC
# if BTRFS_MAX_LEVEL != 8
#  error
# endif
static struct lock_class_key btrfs_eb_class[BTRFS_MAX_LEVEL + 1];
static const char *btrfs_eb_name[BTRFS_MAX_LEVEL + 1] = {
	/* leaf */
	"btrfs-extent-00",
	"btrfs-extent-01",
	"btrfs-extent-02",
	"btrfs-extent-03",
	"btrfs-extent-04",
	"btrfs-extent-05",
	"btrfs-extent-06",
	"btrfs-extent-07",
	/* highest possible level */
	"btrfs-extent-08",
};
#endif

C
Chris Mason 已提交
135 136 137 138
/*
 * extents on the btree inode are pretty simple, there's one extent
 * that covers the entire device
 */
139 140 141
static struct extent_map *btree_get_extent(struct inode *inode,
		struct page *page, size_t page_offset, u64 start, u64 len,
		int create)
142
{
143 144 145 146
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
	struct extent_map *em;
	int ret;

147
	read_lock(&em_tree->lock);
148
	em = lookup_extent_mapping(em_tree, start, len);
149 150 151
	if (em) {
		em->bdev =
			BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev;
152
		read_unlock(&em_tree->lock);
153
		goto out;
154
	}
155
	read_unlock(&em_tree->lock);
156

157 158 159 160 161 162
	em = alloc_extent_map(GFP_NOFS);
	if (!em) {
		em = ERR_PTR(-ENOMEM);
		goto out;
	}
	em->start = 0;
163
	em->len = (u64)-1;
C
Chris Mason 已提交
164
	em->block_len = (u64)-1;
165
	em->block_start = 0;
166
	em->bdev = BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev;
167

168
	write_lock(&em_tree->lock);
169 170
	ret = add_extent_mapping(em_tree, em);
	if (ret == -EEXIST) {
171 172 173
		u64 failed_start = em->start;
		u64 failed_len = em->len;

174
		free_extent_map(em);
175
		em = lookup_extent_mapping(em_tree, start, len);
176
		if (em) {
177
			ret = 0;
178 179 180
		} else {
			em = lookup_extent_mapping(em_tree, failed_start,
						   failed_len);
181
			ret = -EIO;
182
		}
183
	} else if (ret) {
184 185
		free_extent_map(em);
		em = NULL;
186
	}
187
	write_unlock(&em_tree->lock);
188 189 190

	if (ret)
		em = ERR_PTR(ret);
191 192
out:
	return em;
193 194
}

195 196
u32 btrfs_csum_data(struct btrfs_root *root, char *data, u32 seed, size_t len)
{
197
	return crc32c(seed, data, len);
198 199 200 201
}

void btrfs_csum_final(u32 crc, char *result)
{
202
	put_unaligned_le32(~crc, result);
203 204
}

C
Chris Mason 已提交
205 206 207 208
/*
 * compute the csum for a btree block, and either verify it or write it
 * into the csum field of the block.
 */
209 210 211
static int csum_tree_block(struct btrfs_root *root, struct extent_buffer *buf,
			   int verify)
{
212 213 214
	u16 csum_size =
		btrfs_super_csum_size(&root->fs_info->super_copy);
	char *result = NULL;
215 216 217 218 219 220 221 222 223
	unsigned long len;
	unsigned long cur_len;
	unsigned long offset = BTRFS_CSUM_SIZE;
	char *map_token = NULL;
	char *kaddr;
	unsigned long map_start;
	unsigned long map_len;
	int err;
	u32 crc = ~(u32)0;
224
	unsigned long inline_result;
225 226

	len = buf->len - offset;
C
Chris Mason 已提交
227
	while (len > 0) {
228 229 230
		err = map_private_extent_buffer(buf, offset, 32,
					&map_token, &kaddr,
					&map_start, &map_len, KM_USER0);
C
Chris Mason 已提交
231
		if (err)
232 233 234 235 236 237 238 239
			return 1;
		cur_len = min(len, map_len - (offset - map_start));
		crc = btrfs_csum_data(root, kaddr + offset - map_start,
				      crc, cur_len);
		len -= cur_len;
		offset += cur_len;
		unmap_extent_buffer(buf, map_token, KM_USER0);
	}
240 241 242 243 244 245 246 247
	if (csum_size > sizeof(inline_result)) {
		result = kzalloc(csum_size * sizeof(char), GFP_NOFS);
		if (!result)
			return 1;
	} else {
		result = (char *)&inline_result;
	}

248 249 250
	btrfs_csum_final(crc, result);

	if (verify) {
251
		if (memcmp_extent_buffer(buf, result, 0, csum_size)) {
252 253
			u32 val;
			u32 found = 0;
254
			memcpy(&found, result, csum_size);
255

256
			read_extent_buffer(buf, &val, 0, csum_size);
C
Chris Mason 已提交
257 258 259 260 261 262 263 264
			if (printk_ratelimit()) {
				printk(KERN_INFO "btrfs: %s checksum verify "
				       "failed on %llu wanted %X found %X "
				       "level %d\n",
				       root->fs_info->sb->s_id,
				       (unsigned long long)buf->start, val, found,
				       btrfs_header_level(buf));
			}
265 266
			if (result != (char *)&inline_result)
				kfree(result);
267 268 269
			return 1;
		}
	} else {
270
		write_extent_buffer(buf, result, 0, csum_size);
271
	}
272 273
	if (result != (char *)&inline_result)
		kfree(result);
274 275 276
	return 0;
}

C
Chris Mason 已提交
277 278 279 280 281 282
/*
 * 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.
 */
283 284 285
static int verify_parent_transid(struct extent_io_tree *io_tree,
				 struct extent_buffer *eb, u64 parent_transid)
{
286
	struct extent_state *cached_state = NULL;
287 288 289 290 291
	int ret;

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

292 293 294
	lock_extent_bits(io_tree, eb->start, eb->start + eb->len - 1,
			 0, &cached_state, GFP_NOFS);
	if (extent_buffer_uptodate(io_tree, eb, cached_state) &&
295 296 297 298
	    btrfs_header_generation(eb) == parent_transid) {
		ret = 0;
		goto out;
	}
C
Chris Mason 已提交
299 300 301 302 303 304 305
	if (printk_ratelimit()) {
		printk("parent transid verify failed on %llu wanted %llu "
		       "found %llu\n",
		       (unsigned long long)eb->start,
		       (unsigned long long)parent_transid,
		       (unsigned long long)btrfs_header_generation(eb));
	}
306
	ret = 1;
307
	clear_extent_buffer_uptodate(io_tree, eb, &cached_state);
C
Chris Mason 已提交
308
out:
309 310
	unlock_extent_cached(io_tree, eb->start, eb->start + eb->len - 1,
			     &cached_state, GFP_NOFS);
311 312 313
	return ret;
}

C
Chris Mason 已提交
314 315 316 317
/*
 * helper to read a given tree block, doing retries as required when
 * the checksums don't match and we have alternate mirrors to try.
 */
318 319
static int btree_read_extent_buffer_pages(struct btrfs_root *root,
					  struct extent_buffer *eb,
320
					  u64 start, u64 parent_transid)
321 322 323 324 325 326
{
	struct extent_io_tree *io_tree;
	int ret;
	int num_copies = 0;
	int mirror_num = 0;

327
	clear_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags);
328 329 330 331
	io_tree = &BTRFS_I(root->fs_info->btree_inode)->io_tree;
	while (1) {
		ret = read_extent_buffer_pages(io_tree, eb, start, 1,
					       btree_get_extent, mirror_num);
332 333
		if (!ret &&
		    !verify_parent_transid(io_tree, eb, parent_transid))
334
			return ret;
C
Chris Mason 已提交
335

336 337 338 339 340 341 342 343
		/*
		 * This buffer's crc is fine, but its contents are corrupted, so
		 * there is no reason to read the other copies, they won't be
		 * any less wrong.
		 */
		if (test_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags))
			return ret;

344 345
		num_copies = btrfs_num_copies(&root->fs_info->mapping_tree,
					      eb->start, eb->len);
C
Chris Mason 已提交
346
		if (num_copies == 1)
347
			return ret;
C
Chris Mason 已提交
348

349
		mirror_num++;
C
Chris Mason 已提交
350
		if (mirror_num > num_copies)
351 352 353 354
			return ret;
	}
	return -EIO;
}
355

C
Chris Mason 已提交
356
/*
C
Chris Mason 已提交
357 358
 * 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 已提交
359
 */
C
Chris Mason 已提交
360

361
static int csum_dirty_buffer(struct btrfs_root *root, struct page *page)
362
{
363
	struct extent_io_tree *tree;
364
	u64 start = (u64)page->index << PAGE_CACHE_SHIFT;
365 366 367
	u64 found_start;
	unsigned long len;
	struct extent_buffer *eb;
368 369
	int ret;

370
	tree = &BTRFS_I(page->mapping->host)->io_tree;
371

C
Chris Mason 已提交
372 373
	if (page->private == EXTENT_PAGE_PRIVATE) {
		WARN_ON(1);
374
		goto out;
C
Chris Mason 已提交
375 376 377
	}
	if (!page->private) {
		WARN_ON(1);
378
		goto out;
C
Chris Mason 已提交
379
	}
380
	len = page->private >> 2;
C
Chris Mason 已提交
381 382
	WARN_ON(len == 0);

383
	eb = alloc_extent_buffer(tree, start, len, page, GFP_NOFS);
T
Tsutomu Itoh 已提交
384 385 386 387
	if (eb == NULL) {
		WARN_ON(1);
		goto out;
	}
388 389
	ret = btree_read_extent_buffer_pages(root, eb, start + PAGE_CACHE_SIZE,
					     btrfs_header_generation(eb));
390
	BUG_ON(ret);
391 392
	WARN_ON(!btrfs_header_flag(eb, BTRFS_HEADER_FLAG_WRITTEN));

393 394
	found_start = btrfs_header_bytenr(eb);
	if (found_start != start) {
395 396 397 398 399 400 401 402 403 404
		WARN_ON(1);
		goto err;
	}
	if (eb->first_page != page) {
		WARN_ON(1);
		goto err;
	}
	if (!PageUptodate(page)) {
		WARN_ON(1);
		goto err;
405 406
	}
	csum_tree_block(root, eb, 0);
407
err:
408 409 410 411 412
	free_extent_buffer(eb);
out:
	return 0;
}

Y
Yan Zheng 已提交
413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431
static int check_tree_block_fsid(struct btrfs_root *root,
				 struct extent_buffer *eb)
{
	struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
	u8 fsid[BTRFS_UUID_SIZE];
	int ret = 1;

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

432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498
#define CORRUPT(reason, eb, root, slot)				\
	printk(KERN_CRIT "btrfs: corrupt leaf, %s: block=%llu,"	\
	       "root=%llu, slot=%d\n", reason,			\
	       (unsigned long long)btrfs_header_bytenr(eb),	\
	       (unsigned long long)root->objectid, slot)

static noinline int check_leaf(struct btrfs_root *root,
			       struct extent_buffer *leaf)
{
	struct btrfs_key key;
	struct btrfs_key leaf_key;
	u32 nritems = btrfs_header_nritems(leaf);
	int slot;

	if (nritems == 0)
		return 0;

	/* Check the 0 item */
	if (btrfs_item_offset_nr(leaf, 0) + btrfs_item_size_nr(leaf, 0) !=
	    BTRFS_LEAF_DATA_SIZE(root)) {
		CORRUPT("invalid item offset size pair", leaf, root, 0);
		return -EIO;
	}

	/*
	 * Check to make sure each items keys are in the correct order and their
	 * offsets make sense.  We only have to loop through nritems-1 because
	 * we check the current slot against the next slot, which verifies the
	 * next slot's offset+size makes sense and that the current's slot
	 * offset is correct.
	 */
	for (slot = 0; slot < nritems - 1; slot++) {
		btrfs_item_key_to_cpu(leaf, &leaf_key, slot);
		btrfs_item_key_to_cpu(leaf, &key, slot + 1);

		/* Make sure the keys are in the right order */
		if (btrfs_comp_cpu_keys(&leaf_key, &key) >= 0) {
			CORRUPT("bad key order", leaf, root, slot);
			return -EIO;
		}

		/*
		 * Make sure the offset and ends are right, remember that the
		 * item data starts at the end of the leaf and grows towards the
		 * front.
		 */
		if (btrfs_item_offset_nr(leaf, slot) !=
			btrfs_item_end_nr(leaf, slot + 1)) {
			CORRUPT("slot offset bad", leaf, root, slot);
			return -EIO;
		}

		/*
		 * Check to make sure that we don't point outside of the leaf,
		 * just incase all the items are consistent to eachother, but
		 * all point outside of the leaf.
		 */
		if (btrfs_item_end_nr(leaf, slot) >
		    BTRFS_LEAF_DATA_SIZE(root)) {
			CORRUPT("slot end outside of leaf", leaf, root, slot);
			return -EIO;
		}
	}

	return 0;
}

499 500 501 502 503 504 505 506 507
#ifdef CONFIG_DEBUG_LOCK_ALLOC
void btrfs_set_buffer_lockdep_class(struct extent_buffer *eb, int level)
{
	lockdep_set_class_and_name(&eb->lock,
			   &btrfs_eb_class[level],
			   btrfs_eb_name[level]);
}
#endif

508
static int btree_readpage_end_io_hook(struct page *page, u64 start, u64 end,
509 510 511 512 513 514 515 516
			       struct extent_state *state)
{
	struct extent_io_tree *tree;
	u64 found_start;
	int found_level;
	unsigned long len;
	struct extent_buffer *eb;
	struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
517
	int ret = 0;
518 519 520 521 522 523

	tree = &BTRFS_I(page->mapping->host)->io_tree;
	if (page->private == EXTENT_PAGE_PRIVATE)
		goto out;
	if (!page->private)
		goto out;
C
Chris Mason 已提交
524

525
	len = page->private >> 2;
C
Chris Mason 已提交
526 527
	WARN_ON(len == 0);

528
	eb = alloc_extent_buffer(tree, start, len, page, GFP_NOFS);
T
Tsutomu Itoh 已提交
529 530 531 532
	if (eb == NULL) {
		ret = -EIO;
		goto out;
	}
533

534
	found_start = btrfs_header_bytenr(eb);
535
	if (found_start != start) {
C
Chris Mason 已提交
536 537 538 539 540 541
		if (printk_ratelimit()) {
			printk(KERN_INFO "btrfs bad tree block start "
			       "%llu %llu\n",
			       (unsigned long long)found_start,
			       (unsigned long long)eb->start);
		}
542
		ret = -EIO;
543 544 545
		goto err;
	}
	if (eb->first_page != page) {
C
Chris Mason 已提交
546 547
		printk(KERN_INFO "btrfs bad first page %lu %lu\n",
		       eb->first_page->index, page->index);
548
		WARN_ON(1);
549
		ret = -EIO;
550 551
		goto err;
	}
Y
Yan Zheng 已提交
552
	if (check_tree_block_fsid(root, eb)) {
C
Chris Mason 已提交
553 554 555 556
		if (printk_ratelimit()) {
			printk(KERN_INFO "btrfs bad fsid on block %llu\n",
			       (unsigned long long)eb->start);
		}
557 558 559
		ret = -EIO;
		goto err;
	}
560 561
	found_level = btrfs_header_level(eb);

562 563
	btrfs_set_buffer_lockdep_class(eb, found_level);

564
	ret = csum_tree_block(root, eb, 1);
565
	if (ret) {
566
		ret = -EIO;
567 568 569 570 571 572 573 574 575 576 577 578
		goto err;
	}

	/*
	 * If this is a leaf block and it is corrupt, set the corrupt bit so
	 * that we don't try and read the other copies of this block, just
	 * return -EIO.
	 */
	if (found_level == 0 && check_leaf(root, eb)) {
		set_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags);
		ret = -EIO;
	}
579 580 581 582 583 584

	end = min_t(u64, eb->len, PAGE_CACHE_SIZE);
	end = eb->start + end - 1;
err:
	free_extent_buffer(eb);
out:
585
	return ret;
586 587 588 589 590 591 592 593 594
}

static void end_workqueue_bio(struct bio *bio, int err)
{
	struct end_io_wq *end_io_wq = bio->bi_private;
	struct btrfs_fs_info *fs_info;

	fs_info = end_io_wq->info;
	end_io_wq->error = err;
595 596
	end_io_wq->work.func = end_workqueue_fn;
	end_io_wq->work.flags = 0;
597

598
	if (bio->bi_rw & REQ_WRITE) {
J
Josef Bacik 已提交
599
		if (end_io_wq->metadata == 1)
600 601
			btrfs_queue_worker(&fs_info->endio_meta_write_workers,
					   &end_io_wq->work);
J
Josef Bacik 已提交
602 603 604
		else if (end_io_wq->metadata == 2)
			btrfs_queue_worker(&fs_info->endio_freespace_worker,
					   &end_io_wq->work);
605 606 607
		else
			btrfs_queue_worker(&fs_info->endio_write_workers,
					   &end_io_wq->work);
608 609 610 611 612 613 614 615
	} else {
		if (end_io_wq->metadata)
			btrfs_queue_worker(&fs_info->endio_meta_workers,
					   &end_io_wq->work);
		else
			btrfs_queue_worker(&fs_info->endio_workers,
					   &end_io_wq->work);
	}
616 617
}

J
Josef Bacik 已提交
618 619 620 621 622 623 624
/*
 * For the metadata arg you want
 *
 * 0 - if data
 * 1 - if normal metadta
 * 2 - if writing to the free space cache area
 */
625 626
int btrfs_bio_wq_end_io(struct btrfs_fs_info *info, struct bio *bio,
			int metadata)
627
{
628 629 630 631 632 633 634
	struct end_io_wq *end_io_wq;
	end_io_wq = kmalloc(sizeof(*end_io_wq), GFP_NOFS);
	if (!end_io_wq)
		return -ENOMEM;

	end_io_wq->private = bio->bi_private;
	end_io_wq->end_io = bio->bi_end_io;
635
	end_io_wq->info = info;
636 637
	end_io_wq->error = 0;
	end_io_wq->bio = bio;
638
	end_io_wq->metadata = metadata;
639 640 641

	bio->bi_private = end_io_wq;
	bio->bi_end_io = end_workqueue_bio;
642 643 644
	return 0;
}

645
unsigned long btrfs_async_submit_limit(struct btrfs_fs_info *info)
646
{
647 648 649 650 651
	unsigned long limit = min_t(unsigned long,
				    info->workers.max_workers,
				    info->fs_devices->open_devices);
	return 256 * limit;
}
652

653 654
int btrfs_congested_async(struct btrfs_fs_info *info, int iodone)
{
655 656
	return atomic_read(&info->nr_async_bios) >
		btrfs_async_submit_limit(info);
657 658
}

C
Chris Mason 已提交
659 660 661 662 663 664
static void run_one_async_start(struct btrfs_work *work)
{
	struct async_submit_bio *async;

	async = container_of(work, struct  async_submit_bio, work);
	async->submit_bio_start(async->inode, async->rw, async->bio,
665 666
			       async->mirror_num, async->bio_flags,
			       async->bio_offset);
C
Chris Mason 已提交
667 668 669
}

static void run_one_async_done(struct btrfs_work *work)
670 671 672
{
	struct btrfs_fs_info *fs_info;
	struct async_submit_bio *async;
673
	int limit;
674 675 676

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

678
	limit = btrfs_async_submit_limit(fs_info);
679 680
	limit = limit * 2 / 3;

681
	atomic_dec(&fs_info->nr_async_submits);
682

683 684
	if (atomic_read(&fs_info->nr_async_submits) < limit &&
	    waitqueue_active(&fs_info->async_submit_wait))
685 686
		wake_up(&fs_info->async_submit_wait);

C
Chris Mason 已提交
687
	async->submit_bio_done(async->inode, async->rw, async->bio,
688 689
			       async->mirror_num, async->bio_flags,
			       async->bio_offset);
C
Chris Mason 已提交
690 691 692 693 694 695 696
}

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

	async = container_of(work, struct  async_submit_bio, work);
697 698 699
	kfree(async);
}

700 701
int btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info, struct inode *inode,
			int rw, struct bio *bio, int mirror_num,
C
Chris Mason 已提交
702
			unsigned long bio_flags,
703
			u64 bio_offset,
C
Chris Mason 已提交
704 705
			extent_submit_bio_hook_t *submit_bio_start,
			extent_submit_bio_hook_t *submit_bio_done)
706 707 708 709 710 711 712 713 714 715 716
{
	struct async_submit_bio *async;

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

	async->inode = inode;
	async->rw = rw;
	async->bio = bio;
	async->mirror_num = mirror_num;
C
Chris Mason 已提交
717 718 719 720 721 722 723
	async->submit_bio_start = submit_bio_start;
	async->submit_bio_done = submit_bio_done;

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

724
	async->work.flags = 0;
C
Chris Mason 已提交
725
	async->bio_flags = bio_flags;
726
	async->bio_offset = bio_offset;
727

728
	atomic_inc(&fs_info->nr_async_submits);
729

730
	if (rw & REQ_SYNC)
731 732
		btrfs_set_work_high_prio(&async->work);

733
	btrfs_queue_worker(&fs_info->workers, &async->work);
734

C
Chris Mason 已提交
735
	while (atomic_read(&fs_info->async_submit_draining) &&
736 737 738 739 740
	      atomic_read(&fs_info->nr_async_submits)) {
		wait_event(fs_info->async_submit_wait,
			   (atomic_read(&fs_info->nr_async_submits) == 0));
	}

741 742 743
	return 0;
}

744 745 746 747 748 749 750
static int btree_csum_one_bio(struct bio *bio)
{
	struct bio_vec *bvec = bio->bi_io_vec;
	int bio_index = 0;
	struct btrfs_root *root;

	WARN_ON(bio->bi_vcnt <= 0);
C
Chris Mason 已提交
751
	while (bio_index < bio->bi_vcnt) {
752 753 754 755 756 757 758 759
		root = BTRFS_I(bvec->bv_page->mapping->host)->root;
		csum_dirty_buffer(root, bvec->bv_page);
		bio_index++;
		bvec++;
	}
	return 0;
}

C
Chris Mason 已提交
760 761
static int __btree_submit_bio_start(struct inode *inode, int rw,
				    struct bio *bio, int mirror_num,
762 763
				    unsigned long bio_flags,
				    u64 bio_offset)
764
{
765 766
	/*
	 * when we're called for a write, we're already in the async
767
	 * submission context.  Just jump into btrfs_map_bio
768
	 */
C
Chris Mason 已提交
769 770 771
	btree_csum_one_bio(bio);
	return 0;
}
772

C
Chris Mason 已提交
773
static int __btree_submit_bio_done(struct inode *inode, int rw, struct bio *bio,
774 775
				 int mirror_num, unsigned long bio_flags,
				 u64 bio_offset)
C
Chris Mason 已提交
776
{
777
	/*
C
Chris Mason 已提交
778 779
	 * when we're called for a write, we're already in the async
	 * submission context.  Just jump into btrfs_map_bio
780 781
	 */
	return btrfs_map_bio(BTRFS_I(inode)->root, rw, bio, mirror_num, 1);
782 783
}

784
static int btree_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
785 786
				 int mirror_num, unsigned long bio_flags,
				 u64 bio_offset)
787
{
788 789 790 791 792 793
	int ret;

	ret = btrfs_bio_wq_end_io(BTRFS_I(inode)->root->fs_info,
					  bio, 1);
	BUG_ON(ret);

794
	if (!(rw & REQ_WRITE)) {
C
Chris Mason 已提交
795 796 797 798 799
		/*
		 * called for a read, do the setup so that checksum validation
		 * can happen in the async kernel threads
		 */
		return btrfs_map_bio(BTRFS_I(inode)->root, rw, bio,
800
				     mirror_num, 0);
801
	}
802

803 804 805 806
	/*
	 * kthread helpers are used to submit writes so that checksumming
	 * can happen in parallel across all CPUs
	 */
807
	return btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,
C
Chris Mason 已提交
808
				   inode, rw, bio, mirror_num, 0,
809
				   bio_offset,
C
Chris Mason 已提交
810 811
				   __btree_submit_bio_start,
				   __btree_submit_bio_done);
812 813
}

J
Jan Beulich 已提交
814
#ifdef CONFIG_MIGRATION
815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832
static int btree_migratepage(struct address_space *mapping,
			struct page *newpage, struct page *page)
{
	/*
	 * 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;
	return migrate_page(mapping, newpage, page);
}
J
Jan Beulich 已提交
833
#endif
834

835 836
static int btree_writepage(struct page *page, struct writeback_control *wbc)
{
837
	struct extent_io_tree *tree;
838 839 840 841
	struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
	struct extent_buffer *eb;
	int was_dirty;

842
	tree = &BTRFS_I(page->mapping->host)->io_tree;
843 844 845 846
	if (!(current->flags & PF_MEMALLOC)) {
		return extent_write_full_page(tree, page,
					      btree_get_extent, wbc);
	}
847

848
	redirty_page_for_writepage(wbc, page);
849
	eb = btrfs_find_tree_block(root, page_offset(page), PAGE_CACHE_SIZE);
850 851 852 853 854 855 856
	WARN_ON(!eb);

	was_dirty = test_and_set_bit(EXTENT_BUFFER_DIRTY, &eb->bflags);
	if (!was_dirty) {
		spin_lock(&root->fs_info->delalloc_lock);
		root->fs_info->dirty_metadata_bytes += PAGE_CACHE_SIZE;
		spin_unlock(&root->fs_info->delalloc_lock);
857
	}
858 859 860 861
	free_extent_buffer(eb);

	unlock_page(page);
	return 0;
862
}
863 864 865 866

static int btree_writepages(struct address_space *mapping,
			    struct writeback_control *wbc)
{
867 868
	struct extent_io_tree *tree;
	tree = &BTRFS_I(mapping->host)->io_tree;
869
	if (wbc->sync_mode == WB_SYNC_NONE) {
870
		struct btrfs_root *root = BTRFS_I(mapping->host)->root;
871
		u64 num_dirty;
872
		unsigned long thresh = 32 * 1024 * 1024;
873 874 875 876

		if (wbc->for_kupdate)
			return 0;

877 878
		/* this is a bit racy, but that's ok */
		num_dirty = root->fs_info->dirty_metadata_bytes;
C
Chris Mason 已提交
879
		if (num_dirty < thresh)
880 881
			return 0;
	}
882 883 884
	return extent_writepages(tree, mapping, btree_get_extent, wbc);
}

885
static int btree_readpage(struct file *file, struct page *page)
886
{
887 888
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
889 890
	return extent_read_full_page(tree, page, btree_get_extent);
}
C
Chris Mason 已提交
891

892
static int btree_releasepage(struct page *page, gfp_t gfp_flags)
893
{
894 895
	struct extent_io_tree *tree;
	struct extent_map_tree *map;
896
	int ret;
897

898
	if (PageWriteback(page) || PageDirty(page))
C
Chris Mason 已提交
899
		return 0;
900

901 902
	tree = &BTRFS_I(page->mapping->host)->io_tree;
	map = &BTRFS_I(page->mapping->host)->extent_tree;
903

904
	ret = try_release_extent_state(map, tree, page, gfp_flags);
C
Chris Mason 已提交
905
	if (!ret)
906 907 908
		return 0;

	ret = try_release_extent_buffer(tree, page);
909 910 911 912 913
	if (ret == 1) {
		ClearPagePrivate(page);
		set_page_private(page, 0);
		page_cache_release(page);
	}
914

915 916 917
	return ret;
}

918
static void btree_invalidatepage(struct page *page, unsigned long offset)
919
{
920 921
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
922 923
	extent_invalidatepage(tree, page, offset);
	btree_releasepage(page, GFP_NOFS);
924
	if (PagePrivate(page)) {
C
Chris Mason 已提交
925 926
		printk(KERN_WARNING "btrfs warning page private not zero "
		       "on page %llu\n", (unsigned long long)page_offset(page));
927 928 929 930
		ClearPagePrivate(page);
		set_page_private(page, 0);
		page_cache_release(page);
	}
931 932
}

933
static const struct address_space_operations btree_aops = {
934 935
	.readpage	= btree_readpage,
	.writepage	= btree_writepage,
936
	.writepages	= btree_writepages,
937 938
	.releasepage	= btree_releasepage,
	.invalidatepage = btree_invalidatepage,
939
#ifdef CONFIG_MIGRATION
940
	.migratepage	= btree_migratepage,
941
#endif
942 943
};

944 945
int readahead_tree_block(struct btrfs_root *root, u64 bytenr, u32 blocksize,
			 u64 parent_transid)
C
Chris Mason 已提交
946
{
947 948
	struct extent_buffer *buf = NULL;
	struct inode *btree_inode = root->fs_info->btree_inode;
949
	int ret = 0;
C
Chris Mason 已提交
950

951
	buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
952
	if (!buf)
C
Chris Mason 已提交
953
		return 0;
954
	read_extent_buffer_pages(&BTRFS_I(btree_inode)->io_tree,
955
				 buf, 0, 0, btree_get_extent, 0);
956
	free_extent_buffer(buf);
957
	return ret;
C
Chris Mason 已提交
958 959
}

960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981
struct extent_buffer *btrfs_find_tree_block(struct btrfs_root *root,
					    u64 bytenr, u32 blocksize)
{
	struct inode *btree_inode = root->fs_info->btree_inode;
	struct extent_buffer *eb;
	eb = find_extent_buffer(&BTRFS_I(btree_inode)->io_tree,
				bytenr, blocksize, GFP_NOFS);
	return eb;
}

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

	eb = alloc_extent_buffer(&BTRFS_I(btree_inode)->io_tree,
				 bytenr, blocksize, NULL, GFP_NOFS);
	return eb;
}


982 983
int btrfs_write_tree_block(struct extent_buffer *buf)
{
984 985
	return filemap_fdatawrite_range(buf->first_page->mapping, buf->start,
					buf->start + buf->len - 1);
986 987 988 989
}

int btrfs_wait_tree_block_writeback(struct extent_buffer *buf)
{
990 991
	return filemap_fdatawait_range(buf->first_page->mapping,
				       buf->start, buf->start + buf->len - 1);
992 993
}

994
struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 bytenr,
995
				      u32 blocksize, u64 parent_transid)
996 997 998 999 1000 1001 1002 1003
{
	struct extent_buffer *buf = NULL;
	int ret;

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

1004
	ret = btree_read_extent_buffer_pages(root, buf, 0, parent_transid);
1005

C
Chris Mason 已提交
1006
	if (ret == 0)
1007
		set_bit(EXTENT_BUFFER_UPTODATE, &buf->bflags);
1008
	return buf;
1009

1010 1011
}

1012
int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
1013
		     struct extent_buffer *buf)
1014
{
1015
	struct inode *btree_inode = root->fs_info->btree_inode;
1016
	if (btrfs_header_generation(buf) ==
1017
	    root->fs_info->running_transaction->transid) {
1018
		btrfs_assert_tree_locked(buf);
1019

1020 1021 1022 1023 1024 1025 1026 1027
		if (test_and_clear_bit(EXTENT_BUFFER_DIRTY, &buf->bflags)) {
			spin_lock(&root->fs_info->delalloc_lock);
			if (root->fs_info->dirty_metadata_bytes >= buf->len)
				root->fs_info->dirty_metadata_bytes -= buf->len;
			else
				WARN_ON(1);
			spin_unlock(&root->fs_info->delalloc_lock);
		}
1028

1029 1030
		/* ugh, clear_extent_buffer_dirty needs to lock the page */
		btrfs_set_lock_blocking(buf);
1031
		clear_extent_buffer_dirty(&BTRFS_I(btree_inode)->io_tree,
1032
					  buf);
1033
	}
1034 1035 1036
	return 0;
}

1037
static int __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize,
1038
			u32 stripesize, struct btrfs_root *root,
1039
			struct btrfs_fs_info *fs_info,
C
Chris Mason 已提交
1040
			u64 objectid)
1041
{
C
Chris Mason 已提交
1042
	root->node = NULL;
1043
	root->commit_root = NULL;
1044 1045 1046
	root->sectorsize = sectorsize;
	root->nodesize = nodesize;
	root->leafsize = leafsize;
1047
	root->stripesize = stripesize;
C
Chris Mason 已提交
1048
	root->ref_cows = 0;
1049
	root->track_dirty = 0;
1050
	root->in_radix = 0;
1051 1052
	root->orphan_item_inserted = 0;
	root->orphan_cleanup_state = 0;
1053

1054
	root->fs_info = fs_info;
1055 1056
	root->objectid = objectid;
	root->last_trans = 0;
1057
	root->highest_objectid = 0;
1058
	root->name = NULL;
1059
	root->in_sysfs = 0;
1060
	root->inode_tree = RB_ROOT;
1061
	root->block_rsv = NULL;
1062
	root->orphan_block_rsv = NULL;
1063 1064

	INIT_LIST_HEAD(&root->dirty_list);
1065
	INIT_LIST_HEAD(&root->orphan_list);
1066
	INIT_LIST_HEAD(&root->root_list);
1067
	spin_lock_init(&root->node_lock);
1068
	spin_lock_init(&root->orphan_lock);
1069
	spin_lock_init(&root->inode_lock);
1070
	spin_lock_init(&root->accounting_lock);
1071
	mutex_init(&root->objectid_mutex);
1072
	mutex_init(&root->log_mutex);
Y
Yan Zheng 已提交
1073 1074 1075 1076 1077 1078 1079 1080
	init_waitqueue_head(&root->log_writer_wait);
	init_waitqueue_head(&root->log_commit_wait[0]);
	init_waitqueue_head(&root->log_commit_wait[1]);
	atomic_set(&root->log_commit[0], 0);
	atomic_set(&root->log_commit[1], 0);
	atomic_set(&root->log_writers, 0);
	root->log_batch = 0;
	root->log_transid = 0;
1081
	root->last_log_commit = 0;
1082 1083
	extent_io_tree_init(&root->dirty_log_pages,
			     fs_info->btree_inode->i_mapping, GFP_NOFS);
C
Chris Mason 已提交
1084

1085 1086
	memset(&root->root_key, 0, sizeof(root->root_key));
	memset(&root->root_item, 0, sizeof(root->root_item));
1087
	memset(&root->defrag_progress, 0, sizeof(root->defrag_progress));
1088
	memset(&root->root_kobj, 0, sizeof(root->root_kobj));
1089
	root->defrag_trans_start = fs_info->generation;
1090
	init_completion(&root->kobj_unregister);
1091
	root->defrag_running = 0;
1092
	root->root_key.objectid = objectid;
1093 1094 1095 1096 1097 1098
	root->anon_super.s_root = NULL;
	root->anon_super.s_dev = 0;
	INIT_LIST_HEAD(&root->anon_super.s_list);
	INIT_LIST_HEAD(&root->anon_super.s_instances);
	init_rwsem(&root->anon_super.s_umount);

1099 1100 1101
	return 0;
}

1102
static int find_and_setup_root(struct btrfs_root *tree_root,
1103 1104
			       struct btrfs_fs_info *fs_info,
			       u64 objectid,
C
Chris Mason 已提交
1105
			       struct btrfs_root *root)
1106 1107
{
	int ret;
1108
	u32 blocksize;
1109
	u64 generation;
1110

1111
	__setup_root(tree_root->nodesize, tree_root->leafsize,
1112 1113
		     tree_root->sectorsize, tree_root->stripesize,
		     root, fs_info, objectid);
1114 1115
	ret = btrfs_find_last_root(tree_root, objectid,
				   &root->root_item, &root->root_key);
1116 1117
	if (ret > 0)
		return -ENOENT;
1118 1119
	BUG_ON(ret);

1120
	generation = btrfs_root_generation(&root->root_item);
1121 1122
	blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
	root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
1123
				     blocksize, generation);
1124 1125 1126 1127
	if (!root->node || !btrfs_buffer_uptodate(root->node, generation)) {
		free_extent_buffer(root->node);
		return -EIO;
	}
1128
	root->commit_root = btrfs_root_node(root);
1129 1130 1131
	return 0;
}

Y
Yan Zheng 已提交
1132 1133
static struct btrfs_root *alloc_log_tree(struct btrfs_trans_handle *trans,
					 struct btrfs_fs_info *fs_info)
1134 1135 1136
{
	struct btrfs_root *root;
	struct btrfs_root *tree_root = fs_info->tree_root;
Y
Yan Zheng 已提交
1137
	struct extent_buffer *leaf;
1138 1139 1140

	root = kzalloc(sizeof(*root), GFP_NOFS);
	if (!root)
Y
Yan Zheng 已提交
1141
		return ERR_PTR(-ENOMEM);
1142 1143 1144 1145 1146 1147 1148 1149

	__setup_root(tree_root->nodesize, tree_root->leafsize,
		     tree_root->sectorsize, tree_root->stripesize,
		     root, fs_info, BTRFS_TREE_LOG_OBJECTID);

	root->root_key.objectid = BTRFS_TREE_LOG_OBJECTID;
	root->root_key.type = BTRFS_ROOT_ITEM_KEY;
	root->root_key.offset = BTRFS_TREE_LOG_OBJECTID;
Y
Yan Zheng 已提交
1150 1151 1152 1153 1154 1155
	/*
	 * 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).
	 */
1156 1157
	root->ref_cows = 0;

1158 1159
	leaf = btrfs_alloc_free_block(trans, root, root->leafsize, 0,
				      BTRFS_TREE_LOG_OBJECTID, NULL, 0, 0, 0);
Y
Yan Zheng 已提交
1160 1161 1162 1163
	if (IS_ERR(leaf)) {
		kfree(root);
		return ERR_CAST(leaf);
	}
1164

1165 1166 1167 1168 1169
	memset_extent_buffer(leaf, 0, 0, sizeof(struct btrfs_header));
	btrfs_set_header_bytenr(leaf, leaf->start);
	btrfs_set_header_generation(leaf, trans->transid);
	btrfs_set_header_backref_rev(leaf, BTRFS_MIXED_BACKREF_REV);
	btrfs_set_header_owner(leaf, BTRFS_TREE_LOG_OBJECTID);
Y
Yan Zheng 已提交
1170
	root->node = leaf;
1171 1172 1173 1174 1175 1176

	write_extent_buffer(root->node, root->fs_info->fsid,
			    (unsigned long)btrfs_header_fsid(root->node),
			    BTRFS_FSID_SIZE);
	btrfs_mark_buffer_dirty(root->node);
	btrfs_tree_unlock(root->node);
Y
Yan Zheng 已提交
1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212
	return root;
}

int btrfs_init_log_root_tree(struct btrfs_trans_handle *trans,
			     struct btrfs_fs_info *fs_info)
{
	struct btrfs_root *log_root;

	log_root = alloc_log_tree(trans, fs_info);
	if (IS_ERR(log_root))
		return PTR_ERR(log_root);
	WARN_ON(fs_info->log_root_tree);
	fs_info->log_root_tree = log_root;
	return 0;
}

int btrfs_add_log_tree(struct btrfs_trans_handle *trans,
		       struct btrfs_root *root)
{
	struct btrfs_root *log_root;
	struct btrfs_inode_item *inode_item;

	log_root = alloc_log_tree(trans, root->fs_info);
	if (IS_ERR(log_root))
		return PTR_ERR(log_root);

	log_root->last_trans = trans->transid;
	log_root->root_key.offset = root->root_key.objectid;

	inode_item = &log_root->root_item.inode;
	inode_item->generation = cpu_to_le64(1);
	inode_item->size = cpu_to_le64(3);
	inode_item->nlink = cpu_to_le32(1);
	inode_item->nbytes = cpu_to_le64(root->leafsize);
	inode_item->mode = cpu_to_le32(S_IFDIR | 0755);

1213
	btrfs_set_root_node(&log_root->root_item, log_root->node);
Y
Yan Zheng 已提交
1214 1215 1216 1217

	WARN_ON(root->log_root);
	root->log_root = log_root;
	root->log_transid = 0;
1218
	root->last_log_commit = 0;
1219 1220 1221 1222 1223 1224 1225 1226
	return 0;
}

struct btrfs_root *btrfs_read_fs_root_no_radix(struct btrfs_root *tree_root,
					       struct btrfs_key *location)
{
	struct btrfs_root *root;
	struct btrfs_fs_info *fs_info = tree_root->fs_info;
1227
	struct btrfs_path *path;
1228
	struct extent_buffer *l;
1229
	u64 generation;
1230
	u32 blocksize;
1231 1232
	int ret = 0;

1233
	root = kzalloc(sizeof(*root), GFP_NOFS);
C
Chris Mason 已提交
1234
	if (!root)
1235 1236
		return ERR_PTR(-ENOMEM);
	if (location->offset == (u64)-1) {
1237
		ret = find_and_setup_root(tree_root, fs_info,
1238 1239 1240 1241 1242
					  location->objectid, root);
		if (ret) {
			kfree(root);
			return ERR_PTR(ret);
		}
1243
		goto out;
1244 1245
	}

1246
	__setup_root(tree_root->nodesize, tree_root->leafsize,
1247 1248
		     tree_root->sectorsize, tree_root->stripesize,
		     root, fs_info, location->objectid);
1249 1250

	path = btrfs_alloc_path();
T
Tsutomu Itoh 已提交
1251 1252 1253 1254
	if (!path) {
		kfree(root);
		return ERR_PTR(-ENOMEM);
	}
1255
	ret = btrfs_search_slot(NULL, tree_root, location, path, 0, 0);
1256 1257 1258 1259 1260 1261
	if (ret == 0) {
		l = path->nodes[0];
		read_extent_buffer(l, &root->root_item,
				btrfs_item_ptr_offset(l, path->slots[0]),
				sizeof(root->root_item));
		memcpy(&root->root_key, location, sizeof(*location));
1262 1263 1264
	}
	btrfs_free_path(path);
	if (ret) {
1265
		kfree(root);
1266 1267
		if (ret > 0)
			ret = -ENOENT;
1268 1269
		return ERR_PTR(ret);
	}
1270

1271
	generation = btrfs_root_generation(&root->root_item);
1272 1273
	blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
	root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
1274
				     blocksize, generation);
1275
	root->commit_root = btrfs_root_node(root);
1276
	BUG_ON(!root->node);
1277
out:
1278
	if (location->objectid != BTRFS_TREE_LOG_OBJECTID) {
1279
		root->ref_cows = 1;
1280 1281
		btrfs_check_and_init_root_item(&root->root_item);
	}
1282

1283 1284 1285
	return root;
}

C
Chris Mason 已提交
1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300
struct btrfs_root *btrfs_lookup_fs_root(struct btrfs_fs_info *fs_info,
					u64 root_objectid)
{
	struct btrfs_root *root;

	if (root_objectid == BTRFS_ROOT_TREE_OBJECTID)
		return fs_info->tree_root;
	if (root_objectid == BTRFS_EXTENT_TREE_OBJECTID)
		return fs_info->extent_root;

	root = radix_tree_lookup(&fs_info->fs_roots_radix,
				 (unsigned long)root_objectid);
	return root;
}

1301 1302
struct btrfs_root *btrfs_read_fs_root_no_name(struct btrfs_fs_info *fs_info,
					      struct btrfs_key *location)
1303 1304 1305 1306
{
	struct btrfs_root *root;
	int ret;

1307 1308 1309 1310
	if (location->objectid == BTRFS_ROOT_TREE_OBJECTID)
		return fs_info->tree_root;
	if (location->objectid == BTRFS_EXTENT_TREE_OBJECTID)
		return fs_info->extent_root;
1311 1312 1313 1314
	if (location->objectid == BTRFS_CHUNK_TREE_OBJECTID)
		return fs_info->chunk_root;
	if (location->objectid == BTRFS_DEV_TREE_OBJECTID)
		return fs_info->dev_root;
1315 1316
	if (location->objectid == BTRFS_CSUM_TREE_OBJECTID)
		return fs_info->csum_root;
1317 1318
again:
	spin_lock(&fs_info->fs_roots_radix_lock);
1319 1320
	root = radix_tree_lookup(&fs_info->fs_roots_radix,
				 (unsigned long)location->objectid);
1321
	spin_unlock(&fs_info->fs_roots_radix_lock);
1322 1323 1324
	if (root)
		return root;

1325
	root = btrfs_read_fs_root_no_radix(fs_info->tree_root, location);
1326 1327
	if (IS_ERR(root))
		return root;
1328 1329 1330

	set_anon_super(&root->anon_super, NULL);

1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341
	if (btrfs_root_refs(&root->root_item) == 0) {
		ret = -ENOENT;
		goto fail;
	}

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

1342 1343 1344 1345 1346
	ret = radix_tree_preload(GFP_NOFS & ~__GFP_HIGHMEM);
	if (ret)
		goto fail;

	spin_lock(&fs_info->fs_roots_radix_lock);
C
Chris Mason 已提交
1347 1348
	ret = radix_tree_insert(&fs_info->fs_roots_radix,
				(unsigned long)root->root_key.objectid,
1349
				root);
1350
	if (ret == 0)
1351
		root->in_radix = 1;
1352

1353 1354
	spin_unlock(&fs_info->fs_roots_radix_lock);
	radix_tree_preload_end();
1355
	if (ret) {
1356 1357 1358 1359 1360
		if (ret == -EEXIST) {
			free_fs_root(root);
			goto again;
		}
		goto fail;
1361
	}
1362 1363 1364 1365

	ret = btrfs_find_dead_roots(fs_info->tree_root,
				    root->root_key.objectid);
	WARN_ON(ret);
1366
	return root;
1367 1368 1369
fail:
	free_fs_root(root);
	return ERR_PTR(ret);
1370 1371 1372 1373 1374 1375
}

struct btrfs_root *btrfs_read_fs_root(struct btrfs_fs_info *fs_info,
				      struct btrfs_key *location,
				      const char *name, int namelen)
{
1376 1377
	return btrfs_read_fs_root_no_name(fs_info, location);
#if 0
1378 1379 1380 1381 1382 1383
	struct btrfs_root *root;
	int ret;

	root = btrfs_read_fs_root_no_name(fs_info, location);
	if (!root)
		return NULL;
1384

1385 1386 1387
	if (root->in_sysfs)
		return root;

1388 1389
	ret = btrfs_set_root_name(root, name, namelen);
	if (ret) {
1390
		free_extent_buffer(root->node);
1391 1392 1393
		kfree(root);
		return ERR_PTR(ret);
	}
1394

1395 1396
	ret = btrfs_sysfs_add_root(root);
	if (ret) {
1397
		free_extent_buffer(root->node);
1398 1399 1400 1401
		kfree(root->name);
		kfree(root);
		return ERR_PTR(ret);
	}
1402
	root->in_sysfs = 1;
1403
	return root;
1404
#endif
1405
}
C
Chris Mason 已提交
1406 1407 1408 1409 1410 1411 1412

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 已提交
1413

Q
Qinghuang Feng 已提交
1414
	list_for_each_entry(device, &info->fs_devices->devices, dev_list) {
1415 1416
		if (!device->bdev)
			continue;
C
Chris Mason 已提交
1417 1418 1419 1420 1421 1422 1423 1424 1425
		bdi = blk_get_backing_dev_info(device->bdev);
		if (bdi && bdi_congested(bdi, bdi_bits)) {
			ret = 1;
			break;
		}
	}
	return ret;
}

1426 1427 1428 1429
/*
 * If this fails, caller must call bdi_destroy() to get rid of the
 * bdi again.
 */
C
Chris Mason 已提交
1430 1431
static int setup_bdi(struct btrfs_fs_info *info, struct backing_dev_info *bdi)
{
1432 1433 1434
	int err;

	bdi->capabilities = BDI_CAP_MAP_COPY;
1435
	err = bdi_setup_and_register(bdi, "btrfs", BDI_CAP_MAP_COPY);
1436 1437 1438
	if (err)
		return err;

1439
	bdi->ra_pages	= default_backing_dev_info.ra_pages;
C
Chris Mason 已提交
1440 1441 1442 1443 1444
	bdi->congested_fn	= btrfs_congested_fn;
	bdi->congested_data	= info;
	return 0;
}

1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479
static int bio_ready_for_csum(struct bio *bio)
{
	u64 length = 0;
	u64 buf_len = 0;
	u64 start = 0;
	struct page *page;
	struct extent_io_tree *io_tree = NULL;
	struct bio_vec *bvec;
	int i;
	int ret;

	bio_for_each_segment(bvec, bio, i) {
		page = bvec->bv_page;
		if (page->private == EXTENT_PAGE_PRIVATE) {
			length += bvec->bv_len;
			continue;
		}
		if (!page->private) {
			length += bvec->bv_len;
			continue;
		}
		length = bvec->bv_len;
		buf_len = page->private >> 2;
		start = page_offset(page) + bvec->bv_offset;
		io_tree = &BTRFS_I(page->mapping->host)->io_tree;
	}
	/* are we fully contained in this bio? */
	if (buf_len <= length)
		return 1;

	ret = extent_range_uptodate(io_tree, start + length,
				    start + buf_len - 1);
	return ret;
}

1480 1481 1482 1483 1484
/*
 * 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)
1485 1486
{
	struct bio *bio;
1487 1488
	struct end_io_wq *end_io_wq;
	struct btrfs_fs_info *fs_info;
1489 1490
	int error;

1491 1492 1493
	end_io_wq = container_of(work, struct end_io_wq, work);
	bio = end_io_wq->bio;
	fs_info = end_io_wq->info;
1494

1495
	/* metadata bio reads are special because the whole tree block must
1496 1497 1498 1499
	 * be checksummed at once.  This makes sure the entire block is in
	 * ram and up to date before trying to verify things.  For
	 * blocksize <= pagesize, it is basically a noop
	 */
1500
	if (!(bio->bi_rw & REQ_WRITE) && end_io_wq->metadata &&
1501
	    !bio_ready_for_csum(bio)) {
1502
		btrfs_queue_worker(&fs_info->endio_meta_workers,
1503 1504 1505 1506 1507 1508 1509 1510
				   &end_io_wq->work);
		return;
	}
	error = end_io_wq->error;
	bio->bi_private = end_io_wq->private;
	bio->bi_end_io = end_io_wq->end_io;
	kfree(end_io_wq);
	bio_endio(bio, error);
1511 1512
}

1513 1514 1515 1516 1517 1518
static int cleaner_kthread(void *arg)
{
	struct btrfs_root *root = arg;

	do {
		vfs_check_frozen(root->fs_info->sb, SB_FREEZE_WRITE);
1519 1520 1521

		if (!(root->fs_info->sb->s_flags & MS_RDONLY) &&
		    mutex_trylock(&root->fs_info->cleaner_mutex)) {
Y
Yan, Zheng 已提交
1522
			btrfs_run_delayed_iputs(root);
1523 1524 1525
			btrfs_clean_old_snapshots(root);
			mutex_unlock(&root->fs_info->cleaner_mutex);
		}
1526 1527 1528 1529 1530

		if (freezing(current)) {
			refrigerator();
		} else {
			set_current_state(TASK_INTERRUPTIBLE);
1531 1532
			if (!kthread_should_stop())
				schedule();
1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543
			__set_current_state(TASK_RUNNING);
		}
	} while (!kthread_should_stop());
	return 0;
}

static int transaction_kthread(void *arg)
{
	struct btrfs_root *root = arg;
	struct btrfs_trans_handle *trans;
	struct btrfs_transaction *cur;
1544
	u64 transid;
1545 1546 1547 1548 1549 1550 1551 1552 1553
	unsigned long now;
	unsigned long delay;
	int ret;

	do {
		delay = HZ * 30;
		vfs_check_frozen(root->fs_info->sb, SB_FREEZE_WRITE);
		mutex_lock(&root->fs_info->transaction_kthread_mutex);

1554
		spin_lock(&root->fs_info->new_trans_lock);
1555 1556
		cur = root->fs_info->running_transaction;
		if (!cur) {
1557
			spin_unlock(&root->fs_info->new_trans_lock);
1558 1559
			goto sleep;
		}
Y
Yan Zheng 已提交
1560

1561
		now = get_seconds();
1562 1563 1564
		if (!cur->blocked &&
		    (now < cur->start_time || now - cur->start_time < 30)) {
			spin_unlock(&root->fs_info->new_trans_lock);
1565 1566 1567
			delay = HZ * 5;
			goto sleep;
		}
1568 1569
		transid = cur->transid;
		spin_unlock(&root->fs_info->new_trans_lock);
1570

1571
		trans = btrfs_join_transaction(root);
1572
		BUG_ON(IS_ERR(trans));
1573 1574 1575 1576 1577 1578
		if (transid == trans->transid) {
			ret = btrfs_commit_transaction(trans, root);
			BUG_ON(ret);
		} else {
			btrfs_end_transaction(trans, root);
		}
1579 1580 1581 1582 1583 1584 1585 1586
sleep:
		wake_up_process(root->fs_info->cleaner_kthread);
		mutex_unlock(&root->fs_info->transaction_kthread_mutex);

		if (freezing(current)) {
			refrigerator();
		} else {
			set_current_state(TASK_INTERRUPTIBLE);
1587 1588 1589
			if (!kthread_should_stop() &&
			    !btrfs_transaction_blocked(root->fs_info))
				schedule_timeout(delay);
1590 1591 1592 1593 1594 1595
			__set_current_state(TASK_RUNNING);
		}
	} while (!kthread_should_stop());
	return 0;
}

1596
struct btrfs_root *open_ctree(struct super_block *sb,
1597 1598
			      struct btrfs_fs_devices *fs_devices,
			      char *options)
1599
{
1600 1601 1602 1603
	u32 sectorsize;
	u32 nodesize;
	u32 leafsize;
	u32 blocksize;
1604
	u32 stripesize;
1605
	u64 generation;
1606
	u64 features;
1607
	struct btrfs_key location;
1608
	struct buffer_head *bh;
1609
	struct btrfs_root *extent_root = kzalloc(sizeof(struct btrfs_root),
C
Chris Mason 已提交
1610
						 GFP_NOFS);
1611 1612
	struct btrfs_root *csum_root = kzalloc(sizeof(struct btrfs_root),
						 GFP_NOFS);
1613 1614
	struct btrfs_root *tree_root = btrfs_sb(sb);
	struct btrfs_fs_info *fs_info = tree_root->fs_info;
1615
	struct btrfs_root *chunk_root = kzalloc(sizeof(struct btrfs_root),
1616
						GFP_NOFS);
1617
	struct btrfs_root *dev_root = kzalloc(sizeof(struct btrfs_root),
1618
					      GFP_NOFS);
1619 1620
	struct btrfs_root *log_tree_root;

1621
	int ret;
1622
	int err = -EINVAL;
1623

C
Chris Mason 已提交
1624
	struct btrfs_super_block *disk_super;
1625

1626
	if (!extent_root || !tree_root || !fs_info ||
1627
	    !chunk_root || !dev_root || !csum_root) {
C
Chris Mason 已提交
1628 1629 1630
		err = -ENOMEM;
		goto fail;
	}
1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649

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

	ret = setup_bdi(fs_info, &fs_info->bdi);
	if (ret) {
		err = ret;
		goto fail_srcu;
	}

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

1650 1651
	fs_info->btree_inode->i_mapping->flags &= ~__GFP_FS;

1652
	INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_ATOMIC);
C
Chris Mason 已提交
1653
	INIT_LIST_HEAD(&fs_info->trans_list);
1654
	INIT_LIST_HEAD(&fs_info->dead_roots);
Y
Yan, Zheng 已提交
1655
	INIT_LIST_HEAD(&fs_info->delayed_iputs);
1656
	INIT_LIST_HEAD(&fs_info->hashers);
1657
	INIT_LIST_HEAD(&fs_info->delalloc_inodes);
1658
	INIT_LIST_HEAD(&fs_info->ordered_operations);
1659
	INIT_LIST_HEAD(&fs_info->caching_block_groups);
1660
	spin_lock_init(&fs_info->delalloc_lock);
1661
	spin_lock_init(&fs_info->new_trans_lock);
Y
Yan Zheng 已提交
1662
	spin_lock_init(&fs_info->ref_cache_lock);
1663
	spin_lock_init(&fs_info->fs_roots_radix_lock);
Y
Yan, Zheng 已提交
1664
	spin_lock_init(&fs_info->delayed_iput_lock);
1665

1666
	init_completion(&fs_info->kobj_unregister);
1667 1668
	fs_info->tree_root = tree_root;
	fs_info->extent_root = extent_root;
1669
	fs_info->csum_root = csum_root;
1670 1671
	fs_info->chunk_root = chunk_root;
	fs_info->dev_root = dev_root;
1672
	fs_info->fs_devices = fs_devices;
1673
	INIT_LIST_HEAD(&fs_info->dirty_cowonly_roots);
1674
	INIT_LIST_HEAD(&fs_info->space_info);
1675
	btrfs_mapping_init(&fs_info->mapping_tree);
1676 1677 1678 1679 1680 1681 1682
	btrfs_init_block_rsv(&fs_info->global_block_rsv);
	btrfs_init_block_rsv(&fs_info->delalloc_block_rsv);
	btrfs_init_block_rsv(&fs_info->trans_block_rsv);
	btrfs_init_block_rsv(&fs_info->chunk_block_rsv);
	btrfs_init_block_rsv(&fs_info->empty_block_rsv);
	INIT_LIST_HEAD(&fs_info->durable_block_rsv_list);
	mutex_init(&fs_info->durable_block_rsv_mutex);
1683
	atomic_set(&fs_info->nr_async_submits, 0);
1684
	atomic_set(&fs_info->async_delalloc_pages, 0);
1685
	atomic_set(&fs_info->async_submit_draining, 0);
1686
	atomic_set(&fs_info->nr_async_bios, 0);
C
Chris Mason 已提交
1687
	fs_info->sb = sb;
1688
	fs_info->max_inline = 8192 * 1024;
J
Josef Bacik 已提交
1689
	fs_info->metadata_ratio = 0;
C
Chris Mason 已提交
1690

1691 1692
	fs_info->thread_pool_size = min_t(unsigned long,
					  num_online_cpus() + 2, 8);
1693

1694 1695 1696
	INIT_LIST_HEAD(&fs_info->ordered_extents);
	spin_lock_init(&fs_info->ordered_extent_lock);

1697 1698
	sb->s_blocksize = 4096;
	sb->s_blocksize_bits = blksize_bits(4096);
J
Jens Axboe 已提交
1699
	sb->s_bdi = &fs_info->bdi;
1700

1701 1702
	fs_info->btree_inode->i_ino = BTRFS_BTREE_INODE_OBJECTID;
	fs_info->btree_inode->i_nlink = 1;
1703 1704 1705 1706 1707 1708
	/*
	 * we set the i_size on the btree inode to the max possible int.
	 * the real end of the address space is determined by all of
	 * the devices in the system
	 */
	fs_info->btree_inode->i_size = OFFSET_MAX;
1709
	fs_info->btree_inode->i_mapping->a_ops = &btree_aops;
C
Chris Mason 已提交
1710 1711
	fs_info->btree_inode->i_mapping->backing_dev_info = &fs_info->bdi;

1712
	RB_CLEAR_NODE(&BTRFS_I(fs_info->btree_inode)->rb_node);
1713
	extent_io_tree_init(&BTRFS_I(fs_info->btree_inode)->io_tree,
1714 1715
			     fs_info->btree_inode->i_mapping,
			     GFP_NOFS);
1716 1717 1718 1719
	extent_map_tree_init(&BTRFS_I(fs_info->btree_inode)->extent_tree,
			     GFP_NOFS);

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

1721 1722 1723 1724
	BTRFS_I(fs_info->btree_inode)->root = tree_root;
	memset(&BTRFS_I(fs_info->btree_inode)->location, 0,
	       sizeof(struct btrfs_key));
	BTRFS_I(fs_info->btree_inode)->dummy_inode = 1;
1725
	insert_inode_hash(fs_info->btree_inode);
1726

J
Josef Bacik 已提交
1727
	spin_lock_init(&fs_info->block_group_cache_lock);
1728
	fs_info->block_group_cache_tree = RB_ROOT;
J
Josef Bacik 已提交
1729

1730
	extent_io_tree_init(&fs_info->freed_extents[0],
1731
			     fs_info->btree_inode->i_mapping, GFP_NOFS);
1732 1733 1734
	extent_io_tree_init(&fs_info->freed_extents[1],
			     fs_info->btree_inode->i_mapping, GFP_NOFS);
	fs_info->pinned_extents = &fs_info->freed_extents[0];
1735
	fs_info->do_barriers = 1;
1736

C
Chris Mason 已提交
1737

C
Chris Mason 已提交
1738
	mutex_init(&fs_info->trans_mutex);
1739
	mutex_init(&fs_info->ordered_operations_mutex);
1740
	mutex_init(&fs_info->tree_log_mutex);
1741
	mutex_init(&fs_info->chunk_mutex);
1742 1743
	mutex_init(&fs_info->transaction_kthread_mutex);
	mutex_init(&fs_info->cleaner_mutex);
1744
	mutex_init(&fs_info->volume_mutex);
1745
	init_rwsem(&fs_info->extent_commit_sem);
1746
	init_rwsem(&fs_info->cleanup_work_sem);
1747
	init_rwsem(&fs_info->subvol_sem);
1748 1749 1750 1751

	btrfs_init_free_cluster(&fs_info->meta_alloc_cluster);
	btrfs_init_free_cluster(&fs_info->data_alloc_cluster);

1752
	init_waitqueue_head(&fs_info->transaction_throttle);
1753
	init_waitqueue_head(&fs_info->transaction_wait);
S
Sage Weil 已提交
1754
	init_waitqueue_head(&fs_info->transaction_blocked_wait);
1755
	init_waitqueue_head(&fs_info->async_submit_wait);
1756

1757
	__setup_root(4096, 4096, 4096, 4096, tree_root,
C
Chris Mason 已提交
1758
		     fs_info, BTRFS_ROOT_TREE_OBJECTID);
1759

Y
Yan Zheng 已提交
1760
	bh = btrfs_read_dev_super(fs_devices->latest_bdev);
1761 1762
	if (!bh) {
		err = -EINVAL;
C
Chris Mason 已提交
1763
		goto fail_iput;
1764
	}
C
Chris Mason 已提交
1765

1766
	memcpy(&fs_info->super_copy, bh->b_data, sizeof(fs_info->super_copy));
1767 1768
	memcpy(&fs_info->super_for_commit, &fs_info->super_copy,
	       sizeof(fs_info->super_for_commit));
1769
	brelse(bh);
1770

1771
	memcpy(fs_info->fsid, fs_info->super_copy.fsid, BTRFS_FSID_SIZE);
1772

1773
	disk_super = &fs_info->super_copy;
1774
	if (!btrfs_super_root(disk_super))
1775
		goto fail_iput;
1776

L
liubo 已提交
1777 1778 1779 1780 1781
	/* check FS state, whether FS is broken. */
	fs_info->fs_state |= btrfs_super_flags(disk_super);

	btrfs_check_super_valid(fs_info, sb->s_flags & MS_RDONLY);

1782 1783 1784 1785 1786 1787
	/*
	 * In the long term, we'll store the compression type in the super
	 * block, and it'll be used for per file compression control.
	 */
	fs_info->compress_type = BTRFS_COMPRESS_ZLIB;

Y
Yan Zheng 已提交
1788 1789 1790
	ret = btrfs_parse_options(tree_root, options);
	if (ret) {
		err = ret;
1791
		goto fail_iput;
Y
Yan Zheng 已提交
1792
	}
1793

1794 1795 1796 1797 1798
	features = btrfs_super_incompat_flags(disk_super) &
		~BTRFS_FEATURE_INCOMPAT_SUPP;
	if (features) {
		printk(KERN_ERR "BTRFS: couldn't mount because of "
		       "unsupported optional features (%Lx).\n",
1799
		       (unsigned long long)features);
1800
		err = -EINVAL;
1801
		goto fail_iput;
1802 1803
	}

1804
	features = btrfs_super_incompat_flags(disk_super);
L
Li Zefan 已提交
1805 1806 1807 1808
	features |= BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF;
	if (tree_root->fs_info->compress_type & BTRFS_COMPRESS_LZO)
		features |= BTRFS_FEATURE_INCOMPAT_COMPRESS_LZO;
	btrfs_set_super_incompat_flags(disk_super, features);
1809

1810 1811 1812 1813 1814
	features = btrfs_super_compat_ro_flags(disk_super) &
		~BTRFS_FEATURE_COMPAT_RO_SUPP;
	if (!(sb->s_flags & MS_RDONLY) && features) {
		printk(KERN_ERR "BTRFS: couldn't mount RDWR because of "
		       "unsupported option features (%Lx).\n",
1815
		       (unsigned long long)features);
1816
		err = -EINVAL;
1817
		goto fail_iput;
1818
	}
1819 1820 1821 1822

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

1823
	btrfs_init_workers(&fs_info->workers, "worker",
1824 1825
			   fs_info->thread_pool_size,
			   &fs_info->generic_worker);
C
Chris Mason 已提交
1826

1827
	btrfs_init_workers(&fs_info->delalloc_workers, "delalloc",
1828 1829
			   fs_info->thread_pool_size,
			   &fs_info->generic_worker);
1830

1831
	btrfs_init_workers(&fs_info->submit_workers, "submit",
1832
			   min_t(u64, fs_devices->num_devices,
1833 1834
			   fs_info->thread_pool_size),
			   &fs_info->generic_worker);
1835 1836 1837 1838 1839 1840

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

1842
	fs_info->workers.idle_thresh = 16;
C
Chris Mason 已提交
1843
	fs_info->workers.ordered = 1;
1844

1845 1846 1847
	fs_info->delalloc_workers.idle_thresh = 2;
	fs_info->delalloc_workers.ordered = 1;

1848 1849
	btrfs_init_workers(&fs_info->fixup_workers, "fixup", 1,
			   &fs_info->generic_worker);
1850
	btrfs_init_workers(&fs_info->endio_workers, "endio",
1851 1852
			   fs_info->thread_pool_size,
			   &fs_info->generic_worker);
1853
	btrfs_init_workers(&fs_info->endio_meta_workers, "endio-meta",
1854 1855
			   fs_info->thread_pool_size,
			   &fs_info->generic_worker);
1856
	btrfs_init_workers(&fs_info->endio_meta_write_workers,
1857 1858
			   "endio-meta-write", fs_info->thread_pool_size,
			   &fs_info->generic_worker);
1859
	btrfs_init_workers(&fs_info->endio_write_workers, "endio-write",
1860 1861
			   fs_info->thread_pool_size,
			   &fs_info->generic_worker);
J
Josef Bacik 已提交
1862 1863
	btrfs_init_workers(&fs_info->endio_freespace_worker, "freespace-write",
			   1, &fs_info->generic_worker);
1864 1865 1866 1867 1868 1869

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

1872 1873 1874
	fs_info->endio_write_workers.idle_thresh = 2;
	fs_info->endio_meta_write_workers.idle_thresh = 2;

1875
	btrfs_start_workers(&fs_info->workers, 1);
1876
	btrfs_start_workers(&fs_info->generic_worker, 1);
1877
	btrfs_start_workers(&fs_info->submit_workers, 1);
1878
	btrfs_start_workers(&fs_info->delalloc_workers, 1);
1879
	btrfs_start_workers(&fs_info->fixup_workers, 1);
1880 1881 1882 1883
	btrfs_start_workers(&fs_info->endio_workers, 1);
	btrfs_start_workers(&fs_info->endio_meta_workers, 1);
	btrfs_start_workers(&fs_info->endio_meta_write_workers, 1);
	btrfs_start_workers(&fs_info->endio_write_workers, 1);
J
Josef Bacik 已提交
1884
	btrfs_start_workers(&fs_info->endio_freespace_worker, 1);
1885

1886
	fs_info->bdi.ra_pages *= btrfs_super_num_devices(disk_super);
C
Chris Mason 已提交
1887 1888
	fs_info->bdi.ra_pages = max(fs_info->bdi.ra_pages,
				    4 * 1024 * 1024 / PAGE_CACHE_SIZE);
1889

1890 1891 1892
	nodesize = btrfs_super_nodesize(disk_super);
	leafsize = btrfs_super_leafsize(disk_super);
	sectorsize = btrfs_super_sectorsize(disk_super);
1893
	stripesize = btrfs_super_stripesize(disk_super);
1894 1895 1896
	tree_root->nodesize = nodesize;
	tree_root->leafsize = leafsize;
	tree_root->sectorsize = sectorsize;
1897
	tree_root->stripesize = stripesize;
1898 1899 1900

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

C
Chris Mason 已提交
1902 1903
	if (strncmp((char *)(&disk_super->magic), BTRFS_MAGIC,
		    sizeof(disk_super->magic))) {
C
Chris Mason 已提交
1904
		printk(KERN_INFO "btrfs: valid FS not found on %s\n", sb->s_id);
C
Chris Mason 已提交
1905 1906
		goto fail_sb_buffer;
	}
1907

1908
	mutex_lock(&fs_info->chunk_mutex);
Y
Yan Zheng 已提交
1909
	ret = btrfs_read_sys_array(tree_root);
1910
	mutex_unlock(&fs_info->chunk_mutex);
1911
	if (ret) {
C
Chris Mason 已提交
1912 1913
		printk(KERN_WARNING "btrfs: failed to read the system "
		       "array on %s\n", sb->s_id);
1914
		goto fail_sb_buffer;
1915
	}
1916 1917 1918

	blocksize = btrfs_level_size(tree_root,
				     btrfs_super_chunk_root_level(disk_super));
1919
	generation = btrfs_super_chunk_root_generation(disk_super);
1920 1921 1922 1923 1924 1925

	__setup_root(nodesize, leafsize, sectorsize, stripesize,
		     chunk_root, fs_info, BTRFS_CHUNK_TREE_OBJECTID);

	chunk_root->node = read_tree_block(chunk_root,
					   btrfs_super_chunk_root(disk_super),
1926
					   blocksize, generation);
1927
	BUG_ON(!chunk_root->node);
1928 1929 1930 1931 1932
	if (!test_bit(EXTENT_BUFFER_UPTODATE, &chunk_root->node->bflags)) {
		printk(KERN_WARNING "btrfs: failed to read chunk root on %s\n",
		       sb->s_id);
		goto fail_chunk_root;
	}
1933 1934
	btrfs_set_root_node(&chunk_root->root_item, chunk_root->node);
	chunk_root->commit_root = btrfs_root_node(chunk_root);
1935

1936
	read_extent_buffer(chunk_root->node, fs_info->chunk_tree_uuid,
C
Chris Mason 已提交
1937 1938
	   (unsigned long)btrfs_header_chunk_tree_uuid(chunk_root->node),
	   BTRFS_UUID_SIZE);
1939

1940
	mutex_lock(&fs_info->chunk_mutex);
1941
	ret = btrfs_read_chunk_tree(chunk_root);
1942
	mutex_unlock(&fs_info->chunk_mutex);
Y
Yan Zheng 已提交
1943
	if (ret) {
C
Chris Mason 已提交
1944 1945
		printk(KERN_WARNING "btrfs: failed to read chunk tree on %s\n",
		       sb->s_id);
Y
Yan Zheng 已提交
1946 1947
		goto fail_chunk_root;
	}
1948

1949 1950
	btrfs_close_extra_devices(fs_devices);

1951 1952
	blocksize = btrfs_level_size(tree_root,
				     btrfs_super_root_level(disk_super));
1953
	generation = btrfs_super_generation(disk_super);
1954

C
Chris Mason 已提交
1955
	tree_root->node = read_tree_block(tree_root,
1956
					  btrfs_super_root(disk_super),
1957
					  blocksize, generation);
C
Chris Mason 已提交
1958
	if (!tree_root->node)
Y
Yan Zheng 已提交
1959
		goto fail_chunk_root;
1960 1961 1962 1963 1964
	if (!test_bit(EXTENT_BUFFER_UPTODATE, &tree_root->node->bflags)) {
		printk(KERN_WARNING "btrfs: failed to read tree root on %s\n",
		       sb->s_id);
		goto fail_tree_root;
	}
1965 1966
	btrfs_set_root_node(&tree_root->root_item, tree_root->node);
	tree_root->commit_root = btrfs_root_node(tree_root);
1967 1968

	ret = find_and_setup_root(tree_root, fs_info,
C
Chris Mason 已提交
1969
				  BTRFS_EXTENT_TREE_OBJECTID, extent_root);
1970
	if (ret)
C
Chris Mason 已提交
1971
		goto fail_tree_root;
1972 1973 1974 1975 1976 1977
	extent_root->track_dirty = 1;

	ret = find_and_setup_root(tree_root, fs_info,
				  BTRFS_DEV_TREE_OBJECTID, dev_root);
	if (ret)
		goto fail_extent_root;
1978
	dev_root->track_dirty = 1;
1979

1980 1981 1982
	ret = find_and_setup_root(tree_root, fs_info,
				  BTRFS_CSUM_TREE_OBJECTID, csum_root);
	if (ret)
1983
		goto fail_dev_root;
1984 1985 1986

	csum_root->track_dirty = 1;

1987 1988 1989 1990 1991 1992
	fs_info->generation = generation;
	fs_info->last_trans_committed = generation;
	fs_info->data_alloc_profile = (u64)-1;
	fs_info->metadata_alloc_profile = (u64)-1;
	fs_info->system_alloc_profile = fs_info->metadata_alloc_profile;

1993 1994 1995 1996 1997 1998
	ret = btrfs_init_space_info(fs_info);
	if (ret) {
		printk(KERN_ERR "Failed to initial space info: %d\n", ret);
		goto fail_block_groups;
	}

1999 2000 2001 2002 2003
	ret = btrfs_read_block_groups(extent_root);
	if (ret) {
		printk(KERN_ERR "Failed to read block groups: %d\n", ret);
		goto fail_block_groups;
	}
C
Chris Mason 已提交
2004

2005 2006
	fs_info->cleaner_kthread = kthread_run(cleaner_kthread, tree_root,
					       "btrfs-cleaner");
2007
	if (IS_ERR(fs_info->cleaner_kthread))
2008
		goto fail_block_groups;
2009 2010 2011 2012

	fs_info->transaction_kthread = kthread_run(transaction_kthread,
						   tree_root,
						   "btrfs-transaction");
2013
	if (IS_ERR(fs_info->transaction_kthread))
2014
		goto fail_cleaner;
2015

C
Chris Mason 已提交
2016 2017 2018 2019 2020 2021 2022 2023
	if (!btrfs_test_opt(tree_root, SSD) &&
	    !btrfs_test_opt(tree_root, NOSSD) &&
	    !fs_info->fs_devices->rotating) {
		printk(KERN_INFO "Btrfs detected SSD devices, enabling SSD "
		       "mode\n");
		btrfs_set_opt(fs_info->mount_opt, SSD);
	}

L
liubo 已提交
2024 2025 2026
	/* do not make disk changes in broken FS */
	if (btrfs_super_log_root(disk_super) != 0 &&
	    !(fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR)) {
2027 2028
		u64 bytenr = btrfs_super_log_root(disk_super);

2029
		if (fs_devices->rw_devices == 0) {
C
Chris Mason 已提交
2030 2031
			printk(KERN_WARNING "Btrfs log replay required "
			       "on RO media\n");
2032 2033 2034
			err = -EIO;
			goto fail_trans_kthread;
		}
2035 2036 2037
		blocksize =
		     btrfs_level_size(tree_root,
				      btrfs_super_log_root_level(disk_super));
C
Chris Mason 已提交
2038

2039 2040 2041 2042 2043
		log_tree_root = kzalloc(sizeof(struct btrfs_root), GFP_NOFS);
		if (!log_tree_root) {
			err = -ENOMEM;
			goto fail_trans_kthread;
		}
2044 2045 2046 2047 2048

		__setup_root(nodesize, leafsize, sectorsize, stripesize,
			     log_tree_root, fs_info, BTRFS_TREE_LOG_OBJECTID);

		log_tree_root->node = read_tree_block(tree_root, bytenr,
2049 2050
						      blocksize,
						      generation + 1);
2051 2052
		ret = btrfs_recover_log_trees(log_tree_root);
		BUG_ON(ret);
2053 2054 2055 2056 2057

		if (sb->s_flags & MS_RDONLY) {
			ret =  btrfs_commit_super(tree_root);
			BUG_ON(ret);
		}
2058
	}
Z
Zheng Yan 已提交
2059

2060 2061 2062
	ret = btrfs_find_orphan_roots(tree_root);
	BUG_ON(ret);

2063
	if (!(sb->s_flags & MS_RDONLY)) {
2064 2065 2066
		ret = btrfs_cleanup_fs_roots(fs_info);
		BUG_ON(ret);

2067
		ret = btrfs_recover_relocation(tree_root);
2068 2069 2070 2071 2072 2073
		if (ret < 0) {
			printk(KERN_WARNING
			       "btrfs: failed to recover relocation\n");
			err = -EINVAL;
			goto fail_trans_kthread;
		}
2074
	}
Z
Zheng Yan 已提交
2075

2076 2077 2078 2079 2080 2081
	location.objectid = BTRFS_FS_TREE_OBJECTID;
	location.type = BTRFS_ROOT_ITEM_KEY;
	location.offset = (u64)-1;

	fs_info->fs_root = btrfs_read_fs_root_no_name(fs_info, &location);
	if (!fs_info->fs_root)
2082
		goto fail_trans_kthread;
2083 2084 2085 2086
	if (IS_ERR(fs_info->fs_root)) {
		err = PTR_ERR(fs_info->fs_root);
		goto fail_trans_kthread;
	}
C
Chris Mason 已提交
2087

2088 2089
	if (!(sb->s_flags & MS_RDONLY)) {
		down_read(&fs_info->cleanup_work_sem);
2090 2091 2092
		err = btrfs_orphan_cleanup(fs_info->fs_root);
		if (!err)
			err = btrfs_orphan_cleanup(fs_info->tree_root);
2093
		up_read(&fs_info->cleanup_work_sem);
2094 2095 2096 2097
		if (err) {
			close_ctree(tree_root);
			return ERR_PTR(err);
		}
2098 2099
	}

2100
	return tree_root;
C
Chris Mason 已提交
2101

2102 2103
fail_trans_kthread:
	kthread_stop(fs_info->transaction_kthread);
2104
fail_cleaner:
2105
	kthread_stop(fs_info->cleaner_kthread);
2106 2107 2108 2109 2110 2111 2112 2113

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

2114 2115
fail_block_groups:
	btrfs_free_block_groups(fs_info);
2116
	free_extent_buffer(csum_root->node);
2117 2118 2119 2120
	free_extent_buffer(csum_root->commit_root);
fail_dev_root:
	free_extent_buffer(dev_root->node);
	free_extent_buffer(dev_root->commit_root);
2121 2122
fail_extent_root:
	free_extent_buffer(extent_root->node);
2123
	free_extent_buffer(extent_root->commit_root);
C
Chris Mason 已提交
2124
fail_tree_root:
2125
	free_extent_buffer(tree_root->node);
2126
	free_extent_buffer(tree_root->commit_root);
Y
Yan Zheng 已提交
2127 2128
fail_chunk_root:
	free_extent_buffer(chunk_root->node);
2129
	free_extent_buffer(chunk_root->commit_root);
C
Chris Mason 已提交
2130
fail_sb_buffer:
2131
	btrfs_stop_workers(&fs_info->generic_worker);
2132
	btrfs_stop_workers(&fs_info->fixup_workers);
2133
	btrfs_stop_workers(&fs_info->delalloc_workers);
2134 2135
	btrfs_stop_workers(&fs_info->workers);
	btrfs_stop_workers(&fs_info->endio_workers);
2136
	btrfs_stop_workers(&fs_info->endio_meta_workers);
2137
	btrfs_stop_workers(&fs_info->endio_meta_write_workers);
2138
	btrfs_stop_workers(&fs_info->endio_write_workers);
J
Josef Bacik 已提交
2139
	btrfs_stop_workers(&fs_info->endio_freespace_worker);
2140
	btrfs_stop_workers(&fs_info->submit_workers);
2141
fail_iput:
2142
	invalidate_inode_pages2(fs_info->btree_inode->i_mapping);
2143
	iput(fs_info->btree_inode);
2144

2145
	btrfs_close_devices(fs_info->fs_devices);
2146
	btrfs_mapping_tree_free(&fs_info->mapping_tree);
2147
fail_bdi:
2148
	bdi_destroy(&fs_info->bdi);
2149 2150
fail_srcu:
	cleanup_srcu_struct(&fs_info->subvol_srcu);
2151
fail:
C
Chris Mason 已提交
2152 2153 2154
	kfree(extent_root);
	kfree(tree_root);
	kfree(fs_info);
2155 2156
	kfree(chunk_root);
	kfree(dev_root);
2157
	kfree(csum_root);
C
Chris Mason 已提交
2158
	return ERR_PTR(err);
2159 2160
}

2161 2162 2163 2164 2165 2166 2167
static void btrfs_end_buffer_write_sync(struct buffer_head *bh, int uptodate)
{
	char b[BDEVNAME_SIZE];

	if (uptodate) {
		set_buffer_uptodate(bh);
	} else {
2168
		if (printk_ratelimit()) {
2169 2170 2171 2172
			printk(KERN_WARNING "lost page write due to "
					"I/O error on %s\n",
				       bdevname(bh->b_bdev, b));
		}
2173 2174 2175
		/* note, we dont' set_buffer_write_io_error because we have
		 * our own ways of dealing with the IO errors
		 */
2176 2177 2178 2179 2180 2181
		clear_buffer_uptodate(bh);
	}
	unlock_buffer(bh);
	put_bh(bh);
}

Y
Yan Zheng 已提交
2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222
struct buffer_head *btrfs_read_dev_super(struct block_device *bdev)
{
	struct buffer_head *bh;
	struct buffer_head *latest = NULL;
	struct btrfs_super_block *super;
	int i;
	u64 transid = 0;
	u64 bytenr;

	/* we would like to check all the supers, but that would make
	 * a btrfs mount succeed after a mkfs from a different FS.
	 * So, we need to add a special mount option to scan for
	 * later supers, using BTRFS_SUPER_MIRROR_MAX instead
	 */
	for (i = 0; i < 1; i++) {
		bytenr = btrfs_sb_offset(i);
		if (bytenr + 4096 >= i_size_read(bdev->bd_inode))
			break;
		bh = __bread(bdev, bytenr / 4096, 4096);
		if (!bh)
			continue;

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

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

2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233
/*
 * this should be called twice, once with wait == 0 and
 * once with wait == 1.  When wait == 0 is done, all the buffer heads
 * we write are pinned.
 *
 * They are released when wait == 1 is done.
 * max_mirrors must be the same for both runs, and it indicates how
 * many supers on this one device should be written.
 *
 * max_mirrors == 0 means to write them all.
 */
Y
Yan Zheng 已提交
2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269
static int write_dev_supers(struct btrfs_device *device,
			    struct btrfs_super_block *sb,
			    int do_barriers, int wait, int max_mirrors)
{
	struct buffer_head *bh;
	int i;
	int ret;
	int errors = 0;
	u32 crc;
	u64 bytenr;
	int last_barrier = 0;

	if (max_mirrors == 0)
		max_mirrors = BTRFS_SUPER_MIRROR_MAX;

	/* make sure only the last submit_bh does a barrier */
	if (do_barriers) {
		for (i = 0; i < max_mirrors; i++) {
			bytenr = btrfs_sb_offset(i);
			if (bytenr + BTRFS_SUPER_INFO_SIZE >=
			    device->total_bytes)
				break;
			last_barrier = i;
		}
	}

	for (i = 0; i < max_mirrors; i++) {
		bytenr = btrfs_sb_offset(i);
		if (bytenr + BTRFS_SUPER_INFO_SIZE >= device->total_bytes)
			break;

		if (wait) {
			bh = __find_get_block(device->bdev, bytenr / 4096,
					      BTRFS_SUPER_INFO_SIZE);
			BUG_ON(!bh);
			wait_on_buffer(bh);
2270 2271 2272 2273 2274 2275 2276 2277 2278
			if (!buffer_uptodate(bh))
				errors++;

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

			/* drop the reference from the wait == 0 run */
			brelse(bh);
			continue;
Y
Yan Zheng 已提交
2279 2280 2281 2282 2283 2284 2285 2286 2287 2288
		} else {
			btrfs_set_super_bytenr(sb, bytenr);

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

2289 2290 2291 2292
			/*
			 * one reference for us, and we leave it for the
			 * caller
			 */
Y
Yan Zheng 已提交
2293 2294 2295 2296
			bh = __getblk(device->bdev, bytenr / 4096,
				      BTRFS_SUPER_INFO_SIZE);
			memcpy(bh->b_data, sb, BTRFS_SUPER_INFO_SIZE);

2297
			/* one reference for submit_bh */
Y
Yan Zheng 已提交
2298
			get_bh(bh);
2299 2300

			set_buffer_uptodate(bh);
Y
Yan Zheng 已提交
2301 2302 2303 2304
			lock_buffer(bh);
			bh->b_end_io = btrfs_end_buffer_write_sync;
		}

2305 2306 2307
		if (i == last_barrier && do_barriers)
			ret = submit_bh(WRITE_FLUSH_FUA, bh);
		else
2308
			ret = submit_bh(WRITE_SYNC, bh);
Y
Yan Zheng 已提交
2309

2310
		if (ret)
Y
Yan Zheng 已提交
2311 2312 2313 2314 2315 2316
			errors++;
	}
	return errors < i ? 0 : -1;
}

int write_all_supers(struct btrfs_root *root, int max_mirrors)
2317
{
2318
	struct list_head *head;
2319
	struct btrfs_device *dev;
2320
	struct btrfs_super_block *sb;
2321 2322 2323
	struct btrfs_dev_item *dev_item;
	int ret;
	int do_barriers;
2324 2325
	int max_errors;
	int total_errors = 0;
2326
	u64 flags;
2327

2328
	max_errors = btrfs_super_num_devices(&root->fs_info->super_copy) - 1;
2329 2330
	do_barriers = !btrfs_test_opt(root, NOBARRIER);

2331 2332
	sb = &root->fs_info->super_for_commit;
	dev_item = &sb->dev_item;
2333 2334 2335

	mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
	head = &root->fs_info->fs_devices->devices;
Q
Qinghuang Feng 已提交
2336
	list_for_each_entry(dev, head, dev_list) {
2337 2338 2339 2340
		if (!dev->bdev) {
			total_errors++;
			continue;
		}
Y
Yan Zheng 已提交
2341
		if (!dev->in_fs_metadata || !dev->writeable)
2342 2343
			continue;

Y
Yan Zheng 已提交
2344
		btrfs_set_stack_device_generation(dev_item, 0);
2345 2346 2347 2348 2349 2350 2351 2352
		btrfs_set_stack_device_type(dev_item, dev->type);
		btrfs_set_stack_device_id(dev_item, dev->devid);
		btrfs_set_stack_device_total_bytes(dev_item, dev->total_bytes);
		btrfs_set_stack_device_bytes_used(dev_item, dev->bytes_used);
		btrfs_set_stack_device_io_align(dev_item, dev->io_align);
		btrfs_set_stack_device_io_width(dev_item, dev->io_width);
		btrfs_set_stack_device_sector_size(dev_item, dev->sector_size);
		memcpy(dev_item->uuid, dev->uuid, BTRFS_UUID_SIZE);
Y
Yan Zheng 已提交
2353
		memcpy(dev_item->fsid, dev->fs_devices->fsid, BTRFS_UUID_SIZE);
Y
Yan Zheng 已提交
2354

2355 2356 2357
		flags = btrfs_super_flags(sb);
		btrfs_set_super_flags(sb, flags | BTRFS_HEADER_FLAG_WRITTEN);

Y
Yan Zheng 已提交
2358
		ret = write_dev_supers(dev, sb, do_barriers, 0, max_mirrors);
2359 2360
		if (ret)
			total_errors++;
2361
	}
2362
	if (total_errors > max_errors) {
C
Chris Mason 已提交
2363 2364
		printk(KERN_ERR "btrfs: %d errors while writing supers\n",
		       total_errors);
2365 2366
		BUG();
	}
2367

Y
Yan Zheng 已提交
2368
	total_errors = 0;
Q
Qinghuang Feng 已提交
2369
	list_for_each_entry(dev, head, dev_list) {
2370 2371
		if (!dev->bdev)
			continue;
Y
Yan Zheng 已提交
2372
		if (!dev->in_fs_metadata || !dev->writeable)
2373 2374
			continue;

Y
Yan Zheng 已提交
2375 2376 2377
		ret = write_dev_supers(dev, sb, do_barriers, 1, max_mirrors);
		if (ret)
			total_errors++;
2378
	}
2379
	mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
2380
	if (total_errors > max_errors) {
C
Chris Mason 已提交
2381 2382
		printk(KERN_ERR "btrfs: %d errors while writing supers\n",
		       total_errors);
2383 2384
		BUG();
	}
2385 2386 2387
	return 0;
}

Y
Yan Zheng 已提交
2388 2389
int write_ctree_super(struct btrfs_trans_handle *trans,
		      struct btrfs_root *root, int max_mirrors)
2390
{
2391
	int ret;
2392

Y
Yan Zheng 已提交
2393
	ret = write_all_supers(root, max_mirrors);
2394
	return ret;
C
Chris Mason 已提交
2395 2396
}

2397
int btrfs_free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root)
C
Chris Mason 已提交
2398
{
2399
	spin_lock(&fs_info->fs_roots_radix_lock);
C
Chris Mason 已提交
2400 2401
	radix_tree_delete(&fs_info->fs_roots_radix,
			  (unsigned long)root->root_key.objectid);
2402
	spin_unlock(&fs_info->fs_roots_radix_lock);
2403 2404 2405 2406

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

2407 2408 2409 2410 2411 2412 2413
	free_fs_root(root);
	return 0;
}

static void free_fs_root(struct btrfs_root *root)
{
	WARN_ON(!RB_EMPTY_ROOT(&root->inode_tree));
2414 2415 2416 2417
	if (root->anon_super.s_dev) {
		down_write(&root->anon_super.s_umount);
		kill_anon_super(&root->anon_super);
	}
2418 2419
	free_extent_buffer(root->node);
	free_extent_buffer(root->commit_root);
C
Chris Mason 已提交
2420
	kfree(root->name);
C
Chris Mason 已提交
2421 2422 2423
	kfree(root);
}

C
Chris Mason 已提交
2424
static int del_fs_roots(struct btrfs_fs_info *fs_info)
2425 2426 2427 2428 2429
{
	int ret;
	struct btrfs_root *gang[8];
	int i;

2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443
	while (!list_empty(&fs_info->dead_roots)) {
		gang[0] = list_entry(fs_info->dead_roots.next,
				     struct btrfs_root, root_list);
		list_del(&gang[0]->root_list);

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

C
Chris Mason 已提交
2444
	while (1) {
2445 2446 2447 2448 2449
		ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
					     (void **)gang, 0,
					     ARRAY_SIZE(gang));
		if (!ret)
			break;
C
Chris Mason 已提交
2450
		for (i = 0; i < ret; i++)
2451
			btrfs_free_fs_root(fs_info, gang[i]);
2452 2453 2454
	}
	return 0;
}
2455

Y
Yan Zheng 已提交
2456
int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info)
C
Chris Mason 已提交
2457
{
Y
Yan Zheng 已提交
2458 2459 2460
	u64 root_objectid = 0;
	struct btrfs_root *gang[8];
	int i;
2461
	int ret;
2462

Y
Yan Zheng 已提交
2463 2464 2465 2466 2467 2468
	while (1) {
		ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
					     (void **)gang, root_objectid,
					     ARRAY_SIZE(gang));
		if (!ret)
			break;
2469 2470

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

Y
Yan Zheng 已提交
2474
			root_objectid = gang[i]->root_key.objectid;
2475 2476 2477
			err = btrfs_orphan_cleanup(gang[i]);
			if (err)
				return err;
Y
Yan Zheng 已提交
2478 2479 2480 2481 2482
		}
		root_objectid++;
	}
	return 0;
}
2483

Y
Yan Zheng 已提交
2484 2485 2486 2487
int btrfs_commit_super(struct btrfs_root *root)
{
	struct btrfs_trans_handle *trans;
	int ret;
2488

Y
Yan Zheng 已提交
2489
	mutex_lock(&root->fs_info->cleaner_mutex);
Y
Yan, Zheng 已提交
2490
	btrfs_run_delayed_iputs(root);
2491
	btrfs_clean_old_snapshots(root);
Y
Yan Zheng 已提交
2492
	mutex_unlock(&root->fs_info->cleaner_mutex);
2493 2494 2495 2496 2497

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

2498
	trans = btrfs_join_transaction(root);
2499 2500
	if (IS_ERR(trans))
		return PTR_ERR(trans);
2501
	ret = btrfs_commit_transaction(trans, root);
Y
Yan Zheng 已提交
2502 2503
	BUG_ON(ret);
	/* run commit again to drop the original snapshot */
2504
	trans = btrfs_join_transaction(root);
2505 2506
	if (IS_ERR(trans))
		return PTR_ERR(trans);
C
Chris Mason 已提交
2507 2508
	btrfs_commit_transaction(trans, root);
	ret = btrfs_write_and_wait_transaction(NULL, root);
2509
	BUG_ON(ret);
2510

Y
Yan Zheng 已提交
2511
	ret = write_ctree_super(NULL, root, 0);
Y
Yan Zheng 已提交
2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522
	return ret;
}

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

	fs_info->closing = 1;
	smp_mb();

2523
	btrfs_put_block_group_cache(fs_info);
L
liubo 已提交
2524 2525 2526 2527 2528 2529 2530 2531 2532 2533

	/*
	 * Here come 2 situations when btrfs is broken to flip readonly:
	 *
	 * 1. when btrfs flips readonly somewhere else before
	 * btrfs_commit_super, sb->s_flags has MS_RDONLY flag,
	 * and btrfs will skip to write sb directly to keep
	 * ERROR state on disk.
	 *
	 * 2. when btrfs flips readonly just in btrfs_commit_super,
2534
	 * and in such case, btrfs cannot write sb via btrfs_commit_super,
L
liubo 已提交
2535 2536 2537
	 * and since fs_state has been set BTRFS_SUPER_FLAG_ERROR flag,
	 * btrfs will cleanup all FS resources first and write sb then.
	 */
Y
Yan Zheng 已提交
2538
	if (!(fs_info->sb->s_flags & MS_RDONLY)) {
L
liubo 已提交
2539 2540 2541 2542 2543 2544 2545
		ret = btrfs_commit_super(root);
		if (ret)
			printk(KERN_ERR "btrfs: commit super ret %d\n", ret);
	}

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

2550 2551 2552
	kthread_stop(root->fs_info->transaction_kthread);
	kthread_stop(root->fs_info->cleaner_kthread);

2553 2554 2555
	fs_info->closing = 2;
	smp_mb();

C
Chris Mason 已提交
2556
	if (fs_info->delalloc_bytes) {
C
Chris Mason 已提交
2557
		printk(KERN_INFO "btrfs: at unmount delalloc count %llu\n",
2558
		       (unsigned long long)fs_info->delalloc_bytes);
C
Chris Mason 已提交
2559
	}
Y
Yan Zheng 已提交
2560
	if (fs_info->total_ref_cache_size) {
C
Chris Mason 已提交
2561 2562
		printk(KERN_INFO "btrfs: at umount reference cache size %llu\n",
		       (unsigned long long)fs_info->total_ref_cache_size);
Y
Yan Zheng 已提交
2563
	}
2564

2565 2566 2567 2568 2569 2570 2571 2572 2573 2574
	free_extent_buffer(fs_info->extent_root->node);
	free_extent_buffer(fs_info->extent_root->commit_root);
	free_extent_buffer(fs_info->tree_root->node);
	free_extent_buffer(fs_info->tree_root->commit_root);
	free_extent_buffer(root->fs_info->chunk_root->node);
	free_extent_buffer(root->fs_info->chunk_root->commit_root);
	free_extent_buffer(root->fs_info->dev_root->node);
	free_extent_buffer(root->fs_info->dev_root->commit_root);
	free_extent_buffer(root->fs_info->csum_root->node);
	free_extent_buffer(root->fs_info->csum_root->commit_root);
2575

C
Chris Mason 已提交
2576
	btrfs_free_block_groups(root->fs_info);
2577

Y
Yan Zheng 已提交
2578
	del_fs_roots(fs_info);
2579

Y
Yan Zheng 已提交
2580
	iput(fs_info->btree_inode);
2581

2582
	btrfs_stop_workers(&fs_info->generic_worker);
2583
	btrfs_stop_workers(&fs_info->fixup_workers);
2584
	btrfs_stop_workers(&fs_info->delalloc_workers);
2585 2586
	btrfs_stop_workers(&fs_info->workers);
	btrfs_stop_workers(&fs_info->endio_workers);
2587
	btrfs_stop_workers(&fs_info->endio_meta_workers);
2588
	btrfs_stop_workers(&fs_info->endio_meta_write_workers);
2589
	btrfs_stop_workers(&fs_info->endio_write_workers);
J
Josef Bacik 已提交
2590
	btrfs_stop_workers(&fs_info->endio_freespace_worker);
2591
	btrfs_stop_workers(&fs_info->submit_workers);
2592

2593
	btrfs_close_devices(fs_info->fs_devices);
2594
	btrfs_mapping_tree_free(&fs_info->mapping_tree);
2595

C
Chris Mason 已提交
2596
	bdi_destroy(&fs_info->bdi);
2597
	cleanup_srcu_struct(&fs_info->subvol_srcu);
2598

2599 2600
	kfree(fs_info->extent_root);
	kfree(fs_info->tree_root);
2601 2602
	kfree(fs_info->chunk_root);
	kfree(fs_info->dev_root);
2603
	kfree(fs_info->csum_root);
L
Li Zefan 已提交
2604 2605
	kfree(fs_info);

2606 2607 2608
	return 0;
}

2609
int btrfs_buffer_uptodate(struct extent_buffer *buf, u64 parent_transid)
2610
{
2611
	int ret;
2612
	struct inode *btree_inode = buf->first_page->mapping->host;
2613

2614 2615
	ret = extent_buffer_uptodate(&BTRFS_I(btree_inode)->io_tree, buf,
				     NULL);
2616 2617 2618 2619 2620 2621
	if (!ret)
		return ret;

	ret = verify_parent_transid(&BTRFS_I(btree_inode)->io_tree, buf,
				    parent_transid);
	return !ret;
2622 2623 2624
}

int btrfs_set_buffer_uptodate(struct extent_buffer *buf)
C
Chris Mason 已提交
2625
{
2626
	struct inode *btree_inode = buf->first_page->mapping->host;
2627
	return set_extent_buffer_uptodate(&BTRFS_I(btree_inode)->io_tree,
2628 2629
					  buf);
}
2630

2631 2632
void btrfs_mark_buffer_dirty(struct extent_buffer *buf)
{
2633
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
2634 2635
	u64 transid = btrfs_header_generation(buf);
	struct inode *btree_inode = root->fs_info->btree_inode;
2636
	int was_dirty;
2637

2638
	btrfs_assert_tree_locked(buf);
C
Chris Mason 已提交
2639
	if (transid != root->fs_info->generation) {
C
Chris Mason 已提交
2640 2641
		printk(KERN_CRIT "btrfs transid mismatch buffer %llu, "
		       "found %llu running %llu\n",
2642
			(unsigned long long)buf->start,
C
Chris Mason 已提交
2643 2644
			(unsigned long long)transid,
			(unsigned long long)root->fs_info->generation);
C
Chris Mason 已提交
2645 2646
		WARN_ON(1);
	}
2647 2648 2649 2650 2651 2652 2653
	was_dirty = set_extent_buffer_dirty(&BTRFS_I(btree_inode)->io_tree,
					    buf);
	if (!was_dirty) {
		spin_lock(&root->fs_info->delalloc_lock);
		root->fs_info->dirty_metadata_bytes += buf->len;
		spin_unlock(&root->fs_info->delalloc_lock);
	}
2654 2655
}

2656
void btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr)
C
Chris Mason 已提交
2657
{
2658 2659 2660 2661
	/*
	 * looks as though older kernels can get into trouble with
	 * this code, they end up stuck in balance_dirty_pages forever
	 */
2662
	u64 num_dirty;
2663
	unsigned long thresh = 32 * 1024 * 1024;
2664

2665
	if (current->flags & PF_MEMALLOC)
2666 2667
		return;

2668 2669
	num_dirty = root->fs_info->dirty_metadata_bytes;

2670 2671
	if (num_dirty > thresh) {
		balance_dirty_pages_ratelimited_nr(
C
Chris Mason 已提交
2672
				   root->fs_info->btree_inode->i_mapping, 1);
2673
	}
2674
	return;
C
Chris Mason 已提交
2675
}
2676

2677
int btrfs_read_buffer(struct extent_buffer *buf, u64 parent_transid)
2678
{
2679
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
2680
	int ret;
2681
	ret = btree_read_extent_buffer_pages(root, buf, 0, parent_transid);
C
Chris Mason 已提交
2682
	if (ret == 0)
2683
		set_bit(EXTENT_BUFFER_UPTODATE, &buf->bflags);
2684
	return ret;
2685
}
2686

C
Chris Mason 已提交
2687 2688 2689
int btree_lock_page_hook(struct page *page)
{
	struct inode *inode = page->mapping->host;
2690
	struct btrfs_root *root = BTRFS_I(inode)->root;
C
Chris Mason 已提交
2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
	struct extent_buffer *eb;
	unsigned long len;
	u64 bytenr = page_offset(page);

	if (page->private == EXTENT_PAGE_PRIVATE)
		goto out;

	len = page->private >> 2;
	eb = find_extent_buffer(io_tree, bytenr, len, GFP_NOFS);
	if (!eb)
		goto out;

	btrfs_tree_lock(eb);
	btrfs_set_header_flag(eb, BTRFS_HEADER_FLAG_WRITTEN);
2706 2707 2708 2709 2710 2711 2712 2713 2714 2715

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

C
Chris Mason 已提交
2716 2717 2718 2719 2720 2721 2722
	btrfs_tree_unlock(eb);
	free_extent_buffer(eb);
out:
	lock_page(page);
	return 0;
}

L
liubo 已提交
2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826
static void btrfs_check_super_valid(struct btrfs_fs_info *fs_info,
			      int read_only)
{
	if (read_only)
		return;

	if (fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR)
		printk(KERN_WARNING "warning: mount fs with errors, "
		       "running btrfsck is recommended\n");
}

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

	mutex_lock(&root->fs_info->cleaner_mutex);
	btrfs_run_delayed_iputs(root);
	mutex_unlock(&root->fs_info->cleaner_mutex);

	down_write(&root->fs_info->cleanup_work_sem);
	up_write(&root->fs_info->cleanup_work_sem);

	/* cleanup FS via transaction */
	btrfs_cleanup_transaction(root);

	ret = write_ctree_super(NULL, root, 0);

	return ret;
}

static int btrfs_destroy_ordered_operations(struct btrfs_root *root)
{
	struct btrfs_inode *btrfs_inode;
	struct list_head splice;

	INIT_LIST_HEAD(&splice);

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

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

		list_del_init(&btrfs_inode->ordered_operations);

		btrfs_invalidate_inodes(btrfs_inode->root);
	}

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

	return 0;
}

static int btrfs_destroy_ordered_extents(struct btrfs_root *root)
{
	struct list_head splice;
	struct btrfs_ordered_extent *ordered;
	struct inode *inode;

	INIT_LIST_HEAD(&splice);

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

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

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

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

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

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

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

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

	return 0;
}

static int btrfs_destroy_delayed_refs(struct btrfs_transaction *trans,
				      struct btrfs_root *root)
{
	struct rb_node *node;
	struct btrfs_delayed_ref_root *delayed_refs;
	struct btrfs_delayed_ref_node *ref;
	int ret = 0;

	delayed_refs = &trans->delayed_refs;

	spin_lock(&delayed_refs->lock);
	if (delayed_refs->num_entries == 0) {
2827
		spin_unlock(&delayed_refs->lock);
L
liubo 已提交
2828 2829 2830 2831 2832 2833 2834 2835 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 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988
		printk(KERN_INFO "delayed_refs has NO entry\n");
		return ret;
	}

	node = rb_first(&delayed_refs->root);
	while (node) {
		ref = rb_entry(node, struct btrfs_delayed_ref_node, rb_node);
		node = rb_next(node);

		ref->in_tree = 0;
		rb_erase(&ref->rb_node, &delayed_refs->root);
		delayed_refs->num_entries--;

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

			head = btrfs_delayed_node_to_head(ref);
			mutex_lock(&head->mutex);
			kfree(head->extent_op);
			delayed_refs->num_heads--;
			if (list_empty(&head->cluster))
				delayed_refs->num_heads_ready--;
			list_del_init(&head->cluster);
			mutex_unlock(&head->mutex);
		}

		spin_unlock(&delayed_refs->lock);
		btrfs_put_delayed_ref(ref);

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

	spin_unlock(&delayed_refs->lock);

	return ret;
}

static int btrfs_destroy_pending_snapshots(struct btrfs_transaction *t)
{
	struct btrfs_pending_snapshot *snapshot;
	struct list_head splice;

	INIT_LIST_HEAD(&splice);

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

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

		list_del_init(&snapshot->list);

		kfree(snapshot);
	}

	return 0;
}

static int btrfs_destroy_delalloc_inodes(struct btrfs_root *root)
{
	struct btrfs_inode *btrfs_inode;
	struct list_head splice;

	INIT_LIST_HEAD(&splice);

	list_splice_init(&root->fs_info->delalloc_inodes, &splice);

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

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

		list_del_init(&btrfs_inode->delalloc_inodes);

		btrfs_invalidate_inodes(btrfs_inode->root);
	}

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

	return 0;
}

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

	while (1) {
		ret = find_first_extent_bit(dirty_pages, start, &start, &end,
					    mark);
		if (ret)
			break;

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

			spin_lock(&dirty_pages->buffer_lock);
			eb = radix_tree_lookup(
			     &(&BTRFS_I(page->mapping->host)->io_tree)->buffer,
					       offset >> PAGE_CACHE_SHIFT);
			spin_unlock(&dirty_pages->buffer_lock);
			if (eb) {
				ret = test_and_clear_bit(EXTENT_BUFFER_DIRTY,
							 &eb->bflags);
				atomic_set(&eb->refs, 1);
			}
			if (PageWriteback(page))
				end_page_writeback(page);

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

			page->mapping->a_ops->invalidatepage(page, 0);
			unlock_page(page);
		}
	}

	return ret;
}

static int btrfs_destroy_pinned_extent(struct btrfs_root *root,
				       struct extent_io_tree *pinned_extents)
{
	struct extent_io_tree *unpin;
	u64 start;
	u64 end;
	int ret;

	unpin = pinned_extents;
	while (1) {
		ret = find_first_extent_bit(unpin, 0, &start, &end,
					    EXTENT_DIRTY);
		if (ret)
			break;

		/* opt_discard */
2989 2990 2991 2992
		if (btrfs_test_opt(root, DISCARD))
			ret = btrfs_error_discard_extent(root, start,
							 end + 1 - start,
							 NULL);
L
liubo 已提交
2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060

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

	return 0;
}

static int btrfs_cleanup_transaction(struct btrfs_root *root)
{
	struct btrfs_transaction *t;
	LIST_HEAD(list);

	WARN_ON(1);

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

	list_splice_init(&root->fs_info->trans_list, &list);
	while (!list_empty(&list)) {
		t = list_entry(list.next, struct btrfs_transaction, list);
		if (!t)
			break;

		btrfs_destroy_ordered_operations(root);

		btrfs_destroy_ordered_extents(root);

		btrfs_destroy_delayed_refs(t, root);

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

		/* FIXME: cleanup wait for commit */
		t->in_commit = 1;
		t->blocked = 1;
		if (waitqueue_active(&root->fs_info->transaction_blocked_wait))
			wake_up(&root->fs_info->transaction_blocked_wait);

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

		mutex_lock(&root->fs_info->trans_mutex);
		t->commit_done = 1;
		if (waitqueue_active(&t->commit_wait))
			wake_up(&t->commit_wait);
		mutex_unlock(&root->fs_info->trans_mutex);

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

		btrfs_destroy_pending_snapshots(t);

		btrfs_destroy_delalloc_inodes(root);

		spin_lock(&root->fs_info->new_trans_lock);
		root->fs_info->running_transaction = NULL;
		spin_unlock(&root->fs_info->new_trans_lock);

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

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

3061
		atomic_set(&t->use_count, 0);
L
liubo 已提交
3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072
		list_del_init(&t->list);
		memset(t, 0, sizeof(*t));
		kmem_cache_free(btrfs_transaction_cachep, t);
	}

	mutex_unlock(&root->fs_info->transaction_kthread_mutex);
	mutex_unlock(&root->fs_info->trans_mutex);

	return 0;
}

3073
static struct extent_io_ops btree_extent_io_ops = {
C
Chris Mason 已提交
3074
	.write_cache_pages_lock_hook = btree_lock_page_hook,
3075
	.readpage_end_io_hook = btree_readpage_end_io_hook,
3076
	.submit_bio_hook = btree_submit_bio_hook,
3077 3078
	/* note we're sharing with inode.c for the merge bio hook */
	.merge_bio_hook = btrfs_merge_bio_hook,
3079
};