disk-io.c 22.8 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
struct extent_buffer *btrfs_find_tree_block(struct btrfs_root *root,
47
					    u64 bytenr, u32 blocksize)
48
{
49
	struct inode *btree_inode = root->fs_info->btree_inode;
50 51
	struct extent_buffer *eb;
	eb = find_extent_buffer(&BTRFS_I(btree_inode)->extent_tree,
52
				bytenr, blocksize, GFP_NOFS);
53
	return eb;
54
}
55

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

62
	eb = alloc_extent_buffer(&BTRFS_I(btree_inode)->extent_tree,
63
				 bytenr, blocksize, NULL, GFP_NOFS);
64
	return eb;
65 66
}

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

again:
	em = lookup_extent_mapping(em_tree, start, end);
	if (em) {
		goto out;
79
	}
80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
	em = alloc_extent_map(GFP_NOFS);
	if (!em) {
		em = ERR_PTR(-ENOMEM);
		goto out;
	}
	em->start = 0;
	em->end = (i_size_read(inode) & ~((u64)PAGE_CACHE_SIZE -1)) - 1;
	em->block_start = 0;
	em->block_end = em->end;
	em->bdev = inode->i_sb->s_bdev;
	ret = add_extent_mapping(em_tree, em);
	if (ret == -EEXIST) {
		free_extent_map(em);
		em = NULL;
		goto again;
	} else if (ret) {
		em = ERR_PTR(ret);
	}
out:
	return em;
100 101
}

102 103 104 105 106 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 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190
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) {
		if (memcmp_extent_buffer(buf, result, 0, BTRFS_CRC32_SIZE)) {
			printk("btrfs: %s checksum verify failed on %llu\n",
			       root->fs_info->sb->s_id,
			       buf->start);
			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)
{
	struct extent_map_tree *tree;
	u64 start = page->index << PAGE_CACHE_SHIFT;
	u64 found_start;
	int found_level;
	unsigned long len;
	struct extent_buffer *eb;
	tree = &BTRFS_I(page->mapping->host)->extent_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);
	read_extent_buffer_pages(tree, eb, start + PAGE_CACHE_SIZE, 1);
	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);
	}
	found_level = btrfs_header_level(eb);
	csum_tree_block(root, eb, 0);
	free_extent_buffer(eb);
out:
	return 0;
}

191
static int btree_writepage(struct page *page, struct writeback_control *wbc)
192
{
193
	struct extent_map_tree *tree;
194
	struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
195
	tree = &BTRFS_I(page->mapping->host)->extent_tree;
196 197

	csum_dirty_buffer(root, page);
198 199 200 201 202 203 204 205
	return extent_write_full_page(tree, page, btree_get_extent, wbc);
}
int btree_readpage(struct file *file, struct page *page)
{
	struct extent_map_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->extent_tree;
	return extent_read_full_page(tree, page, btree_get_extent);
}
C
Chris Mason 已提交
206

207 208 209 210
static int btree_releasepage(struct page *page, gfp_t unused_gfp_flags)
{
	struct extent_map_tree *tree;
	int ret;
211

212 213 214 215 216 217 218
	tree = &BTRFS_I(page->mapping->host)->extent_tree;
	ret = try_release_extent_mapping(tree, page);
	if (ret == 1) {
		ClearPagePrivate(page);
		set_page_private(page, 0);
		page_cache_release(page);
	}
219 220 221
	return ret;
}

222
static void btree_invalidatepage(struct page *page, unsigned long offset)
223
{
224 225 226 227
	struct extent_map_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->extent_tree;
	extent_invalidatepage(tree, page, offset);
	btree_releasepage(page, GFP_NOFS);
228 229
}

230
#if 0
231
static int btree_writepage(struct page *page, struct writeback_control *wbc)
232
{
C
Chris Mason 已提交
233
	struct buffer_head *bh;
234
	struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
C
Chris Mason 已提交
235 236 237 238 239 240 241 242 243 244 245 246
	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);
247
	return block_write_full_page(page, btree_get_block, wbc);
248
}
249
#endif
250

251 252 253
static struct address_space_operations btree_aops = {
	.readpage	= btree_readpage,
	.writepage	= btree_writepage,
254 255
	.releasepage	= btree_releasepage,
	.invalidatepage = btree_invalidatepage,
256 257 258
	.sync_page	= block_sync_page,
};

259
int readahead_tree_block(struct btrfs_root *root, u64 bytenr, u32 blocksize)
C
Chris Mason 已提交
260
{
261 262
	struct extent_buffer *buf = NULL;
	struct inode *btree_inode = root->fs_info->btree_inode;
263
	int ret = 0;
C
Chris Mason 已提交
264

265
	buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
266
	if (!buf)
C
Chris Mason 已提交
267
		return 0;
268
	read_extent_buffer_pages(&BTRFS_I(btree_inode)->extent_tree,
269
				 buf, 0, 0);
270
	free_extent_buffer(buf);
271
	return ret;
C
Chris Mason 已提交
272 273
}

274 275
struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 bytenr,
				      u32 blocksize)
276
{
277 278
	struct extent_buffer *buf = NULL;
	struct inode *btree_inode = root->fs_info->btree_inode;
279 280 281 282
	struct extent_map_tree *extent_tree;
	int ret;

	extent_tree = &BTRFS_I(btree_inode)->extent_tree;
283

284
	buf = btrfs_find_create_tree_block(root, bytenr, blocksize);
285 286 287
	if (!buf)
		return NULL;
	read_extent_buffer_pages(&BTRFS_I(btree_inode)->extent_tree,
288 289 290 291 292 293 294 295 296 297 298 299 300 301
				 buf, 0, 1);
	if (buf->flags & EXTENT_CSUM) {
		return buf;
	}
	if (test_range_bit(extent_tree, buf->start, buf->start + buf->len - 1,
			   EXTENT_CSUM, 1)) {
		buf->flags |= EXTENT_CSUM;
		return buf;
	}
	ret = csum_tree_block(root, buf, 1);
	set_extent_bits(extent_tree, buf->start,
			buf->start + buf->len - 1,
			EXTENT_CSUM, GFP_NOFS);
	buf->flags |= EXTENT_CSUM;
302
	return buf;
303 304
}

305
int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
306
		     struct extent_buffer *buf)
307
{
308 309 310 311 312 313 314 315 316 317 318 319 320 321
	struct inode *btree_inode = root->fs_info->btree_inode;
	clear_extent_buffer_dirty(&BTRFS_I(btree_inode)->extent_tree, buf);
	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;
	wait_on_extent_buffer_writeback(&BTRFS_I(btree_inode)->extent_tree,
					buf);
	return 0;
}

322
static int __setup_root(u32 nodesize, u32 leafsize, u32 sectorsize,
323 324
			struct btrfs_root *root,
			struct btrfs_fs_info *fs_info,
C
Chris Mason 已提交
325
			u64 objectid)
326
{
C
Chris Mason 已提交
327
	root->node = NULL;
328
	root->inode = NULL;
329
	root->commit_root = NULL;
330 331 332
	root->sectorsize = sectorsize;
	root->nodesize = nodesize;
	root->leafsize = leafsize;
C
Chris Mason 已提交
333
	root->ref_cows = 0;
334
	root->fs_info = fs_info;
335 336
	root->objectid = objectid;
	root->last_trans = 0;
C
Chris Mason 已提交
337 338
	root->highest_inode = 0;
	root->last_inode_alloc = 0;
339
	root->name = NULL;
340 341
	memset(&root->root_key, 0, sizeof(root->root_key));
	memset(&root->root_item, 0, sizeof(root->root_item));
342
	memset(&root->defrag_progress, 0, sizeof(root->defrag_progress));
343 344
	memset(&root->root_kobj, 0, sizeof(root->root_kobj));
	init_completion(&root->kobj_unregister);
345
	init_rwsem(&root->snap_sem);
346 347
	root->defrag_running = 0;
	root->defrag_level = 0;
348
	root->root_key.objectid = objectid;
349 350 351
	return 0;
}

352
static int find_and_setup_root(struct btrfs_root *tree_root,
353 354
			       struct btrfs_fs_info *fs_info,
			       u64 objectid,
C
Chris Mason 已提交
355
			       struct btrfs_root *root)
356 357
{
	int ret;
358
	u32 blocksize;
359

360 361
	__setup_root(tree_root->nodesize, tree_root->leafsize,
		     tree_root->sectorsize, root, fs_info, objectid);
362 363 364 365
	ret = btrfs_find_last_root(tree_root, objectid,
				   &root->root_item, &root->root_key);
	BUG_ON(ret);

366 367 368
	blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
	root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
				     blocksize);
369
	BUG_ON(!root->node);
370 371 372
	return 0;
}

373 374
struct btrfs_root *btrfs_read_fs_root_no_radix(struct btrfs_fs_info *fs_info,
					       struct btrfs_key *location)
375 376 377 378
{
	struct btrfs_root *root;
	struct btrfs_root *tree_root = fs_info->tree_root;
	struct btrfs_path *path;
379
	struct extent_buffer *l;
C
Chris Mason 已提交
380
	u64 highest_inode;
381
	u32 blocksize;
382 383
	int ret = 0;

384
	root = kzalloc(sizeof(*root), GFP_NOFS);
C
Chris Mason 已提交
385
	if (!root)
386 387
		return ERR_PTR(-ENOMEM);
	if (location->offset == (u64)-1) {
388
		ret = find_and_setup_root(tree_root, fs_info,
389 390 391 392 393 394 395 396
					  location->objectid, root);
		if (ret) {
			kfree(root);
			return ERR_PTR(ret);
		}
		goto insert;
	}

397 398
	__setup_root(tree_root->nodesize, tree_root->leafsize,
		     tree_root->sectorsize, root, fs_info,
399 400 401 402 403 404 405 406 407 408
		     location->objectid);

	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;
	}
409 410 411
	l = path->nodes[0];
	read_extent_buffer(l, &root->root_item,
	       btrfs_item_ptr_offset(l, path->slots[0]),
412 413 414 415 416 417 418 419 420
	       sizeof(root->root_item));
	ret = 0;
out:
	btrfs_release_path(root, path);
	btrfs_free_path(path);
	if (ret) {
		kfree(root);
		return ERR_PTR(ret);
	}
421 422 423
	blocksize = btrfs_level_size(root, btrfs_root_level(&root->root_item));
	root->node = read_tree_block(root, btrfs_root_bytenr(&root->root_item),
				     blocksize);
424 425 426
	BUG_ON(!root->node);
insert:
	root->ref_cows = 1;
427 428 429 430 431 432 433 434 435
	ret = btrfs_find_highest_inode(root, &highest_inode);
	if (ret == 0) {
		root->highest_inode = highest_inode;
		root->last_inode_alloc = highest_inode;
	}
	return root;
}

struct btrfs_root *btrfs_read_fs_root(struct btrfs_fs_info *fs_info,
436 437
				      struct btrfs_key *location,
				      const char *name, int namelen)
438 439 440 441 442 443 444 445 446 447 448 449
{
	struct btrfs_root *root;
	int ret;

	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 已提交
450 451
	ret = radix_tree_insert(&fs_info->fs_roots_radix,
				(unsigned long)root->root_key.objectid,
452 453
				root);
	if (ret) {
454
		free_extent_buffer(root->node);
455 456 457
		kfree(root);
		return ERR_PTR(ret);
	}
458 459 460

	ret = btrfs_set_root_name(root, name, namelen);
	if (ret) {
461
		free_extent_buffer(root->node);
462 463 464 465 466 467
		kfree(root);
		return ERR_PTR(ret);
	}

	ret = btrfs_sysfs_add_root(root);
	if (ret) {
468
		free_extent_buffer(root->node);
469 470 471 472 473
		kfree(root->name);
		kfree(root);
		return ERR_PTR(ret);
	}

474 475 476 477
	ret = btrfs_find_dead_roots(fs_info->tree_root,
				    root->root_key.objectid, root);
	BUG_ON(ret);

478 479
	return root;
}
480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497
#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 已提交
498
struct btrfs_root *open_ctree(struct super_block *sb)
499
{
500 501 502 503
	u32 sectorsize;
	u32 nodesize;
	u32 leafsize;
	u32 blocksize;
C
Chris Mason 已提交
504 505 506 507 508 509
	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);
510
	int ret;
C
Chris Mason 已提交
511
	int err = -EIO;
C
Chris Mason 已提交
512
	struct btrfs_super_block *disk_super;
513

C
Chris Mason 已提交
514 515 516 517
	if (!extent_root || !tree_root || !fs_info) {
		err = -ENOMEM;
		goto fail;
	}
518
	INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_NOFS);
C
Chris Mason 已提交
519
	INIT_LIST_HEAD(&fs_info->trans_list);
520
	INIT_LIST_HEAD(&fs_info->dead_roots);
521 522 523
	INIT_LIST_HEAD(&fs_info->hashers);
	spin_lock_init(&fs_info->hash_lock);

524 525
	memset(&fs_info->super_kobj, 0, sizeof(fs_info->super_kobj));
	init_completion(&fs_info->kobj_unregister);
C
Chris Mason 已提交
526
	sb_set_blocksize(sb, 4096);
527
	fs_info->running_transaction = NULL;
528
	fs_info->last_trans_committed = 0;
529 530
	fs_info->tree_root = tree_root;
	fs_info->extent_root = extent_root;
C
Chris Mason 已提交
531
	fs_info->sb = sb;
532 533
	fs_info->btree_inode = new_inode(sb);
	fs_info->btree_inode->i_ino = 1;
C
Chris Mason 已提交
534
	fs_info->btree_inode->i_nlink = 1;
535 536
	fs_info->btree_inode->i_size = sb->s_bdev->bd_inode->i_size;
	fs_info->btree_inode->i_mapping->a_ops = &btree_aops;
537 538 539
	extent_map_tree_init(&BTRFS_I(fs_info->btree_inode)->extent_tree,
			     fs_info->btree_inode->i_mapping,
			     GFP_NOFS);
540 541
	extent_map_tree_init(&fs_info->free_space_cache,
			     fs_info->btree_inode->i_mapping, GFP_NOFS);
542 543
	extent_map_tree_init(&fs_info->block_group_cache,
			     fs_info->btree_inode->i_mapping, GFP_NOFS);
544 545 546 547 548 549
	extent_map_tree_init(&fs_info->pinned_extents,
			     fs_info->btree_inode->i_mapping, GFP_NOFS);
	extent_map_tree_init(&fs_info->pending_del,
			     fs_info->btree_inode->i_mapping, GFP_NOFS);
	extent_map_tree_init(&fs_info->extent_ins,
			     fs_info->btree_inode->i_mapping, GFP_NOFS);
550
	fs_info->do_barriers = 1;
551 552
	fs_info->closing = 0;

C
Chris Mason 已提交
553
	INIT_DELAYED_WORK(&fs_info->trans_work, btrfs_transaction_cleaner);
554 555 556
	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 已提交
557
	insert_inode_hash(fs_info->btree_inode);
558
	mapping_set_gfp_mask(fs_info->btree_inode->i_mapping, GFP_NOFS);
C
Chris Mason 已提交
559

C
Chris Mason 已提交
560
	mutex_init(&fs_info->trans_mutex);
C
Chris Mason 已提交
561
	mutex_init(&fs_info->fs_mutex);
562

563 564 565 566 567 568 569 570
#if 0
	ret = add_hasher(fs_info, "crc32c");
	if (ret) {
		printk("btrfs: failed hash setup, modprobe cryptomgr?\n");
		err = -ENOMEM;
		goto fail_iput;
	}
#endif
571
	__setup_root(512, 512, 512, tree_root,
C
Chris Mason 已提交
572
		     fs_info, BTRFS_ROOT_TREE_OBJECTID);
573

C
Chris Mason 已提交
574
	fs_info->sb_buffer = read_tree_block(tree_root,
575 576
					     BTRFS_SUPER_INFO_OFFSET,
					     512);
577

578
	if (!fs_info->sb_buffer)
C
Chris Mason 已提交
579 580
		goto fail_iput;

581 582 583 584 585 586 587
	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;
588
	if (!btrfs_super_root(disk_super))
C
Chris Mason 已提交
589
		goto fail_sb_buffer;
590

591 592 593 594 595 596 597
	nodesize = btrfs_super_nodesize(disk_super);
	leafsize = btrfs_super_leafsize(disk_super);
	sectorsize = btrfs_super_sectorsize(disk_super);
	tree_root->nodesize = nodesize;
	tree_root->leafsize = leafsize;
	tree_root->sectorsize = sectorsize;

598
	i_size_write(fs_info->btree_inode,
599
		     btrfs_super_total_bytes(disk_super));
600

C
Chris Mason 已提交
601 602 603 604 605
	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;
	}
606

607 608
	blocksize = btrfs_level_size(tree_root,
				     btrfs_super_root_level(disk_super));
609

C
Chris Mason 已提交
610
	tree_root->node = read_tree_block(tree_root,
611 612
					  btrfs_super_root(disk_super),
					  blocksize);
C
Chris Mason 已提交
613 614
	if (!tree_root->node)
		goto fail_sb_buffer;
615

C
Chris Mason 已提交
616
	mutex_lock(&fs_info->fs_mutex);
617 618

	ret = find_and_setup_root(tree_root, fs_info,
C
Chris Mason 已提交
619
				  BTRFS_EXTENT_TREE_OBJECTID, extent_root);
C
Chris Mason 已提交
620 621 622 623
	if (ret) {
		mutex_unlock(&fs_info->fs_mutex);
		goto fail_tree_root;
	}
624

C
Chris Mason 已提交
625 626
	btrfs_read_block_groups(extent_root);

627
	fs_info->generation = btrfs_super_generation(disk_super) + 1;
C
Chris Mason 已提交
628
	mutex_unlock(&fs_info->fs_mutex);
629
	return tree_root;
C
Chris Mason 已提交
630 631

fail_tree_root:
632
	free_extent_buffer(tree_root->node);
C
Chris Mason 已提交
633
fail_sb_buffer:
634
	free_extent_buffer(fs_info->sb_buffer);
C
Chris Mason 已提交
635 636 637 638 639 640 641
fail_iput:
	iput(fs_info->btree_inode);
fail:
	kfree(extent_root);
	kfree(tree_root);
	kfree(fs_info);
	return ERR_PTR(err);
642 643
}

644
int write_ctree_super(struct btrfs_trans_handle *trans, struct btrfs_root
C
Chris Mason 已提交
645
		      *root)
646
{
647
	int ret;
648 649 650 651 652 653 654
	struct extent_buffer *super = root->fs_info->sb_buffer;
	struct inode *btree_inode = root->fs_info->btree_inode;

	set_extent_buffer_dirty(&BTRFS_I(btree_inode)->extent_tree, super);
	ret = sync_page_range_nolock(btree_inode, btree_inode->i_mapping,
				     super->start, super->len);
	return ret;
C
Chris Mason 已提交
655 656
}

657
int btrfs_free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root)
C
Chris Mason 已提交
658 659 660
{
	radix_tree_delete(&fs_info->fs_roots_radix,
			  (unsigned long)root->root_key.objectid);
661
	btrfs_sysfs_del_root(root);
C
Chris Mason 已提交
662 663 664
	if (root->inode)
		iput(root->inode);
	if (root->node)
665
		free_extent_buffer(root->node);
C
Chris Mason 已提交
666
	if (root->commit_root)
667
		free_extent_buffer(root->commit_root);
668 669
	if (root->name)
		kfree(root->name);
C
Chris Mason 已提交
670 671 672 673
	kfree(root);
	return 0;
}

C
Chris Mason 已提交
674
static int del_fs_roots(struct btrfs_fs_info *fs_info)
675 676 677 678 679 680 681 682 683 684 685
{
	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 已提交
686
		for (i = 0; i < ret; i++)
687
			btrfs_free_fs_root(fs_info, gang[i]);
688 689 690
	}
	return 0;
}
691

C
Chris Mason 已提交
692
int close_ctree(struct btrfs_root *root)
C
Chris Mason 已提交
693
{
694
	int ret;
695
	struct btrfs_trans_handle *trans;
696
	struct btrfs_fs_info *fs_info = root->fs_info;
697

698
	fs_info->closing = 1;
C
Chris Mason 已提交
699
	btrfs_transaction_flush_work(root);
700
	mutex_lock(&fs_info->fs_mutex);
701
	btrfs_defrag_dirty_roots(root->fs_info);
C
Chris Mason 已提交
702
	trans = btrfs_start_transaction(root, 1);
703
	ret = btrfs_commit_transaction(trans, root);
C
Chris Mason 已提交
704 705 706 707
	/* 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);
708
	BUG_ON(ret);
C
Chris Mason 已提交
709
	write_ctree_super(NULL, root);
710 711 712
	mutex_unlock(&fs_info->fs_mutex);

	if (fs_info->extent_root->node)
713
		free_extent_buffer(fs_info->extent_root->node);
714

715
	if (fs_info->tree_root->node)
716
		free_extent_buffer(fs_info->tree_root->node);
717

718
	free_extent_buffer(fs_info->sb_buffer);
719

C
Chris Mason 已提交
720
	btrfs_free_block_groups(root->fs_info);
721
	del_fs_roots(fs_info);
722
	extent_map_tree_empty_lru(&BTRFS_I(fs_info->btree_inode)->extent_tree);
723 724
	truncate_inode_pages(fs_info->btree_inode->i_mapping, 0);
	iput(fs_info->btree_inode);
725 726 727 728 729 730 731 732 733 734
#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
735 736
	kfree(fs_info->extent_root);
	kfree(fs_info->tree_root);
737 738 739
	return 0;
}

740 741
int btrfs_buffer_uptodate(struct extent_buffer *buf)
{
742
	struct inode *btree_inode = buf->first_page->mapping->host;
743 744 745 746
	return extent_buffer_uptodate(&BTRFS_I(btree_inode)->extent_tree, buf);
}

int btrfs_set_buffer_uptodate(struct extent_buffer *buf)
C
Chris Mason 已提交
747
{
748
	struct inode *btree_inode = buf->first_page->mapping->host;
749 750 751
	return set_extent_buffer_uptodate(&BTRFS_I(btree_inode)->extent_tree,
					  buf);
}
752

753 754
void btrfs_mark_buffer_dirty(struct extent_buffer *buf)
{
755
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
756 757
	u64 transid = btrfs_header_generation(buf);
	struct inode *btree_inode = root->fs_info->btree_inode;
758

C
Chris Mason 已提交
759 760
	if (transid != root->fs_info->generation) {
		printk(KERN_CRIT "transid mismatch buffer %llu, found %Lu running %Lu\n",
761
			(unsigned long long)buf->start,
C
Chris Mason 已提交
762 763 764
			transid, root->fs_info->generation);
		WARN_ON(1);
	}
765
	set_extent_buffer_dirty(&BTRFS_I(btree_inode)->extent_tree, buf);
766 767
}

768
void btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr)
C
Chris Mason 已提交
769
{
770 771
	balance_dirty_pages_ratelimited_nr(
			root->fs_info->btree_inode->i_mapping, nr);
C
Chris Mason 已提交
772
}
773 774 775

void btrfs_set_buffer_defrag(struct extent_buffer *buf)
{
776
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
777 778 779 780 781 782 783
	struct inode *btree_inode = root->fs_info->btree_inode;
	set_extent_bits(&BTRFS_I(btree_inode)->extent_tree, buf->start,
			buf->start + buf->len - 1, EXTENT_DEFRAG, GFP_NOFS);
}

void btrfs_set_buffer_defrag_done(struct extent_buffer *buf)
{
784
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
785 786 787 788 789 790 791 792
	struct inode *btree_inode = root->fs_info->btree_inode;
	set_extent_bits(&BTRFS_I(btree_inode)->extent_tree, buf->start,
			buf->start + buf->len - 1, EXTENT_DEFRAG_DONE,
			GFP_NOFS);
}

int btrfs_buffer_defrag(struct extent_buffer *buf)
{
793
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
794 795 796 797 798 799 800
	struct inode *btree_inode = root->fs_info->btree_inode;
	return test_range_bit(&BTRFS_I(btree_inode)->extent_tree,
		     buf->start, buf->start + buf->len - 1, EXTENT_DEFRAG, 0);
}

int btrfs_buffer_defrag_done(struct extent_buffer *buf)
{
801
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
802 803 804 805 806 807 808 809
	struct inode *btree_inode = root->fs_info->btree_inode;
	return test_range_bit(&BTRFS_I(btree_inode)->extent_tree,
		     buf->start, buf->start + buf->len - 1,
		     EXTENT_DEFRAG_DONE, 0);
}

int btrfs_clear_buffer_defrag_done(struct extent_buffer *buf)
{
810
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
811 812 813 814 815 816 817 818
	struct inode *btree_inode = root->fs_info->btree_inode;
	return clear_extent_bits(&BTRFS_I(btree_inode)->extent_tree,
		     buf->start, buf->start + buf->len - 1,
		     EXTENT_DEFRAG_DONE, GFP_NOFS);
}

int btrfs_clear_buffer_defrag(struct extent_buffer *buf)
{
819
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
820 821 822 823 824 825 826 827
	struct inode *btree_inode = root->fs_info->btree_inode;
	return clear_extent_bits(&BTRFS_I(btree_inode)->extent_tree,
		     buf->start, buf->start + buf->len - 1,
		     EXTENT_DEFRAG, GFP_NOFS);
}

int btrfs_read_buffer(struct extent_buffer *buf)
{
828
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
829 830
	struct inode *btree_inode = root->fs_info->btree_inode;
	return read_extent_buffer_pages(&BTRFS_I(btree_inode)->extent_tree,
831
					buf, 0, 1);
832
}