16cbd5570SChris Mason /* 26cbd5570SChris Mason * Copyright (C) 2007 Oracle. All rights reserved. 36cbd5570SChris Mason * 46cbd5570SChris Mason * This program is free software; you can redistribute it and/or 56cbd5570SChris Mason * modify it under the terms of the GNU General Public 66cbd5570SChris Mason * License v2 as published by the Free Software Foundation. 76cbd5570SChris Mason * 86cbd5570SChris Mason * This program is distributed in the hope that it will be useful, 96cbd5570SChris Mason * but WITHOUT ANY WARRANTY; without even the implied warranty of 106cbd5570SChris Mason * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 116cbd5570SChris Mason * General Public License for more details. 126cbd5570SChris Mason * 136cbd5570SChris Mason * You should have received a copy of the GNU General Public 146cbd5570SChris Mason * License along with this program; if not, write to the 156cbd5570SChris Mason * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 166cbd5570SChris Mason * Boston, MA 021110-1307, USA. 176cbd5570SChris Mason */ 186cbd5570SChris Mason 19065631f6SChris Mason #include <linux/bio.h> 205a0e3ad6STejun Heo #include <linux/slab.h> 21065631f6SChris Mason #include <linux/pagemap.h> 22065631f6SChris Mason #include <linux/highmem.h> 231e1d2701SChris Mason #include "ctree.h" 24dee26a9fSChris Mason #include "disk-io.h" 259f5fae2fSChris Mason #include "transaction.h" 261de037a4SChris Mason #include "print-tree.h" 271e1d2701SChris Mason 28607d432dSJosef Bacik #define MAX_CSUM_ITEMS(r, size) ((((BTRFS_LEAF_DATA_SIZE(r) - \ 29a429e513SChris Mason sizeof(struct btrfs_item) * 2) / \ 30607d432dSJosef Bacik size) - 1)) 3107d400a6SYan Zheng 3207d400a6SYan Zheng #define MAX_ORDERED_SUM_BYTES(r) ((PAGE_SIZE - \ 3307d400a6SYan Zheng sizeof(struct btrfs_ordered_sum)) / \ 3407d400a6SYan Zheng sizeof(struct btrfs_sector_sum) * \ 3507d400a6SYan Zheng (r)->sectorsize - (r)->sectorsize) 3607d400a6SYan Zheng 37b18c6685SChris Mason int btrfs_insert_file_extent(struct btrfs_trans_handle *trans, 38dee26a9fSChris Mason struct btrfs_root *root, 39b18c6685SChris Mason u64 objectid, u64 pos, 40f2eb0a24SSage Weil u64 disk_offset, u64 disk_num_bytes, 41c8b97818SChris Mason u64 num_bytes, u64 offset, u64 ram_bytes, 42c8b97818SChris Mason u8 compression, u8 encryption, u16 other_encoding) 439f5fae2fSChris Mason { 44dee26a9fSChris Mason int ret = 0; 45dee26a9fSChris Mason struct btrfs_file_extent_item *item; 46dee26a9fSChris Mason struct btrfs_key file_key; 475caf2a00SChris Mason struct btrfs_path *path; 485f39d397SChris Mason struct extent_buffer *leaf; 49dee26a9fSChris Mason 505caf2a00SChris Mason path = btrfs_alloc_path(); 51db5b493aSTsutomu Itoh if (!path) 52db5b493aSTsutomu Itoh return -ENOMEM; 53dee26a9fSChris Mason file_key.objectid = objectid; 54b18c6685SChris Mason file_key.offset = pos; 55dee26a9fSChris Mason btrfs_set_key_type(&file_key, BTRFS_EXTENT_DATA_KEY); 56dee26a9fSChris Mason 57b9473439SChris Mason path->leave_spinning = 1; 585caf2a00SChris Mason ret = btrfs_insert_empty_item(trans, root, path, &file_key, 59dee26a9fSChris Mason sizeof(*item)); 6054aa1f4dSChris Mason if (ret < 0) 6154aa1f4dSChris Mason goto out; 629773a788SChris Mason BUG_ON(ret); 635f39d397SChris Mason leaf = path->nodes[0]; 645f39d397SChris Mason item = btrfs_item_ptr(leaf, path->slots[0], 65dee26a9fSChris Mason struct btrfs_file_extent_item); 66f2eb0a24SSage Weil btrfs_set_file_extent_disk_bytenr(leaf, item, disk_offset); 67db94535dSChris Mason btrfs_set_file_extent_disk_num_bytes(leaf, item, disk_num_bytes); 68f2eb0a24SSage Weil btrfs_set_file_extent_offset(leaf, item, offset); 69db94535dSChris Mason btrfs_set_file_extent_num_bytes(leaf, item, num_bytes); 70c8b97818SChris Mason btrfs_set_file_extent_ram_bytes(leaf, item, ram_bytes); 715f39d397SChris Mason btrfs_set_file_extent_generation(leaf, item, trans->transid); 725f39d397SChris Mason btrfs_set_file_extent_type(leaf, item, BTRFS_FILE_EXTENT_REG); 73c8b97818SChris Mason btrfs_set_file_extent_compression(leaf, item, compression); 74c8b97818SChris Mason btrfs_set_file_extent_encryption(leaf, item, encryption); 75c8b97818SChris Mason btrfs_set_file_extent_other_encoding(leaf, item, other_encoding); 76c8b97818SChris Mason 775f39d397SChris Mason btrfs_mark_buffer_dirty(leaf); 7854aa1f4dSChris Mason out: 795caf2a00SChris Mason btrfs_free_path(path); 8054aa1f4dSChris Mason return ret; 819f5fae2fSChris Mason } 82dee26a9fSChris Mason 83b18c6685SChris Mason struct btrfs_csum_item *btrfs_lookup_csum(struct btrfs_trans_handle *trans, 84b18c6685SChris Mason struct btrfs_root *root, 856567e837SChris Mason struct btrfs_path *path, 86d20f7043SChris Mason u64 bytenr, int cow) 876567e837SChris Mason { 886567e837SChris Mason int ret; 896567e837SChris Mason struct btrfs_key file_key; 906567e837SChris Mason struct btrfs_key found_key; 916567e837SChris Mason struct btrfs_csum_item *item; 925f39d397SChris Mason struct extent_buffer *leaf; 936567e837SChris Mason u64 csum_offset = 0; 94607d432dSJosef Bacik u16 csum_size = 95607d432dSJosef Bacik btrfs_super_csum_size(&root->fs_info->super_copy); 96a429e513SChris Mason int csums_in_item; 976567e837SChris Mason 98d20f7043SChris Mason file_key.objectid = BTRFS_EXTENT_CSUM_OBJECTID; 99d20f7043SChris Mason file_key.offset = bytenr; 100d20f7043SChris Mason btrfs_set_key_type(&file_key, BTRFS_EXTENT_CSUM_KEY); 101b18c6685SChris Mason ret = btrfs_search_slot(trans, root, &file_key, path, 0, cow); 1026567e837SChris Mason if (ret < 0) 1036567e837SChris Mason goto fail; 1045f39d397SChris Mason leaf = path->nodes[0]; 1056567e837SChris Mason if (ret > 0) { 1066567e837SChris Mason ret = 1; 10770b2befdSChris Mason if (path->slots[0] == 0) 1086567e837SChris Mason goto fail; 1096567e837SChris Mason path->slots[0]--; 1105f39d397SChris Mason btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); 111d20f7043SChris Mason if (btrfs_key_type(&found_key) != BTRFS_EXTENT_CSUM_KEY) 1126567e837SChris Mason goto fail; 113d20f7043SChris Mason 114d20f7043SChris Mason csum_offset = (bytenr - found_key.offset) >> 1156567e837SChris Mason root->fs_info->sb->s_blocksize_bits; 1165f39d397SChris Mason csums_in_item = btrfs_item_size_nr(leaf, path->slots[0]); 117607d432dSJosef Bacik csums_in_item /= csum_size; 118a429e513SChris Mason 119a429e513SChris Mason if (csum_offset >= csums_in_item) { 120a429e513SChris Mason ret = -EFBIG; 1216567e837SChris Mason 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 1346567e837SChris Mason 135dee26a9fSChris Mason int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans, 136dee26a9fSChris Mason struct btrfs_root *root, 137dee26a9fSChris Mason struct btrfs_path *path, u64 objectid, 1389773a788SChris Mason u64 offset, int mod) 139dee26a9fSChris Mason { 140dee26a9fSChris Mason int ret; 141dee26a9fSChris Mason struct btrfs_key file_key; 142dee26a9fSChris Mason int ins_len = mod < 0 ? -1 : 0; 143dee26a9fSChris Mason int cow = mod != 0; 144dee26a9fSChris Mason 145dee26a9fSChris Mason file_key.objectid = objectid; 14670b2befdSChris Mason file_key.offset = offset; 147dee26a9fSChris Mason btrfs_set_key_type(&file_key, BTRFS_EXTENT_DATA_KEY); 148dee26a9fSChris Mason ret = btrfs_search_slot(trans, root, &file_key, path, ins_len, cow); 149dee26a9fSChris Mason return ret; 150dee26a9fSChris Mason } 151f254e52cSChris Mason 15217d217feSYan Zheng 1534b46fce2SJosef Bacik static int __btrfs_lookup_bio_sums(struct btrfs_root *root, 1544b46fce2SJosef Bacik struct inode *inode, struct bio *bio, 1554b46fce2SJosef Bacik u64 logical_offset, u32 *dst, int dio) 15661b49440SChris Mason { 15761b49440SChris Mason u32 sum; 15861b49440SChris Mason struct bio_vec *bvec = bio->bi_io_vec; 15961b49440SChris Mason int bio_index = 0; 1604b46fce2SJosef Bacik u64 offset = 0; 16161b49440SChris Mason u64 item_start_offset = 0; 16261b49440SChris Mason u64 item_last_offset = 0; 163d20f7043SChris Mason u64 disk_bytenr; 16461b49440SChris Mason u32 diff; 165607d432dSJosef Bacik u16 csum_size = 166607d432dSJosef Bacik btrfs_super_csum_size(&root->fs_info->super_copy); 16761b49440SChris Mason int ret; 16861b49440SChris Mason struct btrfs_path *path; 16961b49440SChris Mason struct btrfs_csum_item *item = NULL; 17061b49440SChris Mason struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; 17161b49440SChris Mason 17261b49440SChris Mason path = btrfs_alloc_path(); 173c2db1073STsutomu Itoh if (!path) 174c2db1073STsutomu Itoh return -ENOMEM; 1754d1b5fb4SChris Mason if (bio->bi_size > PAGE_CACHE_SIZE * 8) 1764d1b5fb4SChris Mason path->reada = 2; 17761b49440SChris Mason 17861b49440SChris Mason WARN_ON(bio->bi_vcnt <= 0); 17961b49440SChris Mason 180d20f7043SChris Mason disk_bytenr = (u64)bio->bi_sector << 9; 1814b46fce2SJosef Bacik if (dio) 1824b46fce2SJosef Bacik offset = logical_offset; 18361b49440SChris Mason while (bio_index < bio->bi_vcnt) { 1844b46fce2SJosef Bacik if (!dio) 18561b49440SChris Mason offset = page_offset(bvec->bv_page) + bvec->bv_offset; 186d20f7043SChris Mason ret = btrfs_find_ordered_sum(inode, offset, disk_bytenr, &sum); 18761b49440SChris Mason if (ret == 0) 18861b49440SChris Mason goto found; 18961b49440SChris Mason 190d20f7043SChris Mason if (!item || disk_bytenr < item_start_offset || 191d20f7043SChris Mason disk_bytenr >= item_last_offset) { 19261b49440SChris Mason struct btrfs_key found_key; 19361b49440SChris Mason u32 item_size; 19461b49440SChris Mason 19561b49440SChris Mason if (item) 196b3b4aa74SDavid Sterba btrfs_release_path(path); 197d20f7043SChris Mason item = btrfs_lookup_csum(NULL, root->fs_info->csum_root, 198d20f7043SChris Mason path, disk_bytenr, 0); 19961b49440SChris Mason if (IS_ERR(item)) { 20061b49440SChris Mason ret = PTR_ERR(item); 20161b49440SChris Mason if (ret == -ENOENT || ret == -EFBIG) 20261b49440SChris Mason ret = 0; 20361b49440SChris Mason sum = 0; 20417d217feSYan Zheng if (BTRFS_I(inode)->root->root_key.objectid == 20517d217feSYan Zheng BTRFS_DATA_RELOC_TREE_OBJECTID) { 20617d217feSYan Zheng set_extent_bits(io_tree, offset, 20717d217feSYan Zheng offset + bvec->bv_len - 1, 20817d217feSYan Zheng EXTENT_NODATASUM, GFP_NOFS); 20917d217feSYan Zheng } else { 210d397712bSChris Mason printk(KERN_INFO "btrfs no csum found " 21133345d01SLi Zefan "for inode %llu start %llu\n", 21233345d01SLi Zefan (unsigned long long) 21333345d01SLi Zefan btrfs_ino(inode), 21461b49440SChris Mason (unsigned long long)offset); 21517d217feSYan Zheng } 2166dab8157SChris Mason item = NULL; 217b3b4aa74SDavid Sterba btrfs_release_path(path); 21861b49440SChris Mason goto found; 21961b49440SChris Mason } 22061b49440SChris Mason btrfs_item_key_to_cpu(path->nodes[0], &found_key, 22161b49440SChris Mason path->slots[0]); 22261b49440SChris Mason 22361b49440SChris Mason item_start_offset = found_key.offset; 22461b49440SChris Mason item_size = btrfs_item_size_nr(path->nodes[0], 22561b49440SChris Mason path->slots[0]); 22661b49440SChris Mason item_last_offset = item_start_offset + 227607d432dSJosef Bacik (item_size / csum_size) * 22861b49440SChris Mason root->sectorsize; 22961b49440SChris Mason item = btrfs_item_ptr(path->nodes[0], path->slots[0], 23061b49440SChris Mason struct btrfs_csum_item); 23161b49440SChris Mason } 23261b49440SChris Mason /* 23361b49440SChris Mason * this byte range must be able to fit inside 23461b49440SChris Mason * a single leaf so it will also fit inside a u32 23561b49440SChris Mason */ 236d20f7043SChris Mason diff = disk_bytenr - item_start_offset; 23761b49440SChris Mason diff = diff / root->sectorsize; 238607d432dSJosef Bacik diff = diff * csum_size; 23961b49440SChris Mason 24061b49440SChris Mason read_extent_buffer(path->nodes[0], &sum, 2413de9d6b6SChris Mason ((unsigned long)item) + diff, 242607d432dSJosef Bacik csum_size); 24361b49440SChris Mason found: 244d20f7043SChris Mason if (dst) 245d20f7043SChris Mason *dst++ = sum; 246d20f7043SChris Mason else 24761b49440SChris Mason set_state_private(io_tree, offset, sum); 248d20f7043SChris Mason disk_bytenr += bvec->bv_len; 2494b46fce2SJosef Bacik offset += bvec->bv_len; 25061b49440SChris Mason bio_index++; 25161b49440SChris Mason bvec++; 25261b49440SChris Mason } 25361b49440SChris Mason btrfs_free_path(path); 25461b49440SChris Mason return 0; 25561b49440SChris Mason } 25661b49440SChris Mason 2574b46fce2SJosef Bacik int btrfs_lookup_bio_sums(struct btrfs_root *root, struct inode *inode, 2584b46fce2SJosef Bacik struct bio *bio, u32 *dst) 2594b46fce2SJosef Bacik { 2604b46fce2SJosef Bacik return __btrfs_lookup_bio_sums(root, inode, bio, 0, dst, 0); 2614b46fce2SJosef Bacik } 2624b46fce2SJosef Bacik 2634b46fce2SJosef Bacik int btrfs_lookup_bio_sums_dio(struct btrfs_root *root, struct inode *inode, 2644b46fce2SJosef Bacik struct bio *bio, u64 offset, u32 *dst) 2654b46fce2SJosef Bacik { 2664b46fce2SJosef Bacik return __btrfs_lookup_bio_sums(root, inode, bio, offset, dst, 1); 2674b46fce2SJosef Bacik } 2684b46fce2SJosef Bacik 26917d217feSYan Zheng int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end, 270a2de733cSArne Jansen struct list_head *list, int search_commit) 27117d217feSYan Zheng { 27217d217feSYan Zheng struct btrfs_key key; 27317d217feSYan Zheng struct btrfs_path *path; 27417d217feSYan Zheng struct extent_buffer *leaf; 27517d217feSYan Zheng struct btrfs_ordered_sum *sums; 27617d217feSYan Zheng struct btrfs_sector_sum *sector_sum; 27717d217feSYan Zheng struct btrfs_csum_item *item; 27817d217feSYan Zheng unsigned long offset; 27917d217feSYan Zheng int ret; 28017d217feSYan Zheng size_t size; 28117d217feSYan Zheng u64 csum_end; 28217d217feSYan Zheng u16 csum_size = btrfs_super_csum_size(&root->fs_info->super_copy); 28317d217feSYan Zheng 28417d217feSYan Zheng path = btrfs_alloc_path(); 285d8926bb3SMark Fasheh if (!path) 286d8926bb3SMark Fasheh return -ENOMEM; 28717d217feSYan Zheng 288a2de733cSArne Jansen if (search_commit) { 289a2de733cSArne Jansen path->skip_locking = 1; 290a2de733cSArne Jansen path->reada = 2; 291a2de733cSArne Jansen path->search_commit_root = 1; 292a2de733cSArne Jansen } 293a2de733cSArne Jansen 29417d217feSYan Zheng key.objectid = BTRFS_EXTENT_CSUM_OBJECTID; 29517d217feSYan Zheng key.offset = start; 29617d217feSYan Zheng key.type = BTRFS_EXTENT_CSUM_KEY; 29717d217feSYan Zheng 29807d400a6SYan Zheng ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); 29917d217feSYan Zheng if (ret < 0) 30017d217feSYan Zheng goto fail; 30117d217feSYan Zheng if (ret > 0 && path->slots[0] > 0) { 30217d217feSYan Zheng leaf = path->nodes[0]; 30317d217feSYan Zheng btrfs_item_key_to_cpu(leaf, &key, path->slots[0] - 1); 30417d217feSYan Zheng if (key.objectid == BTRFS_EXTENT_CSUM_OBJECTID && 30517d217feSYan Zheng key.type == BTRFS_EXTENT_CSUM_KEY) { 30617d217feSYan Zheng offset = (start - key.offset) >> 30717d217feSYan Zheng root->fs_info->sb->s_blocksize_bits; 30817d217feSYan Zheng if (offset * csum_size < 30917d217feSYan Zheng btrfs_item_size_nr(leaf, path->slots[0] - 1)) 31017d217feSYan Zheng path->slots[0]--; 31117d217feSYan Zheng } 31217d217feSYan Zheng } 31317d217feSYan Zheng 31417d217feSYan Zheng while (start <= end) { 31517d217feSYan Zheng leaf = path->nodes[0]; 31617d217feSYan Zheng if (path->slots[0] >= btrfs_header_nritems(leaf)) { 31707d400a6SYan Zheng ret = btrfs_next_leaf(root, path); 31817d217feSYan Zheng if (ret < 0) 31917d217feSYan Zheng goto fail; 32017d217feSYan Zheng if (ret > 0) 32117d217feSYan Zheng break; 32217d217feSYan Zheng leaf = path->nodes[0]; 32317d217feSYan Zheng } 32417d217feSYan Zheng 32517d217feSYan Zheng btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); 32617d217feSYan Zheng if (key.objectid != BTRFS_EXTENT_CSUM_OBJECTID || 32717d217feSYan Zheng key.type != BTRFS_EXTENT_CSUM_KEY) 32817d217feSYan Zheng break; 32917d217feSYan Zheng 33017d217feSYan Zheng btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); 33117d217feSYan Zheng if (key.offset > end) 33217d217feSYan Zheng break; 33317d217feSYan Zheng 33417d217feSYan Zheng if (key.offset > start) 33517d217feSYan Zheng start = key.offset; 33617d217feSYan Zheng 33717d217feSYan Zheng size = btrfs_item_size_nr(leaf, path->slots[0]); 33817d217feSYan Zheng csum_end = key.offset + (size / csum_size) * root->sectorsize; 33987b29b20SYan Zheng if (csum_end <= start) { 34087b29b20SYan Zheng path->slots[0]++; 34187b29b20SYan Zheng continue; 34287b29b20SYan Zheng } 34317d217feSYan Zheng 34407d400a6SYan Zheng csum_end = min(csum_end, end + 1); 34507d400a6SYan Zheng item = btrfs_item_ptr(path->nodes[0], path->slots[0], 34607d400a6SYan Zheng struct btrfs_csum_item); 34707d400a6SYan Zheng while (start < csum_end) { 34807d400a6SYan Zheng size = min_t(size_t, csum_end - start, 34907d400a6SYan Zheng MAX_ORDERED_SUM_BYTES(root)); 35007d400a6SYan Zheng sums = kzalloc(btrfs_ordered_sum_size(root, size), 35107d400a6SYan Zheng GFP_NOFS); 35217d217feSYan Zheng BUG_ON(!sums); 35317d217feSYan Zheng 35417d217feSYan Zheng sector_sum = sums->sums; 35517d217feSYan Zheng sums->bytenr = start; 35617d217feSYan Zheng sums->len = size; 35717d217feSYan Zheng 35817d217feSYan Zheng offset = (start - key.offset) >> 35917d217feSYan Zheng root->fs_info->sb->s_blocksize_bits; 36017d217feSYan Zheng offset *= csum_size; 36117d217feSYan Zheng 36217d217feSYan Zheng while (size > 0) { 36307d400a6SYan Zheng read_extent_buffer(path->nodes[0], 36407d400a6SYan Zheng §or_sum->sum, 36507d400a6SYan Zheng ((unsigned long)item) + 36607d400a6SYan Zheng offset, csum_size); 36717d217feSYan Zheng sector_sum->bytenr = start; 36817d217feSYan Zheng 36917d217feSYan Zheng size -= root->sectorsize; 37017d217feSYan Zheng start += root->sectorsize; 37117d217feSYan Zheng offset += csum_size; 37217d217feSYan Zheng sector_sum++; 37317d217feSYan Zheng } 37417d217feSYan Zheng list_add_tail(&sums->list, list); 37507d400a6SYan Zheng } 37617d217feSYan Zheng path->slots[0]++; 37717d217feSYan Zheng } 37817d217feSYan Zheng ret = 0; 37917d217feSYan Zheng fail: 38017d217feSYan Zheng btrfs_free_path(path); 38117d217feSYan Zheng return ret; 38217d217feSYan Zheng } 38317d217feSYan Zheng 3843edf7d33SChris Mason int btrfs_csum_one_bio(struct btrfs_root *root, struct inode *inode, 385d20f7043SChris Mason struct bio *bio, u64 file_start, int contig) 386e015640fSChris Mason { 387e6dcd2dcSChris Mason struct btrfs_ordered_sum *sums; 388e6dcd2dcSChris Mason struct btrfs_sector_sum *sector_sum; 3893edf7d33SChris Mason struct btrfs_ordered_extent *ordered; 390e015640fSChris Mason char *data; 391e015640fSChris Mason struct bio_vec *bvec = bio->bi_io_vec; 392e015640fSChris Mason int bio_index = 0; 3933edf7d33SChris Mason unsigned long total_bytes = 0; 3943edf7d33SChris Mason unsigned long this_sum_bytes = 0; 3953edf7d33SChris Mason u64 offset; 396d20f7043SChris Mason u64 disk_bytenr; 397e015640fSChris Mason 398e6dcd2dcSChris Mason WARN_ON(bio->bi_vcnt <= 0); 399e6dcd2dcSChris Mason sums = kzalloc(btrfs_ordered_sum_size(root, bio->bi_size), GFP_NOFS); 400e015640fSChris Mason if (!sums) 401e015640fSChris Mason return -ENOMEM; 4023edf7d33SChris Mason 403ed98b56aSChris Mason sector_sum = sums->sums; 404d20f7043SChris Mason disk_bytenr = (u64)bio->bi_sector << 9; 405e6dcd2dcSChris Mason sums->len = bio->bi_size; 406e6dcd2dcSChris Mason INIT_LIST_HEAD(&sums->list); 407d20f7043SChris Mason 408d20f7043SChris Mason if (contig) 409d20f7043SChris Mason offset = file_start; 410d20f7043SChris Mason else 411d20f7043SChris Mason offset = page_offset(bvec->bv_page) + bvec->bv_offset; 412d20f7043SChris Mason 413d20f7043SChris Mason ordered = btrfs_lookup_ordered_extent(inode, offset); 4143edf7d33SChris Mason BUG_ON(!ordered); 415d20f7043SChris Mason sums->bytenr = ordered->start; 416e015640fSChris Mason 417e015640fSChris Mason while (bio_index < bio->bi_vcnt) { 418d20f7043SChris Mason if (!contig) 4193edf7d33SChris Mason offset = page_offset(bvec->bv_page) + bvec->bv_offset; 420d20f7043SChris Mason 421d20f7043SChris Mason if (!contig && (offset >= ordered->file_offset + ordered->len || 422d20f7043SChris Mason offset < ordered->file_offset)) { 4233edf7d33SChris Mason unsigned long bytes_left; 4243edf7d33SChris Mason sums->len = this_sum_bytes; 4253edf7d33SChris Mason this_sum_bytes = 0; 4263edf7d33SChris Mason btrfs_add_ordered_sum(inode, ordered, sums); 4273edf7d33SChris Mason btrfs_put_ordered_extent(ordered); 4283edf7d33SChris Mason 4293edf7d33SChris Mason bytes_left = bio->bi_size - total_bytes; 4303edf7d33SChris Mason 4313edf7d33SChris Mason sums = kzalloc(btrfs_ordered_sum_size(root, bytes_left), 4323edf7d33SChris Mason GFP_NOFS); 4333edf7d33SChris Mason BUG_ON(!sums); 434ed98b56aSChris Mason sector_sum = sums->sums; 4353edf7d33SChris Mason sums->len = bytes_left; 436d20f7043SChris Mason ordered = btrfs_lookup_ordered_extent(inode, offset); 4373edf7d33SChris Mason BUG_ON(!ordered); 438d20f7043SChris Mason sums->bytenr = ordered->start; 4393edf7d33SChris Mason } 4403edf7d33SChris Mason 441e015640fSChris Mason data = kmap_atomic(bvec->bv_page, KM_USER0); 442e6dcd2dcSChris Mason sector_sum->sum = ~(u32)0; 443e6dcd2dcSChris Mason sector_sum->sum = btrfs_csum_data(root, 444e6dcd2dcSChris Mason data + bvec->bv_offset, 445e6dcd2dcSChris Mason sector_sum->sum, 446e6dcd2dcSChris Mason bvec->bv_len); 447e015640fSChris Mason kunmap_atomic(data, KM_USER0); 448e6dcd2dcSChris Mason btrfs_csum_final(sector_sum->sum, 449e6dcd2dcSChris Mason (char *)§or_sum->sum); 450d20f7043SChris Mason sector_sum->bytenr = disk_bytenr; 451ed98b56aSChris Mason 452e6dcd2dcSChris Mason sector_sum++; 453e015640fSChris Mason bio_index++; 4543edf7d33SChris Mason total_bytes += bvec->bv_len; 4553edf7d33SChris Mason this_sum_bytes += bvec->bv_len; 456d20f7043SChris Mason disk_bytenr += bvec->bv_len; 457d20f7043SChris Mason offset += bvec->bv_len; 458e015640fSChris Mason bvec++; 459e015640fSChris Mason } 460ed98b56aSChris Mason this_sum_bytes = 0; 4613edf7d33SChris Mason btrfs_add_ordered_sum(inode, ordered, sums); 4623edf7d33SChris Mason btrfs_put_ordered_extent(ordered); 463e015640fSChris Mason return 0; 464e015640fSChris Mason } 465e015640fSChris Mason 466459931ecSChris Mason /* 467459931ecSChris Mason * helper function for csum removal, this expects the 468459931ecSChris Mason * key to describe the csum pointed to by the path, and it expects 469459931ecSChris Mason * the csum to overlap the range [bytenr, len] 470459931ecSChris Mason * 471459931ecSChris Mason * The csum should not be entirely contained in the range and the 472459931ecSChris Mason * range should not be entirely contained in the csum. 473459931ecSChris Mason * 474459931ecSChris Mason * This calls btrfs_truncate_item with the correct args based on the 475459931ecSChris Mason * overlap, and fixes up the key as required. 476459931ecSChris Mason */ 477459931ecSChris Mason static noinline int truncate_one_csum(struct btrfs_trans_handle *trans, 478459931ecSChris Mason struct btrfs_root *root, 479459931ecSChris Mason struct btrfs_path *path, 480459931ecSChris Mason struct btrfs_key *key, 481459931ecSChris Mason u64 bytenr, u64 len) 482459931ecSChris Mason { 483459931ecSChris Mason struct extent_buffer *leaf; 484459931ecSChris Mason u16 csum_size = 485459931ecSChris Mason btrfs_super_csum_size(&root->fs_info->super_copy); 486459931ecSChris Mason u64 csum_end; 487459931ecSChris Mason u64 end_byte = bytenr + len; 488459931ecSChris Mason u32 blocksize_bits = root->fs_info->sb->s_blocksize_bits; 489459931ecSChris Mason int ret; 490459931ecSChris Mason 491459931ecSChris Mason leaf = path->nodes[0]; 492459931ecSChris Mason csum_end = btrfs_item_size_nr(leaf, path->slots[0]) / csum_size; 493459931ecSChris Mason csum_end <<= root->fs_info->sb->s_blocksize_bits; 494459931ecSChris Mason csum_end += key->offset; 495459931ecSChris Mason 496459931ecSChris Mason if (key->offset < bytenr && csum_end <= end_byte) { 497459931ecSChris Mason /* 498459931ecSChris Mason * [ bytenr - len ] 499459931ecSChris Mason * [ ] 500459931ecSChris Mason * [csum ] 501459931ecSChris Mason * A simple truncate off the end of the item 502459931ecSChris Mason */ 503459931ecSChris Mason u32 new_size = (bytenr - key->offset) >> blocksize_bits; 504459931ecSChris Mason new_size *= csum_size; 505459931ecSChris Mason ret = btrfs_truncate_item(trans, root, path, new_size, 1); 506459931ecSChris Mason } else if (key->offset >= bytenr && csum_end > end_byte && 507459931ecSChris Mason end_byte > key->offset) { 508459931ecSChris Mason /* 509459931ecSChris Mason * [ bytenr - len ] 510459931ecSChris Mason * [ ] 511459931ecSChris Mason * [csum ] 512459931ecSChris Mason * we need to truncate from the beginning of the csum 513459931ecSChris Mason */ 514459931ecSChris Mason u32 new_size = (csum_end - end_byte) >> blocksize_bits; 515459931ecSChris Mason new_size *= csum_size; 516459931ecSChris Mason 517459931ecSChris Mason ret = btrfs_truncate_item(trans, root, path, new_size, 0); 518459931ecSChris Mason 519459931ecSChris Mason key->offset = end_byte; 520459931ecSChris Mason ret = btrfs_set_item_key_safe(trans, root, path, key); 521459931ecSChris Mason BUG_ON(ret); 522459931ecSChris Mason } else { 523459931ecSChris Mason BUG(); 524459931ecSChris Mason } 525459931ecSChris Mason return 0; 526459931ecSChris Mason } 527459931ecSChris Mason 528459931ecSChris Mason /* 529459931ecSChris Mason * deletes the csum items from the csum tree for a given 530459931ecSChris Mason * range of bytes. 531459931ecSChris Mason */ 532459931ecSChris Mason int btrfs_del_csums(struct btrfs_trans_handle *trans, 533459931ecSChris Mason struct btrfs_root *root, u64 bytenr, u64 len) 534459931ecSChris Mason { 535459931ecSChris Mason struct btrfs_path *path; 536459931ecSChris Mason struct btrfs_key key; 537459931ecSChris Mason u64 end_byte = bytenr + len; 538459931ecSChris Mason u64 csum_end; 539459931ecSChris Mason struct extent_buffer *leaf; 540459931ecSChris Mason int ret; 541459931ecSChris Mason u16 csum_size = 542459931ecSChris Mason btrfs_super_csum_size(&root->fs_info->super_copy); 543459931ecSChris Mason int blocksize_bits = root->fs_info->sb->s_blocksize_bits; 544459931ecSChris Mason 545459931ecSChris Mason root = root->fs_info->csum_root; 546459931ecSChris Mason 547459931ecSChris Mason path = btrfs_alloc_path(); 5482a29edc6Sliubo if (!path) 5492a29edc6Sliubo return -ENOMEM; 550459931ecSChris Mason 551459931ecSChris Mason while (1) { 552459931ecSChris Mason key.objectid = BTRFS_EXTENT_CSUM_OBJECTID; 553459931ecSChris Mason key.offset = end_byte - 1; 554459931ecSChris Mason key.type = BTRFS_EXTENT_CSUM_KEY; 555459931ecSChris Mason 556b9473439SChris Mason path->leave_spinning = 1; 557459931ecSChris Mason ret = btrfs_search_slot(trans, root, &key, path, -1, 1); 558459931ecSChris Mason if (ret > 0) { 559459931ecSChris Mason if (path->slots[0] == 0) 56065a246c5STsutomu Itoh break; 561459931ecSChris Mason path->slots[0]--; 562ad0397a7SJosef Bacik } else if (ret < 0) { 56365a246c5STsutomu Itoh break; 564459931ecSChris Mason } 565ad0397a7SJosef Bacik 566459931ecSChris Mason leaf = path->nodes[0]; 567459931ecSChris Mason btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); 568459931ecSChris Mason 569459931ecSChris Mason if (key.objectid != BTRFS_EXTENT_CSUM_OBJECTID || 570459931ecSChris Mason key.type != BTRFS_EXTENT_CSUM_KEY) { 571459931ecSChris Mason break; 572459931ecSChris Mason } 573459931ecSChris Mason 574459931ecSChris Mason if (key.offset >= end_byte) 575459931ecSChris Mason break; 576459931ecSChris Mason 577459931ecSChris Mason csum_end = btrfs_item_size_nr(leaf, path->slots[0]) / csum_size; 578459931ecSChris Mason csum_end <<= blocksize_bits; 579459931ecSChris Mason csum_end += key.offset; 580459931ecSChris Mason 581459931ecSChris Mason /* this csum ends before we start, we're done */ 582459931ecSChris Mason if (csum_end <= bytenr) 583459931ecSChris Mason break; 584459931ecSChris Mason 585459931ecSChris Mason /* delete the entire item, it is inside our range */ 586459931ecSChris Mason if (key.offset >= bytenr && csum_end <= end_byte) { 587459931ecSChris Mason ret = btrfs_del_item(trans, root, path); 58865a246c5STsutomu Itoh if (ret) 58965a246c5STsutomu Itoh goto out; 590dcbdd4dcSChris Mason if (key.offset == bytenr) 591dcbdd4dcSChris Mason break; 592459931ecSChris Mason } else if (key.offset < bytenr && csum_end > end_byte) { 593459931ecSChris Mason unsigned long offset; 594459931ecSChris Mason unsigned long shift_len; 595459931ecSChris Mason unsigned long item_offset; 596459931ecSChris Mason /* 597459931ecSChris Mason * [ bytenr - len ] 598459931ecSChris Mason * [csum ] 599459931ecSChris Mason * 600459931ecSChris Mason * Our bytes are in the middle of the csum, 601459931ecSChris Mason * we need to split this item and insert a new one. 602459931ecSChris Mason * 603459931ecSChris Mason * But we can't drop the path because the 604459931ecSChris Mason * csum could change, get removed, extended etc. 605459931ecSChris Mason * 606459931ecSChris Mason * The trick here is the max size of a csum item leaves 607459931ecSChris Mason * enough room in the tree block for a single 608459931ecSChris Mason * item header. So, we split the item in place, 609459931ecSChris Mason * adding a new header pointing to the existing 610459931ecSChris Mason * bytes. Then we loop around again and we have 611459931ecSChris Mason * a nicely formed csum item that we can neatly 612459931ecSChris Mason * truncate. 613459931ecSChris Mason */ 614459931ecSChris Mason offset = (bytenr - key.offset) >> blocksize_bits; 615459931ecSChris Mason offset *= csum_size; 616459931ecSChris Mason 617459931ecSChris Mason shift_len = (len >> blocksize_bits) * csum_size; 618459931ecSChris Mason 619459931ecSChris Mason item_offset = btrfs_item_ptr_offset(leaf, 620459931ecSChris Mason path->slots[0]); 621459931ecSChris Mason 622459931ecSChris Mason memset_extent_buffer(leaf, 0, item_offset + offset, 623459931ecSChris Mason shift_len); 624459931ecSChris Mason key.offset = bytenr; 625459931ecSChris Mason 626459931ecSChris Mason /* 627459931ecSChris Mason * btrfs_split_item returns -EAGAIN when the 628459931ecSChris Mason * item changed size or key 629459931ecSChris Mason */ 630459931ecSChris Mason ret = btrfs_split_item(trans, root, path, &key, offset); 631459931ecSChris Mason BUG_ON(ret && ret != -EAGAIN); 632459931ecSChris Mason 633459931ecSChris Mason key.offset = end_byte - 1; 634459931ecSChris Mason } else { 635459931ecSChris Mason ret = truncate_one_csum(trans, root, path, 636459931ecSChris Mason &key, bytenr, len); 637459931ecSChris Mason BUG_ON(ret); 638dcbdd4dcSChris Mason if (key.offset < bytenr) 639dcbdd4dcSChris Mason break; 640459931ecSChris Mason } 641b3b4aa74SDavid Sterba btrfs_release_path(path); 642459931ecSChris Mason } 64365a246c5STsutomu Itoh ret = 0; 644459931ecSChris Mason out: 645459931ecSChris Mason btrfs_free_path(path); 64665a246c5STsutomu Itoh return ret; 647459931ecSChris Mason } 648459931ecSChris Mason 649065631f6SChris Mason int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans, 650d20f7043SChris Mason struct btrfs_root *root, 651e6dcd2dcSChris Mason struct btrfs_ordered_sum *sums) 652f254e52cSChris Mason { 653d20f7043SChris Mason u64 bytenr; 654f254e52cSChris Mason int ret; 655f254e52cSChris Mason struct btrfs_key file_key; 6566567e837SChris Mason struct btrfs_key found_key; 657065631f6SChris Mason u64 next_offset; 658e6dcd2dcSChris Mason u64 total_bytes = 0; 659065631f6SChris Mason int found_next; 6605caf2a00SChris Mason struct btrfs_path *path; 661f254e52cSChris Mason struct btrfs_csum_item *item; 662065631f6SChris Mason struct btrfs_csum_item *item_end; 663ff79f819SChris Mason struct extent_buffer *leaf = NULL; 6646567e837SChris Mason u64 csum_offset; 665e6dcd2dcSChris Mason struct btrfs_sector_sum *sector_sum; 666f578d4bdSChris Mason u32 nritems; 667f578d4bdSChris Mason u32 ins_size; 6686e92f5e6SChris Mason char *eb_map; 6696e92f5e6SChris Mason char *eb_token; 6706e92f5e6SChris Mason unsigned long map_len; 6716e92f5e6SChris Mason unsigned long map_start; 672607d432dSJosef Bacik u16 csum_size = 673607d432dSJosef Bacik btrfs_super_csum_size(&root->fs_info->super_copy); 6746e92f5e6SChris Mason 6755caf2a00SChris Mason path = btrfs_alloc_path(); 676d8926bb3SMark Fasheh if (!path) 677d8926bb3SMark Fasheh return -ENOMEM; 678d8926bb3SMark Fasheh 679ed98b56aSChris Mason sector_sum = sums->sums; 680065631f6SChris Mason again: 681065631f6SChris Mason next_offset = (u64)-1; 682065631f6SChris Mason found_next = 0; 683d20f7043SChris Mason file_key.objectid = BTRFS_EXTENT_CSUM_OBJECTID; 684d20f7043SChris Mason file_key.offset = sector_sum->bytenr; 685d20f7043SChris Mason bytenr = sector_sum->bytenr; 686d20f7043SChris Mason btrfs_set_key_type(&file_key, BTRFS_EXTENT_CSUM_KEY); 687a429e513SChris Mason 688d20f7043SChris Mason item = btrfs_lookup_csum(trans, root, path, sector_sum->bytenr, 1); 689ff79f819SChris Mason if (!IS_ERR(item)) { 690ff79f819SChris Mason leaf = path->nodes[0]; 691639cb586SChris Mason ret = 0; 692a429e513SChris Mason goto found; 693ff79f819SChris Mason } 694a429e513SChris Mason ret = PTR_ERR(item); 6954a500fd1SYan, Zheng if (ret != -EFBIG && ret != -ENOENT) 6964a500fd1SYan, Zheng goto fail_unlock; 6974a500fd1SYan, Zheng 698a429e513SChris Mason if (ret == -EFBIG) { 699a429e513SChris Mason u32 item_size; 700a429e513SChris Mason /* we found one, but it isn't big enough yet */ 7015f39d397SChris Mason leaf = path->nodes[0]; 7025f39d397SChris Mason item_size = btrfs_item_size_nr(leaf, path->slots[0]); 703607d432dSJosef Bacik if ((item_size / csum_size) >= 704607d432dSJosef Bacik MAX_CSUM_ITEMS(root, csum_size)) { 705a429e513SChris Mason /* already at max size, make a new one */ 706a429e513SChris Mason goto insert; 707a429e513SChris Mason } 708a429e513SChris Mason } else { 709f578d4bdSChris Mason int slot = path->slots[0] + 1; 710a429e513SChris Mason /* we didn't find a csum item, insert one */ 711f578d4bdSChris Mason nritems = btrfs_header_nritems(path->nodes[0]); 712f578d4bdSChris Mason if (path->slots[0] >= nritems - 1) { 713f578d4bdSChris Mason ret = btrfs_next_leaf(root, path); 714b56baf5bSYan if (ret == 1) 715f578d4bdSChris Mason found_next = 1; 716b56baf5bSYan if (ret != 0) 717f578d4bdSChris Mason goto insert; 718b56baf5bSYan slot = 0; 719f578d4bdSChris Mason } 720f578d4bdSChris Mason btrfs_item_key_to_cpu(path->nodes[0], &found_key, slot); 721d20f7043SChris Mason if (found_key.objectid != BTRFS_EXTENT_CSUM_OBJECTID || 722d20f7043SChris Mason found_key.type != BTRFS_EXTENT_CSUM_KEY) { 723f578d4bdSChris Mason found_next = 1; 724f578d4bdSChris Mason goto insert; 725f578d4bdSChris Mason } 726f578d4bdSChris Mason next_offset = found_key.offset; 727f578d4bdSChris Mason found_next = 1; 728a429e513SChris Mason goto insert; 729a429e513SChris Mason } 730a429e513SChris Mason 731a429e513SChris Mason /* 732a429e513SChris Mason * at this point, we know the tree has an item, but it isn't big 733a429e513SChris Mason * enough yet to put our csum in. Grow it 734a429e513SChris Mason */ 735b3b4aa74SDavid Sterba btrfs_release_path(path); 7366567e837SChris Mason ret = btrfs_search_slot(trans, root, &file_key, path, 737607d432dSJosef Bacik csum_size, 1); 7386567e837SChris Mason if (ret < 0) 73953863232SChris Mason goto fail_unlock; 740459931ecSChris Mason 741459931ecSChris Mason if (ret > 0) { 742459931ecSChris Mason if (path->slots[0] == 0) 7436567e837SChris Mason goto insert; 7446567e837SChris Mason path->slots[0]--; 745459931ecSChris Mason } 746459931ecSChris Mason 7475f39d397SChris Mason leaf = path->nodes[0]; 7485f39d397SChris Mason btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); 749d20f7043SChris Mason csum_offset = (bytenr - found_key.offset) >> 7506567e837SChris Mason root->fs_info->sb->s_blocksize_bits; 751459931ecSChris Mason 752d20f7043SChris Mason if (btrfs_key_type(&found_key) != BTRFS_EXTENT_CSUM_KEY || 753d20f7043SChris Mason found_key.objectid != BTRFS_EXTENT_CSUM_OBJECTID || 754607d432dSJosef Bacik csum_offset >= MAX_CSUM_ITEMS(root, csum_size)) { 7556567e837SChris Mason goto insert; 7566567e837SChris Mason } 757459931ecSChris Mason 7585f39d397SChris Mason if (csum_offset >= btrfs_item_size_nr(leaf, path->slots[0]) / 759607d432dSJosef Bacik csum_size) { 760607d432dSJosef Bacik u32 diff = (csum_offset + 1) * csum_size; 761459931ecSChris Mason 762459931ecSChris Mason /* 763459931ecSChris Mason * is the item big enough already? we dropped our lock 764459931ecSChris Mason * before and need to recheck 765459931ecSChris Mason */ 766459931ecSChris Mason if (diff < btrfs_item_size_nr(leaf, path->slots[0])) 767459931ecSChris Mason goto csum; 768459931ecSChris Mason 7695f39d397SChris Mason diff = diff - btrfs_item_size_nr(leaf, path->slots[0]); 770d397712bSChris Mason if (diff != csum_size) 7713a686375SChris Mason goto insert; 772459931ecSChris Mason 773a429e513SChris Mason ret = btrfs_extend_item(trans, root, path, diff); 7746567e837SChris Mason goto csum; 7756567e837SChris Mason } 7766567e837SChris Mason 7776567e837SChris Mason insert: 778b3b4aa74SDavid Sterba btrfs_release_path(path); 7796567e837SChris Mason csum_offset = 0; 780f578d4bdSChris Mason if (found_next) { 781d20f7043SChris Mason u64 tmp = total_bytes + root->sectorsize; 782d20f7043SChris Mason u64 next_sector = sector_sum->bytenr; 783d20f7043SChris Mason struct btrfs_sector_sum *next = sector_sum + 1; 784d20f7043SChris Mason 785d20f7043SChris Mason while (tmp < sums->len) { 786d20f7043SChris Mason if (next_sector + root->sectorsize != next->bytenr) 787d20f7043SChris Mason break; 788d20f7043SChris Mason tmp += root->sectorsize; 789d20f7043SChris Mason next_sector = next->bytenr; 790d20f7043SChris Mason next++; 791d20f7043SChris Mason } 792d20f7043SChris Mason tmp = min(tmp, next_offset - file_key.offset); 793f578d4bdSChris Mason tmp >>= root->fs_info->sb->s_blocksize_bits; 794f578d4bdSChris Mason tmp = max((u64)1, tmp); 795607d432dSJosef Bacik tmp = min(tmp, (u64)MAX_CSUM_ITEMS(root, csum_size)); 796607d432dSJosef Bacik ins_size = csum_size * tmp; 797f578d4bdSChris Mason } else { 798607d432dSJosef Bacik ins_size = csum_size; 799f578d4bdSChris Mason } 800b9473439SChris Mason path->leave_spinning = 1; 8015caf2a00SChris Mason ret = btrfs_insert_empty_item(trans, root, path, &file_key, 802f578d4bdSChris Mason ins_size); 803b9473439SChris Mason path->leave_spinning = 0; 80454aa1f4dSChris Mason if (ret < 0) 80553863232SChris Mason goto fail_unlock; 806a429e513SChris Mason if (ret != 0) { 807a429e513SChris Mason WARN_ON(1); 80853863232SChris Mason goto fail_unlock; 809a429e513SChris Mason } 8106567e837SChris Mason csum: 8115f39d397SChris Mason leaf = path->nodes[0]; 8125f39d397SChris Mason item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item); 813f254e52cSChris Mason ret = 0; 814509659cdSChris Mason item = (struct btrfs_csum_item *)((unsigned char *)item + 815607d432dSJosef Bacik csum_offset * csum_size); 816b18c6685SChris Mason found: 817065631f6SChris Mason item_end = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item); 818065631f6SChris Mason item_end = (struct btrfs_csum_item *)((unsigned char *)item_end + 819065631f6SChris Mason btrfs_item_size_nr(leaf, path->slots[0])); 8206e92f5e6SChris Mason eb_token = NULL; 821e6dcd2dcSChris Mason next_sector: 822aadfeb6eSChris Mason 8236e92f5e6SChris Mason if (!eb_token || 824607d432dSJosef Bacik (unsigned long)item + csum_size >= map_start + map_len) { 8256e92f5e6SChris Mason int err; 8266e92f5e6SChris Mason 8276e92f5e6SChris Mason if (eb_token) 828eb20978fSChris Mason unmap_extent_buffer(leaf, eb_token, KM_USER1); 8296e92f5e6SChris Mason eb_token = NULL; 8306e92f5e6SChris Mason err = map_private_extent_buffer(leaf, (unsigned long)item, 831607d432dSJosef Bacik csum_size, 8326e92f5e6SChris Mason &eb_token, &eb_map, 833eb20978fSChris Mason &map_start, &map_len, KM_USER1); 8346e92f5e6SChris Mason if (err) 8356e92f5e6SChris Mason eb_token = NULL; 8366e92f5e6SChris Mason } 8376e92f5e6SChris Mason if (eb_token) { 8386e92f5e6SChris Mason memcpy(eb_token + ((unsigned long)item & (PAGE_CACHE_SIZE - 1)), 839607d432dSJosef Bacik §or_sum->sum, csum_size); 8406e92f5e6SChris Mason } else { 841e6dcd2dcSChris Mason write_extent_buffer(leaf, §or_sum->sum, 842607d432dSJosef Bacik (unsigned long)item, csum_size); 8436e92f5e6SChris Mason } 8447f3c74fbSChris Mason 845e6dcd2dcSChris Mason total_bytes += root->sectorsize; 846e6dcd2dcSChris Mason sector_sum++; 847e6dcd2dcSChris Mason if (total_bytes < sums->len) { 8486e92f5e6SChris Mason item = (struct btrfs_csum_item *)((char *)item + 849607d432dSJosef Bacik csum_size); 850d20f7043SChris Mason if (item < item_end && bytenr + PAGE_CACHE_SIZE == 851d20f7043SChris Mason sector_sum->bytenr) { 852d20f7043SChris Mason bytenr = sector_sum->bytenr; 853e6dcd2dcSChris Mason goto next_sector; 854065631f6SChris Mason } 8552e1a992eSChris Mason } 8566e92f5e6SChris Mason if (eb_token) { 857eb20978fSChris Mason unmap_extent_buffer(leaf, eb_token, KM_USER1); 8586e92f5e6SChris Mason eb_token = NULL; 8596e92f5e6SChris Mason } 8605caf2a00SChris Mason btrfs_mark_buffer_dirty(path->nodes[0]); 861e6dcd2dcSChris Mason if (total_bytes < sums->len) { 862b3b4aa74SDavid Sterba btrfs_release_path(path); 863b9473439SChris Mason cond_resched(); 864065631f6SChris Mason goto again; 865065631f6SChris Mason } 86653863232SChris Mason out: 8675caf2a00SChris Mason btrfs_free_path(path); 868f254e52cSChris Mason return ret; 86953863232SChris Mason 87053863232SChris Mason fail_unlock: 87153863232SChris Mason goto out; 872f254e52cSChris Mason } 873