git.oblomov.eu Git - linux-2.6/blob - fs/btrfs/file-item.c

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