file-item.c

   1 /*
   2  * Copyright (C) 2007 Oracle.  All rights reserved.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public
   6  * License v2 as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11  * General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public
  14  * License along with this program; if not, write to the
  15  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  16  * Boston, MA 021110-1307, USA.
  17  */
  18
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include "kerncompat.h"
  22 #include "radix-tree.h"
  23 #include "ctree.h"
  24 #include "disk-io.h"
  25 #include "transaction.h"
  26 #include "print-tree.h"
  27 #include "crc32c.h"
  28
  29 #define MAX_CSUM_ITEMS(r,size) ((((BTRFS_LEAF_DATA_SIZE(r) - \
  30                                sizeof(struct btrfs_item) * 2) / \
  31                                size) - 1))
  32 int btrfs_create_file(struct btrfs_trans_handle *trans,
  33                       struct btrfs_root *root, u64 dirid, u64 *objectid)
  34 {
  35         return 0;
  36 }
  37
  38 int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
  39                              struct btrfs_root *root,
  40                              u64 objectid, u64 pos, u64 offset,
  41                              u64 disk_num_bytes, u64 num_bytes)
  42 {
  43         int ret = 0;
  44         struct btrfs_file_extent_item *item;
  45         struct btrfs_key file_key;
  46         struct btrfs_path *path;
  47         struct extent_buffer *leaf;
  48
  49         path = btrfs_alloc_path();
  50         BUG_ON(!path);
  51         file_key.objectid = objectid;
  52         file_key.offset = pos;
  53         btrfs_set_key_type(&file_key, BTRFS_EXTENT_DATA_KEY);
  54
  55         ret = btrfs_insert_empty_item(trans, root, path, &file_key,
  56                                       sizeof(*item));
  57         if (ret < 0)
  58                 goto out;
  59         BUG_ON(ret);
  60         leaf = path->nodes[0];
  61         item = btrfs_item_ptr(leaf, path->slots[0],
  62                               struct btrfs_file_extent_item);
  63         btrfs_set_file_extent_disk_bytenr(leaf, item, offset);
  64         btrfs_set_file_extent_disk_num_bytes(leaf, item, disk_num_bytes);
  65         btrfs_set_file_extent_offset(leaf, item, 0);
  66         btrfs_set_file_extent_num_bytes(leaf, item, num_bytes);
  67         btrfs_set_file_extent_generation(leaf, item, trans->transid);
  68         btrfs_set_file_extent_type(leaf, item, BTRFS_FILE_EXTENT_REG);
  69         btrfs_mark_buffer_dirty(leaf);
  70 out:
  71         btrfs_free_path(path);
  72         return ret;
  73 }
  74
  75 int btrfs_insert_inline_extent(struct btrfs_trans_handle *trans,
  76                                struct btrfs_root *root, u64 objectid,
  77                                u64 offset, char *buffer, size_t size)
  78 {
  79         struct btrfs_key key;
  80         struct btrfs_path *path;
  81         struct extent_buffer *leaf;
  82         unsigned long ptr;
  83         struct btrfs_file_extent_item *ei;
  84         u32 datasize;
  85         int err = 0;
  86         int ret;
  87
  88         path = btrfs_alloc_path();
  89         if (!path)
  90                 return -ENOMEM;
  91
  92         key.objectid = objectid;
  93         key.offset = offset;
  94         btrfs_set_key_type(&key, BTRFS_EXTENT_DATA_KEY);
  95
  96         ret = btrfs_search_slot(trans, root, &key, path, 0, 1);
  97         if (ret < 0) {
  98                 err = ret;
  99                 goto fail;
 100         }
 101         if (ret == 1) {
 102                 struct btrfs_key found_key;
 103
 104                 if (path->slots[0] == 0)
 105                         goto insert;
 106
 107                 path->slots[0]--;
 108                 leaf = path->nodes[0];
 109                 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
 110
 111                 if (found_key.objectid != objectid)
 112                         goto insert;
 113
 114                 if (found_key.type != BTRFS_EXTENT_DATA_KEY)
 115                         goto insert;
 116                 ei = btrfs_item_ptr(leaf, path->slots[0],
 117                                     struct btrfs_file_extent_item);
 118
 119                 if (btrfs_file_extent_type(leaf, ei) !=
 120                     BTRFS_FILE_EXTENT_INLINE) {
 121                         goto insert;
 122                 }
 123                 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
 124                 ret = 0;
 125         }
 126         if (ret == 0) {
 127                 u32 found_size;
 128                 u64 found_end;
 129
 130                 leaf = path->nodes[0];
 131                 ei = btrfs_item_ptr(leaf, path->slots[0],
 132                                     struct btrfs_file_extent_item);
 133
 134                 if (btrfs_file_extent_type(leaf, ei) !=
 135                     BTRFS_FILE_EXTENT_INLINE) {
 136                         err = ret;
 137                         btrfs_print_leaf(root, leaf);
 138                         printk("found wasn't inline offset %llu inode %llu\n",
 139                                (unsigned long long)offset,
 140                                (unsigned long long)objectid);
 141                         goto fail;
 142                 }
 143                 found_size = btrfs_file_extent_inline_len(leaf, ei);
 144                 found_end = key.offset + found_size;
 145
 146                 if (found_end < offset + size) {
 147                         btrfs_release_path(root, path);
 148                         ret = btrfs_search_slot(trans, root, &key, path,
 149                                                 offset + size - found_end, 1);
 150                         BUG_ON(ret != 0);
 151
 152                         ret = btrfs_extend_item(trans, root, path,
 153                                                 offset + size - found_end);
 154                         if (ret) {
 155                                 err = ret;
 156                                 goto fail;
 157                         }
 158                         leaf = path->nodes[0];
 159                         ei = btrfs_item_ptr(leaf, path->slots[0],
 160                                             struct btrfs_file_extent_item);
 161                 }
 162                 if (found_end < offset) {
 163                         ptr = btrfs_file_extent_inline_start(ei) + found_size;
 164                         memset_extent_buffer(leaf, 0, ptr, offset - found_end);
 165                 }
 166         } else {
 167 insert:
 168                 btrfs_release_path(root, path);
 169                 datasize = offset + size - key.offset;
 170                 datasize = btrfs_file_extent_calc_inline_size(datasize);
 171                 ret = btrfs_insert_empty_item(trans, root, path, &key,
 172                                               datasize);
 173                 if (ret) {
 174                         err = ret;
 175                         printk("got bad ret %d\n", ret);
 176                         goto fail;
 177                 }
 178                 leaf = path->nodes[0];
 179                 ei = btrfs_item_ptr(leaf, path->slots[0],
 180                                     struct btrfs_file_extent_item);
 181                 btrfs_set_file_extent_generation(leaf, ei, trans->transid);
 182                 btrfs_set_file_extent_type(leaf, ei, BTRFS_FILE_EXTENT_INLINE);
 183         }
 184         ptr = btrfs_file_extent_inline_start(ei) + offset - key.offset;
 185         write_extent_buffer(leaf, buffer, ptr, size);
 186         btrfs_mark_buffer_dirty(leaf);
 187 fail:
 188         btrfs_free_path(path);
 189         return err;
 190 }
 191
 192 struct btrfs_csum_item *btrfs_lookup_csum(struct btrfs_trans_handle *trans,
 193                                           struct btrfs_root *root,
 194                                           struct btrfs_path *path,
 195                                           u64 objectid, u64 offset, int cow)
 196 {
 197         int ret;
 198         struct btrfs_key file_key;
 199         struct btrfs_key found_key;
 200         struct btrfs_csum_item *item;
 201         struct extent_buffer *leaf;
 202         u64 csum_offset = 0;
 203         int csums_in_item;
 204         u16 csum_size =
 205                 btrfs_super_csum_size(&root->fs_info->super_copy);
 206
 207         file_key.objectid = objectid;
 208         file_key.offset = offset;
 209         btrfs_set_key_type(&file_key, BTRFS_CSUM_ITEM_KEY);
 210         ret = btrfs_search_slot(trans, root, &file_key, path, 0, cow);
 211         if (ret < 0)
 212                 goto fail;
 213         leaf = path->nodes[0];
 214         if (ret > 0) {
 215                 ret = 1;
 216                 if (path->slots[0] == 0)
 217                         goto fail;
 218                 path->slots[0]--;
 219                 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
 220                 if (btrfs_key_type(&found_key) != BTRFS_CSUM_ITEM_KEY ||
 221                     found_key.objectid != objectid) {
 222                         goto fail;
 223                 }
 224                 csum_offset = (offset - found_key.offset) >> root->sectorsize;
 225                 csums_in_item = btrfs_item_size_nr(leaf, path->slots[0]);
 226                 csums_in_item /= csum_size;
 227
 228                 if (csum_offset >= csums_in_item) {
 229                         ret = -EFBIG;
 230                         goto fail;
 231                 }
 232         }
 233         item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item);
 234         item = (struct btrfs_csum_item *)((unsigned char *)item +
 235                                           csum_offset * csum_size);
 236         return item;
 237 fail:
 238         if (ret > 0)
 239                 ret = -ENOENT;
 240         return ERR_PTR(ret);
 241 }
 242
 243
 244 int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans,
 245                              struct btrfs_root *root,
 246                              struct btrfs_path *path, u64 objectid,
 247                              u64 offset, int mod)
 248 {
 249         int ret;
 250         struct btrfs_key file_key;
 251         int ins_len = mod < 0 ? -1 : 0;
 252         int cow = mod != 0;
 253
 254         file_key.objectid = objectid;
 255         file_key.offset = offset;
 256         btrfs_set_key_type(&file_key, BTRFS_EXTENT_DATA_KEY);
 257         ret = btrfs_search_slot(trans, root, &file_key, path, ins_len, cow);
 258         return ret;
 259 }
 260
 261 int btrfs_csum_file_block(struct btrfs_trans_handle *trans,
 262                           struct btrfs_root *root,
 263                           struct btrfs_inode_item *inode,
 264                           u64 objectid, u64 offset,
 265                           char *data, size_t len)
 266 {
 267         int ret;
 268         struct btrfs_key file_key;
 269         struct btrfs_key found_key;
 270         u64 next_offset = (u64)-1;
 271         int found_next = 0;
 272         struct btrfs_path *path;
 273         struct btrfs_csum_item *item;
 274         struct extent_buffer *leaf = NULL;
 275         u64 csum_offset;
 276         u32 csum_result = ~(u32)0;
 277         u32 nritems;
 278         u32 ins_size;
 279         u16 csum_size =
 280                 btrfs_super_csum_size(&root->fs_info->super_copy);
 281
 282         path = btrfs_alloc_path();
 283         BUG_ON(!path);
 284
 285         file_key.objectid = objectid;
 286         file_key.offset = offset;
 287         btrfs_set_key_type(&file_key, BTRFS_CSUM_ITEM_KEY);
 288
 289         item = btrfs_lookup_csum(trans, root, path, objectid, offset, 1);
 290         if (!IS_ERR(item)) {
 291                 leaf = path->nodes[0];
 292                 goto found;
 293         }
 294         ret = PTR_ERR(item);
 295         if (ret == -EFBIG) {
 296                 u32 item_size;
 297                 /* we found one, but it isn't big enough yet */
 298                 leaf = path->nodes[0];
 299                 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
 300                 if ((item_size / csum_size) >= MAX_CSUM_ITEMS(root, csum_size)) {
 301                         /* already at max size, make a new one */
 302                         goto insert;
 303                 }
 304         } else {
 305                 int slot = path->slots[0] + 1;
 306                 /* we didn't find a csum item, insert one */
 307                 nritems = btrfs_header_nritems(path->nodes[0]);
 308                 if (path->slots[0] >= nritems - 1) {
 309                         ret = btrfs_next_leaf(root, path);
 310                         if (ret == 1)
 311                                 found_next = 1;
 312                         if (ret != 0)
 313                                 goto insert;
 314                         slot = 0;
 315                 }
 316                 btrfs_item_key_to_cpu(path->nodes[0], &found_key, slot);
 317                 if (found_key.objectid != objectid ||
 318                     found_key.type != BTRFS_CSUM_ITEM_KEY) {
 319                         found_next = 1;
 320                         goto insert;
 321                 }
 322                 next_offset = found_key.offset;
 323                 found_next = 1;
 324                 goto insert;
 325         }
 326
 327         /*
 328          * at this point, we know the tree has an item, but it isn't big
 329          * enough yet to put our csum in.  Grow it
 330          */
 331         btrfs_release_path(root, path);
 332         ret = btrfs_search_slot(trans, root, &file_key, path,
 333                                 csum_size, 1);
 334         if (ret < 0)
 335                 goto fail;
 336         if (ret == 0) {
 337                 BUG();
 338         }
 339         if (path->slots[0] == 0) {
 340                 goto insert;
 341         }
 342         path->slots[0]--;
 343         leaf = path->nodes[0];
 344         btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
 345         csum_offset = (offset - found_key.offset) / root->sectorsize;
 346         if (btrfs_key_type(&found_key) != BTRFS_CSUM_ITEM_KEY ||
 347             found_key.objectid != objectid ||
 348             csum_offset >= MAX_CSUM_ITEMS(root, csum_size)) {
 349                 goto insert;
 350         }
 351         if (csum_offset >= btrfs_item_size_nr(leaf, path->slots[0]) /
 352             csum_size) {
 353                 u32 diff = (csum_offset + 1) * csum_size;
 354                 diff = diff - btrfs_item_size_nr(leaf, path->slots[0]);
 355                 if (diff != csum_size)
 356                         goto insert;
 357                 ret = btrfs_extend_item(trans, root, path, diff);
 358                 BUG_ON(ret);
 359                 goto csum;
 360         }
 361
 362 insert:
 363         btrfs_release_path(root, path);
 364         csum_offset = 0;
 365         if (found_next) {
 366                 u64 tmp = min(btrfs_stack_inode_size(inode), next_offset);
 367                 tmp -= offset & ~((u64)root->sectorsize -1);
 368                 tmp /= root->sectorsize;
 369                 tmp = max((u64)1, tmp);
 370                 tmp = min(tmp, (u64)MAX_CSUM_ITEMS(root, csum_size));
 371                 ins_size = csum_size * tmp;
 372         } else {
 373                 ins_size = csum_size;
 374         }
 375         ret = btrfs_insert_empty_item(trans, root, path, &file_key,
 376                                       ins_size);
 377         if (ret < 0)
 378                 goto fail;
 379         if (ret != 0) {
 380                 WARN_ON(1);
 381                 goto fail;
 382         }
 383 csum:
 384         leaf = path->nodes[0];
 385         item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item);
 386         ret = 0;
 387         item = (struct btrfs_csum_item *)((unsigned char *)item +
 388                                           csum_offset * csum_size);
 389 found:
 390         csum_result = btrfs_csum_data(root, data, csum_result, len);
 391         btrfs_csum_final(csum_result, (char *)&csum_result);
 392         if (csum_result == 0) {
 393                 printk("csum result is 0 for inode %llu offset %llu\n",
 394                        (unsigned long long)objectid,
 395                        (unsigned long long)offset);
 396         }
 397
 398         write_extent_buffer(leaf, &csum_result, (unsigned long)item,
 399                             csum_size);
 400         btrfs_mark_buffer_dirty(path->nodes[0]);
 401 fail:
 402         btrfs_release_path(root, path);
 403         btrfs_free_path(path);
 404         return ret;
 405 }
 406
 407 int btrfs_csum_truncate(struct btrfs_trans_handle *trans,
 408                         struct btrfs_root *root, struct btrfs_path *path,
 409                         u64 isize)
 410 {
 411         struct btrfs_key key;
 412         struct extent_buffer *leaf = path->nodes[0];
 413         int slot = path->slots[0];
 414         int ret;
 415         u32 new_item_size;
 416         u64 new_item_span;
 417         u64 blocks;
 418
 419         btrfs_item_key_to_cpu(leaf, &key, slot);
 420         if (isize <= key.offset)
 421                 return 0;
 422         new_item_span = isize - key.offset;
 423         blocks = (new_item_span + root->sectorsize - 1) / root->sectorsize;
 424         new_item_size = blocks *
 425                btrfs_super_csum_size(&root->fs_info->super_copy);
 426         if (new_item_size >= btrfs_item_size_nr(leaf, slot))
 427                 return 0;
 428         ret = btrfs_truncate_item(trans, root, path, new_item_size, 1);
 429         BUG_ON(ret);
 430         return ret;
 431 }