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

32 33
u64 bh_blocknr(struct buffer_head *bh)
{
C
Chris Mason 已提交
34
	return bh->b_blocknr;
35 36
}

C
Chris Mason 已提交
37
static int check_tree_block(struct btrfs_root *root, struct buffer_head *buf)
38
{
C
Chris Mason 已提交
39
	struct btrfs_node *node = btrfs_buffer_node(buf);
40
	if (bh_blocknr(buf) != btrfs_header_blocknr(&node->header)) {
C
Chris Mason 已提交
41 42 43
		printk(KERN_CRIT "bh_blocknr(buf) is %llu, header is %llu\n",
		       (unsigned long long)bh_blocknr(buf),
		       (unsigned long long)btrfs_header_blocknr(&node->header));
C
Chris Mason 已提交
44
		return 1;
45
	}
46
	return 0;
47 48
}

49 50 51 52 53 54 55 56 57 58
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 已提交
59

60 61 62 63 64 65 66 67 68 69
	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 {
70
		if (buffer_mapped(bh) && bh_blocknr(bh) == blocknr) {
71 72 73 74 75 76 77 78 79 80 81 82
			ret = bh;
			get_bh(bh);
			goto out_unlock;
		}
		bh = bh->b_this_page;
	} while (bh != head);
out_unlock:
	unlock_page(page);
	page_cache_release(page);
	return ret;
}

83
int btrfs_map_bh_to_logical(struct btrfs_root *root, struct buffer_head *bh,
84 85
			     u64 logical)
{
86 87 88 89
	if (logical == 0) {
		bh->b_bdev = NULL;
		bh->b_blocknr = 0;
		set_buffer_mapped(bh);
C
Chris Mason 已提交
90 91
	} else {
		map_bh(bh, root->fs_info->sb, logical);
92
	}
C
Chris Mason 已提交
93
	return 0;
94 95
}

96 97 98 99 100 101 102 103 104 105
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;
106
	int err;
107
	u64 first_block = index << (PAGE_CACHE_SHIFT - blockbits);
C
Chris Mason 已提交
108

C
Chris Mason 已提交
109
	page = find_or_create_page(mapping, index, GFP_NOFS);
110 111 112 113 114 115 116 117 118
	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)) {
119
			err = btrfs_map_bh_to_logical(root, bh, first_block);
120
			BUG_ON(err);
121
		}
122
		if (bh_blocknr(bh) == blocknr) {
123 124 125 126 127 128 129 130 131
			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 已提交
132 133
	if (ret)
		touch_buffer(ret);
134 135 136 137 138 139 140
	page_cache_release(page);
	return ret;
}

static int btree_get_block(struct inode *inode, sector_t iblock,
			   struct buffer_head *bh, int create)
{
141 142
	int err;
	struct btrfs_root *root = BTRFS_I(bh->b_page->mapping->host)->root;
143
	err = btrfs_map_bh_to_logical(root, bh, iblock);
144
	return err;
145 146
}

C
Chris Mason 已提交
147 148
int btrfs_csum_data(struct btrfs_root * root, char *data, size_t len,
		    char *result)
C
Chris Mason 已提交
149
{
150 151 152 153
	u32 crc;
	crc = crc32c(0, data, len);
	memcpy(result, &crc, BTRFS_CRC32_SIZE);
	return 0;
C
Chris Mason 已提交
154
}
155

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

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

200
static int btree_readpage(struct file * file, struct page * page)
201
{
202
	return block_read_full_page(page, btree_get_block);
203 204
}

205 206 207 208 209 210
static struct address_space_operations btree_aops = {
	.readpage	= btree_readpage,
	.writepage	= btree_writepage,
	.sync_page	= block_sync_page,
};

C
Chris Mason 已提交
211 212 213
int readahead_tree_block(struct btrfs_root *root, u64 blocknr)
{
	struct buffer_head *bh = NULL;
214
	int ret = 0;
C
Chris Mason 已提交
215 216 217 218

	bh = btrfs_find_create_tree_block(root, blocknr);
	if (!bh)
		return 0;
219 220
	if (buffer_uptodate(bh)) {
		ret = 1;
C
Chris Mason 已提交
221
		goto done;
222 223 224
	}
	if (test_set_buffer_locked(bh)) {
		ret = 1;
C
Chris Mason 已提交
225
		goto done;
226
	}
C
Chris Mason 已提交
227 228 229 230 231 232
	if (!buffer_uptodate(bh)) {
		get_bh(bh);
		bh->b_end_io = end_buffer_read_sync;
		submit_bh(READ, bh);
	} else {
		unlock_buffer(bh);
233
		ret = 1;
C
Chris Mason 已提交
234 235 236
	}
done:
	brelse(bh);
237
	return ret;
C
Chris Mason 已提交
238 239
}

C
Chris Mason 已提交
240
struct buffer_head *read_tree_block(struct btrfs_root *root, u64 blocknr)
241
{
242
	struct buffer_head *bh = NULL;
243

244 245 246
	bh = btrfs_find_create_tree_block(root, blocknr);
	if (!bh)
		return bh;
247 248
	if (buffer_uptodate(bh))
		goto uptodate;
249 250 251 252 253 254 255 256 257 258 259
	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;
	} else {
		unlock_buffer(bh);
	}
260
uptodate:
C
Chris Mason 已提交
261 262 263 264
	if (!buffer_checked(bh)) {
		csum_tree_block(root, bh, 1);
		set_buffer_checked(bh);
	}
265
	if (check_tree_block(root, bh))
C
Chris Mason 已提交
266
		goto fail;
267 268 269 270
	return bh;
fail:
	brelse(bh);
	return NULL;
271 272
}

273
int dirty_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
C
Chris Mason 已提交
274
		     struct buffer_head *buf)
275
{
C
Chris Mason 已提交
276
	WARN_ON(atomic_read(&buf->b_count) == 0);
C
Chris Mason 已提交
277
	mark_buffer_dirty(buf);
278 279 280
	return 0;
}

281
int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
C
Chris Mason 已提交
282
		     struct buffer_head *buf)
283
{
C
Chris Mason 已提交
284
	WARN_ON(atomic_read(&buf->b_count) == 0);
C
Chris Mason 已提交
285
	clear_buffer_dirty(buf);
286 287 288
	return 0;
}

C
Chris Mason 已提交
289
static int __setup_root(int blocksize,
290 291
			struct btrfs_root *root,
			struct btrfs_fs_info *fs_info,
C
Chris Mason 已提交
292
			u64 objectid)
293
{
C
Chris Mason 已提交
294
	root->node = NULL;
295
	root->inode = NULL;
296
	root->commit_root = NULL;
C
Chris Mason 已提交
297
	root->blocksize = blocksize;
C
Chris Mason 已提交
298
	root->ref_cows = 0;
299
	root->fs_info = fs_info;
300 301
	root->objectid = objectid;
	root->last_trans = 0;
C
Chris Mason 已提交
302 303
	root->highest_inode = 0;
	root->last_inode_alloc = 0;
304 305
	memset(&root->root_key, 0, sizeof(root->root_key));
	memset(&root->root_item, 0, sizeof(root->root_item));
306
	root->root_key.objectid = objectid;
307 308 309
	return 0;
}

C
Chris Mason 已提交
310
static int find_and_setup_root(int blocksize,
311 312 313
			       struct btrfs_root *tree_root,
			       struct btrfs_fs_info *fs_info,
			       u64 objectid,
C
Chris Mason 已提交
314
			       struct btrfs_root *root)
315 316 317
{
	int ret;

C
Chris Mason 已提交
318
	__setup_root(blocksize, root, fs_info, objectid);
319 320 321 322 323 324 325
	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);
326 327 328
	return 0;
}

329 330 331 332 333 334 335
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 已提交
336
	u64 highest_inode;
337 338
	int ret = 0;

C
Chris Mason 已提交
339 340
	root = radix_tree_lookup(&fs_info->fs_roots_radix,
				 (unsigned long)location->objectid);
C
Chris Mason 已提交
341
	if (root)
C
Chris Mason 已提交
342
		return root;
343
	root = kmalloc(sizeof(*root), GFP_NOFS);
C
Chris Mason 已提交
344
	if (!root)
345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385
		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;
	}
	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:
	root->ref_cows = 1;
C
Chris Mason 已提交
386 387
	ret = radix_tree_insert(&fs_info->fs_roots_radix,
				(unsigned long)root->root_key.objectid,
388 389 390 391 392 393
				root);
	if (ret) {
		brelse(root->node);
		kfree(root);
		return ERR_PTR(ret);
	}
C
Chris Mason 已提交
394 395 396 397 398
	ret = btrfs_find_highest_inode(root, &highest_inode);
	if (ret == 0) {
		root->highest_inode = highest_inode;
		root->last_inode_alloc = highest_inode;
	}
399 400 401
	return root;
}

C
Chris Mason 已提交
402
struct btrfs_root *open_ctree(struct super_block *sb)
403
{
C
Chris Mason 已提交
404 405 406 407 408 409
	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);
410
	int ret;
C
Chris Mason 已提交
411
	int err = -EIO;
C
Chris Mason 已提交
412
	struct btrfs_super_block *disk_super;
413

C
Chris Mason 已提交
414 415 416 417
	if (!extent_root || !tree_root || !fs_info) {
		err = -ENOMEM;
		goto fail;
	}
C
Chris Mason 已提交
418 419
	init_bit_radix(&fs_info->pinned_radix);
	init_bit_radix(&fs_info->pending_del_radix);
420
	init_bit_radix(&fs_info->extent_map_radix);
421
	INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_NOFS);
C
Chris Mason 已提交
422
	INIT_RADIX_TREE(&fs_info->block_group_radix, GFP_KERNEL);
C
Chris Mason 已提交
423
	INIT_RADIX_TREE(&fs_info->block_group_data_radix, GFP_KERNEL);
C
Chris Mason 已提交
424
	INIT_LIST_HEAD(&fs_info->trans_list);
425
	INIT_LIST_HEAD(&fs_info->dead_roots);
C
Chris Mason 已提交
426
	sb_set_blocksize(sb, 4096);
427 428 429
	fs_info->running_transaction = NULL;
	fs_info->tree_root = tree_root;
	fs_info->extent_root = extent_root;
C
Chris Mason 已提交
430
	fs_info->sb = sb;
431 432
	fs_info->btree_inode = new_inode(sb);
	fs_info->btree_inode->i_ino = 1;
C
Chris Mason 已提交
433
	fs_info->btree_inode->i_nlink = 1;
434 435
	fs_info->btree_inode->i_size = sb->s_bdev->bd_inode->i_size;
	fs_info->btree_inode->i_mapping->a_ops = &btree_aops;
436
	fs_info->do_barriers = 1;
437 438
	fs_info->extent_tree_insert_nr = 0;
	fs_info->extent_tree_prealloc_nr = 0;
439 440
	fs_info->closing = 0;

C
Chris Mason 已提交
441
	INIT_DELAYED_WORK(&fs_info->trans_work, btrfs_transaction_cleaner);
442 443 444
	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 已提交
445
	insert_inode_hash(fs_info->btree_inode);
446
	mapping_set_gfp_mask(fs_info->btree_inode->i_mapping, GFP_NOFS);
C
Chris Mason 已提交
447

C
Chris Mason 已提交
448
	mutex_init(&fs_info->trans_mutex);
C
Chris Mason 已提交
449
	mutex_init(&fs_info->fs_mutex);
450

C
Chris Mason 已提交
451 452
	__setup_root(sb->s_blocksize, tree_root,
		     fs_info, BTRFS_ROOT_TREE_OBJECTID);
453

C
Chris Mason 已提交
454 455 456
	fs_info->sb_buffer = read_tree_block(tree_root,
					     BTRFS_SUPER_INFO_OFFSET /
					     sb->s_blocksize);
457

458
	if (!fs_info->sb_buffer)
C
Chris Mason 已提交
459
		goto fail_iput;
460
	disk_super = (struct btrfs_super_block *)fs_info->sb_buffer->b_data;
C
Chris Mason 已提交
461

462
	if (!btrfs_super_root(disk_super))
C
Chris Mason 已提交
463
		goto fail_sb_buffer;
464

465 466 467 468
	i_size_write(fs_info->btree_inode,
		     btrfs_super_total_blocks(disk_super) <<
		     fs_info->btree_inode->i_blkbits);

469
	fs_info->disk_super = disk_super;
C
Chris Mason 已提交
470 471 472 473 474 475

	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 已提交
476 477
	tree_root->node = read_tree_block(tree_root,
					  btrfs_super_root(disk_super));
C
Chris Mason 已提交
478 479
	if (!tree_root->node)
		goto fail_sb_buffer;
480

C
Chris Mason 已提交
481 482
	mutex_lock(&fs_info->fs_mutex);
	ret = find_and_setup_root(sb->s_blocksize, tree_root, fs_info,
C
Chris Mason 已提交
483
				  BTRFS_EXTENT_TREE_OBJECTID, extent_root);
C
Chris Mason 已提交
484 485 486 487
	if (ret) {
		mutex_unlock(&fs_info->fs_mutex);
		goto fail_tree_root;
	}
488

C
Chris Mason 已提交
489 490
	btrfs_read_block_groups(extent_root);

491
	fs_info->generation = btrfs_super_generation(disk_super) + 1;
C
Chris Mason 已提交
492
	mutex_unlock(&fs_info->fs_mutex);
493
	return tree_root;
C
Chris Mason 已提交
494 495 496 497 498 499 500 501 502 503 504 505

fail_tree_root:
	btrfs_block_release(tree_root, tree_root->node);
fail_sb_buffer:
	btrfs_block_release(tree_root, fs_info->sb_buffer);
fail_iput:
	iput(fs_info->btree_inode);
fail:
	kfree(extent_root);
	kfree(tree_root);
	kfree(fs_info);
	return ERR_PTR(err);
506 507
}

508
int write_ctree_super(struct btrfs_trans_handle *trans, struct btrfs_root
C
Chris Mason 已提交
509
		      *root)
510
{
511
	int ret;
512
	struct buffer_head *bh = root->fs_info->sb_buffer;
C
Chris Mason 已提交
513

514
	btrfs_set_super_root(root->fs_info->disk_super,
515
			     bh_blocknr(root->fs_info->tree_root->node));
516
	lock_buffer(bh);
C
Chris Mason 已提交
517
	WARN_ON(atomic_read(&bh->b_count) < 1);
518
	clear_buffer_dirty(bh);
C
Chris Mason 已提交
519
	csum_tree_block(root, bh, 0);
520 521
	bh->b_end_io = end_buffer_write_sync;
	get_bh(bh);
522 523 524 525 526
	if (root->fs_info->do_barriers)
		ret = submit_bh(WRITE_BARRIER, bh);
	else
		ret = submit_bh(WRITE, bh);
	if (ret == -EOPNOTSUPP) {
527 528
		get_bh(bh);
		lock_buffer(bh);
529 530 531 532
		set_buffer_uptodate(bh);
		root->fs_info->do_barriers = 0;
		ret = submit_bh(WRITE, bh);
	}
533 534 535 536
	wait_on_buffer(bh);
	if (!buffer_uptodate(bh)) {
		WARN_ON(1);
		return -EIO;
C
Chris Mason 已提交
537 538 539 540
	}
	return 0;
}

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

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

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

579
	fs_info->closing = 1;
C
Chris Mason 已提交
580
	btrfs_transaction_flush_work(root);
581
	mutex_lock(&fs_info->fs_mutex);
C
Chris Mason 已提交
582
	trans = btrfs_start_transaction(root, 1);
583
	ret = btrfs_commit_transaction(trans, root);
C
Chris Mason 已提交
584 585 586 587
	/* 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);
588
	BUG_ON(ret);
C
Chris Mason 已提交
589
	write_ctree_super(NULL, root);
590 591 592 593 594 595 596 597 598 599 600
	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);
	truncate_inode_pages(fs_info->btree_inode->i_mapping, 0);
	iput(fs_info->btree_inode);
601

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

C
Chris Mason 已提交
609
void btrfs_block_release(struct btrfs_root *root, struct buffer_head *buf)
610
{
C
Chris Mason 已提交
611
	brelse(buf);
612 613
}

C
Chris Mason 已提交
614 615 616 617
void btrfs_btree_balance_dirty(struct btrfs_root *root)
{
	balance_dirty_pages_ratelimited(root->fs_info->btree_inode->i_mapping);
}