fs/btrfs/file-item.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) 2007 Oracle.  All rights reserved.
   4  */
   5
   6 #include <linux/bio.h>
   7 #include <linux/slab.h>
   8 #include <linux/pagemap.h>
   9 #include <linux/highmem.h>
  10 #include <linux/sched/mm.h>
  11 #include <crypto/hash.h>
  12 #include "messages.h"
  13 #include "misc.h"
  14 #include "ctree.h"
  15 #include "disk-io.h"
  16 #include "transaction.h"
  17 #include "bio.h"
  18 #include "print-tree.h"
  19 #include "compression.h"
  20 #include "fs.h"
  21 #include "accessors.h"
  22 #include "file-item.h"
  23 #include "super.h"
  24
  25 #define __MAX_CSUM_ITEMS(r, size) ((unsigned long)(((BTRFS_LEAF_DATA_SIZE(r) - \
  26                                    sizeof(struct btrfs_item) * 2) / \
  27                                   size) - 1))
  28
  29 #define MAX_CSUM_ITEMS(r, size) (min_t(u32, __MAX_CSUM_ITEMS(r, size), \
  30                                        PAGE_SIZE))
  31
  32 /*
  33  * Set inode's size according to filesystem options.
  34  *
  35  * @inode:      inode we want to update the disk_i_size for
  36  * @new_i_size: i_size we want to set to, 0 if we use i_size
  37  *
  38  * With NO_HOLES set this simply sets the disk_is_size to whatever i_size_read()
  39  * returns as it is perfectly fine with a file that has holes without hole file
  40  * extent items.
  41  *
  42  * However without NO_HOLES we need to only return the area that is contiguous
  43  * from the 0 offset of the file.  Otherwise we could end up adjust i_size up
  44  * to an extent that has a gap in between.
  45  *
  46  * Finally new_i_size should only be set in the case of truncate where we're not
  47  * ready to use i_size_read() as the limiter yet.
  48  */
  49 void btrfs_inode_safe_disk_i_size_write(struct btrfs_inode *inode, u64 new_i_size)
  50 {
  51         struct btrfs_fs_info *fs_info = inode->root->fs_info;
  52         u64 start, end, i_size;
  53         int ret;
  54
  55         spin_lock(&inode->lock);
  56         i_size = new_i_size ?: i_size_read(&inode->vfs_inode);
  57         if (btrfs_fs_incompat(fs_info, NO_HOLES)) {
  58                 inode->disk_i_size = i_size;
  59                 goto out_unlock;
  60         }
  61
  62         ret = find_contiguous_extent_bit(&inode->file_extent_tree, 0, &start,
  63                                          &end, EXTENT_DIRTY);
  64         if (!ret && start == 0)
  65                 i_size = min(i_size, end + 1);
  66         else
  67                 i_size = 0;
  68         inode->disk_i_size = i_size;
  69 out_unlock:
  70         spin_unlock(&inode->lock);
  71 }
  72
  73 /*
  74  * Mark range within a file as having a new extent inserted.
  75  *
  76  * @inode: inode being modified
  77  * @start: start file offset of the file extent we've inserted
  78  * @len:   logical length of the file extent item
  79  *
  80  * Call when we are inserting a new file extent where there was none before.
  81  * Does not need to call this in the case where we're replacing an existing file
  82  * extent, however if not sure it's fine to call this multiple times.
  83  *
  84  * The start and len must match the file extent item, so thus must be sectorsize
  85  * aligned.
  86  */
  87 int btrfs_inode_set_file_extent_range(struct btrfs_inode *inode, u64 start,
  88                                       u64 len)
  89 {
  90         if (len == 0)
  91                 return 0;
  92
  93         ASSERT(IS_ALIGNED(start + len, inode->root->fs_info->sectorsize));
  94
  95         if (btrfs_fs_incompat(inode->root->fs_info, NO_HOLES))
  96                 return 0;
  97         return set_extent_bits(&inode->file_extent_tree, start, start + len - 1,
  98                                EXTENT_DIRTY);
  99 }
 100
 101 /*
 102  * Mark an inode range as not having a backing extent.
 103  *
 104  * @inode: inode being modified
 105  * @start: start file offset of the file extent we've inserted
 106  * @len:   logical length of the file extent item
 107  *
 108  * Called when we drop a file extent, for example when we truncate.  Doesn't
 109  * need to be called for cases where we're replacing a file extent, like when
 110  * we've COWed a file extent.
 111  *
 112  * The start and len must match the file extent item, so thus must be sectorsize
 113  * aligned.
 114  */
 115 int btrfs_inode_clear_file_extent_range(struct btrfs_inode *inode, u64 start,
 116                                         u64 len)
 117 {
 118         if (len == 0)
 119                 return 0;
 120
 121         ASSERT(IS_ALIGNED(start + len, inode->root->fs_info->sectorsize) ||
 122                len == (u64)-1);
 123
 124         if (btrfs_fs_incompat(inode->root->fs_info, NO_HOLES))
 125                 return 0;
 126         return clear_extent_bit(&inode->file_extent_tree, start,
 127                                 start + len - 1, EXTENT_DIRTY, NULL);
 128 }
 129
 130 static size_t bytes_to_csum_size(const struct btrfs_fs_info *fs_info, u32 bytes)
 131 {
 132         ASSERT(IS_ALIGNED(bytes, fs_info->sectorsize));
 133
 134         return (bytes >> fs_info->sectorsize_bits) * fs_info->csum_size;
 135 }
 136
 137 static size_t csum_size_to_bytes(const struct btrfs_fs_info *fs_info, u32 csum_size)
 138 {
 139         ASSERT(IS_ALIGNED(csum_size, fs_info->csum_size));
 140
 141         return (csum_size / fs_info->csum_size) << fs_info->sectorsize_bits;
 142 }
 143
 144 static inline u32 max_ordered_sum_bytes(const struct btrfs_fs_info *fs_info)
 145 {
 146         u32 max_csum_size = round_down(PAGE_SIZE - sizeof(struct btrfs_ordered_sum),
 147                                        fs_info->csum_size);
 148
 149         return csum_size_to_bytes(fs_info, max_csum_size);
 150 }
 151
 152 /*
 153  * Calculate the total size needed to allocate for an ordered sum structure
 154  * spanning @bytes in the file.
 155  */
 156 static int btrfs_ordered_sum_size(struct btrfs_fs_info *fs_info, unsigned long bytes)
 157 {
 158         return sizeof(struct btrfs_ordered_sum) + bytes_to_csum_size(fs_info, bytes);
 159 }
 160
 161 int btrfs_insert_hole_extent(struct btrfs_trans_handle *trans,
 162                              struct btrfs_root *root,
 163                              u64 objectid, u64 pos, u64 num_bytes)
 164 {
 165         int ret = 0;
 166         struct btrfs_file_extent_item *item;
 167         struct btrfs_key file_key;
 168         struct btrfs_path *path;
 169         struct extent_buffer *leaf;
 170
 171         path = btrfs_alloc_path();
 172         if (!path)
 173                 return -ENOMEM;
 174         file_key.objectid = objectid;
 175         file_key.offset = pos;
 176         file_key.type = BTRFS_EXTENT_DATA_KEY;
 177
 178         ret = btrfs_insert_empty_item(trans, root, path, &file_key,
 179                                       sizeof(*item));
 180         if (ret < 0)
 181                 goto out;
 182         BUG_ON(ret); /* Can't happen */
 183         leaf = path->nodes[0];
 184         item = btrfs_item_ptr(leaf, path->slots[0],
 185                               struct btrfs_file_extent_item);
 186         btrfs_set_file_extent_disk_bytenr(leaf, item, 0);
 187         btrfs_set_file_extent_disk_num_bytes(leaf, item, 0);
 188         btrfs_set_file_extent_offset(leaf, item, 0);
 189         btrfs_set_file_extent_num_bytes(leaf, item, num_bytes);
 190         btrfs_set_file_extent_ram_bytes(leaf, item, num_bytes);
 191         btrfs_set_file_extent_generation(leaf, item, trans->transid);
 192         btrfs_set_file_extent_type(leaf, item, BTRFS_FILE_EXTENT_REG);
 193         btrfs_set_file_extent_compression(leaf, item, 0);
 194         btrfs_set_file_extent_encryption(leaf, item, 0);
 195         btrfs_set_file_extent_other_encoding(leaf, item, 0);
 196
 197         btrfs_mark_buffer_dirty(leaf);
 198 out:
 199         btrfs_free_path(path);
 200         return ret;
 201 }
 202
 203 static struct btrfs_csum_item *
 204 btrfs_lookup_csum(struct btrfs_trans_handle *trans,
 205                   struct btrfs_root *root,
 206                   struct btrfs_path *path,
 207                   u64 bytenr, int cow)
 208 {
 209         struct btrfs_fs_info *fs_info = root->fs_info;
 210         int ret;
 211         struct btrfs_key file_key;
 212         struct btrfs_key found_key;
 213         struct btrfs_csum_item *item;
 214         struct extent_buffer *leaf;
 215         u64 csum_offset = 0;
 216         const u32 csum_size = fs_info->csum_size;
 217         int csums_in_item;
 218
 219         file_key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
 220         file_key.offset = bytenr;
 221         file_key.type = BTRFS_EXTENT_CSUM_KEY;
 222         ret = btrfs_search_slot(trans, root, &file_key, path, 0, cow);
 223         if (ret < 0)
 224                 goto fail;
 225         leaf = path->nodes[0];
 226         if (ret > 0) {
 227                 ret = 1;
 228                 if (path->slots[0] == 0)
 229                         goto fail;
 230                 path->slots[0]--;
 231                 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
 232                 if (found_key.type != BTRFS_EXTENT_CSUM_KEY)
 233                         goto fail;
 234
 235                 csum_offset = (bytenr - found_key.offset) >>
 236                                 fs_info->sectorsize_bits;
 237                 csums_in_item = btrfs_item_size(leaf, path->slots[0]);
 238                 csums_in_item /= csum_size;
 239
 240                 if (csum_offset == csums_in_item) {
 241                         ret = -EFBIG;
 242                         goto fail;
 243                 } else if (csum_offset > csums_in_item) {
 244                         goto fail;
 245                 }
 246         }
 247         item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item);
 248         item = (struct btrfs_csum_item *)((unsigned char *)item +
 249                                           csum_offset * csum_size);
 250         return item;
 251 fail:
 252         if (ret > 0)
 253                 ret = -ENOENT;
 254         return ERR_PTR(ret);
 255 }
 256
 257 int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans,
 258                              struct btrfs_root *root,
 259                              struct btrfs_path *path, u64 objectid,
 260                              u64 offset, int mod)
 261 {
 262         struct btrfs_key file_key;
 263         int ins_len = mod < 0 ? -1 : 0;
 264         int cow = mod != 0;
 265
 266         file_key.objectid = objectid;
 267         file_key.offset = offset;
 268         file_key.type = BTRFS_EXTENT_DATA_KEY;
 269
 270         return btrfs_search_slot(trans, root, &file_key, path, ins_len, cow);
 271 }
 272
 273 /*
 274  * Find checksums for logical bytenr range [disk_bytenr, disk_bytenr + len) and
 275  * store the result to @dst.
 276  *
 277  * Return >0 for the number of sectors we found.
 278  * Return 0 for the range [disk_bytenr, disk_bytenr + sectorsize) has no csum
 279  * for it. Caller may want to try next sector until one range is hit.
 280  * Return <0 for fatal error.
 281  */
 282 static int search_csum_tree(struct btrfs_fs_info *fs_info,
 283                             struct btrfs_path *path, u64 disk_bytenr,
 284                             u64 len, u8 *dst)
 285 {
 286         struct btrfs_root *csum_root;
 287         struct btrfs_csum_item *item = NULL;
 288         struct btrfs_key key;
 289         const u32 sectorsize = fs_info->sectorsize;
 290         const u32 csum_size = fs_info->csum_size;
 291         u32 itemsize;
 292         int ret;
 293         u64 csum_start;
 294         u64 csum_len;
 295
 296         ASSERT(IS_ALIGNED(disk_bytenr, sectorsize) &&
 297                IS_ALIGNED(len, sectorsize));
 298
 299         /* Check if the current csum item covers disk_bytenr */
 300         if (path->nodes[0]) {
 301                 item = btrfs_item_ptr(path->nodes[0], path->slots[0],
 302                                       struct btrfs_csum_item);
 303                 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
 304                 itemsize = btrfs_item_size(path->nodes[0], path->slots[0]);
 305
 306                 csum_start = key.offset;
 307                 csum_len = (itemsize / csum_size) * sectorsize;
 308
 309                 if (in_range(disk_bytenr, csum_start, csum_len))
 310                         goto found;
 311         }
 312
 313         /* Current item doesn't contain the desired range, search again */
 314         btrfs_release_path(path);
 315         csum_root = btrfs_csum_root(fs_info, disk_bytenr);
 316         item = btrfs_lookup_csum(NULL, csum_root, path, disk_bytenr, 0);
 317         if (IS_ERR(item)) {
 318                 ret = PTR_ERR(item);
 319                 goto out;
 320         }
 321         btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
 322         itemsize = btrfs_item_size(path->nodes[0], path->slots[0]);
 323
 324         csum_start = key.offset;
 325         csum_len = (itemsize / csum_size) * sectorsize;
 326         ASSERT(in_range(disk_bytenr, csum_start, csum_len));
 327
 328 found:
 329         ret = (min(csum_start + csum_len, disk_bytenr + len) -
 330                    disk_bytenr) >> fs_info->sectorsize_bits;
 331         read_extent_buffer(path->nodes[0], dst, (unsigned long)item,
 332                         ret * csum_size);
 333 out:
 334         if (ret == -ENOENT || ret == -EFBIG)
 335                 ret = 0;
 336         return ret;
 337 }
 338
 339 /*
 340  * Lookup the checksum for the read bio in csum tree.
 341  *
 342  * Return: BLK_STS_RESOURCE if allocating memory fails, BLK_STS_OK otherwise.
 343  */
 344 blk_status_t btrfs_lookup_bio_sums(struct btrfs_bio *bbio)
 345 {
 346         struct btrfs_inode *inode = bbio->inode;
 347         struct btrfs_fs_info *fs_info = inode->root->fs_info;
 348         struct bio *bio = &bbio->bio;
 349         struct btrfs_path *path;
 350         const u32 sectorsize = fs_info->sectorsize;
 351         const u32 csum_size = fs_info->csum_size;
 352         u32 orig_len = bio->bi_iter.bi_size;
 353         u64 orig_disk_bytenr = bio->bi_iter.bi_sector << SECTOR_SHIFT;
 354         const unsigned int nblocks = orig_len >> fs_info->sectorsize_bits;
 355         blk_status_t ret = BLK_STS_OK;
 356         u32 bio_offset = 0;
 357
 358         if ((inode->flags & BTRFS_INODE_NODATASUM) ||
 359             test_bit(BTRFS_FS_STATE_NO_CSUMS, &fs_info->fs_state))
 360                 return BLK_STS_OK;
 361
 362         /*
 363          * This function is only called for read bio.
 364          *
 365          * This means two things:
 366          * - All our csums should only be in csum tree
 367          *   No ordered extents csums, as ordered extents are only for write
 368          *   path.
 369          * - No need to bother any other info from bvec
 370          *   Since we're looking up csums, the only important info is the
 371          *   disk_bytenr and the length, which can be extracted from bi_iter
 372          *   directly.
 373          */
 374         ASSERT(bio_op(bio) == REQ_OP_READ);
 375         path = btrfs_alloc_path();
 376         if (!path)
 377                 return BLK_STS_RESOURCE;
 378
 379         if (nblocks * csum_size > BTRFS_BIO_INLINE_CSUM_SIZE) {
 380                 bbio->csum = kmalloc_array(nblocks, csum_size, GFP_NOFS);
 381                 if (!bbio->csum) {
 382                         btrfs_free_path(path);
 383                         return BLK_STS_RESOURCE;
 384                 }
 385         } else {
 386                 bbio->csum = bbio->csum_inline;
 387         }
 388
 389         /*
 390          * If requested number of sectors is larger than one leaf can contain,
 391          * kick the readahead for csum tree.
 392          */
 393         if (nblocks > fs_info->csums_per_leaf)
 394                 path->reada = READA_FORWARD;
 395
 396         /*
 397          * the free space stuff is only read when it hasn't been
 398          * updated in the current transaction.  So, we can safely
 399          * read from the commit root and sidestep a nasty deadlock
 400          * between reading the free space cache and updating the csum tree.
 401          */
 402         if (btrfs_is_free_space_inode(inode)) {
 403                 path->search_commit_root = 1;
 404                 path->skip_locking = 1;
 405         }
 406
 407         while (bio_offset < orig_len) {
 408                 int count;
 409                 u64 cur_disk_bytenr = orig_disk_bytenr + bio_offset;
 410                 u8 *csum_dst = bbio->csum +
 411                         (bio_offset >> fs_info->sectorsize_bits) * csum_size;
 412
 413                 count = search_csum_tree(fs_info, path, cur_disk_bytenr,
 414                                          orig_len - bio_offset, csum_dst);
 415                 if (count < 0) {
 416                         ret = errno_to_blk_status(count);
 417                         if (bbio->csum != bbio->csum_inline)
 418                                 kfree(bbio->csum);
 419                         bbio->csum = NULL;
 420                         break;
 421                 }
 422
 423                 /*
 424                  * We didn't find a csum for this range.  We need to make sure
 425                  * we complain loudly about this, because we are not NODATASUM.
 426                  *
 427                  * However for the DATA_RELOC inode we could potentially be
 428                  * relocating data extents for a NODATASUM inode, so the inode
 429                  * itself won't be marked with NODATASUM, but the extent we're
 430                  * copying is in fact NODATASUM.  If we don't find a csum we
 431                  * assume this is the case.
 432                  */
 433                 if (count == 0) {
 434                         memset(csum_dst, 0, csum_size);
 435                         count = 1;
 436
 437                         if (inode->root->root_key.objectid ==
 438                             BTRFS_DATA_RELOC_TREE_OBJECTID) {
 439                                 u64 file_offset = bbio->file_offset + bio_offset;
 440
 441                                 set_extent_bits(&inode->io_tree, file_offset,
 442                                                 file_offset + sectorsize - 1,
 443                                                 EXTENT_NODATASUM);
 444                         } else {
 445                                 btrfs_warn_rl(fs_info,
 446                         "csum hole found for disk bytenr range [%llu, %llu)",
 447                                 cur_disk_bytenr, cur_disk_bytenr + sectorsize);
 448                         }
 449                 }
 450                 bio_offset += count * sectorsize;
 451         }
 452
 453         btrfs_free_path(path);
 454         return ret;
 455 }
 456
 457 int btrfs_lookup_csums_list(struct btrfs_root *root, u64 start, u64 end,
 458                             struct list_head *list, int search_commit,
 459                             bool nowait)
 460 {
 461         struct btrfs_fs_info *fs_info = root->fs_info;
 462         struct btrfs_key key;
 463         struct btrfs_path *path;
 464         struct extent_buffer *leaf;
 465         struct btrfs_ordered_sum *sums;
 466         struct btrfs_csum_item *item;
 467         LIST_HEAD(tmplist);
 468         int ret;
 469
 470         ASSERT(IS_ALIGNED(start, fs_info->sectorsize) &&
 471                IS_ALIGNED(end + 1, fs_info->sectorsize));
 472
 473         path = btrfs_alloc_path();
 474         if (!path)
 475                 return -ENOMEM;
 476
 477         path->nowait = nowait;
 478         if (search_commit) {
 479                 path->skip_locking = 1;
 480                 path->reada = READA_FORWARD;
 481                 path->search_commit_root = 1;
 482         }
 483
 484         key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
 485         key.offset = start;
 486         key.type = BTRFS_EXTENT_CSUM_KEY;
 487
 488         ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
 489         if (ret < 0)
 490                 goto fail;
 491         if (ret > 0 && path->slots[0] > 0) {
 492                 leaf = path->nodes[0];
 493                 btrfs_item_key_to_cpu(leaf, &key, path->slots[0] - 1);
 494
 495                 /*
 496                  * There are two cases we can hit here for the previous csum
 497                  * item:
 498                  *
 499                  *              |<- search range ->|
 500                  *      |<- csum item ->|
 501                  *
 502                  * Or
 503                  *                              |<- search range ->|
 504                  *      |<- csum item ->|
 505                  *
 506                  * Check if the previous csum item covers the leading part of
 507                  * the search range.  If so we have to start from previous csum
 508                  * item.
 509                  */
 510                 if (key.objectid == BTRFS_EXTENT_CSUM_OBJECTID &&
 511                     key.type == BTRFS_EXTENT_CSUM_KEY) {
 512                         if (bytes_to_csum_size(fs_info, start - key.offset) <
 513                             btrfs_item_size(leaf, path->slots[0] - 1))
 514                                 path->slots[0]--;
 515                 }
 516         }
 517
 518         while (start <= end) {
 519                 u64 csum_end;
 520
 521                 leaf = path->nodes[0];
 522                 if (path->slots[0] >= btrfs_header_nritems(leaf)) {
 523                         ret = btrfs_next_leaf(root, path);
 524                         if (ret < 0)
 525                                 goto fail;
 526                         if (ret > 0)
 527                                 break;
 528                         leaf = path->nodes[0];
 529                 }
 530
 531                 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
 532                 if (key.objectid != BTRFS_EXTENT_CSUM_OBJECTID ||
 533                     key.type != BTRFS_EXTENT_CSUM_KEY ||
 534                     key.offset > end)
 535                         break;
 536
 537                 if (key.offset > start)
 538                         start = key.offset;
 539
 540                 csum_end = key.offset + csum_size_to_bytes(fs_info,
 541                                         btrfs_item_size(leaf, path->slots[0]));
 542                 if (csum_end <= start) {
 543                         path->slots[0]++;
 544                         continue;
 545                 }
 546
 547                 csum_end = min(csum_end, end + 1);
 548                 item = btrfs_item_ptr(path->nodes[0], path->slots[0],
 549                                       struct btrfs_csum_item);
 550                 while (start < csum_end) {
 551                         unsigned long offset;
 552                         size_t size;
 553
 554                         size = min_t(size_t, csum_end - start,
 555                                      max_ordered_sum_bytes(fs_info));
 556                         sums = kzalloc(btrfs_ordered_sum_size(fs_info, size),
 557                                        GFP_NOFS);
 558                         if (!sums) {
 559                                 ret = -ENOMEM;
 560                                 goto fail;
 561                         }
 562
 563                         sums->bytenr = start;
 564                         sums->len = (int)size;
 565
 566                         offset = bytes_to_csum_size(fs_info, start - key.offset);
 567
 568                         read_extent_buffer(path->nodes[0],
 569                                            sums->sums,
 570                                            ((unsigned long)item) + offset,
 571                                            bytes_to_csum_size(fs_info, size));
 572
 573                         start += size;
 574                         list_add_tail(&sums->list, &tmplist);
 575                 }
 576                 path->slots[0]++;
 577         }
 578         ret = 0;
 579 fail:
 580         while (ret < 0 && !list_empty(&tmplist)) {
 581                 sums = list_entry(tmplist.next, struct btrfs_ordered_sum, list);
 582                 list_del(&sums->list);
 583                 kfree(sums);
 584         }
 585         list_splice_tail(&tmplist, list);
 586
 587         btrfs_free_path(path);
 588         return ret;
 589 }
 590
 591 /*
 592  * Do the same work as btrfs_lookup_csums_list(), the difference is in how
 593  * we return the result.
 594  *
 595  * This version will set the corresponding bits in @csum_bitmap to represent
 596  * that there is a csum found.
 597  * Each bit represents a sector. Thus caller should ensure @csum_buf passed
 598  * in is large enough to contain all csums.
 599  */
 600 int btrfs_lookup_csums_bitmap(struct btrfs_root *root, u64 start, u64 end,
 601                               u8 *csum_buf, unsigned long *csum_bitmap,
 602                               bool search_commit)
 603 {
 604         struct btrfs_fs_info *fs_info = root->fs_info;
 605         struct btrfs_key key;
 606         struct btrfs_path *path;
 607         struct extent_buffer *leaf;
 608         struct btrfs_csum_item *item;
 609         const u64 orig_start = start;
 610         int ret;
 611
 612         ASSERT(IS_ALIGNED(start, fs_info->sectorsize) &&
 613                IS_ALIGNED(end + 1, fs_info->sectorsize));
 614
 615         path = btrfs_alloc_path();
 616         if (!path)
 617                 return -ENOMEM;
 618
 619         if (search_commit) {
 620                 path->skip_locking = 1;
 621                 path->reada = READA_FORWARD;
 622                 path->search_commit_root = 1;
 623         }
 624
 625         key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
 626         key.type = BTRFS_EXTENT_CSUM_KEY;
 627         key.offset = start;
 628
 629         ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
 630         if (ret < 0)
 631                 goto fail;
 632         if (ret > 0 && path->slots[0] > 0) {
 633                 leaf = path->nodes[0];
 634                 btrfs_item_key_to_cpu(leaf, &key, path->slots[0] - 1);
 635
 636                 /*
 637                  * There are two cases we can hit here for the previous csum
 638                  * item:
 639                  *
 640                  *              |<- search range ->|
 641                  *      |<- csum item ->|
 642                  *
 643                  * Or
 644                  *                              |<- search range ->|
 645                  *      |<- csum item ->|
 646                  *
 647                  * Check if the previous csum item covers the leading part of
 648                  * the search range.  If so we have to start from previous csum
 649                  * item.
 650                  */
 651                 if (key.objectid == BTRFS_EXTENT_CSUM_OBJECTID &&
 652                     key.type == BTRFS_EXTENT_CSUM_KEY) {
 653                         if (bytes_to_csum_size(fs_info, start - key.offset) <
 654                             btrfs_item_size(leaf, path->slots[0] - 1))
 655                                 path->slots[0]--;
 656                 }
 657         }
 658
 659         while (start <= end) {
 660                 u64 csum_end;
 661
 662                 leaf = path->nodes[0];
 663                 if (path->slots[0] >= btrfs_header_nritems(leaf)) {
 664                         ret = btrfs_next_leaf(root, path);
 665                         if (ret < 0)
 666                                 goto fail;
 667                         if (ret > 0)
 668                                 break;
 669                         leaf = path->nodes[0];
 670                 }
 671
 672                 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
 673                 if (key.objectid != BTRFS_EXTENT_CSUM_OBJECTID ||
 674                     key.type != BTRFS_EXTENT_CSUM_KEY ||
 675                     key.offset > end)
 676                         break;
 677
 678                 if (key.offset > start)
 679                         start = key.offset;
 680
 681                 csum_end = key.offset + csum_size_to_bytes(fs_info,
 682                                         btrfs_item_size(leaf, path->slots[0]));
 683                 if (csum_end <= start) {
 684                         path->slots[0]++;
 685                         continue;
 686                 }
 687
 688                 csum_end = min(csum_end, end + 1);
 689                 item = btrfs_item_ptr(path->nodes[0], path->slots[0],
 690                                       struct btrfs_csum_item);
 691                 while (start < csum_end) {
 692                         unsigned long offset;
 693                         size_t size;
 694                         u8 *csum_dest = csum_buf + bytes_to_csum_size(fs_info,
 695                                                 start - orig_start);
 696
 697                         size = min_t(size_t, csum_end - start, end + 1 - start);
 698
 699                         offset = bytes_to_csum_size(fs_info, start - key.offset);
 700
 701                         read_extent_buffer(path->nodes[0], csum_dest,
 702                                            ((unsigned long)item) + offset,
 703                                            bytes_to_csum_size(fs_info, size));
 704
 705                         bitmap_set(csum_bitmap,
 706                                 (start - orig_start) >> fs_info->sectorsize_bits,
 707                                 size >> fs_info->sectorsize_bits);
 708
 709                         start += size;
 710                 }
 711                 path->slots[0]++;
 712         }
 713         ret = 0;
 714 fail:
 715         btrfs_free_path(path);
 716         return ret;
 717 }
 718
 719 /*
 720  * Calculate checksums of the data contained inside a bio.
 721  */
 722 blk_status_t btrfs_csum_one_bio(struct btrfs_bio *bbio)
 723 {
 724         struct btrfs_inode *inode = bbio->inode;
 725         struct btrfs_fs_info *fs_info = inode->root->fs_info;
 726         SHASH_DESC_ON_STACK(shash, fs_info->csum_shash);
 727         struct bio *bio = &bbio->bio;
 728         u64 offset = bbio->file_offset;
 729         struct btrfs_ordered_sum *sums;
 730         struct btrfs_ordered_extent *ordered = NULL;
 731         char *data;
 732         struct bvec_iter iter;
 733         struct bio_vec bvec;
 734         int index;
 735         unsigned int blockcount;
 736         unsigned long total_bytes = 0;
 737         unsigned long this_sum_bytes = 0;
 738         int i;
 739         unsigned nofs_flag;
 740
 741         nofs_flag = memalloc_nofs_save();
 742         sums = kvzalloc(btrfs_ordered_sum_size(fs_info, bio->bi_iter.bi_size),
 743                        GFP_KERNEL);
 744         memalloc_nofs_restore(nofs_flag);
 745
 746         if (!sums)
 747                 return BLK_STS_RESOURCE;
 748
 749         sums->len = bio->bi_iter.bi_size;
 750         INIT_LIST_HEAD(&sums->list);
 751
 752         sums->bytenr = bio->bi_iter.bi_sector << 9;
 753         index = 0;
 754
 755         shash->tfm = fs_info->csum_shash;
 756
 757         bio_for_each_segment(bvec, bio, iter) {
 758                 if (!ordered) {
 759                         ordered = btrfs_lookup_ordered_extent(inode, offset);
 760                         /*
 761                          * The bio range is not covered by any ordered extent,
 762                          * must be a code logic error.
 763                          */
 764                         if (unlikely(!ordered)) {
 765                                 WARN(1, KERN_WARNING
 766                         "no ordered extent for root %llu ino %llu offset %llu\n",
 767                                      inode->root->root_key.objectid,
 768                                      btrfs_ino(inode), offset);
 769                                 kvfree(sums);
 770                                 return BLK_STS_IOERR;
 771                         }
 772                 }
 773
 774                 blockcount = BTRFS_BYTES_TO_BLKS(fs_info,
 775                                                  bvec.bv_len + fs_info->sectorsize
 776                                                  - 1);
 777
 778                 for (i = 0; i < blockcount; i++) {
 779                         if (!(bio->bi_opf & REQ_BTRFS_ONE_ORDERED) &&
 780                             !in_range(offset, ordered->file_offset,
 781                                       ordered->num_bytes)) {
 782                                 unsigned long bytes_left;
 783
 784                                 sums->len = this_sum_bytes;
 785                                 this_sum_bytes = 0;
 786                                 btrfs_add_ordered_sum(ordered, sums);
 787                                 btrfs_put_ordered_extent(ordered);
 788
 789                                 bytes_left = bio->bi_iter.bi_size - total_bytes;
 790
 791                                 nofs_flag = memalloc_nofs_save();
 792                                 sums = kvzalloc(btrfs_ordered_sum_size(fs_info,
 793                                                       bytes_left), GFP_KERNEL);
 794                                 memalloc_nofs_restore(nofs_flag);
 795                                 BUG_ON(!sums); /* -ENOMEM */
 796                                 sums->len = bytes_left;
 797                                 ordered = btrfs_lookup_ordered_extent(inode,
 798                                                                 offset);
 799                                 ASSERT(ordered); /* Logic error */
 800                                 sums->bytenr = (bio->bi_iter.bi_sector << 9)
 801                                         + total_bytes;
 802                                 index = 0;
 803                         }
 804
 805                         data = bvec_kmap_local(&bvec);
 806                         crypto_shash_digest(shash,
 807                                             data + (i * fs_info->sectorsize),
 808                                             fs_info->sectorsize,
 809                                             sums->sums + index);
 810                         kunmap_local(data);
 811                         index += fs_info->csum_size;
 812                         offset += fs_info->sectorsize;
 813                         this_sum_bytes += fs_info->sectorsize;
 814                         total_bytes += fs_info->sectorsize;
 815                 }
 816
 817         }
 818         this_sum_bytes = 0;
 819         btrfs_add_ordered_sum(ordered, sums);
 820         btrfs_put_ordered_extent(ordered);
 821         return 0;
 822 }
 823
 824 /*
 825  * Remove one checksum overlapping a range.
 826  *
 827  * This expects the key to describe the csum pointed to by the path, and it
 828  * expects the csum to overlap the range [bytenr, len]
 829  *
 830  * The csum should not be entirely contained in the range and the range should
 831  * not be entirely contained in the csum.
 832  *
 833  * This calls btrfs_truncate_item with the correct args based on the overlap,
 834  * and fixes up the key as required.
 835  */
 836 static noinline void truncate_one_csum(struct btrfs_fs_info *fs_info,
 837                                        struct btrfs_path *path,
 838                                        struct btrfs_key *key,
 839                                        u64 bytenr, u64 len)
 840 {
 841         struct extent_buffer *leaf;
 842         const u32 csum_size = fs_info->csum_size;
 843         u64 csum_end;
 844         u64 end_byte = bytenr + len;
 845         u32 blocksize_bits = fs_info->sectorsize_bits;
 846
 847         leaf = path->nodes[0];
 848         csum_end = btrfs_item_size(leaf, path->slots[0]) / csum_size;
 849         csum_end <<= blocksize_bits;
 850         csum_end += key->offset;
 851
 852         if (key->offset < bytenr && csum_end <= end_byte) {
 853                 /*
 854                  *         [ bytenr - len ]
 855                  *         [   ]
 856                  *   [csum     ]
 857                  *   A simple truncate off the end of the item
 858                  */
 859                 u32 new_size = (bytenr - key->offset) >> blocksize_bits;
 860                 new_size *= csum_size;
 861                 btrfs_truncate_item(path, new_size, 1);
 862         } else if (key->offset >= bytenr && csum_end > end_byte &&
 863                    end_byte > key->offset) {
 864                 /*
 865                  *         [ bytenr - len ]
 866                  *                 [ ]
 867                  *                 [csum     ]
 868                  * we need to truncate from the beginning of the csum
 869                  */
 870                 u32 new_size = (csum_end - end_byte) >> blocksize_bits;
 871                 new_size *= csum_size;
 872
 873                 btrfs_truncate_item(path, new_size, 0);
 874
 875                 key->offset = end_byte;
 876                 btrfs_set_item_key_safe(fs_info, path, key);
 877         } else {
 878                 BUG();
 879         }
 880 }
 881
 882 /*
 883  * Delete the csum items from the csum tree for a given range of bytes.
 884  */
 885 int btrfs_del_csums(struct btrfs_trans_handle *trans,
 886                     struct btrfs_root *root, u64 bytenr, u64 len)
 887 {
 888         struct btrfs_fs_info *fs_info = trans->fs_info;
 889         struct btrfs_path *path;
 890         struct btrfs_key key;
 891         u64 end_byte = bytenr + len;
 892         u64 csum_end;
 893         struct extent_buffer *leaf;
 894         int ret = 0;
 895         const u32 csum_size = fs_info->csum_size;
 896         u32 blocksize_bits = fs_info->sectorsize_bits;
 897
 898         ASSERT(root->root_key.objectid == BTRFS_CSUM_TREE_OBJECTID ||
 899                root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID);
 900
 901         path = btrfs_alloc_path();
 902         if (!path)
 903                 return -ENOMEM;
 904
 905         while (1) {
 906                 key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
 907                 key.offset = end_byte - 1;
 908                 key.type = BTRFS_EXTENT_CSUM_KEY;
 909
 910                 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
 911                 if (ret > 0) {
 912                         ret = 0;
 913                         if (path->slots[0] == 0)
 914                                 break;
 915                         path->slots[0]--;
 916                 } else if (ret < 0) {
 917                         break;
 918                 }
 919
 920                 leaf = path->nodes[0];
 921                 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
 922
 923                 if (key.objectid != BTRFS_EXTENT_CSUM_OBJECTID ||
 924                     key.type != BTRFS_EXTENT_CSUM_KEY) {
 925                         break;
 926                 }
 927
 928                 if (key.offset >= end_byte)
 929                         break;
 930
 931                 csum_end = btrfs_item_size(leaf, path->slots[0]) / csum_size;
 932                 csum_end <<= blocksize_bits;
 933                 csum_end += key.offset;
 934
 935                 /* this csum ends before we start, we're done */
 936                 if (csum_end <= bytenr)
 937                         break;
 938
 939                 /* delete the entire item, it is inside our range */
 940                 if (key.offset >= bytenr && csum_end <= end_byte) {
 941                         int del_nr = 1;
 942
 943                         /*
 944                          * Check how many csum items preceding this one in this
 945                          * leaf correspond to our range and then delete them all
 946                          * at once.
 947                          */
 948                         if (key.offset > bytenr && path->slots[0] > 0) {
 949                                 int slot = path->slots[0] - 1;
 950
 951                                 while (slot >= 0) {
 952                                         struct btrfs_key pk;
 953
 954                                         btrfs_item_key_to_cpu(leaf, &pk, slot);
 955                                         if (pk.offset < bytenr ||
 956                                             pk.type != BTRFS_EXTENT_CSUM_KEY ||
 957                                             pk.objectid !=
 958                                             BTRFS_EXTENT_CSUM_OBJECTID)
 959                                                 break;
 960                                         path->slots[0] = slot;
 961                                         del_nr++;
 962                                         key.offset = pk.offset;
 963                                         slot--;
 964                                 }
 965                         }
 966                         ret = btrfs_del_items(trans, root, path,
 967                                               path->slots[0], del_nr);
 968                         if (ret)
 969                                 break;
 970                         if (key.offset == bytenr)
 971                                 break;
 972                 } else if (key.offset < bytenr && csum_end > end_byte) {
 973                         unsigned long offset;
 974                         unsigned long shift_len;
 975                         unsigned long item_offset;
 976                         /*
 977                          *        [ bytenr - len ]
 978                          *     [csum                ]
 979                          *
 980                          * Our bytes are in the middle of the csum,
 981                          * we need to split this item and insert a new one.
 982                          *
 983                          * But we can't drop the path because the
 984                          * csum could change, get removed, extended etc.
 985                          *
 986                          * The trick here is the max size of a csum item leaves
 987                          * enough room in the tree block for a single
 988                          * item header.  So, we split the item in place,
 989                          * adding a new header pointing to the existing
 990                          * bytes.  Then we loop around again and we have
 991                          * a nicely formed csum item that we can neatly
 992                          * truncate.
 993                          */
 994                         offset = (bytenr - key.offset) >> blocksize_bits;
 995                         offset *= csum_size;
 996
 997                         shift_len = (len >> blocksize_bits) * csum_size;
 998
 999                         item_offset = btrfs_item_ptr_offset(leaf,
1000                                                             path->slots[0]);
1001
1002                         memzero_extent_buffer(leaf, item_offset + offset,
1003                                              shift_len);
1004                         key.offset = bytenr;
1005
1006                         /*
1007                          * btrfs_split_item returns -EAGAIN when the
1008                          * item changed size or key
1009                          */
1010                         ret = btrfs_split_item(trans, root, path, &key, offset);
1011                         if (ret && ret != -EAGAIN) {
1012                                 btrfs_abort_transaction(trans, ret);
1013                                 break;
1014                         }
1015                         ret = 0;
1016
1017                         key.offset = end_byte - 1;
1018                 } else {
1019                         truncate_one_csum(fs_info, path, &key, bytenr, len);
1020                         if (key.offset < bytenr)
1021                                 break;
1022                 }
1023                 btrfs_release_path(path);
1024         }
1025         btrfs_free_path(path);
1026         return ret;
1027 }
1028
1029 static int find_next_csum_offset(struct btrfs_root *root,
1030                                  struct btrfs_path *path,
1031                                  u64 *next_offset)
1032 {
1033         const u32 nritems = btrfs_header_nritems(path->nodes[0]);
1034         struct btrfs_key found_key;
1035         int slot = path->slots[0] + 1;
1036         int ret;
1037
1038         if (nritems == 0 || slot >= nritems) {
1039                 ret = btrfs_next_leaf(root, path);
1040                 if (ret < 0) {
1041                         return ret;
1042                 } else if (ret > 0) {
1043                         *next_offset = (u64)-1;
1044                         return 0;
1045                 }
1046                 slot = path->slots[0];
1047         }
1048
1049         btrfs_item_key_to_cpu(path->nodes[0], &found_key, slot);
1050
1051         if (found_key.objectid != BTRFS_EXTENT_CSUM_OBJECTID ||
1052             found_key.type != BTRFS_EXTENT_CSUM_KEY)
1053                 *next_offset = (u64)-1;
1054         else
1055                 *next_offset = found_key.offset;
1056
1057         return 0;
1058 }
1059
1060 int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,
1061                            struct btrfs_root *root,
1062                            struct btrfs_ordered_sum *sums)
1063 {
1064         struct btrfs_fs_info *fs_info = root->fs_info;
1065         struct btrfs_key file_key;
1066         struct btrfs_key found_key;
1067         struct btrfs_path *path;
1068         struct btrfs_csum_item *item;
1069         struct btrfs_csum_item *item_end;
1070         struct extent_buffer *leaf = NULL;
1071         u64 next_offset;
1072         u64 total_bytes = 0;
1073         u64 csum_offset;
1074         u64 bytenr;
1075         u32 ins_size;
1076         int index = 0;
1077         int found_next;
1078         int ret;
1079         const u32 csum_size = fs_info->csum_size;
1080
1081         path = btrfs_alloc_path();
1082         if (!path)
1083                 return -ENOMEM;
1084 again:
1085         next_offset = (u64)-1;
1086         found_next = 0;
1087         bytenr = sums->bytenr + total_bytes;
1088         file_key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
1089         file_key.offset = bytenr;
1090         file_key.type = BTRFS_EXTENT_CSUM_KEY;
1091
1092         item = btrfs_lookup_csum(trans, root, path, bytenr, 1);
1093         if (!IS_ERR(item)) {
1094                 ret = 0;
1095                 leaf = path->nodes[0];
1096                 item_end = btrfs_item_ptr(leaf, path->slots[0],
1097                                           struct btrfs_csum_item);
1098                 item_end = (struct btrfs_csum_item *)((char *)item_end +
1099                            btrfs_item_size(leaf, path->slots[0]));
1100                 goto found;
1101         }
1102         ret = PTR_ERR(item);
1103         if (ret != -EFBIG && ret != -ENOENT)
1104                 goto out;
1105
1106         if (ret == -EFBIG) {
1107                 u32 item_size;
1108                 /* we found one, but it isn't big enough yet */
1109                 leaf = path->nodes[0];
1110                 item_size = btrfs_item_size(leaf, path->slots[0]);
1111                 if ((item_size / csum_size) >=
1112                     MAX_CSUM_ITEMS(fs_info, csum_size)) {
1113                         /* already at max size, make a new one */
1114                         goto insert;
1115                 }
1116         } else {
1117                 /* We didn't find a csum item, insert one. */
1118                 ret = find_next_csum_offset(root, path, &next_offset);
1119                 if (ret < 0)
1120                         goto out;
1121                 found_next = 1;
1122                 goto insert;
1123         }
1124
1125         /*
1126          * At this point, we know the tree has a checksum item that ends at an
1127          * offset matching the start of the checksum range we want to insert.
1128          * We try to extend that item as much as possible and then add as many
1129          * checksums to it as they fit.
1130          *
1131          * First check if the leaf has enough free space for at least one
1132          * checksum. If it has go directly to the item extension code, otherwise
1133          * release the path and do a search for insertion before the extension.
1134          */
1135         if (btrfs_leaf_free_space(leaf) >= csum_size) {
1136                 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
1137                 csum_offset = (bytenr - found_key.offset) >>
1138                         fs_info->sectorsize_bits;
1139                 goto extend_csum;
1140         }
1141
1142         btrfs_release_path(path);
1143         path->search_for_extension = 1;
1144         ret = btrfs_search_slot(trans, root, &file_key, path,
1145                                 csum_size, 1);
1146         path->search_for_extension = 0;
1147         if (ret < 0)
1148                 goto out;
1149
1150         if (ret > 0) {
1151                 if (path->slots[0] == 0)
1152                         goto insert;
1153                 path->slots[0]--;
1154         }
1155
1156         leaf = path->nodes[0];
1157         btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
1158         csum_offset = (bytenr - found_key.offset) >> fs_info->sectorsize_bits;
1159
1160         if (found_key.type != BTRFS_EXTENT_CSUM_KEY ||
1161             found_key.objectid != BTRFS_EXTENT_CSUM_OBJECTID ||
1162             csum_offset >= MAX_CSUM_ITEMS(fs_info, csum_size)) {
1163                 goto insert;
1164         }
1165
1166 extend_csum:
1167         if (csum_offset == btrfs_item_size(leaf, path->slots[0]) /
1168             csum_size) {
1169                 int extend_nr;
1170                 u64 tmp;
1171                 u32 diff;
1172
1173                 tmp = sums->len - total_bytes;
1174                 tmp >>= fs_info->sectorsize_bits;
1175                 WARN_ON(tmp < 1);
1176                 extend_nr = max_t(int, 1, tmp);
1177
1178                 /*
1179                  * A log tree can already have checksum items with a subset of
1180                  * the checksums we are trying to log. This can happen after
1181                  * doing a sequence of partial writes into prealloc extents and
1182                  * fsyncs in between, with a full fsync logging a larger subrange
1183                  * of an extent for which a previous fast fsync logged a smaller
1184                  * subrange. And this happens in particular due to merging file
1185                  * extent items when we complete an ordered extent for a range
1186                  * covered by a prealloc extent - this is done at
1187                  * btrfs_mark_extent_written().
1188                  *
1189                  * So if we try to extend the previous checksum item, which has
1190                  * a range that ends at the start of the range we want to insert,
1191                  * make sure we don't extend beyond the start offset of the next
1192                  * checksum item. If we are at the last item in the leaf, then
1193                  * forget the optimization of extending and add a new checksum
1194                  * item - it is not worth the complexity of releasing the path,
1195                  * getting the first key for the next leaf, repeat the btree
1196                  * search, etc, because log trees are temporary anyway and it
1197                  * would only save a few bytes of leaf space.
1198                  */
1199                 if (root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID) {
1200                         if (path->slots[0] + 1 >=
1201                             btrfs_header_nritems(path->nodes[0])) {
1202                                 ret = find_next_csum_offset(root, path, &next_offset);
1203                                 if (ret < 0)
1204                                         goto out;
1205                                 found_next = 1;
1206                                 goto insert;
1207                         }
1208
1209                         ret = find_next_csum_offset(root, path, &next_offset);
1210                         if (ret < 0)
1211                                 goto out;
1212
1213                         tmp = (next_offset - bytenr) >> fs_info->sectorsize_bits;
1214                         if (tmp <= INT_MAX)
1215                                 extend_nr = min_t(int, extend_nr, tmp);
1216                 }
1217
1218                 diff = (csum_offset + extend_nr) * csum_size;
1219                 diff = min(diff,
1220                            MAX_CSUM_ITEMS(fs_info, csum_size) * csum_size);
1221
1222                 diff = diff - btrfs_item_size(leaf, path->slots[0]);
1223                 diff = min_t(u32, btrfs_leaf_free_space(leaf), diff);
1224                 diff /= csum_size;
1225                 diff *= csum_size;
1226
1227                 btrfs_extend_item(path, diff);
1228                 ret = 0;
1229                 goto csum;
1230         }
1231
1232 insert:
1233         btrfs_release_path(path);
1234         csum_offset = 0;
1235         if (found_next) {
1236                 u64 tmp;
1237
1238                 tmp = sums->len - total_bytes;
1239                 tmp >>= fs_info->sectorsize_bits;
1240                 tmp = min(tmp, (next_offset - file_key.offset) >>
1241                                          fs_info->sectorsize_bits);
1242
1243                 tmp = max_t(u64, 1, tmp);
1244                 tmp = min_t(u64, tmp, MAX_CSUM_ITEMS(fs_info, csum_size));
1245                 ins_size = csum_size * tmp;
1246         } else {
1247                 ins_size = csum_size;
1248         }
1249         ret = btrfs_insert_empty_item(trans, root, path, &file_key,
1250                                       ins_size);
1251         if (ret < 0)
1252                 goto out;
1253         if (WARN_ON(ret != 0))
1254                 goto out;
1255         leaf = path->nodes[0];
1256 csum:
1257         item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item);
1258         item_end = (struct btrfs_csum_item *)((unsigned char *)item +
1259                                       btrfs_item_size(leaf, path->slots[0]));
1260         item = (struct btrfs_csum_item *)((unsigned char *)item +
1261                                           csum_offset * csum_size);
1262 found:
1263         ins_size = (u32)(sums->len - total_bytes) >> fs_info->sectorsize_bits;
1264         ins_size *= csum_size;
1265         ins_size = min_t(u32, (unsigned long)item_end - (unsigned long)item,
1266                               ins_size);
1267         write_extent_buffer(leaf, sums->sums + index, (unsigned long)item,
1268                             ins_size);
1269
1270         index += ins_size;
1271         ins_size /= csum_size;
1272         total_bytes += ins_size * fs_info->sectorsize;
1273
1274         btrfs_mark_buffer_dirty(path->nodes[0]);
1275         if (total_bytes < sums->len) {
1276                 btrfs_release_path(path);
1277                 cond_resched();
1278                 goto again;
1279         }
1280 out:
1281         btrfs_free_path(path);
1282         return ret;
1283 }
1284
1285 void btrfs_extent_item_to_extent_map(struct btrfs_inode *inode,
1286                                      const struct btrfs_path *path,
1287                                      struct btrfs_file_extent_item *fi,
1288                                      struct extent_map *em)
1289 {
1290         struct btrfs_fs_info *fs_info = inode->root->fs_info;
1291         struct btrfs_root *root = inode->root;
1292         struct extent_buffer *leaf = path->nodes[0];
1293         const int slot = path->slots[0];
1294         struct btrfs_key key;
1295         u64 extent_start, extent_end;
1296         u64 bytenr;
1297         u8 type = btrfs_file_extent_type(leaf, fi);
1298         int compress_type = btrfs_file_extent_compression(leaf, fi);
1299
1300         btrfs_item_key_to_cpu(leaf, &key, slot);
1301         extent_start = key.offset;
1302         extent_end = btrfs_file_extent_end(path);
1303         em->ram_bytes = btrfs_file_extent_ram_bytes(leaf, fi);
1304         em->generation = btrfs_file_extent_generation(leaf, fi);
1305         if (type == BTRFS_FILE_EXTENT_REG ||
1306             type == BTRFS_FILE_EXTENT_PREALLOC) {
1307                 em->start = extent_start;
1308                 em->len = extent_end - extent_start;
1309                 em->orig_start = extent_start -
1310                         btrfs_file_extent_offset(leaf, fi);
1311                 em->orig_block_len = btrfs_file_extent_disk_num_bytes(leaf, fi);
1312                 bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
1313                 if (bytenr == 0) {
1314                         em->block_start = EXTENT_MAP_HOLE;
1315                         return;
1316                 }
1317                 if (compress_type != BTRFS_COMPRESS_NONE) {
1318                         set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
1319                         em->compress_type = compress_type;
1320                         em->block_start = bytenr;
1321                         em->block_len = em->orig_block_len;
1322                 } else {
1323                         bytenr += btrfs_file_extent_offset(leaf, fi);
1324                         em->block_start = bytenr;
1325                         em->block_len = em->len;
1326                         if (type == BTRFS_FILE_EXTENT_PREALLOC)
1327                                 set_bit(EXTENT_FLAG_PREALLOC, &em->flags);
1328                 }
1329         } else if (type == BTRFS_FILE_EXTENT_INLINE) {
1330                 em->block_start = EXTENT_MAP_INLINE;
1331                 em->start = extent_start;
1332                 em->len = extent_end - extent_start;
1333                 /*
1334                  * Initialize orig_start and block_len with the same values
1335                  * as in inode.c:btrfs_get_extent().
1336                  */
1337                 em->orig_start = EXTENT_MAP_HOLE;
1338                 em->block_len = (u64)-1;
1339                 em->compress_type = compress_type;
1340                 if (compress_type != BTRFS_COMPRESS_NONE)
1341                         set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
1342         } else {
1343                 btrfs_err(fs_info,
1344                           "unknown file extent item type %d, inode %llu, offset %llu, "
1345                           "root %llu", type, btrfs_ino(inode), extent_start,
1346                           root->root_key.objectid);
1347         }
1348 }
1349
1350 /*
1351  * Returns the end offset (non inclusive) of the file extent item the given path
1352  * points to. If it points to an inline extent, the returned offset is rounded
1353  * up to the sector size.
1354  */
1355 u64 btrfs_file_extent_end(const struct btrfs_path *path)
1356 {
1357         const struct extent_buffer *leaf = path->nodes[0];
1358         const int slot = path->slots[0];
1359         struct btrfs_file_extent_item *fi;
1360         struct btrfs_key key;
1361         u64 end;
1362
1363         btrfs_item_key_to_cpu(leaf, &key, slot);
1364         ASSERT(key.type == BTRFS_EXTENT_DATA_KEY);
1365         fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
1366
1367         if (btrfs_file_extent_type(leaf, fi) == BTRFS_FILE_EXTENT_INLINE) {
1368                 end = btrfs_file_extent_ram_bytes(leaf, fi);
1369                 end = ALIGN(key.offset + end, leaf->fs_info->sectorsize);
1370         } else {
1371                 end = key.offset + btrfs_file_extent_num_bytes(leaf, fi);
1372         }
1373
1374         return end;
1375 }