disk-io.c 27.6 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>
21
#include <linux/crc32c.h>
C
Chris Mason 已提交
22
#include <linux/scatterlist.h>
C
Chris Mason 已提交
23
#include <linux/swap.h>
24
#include <linux/radix-tree.h>
C
Chris Mason 已提交
25
#include <linux/writeback.h>
26
#include <linux/buffer_head.h> // for block_sync_page
27 28
#include "ctree.h"
#include "disk-io.h"
29
#include "transaction.h"
30
#include "btrfs_inode.h"
31
#include "print-tree.h"
32

33 34
#if 0
static int check_tree_block(struct btrfs_root *root, struct extent_buffer *buf)
35
{
36 37 38 39
	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 已提交
40
		return 1;
41
	}
42
	return 0;
43
}
44
#endif
45

46
static struct extent_io_ops btree_extent_io_ops;
47

48
struct extent_buffer *btrfs_find_tree_block(struct btrfs_root *root,
49
					    u64 bytenr, u32 blocksize)
50
{
51
	struct inode *btree_inode = root->fs_info->btree_inode;
52
	struct extent_buffer *eb;
53
	eb = find_extent_buffer(&BTRFS_I(btree_inode)->io_tree,
54
				bytenr, blocksize, GFP_NOFS);
55
	return eb;
56
}
57

58
struct extent_buffer *btrfs_find_create_tree_block(struct btrfs_root *root,
59
						 u64 bytenr, u32 blocksize)
60 61
{
	struct inode *btree_inode = root->fs_info->btree_inode;
62
	struct extent_buffer *eb;
63

64
	eb = alloc_extent_buffer(&BTRFS_I(btree_inode)->io_tree,
65
				 bytenr, blocksize, NULL, GFP_NOFS);
66
	return eb;
67 68
}

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

again:
78 79 80
	spin_lock(&em_tree->lock);
	em = lookup_extent_mapping(em_tree, start, len);
	spin_unlock(&em_tree->lock);
81 82
	if (em) {
		goto out;
83
	}
84 85 86 87 88 89
	em = alloc_extent_map(GFP_NOFS);
	if (!em) {
		em = ERR_PTR(-ENOMEM);
		goto out;
	}
	em->start = 0;
90
	em->len = i_size_read(inode);
91 92
	em->block_start = 0;
	em->bdev = inode->i_sb->s_bdev;
93 94

	spin_lock(&em_tree->lock);
95
	ret = add_extent_mapping(em_tree, em);
96 97
	spin_unlock(&em_tree->lock);

98 99 100 101 102 103 104 105 106
	if (ret == -EEXIST) {
		free_extent_map(em);
		em = NULL;
		goto again;
	} else if (ret) {
		em = ERR_PTR(ret);
	}
out:
	return em;
107 108
}

109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
u32 btrfs_csum_data(struct btrfs_root *root, char *data, u32 seed, size_t len)
{
	return crc32c(seed, data, len);
}

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) {
153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169
		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 */
		if (from_this_trans == 0 &&
		    memcmp_extent_buffer(buf, result, 0, BTRFS_CRC32_SIZE)) {
			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 "
			       "wanted %X found %X from_this_trans %d\n",
170
			       root->fs_info->sb->s_id,
171
			       buf->start, val, found, from_this_trans);
172 173 174 175 176 177 178 179 180 181 182
			return 1;
		}
	} else {
		write_extent_buffer(buf, result, 0, BTRFS_CRC32_SIZE);
	}
	return 0;
}


int csum_dirty_buffer(struct btrfs_root *root, struct page *page)
{
183
	struct extent_io_tree *tree;
184
	u64 start = (u64)page->index << PAGE_CACHE_SHIFT;
185 186 187 188
	u64 found_start;
	int found_level;
	unsigned long len;
	struct extent_buffer *eb;
189
	tree = &BTRFS_I(page->mapping->host)->io_tree;
190 191 192 193 194 195 196 197 198 199

	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);
200 201
	read_extent_buffer_pages(tree, eb, start + PAGE_CACHE_SIZE, 1,
				 btree_get_extent);
202
	btrfs_clear_buffer_defrag(eb);
203 204 205 206
	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);
207 208 209 210 211 212 213 214 215 216 217 218 219
		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;
220 221 222
	}
	found_level = btrfs_header_level(eb);
	csum_tree_block(root, eb, 0);
223
err:
224 225 226 227 228
	free_extent_buffer(eb);
out:
	return 0;
}

229
static int btree_writepage_io_hook(struct page *page, u64 start, u64 end)
230
{
231 232 233
	struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;

	csum_dirty_buffer(root, page);
234 235 236 237 238
	return 0;
}

static int btree_writepage(struct page *page, struct writeback_control *wbc)
{
239 240
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
241 242
	return extent_write_full_page(tree, page, btree_get_extent, wbc);
}
243 244 245 246

static int btree_writepages(struct address_space *mapping,
			    struct writeback_control *wbc)
{
247 248
	struct extent_io_tree *tree;
	tree = &BTRFS_I(mapping->host)->io_tree;
249
	if (wbc->sync_mode == WB_SYNC_NONE) {
250 251 252
		u64 num_dirty;
		u64 start = 0;
		unsigned long thresh = 96 * 1024 * 1024;
253 254 255 256

		if (wbc->for_kupdate)
			return 0;

257 258 259 260 261
		if (current_is_pdflush()) {
			thresh = 96 * 1024 * 1024;
		} else {
			thresh = 8 * 1024 * 1024;
		}
262 263
		num_dirty = count_range_bits(tree, &start, (u64)-1,
					     thresh, EXTENT_DIRTY);
264 265 266 267
		if (num_dirty < thresh) {
			return 0;
		}
	}
268 269 270
	return extent_writepages(tree, mapping, btree_get_extent, wbc);
}

271 272
int btree_readpage(struct file *file, struct page *page)
{
273 274
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
275 276
	return extent_read_full_page(tree, page, btree_get_extent);
}
C
Chris Mason 已提交
277

278
static int btree_releasepage(struct page *page, gfp_t gfp_flags)
279
{
280 281
	struct extent_io_tree *tree;
	struct extent_map_tree *map;
282
	int ret;
283

284 285
	tree = &BTRFS_I(page->mapping->host)->io_tree;
	map = &BTRFS_I(page->mapping->host)->extent_tree;
286
	ret = try_release_extent_mapping(map, tree, page, gfp_flags);
287 288 289 290 291
	if (ret == 1) {
		ClearPagePrivate(page);
		set_page_private(page, 0);
		page_cache_release(page);
	}
292 293 294
	return ret;
}

295
static void btree_invalidatepage(struct page *page, unsigned long offset)
296
{
297 298
	struct extent_io_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->io_tree;
299 300
	extent_invalidatepage(tree, page, offset);
	btree_releasepage(page, GFP_NOFS);
301 302
}

303
#if 0
304
static int btree_writepage(struct page *page, struct writeback_control *wbc)
305
{
C
Chris Mason 已提交
306
	struct buffer_head *bh;
307
	struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
C
Chris Mason 已提交
308 309 310 311 312 313 314 315 316 317 318 319
	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);
320
	return block_write_full_page(page, btree_get_block, wbc);
321
}
322
#endif
323

324 325 326
static struct address_space_operations btree_aops = {
	.readpage	= btree_readpage,
	.writepage	= btree_writepage,
327
	.writepages	= btree_writepages,
328 329
	.releasepage	= btree_releasepage,
	.invalidatepage = btree_invalidatepage,
330 331 332
	.sync_page	= block_sync_page,
};

333
int readahead_tree_block(struct btrfs_root *root, u64 bytenr, u32 blocksize)
C
Chris Mason 已提交
334
{
335 336
	struct extent_buffer *buf = NULL;
	struct inode *btree_inode = root->fs_info->btree_inode;
337
	int ret = 0;
C
Chris Mason 已提交
338

339
	buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
340
	if (!buf)
C
Chris Mason 已提交
341
		return 0;
342
	read_extent_buffer_pages(&BTRFS_I(btree_inode)->io_tree,
343
				 buf, 0, 0, btree_get_extent);
344
	free_extent_buffer(buf);
345
	return ret;
C
Chris Mason 已提交
346 347
}

348 349
struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 bytenr,
				      u32 blocksize)
350
{
351 352
	struct extent_buffer *buf = NULL;
	struct inode *btree_inode = root->fs_info->btree_inode;
353
	struct extent_io_tree *io_tree;
354
	u64 end;
355 356
	int ret;

357
	io_tree = &BTRFS_I(btree_inode)->io_tree;
358

359
	buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
360 361
	if (!buf)
		return NULL;
362 363
	read_extent_buffer_pages(&BTRFS_I(btree_inode)->io_tree, buf, 0, 1,
				 btree_get_extent);
364 365

	if (buf->flags & EXTENT_CSUM)
366
		return buf;
367 368

	end = buf->start + PAGE_CACHE_SIZE - 1;
369
	if (test_range_bit(io_tree, buf->start, end, EXTENT_CSUM, 1)) {
370 371 372
		buf->flags |= EXTENT_CSUM;
		return buf;
	}
373

374
	lock_extent(io_tree, buf->start, end, GFP_NOFS);
375

376
	if (test_range_bit(io_tree, buf->start, end, EXTENT_CSUM, 1)) {
377 378 379 380
		buf->flags |= EXTENT_CSUM;
		goto out_unlock;
	}

381
	ret = csum_tree_block(root, buf, 1);
382
	set_extent_bits(io_tree, buf->start, end, EXTENT_CSUM, GFP_NOFS);
383
	buf->flags |= EXTENT_CSUM;
384 385

out_unlock:
386
	unlock_extent(io_tree, buf->start, end, GFP_NOFS);
387
	return buf;
388 389
}

390
int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
391
		     struct extent_buffer *buf)
392
{
393
	struct inode *btree_inode = root->fs_info->btree_inode;
394 395
	if (btrfs_header_generation(buf) ==
	    root->fs_info->running_transaction->transid)
396
		clear_extent_buffer_dirty(&BTRFS_I(btree_inode)->io_tree,
397
					  buf);
398 399 400 401 402 403 404
	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;
405
	wait_on_extent_buffer_writeback(&BTRFS_I(btree_inode)->io_tree,
406 407 408 409
					buf);
	return 0;
}

410
static int __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize,
411
			u32 stripesize, struct btrfs_root *root,
412
			struct btrfs_fs_info *fs_info,
C
Chris Mason 已提交
413
			u64 objectid)
414
{
C
Chris Mason 已提交
415
	root->node = NULL;
416
	root->inode = NULL;
417
	root->commit_root = NULL;
418 419 420
	root->sectorsize = sectorsize;
	root->nodesize = nodesize;
	root->leafsize = leafsize;
421
	root->stripesize = stripesize;
C
Chris Mason 已提交
422
	root->ref_cows = 0;
423
	root->fs_info = fs_info;
424 425
	root->objectid = objectid;
	root->last_trans = 0;
C
Chris Mason 已提交
426 427
	root->highest_inode = 0;
	root->last_inode_alloc = 0;
428
	root->name = NULL;
429
	root->in_sysfs = 0;
430 431
	memset(&root->root_key, 0, sizeof(root->root_key));
	memset(&root->root_item, 0, sizeof(root->root_item));
432
	memset(&root->defrag_progress, 0, sizeof(root->defrag_progress));
433 434
	memset(&root->root_kobj, 0, sizeof(root->root_kobj));
	init_completion(&root->kobj_unregister);
435 436
	root->defrag_running = 0;
	root->defrag_level = 0;
437
	root->root_key.objectid = objectid;
438 439 440
	return 0;
}

441
static int find_and_setup_root(struct btrfs_root *tree_root,
442 443
			       struct btrfs_fs_info *fs_info,
			       u64 objectid,
C
Chris Mason 已提交
444
			       struct btrfs_root *root)
445 446
{
	int ret;
447
	u32 blocksize;
448

449
	__setup_root(tree_root->nodesize, tree_root->leafsize,
450 451
		     tree_root->sectorsize, tree_root->stripesize,
		     root, fs_info, objectid);
452 453 454 455
	ret = btrfs_find_last_root(tree_root, objectid,
				   &root->root_item, &root->root_key);
	BUG_ON(ret);

456 457 458
	blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
	root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
				     blocksize);
459
	BUG_ON(!root->node);
460 461 462
	return 0;
}

463 464
struct btrfs_root *btrfs_read_fs_root_no_radix(struct btrfs_fs_info *fs_info,
					       struct btrfs_key *location)
465 466 467 468
{
	struct btrfs_root *root;
	struct btrfs_root *tree_root = fs_info->tree_root;
	struct btrfs_path *path;
469
	struct extent_buffer *l;
C
Chris Mason 已提交
470
	u64 highest_inode;
471
	u32 blocksize;
472 473
	int ret = 0;

474
	root = kzalloc(sizeof(*root), GFP_NOFS);
C
Chris Mason 已提交
475
	if (!root)
476 477
		return ERR_PTR(-ENOMEM);
	if (location->offset == (u64)-1) {
478
		ret = find_and_setup_root(tree_root, fs_info,
479 480 481 482 483 484 485 486
					  location->objectid, root);
		if (ret) {
			kfree(root);
			return ERR_PTR(ret);
		}
		goto insert;
	}

487
	__setup_root(tree_root->nodesize, tree_root->leafsize,
488 489
		     tree_root->sectorsize, tree_root->stripesize,
		     root, fs_info, location->objectid);
490 491 492 493 494 495 496 497 498

	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;
	}
499 500 501
	l = path->nodes[0];
	read_extent_buffer(l, &root->root_item,
	       btrfs_item_ptr_offset(l, path->slots[0]),
502
	       sizeof(root->root_item));
503
	memcpy(&root->root_key, location, sizeof(*location));
504 505 506 507 508 509 510 511
	ret = 0;
out:
	btrfs_release_path(root, path);
	btrfs_free_path(path);
	if (ret) {
		kfree(root);
		return ERR_PTR(ret);
	}
512 513 514
	blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
	root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
				     blocksize);
515 516 517
	BUG_ON(!root->node);
insert:
	root->ref_cows = 1;
518 519 520 521 522 523 524 525
	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 已提交
526 527 528 529 530 531 532 533 534 535 536 537 538 539 540
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;
}

541 542
struct btrfs_root *btrfs_read_fs_root_no_name(struct btrfs_fs_info *fs_info,
					      struct btrfs_key *location)
543 544 545 546
{
	struct btrfs_root *root;
	int ret;

547 548 549 550 551
	if (location->objectid == BTRFS_ROOT_TREE_OBJECTID)
		return fs_info->tree_root;
	if (location->objectid == BTRFS_EXTENT_TREE_OBJECTID)
		return fs_info->extent_root;

552 553 554 555 556 557 558 559
	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 已提交
560 561
	ret = radix_tree_insert(&fs_info->fs_roots_radix,
				(unsigned long)root->root_key.objectid,
562 563
				root);
	if (ret) {
564
		free_extent_buffer(root->node);
565 566 567
		kfree(root);
		return ERR_PTR(ret);
	}
568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584
	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;
585

586 587 588
	if (root->in_sysfs)
		return root;

589 590
	ret = btrfs_set_root_name(root, name, namelen);
	if (ret) {
591
		free_extent_buffer(root->node);
592 593 594 595 596 597
		kfree(root);
		return ERR_PTR(ret);
	}

	ret = btrfs_sysfs_add_root(root);
	if (ret) {
598
		free_extent_buffer(root->node);
599 600 601 602
		kfree(root->name);
		kfree(root);
		return ERR_PTR(ret);
	}
603
	root->in_sysfs = 1;
604 605
	return root;
}
606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623
#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 已提交
624
struct btrfs_root *open_ctree(struct super_block *sb)
625
{
626 627 628 629
	u32 sectorsize;
	u32 nodesize;
	u32 leafsize;
	u32 blocksize;
630
	u32 stripesize;
C
Chris Mason 已提交
631 632 633 634 635 636
	struct btrfs_root *extent_root = kmalloc(sizeof(struct btrfs_root),
						 GFP_NOFS);
	struct btrfs_root *tree_root = kmalloc(sizeof(struct btrfs_root),
					       GFP_NOFS);
	struct btrfs_fs_info *fs_info = kmalloc(sizeof(*fs_info),
						GFP_NOFS);
637
	int ret;
C
Chris Mason 已提交
638
	int err = -EIO;
C
Chris Mason 已提交
639
	struct btrfs_super_block *disk_super;
640

C
Chris Mason 已提交
641 642 643 644
	if (!extent_root || !tree_root || !fs_info) {
		err = -ENOMEM;
		goto fail;
	}
645
	INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_NOFS);
C
Chris Mason 已提交
646
	INIT_LIST_HEAD(&fs_info->trans_list);
647
	INIT_LIST_HEAD(&fs_info->dead_roots);
648 649
	INIT_LIST_HEAD(&fs_info->hashers);
	spin_lock_init(&fs_info->hash_lock);
650
	spin_lock_init(&fs_info->delalloc_lock);
651
	spin_lock_init(&fs_info->new_trans_lock);
652

653 654
	memset(&fs_info->super_kobj, 0, sizeof(fs_info->super_kobj));
	init_completion(&fs_info->kobj_unregister);
C
Chris Mason 已提交
655
	sb_set_blocksize(sb, 4096);
656
	fs_info->running_transaction = NULL;
657
	fs_info->last_trans_committed = 0;
658 659
	fs_info->tree_root = tree_root;
	fs_info->extent_root = extent_root;
C
Chris Mason 已提交
660
	fs_info->sb = sb;
661
	fs_info->throttles = 0;
662
	fs_info->mount_opt = 0;
663
	fs_info->max_extent = (u64)-1;
664
	fs_info->max_inline = 8192 * 1024;
665
	fs_info->delalloc_bytes = 0;
666 667
	fs_info->btree_inode = new_inode(sb);
	fs_info->btree_inode->i_ino = 1;
C
Chris Mason 已提交
668
	fs_info->btree_inode->i_nlink = 1;
669 670
	fs_info->btree_inode->i_size = sb->s_bdev->bd_inode->i_size;
	fs_info->btree_inode->i_mapping->a_ops = &btree_aops;
671
	extent_io_tree_init(&BTRFS_I(fs_info->btree_inode)->io_tree,
672 673
			     fs_info->btree_inode->i_mapping,
			     GFP_NOFS);
674 675 676 677
	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;
678

679
	extent_io_tree_init(&fs_info->free_space_cache,
680
			     fs_info->btree_inode->i_mapping, GFP_NOFS);
681
	extent_io_tree_init(&fs_info->block_group_cache,
682
			     fs_info->btree_inode->i_mapping, GFP_NOFS);
683
	extent_io_tree_init(&fs_info->pinned_extents,
684
			     fs_info->btree_inode->i_mapping, GFP_NOFS);
685
	extent_io_tree_init(&fs_info->pending_del,
686
			     fs_info->btree_inode->i_mapping, GFP_NOFS);
687
	extent_io_tree_init(&fs_info->extent_ins,
688
			     fs_info->btree_inode->i_mapping, GFP_NOFS);
689
	fs_info->do_barriers = 1;
690
	fs_info->closing = 0;
691
	fs_info->total_pinned = 0;
692
	fs_info->last_alloc = 0;
693
	fs_info->last_data_alloc = 0;
694

695 696 697
#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,18)
	INIT_WORK(&fs_info->trans_work, btrfs_transaction_cleaner, fs_info);
#else
C
Chris Mason 已提交
698
	INIT_DELAYED_WORK(&fs_info->trans_work, btrfs_transaction_cleaner);
699
#endif
700 701 702
	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 已提交
703
	insert_inode_hash(fs_info->btree_inode);
704
	mapping_set_gfp_mask(fs_info->btree_inode->i_mapping, GFP_NOFS);
C
Chris Mason 已提交
705

C
Chris Mason 已提交
706
	mutex_init(&fs_info->trans_mutex);
C
Chris Mason 已提交
707
	mutex_init(&fs_info->fs_mutex);
708

709 710 711 712 713 714 715 716
#if 0
	ret = add_hasher(fs_info, "crc32c");
	if (ret) {
		printk("btrfs: failed hash setup, modprobe cryptomgr?\n");
		err = -ENOMEM;
		goto fail_iput;
	}
#endif
717
	__setup_root(512, 512, 512, 512, tree_root,
C
Chris Mason 已提交
718
		     fs_info, BTRFS_ROOT_TREE_OBJECTID);
719

C
Chris Mason 已提交
720
	fs_info->sb_buffer = read_tree_block(tree_root,
721 722
					     BTRFS_SUPER_INFO_OFFSET,
					     512);
723

724
	if (!fs_info->sb_buffer)
C
Chris Mason 已提交
725 726
		goto fail_iput;

727 728 729 730 731 732 733
	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);
	disk_super = &fs_info->super_copy;
734
	if (!btrfs_super_root(disk_super))
C
Chris Mason 已提交
735
		goto fail_sb_buffer;
736

737 738 739
	nodesize = btrfs_super_nodesize(disk_super);
	leafsize = btrfs_super_leafsize(disk_super);
	sectorsize = btrfs_super_sectorsize(disk_super);
740
	stripesize = btrfs_super_stripesize(disk_super);
741 742 743
	tree_root->nodesize = nodesize;
	tree_root->leafsize = leafsize;
	tree_root->sectorsize = sectorsize;
744
	tree_root->stripesize = stripesize;
745
	sb_set_blocksize(sb, sectorsize);
746

747
	i_size_write(fs_info->btree_inode,
748
		     btrfs_super_total_bytes(disk_super));
749

C
Chris Mason 已提交
750 751 752 753 754
	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;
	}
755

756 757
	blocksize = btrfs_level_size(tree_root,
				     btrfs_super_root_level(disk_super));
758

C
Chris Mason 已提交
759
	tree_root->node = read_tree_block(tree_root,
760 761
					  btrfs_super_root(disk_super),
					  blocksize);
C
Chris Mason 已提交
762 763
	if (!tree_root->node)
		goto fail_sb_buffer;
764

C
Chris Mason 已提交
765
	mutex_lock(&fs_info->fs_mutex);
766 767

	ret = find_and_setup_root(tree_root, fs_info,
C
Chris Mason 已提交
768
				  BTRFS_EXTENT_TREE_OBJECTID, extent_root);
C
Chris Mason 已提交
769 770 771 772
	if (ret) {
		mutex_unlock(&fs_info->fs_mutex);
		goto fail_tree_root;
	}
773

C
Chris Mason 已提交
774 775
	btrfs_read_block_groups(extent_root);

776
	fs_info->generation = btrfs_super_generation(disk_super) + 1;
C
Chris Mason 已提交
777
	mutex_unlock(&fs_info->fs_mutex);
778
	return tree_root;
C
Chris Mason 已提交
779 780

fail_tree_root:
781
	free_extent_buffer(tree_root->node);
C
Chris Mason 已提交
782
fail_sb_buffer:
783
	free_extent_buffer(fs_info->sb_buffer);
C
Chris Mason 已提交
784 785 786 787 788 789 790
fail_iput:
	iput(fs_info->btree_inode);
fail:
	kfree(extent_root);
	kfree(tree_root);
	kfree(fs_info);
	return ERR_PTR(err);
791 792
}

793
int write_ctree_super(struct btrfs_trans_handle *trans, struct btrfs_root
C
Chris Mason 已提交
794
		      *root)
795
{
796
	int ret;
797 798
	struct extent_buffer *super = root->fs_info->sb_buffer;
	struct inode *btree_inode = root->fs_info->btree_inode;
799
	struct super_block *sb = root->fs_info->sb;
800

801 802
	if (!btrfs_test_opt(root, NOBARRIER))
		blkdev_issue_flush(sb->s_bdev, NULL);
803
	set_extent_buffer_dirty(&BTRFS_I(btree_inode)->io_tree, super);
804 805
	ret = sync_page_range_nolock(btree_inode, btree_inode->i_mapping,
				     super->start, super->len);
806 807
	if (!btrfs_test_opt(root, NOBARRIER))
		blkdev_issue_flush(sb->s_bdev, NULL);
808
	return ret;
C
Chris Mason 已提交
809 810
}

811
int btrfs_free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root)
C
Chris Mason 已提交
812 813 814
{
	radix_tree_delete(&fs_info->fs_roots_radix,
			  (unsigned long)root->root_key.objectid);
815 816
	if (root->in_sysfs)
		btrfs_sysfs_del_root(root);
C
Chris Mason 已提交
817 818 819
	if (root->inode)
		iput(root->inode);
	if (root->node)
820
		free_extent_buffer(root->node);
C
Chris Mason 已提交
821
	if (root->commit_root)
822
		free_extent_buffer(root->commit_root);
823 824
	if (root->name)
		kfree(root->name);
C
Chris Mason 已提交
825 826 827 828
	kfree(root);
	return 0;
}

C
Chris Mason 已提交
829
static int del_fs_roots(struct btrfs_fs_info *fs_info)
830 831 832 833 834 835 836 837 838 839 840
{
	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 已提交
841
		for (i = 0; i < ret; i++)
842
			btrfs_free_fs_root(fs_info, gang[i]);
843 844 845
	}
	return 0;
}
846

C
Chris Mason 已提交
847
int close_ctree(struct btrfs_root *root)
C
Chris Mason 已提交
848
{
849
	int ret;
850
	struct btrfs_trans_handle *trans;
851
	struct btrfs_fs_info *fs_info = root->fs_info;
852

853
	fs_info->closing = 1;
C
Chris Mason 已提交
854
	btrfs_transaction_flush_work(root);
855
	mutex_lock(&fs_info->fs_mutex);
856
	btrfs_defrag_dirty_roots(root->fs_info);
C
Chris Mason 已提交
857
	trans = btrfs_start_transaction(root, 1);
858
	ret = btrfs_commit_transaction(trans, root);
C
Chris Mason 已提交
859 860 861 862
	/* 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);
863
	BUG_ON(ret);
C
Chris Mason 已提交
864
	write_ctree_super(NULL, root);
865 866
	mutex_unlock(&fs_info->fs_mutex);

C
Chris Mason 已提交
867 868 869 870
	if (fs_info->delalloc_bytes) {
		printk("btrfs: at unmount delalloc count %Lu\n",
		       fs_info->delalloc_bytes);
	}
871
	if (fs_info->extent_root->node)
872
		free_extent_buffer(fs_info->extent_root->node);
873

874
	if (fs_info->tree_root->node)
875
		free_extent_buffer(fs_info->tree_root->node);
876

877
	free_extent_buffer(fs_info->sb_buffer);
878

C
Chris Mason 已提交
879
	btrfs_free_block_groups(root->fs_info);
880
	del_fs_roots(fs_info);
881 882 883

	filemap_write_and_wait(fs_info->btree_inode->i_mapping);

884 885 886 887 888 889
	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);
890

891
	truncate_inode_pages(fs_info->btree_inode->i_mapping, 0);
892

893
	iput(fs_info->btree_inode);
894 895 896 897 898 899 900 901 902 903
#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
904 905
	kfree(fs_info->extent_root);
	kfree(fs_info->tree_root);
906 907 908
	return 0;
}

909 910
int btrfs_buffer_uptodate(struct extent_buffer *buf)
{
911
	struct inode *btree_inode = buf->first_page->mapping->host;
912
	return extent_buffer_uptodate(&BTRFS_I(btree_inode)->io_tree, buf);
913 914 915
}

int btrfs_set_buffer_uptodate(struct extent_buffer *buf)
C
Chris Mason 已提交
916
{
917
	struct inode *btree_inode = buf->first_page->mapping->host;
918
	return set_extent_buffer_uptodate(&BTRFS_I(btree_inode)->io_tree,
919 920
					  buf);
}
921

922 923
void btrfs_mark_buffer_dirty(struct extent_buffer *buf)
{
924
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
925 926
	u64 transid = btrfs_header_generation(buf);
	struct inode *btree_inode = root->fs_info->btree_inode;
927

C
Chris Mason 已提交
928 929
	if (transid != root->fs_info->generation) {
		printk(KERN_CRIT "transid mismatch buffer %llu, found %Lu running %Lu\n",
930
			(unsigned long long)buf->start,
C
Chris Mason 已提交
931 932 933
			transid, root->fs_info->generation);
		WARN_ON(1);
	}
934
	set_extent_buffer_dirty(&BTRFS_I(btree_inode)->io_tree, buf);
935 936
}

937 938
void btrfs_throttle(struct btrfs_root *root)
{
939 940 941
	struct backing_dev_info *bdi;

	bdi = root->fs_info->sb->s_bdev->bd_inode->i_mapping->backing_dev_info;
942 943
	if (root->fs_info->throttles && bdi_write_congested(bdi)) {
#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,18)
944
		congestion_wait(WRITE, HZ/20);
945 946 947 948
#else
		blk_congestion_wait(WRITE, HZ/20);
#endif
	}
949 950
}

951
void btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr)
C
Chris Mason 已提交
952
{
953
	balance_dirty_pages_ratelimited_nr(
954
			root->fs_info->btree_inode->i_mapping, 1);
C
Chris Mason 已提交
955
}
956 957 958

void btrfs_set_buffer_defrag(struct extent_buffer *buf)
{
959
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
960
	struct inode *btree_inode = root->fs_info->btree_inode;
961
	set_extent_bits(&BTRFS_I(btree_inode)->io_tree, buf->start,
962 963 964 965 966
			buf->start + buf->len - 1, EXTENT_DEFRAG, GFP_NOFS);
}

void btrfs_set_buffer_defrag_done(struct extent_buffer *buf)
{
967
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
968
	struct inode *btree_inode = root->fs_info->btree_inode;
969
	set_extent_bits(&BTRFS_I(btree_inode)->io_tree, buf->start,
970 971 972 973 974 975
			buf->start + buf->len - 1, EXTENT_DEFRAG_DONE,
			GFP_NOFS);
}

int btrfs_buffer_defrag(struct extent_buffer *buf)
{
976
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
977
	struct inode *btree_inode = root->fs_info->btree_inode;
978
	return test_range_bit(&BTRFS_I(btree_inode)->io_tree,
979 980 981 982 983
		     buf->start, buf->start + buf->len - 1, EXTENT_DEFRAG, 0);
}

int btrfs_buffer_defrag_done(struct extent_buffer *buf)
{
984
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
985
	struct inode *btree_inode = root->fs_info->btree_inode;
986
	return test_range_bit(&BTRFS_I(btree_inode)->io_tree,
987 988 989 990 991 992
		     buf->start, buf->start + buf->len - 1,
		     EXTENT_DEFRAG_DONE, 0);
}

int btrfs_clear_buffer_defrag_done(struct extent_buffer *buf)
{
993
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
994
	struct inode *btree_inode = root->fs_info->btree_inode;
995
	return clear_extent_bits(&BTRFS_I(btree_inode)->io_tree,
996 997 998 999 1000 1001
		     buf->start, buf->start + buf->len - 1,
		     EXTENT_DEFRAG_DONE, GFP_NOFS);
}

int btrfs_clear_buffer_defrag(struct extent_buffer *buf)
{
1002
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
1003
	struct inode *btree_inode = root->fs_info->btree_inode;
1004
	return clear_extent_bits(&BTRFS_I(btree_inode)->io_tree,
1005 1006 1007 1008 1009 1010
		     buf->start, buf->start + buf->len - 1,
		     EXTENT_DEFRAG, GFP_NOFS);
}

int btrfs_read_buffer(struct extent_buffer *buf)
{
1011
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
1012
	struct inode *btree_inode = root->fs_info->btree_inode;
1013
	return read_extent_buffer_pages(&BTRFS_I(btree_inode)->io_tree,
1014
					buf, 0, 1, btree_get_extent);
1015
}
1016

1017
static struct extent_io_ops btree_extent_io_ops = {
1018 1019
	.writepage_io_hook = btree_writepage_io_hook,
};