fs/btrfs/disk-io.c

   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 static int check_tree_block(struct btrfs_root *root, struct buffer_head *buf)
  14 {
  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 struct buffer_head *btrfs_find_tree_block(struct btrfs_root *root, u64 blocknr)
  23 {
  24         struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
  25         int blockbits = root->fs_info->sb->s_blocksize_bits;
  26         unsigned long index = blocknr >> (PAGE_CACHE_SHIFT - blockbits);
  27         struct page *page;
  28         struct buffer_head *bh;
  29         struct buffer_head *head;
  30         struct buffer_head *ret = NULL;
  31
  32
  33         page = find_lock_page(mapping, index);
  34         if (!page)
  35                 return NULL;
  36
  37         if (!page_has_buffers(page))
  38                 goto out_unlock;
  39
  40         head = page_buffers(page);
  41         bh = head;
  42         do {
  43                 if (buffer_mapped(bh) && bh->b_blocknr == blocknr) {
  44                         ret = bh;
  45                         get_bh(bh);
  46                         goto out_unlock;
  47                 }
  48                 bh = bh->b_this_page;
  49         } while (bh != head);
  50 out_unlock:
  51         unlock_page(page);
  52         if (ret) {
  53                 touch_buffer(ret);
  54         }
  55         page_cache_release(page);
  56         return ret;
  57 }
  58
  59 struct buffer_head *btrfs_find_create_tree_block(struct btrfs_root *root,
  60                                                  u64 blocknr)
  61 {
  62         struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
  63         int blockbits = root->fs_info->sb->s_blocksize_bits;
  64         unsigned long index = blocknr >> (PAGE_CACHE_SHIFT - blockbits);
  65         struct page *page;
  66         struct buffer_head *bh;
  67         struct buffer_head *head;
  68         struct buffer_head *ret = NULL;
  69         u64 first_block = index << (PAGE_CACHE_SHIFT - blockbits);
  70
  71         page = grab_cache_page(mapping, index);
  72         if (!page)
  73                 return NULL;
  74
  75         if (!page_has_buffers(page))
  76                 create_empty_buffers(page, root->fs_info->sb->s_blocksize, 0);
  77         head = page_buffers(page);
  78         bh = head;
  79         do {
  80                 if (!buffer_mapped(bh)) {
  81                         bh->b_bdev = root->fs_info->sb->s_bdev;
  82                         bh->b_blocknr = first_block;
  83                         set_buffer_mapped(bh);
  84                 }
  85                 if (bh->b_blocknr == blocknr) {
  86                         ret = bh;
  87                         get_bh(bh);
  88                         goto out_unlock;
  89                 }
  90                 bh = bh->b_this_page;
  91                 first_block++;
  92         } while (bh != head);
  93 out_unlock:
  94         unlock_page(page);
  95         if (ret)
  96                 touch_buffer(ret);
  97         page_cache_release(page);
  98         return ret;
  99 }
 100
 101 static sector_t max_block(struct block_device *bdev)
 102 {
 103         sector_t retval = ~((sector_t)0);
 104         loff_t sz = i_size_read(bdev->bd_inode);
 105
 106         if (sz) {
 107                 unsigned int size = block_size(bdev);
 108                 unsigned int sizebits = blksize_bits(size);
 109                 retval = (sz >> sizebits);
 110         }
 111         return retval;
 112 }
 113
 114 static int btree_get_block(struct inode *inode, sector_t iblock,
 115                            struct buffer_head *bh, int create)
 116 {
 117         if (iblock >= max_block(inode->i_sb->s_bdev)) {
 118                 if (create)
 119                         return -EIO;
 120
 121                 /*
 122                  * for reads, we're just trying to fill a partial page.
 123                  * return a hole, they will have to call get_block again
 124                  * before they can fill it, and they will get -EIO at that
 125                  * time
 126                  */
 127                 return 0;
 128         }
 129         bh->b_bdev = inode->i_sb->s_bdev;
 130         bh->b_blocknr = iblock;
 131         set_buffer_mapped(bh);
 132         return 0;
 133 }
 134
 135 int btrfs_csum_data(struct btrfs_root * root, char *data, size_t len,
 136                     char *result)
 137 {
 138         struct scatterlist sg;
 139         struct crypto_hash *tfm = root->fs_info->hash_tfm;
 140         struct hash_desc desc;
 141         int ret;
 142
 143         desc.tfm = tfm;
 144         desc.flags = 0;
 145         sg_init_one(&sg, data, len);
 146         spin_lock(&root->fs_info->hash_lock);
 147         ret = crypto_hash_digest(&desc, &sg, 1, result);
 148         spin_unlock(&root->fs_info->hash_lock);
 149         if (ret) {
 150                 printk("sha256 digest failed\n");
 151         }
 152         return ret;
 153 }
 154 static int csum_tree_block(struct btrfs_root *root, struct buffer_head *bh,
 155                            int verify)
 156 {
 157         char result[BTRFS_CSUM_SIZE];
 158         int ret;
 159         struct btrfs_node *node;
 160
 161         ret = btrfs_csum_data(root, bh->b_data + BTRFS_CSUM_SIZE,
 162                               bh->b_size - BTRFS_CSUM_SIZE, result);
 163         if (ret)
 164                 return ret;
 165         if (verify) {
 166                 if (memcmp(bh->b_data, result, BTRFS_CSUM_SIZE)) {
 167                         printk("checksum verify failed on %lu\n",
 168                                bh->b_blocknr);
 169                         return 1;
 170                 }
 171         } else {
 172                 node = btrfs_buffer_node(bh);
 173                 memcpy(node->header.csum, result, BTRFS_CSUM_SIZE);
 174         }
 175         return 0;
 176 }
 177
 178 static int btree_writepage(struct page *page, struct writeback_control *wbc)
 179 {
 180         struct buffer_head *bh;
 181         struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
 182         struct buffer_head *head;
 183         if (!page_has_buffers(page)) {
 184                 create_empty_buffers(page, root->fs_info->sb->s_blocksize,
 185                                         (1 << BH_Dirty)|(1 << BH_Uptodate));
 186         }
 187         head = page_buffers(page);
 188         bh = head;
 189         do {
 190                 if (buffer_dirty(bh))
 191                         csum_tree_block(root, bh, 0);
 192                 bh = bh->b_this_page;
 193         } 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 static struct address_space_operations btree_aops = {
 203         .readpage       = btree_readpage,
 204         .writepage      = btree_writepage,
 205         .sync_page      = block_sync_page,
 206 };
 207
 208 struct buffer_head *read_tree_block(struct btrfs_root *root, u64 blocknr)
 209 {
 210         struct buffer_head *bh = NULL;
 211
 212         bh = btrfs_find_create_tree_block(root, blocknr);
 213         if (!bh)
 214                 return bh;
 215         if (buffer_uptodate(bh))
 216                 goto uptodate;
 217         lock_buffer(bh);
 218         if (!buffer_uptodate(bh)) {
 219                 get_bh(bh);
 220                 bh->b_end_io = end_buffer_read_sync;
 221                 submit_bh(READ, bh);
 222                 wait_on_buffer(bh);
 223                 if (!buffer_uptodate(bh))
 224                         goto fail;
 225                 csum_tree_block(root, bh, 1);
 226         } else {
 227                 unlock_buffer(bh);
 228         }
 229 uptodate:
 230         if (check_tree_block(root, bh))
 231                 BUG();
 232         return bh;
 233 fail:
 234         brelse(bh);
 235         return NULL;
 236 }
 237
 238 int dirty_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
 239                      struct buffer_head *buf)
 240 {
 241         WARN_ON(atomic_read(&buf->b_count) == 0);
 242         mark_buffer_dirty(buf);
 243         return 0;
 244 }
 245
 246 int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
 247                      struct buffer_head *buf)
 248 {
 249         WARN_ON(atomic_read(&buf->b_count) == 0);
 250         clear_buffer_dirty(buf);
 251         return 0;
 252 }
 253
 254 static int __setup_root(int blocksize,
 255                         struct btrfs_root *root,
 256                         struct btrfs_fs_info *fs_info,
 257                         u64 objectid)
 258 {
 259         root->node = NULL;
 260         root->inode = NULL;
 261         root->commit_root = NULL;
 262         root->blocksize = blocksize;
 263         root->ref_cows = 0;
 264         root->fs_info = fs_info;
 265         root->objectid = objectid;
 266         root->last_trans = 0;
 267         root->highest_inode = 0;
 268         root->last_inode_alloc = 0;
 269         memset(&root->root_key, 0, sizeof(root->root_key));
 270         memset(&root->root_item, 0, sizeof(root->root_item));
 271         return 0;
 272 }
 273
 274 static int find_and_setup_root(int blocksize,
 275                                struct btrfs_root *tree_root,
 276                                struct btrfs_fs_info *fs_info,
 277                                u64 objectid,
 278                                struct btrfs_root *root)
 279 {
 280         int ret;
 281
 282         __setup_root(blocksize, root, fs_info, objectid);
 283         ret = btrfs_find_last_root(tree_root, objectid,
 284                                    &root->root_item, &root->root_key);
 285         BUG_ON(ret);
 286
 287         root->node = read_tree_block(root,
 288                                      btrfs_root_blocknr(&root->root_item));
 289         BUG_ON(!root->node);
 290         return 0;
 291 }
 292
 293 struct btrfs_root *btrfs_read_fs_root(struct btrfs_fs_info *fs_info,
 294                                       struct btrfs_key *location)
 295 {
 296         struct btrfs_root *root;
 297         struct btrfs_root *tree_root = fs_info->tree_root;
 298         struct btrfs_path *path;
 299         struct btrfs_leaf *l;
 300         u64 highest_inode;
 301         int ret = 0;
 302
 303 printk("read_fs_root looking for %Lu %Lu %u\n", location->objectid, location->offset, location->flags);
 304         root = kmalloc(sizeof(*root), GFP_NOFS);
 305         if (!root) {
 306 printk("failed1\n");
 307                 return ERR_PTR(-ENOMEM);
 308         }
 309         if (location->offset == (u64)-1) {
 310                 ret = find_and_setup_root(fs_info->sb->s_blocksize,
 311                                           fs_info->tree_root, fs_info,
 312                                           location->objectid, root);
 313                 if (ret) {
 314 printk("failed2\n");
 315                         kfree(root);
 316                         return ERR_PTR(ret);
 317                 }
 318                 goto insert;
 319         }
 320
 321         __setup_root(fs_info->sb->s_blocksize, root, fs_info,
 322                      location->objectid);
 323
 324         path = btrfs_alloc_path();
 325         BUG_ON(!path);
 326         ret = btrfs_search_slot(NULL, tree_root, location, path, 0, 0);
 327         if (ret != 0) {
 328 printk("internal search_slot gives us %d\n", ret);
 329                 if (ret > 0)
 330                         ret = -ENOENT;
 331                 goto out;
 332         }
 333         l = btrfs_buffer_leaf(path->nodes[0]);
 334         memcpy(&root->root_item,
 335                btrfs_item_ptr(l, path->slots[0], struct btrfs_root_item),
 336                sizeof(root->root_item));
 337         memcpy(&root->root_key, location, sizeof(*location));
 338         ret = 0;
 339 out:
 340         btrfs_release_path(root, path);
 341         btrfs_free_path(path);
 342         if (ret) {
 343                 kfree(root);
 344                 return ERR_PTR(ret);
 345         }
 346         root->node = read_tree_block(root,
 347                                      btrfs_root_blocknr(&root->root_item));
 348         BUG_ON(!root->node);
 349 insert:
 350 printk("inserting %p\n", root);
 351         root->ref_cows = 1;
 352         ret = radix_tree_insert(&fs_info->fs_roots_radix, (unsigned long)root,
 353                                 root);
 354         if (ret) {
 355 printk("radix_tree_insert gives us %d\n", ret);
 356                 brelse(root->node);
 357                 kfree(root);
 358                 return ERR_PTR(ret);
 359         }
 360         ret = btrfs_find_highest_inode(root, &highest_inode);
 361         if (ret == 0) {
 362                 root->highest_inode = highest_inode;
 363                 root->last_inode_alloc = highest_inode;
 364 printk("highest inode is %Lu\n", highest_inode);
 365         }
 366 printk("all worked\n");
 367         return root;
 368 }
 369
 370 struct btrfs_root *open_ctree(struct super_block *sb)
 371 {
 372         struct btrfs_root *extent_root = kmalloc(sizeof(struct btrfs_root),
 373                                                  GFP_NOFS);
 374         struct btrfs_root *tree_root = kmalloc(sizeof(struct btrfs_root),
 375                                                GFP_NOFS);
 376         struct btrfs_fs_info *fs_info = kmalloc(sizeof(*fs_info),
 377                                                 GFP_NOFS);
 378         int ret;
 379         struct btrfs_super_block *disk_super;
 380
 381         init_bit_radix(&fs_info->pinned_radix);
 382         init_bit_radix(&fs_info->pending_del_radix);
 383         INIT_RADIX_TREE(&fs_info->fs_roots_radix, GFP_NOFS);
 384         sb_set_blocksize(sb, 4096);
 385         fs_info->running_transaction = NULL;
 386         fs_info->tree_root = tree_root;
 387         fs_info->extent_root = extent_root;
 388         fs_info->sb = sb;
 389         fs_info->btree_inode = new_inode(sb);
 390         fs_info->btree_inode->i_ino = 1;
 391         fs_info->btree_inode->i_nlink = 1;
 392         fs_info->btree_inode->i_size = sb->s_bdev->bd_inode->i_size;
 393         fs_info->btree_inode->i_mapping->a_ops = &btree_aops;
 394         BTRFS_I(fs_info->btree_inode)->root = tree_root;
 395         memset(&BTRFS_I(fs_info->btree_inode)->location, 0,
 396                sizeof(struct btrfs_key));
 397         insert_inode_hash(fs_info->btree_inode);
 398         mapping_set_gfp_mask(fs_info->btree_inode->i_mapping, GFP_NOFS);
 399         fs_info->hash_tfm = crypto_alloc_hash("sha256", 0, CRYPTO_ALG_ASYNC);
 400         spin_lock_init(&fs_info->hash_lock);
 401         if (!fs_info->hash_tfm || IS_ERR(fs_info->hash_tfm)) {
 402                 printk("failed to allocate sha256 hash\n");
 403                 return NULL;
 404         }
 405         mutex_init(&fs_info->trans_mutex);
 406         mutex_init(&fs_info->fs_mutex);
 407         memset(&fs_info->current_insert, 0, sizeof(fs_info->current_insert));
 408         memset(&fs_info->last_insert, 0, sizeof(fs_info->last_insert));
 409
 410         __setup_root(sb->s_blocksize, tree_root,
 411                      fs_info, BTRFS_ROOT_TREE_OBJECTID);
 412         fs_info->sb_buffer = read_tree_block(tree_root,
 413                                              BTRFS_SUPER_INFO_OFFSET /
 414                                              sb->s_blocksize);
 415
 416         if (!fs_info->sb_buffer)
 417                 return NULL;
 418         disk_super = (struct btrfs_super_block *)fs_info->sb_buffer->b_data;
 419         if (!btrfs_super_root(disk_super))
 420                 return NULL;
 421
 422         fs_info->disk_super = disk_super;
 423         tree_root->node = read_tree_block(tree_root,
 424                                           btrfs_super_root(disk_super));
 425         BUG_ON(!tree_root->node);
 426
 427         mutex_lock(&fs_info->fs_mutex);
 428         ret = find_and_setup_root(sb->s_blocksize, tree_root, fs_info,
 429                                   BTRFS_EXTENT_TREE_OBJECTID, extent_root);
 430         BUG_ON(ret);
 431
 432         fs_info->generation = btrfs_super_generation(disk_super) + 1;
 433         memset(&fs_info->kobj, 0, sizeof(fs_info->kobj));
 434         kobj_set_kset_s(fs_info, btrfs_subsys);
 435         kobject_set_name(&fs_info->kobj, "%s", sb->s_id);
 436         kobject_register(&fs_info->kobj);
 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
 442                       *root)
 443 {
 444         struct buffer_head *bh = root->fs_info->sb_buffer;
 445
 446         btrfs_set_super_root(root->fs_info->disk_super,
 447                              root->fs_info->tree_root->node->b_blocknr);
 448         lock_buffer(bh);
 449         WARN_ON(atomic_read(&bh->b_count) < 1);
 450         clear_buffer_dirty(bh);
 451         csum_tree_block(root, bh, 0);
 452         bh->b_end_io = end_buffer_write_sync;
 453         get_bh(bh);
 454         submit_bh(WRITE, bh);
 455         wait_on_buffer(bh);
 456         if (!buffer_uptodate(bh)) {
 457                 WARN_ON(1);
 458                 return -EIO;
 459         }
 460         return 0;
 461 }
 462
 463 int del_fs_roots(struct btrfs_fs_info *fs_info)
 464 {
 465         int ret;
 466         struct btrfs_root *gang[8];
 467         int i;
 468
 469         while(1) {
 470                 ret = radix_tree_gang_lookup(&fs_info->fs_roots_radix,
 471                                              (void **)gang, 0,
 472                                              ARRAY_SIZE(gang));
 473                 if (!ret)
 474                         break;
 475                 for (i = 0; i < ret; i++) {
 476                         radix_tree_delete(&fs_info->fs_roots_radix,
 477                                           (unsigned long)gang[i]);
 478                         if (gang[i]->inode)
 479                                 iput(gang[i]->inode);
 480                         else
 481                                 printk("no inode for root %p\n", gang[i]);
 482                         if (gang[i]->node)
 483                                 brelse(gang[i]->node);
 484                         if (gang[i]->commit_root)
 485                                 brelse(gang[i]->commit_root);
 486                         kfree(gang[i]);
 487                 }
 488         }
 489         return 0;
 490 }
 491
 492 int close_ctree(struct btrfs_root *root)
 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);
 499         trans = btrfs_start_transaction(root, 1);
 500         btrfs_commit_transaction(trans, root);
 501         /* run commit again to  drop the original snapshot */
 502         trans = btrfs_start_transaction(root, 1);
 503         btrfs_commit_transaction(trans, root);
 504         ret = btrfs_write_and_wait_transaction(NULL, root);
 505         BUG_ON(ret);
 506         write_ctree_super(NULL, root);
 507         mutex_unlock(&fs_info->fs_mutex);
 508
 509         if (fs_info->extent_root->node)
 510                 btrfs_block_release(fs_info->extent_root,
 511                                     fs_info->extent_root->node);
 512         if (fs_info->tree_root->node)
 513                 btrfs_block_release(fs_info->tree_root,
 514                                     fs_info->tree_root->node);
 515         btrfs_block_release(root, fs_info->sb_buffer);
 516         crypto_free_hash(fs_info->hash_tfm);
 517         truncate_inode_pages(fs_info->btree_inode->i_mapping, 0);
 518         iput(fs_info->btree_inode);
 519         del_fs_roots(fs_info);
 520         kfree(fs_info->extent_root);
 521         kfree(fs_info->tree_root);
 522         kobject_unregister(&fs_info->kobj);
 523         return 0;
 524 }
 525
 526 void btrfs_block_release(struct btrfs_root *root, struct buffer_head *buf)
 527 {
 528         brelse(buf);
 529 }
 530