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