xref: /openbmc/u-boot/fs/fs.c (revision 25c7de22)
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 static inline int fs_unlink_unsupported(const char *filename)
109 {
110 	return -1;
111 }
112 
113 static inline int fs_mkdir_unsupported(const char *dirname)
114 {
115 	return -1;
116 }
117 
118 struct fstype_info {
119 	int fstype;
120 	char *name;
121 	/*
122 	 * Is it legal to pass NULL as .probe()'s  fs_dev_desc parameter? This
123 	 * should be false in most cases. For "virtual" filesystems which
124 	 * aren't based on a U-Boot block device (e.g. sandbox), this can be
125 	 * set to true. This should also be true for the dummy entry at the end
126 	 * of fstypes[], since that is essentially a "virtual" (non-existent)
127 	 * filesystem.
128 	 */
129 	bool null_dev_desc_ok;
130 	int (*probe)(struct blk_desc *fs_dev_desc,
131 		     disk_partition_t *fs_partition);
132 	int (*ls)(const char *dirname);
133 	int (*exists)(const char *filename);
134 	int (*size)(const char *filename, loff_t *size);
135 	int (*read)(const char *filename, void *buf, loff_t offset,
136 		    loff_t len, loff_t *actread);
137 	int (*write)(const char *filename, void *buf, loff_t offset,
138 		     loff_t len, loff_t *actwrite);
139 	void (*close)(void);
140 	int (*uuid)(char *uuid_str);
141 	/*
142 	 * Open a directory stream.  On success return 0 and directory
143 	 * stream pointer via 'dirsp'.  On error, return -errno.  See
144 	 * fs_opendir().
145 	 */
146 	int (*opendir)(const char *filename, struct fs_dir_stream **dirsp);
147 	/*
148 	 * Read next entry from directory stream.  On success return 0
149 	 * and directory entry pointer via 'dentp'.  On error return
150 	 * -errno.  See fs_readdir().
151 	 */
152 	int (*readdir)(struct fs_dir_stream *dirs, struct fs_dirent **dentp);
153 	/* see fs_closedir() */
154 	void (*closedir)(struct fs_dir_stream *dirs);
155 	int (*unlink)(const char *filename);
156 	int (*mkdir)(const char *dirname);
157 };
158 
159 static struct fstype_info fstypes[] = {
160 #ifdef CONFIG_FS_FAT
161 	{
162 		.fstype = FS_TYPE_FAT,
163 		.name = "fat",
164 		.null_dev_desc_ok = false,
165 		.probe = fat_set_blk_dev,
166 		.close = fat_close,
167 		.ls = fs_ls_generic,
168 		.exists = fat_exists,
169 		.size = fat_size,
170 		.read = fat_read_file,
171 #ifdef CONFIG_FAT_WRITE
172 		.write = file_fat_write,
173 		.unlink = fat_unlink,
174 		.mkdir = fat_mkdir,
175 #else
176 		.write = fs_write_unsupported,
177 		.unlink = fs_unlink_unsupported,
178 		.mkdir = fs_mkdir_unsupported,
179 #endif
180 		.uuid = fs_uuid_unsupported,
181 		.opendir = fat_opendir,
182 		.readdir = fat_readdir,
183 		.closedir = fat_closedir,
184 	},
185 #endif
186 #ifdef CONFIG_FS_EXT4
187 	{
188 		.fstype = FS_TYPE_EXT,
189 		.name = "ext4",
190 		.null_dev_desc_ok = false,
191 		.probe = ext4fs_probe,
192 		.close = ext4fs_close,
193 		.ls = ext4fs_ls,
194 		.exists = ext4fs_exists,
195 		.size = ext4fs_size,
196 		.read = ext4_read_file,
197 #ifdef CONFIG_CMD_EXT4_WRITE
198 		.write = ext4_write_file,
199 #else
200 		.write = fs_write_unsupported,
201 #endif
202 		.uuid = ext4fs_uuid,
203 		.opendir = fs_opendir_unsupported,
204 		.unlink = fs_unlink_unsupported,
205 		.mkdir = fs_mkdir_unsupported,
206 	},
207 #endif
208 #ifdef CONFIG_SANDBOX
209 	{
210 		.fstype = FS_TYPE_SANDBOX,
211 		.name = "sandbox",
212 		.null_dev_desc_ok = true,
213 		.probe = sandbox_fs_set_blk_dev,
214 		.close = sandbox_fs_close,
215 		.ls = sandbox_fs_ls,
216 		.exists = sandbox_fs_exists,
217 		.size = sandbox_fs_size,
218 		.read = fs_read_sandbox,
219 		.write = fs_write_sandbox,
220 		.uuid = fs_uuid_unsupported,
221 		.opendir = fs_opendir_unsupported,
222 		.unlink = fs_unlink_unsupported,
223 		.mkdir = fs_mkdir_unsupported,
224 	},
225 #endif
226 #ifdef CONFIG_CMD_UBIFS
227 	{
228 		.fstype = FS_TYPE_UBIFS,
229 		.name = "ubifs",
230 		.null_dev_desc_ok = true,
231 		.probe = ubifs_set_blk_dev,
232 		.close = ubifs_close,
233 		.ls = ubifs_ls,
234 		.exists = ubifs_exists,
235 		.size = ubifs_size,
236 		.read = ubifs_read,
237 		.write = fs_write_unsupported,
238 		.uuid = fs_uuid_unsupported,
239 		.opendir = fs_opendir_unsupported,
240 		.unlink = fs_unlink_unsupported,
241 		.mkdir = fs_mkdir_unsupported,
242 	},
243 #endif
244 #ifdef CONFIG_FS_BTRFS
245 	{
246 		.fstype = FS_TYPE_BTRFS,
247 		.name = "btrfs",
248 		.null_dev_desc_ok = false,
249 		.probe = btrfs_probe,
250 		.close = btrfs_close,
251 		.ls = btrfs_ls,
252 		.exists = btrfs_exists,
253 		.size = btrfs_size,
254 		.read = btrfs_read,
255 		.write = fs_write_unsupported,
256 		.uuid = btrfs_uuid,
257 		.opendir = fs_opendir_unsupported,
258 		.unlink = fs_unlink_unsupported,
259 		.mkdir = fs_mkdir_unsupported,
260 	},
261 #endif
262 	{
263 		.fstype = FS_TYPE_ANY,
264 		.name = "unsupported",
265 		.null_dev_desc_ok = true,
266 		.probe = fs_probe_unsupported,
267 		.close = fs_close_unsupported,
268 		.ls = fs_ls_unsupported,
269 		.exists = fs_exists_unsupported,
270 		.size = fs_size_unsupported,
271 		.read = fs_read_unsupported,
272 		.write = fs_write_unsupported,
273 		.uuid = fs_uuid_unsupported,
274 		.opendir = fs_opendir_unsupported,
275 		.unlink = fs_unlink_unsupported,
276 		.mkdir = fs_mkdir_unsupported,
277 	},
278 };
279 
280 static struct fstype_info *fs_get_info(int fstype)
281 {
282 	struct fstype_info *info;
283 	int i;
284 
285 	for (i = 0, info = fstypes; i < ARRAY_SIZE(fstypes) - 1; i++, info++) {
286 		if (fstype == info->fstype)
287 			return info;
288 	}
289 
290 	/* Return the 'unsupported' sentinel */
291 	return info;
292 }
293 
294 /**
295  * fs_get_type_name() - Get type of current filesystem
296  *
297  * Return: Pointer to filesystem name
298  *
299  * Returns a string describing the current filesystem, or the sentinel
300  * "unsupported" for any unrecognised filesystem.
301  */
302 const char *fs_get_type_name(void)
303 {
304 	return fs_get_info(fs_type)->name;
305 }
306 
307 int fs_set_blk_dev(const char *ifname, const char *dev_part_str, int fstype)
308 {
309 	struct fstype_info *info;
310 	int part, i;
311 #ifdef CONFIG_NEEDS_MANUAL_RELOC
312 	static int relocated;
313 
314 	if (!relocated) {
315 		for (i = 0, info = fstypes; i < ARRAY_SIZE(fstypes);
316 				i++, info++) {
317 			info->name += gd->reloc_off;
318 			info->probe += gd->reloc_off;
319 			info->close += gd->reloc_off;
320 			info->ls += gd->reloc_off;
321 			info->read += gd->reloc_off;
322 			info->write += gd->reloc_off;
323 		}
324 		relocated = 1;
325 	}
326 #endif
327 
328 	part = blk_get_device_part_str(ifname, dev_part_str, &fs_dev_desc,
329 					&fs_partition, 1);
330 	if (part < 0)
331 		return -1;
332 
333 	for (i = 0, info = fstypes; i < ARRAY_SIZE(fstypes); i++, info++) {
334 		if (fstype != FS_TYPE_ANY && info->fstype != FS_TYPE_ANY &&
335 				fstype != info->fstype)
336 			continue;
337 
338 		if (!fs_dev_desc && !info->null_dev_desc_ok)
339 			continue;
340 
341 		if (!info->probe(fs_dev_desc, &fs_partition)) {
342 			fs_type = info->fstype;
343 			fs_dev_part = part;
344 			return 0;
345 		}
346 	}
347 
348 	return -1;
349 }
350 
351 /* set current blk device w/ blk_desc + partition # */
352 int fs_set_blk_dev_with_part(struct blk_desc *desc, int part)
353 {
354 	struct fstype_info *info;
355 	int ret, i;
356 
357 	if (part >= 1)
358 		ret = part_get_info(desc, part, &fs_partition);
359 	else
360 		ret = part_get_info_whole_disk(desc, &fs_partition);
361 	if (ret)
362 		return ret;
363 	fs_dev_desc = desc;
364 
365 	for (i = 0, info = fstypes; i < ARRAY_SIZE(fstypes); i++, info++) {
366 		if (!info->probe(fs_dev_desc, &fs_partition)) {
367 			fs_type = info->fstype;
368 			fs_dev_part = part;
369 			return 0;
370 		}
371 	}
372 
373 	return -1;
374 }
375 
376 static void fs_close(void)
377 {
378 	struct fstype_info *info = fs_get_info(fs_type);
379 
380 	info->close();
381 
382 	fs_type = FS_TYPE_ANY;
383 }
384 
385 int fs_uuid(char *uuid_str)
386 {
387 	struct fstype_info *info = fs_get_info(fs_type);
388 
389 	return info->uuid(uuid_str);
390 }
391 
392 int fs_ls(const char *dirname)
393 {
394 	int ret;
395 
396 	struct fstype_info *info = fs_get_info(fs_type);
397 
398 	ret = info->ls(dirname);
399 
400 	fs_type = FS_TYPE_ANY;
401 	fs_close();
402 
403 	return ret;
404 }
405 
406 int fs_exists(const char *filename)
407 {
408 	int ret;
409 
410 	struct fstype_info *info = fs_get_info(fs_type);
411 
412 	ret = info->exists(filename);
413 
414 	fs_close();
415 
416 	return ret;
417 }
418 
419 int fs_size(const char *filename, loff_t *size)
420 {
421 	int ret;
422 
423 	struct fstype_info *info = fs_get_info(fs_type);
424 
425 	ret = info->size(filename, size);
426 
427 	fs_close();
428 
429 	return ret;
430 }
431 
432 int fs_read(const char *filename, ulong addr, loff_t offset, loff_t len,
433 	    loff_t *actread)
434 {
435 	struct fstype_info *info = fs_get_info(fs_type);
436 	void *buf;
437 	int ret;
438 
439 	/*
440 	 * We don't actually know how many bytes are being read, since len==0
441 	 * means read the whole file.
442 	 */
443 	buf = map_sysmem(addr, len);
444 	ret = info->read(filename, buf, offset, len, actread);
445 	unmap_sysmem(buf);
446 
447 	/* If we requested a specific number of bytes, check we got it */
448 	if (ret == 0 && len && *actread != len)
449 		debug("** %s shorter than offset + len **\n", filename);
450 	fs_close();
451 
452 	return ret;
453 }
454 
455 int fs_write(const char *filename, ulong addr, loff_t offset, loff_t len,
456 	     loff_t *actwrite)
457 {
458 	struct fstype_info *info = fs_get_info(fs_type);
459 	void *buf;
460 	int ret;
461 
462 	buf = map_sysmem(addr, len);
463 	ret = info->write(filename, buf, offset, len, actwrite);
464 	unmap_sysmem(buf);
465 
466 	if (ret < 0 && len != *actwrite) {
467 		printf("** Unable to write file %s **\n", filename);
468 		ret = -1;
469 	}
470 	fs_close();
471 
472 	return ret;
473 }
474 
475 struct fs_dir_stream *fs_opendir(const char *filename)
476 {
477 	struct fstype_info *info = fs_get_info(fs_type);
478 	struct fs_dir_stream *dirs = NULL;
479 	int ret;
480 
481 	ret = info->opendir(filename, &dirs);
482 	fs_close();
483 	if (ret) {
484 		errno = -ret;
485 		return NULL;
486 	}
487 
488 	dirs->desc = fs_dev_desc;
489 	dirs->part = fs_dev_part;
490 
491 	return dirs;
492 }
493 
494 struct fs_dirent *fs_readdir(struct fs_dir_stream *dirs)
495 {
496 	struct fstype_info *info;
497 	struct fs_dirent *dirent;
498 	int ret;
499 
500 	fs_set_blk_dev_with_part(dirs->desc, dirs->part);
501 	info = fs_get_info(fs_type);
502 
503 	ret = info->readdir(dirs, &dirent);
504 	fs_close();
505 	if (ret) {
506 		errno = -ret;
507 		return NULL;
508 	}
509 
510 	return dirent;
511 }
512 
513 void fs_closedir(struct fs_dir_stream *dirs)
514 {
515 	struct fstype_info *info;
516 
517 	if (!dirs)
518 		return;
519 
520 	fs_set_blk_dev_with_part(dirs->desc, dirs->part);
521 	info = fs_get_info(fs_type);
522 
523 	info->closedir(dirs);
524 	fs_close();
525 }
526 
527 int fs_unlink(const char *filename)
528 {
529 	int ret;
530 
531 	struct fstype_info *info = fs_get_info(fs_type);
532 
533 	ret = info->unlink(filename);
534 
535 	fs_type = FS_TYPE_ANY;
536 	fs_close();
537 
538 	return ret;
539 }
540 
541 int fs_mkdir(const char *dirname)
542 {
543 	int ret;
544 
545 	struct fstype_info *info = fs_get_info(fs_type);
546 
547 	ret = info->mkdir(dirname);
548 
549 	fs_type = FS_TYPE_ANY;
550 	fs_close();
551 
552 	return ret;
553 }
554 
555 int do_size(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
556 		int fstype)
557 {
558 	loff_t size;
559 
560 	if (argc != 4)
561 		return CMD_RET_USAGE;
562 
563 	if (fs_set_blk_dev(argv[1], argv[2], fstype))
564 		return 1;
565 
566 	if (fs_size(argv[3], &size) < 0)
567 		return CMD_RET_FAILURE;
568 
569 	env_set_hex("filesize", size);
570 
571 	return 0;
572 }
573 
574 int do_load(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
575 		int fstype)
576 {
577 	unsigned long addr;
578 	const char *addr_str;
579 	const char *filename;
580 	loff_t bytes;
581 	loff_t pos;
582 	loff_t len_read;
583 	int ret;
584 	unsigned long time;
585 	char *ep;
586 
587 	if (argc < 2)
588 		return CMD_RET_USAGE;
589 	if (argc > 7)
590 		return CMD_RET_USAGE;
591 
592 	if (fs_set_blk_dev(argv[1], (argc >= 3) ? argv[2] : NULL, fstype))
593 		return 1;
594 
595 	if (argc >= 4) {
596 		addr = simple_strtoul(argv[3], &ep, 16);
597 		if (ep == argv[3] || *ep != '\0')
598 			return CMD_RET_USAGE;
599 	} else {
600 		addr_str = env_get("loadaddr");
601 		if (addr_str != NULL)
602 			addr = simple_strtoul(addr_str, NULL, 16);
603 		else
604 			addr = CONFIG_SYS_LOAD_ADDR;
605 	}
606 	if (argc >= 5) {
607 		filename = argv[4];
608 	} else {
609 		filename = env_get("bootfile");
610 		if (!filename) {
611 			puts("** No boot file defined **\n");
612 			return 1;
613 		}
614 	}
615 	if (argc >= 6)
616 		bytes = simple_strtoul(argv[5], NULL, 16);
617 	else
618 		bytes = 0;
619 	if (argc >= 7)
620 		pos = simple_strtoul(argv[6], NULL, 16);
621 	else
622 		pos = 0;
623 
624 	time = get_timer(0);
625 	ret = fs_read(filename, addr, pos, bytes, &len_read);
626 	time = get_timer(time);
627 	if (ret < 0)
628 		return 1;
629 
630 	printf("%llu bytes read in %lu ms", len_read, time);
631 	if (time > 0) {
632 		puts(" (");
633 		print_size(div_u64(len_read, time) * 1000, "/s");
634 		puts(")");
635 	}
636 	puts("\n");
637 
638 	env_set_hex("fileaddr", addr);
639 	env_set_hex("filesize", len_read);
640 
641 	return 0;
642 }
643 
644 int do_ls(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
645 	int fstype)
646 {
647 	if (argc < 2)
648 		return CMD_RET_USAGE;
649 	if (argc > 4)
650 		return CMD_RET_USAGE;
651 
652 	if (fs_set_blk_dev(argv[1], (argc >= 3) ? argv[2] : NULL, fstype))
653 		return 1;
654 
655 	if (fs_ls(argc >= 4 ? argv[3] : "/"))
656 		return 1;
657 
658 	return 0;
659 }
660 
661 int file_exists(const char *dev_type, const char *dev_part, const char *file,
662 		int fstype)
663 {
664 	if (fs_set_blk_dev(dev_type, dev_part, fstype))
665 		return 0;
666 
667 	return fs_exists(file);
668 }
669 
670 int do_save(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
671 		int fstype)
672 {
673 	unsigned long addr;
674 	const char *filename;
675 	loff_t bytes;
676 	loff_t pos;
677 	loff_t len;
678 	int ret;
679 	unsigned long time;
680 
681 	if (argc < 6 || argc > 7)
682 		return CMD_RET_USAGE;
683 
684 	if (fs_set_blk_dev(argv[1], argv[2], fstype))
685 		return 1;
686 
687 	addr = simple_strtoul(argv[3], NULL, 16);
688 	filename = argv[4];
689 	bytes = simple_strtoul(argv[5], NULL, 16);
690 	if (argc >= 7)
691 		pos = simple_strtoul(argv[6], NULL, 16);
692 	else
693 		pos = 0;
694 
695 	time = get_timer(0);
696 	ret = fs_write(filename, addr, pos, bytes, &len);
697 	time = get_timer(time);
698 	if (ret < 0)
699 		return 1;
700 
701 	printf("%llu bytes written in %lu ms", len, time);
702 	if (time > 0) {
703 		puts(" (");
704 		print_size(div_u64(len, time) * 1000, "/s");
705 		puts(")");
706 	}
707 	puts("\n");
708 
709 	return 0;
710 }
711 
712 int do_fs_uuid(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
713 		int fstype)
714 {
715 	int ret;
716 	char uuid[37];
717 	memset(uuid, 0, sizeof(uuid));
718 
719 	if (argc < 3 || argc > 4)
720 		return CMD_RET_USAGE;
721 
722 	if (fs_set_blk_dev(argv[1], argv[2], fstype))
723 		return 1;
724 
725 	ret = fs_uuid(uuid);
726 	if (ret)
727 		return CMD_RET_FAILURE;
728 
729 	if (argc == 4)
730 		env_set(argv[3], uuid);
731 	else
732 		printf("%s\n", uuid);
733 
734 	return CMD_RET_SUCCESS;
735 }
736 
737 int do_fs_type(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
738 {
739 	struct fstype_info *info;
740 
741 	if (argc < 3 || argc > 4)
742 		return CMD_RET_USAGE;
743 
744 	if (fs_set_blk_dev(argv[1], argv[2], FS_TYPE_ANY))
745 		return 1;
746 
747 	info = fs_get_info(fs_type);
748 
749 	if (argc == 4)
750 		env_set(argv[3], info->name);
751 	else
752 		printf("%s\n", info->name);
753 
754 	return CMD_RET_SUCCESS;
755 }
756 
757 int do_rm(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
758 	  int fstype)
759 {
760 	if (argc != 4)
761 		return CMD_RET_USAGE;
762 
763 	if (fs_set_blk_dev(argv[1], argv[2], fstype))
764 		return 1;
765 
766 	if (fs_unlink(argv[3]))
767 		return 1;
768 
769 	return 0;
770 }
771 
772 int do_mkdir(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[],
773 	     int fstype)
774 {
775 	int ret;
776 
777 	if (argc != 4)
778 		return CMD_RET_USAGE;
779 
780 	if (fs_set_blk_dev(argv[1], argv[2], fstype))
781 		return 1;
782 
783 	ret = fs_mkdir(argv[3]);
784 	if (ret) {
785 		printf("** Unable to create a directory \"%s\" **\n", argv[3]);
786 		return 1;
787 	}
788 
789 	return 0;
790 }
791