disk-io.c 82.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 <linux/ratelimit.h>
33
#include <asm/unaligned.h>
C
Chris Mason 已提交
34
#include "compat.h"
35 36
#include "ctree.h"
#include "disk-io.h"
37
#include "transaction.h"
38
#include "btrfs_inode.h"
39
#include "volumes.h"
40
#include "print-tree.h"
41
#include "async-thread.h"
42
#include "locking.h"
43
#include "tree-log.h"
44
#include "free-space-cache.h"
45
#include "inode-map.h"
46

47
static struct extent_io_ops btree_extent_io_ops;
48
static void end_workqueue_fn(struct btrfs_work *work);
49
static void free_fs_root(struct btrfs_root *root);
L
liubo 已提交
50 51 52 53 54 55 56 57 58 59 60 61 62 63
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);
64

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

C
Chris Mason 已提交
81 82 83 84 85
/*
 * 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.
 */
86 87 88 89
struct async_submit_bio {
	struct inode *inode;
	struct bio *bio;
	struct list_head list;
C
Chris Mason 已提交
90 91
	extent_submit_bio_hook_t *submit_bio_start;
	extent_submit_bio_hook_t *submit_bio_done;
92 93
	int rw;
	int mirror_num;
C
Chris Mason 已提交
94
	unsigned long bio_flags;
95 96 97 98 99
	/*
	 * 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;
100
	struct btrfs_work work;
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 135 136
/* 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 已提交
137 138 139 140
/*
 * extents on the btree inode are pretty simple, there's one extent
 * that covers the entire device
 */
141
static struct extent_map *btree_get_extent(struct inode *inode,
142
		struct page *page, size_t pg_offset, u64 start, u64 len,
143
		int create)
144
{
145 146 147 148
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
	struct extent_map *em;
	int ret;

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

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

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

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

	if (ret)
		em = ERR_PTR(ret);
193 194
out:
	return em;
195 196
}

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

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

C
Chris Mason 已提交
207 208 209 210
/*
 * compute the csum for a btree block, and either verify it or write it
 * into the csum field of the block.
 */
211 212 213
static int csum_tree_block(struct btrfs_root *root, struct extent_buffer *buf,
			   int verify)
{
214 215 216
	u16 csum_size =
		btrfs_super_csum_size(&root->fs_info->super_copy);
	char *result = NULL;
217 218 219 220 221 222 223 224 225
	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;
226
	unsigned long inline_result;
227 228

	len = buf->len - offset;
C
Chris Mason 已提交
229
	while (len > 0) {
230 231 232
		err = map_private_extent_buffer(buf, offset, 32,
					&map_token, &kaddr,
					&map_start, &map_len, KM_USER0);
C
Chris Mason 已提交
233
		if (err)
234 235 236 237 238 239 240 241
			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);
	}
242 243 244 245 246 247 248 249
	if (csum_size > sizeof(inline_result)) {
		result = kzalloc(csum_size * sizeof(char), GFP_NOFS);
		if (!result)
			return 1;
	} else {
		result = (char *)&inline_result;
	}

250 251 252
	btrfs_csum_final(crc, result);

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

258
			read_extent_buffer(buf, &val, 0, csum_size);
259
			printk_ratelimited(KERN_INFO "btrfs: %s checksum verify "
C
Chris Mason 已提交
260 261 262 263 264
				       "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;
	}
299
	printk_ratelimited("parent transid verify failed on %llu wanted %llu "
C
Chris Mason 已提交
300 301 302 303
		       "found %llu\n",
		       (unsigned long long)eb->start,
		       (unsigned long long)parent_transid,
		       (unsigned long long)btrfs_header_generation(eb));
304
	ret = 1;
305
	clear_extent_buffer_uptodate(io_tree, eb, &cached_state);
C
Chris Mason 已提交
306
out:
307 308
	unlock_extent_cached(io_tree, eb->start, eb->start + eb->len - 1,
			     &cached_state, GFP_NOFS);
309 310 311
	return ret;
}

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

325
	clear_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags);
326 327 328 329
	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);
330 331
		if (!ret &&
		    !verify_parent_transid(io_tree, eb, parent_transid))
332
			return ret;
C
Chris Mason 已提交
333

334 335 336 337 338 339 340 341
		/*
		 * 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;

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

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

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

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

368
	tree = &BTRFS_I(page->mapping->host)->io_tree;
369

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

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

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

Y
Yan Zheng 已提交
411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429
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;
}

430 431 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
#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;
}

497 498 499 500 501 502 503 504 505
#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

506
static int btree_readpage_end_io_hook(struct page *page, u64 start, u64 end,
507 508 509 510 511 512 513 514
			       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;
515
	int ret = 0;
516 517 518 519 520 521

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

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

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

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

556 557
	btrfs_set_buffer_lockdep_class(eb, found_level);

558
	ret = csum_tree_block(root, eb, 1);
559
	if (ret) {
560
		ret = -EIO;
561 562 563 564 565 566 567 568 569 570 571 572
		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;
	}
573 574 575 576 577 578

	end = min_t(u64, eb->len, PAGE_CACHE_SIZE);
	end = eb->start + end - 1;
err:
	free_extent_buffer(eb);
out:
579
	return ret;
580 581 582 583 584 585 586 587 588
}

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;
589 590
	end_io_wq->work.func = end_workqueue_fn;
	end_io_wq->work.flags = 0;
591

592
	if (bio->bi_rw & REQ_WRITE) {
J
Josef Bacik 已提交
593
		if (end_io_wq->metadata == 1)
594 595
			btrfs_queue_worker(&fs_info->endio_meta_write_workers,
					   &end_io_wq->work);
J
Josef Bacik 已提交
596 597 598
		else if (end_io_wq->metadata == 2)
			btrfs_queue_worker(&fs_info->endio_freespace_worker,
					   &end_io_wq->work);
599 600 601
		else
			btrfs_queue_worker(&fs_info->endio_write_workers,
					   &end_io_wq->work);
602 603 604 605 606 607 608 609
	} 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);
	}
610 611
}

J
Josef Bacik 已提交
612 613 614 615 616 617 618
/*
 * For the metadata arg you want
 *
 * 0 - if data
 * 1 - if normal metadta
 * 2 - if writing to the free space cache area
 */
619 620
int btrfs_bio_wq_end_io(struct btrfs_fs_info *info, struct bio *bio,
			int metadata)
621
{
622 623 624 625 626 627 628
	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;
629
	end_io_wq->info = info;
630 631
	end_io_wq->error = 0;
	end_io_wq->bio = bio;
632
	end_io_wq->metadata = metadata;
633 634 635

	bio->bi_private = end_io_wq;
	bio->bi_end_io = end_workqueue_bio;
636 637 638
	return 0;
}

639
unsigned long btrfs_async_submit_limit(struct btrfs_fs_info *info)
640
{
641 642 643 644 645
	unsigned long limit = min_t(unsigned long,
				    info->workers.max_workers,
				    info->fs_devices->open_devices);
	return 256 * limit;
}
646

C
Chris Mason 已提交
647 648 649 650 651 652
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,
653 654
			       async->mirror_num, async->bio_flags,
			       async->bio_offset);
C
Chris Mason 已提交
655 656 657
}

static void run_one_async_done(struct btrfs_work *work)
658 659 660
{
	struct btrfs_fs_info *fs_info;
	struct async_submit_bio *async;
661
	int limit;
662 663 664

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

666
	limit = btrfs_async_submit_limit(fs_info);
667 668
	limit = limit * 2 / 3;

669
	atomic_dec(&fs_info->nr_async_submits);
670

671 672
	if (atomic_read(&fs_info->nr_async_submits) < limit &&
	    waitqueue_active(&fs_info->async_submit_wait))
673 674
		wake_up(&fs_info->async_submit_wait);

C
Chris Mason 已提交
675
	async->submit_bio_done(async->inode, async->rw, async->bio,
676 677
			       async->mirror_num, async->bio_flags,
			       async->bio_offset);
C
Chris Mason 已提交
678 679 680 681 682 683 684
}

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

	async = container_of(work, struct  async_submit_bio, work);
685 686 687
	kfree(async);
}

688 689
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 已提交
690
			unsigned long bio_flags,
691
			u64 bio_offset,
C
Chris Mason 已提交
692 693
			extent_submit_bio_hook_t *submit_bio_start,
			extent_submit_bio_hook_t *submit_bio_done)
694 695 696 697 698 699 700 701 702 703 704
{
	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 已提交
705 706 707 708 709 710 711
	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;

712
	async->work.flags = 0;
C
Chris Mason 已提交
713
	async->bio_flags = bio_flags;
714
	async->bio_offset = bio_offset;
715

716
	atomic_inc(&fs_info->nr_async_submits);
717

718
	if (rw & REQ_SYNC)
719 720
		btrfs_set_work_high_prio(&async->work);

721
	btrfs_queue_worker(&fs_info->workers, &async->work);
722

C
Chris Mason 已提交
723
	while (atomic_read(&fs_info->async_submit_draining) &&
724 725 726 727 728
	      atomic_read(&fs_info->nr_async_submits)) {
		wait_event(fs_info->async_submit_wait,
			   (atomic_read(&fs_info->nr_async_submits) == 0));
	}

729 730 731
	return 0;
}

732 733 734 735 736 737 738
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 已提交
739
	while (bio_index < bio->bi_vcnt) {
740 741 742 743 744 745 746 747
		root = BTRFS_I(bvec->bv_page->mapping->host)->root;
		csum_dirty_buffer(root, bvec->bv_page);
		bio_index++;
		bvec++;
	}
	return 0;
}

C
Chris Mason 已提交
748 749
static int __btree_submit_bio_start(struct inode *inode, int rw,
				    struct bio *bio, int mirror_num,
750 751
				    unsigned long bio_flags,
				    u64 bio_offset)
752
{
753 754
	/*
	 * when we're called for a write, we're already in the async
755
	 * submission context.  Just jump into btrfs_map_bio
756
	 */
C
Chris Mason 已提交
757 758 759
	btree_csum_one_bio(bio);
	return 0;
}
760

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

772
static int btree_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
773 774
				 int mirror_num, unsigned long bio_flags,
				 u64 bio_offset)
775
{
776 777 778 779 780 781
	int ret;

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

782
	if (!(rw & REQ_WRITE)) {
C
Chris Mason 已提交
783 784 785 786 787
		/*
		 * 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,
788
				     mirror_num, 0);
789
	}
790

791 792 793 794
	/*
	 * kthread helpers are used to submit writes so that checksumming
	 * can happen in parallel across all CPUs
	 */
795
	return btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,
C
Chris Mason 已提交
796
				   inode, rw, bio, mirror_num, 0,
797
				   bio_offset,
C
Chris Mason 已提交
798 799
				   __btree_submit_bio_start,
				   __btree_submit_bio_done);
800 801
}

J
Jan Beulich 已提交
802
#ifdef CONFIG_MIGRATION
803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820
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 已提交
821
#endif
822

823 824
static int btree_writepage(struct page *page, struct writeback_control *wbc)
{
825
	struct extent_io_tree *tree;
826 827 828 829
	struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
	struct extent_buffer *eb;
	int was_dirty;

830
	tree = &BTRFS_I(page->mapping->host)->io_tree;
831 832 833 834
	if (!(current->flags & PF_MEMALLOC)) {
		return extent_write_full_page(tree, page,
					      btree_get_extent, wbc);
	}
835

836
	redirty_page_for_writepage(wbc, page);
837
	eb = btrfs_find_tree_block(root, page_offset(page), PAGE_CACHE_SIZE);
838 839 840 841 842 843 844
	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);
845
	}
846 847 848 849
	free_extent_buffer(eb);

	unlock_page(page);
	return 0;
850
}
851 852 853 854

static int btree_writepages(struct address_space *mapping,
			    struct writeback_control *wbc)
{
855 856
	struct extent_io_tree *tree;
	tree = &BTRFS_I(mapping->host)->io_tree;
857
	if (wbc->sync_mode == WB_SYNC_NONE) {
858
		struct btrfs_root *root = BTRFS_I(mapping->host)->root;
859
		u64 num_dirty;
860
		unsigned long thresh = 32 * 1024 * 1024;
861 862 863 864

		if (wbc->for_kupdate)
			return 0;

865 866
		/* this is a bit racy, but that's ok */
		num_dirty = root->fs_info->dirty_metadata_bytes;
C
Chris Mason 已提交
867
		if (num_dirty < thresh)
868 869
			return 0;
	}
870 871 872
	return extent_writepages(tree, mapping, btree_get_extent, wbc);
}

873
static int btree_readpage(struct file *file, struct page *page)
874
{
875 876
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
877 878
	return extent_read_full_page(tree, page, btree_get_extent);
}
C
Chris Mason 已提交
879

880
static int btree_releasepage(struct page *page, gfp_t gfp_flags)
881
{
882 883
	struct extent_io_tree *tree;
	struct extent_map_tree *map;
884
	int ret;
885

886
	if (PageWriteback(page) || PageDirty(page))
C
Chris Mason 已提交
887
		return 0;
888

889 890
	tree = &BTRFS_I(page->mapping->host)->io_tree;
	map = &BTRFS_I(page->mapping->host)->extent_tree;
891

892
	ret = try_release_extent_state(map, tree, page, gfp_flags);
C
Chris Mason 已提交
893
	if (!ret)
894 895 896
		return 0;

	ret = try_release_extent_buffer(tree, page);
897 898 899 900 901
	if (ret == 1) {
		ClearPagePrivate(page);
		set_page_private(page, 0);
		page_cache_release(page);
	}
902

903 904 905
	return ret;
}

906
static void btree_invalidatepage(struct page *page, unsigned long offset)
907
{
908 909
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
910 911
	extent_invalidatepage(tree, page, offset);
	btree_releasepage(page, GFP_NOFS);
912
	if (PagePrivate(page)) {
C
Chris Mason 已提交
913 914
		printk(KERN_WARNING "btrfs warning page private not zero "
		       "on page %llu\n", (unsigned long long)page_offset(page));
915 916 917 918
		ClearPagePrivate(page);
		set_page_private(page, 0);
		page_cache_release(page);
	}
919 920
}

921
static const struct address_space_operations btree_aops = {
922 923
	.readpage	= btree_readpage,
	.writepage	= btree_writepage,
924
	.writepages	= btree_writepages,
925 926
	.releasepage	= btree_releasepage,
	.invalidatepage = btree_invalidatepage,
927
#ifdef CONFIG_MIGRATION
928
	.migratepage	= btree_migratepage,
929
#endif
930 931
};

932 933
int readahead_tree_block(struct btrfs_root *root, u64 bytenr, u32 blocksize,
			 u64 parent_transid)
C
Chris Mason 已提交
934
{
935 936
	struct extent_buffer *buf = NULL;
	struct inode *btree_inode = root->fs_info->btree_inode;
937
	int ret = 0;
C
Chris Mason 已提交
938

939
	buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
940
	if (!buf)
C
Chris Mason 已提交
941
		return 0;
942
	read_extent_buffer_pages(&BTRFS_I(btree_inode)->io_tree,
943
				 buf, 0, 0, btree_get_extent, 0);
944
	free_extent_buffer(buf);
945
	return ret;
C
Chris Mason 已提交
946 947
}

948 949 950 951 952 953
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,
954
				bytenr, blocksize);
955 956 957 958 959 960 961 962 963 964
	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,
965
				 bytenr, blocksize, NULL);
966 967 968 969
	return eb;
}


970 971
int btrfs_write_tree_block(struct extent_buffer *buf)
{
972 973
	return filemap_fdatawrite_range(buf->first_page->mapping, buf->start,
					buf->start + buf->len - 1);
974 975 976 977
}

int btrfs_wait_tree_block_writeback(struct extent_buffer *buf)
{
978 979
	return filemap_fdatawait_range(buf->first_page->mapping,
				       buf->start, buf->start + buf->len - 1);
980 981
}

982
struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 bytenr,
983
				      u32 blocksize, u64 parent_transid)
984 985 986 987 988 989 990 991
{
	struct extent_buffer *buf = NULL;
	int ret;

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

992
	ret = btree_read_extent_buffer_pages(root, buf, 0, parent_transid);
993

C
Chris Mason 已提交
994
	if (ret == 0)
995
		set_bit(EXTENT_BUFFER_UPTODATE, &buf->bflags);
996
	return buf;
997

998 999
}

1000
int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
1001
		     struct extent_buffer *buf)
1002
{
1003
	struct inode *btree_inode = root->fs_info->btree_inode;
1004
	if (btrfs_header_generation(buf) ==
1005
	    root->fs_info->running_transaction->transid) {
1006
		btrfs_assert_tree_locked(buf);
1007

1008 1009 1010 1011 1012 1013 1014 1015
		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);
		}
1016

1017 1018
		/* ugh, clear_extent_buffer_dirty needs to lock the page */
		btrfs_set_lock_blocking(buf);
1019
		clear_extent_buffer_dirty(&BTRFS_I(btree_inode)->io_tree,
1020
					  buf);
1021
	}
1022 1023 1024
	return 0;
}

1025
static int __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize,
1026
			u32 stripesize, struct btrfs_root *root,
1027
			struct btrfs_fs_info *fs_info,
C
Chris Mason 已提交
1028
			u64 objectid)
1029
{
C
Chris Mason 已提交
1030
	root->node = NULL;
1031
	root->commit_root = NULL;
1032 1033 1034
	root->sectorsize = sectorsize;
	root->nodesize = nodesize;
	root->leafsize = leafsize;
1035
	root->stripesize = stripesize;
C
Chris Mason 已提交
1036
	root->ref_cows = 0;
1037
	root->track_dirty = 0;
1038
	root->in_radix = 0;
1039 1040
	root->orphan_item_inserted = 0;
	root->orphan_cleanup_state = 0;
1041

1042
	root->fs_info = fs_info;
1043 1044
	root->objectid = objectid;
	root->last_trans = 0;
1045
	root->highest_objectid = 0;
1046
	root->name = NULL;
1047
	root->inode_tree = RB_ROOT;
1048
	INIT_RADIX_TREE(&root->delayed_nodes_tree, GFP_ATOMIC);
1049
	root->block_rsv = NULL;
1050
	root->orphan_block_rsv = NULL;
1051 1052

	INIT_LIST_HEAD(&root->dirty_list);
1053
	INIT_LIST_HEAD(&root->orphan_list);
1054
	INIT_LIST_HEAD(&root->root_list);
1055
	spin_lock_init(&root->orphan_lock);
1056
	spin_lock_init(&root->inode_lock);
1057
	spin_lock_init(&root->accounting_lock);
1058
	mutex_init(&root->objectid_mutex);
1059
	mutex_init(&root->log_mutex);
Y
Yan Zheng 已提交
1060 1061 1062 1063 1064 1065 1066 1067
	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;
1068
	root->last_log_commit = 0;
1069
	extent_io_tree_init(&root->dirty_log_pages,
1070
			     fs_info->btree_inode->i_mapping);
C
Chris Mason 已提交
1071

1072 1073
	memset(&root->root_key, 0, sizeof(root->root_key));
	memset(&root->root_item, 0, sizeof(root->root_item));
1074
	memset(&root->defrag_progress, 0, sizeof(root->defrag_progress));
1075
	memset(&root->root_kobj, 0, sizeof(root->root_kobj));
1076
	root->defrag_trans_start = fs_info->generation;
1077
	init_completion(&root->kobj_unregister);
1078
	root->defrag_running = 0;
1079
	root->root_key.objectid = objectid;
1080 1081 1082 1083 1084 1085
	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);

1086 1087 1088
	return 0;
}

1089
static int find_and_setup_root(struct btrfs_root *tree_root,
1090 1091
			       struct btrfs_fs_info *fs_info,
			       u64 objectid,
C
Chris Mason 已提交
1092
			       struct btrfs_root *root)
1093 1094
{
	int ret;
1095
	u32 blocksize;
1096
	u64 generation;
1097

1098
	__setup_root(tree_root->nodesize, tree_root->leafsize,
1099 1100
		     tree_root->sectorsize, tree_root->stripesize,
		     root, fs_info, objectid);
1101 1102
	ret = btrfs_find_last_root(tree_root, objectid,
				   &root->root_item, &root->root_key);
1103 1104
	if (ret > 0)
		return -ENOENT;
1105 1106
	BUG_ON(ret);

1107
	generation = btrfs_root_generation(&root->root_item);
1108 1109
	blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
	root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
1110
				     blocksize, generation);
1111 1112 1113 1114
	if (!root->node || !btrfs_buffer_uptodate(root->node, generation)) {
		free_extent_buffer(root->node);
		return -EIO;
	}
1115
	root->commit_root = btrfs_root_node(root);
1116 1117 1118
	return 0;
}

Y
Yan Zheng 已提交
1119 1120
static struct btrfs_root *alloc_log_tree(struct btrfs_trans_handle *trans,
					 struct btrfs_fs_info *fs_info)
1121 1122 1123
{
	struct btrfs_root *root;
	struct btrfs_root *tree_root = fs_info->tree_root;
Y
Yan Zheng 已提交
1124
	struct extent_buffer *leaf;
1125 1126 1127

	root = kzalloc(sizeof(*root), GFP_NOFS);
	if (!root)
Y
Yan Zheng 已提交
1128
		return ERR_PTR(-ENOMEM);
1129 1130 1131 1132 1133 1134 1135 1136

	__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 已提交
1137 1138 1139 1140 1141 1142
	/*
	 * 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).
	 */
1143 1144
	root->ref_cows = 0;

1145 1146
	leaf = btrfs_alloc_free_block(trans, root, root->leafsize, 0,
				      BTRFS_TREE_LOG_OBJECTID, NULL, 0, 0, 0);
Y
Yan Zheng 已提交
1147 1148 1149 1150
	if (IS_ERR(leaf)) {
		kfree(root);
		return ERR_CAST(leaf);
	}
1151

1152 1153 1154 1155 1156
	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 已提交
1157
	root->node = leaf;
1158 1159 1160 1161 1162 1163

	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 已提交
1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199
	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);

1200
	btrfs_set_root_node(&log_root->root_item, log_root->node);
Y
Yan Zheng 已提交
1201 1202 1203 1204

	WARN_ON(root->log_root);
	root->log_root = log_root;
	root->log_transid = 0;
1205
	root->last_log_commit = 0;
1206 1207 1208 1209 1210 1211 1212 1213
	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;
1214
	struct btrfs_path *path;
1215
	struct extent_buffer *l;
1216
	u64 generation;
1217
	u32 blocksize;
1218 1219
	int ret = 0;

1220
	root = kzalloc(sizeof(*root), GFP_NOFS);
C
Chris Mason 已提交
1221
	if (!root)
1222 1223
		return ERR_PTR(-ENOMEM);
	if (location->offset == (u64)-1) {
1224
		ret = find_and_setup_root(tree_root, fs_info,
1225 1226 1227 1228 1229
					  location->objectid, root);
		if (ret) {
			kfree(root);
			return ERR_PTR(ret);
		}
1230
		goto out;
1231 1232
	}

1233
	__setup_root(tree_root->nodesize, tree_root->leafsize,
1234 1235
		     tree_root->sectorsize, tree_root->stripesize,
		     root, fs_info, location->objectid);
1236 1237

	path = btrfs_alloc_path();
T
Tsutomu Itoh 已提交
1238 1239 1240 1241
	if (!path) {
		kfree(root);
		return ERR_PTR(-ENOMEM);
	}
1242
	ret = btrfs_search_slot(NULL, tree_root, location, path, 0, 0);
1243 1244 1245 1246 1247 1248
	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));
1249 1250 1251
	}
	btrfs_free_path(path);
	if (ret) {
1252
		kfree(root);
1253 1254
		if (ret > 0)
			ret = -ENOENT;
1255 1256
		return ERR_PTR(ret);
	}
1257

1258
	generation = btrfs_root_generation(&root->root_item);
1259 1260
	blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
	root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
1261
				     blocksize, generation);
1262
	root->commit_root = btrfs_root_node(root);
1263
	BUG_ON(!root->node);
1264
out:
1265
	if (location->objectid != BTRFS_TREE_LOG_OBJECTID) {
1266
		root->ref_cows = 1;
1267 1268
		btrfs_check_and_init_root_item(&root->root_item);
	}
1269

1270 1271 1272
	return root;
}

1273 1274
struct btrfs_root *btrfs_read_fs_root_no_name(struct btrfs_fs_info *fs_info,
					      struct btrfs_key *location)
1275 1276 1277 1278
{
	struct btrfs_root *root;
	int ret;

1279 1280 1281 1282
	if (location->objectid == BTRFS_ROOT_TREE_OBJECTID)
		return fs_info->tree_root;
	if (location->objectid == BTRFS_EXTENT_TREE_OBJECTID)
		return fs_info->extent_root;
1283 1284 1285 1286
	if (location->objectid == BTRFS_CHUNK_TREE_OBJECTID)
		return fs_info->chunk_root;
	if (location->objectid == BTRFS_DEV_TREE_OBJECTID)
		return fs_info->dev_root;
1287 1288
	if (location->objectid == BTRFS_CSUM_TREE_OBJECTID)
		return fs_info->csum_root;
1289 1290
again:
	spin_lock(&fs_info->fs_roots_radix_lock);
1291 1292
	root = radix_tree_lookup(&fs_info->fs_roots_radix,
				 (unsigned long)location->objectid);
1293
	spin_unlock(&fs_info->fs_roots_radix_lock);
1294 1295 1296
	if (root)
		return root;

1297
	root = btrfs_read_fs_root_no_radix(fs_info->tree_root, location);
1298 1299
	if (IS_ERR(root))
		return root;
1300

1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313
	root->free_ino_ctl = kzalloc(sizeof(*root->free_ino_ctl), GFP_NOFS);
	if (!root->free_ino_ctl)
		goto fail;
	root->free_ino_pinned = kzalloc(sizeof(*root->free_ino_pinned),
					GFP_NOFS);
	if (!root->free_ino_pinned)
		goto fail;

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

1314 1315 1316
	ret = set_anon_super(&root->anon_super, NULL);
	if (ret)
		goto fail;
1317

1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328
	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;

1329 1330 1331 1332 1333
	ret = radix_tree_preload(GFP_NOFS & ~__GFP_HIGHMEM);
	if (ret)
		goto fail;

	spin_lock(&fs_info->fs_roots_radix_lock);
C
Chris Mason 已提交
1334 1335
	ret = radix_tree_insert(&fs_info->fs_roots_radix,
				(unsigned long)root->root_key.objectid,
1336
				root);
1337
	if (ret == 0)
1338
		root->in_radix = 1;
1339

1340 1341
	spin_unlock(&fs_info->fs_roots_radix_lock);
	radix_tree_preload_end();
1342
	if (ret) {
1343 1344 1345 1346 1347
		if (ret == -EEXIST) {
			free_fs_root(root);
			goto again;
		}
		goto fail;
1348
	}
1349 1350 1351 1352

	ret = btrfs_find_dead_roots(fs_info->tree_root,
				    root->root_key.objectid);
	WARN_ON(ret);
1353
	return root;
1354 1355 1356
fail:
	free_fs_root(root);
	return ERR_PTR(ret);
1357 1358
}

C
Chris Mason 已提交
1359 1360 1361 1362 1363 1364
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 已提交
1365

1366 1367
	rcu_read_lock();
	list_for_each_entry_rcu(device, &info->fs_devices->devices, dev_list) {
1368 1369
		if (!device->bdev)
			continue;
C
Chris Mason 已提交
1370 1371 1372 1373 1374 1375
		bdi = blk_get_backing_dev_info(device->bdev);
		if (bdi && bdi_congested(bdi, bdi_bits)) {
			ret = 1;
			break;
		}
	}
1376
	rcu_read_unlock();
C
Chris Mason 已提交
1377 1378 1379
	return ret;
}

1380 1381 1382 1383
/*
 * If this fails, caller must call bdi_destroy() to get rid of the
 * bdi again.
 */
C
Chris Mason 已提交
1384 1385
static int setup_bdi(struct btrfs_fs_info *info, struct backing_dev_info *bdi)
{
1386 1387 1388
	int err;

	bdi->capabilities = BDI_CAP_MAP_COPY;
1389
	err = bdi_setup_and_register(bdi, "btrfs", BDI_CAP_MAP_COPY);
1390 1391 1392
	if (err)
		return err;

1393
	bdi->ra_pages	= default_backing_dev_info.ra_pages;
C
Chris Mason 已提交
1394 1395 1396 1397 1398
	bdi->congested_fn	= btrfs_congested_fn;
	bdi->congested_data	= info;
	return 0;
}

1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433
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;
}

1434 1435 1436 1437 1438
/*
 * 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)
1439 1440
{
	struct bio *bio;
1441 1442
	struct end_io_wq *end_io_wq;
	struct btrfs_fs_info *fs_info;
1443 1444
	int error;

1445 1446 1447
	end_io_wq = container_of(work, struct end_io_wq, work);
	bio = end_io_wq->bio;
	fs_info = end_io_wq->info;
1448

1449
	/* metadata bio reads are special because the whole tree block must
1450 1451 1452 1453
	 * 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
	 */
1454
	if (!(bio->bi_rw & REQ_WRITE) && end_io_wq->metadata &&
1455
	    !bio_ready_for_csum(bio)) {
1456
		btrfs_queue_worker(&fs_info->endio_meta_workers,
1457 1458 1459 1460 1461 1462 1463 1464
				   &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);
1465 1466
}

1467 1468 1469 1470 1471 1472
static int cleaner_kthread(void *arg)
{
	struct btrfs_root *root = arg;

	do {
		vfs_check_frozen(root->fs_info->sb, SB_FREEZE_WRITE);
1473 1474 1475

		if (!(root->fs_info->sb->s_flags & MS_RDONLY) &&
		    mutex_trylock(&root->fs_info->cleaner_mutex)) {
Y
Yan, Zheng 已提交
1476
			btrfs_run_delayed_iputs(root);
1477 1478
			btrfs_clean_old_snapshots(root);
			mutex_unlock(&root->fs_info->cleaner_mutex);
C
Chris Mason 已提交
1479
			btrfs_run_defrag_inodes(root->fs_info);
1480
		}
1481 1482 1483 1484 1485

		if (freezing(current)) {
			refrigerator();
		} else {
			set_current_state(TASK_INTERRUPTIBLE);
1486 1487
			if (!kthread_should_stop())
				schedule();
1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498
			__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;
1499
	u64 transid;
1500 1501 1502 1503 1504 1505 1506 1507 1508
	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);

J
Josef Bacik 已提交
1509
		spin_lock(&root->fs_info->trans_lock);
1510 1511
		cur = root->fs_info->running_transaction;
		if (!cur) {
J
Josef Bacik 已提交
1512
			spin_unlock(&root->fs_info->trans_lock);
1513 1514
			goto sleep;
		}
Y
Yan Zheng 已提交
1515

1516
		now = get_seconds();
1517 1518
		if (!cur->blocked &&
		    (now < cur->start_time || now - cur->start_time < 30)) {
J
Josef Bacik 已提交
1519
			spin_unlock(&root->fs_info->trans_lock);
1520 1521 1522
			delay = HZ * 5;
			goto sleep;
		}
1523
		transid = cur->transid;
J
Josef Bacik 已提交
1524
		spin_unlock(&root->fs_info->trans_lock);
1525

1526
		trans = btrfs_join_transaction(root);
1527
		BUG_ON(IS_ERR(trans));
1528 1529 1530 1531 1532 1533
		if (transid == trans->transid) {
			ret = btrfs_commit_transaction(trans, root);
			BUG_ON(ret);
		} else {
			btrfs_end_transaction(trans, root);
		}
1534 1535 1536 1537 1538 1539 1540 1541
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);
1542 1543 1544
			if (!kthread_should_stop() &&
			    !btrfs_transaction_blocked(root->fs_info))
				schedule_timeout(delay);
1545 1546 1547 1548 1549 1550
			__set_current_state(TASK_RUNNING);
		}
	} while (!kthread_should_stop());
	return 0;
}

1551
struct btrfs_root *open_ctree(struct super_block *sb,
1552 1553
			      struct btrfs_fs_devices *fs_devices,
			      char *options)
1554
{
1555 1556 1557 1558
	u32 sectorsize;
	u32 nodesize;
	u32 leafsize;
	u32 blocksize;
1559
	u32 stripesize;
1560
	u64 generation;
1561
	u64 features;
1562
	struct btrfs_key location;
1563
	struct buffer_head *bh;
1564
	struct btrfs_root *extent_root = kzalloc(sizeof(struct btrfs_root),
C
Chris Mason 已提交
1565
						 GFP_NOFS);
1566 1567
	struct btrfs_root *csum_root = kzalloc(sizeof(struct btrfs_root),
						 GFP_NOFS);
1568
	struct btrfs_root *tree_root = btrfs_sb(sb);
1569
	struct btrfs_fs_info *fs_info = NULL;
1570
	struct btrfs_root *chunk_root = kzalloc(sizeof(struct btrfs_root),
1571
						GFP_NOFS);
1572
	struct btrfs_root *dev_root = kzalloc(sizeof(struct btrfs_root),
1573
					      GFP_NOFS);
1574 1575
	struct btrfs_root *log_tree_root;

1576
	int ret;
1577
	int err = -EINVAL;
1578

C
Chris Mason 已提交
1579
	struct btrfs_super_block *disk_super;
1580

1581
	if (!extent_root || !tree_root || !tree_root->fs_info ||
1582
	    !chunk_root || !dev_root || !csum_root) {
C
Chris Mason 已提交
1583 1584 1585
		err = -ENOMEM;
		goto fail;
	}
1586
	fs_info = tree_root->fs_info;
1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605

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

1606 1607
	fs_info->btree_inode->i_mapping->flags &= ~__GFP_FS;

1608
	INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_ATOMIC);
C
Chris Mason 已提交
1609
	INIT_LIST_HEAD(&fs_info->trans_list);
1610
	INIT_LIST_HEAD(&fs_info->dead_roots);
Y
Yan, Zheng 已提交
1611
	INIT_LIST_HEAD(&fs_info->delayed_iputs);
1612
	INIT_LIST_HEAD(&fs_info->hashers);
1613
	INIT_LIST_HEAD(&fs_info->delalloc_inodes);
1614
	INIT_LIST_HEAD(&fs_info->ordered_operations);
1615
	INIT_LIST_HEAD(&fs_info->caching_block_groups);
1616
	spin_lock_init(&fs_info->delalloc_lock);
J
Josef Bacik 已提交
1617
	spin_lock_init(&fs_info->trans_lock);
Y
Yan Zheng 已提交
1618
	spin_lock_init(&fs_info->ref_cache_lock);
1619
	spin_lock_init(&fs_info->fs_roots_radix_lock);
Y
Yan, Zheng 已提交
1620
	spin_lock_init(&fs_info->delayed_iput_lock);
C
Chris Mason 已提交
1621
	spin_lock_init(&fs_info->defrag_inodes_lock);
C
Chris Mason 已提交
1622
	mutex_init(&fs_info->reloc_mutex);
1623

1624
	init_completion(&fs_info->kobj_unregister);
1625 1626
	fs_info->tree_root = tree_root;
	fs_info->extent_root = extent_root;
1627
	fs_info->csum_root = csum_root;
1628 1629
	fs_info->chunk_root = chunk_root;
	fs_info->dev_root = dev_root;
1630
	fs_info->fs_devices = fs_devices;
1631
	INIT_LIST_HEAD(&fs_info->dirty_cowonly_roots);
1632
	INIT_LIST_HEAD(&fs_info->space_info);
1633
	btrfs_mapping_init(&fs_info->mapping_tree);
1634 1635 1636 1637 1638 1639 1640
	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);
1641
	atomic_set(&fs_info->nr_async_submits, 0);
1642
	atomic_set(&fs_info->async_delalloc_pages, 0);
1643
	atomic_set(&fs_info->async_submit_draining, 0);
1644
	atomic_set(&fs_info->nr_async_bios, 0);
C
Chris Mason 已提交
1645
	atomic_set(&fs_info->defrag_running, 0);
C
Chris Mason 已提交
1646
	fs_info->sb = sb;
1647
	fs_info->max_inline = 8192 * 1024;
J
Josef Bacik 已提交
1648
	fs_info->metadata_ratio = 0;
C
Chris Mason 已提交
1649
	fs_info->defrag_inodes = RB_ROOT;
J
Josef Bacik 已提交
1650
	fs_info->trans_no_join = 0;
C
Chris Mason 已提交
1651

1652 1653
	fs_info->thread_pool_size = min_t(unsigned long,
					  num_online_cpus() + 2, 8);
1654

1655 1656
	INIT_LIST_HEAD(&fs_info->ordered_extents);
	spin_lock_init(&fs_info->ordered_extent_lock);
1657 1658 1659 1660 1661 1662 1663
	fs_info->delayed_root = kmalloc(sizeof(struct btrfs_delayed_root),
					GFP_NOFS);
	if (!fs_info->delayed_root) {
		err = -ENOMEM;
		goto fail_iput;
	}
	btrfs_init_delayed_root(fs_info->delayed_root);
1664

A
Arne Jansen 已提交
1665 1666 1667 1668 1669 1670 1671 1672 1673
	mutex_init(&fs_info->scrub_lock);
	atomic_set(&fs_info->scrubs_running, 0);
	atomic_set(&fs_info->scrub_pause_req, 0);
	atomic_set(&fs_info->scrubs_paused, 0);
	atomic_set(&fs_info->scrub_cancel_req, 0);
	init_waitqueue_head(&fs_info->scrub_pause_wait);
	init_rwsem(&fs_info->scrub_super_lock);
	fs_info->scrub_workers_refcnt = 0;

1674 1675
	sb->s_blocksize = 4096;
	sb->s_blocksize_bits = blksize_bits(4096);
J
Jens Axboe 已提交
1676
	sb->s_bdi = &fs_info->bdi;
1677

1678 1679
	fs_info->btree_inode->i_ino = BTRFS_BTREE_INODE_OBJECTID;
	fs_info->btree_inode->i_nlink = 1;
1680 1681 1682 1683 1684 1685
	/*
	 * 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;
1686
	fs_info->btree_inode->i_mapping->a_ops = &btree_aops;
C
Chris Mason 已提交
1687 1688
	fs_info->btree_inode->i_mapping->backing_dev_info = &fs_info->bdi;

1689
	RB_CLEAR_NODE(&BTRFS_I(fs_info->btree_inode)->rb_node);
1690
	extent_io_tree_init(&BTRFS_I(fs_info->btree_inode)->io_tree,
1691
			     fs_info->btree_inode->i_mapping);
1692
	extent_map_tree_init(&BTRFS_I(fs_info->btree_inode)->extent_tree);
1693 1694

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

1696 1697 1698 1699
	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;
1700
	insert_inode_hash(fs_info->btree_inode);
1701

J
Josef Bacik 已提交
1702
	spin_lock_init(&fs_info->block_group_cache_lock);
1703
	fs_info->block_group_cache_tree = RB_ROOT;
J
Josef Bacik 已提交
1704

1705
	extent_io_tree_init(&fs_info->freed_extents[0],
1706
			     fs_info->btree_inode->i_mapping);
1707
	extent_io_tree_init(&fs_info->freed_extents[1],
1708
			     fs_info->btree_inode->i_mapping);
1709
	fs_info->pinned_extents = &fs_info->freed_extents[0];
1710
	fs_info->do_barriers = 1;
1711

C
Chris Mason 已提交
1712

1713
	mutex_init(&fs_info->ordered_operations_mutex);
1714
	mutex_init(&fs_info->tree_log_mutex);
1715
	mutex_init(&fs_info->chunk_mutex);
1716 1717
	mutex_init(&fs_info->transaction_kthread_mutex);
	mutex_init(&fs_info->cleaner_mutex);
1718
	mutex_init(&fs_info->volume_mutex);
1719
	init_rwsem(&fs_info->extent_commit_sem);
1720
	init_rwsem(&fs_info->cleanup_work_sem);
1721
	init_rwsem(&fs_info->subvol_sem);
1722 1723 1724 1725

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

1726
	init_waitqueue_head(&fs_info->transaction_throttle);
1727
	init_waitqueue_head(&fs_info->transaction_wait);
S
Sage Weil 已提交
1728
	init_waitqueue_head(&fs_info->transaction_blocked_wait);
1729
	init_waitqueue_head(&fs_info->async_submit_wait);
1730

1731
	__setup_root(4096, 4096, 4096, 4096, tree_root,
C
Chris Mason 已提交
1732
		     fs_info, BTRFS_ROOT_TREE_OBJECTID);
1733

Y
Yan Zheng 已提交
1734
	bh = btrfs_read_dev_super(fs_devices->latest_bdev);
1735 1736
	if (!bh) {
		err = -EINVAL;
1737
		goto fail_alloc;
1738
	}
C
Chris Mason 已提交
1739

1740
	memcpy(&fs_info->super_copy, bh->b_data, sizeof(fs_info->super_copy));
1741 1742
	memcpy(&fs_info->super_for_commit, &fs_info->super_copy,
	       sizeof(fs_info->super_for_commit));
1743
	brelse(bh);
1744

1745
	memcpy(fs_info->fsid, fs_info->super_copy.fsid, BTRFS_FSID_SIZE);
1746

1747
	disk_super = &fs_info->super_copy;
1748
	if (!btrfs_super_root(disk_super))
1749
		goto fail_alloc;
1750

L
liubo 已提交
1751 1752 1753 1754 1755
	/* 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);

1756 1757 1758 1759 1760 1761
	/*
	 * 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 已提交
1762 1763 1764
	ret = btrfs_parse_options(tree_root, options);
	if (ret) {
		err = ret;
1765
		goto fail_alloc;
Y
Yan Zheng 已提交
1766
	}
1767

1768 1769 1770 1771 1772
	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",
1773
		       (unsigned long long)features);
1774
		err = -EINVAL;
1775
		goto fail_alloc;
1776 1777
	}

1778
	features = btrfs_super_incompat_flags(disk_super);
L
Li Zefan 已提交
1779 1780 1781 1782
	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);
1783

1784 1785 1786 1787 1788
	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",
1789
		       (unsigned long long)features);
1790
		err = -EINVAL;
1791
		goto fail_alloc;
1792
	}
1793 1794 1795 1796

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

1797
	btrfs_init_workers(&fs_info->workers, "worker",
1798 1799
			   fs_info->thread_pool_size,
			   &fs_info->generic_worker);
C
Chris Mason 已提交
1800

1801
	btrfs_init_workers(&fs_info->delalloc_workers, "delalloc",
1802 1803
			   fs_info->thread_pool_size,
			   &fs_info->generic_worker);
1804

1805
	btrfs_init_workers(&fs_info->submit_workers, "submit",
1806
			   min_t(u64, fs_devices->num_devices,
1807 1808
			   fs_info->thread_pool_size),
			   &fs_info->generic_worker);
1809 1810 1811 1812 1813 1814

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

1816
	fs_info->workers.idle_thresh = 16;
C
Chris Mason 已提交
1817
	fs_info->workers.ordered = 1;
1818

1819 1820 1821
	fs_info->delalloc_workers.idle_thresh = 2;
	fs_info->delalloc_workers.ordered = 1;

1822 1823
	btrfs_init_workers(&fs_info->fixup_workers, "fixup", 1,
			   &fs_info->generic_worker);
1824
	btrfs_init_workers(&fs_info->endio_workers, "endio",
1825 1826
			   fs_info->thread_pool_size,
			   &fs_info->generic_worker);
1827
	btrfs_init_workers(&fs_info->endio_meta_workers, "endio-meta",
1828 1829
			   fs_info->thread_pool_size,
			   &fs_info->generic_worker);
1830
	btrfs_init_workers(&fs_info->endio_meta_write_workers,
1831 1832
			   "endio-meta-write", fs_info->thread_pool_size,
			   &fs_info->generic_worker);
1833
	btrfs_init_workers(&fs_info->endio_write_workers, "endio-write",
1834 1835
			   fs_info->thread_pool_size,
			   &fs_info->generic_worker);
J
Josef Bacik 已提交
1836 1837
	btrfs_init_workers(&fs_info->endio_freespace_worker, "freespace-write",
			   1, &fs_info->generic_worker);
1838 1839 1840
	btrfs_init_workers(&fs_info->delayed_workers, "delayed-meta",
			   fs_info->thread_pool_size,
			   &fs_info->generic_worker);
1841 1842 1843 1844 1845 1846

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

1849 1850 1851
	fs_info->endio_write_workers.idle_thresh = 2;
	fs_info->endio_meta_write_workers.idle_thresh = 2;

1852
	btrfs_start_workers(&fs_info->workers, 1);
1853
	btrfs_start_workers(&fs_info->generic_worker, 1);
1854
	btrfs_start_workers(&fs_info->submit_workers, 1);
1855
	btrfs_start_workers(&fs_info->delalloc_workers, 1);
1856
	btrfs_start_workers(&fs_info->fixup_workers, 1);
1857 1858 1859 1860
	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 已提交
1861
	btrfs_start_workers(&fs_info->endio_freespace_worker, 1);
1862
	btrfs_start_workers(&fs_info->delayed_workers, 1);
1863

1864
	fs_info->bdi.ra_pages *= btrfs_super_num_devices(disk_super);
C
Chris Mason 已提交
1865 1866
	fs_info->bdi.ra_pages = max(fs_info->bdi.ra_pages,
				    4 * 1024 * 1024 / PAGE_CACHE_SIZE);
1867

1868 1869 1870
	nodesize = btrfs_super_nodesize(disk_super);
	leafsize = btrfs_super_leafsize(disk_super);
	sectorsize = btrfs_super_sectorsize(disk_super);
1871
	stripesize = btrfs_super_stripesize(disk_super);
1872 1873 1874
	tree_root->nodesize = nodesize;
	tree_root->leafsize = leafsize;
	tree_root->sectorsize = sectorsize;
1875
	tree_root->stripesize = stripesize;
1876 1877 1878

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

C
Chris Mason 已提交
1880 1881
	if (strncmp((char *)(&disk_super->magic), BTRFS_MAGIC,
		    sizeof(disk_super->magic))) {
C
Chris Mason 已提交
1882
		printk(KERN_INFO "btrfs: valid FS not found on %s\n", sb->s_id);
C
Chris Mason 已提交
1883 1884
		goto fail_sb_buffer;
	}
1885

1886
	mutex_lock(&fs_info->chunk_mutex);
Y
Yan Zheng 已提交
1887
	ret = btrfs_read_sys_array(tree_root);
1888
	mutex_unlock(&fs_info->chunk_mutex);
1889
	if (ret) {
C
Chris Mason 已提交
1890 1891
		printk(KERN_WARNING "btrfs: failed to read the system "
		       "array on %s\n", sb->s_id);
1892
		goto fail_sb_buffer;
1893
	}
1894 1895 1896

	blocksize = btrfs_level_size(tree_root,
				     btrfs_super_chunk_root_level(disk_super));
1897
	generation = btrfs_super_chunk_root_generation(disk_super);
1898 1899 1900 1901 1902 1903

	__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),
1904
					   blocksize, generation);
1905
	BUG_ON(!chunk_root->node);
1906 1907 1908 1909 1910
	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;
	}
1911 1912
	btrfs_set_root_node(&chunk_root->root_item, chunk_root->node);
	chunk_root->commit_root = btrfs_root_node(chunk_root);
1913

1914
	read_extent_buffer(chunk_root->node, fs_info->chunk_tree_uuid,
C
Chris Mason 已提交
1915 1916
	   (unsigned long)btrfs_header_chunk_tree_uuid(chunk_root->node),
	   BTRFS_UUID_SIZE);
1917

1918
	mutex_lock(&fs_info->chunk_mutex);
1919
	ret = btrfs_read_chunk_tree(chunk_root);
1920
	mutex_unlock(&fs_info->chunk_mutex);
Y
Yan Zheng 已提交
1921
	if (ret) {
C
Chris Mason 已提交
1922 1923
		printk(KERN_WARNING "btrfs: failed to read chunk tree on %s\n",
		       sb->s_id);
Y
Yan Zheng 已提交
1924 1925
		goto fail_chunk_root;
	}
1926

1927 1928
	btrfs_close_extra_devices(fs_devices);

1929 1930
	blocksize = btrfs_level_size(tree_root,
				     btrfs_super_root_level(disk_super));
1931
	generation = btrfs_super_generation(disk_super);
1932

C
Chris Mason 已提交
1933
	tree_root->node = read_tree_block(tree_root,
1934
					  btrfs_super_root(disk_super),
1935
					  blocksize, generation);
C
Chris Mason 已提交
1936
	if (!tree_root->node)
Y
Yan Zheng 已提交
1937
		goto fail_chunk_root;
1938 1939 1940 1941 1942
	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;
	}
1943 1944
	btrfs_set_root_node(&tree_root->root_item, tree_root->node);
	tree_root->commit_root = btrfs_root_node(tree_root);
1945 1946

	ret = find_and_setup_root(tree_root, fs_info,
C
Chris Mason 已提交
1947
				  BTRFS_EXTENT_TREE_OBJECTID, extent_root);
1948
	if (ret)
C
Chris Mason 已提交
1949
		goto fail_tree_root;
1950 1951 1952 1953 1954 1955
	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;
1956
	dev_root->track_dirty = 1;
1957

1958 1959 1960
	ret = find_and_setup_root(tree_root, fs_info,
				  BTRFS_CSUM_TREE_OBJECTID, csum_root);
	if (ret)
1961
		goto fail_dev_root;
1962 1963 1964

	csum_root->track_dirty = 1;

1965 1966 1967 1968 1969 1970
	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;

1971 1972 1973 1974 1975 1976
	ret = btrfs_init_space_info(fs_info);
	if (ret) {
		printk(KERN_ERR "Failed to initial space info: %d\n", ret);
		goto fail_block_groups;
	}

1977 1978 1979 1980 1981
	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 已提交
1982

1983 1984
	fs_info->cleaner_kthread = kthread_run(cleaner_kthread, tree_root,
					       "btrfs-cleaner");
1985
	if (IS_ERR(fs_info->cleaner_kthread))
1986
		goto fail_block_groups;
1987 1988 1989 1990

	fs_info->transaction_kthread = kthread_run(transaction_kthread,
						   tree_root,
						   "btrfs-transaction");
1991
	if (IS_ERR(fs_info->transaction_kthread))
1992
		goto fail_cleaner;
1993

C
Chris Mason 已提交
1994 1995 1996 1997 1998 1999 2000 2001
	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 已提交
2002 2003 2004
	/* do not make disk changes in broken FS */
	if (btrfs_super_log_root(disk_super) != 0 &&
	    !(fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR)) {
2005 2006
		u64 bytenr = btrfs_super_log_root(disk_super);

2007
		if (fs_devices->rw_devices == 0) {
C
Chris Mason 已提交
2008 2009
			printk(KERN_WARNING "Btrfs log replay required "
			       "on RO media\n");
2010 2011 2012
			err = -EIO;
			goto fail_trans_kthread;
		}
2013 2014 2015
		blocksize =
		     btrfs_level_size(tree_root,
				      btrfs_super_log_root_level(disk_super));
C
Chris Mason 已提交
2016

2017 2018 2019 2020 2021
		log_tree_root = kzalloc(sizeof(struct btrfs_root), GFP_NOFS);
		if (!log_tree_root) {
			err = -ENOMEM;
			goto fail_trans_kthread;
		}
2022 2023 2024 2025 2026

		__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,
2027 2028
						      blocksize,
						      generation + 1);
2029 2030
		ret = btrfs_recover_log_trees(log_tree_root);
		BUG_ON(ret);
2031 2032 2033 2034 2035

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

2038 2039 2040
	ret = btrfs_find_orphan_roots(tree_root);
	BUG_ON(ret);

2041
	if (!(sb->s_flags & MS_RDONLY)) {
2042 2043 2044
		ret = btrfs_cleanup_fs_roots(fs_info);
		BUG_ON(ret);

2045
		ret = btrfs_recover_relocation(tree_root);
2046 2047 2048 2049 2050 2051
		if (ret < 0) {
			printk(KERN_WARNING
			       "btrfs: failed to recover relocation\n");
			err = -EINVAL;
			goto fail_trans_kthread;
		}
2052
	}
Z
Zheng Yan 已提交
2053

2054 2055 2056 2057 2058 2059
	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)
2060
		goto fail_trans_kthread;
2061 2062 2063 2064
	if (IS_ERR(fs_info->fs_root)) {
		err = PTR_ERR(fs_info->fs_root);
		goto fail_trans_kthread;
	}
C
Chris Mason 已提交
2065

2066 2067
	if (!(sb->s_flags & MS_RDONLY)) {
		down_read(&fs_info->cleanup_work_sem);
2068 2069 2070
		err = btrfs_orphan_cleanup(fs_info->fs_root);
		if (!err)
			err = btrfs_orphan_cleanup(fs_info->tree_root);
2071
		up_read(&fs_info->cleanup_work_sem);
2072 2073 2074 2075
		if (err) {
			close_ctree(tree_root);
			return ERR_PTR(err);
		}
2076 2077
	}

2078
	return tree_root;
C
Chris Mason 已提交
2079

2080 2081
fail_trans_kthread:
	kthread_stop(fs_info->transaction_kthread);
2082
fail_cleaner:
2083
	kthread_stop(fs_info->cleaner_kthread);
2084 2085 2086 2087 2088 2089 2090 2091

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

2092 2093
fail_block_groups:
	btrfs_free_block_groups(fs_info);
2094
	free_extent_buffer(csum_root->node);
2095 2096 2097 2098
	free_extent_buffer(csum_root->commit_root);
fail_dev_root:
	free_extent_buffer(dev_root->node);
	free_extent_buffer(dev_root->commit_root);
2099 2100
fail_extent_root:
	free_extent_buffer(extent_root->node);
2101
	free_extent_buffer(extent_root->commit_root);
C
Chris Mason 已提交
2102
fail_tree_root:
2103
	free_extent_buffer(tree_root->node);
2104
	free_extent_buffer(tree_root->commit_root);
Y
Yan Zheng 已提交
2105 2106
fail_chunk_root:
	free_extent_buffer(chunk_root->node);
2107
	free_extent_buffer(chunk_root->commit_root);
C
Chris Mason 已提交
2108
fail_sb_buffer:
2109
	btrfs_stop_workers(&fs_info->generic_worker);
2110
	btrfs_stop_workers(&fs_info->fixup_workers);
2111
	btrfs_stop_workers(&fs_info->delalloc_workers);
2112 2113
	btrfs_stop_workers(&fs_info->workers);
	btrfs_stop_workers(&fs_info->endio_workers);
2114
	btrfs_stop_workers(&fs_info->endio_meta_workers);
2115
	btrfs_stop_workers(&fs_info->endio_meta_write_workers);
2116
	btrfs_stop_workers(&fs_info->endio_write_workers);
J
Josef Bacik 已提交
2117
	btrfs_stop_workers(&fs_info->endio_freespace_worker);
2118
	btrfs_stop_workers(&fs_info->submit_workers);
2119 2120 2121
	btrfs_stop_workers(&fs_info->delayed_workers);
fail_alloc:
	kfree(fs_info->delayed_root);
2122
fail_iput:
2123
	invalidate_inode_pages2(fs_info->btree_inode->i_mapping);
2124
	iput(fs_info->btree_inode);
2125

2126
	btrfs_close_devices(fs_info->fs_devices);
2127
	btrfs_mapping_tree_free(&fs_info->mapping_tree);
2128
fail_bdi:
2129
	bdi_destroy(&fs_info->bdi);
2130 2131
fail_srcu:
	cleanup_srcu_struct(&fs_info->subvol_srcu);
2132
fail:
C
Chris Mason 已提交
2133 2134 2135
	kfree(extent_root);
	kfree(tree_root);
	kfree(fs_info);
2136 2137
	kfree(chunk_root);
	kfree(dev_root);
2138
	kfree(csum_root);
C
Chris Mason 已提交
2139
	return ERR_PTR(err);
2140 2141
}

2142 2143 2144 2145 2146 2147 2148
static void btrfs_end_buffer_write_sync(struct buffer_head *bh, int uptodate)
{
	char b[BDEVNAME_SIZE];

	if (uptodate) {
		set_buffer_uptodate(bh);
	} else {
2149
		printk_ratelimited(KERN_WARNING "lost page write due to "
2150 2151
					"I/O error on %s\n",
				       bdevname(bh->b_bdev, b));
2152 2153 2154
		/* note, we dont' set_buffer_write_io_error because we have
		 * our own ways of dealing with the IO errors
		 */
2155 2156 2157 2158 2159 2160
		clear_buffer_uptodate(bh);
	}
	unlock_buffer(bh);
	put_bh(bh);
}

Y
Yan Zheng 已提交
2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201
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;
}

2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212
/*
 * 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 已提交
2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248
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);
2249 2250 2251 2252 2253 2254 2255 2256 2257
			if (!buffer_uptodate(bh))
				errors++;

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

			/* drop the reference from the wait == 0 run */
			brelse(bh);
			continue;
Y
Yan Zheng 已提交
2258 2259 2260 2261 2262 2263 2264 2265 2266 2267
		} 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);

2268 2269 2270 2271
			/*
			 * one reference for us, and we leave it for the
			 * caller
			 */
Y
Yan Zheng 已提交
2272 2273 2274 2275
			bh = __getblk(device->bdev, bytenr / 4096,
				      BTRFS_SUPER_INFO_SIZE);
			memcpy(bh->b_data, sb, BTRFS_SUPER_INFO_SIZE);

2276
			/* one reference for submit_bh */
Y
Yan Zheng 已提交
2277
			get_bh(bh);
2278 2279

			set_buffer_uptodate(bh);
Y
Yan Zheng 已提交
2280 2281 2282 2283
			lock_buffer(bh);
			bh->b_end_io = btrfs_end_buffer_write_sync;
		}

2284 2285 2286
		if (i == last_barrier && do_barriers)
			ret = submit_bh(WRITE_FLUSH_FUA, bh);
		else
2287
			ret = submit_bh(WRITE_SYNC, bh);
Y
Yan Zheng 已提交
2288

2289
		if (ret)
Y
Yan Zheng 已提交
2290 2291 2292 2293 2294 2295
			errors++;
	}
	return errors < i ? 0 : -1;
}

int write_all_supers(struct btrfs_root *root, int max_mirrors)
2296
{
2297
	struct list_head *head;
2298
	struct btrfs_device *dev;
2299
	struct btrfs_super_block *sb;
2300 2301 2302
	struct btrfs_dev_item *dev_item;
	int ret;
	int do_barriers;
2303 2304
	int max_errors;
	int total_errors = 0;
2305
	u64 flags;
2306

2307
	max_errors = btrfs_super_num_devices(&root->fs_info->super_copy) - 1;
2308 2309
	do_barriers = !btrfs_test_opt(root, NOBARRIER);

2310 2311
	sb = &root->fs_info->super_for_commit;
	dev_item = &sb->dev_item;
2312

2313
	mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
2314
	head = &root->fs_info->fs_devices->devices;
2315
	list_for_each_entry_rcu(dev, head, dev_list) {
2316 2317 2318 2319
		if (!dev->bdev) {
			total_errors++;
			continue;
		}
Y
Yan Zheng 已提交
2320
		if (!dev->in_fs_metadata || !dev->writeable)
2321 2322
			continue;

Y
Yan Zheng 已提交
2323
		btrfs_set_stack_device_generation(dev_item, 0);
2324 2325 2326 2327 2328 2329 2330 2331
		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 已提交
2332
		memcpy(dev_item->fsid, dev->fs_devices->fsid, BTRFS_UUID_SIZE);
Y
Yan Zheng 已提交
2333

2334 2335 2336
		flags = btrfs_super_flags(sb);
		btrfs_set_super_flags(sb, flags | BTRFS_HEADER_FLAG_WRITTEN);

Y
Yan Zheng 已提交
2337
		ret = write_dev_supers(dev, sb, do_barriers, 0, max_mirrors);
2338 2339
		if (ret)
			total_errors++;
2340
	}
2341
	if (total_errors > max_errors) {
C
Chris Mason 已提交
2342 2343
		printk(KERN_ERR "btrfs: %d errors while writing supers\n",
		       total_errors);
2344 2345
		BUG();
	}
2346

Y
Yan Zheng 已提交
2347
	total_errors = 0;
2348
	list_for_each_entry_rcu(dev, head, dev_list) {
2349 2350
		if (!dev->bdev)
			continue;
Y
Yan Zheng 已提交
2351
		if (!dev->in_fs_metadata || !dev->writeable)
2352 2353
			continue;

Y
Yan Zheng 已提交
2354 2355 2356
		ret = write_dev_supers(dev, sb, do_barriers, 1, max_mirrors);
		if (ret)
			total_errors++;
2357
	}
2358
	mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
2359
	if (total_errors > max_errors) {
C
Chris Mason 已提交
2360 2361
		printk(KERN_ERR "btrfs: %d errors while writing supers\n",
		       total_errors);
2362 2363
		BUG();
	}
2364 2365 2366
	return 0;
}

Y
Yan Zheng 已提交
2367 2368
int write_ctree_super(struct btrfs_trans_handle *trans,
		      struct btrfs_root *root, int max_mirrors)
2369
{
2370
	int ret;
2371

Y
Yan Zheng 已提交
2372
	ret = write_all_supers(root, max_mirrors);
2373
	return ret;
C
Chris Mason 已提交
2374 2375
}

2376
int btrfs_free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root)
C
Chris Mason 已提交
2377
{
2378
	spin_lock(&fs_info->fs_roots_radix_lock);
C
Chris Mason 已提交
2379 2380
	radix_tree_delete(&fs_info->fs_roots_radix,
			  (unsigned long)root->root_key.objectid);
2381
	spin_unlock(&fs_info->fs_roots_radix_lock);
2382 2383 2384 2385

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

2386 2387
	__btrfs_remove_free_space_cache(root->free_ino_pinned);
	__btrfs_remove_free_space_cache(root->free_ino_ctl);
2388 2389 2390 2391 2392 2393
	free_fs_root(root);
	return 0;
}

static void free_fs_root(struct btrfs_root *root)
{
2394
	iput(root->cache_inode);
2395
	WARN_ON(!RB_EMPTY_ROOT(&root->inode_tree));
2396 2397 2398 2399
	if (root->anon_super.s_dev) {
		down_write(&root->anon_super.s_umount);
		kill_anon_super(&root->anon_super);
	}
2400 2401
	free_extent_buffer(root->node);
	free_extent_buffer(root->commit_root);
2402 2403
	kfree(root->free_ino_ctl);
	kfree(root->free_ino_pinned);
C
Chris Mason 已提交
2404
	kfree(root->name);
C
Chris Mason 已提交
2405 2406 2407
	kfree(root);
}

C
Chris Mason 已提交
2408
static int del_fs_roots(struct btrfs_fs_info *fs_info)
2409 2410 2411 2412 2413
{
	int ret;
	struct btrfs_root *gang[8];
	int i;

2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427
	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 已提交
2428
	while (1) {
2429 2430 2431 2432 2433
		ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
					     (void **)gang, 0,
					     ARRAY_SIZE(gang));
		if (!ret)
			break;
C
Chris Mason 已提交
2434
		for (i = 0; i < ret; i++)
2435
			btrfs_free_fs_root(fs_info, gang[i]);
2436 2437 2438
	}
	return 0;
}
2439

Y
Yan Zheng 已提交
2440
int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info)
C
Chris Mason 已提交
2441
{
Y
Yan Zheng 已提交
2442 2443 2444
	u64 root_objectid = 0;
	struct btrfs_root *gang[8];
	int i;
2445
	int ret;
2446

Y
Yan Zheng 已提交
2447 2448 2449 2450 2451 2452
	while (1) {
		ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
					     (void **)gang, root_objectid,
					     ARRAY_SIZE(gang));
		if (!ret)
			break;
2453 2454

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

Y
Yan Zheng 已提交
2458
			root_objectid = gang[i]->root_key.objectid;
2459 2460 2461
			err = btrfs_orphan_cleanup(gang[i]);
			if (err)
				return err;
Y
Yan Zheng 已提交
2462 2463 2464 2465 2466
		}
		root_objectid++;
	}
	return 0;
}
2467

Y
Yan Zheng 已提交
2468 2469 2470 2471
int btrfs_commit_super(struct btrfs_root *root)
{
	struct btrfs_trans_handle *trans;
	int ret;
2472

Y
Yan Zheng 已提交
2473
	mutex_lock(&root->fs_info->cleaner_mutex);
Y
Yan, Zheng 已提交
2474
	btrfs_run_delayed_iputs(root);
2475
	btrfs_clean_old_snapshots(root);
Y
Yan Zheng 已提交
2476
	mutex_unlock(&root->fs_info->cleaner_mutex);
2477 2478 2479 2480 2481

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

2482
	trans = btrfs_join_transaction(root);
2483 2484
	if (IS_ERR(trans))
		return PTR_ERR(trans);
2485
	ret = btrfs_commit_transaction(trans, root);
Y
Yan Zheng 已提交
2486 2487
	BUG_ON(ret);
	/* run commit again to drop the original snapshot */
2488
	trans = btrfs_join_transaction(root);
2489 2490
	if (IS_ERR(trans))
		return PTR_ERR(trans);
C
Chris Mason 已提交
2491 2492
	btrfs_commit_transaction(trans, root);
	ret = btrfs_write_and_wait_transaction(NULL, root);
2493
	BUG_ON(ret);
2494

Y
Yan Zheng 已提交
2495
	ret = write_ctree_super(NULL, root, 0);
Y
Yan Zheng 已提交
2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506
	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();

A
Arne Jansen 已提交
2507
	btrfs_scrub_cancel(root);
C
Chris Mason 已提交
2508 2509 2510 2511 2512 2513 2514 2515

	/* wait for any defraggers to finish */
	wait_event(fs_info->transaction_wait,
		   (atomic_read(&fs_info->defrag_running) == 0));

	/* clear out the rbtree of defraggable inodes */
	btrfs_run_defrag_inodes(root->fs_info);

2516
	btrfs_put_block_group_cache(fs_info);
L
liubo 已提交
2517 2518 2519 2520 2521 2522 2523 2524 2525 2526

	/*
	 * 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,
2527
	 * and in such case, btrfs cannot write sb via btrfs_commit_super,
L
liubo 已提交
2528 2529 2530
	 * 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 已提交
2531
	if (!(fs_info->sb->s_flags & MS_RDONLY)) {
L
liubo 已提交
2532 2533 2534 2535 2536 2537 2538
		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 已提交
2539 2540
		if (ret)
			printk(KERN_ERR "btrfs: commit super ret %d\n", ret);
Y
Yan Zheng 已提交
2541
	}
2542

2543 2544 2545
	kthread_stop(root->fs_info->transaction_kthread);
	kthread_stop(root->fs_info->cleaner_kthread);

2546 2547 2548
	fs_info->closing = 2;
	smp_mb();

C
Chris Mason 已提交
2549
	if (fs_info->delalloc_bytes) {
C
Chris Mason 已提交
2550
		printk(KERN_INFO "btrfs: at unmount delalloc count %llu\n",
2551
		       (unsigned long long)fs_info->delalloc_bytes);
C
Chris Mason 已提交
2552
	}
Y
Yan Zheng 已提交
2553
	if (fs_info->total_ref_cache_size) {
C
Chris Mason 已提交
2554 2555
		printk(KERN_INFO "btrfs: at umount reference cache size %llu\n",
		       (unsigned long long)fs_info->total_ref_cache_size);
Y
Yan Zheng 已提交
2556
	}
2557

2558 2559 2560 2561 2562 2563 2564 2565 2566 2567
	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);
2568

C
Chris Mason 已提交
2569
	btrfs_free_block_groups(root->fs_info);
2570

Y
Yan Zheng 已提交
2571
	del_fs_roots(fs_info);
2572

Y
Yan Zheng 已提交
2573
	iput(fs_info->btree_inode);
2574
	kfree(fs_info->delayed_root);
2575

2576
	btrfs_stop_workers(&fs_info->generic_worker);
2577
	btrfs_stop_workers(&fs_info->fixup_workers);
2578
	btrfs_stop_workers(&fs_info->delalloc_workers);
2579 2580
	btrfs_stop_workers(&fs_info->workers);
	btrfs_stop_workers(&fs_info->endio_workers);
2581
	btrfs_stop_workers(&fs_info->endio_meta_workers);
2582
	btrfs_stop_workers(&fs_info->endio_meta_write_workers);
2583
	btrfs_stop_workers(&fs_info->endio_write_workers);
J
Josef Bacik 已提交
2584
	btrfs_stop_workers(&fs_info->endio_freespace_worker);
2585
	btrfs_stop_workers(&fs_info->submit_workers);
2586
	btrfs_stop_workers(&fs_info->delayed_workers);
2587

2588
	btrfs_close_devices(fs_info->fs_devices);
2589
	btrfs_mapping_tree_free(&fs_info->mapping_tree);
2590

C
Chris Mason 已提交
2591
	bdi_destroy(&fs_info->bdi);
2592
	cleanup_srcu_struct(&fs_info->subvol_srcu);
2593

2594 2595
	kfree(fs_info->extent_root);
	kfree(fs_info->tree_root);
2596 2597
	kfree(fs_info->chunk_root);
	kfree(fs_info->dev_root);
2598
	kfree(fs_info->csum_root);
L
Li Zefan 已提交
2599 2600
	kfree(fs_info);

2601 2602 2603
	return 0;
}

2604
int btrfs_buffer_uptodate(struct extent_buffer *buf, u64 parent_transid)
2605
{
2606
	int ret;
2607
	struct inode *btree_inode = buf->first_page->mapping->host;
2608

2609 2610
	ret = extent_buffer_uptodate(&BTRFS_I(btree_inode)->io_tree, buf,
				     NULL);
2611 2612 2613 2614 2615 2616
	if (!ret)
		return ret;

	ret = verify_parent_transid(&BTRFS_I(btree_inode)->io_tree, buf,
				    parent_transid);
	return !ret;
2617 2618 2619
}

int btrfs_set_buffer_uptodate(struct extent_buffer *buf)
C
Chris Mason 已提交
2620
{
2621
	struct inode *btree_inode = buf->first_page->mapping->host;
2622
	return set_extent_buffer_uptodate(&BTRFS_I(btree_inode)->io_tree,
2623 2624
					  buf);
}
2625

2626 2627
void btrfs_mark_buffer_dirty(struct extent_buffer *buf)
{
2628
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
2629 2630
	u64 transid = btrfs_header_generation(buf);
	struct inode *btree_inode = root->fs_info->btree_inode;
2631
	int was_dirty;
2632

2633
	btrfs_assert_tree_locked(buf);
C
Chris Mason 已提交
2634
	if (transid != root->fs_info->generation) {
C
Chris Mason 已提交
2635 2636
		printk(KERN_CRIT "btrfs transid mismatch buffer %llu, "
		       "found %llu running %llu\n",
2637
			(unsigned long long)buf->start,
C
Chris Mason 已提交
2638 2639
			(unsigned long long)transid,
			(unsigned long long)root->fs_info->generation);
C
Chris Mason 已提交
2640 2641
		WARN_ON(1);
	}
2642 2643 2644 2645 2646 2647 2648
	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);
	}
2649 2650
}

2651
void btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr)
2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674
{
	/*
	 * looks as though older kernels can get into trouble with
	 * this code, they end up stuck in balance_dirty_pages forever
	 */
	u64 num_dirty;
	unsigned long thresh = 32 * 1024 * 1024;

	if (current->flags & PF_MEMALLOC)
		return;

	btrfs_balance_delayed_items(root);

	num_dirty = root->fs_info->dirty_metadata_bytes;

	if (num_dirty > thresh) {
		balance_dirty_pages_ratelimited_nr(
				   root->fs_info->btree_inode->i_mapping, 1);
	}
	return;
}

void __btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr)
C
Chris Mason 已提交
2675
{
2676 2677 2678 2679
	/*
	 * looks as though older kernels can get into trouble with
	 * this code, they end up stuck in balance_dirty_pages forever
	 */
2680
	u64 num_dirty;
2681
	unsigned long thresh = 32 * 1024 * 1024;
2682

2683
	if (current->flags & PF_MEMALLOC)
2684 2685
		return;

2686 2687
	num_dirty = root->fs_info->dirty_metadata_bytes;

2688 2689
	if (num_dirty > thresh) {
		balance_dirty_pages_ratelimited_nr(
C
Chris Mason 已提交
2690
				   root->fs_info->btree_inode->i_mapping, 1);
2691
	}
2692
	return;
C
Chris Mason 已提交
2693
}
2694

2695
int btrfs_read_buffer(struct extent_buffer *buf, u64 parent_transid)
2696
{
2697
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
2698
	int ret;
2699
	ret = btree_read_extent_buffer_pages(root, buf, 0, parent_transid);
C
Chris Mason 已提交
2700
	if (ret == 0)
2701
		set_bit(EXTENT_BUFFER_UPTODATE, &buf->bflags);
2702
	return ret;
2703
}
2704

C
Chris Mason 已提交
2705 2706 2707
int btree_lock_page_hook(struct page *page)
{
	struct inode *inode = page->mapping->host;
2708
	struct btrfs_root *root = BTRFS_I(inode)->root;
C
Chris Mason 已提交
2709 2710 2711 2712 2713 2714 2715 2716 2717
	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;
2718
	eb = find_extent_buffer(io_tree, bytenr, len);
C
Chris Mason 已提交
2719 2720 2721 2722 2723
	if (!eb)
		goto out;

	btrfs_tree_lock(eb);
	btrfs_set_header_flag(eb, BTRFS_HEADER_FLAG_WRITTEN);
2724 2725 2726 2727 2728 2729 2730 2731 2732 2733

	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 已提交
2734 2735 2736 2737 2738 2739 2740
	btrfs_tree_unlock(eb);
	free_extent_buffer(eb);
out:
	lock_page(page);
	return 0;
}

L
liubo 已提交
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 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844
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) {
2845
		spin_unlock(&delayed_refs->lock);
L
liubo 已提交
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
		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);

	spin_lock(&root->fs_info->delalloc_lock);
2915
	list_splice_init(&root->fs_info->delalloc_inodes, &splice);
L
liubo 已提交
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 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005

	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 */
3006 3007 3008 3009
		if (btrfs_test_opt(root, DISCARD))
			ret = btrfs_error_discard_extent(root, start,
							 end + 1 - start,
							 NULL);
L
liubo 已提交
3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027

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

J
Josef Bacik 已提交
3028
	spin_lock(&root->fs_info->trans_lock);
L
liubo 已提交
3029
	list_splice_init(&root->fs_info->trans_list, &list);
J
Josef Bacik 已提交
3030 3031 3032
	root->fs_info->trans_no_join = 1;
	spin_unlock(&root->fs_info->trans_lock);

L
liubo 已提交
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 3061 3062 3063 3064 3065
	while (!list_empty(&list)) {
		t = list_entry(list.next, struct btrfs_transaction, list);
		if (!t)
			break;

		btrfs_destroy_ordered_operations(root);

		btrfs_destroy_ordered_extents(root);

		btrfs_destroy_delayed_refs(t, root);

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

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

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

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

		btrfs_destroy_pending_snapshots(t);

		btrfs_destroy_delalloc_inodes(root);

J
Josef Bacik 已提交
3066
		spin_lock(&root->fs_info->trans_lock);
L
liubo 已提交
3067
		root->fs_info->running_transaction = NULL;
J
Josef Bacik 已提交
3068
		spin_unlock(&root->fs_info->trans_lock);
L
liubo 已提交
3069 3070 3071 3072 3073 3074 3075

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

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

3076
		atomic_set(&t->use_count, 0);
L
liubo 已提交
3077 3078 3079 3080 3081
		list_del_init(&t->list);
		memset(t, 0, sizeof(*t));
		kmem_cache_free(btrfs_transaction_cachep, t);
	}

J
Josef Bacik 已提交
3082 3083 3084
	spin_lock(&root->fs_info->trans_lock);
	root->fs_info->trans_no_join = 0;
	spin_unlock(&root->fs_info->trans_lock);
L
liubo 已提交
3085 3086 3087 3088 3089
	mutex_unlock(&root->fs_info->transaction_kthread_mutex);

	return 0;
}

3090
static struct extent_io_ops btree_extent_io_ops = {
C
Chris Mason 已提交
3091
	.write_cache_pages_lock_hook = btree_lock_page_hook,
3092
	.readpage_end_io_hook = btree_readpage_end_io_hook,
3093
	.submit_bio_hook = btree_submit_bio_hook,
3094 3095
	/* note we're sharing with inode.c for the merge bio hook */
	.merge_bio_hook = btrfs_merge_bio_hook,
3096
};