Line data Source code
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 0 : struct btrfs_inode_ref *btrfs_find_name_in_backref(struct extent_buffer *leaf,
19 : int slot,
20 : const struct fscrypt_str *name)
21 : {
22 0 : struct btrfs_inode_ref *ref;
23 0 : unsigned long ptr;
24 0 : unsigned long name_ptr;
25 0 : u32 item_size;
26 0 : u32 cur_offset = 0;
27 0 : int len;
28 :
29 0 : item_size = btrfs_item_size(leaf, slot);
30 0 : ptr = btrfs_item_ptr_offset(leaf, slot);
31 0 : while (cur_offset < item_size) {
32 0 : ref = (struct btrfs_inode_ref *)(ptr + cur_offset);
33 0 : len = btrfs_inode_ref_name_len(leaf, ref);
34 0 : name_ptr = (unsigned long)(ref + 1);
35 0 : cur_offset += len + sizeof(*ref);
36 0 : if (len != name->len)
37 0 : continue;
38 0 : if (memcmp_extent_buffer(leaf, name->name, name_ptr,
39 : name->len) == 0)
40 0 : return ref;
41 : }
42 : return NULL;
43 : }
44 :
45 0 : 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 0 : struct btrfs_inode_extref *extref;
50 0 : unsigned long ptr;
51 0 : unsigned long name_ptr;
52 0 : u32 item_size;
53 0 : u32 cur_offset = 0;
54 0 : int ref_name_len;
55 :
56 0 : item_size = btrfs_item_size(leaf, slot);
57 0 : 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 0 : while (cur_offset < item_size) {
66 0 : extref = (struct btrfs_inode_extref *) (ptr + cur_offset);
67 0 : name_ptr = (unsigned long)(&extref->name);
68 0 : ref_name_len = btrfs_inode_extref_name_len(leaf, extref);
69 :
70 0 : if (ref_name_len == name->len &&
71 0 : btrfs_inode_extref_parent(leaf, extref) == ref_objectid &&
72 0 : (memcmp_extent_buffer(leaf, name->name, name_ptr,
73 0 : name->len) == 0))
74 0 : return extref;
75 :
76 0 : 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 0 : 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 0 : int ret;
91 0 : struct btrfs_key key;
92 :
93 0 : key.objectid = inode_objectid;
94 0 : key.type = BTRFS_INODE_EXTREF_KEY;
95 0 : key.offset = btrfs_extref_hash(ref_objectid, name->name, name->len);
96 :
97 0 : ret = btrfs_search_slot(trans, root, &key, path, ins_len, cow);
98 0 : if (ret < 0)
99 0 : return ERR_PTR(ret);
100 0 : if (ret > 0)
101 : return NULL;
102 0 : return btrfs_find_name_in_ext_backref(path->nodes[0], path->slots[0],
103 : ref_objectid, name);
104 :
105 : }
106 :
107 0 : 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 0 : struct btrfs_path *path;
114 0 : struct btrfs_key key;
115 0 : struct btrfs_inode_extref *extref;
116 0 : struct extent_buffer *leaf;
117 0 : int ret;
118 0 : int del_len = name->len + sizeof(*extref);
119 0 : unsigned long ptr;
120 0 : unsigned long item_start;
121 0 : u32 item_size;
122 :
123 0 : key.objectid = inode_objectid;
124 0 : key.type = BTRFS_INODE_EXTREF_KEY;
125 0 : key.offset = btrfs_extref_hash(ref_objectid, name->name, name->len);
126 :
127 0 : path = btrfs_alloc_path();
128 0 : if (!path)
129 : return -ENOMEM;
130 :
131 0 : ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
132 0 : if (ret > 0)
133 : ret = -ENOENT;
134 0 : if (ret < 0)
135 0 : 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 0 : extref = btrfs_find_name_in_ext_backref(path->nodes[0], path->slots[0],
143 : ref_objectid, name);
144 0 : if (!extref) {
145 0 : btrfs_handle_fs_error(root->fs_info, -ENOENT, NULL);
146 0 : ret = -EROFS;
147 0 : goto out;
148 : }
149 :
150 0 : leaf = path->nodes[0];
151 0 : item_size = btrfs_item_size(leaf, path->slots[0]);
152 0 : if (index)
153 0 : *index = btrfs_inode_extref_index(leaf, extref);
154 :
155 0 : if (del_len == item_size) {
156 : /*
157 : * Common case only one ref in the item, remove the
158 : * whole item.
159 : */
160 0 : ret = btrfs_del_item(trans, root, path);
161 0 : goto out;
162 : }
163 :
164 0 : ptr = (unsigned long)extref;
165 0 : item_start = btrfs_item_ptr_offset(leaf, path->slots[0]);
166 :
167 0 : memmove_extent_buffer(leaf, ptr, ptr + del_len,
168 0 : item_size - (ptr + del_len - item_start));
169 :
170 0 : btrfs_truncate_item(path, item_size - del_len, 1);
171 :
172 0 : out:
173 0 : btrfs_free_path(path);
174 :
175 0 : return ret;
176 : }
177 :
178 0 : 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 0 : struct btrfs_path *path;
183 0 : struct btrfs_key key;
184 0 : struct btrfs_inode_ref *ref;
185 0 : struct extent_buffer *leaf;
186 0 : unsigned long ptr;
187 0 : unsigned long item_start;
188 0 : u32 item_size;
189 0 : u32 sub_item_len;
190 0 : int ret;
191 0 : int search_ext_refs = 0;
192 0 : int del_len = name->len + sizeof(*ref);
193 :
194 0 : key.objectid = inode_objectid;
195 0 : key.offset = ref_objectid;
196 0 : key.type = BTRFS_INODE_REF_KEY;
197 :
198 0 : path = btrfs_alloc_path();
199 0 : if (!path)
200 : return -ENOMEM;
201 :
202 0 : ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
203 0 : if (ret > 0) {
204 0 : ret = -ENOENT;
205 0 : search_ext_refs = 1;
206 0 : goto out;
207 0 : } else if (ret < 0) {
208 0 : goto out;
209 : }
210 :
211 0 : ref = btrfs_find_name_in_backref(path->nodes[0], path->slots[0], name);
212 0 : if (!ref) {
213 0 : ret = -ENOENT;
214 0 : search_ext_refs = 1;
215 0 : goto out;
216 : }
217 0 : leaf = path->nodes[0];
218 0 : item_size = btrfs_item_size(leaf, path->slots[0]);
219 :
220 0 : if (index)
221 0 : *index = btrfs_inode_ref_index(leaf, ref);
222 :
223 0 : if (del_len == item_size) {
224 0 : ret = btrfs_del_item(trans, root, path);
225 0 : goto out;
226 : }
227 0 : ptr = (unsigned long)ref;
228 0 : sub_item_len = name->len + sizeof(*ref);
229 0 : item_start = btrfs_item_ptr_offset(leaf, path->slots[0]);
230 0 : memmove_extent_buffer(leaf, ptr, ptr + sub_item_len,
231 0 : item_size - (ptr + sub_item_len - item_start));
232 0 : btrfs_truncate_item(path, item_size - sub_item_len, 1);
233 0 : out:
234 0 : btrfs_free_path(path);
235 :
236 0 : 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 0 : return btrfs_del_inode_extref(trans, root, name,
243 : inode_objectid, ref_objectid, index);
244 : }
245 :
246 : return ret;
247 : }
248 :
249 : /*
250 : * btrfs_insert_inode_extref() - Inserts an extended inode ref into a tree.
251 : *
252 : * The caller must have checked against BTRFS_LINK_MAX already.
253 : */
254 0 : 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 0 : struct btrfs_inode_extref *extref;
261 0 : int ret;
262 0 : int ins_len = name->len + sizeof(*extref);
263 0 : unsigned long ptr;
264 0 : struct btrfs_path *path;
265 0 : struct btrfs_key key;
266 0 : struct extent_buffer *leaf;
267 :
268 0 : key.objectid = inode_objectid;
269 0 : key.type = BTRFS_INODE_EXTREF_KEY;
270 0 : key.offset = btrfs_extref_hash(ref_objectid, name->name, name->len);
271 :
272 0 : path = btrfs_alloc_path();
273 0 : if (!path)
274 : return -ENOMEM;
275 :
276 0 : ret = btrfs_insert_empty_item(trans, root, path, &key,
277 : ins_len);
278 0 : if (ret == -EEXIST) {
279 0 : if (btrfs_find_name_in_ext_backref(path->nodes[0],
280 : path->slots[0],
281 : ref_objectid,
282 : name))
283 0 : goto out;
284 :
285 0 : btrfs_extend_item(path, ins_len);
286 0 : ret = 0;
287 : }
288 0 : if (ret < 0)
289 0 : goto out;
290 :
291 0 : leaf = path->nodes[0];
292 0 : ptr = (unsigned long)btrfs_item_ptr(leaf, path->slots[0], char);
293 0 : ptr += btrfs_item_size(leaf, path->slots[0]) - ins_len;
294 0 : extref = (struct btrfs_inode_extref *)ptr;
295 :
296 0 : btrfs_set_inode_extref_name_len(path->nodes[0], extref, name->len);
297 0 : btrfs_set_inode_extref_index(path->nodes[0], extref, index);
298 0 : btrfs_set_inode_extref_parent(path->nodes[0], extref, ref_objectid);
299 :
300 0 : ptr = (unsigned long)&extref->name;
301 0 : write_extent_buffer(path->nodes[0], name->name, ptr, name->len);
302 0 : btrfs_mark_buffer_dirty(path->nodes[0]);
303 :
304 0 : out:
305 0 : btrfs_free_path(path);
306 0 : return ret;
307 : }
308 :
309 : /* Will return 0, -ENOMEM, -EMLINK, or -EEXIST or anything from the CoW path */
310 0 : 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 0 : struct btrfs_fs_info *fs_info = root->fs_info;
315 0 : struct btrfs_path *path;
316 0 : struct btrfs_key key;
317 0 : struct btrfs_inode_ref *ref;
318 0 : unsigned long ptr;
319 0 : int ret;
320 0 : int ins_len = name->len + sizeof(*ref);
321 :
322 0 : key.objectid = inode_objectid;
323 0 : key.offset = ref_objectid;
324 0 : key.type = BTRFS_INODE_REF_KEY;
325 :
326 0 : path = btrfs_alloc_path();
327 0 : if (!path)
328 : return -ENOMEM;
329 :
330 0 : path->skip_release_on_error = 1;
331 0 : ret = btrfs_insert_empty_item(trans, root, path, &key,
332 : ins_len);
333 0 : if (ret == -EEXIST) {
334 0 : u32 old_size;
335 0 : ref = btrfs_find_name_in_backref(path->nodes[0], path->slots[0],
336 : name);
337 0 : if (ref)
338 0 : goto out;
339 :
340 0 : old_size = btrfs_item_size(path->nodes[0], path->slots[0]);
341 0 : btrfs_extend_item(path, ins_len);
342 0 : ref = btrfs_item_ptr(path->nodes[0], path->slots[0],
343 : struct btrfs_inode_ref);
344 0 : ref = (struct btrfs_inode_ref *)((unsigned long)ref + old_size);
345 0 : btrfs_set_inode_ref_name_len(path->nodes[0], ref, name->len);
346 0 : btrfs_set_inode_ref_index(path->nodes[0], ref, index);
347 0 : ptr = (unsigned long)(ref + 1);
348 0 : ret = 0;
349 0 : } else if (ret < 0) {
350 0 : if (ret == -EOVERFLOW) {
351 0 : if (btrfs_find_name_in_backref(path->nodes[0],
352 : path->slots[0],
353 : name))
354 : ret = -EEXIST;
355 : else
356 0 : ret = -EMLINK;
357 : }
358 0 : goto out;
359 : } else {
360 0 : ref = btrfs_item_ptr(path->nodes[0], path->slots[0],
361 : struct btrfs_inode_ref);
362 0 : btrfs_set_inode_ref_name_len(path->nodes[0], ref, name->len);
363 0 : btrfs_set_inode_ref_index(path->nodes[0], ref, index);
364 0 : ptr = (unsigned long)(ref + 1);
365 : }
366 0 : write_extent_buffer(path->nodes[0], name->name, ptr, name->len);
367 0 : btrfs_mark_buffer_dirty(path->nodes[0]);
368 :
369 0 : out:
370 0 : btrfs_free_path(path);
371 :
372 0 : if (ret == -EMLINK) {
373 0 : 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 0 : if (btrfs_super_incompat_flags(disk_super)
377 0 : & BTRFS_FEATURE_INCOMPAT_EXTENDED_IREF)
378 0 : ret = btrfs_insert_inode_extref(trans, root, name,
379 : inode_objectid,
380 : ref_objectid, index);
381 : }
382 :
383 : return ret;
384 : }
385 :
386 0 : int btrfs_insert_empty_inode(struct btrfs_trans_handle *trans,
387 : struct btrfs_root *root,
388 : struct btrfs_path *path, u64 objectid)
389 : {
390 0 : struct btrfs_key key;
391 0 : int ret;
392 0 : key.objectid = objectid;
393 0 : key.type = BTRFS_INODE_ITEM_KEY;
394 0 : key.offset = 0;
395 :
396 0 : ret = btrfs_insert_empty_item(trans, root, path, &key,
397 : sizeof(struct btrfs_inode_item));
398 0 : return ret;
399 : }
400 :
401 0 : 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 0 : int ins_len = mod < 0 ? -1 : 0;
406 0 : int cow = mod != 0;
407 0 : int ret;
408 0 : int slot;
409 0 : struct extent_buffer *leaf;
410 0 : struct btrfs_key found_key;
411 :
412 0 : ret = btrfs_search_slot(trans, root, location, path, ins_len, cow);
413 0 : if (ret > 0 && location->type == BTRFS_ROOT_ITEM_KEY &&
414 0 : location->offset == (u64)-1 && path->slots[0] != 0) {
415 0 : slot = path->slots[0] - 1;
416 0 : leaf = path->nodes[0];
417 0 : btrfs_item_key_to_cpu(leaf, &found_key, slot);
418 0 : if (found_key.objectid == location->objectid &&
419 0 : found_key.type == location->type) {
420 0 : path->slots[0]--;
421 0 : return 0;
422 : }
423 : }
424 : return ret;
425 : }
426 :
427 0 : 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 0 : if (!inode)
433 : return;
434 0 : if (extent_type == BTRFS_FILE_EXTENT_INLINE)
435 0 : trace_btrfs_truncate_show_fi_inline(inode, leaf, fi, slot,
436 : offset);
437 : else
438 0 : trace_btrfs_truncate_show_fi_regular(inode, leaf, fi, 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 0 : int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
460 : struct btrfs_root *root,
461 : struct btrfs_truncate_control *control)
462 : {
463 0 : struct btrfs_fs_info *fs_info = root->fs_info;
464 0 : struct btrfs_path *path;
465 0 : struct extent_buffer *leaf;
466 0 : struct btrfs_file_extent_item *fi;
467 0 : struct btrfs_key key;
468 0 : struct btrfs_key found_key;
469 0 : u64 new_size = control->new_size;
470 0 : u64 extent_num_bytes = 0;
471 0 : u64 extent_offset = 0;
472 0 : u64 item_end = 0;
473 0 : u32 found_type = (u8)-1;
474 0 : int del_item;
475 0 : int pending_del_nr = 0;
476 0 : int pending_del_slot = 0;
477 0 : int extent_type = -1;
478 0 : int ret;
479 0 : u64 bytes_deleted = 0;
480 0 : bool be_nice = false;
481 :
482 0 : ASSERT(control->inode || !control->clear_extent_range);
483 0 : ASSERT(new_size == 0 || control->min_type == BTRFS_EXTENT_DATA_KEY);
484 :
485 0 : control->last_size = new_size;
486 0 : 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 0 : if (test_bit(BTRFS_ROOT_SHAREABLE, &root->state))
493 0 : be_nice = true;
494 :
495 0 : path = btrfs_alloc_path();
496 0 : if (!path)
497 : return -ENOMEM;
498 0 : path->reada = READA_BACK;
499 :
500 0 : key.objectid = control->ino;
501 0 : key.offset = (u64)-1;
502 0 : key.type = (u8)-1;
503 :
504 0 : 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 0 : if (be_nice && bytes_deleted > SZ_32M &&
511 0 : btrfs_should_end_transaction(trans)) {
512 0 : ret = -EAGAIN;
513 0 : goto out;
514 : }
515 :
516 0 : ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
517 0 : if (ret < 0)
518 0 : goto out;
519 :
520 0 : if (ret > 0) {
521 0 : ret = 0;
522 : /* There are no items in the tree for us to truncate, we're done */
523 0 : if (path->slots[0] == 0)
524 0 : goto out;
525 0 : path->slots[0]--;
526 : }
527 :
528 0 : while (1) {
529 0 : u64 clear_start = 0, clear_len = 0, extent_start = 0;
530 0 : bool refill_delayed_refs_rsv = false;
531 :
532 0 : fi = NULL;
533 0 : leaf = path->nodes[0];
534 0 : btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
535 0 : found_type = found_key.type;
536 :
537 0 : if (found_key.objectid != control->ino)
538 : break;
539 :
540 0 : if (found_type < control->min_type)
541 : break;
542 :
543 0 : item_end = found_key.offset;
544 0 : if (found_type == BTRFS_EXTENT_DATA_KEY) {
545 0 : fi = btrfs_item_ptr(leaf, path->slots[0],
546 : struct btrfs_file_extent_item);
547 0 : extent_type = btrfs_file_extent_type(leaf, fi);
548 0 : if (extent_type != BTRFS_FILE_EXTENT_INLINE)
549 0 : item_end +=
550 : btrfs_file_extent_num_bytes(leaf, fi);
551 0 : else if (extent_type == BTRFS_FILE_EXTENT_INLINE)
552 0 : item_end += btrfs_file_extent_ram_bytes(leaf, fi);
553 :
554 0 : btrfs_trace_truncate(control->inode, leaf, fi,
555 : found_key.offset, extent_type,
556 : path->slots[0]);
557 0 : item_end--;
558 : }
559 0 : if (found_type > control->min_type) {
560 : del_item = 1;
561 : } else {
562 0 : if (item_end < new_size)
563 : break;
564 0 : if (found_key.offset >= new_size)
565 : del_item = 1;
566 : else
567 0 : del_item = 0;
568 : }
569 :
570 : /* FIXME, shrink the extent if the ref count is only 1 */
571 0 : if (found_type != BTRFS_EXTENT_DATA_KEY)
572 0 : goto delete;
573 :
574 0 : control->extents_found++;
575 :
576 0 : if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
577 0 : u64 num_dec;
578 :
579 0 : clear_start = found_key.offset;
580 0 : extent_start = btrfs_file_extent_disk_bytenr(leaf, fi);
581 0 : if (!del_item) {
582 0 : u64 orig_num_bytes =
583 : btrfs_file_extent_num_bytes(leaf, fi);
584 0 : extent_num_bytes = ALIGN(new_size -
585 : found_key.offset,
586 : fs_info->sectorsize);
587 0 : clear_start = ALIGN(new_size, fs_info->sectorsize);
588 :
589 0 : btrfs_set_file_extent_num_bytes(leaf, fi,
590 : extent_num_bytes);
591 0 : num_dec = (orig_num_bytes - extent_num_bytes);
592 0 : if (extent_start != 0)
593 0 : control->sub_bytes += num_dec;
594 0 : btrfs_mark_buffer_dirty(leaf);
595 : } else {
596 0 : extent_num_bytes =
597 : btrfs_file_extent_disk_num_bytes(leaf, fi);
598 0 : extent_offset = found_key.offset -
599 : btrfs_file_extent_offset(leaf, fi);
600 :
601 : /* FIXME blocksize != 4096 */
602 0 : num_dec = btrfs_file_extent_num_bytes(leaf, fi);
603 0 : if (extent_start != 0)
604 0 : control->sub_bytes += num_dec;
605 : }
606 : clear_len = num_dec;
607 0 : } else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
608 : /*
609 : * We can't truncate inline items that have had
610 : * special encodings
611 : */
612 0 : if (!del_item &&
613 0 : btrfs_file_extent_encryption(leaf, fi) == 0 &&
614 0 : btrfs_file_extent_other_encoding(leaf, fi) == 0 &&
615 0 : btrfs_file_extent_compression(leaf, fi) == 0) {
616 0 : u32 size = (u32)(new_size - found_key.offset);
617 :
618 0 : btrfs_set_file_extent_ram_bytes(leaf, fi, size);
619 0 : size = btrfs_file_extent_calc_inline_size(size);
620 0 : btrfs_truncate_item(path, size, 1);
621 0 : } 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 0 : clear_len = fs_info->sectorsize;
635 : }
636 :
637 0 : control->sub_bytes += item_end + 1 - new_size;
638 : }
639 0 : 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 0 : if (control->clear_extent_range) {
646 0 : ret = btrfs_inode_clear_file_extent_range(control->inode,
647 : clear_start, clear_len);
648 0 : if (ret) {
649 0 : btrfs_abort_transaction(trans, ret);
650 0 : break;
651 : }
652 : }
653 :
654 0 : if (del_item) {
655 0 : ASSERT(!pending_del_nr ||
656 : ((path->slots[0] + 1) == pending_del_slot));
657 :
658 0 : control->last_size = found_key.offset;
659 0 : if (!pending_del_nr) {
660 : /* No pending yet, add ourselves */
661 0 : pending_del_slot = path->slots[0];
662 0 : pending_del_nr = 1;
663 0 : } else if (path->slots[0] + 1 == pending_del_slot) {
664 : /* Hop on the pending chunk */
665 0 : pending_del_nr++;
666 0 : pending_del_slot = path->slots[0];
667 : }
668 : } else {
669 0 : control->last_size = new_size;
670 0 : break;
671 : }
672 :
673 0 : if (del_item && extent_start != 0 && !control->skip_ref_updates) {
674 0 : struct btrfs_ref ref = { 0 };
675 :
676 0 : bytes_deleted += extent_num_bytes;
677 :
678 0 : btrfs_init_generic_ref(&ref, BTRFS_DROP_DELAYED_REF,
679 : extent_start, extent_num_bytes, 0);
680 0 : btrfs_init_data_ref(&ref, btrfs_header_owner(leaf),
681 : control->ino, extent_offset,
682 : root->root_key.objectid, false);
683 0 : ret = btrfs_free_extent(trans, &ref);
684 0 : if (ret) {
685 0 : btrfs_abort_transaction(trans, ret);
686 0 : break;
687 : }
688 0 : if (be_nice && btrfs_check_space_for_delayed_refs(fs_info))
689 0 : refill_delayed_refs_rsv = true;
690 : }
691 :
692 0 : if (found_type == BTRFS_INODE_ITEM_KEY)
693 : break;
694 :
695 0 : if (path->slots[0] == 0 ||
696 0 : path->slots[0] != pending_del_slot ||
697 : refill_delayed_refs_rsv) {
698 0 : if (pending_del_nr) {
699 0 : ret = btrfs_del_items(trans, root, path,
700 : pending_del_slot,
701 : pending_del_nr);
702 0 : if (ret) {
703 0 : btrfs_abort_transaction(trans, ret);
704 0 : break;
705 : }
706 : pending_del_nr = 0;
707 : }
708 0 : btrfs_release_path(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 0 : if (refill_delayed_refs_rsv) {
721 0 : ret = btrfs_delayed_refs_rsv_refill(fs_info,
722 : BTRFS_RESERVE_NO_FLUSH);
723 0 : if (ret) {
724 : ret = -EAGAIN;
725 : break;
726 : }
727 : }
728 0 : goto search_again;
729 : } else {
730 0 : path->slots[0]--;
731 : }
732 : }
733 0 : out:
734 0 : if (ret >= 0 && pending_del_nr) {
735 0 : int err;
736 :
737 0 : err = btrfs_del_items(trans, root, path, pending_del_slot,
738 : pending_del_nr);
739 0 : if (err) {
740 0 : btrfs_abort_transaction(trans, err);
741 0 : ret = err;
742 : }
743 : }
744 :
745 0 : ASSERT(control->last_size >= new_size);
746 0 : if (!ret && control->last_size > new_size)
747 0 : control->last_size = new_size;
748 :
749 0 : btrfs_free_path(path);
750 0 : return ret;
751 : }
|
