xref: /openbmc/u-boot/fs/fs.c (revision 19a5ef60)
1 /*
2  * Copyright (c) 2012, NVIDIA CORPORATION.  All rights reserved.
3  *
4  * SPDX-License-Identifier:	GPL-2.0
5  */
6 
7 #include <config.h>
8 #include <errno.h>
9 #include <common.h>
10 #include <mapmem.h>
11 #include <part.h>
12 #include <ext4fs.h>
13 #include <fat.h>
14 #include <fs.h>
15 #include <sandboxfs.h>
16 #include <ubifs_uboot.h>
17 #include <asm/io.h>
18 #include <div64.h>
19 #include <linux/math64.h>
20 
21 DECLARE_GLOBAL_DATA_PTR;
22 
23 static block_dev_desc_t *fs_dev_desc;
24 static disk_partition_t fs_partition;
25 static int fs_type = FS_TYPE_ANY;
26 
27 static inline int fs_probe_unsupported(block_dev_desc_t *fs_dev_desc,
28 				      disk_partition_t *fs_partition)
29 {
30 	printf("** Unrecognized filesystem type **\n");
31 	return -1;
32 }
33 
34 static inline int fs_ls_unsupported(const char *dirname)
35 {
36 	return -1;
37 }
38 
39 static inline int fs_exists_unsupported(const char *filename)
40 {
41 	return 0;
42 }
43 
44 static inline int fs_size_unsupported(const char *filename, loff_t *size)
45 {
46 	return -1;
47 }
48 
49 static inline int fs_read_unsupported(const char *filename, void *buf,
50 				      loff_t offset, loff_t len,
51 				      loff_t *actread)
52 {
53 	return -1;
54 }
55 
56 static inline int fs_write_unsupported(const char *filename, void *buf,
57 				      loff_t offset, loff_t len,
58 				      loff_t *actwrite)
59 {
60 	return -1;
61 }
62 
63 static inline void fs_close_unsupported(void)
64 {
65 }
66 
67 static inline int fs_uuid_unsupported(char *uuid_str)
68 {
69 	return -1;
70 }
71 
72 struct fstype_info {
73 	int fstype;
74 	char *name;
75 	/*
76 	 * Is it legal to pass NULL as .probe()'s  fs_dev_desc parameter? This
77 	 * should be false in most cases. For "virtual" filesystems which
78 	 * aren't based on a U-Boot block device (e.g. sandbox), this can be
79 	 * set to true. This should also be true for the dumm entry at the end
80 	 * of fstypes[], since that is essentially a "virtual" (non-existent)
81 	 * filesystem.
82 	 */
83 	bool null_dev_desc_ok;
84 	int (*probe)(block_dev_desc_t *fs_dev_desc,
85 		     disk_partition_t *fs_partition);
86 	int (*ls)(const char *dirname);
87 	int (*exists)(const char *filename);
88 	int (*size)(const char *filename, loff_t *size);
89 	int (*read)(const char *filename, void *buf, loff_t offset,
90 		    loff_t len, loff_t *actread);
91 	int (*write)(const char *filename, void *buf, loff_t offset,
92 		     loff_t len, loff_t *actwrite);
93 	void (*close)(void);
94 	int (*uuid)(char *uuid_str);
95 };
96 
97 static struct fstype_info fstypes[] = {
98 #ifdef CONFIG_FS_FAT
99 	{
100 		.fstype = FS_TYPE_FAT,
101 		.name = "fat",
102 		.null_dev_desc_ok = false,
103 		.probe = fat_set_blk_dev,
104 		.close = fat_close,
105 		.ls = file_fat_ls,
106 		.exists = fat_exists,
107 		.size = fat_size,
108 		.read = fat_read_file,
109 #ifdef CONFIG_FAT_WRITE
110 		.write = file_fat_write,
111 #else
112 		.write = fs_write_unsupported,
113 #endif
114 		.uuid = fs_uuid_unsupported,
115 	},
116 #endif
117 #ifdef CONFIG_FS_EXT4
118 	{
119 		.fstype = FS_TYPE_EXT,
120 		.name = "ext4",
121 		.null_dev_desc_ok = false,
122 		.probe = ext4fs_probe,
123 		.close = ext4fs_close,
124 		.ls = ext4fs_ls,
125 		.exists = ext4fs_exists,
126 		.size = ext4fs_size,
127 		.read = ext4_read_file,
128 #ifdef CONFIG_CMD_EXT4_WRITE
129 		.write = ext4_write_file,
130 #else
131 		.write = fs_write_unsupported,
132 #endif
133 		.uuid = ext4fs_uuid,
134 	},
135 #endif
136 #ifdef CONFIG_SANDBOX
137 	{
138 		.fstype = FS_TYPE_SANDBOX,
139 		.name = "sandbox",
140 		.null_dev_desc_ok = true,
141 		.probe = sandbox_fs_set_blk_dev,
142 		.close = sandbox_fs_close,
143 		.ls = sandbox_fs_ls,
144 		.exists = sandbox_fs_exists,
145 		.size = sandbox_fs_size,
146 		.read = fs_read_sandbox,
147 		.write = fs_write_sandbox,
148 		.uuid = fs_uuid_unsupported,
149 	},
150 #endif
151 #ifdef CONFIG_CMD_UBIFS
152 	{
153 		.fstype = FS_TYPE_UBIFS,
154 		.name = "ubifs",
155 		.null_dev_desc_ok = true,
156 		.probe = ubifs_set_blk_dev,
157 		.close = ubifs_close,
158 		.ls = ubifs_ls,
159 		.exists = ubifs_exists,
160 		.size = ubifs_size,
161 		.read = ubifs_read,
162 		.write = fs_write_unsupported,
163 		.uuid = fs_uuid_unsupported,
164 	},
165 #endif
166 	{
167 		.fstype = FS_TYPE_ANY,
168 		.name = "unsupported",
169 		.null_dev_desc_ok = true,
170 		.probe = fs_probe_unsupported,
171 		.close = fs_close_unsupported,
172 		.ls = fs_ls_unsupported,
173 		.exists = fs_exists_unsupported,
174 		.size = fs_size_unsupported,
175 		.read = fs_read_unsupported,
176 		.write = fs_write_unsupported,
177 		.uuid = fs_uuid_unsupported,
178 	},
179 };
180 
181 static struct fstype_info *fs_get_info(int fstype)
182 {
183 	struct fstype_info *info;
184 	int i;
185 
186 	for (i = 0, info = fstypes; i < ARRAY_SIZE(fstypes) - 1; i++, info++) {
187 		if (fstype == info->fstype)
188 			return info;
189 	}
190 
191 	/* Return the 'unsupported' sentinel */
192 	return info;
193 }
194 
195 int fs_set_blk_dev(const char *ifname, const char *dev_part_str, int fstype)
196 {
197 	struct fstype_info *info;
198 	int part, i;
199 #ifdef CONFIG_NEEDS_MANUAL_RELOC
200 	static int relocated;
201 
202 	if (!relocated) {
203 		for (i = 0, info = fstypes; i < ARRAY_SIZE(fstypes);
204 				i++, info++) {
205 			info->name += gd->reloc_off;
206 			info->probe += gd->reloc_off;
207 			info->close += gd->reloc_off;
208 			info->ls += gd->reloc_off;
209 			info->read += gd->reloc_off;
210 			info->write += gd->reloc_off;
211 		}
212 		relocated = 1;
213 	}
214 #endif
215 
216 	part = get_device_and_partition(ifname, dev_part_str, &fs_dev_desc,
217 					&fs_partition, 1);
218 	if (part < 0)
219 		return -1;
220 
221 	for (i = 0, info = fstypes; i < ARRAY_SIZE(fstypes); i++, info++) {
222 		if (fstype != FS_TYPE_ANY && info->fstype != FS_TYPE_ANY &&
223 				fstype != info->fstype)
224 			continue;
225 
226 		if (!fs_dev_desc && !info->null_dev_desc_ok)
227 			continue;
228 
229 		if (!info->probe(fs_dev_desc, &fs_partition)) {
230 			fs_type = info->fstype;
231 			return 0;
232 		}
233 	}
234 
235 	return -1;
236 }
237 
238 static void fs_close(void)
239 {
240 	struct fstype_info *info = fs_get_info(fs_type);
241 
242 	info->close();
243 
244 	fs_type = FS_TYPE_ANY;
245 }
246 
247 int fs_uuid(char *uuid_str)
248 {
249 	struct fstype_info *info = fs_get_info(fs_type);
250 
251 	return info->uuid(uuid_str);
252 }
253 
254 int fs_ls(const char *dirname)
255 {
256 	int ret;
257 
258 	struct fstype_info *info = fs_get_info(fs_type);
259 
260 	ret = info->ls(dirname);
261 
262 	fs_type = FS_TYPE_ANY;
263 	fs_close();
264 
265 	return ret;
266 }
267 
268 int fs_exists(const char *filename)
269 {
270 	int ret;
271 
272 	struct fstype_info *info = fs_get_info(fs_type);
273 
274 	ret = info->exists(filename);
275 
276 	fs_close();
277 
278 	return ret;
279 }
280 
281 int fs_size(const char *filename, loff_t *size)
282 {
283 	int ret;
284 
285 	struct fstype_info *info = fs_get_info(fs_type);
286 
287 	ret = info->size(filename, size);
288 
289 	fs_close();
290 
291 	return ret;
292 }
293 
294 int fs_read(const char *filename, ulong addr, loff_t offset, loff_t len,
295 	    loff_t *actread)
296 {
297 	struct fstype_info *info = fs_get_info(fs_type);
298 	void *buf;
299 	int ret;
300 
301 	/*
302 	 * We don't actually know how many bytes are being read, since len==0
303 	 * means read the whole file.
304 	 */
305 	buf = map_sysmem(addr, len);
306 	ret = info->read(filename, buf, offset, len, actread);
307 	unmap_sysmem(buf);
308 
309 	/* If we requested a specific number of bytes, check we got it */
310 	if (ret == 0 && len && *actread != len)
311 		printf("** %s shorter than offset + len **\n", filename);
312 	fs_close();
313 
314 	return ret;
315 }
316 
317 int fs_write(const char *filename, ulong addr, loff_t offset, loff_t len,
318 	     loff_t *actwrite)
319 {
320 	struct fstype_info *info = fs_get_info(fs_type);
321 	void *buf;
322 	int ret;
323 
324 	buf = map_sysmem(addr, len);
325 	ret = info->write(filename, buf, offset, len, actwrite);
326 	unmap_sysmem(buf);
327 
328 	if (ret < 0 && len != *actwrite) {
329 		printf("** Unable to write file %s **\n", filename);
330 		ret = -1;
331 	}
332 	fs_close();
333 
334 	return ret;
335 }
336 
337 int do_size(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
338 		int fstype)
339 {
340 	loff_t size;
341 
342 	if (argc != 4)
343 		return CMD_RET_USAGE;
344 
345 	if (fs_set_blk_dev(argv[1], argv[2], fstype))
346 		return 1;
347 
348 	if (fs_size(argv[3], &size) < 0)
349 		return CMD_RET_FAILURE;
350 
351 	setenv_hex("filesize", size);
352 
353 	return 0;
354 }
355 
356 int do_load(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
357 		int fstype)
358 {
359 	unsigned long addr;
360 	const char *addr_str;
361 	const char *filename;
362 	loff_t bytes;
363 	loff_t pos;
364 	loff_t len_read;
365 	int ret;
366 	unsigned long time;
367 	char *ep;
368 
369 	if (argc < 2)
370 		return CMD_RET_USAGE;
371 	if (argc > 7)
372 		return CMD_RET_USAGE;
373 
374 	if (fs_set_blk_dev(argv[1], (argc >= 3) ? argv[2] : NULL, fstype))
375 		return 1;
376 
377 	if (argc >= 4) {
378 		addr = simple_strtoul(argv[3], &ep, 16);
379 		if (ep == argv[3] || *ep != '\0')
380 			return CMD_RET_USAGE;
381 	} else {
382 		addr_str = getenv("loadaddr");
383 		if (addr_str != NULL)
384 			addr = simple_strtoul(addr_str, NULL, 16);
385 		else
386 			addr = CONFIG_SYS_LOAD_ADDR;
387 	}
388 	if (argc >= 5) {
389 		filename = argv[4];
390 	} else {
391 		filename = getenv("bootfile");
392 		if (!filename) {
393 			puts("** No boot file defined **\n");
394 			return 1;
395 		}
396 	}
397 	if (argc >= 6)
398 		bytes = simple_strtoul(argv[5], NULL, 16);
399 	else
400 		bytes = 0;
401 	if (argc >= 7)
402 		pos = simple_strtoul(argv[6], NULL, 16);
403 	else
404 		pos = 0;
405 
406 	time = get_timer(0);
407 	ret = fs_read(filename, addr, pos, bytes, &len_read);
408 	time = get_timer(time);
409 	if (ret < 0)
410 		return 1;
411 
412 	printf("%llu bytes read in %lu ms", len_read, time);
413 	if (time > 0) {
414 		puts(" (");
415 		print_size(div_u64(len_read, time) * 1000, "/s");
416 		puts(")");
417 	}
418 	puts("\n");
419 
420 	setenv_hex("fileaddr", addr);
421 	setenv_hex("filesize", len_read);
422 
423 	return 0;
424 }
425 
426 int do_ls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
427 	int fstype)
428 {
429 	if (argc < 2)
430 		return CMD_RET_USAGE;
431 	if (argc > 4)
432 		return CMD_RET_USAGE;
433 
434 	if (fs_set_blk_dev(argv[1], (argc >= 3) ? argv[2] : NULL, fstype))
435 		return 1;
436 
437 	if (fs_ls(argc >= 4 ? argv[3] : "/"))
438 		return 1;
439 
440 	return 0;
441 }
442 
443 int file_exists(const char *dev_type, const char *dev_part, const char *file,
444 		int fstype)
445 {
446 	if (fs_set_blk_dev(dev_type, dev_part, fstype))
447 		return 0;
448 
449 	return fs_exists(file);
450 }
451 
452 int do_save(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
453 		int fstype)
454 {
455 	unsigned long addr;
456 	const char *filename;
457 	loff_t bytes;
458 	loff_t pos;
459 	loff_t len;
460 	int ret;
461 	unsigned long time;
462 
463 	if (argc < 6 || argc > 7)
464 		return CMD_RET_USAGE;
465 
466 	if (fs_set_blk_dev(argv[1], argv[2], fstype))
467 		return 1;
468 
469 	addr = simple_strtoul(argv[3], NULL, 16);
470 	filename = argv[4];
471 	bytes = simple_strtoul(argv[5], NULL, 16);
472 	if (argc >= 7)
473 		pos = simple_strtoul(argv[6], NULL, 16);
474 	else
475 		pos = 0;
476 
477 	time = get_timer(0);
478 	ret = fs_write(filename, addr, pos, bytes, &len);
479 	time = get_timer(time);
480 	if (ret < 0)
481 		return 1;
482 
483 	printf("%llu bytes written in %lu ms", len, time);
484 	if (time > 0) {
485 		puts(" (");
486 		print_size(div_u64(len, time) * 1000, "/s");
487 		puts(")");
488 	}
489 	puts("\n");
490 
491 	return 0;
492 }
493 
494 int do_fs_uuid(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
495 		int fstype)
496 {
497 	int ret;
498 	char uuid[37];
499 	memset(uuid, 0, sizeof(uuid));
500 
501 	if (argc < 3 || argc > 4)
502 		return CMD_RET_USAGE;
503 
504 	if (fs_set_blk_dev(argv[1], argv[2], fstype))
505 		return 1;
506 
507 	ret = fs_uuid(uuid);
508 	if (ret)
509 		return CMD_RET_FAILURE;
510 
511 	if (argc == 4)
512 		setenv(argv[3], uuid);
513 	else
514 		printf("%s\n", uuid);
515 
516 	return CMD_RET_SUCCESS;
517 }
518 
519 int do_fs_type(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
520 {
521 	struct fstype_info *info;
522 
523 	if (argc < 3 || argc > 4)
524 		return CMD_RET_USAGE;
525 
526 	if (fs_set_blk_dev(argv[1], argv[2], FS_TYPE_ANY))
527 		return 1;
528 
529 	info = fs_get_info(fs_type);
530 
531 	if (argc == 4)
532 		setenv(argv[3], info->name);
533 	else
534 		printf("%s\n", info->name);
535 
536 	return CMD_RET_SUCCESS;
537 }
538 
539