disk-io.c 47.8 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.
 */

19
#include <linux/version.h>
C
Chris Mason 已提交
20
#include <linux/fs.h>
21
#include <linux/blkdev.h>
C
Chris Mason 已提交
22
#include <linux/scatterlist.h>
C
Chris Mason 已提交
23
#include <linux/swap.h>
24
#include <linux/radix-tree.h>
C
Chris Mason 已提交
25
#include <linux/writeback.h>
26
#include <linux/buffer_head.h> // for block_sync_page
27
#include <linux/workqueue.h>
28 29 30 31 32 33
#include <linux/kthread.h>
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
# include <linux/freezer.h>
#else
# include <linux/sched.h>
#endif
34
#include "crc32c.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"
C
Chris Mason 已提交
43
#include "ref-cache.h"
44

45 46
#if 0
static int check_tree_block(struct btrfs_root *root, struct extent_buffer *buf)
47
{
48 49 50 51
	if (extent_buffer_blocknr(buf) != btrfs_header_blocknr(buf)) {
		printk(KERN_CRIT "buf blocknr(buf) is %llu, header is %llu\n",
		       (unsigned long long)extent_buffer_blocknr(buf),
		       (unsigned long long)btrfs_header_blocknr(buf));
C
Chris Mason 已提交
52
		return 1;
53
	}
54
	return 0;
55
}
56
#endif
57

58
static struct extent_io_ops btree_extent_io_ops;
59
static void end_workqueue_fn(struct btrfs_work *work);
60 61 62 63 64 65 66

struct end_io_wq {
	struct bio *bio;
	bio_end_io_t *end_io;
	void *private;
	struct btrfs_fs_info *info;
	int error;
67
	int metadata;
68
	struct list_head list;
69
	struct btrfs_work work;
70
};
71

72 73 74 75 76 77 78
struct async_submit_bio {
	struct inode *inode;
	struct bio *bio;
	struct list_head list;
	extent_submit_bio_hook_t *submit_bio_hook;
	int rw;
	int mirror_num;
79
	struct btrfs_work work;
80 81
};

82
struct extent_map *btree_get_extent(struct inode *inode, struct page *page,
83
				    size_t page_offset, u64 start, u64 len,
84
				    int create)
85
{
86 87 88 89
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
	struct extent_map *em;
	int ret;

90 91
	spin_lock(&em_tree->lock);
	em = lookup_extent_mapping(em_tree, start, len);
92 93 94 95
	if (em) {
		em->bdev =
			BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev;
		spin_unlock(&em_tree->lock);
96
		goto out;
97 98
	}
	spin_unlock(&em_tree->lock);
99

100 101 102 103 104 105
	em = alloc_extent_map(GFP_NOFS);
	if (!em) {
		em = ERR_PTR(-ENOMEM);
		goto out;
	}
	em->start = 0;
106
	em->len = (u64)-1;
107
	em->block_start = 0;
108
	em->bdev = BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev;
109 110

	spin_lock(&em_tree->lock);
111 112
	ret = add_extent_mapping(em_tree, em);
	if (ret == -EEXIST) {
113 114 115 116 117
		u64 failed_start = em->start;
		u64 failed_len = em->len;

		printk("failed to insert %Lu %Lu -> %Lu into tree\n",
		       em->start, em->len, em->block_start);
118
		free_extent_map(em);
119
		em = lookup_extent_mapping(em_tree, start, len);
120 121 122
		if (em) {
			printk("after failing, found %Lu %Lu %Lu\n",
			       em->start, em->len, em->block_start);
123
			ret = 0;
124 125 126 127 128 129 130 131 132
		} else {
			em = lookup_extent_mapping(em_tree, failed_start,
						   failed_len);
			if (em) {
				printk("double failure lookup gives us "
				       "%Lu %Lu -> %Lu\n", em->start,
				       em->len, em->block_start);
				free_extent_map(em);
			}
133
			ret = -EIO;
134
		}
135
	} else if (ret) {
136 137
		free_extent_map(em);
		em = NULL;
138
	}
139 140 141 142
	spin_unlock(&em_tree->lock);

	if (ret)
		em = ERR_PTR(ret);
143 144
out:
	return em;
145 146
}

147 148
u32 btrfs_csum_data(struct btrfs_root *root, char *data, u32 seed, size_t len)
{
149
	return btrfs_crc32c(seed, data, len);
150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190
}

void btrfs_csum_final(u32 crc, char *result)
{
	*(__le32 *)result = ~cpu_to_le32(crc);
}

static int csum_tree_block(struct btrfs_root *root, struct extent_buffer *buf,
			   int verify)
{
	char result[BTRFS_CRC32_SIZE];
	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;

	len = buf->len - offset;
	while(len > 0) {
		err = map_private_extent_buffer(buf, offset, 32,
					&map_token, &kaddr,
					&map_start, &map_len, KM_USER0);
		if (err) {
			printk("failed to map extent buffer! %lu\n",
			       offset);
			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);
	}
	btrfs_csum_final(crc, result);

	if (verify) {
191 192 193 194 195 196 197 198
		int from_this_trans = 0;

		if (root->fs_info->running_transaction &&
		    btrfs_header_generation(buf) ==
		    root->fs_info->running_transaction->transid)
			from_this_trans = 1;

		/* FIXME, this is not good */
199
		if (memcmp_extent_buffer(buf, result, 0, BTRFS_CRC32_SIZE)) {
200 201 202 203 204 205
			u32 val;
			u32 found = 0;
			memcpy(&found, result, BTRFS_CRC32_SIZE);

			read_extent_buffer(buf, &val, 0, BTRFS_CRC32_SIZE);
			printk("btrfs: %s checksum verify failed on %llu "
206 207
			       "wanted %X found %X from_this_trans %d "
			       "level %d\n",
208
			       root->fs_info->sb->s_id,
209 210
			       buf->start, val, found, from_this_trans,
			       btrfs_header_level(buf));
211 212 213 214 215 216 217 218
			return 1;
		}
	} else {
		write_extent_buffer(buf, result, 0, BTRFS_CRC32_SIZE);
	}
	return 0;
}

219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245
static int verify_parent_transid(struct extent_io_tree *io_tree,
				 struct extent_buffer *eb, u64 parent_transid)
{
	int ret;

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

	lock_extent(io_tree, eb->start, eb->start + eb->len - 1, GFP_NOFS);
	if (extent_buffer_uptodate(io_tree, eb) &&
	    btrfs_header_generation(eb) == parent_transid) {
		ret = 0;
		goto out;
	}
	printk("parent transid verify failed on %llu wanted %llu found %llu\n",
	       (unsigned long long)eb->start,
	       (unsigned long long)parent_transid,
	       (unsigned long long)btrfs_header_generation(eb));
	ret = 1;
out:
	clear_extent_buffer_uptodate(io_tree, eb);
	unlock_extent(io_tree, eb->start, eb->start + eb->len - 1,
		      GFP_NOFS);
	return ret;

}

246 247
static int btree_read_extent_buffer_pages(struct btrfs_root *root,
					  struct extent_buffer *eb,
248
					  u64 start, u64 parent_transid)
249 250 251 252 253 254 255 256 257 258
{
	struct extent_io_tree *io_tree;
	int ret;
	int num_copies = 0;
	int mirror_num = 0;

	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);
259 260
		if (!ret &&
		    !verify_parent_transid(io_tree, eb, parent_transid))
261
			return ret;
C
Chris Mason 已提交
262

263 264
		num_copies = btrfs_num_copies(&root->fs_info->mapping_tree,
					      eb->start, eb->len);
C
Chris Mason 已提交
265
		if (num_copies == 1)
266
			return ret;
C
Chris Mason 已提交
267

268
		mirror_num++;
C
Chris Mason 已提交
269
		if (mirror_num > num_copies)
270 271 272 273
			return ret;
	}
	return -EIO;
}
274 275 276

int csum_dirty_buffer(struct btrfs_root *root, struct page *page)
{
277
	struct extent_io_tree *tree;
278
	u64 start = (u64)page->index << PAGE_CACHE_SHIFT;
279 280 281 282
	u64 found_start;
	int found_level;
	unsigned long len;
	struct extent_buffer *eb;
283 284
	int ret;

285
	tree = &BTRFS_I(page->mapping->host)->io_tree;
286 287 288 289 290 291 292 293 294 295

	if (page->private == EXTENT_PAGE_PRIVATE)
		goto out;
	if (!page->private)
		goto out;
	len = page->private >> 2;
	if (len == 0) {
		WARN_ON(1);
	}
	eb = alloc_extent_buffer(tree, start, len, page, GFP_NOFS);
296 297
	ret = btree_read_extent_buffer_pages(root, eb, start + PAGE_CACHE_SIZE,
					     btrfs_header_generation(eb));
298
	BUG_ON(ret);
299 300 301 302
	found_start = btrfs_header_bytenr(eb);
	if (found_start != start) {
		printk("warning: eb start incorrect %Lu buffer %Lu len %lu\n",
		       start, found_start, len);
303 304 305 306 307 308 309 310 311 312 313 314 315
		WARN_ON(1);
		goto err;
	}
	if (eb->first_page != page) {
		printk("bad first page %lu %lu\n", eb->first_page->index,
		       page->index);
		WARN_ON(1);
		goto err;
	}
	if (!PageUptodate(page)) {
		printk("csum not up to date page %lu\n", page->index);
		WARN_ON(1);
		goto err;
316 317
	}
	found_level = btrfs_header_level(eb);
318 319 320
	spin_lock(&root->fs_info->hash_lock);
	btrfs_set_header_flag(eb, BTRFS_HEADER_FLAG_WRITTEN);
	spin_unlock(&root->fs_info->hash_lock);
321
	csum_tree_block(root, eb, 0);
322
err:
323 324 325 326 327
	free_extent_buffer(eb);
out:
	return 0;
}

328
static int btree_writepage_io_hook(struct page *page, u64 start, u64 end)
329
{
330 331 332
	struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;

	csum_dirty_buffer(root, page);
333 334 335
	return 0;
}

336 337 338 339 340 341 342 343 344
int btree_readpage_end_io_hook(struct page *page, u64 start, u64 end,
			       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;
345
	int ret = 0;
346 347 348 349 350 351 352 353 354 355 356

	tree = &BTRFS_I(page->mapping->host)->io_tree;
	if (page->private == EXTENT_PAGE_PRIVATE)
		goto out;
	if (!page->private)
		goto out;
	len = page->private >> 2;
	if (len == 0) {
		WARN_ON(1);
	}
	eb = alloc_extent_buffer(tree, start, len, page, GFP_NOFS);
357

358 359
	found_start = btrfs_header_bytenr(eb);
	if (found_start != start) {
360
		ret = -EIO;
361 362 363 364 365 366
		goto err;
	}
	if (eb->first_page != page) {
		printk("bad first page %lu %lu\n", eb->first_page->index,
		       page->index);
		WARN_ON(1);
367
		ret = -EIO;
368 369
		goto err;
	}
370 371 372 373 374 375 376
	if (memcmp_extent_buffer(eb, root->fs_info->fsid,
				 (unsigned long)btrfs_header_fsid(eb),
				 BTRFS_FSID_SIZE)) {
		printk("bad fsid on block %Lu\n", eb->start);
		ret = -EIO;
		goto err;
	}
377 378 379
	found_level = btrfs_header_level(eb);

	ret = csum_tree_block(root, eb, 1);
380 381
	if (ret)
		ret = -EIO;
382 383 384 385 386 387

	end = min_t(u64, eb->len, PAGE_CACHE_SIZE);
	end = eb->start + end - 1;
err:
	free_extent_buffer(eb);
out:
388
	return ret;
389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407
}

#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
static void end_workqueue_bio(struct bio *bio, int err)
#else
static int end_workqueue_bio(struct bio *bio,
				   unsigned int bytes_done, int err)
#endif
{
	struct end_io_wq *end_io_wq = bio->bi_private;
	struct btrfs_fs_info *fs_info;

#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,23)
	if (bio->bi_size)
		return 1;
#endif

	fs_info = end_io_wq->info;
	end_io_wq->error = err;
408 409
	end_io_wq->work.func = end_workqueue_fn;
	end_io_wq->work.flags = 0;
410 411 412 413 414
	if (bio->bi_rw & (1 << BIO_RW))
		btrfs_queue_worker(&fs_info->endio_write_workers,
				   &end_io_wq->work);
	else
		btrfs_queue_worker(&fs_info->endio_workers, &end_io_wq->work);
415 416 417 418 419 420

#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,23)
	return 0;
#endif
}

421 422
int btrfs_bio_wq_end_io(struct btrfs_fs_info *info, struct bio *bio,
			int metadata)
423
{
424 425 426 427 428 429 430
	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;
431
	end_io_wq->info = info;
432 433
	end_io_wq->error = 0;
	end_io_wq->bio = bio;
434
	end_io_wq->metadata = metadata;
435 436 437

	bio->bi_private = end_io_wq;
	bio->bi_end_io = end_workqueue_bio;
438 439 440
	return 0;
}

441 442 443 444 445 446 447 448 449 450 451 452 453
static void run_one_async_submit(struct btrfs_work *work)
{
	struct btrfs_fs_info *fs_info;
	struct async_submit_bio *async;

	async = container_of(work, struct  async_submit_bio, work);
	fs_info = BTRFS_I(async->inode)->root->fs_info;
	atomic_dec(&fs_info->nr_async_submits);
	async->submit_bio_hook(async->inode, async->rw, async->bio,
			       async->mirror_num);
	kfree(async);
}

454 455 456 457 458 459 460 461 462 463 464 465 466 467 468
int btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info, struct inode *inode,
			int rw, struct bio *bio, int mirror_num,
			extent_submit_bio_hook_t *submit_bio_hook)
{
	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;
	async->submit_bio_hook = submit_bio_hook;
469 470
	async->work.func = run_one_async_submit;
	async->work.flags = 0;
471
	atomic_inc(&fs_info->nr_async_submits);
472
	btrfs_queue_worker(&fs_info->workers, &async->work);
473 474 475 476
	return 0;
}

static int __btree_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
477
				 int mirror_num)
478 479 480 481 482 483 484
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	u64 offset;
	int ret;

	offset = bio->bi_sector << 9;

485 486 487 488
	/*
	 * when we're called for a write, we're already in the async
	 * submission context.  Just jump ingo btrfs_map_bio
	 */
489
	if (rw & (1 << BIO_RW)) {
490 491
		return btrfs_map_bio(BTRFS_I(inode)->root, rw, bio,
				     mirror_num, 0);
492 493
	}

494 495 496 497
	/*
	 * called for a read, do the setup so that checksum validation
	 * can happen in the async kernel threads
	 */
498 499
	ret = btrfs_bio_wq_end_io(root->fs_info, bio, 1);
	BUG_ON(ret);
500

501
	return btrfs_map_bio(BTRFS_I(inode)->root, rw, bio, mirror_num, 1);
502 503
}

504 505 506
static int btree_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
				 int mirror_num)
{
507 508 509 510
	/*
	 * kthread helpers are used to submit writes so that checksumming
	 * can happen in parallel across all CPUs
	 */
511 512 513 514 515 516 517 518
	if (!(rw & (1 << BIO_RW))) {
		return __btree_submit_bio_hook(inode, rw, bio, mirror_num);
	}
	return btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,
				   inode, rw, bio, mirror_num,
				   __btree_submit_bio_hook);
}

519 520
static int btree_writepage(struct page *page, struct writeback_control *wbc)
{
521 522
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
523 524
	return extent_write_full_page(tree, page, btree_get_extent, wbc);
}
525 526 527 528

static int btree_writepages(struct address_space *mapping,
			    struct writeback_control *wbc)
{
529 530
	struct extent_io_tree *tree;
	tree = &BTRFS_I(mapping->host)->io_tree;
531
	if (wbc->sync_mode == WB_SYNC_NONE) {
532 533 534
		u64 num_dirty;
		u64 start = 0;
		unsigned long thresh = 96 * 1024 * 1024;
535 536 537 538

		if (wbc->for_kupdate)
			return 0;

539 540 541 542 543
		if (current_is_pdflush()) {
			thresh = 96 * 1024 * 1024;
		} else {
			thresh = 8 * 1024 * 1024;
		}
544 545
		num_dirty = count_range_bits(tree, &start, (u64)-1,
					     thresh, EXTENT_DIRTY);
546 547 548 549
		if (num_dirty < thresh) {
			return 0;
		}
	}
550 551 552
	return extent_writepages(tree, mapping, btree_get_extent, wbc);
}

553 554
int btree_readpage(struct file *file, struct page *page)
{
555 556
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
557 558
	return extent_read_full_page(tree, page, btree_get_extent);
}
C
Chris Mason 已提交
559

560
static int btree_releasepage(struct page *page, gfp_t gfp_flags)
561
{
562 563
	struct extent_io_tree *tree;
	struct extent_map_tree *map;
564
	int ret;
565

566 567
	tree = &BTRFS_I(page->mapping->host)->io_tree;
	map = &BTRFS_I(page->mapping->host)->extent_tree;
568

569
	ret = try_release_extent_state(map, tree, page, gfp_flags);
570 571 572 573 574
	if (!ret) {
		return 0;
	}

	ret = try_release_extent_buffer(tree, page);
575 576 577 578 579
	if (ret == 1) {
		ClearPagePrivate(page);
		set_page_private(page, 0);
		page_cache_release(page);
	}
580

581 582 583
	return ret;
}

584
static void btree_invalidatepage(struct page *page, unsigned long offset)
585
{
586 587
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
588 589
	extent_invalidatepage(tree, page, offset);
	btree_releasepage(page, GFP_NOFS);
590
	if (PagePrivate(page)) {
591 592
		printk("warning page private not zero on page %Lu\n",
		       page_offset(page));
593 594 595 596
		ClearPagePrivate(page);
		set_page_private(page, 0);
		page_cache_release(page);
	}
597 598
}

599
#if 0
600
static int btree_writepage(struct page *page, struct writeback_control *wbc)
601
{
C
Chris Mason 已提交
602
	struct buffer_head *bh;
603
	struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
C
Chris Mason 已提交
604 605 606 607 608 609 610 611 612 613 614 615
	struct buffer_head *head;
	if (!page_has_buffers(page)) {
		create_empty_buffers(page, root->fs_info->sb->s_blocksize,
					(1 << BH_Dirty)|(1 << BH_Uptodate));
	}
	head = page_buffers(page);
	bh = head;
	do {
		if (buffer_dirty(bh))
			csum_tree_block(root, bh, 0);
		bh = bh->b_this_page;
	} while (bh != head);
616
	return block_write_full_page(page, btree_get_block, wbc);
617
}
618
#endif
619

620 621 622
static struct address_space_operations btree_aops = {
	.readpage	= btree_readpage,
	.writepage	= btree_writepage,
623
	.writepages	= btree_writepages,
624 625
	.releasepage	= btree_releasepage,
	.invalidatepage = btree_invalidatepage,
626 627 628
	.sync_page	= block_sync_page,
};

629 630
int readahead_tree_block(struct btrfs_root *root, u64 bytenr, u32 blocksize,
			 u64 parent_transid)
C
Chris Mason 已提交
631
{
632 633
	struct extent_buffer *buf = NULL;
	struct inode *btree_inode = root->fs_info->btree_inode;
634
	int ret = 0;
C
Chris Mason 已提交
635

636
	buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
637
	if (!buf)
C
Chris Mason 已提交
638
		return 0;
639
	read_extent_buffer_pages(&BTRFS_I(btree_inode)->io_tree,
640
				 buf, 0, 0, btree_get_extent, 0);
641
	free_extent_buffer(buf);
642
	return ret;
C
Chris Mason 已提交
643 644
}

645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667
struct extent_buffer *btrfs_find_tree_block(struct btrfs_root *root,
					    u64 bytenr, u32 blocksize)
{
	struct inode *btree_inode = root->fs_info->btree_inode;
	struct extent_buffer *eb;
	eb = find_extent_buffer(&BTRFS_I(btree_inode)->io_tree,
				bytenr, blocksize, GFP_NOFS);
	return eb;
}

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

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


struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 bytenr,
668
				      u32 blocksize, u64 parent_transid)
669 670 671 672 673 674 675 676 677 678 679 680
{
	struct extent_buffer *buf = NULL;
	struct inode *btree_inode = root->fs_info->btree_inode;
	struct extent_io_tree *io_tree;
	int ret;

	io_tree = &BTRFS_I(btree_inode)->io_tree;

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

681
	ret = btree_read_extent_buffer_pages(root, buf, 0, parent_transid);
682 683 684 685

	if (ret == 0) {
		buf->flags |= EXTENT_UPTODATE;
	}
686
	return buf;
687

688 689
}

690
int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
691
		     struct extent_buffer *buf)
692
{
693
	struct inode *btree_inode = root->fs_info->btree_inode;
694
	if (btrfs_header_generation(buf) ==
695 696
	    root->fs_info->running_transaction->transid) {
		WARN_ON(!btrfs_tree_locked(buf));
697
		clear_extent_buffer_dirty(&BTRFS_I(btree_inode)->io_tree,
698
					  buf);
699
	}
700 701 702 703 704 705 706
	return 0;
}

int wait_on_tree_block_writeback(struct btrfs_root *root,
				 struct extent_buffer *buf)
{
	struct inode *btree_inode = root->fs_info->btree_inode;
707
	wait_on_extent_buffer_writeback(&BTRFS_I(btree_inode)->io_tree,
708 709 710 711
					buf);
	return 0;
}

712
static int __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize,
713
			u32 stripesize, struct btrfs_root *root,
714
			struct btrfs_fs_info *fs_info,
C
Chris Mason 已提交
715
			u64 objectid)
716
{
C
Chris Mason 已提交
717
	root->node = NULL;
718
	root->inode = NULL;
719
	root->commit_root = NULL;
Y
Yan Zheng 已提交
720
	root->ref_tree = NULL;
721 722 723
	root->sectorsize = sectorsize;
	root->nodesize = nodesize;
	root->leafsize = leafsize;
724
	root->stripesize = stripesize;
C
Chris Mason 已提交
725
	root->ref_cows = 0;
726 727
	root->track_dirty = 0;

728
	root->fs_info = fs_info;
729 730
	root->objectid = objectid;
	root->last_trans = 0;
C
Chris Mason 已提交
731 732
	root->highest_inode = 0;
	root->last_inode_alloc = 0;
733
	root->name = NULL;
734
	root->in_sysfs = 0;
735 736

	INIT_LIST_HEAD(&root->dirty_list);
737
	INIT_LIST_HEAD(&root->orphan_list);
738
	spin_lock_init(&root->node_lock);
739
	spin_lock_init(&root->orphan_lock);
740
	mutex_init(&root->objectid_mutex);
C
Chris Mason 已提交
741 742 743 744

	btrfs_leaf_ref_tree_init(&root->ref_tree_struct);
	root->ref_tree = &root->ref_tree_struct;

745 746
	memset(&root->root_key, 0, sizeof(root->root_key));
	memset(&root->root_item, 0, sizeof(root->root_item));
747
	memset(&root->defrag_progress, 0, sizeof(root->defrag_progress));
748
	memset(&root->root_kobj, 0, sizeof(root->root_kobj));
749
	root->defrag_trans_start = fs_info->generation;
750
	init_completion(&root->kobj_unregister);
751 752
	root->defrag_running = 0;
	root->defrag_level = 0;
753
	root->root_key.objectid = objectid;
754 755 756
	return 0;
}

757
static int find_and_setup_root(struct btrfs_root *tree_root,
758 759
			       struct btrfs_fs_info *fs_info,
			       u64 objectid,
C
Chris Mason 已提交
760
			       struct btrfs_root *root)
761 762
{
	int ret;
763
	u32 blocksize;
764

765
	__setup_root(tree_root->nodesize, tree_root->leafsize,
766 767
		     tree_root->sectorsize, tree_root->stripesize,
		     root, fs_info, objectid);
768 769 770 771
	ret = btrfs_find_last_root(tree_root, objectid,
				   &root->root_item, &root->root_key);
	BUG_ON(ret);

772 773
	blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
	root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
774
				     blocksize, 0);
775
	BUG_ON(!root->node);
776 777 778
	return 0;
}

779 780
struct btrfs_root *btrfs_read_fs_root_no_radix(struct btrfs_fs_info *fs_info,
					       struct btrfs_key *location)
781 782 783 784
{
	struct btrfs_root *root;
	struct btrfs_root *tree_root = fs_info->tree_root;
	struct btrfs_path *path;
785
	struct extent_buffer *l;
C
Chris Mason 已提交
786
	u64 highest_inode;
787
	u32 blocksize;
788 789
	int ret = 0;

790
	root = kzalloc(sizeof(*root), GFP_NOFS);
C
Chris Mason 已提交
791
	if (!root)
792 793
		return ERR_PTR(-ENOMEM);
	if (location->offset == (u64)-1) {
794
		ret = find_and_setup_root(tree_root, fs_info,
795 796 797 798 799 800 801 802
					  location->objectid, root);
		if (ret) {
			kfree(root);
			return ERR_PTR(ret);
		}
		goto insert;
	}

803
	__setup_root(tree_root->nodesize, tree_root->leafsize,
804 805
		     tree_root->sectorsize, tree_root->stripesize,
		     root, fs_info, location->objectid);
806 807 808 809 810 811 812 813 814

	path = btrfs_alloc_path();
	BUG_ON(!path);
	ret = btrfs_search_slot(NULL, tree_root, location, path, 0, 0);
	if (ret != 0) {
		if (ret > 0)
			ret = -ENOENT;
		goto out;
	}
815 816 817
	l = path->nodes[0];
	read_extent_buffer(l, &root->root_item,
	       btrfs_item_ptr_offset(l, path->slots[0]),
818
	       sizeof(root->root_item));
819
	memcpy(&root->root_key, location, sizeof(*location));
820 821 822 823 824 825 826 827
	ret = 0;
out:
	btrfs_release_path(root, path);
	btrfs_free_path(path);
	if (ret) {
		kfree(root);
		return ERR_PTR(ret);
	}
828 829
	blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
	root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
830
				     blocksize, 0);
831 832 833
	BUG_ON(!root->node);
insert:
	root->ref_cows = 1;
834 835 836 837 838 839 840 841
	ret = btrfs_find_highest_inode(root, &highest_inode);
	if (ret == 0) {
		root->highest_inode = highest_inode;
		root->last_inode_alloc = highest_inode;
	}
	return root;
}

C
Chris Mason 已提交
842 843 844 845 846 847 848 849 850 851 852 853 854 855 856
struct btrfs_root *btrfs_lookup_fs_root(struct btrfs_fs_info *fs_info,
					u64 root_objectid)
{
	struct btrfs_root *root;

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

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

857 858
struct btrfs_root *btrfs_read_fs_root_no_name(struct btrfs_fs_info *fs_info,
					      struct btrfs_key *location)
859 860 861 862
{
	struct btrfs_root *root;
	int ret;

863 864 865 866
	if (location->objectid == BTRFS_ROOT_TREE_OBJECTID)
		return fs_info->tree_root;
	if (location->objectid == BTRFS_EXTENT_TREE_OBJECTID)
		return fs_info->extent_root;
867 868 869 870
	if (location->objectid == BTRFS_CHUNK_TREE_OBJECTID)
		return fs_info->chunk_root;
	if (location->objectid == BTRFS_DEV_TREE_OBJECTID)
		return fs_info->dev_root;
871

872 873 874 875 876 877 878 879
	root = radix_tree_lookup(&fs_info->fs_roots_radix,
				 (unsigned long)location->objectid);
	if (root)
		return root;

	root = btrfs_read_fs_root_no_radix(fs_info, location);
	if (IS_ERR(root))
		return root;
C
Chris Mason 已提交
880 881
	ret = radix_tree_insert(&fs_info->fs_roots_radix,
				(unsigned long)root->root_key.objectid,
882 883
				root);
	if (ret) {
884
		free_extent_buffer(root->node);
885 886 887
		kfree(root);
		return ERR_PTR(ret);
	}
888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904
	ret = btrfs_find_dead_roots(fs_info->tree_root,
				    root->root_key.objectid, root);
	BUG_ON(ret);

	return root;
}

struct btrfs_root *btrfs_read_fs_root(struct btrfs_fs_info *fs_info,
				      struct btrfs_key *location,
				      const char *name, int namelen)
{
	struct btrfs_root *root;
	int ret;

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

906 907 908
	if (root->in_sysfs)
		return root;

909 910
	ret = btrfs_set_root_name(root, name, namelen);
	if (ret) {
911
		free_extent_buffer(root->node);
912 913 914 915 916 917
		kfree(root);
		return ERR_PTR(ret);
	}

	ret = btrfs_sysfs_add_root(root);
	if (ret) {
918
		free_extent_buffer(root->node);
919 920 921 922
		kfree(root->name);
		kfree(root);
		return ERR_PTR(ret);
	}
923
	root->in_sysfs = 1;
924 925
	return root;
}
926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943
#if 0
static int add_hasher(struct btrfs_fs_info *info, char *type) {
	struct btrfs_hasher *hasher;

	hasher = kmalloc(sizeof(*hasher), GFP_NOFS);
	if (!hasher)
		return -ENOMEM;
	hasher->hash_tfm = crypto_alloc_hash(type, 0, CRYPTO_ALG_ASYNC);
	if (!hasher->hash_tfm) {
		kfree(hasher);
		return -EINVAL;
	}
	spin_lock(&info->hash_lock);
	list_add(&hasher->list, &info->hashers);
	spin_unlock(&info->hash_lock);
	return 0;
}
#endif
C
Chris Mason 已提交
944 945 946 947 948

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;
949
	int limit = 256 * info->fs_devices->open_devices;
C
Chris Mason 已提交
950 951 952 953
	struct list_head *cur;
	struct btrfs_device *device;
	struct backing_dev_info *bdi;

954 955 956 957 958
	if ((bdi_bits & (1 << BDI_write_congested)) &&
	    atomic_read(&info->nr_async_submits) > limit) {
		return 1;
	}

C
Chris Mason 已提交
959 960
	list_for_each(cur, &info->fs_devices->devices) {
		device = list_entry(cur, struct btrfs_device, dev_list);
961 962
		if (!device->bdev)
			continue;
C
Chris Mason 已提交
963 964 965 966 967 968 969 970 971
		bdi = blk_get_backing_dev_info(device->bdev);
		if (bdi && bdi_congested(bdi, bdi_bits)) {
			ret = 1;
			break;
		}
	}
	return ret;
}

972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991
/*
 * this unplugs every device on the box, and it is only used when page
 * is null
 */
static void __unplug_io_fn(struct backing_dev_info *bdi, struct page *page)
{
	struct list_head *cur;
	struct btrfs_device *device;
	struct btrfs_fs_info *info;

	info = (struct btrfs_fs_info *)bdi->unplug_io_data;
	list_for_each(cur, &info->fs_devices->devices) {
		device = list_entry(cur, struct btrfs_device, dev_list);
		bdi = blk_get_backing_dev_info(device->bdev);
		if (bdi->unplug_io_fn) {
			bdi->unplug_io_fn(bdi, page);
		}
	}
}

C
Chris Mason 已提交
992 993
void btrfs_unplug_io_fn(struct backing_dev_info *bdi, struct page *page)
{
994
	struct inode *inode;
995 996
	struct extent_map_tree *em_tree;
	struct extent_map *em;
997
	struct address_space *mapping;
998 999
	u64 offset;

1000
	/* the generic O_DIRECT read code does this */
1001 1002 1003 1004 1005
	if (!page) {
		__unplug_io_fn(bdi, page);
		return;
	}

1006 1007 1008 1009 1010 1011 1012 1013 1014 1015
	/*
	 * page->mapping may change at any time.  Get a consistent copy
	 * and use that for everything below
	 */
	smp_mb();
	mapping = page->mapping;
	if (!mapping)
		return;

	inode = mapping->host;
1016
	offset = page_offset(page);
C
Chris Mason 已提交
1017

1018 1019 1020 1021
	em_tree = &BTRFS_I(inode)->extent_tree;
	spin_lock(&em_tree->lock);
	em = lookup_extent_mapping(em_tree, offset, PAGE_CACHE_SIZE);
	spin_unlock(&em_tree->lock);
1022 1023
	if (!em) {
		__unplug_io_fn(bdi, page);
1024
		return;
1025
	}
1026

1027 1028 1029 1030 1031
	if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
		free_extent_map(em);
		__unplug_io_fn(bdi, page);
		return;
	}
1032 1033 1034 1035
	offset = offset - em->start;
	btrfs_unplug_page(&BTRFS_I(inode)->root->fs_info->mapping_tree,
			  em->block_start + offset, page);
	free_extent_map(em);
C
Chris Mason 已提交
1036 1037 1038 1039
}

static int setup_bdi(struct btrfs_fs_info *info, struct backing_dev_info *bdi)
{
1040
#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
C
Chris Mason 已提交
1041
	bdi_init(bdi);
1042
#endif
1043
	bdi->ra_pages	= default_backing_dev_info.ra_pages;
C
Chris Mason 已提交
1044 1045 1046 1047 1048 1049 1050 1051 1052
	bdi->state		= 0;
	bdi->capabilities	= default_backing_dev_info.capabilities;
	bdi->unplug_io_fn	= btrfs_unplug_io_fn;
	bdi->unplug_io_data	= info;
	bdi->congested_fn	= btrfs_congested_fn;
	bdi->congested_data	= info;
	return 0;
}

1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091
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 btrfs_fs_info *info = 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;
		info = BTRFS_I(page->mapping->host)->root->fs_info;
	}
	/* 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);
	if (ret == 1)
		return ret;
	return ret;
}

1092 1093 1094 1095 1096
/*
 * 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)
1097 1098
{
	struct bio *bio;
1099 1100
	struct end_io_wq *end_io_wq;
	struct btrfs_fs_info *fs_info;
1101 1102
	int error;

1103 1104 1105
	end_io_wq = container_of(work, struct end_io_wq, work);
	bio = end_io_wq->bio;
	fs_info = end_io_wq->info;
1106

1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122
	/* metadata bios are special because the whole tree block must
	 * 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
	 */
	if (end_io_wq->metadata && !bio_ready_for_csum(bio)) {
		btrfs_queue_worker(&fs_info->endio_workers,
				   &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);
#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,23)
	bio_endio(bio, bio->bi_size, error);
1123
#else
1124
	bio_endio(bio, error);
1125 1126 1127
#endif
}

1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173
static int cleaner_kthread(void *arg)
{
	struct btrfs_root *root = arg;

	do {
		smp_mb();
		if (root->fs_info->closing)
			break;

		vfs_check_frozen(root->fs_info->sb, SB_FREEZE_WRITE);
		mutex_lock(&root->fs_info->cleaner_mutex);
		btrfs_clean_old_snapshots(root);
		mutex_unlock(&root->fs_info->cleaner_mutex);

		if (freezing(current)) {
			refrigerator();
		} else {
			smp_mb();
			if (root->fs_info->closing)
				break;
			set_current_state(TASK_INTERRUPTIBLE);
			schedule();
			__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;
	unsigned long now;
	unsigned long delay;
	int ret;

	do {
		smp_mb();
		if (root->fs_info->closing)
			break;

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

Y
Yan Zheng 已提交
1174 1175 1176
		printk("btrfs: total reference cache size %Lu\n",
			root->fs_info->total_ref_cache_size);

1177 1178 1179 1180 1181 1182
		mutex_lock(&root->fs_info->trans_mutex);
		cur = root->fs_info->running_transaction;
		if (!cur) {
			mutex_unlock(&root->fs_info->trans_mutex);
			goto sleep;
		}
Y
Yan Zheng 已提交
1183

1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209
		now = get_seconds();
		if (now < cur->start_time || now - cur->start_time < 30) {
			mutex_unlock(&root->fs_info->trans_mutex);
			delay = HZ * 5;
			goto sleep;
		}
		mutex_unlock(&root->fs_info->trans_mutex);
		trans = btrfs_start_transaction(root, 1);
		ret = btrfs_commit_transaction(trans, root);
sleep:
		wake_up_process(root->fs_info->cleaner_kthread);
		mutex_unlock(&root->fs_info->transaction_kthread_mutex);

		if (freezing(current)) {
			refrigerator();
		} else {
			if (root->fs_info->closing)
				break;
			set_current_state(TASK_INTERRUPTIBLE);
			schedule_timeout(delay);
			__set_current_state(TASK_RUNNING);
		}
	} while (!kthread_should_stop());
	return 0;
}

1210
struct btrfs_root *open_ctree(struct super_block *sb,
1211 1212
			      struct btrfs_fs_devices *fs_devices,
			      char *options)
1213
{
1214 1215 1216 1217
	u32 sectorsize;
	u32 nodesize;
	u32 leafsize;
	u32 blocksize;
1218
	u32 stripesize;
1219
	struct buffer_head *bh;
C
Chris Mason 已提交
1220 1221 1222 1223
	struct btrfs_root *extent_root = kmalloc(sizeof(struct btrfs_root),
						 GFP_NOFS);
	struct btrfs_root *tree_root = kmalloc(sizeof(struct btrfs_root),
					       GFP_NOFS);
1224
	struct btrfs_fs_info *fs_info = kzalloc(sizeof(*fs_info),
C
Chris Mason 已提交
1225
						GFP_NOFS);
1226 1227 1228 1229
	struct btrfs_root *chunk_root = kmalloc(sizeof(struct btrfs_root),
						GFP_NOFS);
	struct btrfs_root *dev_root = kmalloc(sizeof(struct btrfs_root),
					      GFP_NOFS);
1230
	int ret;
1231
	int err = -EINVAL;
1232

C
Chris Mason 已提交
1233
	struct btrfs_super_block *disk_super;
1234

C
Chris Mason 已提交
1235 1236 1237 1238
	if (!extent_root || !tree_root || !fs_info) {
		err = -ENOMEM;
		goto fail;
	}
1239
	INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_NOFS);
C
Chris Mason 已提交
1240
	INIT_LIST_HEAD(&fs_info->trans_list);
1241
	INIT_LIST_HEAD(&fs_info->dead_roots);
1242 1243
	INIT_LIST_HEAD(&fs_info->hashers);
	spin_lock_init(&fs_info->hash_lock);
1244
	spin_lock_init(&fs_info->delalloc_lock);
1245
	spin_lock_init(&fs_info->new_trans_lock);
Y
Yan Zheng 已提交
1246
	spin_lock_init(&fs_info->ref_cache_lock);
1247

1248
	init_completion(&fs_info->kobj_unregister);
1249 1250
	fs_info->tree_root = tree_root;
	fs_info->extent_root = extent_root;
1251 1252
	fs_info->chunk_root = chunk_root;
	fs_info->dev_root = dev_root;
1253
	fs_info->fs_devices = fs_devices;
1254
	INIT_LIST_HEAD(&fs_info->dirty_cowonly_roots);
1255
	INIT_LIST_HEAD(&fs_info->space_info);
1256
	btrfs_mapping_init(&fs_info->mapping_tree);
1257
	atomic_set(&fs_info->nr_async_submits, 0);
1258
	atomic_set(&fs_info->throttles, 0);
C
Chris Mason 已提交
1259
	fs_info->sb = sb;
1260
	fs_info->max_extent = (u64)-1;
1261
	fs_info->max_inline = 8192 * 1024;
C
Chris Mason 已提交
1262
	setup_bdi(fs_info, &fs_info->bdi);
1263 1264
	fs_info->btree_inode = new_inode(sb);
	fs_info->btree_inode->i_ino = 1;
C
Chris Mason 已提交
1265
	fs_info->btree_inode->i_nlink = 1;
1266
	fs_info->thread_pool_size = min(num_online_cpus() + 2, 8);
1267

1268 1269 1270
	INIT_LIST_HEAD(&fs_info->ordered_extents);
	spin_lock_init(&fs_info->ordered_extent_lock);

1271 1272 1273
	sb->s_blocksize = 4096;
	sb->s_blocksize_bits = blksize_bits(4096);

1274 1275 1276 1277 1278 1279
	/*
	 * 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;
1280
	fs_info->btree_inode->i_mapping->a_ops = &btree_aops;
C
Chris Mason 已提交
1281 1282
	fs_info->btree_inode->i_mapping->backing_dev_info = &fs_info->bdi;

1283
	extent_io_tree_init(&BTRFS_I(fs_info->btree_inode)->io_tree,
1284 1285
			     fs_info->btree_inode->i_mapping,
			     GFP_NOFS);
1286 1287 1288 1289
	extent_map_tree_init(&BTRFS_I(fs_info->btree_inode)->extent_tree,
			     GFP_NOFS);

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

1291
	extent_io_tree_init(&fs_info->free_space_cache,
1292
			     fs_info->btree_inode->i_mapping, GFP_NOFS);
1293
	extent_io_tree_init(&fs_info->block_group_cache,
1294
			     fs_info->btree_inode->i_mapping, GFP_NOFS);
1295
	extent_io_tree_init(&fs_info->pinned_extents,
1296
			     fs_info->btree_inode->i_mapping, GFP_NOFS);
1297
	extent_io_tree_init(&fs_info->pending_del,
1298
			     fs_info->btree_inode->i_mapping, GFP_NOFS);
1299
	extent_io_tree_init(&fs_info->extent_ins,
1300
			     fs_info->btree_inode->i_mapping, GFP_NOFS);
1301
	fs_info->do_barriers = 1;
1302

1303 1304 1305
	BTRFS_I(fs_info->btree_inode)->root = tree_root;
	memset(&BTRFS_I(fs_info->btree_inode)->location, 0,
	       sizeof(struct btrfs_key));
C
Chris Mason 已提交
1306
	insert_inode_hash(fs_info->btree_inode);
1307
	mapping_set_gfp_mask(fs_info->btree_inode->i_mapping, GFP_NOFS);
C
Chris Mason 已提交
1308

C
Chris Mason 已提交
1309
	mutex_init(&fs_info->trans_mutex);
1310
	mutex_init(&fs_info->drop_mutex);
1311 1312
	mutex_init(&fs_info->alloc_mutex);
	mutex_init(&fs_info->chunk_mutex);
1313 1314
	mutex_init(&fs_info->transaction_kthread_mutex);
	mutex_init(&fs_info->cleaner_mutex);
1315
	mutex_init(&fs_info->volume_mutex);
1316
	init_waitqueue_head(&fs_info->transaction_throttle);
1317
	init_waitqueue_head(&fs_info->transaction_wait);
1318

1319 1320 1321 1322 1323 1324 1325 1326
#if 0
	ret = add_hasher(fs_info, "crc32c");
	if (ret) {
		printk("btrfs: failed hash setup, modprobe cryptomgr?\n");
		err = -ENOMEM;
		goto fail_iput;
	}
#endif
1327
	__setup_root(4096, 4096, 4096, 4096, tree_root,
C
Chris Mason 已提交
1328
		     fs_info, BTRFS_ROOT_TREE_OBJECTID);
1329

1330

1331 1332 1333
	bh = __bread(fs_devices->latest_bdev,
		     BTRFS_SUPER_INFO_OFFSET / 4096, 4096);
	if (!bh)
C
Chris Mason 已提交
1334 1335
		goto fail_iput;

1336 1337
	memcpy(&fs_info->super_copy, bh->b_data, sizeof(fs_info->super_copy));
	brelse(bh);
1338

1339
	memcpy(fs_info->fsid, fs_info->super_copy.fsid, BTRFS_FSID_SIZE);
1340

1341
	disk_super = &fs_info->super_copy;
1342
	if (!btrfs_super_root(disk_super))
C
Chris Mason 已提交
1343
		goto fail_sb_buffer;
1344

1345 1346 1347
	err = btrfs_parse_options(tree_root, options);
	if (err)
		goto fail_sb_buffer;
1348

1349 1350 1351 1352 1353 1354
	/*
	 * we need to start all the end_io workers up front because the
	 * queue work function gets called at interrupt time, and so it
	 * cannot dynamically grow.
	 */
	btrfs_init_workers(&fs_info->workers, fs_info->thread_pool_size);
1355
	btrfs_init_workers(&fs_info->submit_workers, fs_info->thread_pool_size);
1356
	btrfs_init_workers(&fs_info->fixup_workers, 1);
1357
	btrfs_init_workers(&fs_info->endio_workers, fs_info->thread_pool_size);
1358 1359
	btrfs_init_workers(&fs_info->endio_write_workers,
			   fs_info->thread_pool_size);
1360
	btrfs_start_workers(&fs_info->workers, 1);
1361
	btrfs_start_workers(&fs_info->submit_workers, 1);
1362
	btrfs_start_workers(&fs_info->fixup_workers, 1);
1363
	btrfs_start_workers(&fs_info->endio_workers, fs_info->thread_pool_size);
1364 1365
	btrfs_start_workers(&fs_info->endio_write_workers,
			    fs_info->thread_pool_size);
1366

1367
	err = -EINVAL;
1368
	if (btrfs_super_num_devices(disk_super) > fs_devices->open_devices) {
1369 1370
		printk("Btrfs: wanted %llu devices, but found %llu\n",
		       (unsigned long long)btrfs_super_num_devices(disk_super),
1371
		       (unsigned long long)fs_devices->open_devices);
1372 1373 1374 1375 1376
		if (btrfs_test_opt(tree_root, DEGRADED))
			printk("continuing in degraded mode\n");
		else {
			goto fail_sb_buffer;
		}
1377
	}
1378

1379 1380
	fs_info->bdi.ra_pages *= btrfs_super_num_devices(disk_super);

1381 1382 1383
	nodesize = btrfs_super_nodesize(disk_super);
	leafsize = btrfs_super_leafsize(disk_super);
	sectorsize = btrfs_super_sectorsize(disk_super);
1384
	stripesize = btrfs_super_stripesize(disk_super);
1385 1386 1387
	tree_root->nodesize = nodesize;
	tree_root->leafsize = leafsize;
	tree_root->sectorsize = sectorsize;
1388
	tree_root->stripesize = stripesize;
1389 1390 1391

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

C
Chris Mason 已提交
1393 1394 1395 1396 1397
	if (strncmp((char *)(&disk_super->magic), BTRFS_MAGIC,
		    sizeof(disk_super->magic))) {
		printk("btrfs: valid FS not found on %s\n", sb->s_id);
		goto fail_sb_buffer;
	}
1398

1399
	mutex_lock(&fs_info->chunk_mutex);
1400
	ret = btrfs_read_sys_array(tree_root);
1401
	mutex_unlock(&fs_info->chunk_mutex);
1402 1403 1404 1405 1406
	if (ret) {
		printk("btrfs: failed to read the system array on %s\n",
		       sb->s_id);
		goto fail_sys_array;
	}
1407 1408 1409 1410 1411 1412 1413 1414 1415

	blocksize = btrfs_level_size(tree_root,
				     btrfs_super_chunk_root_level(disk_super));

	__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),
1416
					   blocksize, 0);
1417 1418
	BUG_ON(!chunk_root->node);

1419 1420 1421 1422
	read_extent_buffer(chunk_root->node, fs_info->chunk_tree_uuid,
	         (unsigned long)btrfs_header_chunk_tree_uuid(chunk_root->node),
		 BTRFS_UUID_SIZE);

1423
	mutex_lock(&fs_info->chunk_mutex);
1424
	ret = btrfs_read_chunk_tree(chunk_root);
1425
	mutex_unlock(&fs_info->chunk_mutex);
1426 1427
	BUG_ON(ret);

1428 1429
	btrfs_close_extra_devices(fs_devices);

1430 1431
	blocksize = btrfs_level_size(tree_root,
				     btrfs_super_root_level(disk_super));
1432

1433

C
Chris Mason 已提交
1434
	tree_root->node = read_tree_block(tree_root,
1435
					  btrfs_super_root(disk_super),
1436
					  blocksize, 0);
C
Chris Mason 已提交
1437 1438
	if (!tree_root->node)
		goto fail_sb_buffer;
1439

1440 1441

	ret = find_and_setup_root(tree_root, fs_info,
C
Chris Mason 已提交
1442
				  BTRFS_EXTENT_TREE_OBJECTID, extent_root);
1443
	if (ret)
C
Chris Mason 已提交
1444
		goto fail_tree_root;
1445 1446 1447 1448 1449 1450 1451 1452
	extent_root->track_dirty = 1;

	ret = find_and_setup_root(tree_root, fs_info,
				  BTRFS_DEV_TREE_OBJECTID, dev_root);
	dev_root->track_dirty = 1;

	if (ret)
		goto fail_extent_root;
1453

C
Chris Mason 已提交
1454 1455
	btrfs_read_block_groups(extent_root);

1456
	fs_info->generation = btrfs_super_generation(disk_super) + 1;
C
Chris Mason 已提交
1457 1458 1459
	fs_info->data_alloc_profile = (u64)-1;
	fs_info->metadata_alloc_profile = (u64)-1;
	fs_info->system_alloc_profile = fs_info->metadata_alloc_profile;
1460 1461 1462 1463 1464 1465 1466 1467 1468
	fs_info->cleaner_kthread = kthread_run(cleaner_kthread, tree_root,
					       "btrfs-cleaner");
	if (!fs_info->cleaner_kthread)
		goto fail_extent_root;

	fs_info->transaction_kthread = kthread_run(transaction_kthread,
						   tree_root,
						   "btrfs-transaction");
	if (!fs_info->transaction_kthread)
1469
		goto fail_cleaner;
1470

C
Chris Mason 已提交
1471

1472
	return tree_root;
C
Chris Mason 已提交
1473

1474
fail_cleaner:
1475
	kthread_stop(fs_info->cleaner_kthread);
1476 1477
fail_extent_root:
	free_extent_buffer(extent_root->node);
C
Chris Mason 已提交
1478
fail_tree_root:
1479
	free_extent_buffer(tree_root->node);
1480
fail_sys_array:
C
Chris Mason 已提交
1481
fail_sb_buffer:
1482
	btrfs_stop_workers(&fs_info->fixup_workers);
1483 1484
	btrfs_stop_workers(&fs_info->workers);
	btrfs_stop_workers(&fs_info->endio_workers);
1485
	btrfs_stop_workers(&fs_info->endio_write_workers);
1486
	btrfs_stop_workers(&fs_info->submit_workers);
1487 1488
fail_iput:
	iput(fs_info->btree_inode);
C
Chris Mason 已提交
1489
fail:
1490
	btrfs_close_devices(fs_info->fs_devices);
1491 1492
	btrfs_mapping_tree_free(&fs_info->mapping_tree);

C
Chris Mason 已提交
1493 1494
	kfree(extent_root);
	kfree(tree_root);
1495
#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
1496
	bdi_destroy(&fs_info->bdi);
1497
#endif
C
Chris Mason 已提交
1498 1499
	kfree(fs_info);
	return ERR_PTR(err);
1500 1501
}

1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513
static void btrfs_end_buffer_write_sync(struct buffer_head *bh, int uptodate)
{
	char b[BDEVNAME_SIZE];

	if (uptodate) {
		set_buffer_uptodate(bh);
	} else {
		if (!buffer_eopnotsupp(bh) && printk_ratelimit()) {
			printk(KERN_WARNING "lost page write due to "
					"I/O error on %s\n",
				       bdevname(bh->b_bdev, b));
		}
1514 1515 1516
		/* note, we dont' set_buffer_write_io_error because we have
		 * our own ways of dealing with the IO errors
		 */
1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527
		clear_buffer_uptodate(bh);
	}
	unlock_buffer(bh);
	put_bh(bh);
}

int write_all_supers(struct btrfs_root *root)
{
	struct list_head *cur;
	struct list_head *head = &root->fs_info->fs_devices->devices;
	struct btrfs_device *dev;
1528
	struct btrfs_super_block *sb;
1529 1530 1531 1532
	struct btrfs_dev_item *dev_item;
	struct buffer_head *bh;
	int ret;
	int do_barriers;
1533 1534
	int max_errors;
	int total_errors = 0;
1535 1536
	u32 crc;
	u64 flags;
1537

1538
	max_errors = btrfs_super_num_devices(&root->fs_info->super_copy) - 1;
1539 1540
	do_barriers = !btrfs_test_opt(root, NOBARRIER);

1541 1542
	sb = &root->fs_info->super_for_commit;
	dev_item = &sb->dev_item;
1543 1544
	list_for_each(cur, head) {
		dev = list_entry(cur, struct btrfs_device, dev_list);
1545 1546 1547 1548 1549 1550 1551
		if (!dev->bdev) {
			total_errors++;
			continue;
		}
		if (!dev->in_fs_metadata)
			continue;

1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569
		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);
		flags = btrfs_super_flags(sb);
		btrfs_set_super_flags(sb, flags | BTRFS_HEADER_FLAG_WRITTEN);


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

		bh = __getblk(dev->bdev, BTRFS_SUPER_INFO_OFFSET / 4096,
1570 1571
			      BTRFS_SUPER_INFO_SIZE);

1572
		memcpy(bh->b_data, sb, BTRFS_SUPER_INFO_SIZE);
1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593
		dev->pending_io = bh;

		get_bh(bh);
		set_buffer_uptodate(bh);
		lock_buffer(bh);
		bh->b_end_io = btrfs_end_buffer_write_sync;

		if (do_barriers && dev->barriers) {
			ret = submit_bh(WRITE_BARRIER, bh);
			if (ret == -EOPNOTSUPP) {
				printk("btrfs: disabling barriers on dev %s\n",
				       dev->name);
				set_buffer_uptodate(bh);
				dev->barriers = 0;
				get_bh(bh);
				lock_buffer(bh);
				ret = submit_bh(WRITE, bh);
			}
		} else {
			ret = submit_bh(WRITE, bh);
		}
1594 1595
		if (ret)
			total_errors++;
1596
	}
1597 1598 1599 1600 1601
	if (total_errors > max_errors) {
		printk("btrfs: %d errors while writing supers\n", total_errors);
		BUG();
	}
	total_errors = 0;
1602 1603 1604

	list_for_each(cur, head) {
		dev = list_entry(cur, struct btrfs_device, dev_list);
1605 1606 1607 1608 1609
		if (!dev->bdev)
			continue;
		if (!dev->in_fs_metadata)
			continue;

1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623
		BUG_ON(!dev->pending_io);
		bh = dev->pending_io;
		wait_on_buffer(bh);
		if (!buffer_uptodate(dev->pending_io)) {
			if (do_barriers && dev->barriers) {
				printk("btrfs: disabling barriers on dev %s\n",
				       dev->name);
				set_buffer_uptodate(bh);
				get_bh(bh);
				lock_buffer(bh);
				dev->barriers = 0;
				ret = submit_bh(WRITE, bh);
				BUG_ON(ret);
				wait_on_buffer(bh);
1624 1625
				if (!buffer_uptodate(bh))
					total_errors++;
1626
			} else {
1627
				total_errors++;
1628 1629 1630 1631 1632 1633
			}

		}
		dev->pending_io = NULL;
		brelse(bh);
	}
1634 1635 1636 1637
	if (total_errors > max_errors) {
		printk("btrfs: %d errors while writing supers\n", total_errors);
		BUG();
	}
1638 1639 1640
	return 0;
}

1641
int write_ctree_super(struct btrfs_trans_handle *trans, struct btrfs_root
C
Chris Mason 已提交
1642
		      *root)
1643
{
1644
	int ret;
1645

1646
	ret = write_all_supers(root);
1647
	return ret;
C
Chris Mason 已提交
1648 1649
}

1650
int btrfs_free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root)
C
Chris Mason 已提交
1651 1652 1653
{
	radix_tree_delete(&fs_info->fs_roots_radix,
			  (unsigned long)root->root_key.objectid);
1654 1655
	if (root->in_sysfs)
		btrfs_sysfs_del_root(root);
C
Chris Mason 已提交
1656 1657 1658
	if (root->inode)
		iput(root->inode);
	if (root->node)
1659
		free_extent_buffer(root->node);
C
Chris Mason 已提交
1660
	if (root->commit_root)
1661
		free_extent_buffer(root->commit_root);
1662 1663
	if (root->name)
		kfree(root->name);
C
Chris Mason 已提交
1664 1665 1666 1667
	kfree(root);
	return 0;
}

C
Chris Mason 已提交
1668
static int del_fs_roots(struct btrfs_fs_info *fs_info)
1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679
{
	int ret;
	struct btrfs_root *gang[8];
	int i;

	while(1) {
		ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
					     (void **)gang, 0,
					     ARRAY_SIZE(gang));
		if (!ret)
			break;
C
Chris Mason 已提交
1680
		for (i = 0; i < ret; i++)
1681
			btrfs_free_fs_root(fs_info, gang[i]);
1682 1683 1684
	}
	return 0;
}
1685

C
Chris Mason 已提交
1686
int close_ctree(struct btrfs_root *root)
C
Chris Mason 已提交
1687
{
1688
	int ret;
1689
	struct btrfs_trans_handle *trans;
1690
	struct btrfs_fs_info *fs_info = root->fs_info;
1691

1692
	fs_info->closing = 1;
1693 1694
	smp_mb();

1695 1696 1697 1698
	kthread_stop(root->fs_info->transaction_kthread);
	kthread_stop(root->fs_info->cleaner_kthread);

	btrfs_clean_old_snapshots(root);
C
Chris Mason 已提交
1699
	trans = btrfs_start_transaction(root, 1);
1700
	ret = btrfs_commit_transaction(trans, root);
C
Chris Mason 已提交
1701 1702 1703 1704
	/* run commit again to  drop the original snapshot */
	trans = btrfs_start_transaction(root, 1);
	btrfs_commit_transaction(trans, root);
	ret = btrfs_write_and_wait_transaction(NULL, root);
1705
	BUG_ON(ret);
1706

C
Chris Mason 已提交
1707
	write_ctree_super(NULL, root);
1708

C
Chris Mason 已提交
1709 1710 1711 1712
	if (fs_info->delalloc_bytes) {
		printk("btrfs: at unmount delalloc count %Lu\n",
		       fs_info->delalloc_bytes);
	}
Y
Yan Zheng 已提交
1713 1714 1715 1716 1717
	if (fs_info->total_ref_cache_size) {
		printk("btrfs: at umount reference cache size %Lu\n",
			fs_info->total_ref_cache_size);
	}
	
1718
	if (fs_info->extent_root->node)
1719
		free_extent_buffer(fs_info->extent_root->node);
1720

1721
	if (fs_info->tree_root->node)
1722
		free_extent_buffer(fs_info->tree_root->node);
1723

1724 1725 1726 1727 1728 1729
	if (root->fs_info->chunk_root->node);
		free_extent_buffer(root->fs_info->chunk_root->node);

	if (root->fs_info->dev_root->node);
		free_extent_buffer(root->fs_info->dev_root->node);

C
Chris Mason 已提交
1730
	btrfs_free_block_groups(root->fs_info);
1731
	del_fs_roots(fs_info);
1732 1733 1734

	filemap_write_and_wait(fs_info->btree_inode->i_mapping);

1735
	truncate_inode_pages(fs_info->btree_inode->i_mapping, 0);
1736

1737
	btrfs_stop_workers(&fs_info->fixup_workers);
1738 1739
	btrfs_stop_workers(&fs_info->workers);
	btrfs_stop_workers(&fs_info->endio_workers);
1740
	btrfs_stop_workers(&fs_info->endio_write_workers);
1741
	btrfs_stop_workers(&fs_info->submit_workers);
1742

1743
	iput(fs_info->btree_inode);
1744 1745 1746 1747 1748 1749 1750 1751 1752 1753
#if 0
	while(!list_empty(&fs_info->hashers)) {
		struct btrfs_hasher *hasher;
		hasher = list_entry(fs_info->hashers.next, struct btrfs_hasher,
				    hashers);
		list_del(&hasher->hashers);
		crypto_free_hash(&fs_info->hash_tfm);
		kfree(hasher);
	}
#endif
1754
	btrfs_close_devices(fs_info->fs_devices);
1755
	btrfs_mapping_tree_free(&fs_info->mapping_tree);
1756

1757
#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
C
Chris Mason 已提交
1758
	bdi_destroy(&fs_info->bdi);
1759
#endif
1760

1761 1762
	kfree(fs_info->extent_root);
	kfree(fs_info->tree_root);
1763 1764
	kfree(fs_info->chunk_root);
	kfree(fs_info->dev_root);
1765 1766 1767
	return 0;
}

1768
int btrfs_buffer_uptodate(struct extent_buffer *buf, u64 parent_transid)
1769
{
1770
	int ret;
1771
	struct inode *btree_inode = buf->first_page->mapping->host;
1772 1773 1774 1775 1776 1777 1778 1779

	ret = extent_buffer_uptodate(&BTRFS_I(btree_inode)->io_tree, buf);
	if (!ret)
		return ret;

	ret = verify_parent_transid(&BTRFS_I(btree_inode)->io_tree, buf,
				    parent_transid);
	return !ret;
1780 1781 1782
}

int btrfs_set_buffer_uptodate(struct extent_buffer *buf)
C
Chris Mason 已提交
1783
{
1784
	struct inode *btree_inode = buf->first_page->mapping->host;
1785
	return set_extent_buffer_uptodate(&BTRFS_I(btree_inode)->io_tree,
1786 1787
					  buf);
}
1788

1789 1790
void btrfs_mark_buffer_dirty(struct extent_buffer *buf)
{
1791
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
1792 1793
	u64 transid = btrfs_header_generation(buf);
	struct inode *btree_inode = root->fs_info->btree_inode;
1794

1795
	WARN_ON(!btrfs_tree_locked(buf));
C
Chris Mason 已提交
1796 1797
	if (transid != root->fs_info->generation) {
		printk(KERN_CRIT "transid mismatch buffer %llu, found %Lu running %Lu\n",
1798
			(unsigned long long)buf->start,
C
Chris Mason 已提交
1799 1800 1801
			transid, root->fs_info->generation);
		WARN_ON(1);
	}
1802
	set_extent_buffer_dirty(&BTRFS_I(btree_inode)->io_tree, buf);
1803 1804
}

1805
void btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr)
C
Chris Mason 已提交
1806
{
1807 1808 1809 1810
	/*
	 * looks as though older kernels can get into trouble with
	 * this code, they end up stuck in balance_dirty_pages forever
	 */
1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823
	struct extent_io_tree *tree;
	u64 num_dirty;
	u64 start = 0;
	unsigned long thresh = 16 * 1024 * 1024;
	tree = &BTRFS_I(root->fs_info->btree_inode)->io_tree;

	if (current_is_pdflush())
		return;

	num_dirty = count_range_bits(tree, &start, (u64)-1,
				     thresh, EXTENT_DIRTY);
	if (num_dirty > thresh) {
		balance_dirty_pages_ratelimited_nr(
C
Chris Mason 已提交
1824
				   root->fs_info->btree_inode->i_mapping, 1);
1825
	}
1826
	return;
C
Chris Mason 已提交
1827
}
1828

1829
int btrfs_read_buffer(struct extent_buffer *buf, u64 parent_transid)
1830
{
1831
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
1832
	int ret;
1833
	ret = btree_read_extent_buffer_pages(root, buf, 0, parent_transid);
1834 1835 1836 1837
	if (ret == 0) {
		buf->flags |= EXTENT_UPTODATE;
	}
	return ret;
1838
}
1839

1840
static struct extent_io_ops btree_extent_io_ops = {
1841
	.writepage_io_hook = btree_writepage_io_hook,
1842
	.readpage_end_io_hook = btree_readpage_end_io_hook,
1843
	.submit_bio_hook = btree_submit_bio_hook,
1844 1845
	/* note we're sharing with inode.c for the merge bio hook */
	.merge_bio_hook = btrfs_merge_bio_hook,
1846
};