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