disk-io.c 17.1 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

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

45 46
struct extent_buffer *btrfs_find_tree_block(struct btrfs_root *root,
					    u64 blocknr)
47
{
48 49 50 51 52
	struct inode *btree_inode = root->fs_info->btree_inode;
	return find_extent_buffer(&BTRFS_I(btree_inode)->extent_tree,
				   blocknr * root->sectorsize,
				   root->sectorsize, GFP_NOFS);
}
53

54 55 56 57 58 59 60
struct extent_buffer *btrfs_find_create_tree_block(struct btrfs_root *root,
						 u64 blocknr)
{
	struct inode *btree_inode = root->fs_info->btree_inode;
	return alloc_extent_buffer(&BTRFS_I(btree_inode)->extent_tree,
				   blocknr * root->sectorsize,
				   root->sectorsize, GFP_NOFS);
61 62
}

63 64 65
struct extent_map *btree_get_extent(struct inode *inode, struct page *page,
				    size_t page_offset, u64 start, u64 end,
				    int create)
66
{
67 68 69 70 71 72 73 74
	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;
75
	}
76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
	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;
96 97
}

98
static int btree_writepage(struct page *page, struct writeback_control *wbc)
99
{
100 101 102 103 104 105 106 107 108 109
	struct extent_map_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->extent_tree;
	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 已提交
110

111 112 113 114
static int btree_releasepage(struct page *page, gfp_t unused_gfp_flags)
{
	struct extent_map_tree *tree;
	int ret;
115

116 117 118 119 120 121 122 123
	BUG_ON(page->private != 1);
	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);
	}
124 125 126
	return ret;
}

127
static void btree_invalidatepage(struct page *page, unsigned long offset)
128
{
129 130 131 132
	struct extent_map_tree *tree;
	tree = &BTRFS_I(page->mapping->host)->extent_tree;
	extent_invalidatepage(tree, page, offset);
	btree_releasepage(page, GFP_NOFS);
133 134
}

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
	return 0;
#if 0
140 141 142 143
	u32 crc;
	crc = crc32c(0, data, len);
	memcpy(result, &crc, BTRFS_CRC32_SIZE);
	return 0;
144
#endif
C
Chris Mason 已提交
145
}
146

147 148
#if 0
static int csum_tree_block(struct btrfs_root *root, struct extent_buffer *buf,
C
Chris Mason 已提交
149 150
			   int verify)
{
151
	return 0;
152
	char result[BTRFS_CRC32_SIZE];
C
Chris Mason 已提交
153 154 155 156 157 158 159
	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 已提交
160
	if (verify) {
161
		if (memcmp(bh->b_data, result, BTRFS_CRC32_SIZE)) {
C
Chris Mason 已提交
162 163 164
			printk("btrfs: %s checksum verify failed on %llu\n",
			       root->fs_info->sb->s_id,
			       (unsigned long long)bh_blocknr(bh));
C
Chris Mason 已提交
165 166 167 168
			return 1;
		}
	} else {
		node = btrfs_buffer_node(bh);
169
		memcpy(node->header.csum, result, BTRFS_CRC32_SIZE);
C
Chris Mason 已提交
170
	}
C
Chris Mason 已提交
171 172
	return 0;
}
173
#endif
C
Chris Mason 已提交
174

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

196 197 198
static struct address_space_operations btree_aops = {
	.readpage	= btree_readpage,
	.writepage	= btree_writepage,
199 200
	.releasepage	= btree_releasepage,
	.invalidatepage = btree_invalidatepage,
201 202 203
	.sync_page	= block_sync_page,
};

C
Chris Mason 已提交
204 205
int readahead_tree_block(struct btrfs_root *root, u64 blocknr)
{
206 207
	struct extent_buffer *buf = NULL;
	struct inode *btree_inode = root->fs_info->btree_inode;
208
	int ret = 0;
C
Chris Mason 已提交
209

210 211
	buf = btrfs_find_create_tree_block(root, blocknr);
	if (!buf)
C
Chris Mason 已提交
212
		return 0;
213 214 215
	read_extent_buffer_pages(&BTRFS_I(btree_inode)->extent_tree,
				 buf, 0);
	free_extent_buffer(buf);
216
	return ret;
C
Chris Mason 已提交
217 218
}

219
struct extent_buffer *read_tree_block(struct btrfs_root *root, u64 blocknr)
220
{
221 222 223 224 225 226 227 228 229
	struct extent_buffer *buf = NULL;
	struct inode *btree_inode = root->fs_info->btree_inode;

	buf = btrfs_find_create_tree_block(root, blocknr);
	if (!buf)
		return NULL;
	read_extent_buffer_pages(&BTRFS_I(btree_inode)->extent_tree,
				 buf, 1);
	return buf;
230 231
}

232
int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
233
		     struct extent_buffer *buf)
234
{
235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252
	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;
}

int set_tree_block_dirty(struct btrfs_root *root, struct extent_buffer *buf)
{
	struct inode *btree_inode = root->fs_info->btree_inode;
	set_extent_buffer_dirty(&BTRFS_I(btree_inode)->extent_tree, buf);
253 254 255
	return 0;
}

C
Chris Mason 已提交
256
static int __setup_root(int blocksize,
257 258
			struct btrfs_root *root,
			struct btrfs_fs_info *fs_info,
C
Chris Mason 已提交
259
			u64 objectid)
260
{
C
Chris Mason 已提交
261
	root->node = NULL;
262
	root->inode = NULL;
263
	root->commit_root = NULL;
264 265 266
	root->sectorsize = blocksize;
	root->nodesize = blocksize;
	root->leafsize = blocksize;
C
Chris Mason 已提交
267
	root->ref_cows = 0;
268
	root->fs_info = fs_info;
269 270
	root->objectid = objectid;
	root->last_trans = 0;
C
Chris Mason 已提交
271 272
	root->highest_inode = 0;
	root->last_inode_alloc = 0;
273
	root->name = NULL;
274 275
	memset(&root->root_key, 0, sizeof(root->root_key));
	memset(&root->root_item, 0, sizeof(root->root_item));
276
	memset(&root->defrag_progress, 0, sizeof(root->defrag_progress));
277 278
	memset(&root->root_kobj, 0, sizeof(root->root_kobj));
	init_completion(&root->kobj_unregister);
279
	init_rwsem(&root->snap_sem);
280 281
	root->defrag_running = 0;
	root->defrag_level = 0;
282
	root->root_key.objectid = objectid;
283 284 285
	return 0;
}

C
Chris Mason 已提交
286
static int find_and_setup_root(int blocksize,
287 288 289
			       struct btrfs_root *tree_root,
			       struct btrfs_fs_info *fs_info,
			       u64 objectid,
C
Chris Mason 已提交
290
			       struct btrfs_root *root)
291 292 293
{
	int ret;

C
Chris Mason 已提交
294
	__setup_root(blocksize, root, fs_info, objectid);
295 296 297 298 299 300 301
	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);
302 303 304
	return 0;
}

305 306
struct btrfs_root *btrfs_read_fs_root_no_radix(struct btrfs_fs_info *fs_info,
					       struct btrfs_key *location)
307 308 309 310
{
	struct btrfs_root *root;
	struct btrfs_root *tree_root = fs_info->tree_root;
	struct btrfs_path *path;
311
	struct extent_buffer *l;
C
Chris Mason 已提交
312
	u64 highest_inode;
313 314
	int ret = 0;

315
	root = kzalloc(sizeof(*root), GFP_NOFS);
C
Chris Mason 已提交
316
	if (!root)
317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339
		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) {
			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) {
		if (ret > 0)
			ret = -ENOENT;
		goto out;
	}
340 341 342
	l = path->nodes[0];
	read_extent_buffer(l, &root->root_item,
	       btrfs_item_ptr_offset(l, path->slots[0]),
343 344 345 346 347 348 349 350 351 352 353 354 355 356
	       sizeof(root->root_item));
	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:
	root->ref_cows = 1;
357 358 359 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;
	}
	return root;
}

struct btrfs_root *btrfs_read_fs_root(struct btrfs_fs_info *fs_info,
366 367
				      struct btrfs_key *location,
				      const char *name, int namelen)
368 369 370 371 372 373 374 375 376 377 378 379
{
	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 已提交
380 381
	ret = radix_tree_insert(&fs_info->fs_roots_radix,
				(unsigned long)root->root_key.objectid,
382 383
				root);
	if (ret) {
384
		free_extent_buffer(root->node);
385 386 387
		kfree(root);
		return ERR_PTR(ret);
	}
388 389 390

	ret = btrfs_set_root_name(root, name, namelen);
	if (ret) {
391
		free_extent_buffer(root->node);
392 393 394 395 396 397
		kfree(root);
		return ERR_PTR(ret);
	}

	ret = btrfs_sysfs_add_root(root);
	if (ret) {
398
		free_extent_buffer(root->node);
399 400 401 402 403
		kfree(root->name);
		kfree(root);
		return ERR_PTR(ret);
	}

404 405 406 407
	ret = btrfs_find_dead_roots(fs_info->tree_root,
				    root->root_key.objectid, root);
	BUG_ON(ret);

408 409 410
	return root;
}

C
Chris Mason 已提交
411
struct btrfs_root *open_ctree(struct super_block *sb)
412
{
C
Chris Mason 已提交
413 414 415 416 417 418
	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);
419
	int ret;
C
Chris Mason 已提交
420
	int err = -EIO;
C
Chris Mason 已提交
421
	struct btrfs_super_block *disk_super;
422

C
Chris Mason 已提交
423 424 425 426
	if (!extent_root || !tree_root || !fs_info) {
		err = -ENOMEM;
		goto fail;
	}
C
Chris Mason 已提交
427 428
	init_bit_radix(&fs_info->pinned_radix);
	init_bit_radix(&fs_info->pending_del_radix);
429
	init_bit_radix(&fs_info->extent_map_radix);
430
	init_bit_radix(&fs_info->extent_ins_radix);
431
	INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_NOFS);
C
Chris Mason 已提交
432
	INIT_RADIX_TREE(&fs_info->block_group_radix, GFP_KERNEL);
C
Chris Mason 已提交
433
	INIT_RADIX_TREE(&fs_info->block_group_data_radix, GFP_KERNEL);
C
Chris Mason 已提交
434
	INIT_LIST_HEAD(&fs_info->trans_list);
435
	INIT_LIST_HEAD(&fs_info->dead_roots);
436 437
	memset(&fs_info->super_kobj, 0, sizeof(fs_info->super_kobj));
	init_completion(&fs_info->kobj_unregister);
C
Chris Mason 已提交
438
	sb_set_blocksize(sb, 4096);
439
	fs_info->running_transaction = NULL;
440
	fs_info->last_trans_committed = 0;
441 442
	fs_info->tree_root = tree_root;
	fs_info->extent_root = extent_root;
C
Chris Mason 已提交
443
	fs_info->sb = sb;
444 445
	fs_info->btree_inode = new_inode(sb);
	fs_info->btree_inode->i_ino = 1;
C
Chris Mason 已提交
446
	fs_info->btree_inode->i_nlink = 1;
447 448
	fs_info->btree_inode->i_size = sb->s_bdev->bd_inode->i_size;
	fs_info->btree_inode->i_mapping->a_ops = &btree_aops;
449 450 451
	extent_map_tree_init(&BTRFS_I(fs_info->btree_inode)->extent_tree,
			     fs_info->btree_inode->i_mapping,
			     GFP_NOFS);
452
	fs_info->do_barriers = 1;
453 454
	fs_info->closing = 0;

C
Chris Mason 已提交
455
	INIT_DELAYED_WORK(&fs_info->trans_work, btrfs_transaction_cleaner);
456 457 458
	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 已提交
459
	insert_inode_hash(fs_info->btree_inode);
460
	mapping_set_gfp_mask(fs_info->btree_inode->i_mapping, GFP_NOFS);
C
Chris Mason 已提交
461

C
Chris Mason 已提交
462
	mutex_init(&fs_info->trans_mutex);
C
Chris Mason 已提交
463
	mutex_init(&fs_info->fs_mutex);
464

C
Chris Mason 已提交
465 466
	__setup_root(sb->s_blocksize, tree_root,
		     fs_info, BTRFS_ROOT_TREE_OBJECTID);
467

C
Chris Mason 已提交
468 469 470
	fs_info->sb_buffer = read_tree_block(tree_root,
					     BTRFS_SUPER_INFO_OFFSET /
					     sb->s_blocksize);
471

472
	if (!fs_info->sb_buffer)
C
Chris Mason 已提交
473 474
		goto fail_iput;

475 476 477 478 479 480 481
	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;
482
	if (!btrfs_super_root(disk_super))
C
Chris Mason 已提交
483
		goto fail_sb_buffer;
484

485 486 487 488
	i_size_write(fs_info->btree_inode,
		     btrfs_super_total_blocks(disk_super) <<
		     fs_info->btree_inode->i_blkbits);

C
Chris Mason 已提交
489 490 491 492 493 494

	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;
	}
C
Chris Mason 已提交
495 496
	tree_root->node = read_tree_block(tree_root,
					  btrfs_super_root(disk_super));
C
Chris Mason 已提交
497 498
	if (!tree_root->node)
		goto fail_sb_buffer;
499

C
Chris Mason 已提交
500 501
	mutex_lock(&fs_info->fs_mutex);
	ret = find_and_setup_root(sb->s_blocksize, tree_root, fs_info,
C
Chris Mason 已提交
502
				  BTRFS_EXTENT_TREE_OBJECTID, extent_root);
C
Chris Mason 已提交
503 504 505 506
	if (ret) {
		mutex_unlock(&fs_info->fs_mutex);
		goto fail_tree_root;
	}
507

C
Chris Mason 已提交
508 509
	btrfs_read_block_groups(extent_root);

510
	fs_info->generation = btrfs_super_generation(disk_super) + 1;
C
Chris Mason 已提交
511
	mutex_unlock(&fs_info->fs_mutex);
512
	return tree_root;
C
Chris Mason 已提交
513 514

fail_tree_root:
515
	free_extent_buffer(tree_root->node);
C
Chris Mason 已提交
516
fail_sb_buffer:
517
	free_extent_buffer(fs_info->sb_buffer);
C
Chris Mason 已提交
518 519 520 521 522 523 524
fail_iput:
	iput(fs_info->btree_inode);
fail:
	kfree(extent_root);
	kfree(tree_root);
	kfree(fs_info);
	return ERR_PTR(err);
525 526
}

527
int write_ctree_super(struct btrfs_trans_handle *trans, struct btrfs_root
C
Chris Mason 已提交
528
		      *root)
529
{
530
	int ret;
531 532 533 534 535 536 537
	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 已提交
538 539
}

540
int btrfs_free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root)
C
Chris Mason 已提交
541 542 543
{
	radix_tree_delete(&fs_info->fs_roots_radix,
			  (unsigned long)root->root_key.objectid);
544
	btrfs_sysfs_del_root(root);
C
Chris Mason 已提交
545 546 547
	if (root->inode)
		iput(root->inode);
	if (root->node)
548
		free_extent_buffer(root->node);
C
Chris Mason 已提交
549
	if (root->commit_root)
550
		free_extent_buffer(root->commit_root);
551 552
	if (root->name)
		kfree(root->name);
C
Chris Mason 已提交
553 554 555 556
	kfree(root);
	return 0;
}

C
Chris Mason 已提交
557
static int del_fs_roots(struct btrfs_fs_info *fs_info)
558 559 560 561 562 563 564 565 566 567 568
{
	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 已提交
569
		for (i = 0; i < ret; i++)
570
			btrfs_free_fs_root(fs_info, gang[i]);
571 572 573
	}
	return 0;
}
574

C
Chris Mason 已提交
575
int close_ctree(struct btrfs_root *root)
C
Chris Mason 已提交
576
{
577
	int ret;
578
	struct btrfs_trans_handle *trans;
579
	struct btrfs_fs_info *fs_info = root->fs_info;
580

581
	fs_info->closing = 1;
C
Chris Mason 已提交
582
	btrfs_transaction_flush_work(root);
583
	mutex_lock(&fs_info->fs_mutex);
584
	btrfs_defrag_dirty_roots(root->fs_info);
C
Chris Mason 已提交
585
	trans = btrfs_start_transaction(root, 1);
586
	ret = btrfs_commit_transaction(trans, root);
C
Chris Mason 已提交
587 588 589 590
	/* 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);
591
	BUG_ON(ret);
C
Chris Mason 已提交
592
	write_ctree_super(NULL, root);
593 594 595
	mutex_unlock(&fs_info->fs_mutex);

	if (fs_info->extent_root->node)
596
		free_extent_buffer(fs_info->extent_root->node);
597
	if (fs_info->tree_root->node)
598 599
		free_extent_buffer(fs_info->tree_root->node);
	free_extent_buffer(fs_info->sb_buffer);
600 601
	truncate_inode_pages(fs_info->btree_inode->i_mapping, 0);
	iput(fs_info->btree_inode);
602

C
Chris Mason 已提交
603
	btrfs_free_block_groups(root->fs_info);
604 605 606
	del_fs_roots(fs_info);
	kfree(fs_info->extent_root);
	kfree(fs_info->tree_root);
607 608 609
	return 0;
}

610 611
int btrfs_buffer_uptodate(struct extent_buffer *buf)
{
612
	struct inode *btree_inode = buf->first_page->mapping->host;
613 614 615 616
	return extent_buffer_uptodate(&BTRFS_I(btree_inode)->extent_tree, buf);
}

int btrfs_set_buffer_uptodate(struct extent_buffer *buf)
C
Chris Mason 已提交
617
{
618
	struct inode *btree_inode = buf->first_page->mapping->host;
619 620 621
	return set_extent_buffer_uptodate(&BTRFS_I(btree_inode)->extent_tree,
					  buf);
}
622

623 624
void btrfs_mark_buffer_dirty(struct extent_buffer *buf)
{
625
	struct btrfs_root *root = BTRFS_I(buf->first_page->mapping->host)->root;
626 627
	u64 transid = btrfs_header_generation(buf);
	struct inode *btree_inode = root->fs_info->btree_inode;
628

C
Chris Mason 已提交
629 630
	if (transid != root->fs_info->generation) {
		printk(KERN_CRIT "transid mismatch buffer %llu, found %Lu running %Lu\n",
631
			(unsigned long long)extent_buffer_blocknr(buf),
C
Chris Mason 已提交
632 633 634
			transid, root->fs_info->generation);
		WARN_ON(1);
	}
635
	set_extent_buffer_dirty(&BTRFS_I(btree_inode)->extent_tree, buf);
636 637
}

638
void btrfs_btree_balance_dirty(struct btrfs_root *root, unsigned long nr)
C
Chris Mason 已提交
639
{
640 641
	balance_dirty_pages_ratelimited_nr(
			root->fs_info->btree_inode->i_mapping, nr);
C
Chris Mason 已提交
642
}