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