1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * Copyright (C) 2007 Oracle. All rights reserved. |
4 | */ |
5 | |
6 | #include "ctree.h" |
7 | #include "fs.h" |
8 | #include "messages.h" |
9 | #include "inode-item.h" |
10 | #include "disk-io.h" |
11 | #include "transaction.h" |
12 | #include "print-tree.h" |
13 | #include "space-info.h" |
14 | #include "accessors.h" |
15 | #include "extent-tree.h" |
16 | #include "file-item.h" |
17 | |
18 | struct btrfs_inode_ref *btrfs_find_name_in_backref(struct extent_buffer *leaf, |
19 | int slot, |
20 | const struct fscrypt_str *name) |
21 | { |
22 | struct btrfs_inode_ref *ref; |
23 | unsigned long ptr; |
24 | unsigned long name_ptr; |
25 | u32 item_size; |
26 | u32 cur_offset = 0; |
27 | int len; |
28 | |
29 | item_size = btrfs_item_size(eb: leaf, slot); |
30 | ptr = btrfs_item_ptr_offset(leaf, slot); |
31 | while (cur_offset < item_size) { |
32 | ref = (struct btrfs_inode_ref *)(ptr + cur_offset); |
33 | len = btrfs_inode_ref_name_len(eb: leaf, s: ref); |
34 | name_ptr = (unsigned long)(ref + 1); |
35 | cur_offset += len + sizeof(*ref); |
36 | if (len != name->len) |
37 | continue; |
38 | if (memcmp_extent_buffer(eb: leaf, ptrv: name->name, start: name_ptr, |
39 | len: name->len) == 0) |
40 | return ref; |
41 | } |
42 | return NULL; |
43 | } |
44 | |
45 | struct btrfs_inode_extref *btrfs_find_name_in_ext_backref( |
46 | struct extent_buffer *leaf, int slot, u64 ref_objectid, |
47 | const struct fscrypt_str *name) |
48 | { |
49 | struct btrfs_inode_extref *extref; |
50 | unsigned long ptr; |
51 | unsigned long name_ptr; |
52 | u32 item_size; |
53 | u32 cur_offset = 0; |
54 | int ref_name_len; |
55 | |
56 | item_size = btrfs_item_size(eb: leaf, slot); |
57 | ptr = btrfs_item_ptr_offset(leaf, slot); |
58 | |
59 | /* |
60 | * Search all extended backrefs in this item. We're only |
61 | * looking through any collisions so most of the time this is |
62 | * just going to compare against one buffer. If all is well, |
63 | * we'll return success and the inode ref object. |
64 | */ |
65 | while (cur_offset < item_size) { |
66 | extref = (struct btrfs_inode_extref *) (ptr + cur_offset); |
67 | name_ptr = (unsigned long)(&extref->name); |
68 | ref_name_len = btrfs_inode_extref_name_len(eb: leaf, s: extref); |
69 | |
70 | if (ref_name_len == name->len && |
71 | btrfs_inode_extref_parent(eb: leaf, s: extref) == ref_objectid && |
72 | (memcmp_extent_buffer(eb: leaf, ptrv: name->name, start: name_ptr, |
73 | len: name->len) == 0)) |
74 | return extref; |
75 | |
76 | cur_offset += ref_name_len + sizeof(*extref); |
77 | } |
78 | return NULL; |
79 | } |
80 | |
81 | /* Returns NULL if no extref found */ |
82 | struct btrfs_inode_extref * |
83 | btrfs_lookup_inode_extref(struct btrfs_trans_handle *trans, |
84 | struct btrfs_root *root, |
85 | struct btrfs_path *path, |
86 | const struct fscrypt_str *name, |
87 | u64 inode_objectid, u64 ref_objectid, int ins_len, |
88 | int cow) |
89 | { |
90 | int ret; |
91 | struct btrfs_key key; |
92 | |
93 | key.objectid = inode_objectid; |
94 | key.type = BTRFS_INODE_EXTREF_KEY; |
95 | key.offset = btrfs_extref_hash(parent_objectid: ref_objectid, name: name->name, len: name->len); |
96 | |
97 | ret = btrfs_search_slot(trans, root, key: &key, p: path, ins_len, cow); |
98 | if (ret < 0) |
99 | return ERR_PTR(error: ret); |
100 | if (ret > 0) |
101 | return NULL; |
102 | return btrfs_find_name_in_ext_backref(leaf: path->nodes[0], slot: path->slots[0], |
103 | ref_objectid, name); |
104 | |
105 | } |
106 | |
107 | static int btrfs_del_inode_extref(struct btrfs_trans_handle *trans, |
108 | struct btrfs_root *root, |
109 | const struct fscrypt_str *name, |
110 | u64 inode_objectid, u64 ref_objectid, |
111 | u64 *index) |
112 | { |
113 | struct btrfs_path *path; |
114 | struct btrfs_key key; |
115 | struct btrfs_inode_extref *extref; |
116 | struct extent_buffer *leaf; |
117 | int ret; |
118 | int del_len = name->len + sizeof(*extref); |
119 | unsigned long ptr; |
120 | unsigned long item_start; |
121 | u32 item_size; |
122 | |
123 | key.objectid = inode_objectid; |
124 | key.type = BTRFS_INODE_EXTREF_KEY; |
125 | key.offset = btrfs_extref_hash(parent_objectid: ref_objectid, name: name->name, len: name->len); |
126 | |
127 | path = btrfs_alloc_path(); |
128 | if (!path) |
129 | return -ENOMEM; |
130 | |
131 | ret = btrfs_search_slot(trans, root, key: &key, p: path, ins_len: -1, cow: 1); |
132 | if (ret > 0) |
133 | ret = -ENOENT; |
134 | if (ret < 0) |
135 | goto out; |
136 | |
137 | /* |
138 | * Sanity check - did we find the right item for this name? |
139 | * This should always succeed so error here will make the FS |
140 | * readonly. |
141 | */ |
142 | extref = btrfs_find_name_in_ext_backref(leaf: path->nodes[0], slot: path->slots[0], |
143 | ref_objectid, name); |
144 | if (!extref) { |
145 | btrfs_handle_fs_error(root->fs_info, -ENOENT, NULL); |
146 | ret = -EROFS; |
147 | goto out; |
148 | } |
149 | |
150 | leaf = path->nodes[0]; |
151 | item_size = btrfs_item_size(eb: leaf, slot: path->slots[0]); |
152 | if (index) |
153 | *index = btrfs_inode_extref_index(eb: leaf, s: extref); |
154 | |
155 | if (del_len == item_size) { |
156 | /* |
157 | * Common case only one ref in the item, remove the |
158 | * whole item. |
159 | */ |
160 | ret = btrfs_del_item(trans, root, path); |
161 | goto out; |
162 | } |
163 | |
164 | ptr = (unsigned long)extref; |
165 | item_start = btrfs_item_ptr_offset(leaf, path->slots[0]); |
166 | |
167 | memmove_extent_buffer(dst: leaf, dst_offset: ptr, src_offset: ptr + del_len, |
168 | len: item_size - (ptr + del_len - item_start)); |
169 | |
170 | btrfs_truncate_item(trans, path, new_size: item_size - del_len, from_end: 1); |
171 | |
172 | out: |
173 | btrfs_free_path(p: path); |
174 | |
175 | return ret; |
176 | } |
177 | |
178 | int btrfs_del_inode_ref(struct btrfs_trans_handle *trans, |
179 | struct btrfs_root *root, const struct fscrypt_str *name, |
180 | u64 inode_objectid, u64 ref_objectid, u64 *index) |
181 | { |
182 | struct btrfs_path *path; |
183 | struct btrfs_key key; |
184 | struct btrfs_inode_ref *ref; |
185 | struct extent_buffer *leaf; |
186 | unsigned long ptr; |
187 | unsigned long item_start; |
188 | u32 item_size; |
189 | u32 sub_item_len; |
190 | int ret; |
191 | int search_ext_refs = 0; |
192 | int del_len = name->len + sizeof(*ref); |
193 | |
194 | key.objectid = inode_objectid; |
195 | key.offset = ref_objectid; |
196 | key.type = BTRFS_INODE_REF_KEY; |
197 | |
198 | path = btrfs_alloc_path(); |
199 | if (!path) |
200 | return -ENOMEM; |
201 | |
202 | ret = btrfs_search_slot(trans, root, key: &key, p: path, ins_len: -1, cow: 1); |
203 | if (ret > 0) { |
204 | ret = -ENOENT; |
205 | search_ext_refs = 1; |
206 | goto out; |
207 | } else if (ret < 0) { |
208 | goto out; |
209 | } |
210 | |
211 | ref = btrfs_find_name_in_backref(leaf: path->nodes[0], slot: path->slots[0], name); |
212 | if (!ref) { |
213 | ret = -ENOENT; |
214 | search_ext_refs = 1; |
215 | goto out; |
216 | } |
217 | leaf = path->nodes[0]; |
218 | item_size = btrfs_item_size(eb: leaf, slot: path->slots[0]); |
219 | |
220 | if (index) |
221 | *index = btrfs_inode_ref_index(eb: leaf, s: ref); |
222 | |
223 | if (del_len == item_size) { |
224 | ret = btrfs_del_item(trans, root, path); |
225 | goto out; |
226 | } |
227 | ptr = (unsigned long)ref; |
228 | sub_item_len = name->len + sizeof(*ref); |
229 | item_start = btrfs_item_ptr_offset(leaf, path->slots[0]); |
230 | memmove_extent_buffer(dst: leaf, dst_offset: ptr, src_offset: ptr + sub_item_len, |
231 | len: item_size - (ptr + sub_item_len - item_start)); |
232 | btrfs_truncate_item(trans, path, new_size: item_size - sub_item_len, from_end: 1); |
233 | out: |
234 | btrfs_free_path(p: path); |
235 | |
236 | if (search_ext_refs) { |
237 | /* |
238 | * No refs were found, or we could not find the |
239 | * name in our ref array. Find and remove the extended |
240 | * inode ref then. |
241 | */ |
242 | return btrfs_del_inode_extref(trans, root, name, |
243 | inode_objectid, ref_objectid, index); |
244 | } |
245 | |
246 | return ret; |
247 | } |
248 | |
249 | /* |
250 | * Insert an extended inode ref into a tree. |
251 | * |
252 | * The caller must have checked against BTRFS_LINK_MAX already. |
253 | */ |
254 | static int btrfs_insert_inode_extref(struct btrfs_trans_handle *trans, |
255 | struct btrfs_root *root, |
256 | const struct fscrypt_str *name, |
257 | u64 inode_objectid, u64 ref_objectid, |
258 | u64 index) |
259 | { |
260 | struct btrfs_inode_extref *extref; |
261 | int ret; |
262 | int ins_len = name->len + sizeof(*extref); |
263 | unsigned long ptr; |
264 | struct btrfs_path *path; |
265 | struct btrfs_key key; |
266 | struct extent_buffer *leaf; |
267 | |
268 | key.objectid = inode_objectid; |
269 | key.type = BTRFS_INODE_EXTREF_KEY; |
270 | key.offset = btrfs_extref_hash(parent_objectid: ref_objectid, name: name->name, len: name->len); |
271 | |
272 | path = btrfs_alloc_path(); |
273 | if (!path) |
274 | return -ENOMEM; |
275 | |
276 | ret = btrfs_insert_empty_item(trans, root, path, key: &key, |
277 | data_size: ins_len); |
278 | if (ret == -EEXIST) { |
279 | if (btrfs_find_name_in_ext_backref(leaf: path->nodes[0], |
280 | slot: path->slots[0], |
281 | ref_objectid, |
282 | name)) |
283 | goto out; |
284 | |
285 | btrfs_extend_item(trans, path, data_size: ins_len); |
286 | ret = 0; |
287 | } |
288 | if (ret < 0) |
289 | goto out; |
290 | |
291 | leaf = path->nodes[0]; |
292 | ptr = (unsigned long)btrfs_item_ptr(leaf, path->slots[0], char); |
293 | ptr += btrfs_item_size(eb: leaf, slot: path->slots[0]) - ins_len; |
294 | extref = (struct btrfs_inode_extref *)ptr; |
295 | |
296 | btrfs_set_inode_extref_name_len(eb: path->nodes[0], s: extref, val: name->len); |
297 | btrfs_set_inode_extref_index(eb: path->nodes[0], s: extref, val: index); |
298 | btrfs_set_inode_extref_parent(eb: path->nodes[0], s: extref, val: ref_objectid); |
299 | |
300 | ptr = (unsigned long)&extref->name; |
301 | write_extent_buffer(eb: path->nodes[0], src: name->name, start: ptr, len: name->len); |
302 | btrfs_mark_buffer_dirty(trans, buf: path->nodes[0]); |
303 | |
304 | out: |
305 | btrfs_free_path(p: path); |
306 | return ret; |
307 | } |
308 | |
309 | /* Will return 0, -ENOMEM, -EMLINK, or -EEXIST or anything from the CoW path */ |
310 | int btrfs_insert_inode_ref(struct btrfs_trans_handle *trans, |
311 | struct btrfs_root *root, const struct fscrypt_str *name, |
312 | u64 inode_objectid, u64 ref_objectid, u64 index) |
313 | { |
314 | struct btrfs_fs_info *fs_info = root->fs_info; |
315 | struct btrfs_path *path; |
316 | struct btrfs_key key; |
317 | struct btrfs_inode_ref *ref; |
318 | unsigned long ptr; |
319 | int ret; |
320 | int ins_len = name->len + sizeof(*ref); |
321 | |
322 | key.objectid = inode_objectid; |
323 | key.offset = ref_objectid; |
324 | key.type = BTRFS_INODE_REF_KEY; |
325 | |
326 | path = btrfs_alloc_path(); |
327 | if (!path) |
328 | return -ENOMEM; |
329 | |
330 | path->skip_release_on_error = 1; |
331 | ret = btrfs_insert_empty_item(trans, root, path, key: &key, |
332 | data_size: ins_len); |
333 | if (ret == -EEXIST) { |
334 | u32 old_size; |
335 | ref = btrfs_find_name_in_backref(leaf: path->nodes[0], slot: path->slots[0], |
336 | name); |
337 | if (ref) |
338 | goto out; |
339 | |
340 | old_size = btrfs_item_size(eb: path->nodes[0], slot: path->slots[0]); |
341 | btrfs_extend_item(trans, path, data_size: ins_len); |
342 | ref = btrfs_item_ptr(path->nodes[0], path->slots[0], |
343 | struct btrfs_inode_ref); |
344 | ref = (struct btrfs_inode_ref *)((unsigned long)ref + old_size); |
345 | btrfs_set_inode_ref_name_len(eb: path->nodes[0], s: ref, val: name->len); |
346 | btrfs_set_inode_ref_index(eb: path->nodes[0], s: ref, val: index); |
347 | ptr = (unsigned long)(ref + 1); |
348 | ret = 0; |
349 | } else if (ret < 0) { |
350 | if (ret == -EOVERFLOW) { |
351 | if (btrfs_find_name_in_backref(leaf: path->nodes[0], |
352 | slot: path->slots[0], |
353 | name)) |
354 | ret = -EEXIST; |
355 | else |
356 | ret = -EMLINK; |
357 | } |
358 | goto out; |
359 | } else { |
360 | ref = btrfs_item_ptr(path->nodes[0], path->slots[0], |
361 | struct btrfs_inode_ref); |
362 | btrfs_set_inode_ref_name_len(eb: path->nodes[0], s: ref, val: name->len); |
363 | btrfs_set_inode_ref_index(eb: path->nodes[0], s: ref, val: index); |
364 | ptr = (unsigned long)(ref + 1); |
365 | } |
366 | write_extent_buffer(eb: path->nodes[0], src: name->name, start: ptr, len: name->len); |
367 | btrfs_mark_buffer_dirty(trans, buf: path->nodes[0]); |
368 | |
369 | out: |
370 | btrfs_free_path(p: path); |
371 | |
372 | if (ret == -EMLINK) { |
373 | struct btrfs_super_block *disk_super = fs_info->super_copy; |
374 | /* We ran out of space in the ref array. Need to |
375 | * add an extended ref. */ |
376 | if (btrfs_super_incompat_flags(s: disk_super) |
377 | & BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF) |
378 | ret = btrfs_insert_inode_extref(trans, root, name, |
379 | inode_objectid, |
380 | ref_objectid, index); |
381 | } |
382 | |
383 | return ret; |
384 | } |
385 | |
386 | int btrfs_insert_empty_inode(struct btrfs_trans_handle *trans, |
387 | struct btrfs_root *root, |
388 | struct btrfs_path *path, u64 objectid) |
389 | { |
390 | struct btrfs_key key; |
391 | int ret; |
392 | key.objectid = objectid; |
393 | key.type = BTRFS_INODE_ITEM_KEY; |
394 | key.offset = 0; |
395 | |
396 | ret = btrfs_insert_empty_item(trans, root, path, key: &key, |
397 | data_size: sizeof(struct btrfs_inode_item)); |
398 | return ret; |
399 | } |
400 | |
401 | int btrfs_lookup_inode(struct btrfs_trans_handle *trans, struct btrfs_root |
402 | *root, struct btrfs_path *path, |
403 | struct btrfs_key *location, int mod) |
404 | { |
405 | int ins_len = mod < 0 ? -1 : 0; |
406 | int cow = mod != 0; |
407 | int ret; |
408 | int slot; |
409 | struct extent_buffer *leaf; |
410 | struct btrfs_key found_key; |
411 | |
412 | ret = btrfs_search_slot(trans, root, key: location, p: path, ins_len, cow); |
413 | if (ret > 0 && location->type == BTRFS_ROOT_ITEM_KEY && |
414 | location->offset == (u64)-1 && path->slots[0] != 0) { |
415 | slot = path->slots[0] - 1; |
416 | leaf = path->nodes[0]; |
417 | btrfs_item_key_to_cpu(eb: leaf, cpu_key: &found_key, nr: slot); |
418 | if (found_key.objectid == location->objectid && |
419 | found_key.type == location->type) { |
420 | path->slots[0]--; |
421 | return 0; |
422 | } |
423 | } |
424 | return ret; |
425 | } |
426 | |
427 | static inline void btrfs_trace_truncate(struct btrfs_inode *inode, |
428 | struct extent_buffer *leaf, |
429 | struct btrfs_file_extent_item *fi, |
430 | u64 offset, int extent_type, int slot) |
431 | { |
432 | if (!inode) |
433 | return; |
434 | if (extent_type == BTRFS_FILE_EXTENT_INLINE) |
435 | trace_btrfs_truncate_show_fi_inline(bi: inode, l: leaf, fi, slot, |
436 | start: offset); |
437 | else |
438 | trace_btrfs_truncate_show_fi_regular(bi: inode, l: leaf, fi, start: offset); |
439 | } |
440 | |
441 | /* |
442 | * Remove inode items from a given root. |
443 | * |
444 | * @trans: A transaction handle. |
445 | * @root: The root from which to remove items. |
446 | * @inode: The inode whose items we want to remove. |
447 | * @control: The btrfs_truncate_control to control how and what we |
448 | * are truncating. |
449 | * |
450 | * Remove all keys associated with the inode from the given root that have a key |
451 | * with a type greater than or equals to @min_type. When @min_type has a value of |
452 | * BTRFS_EXTENT_DATA_KEY, only remove file extent items that have an offset value |
453 | * greater than or equals to @new_size. If a file extent item that starts before |
454 | * @new_size and ends after it is found, its length is adjusted. |
455 | * |
456 | * Returns: 0 on success, < 0 on error and NEED_TRUNCATE_BLOCK when @min_type is |
457 | * BTRFS_EXTENT_DATA_KEY and the caller must truncate the last block. |
458 | */ |
459 | int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans, |
460 | struct btrfs_root *root, |
461 | struct btrfs_truncate_control *control) |
462 | { |
463 | struct btrfs_fs_info *fs_info = root->fs_info; |
464 | struct btrfs_path *path; |
465 | struct extent_buffer *leaf; |
466 | struct btrfs_file_extent_item *fi; |
467 | struct btrfs_key key; |
468 | struct btrfs_key found_key; |
469 | u64 new_size = control->new_size; |
470 | u64 extent_num_bytes = 0; |
471 | u64 extent_offset = 0; |
472 | u64 item_end = 0; |
473 | u32 found_type = (u8)-1; |
474 | int del_item; |
475 | int pending_del_nr = 0; |
476 | int pending_del_slot = 0; |
477 | int extent_type = -1; |
478 | int ret; |
479 | u64 bytes_deleted = 0; |
480 | bool be_nice = false; |
481 | |
482 | ASSERT(control->inode || !control->clear_extent_range); |
483 | ASSERT(new_size == 0 || control->min_type == BTRFS_EXTENT_DATA_KEY); |
484 | |
485 | control->last_size = new_size; |
486 | control->sub_bytes = 0; |
487 | |
488 | /* |
489 | * For shareable roots we want to back off from time to time, this turns |
490 | * out to be subvolume roots, reloc roots, and data reloc roots. |
491 | */ |
492 | if (test_bit(BTRFS_ROOT_SHAREABLE, &root->state)) |
493 | be_nice = true; |
494 | |
495 | path = btrfs_alloc_path(); |
496 | if (!path) |
497 | return -ENOMEM; |
498 | path->reada = READA_BACK; |
499 | |
500 | key.objectid = control->ino; |
501 | key.offset = (u64)-1; |
502 | key.type = (u8)-1; |
503 | |
504 | search_again: |
505 | /* |
506 | * With a 16K leaf size and 128MiB extents, you can actually queue up a |
507 | * huge file in a single leaf. Most of the time that bytes_deleted is |
508 | * > 0, it will be huge by the time we get here |
509 | */ |
510 | if (be_nice && bytes_deleted > SZ_32M && |
511 | btrfs_should_end_transaction(trans)) { |
512 | ret = -EAGAIN; |
513 | goto out; |
514 | } |
515 | |
516 | ret = btrfs_search_slot(trans, root, key: &key, p: path, ins_len: -1, cow: 1); |
517 | if (ret < 0) |
518 | goto out; |
519 | |
520 | if (ret > 0) { |
521 | ret = 0; |
522 | /* There are no items in the tree for us to truncate, we're done */ |
523 | if (path->slots[0] == 0) |
524 | goto out; |
525 | path->slots[0]--; |
526 | } |
527 | |
528 | while (1) { |
529 | u64 clear_start = 0, clear_len = 0, extent_start = 0; |
530 | bool refill_delayed_refs_rsv = false; |
531 | |
532 | fi = NULL; |
533 | leaf = path->nodes[0]; |
534 | btrfs_item_key_to_cpu(eb: leaf, cpu_key: &found_key, nr: path->slots[0]); |
535 | found_type = found_key.type; |
536 | |
537 | if (found_key.objectid != control->ino) |
538 | break; |
539 | |
540 | if (found_type < control->min_type) |
541 | break; |
542 | |
543 | item_end = found_key.offset; |
544 | if (found_type == BTRFS_EXTENT_DATA_KEY) { |
545 | fi = btrfs_item_ptr(leaf, path->slots[0], |
546 | struct btrfs_file_extent_item); |
547 | extent_type = btrfs_file_extent_type(eb: leaf, s: fi); |
548 | if (extent_type != BTRFS_FILE_EXTENT_INLINE) |
549 | item_end += |
550 | btrfs_file_extent_num_bytes(eb: leaf, s: fi); |
551 | else if (extent_type == BTRFS_FILE_EXTENT_INLINE) |
552 | item_end += btrfs_file_extent_ram_bytes(eb: leaf, s: fi); |
553 | |
554 | btrfs_trace_truncate(inode: control->inode, leaf, fi, |
555 | offset: found_key.offset, extent_type, |
556 | slot: path->slots[0]); |
557 | item_end--; |
558 | } |
559 | if (found_type > control->min_type) { |
560 | del_item = 1; |
561 | } else { |
562 | if (item_end < new_size) |
563 | break; |
564 | if (found_key.offset >= new_size) |
565 | del_item = 1; |
566 | else |
567 | del_item = 0; |
568 | } |
569 | |
570 | /* FIXME, shrink the extent if the ref count is only 1 */ |
571 | if (found_type != BTRFS_EXTENT_DATA_KEY) |
572 | goto delete; |
573 | |
574 | control->extents_found++; |
575 | |
576 | if (extent_type != BTRFS_FILE_EXTENT_INLINE) { |
577 | u64 num_dec; |
578 | |
579 | clear_start = found_key.offset; |
580 | extent_start = btrfs_file_extent_disk_bytenr(eb: leaf, s: fi); |
581 | if (!del_item) { |
582 | u64 orig_num_bytes = |
583 | btrfs_file_extent_num_bytes(eb: leaf, s: fi); |
584 | extent_num_bytes = ALIGN(new_size - |
585 | found_key.offset, |
586 | fs_info->sectorsize); |
587 | clear_start = ALIGN(new_size, fs_info->sectorsize); |
588 | |
589 | btrfs_set_file_extent_num_bytes(eb: leaf, s: fi, |
590 | val: extent_num_bytes); |
591 | num_dec = (orig_num_bytes - extent_num_bytes); |
592 | if (extent_start != 0) |
593 | control->sub_bytes += num_dec; |
594 | btrfs_mark_buffer_dirty(trans, buf: leaf); |
595 | } else { |
596 | extent_num_bytes = |
597 | btrfs_file_extent_disk_num_bytes(eb: leaf, s: fi); |
598 | extent_offset = found_key.offset - |
599 | btrfs_file_extent_offset(eb: leaf, s: fi); |
600 | |
601 | /* FIXME blocksize != 4096 */ |
602 | num_dec = btrfs_file_extent_num_bytes(eb: leaf, s: fi); |
603 | if (extent_start != 0) |
604 | control->sub_bytes += num_dec; |
605 | } |
606 | clear_len = num_dec; |
607 | } else if (extent_type == BTRFS_FILE_EXTENT_INLINE) { |
608 | /* |
609 | * We can't truncate inline items that have had |
610 | * special encodings |
611 | */ |
612 | if (!del_item && |
613 | btrfs_file_extent_encryption(eb: leaf, s: fi) == 0 && |
614 | btrfs_file_extent_other_encoding(eb: leaf, s: fi) == 0 && |
615 | btrfs_file_extent_compression(eb: leaf, s: fi) == 0) { |
616 | u32 size = (u32)(new_size - found_key.offset); |
617 | |
618 | btrfs_set_file_extent_ram_bytes(eb: leaf, s: fi, val: size); |
619 | size = btrfs_file_extent_calc_inline_size(datasize: size); |
620 | btrfs_truncate_item(trans, path, new_size: size, from_end: 1); |
621 | } else if (!del_item) { |
622 | /* |
623 | * We have to bail so the last_size is set to |
624 | * just before this extent. |
625 | */ |
626 | ret = BTRFS_NEED_TRUNCATE_BLOCK; |
627 | break; |
628 | } else { |
629 | /* |
630 | * Inline extents are special, we just treat |
631 | * them as a full sector worth in the file |
632 | * extent tree just for simplicity sake. |
633 | */ |
634 | clear_len = fs_info->sectorsize; |
635 | } |
636 | |
637 | control->sub_bytes += item_end + 1 - new_size; |
638 | } |
639 | delete: |
640 | /* |
641 | * We only want to clear the file extent range if we're |
642 | * modifying the actual inode's mapping, which is just the |
643 | * normal truncate path. |
644 | */ |
645 | if (control->clear_extent_range) { |
646 | ret = btrfs_inode_clear_file_extent_range(inode: control->inode, |
647 | start: clear_start, len: clear_len); |
648 | if (ret) { |
649 | btrfs_abort_transaction(trans, ret); |
650 | break; |
651 | } |
652 | } |
653 | |
654 | if (del_item) { |
655 | ASSERT(!pending_del_nr || |
656 | ((path->slots[0] + 1) == pending_del_slot)); |
657 | |
658 | control->last_size = found_key.offset; |
659 | if (!pending_del_nr) { |
660 | /* No pending yet, add ourselves */ |
661 | pending_del_slot = path->slots[0]; |
662 | pending_del_nr = 1; |
663 | } else if (path->slots[0] + 1 == pending_del_slot) { |
664 | /* Hop on the pending chunk */ |
665 | pending_del_nr++; |
666 | pending_del_slot = path->slots[0]; |
667 | } |
668 | } else { |
669 | control->last_size = new_size; |
670 | break; |
671 | } |
672 | |
673 | if (del_item && extent_start != 0 && !control->skip_ref_updates) { |
674 | struct btrfs_ref ref = { 0 }; |
675 | |
676 | bytes_deleted += extent_num_bytes; |
677 | |
678 | btrfs_init_generic_ref(generic_ref: &ref, action: BTRFS_DROP_DELAYED_REF, |
679 | bytenr: extent_start, len: extent_num_bytes, parent: 0, |
680 | owning_root: root->root_key.objectid); |
681 | btrfs_init_data_ref(generic_ref: &ref, ref_root: btrfs_header_owner(eb: leaf), |
682 | ino: control->ino, offset: extent_offset, |
683 | mod_root: root->root_key.objectid, skip_qgroup: false); |
684 | ret = btrfs_free_extent(trans, ref: &ref); |
685 | if (ret) { |
686 | btrfs_abort_transaction(trans, ret); |
687 | break; |
688 | } |
689 | if (be_nice && btrfs_check_space_for_delayed_refs(fs_info)) |
690 | refill_delayed_refs_rsv = true; |
691 | } |
692 | |
693 | if (found_type == BTRFS_INODE_ITEM_KEY) |
694 | break; |
695 | |
696 | if (path->slots[0] == 0 || |
697 | path->slots[0] != pending_del_slot || |
698 | refill_delayed_refs_rsv) { |
699 | if (pending_del_nr) { |
700 | ret = btrfs_del_items(trans, root, path, |
701 | slot: pending_del_slot, |
702 | nr: pending_del_nr); |
703 | if (ret) { |
704 | btrfs_abort_transaction(trans, ret); |
705 | break; |
706 | } |
707 | pending_del_nr = 0; |
708 | } |
709 | btrfs_release_path(p: path); |
710 | |
711 | /* |
712 | * We can generate a lot of delayed refs, so we need to |
713 | * throttle every once and a while and make sure we're |
714 | * adding enough space to keep up with the work we are |
715 | * generating. Since we hold a transaction here we |
716 | * can't flush, and we don't want to FLUSH_LIMIT because |
717 | * we could have generated too many delayed refs to |
718 | * actually allocate, so just bail if we're short and |
719 | * let the normal reservation dance happen higher up. |
720 | */ |
721 | if (refill_delayed_refs_rsv) { |
722 | ret = btrfs_delayed_refs_rsv_refill(fs_info, |
723 | flush: BTRFS_RESERVE_NO_FLUSH); |
724 | if (ret) { |
725 | ret = -EAGAIN; |
726 | break; |
727 | } |
728 | } |
729 | goto search_again; |
730 | } else { |
731 | path->slots[0]--; |
732 | } |
733 | } |
734 | out: |
735 | if (ret >= 0 && pending_del_nr) { |
736 | int err; |
737 | |
738 | err = btrfs_del_items(trans, root, path, slot: pending_del_slot, |
739 | nr: pending_del_nr); |
740 | if (err) { |
741 | btrfs_abort_transaction(trans, err); |
742 | ret = err; |
743 | } |
744 | } |
745 | |
746 | ASSERT(control->last_size >= new_size); |
747 | if (!ret && control->last_size > new_size) |
748 | control->last_size = new_size; |
749 | |
750 | btrfs_free_path(p: path); |
751 | return ret; |
752 | } |
753 | |