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"
43

44 45
#if 0
static int check_tree_block(struct btrfs_root *root, struct extent_buffer *buf)
46
{
47 48 49 50
	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 已提交
51
		return 1;
52
	}
53
	return 0;
54
}
55
#endif
56

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

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

71 72 73 74 75 76 77
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;
78
	struct btrfs_work work;
79 80
};

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

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

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

	spin_lock(&em_tree->lock);
110 111
	ret = add_extent_mapping(em_tree, em);
	if (ret == -EEXIST) {
112 113 114 115 116
		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);
117
		free_extent_map(em);
118
		em = lookup_extent_mapping(em_tree, start, len);
119 120 121
		if (em) {
			printk("after failing, found %Lu %Lu %Lu\n",
			       em->start, em->len, em->block_start);
122
			ret = 0;
123 124 125 126 127 128 129 130 131
		} 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);
			}
132
			ret = -EIO;
133
		}
134
	} else if (ret) {
135 136
		free_extent_map(em);
		em = NULL;
137
	}
138 139 140 141
	spin_unlock(&em_tree->lock);

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

146 147
u32 btrfs_csum_data(struct btrfs_root *root, char *data, u32 seed, size_t len)
{
148
	return btrfs_crc32c(seed, data, len);
149 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
}

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) {
190 191 192 193 194 195 196 197
		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 */
198
		if (memcmp_extent_buffer(buf, result, 0, BTRFS_CRC32_SIZE)) {
199 200 201 202 203 204
			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 "
205 206
			       "wanted %X found %X from_this_trans %d "
			       "level %d\n",
207
			       root->fs_info->sb->s_id,
208 209
			       buf->start, val, found, from_this_trans,
			       btrfs_header_level(buf));
210 211 212 213 214 215 216 217
			return 1;
		}
	} else {
		write_extent_buffer(buf, result, 0, BTRFS_CRC32_SIZE);
	}
	return 0;
}

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

}

245 246
static int btree_read_extent_buffer_pages(struct btrfs_root *root,
					  struct extent_buffer *eb,
247
					  u64 start, u64 parent_transid)
248 249 250 251 252 253 254 255 256 257
{
	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);
258 259
		if (!ret &&
		    !verify_parent_transid(io_tree, eb, parent_transid))
260
			return ret;
C
Chris Mason 已提交
261

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

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

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

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

	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);
295 296
	ret = btree_read_extent_buffer_pages(root, eb, start + PAGE_CACHE_SIZE,
					     btrfs_header_generation(eb));
297
	BUG_ON(ret);
298 299 300 301
	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);
302 303 304 305 306 307 308 309 310 311 312 313 314
		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;
315 316
	}
	found_level = btrfs_header_level(eb);
317 318 319
	spin_lock(&root->fs_info->hash_lock);
	btrfs_set_header_flag(eb, BTRFS_HEADER_FLAG_WRITTEN);
	spin_unlock(&root->fs_info->hash_lock);
320
	csum_tree_block(root, eb, 0);
321
err:
322 323 324 325 326
	free_extent_buffer(eb);
out:
	return 0;
}

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

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

335 336 337 338 339 340 341 342 343
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;
344
	int ret = 0;
345 346 347 348 349 350 351 352 353 354 355

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

357 358
	found_start = btrfs_header_bytenr(eb);
	if (found_start != start) {
359
		ret = -EIO;
360 361 362 363 364 365
		goto err;
	}
	if (eb->first_page != page) {
		printk("bad first page %lu %lu\n", eb->first_page->index,
		       page->index);
		WARN_ON(1);
366
		ret = -EIO;
367 368
		goto err;
	}
369 370 371 372 373 374 375
	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;
	}
376 377 378
	found_level = btrfs_header_level(eb);

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

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

#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;
407 408
	end_io_wq->work.func = end_workqueue_fn;
	end_io_wq->work.flags = 0;
409 410 411 412 413
	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);
414 415 416 417 418 419

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

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

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

440 441 442 443 444 445 446 447 448 449 450 451 452
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);
}

453 454 455 456 457 458 459 460 461 462 463 464 465 466 467
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;
468 469
	async->work.func = run_one_async_submit;
	async->work.flags = 0;
470
	atomic_inc(&fs_info->nr_async_submits);
471
	btrfs_queue_worker(&fs_info->workers, &async->work);
472 473 474 475
	return 0;
}

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

	offset = bio->bi_sector << 9;

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

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

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

503 504 505
static int btree_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
				 int mirror_num)
{
506 507 508 509
	/*
	 * kthread helpers are used to submit writes so that checksumming
	 * can happen in parallel across all CPUs
	 */
510 511 512 513 514 515 516 517
	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);
}

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

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

		if (wbc->for_kupdate)
			return 0;

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

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

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

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

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

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

580 581 582
	return ret;
}

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

598
#if 0
599
static int btree_writepage(struct page *page, struct writeback_control *wbc)
600
{
C
Chris Mason 已提交
601
	struct buffer_head *bh;
602
	struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
C
Chris Mason 已提交
603 604 605 606 607 608 609 610 611 612 613 614
	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);
615
	return block_write_full_page(page, btree_get_block, wbc);
616
}
617
#endif
618

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

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

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

644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666
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,
667
				      u32 blocksize, u64 parent_transid)
668 669 670 671 672 673 674 675 676 677 678 679
{
	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;

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

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

687 688
}

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

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

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

	INIT_LIST_HEAD(&root->dirty_list);
736
	INIT_LIST_HEAD(&root->orphan_list);
737
	spin_lock_init(&root->node_lock);
738
	spin_lock_init(&root->orphan_lock);
739
	mutex_init(&root->objectid_mutex);
740 741
	memset(&root->root_key, 0, sizeof(root->root_key));
	memset(&root->root_item, 0, sizeof(root->root_item));
742
	memset(&root->defrag_progress, 0, sizeof(root->defrag_progress));
743
	memset(&root->root_kobj, 0, sizeof(root->root_kobj));
744
	root->defrag_trans_start = fs_info->generation;
745
	init_completion(&root->kobj_unregister);
746 747
	root->defrag_running = 0;
	root->defrag_level = 0;
748
	root->root_key.objectid = objectid;
749 750 751
	return 0;
}

752
static int find_and_setup_root(struct btrfs_root *tree_root,
753 754
			       struct btrfs_fs_info *fs_info,
			       u64 objectid,
C
Chris Mason 已提交
755
			       struct btrfs_root *root)
756 757
{
	int ret;
758
	u32 blocksize;
759

760
	__setup_root(tree_root->nodesize, tree_root->leafsize,
761 762
		     tree_root->sectorsize, tree_root->stripesize,
		     root, fs_info, objectid);
763 764 765 766
	ret = btrfs_find_last_root(tree_root, objectid,
				   &root->root_item, &root->root_key);
	BUG_ON(ret);

767 768
	blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
	root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
769
				     blocksize, 0);
770
	BUG_ON(!root->node);
771 772 773
	return 0;
}

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

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

798
	__setup_root(tree_root->nodesize, tree_root->leafsize,
799 800
		     tree_root->sectorsize, tree_root->stripesize,
		     root, fs_info, location->objectid);
801 802 803 804 805 806 807 808 809

	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;
	}
810 811 812
	l = path->nodes[0];
	read_extent_buffer(l, &root->root_item,
	       btrfs_item_ptr_offset(l, path->slots[0]),
813
	       sizeof(root->root_item));
814
	memcpy(&root->root_key, location, sizeof(*location));
815 816 817 818 819 820 821 822
	ret = 0;
out:
	btrfs_release_path(root, path);
	btrfs_free_path(path);
	if (ret) {
		kfree(root);
		return ERR_PTR(ret);
	}
823 824
	blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
	root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
825
				     blocksize, 0);
826 827 828
	BUG_ON(!root->node);
insert:
	root->ref_cows = 1;
829 830 831 832 833 834 835 836
	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 已提交
837 838 839 840 841 842 843 844 845 846 847 848 849 850 851
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;
}

852 853
struct btrfs_root *btrfs_read_fs_root_no_name(struct btrfs_fs_info *fs_info,
					      struct btrfs_key *location)
854 855 856 857
{
	struct btrfs_root *root;
	int ret;

858 859 860 861
	if (location->objectid == BTRFS_ROOT_TREE_OBJECTID)
		return fs_info->tree_root;
	if (location->objectid == BTRFS_EXTENT_TREE_OBJECTID)
		return fs_info->extent_root;
862 863 864 865
	if (location->objectid == BTRFS_CHUNK_TREE_OBJECTID)
		return fs_info->chunk_root;
	if (location->objectid == BTRFS_DEV_TREE_OBJECTID)
		return fs_info->dev_root;
866

867 868 869 870 871 872 873 874
	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 已提交
875 876
	ret = radix_tree_insert(&fs_info->fs_roots_radix,
				(unsigned long)root->root_key.objectid,
877 878
				root);
	if (ret) {
879
		free_extent_buffer(root->node);
880 881 882
		kfree(root);
		return ERR_PTR(ret);
	}
883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899
	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;
900

901 902 903
	if (root->in_sysfs)
		return root;

904 905
	ret = btrfs_set_root_name(root, name, namelen);
	if (ret) {
906
		free_extent_buffer(root->node);
907 908 909 910 911 912
		kfree(root);
		return ERR_PTR(ret);
	}

	ret = btrfs_sysfs_add_root(root);
	if (ret) {
913
		free_extent_buffer(root->node);
914 915 916 917
		kfree(root->name);
		kfree(root);
		return ERR_PTR(ret);
	}
918
	root->in_sysfs = 1;
919 920
	return root;
}
921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938
#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 已提交
939 940 941 942 943

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;
944
	int limit = 256 * info->fs_devices->open_devices;
C
Chris Mason 已提交
945 946 947 948
	struct list_head *cur;
	struct btrfs_device *device;
	struct backing_dev_info *bdi;

949 950 951 952 953
	if ((bdi_bits & (1 << BDI_write_congested)) &&
	    atomic_read(&info->nr_async_submits) > limit) {
		return 1;
	}

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

967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986
/*
 * 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 已提交
987 988
void btrfs_unplug_io_fn(struct backing_dev_info *bdi, struct page *page)
{
989
	struct inode *inode;
990 991
	struct extent_map_tree *em_tree;
	struct extent_map *em;
992
	struct address_space *mapping;
993 994
	u64 offset;

995
	/* the generic O_DIRECT read code does this */
996 997 998 999 1000
	if (!page) {
		__unplug_io_fn(bdi, page);
		return;
	}

1001 1002 1003 1004 1005 1006 1007 1008 1009 1010
	/*
	 * 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;
1011
	offset = page_offset(page);
C
Chris Mason 已提交
1012

1013 1014 1015 1016
	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);
1017 1018
	if (!em) {
		__unplug_io_fn(bdi, page);
1019
		return;
1020
	}
1021

1022 1023 1024 1025 1026
	if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
		free_extent_map(em);
		__unplug_io_fn(bdi, page);
		return;
	}
1027 1028 1029 1030
	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 已提交
1031 1032 1033 1034
}

static int setup_bdi(struct btrfs_fs_info *info, struct backing_dev_info *bdi)
{
1035
#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
C
Chris Mason 已提交
1036
	bdi_init(bdi);
1037
#endif
1038
	bdi->ra_pages	= default_backing_dev_info.ra_pages;
C
Chris Mason 已提交
1039 1040 1041 1042 1043 1044 1045 1046 1047
	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;
}

1048 1049 1050 1051 1052 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
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;
}

1087 1088 1089 1090 1091
/*
 * 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)
1092 1093
{
	struct bio *bio;
1094 1095
	struct end_io_wq *end_io_wq;
	struct btrfs_fs_info *fs_info;
1096 1097
	int error;

1098 1099 1100
	end_io_wq = container_of(work, struct end_io_wq, work);
	bio = end_io_wq->bio;
	fs_info = end_io_wq->info;
1101

1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117
	/* 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);
1118
#else
1119
	bio_endio(bio, error);
1120 1121 1122
#endif
}

1123 1124 1125 1126 1127 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
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 已提交
1169 1170 1171
		printk("btrfs: total reference cache size %Lu\n",
			root->fs_info->total_ref_cache_size);

1172 1173 1174 1175 1176 1177
		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 已提交
1178 1179 1180 1181

		printk("btrfs: running reference cache size %Lu\n",
			root->fs_info->running_ref_cache_size);

1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207
		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;
}

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

C
Chris Mason 已提交
1231
	struct btrfs_super_block *disk_super;
1232

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

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

1266 1267 1268
	INIT_LIST_HEAD(&fs_info->ordered_extents);
	spin_lock_init(&fs_info->ordered_extent_lock);

1269 1270 1271
	sb->s_blocksize = 4096;
	sb->s_blocksize_bits = blksize_bits(4096);

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

1281
	extent_io_tree_init(&BTRFS_I(fs_info->btree_inode)->io_tree,
1282 1283
			     fs_info->btree_inode->i_mapping,
			     GFP_NOFS);
1284 1285 1286 1287
	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;
1288

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

1301 1302 1303
	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 已提交
1304
	insert_inode_hash(fs_info->btree_inode);
1305
	mapping_set_gfp_mask(fs_info->btree_inode->i_mapping, GFP_NOFS);
C
Chris Mason 已提交
1306

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

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

1328

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

1334 1335
	memcpy(&fs_info->super_copy, bh->b_data, sizeof(fs_info->super_copy));
	brelse(bh);
1336

1337
	memcpy(fs_info->fsid, fs_info->super_copy.fsid, BTRFS_FSID_SIZE);
1338

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

1343 1344 1345
	err = btrfs_parse_options(tree_root, options);
	if (err)
		goto fail_sb_buffer;
1346

1347 1348 1349 1350 1351 1352
	/*
	 * 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);
1353
	btrfs_init_workers(&fs_info->submit_workers, fs_info->thread_pool_size);
1354
	btrfs_init_workers(&fs_info->fixup_workers, 1);
1355
	btrfs_init_workers(&fs_info->endio_workers, fs_info->thread_pool_size);
1356 1357
	btrfs_init_workers(&fs_info->endio_write_workers,
			   fs_info->thread_pool_size);
1358
	btrfs_start_workers(&fs_info->workers, 1);
1359
	btrfs_start_workers(&fs_info->submit_workers, 1);
1360
	btrfs_start_workers(&fs_info->fixup_workers, 1);
1361
	btrfs_start_workers(&fs_info->endio_workers, fs_info->thread_pool_size);
1362 1363
	btrfs_start_workers(&fs_info->endio_write_workers,
			    fs_info->thread_pool_size);
1364

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

1377 1378
	fs_info->bdi.ra_pages *= btrfs_super_num_devices(disk_super);

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

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

C
Chris Mason 已提交
1391 1392 1393 1394 1395
	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;
	}
1396

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

	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),
1414
					   blocksize, 0);
1415 1416
	BUG_ON(!chunk_root->node);

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

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

1426 1427
	btrfs_close_extra_devices(fs_devices);

1428 1429
	blocksize = btrfs_level_size(tree_root,
				     btrfs_super_root_level(disk_super));
1430

1431

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

1438 1439

	ret = find_and_setup_root(tree_root, fs_info,
C
Chris Mason 已提交
1440
				  BTRFS_EXTENT_TREE_OBJECTID, extent_root);
1441
	if (ret)
C
Chris Mason 已提交
1442
		goto fail_tree_root;
1443 1444 1445 1446 1447 1448 1449 1450
	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;
1451

C
Chris Mason 已提交
1452 1453
	btrfs_read_block_groups(extent_root);

1454
	fs_info->generation = btrfs_super_generation(disk_super) + 1;
C
Chris Mason 已提交
1455 1456 1457
	fs_info->data_alloc_profile = (u64)-1;
	fs_info->metadata_alloc_profile = (u64)-1;
	fs_info->system_alloc_profile = fs_info->metadata_alloc_profile;
1458 1459 1460 1461 1462 1463 1464 1465 1466
	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)
1467
		goto fail_cleaner;
1468

C
Chris Mason 已提交
1469

1470
	return tree_root;
C
Chris Mason 已提交
1471

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

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

1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511
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));
		}
1512 1513 1514
		/* note, we dont' set_buffer_write_io_error because we have
		 * our own ways of dealing with the IO errors
		 */
1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525
		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;
1526
	struct btrfs_super_block *sb;
1527 1528 1529 1530
	struct btrfs_dev_item *dev_item;
	struct buffer_head *bh;
	int ret;
	int do_barriers;
1531 1532
	int max_errors;
	int total_errors = 0;
1533 1534
	u32 crc;
	u64 flags;
1535

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

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

1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567
		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,
1568 1569
			      BTRFS_SUPER_INFO_SIZE);

1570
		memcpy(bh->b_data, sb, BTRFS_SUPER_INFO_SIZE);
1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591
		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);
		}
1592 1593
		if (ret)
			total_errors++;
1594
	}
1595 1596 1597 1598 1599
	if (total_errors > max_errors) {
		printk("btrfs: %d errors while writing supers\n", total_errors);
		BUG();
	}
	total_errors = 0;
1600 1601 1602

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

1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621
		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);
1622 1623
				if (!buffer_uptodate(bh))
					total_errors++;
1624
			} else {
1625
				total_errors++;
1626 1627 1628 1629 1630 1631
			}

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

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

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

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

C
Chris Mason 已提交
1666
static int del_fs_roots(struct btrfs_fs_info *fs_info)
1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677
{
	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 已提交
1678
		for (i = 0; i < ret; i++)
1679
			btrfs_free_fs_root(fs_info, gang[i]);
1680 1681 1682
	}
	return 0;
}
1683

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

1690
	fs_info->closing = 1;
1691 1692
	smp_mb();

1693 1694 1695 1696
	kthread_stop(root->fs_info->transaction_kthread);
	kthread_stop(root->fs_info->cleaner_kthread);

	btrfs_clean_old_snapshots(root);
C
Chris Mason 已提交
1697
	trans = btrfs_start_transaction(root, 1);
1698
	ret = btrfs_commit_transaction(trans, root);
C
Chris Mason 已提交
1699 1700 1701 1702
	/* 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);
1703
	BUG_ON(ret);
1704

C
Chris Mason 已提交
1705
	write_ctree_super(NULL, root);
1706

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

1719
	if (fs_info->tree_root->node)
1720
		free_extent_buffer(fs_info->tree_root->node);
1721

1722 1723 1724 1725 1726 1727
	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 已提交
1728
	btrfs_free_block_groups(root->fs_info);
1729
	del_fs_roots(fs_info);
1730 1731 1732

	filemap_write_and_wait(fs_info->btree_inode->i_mapping);

1733
	truncate_inode_pages(fs_info->btree_inode->i_mapping, 0);
1734

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

1741
	iput(fs_info->btree_inode);
1742 1743 1744 1745 1746 1747 1748 1749 1750 1751
#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
1752
	btrfs_close_devices(fs_info->fs_devices);
1753
	btrfs_mapping_tree_free(&fs_info->mapping_tree);
1754

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

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

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

	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;
1778 1779 1780
}

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

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

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

1803
void btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr)
C
Chris Mason 已提交
1804
{
1805 1806 1807 1808
	/*
	 * looks as though older kernels can get into trouble with
	 * this code, they end up stuck in balance_dirty_pages forever
	 */
1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821
	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 已提交
1822
				   root->fs_info->btree_inode->i_mapping, 1);
1823
	}
1824
	return;
C
Chris Mason 已提交
1825
}
1826

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

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