disk-io.c 45.9 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>
25
#include <linux/buffer_head.h> // for block_sync_page
26
#include <linux/workqueue.h>
27
#include "crc32c.h"
28 29
#include "ctree.h"
#include "disk-io.h"
30
#include "transaction.h"
31
#include "btrfs_inode.h"
32
#include "volumes.h"
33
#include "print-tree.h"
34

35 36
#if 0
static int check_tree_block(struct btrfs_root *root, struct extent_buffer *buf)
37
{
38 39 40 41
	if (extent_buffer_blocknr(buf) != btrfs_header_blocknr(buf)) {
		printk(KERN_CRIT "buf blocknr(buf) is %llu, header is %llu\n",
		       (unsigned long long)extent_buffer_blocknr(buf),
		       (unsigned long long)btrfs_header_blocknr(buf));
C
Chris Mason 已提交
42
		return 1;
43
	}
44
	return 0;
45
}
46
#endif
47

48
static struct extent_io_ops btree_extent_io_ops;
49
static struct workqueue_struct *end_io_workqueue;
50
static struct workqueue_struct *async_submit_workqueue;
51 52 53 54 55 56 57

struct end_io_wq {
	struct bio *bio;
	bio_end_io_t *end_io;
	void *private;
	struct btrfs_fs_info *info;
	int error;
58
	int metadata;
59 60
	struct list_head list;
};
61

62 63 64 65 66 67 68 69 70
struct async_submit_bio {
	struct inode *inode;
	struct bio *bio;
	struct list_head list;
	extent_submit_bio_hook_t *submit_bio_hook;
	int rw;
	int mirror_num;
};

71
struct extent_map *btree_get_extent(struct inode *inode, struct page *page,
72
				    size_t page_offset, u64 start, u64 len,
73
				    int create)
74
{
75 76 77 78
	struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
	struct extent_map *em;
	int ret;

79 80 81
	spin_lock(&em_tree->lock);
	em = lookup_extent_mapping(em_tree, start, len);
	spin_unlock(&em_tree->lock);
82
	if (em)
83
		goto out;
84

85 86 87 88 89 90
	em = alloc_extent_map(GFP_NOFS);
	if (!em) {
		em = ERR_PTR(-ENOMEM);
		goto out;
	}
	em->start = 0;
91
	em->len = (u64)-1;
92 93
	em->block_start = 0;
	em->bdev = inode->i_sb->s_bdev;
94 95

	spin_lock(&em_tree->lock);
96 97
	ret = add_extent_mapping(em_tree, em);
	if (ret == -EEXIST) {
98 99 100 101 102
		u64 failed_start = em->start;
		u64 failed_len = em->len;

		printk("failed to insert %Lu %Lu -> %Lu into tree\n",
		       em->start, em->len, em->block_start);
103
		free_extent_map(em);
104
		em = lookup_extent_mapping(em_tree, start, len);
105 106 107
		if (em) {
			printk("after failing, found %Lu %Lu %Lu\n",
			       em->start, em->len, em->block_start);
108
			ret = 0;
109 110 111 112 113 114 115 116 117
		} else {
			em = lookup_extent_mapping(em_tree, failed_start,
						   failed_len);
			if (em) {
				printk("double failure lookup gives us "
				       "%Lu %Lu -> %Lu\n", em->start,
				       em->len, em->block_start);
				free_extent_map(em);
			}
118
			ret = -EIO;
119
		}
120
	} else if (ret) {
121 122
		free_extent_map(em);
		em = NULL;
123
	}
124 125 126 127
	spin_unlock(&em_tree->lock);

	if (ret)
		em = ERR_PTR(ret);
128 129
out:
	return em;
130 131
}

132 133
u32 btrfs_csum_data(struct btrfs_root *root, char *data, u32 seed, size_t len)
{
134
	return btrfs_crc32c(seed, data, len);
135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175
}

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

static int csum_tree_block(struct btrfs_root *root, struct extent_buffer *buf,
			   int verify)
{
	char result[BTRFS_CRC32_SIZE];
	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;

	len = buf->len - offset;
	while(len > 0) {
		err = map_private_extent_buffer(buf, offset, 32,
					&map_token, &kaddr,
					&map_start, &map_len, KM_USER0);
		if (err) {
			printk("failed to map extent buffer! %lu\n",
			       offset);
			return 1;
		}
		cur_len = min(len, map_len - (offset - map_start));
		crc = btrfs_csum_data(root, kaddr + offset - map_start,
				      crc, cur_len);
		len -= cur_len;
		offset += cur_len;
		unmap_extent_buffer(buf, map_token, KM_USER0);
	}
	btrfs_csum_final(crc, result);

	if (verify) {
176 177 178 179 180 181 182 183
		int from_this_trans = 0;

		if (root->fs_info->running_transaction &&
		    btrfs_header_generation(buf) ==
		    root->fs_info->running_transaction->transid)
			from_this_trans = 1;

		/* FIXME, this is not good */
184
		if (memcmp_extent_buffer(buf, result, 0, BTRFS_CRC32_SIZE)) {
185 186 187 188 189 190
			u32 val;
			u32 found = 0;
			memcpy(&found, result, BTRFS_CRC32_SIZE);

			read_extent_buffer(buf, &val, 0, BTRFS_CRC32_SIZE);
			printk("btrfs: %s checksum verify failed on %llu "
191 192
			       "wanted %X found %X from_this_trans %d "
			       "level %d\n",
193
			       root->fs_info->sb->s_id,
194 195
			       buf->start, val, found, from_this_trans,
			       btrfs_header_level(buf));
196 197 198 199 200 201 202 203
			return 1;
		}
	} else {
		write_extent_buffer(buf, result, 0, BTRFS_CRC32_SIZE);
	}
	return 0;
}

204 205 206 207 208 209 210 211 212 213 214 215 216
static int btree_read_extent_buffer_pages(struct btrfs_root *root,
					  struct extent_buffer *eb,
					  u64 start)
{
	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);
C
Chris Mason 已提交
217
		if (!ret)
218
			return ret;
C
Chris Mason 已提交
219

220 221
		num_copies = btrfs_num_copies(&root->fs_info->mapping_tree,
					      eb->start, eb->len);
C
Chris Mason 已提交
222
		if (num_copies == 1)
223
			return ret;
C
Chris Mason 已提交
224

225
		mirror_num++;
C
Chris Mason 已提交
226
		if (mirror_num > num_copies)
227 228 229 230
			return ret;
	}
	return -EIO;
}
231 232 233

int csum_dirty_buffer(struct btrfs_root *root, struct page *page)
{
234
	struct extent_io_tree *tree;
235
	u64 start = (u64)page->index << PAGE_CACHE_SHIFT;
236 237 238 239
	u64 found_start;
	int found_level;
	unsigned long len;
	struct extent_buffer *eb;
240 241
	int ret;

242
	tree = &BTRFS_I(page->mapping->host)->io_tree;
243 244 245 246 247 248 249 250 251 252

	if (page->private == EXTENT_PAGE_PRIVATE)
		goto out;
	if (!page->private)
		goto out;
	len = page->private >> 2;
	if (len == 0) {
		WARN_ON(1);
	}
	eb = alloc_extent_buffer(tree, start, len, page, GFP_NOFS);
253 254
	ret = btree_read_extent_buffer_pages(root, eb, start + PAGE_CACHE_SIZE);
	BUG_ON(ret);
255
	btrfs_clear_buffer_defrag(eb);
256 257 258 259
	found_start = btrfs_header_bytenr(eb);
	if (found_start != start) {
		printk("warning: eb start incorrect %Lu buffer %Lu len %lu\n",
		       start, found_start, len);
260 261 262 263 264 265 266 267 268 269 270 271 272
		WARN_ON(1);
		goto err;
	}
	if (eb->first_page != page) {
		printk("bad first page %lu %lu\n", eb->first_page->index,
		       page->index);
		WARN_ON(1);
		goto err;
	}
	if (!PageUptodate(page)) {
		printk("csum not up to date page %lu\n", page->index);
		WARN_ON(1);
		goto err;
273 274
	}
	found_level = btrfs_header_level(eb);
275 276 277
	spin_lock(&root->fs_info->hash_lock);
	btrfs_set_header_flag(eb, BTRFS_HEADER_FLAG_WRITTEN);
	spin_unlock(&root->fs_info->hash_lock);
278
	csum_tree_block(root, eb, 0);
279
err:
280 281 282 283 284
	free_extent_buffer(eb);
out:
	return 0;
}

285
static int btree_writepage_io_hook(struct page *page, u64 start, u64 end)
286
{
287 288 289
	struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;

	csum_dirty_buffer(root, page);
290 291 292
	return 0;
}

293 294 295 296 297 298 299 300 301
int btree_readpage_end_io_hook(struct page *page, u64 start, u64 end,
			       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;
302
	int ret = 0;
303 304 305 306 307 308 309 310 311 312 313

	tree = &BTRFS_I(page->mapping->host)->io_tree;
	if (page->private == EXTENT_PAGE_PRIVATE)
		goto out;
	if (!page->private)
		goto out;
	len = page->private >> 2;
	if (len == 0) {
		WARN_ON(1);
	}
	eb = alloc_extent_buffer(tree, start, len, page, GFP_NOFS);
314

315 316 317
	btrfs_clear_buffer_defrag(eb);
	found_start = btrfs_header_bytenr(eb);
	if (found_start != start) {
318
		ret = -EIO;
319 320 321 322 323 324
		goto err;
	}
	if (eb->first_page != page) {
		printk("bad first page %lu %lu\n", eb->first_page->index,
		       page->index);
		WARN_ON(1);
325
		ret = -EIO;
326 327 328 329 330
		goto err;
	}
	found_level = btrfs_header_level(eb);

	ret = csum_tree_block(root, eb, 1);
331 332
	if (ret)
		ret = -EIO;
333 334 335 336 337 338 339

	end = min_t(u64, eb->len, PAGE_CACHE_SIZE);
	end = eb->start + end - 1;
	release_extent_buffer_tail_pages(eb);
err:
	free_extent_buffer(eb);
out:
340
	return ret;
341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370
}

#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,23)
static void end_workqueue_bio(struct bio *bio, int err)
#else
static int end_workqueue_bio(struct bio *bio,
				   unsigned int bytes_done, int err)
#endif
{
	struct end_io_wq *end_io_wq = bio->bi_private;
	struct btrfs_fs_info *fs_info;
	unsigned long flags;

#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,23)
	if (bio->bi_size)
		return 1;
#endif

	fs_info = end_io_wq->info;
	spin_lock_irqsave(&fs_info->end_io_work_lock, flags);
	end_io_wq->error = err;
	list_add_tail(&end_io_wq->list, &fs_info->end_io_work_list);
	spin_unlock_irqrestore(&fs_info->end_io_work_lock, flags);
	queue_work(end_io_workqueue, &fs_info->end_io_work);

#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,23)
	return 0;
#endif
}

371 372
int btrfs_bio_wq_end_io(struct btrfs_fs_info *info, struct bio *bio,
			int metadata)
373
{
374 375 376 377 378 379 380
	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;
381
	end_io_wq->info = info;
382 383
	end_io_wq->error = 0;
	end_io_wq->bio = bio;
384
	end_io_wq->metadata = metadata;
385 386 387

	bio->bi_private = end_io_wq;
	bio->bi_end_io = end_workqueue_bio;
388 389 390
	return 0;
}

391 392 393 394 395 396
int btrfs_wq_submit_bio(struct btrfs_fs_info *fs_info, struct inode *inode,
			int rw, struct bio *bio, int mirror_num,
			extent_submit_bio_hook_t *submit_bio_hook)
{
	struct async_submit_bio *async;

397 398 399 400 401 402 403
	/*
	 * inline writerback should stay inline, only hop to the async
	 * queue if we're pdflush
	 */
	if (!current_is_pdflush())
		return submit_bio_hook(inode, rw, bio, mirror_num);

404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422
	async = kmalloc(sizeof(*async), GFP_NOFS);
	if (!async)
		return -ENOMEM;

	async->inode = inode;
	async->rw = rw;
	async->bio = bio;
	async->mirror_num = mirror_num;
	async->submit_bio_hook = submit_bio_hook;

	spin_lock(&fs_info->async_submit_work_lock);
	list_add_tail(&async->list, &fs_info->async_submit_work_list);
	spin_unlock(&fs_info->async_submit_work_lock);

	queue_work(async_submit_workqueue, &fs_info->async_submit_work);
	return 0;
}

static int __btree_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
423
				 int mirror_num)
424 425 426 427 428 429 430 431
{
	struct btrfs_root *root = BTRFS_I(inode)->root;
	u64 offset;
	int ret;

	offset = bio->bi_sector << 9;

	if (rw & (1 << BIO_RW)) {
432
		return btrfs_map_bio(BTRFS_I(inode)->root, rw, bio, mirror_num);
433 434 435 436
	}

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

438
	if (offset == BTRFS_SUPER_INFO_OFFSET) {
439
		bio->bi_bdev = root->fs_info->fs_devices->latest_bdev;
440 441 442
		submit_bio(rw, bio);
		return 0;
	}
443
	return btrfs_map_bio(BTRFS_I(inode)->root, rw, bio, mirror_num);
444 445
}

446 447 448 449 450 451 452 453 454 455 456
static int btree_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
				 int mirror_num)
{
	if (!(rw & (1 << BIO_RW))) {
		return __btree_submit_bio_hook(inode, rw, bio, mirror_num);
	}
	return btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,
				   inode, rw, bio, mirror_num,
				   __btree_submit_bio_hook);
}

457 458
static int btree_writepage(struct page *page, struct writeback_control *wbc)
{
459 460
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
461 462
	return extent_write_full_page(tree, page, btree_get_extent, wbc);
}
463 464 465 466

static int btree_writepages(struct address_space *mapping,
			    struct writeback_control *wbc)
{
467 468
	struct extent_io_tree *tree;
	tree = &BTRFS_I(mapping->host)->io_tree;
469
	if (wbc->sync_mode == WB_SYNC_NONE) {
470 471 472
		u64 num_dirty;
		u64 start = 0;
		unsigned long thresh = 96 * 1024 * 1024;
473 474 475 476

		if (wbc->for_kupdate)
			return 0;

477 478 479 480 481
		if (current_is_pdflush()) {
			thresh = 96 * 1024 * 1024;
		} else {
			thresh = 8 * 1024 * 1024;
		}
482 483
		num_dirty = count_range_bits(tree, &start, (u64)-1,
					     thresh, EXTENT_DIRTY);
484 485 486 487
		if (num_dirty < thresh) {
			return 0;
		}
	}
488 489 490
	return extent_writepages(tree, mapping, btree_get_extent, wbc);
}

491 492
int btree_readpage(struct file *file, struct page *page)
{
493 494
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
495 496
	return extent_read_full_page(tree, page, btree_get_extent);
}
C
Chris Mason 已提交
497

498
static int btree_releasepage(struct page *page, gfp_t gfp_flags)
499
{
500 501
	struct extent_io_tree *tree;
	struct extent_map_tree *map;
502
	int ret;
503

504 505 506 507 508 509
	if (page_count(page) > 3) {
		/* once for page->private, once for the caller, once
		 * once for the page cache
		 */
		return 0;
	}
510 511
	tree = &BTRFS_I(page->mapping->host)->io_tree;
	map = &BTRFS_I(page->mapping->host)->extent_tree;
512
	ret = try_release_extent_state(map, tree, page, gfp_flags);
513
	if (ret == 1) {
514
		invalidate_extent_lru(tree, page_offset(page), PAGE_CACHE_SIZE);
515 516 517 518
		ClearPagePrivate(page);
		set_page_private(page, 0);
		page_cache_release(page);
	}
519 520 521
	return ret;
}

522
static void btree_invalidatepage(struct page *page, unsigned long offset)
523
{
524 525
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
526 527
	extent_invalidatepage(tree, page, offset);
	btree_releasepage(page, GFP_NOFS);
528
	if (PagePrivate(page)) {
529
		invalidate_extent_lru(tree, page_offset(page), PAGE_CACHE_SIZE);
530 531 532 533
		ClearPagePrivate(page);
		set_page_private(page, 0);
		page_cache_release(page);
	}
534 535
}

536
#if 0
537
static int btree_writepage(struct page *page, struct writeback_control *wbc)
538
{
C
Chris Mason 已提交
539
	struct buffer_head *bh;
540
	struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
C
Chris Mason 已提交
541 542 543 544 545 546 547 548 549 550 551 552
	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);
553
	return block_write_full_page(page, btree_get_block, wbc);
554
}
555
#endif
556

557 558 559
static struct address_space_operations btree_aops = {
	.readpage	= btree_readpage,
	.writepage	= btree_writepage,
560
	.writepages	= btree_writepages,
561 562
	.releasepage	= btree_releasepage,
	.invalidatepage = btree_invalidatepage,
563 564 565
	.sync_page	= block_sync_page,
};

566
int readahead_tree_block(struct btrfs_root *root, u64 bytenr, u32 blocksize)
C
Chris Mason 已提交
567
{
568 569
	struct extent_buffer *buf = NULL;
	struct inode *btree_inode = root->fs_info->btree_inode;
570
	int ret = 0;
C
Chris Mason 已提交
571

572
	buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
573
	if (!buf)
C
Chris Mason 已提交
574
		return 0;
575
	read_extent_buffer_pages(&BTRFS_I(btree_inode)->io_tree,
576
				 buf, 0, 0, btree_get_extent, 0);
577
	free_extent_buffer(buf);
578
	return ret;
C
Chris Mason 已提交
579 580
}

581 582 583 584 585 586
static int close_all_devices(struct btrfs_fs_info *fs_info)
{
	struct list_head *list;
	struct list_head *next;
	struct btrfs_device *device;

587 588
	list = &fs_info->fs_devices->devices;
	list_for_each(next, list) {
589
		device = list_entry(next, struct btrfs_device, dev_list);
590 591 592
		if (device->bdev && device->bdev != fs_info->sb->s_bdev)
			close_bdev_excl(device->bdev);
		device->bdev = NULL;
593 594 595 596
	}
	return 0;
}

597 598
int btrfs_verify_block_csum(struct btrfs_root *root,
			    struct extent_buffer *buf)
599
{
600
	return btrfs_buffer_uptodate(buf);
601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638
}

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


struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 bytenr,
				      u32 blocksize)
{
	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;

639
	ret = btree_read_extent_buffer_pages(root, buf, 0);
640 641 642 643

	if (ret == 0) {
		buf->flags |= EXTENT_UPTODATE;
	}
644
	return buf;
645

646 647
}

648
int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
649
		     struct extent_buffer *buf)
650
{
651
	struct inode *btree_inode = root->fs_info->btree_inode;
652 653
	if (btrfs_header_generation(buf) ==
	    root->fs_info->running_transaction->transid)
654
		clear_extent_buffer_dirty(&BTRFS_I(btree_inode)->io_tree,
655
					  buf);
656 657 658 659 660 661 662
	return 0;
}

int wait_on_tree_block_writeback(struct btrfs_root *root,
				 struct extent_buffer *buf)
{
	struct inode *btree_inode = root->fs_info->btree_inode;
663
	wait_on_extent_buffer_writeback(&BTRFS_I(btree_inode)->io_tree,
664 665 666 667
					buf);
	return 0;
}

668
static int __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize,
669
			u32 stripesize, struct btrfs_root *root,
670
			struct btrfs_fs_info *fs_info,
C
Chris Mason 已提交
671
			u64 objectid)
672
{
C
Chris Mason 已提交
673
	root->node = NULL;
674
	root->inode = NULL;
675
	root->commit_root = NULL;
676 677 678
	root->sectorsize = sectorsize;
	root->nodesize = nodesize;
	root->leafsize = leafsize;
679
	root->stripesize = stripesize;
C
Chris Mason 已提交
680
	root->ref_cows = 0;
681 682
	root->track_dirty = 0;

683
	root->fs_info = fs_info;
684 685
	root->objectid = objectid;
	root->last_trans = 0;
C
Chris Mason 已提交
686 687
	root->highest_inode = 0;
	root->last_inode_alloc = 0;
688
	root->name = NULL;
689
	root->in_sysfs = 0;
690 691

	INIT_LIST_HEAD(&root->dirty_list);
692 693
	memset(&root->root_key, 0, sizeof(root->root_key));
	memset(&root->root_item, 0, sizeof(root->root_item));
694
	memset(&root->defrag_progress, 0, sizeof(root->defrag_progress));
695 696
	memset(&root->root_kobj, 0, sizeof(root->root_kobj));
	init_completion(&root->kobj_unregister);
697 698
	root->defrag_running = 0;
	root->defrag_level = 0;
699
	root->root_key.objectid = objectid;
700 701 702
	return 0;
}

703
static int find_and_setup_root(struct btrfs_root *tree_root,
704 705
			       struct btrfs_fs_info *fs_info,
			       u64 objectid,
C
Chris Mason 已提交
706
			       struct btrfs_root *root)
707 708
{
	int ret;
709
	u32 blocksize;
710

711
	__setup_root(tree_root->nodesize, tree_root->leafsize,
712 713
		     tree_root->sectorsize, tree_root->stripesize,
		     root, fs_info, objectid);
714 715 716 717
	ret = btrfs_find_last_root(tree_root, objectid,
				   &root->root_item, &root->root_key);
	BUG_ON(ret);

718 719 720
	blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
	root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
				     blocksize);
721
	BUG_ON(!root->node);
722 723 724
	return 0;
}

725 726
struct btrfs_root *btrfs_read_fs_root_no_radix(struct btrfs_fs_info *fs_info,
					       struct btrfs_key *location)
727 728 729 730
{
	struct btrfs_root *root;
	struct btrfs_root *tree_root = fs_info->tree_root;
	struct btrfs_path *path;
731
	struct extent_buffer *l;
C
Chris Mason 已提交
732
	u64 highest_inode;
733
	u32 blocksize;
734 735
	int ret = 0;

736
	root = kzalloc(sizeof(*root), GFP_NOFS);
C
Chris Mason 已提交
737
	if (!root)
738 739
		return ERR_PTR(-ENOMEM);
	if (location->offset == (u64)-1) {
740
		ret = find_and_setup_root(tree_root, fs_info,
741 742 743 744 745 746 747 748
					  location->objectid, root);
		if (ret) {
			kfree(root);
			return ERR_PTR(ret);
		}
		goto insert;
	}

749
	__setup_root(tree_root->nodesize, tree_root->leafsize,
750 751
		     tree_root->sectorsize, tree_root->stripesize,
		     root, fs_info, location->objectid);
752 753 754 755 756 757 758 759 760

	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;
	}
761 762 763
	l = path->nodes[0];
	read_extent_buffer(l, &root->root_item,
	       btrfs_item_ptr_offset(l, path->slots[0]),
764
	       sizeof(root->root_item));
765
	memcpy(&root->root_key, location, sizeof(*location));
766 767 768 769 770 771 772 773
	ret = 0;
out:
	btrfs_release_path(root, path);
	btrfs_free_path(path);
	if (ret) {
		kfree(root);
		return ERR_PTR(ret);
	}
774 775 776
	blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
	root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
				     blocksize);
777 778 779
	BUG_ON(!root->node);
insert:
	root->ref_cows = 1;
780 781 782 783 784 785 786 787
	ret = btrfs_find_highest_inode(root, &highest_inode);
	if (ret == 0) {
		root->highest_inode = highest_inode;
		root->last_inode_alloc = highest_inode;
	}
	return root;
}

C
Chris Mason 已提交
788 789 790 791 792 793 794 795 796 797 798 799 800 801 802
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;
}

803 804
struct btrfs_root *btrfs_read_fs_root_no_name(struct btrfs_fs_info *fs_info,
					      struct btrfs_key *location)
805 806 807 808
{
	struct btrfs_root *root;
	int ret;

809 810 811 812
	if (location->objectid == BTRFS_ROOT_TREE_OBJECTID)
		return fs_info->tree_root;
	if (location->objectid == BTRFS_EXTENT_TREE_OBJECTID)
		return fs_info->extent_root;
813 814 815 816
	if (location->objectid == BTRFS_CHUNK_TREE_OBJECTID)
		return fs_info->chunk_root;
	if (location->objectid == BTRFS_DEV_TREE_OBJECTID)
		return fs_info->dev_root;
817

818 819 820 821 822 823 824 825
	root = radix_tree_lookup(&fs_info->fs_roots_radix,
				 (unsigned long)location->objectid);
	if (root)
		return root;

	root = btrfs_read_fs_root_no_radix(fs_info, location);
	if (IS_ERR(root))
		return root;
C
Chris Mason 已提交
826 827
	ret = radix_tree_insert(&fs_info->fs_roots_radix,
				(unsigned long)root->root_key.objectid,
828 829
				root);
	if (ret) {
830
		free_extent_buffer(root->node);
831 832 833
		kfree(root);
		return ERR_PTR(ret);
	}
834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850
	ret = btrfs_find_dead_roots(fs_info->tree_root,
				    root->root_key.objectid, root);
	BUG_ON(ret);

	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;
851

852 853 854
	if (root->in_sysfs)
		return root;

855 856
	ret = btrfs_set_root_name(root, name, namelen);
	if (ret) {
857
		free_extent_buffer(root->node);
858 859 860 861 862 863
		kfree(root);
		return ERR_PTR(ret);
	}

	ret = btrfs_sysfs_add_root(root);
	if (ret) {
864
		free_extent_buffer(root->node);
865 866 867 868
		kfree(root->name);
		kfree(root);
		return ERR_PTR(ret);
	}
869
	root->in_sysfs = 1;
870 871
	return root;
}
872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889
#if 0
static int add_hasher(struct btrfs_fs_info *info, char *type) {
	struct btrfs_hasher *hasher;

	hasher = kmalloc(sizeof(*hasher), GFP_NOFS);
	if (!hasher)
		return -ENOMEM;
	hasher->hash_tfm = crypto_alloc_hash(type, 0, CRYPTO_ALG_ASYNC);
	if (!hasher->hash_tfm) {
		kfree(hasher);
		return -EINVAL;
	}
	spin_lock(&info->hash_lock);
	list_add(&hasher->list, &info->hashers);
	spin_unlock(&info->hash_lock);
	return 0;
}
#endif
C
Chris Mason 已提交
890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909

static int btrfs_congested_fn(void *congested_data, int bdi_bits)
{
	struct btrfs_fs_info *info = (struct btrfs_fs_info *)congested_data;
	int ret = 0;
	struct list_head *cur;
	struct btrfs_device *device;
	struct backing_dev_info *bdi;

	list_for_each(cur, &info->fs_devices->devices) {
		device = list_entry(cur, struct btrfs_device, dev_list);
		bdi = blk_get_backing_dev_info(device->bdev);
		if (bdi && bdi_congested(bdi, bdi_bits)) {
			ret = 1;
			break;
		}
	}
	return ret;
}

910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929
/*
 * this unplugs every device on the box, and it is only used when page
 * is null
 */
static void __unplug_io_fn(struct backing_dev_info *bdi, struct page *page)
{
	struct list_head *cur;
	struct btrfs_device *device;
	struct btrfs_fs_info *info;

	info = (struct btrfs_fs_info *)bdi->unplug_io_data;
	list_for_each(cur, &info->fs_devices->devices) {
		device = list_entry(cur, struct btrfs_device, dev_list);
		bdi = blk_get_backing_dev_info(device->bdev);
		if (bdi->unplug_io_fn) {
			bdi->unplug_io_fn(bdi, page);
		}
	}
}

C
Chris Mason 已提交
930 931
void btrfs_unplug_io_fn(struct backing_dev_info *bdi, struct page *page)
{
932
	struct inode *inode;
933 934
	struct extent_map_tree *em_tree;
	struct extent_map *em;
935
	struct address_space *mapping;
936 937
	u64 offset;

938
	/* the generic O_DIRECT read code does this */
939 940 941 942 943
	if (!page) {
		__unplug_io_fn(bdi, page);
		return;
	}

944 945 946 947 948 949 950 951 952 953
	/*
	 * 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;
954
	offset = page_offset(page);
C
Chris Mason 已提交
955

956 957 958 959 960 961 962 963 964 965 966
	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);
	if (!em)
		return;

	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 已提交
967 968 969 970
}

static int setup_bdi(struct btrfs_fs_info *info, struct backing_dev_info *bdi)
{
971
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23)
C
Chris Mason 已提交
972
	bdi_init(bdi);
973
#endif
974
	bdi->ra_pages	= default_backing_dev_info.ra_pages;
C
Chris Mason 已提交
975 976 977 978 979 980 981 982 983
	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;
}

984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023
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;
}

#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
1024
static void btrfs_end_io_csum(void *p)
1025
#else
1026
static void btrfs_end_io_csum(struct work_struct *work)
1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056
#endif
{
#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
	struct btrfs_fs_info *fs_info = p;
#else
	struct btrfs_fs_info *fs_info = container_of(work,
						     struct btrfs_fs_info,
						     end_io_work);
#endif
	unsigned long flags;
	struct end_io_wq *end_io_wq;
	struct bio *bio;
	struct list_head *next;
	int error;
	int was_empty;

	while(1) {
		spin_lock_irqsave(&fs_info->end_io_work_lock, flags);
		if (list_empty(&fs_info->end_io_work_list)) {
			spin_unlock_irqrestore(&fs_info->end_io_work_lock,
					       flags);
			return;
		}
		next = fs_info->end_io_work_list.next;
		list_del(next);
		spin_unlock_irqrestore(&fs_info->end_io_work_lock, flags);

		end_io_wq = list_entry(next, struct end_io_wq, list);

		bio = end_io_wq->bio;
1057
		if (end_io_wq->metadata && !bio_ready_for_csum(bio)) {
1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071
			spin_lock_irqsave(&fs_info->end_io_work_lock, flags);
			was_empty = list_empty(&fs_info->end_io_work_list);
			list_add_tail(&end_io_wq->list,
				      &fs_info->end_io_work_list);
			spin_unlock_irqrestore(&fs_info->end_io_work_lock,
					       flags);
			if (was_empty)
				return;
			continue;
		}
		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);
1072
#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,23)
1073
		bio_endio(bio, bio->bi_size, error);
1074
#else
1075
		bio_endio(bio, error);
1076
#endif
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 1106 1107 1108 1109 1110 1111 1112
#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
static void btrfs_async_submit_work(void *p)
#else
static void btrfs_async_submit_work(struct work_struct *work)
#endif
{
#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
	struct btrfs_fs_info *fs_info = p;
#else
	struct btrfs_fs_info *fs_info = container_of(work,
						     struct btrfs_fs_info,
						     async_submit_work);
#endif
	struct async_submit_bio *async;
	struct list_head *next;

	while(1) {
		spin_lock(&fs_info->async_submit_work_lock);
		if (list_empty(&fs_info->async_submit_work_list)) {
			spin_unlock(&fs_info->async_submit_work_lock);
			return;
		}
		next = fs_info->async_submit_work_list.next;
		list_del(next);
		spin_unlock(&fs_info->async_submit_work_lock);

		async = list_entry(next, struct async_submit_bio, list);
		async->submit_bio_hook(async->inode, async->rw, async->bio,
				       async->mirror_num);
		kfree(async);
	}
}

1113 1114
struct btrfs_root *open_ctree(struct super_block *sb,
			      struct btrfs_fs_devices *fs_devices)
1115
{
1116 1117 1118 1119
	u32 sectorsize;
	u32 nodesize;
	u32 leafsize;
	u32 blocksize;
1120
	u32 stripesize;
C
Chris Mason 已提交
1121 1122 1123 1124
	struct btrfs_root *extent_root = kmalloc(sizeof(struct btrfs_root),
						 GFP_NOFS);
	struct btrfs_root *tree_root = kmalloc(sizeof(struct btrfs_root),
					       GFP_NOFS);
1125
	struct btrfs_fs_info *fs_info = kzalloc(sizeof(*fs_info),
C
Chris Mason 已提交
1126
						GFP_NOFS);
1127 1128 1129 1130
	struct btrfs_root *chunk_root = kmalloc(sizeof(struct btrfs_root),
						GFP_NOFS);
	struct btrfs_root *dev_root = kmalloc(sizeof(struct btrfs_root),
					      GFP_NOFS);
1131
	int ret;
1132
	int err = -EINVAL;
C
Chris Mason 已提交
1133
	struct btrfs_super_block *disk_super;
1134

C
Chris Mason 已提交
1135 1136 1137 1138
	if (!extent_root || !tree_root || !fs_info) {
		err = -ENOMEM;
		goto fail;
	}
1139 1140
	end_io_workqueue = create_workqueue("btrfs-end-io");
	BUG_ON(!end_io_workqueue);
1141
	async_submit_workqueue = create_workqueue("btrfs-async-submit");
1142

1143
	INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_NOFS);
C
Chris Mason 已提交
1144
	INIT_LIST_HEAD(&fs_info->trans_list);
1145
	INIT_LIST_HEAD(&fs_info->dead_roots);
1146
	INIT_LIST_HEAD(&fs_info->hashers);
1147
	INIT_LIST_HEAD(&fs_info->end_io_work_list);
1148
	INIT_LIST_HEAD(&fs_info->async_submit_work_list);
1149
	spin_lock_init(&fs_info->hash_lock);
1150
	spin_lock_init(&fs_info->end_io_work_lock);
1151
	spin_lock_init(&fs_info->async_submit_work_lock);
1152
	spin_lock_init(&fs_info->delalloc_lock);
1153
	spin_lock_init(&fs_info->new_trans_lock);
1154

1155
	init_completion(&fs_info->kobj_unregister);
1156
	sb_set_blocksize(sb, BTRFS_SUPER_INFO_SIZE);
1157 1158
	fs_info->tree_root = tree_root;
	fs_info->extent_root = extent_root;
1159 1160
	fs_info->chunk_root = chunk_root;
	fs_info->dev_root = dev_root;
1161
	fs_info->fs_devices = fs_devices;
1162
	INIT_LIST_HEAD(&fs_info->dirty_cowonly_roots);
1163
	INIT_LIST_HEAD(&fs_info->space_info);
1164
	btrfs_mapping_init(&fs_info->mapping_tree);
C
Chris Mason 已提交
1165
	fs_info->sb = sb;
1166
	fs_info->max_extent = (u64)-1;
1167
	fs_info->max_inline = 8192 * 1024;
C
Chris Mason 已提交
1168
	setup_bdi(fs_info, &fs_info->bdi);
1169 1170
	fs_info->btree_inode = new_inode(sb);
	fs_info->btree_inode->i_ino = 1;
C
Chris Mason 已提交
1171
	fs_info->btree_inode->i_nlink = 1;
1172 1173 1174 1175 1176 1177 1178

	/*
	 * 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;
1179
	fs_info->btree_inode->i_mapping->a_ops = &btree_aops;
C
Chris Mason 已提交
1180 1181
	fs_info->btree_inode->i_mapping->backing_dev_info = &fs_info->bdi;

1182
	extent_io_tree_init(&BTRFS_I(fs_info->btree_inode)->io_tree,
1183 1184
			     fs_info->btree_inode->i_mapping,
			     GFP_NOFS);
1185 1186 1187 1188
	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;
1189

1190
	extent_io_tree_init(&fs_info->free_space_cache,
1191
			     fs_info->btree_inode->i_mapping, GFP_NOFS);
1192
	extent_io_tree_init(&fs_info->block_group_cache,
1193
			     fs_info->btree_inode->i_mapping, GFP_NOFS);
1194
	extent_io_tree_init(&fs_info->pinned_extents,
1195
			     fs_info->btree_inode->i_mapping, GFP_NOFS);
1196
	extent_io_tree_init(&fs_info->pending_del,
1197
			     fs_info->btree_inode->i_mapping, GFP_NOFS);
1198
	extent_io_tree_init(&fs_info->extent_ins,
1199
			     fs_info->btree_inode->i_mapping, GFP_NOFS);
1200
	fs_info->do_barriers = 1;
1201

1202
#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
1203
	INIT_WORK(&fs_info->end_io_work, btrfs_end_io_csum, fs_info);
1204 1205
	INIT_WORK(&fs_info->async_submit_work, btrfs_async_submit_work,
		  fs_info);
1206 1207
	INIT_WORK(&fs_info->trans_work, btrfs_transaction_cleaner, fs_info);
#else
1208
	INIT_WORK(&fs_info->end_io_work, btrfs_end_io_csum);
1209
	INIT_WORK(&fs_info->async_submit_work, btrfs_async_submit_work);
C
Chris Mason 已提交
1210
	INIT_DELAYED_WORK(&fs_info->trans_work, btrfs_transaction_cleaner);
1211
#endif
1212 1213 1214
	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 已提交
1215
	insert_inode_hash(fs_info->btree_inode);
1216
	mapping_set_gfp_mask(fs_info->btree_inode->i_mapping, GFP_NOFS);
C
Chris Mason 已提交
1217

C
Chris Mason 已提交
1218
	mutex_init(&fs_info->trans_mutex);
C
Chris Mason 已提交
1219
	mutex_init(&fs_info->fs_mutex);
1220

1221 1222 1223 1224 1225 1226 1227 1228
#if 0
	ret = add_hasher(fs_info, "crc32c");
	if (ret) {
		printk("btrfs: failed hash setup, modprobe cryptomgr?\n");
		err = -ENOMEM;
		goto fail_iput;
	}
#endif
1229
	__setup_root(4096, 4096, 4096, 4096, tree_root,
C
Chris Mason 已提交
1230
		     fs_info, BTRFS_ROOT_TREE_OBJECTID);
1231

C
Chris Mason 已提交
1232
	fs_info->sb_buffer = read_tree_block(tree_root,
1233
					     BTRFS_SUPER_INFO_OFFSET,
1234
					     4096);
1235

1236
	if (!fs_info->sb_buffer)
C
Chris Mason 已提交
1237 1238
		goto fail_iput;

1239 1240 1241 1242 1243 1244
	read_extent_buffer(fs_info->sb_buffer, &fs_info->super_copy, 0,
			   sizeof(fs_info->super_copy));

	read_extent_buffer(fs_info->sb_buffer, fs_info->fsid,
			   (unsigned long)btrfs_super_fsid(fs_info->sb_buffer),
			   BTRFS_FSID_SIZE);
1245

1246
	disk_super = &fs_info->super_copy;
1247
	if (!btrfs_super_root(disk_super))
C
Chris Mason 已提交
1248
		goto fail_sb_buffer;
1249

1250 1251 1252 1253 1254 1255
	if (btrfs_super_num_devices(disk_super) != fs_devices->num_devices) {
		printk("Btrfs: wanted %llu devices, but found %llu\n",
		       (unsigned long long)btrfs_super_num_devices(disk_super),
		       (unsigned long long)fs_devices->num_devices);
		goto fail_sb_buffer;
	}
1256 1257
	fs_info->bdi.ra_pages *= btrfs_super_num_devices(disk_super);

1258 1259 1260
	nodesize = btrfs_super_nodesize(disk_super);
	leafsize = btrfs_super_leafsize(disk_super);
	sectorsize = btrfs_super_sectorsize(disk_super);
1261
	stripesize = btrfs_super_stripesize(disk_super);
1262 1263 1264
	tree_root->nodesize = nodesize;
	tree_root->leafsize = leafsize;
	tree_root->sectorsize = sectorsize;
1265
	tree_root->stripesize = stripesize;
1266
	sb_set_blocksize(sb, sectorsize);
1267

C
Chris Mason 已提交
1268 1269 1270 1271 1272
	if (strncmp((char *)(&disk_super->magic), BTRFS_MAGIC,
		    sizeof(disk_super->magic))) {
		printk("btrfs: valid FS not found on %s\n", sb->s_id);
		goto fail_sb_buffer;
	}
1273

1274
	mutex_lock(&fs_info->fs_mutex);
1275

1276
	ret = btrfs_read_sys_array(tree_root);
1277 1278 1279 1280 1281
	if (ret) {
		printk("btrfs: failed to read the system array on %s\n",
		       sb->s_id);
		goto fail_sys_array;
	}
1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293

	blocksize = btrfs_level_size(tree_root,
				     btrfs_super_chunk_root_level(disk_super));

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

1294 1295 1296 1297
	read_extent_buffer(chunk_root->node, fs_info->chunk_tree_uuid,
	         (unsigned long)btrfs_header_chunk_tree_uuid(chunk_root->node),
		 BTRFS_UUID_SIZE);

1298 1299 1300
	ret = btrfs_read_chunk_tree(chunk_root);
	BUG_ON(ret);

1301 1302
	blocksize = btrfs_level_size(tree_root,
				     btrfs_super_root_level(disk_super));
1303

1304

C
Chris Mason 已提交
1305
	tree_root->node = read_tree_block(tree_root,
1306 1307
					  btrfs_super_root(disk_super),
					  blocksize);
C
Chris Mason 已提交
1308 1309
	if (!tree_root->node)
		goto fail_sb_buffer;
1310

1311 1312

	ret = find_and_setup_root(tree_root, fs_info,
C
Chris Mason 已提交
1313
				  BTRFS_EXTENT_TREE_OBJECTID, extent_root);
1314
	if (ret)
C
Chris Mason 已提交
1315
		goto fail_tree_root;
1316 1317 1318 1319 1320 1321 1322 1323
	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;
1324

C
Chris Mason 已提交
1325 1326
	btrfs_read_block_groups(extent_root);

1327
	fs_info->generation = btrfs_super_generation(disk_super) + 1;
C
Chris Mason 已提交
1328 1329 1330 1331
	fs_info->data_alloc_profile = (u64)-1;
	fs_info->metadata_alloc_profile = (u64)-1;
	fs_info->system_alloc_profile = fs_info->metadata_alloc_profile;

C
Chris Mason 已提交
1332
	mutex_unlock(&fs_info->fs_mutex);
1333
	return tree_root;
C
Chris Mason 已提交
1334

1335 1336
fail_extent_root:
	free_extent_buffer(extent_root->node);
C
Chris Mason 已提交
1337
fail_tree_root:
1338
	free_extent_buffer(tree_root->node);
1339 1340
fail_sys_array:
	mutex_unlock(&fs_info->fs_mutex);
C
Chris Mason 已提交
1341
fail_sb_buffer:
1342
	free_extent_buffer(fs_info->sb_buffer);
1343
	extent_io_tree_empty_lru(&BTRFS_I(fs_info->btree_inode)->io_tree);
C
Chris Mason 已提交
1344 1345 1346
fail_iput:
	iput(fs_info->btree_inode);
fail:
1347
	close_all_devices(fs_info);
1348 1349
	btrfs_mapping_tree_free(&fs_info->mapping_tree);

C
Chris Mason 已提交
1350 1351
	kfree(extent_root);
	kfree(tree_root);
1352
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23)
1353
	bdi_destroy(&fs_info->bdi);
1354
#endif
C
Chris Mason 已提交
1355 1356
	kfree(fs_info);
	return ERR_PTR(err);
1357 1358
}

1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387
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));
		}
		set_buffer_write_io_error(bh);
		clear_buffer_uptodate(bh);
	}
	unlock_buffer(bh);
	put_bh(bh);
}

int write_all_supers(struct btrfs_root *root)
{
	struct list_head *cur;
	struct list_head *head = &root->fs_info->fs_devices->devices;
	struct btrfs_device *dev;
	struct extent_buffer *sb;
	struct btrfs_dev_item *dev_item;
	struct buffer_head *bh;
	int ret;
	int do_barriers;
1388 1389
	int max_errors;
	int total_errors = 0;
1390

1391
	max_errors = btrfs_super_num_devices(&root->fs_info->super_copy) - 1;
1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407
	do_barriers = !btrfs_test_opt(root, NOBARRIER);

	sb = root->fs_info->sb_buffer;
	dev_item = (struct btrfs_dev_item *)offsetof(struct btrfs_super_block,
						      dev_item);
	list_for_each(cur, head) {
		dev = list_entry(cur, struct btrfs_device, dev_list);
		btrfs_set_device_type(sb, dev_item, dev->type);
		btrfs_set_device_id(sb, dev_item, dev->devid);
		btrfs_set_device_total_bytes(sb, dev_item, dev->total_bytes);
		btrfs_set_device_bytes_used(sb, dev_item, dev->bytes_used);
		btrfs_set_device_io_align(sb, dev_item, dev->io_align);
		btrfs_set_device_io_width(sb, dev_item, dev->io_width);
		btrfs_set_device_sector_size(sb, dev_item, dev->sector_size);
		write_extent_buffer(sb, dev->uuid,
				    (unsigned long)btrfs_device_uuid(dev_item),
1408
				    BTRFS_UUID_SIZE);
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 1434 1435 1436 1437 1438

		btrfs_set_header_flag(sb, BTRFS_HEADER_FLAG_WRITTEN);
		csum_tree_block(root, sb, 0);

		bh = __getblk(dev->bdev, BTRFS_SUPER_INFO_OFFSET /
			      root->fs_info->sb->s_blocksize,
			      BTRFS_SUPER_INFO_SIZE);

		read_extent_buffer(sb, bh->b_data, 0, BTRFS_SUPER_INFO_SIZE);
		dev->pending_io = bh;

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

		if (do_barriers && dev->barriers) {
			ret = submit_bh(WRITE_BARRIER, bh);
			if (ret == -EOPNOTSUPP) {
				printk("btrfs: disabling barriers on dev %s\n",
				       dev->name);
				set_buffer_uptodate(bh);
				dev->barriers = 0;
				get_bh(bh);
				lock_buffer(bh);
				ret = submit_bh(WRITE, bh);
			}
		} else {
			ret = submit_bh(WRITE, bh);
		}
1439 1440
		if (ret)
			total_errors++;
1441
	}
1442 1443 1444 1445 1446
	if (total_errors > max_errors) {
		printk("btrfs: %d errors while writing supers\n", total_errors);
		BUG();
	}
	total_errors = 0;
1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465

	list_for_each(cur, head) {
		dev = list_entry(cur, struct btrfs_device, dev_list);
		BUG_ON(!dev->pending_io);
		bh = dev->pending_io;
		wait_on_buffer(bh);
		if (!buffer_uptodate(dev->pending_io)) {
			if (do_barriers && dev->barriers) {
				printk("btrfs: disabling barriers on dev %s\n",
				       dev->name);
				set_buffer_uptodate(bh);
				get_bh(bh);
				lock_buffer(bh);
				dev->barriers = 0;
				ret = submit_bh(WRITE, bh);
				BUG_ON(ret);
				wait_on_buffer(bh);
				BUG_ON(!buffer_uptodate(bh));
			} else {
1466
				total_errors++;
1467 1468 1469 1470 1471 1472
			}

		}
		dev->pending_io = NULL;
		brelse(bh);
	}
1473 1474 1475 1476
	if (total_errors > max_errors) {
		printk("btrfs: %d errors while writing supers\n", total_errors);
		BUG();
	}
1477 1478 1479
	return 0;
}

1480
int write_ctree_super(struct btrfs_trans_handle *trans, struct btrfs_root
C
Chris Mason 已提交
1481
		      *root)
1482
{
1483
	int ret;
1484

1485 1486
	ret = write_all_supers(root);
#if 0
1487 1488
	if (!btrfs_test_opt(root, NOBARRIER))
		blkdev_issue_flush(sb->s_bdev, NULL);
1489
	set_extent_buffer_dirty(&BTRFS_I(btree_inode)->io_tree, super);
1490 1491
	ret = sync_page_range_nolock(btree_inode, btree_inode->i_mapping,
				     super->start, super->len);
1492 1493
	if (!btrfs_test_opt(root, NOBARRIER))
		blkdev_issue_flush(sb->s_bdev, NULL);
1494
#endif
1495
	return ret;
C
Chris Mason 已提交
1496 1497
}

1498
int btrfs_free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root)
C
Chris Mason 已提交
1499 1500 1501
{
	radix_tree_delete(&fs_info->fs_roots_radix,
			  (unsigned long)root->root_key.objectid);
1502 1503
	if (root->in_sysfs)
		btrfs_sysfs_del_root(root);
C
Chris Mason 已提交
1504 1505 1506
	if (root->inode)
		iput(root->inode);
	if (root->node)
1507
		free_extent_buffer(root->node);
C
Chris Mason 已提交
1508
	if (root->commit_root)
1509
		free_extent_buffer(root->commit_root);
1510 1511
	if (root->name)
		kfree(root->name);
C
Chris Mason 已提交
1512 1513 1514 1515
	kfree(root);
	return 0;
}

C
Chris Mason 已提交
1516
static int del_fs_roots(struct btrfs_fs_info *fs_info)
1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527
{
	int ret;
	struct btrfs_root *gang[8];
	int i;

	while(1) {
		ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
					     (void **)gang, 0,
					     ARRAY_SIZE(gang));
		if (!ret)
			break;
C
Chris Mason 已提交
1528
		for (i = 0; i < ret; i++)
1529
			btrfs_free_fs_root(fs_info, gang[i]);
1530 1531 1532
	}
	return 0;
}
1533

C
Chris Mason 已提交
1534
int close_ctree(struct btrfs_root *root)
C
Chris Mason 已提交
1535
{
1536
	int ret;
1537
	struct btrfs_trans_handle *trans;
1538
	struct btrfs_fs_info *fs_info = root->fs_info;
1539

1540
	fs_info->closing = 1;
C
Chris Mason 已提交
1541
	btrfs_transaction_flush_work(root);
1542
	mutex_lock(&fs_info->fs_mutex);
1543
	btrfs_defrag_dirty_roots(root->fs_info);
C
Chris Mason 已提交
1544
	trans = btrfs_start_transaction(root, 1);
1545
	ret = btrfs_commit_transaction(trans, root);
C
Chris Mason 已提交
1546 1547 1548 1549
	/* run commit again to  drop the original snapshot */
	trans = btrfs_start_transaction(root, 1);
	btrfs_commit_transaction(trans, root);
	ret = btrfs_write_and_wait_transaction(NULL, root);
1550
	BUG_ON(ret);
C
Chris Mason 已提交
1551
	write_ctree_super(NULL, root);
1552 1553
	mutex_unlock(&fs_info->fs_mutex);

1554 1555
	btrfs_transaction_flush_work(root);

C
Chris Mason 已提交
1556 1557 1558 1559
	if (fs_info->delalloc_bytes) {
		printk("btrfs: at unmount delalloc count %Lu\n",
		       fs_info->delalloc_bytes);
	}
1560
	if (fs_info->extent_root->node)
1561
		free_extent_buffer(fs_info->extent_root->node);
1562

1563
	if (fs_info->tree_root->node)
1564
		free_extent_buffer(fs_info->tree_root->node);
1565

1566 1567 1568 1569 1570 1571
	if (root->fs_info->chunk_root->node);
		free_extent_buffer(root->fs_info->chunk_root->node);

	if (root->fs_info->dev_root->node);
		free_extent_buffer(root->fs_info->dev_root->node);

1572
	free_extent_buffer(fs_info->sb_buffer);
1573

C
Chris Mason 已提交
1574
	btrfs_free_block_groups(root->fs_info);
1575
	del_fs_roots(fs_info);
1576 1577 1578

	filemap_write_and_wait(fs_info->btree_inode->i_mapping);

1579 1580 1581 1582 1583 1584
	extent_io_tree_empty_lru(&fs_info->free_space_cache);
	extent_io_tree_empty_lru(&fs_info->block_group_cache);
	extent_io_tree_empty_lru(&fs_info->pinned_extents);
	extent_io_tree_empty_lru(&fs_info->pending_del);
	extent_io_tree_empty_lru(&fs_info->extent_ins);
	extent_io_tree_empty_lru(&BTRFS_I(fs_info->btree_inode)->io_tree);
1585

1586 1587 1588
	flush_workqueue(end_io_workqueue);
	flush_workqueue(async_submit_workqueue);

1589
	truncate_inode_pages(fs_info->btree_inode->i_mapping, 0);
1590

1591 1592
	flush_workqueue(end_io_workqueue);
	destroy_workqueue(end_io_workqueue);
1593

1594 1595 1596
	flush_workqueue(async_submit_workqueue);
	destroy_workqueue(async_submit_workqueue);

1597
	iput(fs_info->btree_inode);
1598 1599 1600 1601 1602 1603 1604 1605 1606 1607
#if 0
	while(!list_empty(&fs_info->hashers)) {
		struct btrfs_hasher *hasher;
		hasher = list_entry(fs_info->hashers.next, struct btrfs_hasher,
				    hashers);
		list_del(&hasher->hashers);
		crypto_free_hash(&fs_info->hash_tfm);
		kfree(hasher);
	}
#endif
1608 1609
	close_all_devices(fs_info);
	btrfs_mapping_tree_free(&fs_info->mapping_tree);
1610 1611

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23)
C
Chris Mason 已提交
1612
	bdi_destroy(&fs_info->bdi);
1613
#endif
1614

1615 1616
	kfree(fs_info->extent_root);
	kfree(fs_info->tree_root);
1617 1618
	kfree(fs_info->chunk_root);
	kfree(fs_info->dev_root);
1619 1620 1621
	return 0;
}

1622 1623
int btrfs_buffer_uptodate(struct extent_buffer *buf)
{
1624
	struct inode *btree_inode = buf->first_page->mapping->host;
1625
	return extent_buffer_uptodate(&BTRFS_I(btree_inode)->io_tree, buf);
1626 1627 1628
}

int btrfs_set_buffer_uptodate(struct extent_buffer *buf)
C
Chris Mason 已提交
1629
{
1630
	struct inode *btree_inode = buf->first_page->mapping->host;
1631
	return set_extent_buffer_uptodate(&BTRFS_I(btree_inode)->io_tree,
1632 1633
					  buf);
}
1634

1635 1636
void btrfs_mark_buffer_dirty(struct extent_buffer *buf)
{
1637
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
1638 1639
	u64 transid = btrfs_header_generation(buf);
	struct inode *btree_inode = root->fs_info->btree_inode;
1640

C
Chris Mason 已提交
1641 1642
	if (transid != root->fs_info->generation) {
		printk(KERN_CRIT "transid mismatch buffer %llu, found %Lu running %Lu\n",
1643
			(unsigned long long)buf->start,
C
Chris Mason 已提交
1644 1645 1646
			transid, root->fs_info->generation);
		WARN_ON(1);
	}
1647
	set_extent_buffer_dirty(&BTRFS_I(btree_inode)->io_tree, buf);
1648 1649
}

1650 1651
void btrfs_throttle(struct btrfs_root *root)
{
1652 1653 1654
	struct backing_dev_info *bdi;

	bdi = root->fs_info->sb->s_bdev->bd_inode->i_mapping->backing_dev_info;
1655 1656
	if (root->fs_info->throttles && bdi_write_congested(bdi)) {
#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,18)
1657
		congestion_wait(WRITE, HZ/20);
1658 1659 1660 1661
#else
		blk_congestion_wait(WRITE, HZ/20);
#endif
	}
1662 1663
}

1664
void btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr)
C
Chris Mason 已提交
1665
{
1666
	balance_dirty_pages_ratelimited_nr(
C
Chris Mason 已提交
1667
				   root->fs_info->btree_inode->i_mapping, 1);
C
Chris Mason 已提交
1668
}
1669 1670 1671

void btrfs_set_buffer_defrag(struct extent_buffer *buf)
{
1672
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
1673
	struct inode *btree_inode = root->fs_info->btree_inode;
1674
	set_extent_bits(&BTRFS_I(btree_inode)->io_tree, buf->start,
1675 1676 1677 1678 1679
			buf->start + buf->len - 1, EXTENT_DEFRAG, GFP_NOFS);
}

void btrfs_set_buffer_defrag_done(struct extent_buffer *buf)
{
1680
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
1681
	struct inode *btree_inode = root->fs_info->btree_inode;
1682
	set_extent_bits(&BTRFS_I(btree_inode)->io_tree, buf->start,
1683 1684 1685 1686 1687 1688
			buf->start + buf->len - 1, EXTENT_DEFRAG_DONE,
			GFP_NOFS);
}

int btrfs_buffer_defrag(struct extent_buffer *buf)
{
1689
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
1690
	struct inode *btree_inode = root->fs_info->btree_inode;
1691
	return test_range_bit(&BTRFS_I(btree_inode)->io_tree,
1692 1693 1694 1695 1696
		     buf->start, buf->start + buf->len - 1, EXTENT_DEFRAG, 0);
}

int btrfs_buffer_defrag_done(struct extent_buffer *buf)
{
1697
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
1698
	struct inode *btree_inode = root->fs_info->btree_inode;
1699
	return test_range_bit(&BTRFS_I(btree_inode)->io_tree,
1700 1701 1702 1703 1704 1705
		     buf->start, buf->start + buf->len - 1,
		     EXTENT_DEFRAG_DONE, 0);
}

int btrfs_clear_buffer_defrag_done(struct extent_buffer *buf)
{
1706
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
1707
	struct inode *btree_inode = root->fs_info->btree_inode;
1708
	return clear_extent_bits(&BTRFS_I(btree_inode)->io_tree,
1709 1710 1711 1712 1713 1714
		     buf->start, buf->start + buf->len - 1,
		     EXTENT_DEFRAG_DONE, GFP_NOFS);
}

int btrfs_clear_buffer_defrag(struct extent_buffer *buf)
{
1715
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
1716
	struct inode *btree_inode = root->fs_info->btree_inode;
1717
	return clear_extent_bits(&BTRFS_I(btree_inode)->io_tree,
1718 1719 1720 1721 1722 1723
		     buf->start, buf->start + buf->len - 1,
		     EXTENT_DEFRAG, GFP_NOFS);
}

int btrfs_read_buffer(struct extent_buffer *buf)
{
1724
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
1725
	int ret;
1726
	ret = btree_read_extent_buffer_pages(root, buf, 0);
1727 1728 1729 1730
	if (ret == 0) {
		buf->flags |= EXTENT_UPTODATE;
	}
	return ret;
1731
}
1732

1733
static struct extent_io_ops btree_extent_io_ops = {
1734
	.writepage_io_hook = btree_writepage_io_hook,
1735
	.readpage_end_io_hook = btree_readpage_end_io_hook,
1736
	.submit_bio_hook = btree_submit_bio_hook,
1737 1738
	/* note we're sharing with inode.c for the merge bio hook */
	.merge_bio_hook = btrfs_merge_bio_hook,
1739
};