xref: /openbmc/u-boot/fs/btrfs/inode.c (revision 8a23fc9c)
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * BTRFS filesystem implementation for U-Boot
4  *
5  * 2017 Marek Behun, CZ.NIC, marek.behun@nic.cz
6  */
7 
8 #include "btrfs.h"
9 #include <malloc.h>
10 
11 u64 btrfs_lookup_inode_ref(struct btrfs_root *root, u64 inr,
12 			   struct btrfs_inode_ref *refp, char *name)
13 {
14 	struct btrfs_path path;
15 	struct btrfs_key *key;
16 	struct btrfs_inode_ref *ref;
17 	u64 res = -1ULL;
18 
19 	key = btrfs_search_tree_key_type(root, inr, BTRFS_INODE_REF_KEY,
20 					       &path);
21 
22 	if (!key)
23 		return -1ULL;
24 
25 	ref = btrfs_path_item_ptr(&path, struct btrfs_inode_ref);
26 	btrfs_inode_ref_to_cpu(ref);
27 
28 	if (refp)
29 		*refp = *ref;
30 
31 	if (name) {
32 		if (ref->name_len > BTRFS_NAME_MAX) {
33 			printf("%s: inode name too long: %u\n", __func__,
34 			        ref->name_len);
35 			goto out;
36 		}
37 
38 		memcpy(name, ref + 1, ref->name_len);
39 	}
40 
41 	res = key->offset;
42 out:
43 	btrfs_free_path(&path);
44 	return res;
45 }
46 
47 int btrfs_lookup_inode(const struct btrfs_root *root,
48 		       struct btrfs_key *location,
49 		       struct btrfs_inode_item *item,
50 		       struct btrfs_root *new_root)
51 {
52 	struct btrfs_root tmp_root = *root;
53 	struct btrfs_path path;
54 	int res = -1;
55 
56 	if (location->type == BTRFS_ROOT_ITEM_KEY) {
57 		if (btrfs_find_root(location->objectid, &tmp_root, NULL))
58 			return -1;
59 
60 		location->objectid = tmp_root.root_dirid;
61 		location->type = BTRFS_INODE_ITEM_KEY;
62 		location->offset = 0;
63 	}
64 
65 	if (btrfs_search_tree(&tmp_root, location, &path))
66 		return res;
67 
68 	if (btrfs_comp_keys(location, btrfs_path_leaf_key(&path)))
69 		goto out;
70 
71 	if (item) {
72 		*item = *btrfs_path_item_ptr(&path, struct btrfs_inode_item);
73 		btrfs_inode_item_to_cpu(item);
74 	}
75 
76 	if (new_root)
77 		*new_root = tmp_root;
78 
79 	res = 0;
80 
81 out:
82 	btrfs_free_path(&path);
83 	return res;
84 }
85 
86 int btrfs_readlink(const struct btrfs_root *root, u64 inr, char *target)
87 {
88 	struct btrfs_path path;
89 	struct btrfs_key key;
90 	struct btrfs_file_extent_item *extent;
91 	const char *data_ptr;
92 	int res = -1;
93 
94 	key.objectid = inr;
95 	key.type = BTRFS_EXTENT_DATA_KEY;
96 	key.offset = 0;
97 
98 	if (btrfs_search_tree(root, &key, &path))
99 		return -1;
100 
101 	if (btrfs_comp_keys(&key, btrfs_path_leaf_key(&path)))
102 		goto out;
103 
104 	extent = btrfs_path_item_ptr(&path, struct btrfs_file_extent_item);
105 	if (extent->type != BTRFS_FILE_EXTENT_INLINE) {
106 		printf("%s: Extent for symlink %llu not of INLINE type\n",
107 		       __func__, inr);
108 		goto out;
109 	}
110 
111 	btrfs_file_extent_item_to_cpu_inl(extent);
112 
113 	if (extent->compression != BTRFS_COMPRESS_NONE) {
114 		printf("%s: Symlink %llu extent data compressed!\n", __func__,
115 		       inr);
116 		goto out;
117 	} else if (extent->encryption != 0) {
118 		printf("%s: Symlink %llu extent data encrypted!\n", __func__,
119 		       inr);
120 		goto out;
121 	} else if (extent->ram_bytes >= btrfs_info.sb.sectorsize) {
122 		printf("%s: Symlink %llu extent data too long (%llu)!\n",
123 		       __func__, inr, extent->ram_bytes);
124 		goto out;
125 	}
126 
127 	data_ptr = (const char *) extent
128 		   + offsetof(struct btrfs_file_extent_item, disk_bytenr);
129 
130 	memcpy(target, data_ptr, extent->ram_bytes);
131 	target[extent->ram_bytes] = '\0';
132 	res = 0;
133 out:
134 	btrfs_free_path(&path);
135 	return res;
136 }
137 
138 /* inr must be a directory (for regular files with multiple hard links this
139    function returns only one of the parents of the file) */
140 static u64 get_parent_inode(struct btrfs_root *root, u64 inr,
141 			    struct btrfs_inode_item *inode_item)
142 {
143 	struct btrfs_key key;
144 	u64 res;
145 
146 	if (inr == BTRFS_FIRST_FREE_OBJECTID) {
147 		if (root->objectid != btrfs_info.fs_root.objectid) {
148 			u64 parent;
149 			struct btrfs_root_ref ref;
150 
151 			parent = btrfs_lookup_root_ref(root->objectid, &ref,
152 						       NULL);
153 			if (parent == -1ULL)
154 				return -1ULL;
155 
156 			if (btrfs_find_root(parent, root, NULL))
157 				return -1ULL;
158 
159 			inr = ref.dirid;
160 		}
161 
162 		if (inode_item) {
163 			key.objectid = inr;
164 			key.type = BTRFS_INODE_ITEM_KEY;
165 			key.offset = 0;
166 
167 			if (btrfs_lookup_inode(root, &key, inode_item, NULL))
168 				return -1ULL;
169 		}
170 
171 		return inr;
172 	}
173 
174 	res = btrfs_lookup_inode_ref(root, inr, NULL, NULL);
175 	if (res == -1ULL)
176 		return -1ULL;
177 
178 	if (inode_item) {
179 		key.objectid = res;
180 		key.type = BTRFS_INODE_ITEM_KEY;
181 		key.offset = 0;
182 
183 		if (btrfs_lookup_inode(root, &key, inode_item, NULL))
184 			return -1ULL;
185 	}
186 
187 	return res;
188 }
189 
190 static inline int next_length(const char *path)
191 {
192 	int res = 0;
193 	while (*path != '\0' && *path != '/' && res <= BTRFS_NAME_LEN)
194 		++res, ++path;
195 	return res;
196 }
197 
198 static inline const char *skip_current_directories(const char *cur)
199 {
200 	while (1) {
201 		if (cur[0] == '/')
202 			++cur;
203 		else if (cur[0] == '.' && cur[1] == '/')
204 			cur += 2;
205 		else
206 			break;
207 	}
208 
209 	return cur;
210 }
211 
212 u64 btrfs_lookup_path(struct btrfs_root *root, u64 inr, const char *path,
213 		      u8 *type_p, struct btrfs_inode_item *inode_item_p,
214 		      int symlink_limit)
215 {
216 	struct btrfs_dir_item item;
217 	struct btrfs_inode_item inode_item;
218 	u8 type = BTRFS_FT_DIR;
219 	int len, have_inode = 0;
220 	const char *cur = path;
221 
222 	if (*cur == '/') {
223 		++cur;
224 		inr = root->root_dirid;
225 	}
226 
227 	do {
228 		cur = skip_current_directories(cur);
229 
230 		len = next_length(cur);
231 		if (len > BTRFS_NAME_LEN) {
232 			printf("%s: Name too long at \"%.*s\"\n", __func__,
233 			       BTRFS_NAME_LEN, cur);
234 			return -1ULL;
235 		}
236 
237 		if (len == 1 && cur[0] == '.')
238 			break;
239 
240 		if (len == 2 && cur[0] == '.' && cur[1] == '.') {
241 			cur += 2;
242 			inr = get_parent_inode(root, inr, &inode_item);
243 			if (inr == -1ULL)
244 				return -1ULL;
245 
246 			type = BTRFS_FT_DIR;
247 			continue;
248 		}
249 
250 		if (!*cur)
251 			break;
252 
253 		if (btrfs_lookup_dir_item(root, inr, cur, len, &item))
254 			return -1ULL;
255 
256 		type = item.type;
257 		have_inode = 1;
258 		if (btrfs_lookup_inode(root, &item.location, &inode_item, root))
259 			return -1ULL;
260 
261 		if (item.type == BTRFS_FT_SYMLINK && symlink_limit >= 0) {
262 			char *target;
263 
264 			if (!symlink_limit) {
265 				printf("%s: Too much symlinks!\n", __func__);
266 				return -1ULL;
267 			}
268 
269 			target = malloc(min(inode_item.size + 1,
270 					    (u64) btrfs_info.sb.sectorsize));
271 			if (!target)
272 				return -1ULL;
273 
274 			if (btrfs_readlink(root, item.location.objectid,
275 					   target)) {
276 				free(target);
277 				return -1ULL;
278 			}
279 
280 			inr = btrfs_lookup_path(root, inr, target, &type,
281 						&inode_item, symlink_limit - 1);
282 
283 			free(target);
284 
285 			if (inr == -1ULL)
286 				return -1ULL;
287 		} else if (item.type != BTRFS_FT_DIR && cur[len]) {
288 			printf("%s: \"%.*s\" not a directory\n", __func__,
289 			       (int) (cur - path + len), path);
290 			return -1ULL;
291 		} else {
292 			inr = item.location.objectid;
293 		}
294 
295 		cur += len;
296 	} while (*cur);
297 
298 	if (type_p)
299 		*type_p = type;
300 
301 	if (inode_item_p) {
302 		if (!have_inode) {
303 			struct btrfs_key key;
304 
305 			key.objectid = inr;
306 			key.type = BTRFS_INODE_ITEM_KEY;
307 			key.offset = 0;
308 
309 			if (btrfs_lookup_inode(root, &key, &inode_item, NULL))
310 				return -1ULL;
311 		}
312 
313 		*inode_item_p = inode_item;
314 	}
315 
316 	return inr;
317 }
318 
319 u64 btrfs_file_read(const struct btrfs_root *root, u64 inr, u64 offset,
320 		    u64 size, char *buf)
321 {
322 	struct btrfs_path path;
323 	struct btrfs_key key;
324 	struct btrfs_file_extent_item *extent;
325 	int res = 0;
326 	u64 rd, rd_all = -1ULL;
327 
328 	key.objectid = inr;
329 	key.type = BTRFS_EXTENT_DATA_KEY;
330 	key.offset = offset;
331 
332 	if (btrfs_search_tree(root, &key, &path))
333 		return -1ULL;
334 
335 	if (btrfs_comp_keys(&key, btrfs_path_leaf_key(&path)) < 0) {
336 		if (btrfs_prev_slot(&path))
337 			goto out;
338 
339 		if (btrfs_comp_keys_type(&key, btrfs_path_leaf_key(&path)))
340 			goto out;
341 	}
342 
343 	rd_all = 0;
344 
345 	do {
346 		if (btrfs_comp_keys_type(&key, btrfs_path_leaf_key(&path)))
347 			break;
348 
349 		extent = btrfs_path_item_ptr(&path,
350 					     struct btrfs_file_extent_item);
351 
352 		if (extent->type == BTRFS_FILE_EXTENT_INLINE) {
353 			btrfs_file_extent_item_to_cpu_inl(extent);
354 			rd = btrfs_read_extent_inline(&path, extent, offset,
355 						      size, buf);
356 		} else {
357 			btrfs_file_extent_item_to_cpu(extent);
358 			rd = btrfs_read_extent_reg(&path, extent, offset, size,
359 						   buf);
360 		}
361 
362 		if (rd == -1ULL) {
363 			printf("%s: Error reading extent\n", __func__);
364 			rd_all = -1;
365 			goto out;
366 		}
367 
368 		offset = 0;
369 		buf += rd;
370 		rd_all += rd;
371 		size -= rd;
372 
373 		if (!size)
374 			break;
375 	} while (!(res = btrfs_next_slot(&path)));
376 
377 	if (res)
378 		return -1ULL;
379 
380 out:
381 	btrfs_free_path(&path);
382 	return rd_all;
383 }
384