disk-io.c 62.4 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
#include <linux/kthread.h>
C
Chris Mason 已提交
29 30
#include <linux/freezer.h>
#include "compat.h"
31
#include "crc32c.h"
32 33
#include "ctree.h"
#include "disk-io.h"
34
#include "transaction.h"
35
#include "btrfs_inode.h"
36
#include "volumes.h"
37
#include "print-tree.h"
38
#include "async-thread.h"
39
#include "locking.h"
C
Chris Mason 已提交
40
#include "ref-cache.h"
41
#include "tree-log.h"
42

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

56
static struct extent_io_ops btree_extent_io_ops;
57
static void end_workqueue_fn(struct btrfs_work *work);
58

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

C
Chris Mason 已提交
75 76 77 78 79
/*
 * async submit bios are used to offload expensive checksumming
 * onto the worker threads.  They checksum file and metadata bios
 * just before they are sent down the IO stack.
 */
80 81 82 83
struct async_submit_bio {
	struct inode *inode;
	struct bio *bio;
	struct list_head list;
C
Chris Mason 已提交
84 85
	extent_submit_bio_hook_t *submit_bio_start;
	extent_submit_bio_hook_t *submit_bio_done;
86 87
	int rw;
	int mirror_num;
C
Chris Mason 已提交
88
	unsigned long bio_flags;
89
	struct btrfs_work work;
90 91
};

C
Chris Mason 已提交
92 93 94 95
/*
 * extents on the btree inode are pretty simple, there's one extent
 * that covers the entire device
 */
96 97 98
static struct extent_map *btree_get_extent(struct inode *inode,
		struct page *page, size_t page_offset, u64 start, u64 len,
		int create)
99
{
100 101 102 103
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
	struct extent_map *em;
	int ret;

104 105
	spin_lock(&em_tree->lock);
	em = lookup_extent_mapping(em_tree, start, len);
106 107 108 109
	if (em) {
		em->bdev =
			BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev;
		spin_unlock(&em_tree->lock);
110
		goto out;
111 112
	}
	spin_unlock(&em_tree->lock);
113

114 115 116 117 118 119
	em = alloc_extent_map(GFP_NOFS);
	if (!em) {
		em = ERR_PTR(-ENOMEM);
		goto out;
	}
	em->start = 0;
120
	em->len = (u64)-1;
C
Chris Mason 已提交
121
	em->block_len = (u64)-1;
122
	em->block_start = 0;
123
	em->bdev = BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev;
124 125

	spin_lock(&em_tree->lock);
126 127
	ret = add_extent_mapping(em_tree, em);
	if (ret == -EEXIST) {
128 129 130 131 132
		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);
133
		free_extent_map(em);
134
		em = lookup_extent_mapping(em_tree, start, len);
135 136 137
		if (em) {
			printk("after failing, found %Lu %Lu %Lu\n",
			       em->start, em->len, em->block_start);
138
			ret = 0;
139 140 141 142 143 144 145 146 147
		} 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);
			}
148
			ret = -EIO;
149
		}
150
	} else if (ret) {
151 152
		free_extent_map(em);
		em = NULL;
153
	}
154 155 156 157
	spin_unlock(&em_tree->lock);

	if (ret)
		em = ERR_PTR(ret);
158 159
out:
	return em;
160 161
}

162 163
u32 btrfs_csum_data(struct btrfs_root *root, char *data, u32 seed, size_t len)
{
164
	return btrfs_crc32c(seed, data, len);
165 166 167 168 169 170 171
}

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

C
Chris Mason 已提交
172 173 174 175
/*
 * compute the csum for a btree block, and either verify it or write it
 * into the csum field of the block.
 */
176 177 178
static int csum_tree_block(struct btrfs_root *root, struct extent_buffer *buf,
			   int verify)
{
179 180 181
	u16 csum_size =
		btrfs_super_csum_size(&root->fs_info->super_copy);
	char *result = NULL;
182 183 184 185 186 187 188 189 190
	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;
191
	unsigned long inline_result;
192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209

	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);
	}
210 211 212 213 214 215 216 217
	if (csum_size > sizeof(inline_result)) {
		result = kzalloc(csum_size * sizeof(char), GFP_NOFS);
		if (!result)
			return 1;
	} else {
		result = (char *)&inline_result;
	}

218 219 220
	btrfs_csum_final(crc, result);

	if (verify) {
221
		/* FIXME, this is not good */
222
		if (memcmp_extent_buffer(buf, result, 0, csum_size)) {
223 224
			u32 val;
			u32 found = 0;
225
			memcpy(&found, result, csum_size);
226

227
			read_extent_buffer(buf, &val, 0, csum_size);
228
			printk("btrfs: %s checksum verify failed on %llu "
C
Chris Mason 已提交
229
			       "wanted %X found %X level %d\n",
230
			       root->fs_info->sb->s_id,
C
Chris Mason 已提交
231
			       buf->start, val, found, btrfs_header_level(buf));
232 233
			if (result != (char *)&inline_result)
				kfree(result);
234 235 236
			return 1;
		}
	} else {
237
		write_extent_buffer(buf, result, 0, csum_size);
238
	}
239 240
	if (result != (char *)&inline_result)
		kfree(result);
241 242 243
	return 0;
}

C
Chris Mason 已提交
244 245 246 247 248 249
/*
 * we can't consider a given block up to date unless the transid of the
 * block matches the transid in the parent node's pointer.  This is how we
 * detect blocks that either didn't get written at all or got written
 * in the wrong place.
 */
250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269
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;
	clear_extent_buffer_uptodate(io_tree, eb);
C
Chris Mason 已提交
270
out:
271 272 273 274 275
	unlock_extent(io_tree, eb->start, eb->start + eb->len - 1,
		      GFP_NOFS);
	return ret;
}

C
Chris Mason 已提交
276 277 278 279
/*
 * helper to read a given tree block, doing retries as required when
 * the checksums don't match and we have alternate mirrors to try.
 */
280 281
static int btree_read_extent_buffer_pages(struct btrfs_root *root,
					  struct extent_buffer *eb,
282
					  u64 start, u64 parent_transid)
283 284 285 286 287 288 289 290 291 292
{
	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);
293 294
		if (!ret &&
		    !verify_parent_transid(io_tree, eb, parent_transid))
295
			return ret;
296
printk("read extent buffer pages failed with ret %d mirror no %d\n", ret, mirror_num);
297 298
		num_copies = btrfs_num_copies(&root->fs_info->mapping_tree,
					      eb->start, eb->len);
C
Chris Mason 已提交
299
		if (num_copies == 1)
300
			return ret;
C
Chris Mason 已提交
301

302
		mirror_num++;
C
Chris Mason 已提交
303
		if (mirror_num > num_copies)
304 305 306 307
			return ret;
	}
	return -EIO;
}
308

C
Chris Mason 已提交
309 310 311 312
/*
 * checksum a dirty tree block before IO.  This has extra checks to make
 * sure we only fill in the checksum field in the first page of a multi-page block
 */
313
static int csum_dirty_buffer(struct btrfs_root *root, struct page *page)
314
{
315
	struct extent_io_tree *tree;
316
	u64 start = (u64)page->index << PAGE_CACHE_SHIFT;
317 318 319 320
	u64 found_start;
	int found_level;
	unsigned long len;
	struct extent_buffer *eb;
321 322
	int ret;

323
	tree = &BTRFS_I(page->mapping->host)->io_tree;
324 325 326 327 328 329 330 331 332 333

	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);
334 335
	ret = btree_read_extent_buffer_pages(root, eb, start + PAGE_CACHE_SIZE,
					     btrfs_header_generation(eb));
336
	BUG_ON(ret);
337 338 339 340
	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);
341 342 343 344 345 346 347 348 349 350 351 352 353
		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;
354 355
	}
	found_level = btrfs_header_level(eb);
C
Chris Mason 已提交
356

357
	csum_tree_block(root, eb, 0);
358
err:
359 360 361 362 363
	free_extent_buffer(eb);
out:
	return 0;
}

Y
Yan Zheng 已提交
364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382
static int check_tree_block_fsid(struct btrfs_root *root,
				 struct extent_buffer *eb)
{
	struct btrfs_fs_devices *fs_devices = root->fs_info->fs_devices;
	u8 fsid[BTRFS_UUID_SIZE];
	int ret = 1;

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

383
static int btree_readpage_end_io_hook(struct page *page, u64 start, u64 end,
384 385 386 387 388 389 390 391
			       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;
392
	int ret = 0;
393 394 395 396 397 398 399 400 401 402 403

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

405
	found_start = btrfs_header_bytenr(eb);
406
	if (found_start != start) {
407 408 409
		printk("bad tree block start %llu %llu\n",
		       (unsigned long long)found_start,
		       (unsigned long long)eb->start);
410
		ret = -EIO;
411 412 413 414 415 416
		goto err;
	}
	if (eb->first_page != page) {
		printk("bad first page %lu %lu\n", eb->first_page->index,
		       page->index);
		WARN_ON(1);
417
		ret = -EIO;
418 419
		goto err;
	}
Y
Yan Zheng 已提交
420
	if (check_tree_block_fsid(root, eb)) {
421 422 423 424
		printk("bad fsid on block %Lu\n", eb->start);
		ret = -EIO;
		goto err;
	}
425 426 427
	found_level = btrfs_header_level(eb);

	ret = csum_tree_block(root, eb, 1);
428 429
	if (ret)
		ret = -EIO;
430 431 432 433 434 435

	end = min_t(u64, eb->len, PAGE_CACHE_SIZE);
	end = eb->start + end - 1;
err:
	free_extent_buffer(eb);
out:
436
	return ret;
437 438 439 440 441 442 443 444 445
}

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

	fs_info = end_io_wq->info;
	end_io_wq->error = err;
446 447
	end_io_wq->work.func = end_workqueue_fn;
	end_io_wq->work.flags = 0;
448 449

	if (bio->bi_rw & (1 << BIO_RW)) {
450 451
		btrfs_queue_worker(&fs_info->endio_write_workers,
				   &end_io_wq->work);
452 453 454 455 456 457 458 459
	} else {
		if (end_io_wq->metadata)
			btrfs_queue_worker(&fs_info->endio_meta_workers,
					   &end_io_wq->work);
		else
			btrfs_queue_worker(&fs_info->endio_workers,
					   &end_io_wq->work);
	}
460 461
}

462 463
int btrfs_bio_wq_end_io(struct btrfs_fs_info *info, struct bio *bio,
			int metadata)
464
{
465 466 467 468 469 470 471
	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;
472
	end_io_wq->info = info;
473 474
	end_io_wq->error = 0;
	end_io_wq->bio = bio;
475
	end_io_wq->metadata = metadata;
476 477 478

	bio->bi_private = end_io_wq;
	bio->bi_end_io = end_workqueue_bio;
479 480 481
	return 0;
}

482
unsigned long btrfs_async_submit_limit(struct btrfs_fs_info *info)
483
{
484 485 486 487 488
	unsigned long limit = min_t(unsigned long,
				    info->workers.max_workers,
				    info->fs_devices->open_devices);
	return 256 * limit;
}
489

490 491
int btrfs_congested_async(struct btrfs_fs_info *info, int iodone)
{
492 493
	return atomic_read(&info->nr_async_bios) >
		btrfs_async_submit_limit(info);
494 495
}

C
Chris Mason 已提交
496 497 498 499 500 501 502 503 504 505 506 507
static void run_one_async_start(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;
	async->submit_bio_start(async->inode, async->rw, async->bio,
			       async->mirror_num, async->bio_flags);
}

static void run_one_async_done(struct btrfs_work *work)
508 509 510
{
	struct btrfs_fs_info *fs_info;
	struct async_submit_bio *async;
511
	int limit;
512 513 514

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

516
	limit = btrfs_async_submit_limit(fs_info);
517 518
	limit = limit * 2 / 3;

519
	atomic_dec(&fs_info->nr_async_submits);
520

521 522
	if (atomic_read(&fs_info->nr_async_submits) < limit &&
	    waitqueue_active(&fs_info->async_submit_wait))
523 524
		wake_up(&fs_info->async_submit_wait);

C
Chris Mason 已提交
525
	async->submit_bio_done(async->inode, async->rw, async->bio,
C
Chris Mason 已提交
526
			       async->mirror_num, async->bio_flags);
C
Chris Mason 已提交
527 528 529 530 531 532 533
}

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

	async = container_of(work, struct  async_submit_bio, work);
534 535 536
	kfree(async);
}

537 538
int btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info, struct inode *inode,
			int rw, struct bio *bio, int mirror_num,
C
Chris Mason 已提交
539
			unsigned long bio_flags,
C
Chris Mason 已提交
540 541
			extent_submit_bio_hook_t *submit_bio_start,
			extent_submit_bio_hook_t *submit_bio_done)
542 543 544 545 546 547 548 549 550 551 552
{
	struct async_submit_bio *async;

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

	async->inode = inode;
	async->rw = rw;
	async->bio = bio;
	async->mirror_num = mirror_num;
C
Chris Mason 已提交
553 554 555 556 557 558 559
	async->submit_bio_start = submit_bio_start;
	async->submit_bio_done = submit_bio_done;

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

560
	async->work.flags = 0;
C
Chris Mason 已提交
561
	async->bio_flags = bio_flags;
562

563
	atomic_inc(&fs_info->nr_async_submits);
564
	btrfs_queue_worker(&fs_info->workers, &async->work);
C
Chris Mason 已提交
565
#if 0
566
	int limit = btrfs_async_submit_limit(fs_info);
567 568
	if (atomic_read(&fs_info->nr_async_submits) > limit) {
		wait_event_timeout(fs_info->async_submit_wait,
569 570
			   (atomic_read(&fs_info->nr_async_submits) < limit),
			   HZ/10);
571 572 573 574 575

		wait_event_timeout(fs_info->async_submit_wait,
			   (atomic_read(&fs_info->nr_async_bios) < limit),
			   HZ/10);
	}
C
Chris Mason 已提交
576
#endif
577 578 579 580 581 582
	while(atomic_read(&fs_info->async_submit_draining) &&
	      atomic_read(&fs_info->nr_async_submits)) {
		wait_event(fs_info->async_submit_wait,
			   (atomic_read(&fs_info->nr_async_submits) == 0));
	}

583 584 585
	return 0;
}

586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601
static int btree_csum_one_bio(struct bio *bio)
{
	struct bio_vec *bvec = bio->bi_io_vec;
	int bio_index = 0;
	struct btrfs_root *root;

	WARN_ON(bio->bi_vcnt <= 0);
	while(bio_index < bio->bi_vcnt) {
		root = BTRFS_I(bvec->bv_page->mapping->host)->root;
		csum_dirty_buffer(root, bvec->bv_page);
		bio_index++;
		bvec++;
	}
	return 0;
}

C
Chris Mason 已提交
602 603 604
static int __btree_submit_bio_start(struct inode *inode, int rw,
				    struct bio *bio, int mirror_num,
				    unsigned long bio_flags)
605
{
606 607
	/*
	 * when we're called for a write, we're already in the async
608
	 * submission context.  Just jump into btrfs_map_bio
609
	 */
C
Chris Mason 已提交
610 611 612
	btree_csum_one_bio(bio);
	return 0;
}
613

C
Chris Mason 已提交
614 615 616
static int __btree_submit_bio_done(struct inode *inode, int rw, struct bio *bio,
				 int mirror_num, unsigned long bio_flags)
{
617
	/*
C
Chris Mason 已提交
618 619
	 * when we're called for a write, we're already in the async
	 * submission context.  Just jump into btrfs_map_bio
620 621
	 */
	return btrfs_map_bio(BTRFS_I(inode)->root, rw, bio, mirror_num, 1);
622 623
}

624
static int btree_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
C
Chris Mason 已提交
625
				 int mirror_num, unsigned long bio_flags)
626
{
627 628 629 630
	/*
	 * kthread helpers are used to submit writes so that checksumming
	 * can happen in parallel across all CPUs
	 */
631
	if (!(rw & (1 << BIO_RW))) {
C
Chris Mason 已提交
632 633 634 635 636 637 638 639 640 641
		int ret;
		/*
		 * called for a read, do the setup so that checksum validation
		 * can happen in the async kernel threads
		 */
		ret = btrfs_bio_wq_end_io(BTRFS_I(inode)->root->fs_info,
					  bio, 1);
		BUG_ON(ret);

		return btrfs_map_bio(BTRFS_I(inode)->root, rw, bio,
642
				     mirror_num, 0);
643 644
	}
	return btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,
C
Chris Mason 已提交
645
				   inode, rw, bio, mirror_num, 0,
C
Chris Mason 已提交
646 647
				   __btree_submit_bio_start,
				   __btree_submit_bio_done);
648 649
}

650 651
static int btree_writepage(struct page *page, struct writeback_control *wbc)
{
652 653
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
654 655 656 657 658 659

	if (current->flags & PF_MEMALLOC) {
		redirty_page_for_writepage(wbc, page);
		unlock_page(page);
		return 0;
	}
660 661
	return extent_write_full_page(tree, page, btree_get_extent, wbc);
}
662 663 664 665

static int btree_writepages(struct address_space *mapping,
			    struct writeback_control *wbc)
{
666 667
	struct extent_io_tree *tree;
	tree = &BTRFS_I(mapping->host)->io_tree;
668
	if (wbc->sync_mode == WB_SYNC_NONE) {
669 670
		u64 num_dirty;
		u64 start = 0;
671
		unsigned long thresh = 32 * 1024 * 1024;
672 673 674 675

		if (wbc->for_kupdate)
			return 0;

676 677
		num_dirty = count_range_bits(tree, &start, (u64)-1,
					     thresh, EXTENT_DIRTY);
678 679 680 681
		if (num_dirty < thresh) {
			return 0;
		}
	}
682 683 684
	return extent_writepages(tree, mapping, btree_get_extent, wbc);
}

685
static int btree_readpage(struct file *file, struct page *page)
686
{
687 688
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
689 690
	return extent_read_full_page(tree, page, btree_get_extent);
}
C
Chris Mason 已提交
691

692
static int btree_releasepage(struct page *page, gfp_t gfp_flags)
693
{
694 695
	struct extent_io_tree *tree;
	struct extent_map_tree *map;
696
	int ret;
697

698 699 700
	if (PageWriteback(page) || PageDirty(page))
	    return 0;

701 702
	tree = &BTRFS_I(page->mapping->host)->io_tree;
	map = &BTRFS_I(page->mapping->host)->extent_tree;
703

704
	ret = try_release_extent_state(map, tree, page, gfp_flags);
705 706 707 708 709
	if (!ret) {
		return 0;
	}

	ret = try_release_extent_buffer(tree, page);
710 711 712 713 714
	if (ret == 1) {
		ClearPagePrivate(page);
		set_page_private(page, 0);
		page_cache_release(page);
	}
715

716 717 718
	return ret;
}

719
static void btree_invalidatepage(struct page *page, unsigned long offset)
720
{
721 722
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
723 724
	extent_invalidatepage(tree, page, offset);
	btree_releasepage(page, GFP_NOFS);
725
	if (PagePrivate(page)) {
726 727
		printk("warning page private not zero on page %Lu\n",
		       page_offset(page));
728 729 730 731
		ClearPagePrivate(page);
		set_page_private(page, 0);
		page_cache_release(page);
	}
732 733
}

734
#if 0
735
static int btree_writepage(struct page *page, struct writeback_control *wbc)
736
{
C
Chris Mason 已提交
737
	struct buffer_head *bh;
738
	struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
C
Chris Mason 已提交
739 740 741 742 743 744 745 746 747 748 749 750
	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);
751
	return block_write_full_page(page, btree_get_block, wbc);
752
}
753
#endif
754

755 756 757
static struct address_space_operations btree_aops = {
	.readpage	= btree_readpage,
	.writepage	= btree_writepage,
758
	.writepages	= btree_writepages,
759 760
	.releasepage	= btree_releasepage,
	.invalidatepage = btree_invalidatepage,
761 762 763
	.sync_page	= block_sync_page,
};

764 765
int readahead_tree_block(struct btrfs_root *root, u64 bytenr, u32 blocksize,
			 u64 parent_transid)
C
Chris Mason 已提交
766
{
767 768
	struct extent_buffer *buf = NULL;
	struct inode *btree_inode = root->fs_info->btree_inode;
769
	int ret = 0;
C
Chris Mason 已提交
770

771
	buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
772
	if (!buf)
C
Chris Mason 已提交
773
		return 0;
774
	read_extent_buffer_pages(&BTRFS_I(btree_inode)->io_tree,
775
				 buf, 0, 0, btree_get_extent, 0);
776
	free_extent_buffer(buf);
777
	return ret;
C
Chris Mason 已提交
778 779
}

780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801
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;
}


802 803 804
int btrfs_write_tree_block(struct extent_buffer *buf)
{
	return btrfs_fdatawrite_range(buf->first_page->mapping, buf->start,
805
				      buf->start + buf->len - 1, WB_SYNC_ALL);
806 807 808 809 810 811 812 813
}

int btrfs_wait_tree_block_writeback(struct extent_buffer *buf)
{
	return btrfs_wait_on_page_writeback_range(buf->first_page->mapping,
				  buf->start, buf->start + buf->len -1);
}

814
struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 bytenr,
815
				      u32 blocksize, u64 parent_transid)
816 817 818 819 820 821 822 823 824 825 826 827
{
	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;

828
	ret = btree_read_extent_buffer_pages(root, buf, 0, parent_transid);
829 830 831

	if (ret == 0) {
		buf->flags |= EXTENT_UPTODATE;
832 833
	} else {
		WARN_ON(1);
834
	}
835
	return buf;
836

837 838
}

839
int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
840
		     struct extent_buffer *buf)
841
{
842
	struct inode *btree_inode = root->fs_info->btree_inode;
843
	if (btrfs_header_generation(buf) ==
844 845
	    root->fs_info->running_transaction->transid) {
		WARN_ON(!btrfs_tree_locked(buf));
846
		clear_extent_buffer_dirty(&BTRFS_I(btree_inode)->io_tree,
847
					  buf);
848
	}
849 850 851
	return 0;
}

852
static int __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize,
853
			u32 stripesize, struct btrfs_root *root,
854
			struct btrfs_fs_info *fs_info,
C
Chris Mason 已提交
855
			u64 objectid)
856
{
C
Chris Mason 已提交
857
	root->node = NULL;
858
	root->commit_root = NULL;
Y
Yan Zheng 已提交
859
	root->ref_tree = NULL;
860 861 862
	root->sectorsize = sectorsize;
	root->nodesize = nodesize;
	root->leafsize = leafsize;
863
	root->stripesize = stripesize;
C
Chris Mason 已提交
864
	root->ref_cows = 0;
865 866
	root->track_dirty = 0;

867
	root->fs_info = fs_info;
868 869
	root->objectid = objectid;
	root->last_trans = 0;
C
Chris Mason 已提交
870 871
	root->highest_inode = 0;
	root->last_inode_alloc = 0;
872
	root->name = NULL;
873
	root->in_sysfs = 0;
874 875

	INIT_LIST_HEAD(&root->dirty_list);
876
	INIT_LIST_HEAD(&root->orphan_list);
877
	INIT_LIST_HEAD(&root->dead_list);
878
	spin_lock_init(&root->node_lock);
879
	spin_lock_init(&root->list_lock);
880
	mutex_init(&root->objectid_mutex);
881
	mutex_init(&root->log_mutex);
882 883
	extent_io_tree_init(&root->dirty_log_pages,
			     fs_info->btree_inode->i_mapping, GFP_NOFS);
C
Chris Mason 已提交
884 885 886 887

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

888 889
	memset(&root->root_key, 0, sizeof(root->root_key));
	memset(&root->root_item, 0, sizeof(root->root_item));
890
	memset(&root->defrag_progress, 0, sizeof(root->defrag_progress));
891
	memset(&root->root_kobj, 0, sizeof(root->root_kobj));
892
	root->defrag_trans_start = fs_info->generation;
893
	init_completion(&root->kobj_unregister);
894 895
	root->defrag_running = 0;
	root->defrag_level = 0;
896
	root->root_key.objectid = objectid;
897 898 899 900 901 902
	root->anon_super.s_root = NULL;
	root->anon_super.s_dev = 0;
	INIT_LIST_HEAD(&root->anon_super.s_list);
	INIT_LIST_HEAD(&root->anon_super.s_instances);
	init_rwsem(&root->anon_super.s_umount);

903 904 905
	return 0;
}

906
static int find_and_setup_root(struct btrfs_root *tree_root,
907 908
			       struct btrfs_fs_info *fs_info,
			       u64 objectid,
C
Chris Mason 已提交
909
			       struct btrfs_root *root)
910 911
{
	int ret;
912
	u32 blocksize;
913
	u64 generation;
914

915
	__setup_root(tree_root->nodesize, tree_root->leafsize,
916 917
		     tree_root->sectorsize, tree_root->stripesize,
		     root, fs_info, objectid);
918 919 920 921
	ret = btrfs_find_last_root(tree_root, objectid,
				   &root->root_item, &root->root_key);
	BUG_ON(ret);

922
	generation = btrfs_root_generation(&root->root_item);
923 924
	blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
	root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
925
				     blocksize, generation);
926
	BUG_ON(!root->node);
927 928 929
	return 0;
}

930 931 932 933
int btrfs_free_log_root_tree(struct btrfs_trans_handle *trans,
			     struct btrfs_fs_info *fs_info)
{
	struct extent_buffer *eb;
934 935 936
	struct btrfs_root *log_root_tree = fs_info->log_root_tree;
	u64 start = 0;
	u64 end = 0;
937 938
	int ret;

939
	if (!log_root_tree)
940 941
		return 0;

942 943 944 945 946 947 948 949 950
	while(1) {
		ret = find_first_extent_bit(&log_root_tree->dirty_log_pages,
				    0, &start, &end, EXTENT_DIRTY);
		if (ret)
			break;

		clear_extent_dirty(&log_root_tree->dirty_log_pages,
				   start, end, GFP_NOFS);
	}
951 952 953 954 955
	eb = fs_info->log_root_tree->node;

	WARN_ON(btrfs_header_level(eb) != 0);
	WARN_ON(btrfs_header_nritems(eb) != 0);

956 957
	ret = btrfs_free_reserved_extent(fs_info->tree_root,
				eb->start, eb->len);
958 959 960 961 962 963 964 965 966 967
	BUG_ON(ret);

	free_extent_buffer(eb);
	kfree(fs_info->log_root_tree);
	fs_info->log_root_tree = NULL;
	return 0;
}

int btrfs_init_log_root_tree(struct btrfs_trans_handle *trans,
			     struct btrfs_fs_info *fs_info)
968 969 970
{
	struct btrfs_root *root;
	struct btrfs_root *tree_root = fs_info->tree_root;
971 972 973 974 975 976 977 978 979 980 981 982 983 984 985

	root = kzalloc(sizeof(*root), GFP_NOFS);
	if (!root)
		return -ENOMEM;

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

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

	root->node = btrfs_alloc_free_block(trans, root, root->leafsize,
Z
Zheng Yan 已提交
986 987
					    0, BTRFS_TREE_LOG_OBJECTID,
					    trans->transid, 0, 0, 0);
988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008

	btrfs_set_header_nritems(root->node, 0);
	btrfs_set_header_level(root->node, 0);
	btrfs_set_header_bytenr(root->node, root->node->start);
	btrfs_set_header_generation(root->node, trans->transid);
	btrfs_set_header_owner(root->node, BTRFS_TREE_LOG_OBJECTID);

	write_extent_buffer(root->node, root->fs_info->fsid,
			    (unsigned long)btrfs_header_fsid(root->node),
			    BTRFS_FSID_SIZE);
	btrfs_mark_buffer_dirty(root->node);
	btrfs_tree_unlock(root->node);
	fs_info->log_root_tree = root;
	return 0;
}

struct btrfs_root *btrfs_read_fs_root_no_radix(struct btrfs_root *tree_root,
					       struct btrfs_key *location)
{
	struct btrfs_root *root;
	struct btrfs_fs_info *fs_info = tree_root->fs_info;
1009
	struct btrfs_path *path;
1010
	struct extent_buffer *l;
C
Chris Mason 已提交
1011
	u64 highest_inode;
1012
	u64 generation;
1013
	u32 blocksize;
1014 1015
	int ret = 0;

1016
	root = kzalloc(sizeof(*root), GFP_NOFS);
C
Chris Mason 已提交
1017
	if (!root)
1018 1019
		return ERR_PTR(-ENOMEM);
	if (location->offset == (u64)-1) {
1020
		ret = find_and_setup_root(tree_root, fs_info,
1021 1022 1023 1024 1025 1026 1027 1028
					  location->objectid, root);
		if (ret) {
			kfree(root);
			return ERR_PTR(ret);
		}
		goto insert;
	}

1029
	__setup_root(tree_root->nodesize, tree_root->leafsize,
1030 1031
		     tree_root->sectorsize, tree_root->stripesize,
		     root, fs_info, location->objectid);
1032 1033 1034 1035 1036 1037 1038 1039 1040

	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;
	}
1041 1042 1043
	l = path->nodes[0];
	read_extent_buffer(l, &root->root_item,
	       btrfs_item_ptr_offset(l, path->slots[0]),
1044
	       sizeof(root->root_item));
1045
	memcpy(&root->root_key, location, sizeof(*location));
1046 1047 1048 1049 1050 1051 1052 1053
	ret = 0;
out:
	btrfs_release_path(root, path);
	btrfs_free_path(path);
	if (ret) {
		kfree(root);
		return ERR_PTR(ret);
	}
1054
	generation = btrfs_root_generation(&root->root_item);
1055 1056
	blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
	root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
1057
				     blocksize, generation);
1058 1059
	BUG_ON(!root->node);
insert:
1060 1061 1062 1063 1064 1065 1066
	if (location->objectid != BTRFS_TREE_LOG_OBJECTID) {
		root->ref_cows = 1;
		ret = btrfs_find_highest_inode(root, &highest_inode);
		if (ret == 0) {
			root->highest_inode = highest_inode;
			root->last_inode_alloc = highest_inode;
		}
1067 1068 1069 1070
	}
	return root;
}

C
Chris Mason 已提交
1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085
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;
}

1086 1087
struct btrfs_root *btrfs_read_fs_root_no_name(struct btrfs_fs_info *fs_info,
					      struct btrfs_key *location)
1088 1089 1090 1091
{
	struct btrfs_root *root;
	int ret;

1092 1093 1094 1095
	if (location->objectid == BTRFS_ROOT_TREE_OBJECTID)
		return fs_info->tree_root;
	if (location->objectid == BTRFS_EXTENT_TREE_OBJECTID)
		return fs_info->extent_root;
1096 1097 1098 1099
	if (location->objectid == BTRFS_CHUNK_TREE_OBJECTID)
		return fs_info->chunk_root;
	if (location->objectid == BTRFS_DEV_TREE_OBJECTID)
		return fs_info->dev_root;
1100

1101 1102 1103 1104 1105
	root = radix_tree_lookup(&fs_info->fs_roots_radix,
				 (unsigned long)location->objectid);
	if (root)
		return root;

1106
	root = btrfs_read_fs_root_no_radix(fs_info->tree_root, location);
1107 1108
	if (IS_ERR(root))
		return root;
1109 1110 1111

	set_anon_super(&root->anon_super, NULL);

C
Chris Mason 已提交
1112 1113
	ret = radix_tree_insert(&fs_info->fs_roots_radix,
				(unsigned long)root->root_key.objectid,
1114 1115
				root);
	if (ret) {
1116
		free_extent_buffer(root->node);
1117 1118 1119
		kfree(root);
		return ERR_PTR(ret);
	}
Y
Yan Zheng 已提交
1120 1121 1122 1123 1124 1125
	if (!(fs_info->sb->s_flags & MS_RDONLY)) {
		ret = btrfs_find_dead_roots(fs_info->tree_root,
					    root->root_key.objectid, root);
		BUG_ON(ret);
		btrfs_orphan_cleanup(root);
	}
1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138
	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;
1139

1140 1141 1142
	if (root->in_sysfs)
		return root;

1143 1144
	ret = btrfs_set_root_name(root, name, namelen);
	if (ret) {
1145
		free_extent_buffer(root->node);
1146 1147 1148
		kfree(root);
		return ERR_PTR(ret);
	}
1149
#if 0
1150 1151
	ret = btrfs_sysfs_add_root(root);
	if (ret) {
1152
		free_extent_buffer(root->node);
1153 1154 1155 1156
		kfree(root->name);
		kfree(root);
		return ERR_PTR(ret);
	}
1157
#endif
1158
	root->in_sysfs = 1;
1159 1160
	return root;
}
1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178
#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 已提交
1179 1180 1181 1182 1183 1184 1185 1186

static int btrfs_congested_fn(void *congested_data, int bdi_bits)
{
	struct btrfs_fs_info *info = (struct btrfs_fs_info *)congested_data;
	int ret = 0;
	struct list_head *cur;
	struct btrfs_device *device;
	struct backing_dev_info *bdi;
1187
#if 0
1188
	if ((bdi_bits & (1 << BDI_write_congested)) &&
1189
	    btrfs_congested_async(info, 0))
1190
		return 1;
1191
#endif
C
Chris Mason 已提交
1192 1193
	list_for_each(cur, &info->fs_devices->devices) {
		device = list_entry(cur, struct btrfs_device, dev_list);
1194 1195
		if (!device->bdev)
			continue;
C
Chris Mason 已提交
1196 1197 1198 1199 1200 1201 1202 1203 1204
		bdi = blk_get_backing_dev_info(device->bdev);
		if (bdi && bdi_congested(bdi, bdi_bits)) {
			ret = 1;
			break;
		}
	}
	return ret;
}

1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217
/*
 * 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);
1218 1219 1220
		if (!device->bdev)
			continue;

1221 1222 1223 1224 1225 1226 1227
		bdi = blk_get_backing_dev_info(device->bdev);
		if (bdi->unplug_io_fn) {
			bdi->unplug_io_fn(bdi, page);
		}
	}
}

1228
static void btrfs_unplug_io_fn(struct backing_dev_info *bdi, struct page *page)
C
Chris Mason 已提交
1229
{
1230
	struct inode *inode;
1231 1232
	struct extent_map_tree *em_tree;
	struct extent_map *em;
1233
	struct address_space *mapping;
1234 1235
	u64 offset;

1236
	/* the generic O_DIRECT read code does this */
1237
	if (1 || !page) {
1238 1239 1240 1241
		__unplug_io_fn(bdi, page);
		return;
	}

1242 1243 1244 1245 1246 1247 1248 1249 1250 1251
	/*
	 * 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;
1252 1253 1254 1255 1256 1257 1258 1259 1260 1261

	/*
	 * don't do the expensive searching for a small number of
	 * devices
	 */
	if (BTRFS_I(inode)->root->fs_info->fs_devices->open_devices <= 2) {
		__unplug_io_fn(bdi, page);
		return;
	}

1262
	offset = page_offset(page);
C
Chris Mason 已提交
1263

1264 1265 1266 1267
	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);
1268 1269
	if (!em) {
		__unplug_io_fn(bdi, page);
1270
		return;
1271
	}
1272

1273 1274 1275 1276 1277
	if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
		free_extent_map(em);
		__unplug_io_fn(bdi, page);
		return;
	}
1278 1279 1280 1281
	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 已提交
1282 1283 1284 1285 1286
}

static int setup_bdi(struct btrfs_fs_info *info, struct backing_dev_info *bdi)
{
	bdi_init(bdi);
1287
	bdi->ra_pages	= default_backing_dev_info.ra_pages;
C
Chris Mason 已提交
1288 1289 1290 1291 1292 1293 1294 1295 1296
	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;
}

1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335
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;
}

1336 1337 1338 1339 1340
/*
 * 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)
1341 1342
{
	struct bio *bio;
1343 1344
	struct end_io_wq *end_io_wq;
	struct btrfs_fs_info *fs_info;
1345 1346
	int error;

1347 1348 1349
	end_io_wq = container_of(work, struct end_io_wq, work);
	bio = end_io_wq->bio;
	fs_info = end_io_wq->info;
1350

1351 1352 1353 1354 1355 1356
	/* 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)) {
1357
		btrfs_queue_worker(&fs_info->endio_meta_workers,
1358 1359 1360 1361 1362 1363 1364 1365
				   &end_io_wq->work);
		return;
	}
	error = end_io_wq->error;
	bio->bi_private = end_io_wq->private;
	bio->bi_end_io = end_io_wq->end_io;
	kfree(end_io_wq);
	bio_endio(bio, error);
1366 1367
}

1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413
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);

1414 1415 1416 1417
		if (root->fs_info->total_ref_cache_size > 20 * 1024 * 1024) {
			printk("btrfs: total reference cache size %Lu\n",
				root->fs_info->total_ref_cache_size);
		}
Y
Yan Zheng 已提交
1418

1419 1420 1421 1422 1423 1424
		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 已提交
1425

1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451
		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;
}

1452
struct btrfs_root *open_ctree(struct super_block *sb,
1453 1454
			      struct btrfs_fs_devices *fs_devices,
			      char *options)
1455
{
1456 1457 1458 1459
	u32 sectorsize;
	u32 nodesize;
	u32 leafsize;
	u32 blocksize;
1460
	u32 stripesize;
1461
	u64 generation;
1462
	u64 features;
1463
	struct btrfs_key location;
1464
	struct buffer_head *bh;
1465
	struct btrfs_root *extent_root = kzalloc(sizeof(struct btrfs_root),
C
Chris Mason 已提交
1466
						 GFP_NOFS);
1467 1468
	struct btrfs_root *csum_root = kzalloc(sizeof(struct btrfs_root),
						 GFP_NOFS);
1469
	struct btrfs_root *tree_root = kzalloc(sizeof(struct btrfs_root),
C
Chris Mason 已提交
1470
					       GFP_NOFS);
1471
	struct btrfs_fs_info *fs_info = kzalloc(sizeof(*fs_info),
C
Chris Mason 已提交
1472
						GFP_NOFS);
1473
	struct btrfs_root *chunk_root = kzalloc(sizeof(struct btrfs_root),
1474
						GFP_NOFS);
1475
	struct btrfs_root *dev_root = kzalloc(sizeof(struct btrfs_root),
1476
					      GFP_NOFS);
1477 1478
	struct btrfs_root *log_tree_root;

1479
	int ret;
1480
	int err = -EINVAL;
1481

C
Chris Mason 已提交
1482
	struct btrfs_super_block *disk_super;
1483

1484
	if (!extent_root || !tree_root || !fs_info ||
1485
	    !chunk_root || !dev_root || !csum_root) {
C
Chris Mason 已提交
1486 1487 1488
		err = -ENOMEM;
		goto fail;
	}
1489
	INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_NOFS);
C
Chris Mason 已提交
1490
	INIT_LIST_HEAD(&fs_info->trans_list);
1491
	INIT_LIST_HEAD(&fs_info->dead_roots);
1492
	INIT_LIST_HEAD(&fs_info->hashers);
1493
	INIT_LIST_HEAD(&fs_info->delalloc_inodes);
1494
	spin_lock_init(&fs_info->hash_lock);
1495
	spin_lock_init(&fs_info->delalloc_lock);
1496
	spin_lock_init(&fs_info->new_trans_lock);
Y
Yan Zheng 已提交
1497
	spin_lock_init(&fs_info->ref_cache_lock);
1498

1499
	init_completion(&fs_info->kobj_unregister);
1500 1501
	fs_info->tree_root = tree_root;
	fs_info->extent_root = extent_root;
1502
	fs_info->csum_root = csum_root;
1503 1504
	fs_info->chunk_root = chunk_root;
	fs_info->dev_root = dev_root;
1505
	fs_info->fs_devices = fs_devices;
1506
	INIT_LIST_HEAD(&fs_info->dirty_cowonly_roots);
1507
	INIT_LIST_HEAD(&fs_info->space_info);
1508
	btrfs_mapping_init(&fs_info->mapping_tree);
1509
	atomic_set(&fs_info->nr_async_submits, 0);
1510
	atomic_set(&fs_info->async_delalloc_pages, 0);
1511
	atomic_set(&fs_info->async_submit_draining, 0);
1512
	atomic_set(&fs_info->nr_async_bios, 0);
1513
	atomic_set(&fs_info->throttles, 0);
1514
	atomic_set(&fs_info->throttle_gen, 0);
C
Chris Mason 已提交
1515
	fs_info->sb = sb;
1516
	fs_info->max_extent = (u64)-1;
1517
	fs_info->max_inline = 8192 * 1024;
C
Chris Mason 已提交
1518
	setup_bdi(fs_info, &fs_info->bdi);
1519 1520
	fs_info->btree_inode = new_inode(sb);
	fs_info->btree_inode->i_ino = 1;
C
Chris Mason 已提交
1521
	fs_info->btree_inode->i_nlink = 1;
C
Chris Mason 已提交
1522

1523
	fs_info->thread_pool_size = min(num_online_cpus() + 2, 8);
1524

1525 1526 1527
	INIT_LIST_HEAD(&fs_info->ordered_extents);
	spin_lock_init(&fs_info->ordered_extent_lock);

1528 1529 1530
	sb->s_blocksize = 4096;
	sb->s_blocksize_bits = blksize_bits(4096);

1531 1532 1533 1534 1535 1536
	/*
	 * 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;
1537
	fs_info->btree_inode->i_mapping->a_ops = &btree_aops;
C
Chris Mason 已提交
1538 1539
	fs_info->btree_inode->i_mapping->backing_dev_info = &fs_info->bdi;

1540
	extent_io_tree_init(&BTRFS_I(fs_info->btree_inode)->io_tree,
1541 1542
			     fs_info->btree_inode->i_mapping,
			     GFP_NOFS);
1543 1544 1545 1546
	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;
1547

J
Josef Bacik 已提交
1548 1549 1550
	spin_lock_init(&fs_info->block_group_cache_lock);
	fs_info->block_group_cache_tree.rb_node = NULL;

1551
	extent_io_tree_init(&fs_info->pinned_extents,
1552
			     fs_info->btree_inode->i_mapping, GFP_NOFS);
1553
	extent_io_tree_init(&fs_info->pending_del,
1554
			     fs_info->btree_inode->i_mapping, GFP_NOFS);
1555
	extent_io_tree_init(&fs_info->extent_ins,
1556
			     fs_info->btree_inode->i_mapping, GFP_NOFS);
1557
	fs_info->do_barriers = 1;
1558

Z
Zheng Yan 已提交
1559 1560
	INIT_LIST_HEAD(&fs_info->dead_reloc_roots);
	btrfs_leaf_ref_tree_init(&fs_info->reloc_ref_tree);
Z
Zheng Yan 已提交
1561 1562
	btrfs_leaf_ref_tree_init(&fs_info->shared_ref_tree);

1563 1564 1565
	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 已提交
1566
	insert_inode_hash(fs_info->btree_inode);
C
Chris Mason 已提交
1567

C
Chris Mason 已提交
1568
	mutex_init(&fs_info->trans_mutex);
1569
	mutex_init(&fs_info->tree_log_mutex);
1570
	mutex_init(&fs_info->drop_mutex);
1571 1572
	mutex_init(&fs_info->extent_ins_mutex);
	mutex_init(&fs_info->pinned_mutex);
1573
	mutex_init(&fs_info->chunk_mutex);
1574 1575
	mutex_init(&fs_info->transaction_kthread_mutex);
	mutex_init(&fs_info->cleaner_mutex);
1576
	mutex_init(&fs_info->volume_mutex);
Z
Zheng Yan 已提交
1577
	mutex_init(&fs_info->tree_reloc_mutex);
1578
	init_waitqueue_head(&fs_info->transaction_throttle);
1579
	init_waitqueue_head(&fs_info->transaction_wait);
1580
	init_waitqueue_head(&fs_info->async_submit_wait);
1581 1582 1583 1584
	init_waitqueue_head(&fs_info->tree_log_wait);
	atomic_set(&fs_info->tree_log_commit, 0);
	atomic_set(&fs_info->tree_log_writers, 0);
	fs_info->tree_log_transid = 0;
1585

1586 1587 1588 1589 1590 1591 1592 1593
#if 0
	ret = add_hasher(fs_info, "crc32c");
	if (ret) {
		printk("btrfs: failed hash setup, modprobe cryptomgr?\n");
		err = -ENOMEM;
		goto fail_iput;
	}
#endif
1594
	__setup_root(4096, 4096, 4096, 4096, tree_root,
C
Chris Mason 已提交
1595
		     fs_info, BTRFS_ROOT_TREE_OBJECTID);
1596

1597

Y
Yan Zheng 已提交
1598
	bh = btrfs_read_dev_super(fs_devices->latest_bdev);
1599
	if (!bh)
C
Chris Mason 已提交
1600 1601
		goto fail_iput;

1602 1603
	memcpy(&fs_info->super_copy, bh->b_data, sizeof(fs_info->super_copy));
	brelse(bh);
1604

1605
	memcpy(fs_info->fsid, fs_info->super_copy.fsid, BTRFS_FSID_SIZE);
1606

1607
	disk_super = &fs_info->super_copy;
1608
	if (!btrfs_super_root(disk_super))
1609
		goto fail_iput;
1610

Y
Yan Zheng 已提交
1611 1612 1613
	ret = btrfs_parse_options(tree_root, options);
	if (ret) {
		err = ret;
1614
		goto fail_iput;
Y
Yan Zheng 已提交
1615
	}
1616

1617 1618 1619 1620 1621 1622 1623
	features = btrfs_super_incompat_flags(disk_super) &
		~BTRFS_FEATURE_INCOMPAT_SUPP;
	if (features) {
		printk(KERN_ERR "BTRFS: couldn't mount because of "
		       "unsupported optional features (%Lx).\n",
		       features);
		err = -EINVAL;
1624
		goto fail_iput;
1625 1626 1627 1628 1629 1630 1631 1632 1633
	}

	features = btrfs_super_compat_ro_flags(disk_super) &
		~BTRFS_FEATURE_COMPAT_RO_SUPP;
	if (!(sb->s_flags & MS_RDONLY) && features) {
		printk(KERN_ERR "BTRFS: couldn't mount RDWR because of "
		       "unsupported option features (%Lx).\n",
		       features);
		err = -EINVAL;
1634
		goto fail_iput;
1635 1636
	}

1637 1638 1639 1640 1641
	/*
	 * 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.
	 */
1642 1643
	btrfs_init_workers(&fs_info->workers, "worker",
			   fs_info->thread_pool_size);
C
Chris Mason 已提交
1644

1645 1646 1647
	btrfs_init_workers(&fs_info->delalloc_workers, "delalloc",
			   fs_info->thread_pool_size);

1648
	btrfs_init_workers(&fs_info->submit_workers, "submit",
1649 1650
			   min_t(u64, fs_devices->num_devices,
			   fs_info->thread_pool_size));
1651 1652 1653 1654 1655 1656

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

1658
	fs_info->workers.idle_thresh = 16;
C
Chris Mason 已提交
1659
	fs_info->workers.ordered = 1;
1660

1661 1662 1663
	fs_info->delalloc_workers.idle_thresh = 2;
	fs_info->delalloc_workers.ordered = 1;

1664 1665 1666
	btrfs_init_workers(&fs_info->fixup_workers, "fixup", 1);
	btrfs_init_workers(&fs_info->endio_workers, "endio",
			   fs_info->thread_pool_size);
1667 1668
	btrfs_init_workers(&fs_info->endio_meta_workers, "endio-meta",
			   fs_info->thread_pool_size);
1669
	btrfs_init_workers(&fs_info->endio_write_workers, "endio-write",
1670
			   fs_info->thread_pool_size);
1671 1672 1673 1674 1675 1676

	/*
	 * endios are largely parallel and should have a very
	 * low idle thresh
	 */
	fs_info->endio_workers.idle_thresh = 4;
1677
	fs_info->endio_write_workers.idle_thresh = 64;
1678

1679
	btrfs_start_workers(&fs_info->workers, 1);
1680
	btrfs_start_workers(&fs_info->submit_workers, 1);
1681
	btrfs_start_workers(&fs_info->delalloc_workers, 1);
1682
	btrfs_start_workers(&fs_info->fixup_workers, 1);
1683
	btrfs_start_workers(&fs_info->endio_workers, fs_info->thread_pool_size);
1684 1685
	btrfs_start_workers(&fs_info->endio_meta_workers,
			    fs_info->thread_pool_size);
1686 1687
	btrfs_start_workers(&fs_info->endio_write_workers,
			    fs_info->thread_pool_size);
1688

1689
	fs_info->bdi.ra_pages *= btrfs_super_num_devices(disk_super);
C
Chris Mason 已提交
1690 1691
	fs_info->bdi.ra_pages = max(fs_info->bdi.ra_pages,
				    4 * 1024 * 1024 / PAGE_CACHE_SIZE);
1692

1693 1694 1695
	nodesize = btrfs_super_nodesize(disk_super);
	leafsize = btrfs_super_leafsize(disk_super);
	sectorsize = btrfs_super_sectorsize(disk_super);
1696
	stripesize = btrfs_super_stripesize(disk_super);
1697 1698 1699
	tree_root->nodesize = nodesize;
	tree_root->leafsize = leafsize;
	tree_root->sectorsize = sectorsize;
1700
	tree_root->stripesize = stripesize;
1701 1702 1703

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

C
Chris Mason 已提交
1705 1706 1707 1708 1709
	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;
	}
1710

1711
	mutex_lock(&fs_info->chunk_mutex);
Y
Yan Zheng 已提交
1712
	ret = btrfs_read_sys_array(tree_root, btrfs_super_bytenr(disk_super));
1713
	mutex_unlock(&fs_info->chunk_mutex);
1714 1715 1716 1717 1718
	if (ret) {
		printk("btrfs: failed to read the system array on %s\n",
		       sb->s_id);
		goto fail_sys_array;
	}
1719 1720 1721

	blocksize = btrfs_level_size(tree_root,
				     btrfs_super_chunk_root_level(disk_super));
1722
	generation = btrfs_super_chunk_root_generation(disk_super);
1723 1724 1725 1726 1727 1728

	__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),
1729
					   blocksize, generation);
1730 1731
	BUG_ON(!chunk_root->node);

1732 1733 1734 1735
	read_extent_buffer(chunk_root->node, fs_info->chunk_tree_uuid,
	         (unsigned long)btrfs_header_chunk_tree_uuid(chunk_root->node),
		 BTRFS_UUID_SIZE);

1736
	mutex_lock(&fs_info->chunk_mutex);
1737
	ret = btrfs_read_chunk_tree(chunk_root);
1738
	mutex_unlock(&fs_info->chunk_mutex);
Y
Yan Zheng 已提交
1739 1740 1741 1742
	if (ret) {
		printk("btrfs: failed to read chunk tree on %s\n", sb->s_id);
		goto fail_chunk_root;
	}
1743

1744 1745
	btrfs_close_extra_devices(fs_devices);

1746 1747
	blocksize = btrfs_level_size(tree_root,
				     btrfs_super_root_level(disk_super));
1748
	generation = btrfs_super_generation(disk_super);
1749

C
Chris Mason 已提交
1750
	tree_root->node = read_tree_block(tree_root,
1751
					  btrfs_super_root(disk_super),
1752
					  blocksize, generation);
C
Chris Mason 已提交
1753
	if (!tree_root->node)
Y
Yan Zheng 已提交
1754
		goto fail_chunk_root;
1755

1756 1757

	ret = find_and_setup_root(tree_root, fs_info,
C
Chris Mason 已提交
1758
				  BTRFS_EXTENT_TREE_OBJECTID, extent_root);
1759
	if (ret)
C
Chris Mason 已提交
1760
		goto fail_tree_root;
1761 1762 1763 1764 1765 1766 1767 1768
	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;
1769

1770 1771 1772 1773 1774 1775 1776
	ret = find_and_setup_root(tree_root, fs_info,
				  BTRFS_CSUM_TREE_OBJECTID, csum_root);
	if (ret)
		goto fail_extent_root;

	csum_root->track_dirty = 1;

C
Chris Mason 已提交
1777 1778
	btrfs_read_block_groups(extent_root);

Y
Yan Zheng 已提交
1779 1780
	fs_info->generation = generation + 1;
	fs_info->last_trans_committed = generation;
C
Chris Mason 已提交
1781 1782 1783
	fs_info->data_alloc_profile = (u64)-1;
	fs_info->metadata_alloc_profile = (u64)-1;
	fs_info->system_alloc_profile = fs_info->metadata_alloc_profile;
1784 1785 1786
	fs_info->cleaner_kthread = kthread_run(cleaner_kthread, tree_root,
					       "btrfs-cleaner");
	if (!fs_info->cleaner_kthread)
1787
		goto fail_csum_root;
1788 1789 1790 1791 1792

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

1795 1796 1797
	if (btrfs_super_log_root(disk_super) != 0) {
		u64 bytenr = btrfs_super_log_root(disk_super);

1798 1799 1800 1801 1802
		if (fs_devices->rw_devices == 0) {
			printk("Btrfs log replay required on RO media\n");
			err = -EIO;
			goto fail_trans_kthread;
		}
1803 1804 1805
		blocksize =
		     btrfs_level_size(tree_root,
				      btrfs_super_log_root_level(disk_super));
C
Chris Mason 已提交
1806

1807 1808 1809 1810 1811 1812 1813
		log_tree_root = kzalloc(sizeof(struct btrfs_root),
						      GFP_NOFS);

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

		log_tree_root->node = read_tree_block(tree_root, bytenr,
1814 1815
						      blocksize,
						      generation + 1);
1816 1817
		ret = btrfs_recover_log_trees(log_tree_root);
		BUG_ON(ret);
1818 1819 1820 1821 1822

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

1825 1826 1827 1828
	if (!(sb->s_flags & MS_RDONLY)) {
		ret = btrfs_cleanup_reloc_trees(tree_root);
		BUG_ON(ret);
	}
Z
Zheng Yan 已提交
1829

1830 1831 1832 1833 1834 1835
	location.objectid = BTRFS_FS_TREE_OBJECTID;
	location.type = BTRFS_ROOT_ITEM_KEY;
	location.offset = (u64)-1;

	fs_info->fs_root = btrfs_read_fs_root_no_name(fs_info, &location);
	if (!fs_info->fs_root)
1836
		goto fail_trans_kthread;
1837
	return tree_root;
C
Chris Mason 已提交
1838

1839 1840
fail_trans_kthread:
	kthread_stop(fs_info->transaction_kthread);
1841
fail_cleaner:
1842
	kthread_stop(fs_info->cleaner_kthread);
1843 1844 1845 1846 1847 1848 1849 1850

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

1851 1852
fail_csum_root:
	free_extent_buffer(csum_root->node);
1853 1854
fail_extent_root:
	free_extent_buffer(extent_root->node);
C
Chris Mason 已提交
1855
fail_tree_root:
1856
	free_extent_buffer(tree_root->node);
Y
Yan Zheng 已提交
1857 1858
fail_chunk_root:
	free_extent_buffer(chunk_root->node);
1859
fail_sys_array:
1860
	free_extent_buffer(dev_root->node);
C
Chris Mason 已提交
1861
fail_sb_buffer:
1862
	btrfs_stop_workers(&fs_info->fixup_workers);
1863
	btrfs_stop_workers(&fs_info->delalloc_workers);
1864 1865
	btrfs_stop_workers(&fs_info->workers);
	btrfs_stop_workers(&fs_info->endio_workers);
1866
	btrfs_stop_workers(&fs_info->endio_meta_workers);
1867
	btrfs_stop_workers(&fs_info->endio_write_workers);
1868
	btrfs_stop_workers(&fs_info->submit_workers);
1869
fail_iput:
1870
	invalidate_inode_pages2(fs_info->btree_inode->i_mapping);
1871
	iput(fs_info->btree_inode);
C
Chris Mason 已提交
1872
fail:
1873
	btrfs_close_devices(fs_info->fs_devices);
1874 1875
	btrfs_mapping_tree_free(&fs_info->mapping_tree);

C
Chris Mason 已提交
1876 1877
	kfree(extent_root);
	kfree(tree_root);
1878
	bdi_destroy(&fs_info->bdi);
C
Chris Mason 已提交
1879
	kfree(fs_info);
1880 1881
	kfree(chunk_root);
	kfree(dev_root);
1882
	kfree(csum_root);
C
Chris Mason 已提交
1883
	return ERR_PTR(err);
1884 1885
}

1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897
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));
		}
1898 1899 1900
		/* note, we dont' set_buffer_write_io_error because we have
		 * our own ways of dealing with the IO errors
		 */
1901 1902 1903 1904 1905 1906
		clear_buffer_uptodate(bh);
	}
	unlock_buffer(bh);
	put_bh(bh);
}

Y
Yan Zheng 已提交
1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037
struct buffer_head *btrfs_read_dev_super(struct block_device *bdev)
{
	struct buffer_head *bh;
	struct buffer_head *latest = NULL;
	struct btrfs_super_block *super;
	int i;
	u64 transid = 0;
	u64 bytenr;

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

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

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

static int write_dev_supers(struct btrfs_device *device,
			    struct btrfs_super_block *sb,
			    int do_barriers, int wait, int max_mirrors)
{
	struct buffer_head *bh;
	int i;
	int ret;
	int errors = 0;
	u32 crc;
	u64 bytenr;
	int last_barrier = 0;

	if (max_mirrors == 0)
		max_mirrors = BTRFS_SUPER_MIRROR_MAX;

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

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

		if (wait) {
			bh = __find_get_block(device->bdev, bytenr / 4096,
					      BTRFS_SUPER_INFO_SIZE);
			BUG_ON(!bh);
			brelse(bh);
			wait_on_buffer(bh);
			if (buffer_uptodate(bh)) {
				brelse(bh);
				continue;
			}
		} else {
			btrfs_set_super_bytenr(sb, bytenr);

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

			bh = __getblk(device->bdev, bytenr / 4096,
				      BTRFS_SUPER_INFO_SIZE);
			memcpy(bh->b_data, sb, BTRFS_SUPER_INFO_SIZE);

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

		if (i == last_barrier && do_barriers && device->barriers) {
			ret = submit_bh(WRITE_BARRIER, bh);
			if (ret == -EOPNOTSUPP) {
				printk("btrfs: disabling barriers on dev %s\n",
				       device->name);
				set_buffer_uptodate(bh);
				device->barriers = 0;
				get_bh(bh);
				lock_buffer(bh);
				ret = submit_bh(WRITE, bh);
			}
		} else {
			ret = submit_bh(WRITE, bh);
		}

		if (!ret && wait) {
			wait_on_buffer(bh);
			if (!buffer_uptodate(bh))
				errors++;
		} else if (ret) {
			errors++;
		}
		if (wait)
			brelse(bh);
	}
	return errors < i ? 0 : -1;
}

int write_all_supers(struct btrfs_root *root, int max_mirrors)
2038 2039 2040 2041
{
	struct list_head *cur;
	struct list_head *head = &root->fs_info->fs_devices->devices;
	struct btrfs_device *dev;
2042
	struct btrfs_super_block *sb;
2043 2044 2045
	struct btrfs_dev_item *dev_item;
	int ret;
	int do_barriers;
2046 2047
	int max_errors;
	int total_errors = 0;
2048
	u64 flags;
2049

2050
	max_errors = btrfs_super_num_devices(&root->fs_info->super_copy) - 1;
2051 2052
	do_barriers = !btrfs_test_opt(root, NOBARRIER);

2053 2054
	sb = &root->fs_info->super_for_commit;
	dev_item = &sb->dev_item;
2055 2056
	list_for_each(cur, head) {
		dev = list_entry(cur, struct btrfs_device, dev_list);
2057 2058 2059 2060
		if (!dev->bdev) {
			total_errors++;
			continue;
		}
Y
Yan Zheng 已提交
2061
		if (!dev->in_fs_metadata || !dev->writeable)
2062 2063
			continue;

Y
Yan Zheng 已提交
2064
		btrfs_set_stack_device_generation(dev_item, 0);
2065 2066 2067 2068 2069 2070 2071 2072
		btrfs_set_stack_device_type(dev_item, dev->type);
		btrfs_set_stack_device_id(dev_item, dev->devid);
		btrfs_set_stack_device_total_bytes(dev_item, dev->total_bytes);
		btrfs_set_stack_device_bytes_used(dev_item, dev->bytes_used);
		btrfs_set_stack_device_io_align(dev_item, dev->io_align);
		btrfs_set_stack_device_io_width(dev_item, dev->io_width);
		btrfs_set_stack_device_sector_size(dev_item, dev->sector_size);
		memcpy(dev_item->uuid, dev->uuid, BTRFS_UUID_SIZE);
Y
Yan Zheng 已提交
2073
		memcpy(dev_item->fsid, dev->fs_devices->fsid, BTRFS_UUID_SIZE);
Y
Yan Zheng 已提交
2074

2075 2076 2077
		flags = btrfs_super_flags(sb);
		btrfs_set_super_flags(sb, flags | BTRFS_HEADER_FLAG_WRITTEN);

Y
Yan Zheng 已提交
2078
		ret = write_dev_supers(dev, sb, do_barriers, 0, max_mirrors);
2079 2080
		if (ret)
			total_errors++;
2081
	}
2082 2083 2084 2085
	if (total_errors > max_errors) {
		printk("btrfs: %d errors while writing supers\n", total_errors);
		BUG();
	}
2086

Y
Yan Zheng 已提交
2087
	total_errors = 0;
2088 2089
	list_for_each(cur, head) {
		dev = list_entry(cur, struct btrfs_device, dev_list);
2090 2091
		if (!dev->bdev)
			continue;
Y
Yan Zheng 已提交
2092
		if (!dev->in_fs_metadata || !dev->writeable)
2093 2094
			continue;

Y
Yan Zheng 已提交
2095 2096 2097
		ret = write_dev_supers(dev, sb, do_barriers, 1, max_mirrors);
		if (ret)
			total_errors++;
2098
	}
2099 2100 2101 2102
	if (total_errors > max_errors) {
		printk("btrfs: %d errors while writing supers\n", total_errors);
		BUG();
	}
2103 2104 2105
	return 0;
}

Y
Yan Zheng 已提交
2106 2107
int write_ctree_super(struct btrfs_trans_handle *trans,
		      struct btrfs_root *root, int max_mirrors)
2108
{
2109
	int ret;
2110

Y
Yan Zheng 已提交
2111
	ret = write_all_supers(root, max_mirrors);
2112
	return ret;
C
Chris Mason 已提交
2113 2114
}

2115
int btrfs_free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root)
C
Chris Mason 已提交
2116 2117 2118
{
	radix_tree_delete(&fs_info->fs_roots_radix,
			  (unsigned long)root->root_key.objectid);
2119 2120 2121 2122
	if (root->anon_super.s_dev) {
		down_write(&root->anon_super.s_umount);
		kill_anon_super(&root->anon_super);
	}
2123
#if 0
2124 2125
	if (root->in_sysfs)
		btrfs_sysfs_del_root(root);
2126
#endif
C
Chris Mason 已提交
2127
	if (root->node)
2128
		free_extent_buffer(root->node);
C
Chris Mason 已提交
2129
	if (root->commit_root)
2130
		free_extent_buffer(root->commit_root);
2131 2132
	if (root->name)
		kfree(root->name);
C
Chris Mason 已提交
2133 2134 2135 2136
	kfree(root);
	return 0;
}

C
Chris Mason 已提交
2137
static int del_fs_roots(struct btrfs_fs_info *fs_info)
2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148
{
	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 已提交
2149
		for (i = 0; i < ret; i++)
2150
			btrfs_free_fs_root(fs_info, gang[i]);
2151 2152 2153
	}
	return 0;
}
2154

Y
Yan Zheng 已提交
2155
int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info)
C
Chris Mason 已提交
2156
{
Y
Yan Zheng 已提交
2157 2158 2159
	u64 root_objectid = 0;
	struct btrfs_root *gang[8];
	int i;
2160
	int ret;
2161

Y
Yan Zheng 已提交
2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178
	while (1) {
		ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
					     (void **)gang, root_objectid,
					     ARRAY_SIZE(gang));
		if (!ret)
			break;
		for (i = 0; i < ret; i++) {
			root_objectid = gang[i]->root_key.objectid;
			ret = btrfs_find_dead_roots(fs_info->tree_root,
						    root_objectid, gang[i]);
			BUG_ON(ret);
			btrfs_orphan_cleanup(gang[i]);
		}
		root_objectid++;
	}
	return 0;
}
2179

Y
Yan Zheng 已提交
2180 2181 2182 2183
int btrfs_commit_super(struct btrfs_root *root)
{
	struct btrfs_trans_handle *trans;
	int ret;
2184

Y
Yan Zheng 已提交
2185
	mutex_lock(&root->fs_info->cleaner_mutex);
2186
	btrfs_clean_old_snapshots(root);
Y
Yan Zheng 已提交
2187
	mutex_unlock(&root->fs_info->cleaner_mutex);
C
Chris Mason 已提交
2188
	trans = btrfs_start_transaction(root, 1);
2189
	ret = btrfs_commit_transaction(trans, root);
Y
Yan Zheng 已提交
2190 2191
	BUG_ON(ret);
	/* run commit again to drop the original snapshot */
C
Chris Mason 已提交
2192 2193 2194
	trans = btrfs_start_transaction(root, 1);
	btrfs_commit_transaction(trans, root);
	ret = btrfs_write_and_wait_transaction(NULL, root);
2195
	BUG_ON(ret);
2196

Y
Yan Zheng 已提交
2197
	ret = write_ctree_super(NULL, root, 0);
Y
Yan Zheng 已提交
2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217
	return ret;
}

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

	fs_info->closing = 1;
	smp_mb();

	kthread_stop(root->fs_info->transaction_kthread);
	kthread_stop(root->fs_info->cleaner_kthread);

	if (!(fs_info->sb->s_flags & MS_RDONLY)) {
		ret =  btrfs_commit_super(root);
		if (ret) {
			printk("btrfs: commit super returns %d\n", ret);
		}
	}
2218

C
Chris Mason 已提交
2219 2220 2221 2222
	if (fs_info->delalloc_bytes) {
		printk("btrfs: at unmount delalloc count %Lu\n",
		       fs_info->delalloc_bytes);
	}
Y
Yan Zheng 已提交
2223 2224 2225 2226
	if (fs_info->total_ref_cache_size) {
		printk("btrfs: at umount reference cache size %Lu\n",
			fs_info->total_ref_cache_size);
	}
2227

2228
	if (fs_info->extent_root->node)
2229
		free_extent_buffer(fs_info->extent_root->node);
2230

2231
	if (fs_info->tree_root->node)
2232
		free_extent_buffer(fs_info->tree_root->node);
2233

2234 2235 2236 2237 2238 2239
	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);

2240 2241 2242
	if (root->fs_info->csum_root->node);
		free_extent_buffer(root->fs_info->csum_root->node);

C
Chris Mason 已提交
2243
	btrfs_free_block_groups(root->fs_info);
2244

Y
Yan Zheng 已提交
2245
	del_fs_roots(fs_info);
2246

Y
Yan Zheng 已提交
2247
	iput(fs_info->btree_inode);
2248

2249
	btrfs_stop_workers(&fs_info->fixup_workers);
2250
	btrfs_stop_workers(&fs_info->delalloc_workers);
2251 2252
	btrfs_stop_workers(&fs_info->workers);
	btrfs_stop_workers(&fs_info->endio_workers);
2253
	btrfs_stop_workers(&fs_info->endio_meta_workers);
2254
	btrfs_stop_workers(&fs_info->endio_write_workers);
2255
	btrfs_stop_workers(&fs_info->submit_workers);
2256

2257 2258 2259 2260 2261 2262 2263 2264 2265 2266
#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
2267
	btrfs_close_devices(fs_info->fs_devices);
2268
	btrfs_mapping_tree_free(&fs_info->mapping_tree);
2269

C
Chris Mason 已提交
2270
	bdi_destroy(&fs_info->bdi);
2271

2272 2273
	kfree(fs_info->extent_root);
	kfree(fs_info->tree_root);
2274 2275
	kfree(fs_info->chunk_root);
	kfree(fs_info->dev_root);
2276
	kfree(fs_info->csum_root);
2277 2278 2279
	return 0;
}

2280
int btrfs_buffer_uptodate(struct extent_buffer *buf, u64 parent_transid)
2281
{
2282
	int ret;
2283
	struct inode *btree_inode = buf->first_page->mapping->host;
2284 2285 2286 2287 2288 2289 2290 2291

	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;
2292 2293 2294
}

int btrfs_set_buffer_uptodate(struct extent_buffer *buf)
C
Chris Mason 已提交
2295
{
2296
	struct inode *btree_inode = buf->first_page->mapping->host;
2297
	return set_extent_buffer_uptodate(&BTRFS_I(btree_inode)->io_tree,
2298 2299
					  buf);
}
2300

2301 2302
void btrfs_mark_buffer_dirty(struct extent_buffer *buf)
{
2303
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
2304 2305
	u64 transid = btrfs_header_generation(buf);
	struct inode *btree_inode = root->fs_info->btree_inode;
2306

2307
	WARN_ON(!btrfs_tree_locked(buf));
C
Chris Mason 已提交
2308 2309
	if (transid != root->fs_info->generation) {
		printk(KERN_CRIT "transid mismatch buffer %llu, found %Lu running %Lu\n",
2310
			(unsigned long long)buf->start,
C
Chris Mason 已提交
2311 2312 2313
			transid, root->fs_info->generation);
		WARN_ON(1);
	}
2314
	set_extent_buffer_dirty(&BTRFS_I(btree_inode)->io_tree, buf);
2315 2316
}

2317
void btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr)
C
Chris Mason 已提交
2318
{
2319 2320 2321 2322
	/*
	 * looks as though older kernels can get into trouble with
	 * this code, they end up stuck in balance_dirty_pages forever
	 */
2323 2324 2325
	struct extent_io_tree *tree;
	u64 num_dirty;
	u64 start = 0;
2326
	unsigned long thresh = 32 * 1024 * 1024;
2327 2328
	tree = &BTRFS_I(root->fs_info->btree_inode)->io_tree;

2329
	if (current_is_pdflush() || current->flags & PF_MEMALLOC)
2330 2331 2332 2333 2334 2335
		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 已提交
2336
				   root->fs_info->btree_inode->i_mapping, 1);
2337
	}
2338
	return;
C
Chris Mason 已提交
2339
}
2340

2341
int btrfs_read_buffer(struct extent_buffer *buf, u64 parent_transid)
2342
{
2343
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
2344
	int ret;
2345
	ret = btree_read_extent_buffer_pages(root, buf, 0, parent_transid);
2346 2347 2348 2349
	if (ret == 0) {
		buf->flags |= EXTENT_UPTODATE;
	}
	return ret;
2350
}
2351

C
Chris Mason 已提交
2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379
int btree_lock_page_hook(struct page *page)
{
	struct inode *inode = page->mapping->host;
	struct btrfs_root *root = BTRFS_I(inode)->root;
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
	struct extent_buffer *eb;
	unsigned long len;
	u64 bytenr = page_offset(page);

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

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

	btrfs_tree_lock(eb);
	spin_lock(&root->fs_info->hash_lock);
	btrfs_set_header_flag(eb, BTRFS_HEADER_FLAG_WRITTEN);
	spin_unlock(&root->fs_info->hash_lock);
	btrfs_tree_unlock(eb);
	free_extent_buffer(eb);
out:
	lock_page(page);
	return 0;
}

2380
static struct extent_io_ops btree_extent_io_ops = {
C
Chris Mason 已提交
2381
	.write_cache_pages_lock_hook = btree_lock_page_hook,
2382
	.readpage_end_io_hook = btree_readpage_end_io_hook,
2383
	.submit_bio_hook = btree_submit_bio_hook,
2384 2385
	/* note we're sharing with inode.c for the merge bio hook */
	.merge_bio_hook = btrfs_merge_bio_hook,
2386
};