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 "ctree.h"
   7 #include "disk-io.h"
   8 #include "transaction.h"
   9
  10
  11 static int check_tree_block(struct btrfs_root *root, struct buffer_head *buf)
  12 {
  13         struct btrfs_node *node = btrfs_buffer_node(buf);
  14         if (buf->b_blocknr != btrfs_header_blocknr(&node->header)) {
  15                 BUG();
  16         }
  17         if (root->node && btrfs_header_parentid(&node->header) !=
  18             btrfs_header_parentid(btrfs_buffer_header(root->node))) {
  19                 BUG();
  20         }
  21         return 0;
  22 }
  23
  24 struct buffer_head *btrfs_find_tree_block(struct btrfs_root *root, u64 blocknr)
  25 {
  26         struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
  27         int blockbits = root->fs_info->sb->s_blocksize_bits;
  28         unsigned long index = blocknr >> (PAGE_CACHE_SHIFT - blockbits);
  29         struct page *page;
  30         struct buffer_head *bh;
  31         struct buffer_head *head;
  32         struct buffer_head *ret = NULL;
  33
  34         page = find_lock_page(mapping, index);
  35         if (!page)
  36                 return NULL;
  37
  38         if (!page_has_buffers(page))
  39                 goto out_unlock;
  40
  41         head = page_buffers(page);
  42         bh = head;
  43         do {
  44                 if (buffer_mapped(bh) && bh->b_blocknr == blocknr) {
  45                         ret = bh;
  46                         get_bh(bh);
  47                         goto out_unlock;
  48                 }
  49                 bh = bh->b_this_page;
  50         } while (bh != head);
  51 out_unlock:
  52         unlock_page(page);
  53         page_cache_release(page);
  54         return ret;
  55 }
  56
  57 struct buffer_head *btrfs_find_create_tree_block(struct btrfs_root *root,
  58                                                  u64 blocknr)
  59 {
  60         struct address_space *mapping = root->fs_info->btree_inode->i_mapping;
  61         int blockbits = root->fs_info->sb->s_blocksize_bits;
  62         unsigned long index = blocknr >> (PAGE_CACHE_SHIFT - blockbits);
  63         struct page *page;
  64         struct buffer_head *bh;
  65         struct buffer_head *head;
  66         struct buffer_head *ret = NULL;
  67         u64 first_block = index << (PAGE_CACHE_SHIFT - blockbits);
  68         page = grab_cache_page(mapping, index);
  69         if (!page)
  70                 return NULL;
  71
  72         wait_on_page_writeback(page);
  73         if (!page_has_buffers(page))
  74                 create_empty_buffers(page, root->fs_info->sb->s_blocksize, 0);
  75         head = page_buffers(page);
  76         bh = head;
  77         do {
  78                 if (!buffer_mapped(bh)) {
  79                         bh->b_bdev = root->fs_info->sb->s_bdev;
  80                         bh->b_blocknr = first_block;
  81                         set_buffer_mapped(bh);
  82                 }
  83                 if (bh->b_blocknr == blocknr) {
  84                         ret = bh;
  85                         get_bh(bh);
  86                         goto out_unlock;
  87                 }
  88                 bh = bh->b_this_page;
  89                 first_block++;
  90         } while (bh != head);
  91 out_unlock:
  92         unlock_page(page);
  93         page_cache_release(page);
  94         return ret;
  95 }
  96
  97 static sector_t max_block(struct block_device *bdev)
  98 {
  99         sector_t retval = ~((sector_t)0);
 100         loff_t sz = i_size_read(bdev->bd_inode);
 101
 102         if (sz) {
 103                 unsigned int size = block_size(bdev);
 104                 unsigned int sizebits = blksize_bits(size);
 105                 retval = (sz >> sizebits);
 106         }
 107         return retval;
 108 }
 109
 110 static int btree_get_block(struct inode *inode, sector_t iblock,
 111                            struct buffer_head *bh, int create)
 112 {
 113         if (iblock >= max_block(inode->i_sb->s_bdev)) {
 114                 if (create)
 115                         return -EIO;
 116
 117                 /*
 118                  * for reads, we're just trying to fill a partial page.
 119                  * return a hole, they will have to call get_block again
 120                  * before they can fill it, and they will get -EIO at that
 121                  * time
 122                  */
 123                 return 0;
 124         }
 125         bh->b_bdev = inode->i_sb->s_bdev;
 126         bh->b_blocknr = iblock;
 127         set_buffer_mapped(bh);
 128         return 0;
 129 }
 130
 131 static int csum_tree_block(struct btrfs_root * root, struct buffer_head *bh,
 132                             int verify)
 133 {
 134         struct btrfs_node *node = btrfs_buffer_node(bh);
 135         struct scatterlist sg;
 136         struct crypto_hash *tfm = root->fs_info->hash_tfm;
 137         struct hash_desc desc;
 138         int ret;
 139         char result[32];
 140
 141         desc.tfm = tfm;
 142         desc.flags = 0;
 143         sg_init_one(&sg, bh->b_data + 32, bh->b_size - 32);
 144         spin_lock(&root->fs_info->hash_lock);
 145         ret = crypto_hash_digest(&desc, &sg, bh->b_size - 32, result);
 146         spin_unlock(&root->fs_info->hash_lock);
 147         if (ret) {
 148                 printk("sha256 digest failed\n");
 149         }
 150         if (verify) {
 151                 if (memcmp(node->header.csum, result, sizeof(result)))
 152                         printk("csum verify failed on %Lu\n", bh->b_blocknr);
 153                 return -EINVAL;
 154         } else
 155                 memcpy(node->header.csum, result, sizeof(node->header.csum));
 156         return 0;
 157 }
 158
 159 static int btree_writepage(struct page *page, struct writeback_control *wbc)
 160 {
 161         struct buffer_head *bh;
 162         struct btrfs_root *root = btrfs_sb(page->mapping->host->i_sb);
 163         struct buffer_head *head;
 164
 165         if (!page_has_buffers(page)) {
 166                 create_empty_buffers(page, root->fs_info->sb->s_blocksize,
 167                                         (1 << BH_Dirty)|(1 << BH_Uptodate));
 168         }
 169         head = page_buffers(page);
 170         bh = head;
 171         do {
 172                 if (buffer_dirty(bh))
 173                         csum_tree_block(root, bh, 0);
 174                 bh = bh->b_this_page;
 175         } while (bh != head);
 176         return block_write_full_page(page, btree_get_block, wbc);
 177 }
 178
 179 static int btree_readpage(struct file * file, struct page * page)
 180 {
 181         return block_read_full_page(page, btree_get_block);
 182 }
 183
 184 static struct address_space_operations btree_aops = {
 185         .readpage       = btree_readpage,
 186         .writepage      = btree_writepage,
 187         .sync_page      = block_sync_page,
 188 };
 189
 190 struct buffer_head *read_tree_block(struct btrfs_root *root, u64 blocknr)
 191 {
 192         struct buffer_head *bh = NULL;
 193
 194         bh = btrfs_find_create_tree_block(root, blocknr);
 195         if (!bh)
 196                 return bh;
 197         lock_buffer(bh);
 198         if (!buffer_uptodate(bh)) {
 199                 get_bh(bh);
 200                 bh->b_end_io = end_buffer_read_sync;
 201                 submit_bh(READ, bh);
 202                 wait_on_buffer(bh);
 203                 if (!buffer_uptodate(bh))
 204                         goto fail;
 205                 csum_tree_block(root, bh, 1);
 206         } else {
 207                 unlock_buffer(bh);
 208         }
 209         if (check_tree_block(root, bh))
 210                 BUG();
 211         return bh;
 212 fail:
 213         brelse(bh);
 214         return NULL;
 215
 216 }
 217
 218 int dirty_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
 219                      struct buffer_head *buf)
 220 {
 221         mark_buffer_dirty(buf);
 222         return 0;
 223 }
 224
 225 int clean_tree_block(struct btrfs_trans_handle *trans, struct btrfs_root *root,
 226                      struct buffer_head *buf)
 227 {
 228         clear_buffer_dirty(buf);
 229         return 0;
 230 }
 231
 232 static int __setup_root(struct btrfs_super_block *super,
 233                         struct btrfs_root *root,
 234                         struct btrfs_fs_info *fs_info,
 235                         u64 objectid)
 236 {
 237         root->node = NULL;
 238         root->commit_root = NULL;
 239         root->blocksize = btrfs_super_blocksize(super);
 240         root->ref_cows = 0;
 241         root->fs_info = fs_info;
 242         memset(&root->root_key, 0, sizeof(root->root_key));
 243         memset(&root->root_item, 0, sizeof(root->root_item));
 244         return 0;
 245 }
 246
 247 static int find_and_setup_root(struct btrfs_super_block *super,
 248                                struct btrfs_root *tree_root,
 249                                struct btrfs_fs_info *fs_info,
 250                                u64 objectid,
 251                                struct btrfs_root *root)
 252 {
 253         int ret;
 254
 255         __setup_root(super, root, fs_info, objectid);
 256         ret = btrfs_find_last_root(tree_root, objectid,
 257                                    &root->root_item, &root->root_key);
 258         BUG_ON(ret);
 259
 260         root->node = read_tree_block(root,
 261                                      btrfs_root_blocknr(&root->root_item));
 262         BUG_ON(!root->node);
 263         return 0;
 264 }
 265
 266 struct btrfs_root *open_ctree(struct super_block *sb,
 267                               struct buffer_head *sb_buffer,
 268                               struct btrfs_super_block *disk_super)
 269 {
 270         struct btrfs_root *root = kmalloc(sizeof(struct btrfs_root),
 271                                           GFP_NOFS);
 272         struct btrfs_root *extent_root = kmalloc(sizeof(struct btrfs_root),
 273                                                  GFP_NOFS);
 274         struct btrfs_root *tree_root = kmalloc(sizeof(struct btrfs_root),
 275                                                GFP_NOFS);
 276         struct btrfs_root *inode_root = kmalloc(sizeof(struct btrfs_root),
 277                                                 GFP_NOFS);
 278         struct btrfs_fs_info *fs_info = kmalloc(sizeof(*fs_info),
 279                                                 GFP_NOFS);
 280         int ret;
 281
 282         if (!btrfs_super_root(disk_super)) {
 283                 return NULL;
 284         }
 285         init_bit_radix(&fs_info->pinned_radix);
 286         init_bit_radix(&fs_info->pending_del_radix);
 287         sb_set_blocksize(sb, sb_buffer->b_size);
 288         fs_info->running_transaction = NULL;
 289         fs_info->fs_root = root;
 290         fs_info->tree_root = tree_root;
 291         fs_info->extent_root = extent_root;
 292         fs_info->inode_root = inode_root;
 293         fs_info->last_inode_alloc = 0;
 294         fs_info->last_inode_alloc_dirid = 0;
 295         fs_info->disk_super = disk_super;
 296         fs_info->sb = sb;
 297         fs_info->btree_inode = new_inode(sb);
 298         fs_info->btree_inode->i_ino = 1;
 299         fs_info->btree_inode->i_size = sb->s_bdev->bd_inode->i_size;
 300         fs_info->btree_inode->i_mapping->a_ops = &btree_aops;
 301         mapping_set_gfp_mask(fs_info->btree_inode->i_mapping, GFP_NOFS);
 302         fs_info->hash_tfm = crypto_alloc_hash("sha256", 0, CRYPTO_ALG_ASYNC);
 303         if (!fs_info->hash_tfm) {
 304                 printk("failed to allocate sha256 hash\n");
 305                 return NULL;
 306         }
 307         spin_lock_init(&fs_info->hash_lock);
 308
 309         mutex_init(&fs_info->trans_mutex);
 310         mutex_init(&fs_info->fs_mutex);
 311         memset(&fs_info->current_insert, 0, sizeof(fs_info->current_insert));
 312         memset(&fs_info->last_insert, 0, sizeof(fs_info->last_insert));
 313
 314         __setup_root(disk_super, tree_root, fs_info, BTRFS_ROOT_TREE_OBJECTID);
 315
 316         fs_info->sb_buffer = read_tree_block(tree_root, sb_buffer->b_blocknr);
 317
 318         if (!fs_info->sb_buffer) {
 319 printk("failed2\n");
 320                 return NULL;
 321         }
 322         brelse(sb_buffer);
 323         sb_buffer = NULL;
 324         disk_super = (struct btrfs_super_block *)fs_info->sb_buffer->b_data;
 325         fs_info->disk_super = disk_super;
 326
 327         tree_root->node = read_tree_block(tree_root,
 328                                           btrfs_super_root(disk_super));
 329         BUG_ON(!tree_root->node);
 330
 331         ret = find_and_setup_root(disk_super, tree_root, fs_info,
 332                                   BTRFS_EXTENT_TREE_OBJECTID, extent_root);
 333         BUG_ON(ret);
 334
 335         ret = find_and_setup_root(disk_super, tree_root, fs_info,
 336                                   BTRFS_INODE_MAP_OBJECTID, inode_root);
 337         BUG_ON(ret);
 338
 339         ret = find_and_setup_root(disk_super, tree_root, fs_info,
 340                                   BTRFS_FS_TREE_OBJECTID, root);
 341         BUG_ON(ret);
 342         root->commit_root = root->node;
 343         get_bh(root->node);
 344         root->ref_cows = 1;
 345         root->fs_info->generation = root->root_key.offset + 1;
 346         return root;
 347 }
 348
 349 int write_ctree_super(struct btrfs_trans_handle *trans, struct btrfs_root
 350                       *root)
 351 {
 352         struct buffer_head *bh = root->fs_info->sb_buffer;
 353         btrfs_set_super_root(root->fs_info->disk_super,
 354                              root->fs_info->tree_root->node->b_blocknr);
 355         lock_buffer(bh);
 356         clear_buffer_dirty(bh);
 357         csum_tree_block(root, bh, 0);
 358         bh->b_end_io = end_buffer_write_sync;
 359         get_bh(bh);
 360         submit_bh(WRITE, bh);
 361         wait_on_buffer(bh);
 362         if (!buffer_uptodate(bh)) {
 363                 WARN_ON(1);
 364                 return -EIO;
 365         }
 366         return 0;
 367 }
 368
 369 int close_ctree(struct btrfs_root *root)
 370 {
 371         int ret;
 372         struct btrfs_trans_handle *trans;
 373
 374         trans = btrfs_start_transaction(root, 1);
 375         btrfs_commit_transaction(trans, root);
 376         /* run commit again to  drop the original snapshot */
 377         trans = btrfs_start_transaction(root, 1);
 378         btrfs_commit_transaction(trans, root);
 379         ret = btrfs_write_and_wait_transaction(NULL, root);
 380         BUG_ON(ret);
 381         write_ctree_super(NULL, root);
 382
 383         if (root->node)
 384                 btrfs_block_release(root, root->node);
 385         if (root->fs_info->extent_root->node)
 386                 btrfs_block_release(root->fs_info->extent_root,
 387                                     root->fs_info->extent_root->node);
 388         if (root->fs_info->inode_root->node)
 389                 btrfs_block_release(root->fs_info->inode_root,
 390                                     root->fs_info->inode_root->node);
 391         if (root->fs_info->tree_root->node)
 392                 btrfs_block_release(root->fs_info->tree_root,
 393                                     root->fs_info->tree_root->node);
 394         btrfs_block_release(root, root->commit_root);
 395         btrfs_block_release(root, root->fs_info->sb_buffer);
 396         crypto_free_hash(root->fs_info->hash_tfm);
 397         iput(root->fs_info->btree_inode);
 398         kfree(root->fs_info->extent_root);
 399         kfree(root->fs_info->inode_root);
 400         kfree(root->fs_info->tree_root);
 401         kfree(root->fs_info);
 402         kfree(root);
 403         return 0;
 404 }
 405
 406 void btrfs_block_release(struct btrfs_root *root, struct buffer_head *buf)
 407 {
 408         brelse(buf);
 409 }
 410