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 904682 : struct btrfs_inode_ref *btrfs_find_name_in_backref(struct extent_buffer *leaf,
19 : int slot,
20 : const struct fscrypt_str *name)
21 : {
22 904682 : struct btrfs_inode_ref *ref;
23 904682 : unsigned long ptr;
24 904682 : unsigned long name_ptr;
25 904682 : u32 item_size;
26 904682 : u32 cur_offset = 0;
27 904682 : int len;
28 :
29 904682 : item_size = btrfs_item_size(leaf, slot);
30 904682 : ptr = btrfs_item_ptr_offset(leaf, slot);
31 10333630 : while (cur_offset < item_size) {
32 9974268 : ref = (struct btrfs_inode_ref *)(ptr + cur_offset);
33 9974268 : len = btrfs_inode_ref_name_len(leaf, ref);
34 9974268 : name_ptr = (unsigned long)(ref + 1);
35 9974268 : cur_offset += len + sizeof(*ref);
36 9974268 : if (len != name->len)
37 2272986 : continue;
38 7701282 : if (memcmp_extent_buffer(leaf, name->name, name_ptr,
39 : name->len) == 0)
40 545320 : 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 206 : 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 206 : int ret;
91 206 : struct btrfs_key key;
92 :
93 206 : key.objectid = inode_objectid;
94 206 : key.type = BTRFS_INODE_EXTREF_KEY;
95 206 : key.offset = btrfs_extref_hash(ref_objectid, name->name, name->len);
96 :
97 206 : ret = btrfs_search_slot(trans, root, &key, path, ins_len, cow);
98 206 : if (ret < 0)
99 0 : return ERR_PTR(ret);
100 206 : 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 7332 : 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 7332 : struct btrfs_path *path;
114 7332 : struct btrfs_key key;
115 7332 : struct btrfs_inode_extref *extref;
116 7332 : struct extent_buffer *leaf;
117 7332 : int ret;
118 7332 : int del_len = name->len + sizeof(*extref);
119 7332 : unsigned long ptr;
120 7332 : unsigned long item_start;
121 7332 : u32 item_size;
122 :
123 7332 : key.objectid = inode_objectid;
124 7332 : key.type = BTRFS_INODE_EXTREF_KEY;
125 7332 : key.offset = btrfs_extref_hash(ref_objectid, name->name, name->len);
126 :
127 7332 : path = btrfs_alloc_path();
128 7332 : if (!path)
129 : return -ENOMEM;
130 :
131 7332 : ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
132 7332 : if (ret > 0)
133 : ret = -ENOENT;
134 7278 : if (ret < 0)
135 54 : 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 7332 : out:
173 7332 : btrfs_free_path(path);
174 :
175 7332 : return ret;
176 : }
177 :
178 548739 : 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 548739 : struct btrfs_path *path;
183 548739 : struct btrfs_key key;
184 548739 : struct btrfs_inode_ref *ref;
185 548739 : struct extent_buffer *leaf;
186 548739 : unsigned long ptr;
187 548739 : unsigned long item_start;
188 548739 : u32 item_size;
189 548739 : u32 sub_item_len;
190 548739 : int ret;
191 548739 : int search_ext_refs = 0;
192 548739 : int del_len = name->len + sizeof(*ref);
193 :
194 548739 : key.objectid = inode_objectid;
195 548739 : key.offset = ref_objectid;
196 548739 : key.type = BTRFS_INODE_REF_KEY;
197 :
198 548739 : path = btrfs_alloc_path();
199 548739 : if (!path)
200 : return -ENOMEM;
201 :
202 548739 : ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
203 548739 : if (ret > 0) {
204 1978 : ret = -ENOENT;
205 1978 : search_ext_refs = 1;
206 1978 : goto out;
207 546761 : } else if (ret < 0) {
208 0 : goto out;
209 : }
210 :
211 546761 : ref = btrfs_find_name_in_backref(path->nodes[0], path->slots[0], name);
212 546761 : if (!ref) {
213 5354 : ret = -ENOENT;
214 5354 : search_ext_refs = 1;
215 5354 : goto out;
216 : }
217 541407 : leaf = path->nodes[0];
218 541407 : item_size = btrfs_item_size(leaf, path->slots[0]);
219 :
220 541407 : if (index)
221 541407 : *index = btrfs_inode_ref_index(leaf, ref);
222 :
223 541407 : if (del_len == item_size) {
224 197280 : ret = btrfs_del_item(trans, root, path);
225 197280 : goto out;
226 : }
227 344127 : ptr = (unsigned long)ref;
228 344127 : sub_item_len = name->len + sizeof(*ref);
229 344127 : item_start = btrfs_item_ptr_offset(leaf, path->slots[0]);
230 344127 : memmove_extent_buffer(leaf, ptr, ptr + sub_item_len,
231 344127 : item_size - (ptr + sub_item_len - item_start));
232 344127 : btrfs_truncate_item(path, item_size - sub_item_len, 1);
233 548739 : out:
234 548739 : btrfs_free_path(path);
235 :
236 548739 : 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 7332 : 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 526314 : 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 526314 : struct btrfs_fs_info *fs_info = root->fs_info;
315 526314 : struct btrfs_path *path;
316 526314 : struct btrfs_key key;
317 526314 : struct btrfs_inode_ref *ref;
318 526314 : unsigned long ptr;
319 526314 : int ret;
320 526314 : int ins_len = name->len + sizeof(*ref);
321 :
322 526314 : key.objectid = inode_objectid;
323 526314 : key.offset = ref_objectid;
324 526314 : key.type = BTRFS_INODE_REF_KEY;
325 :
326 526314 : path = btrfs_alloc_path();
327 526309 : if (!path)
328 : return -ENOMEM;
329 :
330 526309 : path->skip_release_on_error = 1;
331 526309 : ret = btrfs_insert_empty_item(trans, root, path, &key,
332 : ins_len);
333 526317 : if (ret == -EEXIST) {
334 345960 : u32 old_size;
335 345960 : ref = btrfs_find_name_in_backref(path->nodes[0], path->slots[0],
336 : name);
337 345960 : if (ref)
338 0 : goto out;
339 :
340 345960 : old_size = btrfs_item_size(path->nodes[0], path->slots[0]);
341 345960 : btrfs_extend_item(path, ins_len);
342 345958 : ref = btrfs_item_ptr(path->nodes[0], path->slots[0],
343 : struct btrfs_inode_ref);
344 345959 : ref = (struct btrfs_inode_ref *)((unsigned long)ref + old_size);
345 345959 : btrfs_set_inode_ref_name_len(path->nodes[0], ref, name->len);
346 345957 : btrfs_set_inode_ref_index(path->nodes[0], ref, index);
347 345958 : ptr = (unsigned long)(ref + 1);
348 345958 : ret = 0;
349 180357 : } 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 172317 : ref = btrfs_item_ptr(path->nodes[0], path->slots[0],
361 : struct btrfs_inode_ref);
362 172317 : btrfs_set_inode_ref_name_len(path->nodes[0], ref, name->len);
363 172317 : btrfs_set_inode_ref_index(path->nodes[0], ref, index);
364 172317 : ptr = (unsigned long)(ref + 1);
365 : }
366 518275 : write_extent_buffer(path->nodes[0], name->name, ptr, name->len);
367 518276 : btrfs_mark_buffer_dirty(path->nodes[0]);
368 :
369 526317 : out:
370 526317 : btrfs_free_path(path);
371 :
372 526317 : 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 525 : int btrfs_insert_empty_inode(struct btrfs_trans_handle *trans,
387 : struct btrfs_root *root,
388 : struct btrfs_path *path, u64 objectid)
389 : {
390 525 : struct btrfs_key key;
391 525 : int ret;
392 525 : key.objectid = objectid;
393 525 : key.type = BTRFS_INODE_ITEM_KEY;
394 525 : key.offset = 0;
395 :
396 525 : ret = btrfs_insert_empty_item(trans, root, path, &key,
397 : sizeof(struct btrfs_inode_item));
398 525 : return ret;
399 : }
400 :
401 9305972 : 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 9305972 : int ins_len = mod < 0 ? -1 : 0;
406 9305972 : int cow = mod != 0;
407 9305972 : int ret;
408 9305972 : int slot;
409 9305972 : struct extent_buffer *leaf;
410 9305972 : struct btrfs_key found_key;
411 :
412 9305972 : ret = btrfs_search_slot(trans, root, location, path, ins_len, cow);
413 9308622 : 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 4810136 : 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 4810136 : if (!inode)
433 : return;
434 2756477 : if (extent_type == BTRFS_FILE_EXTENT_INLINE)
435 739633 : trace_btrfs_truncate_show_fi_inline(inode, leaf, fi, slot,
436 : offset);
437 : else
438 2016844 : 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 2151054 : int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
460 : struct btrfs_root *root,
461 : struct btrfs_truncate_control *control)
462 : {
463 2151054 : struct btrfs_fs_info *fs_info = root->fs_info;
464 2151054 : struct btrfs_path *path;
465 2151054 : struct extent_buffer *leaf;
466 2151054 : struct btrfs_file_extent_item *fi;
467 2151054 : struct btrfs_key key;
468 2151054 : struct btrfs_key found_key;
469 2151054 : u64 new_size = control->new_size;
470 2151054 : u64 extent_num_bytes = 0;
471 2151054 : u64 extent_offset = 0;
472 2151054 : u64 item_end = 0;
473 2151054 : u32 found_type = (u8)-1;
474 2151054 : int del_item;
475 2151054 : int pending_del_nr = 0;
476 2151054 : int pending_del_slot = 0;
477 2151054 : int extent_type = -1;
478 2151054 : int ret;
479 2151054 : u64 bytes_deleted = 0;
480 2151054 : bool be_nice = false;
481 :
482 2151054 : ASSERT(control->inode || !control->clear_extent_range);
483 2151054 : ASSERT(new_size == 0 || control->min_type == BTRFS_EXTENT_DATA_KEY);
484 :
485 2151054 : control->last_size = new_size;
486 2151054 : 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 4302108 : if (test_bit(BTRFS_ROOT_SHAREABLE, &root->state))
493 2024709 : be_nice = true;
494 :
495 2151054 : path = btrfs_alloc_path();
496 2151051 : if (!path)
497 : return -ENOMEM;
498 2151051 : path->reada = READA_BACK;
499 :
500 2151051 : key.objectid = control->ino;
501 2151051 : key.offset = (u64)-1;
502 2151051 : key.type = (u8)-1;
503 :
504 2516623 : 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 2519395 : if (be_nice && bytes_deleted > SZ_32M &&
511 2772 : btrfs_should_end_transaction(trans)) {
512 2248 : ret = -EAGAIN;
513 2248 : goto out;
514 : }
515 :
516 2514375 : ret = btrfs_search_slot(trans, root, &key, path, -1, 1);
517 2514399 : if (ret < 0)
518 59 : goto out;
519 :
520 2514340 : if (ret > 0) {
521 2514340 : ret = 0;
522 : /* There are no items in the tree for us to truncate, we're done */
523 2514340 : if (path->slots[0] == 0)
524 25 : goto out;
525 2514315 : path->slots[0]--;
526 : }
527 :
528 11661105 : while (1) {
529 7087710 : u64 clear_start = 0, clear_len = 0, extent_start = 0;
530 7087710 : bool refill_delayed_refs_rsv = false;
531 :
532 7087710 : fi = NULL;
533 7087710 : leaf = path->nodes[0];
534 7087710 : btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]);
535 7087706 : found_type = found_key.type;
536 :
537 7087706 : if (found_key.objectid != control->ino)
538 : break;
539 :
540 7087706 : if (found_type < control->min_type)
541 : break;
542 :
543 7000950 : item_end = found_key.offset;
544 7000950 : if (found_type == BTRFS_EXTENT_DATA_KEY) {
545 4810139 : fi = btrfs_item_ptr(leaf, path->slots[0],
546 : struct btrfs_file_extent_item);
547 4810138 : extent_type = btrfs_file_extent_type(leaf, fi);
548 4810138 : if (extent_type != BTRFS_FILE_EXTENT_INLINE)
549 4070315 : item_end +=
550 : btrfs_file_extent_num_bytes(leaf, fi);
551 739823 : else if (extent_type == BTRFS_FILE_EXTENT_INLINE)
552 739823 : item_end += btrfs_file_extent_ram_bytes(leaf, fi);
553 :
554 4810136 : btrfs_trace_truncate(control->inode, leaf, fi,
555 : found_key.offset, extent_type,
556 : path->slots[0]);
557 4810136 : item_end--;
558 : }
559 7000947 : if (found_type > control->min_type) {
560 : del_item = 1;
561 : } else {
562 1312582 : if (item_end < new_size)
563 : break;
564 1228538 : if (found_key.offset >= new_size)
565 : del_item = 1;
566 : else
567 90723 : del_item = 0;
568 : }
569 :
570 : /* FIXME, shrink the extent if the ref count is only 1 */
571 6916903 : if (found_type != BTRFS_EXTENT_DATA_KEY)
572 2190811 : goto delete;
573 :
574 4726092 : control->extents_found++;
575 :
576 4726092 : if (extent_type != BTRFS_FILE_EXTENT_INLINE) {
577 3988515 : u64 num_dec;
578 :
579 3988515 : clear_start = found_key.offset;
580 3988515 : extent_start = btrfs_file_extent_disk_bytenr(leaf, fi);
581 3988515 : if (!del_item) {
582 90720 : u64 orig_num_bytes =
583 : btrfs_file_extent_num_bytes(leaf, fi);
584 90720 : extent_num_bytes = ALIGN(new_size -
585 : found_key.offset,
586 : fs_info->sectorsize);
587 90720 : clear_start = ALIGN(new_size, fs_info->sectorsize);
588 :
589 90720 : btrfs_set_file_extent_num_bytes(leaf, fi,
590 : extent_num_bytes);
591 90720 : num_dec = (orig_num_bytes - extent_num_bytes);
592 90720 : if (extent_start != 0)
593 90508 : control->sub_bytes += num_dec;
594 90720 : btrfs_mark_buffer_dirty(leaf);
595 : } else {
596 3897795 : extent_num_bytes =
597 : btrfs_file_extent_disk_num_bytes(leaf, fi);
598 3897796 : extent_offset = found_key.offset -
599 : btrfs_file_extent_offset(leaf, fi);
600 :
601 : /* FIXME blocksize != 4096 */
602 3897795 : num_dec = btrfs_file_extent_num_bytes(leaf, fi);
603 3897793 : if (extent_start != 0)
604 3438739 : control->sub_bytes += num_dec;
605 : }
606 : clear_len = num_dec;
607 737577 : } else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
608 : /*
609 : * We can't truncate inline items that have had
610 : * special encodings
611 : */
612 737580 : 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 737575 : } 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 737574 : clear_len = fs_info->sectorsize;
635 : }
636 :
637 737576 : control->sub_bytes += item_end + 1 - new_size;
638 : }
639 6916900 : 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 6916900 : if (control->clear_extent_range) {
646 1211813 : ret = btrfs_inode_clear_file_extent_range(control->inode,
647 : clear_start, clear_len);
648 1211813 : if (ret) {
649 0 : btrfs_abort_transaction(trans, ret);
650 0 : break;
651 : }
652 : }
653 :
654 6916900 : if (del_item) {
655 6826178 : ASSERT(!pending_del_nr ||
656 : ((path->slots[0] + 1) == pending_del_slot));
657 :
658 6826178 : control->last_size = found_key.offset;
659 6826178 : if (!pending_del_nr) {
660 : /* No pending yet, add ourselves */
661 2403771 : pending_del_slot = path->slots[0];
662 2403771 : pending_del_nr = 1;
663 4422407 : } else if (path->slots[0] + 1 == pending_del_slot) {
664 : /* Hop on the pending chunk */
665 4422407 : pending_del_nr++;
666 4422407 : pending_del_slot = path->slots[0];
667 : }
668 : } else {
669 90722 : control->last_size = new_size;
670 90722 : break;
671 : }
672 :
673 6826178 : if (del_item && extent_start != 0 && !control->skip_ref_updates) {
674 1860639 : struct btrfs_ref ref = { 0 };
675 :
676 1860639 : bytes_deleted += extent_num_bytes;
677 :
678 1860639 : btrfs_init_generic_ref(&ref, BTRFS_DROP_DELAYED_REF,
679 : extent_start, extent_num_bytes, 0);
680 1860639 : btrfs_init_data_ref(&ref, btrfs_header_owner(leaf),
681 : control->ino, extent_offset,
682 : root->root_key.objectid, false);
683 1860639 : ret = btrfs_free_extent(trans, &ref);
684 1860643 : if (ret) {
685 0 : btrfs_abort_transaction(trans, ret);
686 0 : break;
687 : }
688 1860643 : if (be_nice && btrfs_check_space_for_delayed_refs(fs_info))
689 313537 : refill_delayed_refs_rsv = true;
690 : }
691 :
692 6826182 : if (found_type == BTRFS_INODE_ITEM_KEY)
693 : break;
694 :
695 4942345 : if (path->slots[0] == 0 ||
696 4885431 : path->slots[0] != pending_del_slot ||
697 : refill_delayed_refs_rsv) {
698 368950 : if (pending_del_nr) {
699 368950 : ret = btrfs_del_items(trans, root, path,
700 : pending_del_slot,
701 : pending_del_nr);
702 368950 : if (ret) {
703 0 : btrfs_abort_transaction(trans, ret);
704 0 : break;
705 : }
706 : pending_del_nr = 0;
707 : }
708 368950 : 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 368950 : if (refill_delayed_refs_rsv) {
721 313537 : ret = btrfs_delayed_refs_rsv_refill(fs_info,
722 : BTRFS_RESERVE_NO_FLUSH);
723 313537 : if (ret) {
724 : ret = -EAGAIN;
725 : break;
726 : }
727 : }
728 365572 : goto search_again;
729 : } else {
730 4573395 : path->slots[0]--;
731 : }
732 : }
733 2054637 : out:
734 2151070 : if (ret >= 0 && pending_del_nr) {
735 2034822 : int err;
736 :
737 2034822 : err = btrfs_del_items(trans, root, path, pending_del_slot,
738 : pending_del_nr);
739 2034815 : if (err) {
740 0 : btrfs_abort_transaction(trans, err);
741 0 : ret = err;
742 : }
743 : }
744 :
745 2151063 : ASSERT(control->last_size >= new_size);
746 2151063 : if (!ret && control->last_size > new_size)
747 64174 : control->last_size = new_size;
748 :
749 2151063 : btrfs_free_path(path);
750 2151063 : return ret;
751 : }
|
