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

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

42
static struct extent_io_ops btree_extent_io_ops;
43
static void end_workqueue_fn(struct btrfs_work *work);
44

C
Chris Mason 已提交
45 46 47 48 49
/*
 * 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.
 */
50 51 52 53 54 55
struct end_io_wq {
	struct bio *bio;
	bio_end_io_t *end_io;
	void *private;
	struct btrfs_fs_info *info;
	int error;
56
	int metadata;
57
	struct list_head list;
58
	struct btrfs_work work;
59
};
60

C
Chris Mason 已提交
61 62 63 64 65
/*
 * 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.
 */
66 67 68 69
struct async_submit_bio {
	struct inode *inode;
	struct bio *bio;
	struct list_head list;
C
Chris Mason 已提交
70 71
	extent_submit_bio_hook_t *submit_bio_start;
	extent_submit_bio_hook_t *submit_bio_done;
72 73
	int rw;
	int mirror_num;
C
Chris Mason 已提交
74
	unsigned long bio_flags;
75
	struct btrfs_work work;
76 77
};

78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111
/* These are used to set the lockdep class on the extent buffer locks.
 * The class is set by the readpage_end_io_hook after the buffer has
 * passed csum validation but before the pages are unlocked.
 *
 * The lockdep class is also set by btrfs_init_new_buffer on freshly
 * allocated blocks.
 *
 * The class is based on the level in the tree block, which allows lockdep
 * to know that lower nodes nest inside the locks of higher nodes.
 *
 * We also add a check to make sure the highest level of the tree is
 * the same as our lockdep setup here.  If BTRFS_MAX_LEVEL changes, this
 * code needs update as well.
 */
#ifdef CONFIG_DEBUG_LOCK_ALLOC
# if BTRFS_MAX_LEVEL != 8
#  error
# endif
static struct lock_class_key btrfs_eb_class[BTRFS_MAX_LEVEL + 1];
static const char *btrfs_eb_name[BTRFS_MAX_LEVEL + 1] = {
	/* leaf */
	"btrfs-extent-00",
	"btrfs-extent-01",
	"btrfs-extent-02",
	"btrfs-extent-03",
	"btrfs-extent-04",
	"btrfs-extent-05",
	"btrfs-extent-06",
	"btrfs-extent-07",
	/* highest possible level */
	"btrfs-extent-08",
};
#endif

C
Chris Mason 已提交
112 113 114 115
/*
 * extents on the btree inode are pretty simple, there's one extent
 * that covers the entire device
 */
116 117 118
static struct extent_map *btree_get_extent(struct inode *inode,
		struct page *page, size_t page_offset, u64 start, u64 len,
		int create)
119
{
120 121 122 123
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
	struct extent_map *em;
	int ret;

124 125
	spin_lock(&em_tree->lock);
	em = lookup_extent_mapping(em_tree, start, len);
126 127 128 129
	if (em) {
		em->bdev =
			BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev;
		spin_unlock(&em_tree->lock);
130
		goto out;
131 132
	}
	spin_unlock(&em_tree->lock);
133

134 135 136 137 138 139
	em = alloc_extent_map(GFP_NOFS);
	if (!em) {
		em = ERR_PTR(-ENOMEM);
		goto out;
	}
	em->start = 0;
140
	em->len = (u64)-1;
C
Chris Mason 已提交
141
	em->block_len = (u64)-1;
142
	em->block_start = 0;
143
	em->bdev = BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev;
144 145

	spin_lock(&em_tree->lock);
146 147
	ret = add_extent_mapping(em_tree, em);
	if (ret == -EEXIST) {
148 149 150
		u64 failed_start = em->start;
		u64 failed_len = em->len;

151
		free_extent_map(em);
152
		em = lookup_extent_mapping(em_tree, start, len);
153
		if (em) {
154
			ret = 0;
155 156 157
		} else {
			em = lookup_extent_mapping(em_tree, failed_start,
						   failed_len);
158
			ret = -EIO;
159
		}
160
	} else if (ret) {
161 162
		free_extent_map(em);
		em = NULL;
163
	}
164 165 166 167
	spin_unlock(&em_tree->lock);

	if (ret)
		em = ERR_PTR(ret);
168 169
out:
	return em;
170 171
}

172 173
u32 btrfs_csum_data(struct btrfs_root *root, char *data, u32 seed, size_t len)
{
174
	return btrfs_crc32c(seed, data, len);
175 176 177 178 179 180 181
}

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

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

	len = buf->len - offset;
C
Chris Mason 已提交
204
	while (len > 0) {
205 206 207
		err = map_private_extent_buffer(buf, offset, 32,
					&map_token, &kaddr,
					&map_start, &map_len, KM_USER0);
C
Chris Mason 已提交
208
		if (err)
209 210 211 212 213 214 215 216
			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);
	}
217 218 219 220 221 222 223 224
	if (csum_size > sizeof(inline_result)) {
		result = kzalloc(csum_size * sizeof(char), GFP_NOFS);
		if (!result)
			return 1;
	} else {
		result = (char *)&inline_result;
	}

225 226 227
	btrfs_csum_final(crc, result);

	if (verify) {
228
		if (memcmp_extent_buffer(buf, result, 0, csum_size)) {
229 230
			u32 val;
			u32 found = 0;
231
			memcpy(&found, result, csum_size);
232

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

C
Chris Mason 已提交
250 251 252 253 254 255
/*
 * 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.
 */
256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275
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 已提交
276
out:
277 278 279 280 281
	unlock_extent(io_tree, eb->start, eb->start + eb->len - 1,
		      GFP_NOFS);
	return ret;
}

C
Chris Mason 已提交
282 283 284 285
/*
 * helper to read a given tree block, doing retries as required when
 * the checksums don't match and we have alternate mirrors to try.
 */
286 287
static int btree_read_extent_buffer_pages(struct btrfs_root *root,
					  struct extent_buffer *eb,
288
					  u64 start, u64 parent_transid)
289 290 291 292 293 294 295 296 297 298
{
	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);
299 300
		if (!ret &&
		    !verify_parent_transid(io_tree, eb, parent_transid))
301
			return ret;
C
Chris Mason 已提交
302

303 304
		num_copies = btrfs_num_copies(&root->fs_info->mapping_tree,
					      eb->start, eb->len);
C
Chris Mason 已提交
305
		if (num_copies == 1)
306
			return ret;
C
Chris Mason 已提交
307

308
		mirror_num++;
C
Chris Mason 已提交
309
		if (mirror_num > num_copies)
310 311 312 313
			return ret;
	}
	return -EIO;
}
314

C
Chris Mason 已提交
315
/*
C
Chris Mason 已提交
316 317
 * checksum a dirty tree block before IO.  This has extra checks to make sure
 * we only fill in the checksum field in the first page of a multi-page block
C
Chris Mason 已提交
318
 */
C
Chris Mason 已提交
319

320
static int csum_dirty_buffer(struct btrfs_root *root, struct page *page)
321
{
322
	struct extent_io_tree *tree;
323
	u64 start = (u64)page->index << PAGE_CACHE_SHIFT;
324 325 326 327
	u64 found_start;
	int found_level;
	unsigned long len;
	struct extent_buffer *eb;
328 329
	int ret;

330
	tree = &BTRFS_I(page->mapping->host)->io_tree;
331 332 333 334 335 336

	if (page->private == EXTENT_PAGE_PRIVATE)
		goto out;
	if (!page->private)
		goto out;
	len = page->private >> 2;
C
Chris Mason 已提交
337 338
	WARN_ON(len == 0);

339
	eb = alloc_extent_buffer(tree, start, len, page, GFP_NOFS);
340 341
	ret = btree_read_extent_buffer_pages(root, eb, start + PAGE_CACHE_SIZE,
					     btrfs_header_generation(eb));
342
	BUG_ON(ret);
343 344
	found_start = btrfs_header_bytenr(eb);
	if (found_start != start) {
345 346 347 348 349 350 351 352 353 354
		WARN_ON(1);
		goto err;
	}
	if (eb->first_page != page) {
		WARN_ON(1);
		goto err;
	}
	if (!PageUptodate(page)) {
		WARN_ON(1);
		goto err;
355 356
	}
	found_level = btrfs_header_level(eb);
C
Chris Mason 已提交
357

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

Y
Yan Zheng 已提交
365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383
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;
}

384 385 386 387 388 389 390 391 392
#ifdef CONFIG_DEBUG_LOCK_ALLOC
void btrfs_set_buffer_lockdep_class(struct extent_buffer *eb, int level)
{
	lockdep_set_class_and_name(&eb->lock,
			   &btrfs_eb_class[level],
			   btrfs_eb_name[level]);
}
#endif

393
static int btree_readpage_end_io_hook(struct page *page, u64 start, u64 end,
394 395 396 397 398 399 400 401
			       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;
402
	int ret = 0;
403 404 405 406 407 408

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

410
	len = page->private >> 2;
C
Chris Mason 已提交
411 412
	WARN_ON(len == 0);

413
	eb = alloc_extent_buffer(tree, start, len, page, GFP_NOFS);
414

415
	found_start = btrfs_header_bytenr(eb);
416
	if (found_start != start) {
C
Chris Mason 已提交
417
		printk(KERN_INFO "btrfs bad tree block start %llu %llu\n",
418 419
		       (unsigned long long)found_start,
		       (unsigned long long)eb->start);
420
		ret = -EIO;
421 422 423
		goto err;
	}
	if (eb->first_page != page) {
C
Chris Mason 已提交
424 425
		printk(KERN_INFO "btrfs bad first page %lu %lu\n",
		       eb->first_page->index, page->index);
426
		WARN_ON(1);
427
		ret = -EIO;
428 429
		goto err;
	}
Y
Yan Zheng 已提交
430
	if (check_tree_block_fsid(root, eb)) {
C
Chris Mason 已提交
431 432
		printk(KERN_INFO "btrfs bad fsid on block %llu\n",
		       (unsigned long long)eb->start);
433 434 435
		ret = -EIO;
		goto err;
	}
436 437
	found_level = btrfs_header_level(eb);

438 439
	btrfs_set_buffer_lockdep_class(eb, found_level);

440
	ret = csum_tree_block(root, eb, 1);
441 442
	if (ret)
		ret = -EIO;
443 444 445 446 447 448

	end = min_t(u64, eb->len, PAGE_CACHE_SIZE);
	end = eb->start + end - 1;
err:
	free_extent_buffer(eb);
out:
449
	return ret;
450 451 452 453 454 455 456 457 458
}

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;
459 460
	end_io_wq->work.func = end_workqueue_fn;
	end_io_wq->work.flags = 0;
461 462

	if (bio->bi_rw & (1 << BIO_RW)) {
463 464 465 466 467 468
		if (end_io_wq->metadata)
			btrfs_queue_worker(&fs_info->endio_meta_write_workers,
					   &end_io_wq->work);
		else
			btrfs_queue_worker(&fs_info->endio_write_workers,
					   &end_io_wq->work);
469 470 471 472 473 474 475 476
	} 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);
	}
477 478
}

479 480
int btrfs_bio_wq_end_io(struct btrfs_fs_info *info, struct bio *bio,
			int metadata)
481
{
482 483 484 485 486 487 488
	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;
489
	end_io_wq->info = info;
490 491
	end_io_wq->error = 0;
	end_io_wq->bio = bio;
492
	end_io_wq->metadata = metadata;
493 494 495

	bio->bi_private = end_io_wq;
	bio->bi_end_io = end_workqueue_bio;
496 497 498
	return 0;
}

499
unsigned long btrfs_async_submit_limit(struct btrfs_fs_info *info)
500
{
501 502 503 504 505
	unsigned long limit = min_t(unsigned long,
				    info->workers.max_workers,
				    info->fs_devices->open_devices);
	return 256 * limit;
}
506

507 508
int btrfs_congested_async(struct btrfs_fs_info *info, int iodone)
{
509 510
	return atomic_read(&info->nr_async_bios) >
		btrfs_async_submit_limit(info);
511 512
}

C
Chris Mason 已提交
513 514 515 516 517 518 519 520 521 522 523 524
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)
525 526 527
{
	struct btrfs_fs_info *fs_info;
	struct async_submit_bio *async;
528
	int limit;
529 530 531

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

533
	limit = btrfs_async_submit_limit(fs_info);
534 535
	limit = limit * 2 / 3;

536
	atomic_dec(&fs_info->nr_async_submits);
537

538 539
	if (atomic_read(&fs_info->nr_async_submits) < limit &&
	    waitqueue_active(&fs_info->async_submit_wait))
540 541
		wake_up(&fs_info->async_submit_wait);

C
Chris Mason 已提交
542
	async->submit_bio_done(async->inode, async->rw, async->bio,
C
Chris Mason 已提交
543
			       async->mirror_num, async->bio_flags);
C
Chris Mason 已提交
544 545 546 547 548 549 550
}

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

	async = container_of(work, struct  async_submit_bio, work);
551 552 553
	kfree(async);
}

554 555
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 已提交
556
			unsigned long bio_flags,
C
Chris Mason 已提交
557 558
			extent_submit_bio_hook_t *submit_bio_start,
			extent_submit_bio_hook_t *submit_bio_done)
559 560 561 562 563 564 565 566 567 568 569
{
	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 已提交
570 571 572 573 574 575 576
	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;

577
	async->work.flags = 0;
C
Chris Mason 已提交
578
	async->bio_flags = bio_flags;
579

580
	atomic_inc(&fs_info->nr_async_submits);
581
	btrfs_queue_worker(&fs_info->workers, &async->work);
C
Chris Mason 已提交
582
#if 0
583
	int limit = btrfs_async_submit_limit(fs_info);
584 585
	if (atomic_read(&fs_info->nr_async_submits) > limit) {
		wait_event_timeout(fs_info->async_submit_wait,
586 587
			   (atomic_read(&fs_info->nr_async_submits) < limit),
			   HZ/10);
588 589 590 591 592

		wait_event_timeout(fs_info->async_submit_wait,
			   (atomic_read(&fs_info->nr_async_bios) < limit),
			   HZ/10);
	}
C
Chris Mason 已提交
593
#endif
C
Chris Mason 已提交
594
	while (atomic_read(&fs_info->async_submit_draining) &&
595 596 597 598 599
	      atomic_read(&fs_info->nr_async_submits)) {
		wait_event(fs_info->async_submit_wait,
			   (atomic_read(&fs_info->nr_async_submits) == 0));
	}

600 601 602
	return 0;
}

603 604 605 606 607 608 609
static int btree_csum_one_bio(struct bio *bio)
{
	struct bio_vec *bvec = bio->bi_io_vec;
	int bio_index = 0;
	struct btrfs_root *root;

	WARN_ON(bio->bi_vcnt <= 0);
C
Chris Mason 已提交
610
	while (bio_index < bio->bi_vcnt) {
611 612 613 614 615 616 617 618
		root = BTRFS_I(bvec->bv_page->mapping->host)->root;
		csum_dirty_buffer(root, bvec->bv_page);
		bio_index++;
		bvec++;
	}
	return 0;
}

C
Chris Mason 已提交
619 620 621
static int __btree_submit_bio_start(struct inode *inode, int rw,
				    struct bio *bio, int mirror_num,
				    unsigned long bio_flags)
622
{
623 624
	/*
	 * when we're called for a write, we're already in the async
625
	 * submission context.  Just jump into btrfs_map_bio
626
	 */
C
Chris Mason 已提交
627 628 629
	btree_csum_one_bio(bio);
	return 0;
}
630

C
Chris Mason 已提交
631 632 633
static int __btree_submit_bio_done(struct inode *inode, int rw, struct bio *bio,
				 int mirror_num, unsigned long bio_flags)
{
634
	/*
C
Chris Mason 已提交
635 636
	 * when we're called for a write, we're already in the async
	 * submission context.  Just jump into btrfs_map_bio
637 638
	 */
	return btrfs_map_bio(BTRFS_I(inode)->root, rw, bio, mirror_num, 1);
639 640
}

641
static int btree_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
C
Chris Mason 已提交
642
				 int mirror_num, unsigned long bio_flags)
643
{
644 645 646 647 648 649
	int ret;

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

650
	if (!(rw & (1 << BIO_RW))) {
C
Chris Mason 已提交
651 652 653 654 655
		/*
		 * called for a read, do the setup so that checksum validation
		 * can happen in the async kernel threads
		 */
		return btrfs_map_bio(BTRFS_I(inode)->root, rw, bio,
656
				     mirror_num, 0);
657
	}
658 659 660 661
	/*
	 * kthread helpers are used to submit writes so that checksumming
	 * can happen in parallel across all CPUs
	 */
662
	return btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,
C
Chris Mason 已提交
663
				   inode, rw, bio, mirror_num, 0,
C
Chris Mason 已提交
664 665
				   __btree_submit_bio_start,
				   __btree_submit_bio_done);
666 667
}

668 669
static int btree_writepage(struct page *page, struct writeback_control *wbc)
{
670 671
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
672 673 674 675 676 677

	if (current->flags & PF_MEMALLOC) {
		redirty_page_for_writepage(wbc, page);
		unlock_page(page);
		return 0;
	}
678 679
	return extent_write_full_page(tree, page, btree_get_extent, wbc);
}
680 681 682 683

static int btree_writepages(struct address_space *mapping,
			    struct writeback_control *wbc)
{
684 685
	struct extent_io_tree *tree;
	tree = &BTRFS_I(mapping->host)->io_tree;
686
	if (wbc->sync_mode == WB_SYNC_NONE) {
687 688
		u64 num_dirty;
		u64 start = 0;
689
		unsigned long thresh = 32 * 1024 * 1024;
690 691 692 693

		if (wbc->for_kupdate)
			return 0;

694 695
		num_dirty = count_range_bits(tree, &start, (u64)-1,
					     thresh, EXTENT_DIRTY);
C
Chris Mason 已提交
696
		if (num_dirty < thresh)
697 698
			return 0;
	}
699 700 701
	return extent_writepages(tree, mapping, btree_get_extent, wbc);
}

702
static int btree_readpage(struct file *file, struct page *page)
703
{
704 705
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
706 707
	return extent_read_full_page(tree, page, btree_get_extent);
}
C
Chris Mason 已提交
708

709
static int btree_releasepage(struct page *page, gfp_t gfp_flags)
710
{
711 712
	struct extent_io_tree *tree;
	struct extent_map_tree *map;
713
	int ret;
714

715
	if (PageWriteback(page) || PageDirty(page))
C
Chris Mason 已提交
716
		return 0;
717

718 719
	tree = &BTRFS_I(page->mapping->host)->io_tree;
	map = &BTRFS_I(page->mapping->host)->extent_tree;
720

721
	ret = try_release_extent_state(map, tree, page, gfp_flags);
C
Chris Mason 已提交
722
	if (!ret)
723 724 725
		return 0;

	ret = try_release_extent_buffer(tree, page);
726 727 728 729 730
	if (ret == 1) {
		ClearPagePrivate(page);
		set_page_private(page, 0);
		page_cache_release(page);
	}
731

732 733 734
	return ret;
}

735
static void btree_invalidatepage(struct page *page, unsigned long offset)
736
{
737 738
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
739 740
	extent_invalidatepage(tree, page, offset);
	btree_releasepage(page, GFP_NOFS);
741
	if (PagePrivate(page)) {
C
Chris Mason 已提交
742 743
		printk(KERN_WARNING "btrfs warning page private not zero "
		       "on page %llu\n", (unsigned long long)page_offset(page));
744 745 746 747
		ClearPagePrivate(page);
		set_page_private(page, 0);
		page_cache_release(page);
	}
748 749
}

750
#if 0
751
static int btree_writepage(struct page *page, struct writeback_control *wbc)
752
{
C
Chris Mason 已提交
753
	struct buffer_head *bh;
754
	struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
C
Chris Mason 已提交
755 756 757 758 759 760 761 762 763 764 765 766
	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);
767
	return block_write_full_page(page, btree_get_block, wbc);
768
}
769
#endif
770

771 772 773
static struct address_space_operations btree_aops = {
	.readpage	= btree_readpage,
	.writepage	= btree_writepage,
774
	.writepages	= btree_writepages,
775 776
	.releasepage	= btree_releasepage,
	.invalidatepage = btree_invalidatepage,
777 778 779
	.sync_page	= block_sync_page,
};

780 781
int readahead_tree_block(struct btrfs_root *root, u64 bytenr, u32 blocksize,
			 u64 parent_transid)
C
Chris Mason 已提交
782
{
783 784
	struct extent_buffer *buf = NULL;
	struct inode *btree_inode = root->fs_info->btree_inode;
785
	int ret = 0;
C
Chris Mason 已提交
786

787
	buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
788
	if (!buf)
C
Chris Mason 已提交
789
		return 0;
790
	read_extent_buffer_pages(&BTRFS_I(btree_inode)->io_tree,
791
				 buf, 0, 0, btree_get_extent, 0);
792
	free_extent_buffer(buf);
793
	return ret;
C
Chris Mason 已提交
794 795
}

796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817
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;
}


818 819 820
int btrfs_write_tree_block(struct extent_buffer *buf)
{
	return btrfs_fdatawrite_range(buf->first_page->mapping, buf->start,
821
				      buf->start + buf->len - 1, WB_SYNC_ALL);
822 823 824 825 826
}

int btrfs_wait_tree_block_writeback(struct extent_buffer *buf)
{
	return btrfs_wait_on_page_writeback_range(buf->first_page->mapping,
C
Chris Mason 已提交
827
				  buf->start, buf->start + buf->len - 1);
828 829
}

830
struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 bytenr,
831
				      u32 blocksize, u64 parent_transid)
832 833 834 835 836 837 838 839 840 841 842 843
{
	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;

844
	ret = btree_read_extent_buffer_pages(root, buf, 0, parent_transid);
845

C
Chris Mason 已提交
846
	if (ret == 0)
847
		set_bit(EXTENT_BUFFER_UPTODATE, &buf->bflags);
C
Chris Mason 已提交
848
	else
849
		WARN_ON(1);
850
	return buf;
851

852 853
}

854
int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
855
		     struct extent_buffer *buf)
856
{
857
	struct inode *btree_inode = root->fs_info->btree_inode;
858
	if (btrfs_header_generation(buf) ==
859
	    root->fs_info->running_transaction->transid) {
860
		btrfs_assert_tree_locked(buf);
861 862 863 864

		/* ugh, clear_extent_buffer_dirty can be expensive */
		btrfs_set_lock_blocking(buf);

865
		clear_extent_buffer_dirty(&BTRFS_I(btree_inode)->io_tree,
866
					  buf);
867
	}
868 869 870
	return 0;
}

871
static int __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize,
872
			u32 stripesize, struct btrfs_root *root,
873
			struct btrfs_fs_info *fs_info,
C
Chris Mason 已提交
874
			u64 objectid)
875
{
C
Chris Mason 已提交
876
	root->node = NULL;
877
	root->commit_root = NULL;
Y
Yan Zheng 已提交
878
	root->ref_tree = NULL;
879 880 881
	root->sectorsize = sectorsize;
	root->nodesize = nodesize;
	root->leafsize = leafsize;
882
	root->stripesize = stripesize;
C
Chris Mason 已提交
883
	root->ref_cows = 0;
884 885
	root->track_dirty = 0;

886
	root->fs_info = fs_info;
887 888
	root->objectid = objectid;
	root->last_trans = 0;
C
Chris Mason 已提交
889 890
	root->highest_inode = 0;
	root->last_inode_alloc = 0;
891
	root->name = NULL;
892
	root->in_sysfs = 0;
893 894

	INIT_LIST_HEAD(&root->dirty_list);
895
	INIT_LIST_HEAD(&root->orphan_list);
896
	INIT_LIST_HEAD(&root->dead_list);
897
	spin_lock_init(&root->node_lock);
898
	spin_lock_init(&root->list_lock);
899
	mutex_init(&root->objectid_mutex);
900
	mutex_init(&root->log_mutex);
Y
Yan Zheng 已提交
901 902 903 904 905 906 907 908
	init_waitqueue_head(&root->log_writer_wait);
	init_waitqueue_head(&root->log_commit_wait[0]);
	init_waitqueue_head(&root->log_commit_wait[1]);
	atomic_set(&root->log_commit[0], 0);
	atomic_set(&root->log_commit[1], 0);
	atomic_set(&root->log_writers, 0);
	root->log_batch = 0;
	root->log_transid = 0;
909 910
	extent_io_tree_init(&root->dirty_log_pages,
			     fs_info->btree_inode->i_mapping, GFP_NOFS);
C
Chris Mason 已提交
911 912 913 914

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

915 916
	memset(&root->root_key, 0, sizeof(root->root_key));
	memset(&root->root_item, 0, sizeof(root->root_item));
917
	memset(&root->defrag_progress, 0, sizeof(root->defrag_progress));
918
	memset(&root->root_kobj, 0, sizeof(root->root_kobj));
919
	root->defrag_trans_start = fs_info->generation;
920
	init_completion(&root->kobj_unregister);
921 922
	root->defrag_running = 0;
	root->defrag_level = 0;
923
	root->root_key.objectid = objectid;
924 925 926 927 928 929
	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);

930 931 932
	return 0;
}

933
static int find_and_setup_root(struct btrfs_root *tree_root,
934 935
			       struct btrfs_fs_info *fs_info,
			       u64 objectid,
C
Chris Mason 已提交
936
			       struct btrfs_root *root)
937 938
{
	int ret;
939
	u32 blocksize;
940
	u64 generation;
941

942
	__setup_root(tree_root->nodesize, tree_root->leafsize,
943 944
		     tree_root->sectorsize, tree_root->stripesize,
		     root, fs_info, objectid);
945 946 947 948
	ret = btrfs_find_last_root(tree_root, objectid,
				   &root->root_item, &root->root_key);
	BUG_ON(ret);

949
	generation = btrfs_root_generation(&root->root_item);
950 951
	blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
	root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
952
				     blocksize, generation);
953
	BUG_ON(!root->node);
954 955 956
	return 0;
}

957 958 959 960
int btrfs_free_log_root_tree(struct btrfs_trans_handle *trans,
			     struct btrfs_fs_info *fs_info)
{
	struct extent_buffer *eb;
961 962 963
	struct btrfs_root *log_root_tree = fs_info->log_root_tree;
	u64 start = 0;
	u64 end = 0;
964 965
	int ret;

966
	if (!log_root_tree)
967 968
		return 0;

C
Chris Mason 已提交
969
	while (1) {
970 971 972 973 974 975 976 977
		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);
	}
978 979 980 981 982
	eb = fs_info->log_root_tree->node;

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

983 984
	ret = btrfs_free_reserved_extent(fs_info->tree_root,
				eb->start, eb->len);
985 986 987 988 989 990 991 992
	BUG_ON(ret);

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

Y
Yan Zheng 已提交
993 994
static struct btrfs_root *alloc_log_tree(struct btrfs_trans_handle *trans,
					 struct btrfs_fs_info *fs_info)
995 996 997
{
	struct btrfs_root *root;
	struct btrfs_root *tree_root = fs_info->tree_root;
Y
Yan Zheng 已提交
998
	struct extent_buffer *leaf;
999 1000 1001

	root = kzalloc(sizeof(*root), GFP_NOFS);
	if (!root)
Y
Yan Zheng 已提交
1002
		return ERR_PTR(-ENOMEM);
1003 1004 1005 1006 1007 1008 1009 1010

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

	root->root_key.objectid = BTRFS_TREE_LOG_OBJECTID;
	root->root_key.type = BTRFS_ROOT_ITEM_KEY;
	root->root_key.offset = BTRFS_TREE_LOG_OBJECTID;
Y
Yan Zheng 已提交
1011 1012 1013 1014 1015 1016
	/*
	 * log trees do not get reference counted because they go away
	 * before a real commit is actually done.  They do store pointers
	 * to file data extents, and those reference counts still get
	 * updated (along with back refs to the log tree).
	 */
1017 1018
	root->ref_cows = 0;

Y
Yan Zheng 已提交
1019 1020 1021 1022 1023 1024 1025
	leaf = btrfs_alloc_free_block(trans, root, root->leafsize,
				      0, BTRFS_TREE_LOG_OBJECTID,
				      trans->transid, 0, 0, 0);
	if (IS_ERR(leaf)) {
		kfree(root);
		return ERR_CAST(leaf);
	}
1026

Y
Yan Zheng 已提交
1027
	root->node = leaf;
1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038
	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);
Y
Yan Zheng 已提交
1039 1040 1041 1042 1043 1044 1045 1046 1047 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
	return root;
}

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

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

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

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

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

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

	btrfs_set_root_bytenr(&log_root->root_item, log_root->node->start);
	btrfs_set_root_generation(&log_root->root_item, trans->transid);

	WARN_ON(root->log_root);
	root->log_root = log_root;
	root->log_transid = 0;
1081 1082 1083 1084 1085 1086 1087 1088
	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;
1089
	struct btrfs_path *path;
1090
	struct extent_buffer *l;
C
Chris Mason 已提交
1091
	u64 highest_inode;
1092
	u64 generation;
1093
	u32 blocksize;
1094 1095
	int ret = 0;

1096
	root = kzalloc(sizeof(*root), GFP_NOFS);
C
Chris Mason 已提交
1097
	if (!root)
1098 1099
		return ERR_PTR(-ENOMEM);
	if (location->offset == (u64)-1) {
1100
		ret = find_and_setup_root(tree_root, fs_info,
1101 1102 1103 1104 1105 1106 1107 1108
					  location->objectid, root);
		if (ret) {
			kfree(root);
			return ERR_PTR(ret);
		}
		goto insert;
	}

1109
	__setup_root(tree_root->nodesize, tree_root->leafsize,
1110 1111
		     tree_root->sectorsize, tree_root->stripesize,
		     root, fs_info, location->objectid);
1112 1113 1114 1115 1116 1117 1118 1119 1120

	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;
	}
1121 1122 1123
	l = path->nodes[0];
	read_extent_buffer(l, &root->root_item,
	       btrfs_item_ptr_offset(l, path->slots[0]),
1124
	       sizeof(root->root_item));
1125
	memcpy(&root->root_key, location, sizeof(*location));
1126 1127 1128 1129 1130 1131 1132 1133
	ret = 0;
out:
	btrfs_release_path(root, path);
	btrfs_free_path(path);
	if (ret) {
		kfree(root);
		return ERR_PTR(ret);
	}
1134
	generation = btrfs_root_generation(&root->root_item);
1135 1136
	blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
	root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
1137
				     blocksize, generation);
1138 1139
	BUG_ON(!root->node);
insert:
1140 1141 1142 1143 1144 1145 1146
	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;
		}
1147 1148 1149 1150
	}
	return root;
}

C
Chris Mason 已提交
1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165
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;
}

1166 1167
struct btrfs_root *btrfs_read_fs_root_no_name(struct btrfs_fs_info *fs_info,
					      struct btrfs_key *location)
1168 1169 1170 1171
{
	struct btrfs_root *root;
	int ret;

1172 1173 1174 1175
	if (location->objectid == BTRFS_ROOT_TREE_OBJECTID)
		return fs_info->tree_root;
	if (location->objectid == BTRFS_EXTENT_TREE_OBJECTID)
		return fs_info->extent_root;
1176 1177 1178 1179
	if (location->objectid == BTRFS_CHUNK_TREE_OBJECTID)
		return fs_info->chunk_root;
	if (location->objectid == BTRFS_DEV_TREE_OBJECTID)
		return fs_info->dev_root;
1180 1181
	if (location->objectid == BTRFS_CSUM_TREE_OBJECTID)
		return fs_info->csum_root;
1182

1183 1184 1185 1186 1187
	root = radix_tree_lookup(&fs_info->fs_roots_radix,
				 (unsigned long)location->objectid);
	if (root)
		return root;

1188
	root = btrfs_read_fs_root_no_radix(fs_info->tree_root, location);
1189 1190
	if (IS_ERR(root))
		return root;
1191 1192 1193

	set_anon_super(&root->anon_super, NULL);

C
Chris Mason 已提交
1194 1195
	ret = radix_tree_insert(&fs_info->fs_roots_radix,
				(unsigned long)root->root_key.objectid,
1196 1197
				root);
	if (ret) {
1198
		free_extent_buffer(root->node);
1199 1200 1201
		kfree(root);
		return ERR_PTR(ret);
	}
Y
Yan Zheng 已提交
1202 1203 1204 1205 1206 1207
	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);
	}
1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220
	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;
1221

1222 1223 1224
	if (root->in_sysfs)
		return root;

1225 1226
	ret = btrfs_set_root_name(root, name, namelen);
	if (ret) {
1227
		free_extent_buffer(root->node);
1228 1229 1230
		kfree(root);
		return ERR_PTR(ret);
	}
1231
#if 0
1232 1233
	ret = btrfs_sysfs_add_root(root);
	if (ret) {
1234
		free_extent_buffer(root->node);
1235 1236 1237 1238
		kfree(root->name);
		kfree(root);
		return ERR_PTR(ret);
	}
1239
#endif
1240
	root->in_sysfs = 1;
1241 1242
	return root;
}
C
Chris Mason 已提交
1243 1244 1245 1246 1247 1248 1249

static int btrfs_congested_fn(void *congested_data, int bdi_bits)
{
	struct btrfs_fs_info *info = (struct btrfs_fs_info *)congested_data;
	int ret = 0;
	struct btrfs_device *device;
	struct backing_dev_info *bdi;
1250
#if 0
1251
	if ((bdi_bits & (1 << BDI_write_congested)) &&
1252
	    btrfs_congested_async(info, 0))
1253
		return 1;
1254
#endif
Q
Qinghuang Feng 已提交
1255
	list_for_each_entry(device, &info->fs_devices->devices, dev_list) {
1256 1257
		if (!device->bdev)
			continue;
C
Chris Mason 已提交
1258 1259 1260 1261 1262 1263 1264 1265 1266
		bdi = blk_get_backing_dev_info(device->bdev);
		if (bdi && bdi_congested(bdi, bdi_bits)) {
			ret = 1;
			break;
		}
	}
	return ret;
}

1267 1268 1269 1270 1271 1272 1273 1274 1275 1276
/*
 * 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 btrfs_device *device;
	struct btrfs_fs_info *info;

	info = (struct btrfs_fs_info *)bdi->unplug_io_data;
Q
Qinghuang Feng 已提交
1277
	list_for_each_entry(device, &info->fs_devices->devices, dev_list) {
1278 1279 1280
		if (!device->bdev)
			continue;

1281
		bdi = blk_get_backing_dev_info(device->bdev);
C
Chris Mason 已提交
1282
		if (bdi->unplug_io_fn)
1283 1284 1285 1286
			bdi->unplug_io_fn(bdi, page);
	}
}

1287
static void btrfs_unplug_io_fn(struct backing_dev_info *bdi, struct page *page)
C
Chris Mason 已提交
1288
{
1289
	struct inode *inode;
1290 1291
	struct extent_map_tree *em_tree;
	struct extent_map *em;
1292
	struct address_space *mapping;
1293 1294
	u64 offset;

1295
	/* the generic O_DIRECT read code does this */
1296
	if (1 || !page) {
1297 1298 1299 1300
		__unplug_io_fn(bdi, page);
		return;
	}

1301 1302 1303 1304 1305 1306 1307 1308 1309 1310
	/*
	 * 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;
1311 1312 1313 1314 1315 1316 1317 1318 1319 1320

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

1321
	offset = page_offset(page);
C
Chris Mason 已提交
1322

1323 1324 1325 1326
	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);
1327 1328
	if (!em) {
		__unplug_io_fn(bdi, page);
1329
		return;
1330
	}
1331

1332 1333 1334 1335 1336
	if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
		free_extent_map(em);
		__unplug_io_fn(bdi, page);
		return;
	}
1337 1338 1339 1340
	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 已提交
1341 1342 1343 1344 1345
}

static int setup_bdi(struct btrfs_fs_info *info, struct backing_dev_info *bdi)
{
	bdi_init(bdi);
1346
	bdi->ra_pages	= default_backing_dev_info.ra_pages;
C
Chris Mason 已提交
1347 1348 1349 1350 1351 1352 1353 1354 1355
	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;
}

1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 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
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;
}

1395 1396 1397 1398 1399
/*
 * 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)
1400 1401
{
	struct bio *bio;
1402 1403
	struct end_io_wq *end_io_wq;
	struct btrfs_fs_info *fs_info;
1404 1405
	int error;

1406 1407 1408
	end_io_wq = container_of(work, struct end_io_wq, work);
	bio = end_io_wq->bio;
	fs_info = end_io_wq->info;
1409

1410
	/* metadata bio reads are special because the whole tree block must
1411 1412 1413 1414
	 * 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
	 */
1415 1416
	if (!(bio->bi_rw & (1 << BIO_RW)) && end_io_wq->metadata &&
	    !bio_ready_for_csum(bio)) {
1417
		btrfs_queue_worker(&fs_info->endio_meta_workers,
1418 1419 1420 1421 1422 1423 1424 1425
				   &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);
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 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473
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);

1474
		if (root->fs_info->total_ref_cache_size > 20 * 1024 * 1024) {
C
Chris Mason 已提交
1475 1476 1477
			printk(KERN_INFO "btrfs: total reference cache "
			       "size %llu\n",
			       root->fs_info->total_ref_cache_size);
1478
		}
Y
Yan Zheng 已提交
1479

1480 1481 1482 1483 1484 1485
		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 已提交
1486

1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512
		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;
}

1513
struct btrfs_root *open_ctree(struct super_block *sb,
1514 1515
			      struct btrfs_fs_devices *fs_devices,
			      char *options)
1516
{
1517 1518 1519 1520
	u32 sectorsize;
	u32 nodesize;
	u32 leafsize;
	u32 blocksize;
1521
	u32 stripesize;
1522
	u64 generation;
1523
	u64 features;
1524
	struct btrfs_key location;
1525
	struct buffer_head *bh;
1526
	struct btrfs_root *extent_root = kzalloc(sizeof(struct btrfs_root),
C
Chris Mason 已提交
1527
						 GFP_NOFS);
1528 1529
	struct btrfs_root *csum_root = kzalloc(sizeof(struct btrfs_root),
						 GFP_NOFS);
1530
	struct btrfs_root *tree_root = kzalloc(sizeof(struct btrfs_root),
C
Chris Mason 已提交
1531
					       GFP_NOFS);
1532
	struct btrfs_fs_info *fs_info = kzalloc(sizeof(*fs_info),
C
Chris Mason 已提交
1533
						GFP_NOFS);
1534
	struct btrfs_root *chunk_root = kzalloc(sizeof(struct btrfs_root),
1535
						GFP_NOFS);
1536
	struct btrfs_root *dev_root = kzalloc(sizeof(struct btrfs_root),
1537
					      GFP_NOFS);
1538 1539
	struct btrfs_root *log_tree_root;

1540
	int ret;
1541
	int err = -EINVAL;
1542

C
Chris Mason 已提交
1543
	struct btrfs_super_block *disk_super;
1544

1545
	if (!extent_root || !tree_root || !fs_info ||
1546
	    !chunk_root || !dev_root || !csum_root) {
C
Chris Mason 已提交
1547 1548 1549
		err = -ENOMEM;
		goto fail;
	}
1550
	INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_NOFS);
C
Chris Mason 已提交
1551
	INIT_LIST_HEAD(&fs_info->trans_list);
1552
	INIT_LIST_HEAD(&fs_info->dead_roots);
1553
	INIT_LIST_HEAD(&fs_info->hashers);
1554
	INIT_LIST_HEAD(&fs_info->delalloc_inodes);
1555
	spin_lock_init(&fs_info->delalloc_lock);
1556
	spin_lock_init(&fs_info->new_trans_lock);
Y
Yan Zheng 已提交
1557
	spin_lock_init(&fs_info->ref_cache_lock);
1558

1559
	init_completion(&fs_info->kobj_unregister);
1560 1561
	fs_info->tree_root = tree_root;
	fs_info->extent_root = extent_root;
1562
	fs_info->csum_root = csum_root;
1563 1564
	fs_info->chunk_root = chunk_root;
	fs_info->dev_root = dev_root;
1565
	fs_info->fs_devices = fs_devices;
1566
	INIT_LIST_HEAD(&fs_info->dirty_cowonly_roots);
1567
	INIT_LIST_HEAD(&fs_info->space_info);
1568
	btrfs_mapping_init(&fs_info->mapping_tree);
1569
	atomic_set(&fs_info->nr_async_submits, 0);
1570
	atomic_set(&fs_info->async_delalloc_pages, 0);
1571
	atomic_set(&fs_info->async_submit_draining, 0);
1572
	atomic_set(&fs_info->nr_async_bios, 0);
1573
	atomic_set(&fs_info->throttles, 0);
1574
	atomic_set(&fs_info->throttle_gen, 0);
C
Chris Mason 已提交
1575
	fs_info->sb = sb;
1576
	fs_info->max_extent = (u64)-1;
1577
	fs_info->max_inline = 8192 * 1024;
C
Chris Mason 已提交
1578
	setup_bdi(fs_info, &fs_info->bdi);
1579 1580
	fs_info->btree_inode = new_inode(sb);
	fs_info->btree_inode->i_ino = 1;
C
Chris Mason 已提交
1581
	fs_info->btree_inode->i_nlink = 1;
C
Chris Mason 已提交
1582

1583 1584
	fs_info->thread_pool_size = min_t(unsigned long,
					  num_online_cpus() + 2, 8);
1585

1586 1587 1588
	INIT_LIST_HEAD(&fs_info->ordered_extents);
	spin_lock_init(&fs_info->ordered_extent_lock);

1589 1590 1591
	sb->s_blocksize = 4096;
	sb->s_blocksize_bits = blksize_bits(4096);

1592 1593 1594 1595 1596 1597
	/*
	 * 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;
1598
	fs_info->btree_inode->i_mapping->a_ops = &btree_aops;
C
Chris Mason 已提交
1599 1600
	fs_info->btree_inode->i_mapping->backing_dev_info = &fs_info->bdi;

1601
	extent_io_tree_init(&BTRFS_I(fs_info->btree_inode)->io_tree,
1602 1603
			     fs_info->btree_inode->i_mapping,
			     GFP_NOFS);
1604 1605 1606 1607
	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;
1608

J
Josef Bacik 已提交
1609 1610 1611
	spin_lock_init(&fs_info->block_group_cache_lock);
	fs_info->block_group_cache_tree.rb_node = NULL;

1612
	extent_io_tree_init(&fs_info->pinned_extents,
1613
			     fs_info->btree_inode->i_mapping, GFP_NOFS);
1614
	extent_io_tree_init(&fs_info->pending_del,
1615
			     fs_info->btree_inode->i_mapping, GFP_NOFS);
1616
	extent_io_tree_init(&fs_info->extent_ins,
1617
			     fs_info->btree_inode->i_mapping, GFP_NOFS);
1618
	fs_info->do_barriers = 1;
1619

Z
Zheng Yan 已提交
1620 1621
	INIT_LIST_HEAD(&fs_info->dead_reloc_roots);
	btrfs_leaf_ref_tree_init(&fs_info->reloc_ref_tree);
Z
Zheng Yan 已提交
1622 1623
	btrfs_leaf_ref_tree_init(&fs_info->shared_ref_tree);

1624 1625 1626
	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 已提交
1627
	insert_inode_hash(fs_info->btree_inode);
C
Chris Mason 已提交
1628

C
Chris Mason 已提交
1629
	mutex_init(&fs_info->trans_mutex);
1630
	mutex_init(&fs_info->tree_log_mutex);
1631
	mutex_init(&fs_info->drop_mutex);
1632 1633
	mutex_init(&fs_info->extent_ins_mutex);
	mutex_init(&fs_info->pinned_mutex);
1634
	mutex_init(&fs_info->chunk_mutex);
1635 1636
	mutex_init(&fs_info->transaction_kthread_mutex);
	mutex_init(&fs_info->cleaner_mutex);
1637
	mutex_init(&fs_info->volume_mutex);
Z
Zheng Yan 已提交
1638
	mutex_init(&fs_info->tree_reloc_mutex);
1639
	init_waitqueue_head(&fs_info->transaction_throttle);
1640
	init_waitqueue_head(&fs_info->transaction_wait);
1641
	init_waitqueue_head(&fs_info->async_submit_wait);
1642

1643
	__setup_root(4096, 4096, 4096, 4096, tree_root,
C
Chris Mason 已提交
1644
		     fs_info, BTRFS_ROOT_TREE_OBJECTID);
1645

1646

Y
Yan Zheng 已提交
1647
	bh = btrfs_read_dev_super(fs_devices->latest_bdev);
1648
	if (!bh)
C
Chris Mason 已提交
1649 1650
		goto fail_iput;

1651
	memcpy(&fs_info->super_copy, bh->b_data, sizeof(fs_info->super_copy));
1652 1653
	memcpy(&fs_info->super_for_commit, &fs_info->super_copy,
	       sizeof(fs_info->super_for_commit));
1654
	brelse(bh);
1655

1656
	memcpy(fs_info->fsid, fs_info->super_copy.fsid, BTRFS_FSID_SIZE);
1657

1658
	disk_super = &fs_info->super_copy;
1659
	if (!btrfs_super_root(disk_super))
1660
		goto fail_iput;
1661

Y
Yan Zheng 已提交
1662 1663 1664
	ret = btrfs_parse_options(tree_root, options);
	if (ret) {
		err = ret;
1665
		goto fail_iput;
Y
Yan Zheng 已提交
1666
	}
1667

1668 1669 1670 1671 1672 1673 1674
	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;
1675
		goto fail_iput;
1676 1677 1678 1679 1680 1681 1682 1683 1684
	}

	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;
1685
		goto fail_iput;
1686 1687
	}

1688 1689 1690 1691 1692
	/*
	 * 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.
	 */
1693 1694
	btrfs_init_workers(&fs_info->workers, "worker",
			   fs_info->thread_pool_size);
C
Chris Mason 已提交
1695

1696 1697 1698
	btrfs_init_workers(&fs_info->delalloc_workers, "delalloc",
			   fs_info->thread_pool_size);

1699
	btrfs_init_workers(&fs_info->submit_workers, "submit",
1700 1701
			   min_t(u64, fs_devices->num_devices,
			   fs_info->thread_pool_size));
1702 1703 1704 1705 1706 1707

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

1709
	fs_info->workers.idle_thresh = 16;
C
Chris Mason 已提交
1710
	fs_info->workers.ordered = 1;
1711

1712 1713 1714
	fs_info->delalloc_workers.idle_thresh = 2;
	fs_info->delalloc_workers.ordered = 1;

1715 1716 1717
	btrfs_init_workers(&fs_info->fixup_workers, "fixup", 1);
	btrfs_init_workers(&fs_info->endio_workers, "endio",
			   fs_info->thread_pool_size);
1718 1719
	btrfs_init_workers(&fs_info->endio_meta_workers, "endio-meta",
			   fs_info->thread_pool_size);
1720 1721
	btrfs_init_workers(&fs_info->endio_meta_write_workers,
			   "endio-meta-write", fs_info->thread_pool_size);
1722
	btrfs_init_workers(&fs_info->endio_write_workers, "endio-write",
1723
			   fs_info->thread_pool_size);
1724 1725 1726 1727 1728 1729

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

1732
	fs_info->endio_write_workers.idle_thresh = 64;
1733
	fs_info->endio_meta_write_workers.idle_thresh = 64;
1734

1735
	btrfs_start_workers(&fs_info->workers, 1);
1736
	btrfs_start_workers(&fs_info->submit_workers, 1);
1737
	btrfs_start_workers(&fs_info->delalloc_workers, 1);
1738
	btrfs_start_workers(&fs_info->fixup_workers, 1);
1739
	btrfs_start_workers(&fs_info->endio_workers, fs_info->thread_pool_size);
1740 1741
	btrfs_start_workers(&fs_info->endio_meta_workers,
			    fs_info->thread_pool_size);
1742 1743
	btrfs_start_workers(&fs_info->endio_meta_write_workers,
			    fs_info->thread_pool_size);
1744 1745
	btrfs_start_workers(&fs_info->endio_write_workers,
			    fs_info->thread_pool_size);
1746

1747
	fs_info->bdi.ra_pages *= btrfs_super_num_devices(disk_super);
C
Chris Mason 已提交
1748 1749
	fs_info->bdi.ra_pages = max(fs_info->bdi.ra_pages,
				    4 * 1024 * 1024 / PAGE_CACHE_SIZE);
1750

1751 1752 1753
	nodesize = btrfs_super_nodesize(disk_super);
	leafsize = btrfs_super_leafsize(disk_super);
	sectorsize = btrfs_super_sectorsize(disk_super);
1754
	stripesize = btrfs_super_stripesize(disk_super);
1755 1756 1757
	tree_root->nodesize = nodesize;
	tree_root->leafsize = leafsize;
	tree_root->sectorsize = sectorsize;
1758
	tree_root->stripesize = stripesize;
1759 1760 1761

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

C
Chris Mason 已提交
1763 1764
	if (strncmp((char *)(&disk_super->magic), BTRFS_MAGIC,
		    sizeof(disk_super->magic))) {
C
Chris Mason 已提交
1765
		printk(KERN_INFO "btrfs: valid FS not found on %s\n", sb->s_id);
C
Chris Mason 已提交
1766 1767
		goto fail_sb_buffer;
	}
1768

1769
	mutex_lock(&fs_info->chunk_mutex);
Y
Yan Zheng 已提交
1770
	ret = btrfs_read_sys_array(tree_root);
1771
	mutex_unlock(&fs_info->chunk_mutex);
1772
	if (ret) {
C
Chris Mason 已提交
1773 1774
		printk(KERN_WARNING "btrfs: failed to read the system "
		       "array on %s\n", sb->s_id);
1775 1776
		goto fail_sys_array;
	}
1777 1778 1779

	blocksize = btrfs_level_size(tree_root,
				     btrfs_super_chunk_root_level(disk_super));
1780
	generation = btrfs_super_chunk_root_generation(disk_super);
1781 1782 1783 1784 1785 1786

	__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),
1787
					   blocksize, generation);
1788 1789
	BUG_ON(!chunk_root->node);

1790
	read_extent_buffer(chunk_root->node, fs_info->chunk_tree_uuid,
C
Chris Mason 已提交
1791 1792
	   (unsigned long)btrfs_header_chunk_tree_uuid(chunk_root->node),
	   BTRFS_UUID_SIZE);
1793

1794
	mutex_lock(&fs_info->chunk_mutex);
1795
	ret = btrfs_read_chunk_tree(chunk_root);
1796
	mutex_unlock(&fs_info->chunk_mutex);
Y
Yan Zheng 已提交
1797
	if (ret) {
C
Chris Mason 已提交
1798 1799
		printk(KERN_WARNING "btrfs: failed to read chunk tree on %s\n",
		       sb->s_id);
Y
Yan Zheng 已提交
1800 1801
		goto fail_chunk_root;
	}
1802

1803 1804
	btrfs_close_extra_devices(fs_devices);

1805 1806
	blocksize = btrfs_level_size(tree_root,
				     btrfs_super_root_level(disk_super));
1807
	generation = btrfs_super_generation(disk_super);
1808

C
Chris Mason 已提交
1809
	tree_root->node = read_tree_block(tree_root,
1810
					  btrfs_super_root(disk_super),
1811
					  blocksize, generation);
C
Chris Mason 已提交
1812
	if (!tree_root->node)
Y
Yan Zheng 已提交
1813
		goto fail_chunk_root;
1814

1815 1816

	ret = find_and_setup_root(tree_root, fs_info,
C
Chris Mason 已提交
1817
				  BTRFS_EXTENT_TREE_OBJECTID, extent_root);
1818
	if (ret)
C
Chris Mason 已提交
1819
		goto fail_tree_root;
1820 1821 1822 1823 1824 1825 1826
	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;
1827

1828 1829 1830 1831 1832 1833 1834
	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 已提交
1835 1836
	btrfs_read_block_groups(extent_root);

1837
	fs_info->generation = generation;
Y
Yan Zheng 已提交
1838
	fs_info->last_trans_committed = generation;
C
Chris Mason 已提交
1839 1840 1841
	fs_info->data_alloc_profile = (u64)-1;
	fs_info->metadata_alloc_profile = (u64)-1;
	fs_info->system_alloc_profile = fs_info->metadata_alloc_profile;
1842 1843
	fs_info->cleaner_kthread = kthread_run(cleaner_kthread, tree_root,
					       "btrfs-cleaner");
1844
	if (IS_ERR(fs_info->cleaner_kthread))
1845
		goto fail_csum_root;
1846 1847 1848 1849

	fs_info->transaction_kthread = kthread_run(transaction_kthread,
						   tree_root,
						   "btrfs-transaction");
1850
	if (IS_ERR(fs_info->transaction_kthread))
1851
		goto fail_cleaner;
1852

1853 1854 1855
	if (btrfs_super_log_root(disk_super) != 0) {
		u64 bytenr = btrfs_super_log_root(disk_super);

1856
		if (fs_devices->rw_devices == 0) {
C
Chris Mason 已提交
1857 1858
			printk(KERN_WARNING "Btrfs log replay required "
			       "on RO media\n");
1859 1860 1861
			err = -EIO;
			goto fail_trans_kthread;
		}
1862 1863 1864
		blocksize =
		     btrfs_level_size(tree_root,
				      btrfs_super_log_root_level(disk_super));
C
Chris Mason 已提交
1865

1866 1867 1868 1869 1870 1871 1872
		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,
1873 1874
						      blocksize,
						      generation + 1);
1875 1876
		ret = btrfs_recover_log_trees(log_tree_root);
		BUG_ON(ret);
1877 1878 1879 1880 1881

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

1884 1885 1886 1887
	if (!(sb->s_flags & MS_RDONLY)) {
		ret = btrfs_cleanup_reloc_trees(tree_root);
		BUG_ON(ret);
	}
Z
Zheng Yan 已提交
1888

1889 1890 1891 1892 1893 1894
	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)
1895
		goto fail_trans_kthread;
1896
	return tree_root;
C
Chris Mason 已提交
1897

1898 1899
fail_trans_kthread:
	kthread_stop(fs_info->transaction_kthread);
1900
fail_cleaner:
1901
	kthread_stop(fs_info->cleaner_kthread);
1902 1903 1904 1905 1906 1907 1908 1909

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

1910 1911
fail_csum_root:
	free_extent_buffer(csum_root->node);
1912 1913
fail_extent_root:
	free_extent_buffer(extent_root->node);
C
Chris Mason 已提交
1914
fail_tree_root:
1915
	free_extent_buffer(tree_root->node);
Y
Yan Zheng 已提交
1916 1917
fail_chunk_root:
	free_extent_buffer(chunk_root->node);
1918
fail_sys_array:
1919
	free_extent_buffer(dev_root->node);
C
Chris Mason 已提交
1920
fail_sb_buffer:
1921
	btrfs_stop_workers(&fs_info->fixup_workers);
1922
	btrfs_stop_workers(&fs_info->delalloc_workers);
1923 1924
	btrfs_stop_workers(&fs_info->workers);
	btrfs_stop_workers(&fs_info->endio_workers);
1925
	btrfs_stop_workers(&fs_info->endio_meta_workers);
1926
	btrfs_stop_workers(&fs_info->endio_meta_write_workers);
1927
	btrfs_stop_workers(&fs_info->endio_write_workers);
1928
	btrfs_stop_workers(&fs_info->submit_workers);
1929
fail_iput:
1930
	invalidate_inode_pages2(fs_info->btree_inode->i_mapping);
1931
	iput(fs_info->btree_inode);
1932

1933
	btrfs_close_devices(fs_info->fs_devices);
1934
	btrfs_mapping_tree_free(&fs_info->mapping_tree);
1935
	bdi_destroy(&fs_info->bdi);
1936

1937
fail:
C
Chris Mason 已提交
1938 1939 1940
	kfree(extent_root);
	kfree(tree_root);
	kfree(fs_info);
1941 1942
	kfree(chunk_root);
	kfree(dev_root);
1943
	kfree(csum_root);
C
Chris Mason 已提交
1944
	return ERR_PTR(err);
1945 1946
}

1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958
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));
		}
1959 1960 1961
		/* note, we dont' set_buffer_write_io_error because we have
		 * our own ways of dealing with the IO errors
		 */
1962 1963 1964 1965 1966 1967
		clear_buffer_uptodate(bh);
	}
	unlock_buffer(bh);
	put_bh(bh);
}

Y
Yan Zheng 已提交
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 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098
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)
2099 2100 2101
{
	struct list_head *head = &root->fs_info->fs_devices->devices;
	struct btrfs_device *dev;
2102
	struct btrfs_super_block *sb;
2103 2104 2105
	struct btrfs_dev_item *dev_item;
	int ret;
	int do_barriers;
2106 2107
	int max_errors;
	int total_errors = 0;
2108
	u64 flags;
2109

2110
	max_errors = btrfs_super_num_devices(&root->fs_info->super_copy) - 1;
2111 2112
	do_barriers = !btrfs_test_opt(root, NOBARRIER);

2113 2114
	sb = &root->fs_info->super_for_commit;
	dev_item = &sb->dev_item;
Q
Qinghuang Feng 已提交
2115
	list_for_each_entry(dev, head, dev_list) {
2116 2117 2118 2119
		if (!dev->bdev) {
			total_errors++;
			continue;
		}
Y
Yan Zheng 已提交
2120
		if (!dev->in_fs_metadata || !dev->writeable)
2121 2122
			continue;

Y
Yan Zheng 已提交
2123
		btrfs_set_stack_device_generation(dev_item, 0);
2124 2125 2126 2127 2128 2129 2130 2131
		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 已提交
2132
		memcpy(dev_item->fsid, dev->fs_devices->fsid, BTRFS_UUID_SIZE);
Y
Yan Zheng 已提交
2133

2134 2135 2136
		flags = btrfs_super_flags(sb);
		btrfs_set_super_flags(sb, flags | BTRFS_HEADER_FLAG_WRITTEN);

Y
Yan Zheng 已提交
2137
		ret = write_dev_supers(dev, sb, do_barriers, 0, max_mirrors);
2138 2139
		if (ret)
			total_errors++;
2140
	}
2141
	if (total_errors > max_errors) {
C
Chris Mason 已提交
2142 2143
		printk(KERN_ERR "btrfs: %d errors while writing supers\n",
		       total_errors);
2144 2145
		BUG();
	}
2146

Y
Yan Zheng 已提交
2147
	total_errors = 0;
Q
Qinghuang Feng 已提交
2148
	list_for_each_entry(dev, head, dev_list) {
2149 2150
		if (!dev->bdev)
			continue;
Y
Yan Zheng 已提交
2151
		if (!dev->in_fs_metadata || !dev->writeable)
2152 2153
			continue;

Y
Yan Zheng 已提交
2154 2155 2156
		ret = write_dev_supers(dev, sb, do_barriers, 1, max_mirrors);
		if (ret)
			total_errors++;
2157
	}
2158
	if (total_errors > max_errors) {
C
Chris Mason 已提交
2159 2160
		printk(KERN_ERR "btrfs: %d errors while writing supers\n",
		       total_errors);
2161 2162
		BUG();
	}
2163 2164 2165
	return 0;
}

Y
Yan Zheng 已提交
2166 2167
int write_ctree_super(struct btrfs_trans_handle *trans,
		      struct btrfs_root *root, int max_mirrors)
2168
{
2169
	int ret;
2170

Y
Yan Zheng 已提交
2171
	ret = write_all_supers(root, max_mirrors);
2172
	return ret;
C
Chris Mason 已提交
2173 2174
}

2175
int btrfs_free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root)
C
Chris Mason 已提交
2176 2177 2178
{
	radix_tree_delete(&fs_info->fs_roots_radix,
			  (unsigned long)root->root_key.objectid);
2179 2180 2181 2182
	if (root->anon_super.s_dev) {
		down_write(&root->anon_super.s_umount);
		kill_anon_super(&root->anon_super);
	}
C
Chris Mason 已提交
2183
	if (root->node)
2184
		free_extent_buffer(root->node);
C
Chris Mason 已提交
2185
	if (root->commit_root)
2186
		free_extent_buffer(root->commit_root);
C
Chris Mason 已提交
2187
	kfree(root->name);
C
Chris Mason 已提交
2188 2189 2190 2191
	kfree(root);
	return 0;
}

C
Chris Mason 已提交
2192
static int del_fs_roots(struct btrfs_fs_info *fs_info)
2193 2194 2195 2196 2197
{
	int ret;
	struct btrfs_root *gang[8];
	int i;

C
Chris Mason 已提交
2198
	while (1) {
2199 2200 2201 2202 2203
		ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
					     (void **)gang, 0,
					     ARRAY_SIZE(gang));
		if (!ret)
			break;
C
Chris Mason 已提交
2204
		for (i = 0; i < ret; i++)
2205
			btrfs_free_fs_root(fs_info, gang[i]);
2206 2207 2208
	}
	return 0;
}
2209

Y
Yan Zheng 已提交
2210
int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info)
C
Chris Mason 已提交
2211
{
Y
Yan Zheng 已提交
2212 2213 2214
	u64 root_objectid = 0;
	struct btrfs_root *gang[8];
	int i;
2215
	int ret;
2216

Y
Yan Zheng 已提交
2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233
	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;
}
2234

Y
Yan Zheng 已提交
2235 2236 2237 2238
int btrfs_commit_super(struct btrfs_root *root)
{
	struct btrfs_trans_handle *trans;
	int ret;
2239

Y
Yan Zheng 已提交
2240
	mutex_lock(&root->fs_info->cleaner_mutex);
2241
	btrfs_clean_old_snapshots(root);
Y
Yan Zheng 已提交
2242
	mutex_unlock(&root->fs_info->cleaner_mutex);
C
Chris Mason 已提交
2243
	trans = btrfs_start_transaction(root, 1);
2244
	ret = btrfs_commit_transaction(trans, root);
Y
Yan Zheng 已提交
2245 2246
	BUG_ON(ret);
	/* run commit again to drop the original snapshot */
C
Chris Mason 已提交
2247 2248 2249
	trans = btrfs_start_transaction(root, 1);
	btrfs_commit_transaction(trans, root);
	ret = btrfs_write_and_wait_transaction(NULL, root);
2250
	BUG_ON(ret);
2251

Y
Yan Zheng 已提交
2252
	ret = write_ctree_super(NULL, root, 0);
Y
Yan Zheng 已提交
2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268
	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);
C
Chris Mason 已提交
2269 2270
		if (ret)
			printk(KERN_ERR "btrfs: commit super ret %d\n", ret);
Y
Yan Zheng 已提交
2271
	}
2272

C
Chris Mason 已提交
2273
	if (fs_info->delalloc_bytes) {
C
Chris Mason 已提交
2274
		printk(KERN_INFO "btrfs: at unmount delalloc count %llu\n",
C
Chris Mason 已提交
2275 2276
		       fs_info->delalloc_bytes);
	}
Y
Yan Zheng 已提交
2277
	if (fs_info->total_ref_cache_size) {
C
Chris Mason 已提交
2278 2279
		printk(KERN_INFO "btrfs: at umount reference cache size %llu\n",
		       (unsigned long long)fs_info->total_ref_cache_size);
Y
Yan Zheng 已提交
2280
	}
2281

2282
	if (fs_info->extent_root->node)
2283
		free_extent_buffer(fs_info->extent_root->node);
2284

2285
	if (fs_info->tree_root->node)
2286
		free_extent_buffer(fs_info->tree_root->node);
2287

C
Chris Mason 已提交
2288
	if (root->fs_info->chunk_root->node)
2289 2290
		free_extent_buffer(root->fs_info->chunk_root->node);

C
Chris Mason 已提交
2291
	if (root->fs_info->dev_root->node)
2292 2293
		free_extent_buffer(root->fs_info->dev_root->node);

C
Chris Mason 已提交
2294
	if (root->fs_info->csum_root->node)
2295 2296
		free_extent_buffer(root->fs_info->csum_root->node);

C
Chris Mason 已提交
2297
	btrfs_free_block_groups(root->fs_info);
2298

Y
Yan Zheng 已提交
2299
	del_fs_roots(fs_info);
2300

Y
Yan Zheng 已提交
2301
	iput(fs_info->btree_inode);
2302

2303
	btrfs_stop_workers(&fs_info->fixup_workers);
2304
	btrfs_stop_workers(&fs_info->delalloc_workers);
2305 2306
	btrfs_stop_workers(&fs_info->workers);
	btrfs_stop_workers(&fs_info->endio_workers);
2307
	btrfs_stop_workers(&fs_info->endio_meta_workers);
2308
	btrfs_stop_workers(&fs_info->endio_meta_write_workers);
2309
	btrfs_stop_workers(&fs_info->endio_write_workers);
2310
	btrfs_stop_workers(&fs_info->submit_workers);
2311

2312
#if 0
C
Chris Mason 已提交
2313
	while (!list_empty(&fs_info->hashers)) {
2314 2315 2316 2317 2318 2319 2320 2321
		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
2322
	btrfs_close_devices(fs_info->fs_devices);
2323
	btrfs_mapping_tree_free(&fs_info->mapping_tree);
2324

C
Chris Mason 已提交
2325
	bdi_destroy(&fs_info->bdi);
2326

2327 2328
	kfree(fs_info->extent_root);
	kfree(fs_info->tree_root);
2329 2330
	kfree(fs_info->chunk_root);
	kfree(fs_info->dev_root);
2331
	kfree(fs_info->csum_root);
2332 2333 2334
	return 0;
}

2335
int btrfs_buffer_uptodate(struct extent_buffer *buf, u64 parent_transid)
2336
{
2337
	int ret;
2338
	struct inode *btree_inode = buf->first_page->mapping->host;
2339 2340 2341 2342 2343 2344 2345 2346

	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;
2347 2348 2349
}

int btrfs_set_buffer_uptodate(struct extent_buffer *buf)
C
Chris Mason 已提交
2350
{
2351
	struct inode *btree_inode = buf->first_page->mapping->host;
2352
	return set_extent_buffer_uptodate(&BTRFS_I(btree_inode)->io_tree,
2353 2354
					  buf);
}
2355

2356 2357
void btrfs_mark_buffer_dirty(struct extent_buffer *buf)
{
2358
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
2359 2360
	u64 transid = btrfs_header_generation(buf);
	struct inode *btree_inode = root->fs_info->btree_inode;
2361

2362 2363
	btrfs_set_lock_blocking(buf);

2364
	btrfs_assert_tree_locked(buf);
C
Chris Mason 已提交
2365
	if (transid != root->fs_info->generation) {
C
Chris Mason 已提交
2366 2367
		printk(KERN_CRIT "btrfs transid mismatch buffer %llu, "
		       "found %llu running %llu\n",
2368
			(unsigned long long)buf->start,
C
Chris Mason 已提交
2369 2370
			(unsigned long long)transid,
			(unsigned long long)root->fs_info->generation);
C
Chris Mason 已提交
2371 2372
		WARN_ON(1);
	}
2373
	set_extent_buffer_dirty(&BTRFS_I(btree_inode)->io_tree, buf);
2374 2375
}

2376
void btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr)
C
Chris Mason 已提交
2377
{
2378 2379 2380 2381
	/*
	 * looks as though older kernels can get into trouble with
	 * this code, they end up stuck in balance_dirty_pages forever
	 */
2382 2383 2384
	struct extent_io_tree *tree;
	u64 num_dirty;
	u64 start = 0;
2385
	unsigned long thresh = 32 * 1024 * 1024;
2386 2387
	tree = &BTRFS_I(root->fs_info->btree_inode)->io_tree;

2388
	if (current_is_pdflush() || current->flags & PF_MEMALLOC)
2389 2390 2391 2392 2393 2394
		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 已提交
2395
				   root->fs_info->btree_inode->i_mapping, 1);
2396
	}
2397
	return;
C
Chris Mason 已提交
2398
}
2399

2400
int btrfs_read_buffer(struct extent_buffer *buf, u64 parent_transid)
2401
{
2402
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
2403
	int ret;
2404
	ret = btree_read_extent_buffer_pages(root, buf, 0, parent_transid);
C
Chris Mason 已提交
2405
	if (ret == 0)
2406
		set_bit(EXTENT_BUFFER_UPTODATE, &buf->bflags);
2407
	return ret;
2408
}
2409

C
Chris Mason 已提交
2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434
int btree_lock_page_hook(struct page *page)
{
	struct inode *inode = page->mapping->host;
	struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
	struct extent_buffer *eb;
	unsigned long len;
	u64 bytenr = page_offset(page);

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

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

	btrfs_tree_lock(eb);
	btrfs_set_header_flag(eb, BTRFS_HEADER_FLAG_WRITTEN);
	btrfs_tree_unlock(eb);
	free_extent_buffer(eb);
out:
	lock_page(page);
	return 0;
}

2435
static struct extent_io_ops btree_extent_io_ops = {
C
Chris Mason 已提交
2436
	.write_cache_pages_lock_hook = btree_lock_page_hook,
2437
	.readpage_end_io_hook = btree_readpage_end_io_hook,
2438
	.submit_bio_hook = btree_submit_bio_hook,
2439 2440
	/* note we're sharing with inode.c for the merge bio hook */
	.merge_bio_hook = btrfs_merge_bio_hook,
2441
};