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> 121e1d2701SChris Mason #include "ctree.h" 13dee26a9fSChris Mason #include "disk-io.h" 149f5fae2fSChris Mason #include "transaction.h" 15facc8a22SMiao Xie #include "volumes.h" 161de037a4SChris Mason #include "print-tree.h" 17ebb8765bSAnand Jain #include "compression.h" 181e1d2701SChris Mason 1942049bf6SChris Mason #define __MAX_CSUM_ITEMS(r, size) ((unsigned long)(((BTRFS_LEAF_DATA_SIZE(r) - \ 2042049bf6SChris Mason sizeof(struct btrfs_item) * 2) / \ 2142049bf6SChris Mason size) - 1)) 2207d400a6SYan Zheng 23221b8318SZach Brown #define MAX_CSUM_ITEMS(r, size) (min_t(u32, __MAX_CSUM_ITEMS(r, size), \ 2409cbfeafSKirill A. Shutemov PAGE_SIZE)) 257ca4be45SChris Mason 261e25a2e3SJohannes Thumshirn static inline u32 max_ordered_sum_bytes(struct btrfs_fs_info *fs_info, 271e25a2e3SJohannes Thumshirn u16 csum_size) 281e25a2e3SJohannes Thumshirn { 291e25a2e3SJohannes Thumshirn u32 ncsums = (PAGE_SIZE - sizeof(struct btrfs_ordered_sum)) / csum_size; 301e25a2e3SJohannes Thumshirn 311e25a2e3SJohannes Thumshirn return ncsums * fs_info->sectorsize; 321e25a2e3SJohannes Thumshirn } 3307d400a6SYan Zheng 34b18c6685SChris Mason int btrfs_insert_file_extent(struct btrfs_trans_handle *trans, 35dee26a9fSChris Mason struct btrfs_root *root, 36b18c6685SChris Mason u64 objectid, u64 pos, 37f2eb0a24SSage Weil u64 disk_offset, u64 disk_num_bytes, 38c8b97818SChris Mason u64 num_bytes, u64 offset, u64 ram_bytes, 39c8b97818SChris Mason u8 compression, u8 encryption, u16 other_encoding) 409f5fae2fSChris Mason { 41dee26a9fSChris Mason int ret = 0; 42dee26a9fSChris Mason struct btrfs_file_extent_item *item; 43dee26a9fSChris Mason struct btrfs_key file_key; 445caf2a00SChris Mason struct btrfs_path *path; 455f39d397SChris Mason struct extent_buffer *leaf; 46dee26a9fSChris Mason 475caf2a00SChris Mason path = btrfs_alloc_path(); 48db5b493aSTsutomu Itoh if (!path) 49db5b493aSTsutomu Itoh return -ENOMEM; 50dee26a9fSChris Mason file_key.objectid = objectid; 51b18c6685SChris Mason file_key.offset = pos; 52962a298fSDavid Sterba file_key.type = BTRFS_EXTENT_DATA_KEY; 53dee26a9fSChris Mason 54b9473439SChris Mason path->leave_spinning = 1; 555caf2a00SChris Mason ret = btrfs_insert_empty_item(trans, root, path, &file_key, 56dee26a9fSChris Mason sizeof(*item)); 5754aa1f4dSChris Mason if (ret < 0) 5854aa1f4dSChris Mason goto out; 5979787eaaSJeff Mahoney BUG_ON(ret); /* Can't happen */ 605f39d397SChris Mason leaf = path->nodes[0]; 615f39d397SChris Mason item = btrfs_item_ptr(leaf, path->slots[0], 62dee26a9fSChris Mason struct btrfs_file_extent_item); 63f2eb0a24SSage Weil btrfs_set_file_extent_disk_bytenr(leaf, item, disk_offset); 64db94535dSChris Mason btrfs_set_file_extent_disk_num_bytes(leaf, item, disk_num_bytes); 65f2eb0a24SSage Weil btrfs_set_file_extent_offset(leaf, item, offset); 66db94535dSChris Mason btrfs_set_file_extent_num_bytes(leaf, item, num_bytes); 67c8b97818SChris Mason btrfs_set_file_extent_ram_bytes(leaf, item, ram_bytes); 685f39d397SChris Mason btrfs_set_file_extent_generation(leaf, item, trans->transid); 695f39d397SChris Mason btrfs_set_file_extent_type(leaf, item, BTRFS_FILE_EXTENT_REG); 70c8b97818SChris Mason btrfs_set_file_extent_compression(leaf, item, compression); 71c8b97818SChris Mason btrfs_set_file_extent_encryption(leaf, item, encryption); 72c8b97818SChris Mason btrfs_set_file_extent_other_encoding(leaf, item, other_encoding); 73c8b97818SChris Mason 745f39d397SChris Mason btrfs_mark_buffer_dirty(leaf); 7554aa1f4dSChris Mason out: 765caf2a00SChris Mason btrfs_free_path(path); 7754aa1f4dSChris Mason return ret; 789f5fae2fSChris Mason } 79dee26a9fSChris Mason 8048a3b636SEric Sandeen static struct btrfs_csum_item * 8148a3b636SEric Sandeen btrfs_lookup_csum(struct btrfs_trans_handle *trans, 82b18c6685SChris Mason struct btrfs_root *root, 836567e837SChris Mason struct btrfs_path *path, 84d20f7043SChris Mason u64 bytenr, int cow) 856567e837SChris Mason { 860b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 876567e837SChris Mason int ret; 886567e837SChris Mason struct btrfs_key file_key; 896567e837SChris Mason struct btrfs_key found_key; 906567e837SChris Mason struct btrfs_csum_item *item; 915f39d397SChris Mason struct extent_buffer *leaf; 926567e837SChris Mason u64 csum_offset = 0; 930b246afaSJeff Mahoney u16 csum_size = btrfs_super_csum_size(fs_info->super_copy); 94a429e513SChris Mason int csums_in_item; 956567e837SChris Mason 96d20f7043SChris Mason file_key.objectid = BTRFS_EXTENT_CSUM_OBJECTID; 97d20f7043SChris Mason file_key.offset = bytenr; 98962a298fSDavid Sterba file_key.type = BTRFS_EXTENT_CSUM_KEY; 99b18c6685SChris Mason ret = btrfs_search_slot(trans, root, &file_key, path, 0, cow); 1006567e837SChris Mason if (ret < 0) 1016567e837SChris Mason goto fail; 1025f39d397SChris Mason leaf = path->nodes[0]; 1036567e837SChris Mason if (ret > 0) { 1046567e837SChris Mason ret = 1; 10570b2befdSChris Mason if (path->slots[0] == 0) 1066567e837SChris Mason goto fail; 1076567e837SChris Mason path->slots[0]--; 1085f39d397SChris Mason btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); 109962a298fSDavid Sterba if (found_key.type != BTRFS_EXTENT_CSUM_KEY) 1106567e837SChris Mason goto fail; 111d20f7043SChris Mason 112d20f7043SChris Mason csum_offset = (bytenr - found_key.offset) >> 1130b246afaSJeff Mahoney fs_info->sb->s_blocksize_bits; 1145f39d397SChris Mason csums_in_item = btrfs_item_size_nr(leaf, path->slots[0]); 115607d432dSJosef Bacik csums_in_item /= csum_size; 116a429e513SChris Mason 11782d130ffSMiao Xie if (csum_offset == csums_in_item) { 118a429e513SChris Mason ret = -EFBIG; 1196567e837SChris Mason goto fail; 12082d130ffSMiao Xie } else if (csum_offset > csums_in_item) { 12182d130ffSMiao Xie goto fail; 1226567e837SChris Mason } 1236567e837SChris Mason } 1246567e837SChris Mason item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item); 125509659cdSChris Mason item = (struct btrfs_csum_item *)((unsigned char *)item + 126607d432dSJosef Bacik csum_offset * csum_size); 1276567e837SChris Mason return item; 1286567e837SChris Mason fail: 1296567e837SChris Mason if (ret > 0) 130b18c6685SChris Mason ret = -ENOENT; 1316567e837SChris Mason return ERR_PTR(ret); 1326567e837SChris Mason } 1336567e837SChris Mason 134dee26a9fSChris Mason int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans, 135dee26a9fSChris Mason struct btrfs_root *root, 136dee26a9fSChris Mason struct btrfs_path *path, u64 objectid, 1379773a788SChris Mason u64 offset, int mod) 138dee26a9fSChris Mason { 139dee26a9fSChris Mason int ret; 140dee26a9fSChris Mason struct btrfs_key file_key; 141dee26a9fSChris Mason int ins_len = mod < 0 ? -1 : 0; 142dee26a9fSChris Mason int cow = mod != 0; 143dee26a9fSChris Mason 144dee26a9fSChris Mason file_key.objectid = objectid; 14570b2befdSChris Mason file_key.offset = offset; 146962a298fSDavid Sterba file_key.type = BTRFS_EXTENT_DATA_KEY; 147dee26a9fSChris Mason ret = btrfs_search_slot(trans, root, &file_key, path, ins_len, cow); 148dee26a9fSChris Mason return ret; 149dee26a9fSChris Mason } 150f254e52cSChris Mason 1514e4cbee9SChristoph Hellwig static blk_status_t __btrfs_lookup_bio_sums(struct inode *inode, struct bio *bio, 1521e25a2e3SJohannes Thumshirn u64 logical_offset, u8 *dst, int dio) 15361b49440SChris Mason { 1540b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 15517347cecSLiu Bo struct bio_vec bvec; 15617347cecSLiu Bo struct bvec_iter iter; 157facc8a22SMiao Xie struct btrfs_io_bio *btrfs_bio = btrfs_io_bio(bio); 158facc8a22SMiao Xie struct btrfs_csum_item *item = NULL; 159facc8a22SMiao Xie struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; 160facc8a22SMiao Xie struct btrfs_path *path; 161facc8a22SMiao Xie u8 *csum; 1624b46fce2SJosef Bacik u64 offset = 0; 16361b49440SChris Mason u64 item_start_offset = 0; 16461b49440SChris Mason u64 item_last_offset = 0; 165d20f7043SChris Mason u64 disk_bytenr; 166c40a3d38SChandan Rajendra u64 page_bytes_left; 16761b49440SChris Mason u32 diff; 168facc8a22SMiao Xie int nblocks; 16917347cecSLiu Bo int count = 0; 1700b246afaSJeff Mahoney u16 csum_size = btrfs_super_csum_size(fs_info->super_copy); 17161b49440SChris Mason 17261b49440SChris Mason path = btrfs_alloc_path(); 173c2db1073STsutomu Itoh if (!path) 1744e4cbee9SChristoph Hellwig return BLK_STS_RESOURCE; 175facc8a22SMiao Xie 1764f024f37SKent Overstreet nblocks = bio->bi_iter.bi_size >> inode->i_sb->s_blocksize_bits; 177facc8a22SMiao Xie if (!dst) { 178facc8a22SMiao Xie if (nblocks * csum_size > BTRFS_BIO_INLINE_CSUM_SIZE) { 17931fecccbSDavid Sterba btrfs_bio->csum = kmalloc_array(nblocks, csum_size, 18031fecccbSDavid Sterba GFP_NOFS); 18131fecccbSDavid Sterba if (!btrfs_bio->csum) { 182facc8a22SMiao Xie btrfs_free_path(path); 1834e4cbee9SChristoph Hellwig return BLK_STS_RESOURCE; 184facc8a22SMiao Xie } 185facc8a22SMiao Xie } else { 186facc8a22SMiao Xie btrfs_bio->csum = btrfs_bio->csum_inline; 187facc8a22SMiao Xie } 188facc8a22SMiao Xie csum = btrfs_bio->csum; 189facc8a22SMiao Xie } else { 19010fe6ca8SJohannes Thumshirn csum = dst; 191facc8a22SMiao Xie } 192facc8a22SMiao Xie 19309cbfeafSKirill A. Shutemov if (bio->bi_iter.bi_size > PAGE_SIZE * 8) 194e4058b54SDavid Sterba path->reada = READA_FORWARD; 19561b49440SChris Mason 1962cf8572dSChris Mason /* 1972cf8572dSChris Mason * the free space stuff is only read when it hasn't been 1982cf8572dSChris Mason * updated in the current transaction. So, we can safely 1992cf8572dSChris Mason * read from the commit root and sidestep a nasty deadlock 2002cf8572dSChris Mason * between reading the free space cache and updating the csum tree. 2012cf8572dSChris Mason */ 20270ddc553SNikolay Borisov if (btrfs_is_free_space_inode(BTRFS_I(inode))) { 2032cf8572dSChris Mason path->search_commit_root = 1; 204ddf23b3fSJosef Bacik path->skip_locking = 1; 205ddf23b3fSJosef Bacik } 2062cf8572dSChris Mason 2074f024f37SKent Overstreet disk_bytenr = (u64)bio->bi_iter.bi_sector << 9; 2084b46fce2SJosef Bacik if (dio) 2094b46fce2SJosef Bacik offset = logical_offset; 210c40a3d38SChandan Rajendra 21117347cecSLiu Bo bio_for_each_segment(bvec, bio, iter) { 21217347cecSLiu Bo page_bytes_left = bvec.bv_len; 2134989d277SChristoph Hellwig if (count) 2144989d277SChristoph Hellwig goto next; 2154989d277SChristoph Hellwig 2164b46fce2SJosef Bacik if (!dio) 21717347cecSLiu Bo offset = page_offset(bvec.bv_page) + bvec.bv_offset; 218facc8a22SMiao Xie count = btrfs_find_ordered_sum(inode, offset, disk_bytenr, 2191e25a2e3SJohannes Thumshirn csum, nblocks); 220e4100d98SMiao Xie if (count) 22161b49440SChris Mason goto found; 22261b49440SChris Mason 223d20f7043SChris Mason if (!item || disk_bytenr < item_start_offset || 224d20f7043SChris Mason disk_bytenr >= item_last_offset) { 22561b49440SChris Mason struct btrfs_key found_key; 22661b49440SChris Mason u32 item_size; 22761b49440SChris Mason 22861b49440SChris Mason if (item) 229b3b4aa74SDavid Sterba btrfs_release_path(path); 2300b246afaSJeff Mahoney item = btrfs_lookup_csum(NULL, fs_info->csum_root, 231d20f7043SChris Mason path, disk_bytenr, 0); 23261b49440SChris Mason if (IS_ERR(item)) { 233e4100d98SMiao Xie count = 1; 234facc8a22SMiao Xie memset(csum, 0, csum_size); 23517d217feSYan Zheng if (BTRFS_I(inode)->root->root_key.objectid == 23617d217feSYan Zheng BTRFS_DATA_RELOC_TREE_OBJECTID) { 23717d217feSYan Zheng set_extent_bits(io_tree, offset, 2380b246afaSJeff Mahoney offset + fs_info->sectorsize - 1, 239ceeb0ae7SDavid Sterba EXTENT_NODATASUM); 24017d217feSYan Zheng } else { 2410b246afaSJeff Mahoney btrfs_info_rl(fs_info, 242efe120a0SFrank Holton "no csum found for inode %llu start %llu", 2434a0cc7caSNikolay Borisov btrfs_ino(BTRFS_I(inode)), offset); 24417d217feSYan Zheng } 2456dab8157SChris Mason item = NULL; 246b3b4aa74SDavid Sterba btrfs_release_path(path); 24761b49440SChris Mason goto found; 24861b49440SChris Mason } 24961b49440SChris Mason btrfs_item_key_to_cpu(path->nodes[0], &found_key, 25061b49440SChris Mason path->slots[0]); 25161b49440SChris Mason 25261b49440SChris Mason item_start_offset = found_key.offset; 25361b49440SChris Mason item_size = btrfs_item_size_nr(path->nodes[0], 25461b49440SChris Mason path->slots[0]); 25561b49440SChris Mason item_last_offset = item_start_offset + 256607d432dSJosef Bacik (item_size / csum_size) * 2570b246afaSJeff Mahoney fs_info->sectorsize; 25861b49440SChris Mason item = btrfs_item_ptr(path->nodes[0], path->slots[0], 25961b49440SChris Mason struct btrfs_csum_item); 26061b49440SChris Mason } 26161b49440SChris Mason /* 26261b49440SChris Mason * this byte range must be able to fit inside 26361b49440SChris Mason * a single leaf so it will also fit inside a u32 26461b49440SChris Mason */ 265d20f7043SChris Mason diff = disk_bytenr - item_start_offset; 2660b246afaSJeff Mahoney diff = diff / fs_info->sectorsize; 267607d432dSJosef Bacik diff = diff * csum_size; 268facc8a22SMiao Xie count = min_t(int, nblocks, (item_last_offset - disk_bytenr) >> 269e4100d98SMiao Xie inode->i_sb->s_blocksize_bits); 270facc8a22SMiao Xie read_extent_buffer(path->nodes[0], csum, 2713de9d6b6SChris Mason ((unsigned long)item) + diff, 272e4100d98SMiao Xie csum_size * count); 27361b49440SChris Mason found: 274facc8a22SMiao Xie csum += count * csum_size; 275facc8a22SMiao Xie nblocks -= count; 2764989d277SChristoph Hellwig next: 277e4100d98SMiao Xie while (count--) { 2780b246afaSJeff Mahoney disk_bytenr += fs_info->sectorsize; 2790b246afaSJeff Mahoney offset += fs_info->sectorsize; 2800b246afaSJeff Mahoney page_bytes_left -= fs_info->sectorsize; 2814989d277SChristoph Hellwig if (!page_bytes_left) 2824989d277SChristoph Hellwig break; /* move to next bio */ 2834989d277SChristoph Hellwig } 2844989d277SChristoph Hellwig } 2854989d277SChristoph Hellwig 286389f239cSChris Mason WARN_ON_ONCE(count); 28761b49440SChris Mason btrfs_free_path(path); 28861b49440SChris Mason return 0; 28961b49440SChris Mason } 29061b49440SChris Mason 2911e25a2e3SJohannes Thumshirn blk_status_t btrfs_lookup_bio_sums(struct inode *inode, struct bio *bio, 2921e25a2e3SJohannes Thumshirn u8 *dst) 2934b46fce2SJosef Bacik { 2942ff7e61eSJeff Mahoney return __btrfs_lookup_bio_sums(inode, bio, 0, dst, 0); 2954b46fce2SJosef Bacik } 2964b46fce2SJosef Bacik 2974e4cbee9SChristoph Hellwig blk_status_t btrfs_lookup_bio_sums_dio(struct inode *inode, struct bio *bio, u64 offset) 2984b46fce2SJosef Bacik { 2992ff7e61eSJeff Mahoney return __btrfs_lookup_bio_sums(inode, bio, offset, NULL, 1); 3004b46fce2SJosef Bacik } 3014b46fce2SJosef Bacik 30217d217feSYan Zheng int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end, 303a2de733cSArne Jansen struct list_head *list, int search_commit) 30417d217feSYan Zheng { 3050b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 30617d217feSYan Zheng struct btrfs_key key; 30717d217feSYan Zheng struct btrfs_path *path; 30817d217feSYan Zheng struct extent_buffer *leaf; 30917d217feSYan Zheng struct btrfs_ordered_sum *sums; 31017d217feSYan Zheng struct btrfs_csum_item *item; 3110678b618SMark Fasheh LIST_HEAD(tmplist); 31217d217feSYan Zheng unsigned long offset; 31317d217feSYan Zheng int ret; 31417d217feSYan Zheng size_t size; 31517d217feSYan Zheng u64 csum_end; 3160b246afaSJeff Mahoney u16 csum_size = btrfs_super_csum_size(fs_info->super_copy); 31717d217feSYan Zheng 3180b246afaSJeff Mahoney ASSERT(IS_ALIGNED(start, fs_info->sectorsize) && 3190b246afaSJeff Mahoney IS_ALIGNED(end + 1, fs_info->sectorsize)); 3204277a9c3SJosef Bacik 32117d217feSYan Zheng path = btrfs_alloc_path(); 322d8926bb3SMark Fasheh if (!path) 323d8926bb3SMark Fasheh return -ENOMEM; 32417d217feSYan Zheng 325a2de733cSArne Jansen if (search_commit) { 326a2de733cSArne Jansen path->skip_locking = 1; 327e4058b54SDavid Sterba path->reada = READA_FORWARD; 328a2de733cSArne Jansen path->search_commit_root = 1; 329a2de733cSArne Jansen } 330a2de733cSArne Jansen 33117d217feSYan Zheng key.objectid = BTRFS_EXTENT_CSUM_OBJECTID; 33217d217feSYan Zheng key.offset = start; 33317d217feSYan Zheng key.type = BTRFS_EXTENT_CSUM_KEY; 33417d217feSYan Zheng 33507d400a6SYan Zheng ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); 33617d217feSYan Zheng if (ret < 0) 33717d217feSYan Zheng goto fail; 33817d217feSYan Zheng if (ret > 0 && path->slots[0] > 0) { 33917d217feSYan Zheng leaf = path->nodes[0]; 34017d217feSYan Zheng btrfs_item_key_to_cpu(leaf, &key, path->slots[0] - 1); 34117d217feSYan Zheng if (key.objectid == BTRFS_EXTENT_CSUM_OBJECTID && 34217d217feSYan Zheng key.type == BTRFS_EXTENT_CSUM_KEY) { 34317d217feSYan Zheng offset = (start - key.offset) >> 3440b246afaSJeff Mahoney fs_info->sb->s_blocksize_bits; 34517d217feSYan Zheng if (offset * csum_size < 34617d217feSYan Zheng btrfs_item_size_nr(leaf, path->slots[0] - 1)) 34717d217feSYan Zheng path->slots[0]--; 34817d217feSYan Zheng } 34917d217feSYan Zheng } 35017d217feSYan Zheng 35117d217feSYan Zheng while (start <= end) { 35217d217feSYan Zheng leaf = path->nodes[0]; 35317d217feSYan Zheng if (path->slots[0] >= btrfs_header_nritems(leaf)) { 35407d400a6SYan Zheng ret = btrfs_next_leaf(root, path); 35517d217feSYan Zheng if (ret < 0) 35617d217feSYan Zheng goto fail; 35717d217feSYan Zheng if (ret > 0) 35817d217feSYan Zheng break; 35917d217feSYan Zheng leaf = path->nodes[0]; 36017d217feSYan Zheng } 36117d217feSYan Zheng 36217d217feSYan Zheng btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); 36317d217feSYan Zheng if (key.objectid != BTRFS_EXTENT_CSUM_OBJECTID || 364628c8282SZhi Yong Wu key.type != BTRFS_EXTENT_CSUM_KEY || 365628c8282SZhi Yong Wu key.offset > end) 36617d217feSYan Zheng break; 36717d217feSYan Zheng 36817d217feSYan Zheng if (key.offset > start) 36917d217feSYan Zheng start = key.offset; 37017d217feSYan Zheng 37117d217feSYan Zheng size = btrfs_item_size_nr(leaf, path->slots[0]); 3720b246afaSJeff Mahoney csum_end = key.offset + (size / csum_size) * fs_info->sectorsize; 37387b29b20SYan Zheng if (csum_end <= start) { 37487b29b20SYan Zheng path->slots[0]++; 37587b29b20SYan Zheng continue; 37687b29b20SYan Zheng } 37717d217feSYan Zheng 37807d400a6SYan Zheng csum_end = min(csum_end, end + 1); 37907d400a6SYan Zheng item = btrfs_item_ptr(path->nodes[0], path->slots[0], 38007d400a6SYan Zheng struct btrfs_csum_item); 38107d400a6SYan Zheng while (start < csum_end) { 38207d400a6SYan Zheng size = min_t(size_t, csum_end - start, 3831e25a2e3SJohannes Thumshirn max_ordered_sum_bytes(fs_info, csum_size)); 3840b246afaSJeff Mahoney sums = kzalloc(btrfs_ordered_sum_size(fs_info, size), 38507d400a6SYan Zheng GFP_NOFS); 3860678b618SMark Fasheh if (!sums) { 3870678b618SMark Fasheh ret = -ENOMEM; 3880678b618SMark Fasheh goto fail; 3890678b618SMark Fasheh } 39017d217feSYan Zheng 39117d217feSYan Zheng sums->bytenr = start; 392f51a4a18SMiao Xie sums->len = (int)size; 39317d217feSYan Zheng 39417d217feSYan Zheng offset = (start - key.offset) >> 3950b246afaSJeff Mahoney fs_info->sb->s_blocksize_bits; 39617d217feSYan Zheng offset *= csum_size; 3970b246afaSJeff Mahoney size >>= fs_info->sb->s_blocksize_bits; 39817d217feSYan Zheng 39907d400a6SYan Zheng read_extent_buffer(path->nodes[0], 400f51a4a18SMiao Xie sums->sums, 401f51a4a18SMiao Xie ((unsigned long)item) + offset, 402f51a4a18SMiao Xie csum_size * size); 40317d217feSYan Zheng 4040b246afaSJeff Mahoney start += fs_info->sectorsize * size; 4050678b618SMark Fasheh list_add_tail(&sums->list, &tmplist); 40607d400a6SYan Zheng } 40717d217feSYan Zheng path->slots[0]++; 40817d217feSYan Zheng } 40917d217feSYan Zheng ret = 0; 41017d217feSYan Zheng fail: 4110678b618SMark Fasheh while (ret < 0 && !list_empty(&tmplist)) { 4126e5aafb2SChris Mason sums = list_entry(tmplist.next, struct btrfs_ordered_sum, list); 4130678b618SMark Fasheh list_del(&sums->list); 4140678b618SMark Fasheh kfree(sums); 4150678b618SMark Fasheh } 4160678b618SMark Fasheh list_splice_tail(&tmplist, list); 4170678b618SMark Fasheh 41817d217feSYan Zheng btrfs_free_path(path); 41917d217feSYan Zheng return ret; 42017d217feSYan Zheng } 42117d217feSYan Zheng 42251d470aeSNikolay Borisov /* 42351d470aeSNikolay Borisov * btrfs_csum_one_bio - Calculates checksums of the data contained inside a bio 42451d470aeSNikolay Borisov * @inode: Owner of the data inside the bio 42551d470aeSNikolay Borisov * @bio: Contains the data to be checksummed 42651d470aeSNikolay Borisov * @file_start: offset in file this bio begins to describe 42751d470aeSNikolay Borisov * @contig: Boolean. If true/1 means all bio vecs in this bio are 42851d470aeSNikolay Borisov * contiguous and they begin at @file_start in the file. False/0 42951d470aeSNikolay Borisov * means this bio can contains potentially discontigous bio vecs 43051d470aeSNikolay Borisov * so the logical offset of each should be calculated separately. 43151d470aeSNikolay Borisov */ 4324e4cbee9SChristoph Hellwig blk_status_t btrfs_csum_one_bio(struct inode *inode, struct bio *bio, 4332ff7e61eSJeff Mahoney u64 file_start, int contig) 434e015640fSChris Mason { 4350b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb); 436d5178578SJohannes Thumshirn SHASH_DESC_ON_STACK(shash, fs_info->csum_shash); 437e6dcd2dcSChris Mason struct btrfs_ordered_sum *sums; 4386cd7ce49SChristoph Hellwig struct btrfs_ordered_extent *ordered = NULL; 439e015640fSChris Mason char *data; 44017347cecSLiu Bo struct bvec_iter iter; 44117347cecSLiu Bo struct bio_vec bvec; 442f51a4a18SMiao Xie int index; 443c40a3d38SChandan Rajendra int nr_sectors; 4443edf7d33SChris Mason unsigned long total_bytes = 0; 4453edf7d33SChris Mason unsigned long this_sum_bytes = 0; 44617347cecSLiu Bo int i; 4473edf7d33SChris Mason u64 offset; 448a3d46aeaSNikolay Borisov unsigned nofs_flag; 4491e25a2e3SJohannes Thumshirn const u16 csum_size = btrfs_super_csum_size(fs_info->super_copy); 450e015640fSChris Mason 451a3d46aeaSNikolay Borisov nofs_flag = memalloc_nofs_save(); 452a3d46aeaSNikolay Borisov sums = kvzalloc(btrfs_ordered_sum_size(fs_info, bio->bi_iter.bi_size), 453a3d46aeaSNikolay Borisov GFP_KERNEL); 454a3d46aeaSNikolay Borisov memalloc_nofs_restore(nofs_flag); 455a3d46aeaSNikolay Borisov 456e015640fSChris Mason if (!sums) 4574e4cbee9SChristoph Hellwig return BLK_STS_RESOURCE; 4583edf7d33SChris Mason 4594f024f37SKent Overstreet sums->len = bio->bi_iter.bi_size; 460e6dcd2dcSChris Mason INIT_LIST_HEAD(&sums->list); 461d20f7043SChris Mason 462d20f7043SChris Mason if (contig) 463d20f7043SChris Mason offset = file_start; 464d20f7043SChris Mason else 4656cd7ce49SChristoph Hellwig offset = 0; /* shut up gcc */ 466d20f7043SChris Mason 4674f024f37SKent Overstreet sums->bytenr = (u64)bio->bi_iter.bi_sector << 9; 468f51a4a18SMiao Xie index = 0; 469e015640fSChris Mason 470d5178578SJohannes Thumshirn shash->tfm = fs_info->csum_shash; 471d5178578SJohannes Thumshirn 47217347cecSLiu Bo bio_for_each_segment(bvec, bio, iter) { 473d20f7043SChris Mason if (!contig) 47417347cecSLiu Bo offset = page_offset(bvec.bv_page) + bvec.bv_offset; 475d20f7043SChris Mason 4766cd7ce49SChristoph Hellwig if (!ordered) { 4776cd7ce49SChristoph Hellwig ordered = btrfs_lookup_ordered_extent(inode, offset); 4786cd7ce49SChristoph Hellwig BUG_ON(!ordered); /* Logic error */ 4796cd7ce49SChristoph Hellwig } 4806cd7ce49SChristoph Hellwig 4810b246afaSJeff Mahoney nr_sectors = BTRFS_BYTES_TO_BLKS(fs_info, 48217347cecSLiu Bo bvec.bv_len + fs_info->sectorsize 483c40a3d38SChandan Rajendra - 1); 484c40a3d38SChandan Rajendra 485c40a3d38SChandan Rajendra for (i = 0; i < nr_sectors; i++) { 486e58dd74bSJosef Bacik if (offset >= ordered->file_offset + ordered->len || 487e58dd74bSJosef Bacik offset < ordered->file_offset) { 4883edf7d33SChris Mason unsigned long bytes_left; 489c40a3d38SChandan Rajendra 4903edf7d33SChris Mason sums->len = this_sum_bytes; 4913edf7d33SChris Mason this_sum_bytes = 0; 492f9756261SNikolay Borisov btrfs_add_ordered_sum(ordered, sums); 4933edf7d33SChris Mason btrfs_put_ordered_extent(ordered); 4943edf7d33SChris Mason 4954f024f37SKent Overstreet bytes_left = bio->bi_iter.bi_size - total_bytes; 4963edf7d33SChris Mason 497a3d46aeaSNikolay Borisov nofs_flag = memalloc_nofs_save(); 498a3d46aeaSNikolay Borisov sums = kvzalloc(btrfs_ordered_sum_size(fs_info, 499a3d46aeaSNikolay Borisov bytes_left), GFP_KERNEL); 500a3d46aeaSNikolay Borisov memalloc_nofs_restore(nofs_flag); 50179787eaaSJeff Mahoney BUG_ON(!sums); /* -ENOMEM */ 5023edf7d33SChris Mason sums->len = bytes_left; 503c40a3d38SChandan Rajendra ordered = btrfs_lookup_ordered_extent(inode, 504c40a3d38SChandan Rajendra offset); 505c40a3d38SChandan Rajendra ASSERT(ordered); /* Logic error */ 506c40a3d38SChandan Rajendra sums->bytenr = ((u64)bio->bi_iter.bi_sector << 9) 507c40a3d38SChandan Rajendra + total_bytes; 508f51a4a18SMiao Xie index = 0; 509c40a3d38SChandan Rajendra } 510c40a3d38SChandan Rajendra 511d5178578SJohannes Thumshirn crypto_shash_init(shash); 512443c8e2aSJohannes Thumshirn data = kmap_atomic(bvec.bv_page); 513d5178578SJohannes Thumshirn crypto_shash_update(shash, data + bvec.bv_offset 5140b246afaSJeff Mahoney + (i * fs_info->sectorsize), 5150b246afaSJeff Mahoney fs_info->sectorsize); 516443c8e2aSJohannes Thumshirn kunmap_atomic(data); 517d5178578SJohannes Thumshirn crypto_shash_final(shash, (char *)(sums->sums + index)); 5181e25a2e3SJohannes Thumshirn index += csum_size; 5190b246afaSJeff Mahoney offset += fs_info->sectorsize; 5200b246afaSJeff Mahoney this_sum_bytes += fs_info->sectorsize; 5210b246afaSJeff Mahoney total_bytes += fs_info->sectorsize; 522c40a3d38SChandan Rajendra } 523c40a3d38SChandan Rajendra 524e015640fSChris Mason } 525ed98b56aSChris Mason this_sum_bytes = 0; 526f9756261SNikolay Borisov btrfs_add_ordered_sum(ordered, sums); 5273edf7d33SChris Mason btrfs_put_ordered_extent(ordered); 528e015640fSChris Mason return 0; 529e015640fSChris Mason } 530e015640fSChris Mason 531459931ecSChris Mason /* 532459931ecSChris Mason * helper function for csum removal, this expects the 533459931ecSChris Mason * key to describe the csum pointed to by the path, and it expects 534459931ecSChris Mason * the csum to overlap the range [bytenr, len] 535459931ecSChris Mason * 536459931ecSChris Mason * The csum should not be entirely contained in the range and the 537459931ecSChris Mason * range should not be entirely contained in the csum. 538459931ecSChris Mason * 539459931ecSChris Mason * This calls btrfs_truncate_item with the correct args based on the 540459931ecSChris Mason * overlap, and fixes up the key as required. 541459931ecSChris Mason */ 5422ff7e61eSJeff Mahoney static noinline void truncate_one_csum(struct btrfs_fs_info *fs_info, 543459931ecSChris Mason struct btrfs_path *path, 544459931ecSChris Mason struct btrfs_key *key, 545459931ecSChris Mason u64 bytenr, u64 len) 546459931ecSChris Mason { 547459931ecSChris Mason struct extent_buffer *leaf; 5480b246afaSJeff Mahoney u16 csum_size = btrfs_super_csum_size(fs_info->super_copy); 549459931ecSChris Mason u64 csum_end; 550459931ecSChris Mason u64 end_byte = bytenr + len; 5510b246afaSJeff Mahoney u32 blocksize_bits = fs_info->sb->s_blocksize_bits; 552459931ecSChris Mason 553459931ecSChris Mason leaf = path->nodes[0]; 554459931ecSChris Mason csum_end = btrfs_item_size_nr(leaf, path->slots[0]) / csum_size; 5550b246afaSJeff Mahoney csum_end <<= fs_info->sb->s_blocksize_bits; 556459931ecSChris Mason csum_end += key->offset; 557459931ecSChris Mason 558459931ecSChris Mason if (key->offset < bytenr && csum_end <= end_byte) { 559459931ecSChris Mason /* 560459931ecSChris Mason * [ bytenr - len ] 561459931ecSChris Mason * [ ] 562459931ecSChris Mason * [csum ] 563459931ecSChris Mason * A simple truncate off the end of the item 564459931ecSChris Mason */ 565459931ecSChris Mason u32 new_size = (bytenr - key->offset) >> blocksize_bits; 566459931ecSChris Mason new_size *= csum_size; 56778ac4f9eSDavid Sterba btrfs_truncate_item(path, new_size, 1); 568459931ecSChris Mason } else if (key->offset >= bytenr && csum_end > end_byte && 569459931ecSChris Mason end_byte > key->offset) { 570459931ecSChris Mason /* 571459931ecSChris Mason * [ bytenr - len ] 572459931ecSChris Mason * [ ] 573459931ecSChris Mason * [csum ] 574459931ecSChris Mason * we need to truncate from the beginning of the csum 575459931ecSChris Mason */ 576459931ecSChris Mason u32 new_size = (csum_end - end_byte) >> blocksize_bits; 577459931ecSChris Mason new_size *= csum_size; 578459931ecSChris Mason 57978ac4f9eSDavid Sterba btrfs_truncate_item(path, new_size, 0); 580459931ecSChris Mason 581459931ecSChris Mason key->offset = end_byte; 5820b246afaSJeff Mahoney btrfs_set_item_key_safe(fs_info, path, key); 583459931ecSChris Mason } else { 584459931ecSChris Mason BUG(); 585459931ecSChris Mason } 586459931ecSChris Mason } 587459931ecSChris Mason 588459931ecSChris Mason /* 589459931ecSChris Mason * deletes the csum items from the csum tree for a given 590459931ecSChris Mason * range of bytes. 591459931ecSChris Mason */ 592459931ecSChris Mason int btrfs_del_csums(struct btrfs_trans_handle *trans, 59340e046acSFilipe Manana struct btrfs_root *root, u64 bytenr, u64 len) 594459931ecSChris Mason { 59540e046acSFilipe Manana struct btrfs_fs_info *fs_info = trans->fs_info; 596459931ecSChris Mason struct btrfs_path *path; 597459931ecSChris Mason struct btrfs_key key; 598459931ecSChris Mason u64 end_byte = bytenr + len; 599459931ecSChris Mason u64 csum_end; 600459931ecSChris Mason struct extent_buffer *leaf; 601459931ecSChris Mason int ret; 6020b246afaSJeff Mahoney u16 csum_size = btrfs_super_csum_size(fs_info->super_copy); 6030b246afaSJeff Mahoney int blocksize_bits = fs_info->sb->s_blocksize_bits; 604459931ecSChris Mason 60540e046acSFilipe Manana ASSERT(root == fs_info->csum_root || 60640e046acSFilipe Manana root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID); 60740e046acSFilipe Manana 608459931ecSChris Mason path = btrfs_alloc_path(); 6092a29edc6Sliubo if (!path) 6102a29edc6Sliubo return -ENOMEM; 611459931ecSChris Mason 612459931ecSChris Mason while (1) { 613459931ecSChris Mason key.objectid = BTRFS_EXTENT_CSUM_OBJECTID; 614459931ecSChris Mason key.offset = end_byte - 1; 615459931ecSChris Mason key.type = BTRFS_EXTENT_CSUM_KEY; 616459931ecSChris Mason 617b9473439SChris Mason path->leave_spinning = 1; 618459931ecSChris Mason ret = btrfs_search_slot(trans, root, &key, path, -1, 1); 619459931ecSChris Mason if (ret > 0) { 620459931ecSChris Mason if (path->slots[0] == 0) 62165a246c5STsutomu Itoh break; 622459931ecSChris Mason path->slots[0]--; 623ad0397a7SJosef Bacik } else if (ret < 0) { 62465a246c5STsutomu Itoh break; 625459931ecSChris Mason } 626ad0397a7SJosef Bacik 627459931ecSChris Mason leaf = path->nodes[0]; 628459931ecSChris Mason btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); 629459931ecSChris Mason 630459931ecSChris Mason if (key.objectid != BTRFS_EXTENT_CSUM_OBJECTID || 631459931ecSChris Mason key.type != BTRFS_EXTENT_CSUM_KEY) { 632459931ecSChris Mason break; 633459931ecSChris Mason } 634459931ecSChris Mason 635459931ecSChris Mason if (key.offset >= end_byte) 636459931ecSChris Mason break; 637459931ecSChris Mason 638459931ecSChris Mason csum_end = btrfs_item_size_nr(leaf, path->slots[0]) / csum_size; 639459931ecSChris Mason csum_end <<= blocksize_bits; 640459931ecSChris Mason csum_end += key.offset; 641459931ecSChris Mason 642459931ecSChris Mason /* this csum ends before we start, we're done */ 643459931ecSChris Mason if (csum_end <= bytenr) 644459931ecSChris Mason break; 645459931ecSChris Mason 646459931ecSChris Mason /* delete the entire item, it is inside our range */ 647459931ecSChris Mason if (key.offset >= bytenr && csum_end <= end_byte) { 6486f546216SFilipe Manana int del_nr = 1; 6496f546216SFilipe Manana 6506f546216SFilipe Manana /* 6516f546216SFilipe Manana * Check how many csum items preceding this one in this 6526f546216SFilipe Manana * leaf correspond to our range and then delete them all 6536f546216SFilipe Manana * at once. 6546f546216SFilipe Manana */ 6556f546216SFilipe Manana if (key.offset > bytenr && path->slots[0] > 0) { 6566f546216SFilipe Manana int slot = path->slots[0] - 1; 6576f546216SFilipe Manana 6586f546216SFilipe Manana while (slot >= 0) { 6596f546216SFilipe Manana struct btrfs_key pk; 6606f546216SFilipe Manana 6616f546216SFilipe Manana btrfs_item_key_to_cpu(leaf, &pk, slot); 6626f546216SFilipe Manana if (pk.offset < bytenr || 6636f546216SFilipe Manana pk.type != BTRFS_EXTENT_CSUM_KEY || 6646f546216SFilipe Manana pk.objectid != 6656f546216SFilipe Manana BTRFS_EXTENT_CSUM_OBJECTID) 6666f546216SFilipe Manana break; 6676f546216SFilipe Manana path->slots[0] = slot; 6686f546216SFilipe Manana del_nr++; 6696f546216SFilipe Manana key.offset = pk.offset; 6706f546216SFilipe Manana slot--; 6716f546216SFilipe Manana } 6726f546216SFilipe Manana } 6736f546216SFilipe Manana ret = btrfs_del_items(trans, root, path, 6746f546216SFilipe Manana path->slots[0], del_nr); 67565a246c5STsutomu Itoh if (ret) 67665a246c5STsutomu Itoh goto out; 677dcbdd4dcSChris Mason if (key.offset == bytenr) 678dcbdd4dcSChris Mason break; 679459931ecSChris Mason } else if (key.offset < bytenr && csum_end > end_byte) { 680459931ecSChris Mason unsigned long offset; 681459931ecSChris Mason unsigned long shift_len; 682459931ecSChris Mason unsigned long item_offset; 683459931ecSChris Mason /* 684459931ecSChris Mason * [ bytenr - len ] 685459931ecSChris Mason * [csum ] 686459931ecSChris Mason * 687459931ecSChris Mason * Our bytes are in the middle of the csum, 688459931ecSChris Mason * we need to split this item and insert a new one. 689459931ecSChris Mason * 690459931ecSChris Mason * But we can't drop the path because the 691459931ecSChris Mason * csum could change, get removed, extended etc. 692459931ecSChris Mason * 693459931ecSChris Mason * The trick here is the max size of a csum item leaves 694459931ecSChris Mason * enough room in the tree block for a single 695459931ecSChris Mason * item header. So, we split the item in place, 696459931ecSChris Mason * adding a new header pointing to the existing 697459931ecSChris Mason * bytes. Then we loop around again and we have 698459931ecSChris Mason * a nicely formed csum item that we can neatly 699459931ecSChris Mason * truncate. 700459931ecSChris Mason */ 701459931ecSChris Mason offset = (bytenr - key.offset) >> blocksize_bits; 702459931ecSChris Mason offset *= csum_size; 703459931ecSChris Mason 704459931ecSChris Mason shift_len = (len >> blocksize_bits) * csum_size; 705459931ecSChris Mason 706459931ecSChris Mason item_offset = btrfs_item_ptr_offset(leaf, 707459931ecSChris Mason path->slots[0]); 708459931ecSChris Mason 709b159fa28SDavid Sterba memzero_extent_buffer(leaf, item_offset + offset, 710459931ecSChris Mason shift_len); 711459931ecSChris Mason key.offset = bytenr; 712459931ecSChris Mason 713459931ecSChris Mason /* 714459931ecSChris Mason * btrfs_split_item returns -EAGAIN when the 715459931ecSChris Mason * item changed size or key 716459931ecSChris Mason */ 717459931ecSChris Mason ret = btrfs_split_item(trans, root, path, &key, offset); 71879787eaaSJeff Mahoney if (ret && ret != -EAGAIN) { 71966642832SJeff Mahoney btrfs_abort_transaction(trans, ret); 72079787eaaSJeff Mahoney goto out; 72179787eaaSJeff Mahoney } 722459931ecSChris Mason 723459931ecSChris Mason key.offset = end_byte - 1; 724459931ecSChris Mason } else { 7252ff7e61eSJeff Mahoney truncate_one_csum(fs_info, path, &key, bytenr, len); 726dcbdd4dcSChris Mason if (key.offset < bytenr) 727dcbdd4dcSChris Mason break; 728459931ecSChris Mason } 729b3b4aa74SDavid Sterba btrfs_release_path(path); 730459931ecSChris Mason } 73165a246c5STsutomu Itoh ret = 0; 732459931ecSChris Mason out: 733459931ecSChris Mason btrfs_free_path(path); 73465a246c5STsutomu Itoh return ret; 735459931ecSChris Mason } 736459931ecSChris Mason 737065631f6SChris Mason int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans, 738d20f7043SChris Mason struct btrfs_root *root, 739e6dcd2dcSChris Mason struct btrfs_ordered_sum *sums) 740f254e52cSChris Mason { 7410b246afaSJeff Mahoney struct btrfs_fs_info *fs_info = root->fs_info; 742f254e52cSChris Mason struct btrfs_key file_key; 7436567e837SChris Mason struct btrfs_key found_key; 7445caf2a00SChris Mason struct btrfs_path *path; 745f254e52cSChris Mason struct btrfs_csum_item *item; 746065631f6SChris Mason struct btrfs_csum_item *item_end; 747ff79f819SChris Mason struct extent_buffer *leaf = NULL; 748f51a4a18SMiao Xie u64 next_offset; 749f51a4a18SMiao Xie u64 total_bytes = 0; 7506567e837SChris Mason u64 csum_offset; 751f51a4a18SMiao Xie u64 bytenr; 752f578d4bdSChris Mason u32 nritems; 753f578d4bdSChris Mason u32 ins_size; 754f51a4a18SMiao Xie int index = 0; 755f51a4a18SMiao Xie int found_next; 756f51a4a18SMiao Xie int ret; 7570b246afaSJeff Mahoney u16 csum_size = btrfs_super_csum_size(fs_info->super_copy); 7586e92f5e6SChris Mason 7595caf2a00SChris Mason path = btrfs_alloc_path(); 760d8926bb3SMark Fasheh if (!path) 761d8926bb3SMark Fasheh return -ENOMEM; 762065631f6SChris Mason again: 763065631f6SChris Mason next_offset = (u64)-1; 764065631f6SChris Mason found_next = 0; 765f51a4a18SMiao Xie bytenr = sums->bytenr + total_bytes; 766d20f7043SChris Mason file_key.objectid = BTRFS_EXTENT_CSUM_OBJECTID; 767f51a4a18SMiao Xie file_key.offset = bytenr; 768962a298fSDavid Sterba file_key.type = BTRFS_EXTENT_CSUM_KEY; 769a429e513SChris Mason 770f51a4a18SMiao Xie item = btrfs_lookup_csum(trans, root, path, bytenr, 1); 771ff79f819SChris Mason if (!IS_ERR(item)) { 772639cb586SChris Mason ret = 0; 773f51a4a18SMiao Xie leaf = path->nodes[0]; 774f51a4a18SMiao Xie item_end = btrfs_item_ptr(leaf, path->slots[0], 775f51a4a18SMiao Xie struct btrfs_csum_item); 776f51a4a18SMiao Xie item_end = (struct btrfs_csum_item *)((char *)item_end + 777f51a4a18SMiao Xie btrfs_item_size_nr(leaf, path->slots[0])); 778a429e513SChris Mason goto found; 779ff79f819SChris Mason } 780a429e513SChris Mason ret = PTR_ERR(item); 7814a500fd1SYan, Zheng if (ret != -EFBIG && ret != -ENOENT) 7824a500fd1SYan, Zheng goto fail_unlock; 7834a500fd1SYan, Zheng 784a429e513SChris Mason if (ret == -EFBIG) { 785a429e513SChris Mason u32 item_size; 786a429e513SChris Mason /* we found one, but it isn't big enough yet */ 7875f39d397SChris Mason leaf = path->nodes[0]; 7885f39d397SChris Mason item_size = btrfs_item_size_nr(leaf, path->slots[0]); 789607d432dSJosef Bacik if ((item_size / csum_size) >= 7900b246afaSJeff Mahoney MAX_CSUM_ITEMS(fs_info, csum_size)) { 791a429e513SChris Mason /* already at max size, make a new one */ 792a429e513SChris Mason goto insert; 793a429e513SChris Mason } 794a429e513SChris Mason } else { 795f578d4bdSChris Mason int slot = path->slots[0] + 1; 796a429e513SChris Mason /* we didn't find a csum item, insert one */ 797f578d4bdSChris Mason nritems = btrfs_header_nritems(path->nodes[0]); 79835045bf2SFilipe Manana if (!nritems || (path->slots[0] >= nritems - 1)) { 799f578d4bdSChris Mason ret = btrfs_next_leaf(root, path); 800b56baf5bSYan if (ret == 1) 801f578d4bdSChris Mason found_next = 1; 802b56baf5bSYan if (ret != 0) 803f578d4bdSChris Mason goto insert; 80427b9a812SFilipe Manana slot = path->slots[0]; 805f578d4bdSChris Mason } 806f578d4bdSChris Mason btrfs_item_key_to_cpu(path->nodes[0], &found_key, slot); 807d20f7043SChris Mason if (found_key.objectid != BTRFS_EXTENT_CSUM_OBJECTID || 808d20f7043SChris Mason found_key.type != BTRFS_EXTENT_CSUM_KEY) { 809f578d4bdSChris Mason found_next = 1; 810f578d4bdSChris Mason goto insert; 811f578d4bdSChris Mason } 812f578d4bdSChris Mason next_offset = found_key.offset; 813f578d4bdSChris Mason found_next = 1; 814a429e513SChris Mason goto insert; 815a429e513SChris Mason } 816a429e513SChris Mason 817a429e513SChris Mason /* 818a429e513SChris Mason * at this point, we know the tree has an item, but it isn't big 819a429e513SChris Mason * enough yet to put our csum in. Grow it 820a429e513SChris Mason */ 821b3b4aa74SDavid Sterba btrfs_release_path(path); 8226567e837SChris Mason ret = btrfs_search_slot(trans, root, &file_key, path, 823607d432dSJosef Bacik csum_size, 1); 8246567e837SChris Mason if (ret < 0) 82553863232SChris Mason goto fail_unlock; 826459931ecSChris Mason 827459931ecSChris Mason if (ret > 0) { 828459931ecSChris Mason if (path->slots[0] == 0) 8296567e837SChris Mason goto insert; 8306567e837SChris Mason path->slots[0]--; 831459931ecSChris Mason } 832459931ecSChris Mason 8335f39d397SChris Mason leaf = path->nodes[0]; 8345f39d397SChris Mason btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); 835d20f7043SChris Mason csum_offset = (bytenr - found_key.offset) >> 8360b246afaSJeff Mahoney fs_info->sb->s_blocksize_bits; 837459931ecSChris Mason 838962a298fSDavid Sterba if (found_key.type != BTRFS_EXTENT_CSUM_KEY || 839d20f7043SChris Mason found_key.objectid != BTRFS_EXTENT_CSUM_OBJECTID || 8400b246afaSJeff Mahoney csum_offset >= MAX_CSUM_ITEMS(fs_info, csum_size)) { 8416567e837SChris Mason goto insert; 8426567e837SChris Mason } 843459931ecSChris Mason 8442f697dc6SLiu Bo if (csum_offset == btrfs_item_size_nr(leaf, path->slots[0]) / 845607d432dSJosef Bacik csum_size) { 8462f697dc6SLiu Bo int extend_nr; 8472f697dc6SLiu Bo u64 tmp; 8482f697dc6SLiu Bo u32 diff; 8492f697dc6SLiu Bo u32 free_space; 850459931ecSChris Mason 851e902baacSDavid Sterba if (btrfs_leaf_free_space(leaf) < 8522f697dc6SLiu Bo sizeof(struct btrfs_item) + csum_size * 2) 8532f697dc6SLiu Bo goto insert; 8542f697dc6SLiu Bo 855e902baacSDavid Sterba free_space = btrfs_leaf_free_space(leaf) - 8562f697dc6SLiu Bo sizeof(struct btrfs_item) - csum_size; 857f51a4a18SMiao Xie tmp = sums->len - total_bytes; 8580b246afaSJeff Mahoney tmp >>= fs_info->sb->s_blocksize_bits; 8592f697dc6SLiu Bo WARN_ON(tmp < 1); 8602f697dc6SLiu Bo 8612f697dc6SLiu Bo extend_nr = max_t(int, 1, (int)tmp); 8622f697dc6SLiu Bo diff = (csum_offset + extend_nr) * csum_size; 8630b246afaSJeff Mahoney diff = min(diff, 8640b246afaSJeff Mahoney MAX_CSUM_ITEMS(fs_info, csum_size) * csum_size); 865459931ecSChris Mason 8665f39d397SChris Mason diff = diff - btrfs_item_size_nr(leaf, path->slots[0]); 8672f697dc6SLiu Bo diff = min(free_space, diff); 8682f697dc6SLiu Bo diff /= csum_size; 8692f697dc6SLiu Bo diff *= csum_size; 870459931ecSChris Mason 871c71dd880SDavid Sterba btrfs_extend_item(path, diff); 872f51a4a18SMiao Xie ret = 0; 8736567e837SChris Mason goto csum; 8746567e837SChris Mason } 8756567e837SChris Mason 8766567e837SChris Mason insert: 877b3b4aa74SDavid Sterba btrfs_release_path(path); 8786567e837SChris Mason csum_offset = 0; 879f578d4bdSChris Mason if (found_next) { 8802f697dc6SLiu Bo u64 tmp; 881d20f7043SChris Mason 882f51a4a18SMiao Xie tmp = sums->len - total_bytes; 8830b246afaSJeff Mahoney tmp >>= fs_info->sb->s_blocksize_bits; 8842f697dc6SLiu Bo tmp = min(tmp, (next_offset - file_key.offset) >> 8850b246afaSJeff Mahoney fs_info->sb->s_blocksize_bits); 8862f697dc6SLiu Bo 88750d0446eSSeraphime Kirkovski tmp = max_t(u64, 1, tmp); 88850d0446eSSeraphime Kirkovski tmp = min_t(u64, tmp, MAX_CSUM_ITEMS(fs_info, csum_size)); 889607d432dSJosef Bacik ins_size = csum_size * tmp; 890f578d4bdSChris Mason } else { 891607d432dSJosef Bacik ins_size = csum_size; 892f578d4bdSChris Mason } 893b9473439SChris Mason path->leave_spinning = 1; 8945caf2a00SChris Mason ret = btrfs_insert_empty_item(trans, root, path, &file_key, 895f578d4bdSChris Mason ins_size); 896b9473439SChris Mason path->leave_spinning = 0; 89754aa1f4dSChris Mason if (ret < 0) 89853863232SChris Mason goto fail_unlock; 899fae7f21cSDulshani Gunawardhana if (WARN_ON(ret != 0)) 90053863232SChris Mason goto fail_unlock; 9015f39d397SChris Mason leaf = path->nodes[0]; 902f51a4a18SMiao Xie csum: 9035f39d397SChris Mason item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item); 904f51a4a18SMiao Xie item_end = (struct btrfs_csum_item *)((unsigned char *)item + 905f51a4a18SMiao Xie btrfs_item_size_nr(leaf, path->slots[0])); 906509659cdSChris Mason item = (struct btrfs_csum_item *)((unsigned char *)item + 907607d432dSJosef Bacik csum_offset * csum_size); 908b18c6685SChris Mason found: 909f51a4a18SMiao Xie ins_size = (u32)(sums->len - total_bytes) >> 9100b246afaSJeff Mahoney fs_info->sb->s_blocksize_bits; 911f51a4a18SMiao Xie ins_size *= csum_size; 912f51a4a18SMiao Xie ins_size = min_t(u32, (unsigned long)item_end - (unsigned long)item, 913f51a4a18SMiao Xie ins_size); 914f51a4a18SMiao Xie write_extent_buffer(leaf, sums->sums + index, (unsigned long)item, 915f51a4a18SMiao Xie ins_size); 916aadfeb6eSChris Mason 9171e25a2e3SJohannes Thumshirn index += ins_size; 918f51a4a18SMiao Xie ins_size /= csum_size; 9190b246afaSJeff Mahoney total_bytes += ins_size * fs_info->sectorsize; 920a6591715SChris Mason 9215caf2a00SChris Mason btrfs_mark_buffer_dirty(path->nodes[0]); 922e6dcd2dcSChris Mason if (total_bytes < sums->len) { 923b3b4aa74SDavid Sterba btrfs_release_path(path); 924b9473439SChris Mason cond_resched(); 925065631f6SChris Mason goto again; 926065631f6SChris Mason } 92753863232SChris Mason out: 9285caf2a00SChris Mason btrfs_free_path(path); 929f254e52cSChris Mason return ret; 93053863232SChris Mason 93153863232SChris Mason fail_unlock: 93253863232SChris Mason goto out; 933f254e52cSChris Mason } 9347ffbb598SFilipe Manana 9359cdc5124SNikolay Borisov void btrfs_extent_item_to_extent_map(struct btrfs_inode *inode, 9367ffbb598SFilipe Manana const struct btrfs_path *path, 9377ffbb598SFilipe Manana struct btrfs_file_extent_item *fi, 9387ffbb598SFilipe Manana const bool new_inline, 9397ffbb598SFilipe Manana struct extent_map *em) 9407ffbb598SFilipe Manana { 9413ffbd68cSDavid Sterba struct btrfs_fs_info *fs_info = inode->root->fs_info; 9429cdc5124SNikolay Borisov struct btrfs_root *root = inode->root; 9437ffbb598SFilipe Manana struct extent_buffer *leaf = path->nodes[0]; 9447ffbb598SFilipe Manana const int slot = path->slots[0]; 9457ffbb598SFilipe Manana struct btrfs_key key; 9467ffbb598SFilipe Manana u64 extent_start, extent_end; 9477ffbb598SFilipe Manana u64 bytenr; 9487ffbb598SFilipe Manana u8 type = btrfs_file_extent_type(leaf, fi); 9497ffbb598SFilipe Manana int compress_type = btrfs_file_extent_compression(leaf, fi); 9507ffbb598SFilipe Manana 9517ffbb598SFilipe Manana btrfs_item_key_to_cpu(leaf, &key, slot); 9527ffbb598SFilipe Manana extent_start = key.offset; 9537ffbb598SFilipe Manana 9547ffbb598SFilipe Manana if (type == BTRFS_FILE_EXTENT_REG || 9557ffbb598SFilipe Manana type == BTRFS_FILE_EXTENT_PREALLOC) { 9567ffbb598SFilipe Manana extent_end = extent_start + 9577ffbb598SFilipe Manana btrfs_file_extent_num_bytes(leaf, fi); 9587ffbb598SFilipe Manana } else if (type == BTRFS_FILE_EXTENT_INLINE) { 9597ffbb598SFilipe Manana size_t size; 960e41ca589SQu Wenruo size = btrfs_file_extent_ram_bytes(leaf, fi); 961da17066cSJeff Mahoney extent_end = ALIGN(extent_start + size, 9620b246afaSJeff Mahoney fs_info->sectorsize); 9637ffbb598SFilipe Manana } 9647ffbb598SFilipe Manana 9657ffbb598SFilipe Manana em->ram_bytes = btrfs_file_extent_ram_bytes(leaf, fi); 9667ffbb598SFilipe Manana if (type == BTRFS_FILE_EXTENT_REG || 9677ffbb598SFilipe Manana type == BTRFS_FILE_EXTENT_PREALLOC) { 9687ffbb598SFilipe Manana em->start = extent_start; 9697ffbb598SFilipe Manana em->len = extent_end - extent_start; 9707ffbb598SFilipe Manana em->orig_start = extent_start - 9717ffbb598SFilipe Manana btrfs_file_extent_offset(leaf, fi); 9727ffbb598SFilipe Manana em->orig_block_len = btrfs_file_extent_disk_num_bytes(leaf, fi); 9737ffbb598SFilipe Manana bytenr = btrfs_file_extent_disk_bytenr(leaf, fi); 9747ffbb598SFilipe Manana if (bytenr == 0) { 9757ffbb598SFilipe Manana em->block_start = EXTENT_MAP_HOLE; 9767ffbb598SFilipe Manana return; 9777ffbb598SFilipe Manana } 9787ffbb598SFilipe Manana if (compress_type != BTRFS_COMPRESS_NONE) { 9797ffbb598SFilipe Manana set_bit(EXTENT_FLAG_COMPRESSED, &em->flags); 9807ffbb598SFilipe Manana em->compress_type = compress_type; 9817ffbb598SFilipe Manana em->block_start = bytenr; 9827ffbb598SFilipe Manana em->block_len = em->orig_block_len; 9837ffbb598SFilipe Manana } else { 9847ffbb598SFilipe Manana bytenr += btrfs_file_extent_offset(leaf, fi); 9857ffbb598SFilipe Manana em->block_start = bytenr; 9867ffbb598SFilipe Manana em->block_len = em->len; 9877ffbb598SFilipe Manana if (type == BTRFS_FILE_EXTENT_PREALLOC) 9887ffbb598SFilipe Manana set_bit(EXTENT_FLAG_PREALLOC, &em->flags); 9897ffbb598SFilipe Manana } 9907ffbb598SFilipe Manana } else if (type == BTRFS_FILE_EXTENT_INLINE) { 9917ffbb598SFilipe Manana em->block_start = EXTENT_MAP_INLINE; 9927ffbb598SFilipe Manana em->start = extent_start; 9937ffbb598SFilipe Manana em->len = extent_end - extent_start; 9947ffbb598SFilipe Manana /* 9957ffbb598SFilipe Manana * Initialize orig_start and block_len with the same values 9967ffbb598SFilipe Manana * as in inode.c:btrfs_get_extent(). 9977ffbb598SFilipe Manana */ 9987ffbb598SFilipe Manana em->orig_start = EXTENT_MAP_HOLE; 9997ffbb598SFilipe Manana em->block_len = (u64)-1; 10007ffbb598SFilipe Manana if (!new_inline && compress_type != BTRFS_COMPRESS_NONE) { 10017ffbb598SFilipe Manana set_bit(EXTENT_FLAG_COMPRESSED, &em->flags); 10027ffbb598SFilipe Manana em->compress_type = compress_type; 10037ffbb598SFilipe Manana } 10047ffbb598SFilipe Manana } else { 10050b246afaSJeff Mahoney btrfs_err(fs_info, 10069cdc5124SNikolay Borisov "unknown file extent item type %d, inode %llu, offset %llu, " 10079cdc5124SNikolay Borisov "root %llu", type, btrfs_ino(inode), extent_start, 10087ffbb598SFilipe Manana root->root_key.objectid); 10097ffbb598SFilipe Manana } 10107ffbb598SFilipe Manana } 1011