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
fs_probe_unsupported(struct blk_desc * fs_dev_desc,disk_partition_t * fs_partition)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
fs_ls_unsupported(const char * dirname)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
fs_ls_generic(const char * dirname)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
fs_exists_unsupported(const char * filename)69 static inline int fs_exists_unsupported(const char *filename)
70 {
71 return 0;
72 }
73
fs_size_unsupported(const char * filename,loff_t * size)74 static inline int fs_size_unsupported(const char *filename, loff_t *size)
75 {
76 return -1;
77 }
78
fs_read_unsupported(const char * filename,void * buf,loff_t offset,loff_t len,loff_t * actread)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
fs_write_unsupported(const char * filename,void * buf,loff_t offset,loff_t len,loff_t * actwrite)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
fs_close_unsupported(void)93 static inline void fs_close_unsupported(void)
94 {
95 }
96
fs_uuid_unsupported(char * uuid_str)97 static inline int fs_uuid_unsupported(char *uuid_str)
98 {
99 return -1;
100 }
101
fs_opendir_unsupported(const char * filename,struct fs_dir_stream ** dirs)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
fs_get_info(int fstype)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 */
fs_get_type_name(void)276 const char *fs_get_type_name(void)
277 {
278 return fs_get_info(fs_type)->name;
279 }
280
fs_set_blk_dev(const char * ifname,const char * dev_part_str,int fstype)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 # */
fs_set_blk_dev_with_part(struct blk_desc * desc,int part)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
fs_close(void)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
fs_uuid(char * uuid_str)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
fs_ls(const char * dirname)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
fs_exists(const char * filename)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
fs_size(const char * filename,loff_t * size)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
fs_read(const char * filename,ulong addr,loff_t offset,loff_t len,loff_t * actread)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
fs_write(const char * filename,ulong addr,loff_t offset,loff_t len,loff_t * actwrite)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
fs_opendir(const char * filename)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
fs_readdir(struct fs_dir_stream * dirs)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
fs_closedir(struct fs_dir_stream * dirs)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
do_size(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[],int fstype)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
do_load(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[],int fstype)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
do_ls(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[],int fstype)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
file_exists(const char * dev_type,const char * dev_part,const char * file,int fstype)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
do_save(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[],int fstype)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
do_fs_uuid(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[],int fstype)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
do_fs_type(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])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