]>
Commit | Line | Data |
---|---|---|
6cbd5570 CM |
1 | /* |
2 | * Copyright (C) 2007 Oracle. All rights reserved. | |
3 | * | |
4 | * This program is free software; you can redistribute it and/or | |
5 | * modify it under the terms of the GNU General Public | |
6 | * License v2 as published by the Free Software Foundation. | |
7 | * | |
8 | * This program is distributed in the hope that it will be useful, | |
9 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
10 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
11 | * General Public License for more details. | |
12 | * | |
13 | * You should have received a copy of the GNU General Public | |
14 | * License along with this program; if not, write to the | |
15 | * Free Software Foundation, Inc., 59 Temple Place - Suite 330, | |
16 | * Boston, MA 021110-1307, USA. | |
17 | */ | |
18 | ||
065631f6 | 19 | #include <linux/bio.h> |
5a0e3ad6 | 20 | #include <linux/slab.h> |
065631f6 CM |
21 | #include <linux/pagemap.h> |
22 | #include <linux/highmem.h> | |
1e1d2701 | 23 | #include "ctree.h" |
dee26a9f | 24 | #include "disk-io.h" |
9f5fae2f | 25 | #include "transaction.h" |
1de037a4 | 26 | #include "print-tree.h" |
1e1d2701 | 27 | |
995e01b7 | 28 | #define __MAX_CSUM_ITEMS(r, size) ((unsigned long)(((BTRFS_LEAF_DATA_SIZE(r) - \ |
607d432d JB |
29 | sizeof(struct btrfs_item) * 2) / \ |
30 | size) - 1)) | |
07d400a6 | 31 | |
221b8318 ZB |
32 | #define MAX_CSUM_ITEMS(r, size) (min_t(u32, __MAX_CSUM_ITEMS(r, size), \ |
33 | PAGE_CACHE_SIZE)) | |
7ca4be45 | 34 | |
07d400a6 YZ |
35 | #define MAX_ORDERED_SUM_BYTES(r) ((PAGE_SIZE - \ |
36 | sizeof(struct btrfs_ordered_sum)) / \ | |
37 | sizeof(struct btrfs_sector_sum) * \ | |
38 | (r)->sectorsize - (r)->sectorsize) | |
39 | ||
b18c6685 | 40 | int btrfs_insert_file_extent(struct btrfs_trans_handle *trans, |
f2eb0a24 SW |
41 | struct btrfs_root *root, |
42 | u64 objectid, u64 pos, | |
43 | u64 disk_offset, u64 disk_num_bytes, | |
c8b97818 CM |
44 | u64 num_bytes, u64 offset, u64 ram_bytes, |
45 | u8 compression, u8 encryption, u16 other_encoding) | |
9f5fae2f | 46 | { |
dee26a9f CM |
47 | int ret = 0; |
48 | struct btrfs_file_extent_item *item; | |
49 | struct btrfs_key file_key; | |
5caf2a00 | 50 | struct btrfs_path *path; |
5f39d397 | 51 | struct extent_buffer *leaf; |
dee26a9f | 52 | |
5caf2a00 | 53 | path = btrfs_alloc_path(); |
db5b493a TI |
54 | if (!path) |
55 | return -ENOMEM; | |
dee26a9f | 56 | file_key.objectid = objectid; |
b18c6685 | 57 | file_key.offset = pos; |
dee26a9f CM |
58 | btrfs_set_key_type(&file_key, BTRFS_EXTENT_DATA_KEY); |
59 | ||
b9473439 | 60 | path->leave_spinning = 1; |
5caf2a00 | 61 | ret = btrfs_insert_empty_item(trans, root, path, &file_key, |
dee26a9f | 62 | sizeof(*item)); |
54aa1f4d CM |
63 | if (ret < 0) |
64 | goto out; | |
79787eaa | 65 | BUG_ON(ret); /* Can't happen */ |
5f39d397 CM |
66 | leaf = path->nodes[0]; |
67 | item = btrfs_item_ptr(leaf, path->slots[0], | |
dee26a9f | 68 | struct btrfs_file_extent_item); |
f2eb0a24 | 69 | btrfs_set_file_extent_disk_bytenr(leaf, item, disk_offset); |
db94535d | 70 | btrfs_set_file_extent_disk_num_bytes(leaf, item, disk_num_bytes); |
f2eb0a24 | 71 | btrfs_set_file_extent_offset(leaf, item, offset); |
db94535d | 72 | btrfs_set_file_extent_num_bytes(leaf, item, num_bytes); |
c8b97818 | 73 | btrfs_set_file_extent_ram_bytes(leaf, item, ram_bytes); |
5f39d397 CM |
74 | btrfs_set_file_extent_generation(leaf, item, trans->transid); |
75 | btrfs_set_file_extent_type(leaf, item, BTRFS_FILE_EXTENT_REG); | |
c8b97818 CM |
76 | btrfs_set_file_extent_compression(leaf, item, compression); |
77 | btrfs_set_file_extent_encryption(leaf, item, encryption); | |
78 | btrfs_set_file_extent_other_encoding(leaf, item, other_encoding); | |
79 | ||
5f39d397 | 80 | btrfs_mark_buffer_dirty(leaf); |
54aa1f4d | 81 | out: |
5caf2a00 | 82 | btrfs_free_path(path); |
54aa1f4d | 83 | return ret; |
9f5fae2f | 84 | } |
dee26a9f | 85 | |
b18c6685 CM |
86 | struct btrfs_csum_item *btrfs_lookup_csum(struct btrfs_trans_handle *trans, |
87 | struct btrfs_root *root, | |
88 | struct btrfs_path *path, | |
d20f7043 | 89 | u64 bytenr, int cow) |
6567e837 CM |
90 | { |
91 | int ret; | |
92 | struct btrfs_key file_key; | |
93 | struct btrfs_key found_key; | |
94 | struct btrfs_csum_item *item; | |
5f39d397 | 95 | struct extent_buffer *leaf; |
6567e837 | 96 | u64 csum_offset = 0; |
6c41761f | 97 | u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy); |
a429e513 | 98 | int csums_in_item; |
6567e837 | 99 | |
d20f7043 CM |
100 | file_key.objectid = BTRFS_EXTENT_CSUM_OBJECTID; |
101 | file_key.offset = bytenr; | |
102 | btrfs_set_key_type(&file_key, BTRFS_EXTENT_CSUM_KEY); | |
b18c6685 | 103 | ret = btrfs_search_slot(trans, root, &file_key, path, 0, cow); |
6567e837 CM |
104 | if (ret < 0) |
105 | goto fail; | |
5f39d397 | 106 | leaf = path->nodes[0]; |
6567e837 CM |
107 | if (ret > 0) { |
108 | ret = 1; | |
70b2befd | 109 | if (path->slots[0] == 0) |
6567e837 CM |
110 | goto fail; |
111 | path->slots[0]--; | |
5f39d397 | 112 | btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); |
d20f7043 | 113 | if (btrfs_key_type(&found_key) != BTRFS_EXTENT_CSUM_KEY) |
6567e837 | 114 | goto fail; |
d20f7043 CM |
115 | |
116 | csum_offset = (bytenr - found_key.offset) >> | |
6567e837 | 117 | root->fs_info->sb->s_blocksize_bits; |
5f39d397 | 118 | csums_in_item = btrfs_item_size_nr(leaf, path->slots[0]); |
607d432d | 119 | csums_in_item /= csum_size; |
a429e513 | 120 | |
82d130ff | 121 | if (csum_offset == csums_in_item) { |
a429e513 | 122 | ret = -EFBIG; |
6567e837 | 123 | goto fail; |
82d130ff MX |
124 | } else if (csum_offset > csums_in_item) { |
125 | goto fail; | |
6567e837 CM |
126 | } |
127 | } | |
128 | item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item); | |
509659cd | 129 | item = (struct btrfs_csum_item *)((unsigned char *)item + |
607d432d | 130 | csum_offset * csum_size); |
6567e837 CM |
131 | return item; |
132 | fail: | |
133 | if (ret > 0) | |
b18c6685 | 134 | ret = -ENOENT; |
6567e837 CM |
135 | return ERR_PTR(ret); |
136 | } | |
137 | ||
dee26a9f CM |
138 | int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans, |
139 | struct btrfs_root *root, | |
140 | struct btrfs_path *path, u64 objectid, | |
9773a788 | 141 | u64 offset, int mod) |
dee26a9f CM |
142 | { |
143 | int ret; | |
144 | struct btrfs_key file_key; | |
145 | int ins_len = mod < 0 ? -1 : 0; | |
146 | int cow = mod != 0; | |
147 | ||
148 | file_key.objectid = objectid; | |
70b2befd | 149 | file_key.offset = offset; |
dee26a9f CM |
150 | btrfs_set_key_type(&file_key, BTRFS_EXTENT_DATA_KEY); |
151 | ret = btrfs_search_slot(trans, root, &file_key, path, ins_len, cow); | |
152 | return ret; | |
153 | } | |
f254e52c | 154 | |
315a9850 MX |
155 | u64 btrfs_file_extent_length(struct btrfs_path *path) |
156 | { | |
157 | int extent_type; | |
158 | struct btrfs_file_extent_item *fi; | |
159 | u64 len; | |
160 | ||
161 | fi = btrfs_item_ptr(path->nodes[0], path->slots[0], | |
162 | struct btrfs_file_extent_item); | |
163 | extent_type = btrfs_file_extent_type(path->nodes[0], fi); | |
164 | ||
165 | if (extent_type == BTRFS_FILE_EXTENT_REG || | |
166 | extent_type == BTRFS_FILE_EXTENT_PREALLOC) | |
167 | len = btrfs_file_extent_num_bytes(path->nodes[0], fi); | |
168 | else if (extent_type == BTRFS_FILE_EXTENT_INLINE) | |
169 | len = btrfs_file_extent_inline_len(path->nodes[0], fi); | |
170 | else | |
171 | BUG(); | |
172 | ||
173 | return len; | |
174 | } | |
17d217fe | 175 | |
4b46fce2 JB |
176 | static int __btrfs_lookup_bio_sums(struct btrfs_root *root, |
177 | struct inode *inode, struct bio *bio, | |
178 | u64 logical_offset, u32 *dst, int dio) | |
61b49440 | 179 | { |
e4100d98 MX |
180 | u32 sum[16]; |
181 | int len; | |
61b49440 CM |
182 | struct bio_vec *bvec = bio->bi_io_vec; |
183 | int bio_index = 0; | |
4b46fce2 | 184 | u64 offset = 0; |
61b49440 CM |
185 | u64 item_start_offset = 0; |
186 | u64 item_last_offset = 0; | |
d20f7043 | 187 | u64 disk_bytenr; |
61b49440 | 188 | u32 diff; |
6c41761f | 189 | u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy); |
e4100d98 | 190 | int count; |
61b49440 CM |
191 | struct btrfs_path *path; |
192 | struct btrfs_csum_item *item = NULL; | |
193 | struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree; | |
194 | ||
195 | path = btrfs_alloc_path(); | |
c2db1073 TI |
196 | if (!path) |
197 | return -ENOMEM; | |
4d1b5fb4 CM |
198 | if (bio->bi_size > PAGE_CACHE_SIZE * 8) |
199 | path->reada = 2; | |
61b49440 CM |
200 | |
201 | WARN_ON(bio->bi_vcnt <= 0); | |
202 | ||
2cf8572d CM |
203 | /* |
204 | * the free space stuff is only read when it hasn't been | |
205 | * updated in the current transaction. So, we can safely | |
206 | * read from the commit root and sidestep a nasty deadlock | |
207 | * between reading the free space cache and updating the csum tree. | |
208 | */ | |
83eea1f1 | 209 | if (btrfs_is_free_space_inode(inode)) { |
2cf8572d | 210 | path->search_commit_root = 1; |
ddf23b3f JB |
211 | path->skip_locking = 1; |
212 | } | |
2cf8572d | 213 | |
d20f7043 | 214 | disk_bytenr = (u64)bio->bi_sector << 9; |
4b46fce2 JB |
215 | if (dio) |
216 | offset = logical_offset; | |
d397712b | 217 | while (bio_index < bio->bi_vcnt) { |
e4100d98 | 218 | len = min_t(int, ARRAY_SIZE(sum), bio->bi_vcnt - bio_index); |
4b46fce2 JB |
219 | if (!dio) |
220 | offset = page_offset(bvec->bv_page) + bvec->bv_offset; | |
e4100d98 MX |
221 | count = btrfs_find_ordered_sum(inode, offset, disk_bytenr, sum, |
222 | len); | |
223 | if (count) | |
61b49440 CM |
224 | goto found; |
225 | ||
d20f7043 CM |
226 | if (!item || disk_bytenr < item_start_offset || |
227 | disk_bytenr >= item_last_offset) { | |
61b49440 CM |
228 | struct btrfs_key found_key; |
229 | u32 item_size; | |
230 | ||
231 | if (item) | |
b3b4aa74 | 232 | btrfs_release_path(path); |
d20f7043 CM |
233 | item = btrfs_lookup_csum(NULL, root->fs_info->csum_root, |
234 | path, disk_bytenr, 0); | |
61b49440 | 235 | if (IS_ERR(item)) { |
e4100d98 MX |
236 | count = 1; |
237 | sum[0] = 0; | |
17d217fe YZ |
238 | if (BTRFS_I(inode)->root->root_key.objectid == |
239 | BTRFS_DATA_RELOC_TREE_OBJECTID) { | |
240 | set_extent_bits(io_tree, offset, | |
241 | offset + bvec->bv_len - 1, | |
242 | EXTENT_NODATASUM, GFP_NOFS); | |
243 | } else { | |
d397712b | 244 | printk(KERN_INFO "btrfs no csum found " |
33345d01 LZ |
245 | "for inode %llu start %llu\n", |
246 | (unsigned long long) | |
247 | btrfs_ino(inode), | |
17d217fe YZ |
248 | (unsigned long long)offset); |
249 | } | |
6dab8157 | 250 | item = NULL; |
b3b4aa74 | 251 | btrfs_release_path(path); |
61b49440 CM |
252 | goto found; |
253 | } | |
254 | btrfs_item_key_to_cpu(path->nodes[0], &found_key, | |
255 | path->slots[0]); | |
256 | ||
257 | item_start_offset = found_key.offset; | |
258 | item_size = btrfs_item_size_nr(path->nodes[0], | |
259 | path->slots[0]); | |
260 | item_last_offset = item_start_offset + | |
607d432d | 261 | (item_size / csum_size) * |
61b49440 CM |
262 | root->sectorsize; |
263 | item = btrfs_item_ptr(path->nodes[0], path->slots[0], | |
264 | struct btrfs_csum_item); | |
265 | } | |
266 | /* | |
267 | * this byte range must be able to fit inside | |
268 | * a single leaf so it will also fit inside a u32 | |
269 | */ | |
d20f7043 | 270 | diff = disk_bytenr - item_start_offset; |
61b49440 | 271 | diff = diff / root->sectorsize; |
607d432d | 272 | diff = diff * csum_size; |
e4100d98 MX |
273 | count = min_t(int, len, (item_last_offset - disk_bytenr) >> |
274 | inode->i_sb->s_blocksize_bits); | |
275 | read_extent_buffer(path->nodes[0], sum, | |
3de9d6b6 | 276 | ((unsigned long)item) + diff, |
e4100d98 | 277 | csum_size * count); |
61b49440 | 278 | found: |
e4100d98 MX |
279 | if (dst) { |
280 | memcpy(dst, sum, count * csum_size); | |
281 | dst += count; | |
282 | } else { | |
283 | if (dio) | |
284 | extent_cache_csums_dio(io_tree, offset, sum, | |
285 | count); | |
286 | else | |
287 | extent_cache_csums(io_tree, bio, bio_index, sum, | |
288 | count); | |
289 | } | |
290 | while (count--) { | |
291 | disk_bytenr += bvec->bv_len; | |
292 | offset += bvec->bv_len; | |
293 | bio_index++; | |
294 | bvec++; | |
295 | } | |
61b49440 CM |
296 | } |
297 | btrfs_free_path(path); | |
298 | return 0; | |
299 | } | |
300 | ||
4b46fce2 JB |
301 | int btrfs_lookup_bio_sums(struct btrfs_root *root, struct inode *inode, |
302 | struct bio *bio, u32 *dst) | |
303 | { | |
304 | return __btrfs_lookup_bio_sums(root, inode, bio, 0, dst, 0); | |
305 | } | |
306 | ||
307 | int btrfs_lookup_bio_sums_dio(struct btrfs_root *root, struct inode *inode, | |
c329861d | 308 | struct bio *bio, u64 offset) |
4b46fce2 | 309 | { |
c329861d | 310 | return __btrfs_lookup_bio_sums(root, inode, bio, offset, NULL, 1); |
4b46fce2 JB |
311 | } |
312 | ||
17d217fe | 313 | int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end, |
a2de733c | 314 | struct list_head *list, int search_commit) |
17d217fe YZ |
315 | { |
316 | struct btrfs_key key; | |
317 | struct btrfs_path *path; | |
318 | struct extent_buffer *leaf; | |
319 | struct btrfs_ordered_sum *sums; | |
320 | struct btrfs_sector_sum *sector_sum; | |
321 | struct btrfs_csum_item *item; | |
0678b618 | 322 | LIST_HEAD(tmplist); |
17d217fe YZ |
323 | unsigned long offset; |
324 | int ret; | |
325 | size_t size; | |
326 | u64 csum_end; | |
6c41761f | 327 | u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy); |
17d217fe YZ |
328 | |
329 | path = btrfs_alloc_path(); | |
d8926bb3 MF |
330 | if (!path) |
331 | return -ENOMEM; | |
17d217fe | 332 | |
a2de733c AJ |
333 | if (search_commit) { |
334 | path->skip_locking = 1; | |
335 | path->reada = 2; | |
336 | path->search_commit_root = 1; | |
337 | } | |
338 | ||
17d217fe YZ |
339 | key.objectid = BTRFS_EXTENT_CSUM_OBJECTID; |
340 | key.offset = start; | |
341 | key.type = BTRFS_EXTENT_CSUM_KEY; | |
342 | ||
07d400a6 | 343 | ret = btrfs_search_slot(NULL, root, &key, path, 0, 0); |
17d217fe YZ |
344 | if (ret < 0) |
345 | goto fail; | |
346 | if (ret > 0 && path->slots[0] > 0) { | |
347 | leaf = path->nodes[0]; | |
348 | btrfs_item_key_to_cpu(leaf, &key, path->slots[0] - 1); | |
349 | if (key.objectid == BTRFS_EXTENT_CSUM_OBJECTID && | |
350 | key.type == BTRFS_EXTENT_CSUM_KEY) { | |
351 | offset = (start - key.offset) >> | |
352 | root->fs_info->sb->s_blocksize_bits; | |
353 | if (offset * csum_size < | |
354 | btrfs_item_size_nr(leaf, path->slots[0] - 1)) | |
355 | path->slots[0]--; | |
356 | } | |
357 | } | |
358 | ||
359 | while (start <= end) { | |
360 | leaf = path->nodes[0]; | |
361 | if (path->slots[0] >= btrfs_header_nritems(leaf)) { | |
07d400a6 | 362 | ret = btrfs_next_leaf(root, path); |
17d217fe YZ |
363 | if (ret < 0) |
364 | goto fail; | |
365 | if (ret > 0) | |
366 | break; | |
367 | leaf = path->nodes[0]; | |
368 | } | |
369 | ||
370 | btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); | |
371 | if (key.objectid != BTRFS_EXTENT_CSUM_OBJECTID || | |
628c8282 ZYW |
372 | key.type != BTRFS_EXTENT_CSUM_KEY || |
373 | key.offset > end) | |
17d217fe YZ |
374 | break; |
375 | ||
376 | if (key.offset > start) | |
377 | start = key.offset; | |
378 | ||
379 | size = btrfs_item_size_nr(leaf, path->slots[0]); | |
380 | csum_end = key.offset + (size / csum_size) * root->sectorsize; | |
87b29b20 YZ |
381 | if (csum_end <= start) { |
382 | path->slots[0]++; | |
383 | continue; | |
384 | } | |
17d217fe | 385 | |
07d400a6 | 386 | csum_end = min(csum_end, end + 1); |
17d217fe YZ |
387 | item = btrfs_item_ptr(path->nodes[0], path->slots[0], |
388 | struct btrfs_csum_item); | |
07d400a6 YZ |
389 | while (start < csum_end) { |
390 | size = min_t(size_t, csum_end - start, | |
391 | MAX_ORDERED_SUM_BYTES(root)); | |
392 | sums = kzalloc(btrfs_ordered_sum_size(root, size), | |
393 | GFP_NOFS); | |
0678b618 MF |
394 | if (!sums) { |
395 | ret = -ENOMEM; | |
396 | goto fail; | |
397 | } | |
17d217fe | 398 | |
07d400a6 YZ |
399 | sector_sum = sums->sums; |
400 | sums->bytenr = start; | |
401 | sums->len = size; | |
402 | ||
403 | offset = (start - key.offset) >> | |
404 | root->fs_info->sb->s_blocksize_bits; | |
405 | offset *= csum_size; | |
406 | ||
407 | while (size > 0) { | |
408 | read_extent_buffer(path->nodes[0], | |
409 | §or_sum->sum, | |
410 | ((unsigned long)item) + | |
411 | offset, csum_size); | |
412 | sector_sum->bytenr = start; | |
413 | ||
414 | size -= root->sectorsize; | |
415 | start += root->sectorsize; | |
416 | offset += csum_size; | |
417 | sector_sum++; | |
418 | } | |
0678b618 | 419 | list_add_tail(&sums->list, &tmplist); |
07d400a6 | 420 | } |
17d217fe YZ |
421 | path->slots[0]++; |
422 | } | |
423 | ret = 0; | |
424 | fail: | |
0678b618 MF |
425 | while (ret < 0 && !list_empty(&tmplist)) { |
426 | sums = list_entry(&tmplist, struct btrfs_ordered_sum, list); | |
427 | list_del(&sums->list); | |
428 | kfree(sums); | |
429 | } | |
430 | list_splice_tail(&tmplist, list); | |
431 | ||
17d217fe YZ |
432 | btrfs_free_path(path); |
433 | return ret; | |
434 | } | |
435 | ||
3edf7d33 | 436 | int btrfs_csum_one_bio(struct btrfs_root *root, struct inode *inode, |
d20f7043 | 437 | struct bio *bio, u64 file_start, int contig) |
e015640f | 438 | { |
e6dcd2dc CM |
439 | struct btrfs_ordered_sum *sums; |
440 | struct btrfs_sector_sum *sector_sum; | |
3edf7d33 | 441 | struct btrfs_ordered_extent *ordered; |
e015640f CM |
442 | char *data; |
443 | struct bio_vec *bvec = bio->bi_io_vec; | |
444 | int bio_index = 0; | |
3edf7d33 CM |
445 | unsigned long total_bytes = 0; |
446 | unsigned long this_sum_bytes = 0; | |
447 | u64 offset; | |
d20f7043 | 448 | u64 disk_bytenr; |
e015640f | 449 | |
e6dcd2dc CM |
450 | WARN_ON(bio->bi_vcnt <= 0); |
451 | sums = kzalloc(btrfs_ordered_sum_size(root, bio->bi_size), GFP_NOFS); | |
e015640f CM |
452 | if (!sums) |
453 | return -ENOMEM; | |
3edf7d33 | 454 | |
ed98b56a | 455 | sector_sum = sums->sums; |
d20f7043 | 456 | disk_bytenr = (u64)bio->bi_sector << 9; |
e6dcd2dc CM |
457 | sums->len = bio->bi_size; |
458 | INIT_LIST_HEAD(&sums->list); | |
d20f7043 CM |
459 | |
460 | if (contig) | |
461 | offset = file_start; | |
462 | else | |
463 | offset = page_offset(bvec->bv_page) + bvec->bv_offset; | |
464 | ||
465 | ordered = btrfs_lookup_ordered_extent(inode, offset); | |
79787eaa | 466 | BUG_ON(!ordered); /* Logic error */ |
d20f7043 | 467 | sums->bytenr = ordered->start; |
e015640f | 468 | |
d397712b | 469 | while (bio_index < bio->bi_vcnt) { |
d20f7043 CM |
470 | if (!contig) |
471 | offset = page_offset(bvec->bv_page) + bvec->bv_offset; | |
472 | ||
e58dd74b JB |
473 | if (offset >= ordered->file_offset + ordered->len || |
474 | offset < ordered->file_offset) { | |
3edf7d33 CM |
475 | unsigned long bytes_left; |
476 | sums->len = this_sum_bytes; | |
477 | this_sum_bytes = 0; | |
478 | btrfs_add_ordered_sum(inode, ordered, sums); | |
479 | btrfs_put_ordered_extent(ordered); | |
480 | ||
481 | bytes_left = bio->bi_size - total_bytes; | |
482 | ||
483 | sums = kzalloc(btrfs_ordered_sum_size(root, bytes_left), | |
484 | GFP_NOFS); | |
79787eaa | 485 | BUG_ON(!sums); /* -ENOMEM */ |
ed98b56a | 486 | sector_sum = sums->sums; |
3edf7d33 | 487 | sums->len = bytes_left; |
d20f7043 | 488 | ordered = btrfs_lookup_ordered_extent(inode, offset); |
79787eaa | 489 | BUG_ON(!ordered); /* Logic error */ |
d20f7043 | 490 | sums->bytenr = ordered->start; |
3edf7d33 CM |
491 | } |
492 | ||
7ac687d9 | 493 | data = kmap_atomic(bvec->bv_page); |
e6dcd2dc | 494 | sector_sum->sum = ~(u32)0; |
b0496686 | 495 | sector_sum->sum = btrfs_csum_data(data + bvec->bv_offset, |
e6dcd2dc CM |
496 | sector_sum->sum, |
497 | bvec->bv_len); | |
7ac687d9 | 498 | kunmap_atomic(data); |
e6dcd2dc CM |
499 | btrfs_csum_final(sector_sum->sum, |
500 | (char *)§or_sum->sum); | |
d20f7043 | 501 | sector_sum->bytenr = disk_bytenr; |
ed98b56a | 502 | |
e6dcd2dc | 503 | sector_sum++; |
e015640f | 504 | bio_index++; |
3edf7d33 CM |
505 | total_bytes += bvec->bv_len; |
506 | this_sum_bytes += bvec->bv_len; | |
d20f7043 CM |
507 | disk_bytenr += bvec->bv_len; |
508 | offset += bvec->bv_len; | |
e015640f CM |
509 | bvec++; |
510 | } | |
ed98b56a | 511 | this_sum_bytes = 0; |
3edf7d33 CM |
512 | btrfs_add_ordered_sum(inode, ordered, sums); |
513 | btrfs_put_ordered_extent(ordered); | |
e015640f CM |
514 | return 0; |
515 | } | |
516 | ||
459931ec CM |
517 | /* |
518 | * helper function for csum removal, this expects the | |
519 | * key to describe the csum pointed to by the path, and it expects | |
520 | * the csum to overlap the range [bytenr, len] | |
521 | * | |
522 | * The csum should not be entirely contained in the range and the | |
523 | * range should not be entirely contained in the csum. | |
524 | * | |
525 | * This calls btrfs_truncate_item with the correct args based on the | |
526 | * overlap, and fixes up the key as required. | |
527 | */ | |
afe5fea7 | 528 | static noinline void truncate_one_csum(struct btrfs_root *root, |
143bede5 JM |
529 | struct btrfs_path *path, |
530 | struct btrfs_key *key, | |
531 | u64 bytenr, u64 len) | |
459931ec CM |
532 | { |
533 | struct extent_buffer *leaf; | |
6c41761f | 534 | u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy); |
459931ec CM |
535 | u64 csum_end; |
536 | u64 end_byte = bytenr + len; | |
537 | u32 blocksize_bits = root->fs_info->sb->s_blocksize_bits; | |
459931ec CM |
538 | |
539 | leaf = path->nodes[0]; | |
540 | csum_end = btrfs_item_size_nr(leaf, path->slots[0]) / csum_size; | |
541 | csum_end <<= root->fs_info->sb->s_blocksize_bits; | |
542 | csum_end += key->offset; | |
543 | ||
544 | if (key->offset < bytenr && csum_end <= end_byte) { | |
545 | /* | |
546 | * [ bytenr - len ] | |
547 | * [ ] | |
548 | * [csum ] | |
549 | * A simple truncate off the end of the item | |
550 | */ | |
551 | u32 new_size = (bytenr - key->offset) >> blocksize_bits; | |
552 | new_size *= csum_size; | |
afe5fea7 | 553 | btrfs_truncate_item(root, path, new_size, 1); |
459931ec CM |
554 | } else if (key->offset >= bytenr && csum_end > end_byte && |
555 | end_byte > key->offset) { | |
556 | /* | |
557 | * [ bytenr - len ] | |
558 | * [ ] | |
559 | * [csum ] | |
560 | * we need to truncate from the beginning of the csum | |
561 | */ | |
562 | u32 new_size = (csum_end - end_byte) >> blocksize_bits; | |
563 | new_size *= csum_size; | |
564 | ||
afe5fea7 | 565 | btrfs_truncate_item(root, path, new_size, 0); |
459931ec CM |
566 | |
567 | key->offset = end_byte; | |
afe5fea7 | 568 | btrfs_set_item_key_safe(root, path, key); |
459931ec CM |
569 | } else { |
570 | BUG(); | |
571 | } | |
459931ec CM |
572 | } |
573 | ||
574 | /* | |
575 | * deletes the csum items from the csum tree for a given | |
576 | * range of bytes. | |
577 | */ | |
578 | int btrfs_del_csums(struct btrfs_trans_handle *trans, | |
579 | struct btrfs_root *root, u64 bytenr, u64 len) | |
580 | { | |
581 | struct btrfs_path *path; | |
582 | struct btrfs_key key; | |
583 | u64 end_byte = bytenr + len; | |
584 | u64 csum_end; | |
585 | struct extent_buffer *leaf; | |
586 | int ret; | |
6c41761f | 587 | u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy); |
459931ec CM |
588 | int blocksize_bits = root->fs_info->sb->s_blocksize_bits; |
589 | ||
590 | root = root->fs_info->csum_root; | |
591 | ||
592 | path = btrfs_alloc_path(); | |
2a29edc6 | 593 | if (!path) |
594 | return -ENOMEM; | |
459931ec | 595 | |
d397712b | 596 | while (1) { |
459931ec CM |
597 | key.objectid = BTRFS_EXTENT_CSUM_OBJECTID; |
598 | key.offset = end_byte - 1; | |
599 | key.type = BTRFS_EXTENT_CSUM_KEY; | |
600 | ||
b9473439 | 601 | path->leave_spinning = 1; |
459931ec CM |
602 | ret = btrfs_search_slot(trans, root, &key, path, -1, 1); |
603 | if (ret > 0) { | |
604 | if (path->slots[0] == 0) | |
65a246c5 | 605 | break; |
459931ec | 606 | path->slots[0]--; |
ad0397a7 | 607 | } else if (ret < 0) { |
65a246c5 | 608 | break; |
459931ec | 609 | } |
ad0397a7 | 610 | |
459931ec CM |
611 | leaf = path->nodes[0]; |
612 | btrfs_item_key_to_cpu(leaf, &key, path->slots[0]); | |
613 | ||
614 | if (key.objectid != BTRFS_EXTENT_CSUM_OBJECTID || | |
615 | key.type != BTRFS_EXTENT_CSUM_KEY) { | |
616 | break; | |
617 | } | |
618 | ||
619 | if (key.offset >= end_byte) | |
620 | break; | |
621 | ||
622 | csum_end = btrfs_item_size_nr(leaf, path->slots[0]) / csum_size; | |
623 | csum_end <<= blocksize_bits; | |
624 | csum_end += key.offset; | |
625 | ||
626 | /* this csum ends before we start, we're done */ | |
627 | if (csum_end <= bytenr) | |
628 | break; | |
629 | ||
630 | /* delete the entire item, it is inside our range */ | |
631 | if (key.offset >= bytenr && csum_end <= end_byte) { | |
632 | ret = btrfs_del_item(trans, root, path); | |
65a246c5 TI |
633 | if (ret) |
634 | goto out; | |
dcbdd4dc CM |
635 | if (key.offset == bytenr) |
636 | break; | |
459931ec CM |
637 | } else if (key.offset < bytenr && csum_end > end_byte) { |
638 | unsigned long offset; | |
639 | unsigned long shift_len; | |
640 | unsigned long item_offset; | |
641 | /* | |
642 | * [ bytenr - len ] | |
643 | * [csum ] | |
644 | * | |
645 | * Our bytes are in the middle of the csum, | |
646 | * we need to split this item and insert a new one. | |
647 | * | |
648 | * But we can't drop the path because the | |
649 | * csum could change, get removed, extended etc. | |
650 | * | |
651 | * The trick here is the max size of a csum item leaves | |
652 | * enough room in the tree block for a single | |
653 | * item header. So, we split the item in place, | |
654 | * adding a new header pointing to the existing | |
655 | * bytes. Then we loop around again and we have | |
656 | * a nicely formed csum item that we can neatly | |
657 | * truncate. | |
658 | */ | |
659 | offset = (bytenr - key.offset) >> blocksize_bits; | |
660 | offset *= csum_size; | |
661 | ||
662 | shift_len = (len >> blocksize_bits) * csum_size; | |
663 | ||
664 | item_offset = btrfs_item_ptr_offset(leaf, | |
665 | path->slots[0]); | |
666 | ||
667 | memset_extent_buffer(leaf, 0, item_offset + offset, | |
668 | shift_len); | |
669 | key.offset = bytenr; | |
670 | ||
671 | /* | |
672 | * btrfs_split_item returns -EAGAIN when the | |
673 | * item changed size or key | |
674 | */ | |
675 | ret = btrfs_split_item(trans, root, path, &key, offset); | |
79787eaa JM |
676 | if (ret && ret != -EAGAIN) { |
677 | btrfs_abort_transaction(trans, root, ret); | |
678 | goto out; | |
679 | } | |
459931ec CM |
680 | |
681 | key.offset = end_byte - 1; | |
682 | } else { | |
afe5fea7 | 683 | truncate_one_csum(root, path, &key, bytenr, len); |
dcbdd4dc CM |
684 | if (key.offset < bytenr) |
685 | break; | |
459931ec | 686 | } |
b3b4aa74 | 687 | btrfs_release_path(path); |
459931ec | 688 | } |
65a246c5 | 689 | ret = 0; |
459931ec CM |
690 | out: |
691 | btrfs_free_path(path); | |
65a246c5 | 692 | return ret; |
459931ec CM |
693 | } |
694 | ||
2f697dc6 LB |
695 | static u64 btrfs_sector_sum_left(struct btrfs_ordered_sum *sums, |
696 | struct btrfs_sector_sum *sector_sum, | |
697 | u64 total_bytes, u64 sectorsize) | |
698 | { | |
699 | u64 tmp = sectorsize; | |
700 | u64 next_sector = sector_sum->bytenr; | |
701 | struct btrfs_sector_sum *next = sector_sum + 1; | |
702 | ||
703 | while ((tmp + total_bytes) < sums->len) { | |
704 | if (next_sector + sectorsize != next->bytenr) | |
705 | break; | |
706 | tmp += sectorsize; | |
707 | next_sector = next->bytenr; | |
708 | next++; | |
709 | } | |
710 | return tmp; | |
711 | } | |
712 | ||
065631f6 | 713 | int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans, |
d20f7043 | 714 | struct btrfs_root *root, |
e6dcd2dc | 715 | struct btrfs_ordered_sum *sums) |
f254e52c | 716 | { |
d20f7043 | 717 | u64 bytenr; |
f254e52c CM |
718 | int ret; |
719 | struct btrfs_key file_key; | |
6567e837 | 720 | struct btrfs_key found_key; |
065631f6 | 721 | u64 next_offset; |
e6dcd2dc | 722 | u64 total_bytes = 0; |
065631f6 | 723 | int found_next; |
5caf2a00 | 724 | struct btrfs_path *path; |
f254e52c | 725 | struct btrfs_csum_item *item; |
065631f6 | 726 | struct btrfs_csum_item *item_end; |
ff79f819 | 727 | struct extent_buffer *leaf = NULL; |
6567e837 | 728 | u64 csum_offset; |
e6dcd2dc | 729 | struct btrfs_sector_sum *sector_sum; |
f578d4bd CM |
730 | u32 nritems; |
731 | u32 ins_size; | |
6c41761f | 732 | u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy); |
6e92f5e6 | 733 | |
5caf2a00 | 734 | path = btrfs_alloc_path(); |
d8926bb3 MF |
735 | if (!path) |
736 | return -ENOMEM; | |
737 | ||
ed98b56a | 738 | sector_sum = sums->sums; |
065631f6 CM |
739 | again: |
740 | next_offset = (u64)-1; | |
741 | found_next = 0; | |
d20f7043 CM |
742 | file_key.objectid = BTRFS_EXTENT_CSUM_OBJECTID; |
743 | file_key.offset = sector_sum->bytenr; | |
744 | bytenr = sector_sum->bytenr; | |
745 | btrfs_set_key_type(&file_key, BTRFS_EXTENT_CSUM_KEY); | |
a429e513 | 746 | |
d20f7043 | 747 | item = btrfs_lookup_csum(trans, root, path, sector_sum->bytenr, 1); |
ff79f819 CM |
748 | if (!IS_ERR(item)) { |
749 | leaf = path->nodes[0]; | |
639cb586 | 750 | ret = 0; |
a429e513 | 751 | goto found; |
ff79f819 | 752 | } |
a429e513 | 753 | ret = PTR_ERR(item); |
4a500fd1 YZ |
754 | if (ret != -EFBIG && ret != -ENOENT) |
755 | goto fail_unlock; | |
756 | ||
a429e513 CM |
757 | if (ret == -EFBIG) { |
758 | u32 item_size; | |
759 | /* we found one, but it isn't big enough yet */ | |
5f39d397 CM |
760 | leaf = path->nodes[0]; |
761 | item_size = btrfs_item_size_nr(leaf, path->slots[0]); | |
607d432d JB |
762 | if ((item_size / csum_size) >= |
763 | MAX_CSUM_ITEMS(root, csum_size)) { | |
a429e513 CM |
764 | /* already at max size, make a new one */ |
765 | goto insert; | |
766 | } | |
767 | } else { | |
f578d4bd | 768 | int slot = path->slots[0] + 1; |
a429e513 | 769 | /* we didn't find a csum item, insert one */ |
f578d4bd CM |
770 | nritems = btrfs_header_nritems(path->nodes[0]); |
771 | if (path->slots[0] >= nritems - 1) { | |
772 | ret = btrfs_next_leaf(root, path); | |
b56baf5b | 773 | if (ret == 1) |
f578d4bd | 774 | found_next = 1; |
b56baf5b | 775 | if (ret != 0) |
f578d4bd | 776 | goto insert; |
b56baf5b | 777 | slot = 0; |
f578d4bd CM |
778 | } |
779 | btrfs_item_key_to_cpu(path->nodes[0], &found_key, slot); | |
d20f7043 CM |
780 | if (found_key.objectid != BTRFS_EXTENT_CSUM_OBJECTID || |
781 | found_key.type != BTRFS_EXTENT_CSUM_KEY) { | |
f578d4bd CM |
782 | found_next = 1; |
783 | goto insert; | |
784 | } | |
785 | next_offset = found_key.offset; | |
786 | found_next = 1; | |
a429e513 CM |
787 | goto insert; |
788 | } | |
789 | ||
790 | /* | |
791 | * at this point, we know the tree has an item, but it isn't big | |
792 | * enough yet to put our csum in. Grow it | |
793 | */ | |
b3b4aa74 | 794 | btrfs_release_path(path); |
6567e837 | 795 | ret = btrfs_search_slot(trans, root, &file_key, path, |
607d432d | 796 | csum_size, 1); |
6567e837 | 797 | if (ret < 0) |
53863232 | 798 | goto fail_unlock; |
459931ec CM |
799 | |
800 | if (ret > 0) { | |
801 | if (path->slots[0] == 0) | |
802 | goto insert; | |
803 | path->slots[0]--; | |
6567e837 | 804 | } |
459931ec | 805 | |
5f39d397 CM |
806 | leaf = path->nodes[0]; |
807 | btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); | |
d20f7043 | 808 | csum_offset = (bytenr - found_key.offset) >> |
6567e837 | 809 | root->fs_info->sb->s_blocksize_bits; |
459931ec | 810 | |
d20f7043 CM |
811 | if (btrfs_key_type(&found_key) != BTRFS_EXTENT_CSUM_KEY || |
812 | found_key.objectid != BTRFS_EXTENT_CSUM_OBJECTID || | |
607d432d | 813 | csum_offset >= MAX_CSUM_ITEMS(root, csum_size)) { |
6567e837 CM |
814 | goto insert; |
815 | } | |
459931ec | 816 | |
2f697dc6 | 817 | if (csum_offset == btrfs_item_size_nr(leaf, path->slots[0]) / |
607d432d | 818 | csum_size) { |
2f697dc6 LB |
819 | int extend_nr; |
820 | u64 tmp; | |
821 | u32 diff; | |
822 | u32 free_space; | |
459931ec | 823 | |
2f697dc6 LB |
824 | if (btrfs_leaf_free_space(root, leaf) < |
825 | sizeof(struct btrfs_item) + csum_size * 2) | |
826 | goto insert; | |
827 | ||
828 | free_space = btrfs_leaf_free_space(root, leaf) - | |
829 | sizeof(struct btrfs_item) - csum_size; | |
830 | tmp = btrfs_sector_sum_left(sums, sector_sum, total_bytes, | |
831 | root->sectorsize); | |
832 | tmp >>= root->fs_info->sb->s_blocksize_bits; | |
833 | WARN_ON(tmp < 1); | |
834 | ||
835 | extend_nr = max_t(int, 1, (int)tmp); | |
836 | diff = (csum_offset + extend_nr) * csum_size; | |
837 | diff = min(diff, MAX_CSUM_ITEMS(root, csum_size) * csum_size); | |
459931ec | 838 | |
5f39d397 | 839 | diff = diff - btrfs_item_size_nr(leaf, path->slots[0]); |
2f697dc6 LB |
840 | diff = min(free_space, diff); |
841 | diff /= csum_size; | |
842 | diff *= csum_size; | |
459931ec | 843 | |
4b90c680 | 844 | btrfs_extend_item(root, path, diff); |
6567e837 CM |
845 | goto csum; |
846 | } | |
847 | ||
848 | insert: | |
b3b4aa74 | 849 | btrfs_release_path(path); |
6567e837 | 850 | csum_offset = 0; |
f578d4bd | 851 | if (found_next) { |
2f697dc6 | 852 | u64 tmp; |
d20f7043 | 853 | |
2f697dc6 LB |
854 | tmp = btrfs_sector_sum_left(sums, sector_sum, total_bytes, |
855 | root->sectorsize); | |
f578d4bd | 856 | tmp >>= root->fs_info->sb->s_blocksize_bits; |
2f697dc6 LB |
857 | tmp = min(tmp, (next_offset - file_key.offset) >> |
858 | root->fs_info->sb->s_blocksize_bits); | |
859 | ||
f578d4bd | 860 | tmp = max((u64)1, tmp); |
607d432d JB |
861 | tmp = min(tmp, (u64)MAX_CSUM_ITEMS(root, csum_size)); |
862 | ins_size = csum_size * tmp; | |
f578d4bd | 863 | } else { |
607d432d | 864 | ins_size = csum_size; |
f578d4bd | 865 | } |
b9473439 | 866 | path->leave_spinning = 1; |
5caf2a00 | 867 | ret = btrfs_insert_empty_item(trans, root, path, &file_key, |
f578d4bd | 868 | ins_size); |
b9473439 | 869 | path->leave_spinning = 0; |
54aa1f4d | 870 | if (ret < 0) |
53863232 | 871 | goto fail_unlock; |
a429e513 | 872 | if (ret != 0) { |
a429e513 | 873 | WARN_ON(1); |
53863232 | 874 | goto fail_unlock; |
a429e513 | 875 | } |
6567e837 | 876 | csum: |
5f39d397 CM |
877 | leaf = path->nodes[0]; |
878 | item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item); | |
f254e52c | 879 | ret = 0; |
509659cd | 880 | item = (struct btrfs_csum_item *)((unsigned char *)item + |
607d432d | 881 | csum_offset * csum_size); |
b18c6685 | 882 | found: |
065631f6 CM |
883 | item_end = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item); |
884 | item_end = (struct btrfs_csum_item *)((unsigned char *)item_end + | |
885 | btrfs_item_size_nr(leaf, path->slots[0])); | |
e6dcd2dc | 886 | next_sector: |
aadfeb6e | 887 | |
a6591715 | 888 | write_extent_buffer(leaf, §or_sum->sum, (unsigned long)item, csum_size); |
7f3c74fb | 889 | |
e6dcd2dc CM |
890 | total_bytes += root->sectorsize; |
891 | sector_sum++; | |
892 | if (total_bytes < sums->len) { | |
6e92f5e6 | 893 | item = (struct btrfs_csum_item *)((char *)item + |
607d432d | 894 | csum_size); |
d20f7043 CM |
895 | if (item < item_end && bytenr + PAGE_CACHE_SIZE == |
896 | sector_sum->bytenr) { | |
897 | bytenr = sector_sum->bytenr; | |
e6dcd2dc | 898 | goto next_sector; |
2e1a992e | 899 | } |
065631f6 | 900 | } |
a6591715 | 901 | |
5caf2a00 | 902 | btrfs_mark_buffer_dirty(path->nodes[0]); |
e6dcd2dc | 903 | if (total_bytes < sums->len) { |
b3b4aa74 | 904 | btrfs_release_path(path); |
b9473439 | 905 | cond_resched(); |
065631f6 CM |
906 | goto again; |
907 | } | |
53863232 | 908 | out: |
5caf2a00 | 909 | btrfs_free_path(path); |
f254e52c | 910 | return ret; |
53863232 CM |
911 | |
912 | fail_unlock: | |
53863232 | 913 | goto out; |
f254e52c | 914 | } |