1
2
3
4
5
6#include <linux/bio.h>
7#include <linux/slab.h>
8#include <linux/pagemap.h>
9#include <linux/highmem.h>
10#include <linux/sched/mm.h>
11#include <crypto/hash.h>
12#include "misc.h"
13#include "ctree.h"
14#include "disk-io.h"
15#include "transaction.h"
16#include "volumes.h"
17#include "print-tree.h"
18#include "compression.h"
19
20#define __MAX_CSUM_ITEMS(r, size) ((unsigned long)(((BTRFS_LEAF_DATA_SIZE(r) - \
21 sizeof(struct btrfs_item) * 2) / \
22 size) - 1))
23
24#define MAX_CSUM_ITEMS(r, size) (min_t(u32, __MAX_CSUM_ITEMS(r, size), \
25 PAGE_SIZE))
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44void btrfs_inode_safe_disk_i_size_write(struct btrfs_inode *inode, u64 new_i_size)
45{
46 struct btrfs_fs_info *fs_info = inode->root->fs_info;
47 u64 start, end, i_size;
48 int ret;
49
50 i_size = new_i_size ?: i_size_read(&inode->vfs_inode);
51 if (btrfs_fs_incompat(fs_info, NO_HOLES)) {
52 inode->disk_i_size = i_size;
53 return;
54 }
55
56 spin_lock(&inode->lock);
57 ret = find_contiguous_extent_bit(&inode->file_extent_tree, 0, &start,
58 &end, EXTENT_DIRTY);
59 if (!ret && start == 0)
60 i_size = min(i_size, end + 1);
61 else
62 i_size = 0;
63 inode->disk_i_size = i_size;
64 spin_unlock(&inode->lock);
65}
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81int btrfs_inode_set_file_extent_range(struct btrfs_inode *inode, u64 start,
82 u64 len)
83{
84 if (len == 0)
85 return 0;
86
87 ASSERT(IS_ALIGNED(start + len, inode->root->fs_info->sectorsize));
88
89 if (btrfs_fs_incompat(inode->root->fs_info, NO_HOLES))
90 return 0;
91 return set_extent_bits(&inode->file_extent_tree, start, start + len - 1,
92 EXTENT_DIRTY);
93}
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109int btrfs_inode_clear_file_extent_range(struct btrfs_inode *inode, u64 start,
110 u64 len)
111{
112 if (len == 0)
113 return 0;
114
115 ASSERT(IS_ALIGNED(start + len, inode->root->fs_info->sectorsize) ||
116 len == (u64)-1);
117
118 if (btrfs_fs_incompat(inode->root->fs_info, NO_HOLES))
119 return 0;
120 return clear_extent_bit(&inode->file_extent_tree, start,
121 start + len - 1, EXTENT_DIRTY, 0, 0, NULL);
122}
123
124static inline u32 max_ordered_sum_bytes(struct btrfs_fs_info *fs_info,
125 u16 csum_size)
126{
127 u32 ncsums = (PAGE_SIZE - sizeof(struct btrfs_ordered_sum)) / csum_size;
128
129 return ncsums * fs_info->sectorsize;
130}
131
132int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
133 struct btrfs_root *root,
134 u64 objectid, u64 pos,
135 u64 disk_offset, u64 disk_num_bytes,
136 u64 num_bytes, u64 offset, u64 ram_bytes,
137 u8 compression, u8 encryption, u16 other_encoding)
138{
139 int ret = 0;
140 struct btrfs_file_extent_item *item;
141 struct btrfs_key file_key;
142 struct btrfs_path *path;
143 struct extent_buffer *leaf;
144
145 path = btrfs_alloc_path();
146 if (!path)
147 return -ENOMEM;
148 file_key.objectid = objectid;
149 file_key.offset = pos;
150 file_key.type = BTRFS_EXTENT_DATA_KEY;
151
152 ret = btrfs_insert_empty_item(trans, root, path, &file_key,
153 sizeof(*item));
154 if (ret < 0)
155 goto out;
156 BUG_ON(ret);
157 leaf = path->nodes[0];
158 item = btrfs_item_ptr(leaf, path->slots[0],
159 struct btrfs_file_extent_item);
160 btrfs_set_file_extent_disk_bytenr(leaf, item, disk_offset);
161 btrfs_set_file_extent_disk_num_bytes(leaf, item, disk_num_bytes);
162 btrfs_set_file_extent_offset(leaf, item, offset);
163 btrfs_set_file_extent_num_bytes(leaf, item, num_bytes);
164 btrfs_set_file_extent_ram_bytes(leaf, item, ram_bytes);
165 btrfs_set_file_extent_generation(leaf, item, trans->transid);
166 btrfs_set_file_extent_type(leaf, item, BTRFS_FILE_EXTENT_REG);
167 btrfs_set_file_extent_compression(leaf, item, compression);
168 btrfs_set_file_extent_encryption(leaf, item, encryption);
169 btrfs_set_file_extent_other_encoding(leaf, item, other_encoding);
170
171 btrfs_mark_buffer_dirty(leaf);
172out:
173 btrfs_free_path(path);
174 return ret;
175}
176
177static struct btrfs_csum_item *
178btrfs_lookup_csum(struct btrfs_trans_handle *trans,
179 struct btrfs_root *root,
180 struct btrfs_path *path,
181 u64 bytenr, int cow)
182{
183 struct btrfs_fs_info *fs_info = root->fs_info;
184 int ret;
185 struct btrfs_key file_key;
186 struct btrfs_key found_key;
187 struct btrfs_csum_item *item;
188 struct extent_buffer *leaf;
189 u64 csum_offset = 0;
190 const u32 csum_size = fs_info->csum_size;
191 int csums_in_item;
192
193 file_key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
194 file_key.offset = bytenr;
195 file_key.type = BTRFS_EXTENT_CSUM_KEY;
196 ret = btrfs_search_slot(trans, root, &file_key, path, 0, cow);
197 if (ret < 0)
198 goto fail;
199 leaf = path->nodes[0];
200 if (ret > 0) {
201 ret = 1;
202 if (path->slots[0] == 0)
203 goto fail;
204 path->slots[0]--;
205 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
206 if (found_key.type != BTRFS_EXTENT_CSUM_KEY)
207 goto fail;
208
209 csum_offset = (bytenr - found_key.offset) >>
210 fs_info->sectorsize_bits;
211 csums_in_item = btrfs_item_size(leaf, path->slots[0]);
212 csums_in_item /= csum_size;
213
214 if (csum_offset == csums_in_item) {
215 ret = -EFBIG;
216 goto fail;
217 } else if (csum_offset > csums_in_item) {
218 goto fail;
219 }
220 }
221 item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item);
222 item = (struct btrfs_csum_item *)((unsigned char *)item +
223 csum_offset * csum_size);
224 return item;
225fail:
226 if (ret > 0)
227 ret = -ENOENT;
228 return ERR_PTR(ret);
229}
230
231int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans,
232 struct btrfs_root *root,
233 struct btrfs_path *path, u64 objectid,
234 u64 offset, int mod)
235{
236 struct btrfs_key file_key;
237 int ins_len = mod < 0 ? -1 : 0;
238 int cow = mod != 0;
239
240 file_key.objectid = objectid;
241 file_key.offset = offset;
242 file_key.type = BTRFS_EXTENT_DATA_KEY;
243
244 return btrfs_search_slot(trans, root, &file_key, path, ins_len, cow);
245}
246
247
248
249
250
251
252
253
254
255
256static int search_csum_tree(struct btrfs_fs_info *fs_info,
257 struct btrfs_path *path, u64 disk_bytenr,
258 u64 len, u8 *dst)
259{
260 struct btrfs_root *csum_root;
261 struct btrfs_csum_item *item = NULL;
262 struct btrfs_key key;
263 const u32 sectorsize = fs_info->sectorsize;
264 const u32 csum_size = fs_info->csum_size;
265 u32 itemsize;
266 int ret;
267 u64 csum_start;
268 u64 csum_len;
269
270 ASSERT(IS_ALIGNED(disk_bytenr, sectorsize) &&
271 IS_ALIGNED(len, sectorsize));
272
273
274 if (path->nodes[0]) {
275 item = btrfs_item_ptr(path->nodes[0], path->slots[0],
276 struct btrfs_csum_item);
277 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
278 itemsize = btrfs_item_size(path->nodes[0], path->slots[0]);
279
280 csum_start = key.offset;
281 csum_len = (itemsize / csum_size) * sectorsize;
282
283 if (in_range(disk_bytenr, csum_start, csum_len))
284 goto found;
285 }
286
287
288 btrfs_release_path(path);
289 csum_root = btrfs_csum_root(fs_info, disk_bytenr);
290 item = btrfs_lookup_csum(NULL, csum_root, path, disk_bytenr, 0);
291 if (IS_ERR(item)) {
292 ret = PTR_ERR(item);
293 goto out;
294 }
295 btrfs_item_key_to_cpu(path->nodes[0], &key, path->slots[0]);
296 itemsize = btrfs_item_size(path->nodes[0], path->slots[0]);
297
298 csum_start = key.offset;
299 csum_len = (itemsize / csum_size) * sectorsize;
300 ASSERT(in_range(disk_bytenr, csum_start, csum_len));
301
302found:
303 ret = (min(csum_start + csum_len, disk_bytenr + len) -
304 disk_bytenr) >> fs_info->sectorsize_bits;
305 read_extent_buffer(path->nodes[0], dst, (unsigned long)item,
306 ret * csum_size);
307out:
308 if (ret == -ENOENT)
309 ret = 0;
310 return ret;
311}
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326static int search_file_offset_in_bio(struct bio *bio, struct inode *inode,
327 u64 disk_bytenr, u64 *file_offset_ret)
328{
329 struct bvec_iter iter;
330 struct bio_vec bvec;
331 u64 cur = bio->bi_iter.bi_sector << SECTOR_SHIFT;
332 int ret = 0;
333
334 bio_for_each_segment(bvec, bio, iter) {
335 struct page *page = bvec.bv_page;
336
337 if (cur > disk_bytenr)
338 break;
339 if (cur + bvec.bv_len <= disk_bytenr) {
340 cur += bvec.bv_len;
341 continue;
342 }
343 ASSERT(in_range(disk_bytenr, cur, bvec.bv_len));
344 if (page->mapping && page->mapping->host &&
345 page->mapping->host == inode) {
346 ret = 1;
347 *file_offset_ret = page_offset(page) + bvec.bv_offset +
348 disk_bytenr - cur;
349 break;
350 }
351 }
352 return ret;
353}
354
355
356
357
358
359
360
361
362
363
364
365
366
367blk_status_t btrfs_lookup_bio_sums(struct inode *inode, struct bio *bio, u8 *dst)
368{
369 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
370 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
371 struct btrfs_path *path;
372 const u32 sectorsize = fs_info->sectorsize;
373 const u32 csum_size = fs_info->csum_size;
374 u32 orig_len = bio->bi_iter.bi_size;
375 u64 orig_disk_bytenr = bio->bi_iter.bi_sector << SECTOR_SHIFT;
376 u64 cur_disk_bytenr;
377 u8 *csum;
378 const unsigned int nblocks = orig_len >> fs_info->sectorsize_bits;
379 int count = 0;
380
381 if ((BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM) ||
382 test_bit(BTRFS_FS_STATE_NO_CSUMS, &fs_info->fs_state))
383 return BLK_STS_OK;
384
385
386
387
388
389
390
391
392
393
394
395
396
397 ASSERT(bio_op(bio) == REQ_OP_READ);
398 path = btrfs_alloc_path();
399 if (!path)
400 return BLK_STS_RESOURCE;
401
402 if (!dst) {
403 struct btrfs_bio *bbio = btrfs_bio(bio);
404
405 if (nblocks * csum_size > BTRFS_BIO_INLINE_CSUM_SIZE) {
406 bbio->csum = kmalloc_array(nblocks, csum_size, GFP_NOFS);
407 if (!bbio->csum) {
408 btrfs_free_path(path);
409 return BLK_STS_RESOURCE;
410 }
411 } else {
412 bbio->csum = bbio->csum_inline;
413 }
414 csum = bbio->csum;
415 } else {
416 csum = dst;
417 }
418
419
420
421
422
423 if (nblocks > fs_info->csums_per_leaf)
424 path->reada = READA_FORWARD;
425
426
427
428
429
430
431
432 if (btrfs_is_free_space_inode(BTRFS_I(inode))) {
433 path->search_commit_root = 1;
434 path->skip_locking = 1;
435 }
436
437 for (cur_disk_bytenr = orig_disk_bytenr;
438 cur_disk_bytenr < orig_disk_bytenr + orig_len;
439 cur_disk_bytenr += (count * sectorsize)) {
440 u64 search_len = orig_disk_bytenr + orig_len - cur_disk_bytenr;
441 unsigned int sector_offset;
442 u8 *csum_dst;
443
444
445
446
447
448
449
450
451
452 ASSERT(cur_disk_bytenr - orig_disk_bytenr < UINT_MAX);
453 sector_offset = (cur_disk_bytenr - orig_disk_bytenr) >>
454 fs_info->sectorsize_bits;
455 csum_dst = csum + sector_offset * csum_size;
456
457 count = search_csum_tree(fs_info, path, cur_disk_bytenr,
458 search_len, csum_dst);
459 if (count <= 0) {
460
461
462
463
464
465
466 memset(csum_dst, 0, csum_size);
467 count = 1;
468
469
470
471
472
473
474 if (BTRFS_I(inode)->root->root_key.objectid ==
475 BTRFS_DATA_RELOC_TREE_OBJECTID) {
476 u64 file_offset;
477 int ret;
478
479 ret = search_file_offset_in_bio(bio, inode,
480 cur_disk_bytenr, &file_offset);
481 if (ret)
482 set_extent_bits(io_tree, file_offset,
483 file_offset + sectorsize - 1,
484 EXTENT_NODATASUM);
485 } else {
486 btrfs_warn_rl(fs_info,
487 "csum hole found for disk bytenr range [%llu, %llu)",
488 cur_disk_bytenr, cur_disk_bytenr + sectorsize);
489 }
490 }
491 }
492
493 btrfs_free_path(path);
494 return BLK_STS_OK;
495}
496
497int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end,
498 struct list_head *list, int search_commit)
499{
500 struct btrfs_fs_info *fs_info = root->fs_info;
501 struct btrfs_key key;
502 struct btrfs_path *path;
503 struct extent_buffer *leaf;
504 struct btrfs_ordered_sum *sums;
505 struct btrfs_csum_item *item;
506 LIST_HEAD(tmplist);
507 unsigned long offset;
508 int ret;
509 size_t size;
510 u64 csum_end;
511 const u32 csum_size = fs_info->csum_size;
512
513 ASSERT(IS_ALIGNED(start, fs_info->sectorsize) &&
514 IS_ALIGNED(end + 1, fs_info->sectorsize));
515
516 path = btrfs_alloc_path();
517 if (!path)
518 return -ENOMEM;
519
520 if (search_commit) {
521 path->skip_locking = 1;
522 path->reada = READA_FORWARD;
523 path->search_commit_root = 1;
524 }
525
526 key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
527 key.offset = start;
528 key.type = BTRFS_EXTENT_CSUM_KEY;
529
530 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
531 if (ret < 0)
532 goto fail;
533 if (ret > 0 && path->slots[0] > 0) {
534 leaf = path->nodes[0];
535 btrfs_item_key_to_cpu(leaf, &key, path->slots[0] - 1);
536 if (key.objectid == BTRFS_EXTENT_CSUM_OBJECTID &&
537 key.type == BTRFS_EXTENT_CSUM_KEY) {
538 offset = (start - key.offset) >> fs_info->sectorsize_bits;
539 if (offset * csum_size <
540 btrfs_item_size(leaf, path->slots[0] - 1))
541 path->slots[0]--;
542 }
543 }
544
545 while (start <= end) {
546 leaf = path->nodes[0];
547 if (path->slots[0] >= btrfs_header_nritems(leaf)) {
548 ret = btrfs_next_leaf(root, path);
549 if (ret < 0)
550 goto fail;
551 if (ret > 0)
552 break;
553 leaf = path->nodes[0];
554 }
555
556 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
557 if (key.objectid != BTRFS_EXTENT_CSUM_OBJECTID ||
558 key.type != BTRFS_EXTENT_CSUM_KEY ||
559 key.offset > end)
560 break;
561
562 if (key.offset > start)
563 start = key.offset;
564
565 size = btrfs_item_size(leaf, path->slots[0]);
566 csum_end = key.offset + (size / csum_size) * fs_info->sectorsize;
567 if (csum_end <= start) {
568 path->slots[0]++;
569 continue;
570 }
571
572 csum_end = min(csum_end, end + 1);
573 item = btrfs_item_ptr(path->nodes[0], path->slots[0],
574 struct btrfs_csum_item);
575 while (start < csum_end) {
576 size = min_t(size_t, csum_end - start,
577 max_ordered_sum_bytes(fs_info, csum_size));
578 sums = kzalloc(btrfs_ordered_sum_size(fs_info, size),
579 GFP_NOFS);
580 if (!sums) {
581 ret = -ENOMEM;
582 goto fail;
583 }
584
585 sums->bytenr = start;
586 sums->len = (int)size;
587
588 offset = (start - key.offset) >> fs_info->sectorsize_bits;
589 offset *= csum_size;
590 size >>= fs_info->sectorsize_bits;
591
592 read_extent_buffer(path->nodes[0],
593 sums->sums,
594 ((unsigned long)item) + offset,
595 csum_size * size);
596
597 start += fs_info->sectorsize * size;
598 list_add_tail(&sums->list, &tmplist);
599 }
600 path->slots[0]++;
601 }
602 ret = 0;
603fail:
604 while (ret < 0 && !list_empty(&tmplist)) {
605 sums = list_entry(tmplist.next, struct btrfs_ordered_sum, list);
606 list_del(&sums->list);
607 kfree(sums);
608 }
609 list_splice_tail(&tmplist, list);
610
611 btrfs_free_path(path);
612 return ret;
613}
614
615
616
617
618
619
620
621
622
623
624
625blk_status_t btrfs_csum_one_bio(struct btrfs_inode *inode, struct bio *bio,
626 u64 file_start, int contig)
627{
628 struct btrfs_fs_info *fs_info = inode->root->fs_info;
629 SHASH_DESC_ON_STACK(shash, fs_info->csum_shash);
630 struct btrfs_ordered_sum *sums;
631 struct btrfs_ordered_extent *ordered = NULL;
632 char *data;
633 struct bvec_iter iter;
634 struct bio_vec bvec;
635 int index;
636 int nr_sectors;
637 unsigned long total_bytes = 0;
638 unsigned long this_sum_bytes = 0;
639 int i;
640 u64 offset;
641 unsigned nofs_flag;
642
643 nofs_flag = memalloc_nofs_save();
644 sums = kvzalloc(btrfs_ordered_sum_size(fs_info, bio->bi_iter.bi_size),
645 GFP_KERNEL);
646 memalloc_nofs_restore(nofs_flag);
647
648 if (!sums)
649 return BLK_STS_RESOURCE;
650
651 sums->len = bio->bi_iter.bi_size;
652 INIT_LIST_HEAD(&sums->list);
653
654 if (contig)
655 offset = file_start;
656 else
657 offset = 0;
658
659 sums->bytenr = bio->bi_iter.bi_sector << 9;
660 index = 0;
661
662 shash->tfm = fs_info->csum_shash;
663
664 bio_for_each_segment(bvec, bio, iter) {
665 if (!contig)
666 offset = page_offset(bvec.bv_page) + bvec.bv_offset;
667
668 if (!ordered) {
669 ordered = btrfs_lookup_ordered_extent(inode, offset);
670
671
672
673
674 if (unlikely(!ordered)) {
675 WARN(1, KERN_WARNING
676 "no ordered extent for root %llu ino %llu offset %llu\n",
677 inode->root->root_key.objectid,
678 btrfs_ino(inode), offset);
679 kvfree(sums);
680 return BLK_STS_IOERR;
681 }
682 }
683
684 nr_sectors = BTRFS_BYTES_TO_BLKS(fs_info,
685 bvec.bv_len + fs_info->sectorsize
686 - 1);
687
688 for (i = 0; i < nr_sectors; i++) {
689 if (offset >= ordered->file_offset + ordered->num_bytes ||
690 offset < ordered->file_offset) {
691 unsigned long bytes_left;
692
693 sums->len = this_sum_bytes;
694 this_sum_bytes = 0;
695 btrfs_add_ordered_sum(ordered, sums);
696 btrfs_put_ordered_extent(ordered);
697
698 bytes_left = bio->bi_iter.bi_size - total_bytes;
699
700 nofs_flag = memalloc_nofs_save();
701 sums = kvzalloc(btrfs_ordered_sum_size(fs_info,
702 bytes_left), GFP_KERNEL);
703 memalloc_nofs_restore(nofs_flag);
704 BUG_ON(!sums);
705 sums->len = bytes_left;
706 ordered = btrfs_lookup_ordered_extent(inode,
707 offset);
708 ASSERT(ordered);
709 sums->bytenr = (bio->bi_iter.bi_sector << 9)
710 + total_bytes;
711 index = 0;
712 }
713
714 data = bvec_kmap_local(&bvec);
715 crypto_shash_digest(shash,
716 data + (i * fs_info->sectorsize),
717 fs_info->sectorsize,
718 sums->sums + index);
719 kunmap_local(data);
720 index += fs_info->csum_size;
721 offset += fs_info->sectorsize;
722 this_sum_bytes += fs_info->sectorsize;
723 total_bytes += fs_info->sectorsize;
724 }
725
726 }
727 this_sum_bytes = 0;
728 btrfs_add_ordered_sum(ordered, sums);
729 btrfs_put_ordered_extent(ordered);
730 return 0;
731}
732
733
734
735
736
737
738
739
740
741
742
743
744static noinline void truncate_one_csum(struct btrfs_fs_info *fs_info,
745 struct btrfs_path *path,
746 struct btrfs_key *key,
747 u64 bytenr, u64 len)
748{
749 struct extent_buffer *leaf;
750 const u32 csum_size = fs_info->csum_size;
751 u64 csum_end;
752 u64 end_byte = bytenr + len;
753 u32 blocksize_bits = fs_info->sectorsize_bits;
754
755 leaf = path->nodes[0];
756 csum_end = btrfs_item_size(leaf, path->slots[0]) / csum_size;
757 csum_end <<= blocksize_bits;
758 csum_end += key->offset;
759
760 if (key->offset < bytenr && csum_end <= end_byte) {
761
762
763
764
765
766
767 u32 new_size = (bytenr - key->offset) >> blocksize_bits;
768 new_size *= csum_size;
769 btrfs_truncate_item(path, new_size, 1);
770 } else if (key->offset >= bytenr && csum_end > end_byte &&
771 end_byte > key->offset) {
772
773
774
775
776
777
778 u32 new_size = (csum_end - end_byte) >> blocksize_bits;
779 new_size *= csum_size;
780
781 btrfs_truncate_item(path, new_size, 0);
782
783 key->offset = end_byte;
784 btrfs_set_item_key_safe(fs_info, path, key);
785 } else {
786 BUG();
787 }
788}
789
790
791
792
793
794int btrfs_del_csums(struct btrfs_trans_handle *trans,
795 struct btrfs_root *root, u64 bytenr, u64 len)
796{
797 struct btrfs_fs_info *fs_info = trans->fs_info;
798 struct btrfs_path *path;
799 struct btrfs_key key;
800 u64 end_byte = bytenr + len;
801 u64 csum_end;
802 struct extent_buffer *leaf;
803 int ret = 0;
804 const u32 csum_size = fs_info->csum_size;
805 u32 blocksize_bits = fs_info->sectorsize_bits;
806
807 ASSERT(root->root_key.objectid == BTRFS_CSUM_TREE_OBJECTID ||
808 root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID);
809
810 path = btrfs_alloc_path();
811 if (!path)
812 return -ENOMEM;
813
814 while (1) {
815 key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
816 key.offset = end_byte - 1;
817 key.type = BTRFS_EXTENT_CSUM_KEY;
818
819 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
820 if (ret > 0) {
821 ret = 0;
822 if (path->slots[0] == 0)
823 break;
824 path->slots[0]--;
825 } else if (ret < 0) {
826 break;
827 }
828
829 leaf = path->nodes[0];
830 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
831
832 if (key.objectid != BTRFS_EXTENT_CSUM_OBJECTID ||
833 key.type != BTRFS_EXTENT_CSUM_KEY) {
834 break;
835 }
836
837 if (key.offset >= end_byte)
838 break;
839
840 csum_end = btrfs_item_size(leaf, path->slots[0]) / csum_size;
841 csum_end <<= blocksize_bits;
842 csum_end += key.offset;
843
844
845 if (csum_end <= bytenr)
846 break;
847
848
849 if (key.offset >= bytenr && csum_end <= end_byte) {
850 int del_nr = 1;
851
852
853
854
855
856
857 if (key.offset > bytenr && path->slots[0] > 0) {
858 int slot = path->slots[0] - 1;
859
860 while (slot >= 0) {
861 struct btrfs_key pk;
862
863 btrfs_item_key_to_cpu(leaf, &pk, slot);
864 if (pk.offset < bytenr ||
865 pk.type != BTRFS_EXTENT_CSUM_KEY ||
866 pk.objectid !=
867 BTRFS_EXTENT_CSUM_OBJECTID)
868 break;
869 path->slots[0] = slot;
870 del_nr++;
871 key.offset = pk.offset;
872 slot--;
873 }
874 }
875 ret = btrfs_del_items(trans, root, path,
876 path->slots[0], del_nr);
877 if (ret)
878 break;
879 if (key.offset == bytenr)
880 break;
881 } else if (key.offset < bytenr && csum_end > end_byte) {
882 unsigned long offset;
883 unsigned long shift_len;
884 unsigned long item_offset;
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903 offset = (bytenr - key.offset) >> blocksize_bits;
904 offset *= csum_size;
905
906 shift_len = (len >> blocksize_bits) * csum_size;
907
908 item_offset = btrfs_item_ptr_offset(leaf,
909 path->slots[0]);
910
911 memzero_extent_buffer(leaf, item_offset + offset,
912 shift_len);
913 key.offset = bytenr;
914
915
916
917
918
919 ret = btrfs_split_item(trans, root, path, &key, offset);
920 if (ret && ret != -EAGAIN) {
921 btrfs_abort_transaction(trans, ret);
922 break;
923 }
924 ret = 0;
925
926 key.offset = end_byte - 1;
927 } else {
928 truncate_one_csum(fs_info, path, &key, bytenr, len);
929 if (key.offset < bytenr)
930 break;
931 }
932 btrfs_release_path(path);
933 }
934 btrfs_free_path(path);
935 return ret;
936}
937
938static int find_next_csum_offset(struct btrfs_root *root,
939 struct btrfs_path *path,
940 u64 *next_offset)
941{
942 const u32 nritems = btrfs_header_nritems(path->nodes[0]);
943 struct btrfs_key found_key;
944 int slot = path->slots[0] + 1;
945 int ret;
946
947 if (nritems == 0 || slot >= nritems) {
948 ret = btrfs_next_leaf(root, path);
949 if (ret < 0) {
950 return ret;
951 } else if (ret > 0) {
952 *next_offset = (u64)-1;
953 return 0;
954 }
955 slot = path->slots[0];
956 }
957
958 btrfs_item_key_to_cpu(path->nodes[0], &found_key, slot);
959
960 if (found_key.objectid != BTRFS_EXTENT_CSUM_OBJECTID ||
961 found_key.type != BTRFS_EXTENT_CSUM_KEY)
962 *next_offset = (u64)-1;
963 else
964 *next_offset = found_key.offset;
965
966 return 0;
967}
968
969int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,
970 struct btrfs_root *root,
971 struct btrfs_ordered_sum *sums)
972{
973 struct btrfs_fs_info *fs_info = root->fs_info;
974 struct btrfs_key file_key;
975 struct btrfs_key found_key;
976 struct btrfs_path *path;
977 struct btrfs_csum_item *item;
978 struct btrfs_csum_item *item_end;
979 struct extent_buffer *leaf = NULL;
980 u64 next_offset;
981 u64 total_bytes = 0;
982 u64 csum_offset;
983 u64 bytenr;
984 u32 ins_size;
985 int index = 0;
986 int found_next;
987 int ret;
988 const u32 csum_size = fs_info->csum_size;
989
990 path = btrfs_alloc_path();
991 if (!path)
992 return -ENOMEM;
993again:
994 next_offset = (u64)-1;
995 found_next = 0;
996 bytenr = sums->bytenr + total_bytes;
997 file_key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
998 file_key.offset = bytenr;
999 file_key.type = BTRFS_EXTENT_CSUM_KEY;
1000
1001 item = btrfs_lookup_csum(trans, root, path, bytenr, 1);
1002 if (!IS_ERR(item)) {
1003 ret = 0;
1004 leaf = path->nodes[0];
1005 item_end = btrfs_item_ptr(leaf, path->slots[0],
1006 struct btrfs_csum_item);
1007 item_end = (struct btrfs_csum_item *)((char *)item_end +
1008 btrfs_item_size(leaf, path->slots[0]));
1009 goto found;
1010 }
1011 ret = PTR_ERR(item);
1012 if (ret != -EFBIG && ret != -ENOENT)
1013 goto out;
1014
1015 if (ret == -EFBIG) {
1016 u32 item_size;
1017
1018 leaf = path->nodes[0];
1019 item_size = btrfs_item_size(leaf, path->slots[0]);
1020 if ((item_size / csum_size) >=
1021 MAX_CSUM_ITEMS(fs_info, csum_size)) {
1022
1023 goto insert;
1024 }
1025 } else {
1026
1027 ret = find_next_csum_offset(root, path, &next_offset);
1028 if (ret < 0)
1029 goto out;
1030 found_next = 1;
1031 goto insert;
1032 }
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044 if (btrfs_leaf_free_space(leaf) >= csum_size) {
1045 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
1046 csum_offset = (bytenr - found_key.offset) >>
1047 fs_info->sectorsize_bits;
1048 goto extend_csum;
1049 }
1050
1051 btrfs_release_path(path);
1052 path->search_for_extension = 1;
1053 ret = btrfs_search_slot(trans, root, &file_key, path,
1054 csum_size, 1);
1055 path->search_for_extension = 0;
1056 if (ret < 0)
1057 goto out;
1058
1059 if (ret > 0) {
1060 if (path->slots[0] == 0)
1061 goto insert;
1062 path->slots[0]--;
1063 }
1064
1065 leaf = path->nodes[0];
1066 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
1067 csum_offset = (bytenr - found_key.offset) >> fs_info->sectorsize_bits;
1068
1069 if (found_key.type != BTRFS_EXTENT_CSUM_KEY ||
1070 found_key.objectid != BTRFS_EXTENT_CSUM_OBJECTID ||
1071 csum_offset >= MAX_CSUM_ITEMS(fs_info, csum_size)) {
1072 goto insert;
1073 }
1074
1075extend_csum:
1076 if (csum_offset == btrfs_item_size(leaf, path->slots[0]) /
1077 csum_size) {
1078 int extend_nr;
1079 u64 tmp;
1080 u32 diff;
1081
1082 tmp = sums->len - total_bytes;
1083 tmp >>= fs_info->sectorsize_bits;
1084 WARN_ON(tmp < 1);
1085 extend_nr = max_t(int, 1, tmp);
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108 if (root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID) {
1109 if (path->slots[0] + 1 >=
1110 btrfs_header_nritems(path->nodes[0])) {
1111 ret = find_next_csum_offset(root, path, &next_offset);
1112 if (ret < 0)
1113 goto out;
1114 found_next = 1;
1115 goto insert;
1116 }
1117
1118 ret = find_next_csum_offset(root, path, &next_offset);
1119 if (ret < 0)
1120 goto out;
1121
1122 tmp = (next_offset - bytenr) >> fs_info->sectorsize_bits;
1123 if (tmp <= INT_MAX)
1124 extend_nr = min_t(int, extend_nr, tmp);
1125 }
1126
1127 diff = (csum_offset + extend_nr) * csum_size;
1128 diff = min(diff,
1129 MAX_CSUM_ITEMS(fs_info, csum_size) * csum_size);
1130
1131 diff = diff - btrfs_item_size(leaf, path->slots[0]);
1132 diff = min_t(u32, btrfs_leaf_free_space(leaf), diff);
1133 diff /= csum_size;
1134 diff *= csum_size;
1135
1136 btrfs_extend_item(path, diff);
1137 ret = 0;
1138 goto csum;
1139 }
1140
1141insert:
1142 btrfs_release_path(path);
1143 csum_offset = 0;
1144 if (found_next) {
1145 u64 tmp;
1146
1147 tmp = sums->len - total_bytes;
1148 tmp >>= fs_info->sectorsize_bits;
1149 tmp = min(tmp, (next_offset - file_key.offset) >>
1150 fs_info->sectorsize_bits);
1151
1152 tmp = max_t(u64, 1, tmp);
1153 tmp = min_t(u64, tmp, MAX_CSUM_ITEMS(fs_info, csum_size));
1154 ins_size = csum_size * tmp;
1155 } else {
1156 ins_size = csum_size;
1157 }
1158 ret = btrfs_insert_empty_item(trans, root, path, &file_key,
1159 ins_size);
1160 if (ret < 0)
1161 goto out;
1162 if (WARN_ON(ret != 0))
1163 goto out;
1164 leaf = path->nodes[0];
1165csum:
1166 item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item);
1167 item_end = (struct btrfs_csum_item *)((unsigned char *)item +
1168 btrfs_item_size(leaf, path->slots[0]));
1169 item = (struct btrfs_csum_item *)((unsigned char *)item +
1170 csum_offset * csum_size);
1171found:
1172 ins_size = (u32)(sums->len - total_bytes) >> fs_info->sectorsize_bits;
1173 ins_size *= csum_size;
1174 ins_size = min_t(u32, (unsigned long)item_end - (unsigned long)item,
1175 ins_size);
1176 write_extent_buffer(leaf, sums->sums + index, (unsigned long)item,
1177 ins_size);
1178
1179 index += ins_size;
1180 ins_size /= csum_size;
1181 total_bytes += ins_size * fs_info->sectorsize;
1182
1183 btrfs_mark_buffer_dirty(path->nodes[0]);
1184 if (total_bytes < sums->len) {
1185 btrfs_release_path(path);
1186 cond_resched();
1187 goto again;
1188 }
1189out:
1190 btrfs_free_path(path);
1191 return ret;
1192}
1193
1194void btrfs_extent_item_to_extent_map(struct btrfs_inode *inode,
1195 const struct btrfs_path *path,
1196 struct btrfs_file_extent_item *fi,
1197 const bool new_inline,
1198 struct extent_map *em)
1199{
1200 struct btrfs_fs_info *fs_info = inode->root->fs_info;
1201 struct btrfs_root *root = inode->root;
1202 struct extent_buffer *leaf = path->nodes[0];
1203 const int slot = path->slots[0];
1204 struct btrfs_key key;
1205 u64 extent_start, extent_end;
1206 u64 bytenr;
1207 u8 type = btrfs_file_extent_type(leaf, fi);
1208 int compress_type = btrfs_file_extent_compression(leaf, fi);
1209
1210 btrfs_item_key_to_cpu(leaf, &key, slot);
1211 extent_start = key.offset;
1212 extent_end = btrfs_file_extent_end(path);
1213 em->ram_bytes = btrfs_file_extent_ram_bytes(leaf, fi);
1214 if (type == BTRFS_FILE_EXTENT_REG ||
1215 type == BTRFS_FILE_EXTENT_PREALLOC) {
1216 em->start = extent_start;
1217 em->len = extent_end - extent_start;
1218 em->orig_start = extent_start -
1219 btrfs_file_extent_offset(leaf, fi);
1220 em->orig_block_len = btrfs_file_extent_disk_num_bytes(leaf, fi);
1221 bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
1222 if (bytenr == 0) {
1223 em->block_start = EXTENT_MAP_HOLE;
1224 return;
1225 }
1226 if (compress_type != BTRFS_COMPRESS_NONE) {
1227 set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
1228 em->compress_type = compress_type;
1229 em->block_start = bytenr;
1230 em->block_len = em->orig_block_len;
1231 } else {
1232 bytenr += btrfs_file_extent_offset(leaf, fi);
1233 em->block_start = bytenr;
1234 em->block_len = em->len;
1235 if (type == BTRFS_FILE_EXTENT_PREALLOC)
1236 set_bit(EXTENT_FLAG_PREALLOC, &em->flags);
1237 }
1238 } else if (type == BTRFS_FILE_EXTENT_INLINE) {
1239 em->block_start = EXTENT_MAP_INLINE;
1240 em->start = extent_start;
1241 em->len = extent_end - extent_start;
1242
1243
1244
1245
1246 em->orig_start = EXTENT_MAP_HOLE;
1247 em->block_len = (u64)-1;
1248 if (!new_inline && compress_type != BTRFS_COMPRESS_NONE) {
1249 set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
1250 em->compress_type = compress_type;
1251 }
1252 } else {
1253 btrfs_err(fs_info,
1254 "unknown file extent item type %d, inode %llu, offset %llu, "
1255 "root %llu", type, btrfs_ino(inode), extent_start,
1256 root->root_key.objectid);
1257 }
1258}
1259
1260
1261
1262
1263
1264
1265u64 btrfs_file_extent_end(const struct btrfs_path *path)
1266{
1267 const struct extent_buffer *leaf = path->nodes[0];
1268 const int slot = path->slots[0];
1269 struct btrfs_file_extent_item *fi;
1270 struct btrfs_key key;
1271 u64 end;
1272
1273 btrfs_item_key_to_cpu(leaf, &key, slot);
1274 ASSERT(key.type == BTRFS_EXTENT_DATA_KEY);
1275 fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
1276
1277 if (btrfs_file_extent_type(leaf, fi) == BTRFS_FILE_EXTENT_INLINE) {
1278 end = btrfs_file_extent_ram_bytes(leaf, fi);
1279 end = ALIGN(key.offset + end, leaf->fs_info->sectorsize);
1280 } else {
1281 end = key.offset + btrfs_file_extent_num_bytes(leaf, fi);
1282 }
1283
1284 return end;
1285}
1286