fs/btrfs/file-item.c

   1 #include <linux/module.h>
   2 #include "ctree.h"
   3 #include "disk-io.h"
   4 #include "transaction.h"
   5
   6 #define MAX_CSUM_ITEMS(r) ((((BTRFS_LEAF_DATA_SIZE(r) - \
   7                                sizeof(struct btrfs_item) * 2) / \
   8                                BTRFS_CRC32_SIZE) - 1))
   9 int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
  10                                struct btrfs_root *root,
  11                                u64 objectid, u64 pos,
  12                                u64 offset, u64 disk_num_blocks,
  13                                u64 num_blocks)
  14 {
  15         int ret = 0;
  16         struct btrfs_file_extent_item *item;
  17         struct btrfs_key file_key;
  18         struct btrfs_path *path;
  19
  20         path = btrfs_alloc_path();
  21         BUG_ON(!path);
  22         btrfs_init_path(path);
  23         file_key.objectid = objectid;
  24         file_key.offset = pos;
  25         file_key.flags = 0;
  26         btrfs_set_key_type(&file_key, BTRFS_EXTENT_DATA_KEY);
  27
  28         ret = btrfs_insert_empty_item(trans, root, path, &file_key,
  29                                       sizeof(*item));
  30         BUG_ON(ret);
  31         item = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]), path->slots[0],
  32                               struct btrfs_file_extent_item);
  33         btrfs_set_file_extent_disk_blocknr(item, offset);
  34         btrfs_set_file_extent_disk_num_blocks(item, disk_num_blocks);
  35         btrfs_set_file_extent_offset(item, 0);
  36         btrfs_set_file_extent_num_blocks(item, num_blocks);
  37         btrfs_set_file_extent_generation(item, trans->transid);
  38         btrfs_set_file_extent_type(item, BTRFS_FILE_EXTENT_REG);
  39         btrfs_mark_buffer_dirty(path->nodes[0]);
  40
  41         btrfs_release_path(root, path);
  42         btrfs_free_path(path);
  43         return 0;
  44 }
  45
  46 struct btrfs_csum_item *btrfs_lookup_csum(struct btrfs_trans_handle *trans,
  47                                           struct btrfs_root *root,
  48                                           struct btrfs_path *path,
  49                                           u64 objectid, u64 offset,
  50                                           int cow)
  51 {
  52         int ret;
  53         struct btrfs_key file_key;
  54         struct btrfs_key found_key;
  55         struct btrfs_csum_item *item;
  56         struct btrfs_leaf *leaf;
  57         u64 csum_offset = 0;
  58         int csums_in_item;
  59
  60         file_key.objectid = objectid;
  61         file_key.offset = offset;
  62         file_key.flags = 0;
  63         btrfs_set_key_type(&file_key, BTRFS_CSUM_ITEM_KEY);
  64         ret = btrfs_search_slot(trans, root, &file_key, path, 0, cow);
  65         if (ret < 0)
  66                 goto fail;
  67         leaf = btrfs_buffer_leaf(path->nodes[0]);
  68         if (ret > 0) {
  69                 ret = 1;
  70                 if (path->slots[0] == 0)
  71                         goto fail;
  72                 path->slots[0]--;
  73                 btrfs_disk_key_to_cpu(&found_key,
  74                                       &leaf->items[path->slots[0]].key);
  75                 if (btrfs_key_type(&found_key) != BTRFS_CSUM_ITEM_KEY ||
  76                     found_key.objectid != objectid) {
  77                         goto fail;
  78                 }
  79                 csum_offset = (offset - found_key.offset) >>
  80                                 root->fs_info->sb->s_blocksize_bits;
  81                 csums_in_item = btrfs_item_size(leaf->items + path->slots[0]);
  82                 csums_in_item /= BTRFS_CRC32_SIZE;
  83
  84                 if (csum_offset >= csums_in_item) {
  85                         ret = -EFBIG;
  86                         goto fail;
  87                 }
  88         }
  89         item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item);
  90         item = (struct btrfs_csum_item *)((unsigned char *)item +
  91                                           csum_offset * BTRFS_CRC32_SIZE);
  92         return item;
  93 fail:
  94         if (ret > 0)
  95                 ret = -ENOENT;
  96         return ERR_PTR(ret);
  97 }
  98
  99
 100 int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans,
 101                              struct btrfs_root *root,
 102                              struct btrfs_path *path, u64 objectid,
 103                              u64 offset, int mod)
 104 {
 105         int ret;
 106         struct btrfs_key file_key;
 107         int ins_len = mod < 0 ? -1 : 0;
 108         int cow = mod != 0;
 109
 110         file_key.objectid = objectid;
 111         file_key.offset = offset;
 112         file_key.flags = 0;
 113         btrfs_set_key_type(&file_key, BTRFS_EXTENT_DATA_KEY);
 114         ret = btrfs_search_slot(trans, root, &file_key, path, ins_len, cow);
 115         return ret;
 116 }
 117
 118 int btrfs_csum_file_block(struct btrfs_trans_handle *trans,
 119                           struct btrfs_root *root,
 120                           u64 objectid, u64 offset,
 121                           char *data, size_t len)
 122 {
 123         int ret;
 124         struct btrfs_key file_key;
 125         struct btrfs_key found_key;
 126         struct btrfs_path *path;
 127         struct btrfs_csum_item *item;
 128         struct btrfs_leaf *leaf;
 129         u64 csum_offset;
 130
 131         path = btrfs_alloc_path();
 132         BUG_ON(!path);
 133
 134         file_key.objectid = objectid;
 135         file_key.offset = offset;
 136         file_key.flags = 0;
 137         btrfs_set_key_type(&file_key, BTRFS_CSUM_ITEM_KEY);
 138
 139         item = btrfs_lookup_csum(trans, root, path, objectid, offset, 1);
 140         if (!IS_ERR(item))
 141                 goto found;
 142         ret = PTR_ERR(item);
 143         if (ret == -EFBIG) {
 144                 u32 item_size;
 145                 /* we found one, but it isn't big enough yet */
 146                 leaf = btrfs_buffer_leaf(path->nodes[0]);
 147                 item_size = btrfs_item_size(leaf->items + path->slots[0]);
 148                 if ((item_size / BTRFS_CRC32_SIZE) >= MAX_CSUM_ITEMS(root)) {
 149                         /* already at max size, make a new one */
 150                         goto insert;
 151                 }
 152         } else {
 153                 /* we didn't find a csum item, insert one */
 154                 goto insert;
 155         }
 156
 157         /*
 158          * at this point, we know the tree has an item, but it isn't big
 159          * enough yet to put our csum in.  Grow it
 160          */
 161         btrfs_release_path(root, path);
 162         ret = btrfs_search_slot(trans, root, &file_key, path,
 163                                 BTRFS_CRC32_SIZE, 1);
 164         if (ret < 0)
 165                 goto fail;
 166         if (ret == 0) {
 167                 BUG();
 168         }
 169         if (path->slots[0] == 0) {
 170                 goto insert;
 171         }
 172         path->slots[0]--;
 173         leaf = btrfs_buffer_leaf(path->nodes[0]);
 174         btrfs_disk_key_to_cpu(&found_key, &leaf->items[path->slots[0]].key);
 175         csum_offset = (offset - found_key.offset) >>
 176                         root->fs_info->sb->s_blocksize_bits;
 177         if (btrfs_key_type(&found_key) != BTRFS_CSUM_ITEM_KEY ||
 178             found_key.objectid != objectid ||
 179             csum_offset >= MAX_CSUM_ITEMS(root)) {
 180                 goto insert;
 181         }
 182         if (csum_offset >= btrfs_item_size(leaf->items + path->slots[0]) /
 183             BTRFS_CRC32_SIZE) {
 184                 u32 diff = (csum_offset + 1) * BTRFS_CRC32_SIZE;
 185                 diff = diff - btrfs_item_size(leaf->items + path->slots[0]);
 186                 if (diff != BTRFS_CRC32_SIZE)
 187                         goto insert;
 188                 ret = btrfs_extend_item(trans, root, path, diff);
 189                 BUG_ON(ret);
 190                 goto csum;
 191         }
 192
 193 insert:
 194         btrfs_release_path(root, path);
 195         csum_offset = 0;
 196         ret = btrfs_insert_empty_item(trans, root, path, &file_key,
 197                                       BTRFS_CRC32_SIZE);
 198         if (ret != 0) {
 199                 printk("at insert for %Lu %u %Lu ret is %d\n", file_key.objectid, file_key.flags, file_key.offset, ret);
 200                 WARN_ON(1);
 201                 goto fail;
 202         }
 203 csum:
 204         item = btrfs_item_ptr(btrfs_buffer_leaf(path->nodes[0]), path->slots[0],
 205                               struct btrfs_csum_item);
 206         ret = 0;
 207         item = (struct btrfs_csum_item *)((unsigned char *)item +
 208                                           csum_offset * BTRFS_CRC32_SIZE);
 209 found:
 210         btrfs_check_bounds(&item->csum, BTRFS_CRC32_SIZE,
 211                            path->nodes[0]->b_data,
 212                            root->fs_info->sb->s_blocksize);
 213         ret = btrfs_csum_data(root, data, len, &item->csum);
 214         btrfs_mark_buffer_dirty(path->nodes[0]);
 215 fail:
 216         btrfs_release_path(root, path);
 217         btrfs_free_path(path);
 218         return ret;
 219 }
 220
 221 int btrfs_csum_verify_file_block(struct btrfs_root *root,
 222                                  u64 objectid, u64 offset,
 223                                  char *data, size_t len)
 224 {
 225         int ret;
 226         struct btrfs_key file_key;
 227         struct btrfs_path *path;
 228         struct btrfs_csum_item *item;
 229         char result[BTRFS_CRC32_SIZE];
 230
 231         path = btrfs_alloc_path();
 232         BUG_ON(!path);
 233         btrfs_init_path(path);
 234         file_key.objectid = objectid;
 235         file_key.offset = offset;
 236         file_key.flags = 0;
 237         btrfs_set_key_type(&file_key, BTRFS_CSUM_ITEM_KEY);
 238         mutex_lock(&root->fs_info->fs_mutex);
 239
 240         item = btrfs_lookup_csum(NULL, root, path, objectid, offset, 0);
 241         if (IS_ERR(item)) {
 242                 ret = PTR_ERR(item);
 243                 /* a csum that isn't present is a preallocated region. */
 244                 if (ret == -ENOENT || ret == -EFBIG)
 245                         ret = -ENOENT;
 246                 goto fail;
 247         }
 248
 249         ret = btrfs_csum_data(root, data, len, result);
 250         WARN_ON(ret);
 251         if (memcmp(result, &item->csum, BTRFS_CRC32_SIZE))
 252                 ret = 1;
 253 fail:
 254         btrfs_release_path(root, path);
 255         btrfs_free_path(path);
 256         mutex_unlock(&root->fs_info->fs_mutex);
 257         return ret;
 258 }
 259