1c1d7c514SDavid Sterba // SPDX-License-Identifier: GPL-2.0 26cbd5570SChris Mason /* 36cbd5570SChris Mason * Copyright (C) 2007 Oracle. All rights reserved. 46cbd5570SChris Mason */ 56cbd5570SChris Mason 6065631f6SChris Mason #include <linux/bio.h> 75a0e3ad6STejun Heo #include <linux/slab.h> 8065631f6SChris Mason #include <linux/pagemap.h> 9065631f6SChris Mason #include <linux/highmem.h> 10a3d46aeaSNikolay Borisov #include <linux/sched/mm.h> 11d5178578SJohannes Thumshirn #include <crypto/hash.h> 12cea62800SJohannes Thumshirn #include "misc.h" 131e1d2701SChris Mason #include "ctree.h" 14dee26a9fSChris Mason #include "disk-io.h" 159f5fae2fSChris Mason #include "transaction.h" 16facc8a22SMiao Xie #include "volumes.h" 171de037a4SChris Mason #include "print-tree.h" 18ebb8765bSAnand Jain #include "compression.h" 191e1d2701SChris Mason 2042049bf6SChris Mason #define __MAX_CSUM_ITEMS(r, size) ((unsigned long)(((BTRFS_LEAF_DATA_SIZE(r) - \ 2142049bf6SChris Mason sizeof(struct btrfs_item) * 2) / \ 2242049bf6SChris Mason size) - 1)) 2307d400a6SYan Zheng 24221b8318SZach Brown #define MAX_CSUM_ITEMS(r, size) (min_t(u32, __MAX_CSUM_ITEMS(r, size), \ 2509cbfeafSKirill A. Shutemov PAGE_SIZE)) 267ca4be45SChris Mason 2741a2ee75SJosef Bacik /** 28ca4207aeSNikolay Borisov * Set inode's size according to filesystem options 29ca4207aeSNikolay Borisov * 30ca4207aeSNikolay Borisov * @inode: inode we want to update the disk_i_size for 31ca4207aeSNikolay Borisov * @new_i_size: i_size we want to set to, 0 if we use i_size 3241a2ee75SJosef Bacik * 3341a2ee75SJosef Bacik * With NO_HOLES set this simply sets the disk_is_size to whatever i_size_read() 3441a2ee75SJosef Bacik * returns as it is perfectly fine with a file that has holes without hole file 3541a2ee75SJosef Bacik * extent items. 3641a2ee75SJosef Bacik * 3741a2ee75SJosef Bacik * However without NO_HOLES we need to only return the area that is contiguous 3841a2ee75SJosef Bacik * from the 0 offset of the file. Otherwise we could end up adjust i_size up 3941a2ee75SJosef Bacik * to an extent that has a gap in between. 4041a2ee75SJosef Bacik * 4141a2ee75SJosef Bacik * Finally new_i_size should only be set in the case of truncate where we're not 4241a2ee75SJosef Bacik * ready to use i_size_read() as the limiter yet. 4341a2ee75SJosef Bacik */ 4476aea537SNikolay Borisov void btrfs_inode_safe_disk_i_size_write(struct btrfs_inode *inode, u64 new_i_size) 4541a2ee75SJosef Bacik { 4676aea537SNikolay Borisov struct btrfs_fs_info *fs_info = inode->root->fs_info; 4741a2ee75SJosef Bacik u64 start, end, i_size; 4841a2ee75SJosef Bacik int ret; 4941a2ee75SJosef Bacik 5076aea537SNikolay Borisov i_size = new_i_size ?: i_size_read(&inode->vfs_inode); 5141a2ee75SJosef Bacik if (btrfs_fs_incompat(fs_info, NO_HOLES)) { 5276aea537SNikolay Borisov inode->disk_i_size = i_size; 5341a2ee75SJosef Bacik return; 5441a2ee75SJosef Bacik } 5541a2ee75SJosef Bacik 5676aea537SNikolay Borisov spin_lock(&inode->lock); 5776aea537SNikolay Borisov ret = find_contiguous_extent_bit(&inode->file_extent_tree, 0, &start, 5876aea537SNikolay Borisov &end, EXTENT_DIRTY); 5941a2ee75SJosef Bacik if (!ret && start == 0) 6041a2ee75SJosef Bacik i_size = min(i_size, end + 1); 6141a2ee75SJosef Bacik else 6241a2ee75SJosef Bacik i_size = 0; 6376aea537SNikolay Borisov inode->disk_i_size = i_size; 6476aea537SNikolay Borisov spin_unlock(&inode->lock); 6541a2ee75SJosef Bacik } 6641a2ee75SJosef Bacik 6741a2ee75SJosef Bacik /** 68ca4207aeSNikolay Borisov * Mark range within a file as having a new extent inserted 69ca4207aeSNikolay Borisov * 70ca4207aeSNikolay Borisov * @inode: inode being modified 71ca4207aeSNikolay Borisov * @start: start file offset of the file extent we've inserted 72ca4207aeSNikolay Borisov * @len: logical length of the file extent item 7341a2ee75SJosef Bacik * 7441a2ee75SJosef Bacik * Call when we are inserting a new file extent where there was none before. 7541a2ee75SJosef Bacik * Does not need to call this in the case where we're replacing an existing file 7641a2ee75SJosef Bacik * extent, however if not sure it's fine to call this multiple times. 7741a2ee75SJosef Bacik * 7841a2ee75SJosef Bacik * The start and len must match the file extent item, so thus must be sectorsize 7941a2ee75SJosef Bacik * aligned. 8041a2ee75SJosef Bacik */ 8141a2ee75SJosef Bacik int btrfs_inode_set_file_extent_range(struct btrfs_inode *inode, u64 start, 8241a2ee75SJosef Bacik u64 len) 8341a2ee75SJosef Bacik { 8441a2ee75SJosef Bacik if (len == 0) 8541a2ee75SJosef Bacik return 0; 8641a2ee75SJosef Bacik 8741a2ee75SJosef Bacik ASSERT(IS_ALIGNED(start + len, inode->root->fs_info->sectorsize)); 8841a2ee75SJosef Bacik 8941a2ee75SJosef Bacik if (btrfs_fs_incompat(inode->root->fs_info, NO_HOLES)) 9041a2ee75SJosef Bacik return 0; 9141a2ee75SJosef Bacik return set_extent_bits(&inode->file_extent_tree, start, start + len - 1, 9241a2ee75SJosef Bacik EXTENT_DIRTY); 9341a2ee75SJosef Bacik } 9441a2ee75SJosef Bacik 9541a2ee75SJosef Bacik /** 96ca4207aeSNikolay Borisov * Marks an inode range as not having a backing extent 97ca4207aeSNikolay Borisov * 98ca4207aeSNikolay Borisov * @inode: inode being modified 99ca4207aeSNikolay Borisov * @start: start file offset of the file extent we've inserted 100ca4207aeSNikolay Borisov * @len: logical length of the file extent item 10141a2ee75SJosef Bacik * 10241a2ee75SJosef Bacik * Called when we drop a file extent, for example when we truncate. Doesn't 10341a2ee75SJosef Bacik * need to be called for cases where we're replacing a file extent, like when 10441a2ee75SJosef Bacik * we've COWed a file extent. 10541a2ee75SJosef Bacik * 10641a2ee75SJosef Bacik * The start and len must match the file extent item, so thus must be sectorsize 10741a2ee75SJosef Bacik * aligned. 10841a2ee75SJosef Bacik */ 10941a2ee75SJosef Bacik int btrfs_inode_clear_file_extent_range(struct btrfs_inode *inode, u64 start, 11041a2ee75SJosef Bacik u64 len) 11141a2ee75SJosef Bacik { 11241a2ee75SJosef Bacik if (len == 0) 11341a2ee75SJosef Bacik return 0; 11441a2ee75SJosef Bacik 11541a2ee75SJosef Bacik ASSERT(IS_ALIGNED(start + len, inode->root->fs_info->sectorsize) || 11641a2ee75SJosef Bacik len == (u64)-1); 11741a2ee75SJosef Bacik 11841a2ee75SJosef Bacik if (btrfs_fs_incompat(inode->root->fs_info, NO_HOLES)) 11941a2ee75SJosef Bacik return 0; 12041a2ee75SJosef Bacik return clear_extent_bit(&inode->file_extent_tree, start, 12141a2ee75SJosef Bacik start + len - 1, EXTENT_DIRTY, 0, 0, NULL); 12241a2ee75SJosef Bacik } 12341a2ee75SJosef Bacik 1241e25a2e3SJohannes Thumshirn static inline u32 max_ordered_sum_bytes(struct btrfs_fs_info *fs_info, 1251e25a2e3SJohannes Thumshirn u16 csum_size) 1261e25a2e3SJohannes Thumshirn { 1271e25a2e3SJohannes Thumshirn u32 ncsums = (PAGE_SIZE - sizeof(struct btrfs_ordered_sum)) / csum_size; 1281e25a2e3SJohannes Thumshirn 1291e25a2e3SJohannes Thumshirn return ncsums * fs_info->sectorsize; 1301e25a2e3SJohannes Thumshirn } 13107d400a6SYan Zheng 132b18c6685SChris Mason int btrfs_insert_file_extent(struct btrfs_trans_handle *trans, 133dee26a9fSChris Mason struct btrfs_root *root, 134b18c6685SChris Mason u64 objectid, u64 pos, 135f2eb0a24SSage Weil u64 disk_offset, u64 disk_num_bytes, 136c8b97818SChris Mason u64 num_bytes, u64 offset, u64 ram_bytes, 137c8b97818SChris Mason u8 compression, u8 encryption, u16 other_encoding) 1389f5fae2fSChris Mason { 139dee26a9fSChris Mason int ret = 0; 140dee26a9fSChris Mason struct btrfs_file_extent_item *item; 141dee26a9fSChris Mason struct btrfs_key file_key; 1425caf2a00SChris Mason struct btrfs_path *path; 1435f39d397SChris Mason struct extent_buffer *leaf; 144dee26a9fSChris Mason 1455caf2a00SChris Mason path = btrfs_alloc_path(); 146db5b493aSTsutomu Itoh if (!path) 147db5b493aSTsutomu Itoh return -ENOMEM; 148dee26a9fSChris Mason file_key.objectid = objectid; 149b18c6685SChris Mason file_key.offset = pos; 150962a298fSDavid Sterba file_key.type = BTRFS_EXTENT_DATA_KEY; 151dee26a9fSChris Mason 1525caf2a00SChris Mason ret = btrfs_insert_empty_item(trans, root, path, &file_key, 153dee26a9fSChris Mason sizeof(*item)); 15454aa1f4dSChris Mason if (ret < 0) 15554aa1f4dSChris Mason goto out; 15679787eaaSJeff Mahoney BUG_ON(ret); /* Can't happen */ 1575f39d397SChris Mason leaf = path->nodes[0]; 1585f39d397SChris Mason item = btrfs_item_ptr(leaf, path->slots[0], 159dee26a9fSChris Mason struct btrfs_file_extent_item); 160f2eb0a24SSage Weil btrfs_set_file_extent_disk_bytenr(leaf, item, disk_offset); 161db94535dSChris Mason btrfs_set_file_extent_disk_num_bytes(leaf, item, disk_num_bytes); 162f2eb0a24SSage Weil btrfs_set_file_extent_offset(leaf, item, offset); 163db94535dSChris Mason btrfs_set_file_extent_num_bytes(leaf, item, num_bytes); 164c8b97818SChris Mason btrfs_set_file_extent_ram_bytes(leaf, item, ram_bytes); 1655f39d397SChris Mason btrfs_set_file_extent_generation(leaf, item, trans->transid); 1665f39d397SChris Mason btrfs_set_file_extent_type(leaf, item, BTRFS_FILE_EXTENT_REG); 167c8b97818SChris Mason btrfs_set_file_extent_compression(leaf, item, compression); 168c8b97818SChris Mason btrfs_set_file_extent_encryption(leaf, item, encryption); 169c8b97818SChris Mason btrfs_set_file_extent_other_encoding(leaf, item, other_encoding); 170c8b97818SChris Mason 1715f39d397SChris Mason btrfs_mark_buffer_dirty(leaf); 17254aa1f4dSChris Mason out: 1735caf2a00SChris Mason btrfs_free_path(path); 17454aa1f4dSChris Mason return ret; 1759f5fae2fSChris Mason } 176dee26a9fSChris Mason 17748a3b636SEric Sandeen static struct btrfs_csum_item * 17848a3b636SEric Sandeen btrfs_lookup_csum(struct btrfs_trans_handle *trans, 179b18c6685SChris Mason struct btrfs_root *root, 1806567e837SChris Mason struct btrfs_path *path, 181d20f7043SChris Mason u64 bytenr, int cow) 1826567e837SChris Mason { 1830b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 1846567e837SChris Mason int ret; 1856567e837SChris Mason struct btrfs_key file_key; 1866567e837SChris Mason struct btrfs_key found_key; 1876567e837SChris Mason struct btrfs_csum_item *item; 1885f39d397SChris Mason struct extent_buffer *leaf; 1896567e837SChris Mason u64 csum_offset = 0; 190223486c2SDavid Sterba const u32 csum_size = fs_info->csum_size; 191a429e513SChris Mason int csums_in_item; 1926567e837SChris Mason 193d20f7043SChris Mason file_key.objectid = BTRFS_EXTENT_CSUM_OBJECTID; 194d20f7043SChris Mason file_key.offset = bytenr; 195962a298fSDavid Sterba file_key.type = BTRFS_EXTENT_CSUM_KEY; 196b18c6685SChris Mason ret = btrfs_search_slot(trans, root, &file_key, path, 0, cow); 1976567e837SChris Mason if (ret < 0) 1986567e837SChris Mason goto fail; 1995f39d397SChris Mason leaf = path->nodes[0]; 2006567e837SChris Mason if (ret > 0) { 2016567e837SChris Mason ret = 1; 20270b2befdSChris Mason if (path->slots[0] == 0) 2036567e837SChris Mason goto fail; 2046567e837SChris Mason path->slots[0]--; 2055f39d397SChris Mason btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); 206962a298fSDavid Sterba if (found_key.type != BTRFS_EXTENT_CSUM_KEY) 2076567e837SChris Mason goto fail; 208d20f7043SChris Mason 209d20f7043SChris Mason csum_offset = (bytenr - found_key.offset) >> 210265fdfa6SDavid Sterba fs_info->sectorsize_bits; 2115f39d397SChris Mason csums_in_item = btrfs_item_size_nr(leaf, path->slots[0]); 212607d432dSJosef Bacik csums_in_item /= csum_size; 213a429e513SChris Mason 21482d130ffSMiao Xie if (csum_offset == csums_in_item) { 215a429e513SChris Mason ret = -EFBIG; 2166567e837SChris Mason goto fail; 21782d130ffSMiao Xie } else if (csum_offset > csums_in_item) { 21882d130ffSMiao Xie goto fail; 2196567e837SChris Mason } 2206567e837SChris Mason } 2216567e837SChris Mason item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item); 222509659cdSChris Mason item = (struct btrfs_csum_item *)((unsigned char *)item + 223607d432dSJosef Bacik csum_offset * csum_size); 2246567e837SChris Mason return item; 2256567e837SChris Mason fail: 2266567e837SChris Mason if (ret > 0) 227b18c6685SChris Mason ret = -ENOENT; 2286567e837SChris Mason return ERR_PTR(ret); 2296567e837SChris Mason } 2306567e837SChris Mason 231dee26a9fSChris Mason int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans, 232dee26a9fSChris Mason struct btrfs_root *root, 233dee26a9fSChris Mason struct btrfs_path *path, u64 objectid, 2349773a788SChris Mason u64 offset, int mod) 235dee26a9fSChris Mason { 236dee26a9fSChris Mason struct btrfs_key file_key; 237dee26a9fSChris Mason int ins_len = mod < 0 ? -1 : 0; 238dee26a9fSChris Mason int cow = mod != 0; 239dee26a9fSChris Mason 240dee26a9fSChris Mason file_key.objectid = objectid; 24170b2befdSChris Mason file_key.offset = offset; 242962a298fSDavid Sterba file_key.type = BTRFS_EXTENT_DATA_KEY; 243*f8ee80deSMarcos Paulo de Souza 244*f8ee80deSMarcos Paulo de Souza return btrfs_search_slot(trans, root, &file_key, path, ins_len, cow); 245dee26a9fSChris Mason } 246f254e52cSChris Mason 2476275193eSQu Wenruo /* 2486275193eSQu Wenruo * Find checksums for logical bytenr range [disk_bytenr, disk_bytenr + len) and 2496275193eSQu Wenruo * estore the result to @dst. 2506275193eSQu Wenruo * 2516275193eSQu Wenruo * Return >0 for the number of sectors we found. 2526275193eSQu Wenruo * Return 0 for the range [disk_bytenr, disk_bytenr + sectorsize) has no csum 2536275193eSQu Wenruo * for it. Caller may want to try next sector until one range is hit. 2546275193eSQu Wenruo * Return <0 for fatal error. 2556275193eSQu Wenruo */ 2566275193eSQu Wenruo static int search_csum_tree(struct btrfs_fs_info *fs_info, 2576275193eSQu Wenruo struct btrfs_path *path, u64 disk_bytenr, 2586275193eSQu Wenruo u64 len, u8 *dst) 2596275193eSQu Wenruo { 2606275193eSQu Wenruo struct btrfs_csum_item *item = NULL; 2616275193eSQu Wenruo struct btrfs_key key; 2626275193eSQu Wenruo const u32 sectorsize = fs_info->sectorsize; 2636275193eSQu Wenruo const u32 csum_size = fs_info->csum_size; 2646275193eSQu Wenruo u32 itemsize; 2656275193eSQu Wenruo int ret; 2666275193eSQu Wenruo u64 csum_start; 2676275193eSQu Wenruo u64 csum_len; 2686275193eSQu Wenruo 2696275193eSQu Wenruo ASSERT(IS_ALIGNED(disk_bytenr, sectorsize) && 2706275193eSQu Wenruo IS_ALIGNED(len, sectorsize)); 2716275193eSQu Wenruo 2726275193eSQu Wenruo /* Check if the current csum item covers disk_bytenr */ 2736275193eSQu Wenruo if (path->nodes[0]) { 2746275193eSQu Wenruo item = btrfs_item_ptr(path->nodes[0], path->slots[0], 2756275193eSQu Wenruo struct btrfs_csum_item); 2766275193eSQu Wenruo btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]); 2776275193eSQu Wenruo itemsize = btrfs_item_size_nr(path->nodes[0], path->slots[0]); 2786275193eSQu Wenruo 2796275193eSQu Wenruo csum_start = key.offset; 2806275193eSQu Wenruo csum_len = (itemsize / csum_size) * sectorsize; 2816275193eSQu Wenruo 2826275193eSQu Wenruo if (in_range(disk_bytenr, csum_start, csum_len)) 2836275193eSQu Wenruo goto found; 2846275193eSQu Wenruo } 2856275193eSQu Wenruo 2866275193eSQu Wenruo /* Current item doesn't contain the desired range, search again */ 2876275193eSQu Wenruo btrfs_release_path(path); 2886275193eSQu Wenruo item = btrfs_lookup_csum(NULL, fs_info->csum_root, path, disk_bytenr, 0); 2896275193eSQu Wenruo if (IS_ERR(item)) { 2906275193eSQu Wenruo ret = PTR_ERR(item); 2916275193eSQu Wenruo goto out; 2926275193eSQu Wenruo } 2936275193eSQu Wenruo btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]); 2946275193eSQu Wenruo itemsize = btrfs_item_size_nr(path->nodes[0], path->slots[0]); 2956275193eSQu Wenruo 2966275193eSQu Wenruo csum_start = key.offset; 2976275193eSQu Wenruo csum_len = (itemsize / csum_size) * sectorsize; 2986275193eSQu Wenruo ASSERT(in_range(disk_bytenr, csum_start, csum_len)); 2996275193eSQu Wenruo 3006275193eSQu Wenruo found: 3016275193eSQu Wenruo ret = (min(csum_start + csum_len, disk_bytenr + len) - 3026275193eSQu Wenruo disk_bytenr) >> fs_info->sectorsize_bits; 3036275193eSQu Wenruo read_extent_buffer(path->nodes[0], dst, (unsigned long)item, 3046275193eSQu Wenruo ret * csum_size); 3056275193eSQu Wenruo out: 3066275193eSQu Wenruo if (ret == -ENOENT) 3076275193eSQu Wenruo ret = 0; 3086275193eSQu Wenruo return ret; 3096275193eSQu Wenruo } 3106275193eSQu Wenruo 3116275193eSQu Wenruo /* 3126275193eSQu Wenruo * Locate the file_offset of @cur_disk_bytenr of a @bio. 3136275193eSQu Wenruo * 3146275193eSQu Wenruo * Bio of btrfs represents read range of 3156275193eSQu Wenruo * [bi_sector << 9, bi_sector << 9 + bi_size). 3166275193eSQu Wenruo * Knowing this, we can iterate through each bvec to locate the page belong to 3176275193eSQu Wenruo * @cur_disk_bytenr and get the file offset. 3186275193eSQu Wenruo * 3196275193eSQu Wenruo * @inode is used to determine if the bvec page really belongs to @inode. 3206275193eSQu Wenruo * 3216275193eSQu Wenruo * Return 0 if we can't find the file offset 3226275193eSQu Wenruo * Return >0 if we find the file offset and restore it to @file_offset_ret 3236275193eSQu Wenruo */ 3246275193eSQu Wenruo static int search_file_offset_in_bio(struct bio *bio, struct inode *inode, 3256275193eSQu Wenruo u64 disk_bytenr, u64 *file_offset_ret) 3266275193eSQu Wenruo { 3276275193eSQu Wenruo struct bvec_iter iter; 3286275193eSQu Wenruo struct bio_vec bvec; 3296275193eSQu Wenruo u64 cur = bio->bi_iter.bi_sector << SECTOR_SHIFT; 3306275193eSQu Wenruo int ret = 0; 3316275193eSQu Wenruo 3326275193eSQu Wenruo bio_for_each_segment(bvec, bio, iter) { 3336275193eSQu Wenruo struct page *page = bvec.bv_page; 3346275193eSQu Wenruo 3356275193eSQu Wenruo if (cur > disk_bytenr) 3366275193eSQu Wenruo break; 3376275193eSQu Wenruo if (cur + bvec.bv_len <= disk_bytenr) { 3386275193eSQu Wenruo cur += bvec.bv_len; 3396275193eSQu Wenruo continue; 3406275193eSQu Wenruo } 3416275193eSQu Wenruo ASSERT(in_range(disk_bytenr, cur, bvec.bv_len)); 3426275193eSQu Wenruo if (page->mapping && page->mapping->host && 3436275193eSQu Wenruo page->mapping->host == inode) { 3446275193eSQu Wenruo ret = 1; 3456275193eSQu Wenruo *file_offset_ret = page_offset(page) + bvec.bv_offset + 3466275193eSQu Wenruo disk_bytenr - cur; 3476275193eSQu Wenruo break; 3486275193eSQu Wenruo } 3496275193eSQu Wenruo } 3506275193eSQu Wenruo return ret; 3516275193eSQu Wenruo } 3526275193eSQu Wenruo 353e62958fcSOmar Sandoval /** 3546275193eSQu Wenruo * Lookup the checksum for the read bio in csum tree. 3559e46458aSQu Wenruo * 356e62958fcSOmar Sandoval * @inode: inode that the bio is for. 357fb30f470SOmar Sandoval * @bio: bio to look up. 358fb30f470SOmar Sandoval * @dst: Buffer of size nblocks * btrfs_super_csum_size() used to return 359fb30f470SOmar Sandoval * checksum (nblocks = bio->bi_iter.bi_size / fs_info->sectorsize). If 360fb30f470SOmar Sandoval * NULL, the checksum buffer is allocated and returned in 361fb30f470SOmar Sandoval * btrfs_io_bio(bio)->csum instead. 362e62958fcSOmar Sandoval * 363e62958fcSOmar Sandoval * Return: BLK_STS_RESOURCE if allocating memory fails, BLK_STS_OK otherwise. 364e62958fcSOmar Sandoval */ 3656275193eSQu Wenruo blk_status_t btrfs_lookup_bio_sums(struct inode *inode, struct bio *bio, u8 *dst) 36661b49440SChris Mason { 3670b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 368facc8a22SMiao Xie struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; 369facc8a22SMiao Xie struct btrfs_path *path; 3706275193eSQu Wenruo const u32 sectorsize = fs_info->sectorsize; 371223486c2SDavid Sterba const u32 csum_size = fs_info->csum_size; 3726275193eSQu Wenruo u32 orig_len = bio->bi_iter.bi_size; 3736275193eSQu Wenruo u64 orig_disk_bytenr = bio->bi_iter.bi_sector << SECTOR_SHIFT; 3746275193eSQu Wenruo u64 cur_disk_bytenr; 3756275193eSQu Wenruo u8 *csum; 3766275193eSQu Wenruo const unsigned int nblocks = orig_len >> fs_info->sectorsize_bits; 3776275193eSQu Wenruo int count = 0; 37861b49440SChris Mason 37942437a63SJosef Bacik if (!fs_info->csum_root || (BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)) 380334c16d8SJosef Bacik return BLK_STS_OK; 381334c16d8SJosef Bacik 3829e46458aSQu Wenruo /* 3839e46458aSQu Wenruo * This function is only called for read bio. 3849e46458aSQu Wenruo * 3859e46458aSQu Wenruo * This means two things: 3869e46458aSQu Wenruo * - All our csums should only be in csum tree 3879e46458aSQu Wenruo * No ordered extents csums, as ordered extents are only for write 3889e46458aSQu Wenruo * path. 3896275193eSQu Wenruo * - No need to bother any other info from bvec 3906275193eSQu Wenruo * Since we're looking up csums, the only important info is the 3916275193eSQu Wenruo * disk_bytenr and the length, which can be extracted from bi_iter 3926275193eSQu Wenruo * directly. 3939e46458aSQu Wenruo */ 3949e46458aSQu Wenruo ASSERT(bio_op(bio) == REQ_OP_READ); 39561b49440SChris Mason path = btrfs_alloc_path(); 396c2db1073STsutomu Itoh if (!path) 3974e4cbee9SChristoph Hellwig return BLK_STS_RESOURCE; 398facc8a22SMiao Xie 399facc8a22SMiao Xie if (!dst) { 400fb30f470SOmar Sandoval struct btrfs_io_bio *btrfs_bio = btrfs_io_bio(bio); 401fb30f470SOmar Sandoval 402facc8a22SMiao Xie if (nblocks * csum_size > BTRFS_BIO_INLINE_CSUM_SIZE) { 40331fecccbSDavid Sterba btrfs_bio->csum = kmalloc_array(nblocks, csum_size, 40431fecccbSDavid Sterba GFP_NOFS); 40531fecccbSDavid Sterba if (!btrfs_bio->csum) { 406facc8a22SMiao Xie btrfs_free_path(path); 4074e4cbee9SChristoph Hellwig return BLK_STS_RESOURCE; 408facc8a22SMiao Xie } 409facc8a22SMiao Xie } else { 410facc8a22SMiao Xie btrfs_bio->csum = btrfs_bio->csum_inline; 411facc8a22SMiao Xie } 412facc8a22SMiao Xie csum = btrfs_bio->csum; 413facc8a22SMiao Xie } else { 41410fe6ca8SJohannes Thumshirn csum = dst; 415facc8a22SMiao Xie } 416facc8a22SMiao Xie 41735478d05SQu Wenruo /* 41835478d05SQu Wenruo * If requested number of sectors is larger than one leaf can contain, 41935478d05SQu Wenruo * kick the readahead for csum tree. 42035478d05SQu Wenruo */ 42135478d05SQu Wenruo if (nblocks > fs_info->csums_per_leaf) 422e4058b54SDavid Sterba path->reada = READA_FORWARD; 42361b49440SChris Mason 4242cf8572dSChris Mason /* 4252cf8572dSChris Mason * the free space stuff is only read when it hasn't been 4262cf8572dSChris Mason * updated in the current transaction. So, we can safely 4272cf8572dSChris Mason * read from the commit root and sidestep a nasty deadlock 4282cf8572dSChris Mason * between reading the free space cache and updating the csum tree. 4292cf8572dSChris Mason */ 43070ddc553SNikolay Borisov if (btrfs_is_free_space_inode(BTRFS_I(inode))) { 4312cf8572dSChris Mason path->search_commit_root = 1; 432ddf23b3fSJosef Bacik path->skip_locking = 1; 433ddf23b3fSJosef Bacik } 4342cf8572dSChris Mason 4356275193eSQu Wenruo for (cur_disk_bytenr = orig_disk_bytenr; 4366275193eSQu Wenruo cur_disk_bytenr < orig_disk_bytenr + orig_len; 4376275193eSQu Wenruo cur_disk_bytenr += (count * sectorsize)) { 4386275193eSQu Wenruo u64 search_len = orig_disk_bytenr + orig_len - cur_disk_bytenr; 4396275193eSQu Wenruo unsigned int sector_offset; 4406275193eSQu Wenruo u8 *csum_dst; 441c40a3d38SChandan Rajendra 4426275193eSQu Wenruo /* 4436275193eSQu Wenruo * Although both cur_disk_bytenr and orig_disk_bytenr is u64, 4446275193eSQu Wenruo * we're calculating the offset to the bio start. 4456275193eSQu Wenruo * 4466275193eSQu Wenruo * Bio size is limited to UINT_MAX, thus unsigned int is large 4476275193eSQu Wenruo * enough to contain the raw result, not to mention the right 4486275193eSQu Wenruo * shifted result. 4496275193eSQu Wenruo */ 4506275193eSQu Wenruo ASSERT(cur_disk_bytenr - orig_disk_bytenr < UINT_MAX); 4516275193eSQu Wenruo sector_offset = (cur_disk_bytenr - orig_disk_bytenr) >> 4526275193eSQu Wenruo fs_info->sectorsize_bits; 4536275193eSQu Wenruo csum_dst = csum + sector_offset * csum_size; 4544989d277SChristoph Hellwig 4556275193eSQu Wenruo count = search_csum_tree(fs_info, path, cur_disk_bytenr, 4566275193eSQu Wenruo search_len, csum_dst); 4576275193eSQu Wenruo if (count <= 0) { 4586275193eSQu Wenruo /* 4596275193eSQu Wenruo * Either we hit a critical error or we didn't find 4606275193eSQu Wenruo * the csum. 4616275193eSQu Wenruo * Either way, we put zero into the csums dst, and skip 4626275193eSQu Wenruo * to the next sector. 4636275193eSQu Wenruo */ 4646275193eSQu Wenruo memset(csum_dst, 0, csum_size); 465e4100d98SMiao Xie count = 1; 4666275193eSQu Wenruo 4676275193eSQu Wenruo /* 4686275193eSQu Wenruo * For data reloc inode, we need to mark the range 4696275193eSQu Wenruo * NODATASUM so that balance won't report false csum 4706275193eSQu Wenruo * error. 4716275193eSQu Wenruo */ 47217d217feSYan Zheng if (BTRFS_I(inode)->root->root_key.objectid == 47317d217feSYan Zheng BTRFS_DATA_RELOC_TREE_OBJECTID) { 4746275193eSQu Wenruo u64 file_offset; 4756275193eSQu Wenruo int ret; 4766275193eSQu Wenruo 4776275193eSQu Wenruo ret = search_file_offset_in_bio(bio, inode, 4786275193eSQu Wenruo cur_disk_bytenr, &file_offset); 4796275193eSQu Wenruo if (ret) 4806275193eSQu Wenruo set_extent_bits(io_tree, file_offset, 4816275193eSQu Wenruo file_offset + sectorsize - 1, 482ceeb0ae7SDavid Sterba EXTENT_NODATASUM); 48317d217feSYan Zheng } else { 4846275193eSQu Wenruo btrfs_warn_rl(fs_info, 4856275193eSQu Wenruo "csum hole found for disk bytenr range [%llu, %llu)", 4866275193eSQu Wenruo cur_disk_bytenr, cur_disk_bytenr + sectorsize); 48717d217feSYan Zheng } 4884989d277SChristoph Hellwig } 4894989d277SChristoph Hellwig } 4904989d277SChristoph Hellwig 49161b49440SChris Mason btrfs_free_path(path); 492e62958fcSOmar Sandoval return BLK_STS_OK; 4934b46fce2SJosef Bacik } 4944b46fce2SJosef Bacik 49517d217feSYan Zheng int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end, 496a2de733cSArne Jansen struct list_head *list, int search_commit) 49717d217feSYan Zheng { 4980b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 49917d217feSYan Zheng struct btrfs_key key; 50017d217feSYan Zheng struct btrfs_path *path; 50117d217feSYan Zheng struct extent_buffer *leaf; 50217d217feSYan Zheng struct btrfs_ordered_sum *sums; 50317d217feSYan Zheng struct btrfs_csum_item *item; 5040678b618SMark Fasheh LIST_HEAD(tmplist); 50517d217feSYan Zheng unsigned long offset; 50617d217feSYan Zheng int ret; 50717d217feSYan Zheng size_t size; 50817d217feSYan Zheng u64 csum_end; 509223486c2SDavid Sterba const u32 csum_size = fs_info->csum_size; 51017d217feSYan Zheng 5110b246afaSJeff Mahoney ASSERT(IS_ALIGNED(start, fs_info->sectorsize) && 5120b246afaSJeff Mahoney IS_ALIGNED(end + 1, fs_info->sectorsize)); 5134277a9c3SJosef Bacik 51417d217feSYan Zheng path = btrfs_alloc_path(); 515d8926bb3SMark Fasheh if (!path) 516d8926bb3SMark Fasheh return -ENOMEM; 51717d217feSYan Zheng 518a2de733cSArne Jansen if (search_commit) { 519a2de733cSArne Jansen path->skip_locking = 1; 520e4058b54SDavid Sterba path->reada = READA_FORWARD; 521a2de733cSArne Jansen path->search_commit_root = 1; 522a2de733cSArne Jansen } 523a2de733cSArne Jansen 52417d217feSYan Zheng key.objectid = BTRFS_EXTENT_CSUM_OBJECTID; 52517d217feSYan Zheng key.offset = start; 52617d217feSYan Zheng key.type = BTRFS_EXTENT_CSUM_KEY; 52717d217feSYan Zheng 52807d400a6SYan Zheng ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); 52917d217feSYan Zheng if (ret < 0) 53017d217feSYan Zheng goto fail; 53117d217feSYan Zheng if (ret > 0 && path->slots[0] > 0) { 53217d217feSYan Zheng leaf = path->nodes[0]; 53317d217feSYan Zheng btrfs_item_key_to_cpu(leaf, &key, path->slots[0] - 1); 53417d217feSYan Zheng if (key.objectid == BTRFS_EXTENT_CSUM_OBJECTID && 53517d217feSYan Zheng key.type == BTRFS_EXTENT_CSUM_KEY) { 536265fdfa6SDavid Sterba offset = (start - key.offset) >> fs_info->sectorsize_bits; 53717d217feSYan Zheng if (offset * csum_size < 53817d217feSYan Zheng btrfs_item_size_nr(leaf, path->slots[0] - 1)) 53917d217feSYan Zheng path->slots[0]--; 54017d217feSYan Zheng } 54117d217feSYan Zheng } 54217d217feSYan Zheng 54317d217feSYan Zheng while (start <= end) { 54417d217feSYan Zheng leaf = path->nodes[0]; 54517d217feSYan Zheng if (path->slots[0] >= btrfs_header_nritems(leaf)) { 54607d400a6SYan Zheng ret = btrfs_next_leaf(root, path); 54717d217feSYan Zheng if (ret < 0) 54817d217feSYan Zheng goto fail; 54917d217feSYan Zheng if (ret > 0) 55017d217feSYan Zheng break; 55117d217feSYan Zheng leaf = path->nodes[0]; 55217d217feSYan Zheng } 55317d217feSYan Zheng 55417d217feSYan Zheng btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); 55517d217feSYan Zheng if (key.objectid != BTRFS_EXTENT_CSUM_OBJECTID || 556628c8282SZhi Yong Wu key.type != BTRFS_EXTENT_CSUM_KEY || 557628c8282SZhi Yong Wu key.offset > end) 55817d217feSYan Zheng break; 55917d217feSYan Zheng 56017d217feSYan Zheng if (key.offset > start) 56117d217feSYan Zheng start = key.offset; 56217d217feSYan Zheng 56317d217feSYan Zheng size = btrfs_item_size_nr(leaf, path->slots[0]); 5640b246afaSJeff Mahoney csum_end = key.offset + (size / csum_size) * fs_info->sectorsize; 56587b29b20SYan Zheng if (csum_end <= start) { 56687b29b20SYan Zheng path->slots[0]++; 56787b29b20SYan Zheng continue; 56887b29b20SYan Zheng } 56917d217feSYan Zheng 57007d400a6SYan Zheng csum_end = min(csum_end, end + 1); 57107d400a6SYan Zheng item = btrfs_item_ptr(path->nodes[0], path->slots[0], 57207d400a6SYan Zheng struct btrfs_csum_item); 57307d400a6SYan Zheng while (start < csum_end) { 57407d400a6SYan Zheng size = min_t(size_t, csum_end - start, 5751e25a2e3SJohannes Thumshirn max_ordered_sum_bytes(fs_info, csum_size)); 5760b246afaSJeff Mahoney sums = kzalloc(btrfs_ordered_sum_size(fs_info, size), 57707d400a6SYan Zheng GFP_NOFS); 5780678b618SMark Fasheh if (!sums) { 5790678b618SMark Fasheh ret = -ENOMEM; 5800678b618SMark Fasheh goto fail; 5810678b618SMark Fasheh } 58217d217feSYan Zheng 58317d217feSYan Zheng sums->bytenr = start; 584f51a4a18SMiao Xie sums->len = (int)size; 58517d217feSYan Zheng 586265fdfa6SDavid Sterba offset = (start - key.offset) >> fs_info->sectorsize_bits; 58717d217feSYan Zheng offset *= csum_size; 588265fdfa6SDavid Sterba size >>= fs_info->sectorsize_bits; 58917d217feSYan Zheng 59007d400a6SYan Zheng read_extent_buffer(path->nodes[0], 591f51a4a18SMiao Xie sums->sums, 592f51a4a18SMiao Xie ((unsigned long)item) + offset, 593f51a4a18SMiao Xie csum_size * size); 59417d217feSYan Zheng 5950b246afaSJeff Mahoney start += fs_info->sectorsize * size; 5960678b618SMark Fasheh list_add_tail(&sums->list, &tmplist); 59707d400a6SYan Zheng } 59817d217feSYan Zheng path->slots[0]++; 59917d217feSYan Zheng } 60017d217feSYan Zheng ret = 0; 60117d217feSYan Zheng fail: 6020678b618SMark Fasheh while (ret < 0 && !list_empty(&tmplist)) { 6036e5aafb2SChris Mason sums = list_entry(tmplist.next, struct btrfs_ordered_sum, list); 6040678b618SMark Fasheh list_del(&sums->list); 6050678b618SMark Fasheh kfree(sums); 6060678b618SMark Fasheh } 6070678b618SMark Fasheh list_splice_tail(&tmplist, list); 6080678b618SMark Fasheh 60917d217feSYan Zheng btrfs_free_path(path); 61017d217feSYan Zheng return ret; 61117d217feSYan Zheng } 61217d217feSYan Zheng 61351d470aeSNikolay Borisov /* 61451d470aeSNikolay Borisov * btrfs_csum_one_bio - Calculates checksums of the data contained inside a bio 61551d470aeSNikolay Borisov * @inode: Owner of the data inside the bio 61651d470aeSNikolay Borisov * @bio: Contains the data to be checksummed 61751d470aeSNikolay Borisov * @file_start: offset in file this bio begins to describe 61851d470aeSNikolay Borisov * @contig: Boolean. If true/1 means all bio vecs in this bio are 61951d470aeSNikolay Borisov * contiguous and they begin at @file_start in the file. False/0 6201a9fd417SDavid Sterba * means this bio can contain potentially discontiguous bio vecs 62151d470aeSNikolay Borisov * so the logical offset of each should be calculated separately. 62251d470aeSNikolay Borisov */ 623bd242a08SNikolay Borisov blk_status_t btrfs_csum_one_bio(struct btrfs_inode *inode, struct bio *bio, 6242ff7e61eSJeff Mahoney u64 file_start, int contig) 625e015640fSChris Mason { 626c3504372SNikolay Borisov struct btrfs_fs_info *fs_info = inode->root->fs_info; 627d5178578SJohannes Thumshirn SHASH_DESC_ON_STACK(shash, fs_info->csum_shash); 628e6dcd2dcSChris Mason struct btrfs_ordered_sum *sums; 6296cd7ce49SChristoph Hellwig struct btrfs_ordered_extent *ordered = NULL; 630e015640fSChris Mason char *data; 63117347cecSLiu Bo struct bvec_iter iter; 63217347cecSLiu Bo struct bio_vec bvec; 633f51a4a18SMiao Xie int index; 634c40a3d38SChandan Rajendra int nr_sectors; 6353edf7d33SChris Mason unsigned long total_bytes = 0; 6363edf7d33SChris Mason unsigned long this_sum_bytes = 0; 63717347cecSLiu Bo int i; 6383edf7d33SChris Mason u64 offset; 639a3d46aeaSNikolay Borisov unsigned nofs_flag; 640e015640fSChris Mason 641a3d46aeaSNikolay Borisov nofs_flag = memalloc_nofs_save(); 642a3d46aeaSNikolay Borisov sums = kvzalloc(btrfs_ordered_sum_size(fs_info, bio->bi_iter.bi_size), 643a3d46aeaSNikolay Borisov GFP_KERNEL); 644a3d46aeaSNikolay Borisov memalloc_nofs_restore(nofs_flag); 645a3d46aeaSNikolay Borisov 646e015640fSChris Mason if (!sums) 6474e4cbee9SChristoph Hellwig return BLK_STS_RESOURCE; 6483edf7d33SChris Mason 6494f024f37SKent Overstreet sums->len = bio->bi_iter.bi_size; 650e6dcd2dcSChris Mason INIT_LIST_HEAD(&sums->list); 651d20f7043SChris Mason 652d20f7043SChris Mason if (contig) 653d20f7043SChris Mason offset = file_start; 654d20f7043SChris Mason else 6556cd7ce49SChristoph Hellwig offset = 0; /* shut up gcc */ 656d20f7043SChris Mason 6571201b58bSDavid Sterba sums->bytenr = bio->bi_iter.bi_sector << 9; 658f51a4a18SMiao Xie index = 0; 659e015640fSChris Mason 660d5178578SJohannes Thumshirn shash->tfm = fs_info->csum_shash; 661d5178578SJohannes Thumshirn 66217347cecSLiu Bo bio_for_each_segment(bvec, bio, iter) { 663d20f7043SChris Mason if (!contig) 66417347cecSLiu Bo offset = page_offset(bvec.bv_page) + bvec.bv_offset; 665d20f7043SChris Mason 6666cd7ce49SChristoph Hellwig if (!ordered) { 6676cd7ce49SChristoph Hellwig ordered = btrfs_lookup_ordered_extent(inode, offset); 6686cd7ce49SChristoph Hellwig BUG_ON(!ordered); /* Logic error */ 6696cd7ce49SChristoph Hellwig } 6706cd7ce49SChristoph Hellwig 6710b246afaSJeff Mahoney nr_sectors = BTRFS_BYTES_TO_BLKS(fs_info, 67217347cecSLiu Bo bvec.bv_len + fs_info->sectorsize 673c40a3d38SChandan Rajendra - 1); 674c40a3d38SChandan Rajendra 675c40a3d38SChandan Rajendra for (i = 0; i < nr_sectors; i++) { 676bffe633eSOmar Sandoval if (offset >= ordered->file_offset + ordered->num_bytes || 677e58dd74bSJosef Bacik offset < ordered->file_offset) { 6783edf7d33SChris Mason unsigned long bytes_left; 679c40a3d38SChandan Rajendra 6803edf7d33SChris Mason sums->len = this_sum_bytes; 6813edf7d33SChris Mason this_sum_bytes = 0; 682f9756261SNikolay Borisov btrfs_add_ordered_sum(ordered, sums); 6833edf7d33SChris Mason btrfs_put_ordered_extent(ordered); 6843edf7d33SChris Mason 6854f024f37SKent Overstreet bytes_left = bio->bi_iter.bi_size - total_bytes; 6863edf7d33SChris Mason 687a3d46aeaSNikolay Borisov nofs_flag = memalloc_nofs_save(); 688a3d46aeaSNikolay Borisov sums = kvzalloc(btrfs_ordered_sum_size(fs_info, 689a3d46aeaSNikolay Borisov bytes_left), GFP_KERNEL); 690a3d46aeaSNikolay Borisov memalloc_nofs_restore(nofs_flag); 69179787eaaSJeff Mahoney BUG_ON(!sums); /* -ENOMEM */ 6923edf7d33SChris Mason sums->len = bytes_left; 693c40a3d38SChandan Rajendra ordered = btrfs_lookup_ordered_extent(inode, 694c40a3d38SChandan Rajendra offset); 695c40a3d38SChandan Rajendra ASSERT(ordered); /* Logic error */ 6961201b58bSDavid Sterba sums->bytenr = (bio->bi_iter.bi_sector << 9) 697c40a3d38SChandan Rajendra + total_bytes; 698f51a4a18SMiao Xie index = 0; 699c40a3d38SChandan Rajendra } 700c40a3d38SChandan Rajendra 701443c8e2aSJohannes Thumshirn data = kmap_atomic(bvec.bv_page); 702fd08001fSEric Biggers crypto_shash_digest(shash, data + bvec.bv_offset 7030b246afaSJeff Mahoney + (i * fs_info->sectorsize), 704fd08001fSEric Biggers fs_info->sectorsize, 705fd08001fSEric Biggers sums->sums + index); 706443c8e2aSJohannes Thumshirn kunmap_atomic(data); 707713cebfbSDavid Sterba index += fs_info->csum_size; 7080b246afaSJeff Mahoney offset += fs_info->sectorsize; 7090b246afaSJeff Mahoney this_sum_bytes += fs_info->sectorsize; 7100b246afaSJeff Mahoney total_bytes += fs_info->sectorsize; 711c40a3d38SChandan Rajendra } 712c40a3d38SChandan Rajendra 713e015640fSChris Mason } 714ed98b56aSChris Mason this_sum_bytes = 0; 715f9756261SNikolay Borisov btrfs_add_ordered_sum(ordered, sums); 7163edf7d33SChris Mason btrfs_put_ordered_extent(ordered); 717e015640fSChris Mason return 0; 718e015640fSChris Mason } 719e015640fSChris Mason 720459931ecSChris Mason /* 721459931ecSChris Mason * helper function for csum removal, this expects the 722459931ecSChris Mason * key to describe the csum pointed to by the path, and it expects 723459931ecSChris Mason * the csum to overlap the range [bytenr, len] 724459931ecSChris Mason * 725459931ecSChris Mason * The csum should not be entirely contained in the range and the 726459931ecSChris Mason * range should not be entirely contained in the csum. 727459931ecSChris Mason * 728459931ecSChris Mason * This calls btrfs_truncate_item with the correct args based on the 729459931ecSChris Mason * overlap, and fixes up the key as required. 730459931ecSChris Mason */ 7312ff7e61eSJeff Mahoney static noinline void truncate_one_csum(struct btrfs_fs_info *fs_info, 732459931ecSChris Mason struct btrfs_path *path, 733459931ecSChris Mason struct btrfs_key *key, 734459931ecSChris Mason u64 bytenr, u64 len) 735459931ecSChris Mason { 736459931ecSChris Mason struct extent_buffer *leaf; 737223486c2SDavid Sterba const u32 csum_size = fs_info->csum_size; 738459931ecSChris Mason u64 csum_end; 739459931ecSChris Mason u64 end_byte = bytenr + len; 740265fdfa6SDavid Sterba u32 blocksize_bits = fs_info->sectorsize_bits; 741459931ecSChris Mason 742459931ecSChris Mason leaf = path->nodes[0]; 743459931ecSChris Mason csum_end = btrfs_item_size_nr(leaf, path->slots[0]) / csum_size; 744265fdfa6SDavid Sterba csum_end <<= blocksize_bits; 745459931ecSChris Mason csum_end += key->offset; 746459931ecSChris Mason 747459931ecSChris Mason if (key->offset < bytenr && csum_end <= end_byte) { 748459931ecSChris Mason /* 749459931ecSChris Mason * [ bytenr - len ] 750459931ecSChris Mason * [ ] 751459931ecSChris Mason * [csum ] 752459931ecSChris Mason * A simple truncate off the end of the item 753459931ecSChris Mason */ 754459931ecSChris Mason u32 new_size = (bytenr - key->offset) >> blocksize_bits; 755459931ecSChris Mason new_size *= csum_size; 75678ac4f9eSDavid Sterba btrfs_truncate_item(path, new_size, 1); 757459931ecSChris Mason } else if (key->offset >= bytenr && csum_end > end_byte && 758459931ecSChris Mason end_byte > key->offset) { 759459931ecSChris Mason /* 760459931ecSChris Mason * [ bytenr - len ] 761459931ecSChris Mason * [ ] 762459931ecSChris Mason * [csum ] 763459931ecSChris Mason * we need to truncate from the beginning of the csum 764459931ecSChris Mason */ 765459931ecSChris Mason u32 new_size = (csum_end - end_byte) >> blocksize_bits; 766459931ecSChris Mason new_size *= csum_size; 767459931ecSChris Mason 76878ac4f9eSDavid Sterba btrfs_truncate_item(path, new_size, 0); 769459931ecSChris Mason 770459931ecSChris Mason key->offset = end_byte; 7710b246afaSJeff Mahoney btrfs_set_item_key_safe(fs_info, path, key); 772459931ecSChris Mason } else { 773459931ecSChris Mason BUG(); 774459931ecSChris Mason } 775459931ecSChris Mason } 776459931ecSChris Mason 777459931ecSChris Mason /* 778459931ecSChris Mason * deletes the csum items from the csum tree for a given 779459931ecSChris Mason * range of bytes. 780459931ecSChris Mason */ 781459931ecSChris Mason int btrfs_del_csums(struct btrfs_trans_handle *trans, 78240e046acSFilipe Manana struct btrfs_root *root, u64 bytenr, u64 len) 783459931ecSChris Mason { 78440e046acSFilipe Manana struct btrfs_fs_info *fs_info = trans->fs_info; 785459931ecSChris Mason struct btrfs_path *path; 786459931ecSChris Mason struct btrfs_key key; 787459931ecSChris Mason u64 end_byte = bytenr + len; 788459931ecSChris Mason u64 csum_end; 789459931ecSChris Mason struct extent_buffer *leaf; 790b86652beSJosef Bacik int ret = 0; 791223486c2SDavid Sterba const u32 csum_size = fs_info->csum_size; 792265fdfa6SDavid Sterba u32 blocksize_bits = fs_info->sectorsize_bits; 793459931ecSChris Mason 79440e046acSFilipe Manana ASSERT(root == fs_info->csum_root || 79540e046acSFilipe Manana root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID); 79640e046acSFilipe Manana 797459931ecSChris Mason path = btrfs_alloc_path(); 7982a29edc6Sliubo if (!path) 7992a29edc6Sliubo return -ENOMEM; 800459931ecSChris Mason 801459931ecSChris Mason while (1) { 802459931ecSChris Mason key.objectid = BTRFS_EXTENT_CSUM_OBJECTID; 803459931ecSChris Mason key.offset = end_byte - 1; 804459931ecSChris Mason key.type = BTRFS_EXTENT_CSUM_KEY; 805459931ecSChris Mason 806459931ecSChris Mason ret = btrfs_search_slot(trans, root, &key, path, -1, 1); 807459931ecSChris Mason if (ret > 0) { 808b86652beSJosef Bacik ret = 0; 809459931ecSChris Mason if (path->slots[0] == 0) 81065a246c5STsutomu Itoh break; 811459931ecSChris Mason path->slots[0]--; 812ad0397a7SJosef Bacik } else if (ret < 0) { 81365a246c5STsutomu Itoh break; 814459931ecSChris Mason } 815ad0397a7SJosef Bacik 816459931ecSChris Mason leaf = path->nodes[0]; 817459931ecSChris Mason btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); 818459931ecSChris Mason 819459931ecSChris Mason if (key.objectid != BTRFS_EXTENT_CSUM_OBJECTID || 820459931ecSChris Mason key.type != BTRFS_EXTENT_CSUM_KEY) { 821459931ecSChris Mason break; 822459931ecSChris Mason } 823459931ecSChris Mason 824459931ecSChris Mason if (key.offset >= end_byte) 825459931ecSChris Mason break; 826459931ecSChris Mason 827459931ecSChris Mason csum_end = btrfs_item_size_nr(leaf, path->slots[0]) / csum_size; 828459931ecSChris Mason csum_end <<= blocksize_bits; 829459931ecSChris Mason csum_end += key.offset; 830459931ecSChris Mason 831459931ecSChris Mason /* this csum ends before we start, we're done */ 832459931ecSChris Mason if (csum_end <= bytenr) 833459931ecSChris Mason break; 834459931ecSChris Mason 835459931ecSChris Mason /* delete the entire item, it is inside our range */ 836459931ecSChris Mason if (key.offset >= bytenr && csum_end <= end_byte) { 8376f546216SFilipe Manana int del_nr = 1; 8386f546216SFilipe Manana 8396f546216SFilipe Manana /* 8406f546216SFilipe Manana * Check how many csum items preceding this one in this 8416f546216SFilipe Manana * leaf correspond to our range and then delete them all 8426f546216SFilipe Manana * at once. 8436f546216SFilipe Manana */ 8446f546216SFilipe Manana if (key.offset > bytenr && path->slots[0] > 0) { 8456f546216SFilipe Manana int slot = path->slots[0] - 1; 8466f546216SFilipe Manana 8476f546216SFilipe Manana while (slot >= 0) { 8486f546216SFilipe Manana struct btrfs_key pk; 8496f546216SFilipe Manana 8506f546216SFilipe Manana btrfs_item_key_to_cpu(leaf, &pk, slot); 8516f546216SFilipe Manana if (pk.offset < bytenr || 8526f546216SFilipe Manana pk.type != BTRFS_EXTENT_CSUM_KEY || 8536f546216SFilipe Manana pk.objectid != 8546f546216SFilipe Manana BTRFS_EXTENT_CSUM_OBJECTID) 8556f546216SFilipe Manana break; 8566f546216SFilipe Manana path->slots[0] = slot; 8576f546216SFilipe Manana del_nr++; 8586f546216SFilipe Manana key.offset = pk.offset; 8596f546216SFilipe Manana slot--; 8606f546216SFilipe Manana } 8616f546216SFilipe Manana } 8626f546216SFilipe Manana ret = btrfs_del_items(trans, root, path, 8636f546216SFilipe Manana path->slots[0], del_nr); 86465a246c5STsutomu Itoh if (ret) 865b86652beSJosef Bacik break; 866dcbdd4dcSChris Mason if (key.offset == bytenr) 867dcbdd4dcSChris Mason break; 868459931ecSChris Mason } else if (key.offset < bytenr && csum_end > end_byte) { 869459931ecSChris Mason unsigned long offset; 870459931ecSChris Mason unsigned long shift_len; 871459931ecSChris Mason unsigned long item_offset; 872459931ecSChris Mason /* 873459931ecSChris Mason * [ bytenr - len ] 874459931ecSChris Mason * [csum ] 875459931ecSChris Mason * 876459931ecSChris Mason * Our bytes are in the middle of the csum, 877459931ecSChris Mason * we need to split this item and insert a new one. 878459931ecSChris Mason * 879459931ecSChris Mason * But we can't drop the path because the 880459931ecSChris Mason * csum could change, get removed, extended etc. 881459931ecSChris Mason * 882459931ecSChris Mason * The trick here is the max size of a csum item leaves 883459931ecSChris Mason * enough room in the tree block for a single 884459931ecSChris Mason * item header. So, we split the item in place, 885459931ecSChris Mason * adding a new header pointing to the existing 886459931ecSChris Mason * bytes. Then we loop around again and we have 887459931ecSChris Mason * a nicely formed csum item that we can neatly 888459931ecSChris Mason * truncate. 889459931ecSChris Mason */ 890459931ecSChris Mason offset = (bytenr - key.offset) >> blocksize_bits; 891459931ecSChris Mason offset *= csum_size; 892459931ecSChris Mason 893459931ecSChris Mason shift_len = (len >> blocksize_bits) * csum_size; 894459931ecSChris Mason 895459931ecSChris Mason item_offset = btrfs_item_ptr_offset(leaf, 896459931ecSChris Mason path->slots[0]); 897459931ecSChris Mason 898b159fa28SDavid Sterba memzero_extent_buffer(leaf, item_offset + offset, 899459931ecSChris Mason shift_len); 900459931ecSChris Mason key.offset = bytenr; 901459931ecSChris Mason 902459931ecSChris Mason /* 903459931ecSChris Mason * btrfs_split_item returns -EAGAIN when the 904459931ecSChris Mason * item changed size or key 905459931ecSChris Mason */ 906459931ecSChris Mason ret = btrfs_split_item(trans, root, path, &key, offset); 90779787eaaSJeff Mahoney if (ret && ret != -EAGAIN) { 90866642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 909b86652beSJosef Bacik break; 91079787eaaSJeff Mahoney } 911b86652beSJosef Bacik ret = 0; 912459931ecSChris Mason 913459931ecSChris Mason key.offset = end_byte - 1; 914459931ecSChris Mason } else { 9152ff7e61eSJeff Mahoney truncate_one_csum(fs_info, path, &key, bytenr, len); 916dcbdd4dcSChris Mason if (key.offset < bytenr) 917dcbdd4dcSChris Mason break; 918459931ecSChris Mason } 919b3b4aa74SDavid Sterba btrfs_release_path(path); 920459931ecSChris Mason } 921459931ecSChris Mason btrfs_free_path(path); 92265a246c5STsutomu Itoh return ret; 923459931ecSChris Mason } 924459931ecSChris Mason 925ea7036deSFilipe Manana static int find_next_csum_offset(struct btrfs_root *root, 926ea7036deSFilipe Manana struct btrfs_path *path, 927ea7036deSFilipe Manana u64 *next_offset) 928ea7036deSFilipe Manana { 929ea7036deSFilipe Manana const u32 nritems = btrfs_header_nritems(path->nodes[0]); 930ea7036deSFilipe Manana struct btrfs_key found_key; 931ea7036deSFilipe Manana int slot = path->slots[0] + 1; 932ea7036deSFilipe Manana int ret; 933ea7036deSFilipe Manana 934ea7036deSFilipe Manana if (nritems == 0 || slot >= nritems) { 935ea7036deSFilipe Manana ret = btrfs_next_leaf(root, path); 936ea7036deSFilipe Manana if (ret < 0) { 937ea7036deSFilipe Manana return ret; 938ea7036deSFilipe Manana } else if (ret > 0) { 939ea7036deSFilipe Manana *next_offset = (u64)-1; 940ea7036deSFilipe Manana return 0; 941ea7036deSFilipe Manana } 942ea7036deSFilipe Manana slot = path->slots[0]; 943ea7036deSFilipe Manana } 944ea7036deSFilipe Manana 945ea7036deSFilipe Manana btrfs_item_key_to_cpu(path->nodes[0], &found_key, slot); 946ea7036deSFilipe Manana 947ea7036deSFilipe Manana if (found_key.objectid != BTRFS_EXTENT_CSUM_OBJECTID || 948ea7036deSFilipe Manana found_key.type != BTRFS_EXTENT_CSUM_KEY) 949ea7036deSFilipe Manana *next_offset = (u64)-1; 950ea7036deSFilipe Manana else 951ea7036deSFilipe Manana *next_offset = found_key.offset; 952ea7036deSFilipe Manana 953ea7036deSFilipe Manana return 0; 954ea7036deSFilipe Manana } 955ea7036deSFilipe Manana 956065631f6SChris Mason int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans, 957d20f7043SChris Mason struct btrfs_root *root, 958e6dcd2dcSChris Mason struct btrfs_ordered_sum *sums) 959f254e52cSChris Mason { 9600b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 961f254e52cSChris Mason struct btrfs_key file_key; 9626567e837SChris Mason struct btrfs_key found_key; 9635caf2a00SChris Mason struct btrfs_path *path; 964f254e52cSChris Mason struct btrfs_csum_item *item; 965065631f6SChris Mason struct btrfs_csum_item *item_end; 966ff79f819SChris Mason struct extent_buffer *leaf = NULL; 967f51a4a18SMiao Xie u64 next_offset; 968f51a4a18SMiao Xie u64 total_bytes = 0; 9696567e837SChris Mason u64 csum_offset; 970f51a4a18SMiao Xie u64 bytenr; 971f578d4bdSChris Mason u32 ins_size; 972f51a4a18SMiao Xie int index = 0; 973f51a4a18SMiao Xie int found_next; 974f51a4a18SMiao Xie int ret; 975223486c2SDavid Sterba const u32 csum_size = fs_info->csum_size; 9766e92f5e6SChris Mason 9775caf2a00SChris Mason path = btrfs_alloc_path(); 978d8926bb3SMark Fasheh if (!path) 979d8926bb3SMark Fasheh return -ENOMEM; 980065631f6SChris Mason again: 981065631f6SChris Mason next_offset = (u64)-1; 982065631f6SChris Mason found_next = 0; 983f51a4a18SMiao Xie bytenr = sums->bytenr + total_bytes; 984d20f7043SChris Mason file_key.objectid = BTRFS_EXTENT_CSUM_OBJECTID; 985f51a4a18SMiao Xie file_key.offset = bytenr; 986962a298fSDavid Sterba file_key.type = BTRFS_EXTENT_CSUM_KEY; 987a429e513SChris Mason 988f51a4a18SMiao Xie item = btrfs_lookup_csum(trans, root, path, bytenr, 1); 989ff79f819SChris Mason if (!IS_ERR(item)) { 990639cb586SChris Mason ret = 0; 991f51a4a18SMiao Xie leaf = path->nodes[0]; 992f51a4a18SMiao Xie item_end = btrfs_item_ptr(leaf, path->slots[0], 993f51a4a18SMiao Xie struct btrfs_csum_item); 994f51a4a18SMiao Xie item_end = (struct btrfs_csum_item *)((char *)item_end + 995f51a4a18SMiao Xie btrfs_item_size_nr(leaf, path->slots[0])); 996a429e513SChris Mason goto found; 997ff79f819SChris Mason } 998a429e513SChris Mason ret = PTR_ERR(item); 9994a500fd1SYan, Zheng if (ret != -EFBIG && ret != -ENOENT) 1000918cdf44SFilipe Manana goto out; 10014a500fd1SYan, Zheng 1002a429e513SChris Mason if (ret == -EFBIG) { 1003a429e513SChris Mason u32 item_size; 1004a429e513SChris Mason /* we found one, but it isn't big enough yet */ 10055f39d397SChris Mason leaf = path->nodes[0]; 10065f39d397SChris Mason item_size = btrfs_item_size_nr(leaf, path->slots[0]); 1007607d432dSJosef Bacik if ((item_size / csum_size) >= 10080b246afaSJeff Mahoney MAX_CSUM_ITEMS(fs_info, csum_size)) { 1009a429e513SChris Mason /* already at max size, make a new one */ 1010a429e513SChris Mason goto insert; 1011a429e513SChris Mason } 1012a429e513SChris Mason } else { 1013ea7036deSFilipe Manana /* We didn't find a csum item, insert one. */ 1014ea7036deSFilipe Manana ret = find_next_csum_offset(root, path, &next_offset); 1015ea7036deSFilipe Manana if (ret < 0) 10167e4a3f7eSFilipe Manana goto out; 1017f578d4bdSChris Mason found_next = 1; 1018a429e513SChris Mason goto insert; 1019a429e513SChris Mason } 1020a429e513SChris Mason 1021a429e513SChris Mason /* 1022cc14600cSFilipe Manana * At this point, we know the tree has a checksum item that ends at an 1023cc14600cSFilipe Manana * offset matching the start of the checksum range we want to insert. 1024cc14600cSFilipe Manana * We try to extend that item as much as possible and then add as many 1025cc14600cSFilipe Manana * checksums to it as they fit. 1026cc14600cSFilipe Manana * 1027cc14600cSFilipe Manana * First check if the leaf has enough free space for at least one 1028cc14600cSFilipe Manana * checksum. If it has go directly to the item extension code, otherwise 1029cc14600cSFilipe Manana * release the path and do a search for insertion before the extension. 1030a429e513SChris Mason */ 1031cc14600cSFilipe Manana if (btrfs_leaf_free_space(leaf) >= csum_size) { 1032cc14600cSFilipe Manana btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); 1033cc14600cSFilipe Manana csum_offset = (bytenr - found_key.offset) >> 1034265fdfa6SDavid Sterba fs_info->sectorsize_bits; 1035cc14600cSFilipe Manana goto extend_csum; 1036cc14600cSFilipe Manana } 1037cc14600cSFilipe Manana 1038b3b4aa74SDavid Sterba btrfs_release_path(path); 10399a664971Sethanwu path->search_for_extension = 1; 10406567e837SChris Mason ret = btrfs_search_slot(trans, root, &file_key, path, 1041607d432dSJosef Bacik csum_size, 1); 10429a664971Sethanwu path->search_for_extension = 0; 10436567e837SChris Mason if (ret < 0) 1044918cdf44SFilipe Manana goto out; 1045459931ecSChris Mason 1046459931ecSChris Mason if (ret > 0) { 1047459931ecSChris Mason if (path->slots[0] == 0) 10486567e837SChris Mason goto insert; 10496567e837SChris Mason path->slots[0]--; 1050459931ecSChris Mason } 1051459931ecSChris Mason 10525f39d397SChris Mason leaf = path->nodes[0]; 10535f39d397SChris Mason btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); 1054265fdfa6SDavid Sterba csum_offset = (bytenr - found_key.offset) >> fs_info->sectorsize_bits; 1055459931ecSChris Mason 1056962a298fSDavid Sterba if (found_key.type != BTRFS_EXTENT_CSUM_KEY || 1057d20f7043SChris Mason found_key.objectid != BTRFS_EXTENT_CSUM_OBJECTID || 10580b246afaSJeff Mahoney csum_offset >= MAX_CSUM_ITEMS(fs_info, csum_size)) { 10596567e837SChris Mason goto insert; 10606567e837SChris Mason } 1061459931ecSChris Mason 1062cc14600cSFilipe Manana extend_csum: 10632f697dc6SLiu Bo if (csum_offset == btrfs_item_size_nr(leaf, path->slots[0]) / 1064607d432dSJosef Bacik csum_size) { 10652f697dc6SLiu Bo int extend_nr; 10662f697dc6SLiu Bo u64 tmp; 10672f697dc6SLiu Bo u32 diff; 1068459931ecSChris Mason 1069f51a4a18SMiao Xie tmp = sums->len - total_bytes; 1070265fdfa6SDavid Sterba tmp >>= fs_info->sectorsize_bits; 10712f697dc6SLiu Bo WARN_ON(tmp < 1); 1072ea7036deSFilipe Manana extend_nr = max_t(int, 1, tmp); 10732f697dc6SLiu Bo 1074ea7036deSFilipe Manana /* 1075ea7036deSFilipe Manana * A log tree can already have checksum items with a subset of 1076ea7036deSFilipe Manana * the checksums we are trying to log. This can happen after 1077ea7036deSFilipe Manana * doing a sequence of partial writes into prealloc extents and 1078ea7036deSFilipe Manana * fsyncs in between, with a full fsync logging a larger subrange 1079ea7036deSFilipe Manana * of an extent for which a previous fast fsync logged a smaller 1080ea7036deSFilipe Manana * subrange. And this happens in particular due to merging file 1081ea7036deSFilipe Manana * extent items when we complete an ordered extent for a range 1082ea7036deSFilipe Manana * covered by a prealloc extent - this is done at 1083ea7036deSFilipe Manana * btrfs_mark_extent_written(). 1084ea7036deSFilipe Manana * 1085ea7036deSFilipe Manana * So if we try to extend the previous checksum item, which has 1086ea7036deSFilipe Manana * a range that ends at the start of the range we want to insert, 1087ea7036deSFilipe Manana * make sure we don't extend beyond the start offset of the next 1088ea7036deSFilipe Manana * checksum item. If we are at the last item in the leaf, then 1089ea7036deSFilipe Manana * forget the optimization of extending and add a new checksum 1090ea7036deSFilipe Manana * item - it is not worth the complexity of releasing the path, 1091ea7036deSFilipe Manana * getting the first key for the next leaf, repeat the btree 1092ea7036deSFilipe Manana * search, etc, because log trees are temporary anyway and it 1093ea7036deSFilipe Manana * would only save a few bytes of leaf space. 1094ea7036deSFilipe Manana */ 1095ea7036deSFilipe Manana if (root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID) { 1096ea7036deSFilipe Manana if (path->slots[0] + 1 >= 1097ea7036deSFilipe Manana btrfs_header_nritems(path->nodes[0])) { 1098ea7036deSFilipe Manana ret = find_next_csum_offset(root, path, &next_offset); 1099ea7036deSFilipe Manana if (ret < 0) 1100ea7036deSFilipe Manana goto out; 1101ea7036deSFilipe Manana found_next = 1; 1102ea7036deSFilipe Manana goto insert; 1103ea7036deSFilipe Manana } 1104ea7036deSFilipe Manana 1105ea7036deSFilipe Manana ret = find_next_csum_offset(root, path, &next_offset); 1106ea7036deSFilipe Manana if (ret < 0) 1107ea7036deSFilipe Manana goto out; 1108ea7036deSFilipe Manana 1109ea7036deSFilipe Manana tmp = (next_offset - bytenr) >> fs_info->sectorsize_bits; 1110ea7036deSFilipe Manana if (tmp <= INT_MAX) 1111ea7036deSFilipe Manana extend_nr = min_t(int, extend_nr, tmp); 1112ea7036deSFilipe Manana } 1113ea7036deSFilipe Manana 11142f697dc6SLiu Bo diff = (csum_offset + extend_nr) * csum_size; 11150b246afaSJeff Mahoney diff = min(diff, 11160b246afaSJeff Mahoney MAX_CSUM_ITEMS(fs_info, csum_size) * csum_size); 1117459931ecSChris Mason 11185f39d397SChris Mason diff = diff - btrfs_item_size_nr(leaf, path->slots[0]); 1119cc14600cSFilipe Manana diff = min_t(u32, btrfs_leaf_free_space(leaf), diff); 11202f697dc6SLiu Bo diff /= csum_size; 11212f697dc6SLiu Bo diff *= csum_size; 1122459931ecSChris Mason 1123c71dd880SDavid Sterba btrfs_extend_item(path, diff); 1124f51a4a18SMiao Xie ret = 0; 11256567e837SChris Mason goto csum; 11266567e837SChris Mason } 11276567e837SChris Mason 11286567e837SChris Mason insert: 1129b3b4aa74SDavid Sterba btrfs_release_path(path); 11306567e837SChris Mason csum_offset = 0; 1131f578d4bdSChris Mason if (found_next) { 11322f697dc6SLiu Bo u64 tmp; 1133d20f7043SChris Mason 1134f51a4a18SMiao Xie tmp = sums->len - total_bytes; 1135265fdfa6SDavid Sterba tmp >>= fs_info->sectorsize_bits; 11362f697dc6SLiu Bo tmp = min(tmp, (next_offset - file_key.offset) >> 1137265fdfa6SDavid Sterba fs_info->sectorsize_bits); 11382f697dc6SLiu Bo 113950d0446eSSeraphime Kirkovski tmp = max_t(u64, 1, tmp); 114050d0446eSSeraphime Kirkovski tmp = min_t(u64, tmp, MAX_CSUM_ITEMS(fs_info, csum_size)); 1141607d432dSJosef Bacik ins_size = csum_size * tmp; 1142f578d4bdSChris Mason } else { 1143607d432dSJosef Bacik ins_size = csum_size; 1144f578d4bdSChris Mason } 11455caf2a00SChris Mason ret = btrfs_insert_empty_item(trans, root, path, &file_key, 1146f578d4bdSChris Mason ins_size); 114754aa1f4dSChris Mason if (ret < 0) 1148918cdf44SFilipe Manana goto out; 1149fae7f21cSDulshani Gunawardhana if (WARN_ON(ret != 0)) 1150918cdf44SFilipe Manana goto out; 11515f39d397SChris Mason leaf = path->nodes[0]; 1152f51a4a18SMiao Xie csum: 11535f39d397SChris Mason item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item); 1154f51a4a18SMiao Xie item_end = (struct btrfs_csum_item *)((unsigned char *)item + 1155f51a4a18SMiao Xie btrfs_item_size_nr(leaf, path->slots[0])); 1156509659cdSChris Mason item = (struct btrfs_csum_item *)((unsigned char *)item + 1157607d432dSJosef Bacik csum_offset * csum_size); 1158b18c6685SChris Mason found: 1159265fdfa6SDavid Sterba ins_size = (u32)(sums->len - total_bytes) >> fs_info->sectorsize_bits; 1160f51a4a18SMiao Xie ins_size *= csum_size; 1161f51a4a18SMiao Xie ins_size = min_t(u32, (unsigned long)item_end - (unsigned long)item, 1162f51a4a18SMiao Xie ins_size); 1163f51a4a18SMiao Xie write_extent_buffer(leaf, sums->sums + index, (unsigned long)item, 1164f51a4a18SMiao Xie ins_size); 1165aadfeb6eSChris Mason 11661e25a2e3SJohannes Thumshirn index += ins_size; 1167f51a4a18SMiao Xie ins_size /= csum_size; 11680b246afaSJeff Mahoney total_bytes += ins_size * fs_info->sectorsize; 1169a6591715SChris Mason 11705caf2a00SChris Mason btrfs_mark_buffer_dirty(path->nodes[0]); 1171e6dcd2dcSChris Mason if (total_bytes < sums->len) { 1172b3b4aa74SDavid Sterba btrfs_release_path(path); 1173b9473439SChris Mason cond_resched(); 1174065631f6SChris Mason goto again; 1175065631f6SChris Mason } 117653863232SChris Mason out: 11775caf2a00SChris Mason btrfs_free_path(path); 1178f254e52cSChris Mason return ret; 1179f254e52cSChris Mason } 11807ffbb598SFilipe Manana 11819cdc5124SNikolay Borisov void btrfs_extent_item_to_extent_map(struct btrfs_inode *inode, 11827ffbb598SFilipe Manana const struct btrfs_path *path, 11837ffbb598SFilipe Manana struct btrfs_file_extent_item *fi, 11847ffbb598SFilipe Manana const bool new_inline, 11857ffbb598SFilipe Manana struct extent_map *em) 11867ffbb598SFilipe Manana { 11873ffbd68cSDavid Sterba struct btrfs_fs_info *fs_info = inode->root->fs_info; 11889cdc5124SNikolay Borisov struct btrfs_root *root = inode->root; 11897ffbb598SFilipe Manana struct extent_buffer *leaf = path->nodes[0]; 11907ffbb598SFilipe Manana const int slot = path->slots[0]; 11917ffbb598SFilipe Manana struct btrfs_key key; 11927ffbb598SFilipe Manana u64 extent_start, extent_end; 11937ffbb598SFilipe Manana u64 bytenr; 11947ffbb598SFilipe Manana u8 type = btrfs_file_extent_type(leaf, fi); 11957ffbb598SFilipe Manana int compress_type = btrfs_file_extent_compression(leaf, fi); 11967ffbb598SFilipe Manana 11977ffbb598SFilipe Manana btrfs_item_key_to_cpu(leaf, &key, slot); 11987ffbb598SFilipe Manana extent_start = key.offset; 1199a5eeb3d1SFilipe Manana extent_end = btrfs_file_extent_end(path); 12007ffbb598SFilipe Manana em->ram_bytes = btrfs_file_extent_ram_bytes(leaf, fi); 12017ffbb598SFilipe Manana if (type == BTRFS_FILE_EXTENT_REG || 12027ffbb598SFilipe Manana type == BTRFS_FILE_EXTENT_PREALLOC) { 12037ffbb598SFilipe Manana em->start = extent_start; 12047ffbb598SFilipe Manana em->len = extent_end - extent_start; 12057ffbb598SFilipe Manana em->orig_start = extent_start - 12067ffbb598SFilipe Manana btrfs_file_extent_offset(leaf, fi); 12077ffbb598SFilipe Manana em->orig_block_len = btrfs_file_extent_disk_num_bytes(leaf, fi); 12087ffbb598SFilipe Manana bytenr = btrfs_file_extent_disk_bytenr(leaf, fi); 12097ffbb598SFilipe Manana if (bytenr == 0) { 12107ffbb598SFilipe Manana em->block_start = EXTENT_MAP_HOLE; 12117ffbb598SFilipe Manana return; 12127ffbb598SFilipe Manana } 12137ffbb598SFilipe Manana if (compress_type != BTRFS_COMPRESS_NONE) { 12147ffbb598SFilipe Manana set_bit(EXTENT_FLAG_COMPRESSED, &em->flags); 12157ffbb598SFilipe Manana em->compress_type = compress_type; 12167ffbb598SFilipe Manana em->block_start = bytenr; 12177ffbb598SFilipe Manana em->block_len = em->orig_block_len; 12187ffbb598SFilipe Manana } else { 12197ffbb598SFilipe Manana bytenr += btrfs_file_extent_offset(leaf, fi); 12207ffbb598SFilipe Manana em->block_start = bytenr; 12217ffbb598SFilipe Manana em->block_len = em->len; 12227ffbb598SFilipe Manana if (type == BTRFS_FILE_EXTENT_PREALLOC) 12237ffbb598SFilipe Manana set_bit(EXTENT_FLAG_PREALLOC, &em->flags); 12247ffbb598SFilipe Manana } 12257ffbb598SFilipe Manana } else if (type == BTRFS_FILE_EXTENT_INLINE) { 12267ffbb598SFilipe Manana em->block_start = EXTENT_MAP_INLINE; 12277ffbb598SFilipe Manana em->start = extent_start; 12287ffbb598SFilipe Manana em->len = extent_end - extent_start; 12297ffbb598SFilipe Manana /* 12307ffbb598SFilipe Manana * Initialize orig_start and block_len with the same values 12317ffbb598SFilipe Manana * as in inode.c:btrfs_get_extent(). 12327ffbb598SFilipe Manana */ 12337ffbb598SFilipe Manana em->orig_start = EXTENT_MAP_HOLE; 12347ffbb598SFilipe Manana em->block_len = (u64)-1; 12357ffbb598SFilipe Manana if (!new_inline && compress_type != BTRFS_COMPRESS_NONE) { 12367ffbb598SFilipe Manana set_bit(EXTENT_FLAG_COMPRESSED, &em->flags); 12377ffbb598SFilipe Manana em->compress_type = compress_type; 12387ffbb598SFilipe Manana } 12397ffbb598SFilipe Manana } else { 12400b246afaSJeff Mahoney btrfs_err(fs_info, 12419cdc5124SNikolay Borisov "unknown file extent item type %d, inode %llu, offset %llu, " 12429cdc5124SNikolay Borisov "root %llu", type, btrfs_ino(inode), extent_start, 12437ffbb598SFilipe Manana root->root_key.objectid); 12447ffbb598SFilipe Manana } 12457ffbb598SFilipe Manana } 1246a5eeb3d1SFilipe Manana 1247a5eeb3d1SFilipe Manana /* 1248a5eeb3d1SFilipe Manana * Returns the end offset (non inclusive) of the file extent item the given path 1249a5eeb3d1SFilipe Manana * points to. If it points to an inline extent, the returned offset is rounded 1250a5eeb3d1SFilipe Manana * up to the sector size. 1251a5eeb3d1SFilipe Manana */ 1252a5eeb3d1SFilipe Manana u64 btrfs_file_extent_end(const struct btrfs_path *path) 1253a5eeb3d1SFilipe Manana { 1254a5eeb3d1SFilipe Manana const struct extent_buffer *leaf = path->nodes[0]; 1255a5eeb3d1SFilipe Manana const int slot = path->slots[0]; 1256a5eeb3d1SFilipe Manana struct btrfs_file_extent_item *fi; 1257a5eeb3d1SFilipe Manana struct btrfs_key key; 1258a5eeb3d1SFilipe Manana u64 end; 1259a5eeb3d1SFilipe Manana 1260a5eeb3d1SFilipe Manana btrfs_item_key_to_cpu(leaf, &key, slot); 1261a5eeb3d1SFilipe Manana ASSERT(key.type == BTRFS_EXTENT_DATA_KEY); 1262a5eeb3d1SFilipe Manana fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item); 1263a5eeb3d1SFilipe Manana 1264a5eeb3d1SFilipe Manana if (btrfs_file_extent_type(leaf, fi) == BTRFS_FILE_EXTENT_INLINE) { 1265a5eeb3d1SFilipe Manana end = btrfs_file_extent_ram_bytes(leaf, fi); 1266a5eeb3d1SFilipe Manana end = ALIGN(key.offset + end, leaf->fs_info->sectorsize); 1267a5eeb3d1SFilipe Manana } else { 1268a5eeb3d1SFilipe Manana end = key.offset + btrfs_file_extent_num_bytes(leaf, fi); 1269a5eeb3d1SFilipe Manana } 1270a5eeb3d1SFilipe Manana 1271a5eeb3d1SFilipe Manana return end; 1272a5eeb3d1SFilipe Manana } 1273