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