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

C
Chris Mason 已提交
19
#include <linux/fs.h>
20
#include <linux/blkdev.h>
C
Chris Mason 已提交
21
#include <linux/scatterlist.h>
C
Chris Mason 已提交
22
#include <linux/swap.h>
23
#include <linux/radix-tree.h>
C
Chris Mason 已提交
24
#include <linux/writeback.h>
C
Chris Mason 已提交
25
#include <linux/buffer_head.h>
26
#include <linux/workqueue.h>
27
#include <linux/kthread.h>
C
Chris Mason 已提交
28
#include <linux/freezer.h>
29
#include <linux/crc32c.h>
C
Chris Mason 已提交
30
#include "compat.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"
39
#include "tree-log.h"
40
#include "free-space-cache.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 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 236 237 238 239 240 241
			if (printk_ratelimit()) {
				printk(KERN_INFO "btrfs: %s checksum verify "
				       "failed on %llu wanted %X found %X "
				       "level %d\n",
				       root->fs_info->sb->s_id,
				       (unsigned long long)buf->start, val, found,
				       btrfs_header_level(buf));
			}
242 243
			if (result != (char *)&inline_result)
				kfree(result);
244 245 246
			return 1;
		}
	} else {
247
		write_extent_buffer(buf, result, 0, csum_size);
248
	}
249 250
	if (result != (char *)&inline_result)
		kfree(result);
251 252 253
	return 0;
}

C
Chris Mason 已提交
254 255 256 257 258 259
/*
 * 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.
 */
260 261 262 263 264 265 266 267 268 269 270 271 272 273
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;
	}
C
Chris Mason 已提交
274 275 276 277 278 279 280
	if (printk_ratelimit()) {
		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));
	}
281 282
	ret = 1;
	clear_extent_buffer_uptodate(io_tree, eb);
C
Chris Mason 已提交
283
out:
284 285 286 287 288
	unlock_extent(io_tree, eb->start, eb->start + eb->len - 1,
		      GFP_NOFS);
	return ret;
}

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

310 311
		num_copies = btrfs_num_copies(&root->fs_info->mapping_tree,
					      eb->start, eb->len);
C
Chris Mason 已提交
312
		if (num_copies == 1)
313
			return ret;
C
Chris Mason 已提交
314

315
		mirror_num++;
C
Chris Mason 已提交
316
		if (mirror_num > num_copies)
317 318 319 320
			return ret;
	}
	return -EIO;
}
321

C
Chris Mason 已提交
322
/*
C
Chris Mason 已提交
323 324
 * 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 已提交
325
 */
C
Chris Mason 已提交
326

327
static int csum_dirty_buffer(struct btrfs_root *root, struct page *page)
328
{
329
	struct extent_io_tree *tree;
330
	u64 start = (u64)page->index << PAGE_CACHE_SHIFT;
331 332 333 334
	u64 found_start;
	int found_level;
	unsigned long len;
	struct extent_buffer *eb;
335 336
	int ret;

337
	tree = &BTRFS_I(page->mapping->host)->io_tree;
338 339 340 341 342 343

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

346
	eb = alloc_extent_buffer(tree, start, len, page, GFP_NOFS);
347 348
	ret = btree_read_extent_buffer_pages(root, eb, start + PAGE_CACHE_SIZE,
					     btrfs_header_generation(eb));
349
	BUG_ON(ret);
350 351
	found_start = btrfs_header_bytenr(eb);
	if (found_start != start) {
352 353 354 355 356 357 358 359 360 361
		WARN_ON(1);
		goto err;
	}
	if (eb->first_page != page) {
		WARN_ON(1);
		goto err;
	}
	if (!PageUptodate(page)) {
		WARN_ON(1);
		goto err;
362 363
	}
	found_level = btrfs_header_level(eb);
C
Chris Mason 已提交
364

365
	csum_tree_block(root, eb, 0);
366
err:
367 368 369 370 371
	free_extent_buffer(eb);
out:
	return 0;
}

Y
Yan Zheng 已提交
372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390
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;
}

391 392 393 394 395 396 397 398 399
#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

400
static int btree_readpage_end_io_hook(struct page *page, u64 start, u64 end,
401 402 403 404 405 406 407 408
			       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;
409
	int ret = 0;
410 411 412 413 414 415

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

417
	len = page->private >> 2;
C
Chris Mason 已提交
418 419
	WARN_ON(len == 0);

420
	eb = alloc_extent_buffer(tree, start, len, page, GFP_NOFS);
421

422
	found_start = btrfs_header_bytenr(eb);
423
	if (found_start != start) {
C
Chris Mason 已提交
424 425 426 427 428 429
		if (printk_ratelimit()) {
			printk(KERN_INFO "btrfs bad tree block start "
			       "%llu %llu\n",
			       (unsigned long long)found_start,
			       (unsigned long long)eb->start);
		}
430
		ret = -EIO;
431 432 433
		goto err;
	}
	if (eb->first_page != page) {
C
Chris Mason 已提交
434 435
		printk(KERN_INFO "btrfs bad first page %lu %lu\n",
		       eb->first_page->index, page->index);
436
		WARN_ON(1);
437
		ret = -EIO;
438 439
		goto err;
	}
Y
Yan Zheng 已提交
440
	if (check_tree_block_fsid(root, eb)) {
C
Chris Mason 已提交
441 442 443 444
		if (printk_ratelimit()) {
			printk(KERN_INFO "btrfs bad fsid on block %llu\n",
			       (unsigned long long)eb->start);
		}
445 446 447
		ret = -EIO;
		goto err;
	}
448 449
	found_level = btrfs_header_level(eb);

450 451
	btrfs_set_buffer_lockdep_class(eb, found_level);

452
	ret = csum_tree_block(root, eb, 1);
453 454
	if (ret)
		ret = -EIO;
455 456 457 458 459 460

	end = min_t(u64, eb->len, PAGE_CACHE_SIZE);
	end = eb->start + end - 1;
err:
	free_extent_buffer(eb);
out:
461
	return ret;
462 463 464 465 466 467 468 469 470
}

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;
471 472
	end_io_wq->work.func = end_workqueue_fn;
	end_io_wq->work.flags = 0;
473 474

	if (bio->bi_rw & (1 << BIO_RW)) {
475 476 477 478 479 480
		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);
481 482 483 484 485 486 487 488
	} 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);
	}
489 490
}

491 492
int btrfs_bio_wq_end_io(struct btrfs_fs_info *info, struct bio *bio,
			int metadata)
493
{
494 495 496 497 498 499 500
	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;
501
	end_io_wq->info = info;
502 503
	end_io_wq->error = 0;
	end_io_wq->bio = bio;
504
	end_io_wq->metadata = metadata;
505 506 507

	bio->bi_private = end_io_wq;
	bio->bi_end_io = end_workqueue_bio;
508 509 510
	return 0;
}

511
unsigned long btrfs_async_submit_limit(struct btrfs_fs_info *info)
512
{
513 514 515 516 517
	unsigned long limit = min_t(unsigned long,
				    info->workers.max_workers,
				    info->fs_devices->open_devices);
	return 256 * limit;
}
518

519 520
int btrfs_congested_async(struct btrfs_fs_info *info, int iodone)
{
521 522
	return atomic_read(&info->nr_async_bios) >
		btrfs_async_submit_limit(info);
523 524
}

C
Chris Mason 已提交
525 526 527 528 529 530 531 532 533 534 535 536
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)
537 538 539
{
	struct btrfs_fs_info *fs_info;
	struct async_submit_bio *async;
540
	int limit;
541 542 543

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

545
	limit = btrfs_async_submit_limit(fs_info);
546 547
	limit = limit * 2 / 3;

548
	atomic_dec(&fs_info->nr_async_submits);
549

550 551
	if (atomic_read(&fs_info->nr_async_submits) < limit &&
	    waitqueue_active(&fs_info->async_submit_wait))
552 553
		wake_up(&fs_info->async_submit_wait);

C
Chris Mason 已提交
554
	async->submit_bio_done(async->inode, async->rw, async->bio,
C
Chris Mason 已提交
555
			       async->mirror_num, async->bio_flags);
C
Chris Mason 已提交
556 557 558 559 560 561 562
}

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

	async = container_of(work, struct  async_submit_bio, work);
563 564 565
	kfree(async);
}

566 567
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 已提交
568
			unsigned long bio_flags,
C
Chris Mason 已提交
569 570
			extent_submit_bio_hook_t *submit_bio_start,
			extent_submit_bio_hook_t *submit_bio_done)
571 572 573 574 575 576 577 578 579 580 581
{
	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 已提交
582 583 584 585 586 587 588
	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;

589
	async->work.flags = 0;
C
Chris Mason 已提交
590
	async->bio_flags = bio_flags;
591

592
	atomic_inc(&fs_info->nr_async_submits);
593 594 595 596

	if (rw & (1 << BIO_RW_SYNCIO))
		btrfs_set_work_high_prio(&async->work);

597
	btrfs_queue_worker(&fs_info->workers, &async->work);
598

C
Chris Mason 已提交
599
	while (atomic_read(&fs_info->async_submit_draining) &&
600 601 602 603 604
	      atomic_read(&fs_info->nr_async_submits)) {
		wait_event(fs_info->async_submit_wait,
			   (atomic_read(&fs_info->nr_async_submits) == 0));
	}

605 606 607
	return 0;
}

608 609 610 611 612 613 614
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 已提交
615
	while (bio_index < bio->bi_vcnt) {
616 617 618 619 620 621 622 623
		root = BTRFS_I(bvec->bv_page->mapping->host)->root;
		csum_dirty_buffer(root, bvec->bv_page);
		bio_index++;
		bvec++;
	}
	return 0;
}

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

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

646
static int btree_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
C
Chris Mason 已提交
647
				 int mirror_num, unsigned long bio_flags)
648
{
649 650 651 652 653 654
	int ret;

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

655
	if (!(rw & (1 << BIO_RW))) {
C
Chris Mason 已提交
656 657 658 659 660
		/*
		 * 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,
661
				     mirror_num, 0);
662
	}
663

664 665 666 667
	/*
	 * kthread helpers are used to submit writes so that checksumming
	 * can happen in parallel across all CPUs
	 */
668
	return btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,
C
Chris Mason 已提交
669
				   inode, rw, bio, mirror_num, 0,
C
Chris Mason 已提交
670 671
				   __btree_submit_bio_start,
				   __btree_submit_bio_done);
672 673
}

674 675
static int btree_writepage(struct page *page, struct writeback_control *wbc)
{
676
	struct extent_io_tree *tree;
677 678 679 680
	struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
	struct extent_buffer *eb;
	int was_dirty;

681
	tree = &BTRFS_I(page->mapping->host)->io_tree;
682 683 684 685
	if (!(current->flags & PF_MEMALLOC)) {
		return extent_write_full_page(tree, page,
					      btree_get_extent, wbc);
	}
686

687 688 689 690 691 692 693 694 695 696
	redirty_page_for_writepage(wbc, page);
	eb = btrfs_find_tree_block(root, page_offset(page),
				      PAGE_CACHE_SIZE);
	WARN_ON(!eb);

	was_dirty = test_and_set_bit(EXTENT_BUFFER_DIRTY, &eb->bflags);
	if (!was_dirty) {
		spin_lock(&root->fs_info->delalloc_lock);
		root->fs_info->dirty_metadata_bytes += PAGE_CACHE_SIZE;
		spin_unlock(&root->fs_info->delalloc_lock);
697
	}
698 699 700 701
	free_extent_buffer(eb);

	unlock_page(page);
	return 0;
702
}
703 704 705 706

static int btree_writepages(struct address_space *mapping,
			    struct writeback_control *wbc)
{
707 708
	struct extent_io_tree *tree;
	tree = &BTRFS_I(mapping->host)->io_tree;
709
	if (wbc->sync_mode == WB_SYNC_NONE) {
710
		struct btrfs_root *root = BTRFS_I(mapping->host)->root;
711
		u64 num_dirty;
712
		unsigned long thresh = 32 * 1024 * 1024;
713 714 715 716

		if (wbc->for_kupdate)
			return 0;

717 718
		/* this is a bit racy, but that's ok */
		num_dirty = root->fs_info->dirty_metadata_bytes;
C
Chris Mason 已提交
719
		if (num_dirty < thresh)
720 721
			return 0;
	}
722 723 724
	return extent_writepages(tree, mapping, btree_get_extent, wbc);
}

725
static int btree_readpage(struct file *file, struct page *page)
726
{
727 728
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
729 730
	return extent_read_full_page(tree, page, btree_get_extent);
}
C
Chris Mason 已提交
731

732
static int btree_releasepage(struct page *page, gfp_t gfp_flags)
733
{
734 735
	struct extent_io_tree *tree;
	struct extent_map_tree *map;
736
	int ret;
737

738
	if (PageWriteback(page) || PageDirty(page))
C
Chris Mason 已提交
739
		return 0;
740

741 742
	tree = &BTRFS_I(page->mapping->host)->io_tree;
	map = &BTRFS_I(page->mapping->host)->extent_tree;
743

744
	ret = try_release_extent_state(map, tree, page, gfp_flags);
C
Chris Mason 已提交
745
	if (!ret)
746 747 748
		return 0;

	ret = try_release_extent_buffer(tree, page);
749 750 751 752 753
	if (ret == 1) {
		ClearPagePrivate(page);
		set_page_private(page, 0);
		page_cache_release(page);
	}
754

755 756 757
	return ret;
}

758
static void btree_invalidatepage(struct page *page, unsigned long offset)
759
{
760 761
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
762 763
	extent_invalidatepage(tree, page, offset);
	btree_releasepage(page, GFP_NOFS);
764
	if (PagePrivate(page)) {
C
Chris Mason 已提交
765 766
		printk(KERN_WARNING "btrfs warning page private not zero "
		       "on page %llu\n", (unsigned long long)page_offset(page));
767 768 769 770
		ClearPagePrivate(page);
		set_page_private(page, 0);
		page_cache_release(page);
	}
771 772 773 774 775
}

static struct address_space_operations btree_aops = {
	.readpage	= btree_readpage,
	.writepage	= btree_writepage,
776
	.writepages	= btree_writepages,
777 778
	.releasepage	= btree_releasepage,
	.invalidatepage = btree_invalidatepage,
779 780 781
	.sync_page	= block_sync_page,
};

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

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

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


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

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

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

846
	ret = btree_read_extent_buffer_pages(root, buf, 0, parent_transid);
847

C
Chris Mason 已提交
848
	if (ret == 0)
849
		set_bit(EXTENT_BUFFER_UPTODATE, &buf->bflags);
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 865 866 867 868 869
		if (test_and_clear_bit(EXTENT_BUFFER_DIRTY, &buf->bflags)) {
			spin_lock(&root->fs_info->delalloc_lock);
			if (root->fs_info->dirty_metadata_bytes >= buf->len)
				root->fs_info->dirty_metadata_bytes -= buf->len;
			else
				WARN_ON(1);
			spin_unlock(&root->fs_info->delalloc_lock);
		}
870

871 872
		/* ugh, clear_extent_buffer_dirty needs to lock the page */
		btrfs_set_lock_blocking(buf);
873
		clear_extent_buffer_dirty(&BTRFS_I(btree_inode)->io_tree,
874
					  buf);
875
	}
876 877 878
	return 0;
}

879
static int __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize,
880
			u32 stripesize, struct btrfs_root *root,
881
			struct btrfs_fs_info *fs_info,
C
Chris Mason 已提交
882
			u64 objectid)
883
{
C
Chris Mason 已提交
884
	root->node = NULL;
885
	root->commit_root = NULL;
886 887 888
	root->sectorsize = sectorsize;
	root->nodesize = nodesize;
	root->leafsize = leafsize;
889
	root->stripesize = stripesize;
C
Chris Mason 已提交
890
	root->ref_cows = 0;
891 892
	root->track_dirty = 0;

893
	root->fs_info = fs_info;
894 895
	root->objectid = objectid;
	root->last_trans = 0;
C
Chris Mason 已提交
896 897
	root->highest_inode = 0;
	root->last_inode_alloc = 0;
898
	root->name = NULL;
899
	root->in_sysfs = 0;
900
	root->inode_tree.rb_node = NULL;
901 902

	INIT_LIST_HEAD(&root->dirty_list);
903
	INIT_LIST_HEAD(&root->orphan_list);
904
	INIT_LIST_HEAD(&root->root_list);
905
	spin_lock_init(&root->node_lock);
906
	spin_lock_init(&root->list_lock);
907
	spin_lock_init(&root->inode_lock);
908
	mutex_init(&root->objectid_mutex);
909
	mutex_init(&root->log_mutex);
Y
Yan Zheng 已提交
910 911 912 913 914 915 916 917
	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;
918 919
	extent_io_tree_init(&root->dirty_log_pages,
			     fs_info->btree_inode->i_mapping, GFP_NOFS);
C
Chris Mason 已提交
920

921 922
	memset(&root->root_key, 0, sizeof(root->root_key));
	memset(&root->root_item, 0, sizeof(root->root_item));
923
	memset(&root->defrag_progress, 0, sizeof(root->defrag_progress));
924
	memset(&root->root_kobj, 0, sizeof(root->root_kobj));
925
	root->defrag_trans_start = fs_info->generation;
926
	init_completion(&root->kobj_unregister);
927 928
	root->defrag_running = 0;
	root->defrag_level = 0;
929
	root->root_key.objectid = objectid;
930 931 932 933 934 935
	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);

936 937 938
	return 0;
}

939
static int find_and_setup_root(struct btrfs_root *tree_root,
940 941
			       struct btrfs_fs_info *fs_info,
			       u64 objectid,
C
Chris Mason 已提交
942
			       struct btrfs_root *root)
943 944
{
	int ret;
945
	u32 blocksize;
946
	u64 generation;
947

948
	__setup_root(tree_root->nodesize, tree_root->leafsize,
949 950
		     tree_root->sectorsize, tree_root->stripesize,
		     root, fs_info, objectid);
951 952 953 954
	ret = btrfs_find_last_root(tree_root, objectid,
				   &root->root_item, &root->root_key);
	BUG_ON(ret);

955
	generation = btrfs_root_generation(&root->root_item);
956 957
	blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
	root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
958
				     blocksize, generation);
959
	root->commit_root = btrfs_root_node(root);
960
	BUG_ON(!root->node);
961 962 963
	return 0;
}

964 965 966 967
int btrfs_free_log_root_tree(struct btrfs_trans_handle *trans,
			     struct btrfs_fs_info *fs_info)
{
	struct extent_buffer *eb;
968 969 970
	struct btrfs_root *log_root_tree = fs_info->log_root_tree;
	u64 start = 0;
	u64 end = 0;
971 972
	int ret;

973
	if (!log_root_tree)
974 975
		return 0;

C
Chris Mason 已提交
976
	while (1) {
977 978 979 980 981 982 983 984
		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);
	}
985 986 987 988 989
	eb = fs_info->log_root_tree->node;

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

990 991
	ret = btrfs_free_reserved_extent(fs_info->tree_root,
				eb->start, eb->len);
992 993 994 995 996 997 998 999
	BUG_ON(ret);

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

Y
Yan Zheng 已提交
1000 1001
static struct btrfs_root *alloc_log_tree(struct btrfs_trans_handle *trans,
					 struct btrfs_fs_info *fs_info)
1002 1003 1004
{
	struct btrfs_root *root;
	struct btrfs_root *tree_root = fs_info->tree_root;
Y
Yan Zheng 已提交
1005
	struct extent_buffer *leaf;
1006 1007 1008

	root = kzalloc(sizeof(*root), GFP_NOFS);
	if (!root)
Y
Yan Zheng 已提交
1009
		return ERR_PTR(-ENOMEM);
1010 1011 1012 1013 1014 1015 1016 1017

	__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 已提交
1018 1019 1020 1021 1022 1023
	/*
	 * 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).
	 */
1024 1025
	root->ref_cows = 0;

1026 1027
	leaf = btrfs_alloc_free_block(trans, root, root->leafsize, 0,
				      BTRFS_TREE_LOG_OBJECTID, NULL, 0, 0, 0);
Y
Yan Zheng 已提交
1028 1029 1030 1031
	if (IS_ERR(leaf)) {
		kfree(root);
		return ERR_CAST(leaf);
	}
1032

1033 1034 1035 1036 1037
	memset_extent_buffer(leaf, 0, 0, sizeof(struct btrfs_header));
	btrfs_set_header_bytenr(leaf, leaf->start);
	btrfs_set_header_generation(leaf, trans->transid);
	btrfs_set_header_backref_rev(leaf, BTRFS_MIXED_BACKREF_REV);
	btrfs_set_header_owner(leaf, BTRFS_TREE_LOG_OBJECTID);
Y
Yan Zheng 已提交
1038
	root->node = leaf;
1039 1040 1041 1042 1043 1044

	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 已提交
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);

1081
	btrfs_set_root_node(&log_root->root_item, log_root->node);
Y
Yan Zheng 已提交
1082 1083 1084 1085

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

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

1114
	__setup_root(tree_root->nodesize, tree_root->leafsize,
1115 1116
		     tree_root->sectorsize, tree_root->stripesize,
		     root, fs_info, location->objectid);
1117 1118 1119 1120 1121 1122 1123 1124 1125

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

C
Chris Mason 已提交
1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171
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;
}

1172 1173
struct btrfs_root *btrfs_read_fs_root_no_name(struct btrfs_fs_info *fs_info,
					      struct btrfs_key *location)
1174 1175 1176 1177
{
	struct btrfs_root *root;
	int ret;

1178 1179 1180 1181
	if (location->objectid == BTRFS_ROOT_TREE_OBJECTID)
		return fs_info->tree_root;
	if (location->objectid == BTRFS_EXTENT_TREE_OBJECTID)
		return fs_info->extent_root;
1182 1183 1184 1185
	if (location->objectid == BTRFS_CHUNK_TREE_OBJECTID)
		return fs_info->chunk_root;
	if (location->objectid == BTRFS_DEV_TREE_OBJECTID)
		return fs_info->dev_root;
1186 1187
	if (location->objectid == BTRFS_CSUM_TREE_OBJECTID)
		return fs_info->csum_root;
1188

1189 1190 1191 1192 1193
	root = radix_tree_lookup(&fs_info->fs_roots_radix,
				 (unsigned long)location->objectid);
	if (root)
		return root;

1194
	root = btrfs_read_fs_root_no_radix(fs_info->tree_root, location);
1195 1196
	if (IS_ERR(root))
		return root;
1197 1198 1199

	set_anon_super(&root->anon_super, NULL);

C
Chris Mason 已提交
1200 1201
	ret = radix_tree_insert(&fs_info->fs_roots_radix,
				(unsigned long)root->root_key.objectid,
1202 1203
				root);
	if (ret) {
1204
		free_extent_buffer(root->node);
1205 1206 1207
		kfree(root);
		return ERR_PTR(ret);
	}
Y
Yan Zheng 已提交
1208 1209
	if (!(fs_info->sb->s_flags & MS_RDONLY)) {
		ret = btrfs_find_dead_roots(fs_info->tree_root,
1210
					    root->root_key.objectid);
Y
Yan Zheng 已提交
1211 1212 1213
		BUG_ON(ret);
		btrfs_orphan_cleanup(root);
	}
1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226
	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;
1227

1228 1229 1230
	if (root->in_sysfs)
		return root;

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

static int btrfs_congested_fn(void *congested_data, int bdi_bits)
{
	struct btrfs_fs_info *info = (struct btrfs_fs_info *)congested_data;
	int ret = 0;
	struct btrfs_device *device;
	struct backing_dev_info *bdi;
C
Chris Mason 已提交
1256

Q
Qinghuang Feng 已提交
1257
	list_for_each_entry(device, &info->fs_devices->devices, dev_list) {
1258 1259
		if (!device->bdev)
			continue;
C
Chris Mason 已提交
1260 1261 1262 1263 1264 1265 1266 1267 1268
		bdi = blk_get_backing_dev_info(device->bdev);
		if (bdi && bdi_congested(bdi, bdi_bits)) {
			ret = 1;
			break;
		}
	}
	return ret;
}

1269 1270 1271 1272 1273 1274 1275 1276 1277 1278
/*
 * 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 已提交
1279
	list_for_each_entry(device, &info->fs_devices->devices, dev_list) {
1280 1281 1282
		if (!device->bdev)
			continue;

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

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

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

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

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

1323
	offset = page_offset(page);
C
Chris Mason 已提交
1324

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

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

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

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);
	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 1474 1475 1476 1477 1478 1479
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);

		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 已提交
1480

1481 1482 1483 1484 1485 1486 1487 1488 1489
		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);
1490

1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507
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;
}

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

1535
	int ret;
1536
	int err = -EINVAL;
1537

C
Chris Mason 已提交
1538
	struct btrfs_super_block *disk_super;
1539

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

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

1578 1579
	fs_info->thread_pool_size = min_t(unsigned long,
					  num_online_cpus() + 2, 8);
1580

1581 1582 1583
	INIT_LIST_HEAD(&fs_info->ordered_extents);
	spin_lock_init(&fs_info->ordered_extent_lock);

1584 1585 1586
	sb->s_blocksize = 4096;
	sb->s_blocksize_bits = blksize_bits(4096);

1587 1588 1589 1590 1591 1592
	/*
	 * 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;
1593
	fs_info->btree_inode->i_mapping->a_ops = &btree_aops;
C
Chris Mason 已提交
1594 1595
	fs_info->btree_inode->i_mapping->backing_dev_info = &fs_info->bdi;

1596
	RB_CLEAR_NODE(&BTRFS_I(fs_info->btree_inode)->rb_node);
1597
	extent_io_tree_init(&BTRFS_I(fs_info->btree_inode)->io_tree,
1598 1599
			     fs_info->btree_inode->i_mapping,
			     GFP_NOFS);
1600 1601 1602 1603
	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;
1604

J
Josef Bacik 已提交
1605 1606 1607
	spin_lock_init(&fs_info->block_group_cache_lock);
	fs_info->block_group_cache_tree.rb_node = NULL;

1608
	extent_io_tree_init(&fs_info->pinned_extents,
1609
			     fs_info->btree_inode->i_mapping, GFP_NOFS);
1610
	fs_info->do_barriers = 1;
1611

1612 1613 1614
	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 已提交
1615
	insert_inode_hash(fs_info->btree_inode);
C
Chris Mason 已提交
1616

C
Chris Mason 已提交
1617
	mutex_init(&fs_info->trans_mutex);
1618
	mutex_init(&fs_info->ordered_operations_mutex);
1619
	mutex_init(&fs_info->tree_log_mutex);
1620
	mutex_init(&fs_info->drop_mutex);
1621
	mutex_init(&fs_info->chunk_mutex);
1622 1623
	mutex_init(&fs_info->transaction_kthread_mutex);
	mutex_init(&fs_info->cleaner_mutex);
1624
	mutex_init(&fs_info->volume_mutex);
Z
Zheng Yan 已提交
1625
	mutex_init(&fs_info->tree_reloc_mutex);
1626 1627 1628 1629

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

1630
	init_waitqueue_head(&fs_info->transaction_throttle);
1631
	init_waitqueue_head(&fs_info->transaction_wait);
1632
	init_waitqueue_head(&fs_info->async_submit_wait);
1633

1634
	__setup_root(4096, 4096, 4096, 4096, tree_root,
C
Chris Mason 已提交
1635
		     fs_info, BTRFS_ROOT_TREE_OBJECTID);
1636

1637

Y
Yan Zheng 已提交
1638
	bh = btrfs_read_dev_super(fs_devices->latest_bdev);
1639
	if (!bh)
C
Chris Mason 已提交
1640 1641
		goto fail_iput;

1642
	memcpy(&fs_info->super_copy, bh->b_data, sizeof(fs_info->super_copy));
1643 1644
	memcpy(&fs_info->super_for_commit, &fs_info->super_copy,
	       sizeof(fs_info->super_for_commit));
1645
	brelse(bh);
1646

1647
	memcpy(fs_info->fsid, fs_info->super_copy.fsid, BTRFS_FSID_SIZE);
1648

1649
	disk_super = &fs_info->super_copy;
1650
	if (!btrfs_super_root(disk_super))
1651
		goto fail_iput;
1652

Y
Yan Zheng 已提交
1653 1654 1655
	ret = btrfs_parse_options(tree_root, options);
	if (ret) {
		err = ret;
1656
		goto fail_iput;
Y
Yan Zheng 已提交
1657
	}
1658

1659 1660 1661 1662 1663
	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",
1664
		       (unsigned long long)features);
1665
		err = -EINVAL;
1666
		goto fail_iput;
1667 1668
	}

1669 1670 1671 1672 1673 1674
	features = btrfs_super_incompat_flags(disk_super);
	if (!(features & BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF)) {
		features |= BTRFS_FEATURE_INCOMPAT_MIXED_BACKREF;
		btrfs_set_super_incompat_flags(disk_super, features);
	}

1675 1676 1677 1678 1679
	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",
1680
		       (unsigned long long)features);
1681
		err = -EINVAL;
1682
		goto fail_iput;
1683 1684
	}

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

1693 1694 1695
	btrfs_init_workers(&fs_info->delalloc_workers, "delalloc",
			   fs_info->thread_pool_size);

1696
	btrfs_init_workers(&fs_info->submit_workers, "submit",
1697 1698
			   min_t(u64, fs_devices->num_devices,
			   fs_info->thread_pool_size));
1699 1700 1701 1702 1703 1704

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

1706
	fs_info->workers.idle_thresh = 16;
C
Chris Mason 已提交
1707
	fs_info->workers.ordered = 1;
1708

1709 1710 1711
	fs_info->delalloc_workers.idle_thresh = 2;
	fs_info->delalloc_workers.ordered = 1;

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

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

1729
	fs_info->endio_write_workers.idle_thresh = 64;
1730
	fs_info->endio_meta_write_workers.idle_thresh = 64;
1731

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

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

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

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

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

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

	blocksize = btrfs_level_size(tree_root,
				     btrfs_super_chunk_root_level(disk_super));
1777
	generation = btrfs_super_chunk_root_generation(disk_super);
1778 1779 1780 1781 1782 1783

	__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),
1784
					   blocksize, generation);
1785
	BUG_ON(!chunk_root->node);
1786 1787
	btrfs_set_root_node(&chunk_root->root_item, chunk_root->node);
	chunk_root->commit_root = btrfs_root_node(chunk_root);
1788

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

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

1802 1803
	btrfs_close_extra_devices(fs_devices);

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

C
Chris Mason 已提交
1808
	tree_root->node = read_tree_block(tree_root,
1809
					  btrfs_super_root(disk_super),
1810
					  blocksize, generation);
C
Chris Mason 已提交
1811
	if (!tree_root->node)
Y
Yan Zheng 已提交
1812
		goto fail_chunk_root;
1813 1814
	btrfs_set_root_node(&tree_root->root_item, tree_root->node);
	tree_root->commit_root = btrfs_root_node(tree_root);
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
	extent_root->track_dirty = 1;

	ret = find_and_setup_root(tree_root, fs_info,
				  BTRFS_DEV_TREE_OBJECTID, dev_root);
	if (ret)
		goto fail_extent_root;
1826
	dev_root->track_dirty = 1;
1827

1828 1829 1830
	ret = find_and_setup_root(tree_root, fs_info,
				  BTRFS_CSUM_TREE_OBJECTID, csum_root);
	if (ret)
1831
		goto fail_dev_root;
1832 1833 1834

	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

C
Chris Mason 已提交
1853 1854 1855 1856 1857 1858 1859 1860
	if (!btrfs_test_opt(tree_root, SSD) &&
	    !btrfs_test_opt(tree_root, NOSSD) &&
	    !fs_info->fs_devices->rotating) {
		printk(KERN_INFO "Btrfs detected SSD devices, enabling SSD "
		       "mode\n");
		btrfs_set_opt(fs_info->mount_opt, SSD);
	}

1861 1862 1863
	if (btrfs_super_log_root(disk_super) != 0) {
		u64 bytenr = btrfs_super_log_root(disk_super);

1864
		if (fs_devices->rw_devices == 0) {
C
Chris Mason 已提交
1865 1866
			printk(KERN_WARNING "Btrfs log replay required "
			       "on RO media\n");
1867 1868 1869
			err = -EIO;
			goto fail_trans_kthread;
		}
1870 1871 1872
		blocksize =
		     btrfs_level_size(tree_root,
				      btrfs_super_log_root_level(disk_super));
C
Chris Mason 已提交
1873

1874 1875 1876 1877 1878 1879 1880
		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,
1881 1882
						      blocksize,
						      generation + 1);
1883 1884
		ret = btrfs_recover_log_trees(log_tree_root);
		BUG_ON(ret);
1885 1886 1887 1888 1889

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

1892
	if (!(sb->s_flags & MS_RDONLY)) {
1893
		ret = btrfs_recover_relocation(tree_root);
1894 1895
		BUG_ON(ret);
	}
Z
Zheng Yan 已提交
1896

1897 1898 1899 1900 1901 1902
	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)
1903
		goto fail_trans_kthread;
C
Chris Mason 已提交
1904

1905
	return tree_root;
C
Chris Mason 已提交
1906

1907 1908
fail_trans_kthread:
	kthread_stop(fs_info->transaction_kthread);
1909
fail_cleaner:
1910
	kthread_stop(fs_info->cleaner_kthread);
1911 1912 1913 1914 1915 1916 1917 1918

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

1919 1920
fail_csum_root:
	free_extent_buffer(csum_root->node);
1921 1922 1923 1924
	free_extent_buffer(csum_root->commit_root);
fail_dev_root:
	free_extent_buffer(dev_root->node);
	free_extent_buffer(dev_root->commit_root);
1925 1926
fail_extent_root:
	free_extent_buffer(extent_root->node);
1927
	free_extent_buffer(extent_root->commit_root);
C
Chris Mason 已提交
1928
fail_tree_root:
1929
	free_extent_buffer(tree_root->node);
1930
	free_extent_buffer(tree_root->commit_root);
Y
Yan Zheng 已提交
1931 1932
fail_chunk_root:
	free_extent_buffer(chunk_root->node);
1933
	free_extent_buffer(chunk_root->commit_root);
C
Chris Mason 已提交
1934
fail_sb_buffer:
1935
	btrfs_stop_workers(&fs_info->fixup_workers);
1936
	btrfs_stop_workers(&fs_info->delalloc_workers);
1937 1938
	btrfs_stop_workers(&fs_info->workers);
	btrfs_stop_workers(&fs_info->endio_workers);
1939
	btrfs_stop_workers(&fs_info->endio_meta_workers);
1940
	btrfs_stop_workers(&fs_info->endio_meta_write_workers);
1941
	btrfs_stop_workers(&fs_info->endio_write_workers);
1942
	btrfs_stop_workers(&fs_info->submit_workers);
1943
fail_iput:
1944
	invalidate_inode_pages2(fs_info->btree_inode->i_mapping);
1945
	iput(fs_info->btree_inode);
1946

1947
	btrfs_close_devices(fs_info->fs_devices);
1948
	btrfs_mapping_tree_free(&fs_info->mapping_tree);
1949
	bdi_destroy(&fs_info->bdi);
1950

1951
fail:
C
Chris Mason 已提交
1952 1953 1954
	kfree(extent_root);
	kfree(tree_root);
	kfree(fs_info);
1955 1956
	kfree(chunk_root);
	kfree(dev_root);
1957
	kfree(csum_root);
C
Chris Mason 已提交
1958
	return ERR_PTR(err);
1959 1960
}

1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972
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));
		}
1973 1974 1975
		/* note, we dont' set_buffer_write_io_error because we have
		 * our own ways of dealing with the IO errors
		 */
1976 1977 1978 1979 1980 1981
		clear_buffer_uptodate(bh);
	}
	unlock_buffer(bh);
	put_bh(bh);
}

Y
Yan Zheng 已提交
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
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;
}

2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033
/*
 * this should be called twice, once with wait == 0 and
 * once with wait == 1.  When wait == 0 is done, all the buffer heads
 * we write are pinned.
 *
 * They are released when wait == 1 is done.
 * max_mirrors must be the same for both runs, and it indicates how
 * many supers on this one device should be written.
 *
 * max_mirrors == 0 means to write them all.
 */
Y
Yan Zheng 已提交
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
static int write_dev_supers(struct btrfs_device *device,
			    struct btrfs_super_block *sb,
			    int do_barriers, int wait, int max_mirrors)
{
	struct buffer_head *bh;
	int i;
	int ret;
	int errors = 0;
	u32 crc;
	u64 bytenr;
	int last_barrier = 0;

	if (max_mirrors == 0)
		max_mirrors = BTRFS_SUPER_MIRROR_MAX;

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

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

		if (wait) {
			bh = __find_get_block(device->bdev, bytenr / 4096,
					      BTRFS_SUPER_INFO_SIZE);
			BUG_ON(!bh);
			wait_on_buffer(bh);
2070 2071 2072 2073 2074 2075 2076 2077 2078
			if (!buffer_uptodate(bh))
				errors++;

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

			/* drop the reference from the wait == 0 run */
			brelse(bh);
			continue;
Y
Yan Zheng 已提交
2079 2080 2081 2082 2083 2084 2085 2086 2087 2088
		} 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);

2089 2090 2091 2092
			/*
			 * one reference for us, and we leave it for the
			 * caller
			 */
Y
Yan Zheng 已提交
2093 2094 2095 2096
			bh = __getblk(device->bdev, bytenr / 4096,
				      BTRFS_SUPER_INFO_SIZE);
			memcpy(bh->b_data, sb, BTRFS_SUPER_INFO_SIZE);

2097
			/* one reference for submit_bh */
Y
Yan Zheng 已提交
2098
			get_bh(bh);
2099 2100

			set_buffer_uptodate(bh);
Y
Yan Zheng 已提交
2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111
			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;
2112
				/* one reference for submit_bh */
Y
Yan Zheng 已提交
2113 2114
				get_bh(bh);
				lock_buffer(bh);
2115
				ret = submit_bh(WRITE_SYNC, bh);
Y
Yan Zheng 已提交
2116 2117
			}
		} else {
2118
			ret = submit_bh(WRITE_SYNC, bh);
Y
Yan Zheng 已提交
2119 2120
		}

2121
		if (ret)
Y
Yan Zheng 已提交
2122 2123 2124 2125 2126 2127
			errors++;
	}
	return errors < i ? 0 : -1;
}

int write_all_supers(struct btrfs_root *root, int max_mirrors)
2128
{
2129
	struct list_head *head;
2130
	struct btrfs_device *dev;
2131
	struct btrfs_super_block *sb;
2132 2133 2134
	struct btrfs_dev_item *dev_item;
	int ret;
	int do_barriers;
2135 2136
	int max_errors;
	int total_errors = 0;
2137
	u64 flags;
2138

2139
	max_errors = btrfs_super_num_devices(&root->fs_info->super_copy) - 1;
2140 2141
	do_barriers = !btrfs_test_opt(root, NOBARRIER);

2142 2143
	sb = &root->fs_info->super_for_commit;
	dev_item = &sb->dev_item;
2144 2145 2146

	mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
	head = &root->fs_info->fs_devices->devices;
Q
Qinghuang Feng 已提交
2147
	list_for_each_entry(dev, head, dev_list) {
2148 2149 2150 2151
		if (!dev->bdev) {
			total_errors++;
			continue;
		}
Y
Yan Zheng 已提交
2152
		if (!dev->in_fs_metadata || !dev->writeable)
2153 2154
			continue;

Y
Yan Zheng 已提交
2155
		btrfs_set_stack_device_generation(dev_item, 0);
2156 2157 2158 2159 2160 2161 2162 2163
		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 已提交
2164
		memcpy(dev_item->fsid, dev->fs_devices->fsid, BTRFS_UUID_SIZE);
Y
Yan Zheng 已提交
2165

2166 2167 2168
		flags = btrfs_super_flags(sb);
		btrfs_set_super_flags(sb, flags | BTRFS_HEADER_FLAG_WRITTEN);

Y
Yan Zheng 已提交
2169
		ret = write_dev_supers(dev, sb, do_barriers, 0, max_mirrors);
2170 2171
		if (ret)
			total_errors++;
2172
	}
2173
	if (total_errors > max_errors) {
C
Chris Mason 已提交
2174 2175
		printk(KERN_ERR "btrfs: %d errors while writing supers\n",
		       total_errors);
2176 2177
		BUG();
	}
2178

Y
Yan Zheng 已提交
2179
	total_errors = 0;
Q
Qinghuang Feng 已提交
2180
	list_for_each_entry(dev, head, dev_list) {
2181 2182
		if (!dev->bdev)
			continue;
Y
Yan Zheng 已提交
2183
		if (!dev->in_fs_metadata || !dev->writeable)
2184 2185
			continue;

Y
Yan Zheng 已提交
2186 2187 2188
		ret = write_dev_supers(dev, sb, do_barriers, 1, max_mirrors);
		if (ret)
			total_errors++;
2189
	}
2190
	mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
2191
	if (total_errors > max_errors) {
C
Chris Mason 已提交
2192 2193
		printk(KERN_ERR "btrfs: %d errors while writing supers\n",
		       total_errors);
2194 2195
		BUG();
	}
2196 2197 2198
	return 0;
}

Y
Yan Zheng 已提交
2199 2200
int write_ctree_super(struct btrfs_trans_handle *trans,
		      struct btrfs_root *root, int max_mirrors)
2201
{
2202
	int ret;
2203

Y
Yan Zheng 已提交
2204
	ret = write_all_supers(root, max_mirrors);
2205
	return ret;
C
Chris Mason 已提交
2206 2207
}

2208
int btrfs_free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root)
C
Chris Mason 已提交
2209
{
2210
	WARN_ON(!RB_EMPTY_ROOT(&root->inode_tree));
C
Chris Mason 已提交
2211 2212
	radix_tree_delete(&fs_info->fs_roots_radix,
			  (unsigned long)root->root_key.objectid);
2213 2214 2215 2216
	if (root->anon_super.s_dev) {
		down_write(&root->anon_super.s_umount);
		kill_anon_super(&root->anon_super);
	}
C
Chris Mason 已提交
2217
	if (root->node)
2218
		free_extent_buffer(root->node);
C
Chris Mason 已提交
2219
	if (root->commit_root)
2220
		free_extent_buffer(root->commit_root);
C
Chris Mason 已提交
2221
	kfree(root->name);
C
Chris Mason 已提交
2222 2223 2224 2225
	kfree(root);
	return 0;
}

C
Chris Mason 已提交
2226
static int del_fs_roots(struct btrfs_fs_info *fs_info)
2227 2228 2229 2230 2231
{
	int ret;
	struct btrfs_root *gang[8];
	int i;

C
Chris Mason 已提交
2232
	while (1) {
2233 2234 2235 2236 2237
		ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
					     (void **)gang, 0,
					     ARRAY_SIZE(gang));
		if (!ret)
			break;
C
Chris Mason 已提交
2238
		for (i = 0; i < ret; i++)
2239
			btrfs_free_fs_root(fs_info, gang[i]);
2240 2241 2242
	}
	return 0;
}
2243

Y
Yan Zheng 已提交
2244
int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info)
C
Chris Mason 已提交
2245
{
Y
Yan Zheng 已提交
2246 2247 2248
	u64 root_objectid = 0;
	struct btrfs_root *gang[8];
	int i;
2249
	int ret;
2250

Y
Yan Zheng 已提交
2251 2252 2253 2254 2255 2256
	while (1) {
		ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
					     (void **)gang, root_objectid,
					     ARRAY_SIZE(gang));
		if (!ret)
			break;
2257 2258

		root_objectid = gang[ret - 1]->root_key.objectid + 1;
Y
Yan Zheng 已提交
2259 2260 2261
		for (i = 0; i < ret; i++) {
			root_objectid = gang[i]->root_key.objectid;
			ret = btrfs_find_dead_roots(fs_info->tree_root,
2262
						    root_objectid);
Y
Yan Zheng 已提交
2263 2264 2265 2266 2267 2268 2269
			BUG_ON(ret);
			btrfs_orphan_cleanup(gang[i]);
		}
		root_objectid++;
	}
	return 0;
}
2270

Y
Yan Zheng 已提交
2271 2272 2273 2274
int btrfs_commit_super(struct btrfs_root *root)
{
	struct btrfs_trans_handle *trans;
	int ret;
2275

Y
Yan Zheng 已提交
2276
	mutex_lock(&root->fs_info->cleaner_mutex);
2277
	btrfs_clean_old_snapshots(root);
Y
Yan Zheng 已提交
2278
	mutex_unlock(&root->fs_info->cleaner_mutex);
C
Chris Mason 已提交
2279
	trans = btrfs_start_transaction(root, 1);
2280
	ret = btrfs_commit_transaction(trans, root);
Y
Yan Zheng 已提交
2281 2282
	BUG_ON(ret);
	/* run commit again to drop the original snapshot */
C
Chris Mason 已提交
2283 2284 2285
	trans = btrfs_start_transaction(root, 1);
	btrfs_commit_transaction(trans, root);
	ret = btrfs_write_and_wait_transaction(NULL, root);
2286
	BUG_ON(ret);
2287

Y
Yan Zheng 已提交
2288
	ret = write_ctree_super(NULL, root, 0);
Y
Yan Zheng 已提交
2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304
	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 已提交
2305 2306
		if (ret)
			printk(KERN_ERR "btrfs: commit super ret %d\n", ret);
Y
Yan Zheng 已提交
2307
	}
2308

C
Chris Mason 已提交
2309
	if (fs_info->delalloc_bytes) {
C
Chris Mason 已提交
2310
		printk(KERN_INFO "btrfs: at unmount delalloc count %llu\n",
2311
		       (unsigned long long)fs_info->delalloc_bytes);
C
Chris Mason 已提交
2312
	}
Y
Yan Zheng 已提交
2313
	if (fs_info->total_ref_cache_size) {
C
Chris Mason 已提交
2314 2315
		printk(KERN_INFO "btrfs: at umount reference cache size %llu\n",
		       (unsigned long long)fs_info->total_ref_cache_size);
Y
Yan Zheng 已提交
2316
	}
2317

2318 2319 2320 2321 2322 2323 2324 2325 2326 2327
	free_extent_buffer(fs_info->extent_root->node);
	free_extent_buffer(fs_info->extent_root->commit_root);
	free_extent_buffer(fs_info->tree_root->node);
	free_extent_buffer(fs_info->tree_root->commit_root);
	free_extent_buffer(root->fs_info->chunk_root->node);
	free_extent_buffer(root->fs_info->chunk_root->commit_root);
	free_extent_buffer(root->fs_info->dev_root->node);
	free_extent_buffer(root->fs_info->dev_root->commit_root);
	free_extent_buffer(root->fs_info->csum_root->node);
	free_extent_buffer(root->fs_info->csum_root->commit_root);
2328

C
Chris Mason 已提交
2329
	btrfs_free_block_groups(root->fs_info);
2330

Y
Yan Zheng 已提交
2331
	del_fs_roots(fs_info);
2332

Y
Yan Zheng 已提交
2333
	iput(fs_info->btree_inode);
2334

2335
	btrfs_stop_workers(&fs_info->fixup_workers);
2336
	btrfs_stop_workers(&fs_info->delalloc_workers);
2337 2338
	btrfs_stop_workers(&fs_info->workers);
	btrfs_stop_workers(&fs_info->endio_workers);
2339
	btrfs_stop_workers(&fs_info->endio_meta_workers);
2340
	btrfs_stop_workers(&fs_info->endio_meta_write_workers);
2341
	btrfs_stop_workers(&fs_info->endio_write_workers);
2342
	btrfs_stop_workers(&fs_info->submit_workers);
2343

2344
	btrfs_close_devices(fs_info->fs_devices);
2345
	btrfs_mapping_tree_free(&fs_info->mapping_tree);
2346

C
Chris Mason 已提交
2347
	bdi_destroy(&fs_info->bdi);
2348

2349 2350
	kfree(fs_info->extent_root);
	kfree(fs_info->tree_root);
2351 2352
	kfree(fs_info->chunk_root);
	kfree(fs_info->dev_root);
2353
	kfree(fs_info->csum_root);
2354 2355 2356
	return 0;
}

2357
int btrfs_buffer_uptodate(struct extent_buffer *buf, u64 parent_transid)
2358
{
2359
	int ret;
2360
	struct inode *btree_inode = buf->first_page->mapping->host;
2361 2362 2363 2364 2365 2366 2367 2368

	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;
2369 2370 2371
}

int btrfs_set_buffer_uptodate(struct extent_buffer *buf)
C
Chris Mason 已提交
2372
{
2373
	struct inode *btree_inode = buf->first_page->mapping->host;
2374
	return set_extent_buffer_uptodate(&BTRFS_I(btree_inode)->io_tree,
2375 2376
					  buf);
}
2377

2378 2379
void btrfs_mark_buffer_dirty(struct extent_buffer *buf)
{
2380
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
2381 2382
	u64 transid = btrfs_header_generation(buf);
	struct inode *btree_inode = root->fs_info->btree_inode;
2383
	int was_dirty;
2384

2385
	btrfs_assert_tree_locked(buf);
C
Chris Mason 已提交
2386
	if (transid != root->fs_info->generation) {
C
Chris Mason 已提交
2387 2388
		printk(KERN_CRIT "btrfs transid mismatch buffer %llu, "
		       "found %llu running %llu\n",
2389
			(unsigned long long)buf->start,
C
Chris Mason 已提交
2390 2391
			(unsigned long long)transid,
			(unsigned long long)root->fs_info->generation);
C
Chris Mason 已提交
2392 2393
		WARN_ON(1);
	}
2394 2395 2396 2397 2398 2399 2400
	was_dirty = set_extent_buffer_dirty(&BTRFS_I(btree_inode)->io_tree,
					    buf);
	if (!was_dirty) {
		spin_lock(&root->fs_info->delalloc_lock);
		root->fs_info->dirty_metadata_bytes += buf->len;
		spin_unlock(&root->fs_info->delalloc_lock);
	}
2401 2402
}

2403
void btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr)
C
Chris Mason 已提交
2404
{
2405 2406 2407 2408
	/*
	 * looks as though older kernels can get into trouble with
	 * this code, they end up stuck in balance_dirty_pages forever
	 */
2409
	u64 num_dirty;
2410
	unsigned long thresh = 32 * 1024 * 1024;
2411

2412
	if (current->flags & PF_MEMALLOC)
2413 2414
		return;

2415 2416
	num_dirty = root->fs_info->dirty_metadata_bytes;

2417 2418
	if (num_dirty > thresh) {
		balance_dirty_pages_ratelimited_nr(
C
Chris Mason 已提交
2419
				   root->fs_info->btree_inode->i_mapping, 1);
2420
	}
2421
	return;
C
Chris Mason 已提交
2422
}
2423

2424
int btrfs_read_buffer(struct extent_buffer *buf, u64 parent_transid)
2425
{
2426
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
2427
	int ret;
2428
	ret = btree_read_extent_buffer_pages(root, buf, 0, parent_transid);
C
Chris Mason 已提交
2429
	if (ret == 0)
2430
		set_bit(EXTENT_BUFFER_UPTODATE, &buf->bflags);
2431
	return ret;
2432
}
2433

C
Chris Mason 已提交
2434 2435 2436
int btree_lock_page_hook(struct page *page)
{
	struct inode *inode = page->mapping->host;
2437
	struct btrfs_root *root = BTRFS_I(inode)->root;
C
Chris Mason 已提交
2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452
	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);
2453 2454 2455 2456 2457 2458 2459 2460 2461 2462

	if (test_and_clear_bit(EXTENT_BUFFER_DIRTY, &eb->bflags)) {
		spin_lock(&root->fs_info->delalloc_lock);
		if (root->fs_info->dirty_metadata_bytes >= eb->len)
			root->fs_info->dirty_metadata_bytes -= eb->len;
		else
			WARN_ON(1);
		spin_unlock(&root->fs_info->delalloc_lock);
	}

C
Chris Mason 已提交
2463 2464 2465 2466 2467 2468 2469
	btrfs_tree_unlock(eb);
	free_extent_buffer(eb);
out:
	lock_page(page);
	return 0;
}

2470
static struct extent_io_ops btree_extent_io_ops = {
C
Chris Mason 已提交
2471
	.write_cache_pages_lock_hook = btree_lock_page_hook,
2472
	.readpage_end_io_hook = btree_readpage_end_io_hook,
2473
	.submit_bio_hook = btree_submit_bio_hook,
2474 2475
	/* note we're sharing with inode.c for the merge bio hook */
	.merge_bio_hook = btrfs_merge_bio_hook,
2476
};