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                                 if (!sums)
 796                                         return BLK_STS_RESOURCE;
 797
 798                                 sums->len = bytes_left;
 799                                 ordered = btrfs_lookup_ordered_extent(inode,
 800                                                                 offset);
 801                                 ASSERT(ordered); /* Logic error */
 802                                 sums->bytenr = (bio->bi_iter.bi_sector << 9)
 803                                         + total_bytes;
 804                                 index = 0;
 805                         }
 806
 807                         data = bvec_kmap_local(&bvec);
 808                         crypto_shash_digest(shash,
 809                                             data + (i * fs_info->sectorsize),
 810                                             fs_info->sectorsize,
 811                                             sums->sums + index);
 812                         kunmap_local(data);
 813                         index += fs_info->csum_size;
 814                         offset += fs_info->sectorsize;
 815                         this_sum_bytes += fs_info->sectorsize;
 816                         total_bytes += fs_info->sectorsize;
 817                 }
 818
 819         }
 820         this_sum_bytes = 0;
 821         btrfs_add_ordered_sum(ordered, sums);
 822         btrfs_put_ordered_extent(ordered);
 823         return 0;
 824 }
 825
 826 /*
 827  * Remove one checksum overlapping a range.
 828  *
 829  * This expects the key to describe the csum pointed to by the path, and it
 830  * expects the csum to overlap the range [bytenr, len]
 831  *
 832  * The csum should not be entirely contained in the range and the range should
 833  * not be entirely contained in the csum.
 834  *
 835  * This calls btrfs_truncate_item with the correct args based on the overlap,
 836  * and fixes up the key as required.
 837  */
 838 static noinline void truncate_one_csum(struct btrfs_fs_info *fs_info,
 839                                        struct btrfs_path *path,
 840                                        struct btrfs_key *key,
 841                                        u64 bytenr, u64 len)
 842 {
 843         struct extent_buffer *leaf;
 844         const u32 csum_size = fs_info->csum_size;
 845         u64 csum_end;
 846         u64 end_byte = bytenr + len;
 847         u32 blocksize_bits = fs_info->sectorsize_bits;
 848
 849         leaf = path->nodes[0];
 850         csum_end = btrfs_item_size(leaf, path->slots[0]) / csum_size;
 851         csum_end <<= blocksize_bits;
 852         csum_end += key->offset;
 853
 854         if (key->offset < bytenr && csum_end <= end_byte) {
 855                 /*
 856                  *         [ bytenr - len ]
 857                  *         [   ]
 858                  *   [csum     ]
 859                  *   A simple truncate off the end of the item
 860                  */
 861                 u32 new_size = (bytenr - key->offset) >> blocksize_bits;
 862                 new_size *= csum_size;
 863                 btrfs_truncate_item(path, new_size, 1);
 864         } else if (key->offset >= bytenr && csum_end > end_byte &&
 865                    end_byte > key->offset) {
 866                 /*
 867                  *         [ bytenr - len ]
 868                  *                 [ ]
 869                  *                 [csum     ]
 870                  * we need to truncate from the beginning of the csum
 871                  */
 872                 u32 new_size = (csum_end - end_byte) >> blocksize_bits;
 873                 new_size *= csum_size;
 874
 875                 btrfs_truncate_item(path, new_size, 0);
 876
 877                 key->offset = end_byte;
 878                 btrfs_set_item_key_safe(fs_info, path, key);
 879         } else {
 880                 BUG();
 881         }
 882 }
 883
 884 /*
 885  * Delete the csum items from the csum tree for a given range of bytes.
 886  */
 887 int btrfs_del_csums(struct btrfs_trans_handle *trans,
 888                     struct btrfs_root *root, u64 bytenr, u64 len)
 889 {
 890         struct btrfs_fs_info *fs_info = trans->fs_info;
 891         struct btrfs_path *path;
 892         struct btrfs_key key;
 893         u64 end_byte = bytenr + len;
 894         u64 csum_end;
 895         struct extent_buffer *leaf;
 896         int ret = 0;
 897         const u32 csum_size = fs_info->csum_size;
 898         u32 blocksize_bits = fs_info->sectorsize_bits;
 899
 900         ASSERT(root->root_key.objectid == BTRFS_CSUM_TREE_OBJECTID ||
 901                root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID);
 902
 903         path = btrfs_alloc_path();
 904         if (!path)
 905                 return -ENOMEM;
 906
 907         while (1) {
 908                 key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
 909                 key.offset = end_byte - 1;
 910                 key.type = BTRFS_EXTENT_CSUM_KEY;
 911
 912                 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
 913                 if (ret > 0) {
 914                         ret = 0;
 915                         if (path->slots[0] == 0)
 916                                 break;
 917                         path->slots[0]--;
 918                 } else if (ret < 0) {
 919                         break;
 920                 }
 921
 922                 leaf = path->nodes[0];
 923                 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
 924
 925                 if (key.objectid != BTRFS_EXTENT_CSUM_OBJECTID ||
 926                     key.type != BTRFS_EXTENT_CSUM_KEY) {
 927                         break;
 928                 }
 929
 930                 if (key.offset >= end_byte)
 931                         break;
 932
 933                 csum_end = btrfs_item_size(leaf, path->slots[0]) / csum_size;
 934                 csum_end <<= blocksize_bits;
 935                 csum_end += key.offset;
 936
 937                 /* this csum ends before we start, we're done */
 938                 if (csum_end <= bytenr)
 939                         break;
 940
 941                 /* delete the entire item, it is inside our range */
 942                 if (key.offset >= bytenr && csum_end <= end_byte) {
 943                         int del_nr = 1;
 944
 945                         /*
 946                          * Check how many csum items preceding this one in this
 947                          * leaf correspond to our range and then delete them all
 948                          * at once.
 949                          */
 950                         if (key.offset > bytenr && path->slots[0] > 0) {
 951                                 int slot = path->slots[0] - 1;
 952
 953                                 while (slot >= 0) {
 954                                         struct btrfs_key pk;
 955
 956                                         btrfs_item_key_to_cpu(leaf, &pk, slot);
 957                                         if (pk.offset < bytenr ||
 958                                             pk.type != BTRFS_EXTENT_CSUM_KEY ||
 959                                             pk.objectid !=
 960                                             BTRFS_EXTENT_CSUM_OBJECTID)
 961                                                 break;
 962                                         path->slots[0] = slot;
 963                                         del_nr++;
 964                                         key.offset = pk.offset;
 965                                         slot--;
 966                                 }
 967                         }
 968                         ret = btrfs_del_items(trans, root, path,
 969                                               path->slots[0], del_nr);
 970                         if (ret)
 971                                 break;
 972                         if (key.offset == bytenr)
 973                                 break;
 974                 } else if (key.offset < bytenr && csum_end > end_byte) {
 975                         unsigned long offset;
 976                         unsigned long shift_len;
 977                         unsigned long item_offset;
 978                         /*
 979                          *        [ bytenr - len ]
 980                          *     [csum                ]
 981                          *
 982                          * Our bytes are in the middle of the csum,
 983                          * we need to split this item and insert a new one.
 984                          *
 985                          * But we can't drop the path because the
 986                          * csum could change, get removed, extended etc.
 987                          *
 988                          * The trick here is the max size of a csum item leaves
 989                          * enough room in the tree block for a single
 990                          * item header.  So, we split the item in place,
 991                          * adding a new header pointing to the existing
 992                          * bytes.  Then we loop around again and we have
 993                          * a nicely formed csum item that we can neatly
 994                          * truncate.
 995                          */
 996                         offset = (bytenr - key.offset) >> blocksize_bits;
 997                         offset *= csum_size;
 998
 999                         shift_len = (len >> blocksize_bits) * csum_size;
1000
1001                         item_offset = btrfs_item_ptr_offset(leaf,
1002                                                             path->slots[0]);
1003
1004                         memzero_extent_buffer(leaf, item_offset + offset,
1005                                              shift_len);
1006                         key.offset = bytenr;
1007
1008                         /*
1009                          * btrfs_split_item returns -EAGAIN when the
1010                          * item changed size or key
1011                          */
1012                         ret = btrfs_split_item(trans, root, path, &key, offset);
1013                         if (ret && ret != -EAGAIN) {
1014                                 btrfs_abort_transaction(trans, ret);
1015                                 break;
1016                         }
1017                         ret = 0;
1018
1019                         key.offset = end_byte - 1;
1020                 } else {
1021                         truncate_one_csum(fs_info, path, &key, bytenr, len);
1022                         if (key.offset < bytenr)
1023                                 break;
1024                 }
1025                 btrfs_release_path(path);
1026         }
1027         btrfs_free_path(path);
1028         return ret;
1029 }
1030
1031 static int find_next_csum_offset(struct btrfs_root *root,
1032                                  struct btrfs_path *path,
1033                                  u64 *next_offset)
1034 {
1035         const u32 nritems = btrfs_header_nritems(path->nodes[0]);
1036         struct btrfs_key found_key;
1037         int slot = path->slots[0] + 1;
1038         int ret;
1039
1040         if (nritems == 0 || slot >= nritems) {
1041                 ret = btrfs_next_leaf(root, path);
1042                 if (ret < 0) {
1043                         return ret;
1044                 } else if (ret > 0) {
1045                         *next_offset = (u64)-1;
1046                         return 0;
1047                 }
1048                 slot = path->slots[0];
1049         }
1050
1051         btrfs_item_key_to_cpu(path->nodes[0], &found_key, slot);
1052
1053         if (found_key.objectid != BTRFS_EXTENT_CSUM_OBJECTID ||
1054             found_key.type != BTRFS_EXTENT_CSUM_KEY)
1055                 *next_offset = (u64)-1;
1056         else
1057                 *next_offset = found_key.offset;
1058
1059         return 0;
1060 }
1061
1062 int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,
1063                            struct btrfs_root *root,
1064                            struct btrfs_ordered_sum *sums)
1065 {
1066         struct btrfs_fs_info *fs_info = root->fs_info;
1067         struct btrfs_key file_key;
1068         struct btrfs_key found_key;
1069         struct btrfs_path *path;
1070         struct btrfs_csum_item *item;
1071         struct btrfs_csum_item *item_end;
1072         struct extent_buffer *leaf = NULL;
1073         u64 next_offset;
1074         u64 total_bytes = 0;
1075         u64 csum_offset;
1076         u64 bytenr;
1077         u32 ins_size;
1078         int index = 0;
1079         int found_next;
1080         int ret;
1081         const u32 csum_size = fs_info->csum_size;
1082
1083         path = btrfs_alloc_path();
1084         if (!path)
1085                 return -ENOMEM;
1086 again:
1087         next_offset = (u64)-1;
1088         found_next = 0;
1089         bytenr = sums->bytenr + total_bytes;
1090         file_key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
1091         file_key.offset = bytenr;
1092         file_key.type = BTRFS_EXTENT_CSUM_KEY;
1093
1094         item = btrfs_lookup_csum(trans, root, path, bytenr, 1);
1095         if (!IS_ERR(item)) {
1096                 ret = 0;
1097                 leaf = path->nodes[0];
1098                 item_end = btrfs_item_ptr(leaf, path->slots[0],
1099                                           struct btrfs_csum_item);
1100                 item_end = (struct btrfs_csum_item *)((char *)item_end +
1101                            btrfs_item_size(leaf, path->slots[0]));
1102                 goto found;
1103         }
1104         ret = PTR_ERR(item);
1105         if (ret != -EFBIG && ret != -ENOENT)
1106                 goto out;
1107
1108         if (ret == -EFBIG) {
1109                 u32 item_size;
1110                 /* we found one, but it isn't big enough yet */
1111                 leaf = path->nodes[0];
1112                 item_size = btrfs_item_size(leaf, path->slots[0]);
1113                 if ((item_size / csum_size) >=
1114                     MAX_CSUM_ITEMS(fs_info, csum_size)) {
1115                         /* already at max size, make a new one */
1116                         goto insert;
1117                 }
1118         } else {
1119                 /* We didn't find a csum item, insert one. */
1120                 ret = find_next_csum_offset(root, path, &next_offset);
1121                 if (ret < 0)
1122                         goto out;
1123                 found_next = 1;
1124                 goto insert;
1125         }
1126
1127         /*
1128          * At this point, we know the tree has a checksum item that ends at an
1129          * offset matching the start of the checksum range we want to insert.
1130          * We try to extend that item as much as possible and then add as many
1131          * checksums to it as they fit.
1132          *
1133          * First check if the leaf has enough free space for at least one
1134          * checksum. If it has go directly to the item extension code, otherwise
1135          * release the path and do a search for insertion before the extension.
1136          */
1137         if (btrfs_leaf_free_space(leaf) >= csum_size) {
1138                 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
1139                 csum_offset = (bytenr - found_key.offset) >>
1140                         fs_info->sectorsize_bits;
1141                 goto extend_csum;
1142         }
1143
1144         btrfs_release_path(path);
1145         path->search_for_extension = 1;
1146         ret = btrfs_search_slot(trans, root, &file_key, path,
1147                                 csum_size, 1);
1148         path->search_for_extension = 0;
1149         if (ret < 0)
1150                 goto out;
1151
1152         if (ret > 0) {
1153                 if (path->slots[0] == 0)
1154                         goto insert;
1155                 path->slots[0]--;
1156         }
1157
1158         leaf = path->nodes[0];
1159         btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
1160         csum_offset = (bytenr - found_key.offset) >> fs_info->sectorsize_bits;
1161
1162         if (found_key.type != BTRFS_EXTENT_CSUM_KEY ||
1163             found_key.objectid != BTRFS_EXTENT_CSUM_OBJECTID ||
1164             csum_offset >= MAX_CSUM_ITEMS(fs_info, csum_size)) {
1165                 goto insert;
1166         }
1167
1168 extend_csum:
1169         if (csum_offset == btrfs_item_size(leaf, path->slots[0]) /
1170             csum_size) {
1171                 int extend_nr;
1172                 u64 tmp;
1173                 u32 diff;
1174
1175                 tmp = sums->len - total_bytes;
1176                 tmp >>= fs_info->sectorsize_bits;
1177                 WARN_ON(tmp < 1);
1178                 extend_nr = max_t(int, 1, tmp);
1179
1180                 /*
1181                  * A log tree can already have checksum items with a subset of
1182                  * the checksums we are trying to log. This can happen after
1183                  * doing a sequence of partial writes into prealloc extents and
1184                  * fsyncs in between, with a full fsync logging a larger subrange
1185                  * of an extent for which a previous fast fsync logged a smaller
1186                  * subrange. And this happens in particular due to merging file
1187                  * extent items when we complete an ordered extent for a range
1188                  * covered by a prealloc extent - this is done at
1189                  * btrfs_mark_extent_written().
1190                  *
1191                  * So if we try to extend the previous checksum item, which has
1192                  * a range that ends at the start of the range we want to insert,
1193                  * make sure we don't extend beyond the start offset of the next
1194                  * checksum item. If we are at the last item in the leaf, then
1195                  * forget the optimization of extending and add a new checksum
1196                  * item - it is not worth the complexity of releasing the path,
1197                  * getting the first key for the next leaf, repeat the btree
1198                  * search, etc, because log trees are temporary anyway and it
1199                  * would only save a few bytes of leaf space.
1200                  */
1201                 if (root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID) {
1202                         if (path->slots[0] + 1 >=
1203                             btrfs_header_nritems(path->nodes[0])) {
1204                                 ret = find_next_csum_offset(root, path, &next_offset);
1205                                 if (ret < 0)
1206                                         goto out;
1207                                 found_next = 1;
1208                                 goto insert;
1209                         }
1210
1211                         ret = find_next_csum_offset(root, path, &next_offset);
1212                         if (ret < 0)
1213                                 goto out;
1214
1215                         tmp = (next_offset - bytenr) >> fs_info->sectorsize_bits;
1216                         if (tmp <= INT_MAX)
1217                                 extend_nr = min_t(int, extend_nr, tmp);
1218                 }
1219
1220                 diff = (csum_offset + extend_nr) * csum_size;
1221                 diff = min(diff,
1222                            MAX_CSUM_ITEMS(fs_info, csum_size) * csum_size);
1223
1224                 diff = diff - btrfs_item_size(leaf, path->slots[0]);
1225                 diff = min_t(u32, btrfs_leaf_free_space(leaf), diff);
1226                 diff /= csum_size;
1227                 diff *= csum_size;
1228
1229                 btrfs_extend_item(path, diff);
1230                 ret = 0;
1231                 goto csum;
1232         }
1233
1234 insert:
1235         btrfs_release_path(path);
1236         csum_offset = 0;
1237         if (found_next) {
1238                 u64 tmp;
1239
1240                 tmp = sums->len - total_bytes;
1241                 tmp >>= fs_info->sectorsize_bits;
1242                 tmp = min(tmp, (next_offset - file_key.offset) >>
1243                                          fs_info->sectorsize_bits);
1244
1245                 tmp = max_t(u64, 1, tmp);
1246                 tmp = min_t(u64, tmp, MAX_CSUM_ITEMS(fs_info, csum_size));
1247                 ins_size = csum_size * tmp;
1248         } else {
1249                 ins_size = csum_size;
1250         }
1251         ret = btrfs_insert_empty_item(trans, root, path, &file_key,
1252                                       ins_size);
1253         if (ret < 0)
1254                 goto out;
1255         if (WARN_ON(ret != 0))
1256                 goto out;
1257         leaf = path->nodes[0];
1258 csum:
1259         item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item);
1260         item_end = (struct btrfs_csum_item *)((unsigned char *)item +
1261                                       btrfs_item_size(leaf, path->slots[0]));
1262         item = (struct btrfs_csum_item *)((unsigned char *)item +
1263                                           csum_offset * csum_size);
1264 found:
1265         ins_size = (u32)(sums->len - total_bytes) >> fs_info->sectorsize_bits;
1266         ins_size *= csum_size;
1267         ins_size = min_t(u32, (unsigned long)item_end - (unsigned long)item,
1268                               ins_size);
1269         write_extent_buffer(leaf, sums->sums + index, (unsigned long)item,
1270                             ins_size);
1271
1272         index += ins_size;
1273         ins_size /= csum_size;
1274         total_bytes += ins_size * fs_info->sectorsize;
1275
1276         btrfs_mark_buffer_dirty(path->nodes[0]);
1277         if (total_bytes < sums->len) {
1278                 btrfs_release_path(path);
1279                 cond_resched();
1280                 goto again;
1281         }
1282 out:
1283         btrfs_free_path(path);
1284         return ret;
1285 }
1286
1287 void btrfs_extent_item_to_extent_map(struct btrfs_inode *inode,
1288                                      const struct btrfs_path *path,
1289                                      struct btrfs_file_extent_item *fi,
1290                                      struct extent_map *em)
1291 {
1292         struct btrfs_fs_info *fs_info = inode->root->fs_info;
1293         struct btrfs_root *root = inode->root;
1294         struct extent_buffer *leaf = path->nodes[0];
1295         const int slot = path->slots[0];
1296         struct btrfs_key key;
1297         u64 extent_start, extent_end;
1298         u64 bytenr;
1299         u8 type = btrfs_file_extent_type(leaf, fi);
1300         int compress_type = btrfs_file_extent_compression(leaf, fi);
1301
1302         btrfs_item_key_to_cpu(leaf, &key, slot);
1303         extent_start = key.offset;
1304         extent_end = btrfs_file_extent_end(path);
1305         em->ram_bytes = btrfs_file_extent_ram_bytes(leaf, fi);
1306         em->generation = btrfs_file_extent_generation(leaf, fi);
1307         if (type == BTRFS_FILE_EXTENT_REG ||
1308             type == BTRFS_FILE_EXTENT_PREALLOC) {
1309                 em->start = extent_start;
1310                 em->len = extent_end - extent_start;
1311                 em->orig_start = extent_start -
1312                         btrfs_file_extent_offset(leaf, fi);
1313                 em->orig_block_len = btrfs_file_extent_disk_num_bytes(leaf, fi);
1314                 bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
1315                 if (bytenr == 0) {
1316                         em->block_start = EXTENT_MAP_HOLE;
1317                         return;
1318                 }
1319                 if (compress_type != BTRFS_COMPRESS_NONE) {
1320                         set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
1321                         em->compress_type = compress_type;
1322                         em->block_start = bytenr;
1323                         em->block_len = em->orig_block_len;
1324                 } else {
1325                         bytenr += btrfs_file_extent_offset(leaf, fi);
1326                         em->block_start = bytenr;
1327                         em->block_len = em->len;
1328                         if (type == BTRFS_FILE_EXTENT_PREALLOC)
1329                                 set_bit(EXTENT_FLAG_PREALLOC, &em->flags);
1330                 }
1331         } else if (type == BTRFS_FILE_EXTENT_INLINE) {
1332                 em->block_start = EXTENT_MAP_INLINE;
1333                 em->start = extent_start;
1334                 em->len = extent_end - extent_start;
1335                 /*
1336                  * Initialize orig_start and block_len with the same values
1337                  * as in inode.c:btrfs_get_extent().
1338                  */
1339                 em->orig_start = EXTENT_MAP_HOLE;
1340                 em->block_len = (u64)-1;
1341                 em->compress_type = compress_type;
1342                 if (compress_type != BTRFS_COMPRESS_NONE)
1343                         set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
1344         } else {
1345                 btrfs_err(fs_info,
1346                           "unknown file extent item type %d, inode %llu, offset %llu, "
1347                           "root %llu", type, btrfs_ino(inode), extent_start,
1348                           root->root_key.objectid);
1349         }
1350 }
1351
1352 /*
1353  * Returns the end offset (non inclusive) of the file extent item the given path
1354  * points to. If it points to an inline extent, the returned offset is rounded
1355  * up to the sector size.
1356  */
1357 u64 btrfs_file_extent_end(const struct btrfs_path *path)
1358 {
1359         const struct extent_buffer *leaf = path->nodes[0];
1360         const int slot = path->slots[0];
1361         struct btrfs_file_extent_item *fi;
1362         struct btrfs_key key;
1363         u64 end;
1364
1365         btrfs_item_key_to_cpu(leaf, &key, slot);
1366         ASSERT(key.type == BTRFS_EXTENT_DATA_KEY);
1367         fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
1368
1369         if (btrfs_file_extent_type(leaf, fi) == BTRFS_FILE_EXTENT_INLINE) {
1370                 end = btrfs_file_extent_ram_bytes(leaf, fi);
1371                 end = ALIGN(key.offset + end, leaf->fs_info->sectorsize);
1372         } else {
1373                 end = key.offset + btrfs_file_extent_num_bytes(leaf, fi);
1374         }
1375
1376         return end;
1377 }