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

C
Chris Mason 已提交
19
#include <linux/fs.h>
20
#include <linux/blkdev.h>
C
Chris Mason 已提交
21
#include <linux/scatterlist.h>
C
Chris Mason 已提交
22
#include <linux/swap.h>
23
#include <linux/radix-tree.h>
C
Chris Mason 已提交
24
#include <linux/writeback.h>
C
Chris Mason 已提交
25
#include <linux/buffer_head.h>
26
#include <linux/workqueue.h>
27
#include <linux/kthread.h>
C
Chris Mason 已提交
28
#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
static void free_fs_root(struct btrfs_root *root);
45

46 47
static atomic_t btrfs_bdi_num = ATOMIC_INIT(0);

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

C
Chris Mason 已提交
64 65 66 67 68
/*
 * 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.
 */
69 70 71 72
struct async_submit_bio {
	struct inode *inode;
	struct bio *bio;
	struct list_head list;
C
Chris Mason 已提交
73 74
	extent_submit_bio_hook_t *submit_bio_start;
	extent_submit_bio_hook_t *submit_bio_done;
75 76
	int rw;
	int mirror_num;
C
Chris Mason 已提交
77
	unsigned long bio_flags;
78
	struct btrfs_work work;
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 112 113 114
/* 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 已提交
115 116 117 118
/*
 * extents on the btree inode are pretty simple, there's one extent
 * that covers the entire device
 */
119 120 121
static struct extent_map *btree_get_extent(struct inode *inode,
		struct page *page, size_t page_offset, u64 start, u64 len,
		int create)
122
{
123 124 125 126
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
	struct extent_map *em;
	int ret;

127
	read_lock(&em_tree->lock);
128
	em = lookup_extent_mapping(em_tree, start, len);
129 130 131
	if (em) {
		em->bdev =
			BTRFS_I(inode)->root->fs_info->fs_devices->latest_bdev;
132
		read_unlock(&em_tree->lock);
133
		goto out;
134
	}
135
	read_unlock(&em_tree->lock);
136

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

148
	write_lock(&em_tree->lock);
149 150
	ret = add_extent_mapping(em_tree, em);
	if (ret == -EEXIST) {
151 152 153
		u64 failed_start = em->start;
		u64 failed_len = em->len;

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

	if (ret)
		em = ERR_PTR(ret);
171 172
out:
	return em;
173 174
}

175 176
u32 btrfs_csum_data(struct btrfs_root *root, char *data, u32 seed, size_t len)
{
177
	return crc32c(seed, data, len);
178 179 180 181 182 183 184
}

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

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

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

228 229 230
	btrfs_csum_final(crc, result);

	if (verify) {
231
		if (memcmp_extent_buffer(buf, result, 0, csum_size)) {
232 233
			u32 val;
			u32 found = 0;
234
			memcpy(&found, result, csum_size);
235

236
			read_extent_buffer(buf, &val, 0, csum_size);
C
Chris Mason 已提交
237 238 239 240 241 242 243 244
			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));
			}
245 246
			if (result != (char *)&inline_result)
				kfree(result);
247 248 249
			return 1;
		}
	} else {
250
		write_extent_buffer(buf, result, 0, csum_size);
251
	}
252 253
	if (result != (char *)&inline_result)
		kfree(result);
254 255 256
	return 0;
}

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

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

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

318
		mirror_num++;
C
Chris Mason 已提交
319
		if (mirror_num > num_copies)
320 321 322 323
			return ret;
	}
	return -EIO;
}
324

C
Chris Mason 已提交
325
/*
C
Chris Mason 已提交
326 327
 * 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 已提交
328
 */
C
Chris Mason 已提交
329

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

340
	tree = &BTRFS_I(page->mapping->host)->io_tree;
341 342 343 344 345 346

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

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

368
	csum_tree_block(root, eb, 0);
369
err:
370 371 372 373 374
	free_extent_buffer(eb);
out:
	return 0;
}

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

394 395 396 397 398 399 400 401 402
#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

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

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

420
	len = page->private >> 2;
C
Chris Mason 已提交
421 422
	WARN_ON(len == 0);

423
	eb = alloc_extent_buffer(tree, start, len, page, GFP_NOFS);
424

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

453 454
	btrfs_set_buffer_lockdep_class(eb, found_level);

455
	ret = csum_tree_block(root, eb, 1);
456 457
	if (ret)
		ret = -EIO;
458 459 460 461 462 463

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

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;
474 475
	end_io_wq->work.func = end_workqueue_fn;
	end_io_wq->work.flags = 0;
476 477

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

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

	bio->bi_private = end_io_wq;
	bio->bi_end_io = end_workqueue_bio;
511 512 513
	return 0;
}

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

522 523
int btrfs_congested_async(struct btrfs_fs_info *info, int iodone)
{
524 525
	return atomic_read(&info->nr_async_bios) >
		btrfs_async_submit_limit(info);
526 527
}

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

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

548
	limit = btrfs_async_submit_limit(fs_info);
549 550
	limit = limit * 2 / 3;

551
	atomic_dec(&fs_info->nr_async_submits);
552

553 554
	if (atomic_read(&fs_info->nr_async_submits) < limit &&
	    waitqueue_active(&fs_info->async_submit_wait))
555 556
		wake_up(&fs_info->async_submit_wait);

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

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

	async = container_of(work, struct  async_submit_bio, work);
566 567 568
	kfree(async);
}

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

592
	async->work.flags = 0;
C
Chris Mason 已提交
593
	async->bio_flags = bio_flags;
594

595
	atomic_inc(&fs_info->nr_async_submits);
596 597 598 599

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

600
	btrfs_queue_worker(&fs_info->workers, &async->work);
601

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

608 609 610
	return 0;
}

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

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

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

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

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

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

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

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

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

690 691 692 693 694 695 696 697 698 699
	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);
700
	}
701 702 703 704
	free_extent_buffer(eb);

	unlock_page(page);
	return 0;
705
}
706 707 708 709

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

		if (wbc->for_kupdate)
			return 0;

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

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

735
static int btree_releasepage(struct page *page, gfp_t gfp_flags)
736
{
737 738
	struct extent_io_tree *tree;
	struct extent_map_tree *map;
739
	int ret;
740

741
	if (PageWriteback(page) || PageDirty(page))
C
Chris Mason 已提交
742
		return 0;
743

744 745
	tree = &BTRFS_I(page->mapping->host)->io_tree;
	map = &BTRFS_I(page->mapping->host)->extent_tree;
746

747
	ret = try_release_extent_state(map, tree, page, gfp_flags);
C
Chris Mason 已提交
748
	if (!ret)
749 750 751
		return 0;

	ret = try_release_extent_buffer(tree, page);
752 753 754 755 756
	if (ret == 1) {
		ClearPagePrivate(page);
		set_page_private(page, 0);
		page_cache_release(page);
	}
757

758 759 760
	return ret;
}

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

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

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

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

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


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

int btrfs_wait_tree_block_writeback(struct extent_buffer *buf)
{
	return btrfs_wait_on_page_writeback_range(buf->first_page->mapping,
832 833 834
				  buf->start >> PAGE_CACHE_SHIFT,
				  (buf->start + buf->len - 1) >>
				   PAGE_CACHE_SHIFT);
835 836
}

837
struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 bytenr,
838
				      u32 blocksize, u64 parent_transid)
839 840 841 842 843 844 845 846 847 848 849 850
{
	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;

851
	ret = btree_read_extent_buffer_pages(root, buf, 0, parent_transid);
852

C
Chris Mason 已提交
853
	if (ret == 0)
854
		set_bit(EXTENT_BUFFER_UPTODATE, &buf->bflags);
855
	return buf;
856

857 858
}

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

867 868 869 870 871 872 873 874
		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);
		}
875

876 877
		/* ugh, clear_extent_buffer_dirty needs to lock the page */
		btrfs_set_lock_blocking(buf);
878
		clear_extent_buffer_dirty(&BTRFS_I(btree_inode)->io_tree,
879
					  buf);
880
	}
881 882 883
	return 0;
}

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

898
	root->fs_info = fs_info;
899 900
	root->objectid = objectid;
	root->last_trans = 0;
901
	root->highest_objectid = 0;
902
	root->name = NULL;
903
	root->in_sysfs = 0;
904
	root->inode_tree.rb_node = NULL;
905 906

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

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

940 941 942
	return 0;
}

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

952
	__setup_root(tree_root->nodesize, tree_root->leafsize,
953 954
		     tree_root->sectorsize, tree_root->stripesize,
		     root, fs_info, objectid);
955 956
	ret = btrfs_find_last_root(tree_root, objectid,
				   &root->root_item, &root->root_key);
957 958
	if (ret > 0)
		return -ENOENT;
959 960
	BUG_ON(ret);

961
	generation = btrfs_root_generation(&root->root_item);
962 963
	blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
	root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
964
				     blocksize, generation);
965
	BUG_ON(!root->node);
966
	root->commit_root = btrfs_root_node(root);
967 968 969
	return 0;
}

970 971 972 973
int btrfs_free_log_root_tree(struct btrfs_trans_handle *trans,
			     struct btrfs_fs_info *fs_info)
{
	struct extent_buffer *eb;
974 975 976
	struct btrfs_root *log_root_tree = fs_info->log_root_tree;
	u64 start = 0;
	u64 end = 0;
977 978
	int ret;

979
	if (!log_root_tree)
980 981
		return 0;

C
Chris Mason 已提交
982
	while (1) {
983 984 985 986 987 988 989 990
		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);
	}
991 992 993 994 995
	eb = fs_info->log_root_tree->node;

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

996 997
	ret = btrfs_free_reserved_extent(fs_info->tree_root,
				eb->start, eb->len);
998 999 1000 1001 1002 1003 1004 1005
	BUG_ON(ret);

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

Y
Yan Zheng 已提交
1006 1007
static struct btrfs_root *alloc_log_tree(struct btrfs_trans_handle *trans,
					 struct btrfs_fs_info *fs_info)
1008 1009 1010
{
	struct btrfs_root *root;
	struct btrfs_root *tree_root = fs_info->tree_root;
Y
Yan Zheng 已提交
1011
	struct extent_buffer *leaf;
1012 1013 1014

	root = kzalloc(sizeof(*root), GFP_NOFS);
	if (!root)
Y
Yan Zheng 已提交
1015
		return ERR_PTR(-ENOMEM);
1016 1017 1018 1019 1020 1021 1022 1023

	__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 已提交
1024 1025 1026 1027 1028 1029
	/*
	 * 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).
	 */
1030 1031
	root->ref_cows = 0;

1032 1033
	leaf = btrfs_alloc_free_block(trans, root, root->leafsize, 0,
				      BTRFS_TREE_LOG_OBJECTID, NULL, 0, 0, 0);
Y
Yan Zheng 已提交
1034 1035 1036 1037
	if (IS_ERR(leaf)) {
		kfree(root);
		return ERR_CAST(leaf);
	}
1038

1039 1040 1041 1042 1043
	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 已提交
1044
	root->node = leaf;
1045 1046 1047 1048 1049 1050

	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 已提交
1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086
	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);

1087
	btrfs_set_root_node(&log_root->root_item, log_root->node);
Y
Yan Zheng 已提交
1088 1089 1090 1091

	WARN_ON(root->log_root);
	root->log_root = log_root;
	root->log_transid = 0;
1092 1093 1094 1095 1096 1097 1098 1099
	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;
1100
	struct btrfs_path *path;
1101
	struct extent_buffer *l;
1102
	u64 generation;
1103
	u32 blocksize;
1104 1105
	int ret = 0;

1106
	root = kzalloc(sizeof(*root), GFP_NOFS);
C
Chris Mason 已提交
1107
	if (!root)
1108 1109
		return ERR_PTR(-ENOMEM);
	if (location->offset == (u64)-1) {
1110
		ret = find_and_setup_root(tree_root, fs_info,
1111 1112 1113 1114 1115
					  location->objectid, root);
		if (ret) {
			kfree(root);
			return ERR_PTR(ret);
		}
1116
		goto out;
1117 1118
	}

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

	path = btrfs_alloc_path();
	BUG_ON(!path);
	ret = btrfs_search_slot(NULL, tree_root, location, path, 0, 0);
1126 1127 1128 1129 1130 1131
	if (ret == 0) {
		l = path->nodes[0];
		read_extent_buffer(l, &root->root_item,
				btrfs_item_ptr_offset(l, path->slots[0]),
				sizeof(root->root_item));
		memcpy(&root->root_key, location, sizeof(*location));
1132 1133 1134
	}
	btrfs_free_path(path);
	if (ret) {
1135 1136
		if (ret > 0)
			ret = -ENOENT;
1137 1138
		return ERR_PTR(ret);
	}
1139

1140
	generation = btrfs_root_generation(&root->root_item);
1141 1142
	blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
	root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
1143
				     blocksize, generation);
1144
	root->commit_root = btrfs_root_node(root);
1145
	BUG_ON(!root->node);
1146 1147
out:
	if (location->objectid != BTRFS_TREE_LOG_OBJECTID)
1148
		root->ref_cows = 1;
1149

1150 1151 1152
	return root;
}

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

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

1174 1175 1176 1177
	if (location->objectid == BTRFS_ROOT_TREE_OBJECTID)
		return fs_info->tree_root;
	if (location->objectid == BTRFS_EXTENT_TREE_OBJECTID)
		return fs_info->extent_root;
1178 1179 1180 1181
	if (location->objectid == BTRFS_CHUNK_TREE_OBJECTID)
		return fs_info->chunk_root;
	if (location->objectid == BTRFS_DEV_TREE_OBJECTID)
		return fs_info->dev_root;
1182 1183
	if (location->objectid == BTRFS_CSUM_TREE_OBJECTID)
		return fs_info->csum_root;
1184 1185
again:
	spin_lock(&fs_info->fs_roots_radix_lock);
1186 1187
	root = radix_tree_lookup(&fs_info->fs_roots_radix,
				 (unsigned long)location->objectid);
1188
	spin_unlock(&fs_info->fs_roots_radix_lock);
1189 1190 1191
	if (root)
		return root;

1192 1193 1194 1195 1196 1197
	ret = btrfs_find_orphan_item(fs_info->tree_root, location->objectid);
	if (ret == 0)
		ret = -ENOENT;
	if (ret < 0)
		return ERR_PTR(ret);

1198
	root = btrfs_read_fs_root_no_radix(fs_info->tree_root, location);
1199 1200
	if (IS_ERR(root))
		return root;
1201

1202
	WARN_ON(btrfs_root_refs(&root->root_item) == 0);
1203 1204
	set_anon_super(&root->anon_super, NULL);

1205 1206 1207 1208 1209
	ret = radix_tree_preload(GFP_NOFS & ~__GFP_HIGHMEM);
	if (ret)
		goto fail;

	spin_lock(&fs_info->fs_roots_radix_lock);
C
Chris Mason 已提交
1210 1211
	ret = radix_tree_insert(&fs_info->fs_roots_radix,
				(unsigned long)root->root_key.objectid,
1212
				root);
1213 1214 1215 1216
	if (ret == 0)
		root->in_radix = 1;
	spin_unlock(&fs_info->fs_roots_radix_lock);
	radix_tree_preload_end();
1217
	if (ret) {
1218 1219 1220 1221 1222
		if (ret == -EEXIST) {
			free_fs_root(root);
			goto again;
		}
		goto fail;
1223
	}
1224 1225 1226 1227 1228 1229

	ret = btrfs_find_dead_roots(fs_info->tree_root,
				    root->root_key.objectid);
	WARN_ON(ret);

	if (!(fs_info->sb->s_flags & MS_RDONLY))
Y
Yan Zheng 已提交
1230
		btrfs_orphan_cleanup(root);
1231

1232
	return root;
1233 1234 1235
fail:
	free_fs_root(root);
	return ERR_PTR(ret);
1236 1237 1238 1239 1240 1241
}

struct btrfs_root *btrfs_read_fs_root(struct btrfs_fs_info *fs_info,
				      struct btrfs_key *location,
				      const char *name, int namelen)
{
1242 1243
	return btrfs_read_fs_root_no_name(fs_info, location);
#if 0
1244 1245 1246 1247 1248 1249
	struct btrfs_root *root;
	int ret;

	root = btrfs_read_fs_root_no_name(fs_info, location);
	if (!root)
		return NULL;
1250

1251 1252 1253
	if (root->in_sysfs)
		return root;

1254 1255
	ret = btrfs_set_root_name(root, name, namelen);
	if (ret) {
1256
		free_extent_buffer(root->node);
1257 1258 1259
		kfree(root);
		return ERR_PTR(ret);
	}
1260

1261 1262
	ret = btrfs_sysfs_add_root(root);
	if (ret) {
1263
		free_extent_buffer(root->node);
1264 1265 1266 1267
		kfree(root->name);
		kfree(root);
		return ERR_PTR(ret);
	}
1268
	root->in_sysfs = 1;
1269
	return root;
1270
#endif
1271
}
C
Chris Mason 已提交
1272 1273 1274 1275 1276 1277 1278

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

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
	em_tree = &BTRFS_I(inode)->extent_tree;
1349
	read_lock(&em_tree->lock);
1350
	em = lookup_extent_mapping(em_tree, offset, PAGE_CACHE_SIZE);
1351
	read_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 1371
/*
 * If this fails, caller must call bdi_destroy() to get rid of the
 * bdi again.
 */
C
Chris Mason 已提交
1372 1373
static int setup_bdi(struct btrfs_fs_info *info, struct backing_dev_info *bdi)
{
1374 1375
	int err;

1376
	bdi->name = "btrfs";
1377 1378 1379 1380 1381 1382 1383
	bdi->capabilities = BDI_CAP_MAP_COPY;
	err = bdi_init(bdi);
	if (err)
		return err;

	err = bdi_register(bdi, NULL, "btrfs-%d",
				atomic_inc_return(&btrfs_bdi_num));
1384 1385
	if (err) {
		bdi_destroy(bdi);
1386
		return err;
1387
	}
1388

1389
	bdi->ra_pages	= default_backing_dev_info.ra_pages;
C
Chris Mason 已提交
1390 1391 1392 1393 1394 1395 1396
	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;
}

1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433
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;
}

1434 1435 1436 1437 1438
/*
 * 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)
1439 1440
{
	struct bio *bio;
1441 1442
	struct end_io_wq *end_io_wq;
	struct btrfs_fs_info *fs_info;
1443 1444
	int error;

1445 1446 1447
	end_io_wq = container_of(work, struct end_io_wq, work);
	bio = end_io_wq->bio;
	fs_info = end_io_wq->info;
1448

1449
	/* metadata bio reads are special because the whole tree block must
1450 1451 1452 1453
	 * 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
	 */
1454 1455
	if (!(bio->bi_rw & (1 << BIO_RW)) && end_io_wq->metadata &&
	    !bio_ready_for_csum(bio)) {
1456
		btrfs_queue_worker(&fs_info->endio_meta_workers,
1457 1458 1459 1460 1461 1462 1463 1464
				   &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);
1465 1466
}

1467 1468 1469 1470 1471 1472 1473 1474 1475 1476
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);
1477 1478 1479 1480 1481 1482

		if (!(root->fs_info->sb->s_flags & MS_RDONLY) &&
		    mutex_trylock(&root->fs_info->cleaner_mutex)) {
			btrfs_clean_old_snapshots(root);
			mutex_unlock(&root->fs_info->cleaner_mutex);
		}
1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521

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

1523 1524 1525 1526 1527 1528 1529 1530 1531
		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);
1532

1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549
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;
}

1550
struct btrfs_root *open_ctree(struct super_block *sb,
1551 1552
			      struct btrfs_fs_devices *fs_devices,
			      char *options)
1553
{
1554 1555 1556 1557
	u32 sectorsize;
	u32 nodesize;
	u32 leafsize;
	u32 blocksize;
1558
	u32 stripesize;
1559
	u64 generation;
1560
	u64 features;
1561
	struct btrfs_key location;
1562
	struct buffer_head *bh;
1563
	struct btrfs_root *extent_root = kzalloc(sizeof(struct btrfs_root),
C
Chris Mason 已提交
1564
						 GFP_NOFS);
1565 1566
	struct btrfs_root *csum_root = kzalloc(sizeof(struct btrfs_root),
						 GFP_NOFS);
1567
	struct btrfs_root *tree_root = kzalloc(sizeof(struct btrfs_root),
C
Chris Mason 已提交
1568
					       GFP_NOFS);
1569
	struct btrfs_fs_info *fs_info = kzalloc(sizeof(*fs_info),
C
Chris Mason 已提交
1570
						GFP_NOFS);
1571
	struct btrfs_root *chunk_root = kzalloc(sizeof(struct btrfs_root),
1572
						GFP_NOFS);
1573
	struct btrfs_root *dev_root = kzalloc(sizeof(struct btrfs_root),
1574
					      GFP_NOFS);
1575 1576
	struct btrfs_root *log_tree_root;

1577
	int ret;
1578
	int err = -EINVAL;
1579

C
Chris Mason 已提交
1580
	struct btrfs_super_block *disk_super;
1581

1582
	if (!extent_root || !tree_root || !fs_info ||
1583
	    !chunk_root || !dev_root || !csum_root) {
C
Chris Mason 已提交
1584 1585 1586
		err = -ENOMEM;
		goto fail;
	}
1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606

	ret = init_srcu_struct(&fs_info->subvol_srcu);
	if (ret) {
		err = ret;
		goto fail;
	}

	ret = setup_bdi(fs_info, &fs_info->bdi);
	if (ret) {
		err = ret;
		goto fail_srcu;
	}

	fs_info->btree_inode = new_inode(sb);
	if (!fs_info->btree_inode) {
		err = -ENOMEM;
		goto fail_bdi;
	}

	INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_ATOMIC);
C
Chris Mason 已提交
1607
	INIT_LIST_HEAD(&fs_info->trans_list);
1608
	INIT_LIST_HEAD(&fs_info->dead_roots);
1609
	INIT_LIST_HEAD(&fs_info->hashers);
1610
	INIT_LIST_HEAD(&fs_info->delalloc_inodes);
1611
	INIT_LIST_HEAD(&fs_info->ordered_operations);
1612
	INIT_LIST_HEAD(&fs_info->caching_block_groups);
1613
	spin_lock_init(&fs_info->delalloc_lock);
1614
	spin_lock_init(&fs_info->new_trans_lock);
Y
Yan Zheng 已提交
1615
	spin_lock_init(&fs_info->ref_cache_lock);
1616
	spin_lock_init(&fs_info->fs_roots_radix_lock);
1617

1618
	init_completion(&fs_info->kobj_unregister);
1619 1620
	fs_info->tree_root = tree_root;
	fs_info->extent_root = extent_root;
1621
	fs_info->csum_root = csum_root;
1622 1623
	fs_info->chunk_root = chunk_root;
	fs_info->dev_root = dev_root;
1624
	fs_info->fs_devices = fs_devices;
1625
	INIT_LIST_HEAD(&fs_info->dirty_cowonly_roots);
1626
	INIT_LIST_HEAD(&fs_info->space_info);
1627
	btrfs_mapping_init(&fs_info->mapping_tree);
1628
	atomic_set(&fs_info->nr_async_submits, 0);
1629
	atomic_set(&fs_info->async_delalloc_pages, 0);
1630
	atomic_set(&fs_info->async_submit_draining, 0);
1631
	atomic_set(&fs_info->nr_async_bios, 0);
C
Chris Mason 已提交
1632
	fs_info->sb = sb;
1633
	fs_info->max_extent = (u64)-1;
1634
	fs_info->max_inline = 8192 * 1024;
J
Josef Bacik 已提交
1635
	fs_info->metadata_ratio = 0;
C
Chris Mason 已提交
1636

1637 1638
	fs_info->thread_pool_size = min_t(unsigned long,
					  num_online_cpus() + 2, 8);
1639

1640 1641 1642
	INIT_LIST_HEAD(&fs_info->ordered_extents);
	spin_lock_init(&fs_info->ordered_extent_lock);

1643 1644
	sb->s_blocksize = 4096;
	sb->s_blocksize_bits = blksize_bits(4096);
J
Jens Axboe 已提交
1645
	sb->s_bdi = &fs_info->bdi;
1646

1647 1648
	fs_info->btree_inode->i_ino = BTRFS_BTREE_INODE_OBJECTID;
	fs_info->btree_inode->i_nlink = 1;
1649 1650 1651 1652 1653 1654
	/*
	 * 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;
1655
	fs_info->btree_inode->i_mapping->a_ops = &btree_aops;
C
Chris Mason 已提交
1656 1657
	fs_info->btree_inode->i_mapping->backing_dev_info = &fs_info->bdi;

1658
	RB_CLEAR_NODE(&BTRFS_I(fs_info->btree_inode)->rb_node);
1659
	extent_io_tree_init(&BTRFS_I(fs_info->btree_inode)->io_tree,
1660 1661
			     fs_info->btree_inode->i_mapping,
			     GFP_NOFS);
1662 1663 1664 1665
	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;
1666

1667 1668 1669 1670
	BTRFS_I(fs_info->btree_inode)->root = tree_root;
	memset(&BTRFS_I(fs_info->btree_inode)->location, 0,
	       sizeof(struct btrfs_key));
	BTRFS_I(fs_info->btree_inode)->dummy_inode = 1;
1671
	insert_inode_hash(fs_info->btree_inode);
1672

J
Josef Bacik 已提交
1673 1674 1675
	spin_lock_init(&fs_info->block_group_cache_lock);
	fs_info->block_group_cache_tree.rb_node = NULL;

1676
	extent_io_tree_init(&fs_info->freed_extents[0],
1677
			     fs_info->btree_inode->i_mapping, GFP_NOFS);
1678 1679 1680
	extent_io_tree_init(&fs_info->freed_extents[1],
			     fs_info->btree_inode->i_mapping, GFP_NOFS);
	fs_info->pinned_extents = &fs_info->freed_extents[0];
1681
	fs_info->do_barriers = 1;
1682

C
Chris Mason 已提交
1683

C
Chris Mason 已提交
1684
	mutex_init(&fs_info->trans_mutex);
1685
	mutex_init(&fs_info->ordered_operations_mutex);
1686
	mutex_init(&fs_info->tree_log_mutex);
1687
	mutex_init(&fs_info->chunk_mutex);
1688 1689
	mutex_init(&fs_info->transaction_kthread_mutex);
	mutex_init(&fs_info->cleaner_mutex);
1690
	mutex_init(&fs_info->volume_mutex);
1691
	init_rwsem(&fs_info->extent_commit_sem);
1692
	init_rwsem(&fs_info->subvol_sem);
1693 1694 1695 1696

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

1697
	init_waitqueue_head(&fs_info->transaction_throttle);
1698
	init_waitqueue_head(&fs_info->transaction_wait);
1699
	init_waitqueue_head(&fs_info->async_submit_wait);
1700

1701
	__setup_root(4096, 4096, 4096, 4096, tree_root,
C
Chris Mason 已提交
1702
		     fs_info, BTRFS_ROOT_TREE_OBJECTID);
1703

1704

Y
Yan Zheng 已提交
1705
	bh = btrfs_read_dev_super(fs_devices->latest_bdev);
1706
	if (!bh)
C
Chris Mason 已提交
1707 1708
		goto fail_iput;

1709
	memcpy(&fs_info->super_copy, bh->b_data, sizeof(fs_info->super_copy));
1710 1711
	memcpy(&fs_info->super_for_commit, &fs_info->super_copy,
	       sizeof(fs_info->super_for_commit));
1712
	brelse(bh);
1713

1714
	memcpy(fs_info->fsid, fs_info->super_copy.fsid, BTRFS_FSID_SIZE);
1715

1716
	disk_super = &fs_info->super_copy;
1717
	if (!btrfs_super_root(disk_super))
1718
		goto fail_iput;
1719

Y
Yan Zheng 已提交
1720 1721 1722
	ret = btrfs_parse_options(tree_root, options);
	if (ret) {
		err = ret;
1723
		goto fail_iput;
Y
Yan Zheng 已提交
1724
	}
1725

1726 1727 1728 1729 1730
	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",
1731
		       (unsigned long long)features);
1732
		err = -EINVAL;
1733
		goto fail_iput;
1734 1735
	}

1736 1737 1738 1739 1740 1741
	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);
	}

1742 1743 1744 1745 1746
	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",
1747
		       (unsigned long long)features);
1748
		err = -EINVAL;
1749
		goto fail_iput;
1750
	}
1751
printk("thread pool is %d\n", fs_info->thread_pool_size);
1752 1753 1754 1755 1756
	/*
	 * 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.
	 */
1757 1758
	btrfs_init_workers(&fs_info->workers, "worker",
			   fs_info->thread_pool_size);
C
Chris Mason 已提交
1759

1760 1761 1762
	btrfs_init_workers(&fs_info->delalloc_workers, "delalloc",
			   fs_info->thread_pool_size);

1763
	btrfs_init_workers(&fs_info->submit_workers, "submit",
1764 1765
			   min_t(u64, fs_devices->num_devices,
			   fs_info->thread_pool_size));
1766 1767 1768 1769 1770 1771

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

1773
	fs_info->workers.idle_thresh = 16;
C
Chris Mason 已提交
1774
	fs_info->workers.ordered = 1;
1775

1776 1777 1778
	fs_info->delalloc_workers.idle_thresh = 2;
	fs_info->delalloc_workers.ordered = 1;

1779 1780 1781
	btrfs_init_workers(&fs_info->fixup_workers, "fixup", 1);
	btrfs_init_workers(&fs_info->endio_workers, "endio",
			   fs_info->thread_pool_size);
1782 1783
	btrfs_init_workers(&fs_info->endio_meta_workers, "endio-meta",
			   fs_info->thread_pool_size);
1784 1785
	btrfs_init_workers(&fs_info->endio_meta_write_workers,
			   "endio-meta-write", fs_info->thread_pool_size);
1786
	btrfs_init_workers(&fs_info->endio_write_workers, "endio-write",
1787
			   fs_info->thread_pool_size);
1788 1789 1790 1791 1792 1793

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

1796 1797 1798 1799 1800 1801 1802
	fs_info->endio_write_workers.idle_thresh = 2;
	fs_info->endio_meta_write_workers.idle_thresh = 2;

	fs_info->endio_workers.atomic_worker_start = 1;
	fs_info->endio_meta_workers.atomic_worker_start = 1;
	fs_info->endio_write_workers.atomic_worker_start = 1;
	fs_info->endio_meta_write_workers.atomic_worker_start = 1;
1803

1804
	btrfs_start_workers(&fs_info->workers, 1);
1805
	btrfs_start_workers(&fs_info->submit_workers, 1);
1806
	btrfs_start_workers(&fs_info->delalloc_workers, 1);
1807
	btrfs_start_workers(&fs_info->fixup_workers, 1);
1808 1809 1810 1811
	btrfs_start_workers(&fs_info->endio_workers, 1);
	btrfs_start_workers(&fs_info->endio_meta_workers, 1);
	btrfs_start_workers(&fs_info->endio_meta_write_workers, 1);
	btrfs_start_workers(&fs_info->endio_write_workers, 1);
1812

1813
	fs_info->bdi.ra_pages *= btrfs_super_num_devices(disk_super);
C
Chris Mason 已提交
1814 1815
	fs_info->bdi.ra_pages = max(fs_info->bdi.ra_pages,
				    4 * 1024 * 1024 / PAGE_CACHE_SIZE);
1816

1817 1818 1819
	nodesize = btrfs_super_nodesize(disk_super);
	leafsize = btrfs_super_leafsize(disk_super);
	sectorsize = btrfs_super_sectorsize(disk_super);
1820
	stripesize = btrfs_super_stripesize(disk_super);
1821 1822 1823
	tree_root->nodesize = nodesize;
	tree_root->leafsize = leafsize;
	tree_root->sectorsize = sectorsize;
1824
	tree_root->stripesize = stripesize;
1825 1826 1827

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

C
Chris Mason 已提交
1829 1830
	if (strncmp((char *)(&disk_super->magic), BTRFS_MAGIC,
		    sizeof(disk_super->magic))) {
C
Chris Mason 已提交
1831
		printk(KERN_INFO "btrfs: valid FS not found on %s\n", sb->s_id);
C
Chris Mason 已提交
1832 1833
		goto fail_sb_buffer;
	}
1834

1835
	mutex_lock(&fs_info->chunk_mutex);
Y
Yan Zheng 已提交
1836
	ret = btrfs_read_sys_array(tree_root);
1837
	mutex_unlock(&fs_info->chunk_mutex);
1838
	if (ret) {
C
Chris Mason 已提交
1839 1840
		printk(KERN_WARNING "btrfs: failed to read the system "
		       "array on %s\n", sb->s_id);
1841
		goto fail_sb_buffer;
1842
	}
1843 1844 1845

	blocksize = btrfs_level_size(tree_root,
				     btrfs_super_chunk_root_level(disk_super));
1846
	generation = btrfs_super_chunk_root_generation(disk_super);
1847 1848 1849 1850 1851 1852

	__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),
1853
					   blocksize, generation);
1854
	BUG_ON(!chunk_root->node);
1855 1856 1857 1858 1859
	if (!test_bit(EXTENT_BUFFER_UPTODATE, &chunk_root->node->bflags)) {
		printk(KERN_WARNING "btrfs: failed to read chunk root on %s\n",
		       sb->s_id);
		goto fail_chunk_root;
	}
1860 1861
	btrfs_set_root_node(&chunk_root->root_item, chunk_root->node);
	chunk_root->commit_root = btrfs_root_node(chunk_root);
1862

1863
	read_extent_buffer(chunk_root->node, fs_info->chunk_tree_uuid,
C
Chris Mason 已提交
1864 1865
	   (unsigned long)btrfs_header_chunk_tree_uuid(chunk_root->node),
	   BTRFS_UUID_SIZE);
1866

1867
	mutex_lock(&fs_info->chunk_mutex);
1868
	ret = btrfs_read_chunk_tree(chunk_root);
1869
	mutex_unlock(&fs_info->chunk_mutex);
Y
Yan Zheng 已提交
1870
	if (ret) {
C
Chris Mason 已提交
1871 1872
		printk(KERN_WARNING "btrfs: failed to read chunk tree on %s\n",
		       sb->s_id);
Y
Yan Zheng 已提交
1873 1874
		goto fail_chunk_root;
	}
1875

1876 1877
	btrfs_close_extra_devices(fs_devices);

1878 1879
	blocksize = btrfs_level_size(tree_root,
				     btrfs_super_root_level(disk_super));
1880
	generation = btrfs_super_generation(disk_super);
1881

C
Chris Mason 已提交
1882
	tree_root->node = read_tree_block(tree_root,
1883
					  btrfs_super_root(disk_super),
1884
					  blocksize, generation);
C
Chris Mason 已提交
1885
	if (!tree_root->node)
Y
Yan Zheng 已提交
1886
		goto fail_chunk_root;
1887 1888 1889 1890 1891
	if (!test_bit(EXTENT_BUFFER_UPTODATE, &tree_root->node->bflags)) {
		printk(KERN_WARNING "btrfs: failed to read tree root on %s\n",
		       sb->s_id);
		goto fail_tree_root;
	}
1892 1893
	btrfs_set_root_node(&tree_root->root_item, tree_root->node);
	tree_root->commit_root = btrfs_root_node(tree_root);
1894 1895

	ret = find_and_setup_root(tree_root, fs_info,
C
Chris Mason 已提交
1896
				  BTRFS_EXTENT_TREE_OBJECTID, extent_root);
1897
	if (ret)
C
Chris Mason 已提交
1898
		goto fail_tree_root;
1899 1900 1901 1902 1903 1904
	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;
1905
	dev_root->track_dirty = 1;
1906

1907 1908 1909
	ret = find_and_setup_root(tree_root, fs_info,
				  BTRFS_CSUM_TREE_OBJECTID, csum_root);
	if (ret)
1910
		goto fail_dev_root;
1911 1912 1913

	csum_root->track_dirty = 1;

C
Chris Mason 已提交
1914 1915
	btrfs_read_block_groups(extent_root);

1916
	fs_info->generation = generation;
Y
Yan Zheng 已提交
1917
	fs_info->last_trans_committed = generation;
C
Chris Mason 已提交
1918 1919 1920
	fs_info->data_alloc_profile = (u64)-1;
	fs_info->metadata_alloc_profile = (u64)-1;
	fs_info->system_alloc_profile = fs_info->metadata_alloc_profile;
1921 1922
	fs_info->cleaner_kthread = kthread_run(cleaner_kthread, tree_root,
					       "btrfs-cleaner");
1923
	if (IS_ERR(fs_info->cleaner_kthread))
1924
		goto fail_csum_root;
1925 1926 1927 1928

	fs_info->transaction_kthread = kthread_run(transaction_kthread,
						   tree_root,
						   "btrfs-transaction");
1929
	if (IS_ERR(fs_info->transaction_kthread))
1930
		goto fail_cleaner;
1931

C
Chris Mason 已提交
1932 1933 1934 1935 1936 1937 1938 1939
	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);
	}

1940 1941 1942
	if (btrfs_super_log_root(disk_super) != 0) {
		u64 bytenr = btrfs_super_log_root(disk_super);

1943
		if (fs_devices->rw_devices == 0) {
C
Chris Mason 已提交
1944 1945
			printk(KERN_WARNING "Btrfs log replay required "
			       "on RO media\n");
1946 1947 1948
			err = -EIO;
			goto fail_trans_kthread;
		}
1949 1950 1951
		blocksize =
		     btrfs_level_size(tree_root,
				      btrfs_super_log_root_level(disk_super));
C
Chris Mason 已提交
1952

1953 1954 1955 1956 1957 1958 1959
		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,
1960 1961
						      blocksize,
						      generation + 1);
1962 1963
		ret = btrfs_recover_log_trees(log_tree_root);
		BUG_ON(ret);
1964 1965 1966 1967 1968

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

1971 1972 1973
	ret = btrfs_find_orphan_roots(tree_root);
	BUG_ON(ret);

1974
	if (!(sb->s_flags & MS_RDONLY)) {
1975
		ret = btrfs_recover_relocation(tree_root);
1976 1977
		BUG_ON(ret);
	}
Z
Zheng Yan 已提交
1978

1979 1980 1981 1982 1983 1984
	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)
1985
		goto fail_trans_kthread;
C
Chris Mason 已提交
1986

1987
	return tree_root;
C
Chris Mason 已提交
1988

1989 1990
fail_trans_kthread:
	kthread_stop(fs_info->transaction_kthread);
1991
fail_cleaner:
1992
	kthread_stop(fs_info->cleaner_kthread);
1993 1994 1995 1996 1997 1998 1999 2000

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

2001 2002
fail_csum_root:
	free_extent_buffer(csum_root->node);
2003 2004 2005 2006
	free_extent_buffer(csum_root->commit_root);
fail_dev_root:
	free_extent_buffer(dev_root->node);
	free_extent_buffer(dev_root->commit_root);
2007 2008
fail_extent_root:
	free_extent_buffer(extent_root->node);
2009
	free_extent_buffer(extent_root->commit_root);
C
Chris Mason 已提交
2010
fail_tree_root:
2011
	free_extent_buffer(tree_root->node);
2012
	free_extent_buffer(tree_root->commit_root);
Y
Yan Zheng 已提交
2013 2014
fail_chunk_root:
	free_extent_buffer(chunk_root->node);
2015
	free_extent_buffer(chunk_root->commit_root);
C
Chris Mason 已提交
2016
fail_sb_buffer:
2017
	btrfs_stop_workers(&fs_info->fixup_workers);
2018
	btrfs_stop_workers(&fs_info->delalloc_workers);
2019 2020
	btrfs_stop_workers(&fs_info->workers);
	btrfs_stop_workers(&fs_info->endio_workers);
2021
	btrfs_stop_workers(&fs_info->endio_meta_workers);
2022
	btrfs_stop_workers(&fs_info->endio_meta_write_workers);
2023
	btrfs_stop_workers(&fs_info->endio_write_workers);
2024
	btrfs_stop_workers(&fs_info->submit_workers);
2025
fail_iput:
2026
	invalidate_inode_pages2(fs_info->btree_inode->i_mapping);
2027
	iput(fs_info->btree_inode);
2028

2029
	btrfs_close_devices(fs_info->fs_devices);
2030
	btrfs_mapping_tree_free(&fs_info->mapping_tree);
2031
fail_bdi:
2032
	bdi_destroy(&fs_info->bdi);
2033 2034
fail_srcu:
	cleanup_srcu_struct(&fs_info->subvol_srcu);
2035
fail:
C
Chris Mason 已提交
2036 2037 2038
	kfree(extent_root);
	kfree(tree_root);
	kfree(fs_info);
2039 2040
	kfree(chunk_root);
	kfree(dev_root);
2041
	kfree(csum_root);
C
Chris Mason 已提交
2042
	return ERR_PTR(err);
2043 2044
}

2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056
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));
		}
2057 2058 2059
		/* note, we dont' set_buffer_write_io_error because we have
		 * our own ways of dealing with the IO errors
		 */
2060 2061 2062 2063 2064 2065
		clear_buffer_uptodate(bh);
	}
	unlock_buffer(bh);
	put_bh(bh);
}

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

2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117
/*
 * 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 已提交
2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153
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);
2154 2155 2156 2157 2158 2159 2160 2161 2162
			if (!buffer_uptodate(bh))
				errors++;

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

			/* drop the reference from the wait == 0 run */
			brelse(bh);
			continue;
Y
Yan Zheng 已提交
2163 2164 2165 2166 2167 2168 2169 2170 2171 2172
		} 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);

2173 2174 2175 2176
			/*
			 * one reference for us, and we leave it for the
			 * caller
			 */
Y
Yan Zheng 已提交
2177 2178 2179 2180
			bh = __getblk(device->bdev, bytenr / 4096,
				      BTRFS_SUPER_INFO_SIZE);
			memcpy(bh->b_data, sb, BTRFS_SUPER_INFO_SIZE);

2181
			/* one reference for submit_bh */
Y
Yan Zheng 已提交
2182
			get_bh(bh);
2183 2184

			set_buffer_uptodate(bh);
Y
Yan Zheng 已提交
2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195
			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;
2196
				/* one reference for submit_bh */
Y
Yan Zheng 已提交
2197 2198
				get_bh(bh);
				lock_buffer(bh);
2199
				ret = submit_bh(WRITE_SYNC, bh);
Y
Yan Zheng 已提交
2200 2201
			}
		} else {
2202
			ret = submit_bh(WRITE_SYNC, bh);
Y
Yan Zheng 已提交
2203 2204
		}

2205
		if (ret)
Y
Yan Zheng 已提交
2206 2207 2208 2209 2210 2211
			errors++;
	}
	return errors < i ? 0 : -1;
}

int write_all_supers(struct btrfs_root *root, int max_mirrors)
2212
{
2213
	struct list_head *head;
2214
	struct btrfs_device *dev;
2215
	struct btrfs_super_block *sb;
2216 2217 2218
	struct btrfs_dev_item *dev_item;
	int ret;
	int do_barriers;
2219 2220
	int max_errors;
	int total_errors = 0;
2221
	u64 flags;
2222

2223
	max_errors = btrfs_super_num_devices(&root->fs_info->super_copy) - 1;
2224 2225
	do_barriers = !btrfs_test_opt(root, NOBARRIER);

2226 2227
	sb = &root->fs_info->super_for_commit;
	dev_item = &sb->dev_item;
2228 2229 2230

	mutex_lock(&root->fs_info->fs_devices->device_list_mutex);
	head = &root->fs_info->fs_devices->devices;
Q
Qinghuang Feng 已提交
2231
	list_for_each_entry(dev, head, dev_list) {
2232 2233 2234 2235
		if (!dev->bdev) {
			total_errors++;
			continue;
		}
Y
Yan Zheng 已提交
2236
		if (!dev->in_fs_metadata || !dev->writeable)
2237 2238
			continue;

Y
Yan Zheng 已提交
2239
		btrfs_set_stack_device_generation(dev_item, 0);
2240 2241 2242 2243 2244 2245 2246 2247
		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 已提交
2248
		memcpy(dev_item->fsid, dev->fs_devices->fsid, BTRFS_UUID_SIZE);
Y
Yan Zheng 已提交
2249

2250 2251 2252
		flags = btrfs_super_flags(sb);
		btrfs_set_super_flags(sb, flags | BTRFS_HEADER_FLAG_WRITTEN);

Y
Yan Zheng 已提交
2253
		ret = write_dev_supers(dev, sb, do_barriers, 0, max_mirrors);
2254 2255
		if (ret)
			total_errors++;
2256
	}
2257
	if (total_errors > max_errors) {
C
Chris Mason 已提交
2258 2259
		printk(KERN_ERR "btrfs: %d errors while writing supers\n",
		       total_errors);
2260 2261
		BUG();
	}
2262

Y
Yan Zheng 已提交
2263
	total_errors = 0;
Q
Qinghuang Feng 已提交
2264
	list_for_each_entry(dev, head, dev_list) {
2265 2266
		if (!dev->bdev)
			continue;
Y
Yan Zheng 已提交
2267
		if (!dev->in_fs_metadata || !dev->writeable)
2268 2269
			continue;

Y
Yan Zheng 已提交
2270 2271 2272
		ret = write_dev_supers(dev, sb, do_barriers, 1, max_mirrors);
		if (ret)
			total_errors++;
2273
	}
2274
	mutex_unlock(&root->fs_info->fs_devices->device_list_mutex);
2275
	if (total_errors > max_errors) {
C
Chris Mason 已提交
2276 2277
		printk(KERN_ERR "btrfs: %d errors while writing supers\n",
		       total_errors);
2278 2279
		BUG();
	}
2280 2281 2282
	return 0;
}

Y
Yan Zheng 已提交
2283 2284
int write_ctree_super(struct btrfs_trans_handle *trans,
		      struct btrfs_root *root, int max_mirrors)
2285
{
2286
	int ret;
2287

Y
Yan Zheng 已提交
2288
	ret = write_all_supers(root, max_mirrors);
2289
	return ret;
C
Chris Mason 已提交
2290 2291
}

2292
int btrfs_free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root)
C
Chris Mason 已提交
2293
{
2294
	spin_lock(&fs_info->fs_roots_radix_lock);
C
Chris Mason 已提交
2295 2296
	radix_tree_delete(&fs_info->fs_roots_radix,
			  (unsigned long)root->root_key.objectid);
2297
	spin_unlock(&fs_info->fs_roots_radix_lock);
2298 2299 2300 2301

	if (btrfs_root_refs(&root->root_item) == 0)
		synchronize_srcu(&fs_info->subvol_srcu);

2302 2303 2304 2305 2306 2307 2308
	free_fs_root(root);
	return 0;
}

static void free_fs_root(struct btrfs_root *root)
{
	WARN_ON(!RB_EMPTY_ROOT(&root->inode_tree));
2309 2310 2311 2312
	if (root->anon_super.s_dev) {
		down_write(&root->anon_super.s_umount);
		kill_anon_super(&root->anon_super);
	}
2313 2314
	free_extent_buffer(root->node);
	free_extent_buffer(root->commit_root);
C
Chris Mason 已提交
2315
	kfree(root->name);
C
Chris Mason 已提交
2316 2317 2318
	kfree(root);
}

C
Chris Mason 已提交
2319
static int del_fs_roots(struct btrfs_fs_info *fs_info)
2320 2321 2322 2323 2324
{
	int ret;
	struct btrfs_root *gang[8];
	int i;

2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338
	while (!list_empty(&fs_info->dead_roots)) {
		gang[0] = list_entry(fs_info->dead_roots.next,
				     struct btrfs_root, root_list);
		list_del(&gang[0]->root_list);

		if (gang[0]->in_radix) {
			btrfs_free_fs_root(fs_info, gang[0]);
		} else {
			free_extent_buffer(gang[0]->node);
			free_extent_buffer(gang[0]->commit_root);
			kfree(gang[0]);
		}
	}

C
Chris Mason 已提交
2339
	while (1) {
2340 2341 2342 2343 2344
		ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
					     (void **)gang, 0,
					     ARRAY_SIZE(gang));
		if (!ret)
			break;
C
Chris Mason 已提交
2345
		for (i = 0; i < ret; i++)
2346
			btrfs_free_fs_root(fs_info, gang[i]);
2347 2348 2349
	}
	return 0;
}
2350

Y
Yan Zheng 已提交
2351
int btrfs_cleanup_fs_roots(struct btrfs_fs_info *fs_info)
C
Chris Mason 已提交
2352
{
Y
Yan Zheng 已提交
2353 2354 2355
	u64 root_objectid = 0;
	struct btrfs_root *gang[8];
	int i;
2356
	int ret;
2357

Y
Yan Zheng 已提交
2358 2359 2360 2361 2362 2363
	while (1) {
		ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
					     (void **)gang, root_objectid,
					     ARRAY_SIZE(gang));
		if (!ret)
			break;
2364 2365

		root_objectid = gang[ret - 1]->root_key.objectid + 1;
Y
Yan Zheng 已提交
2366 2367 2368 2369 2370 2371 2372 2373
		for (i = 0; i < ret; i++) {
			root_objectid = gang[i]->root_key.objectid;
			btrfs_orphan_cleanup(gang[i]);
		}
		root_objectid++;
	}
	return 0;
}
2374

Y
Yan Zheng 已提交
2375 2376 2377 2378
int btrfs_commit_super(struct btrfs_root *root)
{
	struct btrfs_trans_handle *trans;
	int ret;
2379

Y
Yan Zheng 已提交
2380
	mutex_lock(&root->fs_info->cleaner_mutex);
2381
	btrfs_clean_old_snapshots(root);
Y
Yan Zheng 已提交
2382
	mutex_unlock(&root->fs_info->cleaner_mutex);
C
Chris Mason 已提交
2383
	trans = btrfs_start_transaction(root, 1);
2384
	ret = btrfs_commit_transaction(trans, root);
Y
Yan Zheng 已提交
2385 2386
	BUG_ON(ret);
	/* run commit again to drop the original snapshot */
C
Chris Mason 已提交
2387 2388 2389
	trans = btrfs_start_transaction(root, 1);
	btrfs_commit_transaction(trans, root);
	ret = btrfs_write_and_wait_transaction(NULL, root);
2390
	BUG_ON(ret);
2391

Y
Yan Zheng 已提交
2392
	ret = write_ctree_super(NULL, root, 0);
Y
Yan Zheng 已提交
2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408
	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 已提交
2409 2410
		if (ret)
			printk(KERN_ERR "btrfs: commit super ret %d\n", ret);
Y
Yan Zheng 已提交
2411
	}
2412

2413 2414 2415
	fs_info->closing = 2;
	smp_mb();

C
Chris Mason 已提交
2416
	if (fs_info->delalloc_bytes) {
C
Chris Mason 已提交
2417
		printk(KERN_INFO "btrfs: at unmount delalloc count %llu\n",
2418
		       (unsigned long long)fs_info->delalloc_bytes);
C
Chris Mason 已提交
2419
	}
Y
Yan Zheng 已提交
2420
	if (fs_info->total_ref_cache_size) {
C
Chris Mason 已提交
2421 2422
		printk(KERN_INFO "btrfs: at umount reference cache size %llu\n",
		       (unsigned long long)fs_info->total_ref_cache_size);
Y
Yan Zheng 已提交
2423
	}
2424

2425 2426 2427 2428 2429 2430 2431 2432 2433 2434
	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);
2435

C
Chris Mason 已提交
2436
	btrfs_free_block_groups(root->fs_info);
2437

Y
Yan Zheng 已提交
2438
	del_fs_roots(fs_info);
2439

Y
Yan Zheng 已提交
2440
	iput(fs_info->btree_inode);
2441

2442
	btrfs_stop_workers(&fs_info->fixup_workers);
2443
	btrfs_stop_workers(&fs_info->delalloc_workers);
2444 2445
	btrfs_stop_workers(&fs_info->workers);
	btrfs_stop_workers(&fs_info->endio_workers);
2446
	btrfs_stop_workers(&fs_info->endio_meta_workers);
2447
	btrfs_stop_workers(&fs_info->endio_meta_write_workers);
2448
	btrfs_stop_workers(&fs_info->endio_write_workers);
2449
	btrfs_stop_workers(&fs_info->submit_workers);
2450

2451
	btrfs_close_devices(fs_info->fs_devices);
2452
	btrfs_mapping_tree_free(&fs_info->mapping_tree);
2453

C
Chris Mason 已提交
2454
	bdi_destroy(&fs_info->bdi);
2455
	cleanup_srcu_struct(&fs_info->subvol_srcu);
2456

2457 2458
	kfree(fs_info->extent_root);
	kfree(fs_info->tree_root);
2459 2460
	kfree(fs_info->chunk_root);
	kfree(fs_info->dev_root);
2461
	kfree(fs_info->csum_root);
2462 2463 2464
	return 0;
}

2465
int btrfs_buffer_uptodate(struct extent_buffer *buf, u64 parent_transid)
2466
{
2467
	int ret;
2468
	struct inode *btree_inode = buf->first_page->mapping->host;
2469 2470 2471 2472 2473 2474 2475 2476

	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;
2477 2478 2479
}

int btrfs_set_buffer_uptodate(struct extent_buffer *buf)
C
Chris Mason 已提交
2480
{
2481
	struct inode *btree_inode = buf->first_page->mapping->host;
2482
	return set_extent_buffer_uptodate(&BTRFS_I(btree_inode)->io_tree,
2483 2484
					  buf);
}
2485

2486 2487
void btrfs_mark_buffer_dirty(struct extent_buffer *buf)
{
2488
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
2489 2490
	u64 transid = btrfs_header_generation(buf);
	struct inode *btree_inode = root->fs_info->btree_inode;
2491
	int was_dirty;
2492

2493
	btrfs_assert_tree_locked(buf);
C
Chris Mason 已提交
2494
	if (transid != root->fs_info->generation) {
C
Chris Mason 已提交
2495 2496
		printk(KERN_CRIT "btrfs transid mismatch buffer %llu, "
		       "found %llu running %llu\n",
2497
			(unsigned long long)buf->start,
C
Chris Mason 已提交
2498 2499
			(unsigned long long)transid,
			(unsigned long long)root->fs_info->generation);
C
Chris Mason 已提交
2500 2501
		WARN_ON(1);
	}
2502 2503 2504 2505 2506 2507 2508
	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);
	}
2509 2510
}

2511
void btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr)
C
Chris Mason 已提交
2512
{
2513 2514 2515 2516
	/*
	 * looks as though older kernels can get into trouble with
	 * this code, they end up stuck in balance_dirty_pages forever
	 */
2517
	u64 num_dirty;
2518
	unsigned long thresh = 32 * 1024 * 1024;
2519

2520
	if (current->flags & PF_MEMALLOC)
2521 2522
		return;

2523 2524
	num_dirty = root->fs_info->dirty_metadata_bytes;

2525 2526
	if (num_dirty > thresh) {
		balance_dirty_pages_ratelimited_nr(
C
Chris Mason 已提交
2527
				   root->fs_info->btree_inode->i_mapping, 1);
2528
	}
2529
	return;
C
Chris Mason 已提交
2530
}
2531

2532
int btrfs_read_buffer(struct extent_buffer *buf, u64 parent_transid)
2533
{
2534
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
2535
	int ret;
2536
	ret = btree_read_extent_buffer_pages(root, buf, 0, parent_transid);
C
Chris Mason 已提交
2537
	if (ret == 0)
2538
		set_bit(EXTENT_BUFFER_UPTODATE, &buf->bflags);
2539
	return ret;
2540
}
2541

C
Chris Mason 已提交
2542 2543 2544
int btree_lock_page_hook(struct page *page)
{
	struct inode *inode = page->mapping->host;
2545
	struct btrfs_root *root = BTRFS_I(inode)->root;
C
Chris Mason 已提交
2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560
	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);
2561 2562 2563 2564 2565 2566 2567 2568 2569 2570

	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 已提交
2571 2572 2573 2574 2575 2576 2577
	btrfs_tree_unlock(eb);
	free_extent_buffer(eb);
out:
	lock_page(page);
	return 0;
}

2578
static struct extent_io_ops btree_extent_io_ops = {
C
Chris Mason 已提交
2579
	.write_cache_pages_lock_hook = btree_lock_page_hook,
2580
	.readpage_end_io_hook = btree_readpage_end_io_hook,
2581
	.submit_bio_hook = btree_submit_bio_hook,
2582 2583
	/* note we're sharing with inode.c for the merge bio hook */
	.merge_bio_hook = btrfs_merge_bio_hook,
2584
};