disk-io.c 13.4 KB
Newer Older
C
Chris Mason 已提交
1 2
#include <linux/module.h>
#include <linux/fs.h>
3
#include <linux/blkdev.h>
C
Chris Mason 已提交
4 5
#include <linux/crypto.h>
#include <linux/scatterlist.h>
C
Chris Mason 已提交
6
#include <linux/swap.h>
7
#include <linux/radix-tree.h>
8 9
#include "ctree.h"
#include "disk-io.h"
10
#include "transaction.h"
11
#include "btrfs_inode.h"
12

C
Chris Mason 已提交
13
static int check_tree_block(struct btrfs_root *root, struct buffer_head *buf)
14
{
C
Chris Mason 已提交
15
	struct btrfs_node *node = btrfs_buffer_node(buf);
16
	if (buf->b_blocknr != btrfs_header_blocknr(&node->header)) {
17
		BUG();
18
	}
19
	return 0;
20 21
}

22 23 24 25 26 27 28 29 30 31
struct buffer_head *btrfs_find_tree_block(struct btrfs_root *root, u64 blocknr)
{
	struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
	int blockbits = root->fs_info->sb->s_blocksize_bits;
	unsigned long index = blocknr >> (PAGE_CACHE_SHIFT - blockbits);
	struct page *page;
	struct buffer_head *bh;
	struct buffer_head *head;
	struct buffer_head *ret = NULL;

C
Chris Mason 已提交
32

33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51
	page = find_lock_page(mapping, index);
	if (!page)
		return NULL;

	if (!page_has_buffers(page))
		goto out_unlock;

	head = page_buffers(page);
	bh = head;
	do {
		if (buffer_mapped(bh) && bh->b_blocknr == blocknr) {
			ret = bh;
			get_bh(bh);
			goto out_unlock;
		}
		bh = bh->b_this_page;
	} while (bh != head);
out_unlock:
	unlock_page(page);
C
Chris Mason 已提交
52
	if (ret) {
C
Chris Mason 已提交
53
		touch_buffer(ret);
C
Chris Mason 已提交
54
	}
55 56 57 58 59 60 61 62 63 64 65 66 67 68 69
	page_cache_release(page);
	return ret;
}

struct buffer_head *btrfs_find_create_tree_block(struct btrfs_root *root,
						 u64 blocknr)
{
	struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
	int blockbits = root->fs_info->sb->s_blocksize_bits;
	unsigned long index = blocknr >> (PAGE_CACHE_SHIFT - blockbits);
	struct page *page;
	struct buffer_head *bh;
	struct buffer_head *head;
	struct buffer_head *ret = NULL;
	u64 first_block = index << (PAGE_CACHE_SHIFT - blockbits);
C
Chris Mason 已提交
70

71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94
	page = grab_cache_page(mapping, index);
	if (!page)
		return NULL;

	if (!page_has_buffers(page))
		create_empty_buffers(page, root->fs_info->sb->s_blocksize, 0);
	head = page_buffers(page);
	bh = head;
	do {
		if (!buffer_mapped(bh)) {
			bh->b_bdev = root->fs_info->sb->s_bdev;
			bh->b_blocknr = first_block;
			set_buffer_mapped(bh);
		}
		if (bh->b_blocknr == blocknr) {
			ret = bh;
			get_bh(bh);
			goto out_unlock;
		}
		bh = bh->b_this_page;
		first_block++;
	} while (bh != head);
out_unlock:
	unlock_page(page);
C
Chris Mason 已提交
95 96
	if (ret)
		touch_buffer(ret);
97 98 99 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
	page_cache_release(page);
	return ret;
}

static sector_t max_block(struct block_device *bdev)
{
	sector_t retval = ~((sector_t)0);
	loff_t sz = i_size_read(bdev->bd_inode);

	if (sz) {
		unsigned int size = block_size(bdev);
		unsigned int sizebits = blksize_bits(size);
		retval = (sz >> sizebits);
	}
	return retval;
}

static int btree_get_block(struct inode *inode, sector_t iblock,
			   struct buffer_head *bh, int create)
{
	if (iblock >= max_block(inode->i_sb->s_bdev)) {
		if (create)
			return -EIO;

		/*
		 * for reads, we're just trying to fill a partial page.
		 * return a hole, they will have to call get_block again
		 * before they can fill it, and they will get -EIO at that
		 * time
		 */
		return 0;
	}
	bh->b_bdev = inode->i_sb->s_bdev;
	bh->b_blocknr = iblock;
	set_buffer_mapped(bh);
	return 0;
}

C
Chris Mason 已提交
135 136
int btrfs_csum_data(struct btrfs_root * root, char *data, size_t len,
		    char *result)
C
Chris Mason 已提交
137 138 139 140 141 142 143 144
{
	struct scatterlist sg;
	struct crypto_hash *tfm = root->fs_info->hash_tfm;
	struct hash_desc desc;
	int ret;

	desc.tfm = tfm;
	desc.flags = 0;
C
Chris Mason 已提交
145
	sg_init_one(&sg, data, len);
C
Chris Mason 已提交
146
	spin_lock(&root->fs_info->hash_lock);
C
Chris Mason 已提交
147
	ret = crypto_hash_digest(&desc, &sg, 1, result);
C
Chris Mason 已提交
148 149 150 151
	spin_unlock(&root->fs_info->hash_lock);
	if (ret) {
		printk("sha256 digest failed\n");
	}
C
Chris Mason 已提交
152 153 154 155 156 157 158 159 160 161 162 163 164
	return ret;
}
static int csum_tree_block(struct btrfs_root *root, struct buffer_head *bh,
			   int verify)
{
	char result[BTRFS_CSUM_SIZE];
	int ret;
	struct btrfs_node *node;

	ret = btrfs_csum_data(root, bh->b_data + BTRFS_CSUM_SIZE,
			      bh->b_size - BTRFS_CSUM_SIZE, result);
	if (ret)
		return ret;
C
Chris Mason 已提交
165
	if (verify) {
C
Chris Mason 已提交
166 167 168 169 170 171 172
		if (memcmp(bh->b_data, result, BTRFS_CSUM_SIZE)) {
			printk("checksum verify failed on %lu\n",
			       bh->b_blocknr);
			return 1;
		}
	} else {
		node = btrfs_buffer_node(bh);
C
Chris Mason 已提交
173
		memcpy(node->header.csum, result, BTRFS_CSUM_SIZE);
C
Chris Mason 已提交
174
	}
C
Chris Mason 已提交
175 176 177
	return 0;
}

178
static int btree_writepage(struct page *page, struct writeback_control *wbc)
179
{
C
Chris Mason 已提交
180
	struct buffer_head *bh;
181
	struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
C
Chris Mason 已提交
182 183 184 185 186 187 188 189 190 191 192 193
	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);
194
	return block_write_full_page(page, btree_get_block, wbc);
195 196
}

197
static int btree_readpage(struct file * file, struct page * page)
198
{
199
	return block_read_full_page(page, btree_get_block);
200 201
}

202 203 204 205 206 207
static struct address_space_operations btree_aops = {
	.readpage	= btree_readpage,
	.writepage	= btree_writepage,
	.sync_page	= block_sync_page,
};

C
Chris Mason 已提交
208
struct buffer_head *read_tree_block(struct btrfs_root *root, u64 blocknr)
209
{
210
	struct buffer_head *bh = NULL;
211

212 213 214
	bh = btrfs_find_create_tree_block(root, blocknr);
	if (!bh)
		return bh;
215 216
	if (buffer_uptodate(bh))
		goto uptodate;
217 218 219 220 221 222 223 224
	lock_buffer(bh);
	if (!buffer_uptodate(bh)) {
		get_bh(bh);
		bh->b_end_io = end_buffer_read_sync;
		submit_bh(READ, bh);
		wait_on_buffer(bh);
		if (!buffer_uptodate(bh))
			goto fail;
C
Chris Mason 已提交
225
		csum_tree_block(root, bh, 1);
226 227 228
	} else {
		unlock_buffer(bh);
	}
229
uptodate:
230
	if (check_tree_block(root, bh))
C
Chris Mason 已提交
231
		BUG();
232 233 234 235
	return bh;
fail:
	brelse(bh);
	return NULL;
236 237
}

238
int dirty_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
C
Chris Mason 已提交
239
		     struct buffer_head *buf)
240
{
C
Chris Mason 已提交
241
	WARN_ON(atomic_read(&buf->b_count) == 0);
C
Chris Mason 已提交
242
	mark_buffer_dirty(buf);
243 244 245
	return 0;
}

246
int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
C
Chris Mason 已提交
247
		     struct buffer_head *buf)
248
{
C
Chris Mason 已提交
249
	WARN_ON(atomic_read(&buf->b_count) == 0);
C
Chris Mason 已提交
250
	clear_buffer_dirty(buf);
251 252 253
	return 0;
}

C
Chris Mason 已提交
254
static int __setup_root(int blocksize,
255 256
			struct btrfs_root *root,
			struct btrfs_fs_info *fs_info,
C
Chris Mason 已提交
257
			u64 objectid)
258
{
C
Chris Mason 已提交
259
	root->node = NULL;
260
	root->inode = NULL;
261
	root->commit_root = NULL;
C
Chris Mason 已提交
262
	root->blocksize = blocksize;
C
Chris Mason 已提交
263
	root->ref_cows = 0;
264
	root->fs_info = fs_info;
265 266
	root->objectid = objectid;
	root->last_trans = 0;
C
Chris Mason 已提交
267 268
	root->highest_inode = 0;
	root->last_inode_alloc = 0;
269 270 271 272 273
	memset(&root->root_key, 0, sizeof(root->root_key));
	memset(&root->root_item, 0, sizeof(root->root_item));
	return 0;
}

C
Chris Mason 已提交
274
static int find_and_setup_root(int blocksize,
275 276 277
			       struct btrfs_root *tree_root,
			       struct btrfs_fs_info *fs_info,
			       u64 objectid,
C
Chris Mason 已提交
278
			       struct btrfs_root *root)
279 280 281
{
	int ret;

C
Chris Mason 已提交
282
	__setup_root(blocksize, root, fs_info, objectid);
283 284 285 286 287 288 289
	ret = btrfs_find_last_root(tree_root, objectid,
				   &root->root_item, &root->root_key);
	BUG_ON(ret);

	root->node = read_tree_block(root,
				     btrfs_root_blocknr(&root->root_item));
	BUG_ON(!root->node);
290 291 292
	return 0;
}

293 294 295 296 297 298 299
struct btrfs_root *btrfs_read_fs_root(struct btrfs_fs_info *fs_info,
				      struct btrfs_key *location)
{
	struct btrfs_root *root;
	struct btrfs_root *tree_root = fs_info->tree_root;
	struct btrfs_path *path;
	struct btrfs_leaf *l;
C
Chris Mason 已提交
300
	u64 highest_inode;
301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359
	int ret = 0;

printk("read_fs_root looking for %Lu %Lu %u\n", location->objectid, location->offset, location->flags);
	root = kmalloc(sizeof(*root), GFP_NOFS);
	if (!root) {
printk("failed1\n");
		return ERR_PTR(-ENOMEM);
	}
	if (location->offset == (u64)-1) {
		ret = find_and_setup_root(fs_info->sb->s_blocksize,
					  fs_info->tree_root, fs_info,
					  location->objectid, root);
		if (ret) {
printk("failed2\n");
			kfree(root);
			return ERR_PTR(ret);
		}
		goto insert;
	}

	__setup_root(fs_info->sb->s_blocksize, root, fs_info,
		     location->objectid);

	path = btrfs_alloc_path();
	BUG_ON(!path);
	ret = btrfs_search_slot(NULL, tree_root, location, path, 0, 0);
	if (ret != 0) {
printk("internal search_slot gives us %d\n", ret);
		if (ret > 0)
			ret = -ENOENT;
		goto out;
	}
	l = btrfs_buffer_leaf(path->nodes[0]);
	memcpy(&root->root_item,
	       btrfs_item_ptr(l, path->slots[0], struct btrfs_root_item),
	       sizeof(root->root_item));
	memcpy(&root->root_key, location, sizeof(*location));
	ret = 0;
out:
	btrfs_release_path(root, path);
	btrfs_free_path(path);
	if (ret) {
		kfree(root);
		return ERR_PTR(ret);
	}
	root->node = read_tree_block(root,
				     btrfs_root_blocknr(&root->root_item));
	BUG_ON(!root->node);
insert:
printk("inserting %p\n", root);
	root->ref_cows = 1;
	ret = radix_tree_insert(&fs_info->fs_roots_radix, (unsigned long)root,
				root);
	if (ret) {
printk("radix_tree_insert gives us %d\n", ret);
		brelse(root->node);
		kfree(root);
		return ERR_PTR(ret);
	}
C
Chris Mason 已提交
360 361 362 363 364 365
	ret = btrfs_find_highest_inode(root, &highest_inode);
	if (ret == 0) {
		root->highest_inode = highest_inode;
		root->last_inode_alloc = highest_inode;
printk("highest inode is %Lu\n", highest_inode);
	}
366 367 368 369
printk("all worked\n");
	return root;
}

C
Chris Mason 已提交
370
struct btrfs_root *open_ctree(struct super_block *sb)
371
{
C
Chris Mason 已提交
372 373 374 375 376 377
	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);
378
	int ret;
C
Chris Mason 已提交
379
	struct btrfs_super_block *disk_super;
380

C
Chris Mason 已提交
381 382
	init_bit_radix(&fs_info->pinned_radix);
	init_bit_radix(&fs_info->pending_del_radix);
383
	INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_NOFS);
C
Chris Mason 已提交
384
	sb_set_blocksize(sb, 4096);
385 386 387
	fs_info->running_transaction = NULL;
	fs_info->tree_root = tree_root;
	fs_info->extent_root = extent_root;
C
Chris Mason 已提交
388
	fs_info->sb = sb;
389 390
	fs_info->btree_inode = new_inode(sb);
	fs_info->btree_inode->i_ino = 1;
C
Chris Mason 已提交
391
	fs_info->btree_inode->i_nlink = 1;
392 393
	fs_info->btree_inode->i_size = sb->s_bdev->bd_inode->i_size;
	fs_info->btree_inode->i_mapping->a_ops = &btree_aops;
394 395 396
	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 已提交
397
	insert_inode_hash(fs_info->btree_inode);
398
	mapping_set_gfp_mask(fs_info->btree_inode->i_mapping, GFP_NOFS);
C
Chris Mason 已提交
399
	fs_info->hash_tfm = crypto_alloc_hash("sha256", 0, CRYPTO_ALG_ASYNC);
C
Chris Mason 已提交
400 401
	spin_lock_init(&fs_info->hash_lock);
	if (!fs_info->hash_tfm || IS_ERR(fs_info->hash_tfm)) {
C
Chris Mason 已提交
402 403 404
		printk("failed to allocate sha256 hash\n");
		return NULL;
	}
C
Chris Mason 已提交
405
	mutex_init(&fs_info->trans_mutex);
C
Chris Mason 已提交
406
	mutex_init(&fs_info->fs_mutex);
407 408
	memset(&fs_info->current_insert, 0, sizeof(fs_info->current_insert));
	memset(&fs_info->last_insert, 0, sizeof(fs_info->last_insert));
409

C
Chris Mason 已提交
410 411 412 413 414
	__setup_root(sb->s_blocksize, tree_root,
		     fs_info, BTRFS_ROOT_TREE_OBJECTID);
	fs_info->sb_buffer = read_tree_block(tree_root,
					     BTRFS_SUPER_INFO_OFFSET /
					     sb->s_blocksize);
415

416
	if (!fs_info->sb_buffer)
417 418
		return NULL;
	disk_super = (struct btrfs_super_block *)fs_info->sb_buffer->b_data;
419
	if (!btrfs_super_root(disk_super))
C
Chris Mason 已提交
420
		return NULL;
421

422
	fs_info->disk_super = disk_super;
C
Chris Mason 已提交
423 424
	tree_root->node = read_tree_block(tree_root,
					  btrfs_super_root(disk_super));
425 426
	BUG_ON(!tree_root->node);

C
Chris Mason 已提交
427 428
	mutex_lock(&fs_info->fs_mutex);
	ret = find_and_setup_root(sb->s_blocksize, tree_root, fs_info,
C
Chris Mason 已提交
429
				  BTRFS_EXTENT_TREE_OBJECTID, extent_root);
430 431
	BUG_ON(ret);

432
	fs_info->generation = btrfs_super_generation(disk_super) + 1;
433 434 435 436
	memset(&fs_info->kobj, 0, sizeof(fs_info->kobj));
	kobj_set_kset_s(fs_info, btrfs_subsys);
	kobject_set_name(&fs_info->kobj, "%s", sb->s_id);
	kobject_register(&fs_info->kobj);
C
Chris Mason 已提交
437
	mutex_unlock(&fs_info->fs_mutex);
438
	return tree_root;
439 440
}

441
int write_ctree_super(struct btrfs_trans_handle *trans, struct btrfs_root
C
Chris Mason 已提交
442
		      *root)
443
{
444
	struct buffer_head *bh = root->fs_info->sb_buffer;
C
Chris Mason 已提交
445

446 447 448
	btrfs_set_super_root(root->fs_info->disk_super,
			     root->fs_info->tree_root->node->b_blocknr);
	lock_buffer(bh);
C
Chris Mason 已提交
449
	WARN_ON(atomic_read(&bh->b_count) < 1);
450
	clear_buffer_dirty(bh);
C
Chris Mason 已提交
451
	csum_tree_block(root, bh, 0);
452 453 454 455 456 457 458
	bh->b_end_io = end_buffer_write_sync;
	get_bh(bh);
	submit_bh(WRITE, bh);
	wait_on_buffer(bh);
	if (!buffer_uptodate(bh)) {
		WARN_ON(1);
		return -EIO;
C
Chris Mason 已提交
459 460 461 462
	}
	return 0;
}

463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491
int del_fs_roots(struct btrfs_fs_info *fs_info)
{
	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;
		for (i = 0; i < ret; i++) {
			radix_tree_delete(&fs_info->fs_roots_radix,
					  (unsigned long)gang[i]);
			if (gang[i]->inode)
				iput(gang[i]->inode);
			else
				printk("no inode for root %p\n", gang[i]);
			if (gang[i]->node)
				brelse(gang[i]->node);
			if (gang[i]->commit_root)
				brelse(gang[i]->commit_root);
			kfree(gang[i]);
		}
	}
	return 0;
}

C
Chris Mason 已提交
492
int close_ctree(struct btrfs_root *root)
C
Chris Mason 已提交
493
{
494
	int ret;
495
	struct btrfs_trans_handle *trans;
496
	struct btrfs_fs_info *fs_info = root->fs_info;
497

498
	mutex_lock(&fs_info->fs_mutex);
C
Chris Mason 已提交
499 500 501 502 503 504
	trans = btrfs_start_transaction(root, 1);
	btrfs_commit_transaction(trans, root);
	/* 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);
505
	BUG_ON(ret);
C
Chris Mason 已提交
506
	write_ctree_super(NULL, root);
507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522
	mutex_unlock(&fs_info->fs_mutex);

	if (fs_info->extent_root->node)
		btrfs_block_release(fs_info->extent_root,
				    fs_info->extent_root->node);
	if (fs_info->tree_root->node)
		btrfs_block_release(fs_info->tree_root,
				    fs_info->tree_root->node);
	btrfs_block_release(root, fs_info->sb_buffer);
	crypto_free_hash(fs_info->hash_tfm);
	truncate_inode_pages(fs_info->btree_inode->i_mapping, 0);
	iput(fs_info->btree_inode);
	del_fs_roots(fs_info);
	kfree(fs_info->extent_root);
	kfree(fs_info->tree_root);
	kobject_unregister(&fs_info->kobj);
523 524 525
	return 0;
}

C
Chris Mason 已提交
526
void btrfs_block_release(struct btrfs_root *root, struct buffer_head *buf)
527
{
C
Chris Mason 已提交
528
	brelse(buf);
529 530
}