SAFE public projects git trees. - safe/jmp/linux-2.6/blob - fs/btrfs/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 <linux/bio.h>
  20 #include <linux/pagemap.h>
  21 #include <linux/highmem.h>
  22 #include "ctree.h"
  23 #include "disk-io.h"
  24 #include "transaction.h"
  25 #include "print-tree.h"
  26
  27 #define MAX_CSUM_ITEMS(r,size) ((((BTRFS_LEAF_DATA_SIZE(r) - \
  28                                    sizeof(struct btrfs_item) * 2) / \
  29                                   size) - 1))
  30 int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
  31                              struct btrfs_root *root,
  32                              u64 objectid, u64 pos,
  33                              u64 disk_offset, u64 disk_num_bytes,
  34                              u64 num_bytes, u64 offset, u64 ram_bytes,
  35                              u8 compression, u8 encryption, u16 other_encoding)
  36 {
  37         int ret = 0;
  38         struct btrfs_file_extent_item *item;
  39         struct btrfs_key file_key;
  40         struct btrfs_path *path;
  41         struct extent_buffer *leaf;
  42
  43         path = btrfs_alloc_path();
  44         BUG_ON(!path);
  45         file_key.objectid = objectid;
  46         file_key.offset = pos;
  47         btrfs_set_key_type(&file_key, BTRFS_EXTENT_DATA_KEY);
  48
  49         ret = btrfs_insert_empty_item(trans, root, path, &file_key,
  50                                       sizeof(*item));
  51         if (ret < 0)
  52                 goto out;
  53         BUG_ON(ret);
  54         leaf = path->nodes[0];
  55         item = btrfs_item_ptr(leaf, path->slots[0],
  56                               struct btrfs_file_extent_item);
  57         btrfs_set_file_extent_disk_bytenr(leaf, item, disk_offset);
  58         btrfs_set_file_extent_disk_num_bytes(leaf, item, disk_num_bytes);
  59         btrfs_set_file_extent_offset(leaf, item, offset);
  60         btrfs_set_file_extent_num_bytes(leaf, item, num_bytes);
  61         btrfs_set_file_extent_ram_bytes(leaf, item, ram_bytes);
  62         btrfs_set_file_extent_generation(leaf, item, trans->transid);
  63         btrfs_set_file_extent_type(leaf, item, BTRFS_FILE_EXTENT_REG);
  64         btrfs_set_file_extent_compression(leaf, item, compression);
  65         btrfs_set_file_extent_encryption(leaf, item, encryption);
  66         btrfs_set_file_extent_other_encoding(leaf, item, other_encoding);
  67
  68         btrfs_mark_buffer_dirty(leaf);
  69 out:
  70         btrfs_free_path(path);
  71         return ret;
  72 }
  73
  74 struct btrfs_csum_item *btrfs_lookup_csum(struct btrfs_trans_handle *trans,
  75                                           struct btrfs_root *root,
  76                                           struct btrfs_path *path,
  77                                           u64 objectid, u64 offset,
  78                                           int cow)
  79 {
  80         int ret;
  81         struct btrfs_key file_key;
  82         struct btrfs_key found_key;
  83         struct btrfs_csum_item *item;
  84         struct extent_buffer *leaf;
  85         u64 csum_offset = 0;
  86         u16 csum_size =
  87                 btrfs_super_csum_size(&root->fs_info->super_copy);
  88         int csums_in_item;
  89
  90         file_key.objectid = objectid;
  91         file_key.offset = offset;
  92         btrfs_set_key_type(&file_key, BTRFS_CSUM_ITEM_KEY);
  93         ret = btrfs_search_slot(trans, root, &file_key, path, 0, cow);
  94         if (ret < 0)
  95                 goto fail;
  96         leaf = path->nodes[0];
  97         if (ret > 0) {
  98                 ret = 1;
  99                 if (path->slots[0] == 0)
 100                         goto fail;
 101                 path->slots[0]--;
 102                 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
 103                 if (btrfs_key_type(&found_key) != BTRFS_CSUM_ITEM_KEY ||
 104                     found_key.objectid != objectid) {
 105                         goto fail;
 106                 }
 107                 csum_offset = (offset - found_key.offset) >>
 108                                 root->fs_info->sb->s_blocksize_bits;
 109                 csums_in_item = btrfs_item_size_nr(leaf, path->slots[0]);
 110                 csums_in_item /= csum_size;
 111
 112                 if (csum_offset >= csums_in_item) {
 113                         ret = -EFBIG;
 114                         goto fail;
 115                 }
 116         }
 117         item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item);
 118         item = (struct btrfs_csum_item *)((unsigned char *)item +
 119                                           csum_offset * csum_size);
 120         return item;
 121 fail:
 122         if (ret > 0)
 123                 ret = -ENOENT;
 124         return ERR_PTR(ret);
 125 }
 126
 127
 128 int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans,
 129                              struct btrfs_root *root,
 130                              struct btrfs_path *path, u64 objectid,
 131                              u64 offset, int mod)
 132 {
 133         int ret;
 134         struct btrfs_key file_key;
 135         int ins_len = mod < 0 ? -1 : 0;
 136         int cow = mod != 0;
 137
 138         file_key.objectid = objectid;
 139         file_key.offset = offset;
 140         btrfs_set_key_type(&file_key, BTRFS_EXTENT_DATA_KEY);
 141         ret = btrfs_search_slot(trans, root, &file_key, path, ins_len, cow);
 142         return ret;
 143 }
 144
 145 int btrfs_lookup_bio_sums(struct btrfs_root *root, struct inode *inode,
 146                           struct bio *bio)
 147 {
 148         u32 sum;
 149         struct bio_vec *bvec = bio->bi_io_vec;
 150         int bio_index = 0;
 151         u64 offset;
 152         u64 item_start_offset = 0;
 153         u64 item_last_offset = 0;
 154         u32 diff;
 155         u16 csum_size =
 156                 btrfs_super_csum_size(&root->fs_info->super_copy);
 157         int ret;
 158         struct btrfs_path *path;
 159         struct btrfs_csum_item *item = NULL;
 160         struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
 161
 162         path = btrfs_alloc_path();
 163         if (bio->bi_size > PAGE_CACHE_SIZE * 8)
 164                 path->reada = 2;
 165
 166         WARN_ON(bio->bi_vcnt <= 0);
 167
 168         while(bio_index < bio->bi_vcnt) {
 169                 offset = page_offset(bvec->bv_page) + bvec->bv_offset;
 170                 ret = btrfs_find_ordered_sum(inode, offset, &sum);
 171                 if (ret == 0)
 172                         goto found;
 173
 174                 if (!item || offset < item_start_offset ||
 175                     offset >= item_last_offset) {
 176                         struct btrfs_key found_key;
 177                         u32 item_size;
 178
 179                         if (item)
 180                                 btrfs_release_path(root, path);
 181                         item = btrfs_lookup_csum(NULL, root, path,
 182                                                  inode->i_ino, offset, 0);
 183                         if (IS_ERR(item)) {
 184                                 ret = PTR_ERR(item);
 185                                 if (ret == -ENOENT || ret == -EFBIG)
 186                                         ret = 0;
 187                                 sum = 0;
 188                                 printk("no csum found for inode %lu start "
 189                                        "%llu\n", inode->i_ino,
 190                                        (unsigned long long)offset);
 191                                 item = NULL;
 192                                 btrfs_release_path(root, path);
 193                                 goto found;
 194                         }
 195                         btrfs_item_key_to_cpu(path->nodes[0], &found_key,
 196                                               path->slots[0]);
 197
 198                         item_start_offset = found_key.offset;
 199                         item_size = btrfs_item_size_nr(path->nodes[0],
 200                                                        path->slots[0]);
 201                         item_last_offset = item_start_offset +
 202                                 (item_size / csum_size) *
 203                                 root->sectorsize;
 204                         item = btrfs_item_ptr(path->nodes[0], path->slots[0],
 205                                               struct btrfs_csum_item);
 206                 }
 207                 /*
 208                  * this byte range must be able to fit inside
 209                  * a single leaf so it will also fit inside a u32
 210                  */
 211                 diff = offset - item_start_offset;
 212                 diff = diff / root->sectorsize;
 213                 diff = diff * csum_size;
 214
 215                 read_extent_buffer(path->nodes[0], &sum,
 216                                    ((unsigned long)item) + diff,
 217                                    csum_size);
 218 found:
 219                 set_state_private(io_tree, offset, sum);
 220                 bio_index++;
 221                 bvec++;
 222         }
 223         btrfs_free_path(path);
 224         return 0;
 225 }
 226
 227 int btrfs_csum_file_bytes(struct btrfs_root *root, struct inode *inode,
 228                           u64 start, unsigned long len)
 229 {
 230         struct btrfs_ordered_sum *sums;
 231         struct btrfs_sector_sum *sector_sum;
 232         struct btrfs_ordered_extent *ordered;
 233         char *data;
 234         struct page *page;
 235         unsigned long total_bytes = 0;
 236         unsigned long this_sum_bytes = 0;
 237
 238         sums = kzalloc(btrfs_ordered_sum_size(root, len), GFP_NOFS);
 239         if (!sums)
 240                 return -ENOMEM;
 241
 242         sector_sum = sums->sums;
 243         sums->file_offset = start;
 244         sums->len = len;
 245         INIT_LIST_HEAD(&sums->list);
 246         ordered = btrfs_lookup_ordered_extent(inode, sums->file_offset);
 247         BUG_ON(!ordered);
 248
 249         while(len > 0) {
 250                 if (start >= ordered->file_offset + ordered->len ||
 251                     start < ordered->file_offset) {
 252                         sums->len = this_sum_bytes;
 253                         this_sum_bytes = 0;
 254                         btrfs_add_ordered_sum(inode, ordered, sums);
 255                         btrfs_put_ordered_extent(ordered);
 256
 257                         sums = kzalloc(btrfs_ordered_sum_size(root, len),
 258                                        GFP_NOFS);
 259                         BUG_ON(!sums);
 260                         sector_sum = sums->sums;
 261                         sums->len = len;
 262                         sums->file_offset = start;
 263                         ordered = btrfs_lookup_ordered_extent(inode,
 264                                                       sums->file_offset);
 265                         BUG_ON(!ordered);
 266                 }
 267
 268                 page = find_get_page(inode->i_mapping,
 269                                      start >> PAGE_CACHE_SHIFT);
 270
 271                 data = kmap_atomic(page, KM_USER0);
 272                 sector_sum->sum = ~(u32)0;
 273                 sector_sum->sum = btrfs_csum_data(root, data, sector_sum->sum,
 274                                                   PAGE_CACHE_SIZE);
 275                 kunmap_atomic(data, KM_USER0);
 276                 btrfs_csum_final(sector_sum->sum,
 277                                  (char *)&sector_sum->sum);
 278                 sector_sum->offset = page_offset(page);
 279                 page_cache_release(page);
 280
 281                 sector_sum++;
 282                 total_bytes += PAGE_CACHE_SIZE;
 283                 this_sum_bytes += PAGE_CACHE_SIZE;
 284                 start += PAGE_CACHE_SIZE;
 285
 286                 WARN_ON(len < PAGE_CACHE_SIZE);
 287                 len -= PAGE_CACHE_SIZE;
 288         }
 289         btrfs_add_ordered_sum(inode, ordered, sums);
 290         btrfs_put_ordered_extent(ordered);
 291         return 0;
 292 }
 293
 294 int btrfs_csum_one_bio(struct btrfs_root *root, struct inode *inode,
 295                        struct bio *bio)
 296 {
 297         struct btrfs_ordered_sum *sums;
 298         struct btrfs_sector_sum *sector_sum;
 299         struct btrfs_ordered_extent *ordered;
 300         char *data;
 301         struct bio_vec *bvec = bio->bi_io_vec;
 302         int bio_index = 0;
 303         unsigned long total_bytes = 0;
 304         unsigned long this_sum_bytes = 0;
 305         u64 offset;
 306
 307         WARN_ON(bio->bi_vcnt <= 0);
 308         sums = kzalloc(btrfs_ordered_sum_size(root, bio->bi_size), GFP_NOFS);
 309         if (!sums)
 310                 return -ENOMEM;
 311
 312         sector_sum = sums->sums;
 313         sums->file_offset = page_offset(bvec->bv_page) + bvec->bv_offset;
 314         sums->len = bio->bi_size;
 315         INIT_LIST_HEAD(&sums->list);
 316         ordered = btrfs_lookup_ordered_extent(inode, sums->file_offset);
 317         BUG_ON(!ordered);
 318
 319         while(bio_index < bio->bi_vcnt) {
 320                 offset = page_offset(bvec->bv_page) + bvec->bv_offset;
 321                 if (offset >= ordered->file_offset + ordered->len ||
 322                     offset < ordered->file_offset) {
 323                         unsigned long bytes_left;
 324                         sums->len = this_sum_bytes;
 325                         this_sum_bytes = 0;
 326                         btrfs_add_ordered_sum(inode, ordered, sums);
 327                         btrfs_put_ordered_extent(ordered);
 328
 329                         bytes_left = bio->bi_size - total_bytes;
 330
 331                         sums = kzalloc(btrfs_ordered_sum_size(root, bytes_left),
 332                                        GFP_NOFS);
 333                         BUG_ON(!sums);
 334                         sector_sum = sums->sums;
 335                         sums->len = bytes_left;
 336                         sums->file_offset = offset;
 337                         ordered = btrfs_lookup_ordered_extent(inode,
 338                                                       sums->file_offset);
 339                         BUG_ON(!ordered);
 340                 }
 341
 342                 data = kmap_atomic(bvec->bv_page, KM_USER0);
 343                 sector_sum->sum = ~(u32)0;
 344                 sector_sum->sum = btrfs_csum_data(root,
 345                                                   data + bvec->bv_offset,
 346                                                   sector_sum->sum,
 347                                                   bvec->bv_len);
 348                 kunmap_atomic(data, KM_USER0);
 349                 btrfs_csum_final(sector_sum->sum,
 350                                  (char *)&sector_sum->sum);
 351                 sector_sum->offset = page_offset(bvec->bv_page) +
 352                         bvec->bv_offset;
 353
 354                 sector_sum++;
 355                 bio_index++;
 356                 total_bytes += bvec->bv_len;
 357                 this_sum_bytes += bvec->bv_len;
 358                 bvec++;
 359         }
 360         this_sum_bytes = 0;
 361         btrfs_add_ordered_sum(inode, ordered, sums);
 362         btrfs_put_ordered_extent(ordered);
 363         return 0;
 364 }
 365
 366 int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,
 367                            struct btrfs_root *root, struct inode *inode,
 368                            struct btrfs_ordered_sum *sums)
 369 {
 370         u64 objectid = inode->i_ino;
 371         u64 offset;
 372         int ret;
 373         struct btrfs_key file_key;
 374         struct btrfs_key found_key;
 375         u64 next_offset;
 376         u64 total_bytes = 0;
 377         int found_next;
 378         struct btrfs_path *path;
 379         struct btrfs_csum_item *item;
 380         struct btrfs_csum_item *item_end;
 381         struct extent_buffer *leaf = NULL;
 382         u64 csum_offset;
 383         struct btrfs_sector_sum *sector_sum;
 384         u32 nritems;
 385         u32 ins_size;
 386         char *eb_map;
 387         char *eb_token;
 388         unsigned long map_len;
 389         unsigned long map_start;
 390         u16 csum_size =
 391                 btrfs_super_csum_size(&root->fs_info->super_copy);
 392
 393         path = btrfs_alloc_path();
 394         BUG_ON(!path);
 395         sector_sum = sums->sums;
 396 again:
 397         next_offset = (u64)-1;
 398         found_next = 0;
 399         offset = sector_sum->offset;
 400         file_key.objectid = objectid;
 401         file_key.offset = offset;
 402         btrfs_set_key_type(&file_key, BTRFS_CSUM_ITEM_KEY);
 403
 404         mutex_lock(&BTRFS_I(inode)->csum_mutex);
 405         item = btrfs_lookup_csum(trans, root, path, objectid, offset, 1);
 406         if (!IS_ERR(item)) {
 407                 leaf = path->nodes[0];
 408                 ret = 0;
 409                 goto found;
 410         }
 411         ret = PTR_ERR(item);
 412         if (ret == -EFBIG) {
 413                 u32 item_size;
 414                 /* we found one, but it isn't big enough yet */
 415                 leaf = path->nodes[0];
 416                 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
 417                 if ((item_size / csum_size) >=
 418                     MAX_CSUM_ITEMS(root, csum_size)) {
 419                         /* already at max size, make a new one */
 420                         goto insert;
 421                 }
 422         } else {
 423                 int slot = path->slots[0] + 1;
 424                 /* we didn't find a csum item, insert one */
 425                 nritems = btrfs_header_nritems(path->nodes[0]);
 426                 if (path->slots[0] >= nritems - 1) {
 427                         ret = btrfs_next_leaf(root, path);
 428                         if (ret == 1)
 429                                 found_next = 1;
 430                         if (ret != 0)
 431                                 goto insert;
 432                         slot = 0;
 433                 }
 434                 btrfs_item_key_to_cpu(path->nodes[0], &found_key, slot);
 435                 if (found_key.objectid != objectid ||
 436                     found_key.type != BTRFS_CSUM_ITEM_KEY) {
 437                         found_next = 1;
 438                         goto insert;
 439                 }
 440                 next_offset = found_key.offset;
 441                 found_next = 1;
 442                 goto insert;
 443         }
 444
 445         /*
 446          * at this point, we know the tree has an item, but it isn't big
 447          * enough yet to put our csum in.  Grow it
 448          */
 449         btrfs_release_path(root, path);
 450         ret = btrfs_search_slot(trans, root, &file_key, path,
 451                                 csum_size, 1);
 452         if (ret < 0)
 453                 goto fail_unlock;
 454         if (ret == 0) {
 455                 BUG();
 456         }
 457         if (path->slots[0] == 0) {
 458                 goto insert;
 459         }
 460         path->slots[0]--;
 461         leaf = path->nodes[0];
 462         btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
 463         csum_offset = (offset - found_key.offset) >>
 464                         root->fs_info->sb->s_blocksize_bits;
 465         if (btrfs_key_type(&found_key) != BTRFS_CSUM_ITEM_KEY ||
 466             found_key.objectid != objectid ||
 467             csum_offset >= MAX_CSUM_ITEMS(root, csum_size)) {
 468                 goto insert;
 469         }
 470         if (csum_offset >= btrfs_item_size_nr(leaf, path->slots[0]) /
 471             csum_size) {
 472                 u32 diff = (csum_offset + 1) * csum_size;
 473                 diff = diff - btrfs_item_size_nr(leaf, path->slots[0]);
 474                 if (diff != csum_size)
 475                         goto insert;
 476                 ret = btrfs_extend_item(trans, root, path, diff);
 477                 BUG_ON(ret);
 478                 goto csum;
 479         }
 480
 481 insert:
 482         btrfs_release_path(root, path);
 483         csum_offset = 0;
 484         if (found_next) {
 485                 u64 tmp = min((u64)i_size_read(inode), next_offset);
 486                 tmp -= offset & ~((u64)root->sectorsize -1);
 487                 tmp >>= root->fs_info->sb->s_blocksize_bits;
 488                 tmp = max((u64)1, tmp);
 489                 tmp = min(tmp, (u64)MAX_CSUM_ITEMS(root, csum_size));
 490                 ins_size = csum_size * tmp;
 491         } else {
 492                 ins_size = csum_size;
 493         }
 494         ret = btrfs_insert_empty_item(trans, root, path, &file_key,
 495                                       ins_size);
 496         if (ret < 0)
 497                 goto fail_unlock;
 498         if (ret != 0) {
 499                 WARN_ON(1);
 500                 goto fail_unlock;
 501         }
 502 csum:
 503         leaf = path->nodes[0];
 504         item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item);
 505         ret = 0;
 506         item = (struct btrfs_csum_item *)((unsigned char *)item +
 507                                           csum_offset * csum_size);
 508 found:
 509         item_end = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item);
 510         item_end = (struct btrfs_csum_item *)((unsigned char *)item_end +
 511                                       btrfs_item_size_nr(leaf, path->slots[0]));
 512         eb_token = NULL;
 513         mutex_unlock(&BTRFS_I(inode)->csum_mutex);
 514         cond_resched();
 515 next_sector:
 516
 517         if (!eb_token ||
 518            (unsigned long)item + csum_size >= map_start + map_len) {
 519                 int err;
 520
 521                 if (eb_token)
 522                         unmap_extent_buffer(leaf, eb_token, KM_USER1);
 523                 eb_token = NULL;
 524                 err = map_private_extent_buffer(leaf, (unsigned long)item,
 525                                                 csum_size,
 526                                                 &eb_token, &eb_map,
 527                                                 &map_start, &map_len, KM_USER1);
 528                 if (err)
 529                         eb_token = NULL;
 530         }
 531         if (eb_token) {
 532                 memcpy(eb_token + ((unsigned long)item & (PAGE_CACHE_SIZE - 1)),
 533                        &sector_sum->sum, csum_size);
 534         } else {
 535                 write_extent_buffer(leaf, &sector_sum->sum,
 536                                     (unsigned long)item, csum_size);
 537         }
 538
 539         total_bytes += root->sectorsize;
 540         sector_sum++;
 541         if (total_bytes < sums->len) {
 542                 item = (struct btrfs_csum_item *)((char *)item +
 543                                                   csum_size);
 544                 if (item < item_end && offset + PAGE_CACHE_SIZE ==
 545                     sector_sum->offset) {
 546                             offset = sector_sum->offset;
 547                         goto next_sector;
 548                 }
 549         }
 550         if (eb_token) {
 551                 unmap_extent_buffer(leaf, eb_token, KM_USER1);
 552                 eb_token = NULL;
 553         }
 554         btrfs_mark_buffer_dirty(path->nodes[0]);
 555         cond_resched();
 556         if (total_bytes < sums->len) {
 557                 btrfs_release_path(root, path);
 558                 goto again;
 559         }
 560 out:
 561         btrfs_free_path(path);
 562         return ret;
 563
 564 fail_unlock:
 565         mutex_unlock(&BTRFS_I(inode)->csum_mutex);
 566         goto out;
 567 }
 568
 569 int btrfs_csum_truncate(struct btrfs_trans_handle *trans,
 570                         struct btrfs_root *root, struct btrfs_path *path,
 571                         u64 isize)
 572 {
 573         struct btrfs_key key;
 574         struct extent_buffer *leaf = path->nodes[0];
 575         int slot = path->slots[0];
 576         int ret;
 577         u32 new_item_size;
 578         u64 new_item_span;
 579         u64 blocks;
 580
 581         btrfs_item_key_to_cpu(leaf, &key, slot);
 582         if (isize <= key.offset)
 583                 return 0;
 584         new_item_span = isize - key.offset;
 585         blocks = (new_item_span + root->sectorsize - 1) >>
 586                 root->fs_info->sb->s_blocksize_bits;
 587         new_item_size = blocks *
 588                 btrfs_super_csum_size(&root->fs_info->super_copy);
 589         if (new_item_size >= btrfs_item_size_nr(leaf, slot))
 590                 return 0;
 591         ret = btrfs_truncate_item(trans, root, path, new_item_size, 1);
 592         BUG_ON(ret);
 593         return ret;
 594 }