disk-io.c 65.2 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
	struct extent_io_tree *tree;
671 672 673 674
	struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
	struct extent_buffer *eb;
	int was_dirty;

675
	tree = &BTRFS_I(page->mapping->host)->io_tree;
676 677 678 679
	if (!(current->flags & PF_MEMALLOC)) {
		return extent_write_full_page(tree, page,
					      btree_get_extent, wbc);
	}
680

681 682 683 684 685 686 687 688 689 690
	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);
691
	}
692 693 694 695
	free_extent_buffer(eb);

	unlock_page(page);
	return 0;
696
}
697 698 699 700

static int btree_writepages(struct address_space *mapping,
			    struct writeback_control *wbc)
{
701 702
	struct extent_io_tree *tree;
	tree = &BTRFS_I(mapping->host)->io_tree;
703
	if (wbc->sync_mode == WB_SYNC_NONE) {
704
		struct btrfs_root *root = BTRFS_I(mapping->host)->root;
705
		u64 num_dirty;
706
		unsigned long thresh = 32 * 1024 * 1024;
707 708 709 710

		if (wbc->for_kupdate)
			return 0;

711 712
		/* this is a bit racy, but that's ok */
		num_dirty = root->fs_info->dirty_metadata_bytes;
C
Chris Mason 已提交
713
		if (num_dirty < thresh)
714 715
			return 0;
	}
716 717 718
	return extent_writepages(tree, mapping, btree_get_extent, wbc);
}

719
static int btree_readpage(struct file *file, struct page *page)
720
{
721 722
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
723 724
	return extent_read_full_page(tree, page, btree_get_extent);
}
C
Chris Mason 已提交
725

726
static int btree_releasepage(struct page *page, gfp_t gfp_flags)
727
{
728 729
	struct extent_io_tree *tree;
	struct extent_map_tree *map;
730
	int ret;
731

732
	if (PageWriteback(page) || PageDirty(page))
C
Chris Mason 已提交
733
		return 0;
734

735 736
	tree = &BTRFS_I(page->mapping->host)->io_tree;
	map = &BTRFS_I(page->mapping->host)->extent_tree;
737

738
	ret = try_release_extent_state(map, tree, page, gfp_flags);
C
Chris Mason 已提交
739
	if (!ret)
740 741 742
		return 0;

	ret = try_release_extent_buffer(tree, page);
743 744 745 746 747
	if (ret == 1) {
		ClearPagePrivate(page);
		set_page_private(page, 0);
		page_cache_release(page);
	}
748

749 750 751
	return ret;
}

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

767
#if 0
768
static int btree_writepage(struct page *page, struct writeback_control *wbc)
769
{
C
Chris Mason 已提交
770
	struct buffer_head *bh;
771
	struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
C
Chris Mason 已提交
772 773 774 775 776 777 778 779 780 781 782 783
	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);
784
	return block_write_full_page(page, btree_get_block, wbc);
785
}
786
#endif
787

788 789 790
static struct address_space_operations btree_aops = {
	.readpage	= btree_readpage,
	.writepage	= btree_writepage,
791
	.writepages	= btree_writepages,
792 793
	.releasepage	= btree_releasepage,
	.invalidatepage = btree_invalidatepage,
794 795 796
	.sync_page	= block_sync_page,
};

797 798
int readahead_tree_block(struct btrfs_root *root, u64 bytenr, u32 blocksize,
			 u64 parent_transid)
C
Chris Mason 已提交
799
{
800 801
	struct extent_buffer *buf = NULL;
	struct inode *btree_inode = root->fs_info->btree_inode;
802
	int ret = 0;
C
Chris Mason 已提交
803

804
	buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
805
	if (!buf)
C
Chris Mason 已提交
806
		return 0;
807
	read_extent_buffer_pages(&BTRFS_I(btree_inode)->io_tree,
808
				 buf, 0, 0, btree_get_extent, 0);
809
	free_extent_buffer(buf);
810
	return ret;
C
Chris Mason 已提交
811 812
}

813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834
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;
}


835 836 837
int btrfs_write_tree_block(struct extent_buffer *buf)
{
	return btrfs_fdatawrite_range(buf->first_page->mapping, buf->start,
838
				      buf->start + buf->len - 1, WB_SYNC_ALL);
839 840 841 842 843
}

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

847
struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 bytenr,
848
				      u32 blocksize, u64 parent_transid)
849 850 851 852 853 854 855 856 857 858 859 860
{
	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;

861
	ret = btree_read_extent_buffer_pages(root, buf, 0, parent_transid);
862

C
Chris Mason 已提交
863
	if (ret == 0)
864
		set_bit(EXTENT_BUFFER_UPTODATE, &buf->bflags);
C
Chris Mason 已提交
865
	else
866
		WARN_ON(1);
867
	return buf;
868

869 870
}

871
int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
872
		     struct extent_buffer *buf)
873
{
874
	struct inode *btree_inode = root->fs_info->btree_inode;
875
	if (btrfs_header_generation(buf) ==
876
	    root->fs_info->running_transaction->transid) {
877
		btrfs_assert_tree_locked(buf);
878

879 880 881 882 883 884 885 886
		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);
		}
887

888 889
		/* ugh, clear_extent_buffer_dirty needs to lock the page */
		btrfs_set_lock_blocking(buf);
890
		clear_extent_buffer_dirty(&BTRFS_I(btree_inode)->io_tree,
891
					  buf);
892
	}
893 894 895
	return 0;
}

896
static int __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize,
897
			u32 stripesize, struct btrfs_root *root,
898
			struct btrfs_fs_info *fs_info,
C
Chris Mason 已提交
899
			u64 objectid)
900
{
C
Chris Mason 已提交
901
	root->node = NULL;
902
	root->commit_root = NULL;
Y
Yan Zheng 已提交
903
	root->ref_tree = NULL;
904 905 906
	root->sectorsize = sectorsize;
	root->nodesize = nodesize;
	root->leafsize = leafsize;
907
	root->stripesize = stripesize;
C
Chris Mason 已提交
908
	root->ref_cows = 0;
909 910
	root->track_dirty = 0;

911
	root->fs_info = fs_info;
912 913
	root->objectid = objectid;
	root->last_trans = 0;
C
Chris Mason 已提交
914 915
	root->highest_inode = 0;
	root->last_inode_alloc = 0;
916
	root->name = NULL;
917
	root->in_sysfs = 0;
918 919

	INIT_LIST_HEAD(&root->dirty_list);
920
	INIT_LIST_HEAD(&root->orphan_list);
921
	INIT_LIST_HEAD(&root->dead_list);
922
	spin_lock_init(&root->node_lock);
923
	spin_lock_init(&root->list_lock);
924
	mutex_init(&root->objectid_mutex);
925
	mutex_init(&root->log_mutex);
Y
Yan Zheng 已提交
926 927 928 929 930 931 932 933
	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;
934 935
	extent_io_tree_init(&root->dirty_log_pages,
			     fs_info->btree_inode->i_mapping, GFP_NOFS);
C
Chris Mason 已提交
936 937 938 939

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

940 941
	memset(&root->root_key, 0, sizeof(root->root_key));
	memset(&root->root_item, 0, sizeof(root->root_item));
942
	memset(&root->defrag_progress, 0, sizeof(root->defrag_progress));
943
	memset(&root->root_kobj, 0, sizeof(root->root_kobj));
944
	root->defrag_trans_start = fs_info->generation;
945
	init_completion(&root->kobj_unregister);
946 947
	root->defrag_running = 0;
	root->defrag_level = 0;
948
	root->root_key.objectid = objectid;
949 950 951 952 953 954
	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);

955 956 957
	return 0;
}

958
static int find_and_setup_root(struct btrfs_root *tree_root,
959 960
			       struct btrfs_fs_info *fs_info,
			       u64 objectid,
C
Chris Mason 已提交
961
			       struct btrfs_root *root)
962 963
{
	int ret;
964
	u32 blocksize;
965
	u64 generation;
966

967
	__setup_root(tree_root->nodesize, tree_root->leafsize,
968 969
		     tree_root->sectorsize, tree_root->stripesize,
		     root, fs_info, objectid);
970 971 972 973
	ret = btrfs_find_last_root(tree_root, objectid,
				   &root->root_item, &root->root_key);
	BUG_ON(ret);

974
	generation = btrfs_root_generation(&root->root_item);
975 976
	blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
	root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
977
				     blocksize, generation);
978
	BUG_ON(!root->node);
979 980 981
	return 0;
}

982 983 984 985
int btrfs_free_log_root_tree(struct btrfs_trans_handle *trans,
			     struct btrfs_fs_info *fs_info)
{
	struct extent_buffer *eb;
986 987 988
	struct btrfs_root *log_root_tree = fs_info->log_root_tree;
	u64 start = 0;
	u64 end = 0;
989 990
	int ret;

991
	if (!log_root_tree)
992 993
		return 0;

C
Chris Mason 已提交
994
	while (1) {
995 996 997 998 999 1000 1001 1002
		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);
	}
1003 1004 1005 1006 1007
	eb = fs_info->log_root_tree->node;

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

1008 1009
	ret = btrfs_free_reserved_extent(fs_info->tree_root,
				eb->start, eb->len);
1010 1011 1012 1013 1014 1015 1016 1017
	BUG_ON(ret);

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

Y
Yan Zheng 已提交
1018 1019
static struct btrfs_root *alloc_log_tree(struct btrfs_trans_handle *trans,
					 struct btrfs_fs_info *fs_info)
1020 1021 1022
{
	struct btrfs_root *root;
	struct btrfs_root *tree_root = fs_info->tree_root;
Y
Yan Zheng 已提交
1023
	struct extent_buffer *leaf;
1024 1025 1026

	root = kzalloc(sizeof(*root), GFP_NOFS);
	if (!root)
Y
Yan Zheng 已提交
1027
		return ERR_PTR(-ENOMEM);
1028 1029 1030 1031 1032 1033 1034 1035

	__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 已提交
1036 1037 1038 1039 1040 1041
	/*
	 * 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).
	 */
1042 1043
	root->ref_cows = 0;

Y
Yan Zheng 已提交
1044 1045 1046 1047 1048 1049 1050
	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);
	}
1051

Y
Yan Zheng 已提交
1052
	root->node = leaf;
1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063
	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 已提交
1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105
	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;
1106 1107 1108 1109 1110 1111 1112 1113
	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;
1114
	struct btrfs_path *path;
1115
	struct extent_buffer *l;
C
Chris Mason 已提交
1116
	u64 highest_inode;
1117
	u64 generation;
1118
	u32 blocksize;
1119 1120
	int ret = 0;

1121
	root = kzalloc(sizeof(*root), GFP_NOFS);
C
Chris Mason 已提交
1122
	if (!root)
1123 1124
		return ERR_PTR(-ENOMEM);
	if (location->offset == (u64)-1) {
1125
		ret = find_and_setup_root(tree_root, fs_info,
1126 1127 1128 1129 1130 1131 1132 1133
					  location->objectid, root);
		if (ret) {
			kfree(root);
			return ERR_PTR(ret);
		}
		goto insert;
	}

1134
	__setup_root(tree_root->nodesize, tree_root->leafsize,
1135 1136
		     tree_root->sectorsize, tree_root->stripesize,
		     root, fs_info, location->objectid);
1137 1138 1139 1140 1141 1142 1143 1144 1145

	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;
	}
1146 1147 1148
	l = path->nodes[0];
	read_extent_buffer(l, &root->root_item,
	       btrfs_item_ptr_offset(l, path->slots[0]),
1149
	       sizeof(root->root_item));
1150
	memcpy(&root->root_key, location, sizeof(*location));
1151 1152 1153 1154 1155 1156 1157 1158
	ret = 0;
out:
	btrfs_release_path(root, path);
	btrfs_free_path(path);
	if (ret) {
		kfree(root);
		return ERR_PTR(ret);
	}
1159
	generation = btrfs_root_generation(&root->root_item);
1160 1161
	blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
	root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
1162
				     blocksize, generation);
1163 1164
	BUG_ON(!root->node);
insert:
1165 1166 1167 1168 1169 1170 1171
	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;
		}
1172 1173 1174 1175
	}
	return root;
}

C
Chris Mason 已提交
1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190
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;
}

1191 1192
struct btrfs_root *btrfs_read_fs_root_no_name(struct btrfs_fs_info *fs_info,
					      struct btrfs_key *location)
1193 1194 1195 1196
{
	struct btrfs_root *root;
	int ret;

1197 1198 1199 1200
	if (location->objectid == BTRFS_ROOT_TREE_OBJECTID)
		return fs_info->tree_root;
	if (location->objectid == BTRFS_EXTENT_TREE_OBJECTID)
		return fs_info->extent_root;
1201 1202 1203 1204
	if (location->objectid == BTRFS_CHUNK_TREE_OBJECTID)
		return fs_info->chunk_root;
	if (location->objectid == BTRFS_DEV_TREE_OBJECTID)
		return fs_info->dev_root;
1205 1206
	if (location->objectid == BTRFS_CSUM_TREE_OBJECTID)
		return fs_info->csum_root;
1207

1208 1209 1210 1211 1212
	root = radix_tree_lookup(&fs_info->fs_roots_radix,
				 (unsigned long)location->objectid);
	if (root)
		return root;

1213
	root = btrfs_read_fs_root_no_radix(fs_info->tree_root, location);
1214 1215
	if (IS_ERR(root))
		return root;
1216 1217 1218

	set_anon_super(&root->anon_super, NULL);

C
Chris Mason 已提交
1219 1220
	ret = radix_tree_insert(&fs_info->fs_roots_radix,
				(unsigned long)root->root_key.objectid,
1221 1222
				root);
	if (ret) {
1223
		free_extent_buffer(root->node);
1224 1225 1226
		kfree(root);
		return ERR_PTR(ret);
	}
Y
Yan Zheng 已提交
1227 1228 1229 1230 1231 1232
	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);
	}
1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245
	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;
1246

1247 1248 1249
	if (root->in_sysfs)
		return root;

1250 1251
	ret = btrfs_set_root_name(root, name, namelen);
	if (ret) {
1252
		free_extent_buffer(root->node);
1253 1254 1255
		kfree(root);
		return ERR_PTR(ret);
	}
1256
#if 0
1257 1258
	ret = btrfs_sysfs_add_root(root);
	if (ret) {
1259
		free_extent_buffer(root->node);
1260 1261 1262 1263
		kfree(root->name);
		kfree(root);
		return ERR_PTR(ret);
	}
1264
#endif
1265
	root->in_sysfs = 1;
1266 1267
	return root;
}
C
Chris Mason 已提交
1268 1269 1270 1271 1272 1273 1274

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;
1275
#if 0
1276
	if ((bdi_bits & (1 << BDI_write_congested)) &&
1277
	    btrfs_congested_async(info, 0))
1278
		return 1;
1279
#endif
Q
Qinghuang Feng 已提交
1280
	list_for_each_entry(device, &info->fs_devices->devices, dev_list) {
1281 1282
		if (!device->bdev)
			continue;
C
Chris Mason 已提交
1283 1284 1285 1286 1287 1288 1289 1290 1291
		bdi = blk_get_backing_dev_info(device->bdev);
		if (bdi && bdi_congested(bdi, bdi_bits)) {
			ret = 1;
			break;
		}
	}
	return ret;
}

1292 1293 1294 1295 1296 1297 1298 1299 1300 1301
/*
 * 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 已提交
1302
	list_for_each_entry(device, &info->fs_devices->devices, dev_list) {
1303 1304 1305
		if (!device->bdev)
			continue;

1306
		bdi = blk_get_backing_dev_info(device->bdev);
C
Chris Mason 已提交
1307
		if (bdi->unplug_io_fn)
1308 1309 1310 1311
			bdi->unplug_io_fn(bdi, page);
	}
}

1312
static void btrfs_unplug_io_fn(struct backing_dev_info *bdi, struct page *page)
C
Chris Mason 已提交
1313
{
1314
	struct inode *inode;
1315 1316
	struct extent_map_tree *em_tree;
	struct extent_map *em;
1317
	struct address_space *mapping;
1318 1319
	u64 offset;

1320
	/* the generic O_DIRECT read code does this */
1321
	if (1 || !page) {
1322 1323 1324 1325
		__unplug_io_fn(bdi, page);
		return;
	}

1326 1327 1328 1329 1330 1331 1332 1333 1334 1335
	/*
	 * 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;
1336 1337 1338 1339 1340 1341 1342 1343 1344 1345

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

1346
	offset = page_offset(page);
C
Chris Mason 已提交
1347

1348 1349 1350 1351
	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);
1352 1353
	if (!em) {
		__unplug_io_fn(bdi, page);
1354
		return;
1355
	}
1356

1357 1358 1359 1360 1361
	if (em->block_start >= EXTENT_MAP_LAST_BYTE) {
		free_extent_map(em);
		__unplug_io_fn(bdi, page);
		return;
	}
1362 1363 1364 1365
	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 已提交
1366 1367 1368 1369 1370
}

static int setup_bdi(struct btrfs_fs_info *info, struct backing_dev_info *bdi)
{
	bdi_init(bdi);
1371
	bdi->ra_pages	= default_backing_dev_info.ra_pages;
C
Chris Mason 已提交
1372 1373 1374 1375 1376 1377 1378 1379 1380
	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;
}

1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419
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;
}

1420 1421 1422 1423 1424
/*
 * 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)
1425 1426
{
	struct bio *bio;
1427 1428
	struct end_io_wq *end_io_wq;
	struct btrfs_fs_info *fs_info;
1429 1430
	int error;

1431 1432 1433
	end_io_wq = container_of(work, struct end_io_wq, work);
	bio = end_io_wq->bio;
	fs_info = end_io_wq->info;
1434

1435
	/* metadata bio reads are special because the whole tree block must
1436 1437 1438 1439
	 * 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
	 */
1440 1441
	if (!(bio->bi_rw & (1 << BIO_RW)) && end_io_wq->metadata &&
	    !bio_ready_for_csum(bio)) {
1442
		btrfs_queue_worker(&fs_info->endio_meta_workers,
1443 1444 1445 1446 1447 1448 1449 1450
				   &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);
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 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504
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 已提交
1505

1506 1507 1508 1509 1510 1511 1512 1513 1514
		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);
1515

1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532
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;
}

1533
struct btrfs_root *open_ctree(struct super_block *sb,
1534 1535
			      struct btrfs_fs_devices *fs_devices,
			      char *options)
1536
{
1537 1538 1539 1540
	u32 sectorsize;
	u32 nodesize;
	u32 leafsize;
	u32 blocksize;
1541
	u32 stripesize;
1542
	u64 generation;
1543
	u64 features;
1544
	struct btrfs_key location;
1545
	struct buffer_head *bh;
1546
	struct btrfs_root *extent_root = kzalloc(sizeof(struct btrfs_root),
C
Chris Mason 已提交
1547
						 GFP_NOFS);
1548 1549
	struct btrfs_root *csum_root = kzalloc(sizeof(struct btrfs_root),
						 GFP_NOFS);
1550
	struct btrfs_root *tree_root = kzalloc(sizeof(struct btrfs_root),
C
Chris Mason 已提交
1551
					       GFP_NOFS);
1552
	struct btrfs_fs_info *fs_info = kzalloc(sizeof(*fs_info),
C
Chris Mason 已提交
1553
						GFP_NOFS);
1554
	struct btrfs_root *chunk_root = kzalloc(sizeof(struct btrfs_root),
1555
						GFP_NOFS);
1556
	struct btrfs_root *dev_root = kzalloc(sizeof(struct btrfs_root),
1557
					      GFP_NOFS);
1558 1559
	struct btrfs_root *log_tree_root;

1560
	int ret;
1561
	int err = -EINVAL;
1562

C
Chris Mason 已提交
1563
	struct btrfs_super_block *disk_super;
1564

1565
	if (!extent_root || !tree_root || !fs_info ||
1566
	    !chunk_root || !dev_root || !csum_root) {
C
Chris Mason 已提交
1567 1568 1569
		err = -ENOMEM;
		goto fail;
	}
1570
	INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_NOFS);
C
Chris Mason 已提交
1571
	INIT_LIST_HEAD(&fs_info->trans_list);
1572
	INIT_LIST_HEAD(&fs_info->dead_roots);
1573
	INIT_LIST_HEAD(&fs_info->hashers);
1574
	INIT_LIST_HEAD(&fs_info->delalloc_inodes);
1575
	spin_lock_init(&fs_info->delalloc_lock);
1576
	spin_lock_init(&fs_info->new_trans_lock);
Y
Yan Zheng 已提交
1577
	spin_lock_init(&fs_info->ref_cache_lock);
1578

1579
	init_completion(&fs_info->kobj_unregister);
1580 1581
	fs_info->tree_root = tree_root;
	fs_info->extent_root = extent_root;
1582
	fs_info->csum_root = csum_root;
1583 1584
	fs_info->chunk_root = chunk_root;
	fs_info->dev_root = dev_root;
1585
	fs_info->fs_devices = fs_devices;
1586
	INIT_LIST_HEAD(&fs_info->dirty_cowonly_roots);
1587
	INIT_LIST_HEAD(&fs_info->space_info);
1588
	btrfs_mapping_init(&fs_info->mapping_tree);
1589
	atomic_set(&fs_info->nr_async_submits, 0);
1590
	atomic_set(&fs_info->async_delalloc_pages, 0);
1591
	atomic_set(&fs_info->async_submit_draining, 0);
1592
	atomic_set(&fs_info->nr_async_bios, 0);
1593
	atomic_set(&fs_info->throttles, 0);
1594
	atomic_set(&fs_info->throttle_gen, 0);
C
Chris Mason 已提交
1595
	fs_info->sb = sb;
1596
	fs_info->max_extent = (u64)-1;
1597
	fs_info->max_inline = 8192 * 1024;
C
Chris Mason 已提交
1598
	setup_bdi(fs_info, &fs_info->bdi);
1599 1600
	fs_info->btree_inode = new_inode(sb);
	fs_info->btree_inode->i_ino = 1;
C
Chris Mason 已提交
1601
	fs_info->btree_inode->i_nlink = 1;
C
Chris Mason 已提交
1602

1603 1604
	fs_info->thread_pool_size = min_t(unsigned long,
					  num_online_cpus() + 2, 8);
1605

1606 1607 1608
	INIT_LIST_HEAD(&fs_info->ordered_extents);
	spin_lock_init(&fs_info->ordered_extent_lock);

1609 1610 1611
	sb->s_blocksize = 4096;
	sb->s_blocksize_bits = blksize_bits(4096);

1612 1613 1614 1615 1616 1617
	/*
	 * 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;
1618
	fs_info->btree_inode->i_mapping->a_ops = &btree_aops;
C
Chris Mason 已提交
1619 1620
	fs_info->btree_inode->i_mapping->backing_dev_info = &fs_info->bdi;

1621
	extent_io_tree_init(&BTRFS_I(fs_info->btree_inode)->io_tree,
1622 1623
			     fs_info->btree_inode->i_mapping,
			     GFP_NOFS);
1624 1625 1626 1627
	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;
1628

J
Josef Bacik 已提交
1629 1630 1631
	spin_lock_init(&fs_info->block_group_cache_lock);
	fs_info->block_group_cache_tree.rb_node = NULL;

1632
	extent_io_tree_init(&fs_info->pinned_extents,
1633
			     fs_info->btree_inode->i_mapping, GFP_NOFS);
1634
	fs_info->do_barriers = 1;
1635

Z
Zheng Yan 已提交
1636 1637
	INIT_LIST_HEAD(&fs_info->dead_reloc_roots);
	btrfs_leaf_ref_tree_init(&fs_info->reloc_ref_tree);
Z
Zheng Yan 已提交
1638 1639
	btrfs_leaf_ref_tree_init(&fs_info->shared_ref_tree);

1640 1641 1642
	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 已提交
1643
	insert_inode_hash(fs_info->btree_inode);
C
Chris Mason 已提交
1644

C
Chris Mason 已提交
1645
	mutex_init(&fs_info->trans_mutex);
1646
	mutex_init(&fs_info->tree_log_mutex);
1647
	mutex_init(&fs_info->drop_mutex);
1648
	mutex_init(&fs_info->pinned_mutex);
1649
	mutex_init(&fs_info->chunk_mutex);
1650 1651
	mutex_init(&fs_info->transaction_kthread_mutex);
	mutex_init(&fs_info->cleaner_mutex);
1652
	mutex_init(&fs_info->volume_mutex);
Z
Zheng Yan 已提交
1653
	mutex_init(&fs_info->tree_reloc_mutex);
1654
	init_waitqueue_head(&fs_info->transaction_throttle);
1655
	init_waitqueue_head(&fs_info->transaction_wait);
1656
	init_waitqueue_head(&fs_info->async_submit_wait);
1657

1658
	__setup_root(4096, 4096, 4096, 4096, tree_root,
C
Chris Mason 已提交
1659
		     fs_info, BTRFS_ROOT_TREE_OBJECTID);
1660

1661

Y
Yan Zheng 已提交
1662
	bh = btrfs_read_dev_super(fs_devices->latest_bdev);
1663
	if (!bh)
C
Chris Mason 已提交
1664 1665
		goto fail_iput;

1666
	memcpy(&fs_info->super_copy, bh->b_data, sizeof(fs_info->super_copy));
1667 1668
	memcpy(&fs_info->super_for_commit, &fs_info->super_copy,
	       sizeof(fs_info->super_for_commit));
1669
	brelse(bh);
1670

1671
	memcpy(fs_info->fsid, fs_info->super_copy.fsid, BTRFS_FSID_SIZE);
1672

1673
	disk_super = &fs_info->super_copy;
1674
	if (!btrfs_super_root(disk_super))
1675
		goto fail_iput;
1676

Y
Yan Zheng 已提交
1677 1678 1679
	ret = btrfs_parse_options(tree_root, options);
	if (ret) {
		err = ret;
1680
		goto fail_iput;
Y
Yan Zheng 已提交
1681
	}
1682

1683 1684 1685 1686 1687 1688 1689
	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;
1690
		goto fail_iput;
1691 1692 1693 1694 1695 1696 1697 1698 1699
	}

	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;
1700
		goto fail_iput;
1701 1702
	}

1703 1704 1705 1706 1707
	/*
	 * 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.
	 */
1708 1709
	btrfs_init_workers(&fs_info->workers, "worker",
			   fs_info->thread_pool_size);
C
Chris Mason 已提交
1710

1711 1712 1713
	btrfs_init_workers(&fs_info->delalloc_workers, "delalloc",
			   fs_info->thread_pool_size);

1714
	btrfs_init_workers(&fs_info->submit_workers, "submit",
1715 1716
			   min_t(u64, fs_devices->num_devices,
			   fs_info->thread_pool_size));
1717 1718 1719 1720 1721 1722

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

1724
	fs_info->workers.idle_thresh = 16;
C
Chris Mason 已提交
1725
	fs_info->workers.ordered = 1;
1726

1727 1728 1729
	fs_info->delalloc_workers.idle_thresh = 2;
	fs_info->delalloc_workers.ordered = 1;

1730 1731 1732
	btrfs_init_workers(&fs_info->fixup_workers, "fixup", 1);
	btrfs_init_workers(&fs_info->endio_workers, "endio",
			   fs_info->thread_pool_size);
1733 1734
	btrfs_init_workers(&fs_info->endio_meta_workers, "endio-meta",
			   fs_info->thread_pool_size);
1735 1736
	btrfs_init_workers(&fs_info->endio_meta_write_workers,
			   "endio-meta-write", fs_info->thread_pool_size);
1737
	btrfs_init_workers(&fs_info->endio_write_workers, "endio-write",
1738
			   fs_info->thread_pool_size);
1739 1740 1741 1742 1743 1744

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

1747
	fs_info->endio_write_workers.idle_thresh = 64;
1748
	fs_info->endio_meta_write_workers.idle_thresh = 64;
1749

1750
	btrfs_start_workers(&fs_info->workers, 1);
1751
	btrfs_start_workers(&fs_info->submit_workers, 1);
1752
	btrfs_start_workers(&fs_info->delalloc_workers, 1);
1753
	btrfs_start_workers(&fs_info->fixup_workers, 1);
1754
	btrfs_start_workers(&fs_info->endio_workers, fs_info->thread_pool_size);
1755 1756
	btrfs_start_workers(&fs_info->endio_meta_workers,
			    fs_info->thread_pool_size);
1757 1758
	btrfs_start_workers(&fs_info->endio_meta_write_workers,
			    fs_info->thread_pool_size);
1759 1760
	btrfs_start_workers(&fs_info->endio_write_workers,
			    fs_info->thread_pool_size);
1761

1762
	fs_info->bdi.ra_pages *= btrfs_super_num_devices(disk_super);
C
Chris Mason 已提交
1763 1764
	fs_info->bdi.ra_pages = max(fs_info->bdi.ra_pages,
				    4 * 1024 * 1024 / PAGE_CACHE_SIZE);
1765

1766 1767 1768
	nodesize = btrfs_super_nodesize(disk_super);
	leafsize = btrfs_super_leafsize(disk_super);
	sectorsize = btrfs_super_sectorsize(disk_super);
1769
	stripesize = btrfs_super_stripesize(disk_super);
1770 1771 1772
	tree_root->nodesize = nodesize;
	tree_root->leafsize = leafsize;
	tree_root->sectorsize = sectorsize;
1773
	tree_root->stripesize = stripesize;
1774 1775 1776

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

C
Chris Mason 已提交
1778 1779
	if (strncmp((char *)(&disk_super->magic), BTRFS_MAGIC,
		    sizeof(disk_super->magic))) {
C
Chris Mason 已提交
1780
		printk(KERN_INFO "btrfs: valid FS not found on %s\n", sb->s_id);
C
Chris Mason 已提交
1781 1782
		goto fail_sb_buffer;
	}
1783

1784
	mutex_lock(&fs_info->chunk_mutex);
Y
Yan Zheng 已提交
1785
	ret = btrfs_read_sys_array(tree_root);
1786
	mutex_unlock(&fs_info->chunk_mutex);
1787
	if (ret) {
C
Chris Mason 已提交
1788 1789
		printk(KERN_WARNING "btrfs: failed to read the system "
		       "array on %s\n", sb->s_id);
1790 1791
		goto fail_sys_array;
	}
1792 1793 1794

	blocksize = btrfs_level_size(tree_root,
				     btrfs_super_chunk_root_level(disk_super));
1795
	generation = btrfs_super_chunk_root_generation(disk_super);
1796 1797 1798 1799 1800 1801

	__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),
1802
					   blocksize, generation);
1803 1804
	BUG_ON(!chunk_root->node);

1805
	read_extent_buffer(chunk_root->node, fs_info->chunk_tree_uuid,
C
Chris Mason 已提交
1806 1807
	   (unsigned long)btrfs_header_chunk_tree_uuid(chunk_root->node),
	   BTRFS_UUID_SIZE);
1808

1809
	mutex_lock(&fs_info->chunk_mutex);
1810
	ret = btrfs_read_chunk_tree(chunk_root);
1811
	mutex_unlock(&fs_info->chunk_mutex);
Y
Yan Zheng 已提交
1812
	if (ret) {
C
Chris Mason 已提交
1813 1814
		printk(KERN_WARNING "btrfs: failed to read chunk tree on %s\n",
		       sb->s_id);
Y
Yan Zheng 已提交
1815 1816
		goto fail_chunk_root;
	}
1817

1818 1819
	btrfs_close_extra_devices(fs_devices);

1820 1821
	blocksize = btrfs_level_size(tree_root,
				     btrfs_super_root_level(disk_super));
1822
	generation = btrfs_super_generation(disk_super);
1823

C
Chris Mason 已提交
1824
	tree_root->node = read_tree_block(tree_root,
1825
					  btrfs_super_root(disk_super),
1826
					  blocksize, generation);
C
Chris Mason 已提交
1827
	if (!tree_root->node)
Y
Yan Zheng 已提交
1828
		goto fail_chunk_root;
1829

1830 1831

	ret = find_and_setup_root(tree_root, fs_info,
C
Chris Mason 已提交
1832
				  BTRFS_EXTENT_TREE_OBJECTID, extent_root);
1833
	if (ret)
C
Chris Mason 已提交
1834
		goto fail_tree_root;
1835 1836 1837 1838 1839 1840 1841
	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;
1842

1843 1844 1845 1846 1847 1848 1849
	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 已提交
1850 1851
	btrfs_read_block_groups(extent_root);

1852
	fs_info->generation = generation;
Y
Yan Zheng 已提交
1853
	fs_info->last_trans_committed = generation;
C
Chris Mason 已提交
1854 1855 1856
	fs_info->data_alloc_profile = (u64)-1;
	fs_info->metadata_alloc_profile = (u64)-1;
	fs_info->system_alloc_profile = fs_info->metadata_alloc_profile;
1857 1858
	fs_info->cleaner_kthread = kthread_run(cleaner_kthread, tree_root,
					       "btrfs-cleaner");
1859
	if (IS_ERR(fs_info->cleaner_kthread))
1860
		goto fail_csum_root;
1861 1862 1863 1864

	fs_info->transaction_kthread = kthread_run(transaction_kthread,
						   tree_root,
						   "btrfs-transaction");
1865
	if (IS_ERR(fs_info->transaction_kthread))
1866
		goto fail_cleaner;
1867

1868 1869 1870
	if (btrfs_super_log_root(disk_super) != 0) {
		u64 bytenr = btrfs_super_log_root(disk_super);

1871
		if (fs_devices->rw_devices == 0) {
C
Chris Mason 已提交
1872 1873
			printk(KERN_WARNING "Btrfs log replay required "
			       "on RO media\n");
1874 1875 1876
			err = -EIO;
			goto fail_trans_kthread;
		}
1877 1878 1879
		blocksize =
		     btrfs_level_size(tree_root,
				      btrfs_super_log_root_level(disk_super));
C
Chris Mason 已提交
1880

1881 1882 1883 1884 1885 1886 1887
		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,
1888 1889
						      blocksize,
						      generation + 1);
1890 1891
		ret = btrfs_recover_log_trees(log_tree_root);
		BUG_ON(ret);
1892 1893 1894 1895 1896

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

1899 1900 1901 1902
	if (!(sb->s_flags & MS_RDONLY)) {
		ret = btrfs_cleanup_reloc_trees(tree_root);
		BUG_ON(ret);
	}
Z
Zheng Yan 已提交
1903

1904 1905 1906 1907 1908 1909
	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)
1910
		goto fail_trans_kthread;
1911
	return tree_root;
C
Chris Mason 已提交
1912

1913 1914
fail_trans_kthread:
	kthread_stop(fs_info->transaction_kthread);
1915
fail_cleaner:
1916
	kthread_stop(fs_info->cleaner_kthread);
1917 1918 1919 1920 1921 1922 1923 1924

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

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

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

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

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

Y
Yan Zheng 已提交
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 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113
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)
2114 2115 2116
{
	struct list_head *head = &root->fs_info->fs_devices->devices;
	struct btrfs_device *dev;
2117
	struct btrfs_super_block *sb;
2118 2119 2120
	struct btrfs_dev_item *dev_item;
	int ret;
	int do_barriers;
2121 2122
	int max_errors;
	int total_errors = 0;
2123
	u64 flags;
2124

2125
	max_errors = btrfs_super_num_devices(&root->fs_info->super_copy) - 1;
2126 2127
	do_barriers = !btrfs_test_opt(root, NOBARRIER);

2128 2129
	sb = &root->fs_info->super_for_commit;
	dev_item = &sb->dev_item;
Q
Qinghuang Feng 已提交
2130
	list_for_each_entry(dev, head, dev_list) {
2131 2132 2133 2134
		if (!dev->bdev) {
			total_errors++;
			continue;
		}
Y
Yan Zheng 已提交
2135
		if (!dev->in_fs_metadata || !dev->writeable)
2136 2137
			continue;

Y
Yan Zheng 已提交
2138
		btrfs_set_stack_device_generation(dev_item, 0);
2139 2140 2141 2142 2143 2144 2145 2146
		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 已提交
2147
		memcpy(dev_item->fsid, dev->fs_devices->fsid, BTRFS_UUID_SIZE);
Y
Yan Zheng 已提交
2148

2149 2150 2151
		flags = btrfs_super_flags(sb);
		btrfs_set_super_flags(sb, flags | BTRFS_HEADER_FLAG_WRITTEN);

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

Y
Yan Zheng 已提交
2162
	total_errors = 0;
Q
Qinghuang Feng 已提交
2163
	list_for_each_entry(dev, head, dev_list) {
2164 2165
		if (!dev->bdev)
			continue;
Y
Yan Zheng 已提交
2166
		if (!dev->in_fs_metadata || !dev->writeable)
2167 2168
			continue;

Y
Yan Zheng 已提交
2169 2170 2171
		ret = write_dev_supers(dev, sb, do_barriers, 1, max_mirrors);
		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 2179 2180
	return 0;
}

Y
Yan Zheng 已提交
2181 2182
int write_ctree_super(struct btrfs_trans_handle *trans,
		      struct btrfs_root *root, int max_mirrors)
2183
{
2184
	int ret;
2185

Y
Yan Zheng 已提交
2186
	ret = write_all_supers(root, max_mirrors);
2187
	return ret;
C
Chris Mason 已提交
2188 2189
}

2190
int btrfs_free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root)
C
Chris Mason 已提交
2191 2192 2193
{
	radix_tree_delete(&fs_info->fs_roots_radix,
			  (unsigned long)root->root_key.objectid);
2194 2195 2196 2197
	if (root->anon_super.s_dev) {
		down_write(&root->anon_super.s_umount);
		kill_anon_super(&root->anon_super);
	}
C
Chris Mason 已提交
2198
	if (root->node)
2199
		free_extent_buffer(root->node);
C
Chris Mason 已提交
2200
	if (root->commit_root)
2201
		free_extent_buffer(root->commit_root);
C
Chris Mason 已提交
2202
	kfree(root->name);
C
Chris Mason 已提交
2203 2204 2205 2206
	kfree(root);
	return 0;
}

C
Chris Mason 已提交
2207
static int del_fs_roots(struct btrfs_fs_info *fs_info)
2208 2209 2210 2211 2212
{
	int ret;
	struct btrfs_root *gang[8];
	int i;

C
Chris Mason 已提交
2213
	while (1) {
2214 2215 2216 2217 2218
		ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
					     (void **)gang, 0,
					     ARRAY_SIZE(gang));
		if (!ret)
			break;
C
Chris Mason 已提交
2219
		for (i = 0; i < ret; i++)
2220
			btrfs_free_fs_root(fs_info, gang[i]);
2221 2222 2223
	}
	return 0;
}
2224

Y
Yan Zheng 已提交
2225
int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info)
C
Chris Mason 已提交
2226
{
Y
Yan Zheng 已提交
2227 2228 2229
	u64 root_objectid = 0;
	struct btrfs_root *gang[8];
	int i;
2230
	int ret;
2231

Y
Yan Zheng 已提交
2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248
	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;
}
2249

Y
Yan Zheng 已提交
2250 2251 2252 2253
int btrfs_commit_super(struct btrfs_root *root)
{
	struct btrfs_trans_handle *trans;
	int ret;
2254

Y
Yan Zheng 已提交
2255
	mutex_lock(&root->fs_info->cleaner_mutex);
2256
	btrfs_clean_old_snapshots(root);
Y
Yan Zheng 已提交
2257
	mutex_unlock(&root->fs_info->cleaner_mutex);
C
Chris Mason 已提交
2258
	trans = btrfs_start_transaction(root, 1);
2259
	ret = btrfs_commit_transaction(trans, root);
Y
Yan Zheng 已提交
2260 2261
	BUG_ON(ret);
	/* run commit again to drop the original snapshot */
C
Chris Mason 已提交
2262 2263 2264
	trans = btrfs_start_transaction(root, 1);
	btrfs_commit_transaction(trans, root);
	ret = btrfs_write_and_wait_transaction(NULL, root);
2265
	BUG_ON(ret);
2266

Y
Yan Zheng 已提交
2267
	ret = write_ctree_super(NULL, root, 0);
Y
Yan Zheng 已提交
2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283
	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 已提交
2284 2285
		if (ret)
			printk(KERN_ERR "btrfs: commit super ret %d\n", ret);
Y
Yan Zheng 已提交
2286
	}
2287

C
Chris Mason 已提交
2288
	if (fs_info->delalloc_bytes) {
C
Chris Mason 已提交
2289
		printk(KERN_INFO "btrfs: at unmount delalloc count %llu\n",
C
Chris Mason 已提交
2290 2291
		       fs_info->delalloc_bytes);
	}
Y
Yan Zheng 已提交
2292
	if (fs_info->total_ref_cache_size) {
C
Chris Mason 已提交
2293 2294
		printk(KERN_INFO "btrfs: at umount reference cache size %llu\n",
		       (unsigned long long)fs_info->total_ref_cache_size);
Y
Yan Zheng 已提交
2295
	}
2296

2297
	if (fs_info->extent_root->node)
2298
		free_extent_buffer(fs_info->extent_root->node);
2299

2300
	if (fs_info->tree_root->node)
2301
		free_extent_buffer(fs_info->tree_root->node);
2302

C
Chris Mason 已提交
2303
	if (root->fs_info->chunk_root->node)
2304 2305
		free_extent_buffer(root->fs_info->chunk_root->node);

C
Chris Mason 已提交
2306
	if (root->fs_info->dev_root->node)
2307 2308
		free_extent_buffer(root->fs_info->dev_root->node);

C
Chris Mason 已提交
2309
	if (root->fs_info->csum_root->node)
2310 2311
		free_extent_buffer(root->fs_info->csum_root->node);

C
Chris Mason 已提交
2312
	btrfs_free_block_groups(root->fs_info);
2313

Y
Yan Zheng 已提交
2314
	del_fs_roots(fs_info);
2315

Y
Yan Zheng 已提交
2316
	iput(fs_info->btree_inode);
2317

2318
	btrfs_stop_workers(&fs_info->fixup_workers);
2319
	btrfs_stop_workers(&fs_info->delalloc_workers);
2320 2321
	btrfs_stop_workers(&fs_info->workers);
	btrfs_stop_workers(&fs_info->endio_workers);
2322
	btrfs_stop_workers(&fs_info->endio_meta_workers);
2323
	btrfs_stop_workers(&fs_info->endio_meta_write_workers);
2324
	btrfs_stop_workers(&fs_info->endio_write_workers);
2325
	btrfs_stop_workers(&fs_info->submit_workers);
2326

2327
#if 0
C
Chris Mason 已提交
2328
	while (!list_empty(&fs_info->hashers)) {
2329 2330 2331 2332 2333 2334 2335 2336
		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
2337
	btrfs_close_devices(fs_info->fs_devices);
2338
	btrfs_mapping_tree_free(&fs_info->mapping_tree);
2339

C
Chris Mason 已提交
2340
	bdi_destroy(&fs_info->bdi);
2341

2342 2343
	kfree(fs_info->extent_root);
	kfree(fs_info->tree_root);
2344 2345
	kfree(fs_info->chunk_root);
	kfree(fs_info->dev_root);
2346
	kfree(fs_info->csum_root);
2347 2348 2349
	return 0;
}

2350
int btrfs_buffer_uptodate(struct extent_buffer *buf, u64 parent_transid)
2351
{
2352
	int ret;
2353
	struct inode *btree_inode = buf->first_page->mapping->host;
2354 2355 2356 2357 2358 2359 2360 2361

	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;
2362 2363 2364
}

int btrfs_set_buffer_uptodate(struct extent_buffer *buf)
C
Chris Mason 已提交
2365
{
2366
	struct inode *btree_inode = buf->first_page->mapping->host;
2367
	return set_extent_buffer_uptodate(&BTRFS_I(btree_inode)->io_tree,
2368 2369
					  buf);
}
2370

2371 2372
void btrfs_mark_buffer_dirty(struct extent_buffer *buf)
{
2373
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
2374 2375
	u64 transid = btrfs_header_generation(buf);
	struct inode *btree_inode = root->fs_info->btree_inode;
2376
	int was_dirty;
2377

2378
	btrfs_assert_tree_locked(buf);
C
Chris Mason 已提交
2379
	if (transid != root->fs_info->generation) {
C
Chris Mason 已提交
2380 2381
		printk(KERN_CRIT "btrfs transid mismatch buffer %llu, "
		       "found %llu running %llu\n",
2382
			(unsigned long long)buf->start,
C
Chris Mason 已提交
2383 2384
			(unsigned long long)transid,
			(unsigned long long)root->fs_info->generation);
C
Chris Mason 已提交
2385 2386
		WARN_ON(1);
	}
2387 2388 2389 2390 2391 2392 2393
	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);
	}
2394 2395
}

2396
void btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr)
C
Chris Mason 已提交
2397
{
2398 2399 2400 2401
	/*
	 * looks as though older kernels can get into trouble with
	 * this code, they end up stuck in balance_dirty_pages forever
	 */
2402 2403 2404
	struct extent_io_tree *tree;
	u64 num_dirty;
	u64 start = 0;
2405
	unsigned long thresh = 32 * 1024 * 1024;
2406 2407
	tree = &BTRFS_I(root->fs_info->btree_inode)->io_tree;

2408
	if (current_is_pdflush() || current->flags & PF_MEMALLOC)
2409 2410 2411 2412 2413 2414
		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 已提交
2415
				   root->fs_info->btree_inode->i_mapping, 1);
2416
	}
2417
	return;
C
Chris Mason 已提交
2418
}
2419

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

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

	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 已提交
2459 2460 2461 2462 2463 2464 2465
	btrfs_tree_unlock(eb);
	free_extent_buffer(eb);
out:
	lock_page(page);
	return 0;
}

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