1 #include <linux/module.h> 2 #include <linux/fs.h> 3 #include <linux/blkdev.h> 4 #include <linux/crypto.h> 5 #include <linux/scatterlist.h> 6 #include <linux/swap.h> 7 #include <linux/radix-tree.h> 8 #include "ctree.h" 9 #include "disk-io.h" 10 #include "transaction.h" 11 #include "btrfs_inode.h" 12 13 struct dev_lookup { 14 u64 block_start; 15 u64 num_blocks; 16 u64 device_id; 17 struct block_device *bdev; 18 }; 19 20 int btrfs_insert_dev_radix(struct btrfs_root *root, 21 struct block_device *bdev, 22 u64 device_id, 23 u64 block_start, 24 u64 num_blocks) 25 { 26 struct dev_lookup *lookup; 27 int ret; 28 29 lookup = kmalloc(sizeof(*lookup), GFP_NOFS); 30 if (!lookup) 31 return -ENOMEM; 32 lookup->block_start = block_start; 33 lookup->num_blocks = num_blocks; 34 lookup->bdev = bdev; 35 lookup->device_id = device_id; 36 37 ret = radix_tree_insert(&root->fs_info->dev_radix, block_start + 38 num_blocks - 1, lookup); 39 return ret; 40 } 41 42 u64 bh_blocknr(struct buffer_head *bh) 43 { 44 int blkbits = bh->b_page->mapping->host->i_blkbits; 45 u64 blocknr = bh->b_page->index << (PAGE_CACHE_SHIFT - blkbits); 46 unsigned long offset; 47 48 if (PageHighMem(bh->b_page)) 49 offset = (unsigned long)bh->b_data; 50 else 51 offset = bh->b_data - (char *)page_address(bh->b_page); 52 blocknr += offset >> (PAGE_CACHE_SHIFT - blkbits); 53 return blocknr; 54 } 55 56 static int check_tree_block(struct btrfs_root *root, struct buffer_head *buf) 57 { 58 struct btrfs_node *node = btrfs_buffer_node(buf); 59 if (bh_blocknr(buf) != btrfs_header_blocknr(&node->header)) { 60 printk(KERN_CRIT "bh_blocknr(buf) is %Lu, header is %Lu\n", 61 bh_blocknr(buf), btrfs_header_blocknr(&node->header)); 62 BUG(); 63 } 64 return 0; 65 } 66 67 struct buffer_head *btrfs_find_tree_block(struct btrfs_root *root, u64 blocknr) 68 { 69 struct address_space *mapping = root->fs_info->btree_inode->i_mapping; 70 int blockbits = root->fs_info->sb->s_blocksize_bits; 71 unsigned long index = blocknr >> (PAGE_CACHE_SHIFT - blockbits); 72 struct page *page; 73 struct buffer_head *bh; 74 struct buffer_head *head; 75 struct buffer_head *ret = NULL; 76 77 78 page = find_lock_page(mapping, index); 79 if (!page) 80 return NULL; 81 82 if (!page_has_buffers(page)) 83 goto out_unlock; 84 85 head = page_buffers(page); 86 bh = head; 87 do { 88 if (buffer_mapped(bh) && bh_blocknr(bh) == blocknr) { 89 ret = bh; 90 get_bh(bh); 91 goto out_unlock; 92 } 93 bh = bh->b_this_page; 94 } while (bh != head); 95 out_unlock: 96 unlock_page(page); 97 if (ret) { 98 touch_buffer(ret); 99 } 100 page_cache_release(page); 101 return ret; 102 } 103 104 int btrfs_map_bh_to_logical(struct btrfs_root *root, struct buffer_head *bh, 105 u64 logical) 106 { 107 struct dev_lookup *lookup[2]; 108 109 int ret; 110 111 root = root->fs_info->dev_root; 112 ret = radix_tree_gang_lookup(&root->fs_info->dev_radix, 113 (void **)lookup, 114 (unsigned long)logical, 115 ARRAY_SIZE(lookup)); 116 if (ret == 0 || lookup[0]->block_start > logical || 117 lookup[0]->block_start + lookup[0]->num_blocks <= logical) { 118 ret = -ENOENT; 119 goto out; 120 } 121 bh->b_bdev = lookup[0]->bdev; 122 bh->b_blocknr = logical - lookup[0]->block_start; 123 set_buffer_mapped(bh); 124 ret = 0; 125 out: 126 return ret; 127 } 128 129 struct buffer_head *btrfs_find_create_tree_block(struct btrfs_root *root, 130 u64 blocknr) 131 { 132 struct address_space *mapping = root->fs_info->btree_inode->i_mapping; 133 int blockbits = root->fs_info->sb->s_blocksize_bits; 134 unsigned long index = blocknr >> (PAGE_CACHE_SHIFT - blockbits); 135 struct page *page; 136 struct buffer_head *bh; 137 struct buffer_head *head; 138 struct buffer_head *ret = NULL; 139 int err; 140 u64 first_block = index << (PAGE_CACHE_SHIFT - blockbits); 141 142 page = grab_cache_page(mapping, index); 143 if (!page) 144 return NULL; 145 146 if (!page_has_buffers(page)) 147 create_empty_buffers(page, root->fs_info->sb->s_blocksize, 0); 148 head = page_buffers(page); 149 bh = head; 150 do { 151 if (!buffer_mapped(bh)) { 152 err = btrfs_map_bh_to_logical(root, bh, first_block); 153 BUG_ON(err); 154 } 155 if (bh_blocknr(bh) == blocknr) { 156 ret = bh; 157 get_bh(bh); 158 goto out_unlock; 159 } 160 bh = bh->b_this_page; 161 first_block++; 162 } while (bh != head); 163 out_unlock: 164 unlock_page(page); 165 if (ret) 166 touch_buffer(ret); 167 page_cache_release(page); 168 return ret; 169 } 170 171 static int btree_get_block(struct inode *inode, sector_t iblock, 172 struct buffer_head *bh, int create) 173 { 174 int err; 175 struct btrfs_root *root = BTRFS_I(bh->b_page->mapping->host)->root; 176 err = btrfs_map_bh_to_logical(root, bh, iblock); 177 return err; 178 } 179 180 int btrfs_csum_data(struct btrfs_root * root, char *data, size_t len, 181 char *result) 182 { 183 struct scatterlist sg; 184 struct crypto_hash *tfm = root->fs_info->hash_tfm; 185 struct hash_desc desc; 186 int ret; 187 188 desc.tfm = tfm; 189 desc.flags = 0; 190 sg_init_one(&sg, data, len); 191 spin_lock(&root->fs_info->hash_lock); 192 ret = crypto_hash_digest(&desc, &sg, 1, result); 193 spin_unlock(&root->fs_info->hash_lock); 194 if (ret) { 195 printk("sha256 digest failed\n"); 196 } 197 return ret; 198 } 199 static int csum_tree_block(struct btrfs_root *root, struct buffer_head *bh, 200 int verify) 201 { 202 char result[BTRFS_CSUM_SIZE]; 203 int ret; 204 struct btrfs_node *node; 205 206 ret = btrfs_csum_data(root, bh->b_data + BTRFS_CSUM_SIZE, 207 bh->b_size - BTRFS_CSUM_SIZE, result); 208 if (ret) 209 return ret; 210 if (verify) { 211 if (memcmp(bh->b_data, result, BTRFS_CSUM_SIZE)) { 212 printk("checksum verify failed on %Lu\n", 213 bh_blocknr(bh)); 214 return 1; 215 } 216 } else { 217 node = btrfs_buffer_node(bh); 218 memcpy(node->header.csum, result, BTRFS_CSUM_SIZE); 219 } 220 return 0; 221 } 222 223 static int btree_writepage(struct page *page, struct writeback_control *wbc) 224 { 225 struct buffer_head *bh; 226 struct btrfs_root *root = BTRFS_I(page->mapping->host)->root; 227 struct buffer_head *head; 228 if (!page_has_buffers(page)) { 229 create_empty_buffers(page, root->fs_info->sb->s_blocksize, 230 (1 << BH_Dirty)|(1 << BH_Uptodate)); 231 } 232 head = page_buffers(page); 233 bh = head; 234 do { 235 if (buffer_dirty(bh)) 236 csum_tree_block(root, bh, 0); 237 bh = bh->b_this_page; 238 } while (bh != head); 239 return block_write_full_page(page, btree_get_block, wbc); 240 } 241 242 static int btree_readpage(struct file * file, struct page * page) 243 { 244 return block_read_full_page(page, btree_get_block); 245 } 246 247 static struct address_space_operations btree_aops = { 248 .readpage = btree_readpage, 249 .writepage = btree_writepage, 250 .sync_page = block_sync_page, 251 }; 252 253 struct buffer_head *read_tree_block(struct btrfs_root *root, u64 blocknr) 254 { 255 struct buffer_head *bh = NULL; 256 257 bh = btrfs_find_create_tree_block(root, blocknr); 258 if (!bh) 259 return bh; 260 if (buffer_uptodate(bh)) 261 goto uptodate; 262 lock_buffer(bh); 263 if (!buffer_uptodate(bh)) { 264 get_bh(bh); 265 bh->b_end_io = end_buffer_read_sync; 266 submit_bh(READ, bh); 267 wait_on_buffer(bh); 268 if (!buffer_uptodate(bh)) 269 goto fail; 270 csum_tree_block(root, bh, 1); 271 } else { 272 unlock_buffer(bh); 273 } 274 uptodate: 275 if (check_tree_block(root, bh)) 276 BUG(); 277 return bh; 278 fail: 279 brelse(bh); 280 return NULL; 281 } 282 283 int dirty_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root, 284 struct buffer_head *buf) 285 { 286 WARN_ON(atomic_read(&buf->b_count) == 0); 287 mark_buffer_dirty(buf); 288 return 0; 289 } 290 291 int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root, 292 struct buffer_head *buf) 293 { 294 WARN_ON(atomic_read(&buf->b_count) == 0); 295 clear_buffer_dirty(buf); 296 return 0; 297 } 298 299 static int __setup_root(int blocksize, 300 struct btrfs_root *root, 301 struct btrfs_fs_info *fs_info, 302 u64 objectid) 303 { 304 root->node = NULL; 305 root->inode = NULL; 306 root->commit_root = NULL; 307 root->blocksize = blocksize; 308 root->ref_cows = 0; 309 root->fs_info = fs_info; 310 root->objectid = objectid; 311 root->last_trans = 0; 312 root->highest_inode = 0; 313 root->last_inode_alloc = 0; 314 memset(&root->root_key, 0, sizeof(root->root_key)); 315 memset(&root->root_item, 0, sizeof(root->root_item)); 316 return 0; 317 } 318 319 static int find_and_setup_root(int blocksize, 320 struct btrfs_root *tree_root, 321 struct btrfs_fs_info *fs_info, 322 u64 objectid, 323 struct btrfs_root *root) 324 { 325 int ret; 326 327 __setup_root(blocksize, root, fs_info, objectid); 328 ret = btrfs_find_last_root(tree_root, objectid, 329 &root->root_item, &root->root_key); 330 BUG_ON(ret); 331 332 root->node = read_tree_block(root, 333 btrfs_root_blocknr(&root->root_item)); 334 BUG_ON(!root->node); 335 return 0; 336 } 337 338 struct btrfs_root *btrfs_read_fs_root(struct btrfs_fs_info *fs_info, 339 struct btrfs_key *location) 340 { 341 struct btrfs_root *root; 342 struct btrfs_root *tree_root = fs_info->tree_root; 343 struct btrfs_path *path; 344 struct btrfs_leaf *l; 345 u64 highest_inode; 346 int ret = 0; 347 348 printk("read_fs_root looking for %Lu %Lu %u\n", location->objectid, location->offset, location->flags); 349 root = radix_tree_lookup(&fs_info->fs_roots_radix, 350 (unsigned long)location->objectid); 351 if (root) { 352 printk("found %p in cache\n", root); 353 return root; 354 } 355 root = kmalloc(sizeof(*root), GFP_NOFS); 356 if (!root) { 357 printk("failed1\n"); 358 return ERR_PTR(-ENOMEM); 359 } 360 if (location->offset == (u64)-1) { 361 ret = find_and_setup_root(fs_info->sb->s_blocksize, 362 fs_info->tree_root, fs_info, 363 location->objectid, root); 364 if (ret) { 365 printk("failed2\n"); 366 kfree(root); 367 return ERR_PTR(ret); 368 } 369 goto insert; 370 } 371 372 __setup_root(fs_info->sb->s_blocksize, root, fs_info, 373 location->objectid); 374 375 path = btrfs_alloc_path(); 376 BUG_ON(!path); 377 ret = btrfs_search_slot(NULL, tree_root, location, path, 0, 0); 378 if (ret != 0) { 379 printk("internal search_slot gives us %d\n", ret); 380 if (ret > 0) 381 ret = -ENOENT; 382 goto out; 383 } 384 l = btrfs_buffer_leaf(path->nodes[0]); 385 memcpy(&root->root_item, 386 btrfs_item_ptr(l, path->slots[0], struct btrfs_root_item), 387 sizeof(root->root_item)); 388 memcpy(&root->root_key, location, sizeof(*location)); 389 ret = 0; 390 out: 391 btrfs_release_path(root, path); 392 btrfs_free_path(path); 393 if (ret) { 394 kfree(root); 395 return ERR_PTR(ret); 396 } 397 root->node = read_tree_block(root, 398 btrfs_root_blocknr(&root->root_item)); 399 BUG_ON(!root->node); 400 insert: 401 printk("inserting %p\n", root); 402 root->ref_cows = 1; 403 ret = radix_tree_insert(&fs_info->fs_roots_radix, 404 (unsigned long)root->root_key.objectid, 405 root); 406 if (ret) { 407 printk("radix_tree_insert gives us %d\n", ret); 408 brelse(root->node); 409 kfree(root); 410 return ERR_PTR(ret); 411 } 412 ret = btrfs_find_highest_inode(root, &highest_inode); 413 if (ret == 0) { 414 root->highest_inode = highest_inode; 415 root->last_inode_alloc = highest_inode; 416 printk("highest inode is %Lu\n", highest_inode); 417 } 418 printk("all worked\n"); 419 return root; 420 } 421 422 static int btrfs_open_disk(struct btrfs_root *root, u64 device_id, 423 u64 block_start, u64 num_blocks, 424 char *filename, int name_len) 425 { 426 char *null_filename; 427 struct block_device *bdev; 428 int ret; 429 430 null_filename = kmalloc(name_len + 1, GFP_NOFS); 431 if (!null_filename) 432 return -ENOMEM; 433 memcpy(null_filename, filename, name_len); 434 null_filename[name_len] = '\0'; 435 436 bdev = open_bdev_excl(null_filename, O_RDWR, root->fs_info->sb); 437 if (IS_ERR(bdev)) { 438 ret = PTR_ERR(bdev); 439 goto out; 440 } 441 set_blocksize(bdev, root->fs_info->sb->s_blocksize); 442 ret = btrfs_insert_dev_radix(root, bdev, device_id, 443 block_start, num_blocks); 444 BUG_ON(ret); 445 ret = 0; 446 out: 447 kfree(null_filename); 448 return ret; 449 } 450 451 static int read_device_info(struct btrfs_root *root) 452 { 453 struct btrfs_path *path; 454 int ret; 455 struct btrfs_key key; 456 struct btrfs_leaf *leaf; 457 struct btrfs_device_item *dev_item; 458 int nritems; 459 int slot; 460 461 root = root->fs_info->dev_root; 462 463 path = btrfs_alloc_path(); 464 if (!path) 465 return -ENOMEM; 466 key.objectid = 0; 467 key.offset = 0; 468 key.flags = 0; 469 btrfs_set_key_type(&key, BTRFS_DEV_ITEM_KEY); 470 471 mutex_lock(&root->fs_info->fs_mutex); 472 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); 473 leaf = btrfs_buffer_leaf(path->nodes[0]); 474 nritems = btrfs_header_nritems(&leaf->header); 475 while(1) { 476 slot = path->slots[0]; 477 if (slot >= nritems) { 478 ret = btrfs_next_leaf(root, path); 479 if (ret) 480 break; 481 leaf = btrfs_buffer_leaf(path->nodes[0]); 482 nritems = btrfs_header_nritems(&leaf->header); 483 slot = path->slots[0]; 484 } 485 btrfs_disk_key_to_cpu(&key, &leaf->items[slot].key); 486 if (btrfs_key_type(&key) != BTRFS_DEV_ITEM_KEY) { 487 path->slots[0]++; 488 continue; 489 } 490 dev_item = btrfs_item_ptr(leaf, slot, struct btrfs_device_item); 491 printk("found key %Lu %Lu\n", key.objectid, key.offset); 492 if (btrfs_device_id(dev_item) != 493 btrfs_super_device_id(root->fs_info->disk_super)) { 494 ret = btrfs_open_disk(root, btrfs_device_id(dev_item), 495 key.objectid, key.offset, 496 (char *)(dev_item + 1), 497 btrfs_device_pathlen(dev_item)); 498 BUG_ON(ret); 499 } 500 path->slots[0]++; 501 } 502 btrfs_free_path(path); 503 mutex_unlock(&root->fs_info->fs_mutex); 504 return 0; 505 } 506 507 struct btrfs_root *open_ctree(struct super_block *sb) 508 { 509 struct btrfs_root *extent_root = kmalloc(sizeof(struct btrfs_root), 510 GFP_NOFS); 511 struct btrfs_root *dev_root = kmalloc(sizeof(struct btrfs_root), 512 GFP_NOFS); 513 struct btrfs_root *tree_root = kmalloc(sizeof(struct btrfs_root), 514 GFP_NOFS); 515 struct btrfs_fs_info *fs_info = kmalloc(sizeof(*fs_info), 516 GFP_NOFS); 517 int ret; 518 struct btrfs_super_block *disk_super; 519 struct dev_lookup *dev_lookup; 520 521 init_bit_radix(&fs_info->pinned_radix); 522 init_bit_radix(&fs_info->pending_del_radix); 523 INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_NOFS); 524 INIT_RADIX_TREE(&fs_info->dev_radix, GFP_NOFS); 525 sb_set_blocksize(sb, 4096); 526 fs_info->running_transaction = NULL; 527 fs_info->tree_root = tree_root; 528 fs_info->extent_root = extent_root; 529 fs_info->dev_root = dev_root; 530 fs_info->sb = sb; 531 fs_info->btree_inode = new_inode(sb); 532 fs_info->btree_inode->i_ino = 1; 533 fs_info->btree_inode->i_nlink = 1; 534 fs_info->btree_inode->i_size = sb->s_bdev->bd_inode->i_size; 535 fs_info->btree_inode->i_mapping->a_ops = &btree_aops; 536 BTRFS_I(fs_info->btree_inode)->root = tree_root; 537 memset(&BTRFS_I(fs_info->btree_inode)->location, 0, 538 sizeof(struct btrfs_key)); 539 insert_inode_hash(fs_info->btree_inode); 540 mapping_set_gfp_mask(fs_info->btree_inode->i_mapping, GFP_NOFS); 541 fs_info->hash_tfm = crypto_alloc_hash("sha256", 0, CRYPTO_ALG_ASYNC); 542 spin_lock_init(&fs_info->hash_lock); 543 if (!fs_info->hash_tfm || IS_ERR(fs_info->hash_tfm)) { 544 printk("failed to allocate sha256 hash\n"); 545 return NULL; 546 } 547 mutex_init(&fs_info->trans_mutex); 548 mutex_init(&fs_info->fs_mutex); 549 memset(&fs_info->current_insert, 0, sizeof(fs_info->current_insert)); 550 memset(&fs_info->last_insert, 0, sizeof(fs_info->last_insert)); 551 552 __setup_root(sb->s_blocksize, dev_root, 553 fs_info, BTRFS_DEV_TREE_OBJECTID); 554 555 __setup_root(sb->s_blocksize, tree_root, 556 fs_info, BTRFS_ROOT_TREE_OBJECTID); 557 558 dev_lookup = kmalloc(sizeof(*dev_lookup), GFP_NOFS); 559 dev_lookup->block_start = 0; 560 dev_lookup->num_blocks = (u32)-2; 561 dev_lookup->bdev = sb->s_bdev; 562 dev_lookup->device_id = 0; 563 ret = radix_tree_insert(&fs_info->dev_radix, (u32)-2, dev_lookup); 564 BUG_ON(ret); 565 fs_info->sb_buffer = read_tree_block(tree_root, 566 BTRFS_SUPER_INFO_OFFSET / 567 sb->s_blocksize); 568 569 if (!fs_info->sb_buffer) 570 return NULL; 571 disk_super = (struct btrfs_super_block *)fs_info->sb_buffer->b_data; 572 if (!btrfs_super_root(disk_super)) 573 return NULL; 574 575 i_size_write(fs_info->btree_inode, 576 btrfs_super_total_blocks(disk_super) << 577 fs_info->btree_inode->i_blkbits); 578 579 radix_tree_delete(&fs_info->dev_radix, (u32)-2); 580 dev_lookup->block_start = btrfs_super_device_block_start(disk_super); 581 dev_lookup->num_blocks = btrfs_super_device_num_blocks(disk_super); 582 dev_lookup->device_id = btrfs_super_device_id(disk_super); 583 584 ret = radix_tree_insert(&fs_info->dev_radix, 585 dev_lookup->block_start + 586 dev_lookup->num_blocks - 1, dev_lookup); 587 BUG_ON(ret); 588 589 fs_info->disk_super = disk_super; 590 591 dev_root->node = read_tree_block(tree_root, 592 btrfs_super_device_root(disk_super)); 593 594 ret = read_device_info(dev_root); 595 BUG_ON(ret); 596 597 tree_root->node = read_tree_block(tree_root, 598 btrfs_super_root(disk_super)); 599 BUG_ON(!tree_root->node); 600 601 mutex_lock(&fs_info->fs_mutex); 602 ret = find_and_setup_root(sb->s_blocksize, tree_root, fs_info, 603 BTRFS_EXTENT_TREE_OBJECTID, extent_root); 604 BUG_ON(ret); 605 606 fs_info->generation = btrfs_super_generation(disk_super) + 1; 607 memset(&fs_info->kobj, 0, sizeof(fs_info->kobj)); 608 kobj_set_kset_s(fs_info, btrfs_subsys); 609 kobject_set_name(&fs_info->kobj, "%s", sb->s_id); 610 kobject_register(&fs_info->kobj); 611 mutex_unlock(&fs_info->fs_mutex); 612 return tree_root; 613 } 614 615 int write_ctree_super(struct btrfs_trans_handle *trans, struct btrfs_root 616 *root) 617 { 618 struct buffer_head *bh = root->fs_info->sb_buffer; 619 620 btrfs_set_super_root(root->fs_info->disk_super, 621 bh_blocknr(root->fs_info->tree_root->node)); 622 lock_buffer(bh); 623 WARN_ON(atomic_read(&bh->b_count) < 1); 624 clear_buffer_dirty(bh); 625 csum_tree_block(root, bh, 0); 626 bh->b_end_io = end_buffer_write_sync; 627 get_bh(bh); 628 submit_bh(WRITE, bh); 629 wait_on_buffer(bh); 630 if (!buffer_uptodate(bh)) { 631 WARN_ON(1); 632 return -EIO; 633 } 634 return 0; 635 } 636 637 static int free_fs_root(struct btrfs_fs_info *fs_info, struct btrfs_root *root) 638 { 639 radix_tree_delete(&fs_info->fs_roots_radix, 640 (unsigned long)root->root_key.objectid); 641 if (root->inode) 642 iput(root->inode); 643 if (root->node) 644 brelse(root->node); 645 if (root->commit_root) 646 brelse(root->commit_root); 647 kfree(root); 648 return 0; 649 } 650 651 int del_fs_roots(struct btrfs_fs_info *fs_info) 652 { 653 int ret; 654 struct btrfs_root *gang[8]; 655 int i; 656 657 while(1) { 658 ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix, 659 (void **)gang, 0, 660 ARRAY_SIZE(gang)); 661 if (!ret) 662 break; 663 for (i = 0; i < ret; i++) 664 free_fs_root(fs_info, gang[i]); 665 } 666 return 0; 667 } 668 669 static int free_dev_radix(struct btrfs_fs_info *fs_info) 670 { 671 struct dev_lookup *lookup[8]; 672 struct block_device *super_bdev = fs_info->sb->s_bdev; 673 int ret; 674 int i; 675 while(1) { 676 ret = radix_tree_gang_lookup(&fs_info->dev_radix, 677 (void **)lookup, 0, 678 ARRAY_SIZE(lookup)); 679 if (!ret) 680 break; 681 for (i = 0; i < ret; i++) { 682 if (lookup[i]->bdev != super_bdev) 683 close_bdev_excl(lookup[i]->bdev); 684 radix_tree_delete(&fs_info->dev_radix, 685 lookup[i]->block_start + 686 lookup[i]->num_blocks - 1); 687 kfree(lookup[i]); 688 } 689 } 690 return 0; 691 } 692 693 int close_ctree(struct btrfs_root *root) 694 { 695 int ret; 696 struct btrfs_trans_handle *trans; 697 struct btrfs_fs_info *fs_info = root->fs_info; 698 699 mutex_lock(&fs_info->fs_mutex); 700 trans = btrfs_start_transaction(root, 1); 701 btrfs_commit_transaction(trans, root); 702 /* run commit again to drop the original snapshot */ 703 trans = btrfs_start_transaction(root, 1); 704 btrfs_commit_transaction(trans, root); 705 ret = btrfs_write_and_wait_transaction(NULL, root); 706 BUG_ON(ret); 707 write_ctree_super(NULL, root); 708 mutex_unlock(&fs_info->fs_mutex); 709 710 if (fs_info->extent_root->node) 711 btrfs_block_release(fs_info->extent_root, 712 fs_info->extent_root->node); 713 if (fs_info->dev_root->node) 714 btrfs_block_release(fs_info->dev_root, 715 fs_info->dev_root->node); 716 if (fs_info->tree_root->node) 717 btrfs_block_release(fs_info->tree_root, 718 fs_info->tree_root->node); 719 btrfs_block_release(root, fs_info->sb_buffer); 720 crypto_free_hash(fs_info->hash_tfm); 721 truncate_inode_pages(fs_info->btree_inode->i_mapping, 0); 722 iput(fs_info->btree_inode); 723 724 free_dev_radix(fs_info); 725 del_fs_roots(fs_info); 726 kfree(fs_info->extent_root); 727 kfree(fs_info->tree_root); 728 kobject_unregister(&fs_info->kobj); 729 return 0; 730 } 731 732 void btrfs_block_release(struct btrfs_root *root, struct buffer_head *buf) 733 { 734 brelse(buf); 735 } 736 737