1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * Copyright (C) 2007 Oracle. All rights reserved. |
4 | */ |
5 | |
6 | #include "messages.h" |
7 | #include "ctree.h" |
8 | #include "disk-io.h" |
9 | #include "transaction.h" |
10 | #include "accessors.h" |
11 | #include "dir-item.h" |
12 | |
13 | /* |
14 | * insert a name into a directory, doing overflow properly if there is a hash |
15 | * collision. data_size indicates how big the item inserted should be. On |
16 | * success a struct btrfs_dir_item pointer is returned, otherwise it is |
17 | * an ERR_PTR. |
18 | * |
19 | * The name is not copied into the dir item, you have to do that yourself. |
20 | */ |
21 | static struct btrfs_dir_item *insert_with_overflow(struct btrfs_trans_handle |
22 | *trans, |
23 | struct btrfs_root *root, |
24 | struct btrfs_path *path, |
25 | struct btrfs_key *cpu_key, |
26 | u32 data_size, |
27 | const char *name, |
28 | int name_len) |
29 | { |
30 | struct btrfs_fs_info *fs_info = root->fs_info; |
31 | int ret; |
32 | char *ptr; |
33 | struct extent_buffer *leaf; |
34 | |
35 | ret = btrfs_insert_empty_item(trans, root, path, key: cpu_key, data_size); |
36 | if (ret == -EEXIST) { |
37 | struct btrfs_dir_item *di; |
38 | di = btrfs_match_dir_item_name(fs_info, path, name, name_len); |
39 | if (di) |
40 | return ERR_PTR(error: -EEXIST); |
41 | btrfs_extend_item(trans, path, data_size); |
42 | } else if (ret < 0) |
43 | return ERR_PTR(error: ret); |
44 | WARN_ON(ret > 0); |
45 | leaf = path->nodes[0]; |
46 | ptr = btrfs_item_ptr(leaf, path->slots[0], char); |
47 | ASSERT(data_size <= btrfs_item_size(leaf, path->slots[0])); |
48 | ptr += btrfs_item_size(eb: leaf, slot: path->slots[0]) - data_size; |
49 | return (struct btrfs_dir_item *)ptr; |
50 | } |
51 | |
52 | /* |
53 | * xattrs work a lot like directories, this inserts an xattr item |
54 | * into the tree |
55 | */ |
56 | int btrfs_insert_xattr_item(struct btrfs_trans_handle *trans, |
57 | struct btrfs_root *root, |
58 | struct btrfs_path *path, u64 objectid, |
59 | const char *name, u16 name_len, |
60 | const void *data, u16 data_len) |
61 | { |
62 | int ret = 0; |
63 | struct btrfs_dir_item *dir_item; |
64 | unsigned long name_ptr, data_ptr; |
65 | struct btrfs_key key, location; |
66 | struct btrfs_disk_key disk_key; |
67 | struct extent_buffer *leaf; |
68 | u32 data_size; |
69 | |
70 | if (name_len + data_len > BTRFS_MAX_XATTR_SIZE(info: root->fs_info)) |
71 | return -ENOSPC; |
72 | |
73 | key.objectid = objectid; |
74 | key.type = BTRFS_XATTR_ITEM_KEY; |
75 | key.offset = btrfs_name_hash(name, len: name_len); |
76 | |
77 | data_size = sizeof(*dir_item) + name_len + data_len; |
78 | dir_item = insert_with_overflow(trans, root, path, cpu_key: &key, data_size, |
79 | name, name_len); |
80 | if (IS_ERR(ptr: dir_item)) |
81 | return PTR_ERR(ptr: dir_item); |
82 | memset(&location, 0, sizeof(location)); |
83 | |
84 | leaf = path->nodes[0]; |
85 | btrfs_cpu_key_to_disk(disk_key: &disk_key, cpu_key: &location); |
86 | btrfs_set_dir_item_key(eb: leaf, item: dir_item, key: &disk_key); |
87 | btrfs_set_dir_flags(eb: leaf, s: dir_item, BTRFS_FT_XATTR); |
88 | btrfs_set_dir_name_len(eb: leaf, s: dir_item, val: name_len); |
89 | btrfs_set_dir_transid(eb: leaf, s: dir_item, val: trans->transid); |
90 | btrfs_set_dir_data_len(eb: leaf, s: dir_item, val: data_len); |
91 | name_ptr = (unsigned long)(dir_item + 1); |
92 | data_ptr = (unsigned long)((char *)name_ptr + name_len); |
93 | |
94 | write_extent_buffer(eb: leaf, src: name, start: name_ptr, len: name_len); |
95 | write_extent_buffer(eb: leaf, src: data, start: data_ptr, len: data_len); |
96 | btrfs_mark_buffer_dirty(trans, buf: path->nodes[0]); |
97 | |
98 | return ret; |
99 | } |
100 | |
101 | /* |
102 | * insert a directory item in the tree, doing all the magic for |
103 | * both indexes. 'dir' indicates which objectid to insert it into, |
104 | * 'location' is the key to stuff into the directory item, 'type' is the |
105 | * type of the inode we're pointing to, and 'index' is the sequence number |
106 | * to use for the second index (if one is created). |
107 | * Will return 0 or -ENOMEM |
108 | */ |
109 | int btrfs_insert_dir_item(struct btrfs_trans_handle *trans, |
110 | const struct fscrypt_str *name, struct btrfs_inode *dir, |
111 | struct btrfs_key *location, u8 type, u64 index) |
112 | { |
113 | int ret = 0; |
114 | int ret2 = 0; |
115 | struct btrfs_root *root = dir->root; |
116 | struct btrfs_path *path; |
117 | struct btrfs_dir_item *dir_item; |
118 | struct extent_buffer *leaf; |
119 | unsigned long name_ptr; |
120 | struct btrfs_key key; |
121 | struct btrfs_disk_key disk_key; |
122 | u32 data_size; |
123 | |
124 | key.objectid = btrfs_ino(inode: dir); |
125 | key.type = BTRFS_DIR_ITEM_KEY; |
126 | key.offset = btrfs_name_hash(name: name->name, len: name->len); |
127 | |
128 | path = btrfs_alloc_path(); |
129 | if (!path) |
130 | return -ENOMEM; |
131 | |
132 | btrfs_cpu_key_to_disk(disk_key: &disk_key, cpu_key: location); |
133 | |
134 | data_size = sizeof(*dir_item) + name->len; |
135 | dir_item = insert_with_overflow(trans, root, path, cpu_key: &key, data_size, |
136 | name: name->name, name_len: name->len); |
137 | if (IS_ERR(ptr: dir_item)) { |
138 | ret = PTR_ERR(ptr: dir_item); |
139 | if (ret == -EEXIST) |
140 | goto second_insert; |
141 | goto out_free; |
142 | } |
143 | |
144 | if (IS_ENCRYPTED(&dir->vfs_inode)) |
145 | type |= BTRFS_FT_ENCRYPTED; |
146 | |
147 | leaf = path->nodes[0]; |
148 | btrfs_set_dir_item_key(eb: leaf, item: dir_item, key: &disk_key); |
149 | btrfs_set_dir_flags(eb: leaf, s: dir_item, val: type); |
150 | btrfs_set_dir_data_len(eb: leaf, s: dir_item, val: 0); |
151 | btrfs_set_dir_name_len(eb: leaf, s: dir_item, val: name->len); |
152 | btrfs_set_dir_transid(eb: leaf, s: dir_item, val: trans->transid); |
153 | name_ptr = (unsigned long)(dir_item + 1); |
154 | |
155 | write_extent_buffer(eb: leaf, src: name->name, start: name_ptr, len: name->len); |
156 | btrfs_mark_buffer_dirty(trans, buf: leaf); |
157 | |
158 | second_insert: |
159 | /* FIXME, use some real flag for selecting the extra index */ |
160 | if (root == root->fs_info->tree_root) { |
161 | ret = 0; |
162 | goto out_free; |
163 | } |
164 | btrfs_release_path(p: path); |
165 | |
166 | ret2 = btrfs_insert_delayed_dir_index(trans, name: name->name, name_len: name->len, dir, |
167 | disk_key: &disk_key, flags: type, index); |
168 | out_free: |
169 | btrfs_free_path(p: path); |
170 | if (ret) |
171 | return ret; |
172 | if (ret2) |
173 | return ret2; |
174 | return 0; |
175 | } |
176 | |
177 | static struct btrfs_dir_item *btrfs_lookup_match_dir( |
178 | struct btrfs_trans_handle *trans, |
179 | struct btrfs_root *root, struct btrfs_path *path, |
180 | struct btrfs_key *key, const char *name, |
181 | int name_len, int mod) |
182 | { |
183 | const int ins_len = (mod < 0 ? -1 : 0); |
184 | const int cow = (mod != 0); |
185 | int ret; |
186 | |
187 | ret = btrfs_search_slot(trans, root, key, p: path, ins_len, cow); |
188 | if (ret < 0) |
189 | return ERR_PTR(error: ret); |
190 | if (ret > 0) |
191 | return ERR_PTR(error: -ENOENT); |
192 | |
193 | return btrfs_match_dir_item_name(fs_info: root->fs_info, path, name, name_len); |
194 | } |
195 | |
196 | /* |
197 | * Lookup for a directory item by name. |
198 | * |
199 | * @trans: The transaction handle to use. Can be NULL if @mod is 0. |
200 | * @root: The root of the target tree. |
201 | * @path: Path to use for the search. |
202 | * @dir: The inode number (objectid) of the directory. |
203 | * @name: The name associated to the directory entry we are looking for. |
204 | * @name_len: The length of the name. |
205 | * @mod: Used to indicate if the tree search is meant for a read only |
206 | * lookup, for a modification lookup or for a deletion lookup, so |
207 | * its value should be 0, 1 or -1, respectively. |
208 | * |
209 | * Returns: NULL if the dir item does not exists, an error pointer if an error |
210 | * happened, or a pointer to a dir item if a dir item exists for the given name. |
211 | */ |
212 | struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans, |
213 | struct btrfs_root *root, |
214 | struct btrfs_path *path, u64 dir, |
215 | const struct fscrypt_str *name, |
216 | int mod) |
217 | { |
218 | struct btrfs_key key; |
219 | struct btrfs_dir_item *di; |
220 | |
221 | key.objectid = dir; |
222 | key.type = BTRFS_DIR_ITEM_KEY; |
223 | key.offset = btrfs_name_hash(name: name->name, len: name->len); |
224 | |
225 | di = btrfs_lookup_match_dir(trans, root, path, key: &key, name: name->name, |
226 | name_len: name->len, mod); |
227 | if (IS_ERR(ptr: di) && PTR_ERR(ptr: di) == -ENOENT) |
228 | return NULL; |
229 | |
230 | return di; |
231 | } |
232 | |
233 | int btrfs_check_dir_item_collision(struct btrfs_root *root, u64 dir, |
234 | const struct fscrypt_str *name) |
235 | { |
236 | int ret; |
237 | struct btrfs_key key; |
238 | struct btrfs_dir_item *di; |
239 | int data_size; |
240 | struct extent_buffer *leaf; |
241 | int slot; |
242 | struct btrfs_path *path; |
243 | |
244 | path = btrfs_alloc_path(); |
245 | if (!path) |
246 | return -ENOMEM; |
247 | |
248 | key.objectid = dir; |
249 | key.type = BTRFS_DIR_ITEM_KEY; |
250 | key.offset = btrfs_name_hash(name: name->name, len: name->len); |
251 | |
252 | di = btrfs_lookup_match_dir(NULL, root, path, key: &key, name: name->name, |
253 | name_len: name->len, mod: 0); |
254 | if (IS_ERR(ptr: di)) { |
255 | ret = PTR_ERR(ptr: di); |
256 | /* Nothing found, we're safe */ |
257 | if (ret == -ENOENT) { |
258 | ret = 0; |
259 | goto out; |
260 | } |
261 | |
262 | if (ret < 0) |
263 | goto out; |
264 | } |
265 | |
266 | /* we found an item, look for our name in the item */ |
267 | if (di) { |
268 | /* our exact name was found */ |
269 | ret = -EEXIST; |
270 | goto out; |
271 | } |
272 | |
273 | /* See if there is room in the item to insert this name. */ |
274 | data_size = sizeof(*di) + name->len; |
275 | leaf = path->nodes[0]; |
276 | slot = path->slots[0]; |
277 | if (data_size + btrfs_item_size(eb: leaf, slot) + |
278 | sizeof(struct btrfs_item) > BTRFS_LEAF_DATA_SIZE(info: root->fs_info)) { |
279 | ret = -EOVERFLOW; |
280 | } else { |
281 | /* plenty of insertion room */ |
282 | ret = 0; |
283 | } |
284 | out: |
285 | btrfs_free_path(p: path); |
286 | return ret; |
287 | } |
288 | |
289 | /* |
290 | * Lookup for a directory index item by name and index number. |
291 | * |
292 | * @trans: The transaction handle to use. Can be NULL if @mod is 0. |
293 | * @root: The root of the target tree. |
294 | * @path: Path to use for the search. |
295 | * @dir: The inode number (objectid) of the directory. |
296 | * @index: The index number. |
297 | * @name: The name associated to the directory entry we are looking for. |
298 | * @name_len: The length of the name. |
299 | * @mod: Used to indicate if the tree search is meant for a read only |
300 | * lookup, for a modification lookup or for a deletion lookup, so |
301 | * its value should be 0, 1 or -1, respectively. |
302 | * |
303 | * Returns: NULL if the dir index item does not exists, an error pointer if an |
304 | * error happened, or a pointer to a dir item if the dir index item exists and |
305 | * matches the criteria (name and index number). |
306 | */ |
307 | struct btrfs_dir_item * |
308 | btrfs_lookup_dir_index_item(struct btrfs_trans_handle *trans, |
309 | struct btrfs_root *root, |
310 | struct btrfs_path *path, u64 dir, |
311 | u64 index, const struct fscrypt_str *name, int mod) |
312 | { |
313 | struct btrfs_dir_item *di; |
314 | struct btrfs_key key; |
315 | |
316 | key.objectid = dir; |
317 | key.type = BTRFS_DIR_INDEX_KEY; |
318 | key.offset = index; |
319 | |
320 | di = btrfs_lookup_match_dir(trans, root, path, key: &key, name: name->name, |
321 | name_len: name->len, mod); |
322 | if (di == ERR_PTR(error: -ENOENT)) |
323 | return NULL; |
324 | |
325 | return di; |
326 | } |
327 | |
328 | struct btrfs_dir_item * |
329 | btrfs_search_dir_index_item(struct btrfs_root *root, struct btrfs_path *path, |
330 | u64 dirid, const struct fscrypt_str *name) |
331 | { |
332 | struct btrfs_dir_item *di; |
333 | struct btrfs_key key; |
334 | int ret; |
335 | |
336 | key.objectid = dirid; |
337 | key.type = BTRFS_DIR_INDEX_KEY; |
338 | key.offset = 0; |
339 | |
340 | btrfs_for_each_slot(root, &key, &key, path, ret) { |
341 | if (key.objectid != dirid || key.type != BTRFS_DIR_INDEX_KEY) |
342 | break; |
343 | |
344 | di = btrfs_match_dir_item_name(fs_info: root->fs_info, path, |
345 | name: name->name, name_len: name->len); |
346 | if (di) |
347 | return di; |
348 | } |
349 | /* Adjust return code if the key was not found in the next leaf. */ |
350 | if (ret > 0) |
351 | ret = 0; |
352 | |
353 | return ERR_PTR(error: ret); |
354 | } |
355 | |
356 | struct btrfs_dir_item *btrfs_lookup_xattr(struct btrfs_trans_handle *trans, |
357 | struct btrfs_root *root, |
358 | struct btrfs_path *path, u64 dir, |
359 | const char *name, u16 name_len, |
360 | int mod) |
361 | { |
362 | struct btrfs_key key; |
363 | struct btrfs_dir_item *di; |
364 | |
365 | key.objectid = dir; |
366 | key.type = BTRFS_XATTR_ITEM_KEY; |
367 | key.offset = btrfs_name_hash(name, len: name_len); |
368 | |
369 | di = btrfs_lookup_match_dir(trans, root, path, key: &key, name, name_len, mod); |
370 | if (IS_ERR(ptr: di) && PTR_ERR(ptr: di) == -ENOENT) |
371 | return NULL; |
372 | |
373 | return di; |
374 | } |
375 | |
376 | /* |
377 | * helper function to look at the directory item pointed to by 'path' |
378 | * this walks through all the entries in a dir item and finds one |
379 | * for a specific name. |
380 | */ |
381 | struct btrfs_dir_item *btrfs_match_dir_item_name(struct btrfs_fs_info *fs_info, |
382 | struct btrfs_path *path, |
383 | const char *name, int name_len) |
384 | { |
385 | struct btrfs_dir_item *dir_item; |
386 | unsigned long name_ptr; |
387 | u32 total_len; |
388 | u32 cur = 0; |
389 | u32 this_len; |
390 | struct extent_buffer *leaf; |
391 | |
392 | leaf = path->nodes[0]; |
393 | dir_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dir_item); |
394 | |
395 | total_len = btrfs_item_size(eb: leaf, slot: path->slots[0]); |
396 | while (cur < total_len) { |
397 | this_len = sizeof(*dir_item) + |
398 | btrfs_dir_name_len(eb: leaf, s: dir_item) + |
399 | btrfs_dir_data_len(eb: leaf, s: dir_item); |
400 | name_ptr = (unsigned long)(dir_item + 1); |
401 | |
402 | if (btrfs_dir_name_len(eb: leaf, s: dir_item) == name_len && |
403 | memcmp_extent_buffer(eb: leaf, ptrv: name, start: name_ptr, len: name_len) == 0) |
404 | return dir_item; |
405 | |
406 | cur += this_len; |
407 | dir_item = (struct btrfs_dir_item *)((char *)dir_item + |
408 | this_len); |
409 | } |
410 | return NULL; |
411 | } |
412 | |
413 | /* |
414 | * given a pointer into a directory item, delete it. This |
415 | * handles items that have more than one entry in them. |
416 | */ |
417 | int btrfs_delete_one_dir_name(struct btrfs_trans_handle *trans, |
418 | struct btrfs_root *root, |
419 | struct btrfs_path *path, |
420 | struct btrfs_dir_item *di) |
421 | { |
422 | |
423 | struct extent_buffer *leaf; |
424 | u32 sub_item_len; |
425 | u32 item_len; |
426 | int ret = 0; |
427 | |
428 | leaf = path->nodes[0]; |
429 | sub_item_len = sizeof(*di) + btrfs_dir_name_len(eb: leaf, s: di) + |
430 | btrfs_dir_data_len(eb: leaf, s: di); |
431 | item_len = btrfs_item_size(eb: leaf, slot: path->slots[0]); |
432 | if (sub_item_len == item_len) { |
433 | ret = btrfs_del_item(trans, root, path); |
434 | } else { |
435 | /* MARKER */ |
436 | unsigned long ptr = (unsigned long)di; |
437 | unsigned long start; |
438 | |
439 | start = btrfs_item_ptr_offset(leaf, path->slots[0]); |
440 | memmove_extent_buffer(dst: leaf, dst_offset: ptr, src_offset: ptr + sub_item_len, |
441 | len: item_len - (ptr + sub_item_len - start)); |
442 | btrfs_truncate_item(trans, path, new_size: item_len - sub_item_len, from_end: 1); |
443 | } |
444 | return ret; |
445 | } |
446 | |