?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gpio: rcar: Fix runtime PM imbalance on error
[linux/fpc-iii.git] / fs / btrfs / file-item.c
blobb618ad5339bad7bf680e4420e02d5997ce1dc8ec
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (C) 2007 Oracle. All rights reserved.
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 "ctree.h"
13 #include "disk-io.h"
14 #include "transaction.h"
15 #include "volumes.h"
16 #include "print-tree.h"
17 #include "compression.h"
18
19 #define __MAX_CSUM_ITEMS(r, size) ((unsigned long)(((BTRFS_LEAF_DATA_SIZE(r) - \
20 sizeof(struct btrfs_item) * 2) / \
21 size) - 1))
22
23 #define MAX_CSUM_ITEMS(r, size) (min_t(u32, __MAX_CSUM_ITEMS(r, size), \
24 PAGE_SIZE))
25
26 /**
27 * @inode - the inode we want to update the disk_i_size for
28 * @new_i_size - the i_size we want to set to, 0 if we use i_size
29 *
30 * With NO_HOLES set this simply sets the disk_is_size to whatever i_size_read()
31 * returns as it is perfectly fine with a file that has holes without hole file
32 * extent items.
33 *
34 * However without NO_HOLES we need to only return the area that is contiguous
35 * from the 0 offset of the file. Otherwise we could end up adjust i_size up
36 * to an extent that has a gap in between.
37 *
38 * Finally new_i_size should only be set in the case of truncate where we're not
39 * ready to use i_size_read() as the limiter yet.
40 */
41 void btrfs_inode_safe_disk_i_size_write(struct inode *inode, u64 new_i_size)
42 {
43 struct btrfs_fs_info *fs_info = BTRFS_I(inode)->root->fs_info;
44 u64 start, end, i_size;
45 int ret;
46
47 i_size = new_i_size ?: i_size_read(inode);
48 if (btrfs_fs_incompat(fs_info, NO_HOLES)) {
49 BTRFS_I(inode)->disk_i_size = i_size;
50 return;
51 }
52
53 spin_lock(&BTRFS_I(inode)->lock);
54 ret = find_contiguous_extent_bit(&BTRFS_I(inode)->file_extent_tree, 0,
55 &start, &end, EXTENT_DIRTY);
56 if (!ret && start == 0)
57 i_size = min(i_size, end + 1);
58 else
59 i_size = 0;
60 BTRFS_I(inode)->disk_i_size = i_size;
61 spin_unlock(&BTRFS_I(inode)->lock);
62 }
63
64 /**
65 * @inode - the inode we're modifying
66 * @start - the start file offset of the file extent we've inserted
67 * @len - the logical length of the file extent item
68 *
69 * Call when we are inserting a new file extent where there was none before.
70 * Does not need to call this in the case where we're replacing an existing file
71 * extent, however if not sure it's fine to call this multiple times.
72 *
73 * The start and len must match the file extent item, so thus must be sectorsize
74 * aligned.
75 */
76 int btrfs_inode_set_file_extent_range(struct btrfs_inode *inode, u64 start,
77 u64 len)
78 {
79 if (len == 0)
80 return 0;
81
82 ASSERT(IS_ALIGNED(start + len, inode->root->fs_info->sectorsize));
83
84 if (btrfs_fs_incompat(inode->root->fs_info, NO_HOLES))
85 return 0;
86 return set_extent_bits(&inode->file_extent_tree, start, start + len - 1,
87 EXTENT_DIRTY);
88 }
89
90 /**
91 * @inode - the inode we're modifying
92 * @start - the start file offset of the file extent we've inserted
93 * @len - the logical length of the file extent item
94 *
95 * Called when we drop a file extent, for example when we truncate. Doesn't
96 * need to be called for cases where we're replacing a file extent, like when
97 * we've COWed a file extent.
98 *
99 * The start and len must match the file extent item, so thus must be sectorsize
100 * aligned.
101 */
102 int btrfs_inode_clear_file_extent_range(struct btrfs_inode *inode, u64 start,
103 u64 len)
104 {
105 if (len == 0)
106 return 0;
107
108 ASSERT(IS_ALIGNED(start + len, inode->root->fs_info->sectorsize) ||
109 len == (u64)-1);
110
111 if (btrfs_fs_incompat(inode->root->fs_info, NO_HOLES))
112 return 0;
113 return clear_extent_bit(&inode->file_extent_tree, start,
114 start + len - 1, EXTENT_DIRTY, 0, 0, NULL);
115 }
116
117 static inline u32 max_ordered_sum_bytes(struct btrfs_fs_info *fs_info,
118 u16 csum_size)
119 {
120 u32 ncsums = (PAGE_SIZE - sizeof(struct btrfs_ordered_sum)) / csum_size;
121
122 return ncsums * fs_info->sectorsize;
123 }
124
125 int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
126 struct btrfs_root *root,
127 u64 objectid, u64 pos,
128 u64 disk_offset, u64 disk_num_bytes,
129 u64 num_bytes, u64 offset, u64 ram_bytes,
130 u8 compression, u8 encryption, u16 other_encoding)
131 {
132 int ret = 0;
133 struct btrfs_file_extent_item *item;
134 struct btrfs_key file_key;
135 struct btrfs_path *path;
136 struct extent_buffer *leaf;
137
138 path = btrfs_alloc_path();
139 if (!path)
140 return -ENOMEM;
141 file_key.objectid = objectid;
142 file_key.offset = pos;
143 file_key.type = BTRFS_EXTENT_DATA_KEY;
144
145 path->leave_spinning = 1;
146 ret = btrfs_insert_empty_item(trans, root, path, &file_key,
147 sizeof(*item));
148 if (ret < 0)
149 goto out;
150 BUG_ON(ret); /* Can't happen */
151 leaf = path->nodes[0];
152 item = btrfs_item_ptr(leaf, path->slots[0],
153 struct btrfs_file_extent_item);
154 btrfs_set_file_extent_disk_bytenr(leaf, item, disk_offset);
155 btrfs_set_file_extent_disk_num_bytes(leaf, item, disk_num_bytes);
156 btrfs_set_file_extent_offset(leaf, item, offset);
157 btrfs_set_file_extent_num_bytes(leaf, item, num_bytes);
158 btrfs_set_file_extent_ram_bytes(leaf, item, ram_bytes);
159 btrfs_set_file_extent_generation(leaf, item, trans->transid);
160 btrfs_set_file_extent_type(leaf, item, BTRFS_FILE_EXTENT_REG);
161 btrfs_set_file_extent_compression(leaf, item, compression);
162 btrfs_set_file_extent_encryption(leaf, item, encryption);
163 btrfs_set_file_extent_other_encoding(leaf, item, other_encoding);
164
165 btrfs_mark_buffer_dirty(leaf);
166 out:
167 btrfs_free_path(path);
168 return ret;
169 }
170
171 static struct btrfs_csum_item *
172 btrfs_lookup_csum(struct btrfs_trans_handle *trans,
173 struct btrfs_root *root,
174 struct btrfs_path *path,
175 u64 bytenr, int cow)
176 {
177 struct btrfs_fs_info *fs_info = root->fs_info;
178 int ret;
179 struct btrfs_key file_key;
180 struct btrfs_key found_key;
181 struct btrfs_csum_item *item;
182 struct extent_buffer *leaf;
183 u64 csum_offset = 0;
184 u16 csum_size = btrfs_super_csum_size(fs_info->super_copy);
185 int csums_in_item;
186
187 file_key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
188 file_key.offset = bytenr;
189 file_key.type = BTRFS_EXTENT_CSUM_KEY;
190 ret = btrfs_search_slot(trans, root, &file_key, path, 0, cow);
191 if (ret < 0)
192 goto fail;
193 leaf = path->nodes[0];
194 if (ret > 0) {
195 ret = 1;
196 if (path->slots[0] == 0)
197 goto fail;
198 path->slots[0]--;
199 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
200 if (found_key.type != BTRFS_EXTENT_CSUM_KEY)
201 goto fail;
202
203 csum_offset = (bytenr - found_key.offset) >>
204 fs_info->sb->s_blocksize_bits;
205 csums_in_item = btrfs_item_size_nr(leaf, path->slots[0]);
206 csums_in_item /= csum_size;
207
208 if (csum_offset == csums_in_item) {
209 ret = -EFBIG;
210 goto fail;
211 } else if (csum_offset > csums_in_item) {
212 goto fail;
213 }
214 }
215 item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item);
216 item = (struct btrfs_csum_item *)((unsigned char *)item +
217 csum_offset * csum_size);
218 return item;
219 fail:
220 if (ret > 0)
221 ret = -ENOENT;
222 return ERR_PTR(ret);
223 }
224
225 int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans,
226 struct btrfs_root *root,
227 struct btrfs_path *path, u64 objectid,
228 u64 offset, int mod)
229 {
230 int ret;
231 struct btrfs_key file_key;
232 int ins_len = mod < 0 ? -1 : 0;
233 int cow = mod != 0;
234
235 file_key.objectid = objectid;
236 file_key.offset = offset;
237 file_key.type = BTRFS_EXTENT_DATA_KEY;
238 ret = btrfs_search_slot(trans, root, &file_key, path, ins_len, cow);
239 return ret;
240 }
241
242 /**
243 * btrfs_lookup_bio_sums - Look up checksums for a bio.
244 * @inode: inode that the bio is for.
245 * @bio: bio embedded in btrfs_io_bio.
246 * @offset: Unless (u64)-1, look up checksums for this offset in the file.
247 * If (u64)-1, use the page offsets from the bio instead.
248 * @dst: Buffer of size btrfs_super_csum_size() used to return checksum. If
249 * NULL, the checksum is returned in btrfs_io_bio(bio)->csum instead.
250 *
251 * Return: BLK_STS_RESOURCE if allocating memory fails, BLK_STS_OK otherwise.
252 */
253 blk_status_t btrfs_lookup_bio_sums(struct inode *inode, struct bio *bio,
254 u64 offset, u8 *dst)
255 {
256 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
257 struct bio_vec bvec;
258 struct bvec_iter iter;
259 struct btrfs_io_bio *btrfs_bio = btrfs_io_bio(bio);
260 struct btrfs_csum_item *item = NULL;
261 struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
262 struct btrfs_path *path;
263 const bool page_offsets = (offset == (u64)-1);
264 u8 *csum;
265 u64 item_start_offset = 0;
266 u64 item_last_offset = 0;
267 u64 disk_bytenr;
268 u64 page_bytes_left;
269 u32 diff;
270 int nblocks;
271 int count = 0;
272 u16 csum_size = btrfs_super_csum_size(fs_info->super_copy);
273
274 path = btrfs_alloc_path();
275 if (!path)
276 return BLK_STS_RESOURCE;
277
278 nblocks = bio->bi_iter.bi_size >> inode->i_sb->s_blocksize_bits;
279 if (!dst) {
280 if (nblocks * csum_size > BTRFS_BIO_INLINE_CSUM_SIZE) {
281 btrfs_bio->csum = kmalloc_array(nblocks, csum_size,
282 GFP_NOFS);
283 if (!btrfs_bio->csum) {
284 btrfs_free_path(path);
285 return BLK_STS_RESOURCE;
286 }
287 } else {
288 btrfs_bio->csum = btrfs_bio->csum_inline;
289 }
290 csum = btrfs_bio->csum;
291 } else {
292 csum = dst;
293 }
294
295 if (bio->bi_iter.bi_size > PAGE_SIZE * 8)
296 path->reada = READA_FORWARD;
297
298 /*
299 * the free space stuff is only read when it hasn't been
300 * updated in the current transaction. So, we can safely
301 * read from the commit root and sidestep a nasty deadlock
302 * between reading the free space cache and updating the csum tree.
303 */
304 if (btrfs_is_free_space_inode(BTRFS_I(inode))) {
305 path->search_commit_root = 1;
306 path->skip_locking = 1;
307 }
308
309 disk_bytenr = (u64)bio->bi_iter.bi_sector << 9;
310
311 bio_for_each_segment(bvec, bio, iter) {
312 page_bytes_left = bvec.bv_len;
313 if (count)
314 goto next;
315
316 if (page_offsets)
317 offset = page_offset(bvec.bv_page) + bvec.bv_offset;
318 count = btrfs_find_ordered_sum(inode, offset, disk_bytenr,
319 csum, nblocks);
320 if (count)
321 goto found;
322
323 if (!item || disk_bytenr < item_start_offset ||
324 disk_bytenr >= item_last_offset) {
325 struct btrfs_key found_key;
326 u32 item_size;
327
328 if (item)
329 btrfs_release_path(path);
330 item = btrfs_lookup_csum(NULL, fs_info->csum_root,
331 path, disk_bytenr, 0);
332 if (IS_ERR(item)) {
333 count = 1;
334 memset(csum, 0, csum_size);
335 if (BTRFS_I(inode)->root->root_key.objectid ==
336 BTRFS_DATA_RELOC_TREE_OBJECTID) {
337 set_extent_bits(io_tree, offset,
338 offset + fs_info->sectorsize - 1,
339 EXTENT_NODATASUM);
340 } else {
341 btrfs_info_rl(fs_info,
342 "no csum found for inode %llu start %llu",
343 btrfs_ino(BTRFS_I(inode)), offset);
344 }
345 item = NULL;
346 btrfs_release_path(path);
347 goto found;
348 }
349 btrfs_item_key_to_cpu(path->nodes[0], &found_key,
350 path->slots[0]);
351
352 item_start_offset = found_key.offset;
353 item_size = btrfs_item_size_nr(path->nodes[0],
354 path->slots[0]);
355 item_last_offset = item_start_offset +
356 (item_size / csum_size) *
357 fs_info->sectorsize;
358 item = btrfs_item_ptr(path->nodes[0], path->slots[0],
359 struct btrfs_csum_item);
360 }
361 /*
362 * this byte range must be able to fit inside
363 * a single leaf so it will also fit inside a u32
364 */
365 diff = disk_bytenr - item_start_offset;
366 diff = diff / fs_info->sectorsize;
367 diff = diff * csum_size;
368 count = min_t(int, nblocks, (item_last_offset - disk_bytenr) >>
369 inode->i_sb->s_blocksize_bits);
370 read_extent_buffer(path->nodes[0], csum,
371 ((unsigned long)item) + diff,
372 csum_size * count);
373 found:
374 csum += count * csum_size;
375 nblocks -= count;
376 next:
377 while (count > 0) {
378 count--;
379 disk_bytenr += fs_info->sectorsize;
380 offset += fs_info->sectorsize;
381 page_bytes_left -= fs_info->sectorsize;
382 if (!page_bytes_left)
383 break; /* move to next bio */
384 }
385 }
386
387 WARN_ON_ONCE(count);
388 btrfs_free_path(path);
389 return BLK_STS_OK;
390 }
391
392 int btrfs_lookup_csums_range(struct btrfs_root *root, u64 start, u64 end,
393 struct list_head *list, int search_commit)
394 {
395 struct btrfs_fs_info *fs_info = root->fs_info;
396 struct btrfs_key key;
397 struct btrfs_path *path;
398 struct extent_buffer *leaf;
399 struct btrfs_ordered_sum *sums;
400 struct btrfs_csum_item *item;
401 LIST_HEAD(tmplist);
402 unsigned long offset;
403 int ret;
404 size_t size;
405 u64 csum_end;
406 u16 csum_size = btrfs_super_csum_size(fs_info->super_copy);
407
408 ASSERT(IS_ALIGNED(start, fs_info->sectorsize) &&
409 IS_ALIGNED(end + 1, fs_info->sectorsize));
410
411 path = btrfs_alloc_path();
412 if (!path)
413 return -ENOMEM;
414
415 if (search_commit) {
416 path->skip_locking = 1;
417 path->reada = READA_FORWARD;
418 path->search_commit_root = 1;
419 }
420
421 key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
422 key.offset = start;
423 key.type = BTRFS_EXTENT_CSUM_KEY;
424
425 ret = btrfs_search_slot(NULL, root, &key, path, 0, 0);
426 if (ret < 0)
427 goto fail;
428 if (ret > 0 && path->slots[0] > 0) {
429 leaf = path->nodes[0];
430 btrfs_item_key_to_cpu(leaf, &key, path->slots[0] - 1);
431 if (key.objectid == BTRFS_EXTENT_CSUM_OBJECTID &&
432 key.type == BTRFS_EXTENT_CSUM_KEY) {
433 offset = (start - key.offset) >>
434 fs_info->sb->s_blocksize_bits;
435 if (offset * csum_size <
436 btrfs_item_size_nr(leaf, path->slots[0] - 1))
437 path->slots[0]--;
438 }
439 }
440
441 while (start <= end) {
442 leaf = path->nodes[0];
443 if (path->slots[0] >= btrfs_header_nritems(leaf)) {
444 ret = btrfs_next_leaf(root, path);
445 if (ret < 0)
446 goto fail;
447 if (ret > 0)
448 break;
449 leaf = path->nodes[0];
450 }
451
452 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
453 if (key.objectid != BTRFS_EXTENT_CSUM_OBJECTID ||
454 key.type != BTRFS_EXTENT_CSUM_KEY ||
455 key.offset > end)
456 break;
457
458 if (key.offset > start)
459 start = key.offset;
460
461 size = btrfs_item_size_nr(leaf, path->slots[0]);
462 csum_end = key.offset + (size / csum_size) * fs_info->sectorsize;
463 if (csum_end <= start) {
464 path->slots[0]++;
465 continue;
466 }
467
468 csum_end = min(csum_end, end + 1);
469 item = btrfs_item_ptr(path->nodes[0], path->slots[0],
470 struct btrfs_csum_item);
471 while (start < csum_end) {
472 size = min_t(size_t, csum_end - start,
473 max_ordered_sum_bytes(fs_info, csum_size));
474 sums = kzalloc(btrfs_ordered_sum_size(fs_info, size),
475 GFP_NOFS);
476 if (!sums) {
477 ret = -ENOMEM;
478 goto fail;
479 }
480
481 sums->bytenr = start;
482 sums->len = (int)size;
483
484 offset = (start - key.offset) >>
485 fs_info->sb->s_blocksize_bits;
486 offset *= csum_size;
487 size >>= fs_info->sb->s_blocksize_bits;
488
489 read_extent_buffer(path->nodes[0],
490 sums->sums,
491 ((unsigned long)item) + offset,
492 csum_size * size);
493
494 start += fs_info->sectorsize * size;
495 list_add_tail(&sums->list, &tmplist);
496 }
497 path->slots[0]++;
498 }
499 ret = 0;
500 fail:
501 while (ret < 0 && !list_empty(&tmplist)) {
502 sums = list_entry(tmplist.next, struct btrfs_ordered_sum, list);
503 list_del(&sums->list);
504 kfree(sums);
505 }
506 list_splice_tail(&tmplist, list);
507
508 btrfs_free_path(path);
509 return ret;
510 }
511
512 /*
513 * btrfs_csum_one_bio - Calculates checksums of the data contained inside a bio
514 * @inode: Owner of the data inside the bio
515 * @bio: Contains the data to be checksummed
516 * @file_start: offset in file this bio begins to describe
517 * @contig: Boolean. If true/1 means all bio vecs in this bio are
518 * contiguous and they begin at @file_start in the file. False/0
519 * means this bio can contains potentially discontigous bio vecs
520 * so the logical offset of each should be calculated separately.
521 */
522 blk_status_t btrfs_csum_one_bio(struct inode *inode, struct bio *bio,
523 u64 file_start, int contig)
524 {
525 struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
526 SHASH_DESC_ON_STACK(shash, fs_info->csum_shash);
527 struct btrfs_ordered_sum *sums;
528 struct btrfs_ordered_extent *ordered = NULL;
529 char *data;
530 struct bvec_iter iter;
531 struct bio_vec bvec;
532 int index;
533 int nr_sectors;
534 unsigned long total_bytes = 0;
535 unsigned long this_sum_bytes = 0;
536 int i;
537 u64 offset;
538 unsigned nofs_flag;
539 const u16 csum_size = btrfs_super_csum_size(fs_info->super_copy);
540
541 nofs_flag = memalloc_nofs_save();
542 sums = kvzalloc(btrfs_ordered_sum_size(fs_info, bio->bi_iter.bi_size),
543 GFP_KERNEL);
544 memalloc_nofs_restore(nofs_flag);
545
546 if (!sums)
547 return BLK_STS_RESOURCE;
548
549 sums->len = bio->bi_iter.bi_size;
550 INIT_LIST_HEAD(&sums->list);
551
552 if (contig)
553 offset = file_start;
554 else
555 offset = 0; /* shut up gcc */
556
557 sums->bytenr = (u64)bio->bi_iter.bi_sector << 9;
558 index = 0;
559
560 shash->tfm = fs_info->csum_shash;
561
562 bio_for_each_segment(bvec, bio, iter) {
563 if (!contig)
564 offset = page_offset(bvec.bv_page) + bvec.bv_offset;
565
566 if (!ordered) {
567 ordered = btrfs_lookup_ordered_extent(inode, offset);
568 BUG_ON(!ordered); /* Logic error */
569 }
570
571 nr_sectors = BTRFS_BYTES_TO_BLKS(fs_info,
572 bvec.bv_len + fs_info->sectorsize
573 - 1);
574
575 for (i = 0; i < nr_sectors; i++) {
576 if (offset >= ordered->file_offset + ordered->num_bytes ||
577 offset < ordered->file_offset) {
578 unsigned long bytes_left;
579
580 sums->len = this_sum_bytes;
581 this_sum_bytes = 0;
582 btrfs_add_ordered_sum(ordered, sums);
583 btrfs_put_ordered_extent(ordered);
584
585 bytes_left = bio->bi_iter.bi_size - total_bytes;
586
587 nofs_flag = memalloc_nofs_save();
588 sums = kvzalloc(btrfs_ordered_sum_size(fs_info,
589 bytes_left), GFP_KERNEL);
590 memalloc_nofs_restore(nofs_flag);
591 BUG_ON(!sums); /* -ENOMEM */
592 sums->len = bytes_left;
593 ordered = btrfs_lookup_ordered_extent(inode,
594 offset);
595 ASSERT(ordered); /* Logic error */
596 sums->bytenr = ((u64)bio->bi_iter.bi_sector << 9)
597 + total_bytes;
598 index = 0;
599 }
600
601 crypto_shash_init(shash);
602 data = kmap_atomic(bvec.bv_page);
603 crypto_shash_update(shash, data + bvec.bv_offset
604 + (i * fs_info->sectorsize),
605 fs_info->sectorsize);
606 kunmap_atomic(data);
607 crypto_shash_final(shash, (char *)(sums->sums + index));
608 index += csum_size;
609 offset += fs_info->sectorsize;
610 this_sum_bytes += fs_info->sectorsize;
611 total_bytes += fs_info->sectorsize;
612 }
613
614 }
615 this_sum_bytes = 0;
616 btrfs_add_ordered_sum(ordered, sums);
617 btrfs_put_ordered_extent(ordered);
618 return 0;
619 }
620
621 /*
622 * helper function for csum removal, this expects the
623 * key to describe the csum pointed to by the path, and it expects
624 * the csum to overlap the range [bytenr, len]
625 *
626 * The csum should not be entirely contained in the range and the
627 * range should not be entirely contained in the csum.
628 *
629 * This calls btrfs_truncate_item with the correct args based on the
630 * overlap, and fixes up the key as required.
631 */
632 static noinline void truncate_one_csum(struct btrfs_fs_info *fs_info,
633 struct btrfs_path *path,
634 struct btrfs_key *key,
635 u64 bytenr, u64 len)
636 {
637 struct extent_buffer *leaf;
638 u16 csum_size = btrfs_super_csum_size(fs_info->super_copy);
639 u64 csum_end;
640 u64 end_byte = bytenr + len;
641 u32 blocksize_bits = fs_info->sb->s_blocksize_bits;
642
643 leaf = path->nodes[0];
644 csum_end = btrfs_item_size_nr(leaf, path->slots[0]) / csum_size;
645 csum_end <<= fs_info->sb->s_blocksize_bits;
646 csum_end += key->offset;
647
648 if (key->offset < bytenr && csum_end <= end_byte) {
649 /*
650 * [ bytenr - len ]
651 * [ ]
652 * [csum ]
653 * A simple truncate off the end of the item
654 */
655 u32 new_size = (bytenr - key->offset) >> blocksize_bits;
656 new_size *= csum_size;
657 btrfs_truncate_item(path, new_size, 1);
658 } else if (key->offset >= bytenr && csum_end > end_byte &&
659 end_byte > key->offset) {
660 /*
661 * [ bytenr - len ]
662 * [ ]
663 * [csum ]
664 * we need to truncate from the beginning of the csum
665 */
666 u32 new_size = (csum_end - end_byte) >> blocksize_bits;
667 new_size *= csum_size;
668
669 btrfs_truncate_item(path, new_size, 0);
670
671 key->offset = end_byte;
672 btrfs_set_item_key_safe(fs_info, path, key);
673 } else {
674 BUG();
675 }
676 }
677
678 /*
679 * deletes the csum items from the csum tree for a given
680 * range of bytes.
681 */
682 int btrfs_del_csums(struct btrfs_trans_handle *trans,
683 struct btrfs_root *root, u64 bytenr, u64 len)
684 {
685 struct btrfs_fs_info *fs_info = trans->fs_info;
686 struct btrfs_path *path;
687 struct btrfs_key key;
688 u64 end_byte = bytenr + len;
689 u64 csum_end;
690 struct extent_buffer *leaf;
691 int ret;
692 u16 csum_size = btrfs_super_csum_size(fs_info->super_copy);
693 int blocksize_bits = fs_info->sb->s_blocksize_bits;
694
695 ASSERT(root == fs_info->csum_root ||
696 root->root_key.objectid == BTRFS_TREE_LOG_OBJECTID);
697
698 path = btrfs_alloc_path();
699 if (!path)
700 return -ENOMEM;
701
702 while (1) {
703 key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
704 key.offset = end_byte - 1;
705 key.type = BTRFS_EXTENT_CSUM_KEY;
706
707 path->leave_spinning = 1;
708 ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
709 if (ret > 0) {
710 if (path->slots[0] == 0)
711 break;
712 path->slots[0]--;
713 } else if (ret < 0) {
714 break;
715 }
716
717 leaf = path->nodes[0];
718 btrfs_item_key_to_cpu(leaf, &key, path->slots[0]);
719
720 if (key.objectid != BTRFS_EXTENT_CSUM_OBJECTID ||
721 key.type != BTRFS_EXTENT_CSUM_KEY) {
722 break;
723 }
724
725 if (key.offset >= end_byte)
726 break;
727
728 csum_end = btrfs_item_size_nr(leaf, path->slots[0]) / csum_size;
729 csum_end <<= blocksize_bits;
730 csum_end += key.offset;
731
732 /* this csum ends before we start, we're done */
733 if (csum_end <= bytenr)
734 break;
735
736 /* delete the entire item, it is inside our range */
737 if (key.offset >= bytenr && csum_end <= end_byte) {
738 int del_nr = 1;
739
740 /*
741 * Check how many csum items preceding this one in this
742 * leaf correspond to our range and then delete them all
743 * at once.
744 */
745 if (key.offset > bytenr && path->slots[0] > 0) {
746 int slot = path->slots[0] - 1;
747
748 while (slot >= 0) {
749 struct btrfs_key pk;
750
751 btrfs_item_key_to_cpu(leaf, &pk, slot);
752 if (pk.offset < bytenr ||
753 pk.type != BTRFS_EXTENT_CSUM_KEY ||
754 pk.objectid !=
755 BTRFS_EXTENT_CSUM_OBJECTID)
756 break;
757 path->slots[0] = slot;
758 del_nr++;
759 key.offset = pk.offset;
760 slot--;
761 }
762 }
763 ret = btrfs_del_items(trans, root, path,
764 path->slots[0], del_nr);
765 if (ret)
766 goto out;
767 if (key.offset == bytenr)
768 break;
769 } else if (key.offset < bytenr && csum_end > end_byte) {
770 unsigned long offset;
771 unsigned long shift_len;
772 unsigned long item_offset;
773 /*
774 * [ bytenr - len ]
775 * [csum ]
776 *
777 * Our bytes are in the middle of the csum,
778 * we need to split this item and insert a new one.
779 *
780 * But we can't drop the path because the
781 * csum could change, get removed, extended etc.
782 *
783 * The trick here is the max size of a csum item leaves
784 * enough room in the tree block for a single
785 * item header. So, we split the item in place,
786 * adding a new header pointing to the existing
787 * bytes. Then we loop around again and we have
788 * a nicely formed csum item that we can neatly
789 * truncate.
790 */
791 offset = (bytenr - key.offset) >> blocksize_bits;
792 offset *= csum_size;
793
794 shift_len = (len >> blocksize_bits) * csum_size;
795
796 item_offset = btrfs_item_ptr_offset(leaf,
797 path->slots[0]);
798
799 memzero_extent_buffer(leaf, item_offset + offset,
800 shift_len);
801 key.offset = bytenr;
802
803 /*
804 * btrfs_split_item returns -EAGAIN when the
805 * item changed size or key
806 */
807 ret = btrfs_split_item(trans, root, path, &key, offset);
808 if (ret && ret != -EAGAIN) {
809 btrfs_abort_transaction(trans, ret);
810 goto out;
811 }
812
813 key.offset = end_byte - 1;
814 } else {
815 truncate_one_csum(fs_info, path, &key, bytenr, len);
816 if (key.offset < bytenr)
817 break;
818 }
819 btrfs_release_path(path);
820 }
821 ret = 0;
822 out:
823 btrfs_free_path(path);
824 return ret;
825 }
826
827 int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,
828 struct btrfs_root *root,
829 struct btrfs_ordered_sum *sums)
830 {
831 struct btrfs_fs_info *fs_info = root->fs_info;
832 struct btrfs_key file_key;
833 struct btrfs_key found_key;
834 struct btrfs_path *path;
835 struct btrfs_csum_item *item;
836 struct btrfs_csum_item *item_end;
837 struct extent_buffer *leaf = NULL;
838 u64 next_offset;
839 u64 total_bytes = 0;
840 u64 csum_offset;
841 u64 bytenr;
842 u32 nritems;
843 u32 ins_size;
844 int index = 0;
845 int found_next;
846 int ret;
847 u16 csum_size = btrfs_super_csum_size(fs_info->super_copy);
848
849 path = btrfs_alloc_path();
850 if (!path)
851 return -ENOMEM;
852 again:
853 next_offset = (u64)-1;
854 found_next = 0;
855 bytenr = sums->bytenr + total_bytes;
856 file_key.objectid = BTRFS_EXTENT_CSUM_OBJECTID;
857 file_key.offset = bytenr;
858 file_key.type = BTRFS_EXTENT_CSUM_KEY;
859
860 item = btrfs_lookup_csum(trans, root, path, bytenr, 1);
861 if (!IS_ERR(item)) {
862 ret = 0;
863 leaf = path->nodes[0];
864 item_end = btrfs_item_ptr(leaf, path->slots[0],
865 struct btrfs_csum_item);
866 item_end = (struct btrfs_csum_item *)((char *)item_end +
867 btrfs_item_size_nr(leaf, path->slots[0]));
868 goto found;
869 }
870 ret = PTR_ERR(item);
871 if (ret != -EFBIG && ret != -ENOENT)
872 goto fail_unlock;
873
874 if (ret == -EFBIG) {
875 u32 item_size;
876 /* we found one, but it isn't big enough yet */
877 leaf = path->nodes[0];
878 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
879 if ((item_size / csum_size) >=
880 MAX_CSUM_ITEMS(fs_info, csum_size)) {
881 /* already at max size, make a new one */
882 goto insert;
883 }
884 } else {
885 int slot = path->slots[0] + 1;
886 /* we didn't find a csum item, insert one */
887 nritems = btrfs_header_nritems(path->nodes[0]);
888 if (!nritems || (path->slots[0] >= nritems - 1)) {
889 ret = btrfs_next_leaf(root, path);
890 if (ret == 1)
891 found_next = 1;
892 if (ret != 0)
893 goto insert;
894 slot = path->slots[0];
895 }
896 btrfs_item_key_to_cpu(path->nodes[0], &found_key, slot);
897 if (found_key.objectid != BTRFS_EXTENT_CSUM_OBJECTID ||
898 found_key.type != BTRFS_EXTENT_CSUM_KEY) {
899 found_next = 1;
900 goto insert;
901 }
902 next_offset = found_key.offset;
903 found_next = 1;
904 goto insert;
905 }
906
907 /*
908 * at this point, we know the tree has an item, but it isn't big
909 * enough yet to put our csum in. Grow it
910 */
911 btrfs_release_path(path);
912 ret = btrfs_search_slot(trans, root, &file_key, path,
913 csum_size, 1);
914 if (ret < 0)
915 goto fail_unlock;
916
917 if (ret > 0) {
918 if (path->slots[0] == 0)
919 goto insert;
920 path->slots[0]--;
921 }
922
923 leaf = path->nodes[0];
924 btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
925 csum_offset = (bytenr - found_key.offset) >>
926 fs_info->sb->s_blocksize_bits;
927
928 if (found_key.type != BTRFS_EXTENT_CSUM_KEY ||
929 found_key.objectid != BTRFS_EXTENT_CSUM_OBJECTID ||
930 csum_offset >= MAX_CSUM_ITEMS(fs_info, csum_size)) {
931 goto insert;
932 }
933
934 if (csum_offset == btrfs_item_size_nr(leaf, path->slots[0]) /
935 csum_size) {
936 int extend_nr;
937 u64 tmp;
938 u32 diff;
939 u32 free_space;
940
941 if (btrfs_leaf_free_space(leaf) <
942 sizeof(struct btrfs_item) + csum_size * 2)
943 goto insert;
944
945 free_space = btrfs_leaf_free_space(leaf) -
946 sizeof(struct btrfs_item) - csum_size;
947 tmp = sums->len - total_bytes;
948 tmp >>= fs_info->sb->s_blocksize_bits;
949 WARN_ON(tmp < 1);
950
951 extend_nr = max_t(int, 1, (int)tmp);
952 diff = (csum_offset + extend_nr) * csum_size;
953 diff = min(diff,
954 MAX_CSUM_ITEMS(fs_info, csum_size) * csum_size);
955
956 diff = diff - btrfs_item_size_nr(leaf, path->slots[0]);
957 diff = min(free_space, diff);
958 diff /= csum_size;
959 diff *= csum_size;
960
961 btrfs_extend_item(path, diff);
962 ret = 0;
963 goto csum;
964 }
965
966 insert:
967 btrfs_release_path(path);
968 csum_offset = 0;
969 if (found_next) {
970 u64 tmp;
971
972 tmp = sums->len - total_bytes;
973 tmp >>= fs_info->sb->s_blocksize_bits;
974 tmp = min(tmp, (next_offset - file_key.offset) >>
975 fs_info->sb->s_blocksize_bits);
976
977 tmp = max_t(u64, 1, tmp);
978 tmp = min_t(u64, tmp, MAX_CSUM_ITEMS(fs_info, csum_size));
979 ins_size = csum_size * tmp;
980 } else {
981 ins_size = csum_size;
982 }
983 path->leave_spinning = 1;
984 ret = btrfs_insert_empty_item(trans, root, path, &file_key,
985 ins_size);
986 path->leave_spinning = 0;
987 if (ret < 0)
988 goto fail_unlock;
989 if (WARN_ON(ret != 0))
990 goto fail_unlock;
991 leaf = path->nodes[0];
992 csum:
993 item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item);
994 item_end = (struct btrfs_csum_item *)((unsigned char *)item +
995 btrfs_item_size_nr(leaf, path->slots[0]));
996 item = (struct btrfs_csum_item *)((unsigned char *)item +
997 csum_offset * csum_size);
998 found:
999 ins_size = (u32)(sums->len - total_bytes) >>
1000 fs_info->sb->s_blocksize_bits;
1001 ins_size *= csum_size;
1002 ins_size = min_t(u32, (unsigned long)item_end - (unsigned long)item,
1003 ins_size);
1004 write_extent_buffer(leaf, sums->sums + index, (unsigned long)item,
1005 ins_size);
1006
1007 index += ins_size;
1008 ins_size /= csum_size;
1009 total_bytes += ins_size * fs_info->sectorsize;
1010
1011 btrfs_mark_buffer_dirty(path->nodes[0]);
1012 if (total_bytes < sums->len) {
1013 btrfs_release_path(path);
1014 cond_resched();
1015 goto again;
1016 }
1017 out:
1018 btrfs_free_path(path);
1019 return ret;
1020
1021 fail_unlock:
1022 goto out;
1023 }
1024
1025 void btrfs_extent_item_to_extent_map(struct btrfs_inode *inode,
1026 const struct btrfs_path *path,
1027 struct btrfs_file_extent_item *fi,
1028 const bool new_inline,
1029 struct extent_map *em)
1030 {
1031 struct btrfs_fs_info *fs_info = inode->root->fs_info;
1032 struct btrfs_root *root = inode->root;
1033 struct extent_buffer *leaf = path->nodes[0];
1034 const int slot = path->slots[0];
1035 struct btrfs_key key;
1036 u64 extent_start, extent_end;
1037 u64 bytenr;
1038 u8 type = btrfs_file_extent_type(leaf, fi);
1039 int compress_type = btrfs_file_extent_compression(leaf, fi);
1040
1041 btrfs_item_key_to_cpu(leaf, &key, slot);
1042 extent_start = key.offset;
1043 extent_end = btrfs_file_extent_end(path);
1044 em->ram_bytes = btrfs_file_extent_ram_bytes(leaf, fi);
1045 if (type == BTRFS_FILE_EXTENT_REG ||
1046 type == BTRFS_FILE_EXTENT_PREALLOC) {
1047 em->start = extent_start;
1048 em->len = extent_end - extent_start;
1049 em->orig_start = extent_start -
1050 btrfs_file_extent_offset(leaf, fi);
1051 em->orig_block_len = btrfs_file_extent_disk_num_bytes(leaf, fi);
1052 bytenr = btrfs_file_extent_disk_bytenr(leaf, fi);
1053 if (bytenr == 0) {
1054 em->block_start = EXTENT_MAP_HOLE;
1055 return;
1056 }
1057 if (compress_type != BTRFS_COMPRESS_NONE) {
1058 set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
1059 em->compress_type = compress_type;
1060 em->block_start = bytenr;
1061 em->block_len = em->orig_block_len;
1062 } else {
1063 bytenr += btrfs_file_extent_offset(leaf, fi);
1064 em->block_start = bytenr;
1065 em->block_len = em->len;
1066 if (type == BTRFS_FILE_EXTENT_PREALLOC)
1067 set_bit(EXTENT_FLAG_PREALLOC, &em->flags);
1068 }
1069 } else if (type == BTRFS_FILE_EXTENT_INLINE) {
1070 em->block_start = EXTENT_MAP_INLINE;
1071 em->start = extent_start;
1072 em->len = extent_end - extent_start;
1073 /*
1074 * Initialize orig_start and block_len with the same values
1075 * as in inode.c:btrfs_get_extent().
1076 */
1077 em->orig_start = EXTENT_MAP_HOLE;
1078 em->block_len = (u64)-1;
1079 if (!new_inline && compress_type != BTRFS_COMPRESS_NONE) {
1080 set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
1081 em->compress_type = compress_type;
1082 }
1083 } else {
1084 btrfs_err(fs_info,
1085 "unknown file extent item type %d, inode %llu, offset %llu, "
1086 "root %llu", type, btrfs_ino(inode), extent_start,
1087 root->root_key.objectid);
1088 }
1089 }
1090
1091 /*
1092 * Returns the end offset (non inclusive) of the file extent item the given path
1093 * points to. If it points to an inline extent, the returned offset is rounded
1094 * up to the sector size.
1095 */
1096 u64 btrfs_file_extent_end(const struct btrfs_path *path)
1097 {
1098 const struct extent_buffer *leaf = path->nodes[0];
1099 const int slot = path->slots[0];
1100 struct btrfs_file_extent_item *fi;
1101 struct btrfs_key key;
1102 u64 end;
1103
1104 btrfs_item_key_to_cpu(leaf, &key, slot);
1105 ASSERT(key.type == BTRFS_EXTENT_DATA_KEY);
1106 fi = btrfs_item_ptr(leaf, slot, struct btrfs_file_extent_item);
1107
1108 if (btrfs_file_extent_type(leaf, fi) == BTRFS_FILE_EXTENT_INLINE) {
1109 end = btrfs_file_extent_ram_bytes(leaf, fi);
1110 end = ALIGN(key.offset + end, leaf->fs_info->sectorsize);
1111 } else {
1112 end = key.offset + btrfs_file_extent_num_bytes(leaf, fi);
1113 }
1114
1115 return end;
1116 }
Linux with added FPC-III support