xref: /openbmc/u-boot/fs/fs.c (revision e3b1aaa4)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (c) 2012, NVIDIA CORPORATION.  All rights reserved.
4  */
5 
6 #include <config.h>
7 #include <errno.h>
8 #include <common.h>
9 #include <mapmem.h>
10 #include <part.h>
11 #include <ext4fs.h>
12 #include <fat.h>
13 #include <fs.h>
14 #include <sandboxfs.h>
15 #include <ubifs_uboot.h>
16 #include <btrfs.h>
17 #include <asm/io.h>
18 #include <div64.h>
19 #include <linux/math64.h>
20 
21 DECLARE_GLOBAL_DATA_PTR;
22 
23 static struct blk_desc *fs_dev_desc;
24 static int fs_dev_part;
25 static disk_partition_t fs_partition;
26 static int fs_type = FS_TYPE_ANY;
27 
28 static inline int fs_probe_unsupported(struct blk_desc *fs_dev_desc,
29 				      disk_partition_t *fs_partition)
30 {
31 	printf("** Unrecognized filesystem type **\n");
32 	return -1;
33 }
34 
35 static inline int fs_ls_unsupported(const char *dirname)
36 {
37 	return -1;
38 }
39 
40 /* generic implementation of ls in terms of opendir/readdir/closedir */
41 __maybe_unused
42 static int fs_ls_generic(const char *dirname)
43 {
44 	struct fs_dir_stream *dirs;
45 	struct fs_dirent *dent;
46 	int nfiles = 0, ndirs = 0;
47 
48 	dirs = fs_opendir(dirname);
49 	if (!dirs)
50 		return -errno;
51 
52 	while ((dent = fs_readdir(dirs))) {
53 		if (dent->type == FS_DT_DIR) {
54 			printf("            %s/\n", dent->name);
55 			ndirs++;
56 		} else {
57 			printf(" %8lld   %s\n", dent->size, dent->name);
58 			nfiles++;
59 		}
60 	}
61 
62 	fs_closedir(dirs);
63 
64 	printf("\n%d file(s), %d dir(s)\n\n", nfiles, ndirs);
65 
66 	return 0;
67 }
68 
69 static inline int fs_exists_unsupported(const char *filename)
70 {
71 	return 0;
72 }
73 
74 static inline int fs_size_unsupported(const char *filename, loff_t *size)
75 {
76 	return -1;
77 }
78 
79 static inline int fs_read_unsupported(const char *filename, void *buf,
80 				      loff_t offset, loff_t len,
81 				      loff_t *actread)
82 {
83 	return -1;
84 }
85 
86 static inline int fs_write_unsupported(const char *filename, void *buf,
87 				      loff_t offset, loff_t len,
88 				      loff_t *actwrite)
89 {
90 	return -1;
91 }
92 
93 static inline void fs_close_unsupported(void)
94 {
95 }
96 
97 static inline int fs_uuid_unsupported(char *uuid_str)
98 {
99 	return -1;
100 }
101 
102 static inline int fs_opendir_unsupported(const char *filename,
103 					 struct fs_dir_stream **dirs)
104 {
105 	return -EACCES;
106 }
107 
108 struct fstype_info {
109 	int fstype;
110 	char *name;
111 	/*
112 	 * Is it legal to pass NULL as .probe()'s  fs_dev_desc parameter? This
113 	 * should be false in most cases. For "virtual" filesystems which
114 	 * aren't based on a U-Boot block device (e.g. sandbox), this can be
115 	 * set to true. This should also be true for the dumm entry at the end
116 	 * of fstypes[], since that is essentially a "virtual" (non-existent)
117 	 * filesystem.
118 	 */
119 	bool null_dev_desc_ok;
120 	int (*probe)(struct blk_desc *fs_dev_desc,
121 		     disk_partition_t *fs_partition);
122 	int (*ls)(const char *dirname);
123 	int (*exists)(const char *filename);
124 	int (*size)(const char *filename, loff_t *size);
125 	int (*read)(const char *filename, void *buf, loff_t offset,
126 		    loff_t len, loff_t *actread);
127 	int (*write)(const char *filename, void *buf, loff_t offset,
128 		     loff_t len, loff_t *actwrite);
129 	void (*close)(void);
130 	int (*uuid)(char *uuid_str);
131 	/*
132 	 * Open a directory stream.  On success return 0 and directory
133 	 * stream pointer via 'dirsp'.  On error, return -errno.  See
134 	 * fs_opendir().
135 	 */
136 	int (*opendir)(const char *filename, struct fs_dir_stream **dirsp);
137 	/*
138 	 * Read next entry from directory stream.  On success return 0
139 	 * and directory entry pointer via 'dentp'.  On error return
140 	 * -errno.  See fs_readdir().
141 	 */
142 	int (*readdir)(struct fs_dir_stream *dirs, struct fs_dirent **dentp);
143 	/* see fs_closedir() */
144 	void (*closedir)(struct fs_dir_stream *dirs);
145 };
146 
147 static struct fstype_info fstypes[] = {
148 #ifdef CONFIG_FS_FAT
149 	{
150 		.fstype = FS_TYPE_FAT,
151 		.name = "fat",
152 		.null_dev_desc_ok = false,
153 		.probe = fat_set_blk_dev,
154 		.close = fat_close,
155 		.ls = fs_ls_generic,
156 		.exists = fat_exists,
157 		.size = fat_size,
158 		.read = fat_read_file,
159 #ifdef CONFIG_FAT_WRITE
160 		.write = file_fat_write,
161 #else
162 		.write = fs_write_unsupported,
163 #endif
164 		.uuid = fs_uuid_unsupported,
165 		.opendir = fat_opendir,
166 		.readdir = fat_readdir,
167 		.closedir = fat_closedir,
168 	},
169 #endif
170 #ifdef CONFIG_FS_EXT4
171 	{
172 		.fstype = FS_TYPE_EXT,
173 		.name = "ext4",
174 		.null_dev_desc_ok = false,
175 		.probe = ext4fs_probe,
176 		.close = ext4fs_close,
177 		.ls = ext4fs_ls,
178 		.exists = ext4fs_exists,
179 		.size = ext4fs_size,
180 		.read = ext4_read_file,
181 #ifdef CONFIG_CMD_EXT4_WRITE
182 		.write = ext4_write_file,
183 #else
184 		.write = fs_write_unsupported,
185 #endif
186 		.uuid = ext4fs_uuid,
187 		.opendir = fs_opendir_unsupported,
188 	},
189 #endif
190 #ifdef CONFIG_SANDBOX
191 	{
192 		.fstype = FS_TYPE_SANDBOX,
193 		.name = "sandbox",
194 		.null_dev_desc_ok = true,
195 		.probe = sandbox_fs_set_blk_dev,
196 		.close = sandbox_fs_close,
197 		.ls = sandbox_fs_ls,
198 		.exists = sandbox_fs_exists,
199 		.size = sandbox_fs_size,
200 		.read = fs_read_sandbox,
201 		.write = fs_write_sandbox,
202 		.uuid = fs_uuid_unsupported,
203 		.opendir = fs_opendir_unsupported,
204 	},
205 #endif
206 #ifdef CONFIG_CMD_UBIFS
207 	{
208 		.fstype = FS_TYPE_UBIFS,
209 		.name = "ubifs",
210 		.null_dev_desc_ok = true,
211 		.probe = ubifs_set_blk_dev,
212 		.close = ubifs_close,
213 		.ls = ubifs_ls,
214 		.exists = ubifs_exists,
215 		.size = ubifs_size,
216 		.read = ubifs_read,
217 		.write = fs_write_unsupported,
218 		.uuid = fs_uuid_unsupported,
219 		.opendir = fs_opendir_unsupported,
220 	},
221 #endif
222 #ifdef CONFIG_FS_BTRFS
223 	{
224 		.fstype = FS_TYPE_BTRFS,
225 		.name = "btrfs",
226 		.null_dev_desc_ok = false,
227 		.probe = btrfs_probe,
228 		.close = btrfs_close,
229 		.ls = btrfs_ls,
230 		.exists = btrfs_exists,
231 		.size = btrfs_size,
232 		.read = btrfs_read,
233 		.write = fs_write_unsupported,
234 		.uuid = btrfs_uuid,
235 		.opendir = fs_opendir_unsupported,
236 	},
237 #endif
238 	{
239 		.fstype = FS_TYPE_ANY,
240 		.name = "unsupported",
241 		.null_dev_desc_ok = true,
242 		.probe = fs_probe_unsupported,
243 		.close = fs_close_unsupported,
244 		.ls = fs_ls_unsupported,
245 		.exists = fs_exists_unsupported,
246 		.size = fs_size_unsupported,
247 		.read = fs_read_unsupported,
248 		.write = fs_write_unsupported,
249 		.uuid = fs_uuid_unsupported,
250 		.opendir = fs_opendir_unsupported,
251 	},
252 };
253 
254 static struct fstype_info *fs_get_info(int fstype)
255 {
256 	struct fstype_info *info;
257 	int i;
258 
259 	for (i = 0, info = fstypes; i < ARRAY_SIZE(fstypes) - 1; i++, info++) {
260 		if (fstype == info->fstype)
261 			return info;
262 	}
263 
264 	/* Return the 'unsupported' sentinel */
265 	return info;
266 }
267 
268 /**
269  * fs_get_type_name() - Get type of current filesystem
270  *
271  * Return: Pointer to filesystem name
272  *
273  * Returns a string describing the current filesystem, or the sentinel
274  * "unsupported" for any unrecognised filesystem.
275  */
276 const char *fs_get_type_name(void)
277 {
278 	return fs_get_info(fs_type)->name;
279 }
280 
281 int fs_set_blk_dev(const char *ifname, const char *dev_part_str, int fstype)
282 {
283 	struct fstype_info *info;
284 	int part, i;
285 #ifdef CONFIG_NEEDS_MANUAL_RELOC
286 	static int relocated;
287 
288 	if (!relocated) {
289 		for (i = 0, info = fstypes; i < ARRAY_SIZE(fstypes);
290 				i++, info++) {
291 			info->name += gd->reloc_off;
292 			info->probe += gd->reloc_off;
293 			info->close += gd->reloc_off;
294 			info->ls += gd->reloc_off;
295 			info->read += gd->reloc_off;
296 			info->write += gd->reloc_off;
297 		}
298 		relocated = 1;
299 	}
300 #endif
301 
302 	part = blk_get_device_part_str(ifname, dev_part_str, &fs_dev_desc,
303 					&fs_partition, 1);
304 	if (part < 0)
305 		return -1;
306 
307 	for (i = 0, info = fstypes; i < ARRAY_SIZE(fstypes); i++, info++) {
308 		if (fstype != FS_TYPE_ANY && info->fstype != FS_TYPE_ANY &&
309 				fstype != info->fstype)
310 			continue;
311 
312 		if (!fs_dev_desc && !info->null_dev_desc_ok)
313 			continue;
314 
315 		if (!info->probe(fs_dev_desc, &fs_partition)) {
316 			fs_type = info->fstype;
317 			fs_dev_part = part;
318 			return 0;
319 		}
320 	}
321 
322 	return -1;
323 }
324 
325 /* set current blk device w/ blk_desc + partition # */
326 int fs_set_blk_dev_with_part(struct blk_desc *desc, int part)
327 {
328 	struct fstype_info *info;
329 	int ret, i;
330 
331 	if (part >= 1)
332 		ret = part_get_info(desc, part, &fs_partition);
333 	else
334 		ret = part_get_info_whole_disk(desc, &fs_partition);
335 	if (ret)
336 		return ret;
337 	fs_dev_desc = desc;
338 
339 	for (i = 0, info = fstypes; i < ARRAY_SIZE(fstypes); i++, info++) {
340 		if (!info->probe(fs_dev_desc, &fs_partition)) {
341 			fs_type = info->fstype;
342 			return 0;
343 		}
344 	}
345 
346 	return -1;
347 }
348 
349 static void fs_close(void)
350 {
351 	struct fstype_info *info = fs_get_info(fs_type);
352 
353 	info->close();
354 
355 	fs_type = FS_TYPE_ANY;
356 }
357 
358 int fs_uuid(char *uuid_str)
359 {
360 	struct fstype_info *info = fs_get_info(fs_type);
361 
362 	return info->uuid(uuid_str);
363 }
364 
365 int fs_ls(const char *dirname)
366 {
367 	int ret;
368 
369 	struct fstype_info *info = fs_get_info(fs_type);
370 
371 	ret = info->ls(dirname);
372 
373 	fs_type = FS_TYPE_ANY;
374 	fs_close();
375 
376 	return ret;
377 }
378 
379 int fs_exists(const char *filename)
380 {
381 	int ret;
382 
383 	struct fstype_info *info = fs_get_info(fs_type);
384 
385 	ret = info->exists(filename);
386 
387 	fs_close();
388 
389 	return ret;
390 }
391 
392 int fs_size(const char *filename, loff_t *size)
393 {
394 	int ret;
395 
396 	struct fstype_info *info = fs_get_info(fs_type);
397 
398 	ret = info->size(filename, size);
399 
400 	fs_close();
401 
402 	return ret;
403 }
404 
405 int fs_read(const char *filename, ulong addr, loff_t offset, loff_t len,
406 	    loff_t *actread)
407 {
408 	struct fstype_info *info = fs_get_info(fs_type);
409 	void *buf;
410 	int ret;
411 
412 	/*
413 	 * We don't actually know how many bytes are being read, since len==0
414 	 * means read the whole file.
415 	 */
416 	buf = map_sysmem(addr, len);
417 	ret = info->read(filename, buf, offset, len, actread);
418 	unmap_sysmem(buf);
419 
420 	/* If we requested a specific number of bytes, check we got it */
421 	if (ret == 0 && len && *actread != len)
422 		debug("** %s shorter than offset + len **\n", filename);
423 	fs_close();
424 
425 	return ret;
426 }
427 
428 int fs_write(const char *filename, ulong addr, loff_t offset, loff_t len,
429 	     loff_t *actwrite)
430 {
431 	struct fstype_info *info = fs_get_info(fs_type);
432 	void *buf;
433 	int ret;
434 
435 	buf = map_sysmem(addr, len);
436 	ret = info->write(filename, buf, offset, len, actwrite);
437 	unmap_sysmem(buf);
438 
439 	if (ret < 0 && len != *actwrite) {
440 		printf("** Unable to write file %s **\n", filename);
441 		ret = -1;
442 	}
443 	fs_close();
444 
445 	return ret;
446 }
447 
448 struct fs_dir_stream *fs_opendir(const char *filename)
449 {
450 	struct fstype_info *info = fs_get_info(fs_type);
451 	struct fs_dir_stream *dirs = NULL;
452 	int ret;
453 
454 	ret = info->opendir(filename, &dirs);
455 	fs_close();
456 	if (ret) {
457 		errno = -ret;
458 		return NULL;
459 	}
460 
461 	dirs->desc = fs_dev_desc;
462 	dirs->part = fs_dev_part;
463 
464 	return dirs;
465 }
466 
467 struct fs_dirent *fs_readdir(struct fs_dir_stream *dirs)
468 {
469 	struct fstype_info *info;
470 	struct fs_dirent *dirent;
471 	int ret;
472 
473 	fs_set_blk_dev_with_part(dirs->desc, dirs->part);
474 	info = fs_get_info(fs_type);
475 
476 	ret = info->readdir(dirs, &dirent);
477 	fs_close();
478 	if (ret) {
479 		errno = -ret;
480 		return NULL;
481 	}
482 
483 	return dirent;
484 }
485 
486 void fs_closedir(struct fs_dir_stream *dirs)
487 {
488 	struct fstype_info *info;
489 
490 	if (!dirs)
491 		return;
492 
493 	fs_set_blk_dev_with_part(dirs->desc, dirs->part);
494 	info = fs_get_info(fs_type);
495 
496 	info->closedir(dirs);
497 	fs_close();
498 }
499 
500 
501 int do_size(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
502 		int fstype)
503 {
504 	loff_t size;
505 
506 	if (argc != 4)
507 		return CMD_RET_USAGE;
508 
509 	if (fs_set_blk_dev(argv[1], argv[2], fstype))
510 		return 1;
511 
512 	if (fs_size(argv[3], &size) < 0)
513 		return CMD_RET_FAILURE;
514 
515 	env_set_hex("filesize", size);
516 
517 	return 0;
518 }
519 
520 int do_load(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
521 		int fstype)
522 {
523 	unsigned long addr;
524 	const char *addr_str;
525 	const char *filename;
526 	loff_t bytes;
527 	loff_t pos;
528 	loff_t len_read;
529 	int ret;
530 	unsigned long time;
531 	char *ep;
532 
533 	if (argc < 2)
534 		return CMD_RET_USAGE;
535 	if (argc > 7)
536 		return CMD_RET_USAGE;
537 
538 	if (fs_set_blk_dev(argv[1], (argc >= 3) ? argv[2] : NULL, fstype))
539 		return 1;
540 
541 	if (argc >= 4) {
542 		addr = simple_strtoul(argv[3], &ep, 16);
543 		if (ep == argv[3] || *ep != '\0')
544 			return CMD_RET_USAGE;
545 	} else {
546 		addr_str = env_get("loadaddr");
547 		if (addr_str != NULL)
548 			addr = simple_strtoul(addr_str, NULL, 16);
549 		else
550 			addr = CONFIG_SYS_LOAD_ADDR;
551 	}
552 	if (argc >= 5) {
553 		filename = argv[4];
554 	} else {
555 		filename = env_get("bootfile");
556 		if (!filename) {
557 			puts("** No boot file defined **\n");
558 			return 1;
559 		}
560 	}
561 	if (argc >= 6)
562 		bytes = simple_strtoul(argv[5], NULL, 16);
563 	else
564 		bytes = 0;
565 	if (argc >= 7)
566 		pos = simple_strtoul(argv[6], NULL, 16);
567 	else
568 		pos = 0;
569 
570 	time = get_timer(0);
571 	ret = fs_read(filename, addr, pos, bytes, &len_read);
572 	time = get_timer(time);
573 	if (ret < 0)
574 		return 1;
575 
576 	printf("%llu bytes read in %lu ms", len_read, time);
577 	if (time > 0) {
578 		puts(" (");
579 		print_size(div_u64(len_read, time) * 1000, "/s");
580 		puts(")");
581 	}
582 	puts("\n");
583 
584 	env_set_hex("fileaddr", addr);
585 	env_set_hex("filesize", len_read);
586 
587 	return 0;
588 }
589 
590 int do_ls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
591 	int fstype)
592 {
593 	if (argc < 2)
594 		return CMD_RET_USAGE;
595 	if (argc > 4)
596 		return CMD_RET_USAGE;
597 
598 	if (fs_set_blk_dev(argv[1], (argc >= 3) ? argv[2] : NULL, fstype))
599 		return 1;
600 
601 	if (fs_ls(argc >= 4 ? argv[3] : "/"))
602 		return 1;
603 
604 	return 0;
605 }
606 
607 int file_exists(const char *dev_type, const char *dev_part, const char *file,
608 		int fstype)
609 {
610 	if (fs_set_blk_dev(dev_type, dev_part, fstype))
611 		return 0;
612 
613 	return fs_exists(file);
614 }
615 
616 int do_save(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
617 		int fstype)
618 {
619 	unsigned long addr;
620 	const char *filename;
621 	loff_t bytes;
622 	loff_t pos;
623 	loff_t len;
624 	int ret;
625 	unsigned long time;
626 
627 	if (argc < 6 || argc > 7)
628 		return CMD_RET_USAGE;
629 
630 	if (fs_set_blk_dev(argv[1], argv[2], fstype))
631 		return 1;
632 
633 	addr = simple_strtoul(argv[3], NULL, 16);
634 	filename = argv[4];
635 	bytes = simple_strtoul(argv[5], NULL, 16);
636 	if (argc >= 7)
637 		pos = simple_strtoul(argv[6], NULL, 16);
638 	else
639 		pos = 0;
640 
641 	time = get_timer(0);
642 	ret = fs_write(filename, addr, pos, bytes, &len);
643 	time = get_timer(time);
644 	if (ret < 0)
645 		return 1;
646 
647 	printf("%llu bytes written in %lu ms", len, time);
648 	if (time > 0) {
649 		puts(" (");
650 		print_size(div_u64(len, time) * 1000, "/s");
651 		puts(")");
652 	}
653 	puts("\n");
654 
655 	return 0;
656 }
657 
658 int do_fs_uuid(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
659 		int fstype)
660 {
661 	int ret;
662 	char uuid[37];
663 	memset(uuid, 0, sizeof(uuid));
664 
665 	if (argc < 3 || argc > 4)
666 		return CMD_RET_USAGE;
667 
668 	if (fs_set_blk_dev(argv[1], argv[2], fstype))
669 		return 1;
670 
671 	ret = fs_uuid(uuid);
672 	if (ret)
673 		return CMD_RET_FAILURE;
674 
675 	if (argc == 4)
676 		env_set(argv[3], uuid);
677 	else
678 		printf("%s\n", uuid);
679 
680 	return CMD_RET_SUCCESS;
681 }
682 
683 int do_fs_type(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
684 {
685 	struct fstype_info *info;
686 
687 	if (argc < 3 || argc > 4)
688 		return CMD_RET_USAGE;
689 
690 	if (fs_set_blk_dev(argv[1], argv[2], FS_TYPE_ANY))
691 		return 1;
692 
693 	info = fs_get_info(fs_type);
694 
695 	if (argc == 4)
696 		env_set(argv[3], info->name);
697 	else
698 		printf("%s\n", info->name);
699 
700 	return CMD_RET_SUCCESS;
701 }
702 
703