Merge branch '2022-04-19-assorted-updates'
[platform/kernel/u-boot.git] / fs / fs.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (c) 2012, NVIDIA CORPORATION.  All rights reserved.
4  */
5
6 #define LOG_CATEGORY LOGC_CORE
7
8 #include <command.h>
9 #include <config.h>
10 #include <errno.h>
11 #include <common.h>
12 #include <env.h>
13 #include <lmb.h>
14 #include <log.h>
15 #include <mapmem.h>
16 #include <part.h>
17 #include <ext4fs.h>
18 #include <fat.h>
19 #include <fs.h>
20 #include <sandboxfs.h>
21 #include <semihostingfs.h>
22 #include <ubifs_uboot.h>
23 #include <btrfs.h>
24 #include <asm/global_data.h>
25 #include <asm/io.h>
26 #include <div64.h>
27 #include <linux/math64.h>
28 #include <efi_loader.h>
29 #include <squashfs.h>
30 #include <erofs.h>
31
32 DECLARE_GLOBAL_DATA_PTR;
33
34 static struct blk_desc *fs_dev_desc;
35 static int fs_dev_part;
36 static struct disk_partition fs_partition;
37 static int fs_type = FS_TYPE_ANY;
38
39 static inline int fs_probe_unsupported(struct blk_desc *fs_dev_desc,
40                                       struct disk_partition *fs_partition)
41 {
42         log_debug("Unrecognized filesystem type\n");
43         return -1;
44 }
45
46 static inline int fs_ls_unsupported(const char *dirname)
47 {
48         return -1;
49 }
50
51 /* generic implementation of ls in terms of opendir/readdir/closedir */
52 __maybe_unused
53 static int fs_ls_generic(const char *dirname)
54 {
55         struct fs_dir_stream *dirs;
56         struct fs_dirent *dent;
57         int nfiles = 0, ndirs = 0;
58
59         dirs = fs_opendir(dirname);
60         if (!dirs)
61                 return -errno;
62
63         while ((dent = fs_readdir(dirs))) {
64                 if (dent->type == FS_DT_DIR) {
65                         printf("            %s/\n", dent->name);
66                         ndirs++;
67                 } else if (dent->type == FS_DT_LNK) {
68                         printf("    <SYM>   %s\n", dent->name);
69                         nfiles++;
70                 } else {
71                         printf(" %8lld   %s\n", dent->size, dent->name);
72                         nfiles++;
73                 }
74         }
75
76         fs_closedir(dirs);
77
78         printf("\n%d file(s), %d dir(s)\n\n", nfiles, ndirs);
79
80         return 0;
81 }
82
83 static inline int fs_exists_unsupported(const char *filename)
84 {
85         return 0;
86 }
87
88 static inline int fs_size_unsupported(const char *filename, loff_t *size)
89 {
90         return -1;
91 }
92
93 static inline int fs_read_unsupported(const char *filename, void *buf,
94                                       loff_t offset, loff_t len,
95                                       loff_t *actread)
96 {
97         return -1;
98 }
99
100 static inline int fs_write_unsupported(const char *filename, void *buf,
101                                       loff_t offset, loff_t len,
102                                       loff_t *actwrite)
103 {
104         return -1;
105 }
106
107 static inline int fs_ln_unsupported(const char *filename, const char *target)
108 {
109         return -1;
110 }
111
112 static inline void fs_close_unsupported(void)
113 {
114 }
115
116 static inline int fs_uuid_unsupported(char *uuid_str)
117 {
118         return -1;
119 }
120
121 static inline int fs_opendir_unsupported(const char *filename,
122                                          struct fs_dir_stream **dirs)
123 {
124         return -EACCES;
125 }
126
127 static inline int fs_unlink_unsupported(const char *filename)
128 {
129         return -1;
130 }
131
132 static inline int fs_mkdir_unsupported(const char *dirname)
133 {
134         return -1;
135 }
136
137 struct fstype_info {
138         int fstype;
139         char *name;
140         /*
141          * Is it legal to pass NULL as .probe()'s  fs_dev_desc parameter? This
142          * should be false in most cases. For "virtual" filesystems which
143          * aren't based on a U-Boot block device (e.g. sandbox), this can be
144          * set to true. This should also be true for the dummy entry at the end
145          * of fstypes[], since that is essentially a "virtual" (non-existent)
146          * filesystem.
147          */
148         bool null_dev_desc_ok;
149         int (*probe)(struct blk_desc *fs_dev_desc,
150                      struct disk_partition *fs_partition);
151         int (*ls)(const char *dirname);
152         int (*exists)(const char *filename);
153         int (*size)(const char *filename, loff_t *size);
154         int (*read)(const char *filename, void *buf, loff_t offset,
155                     loff_t len, loff_t *actread);
156         int (*write)(const char *filename, void *buf, loff_t offset,
157                      loff_t len, loff_t *actwrite);
158         void (*close)(void);
159         int (*uuid)(char *uuid_str);
160         /*
161          * Open a directory stream.  On success return 0 and directory
162          * stream pointer via 'dirsp'.  On error, return -errno.  See
163          * fs_opendir().
164          */
165         int (*opendir)(const char *filename, struct fs_dir_stream **dirsp);
166         /*
167          * Read next entry from directory stream.  On success return 0
168          * and directory entry pointer via 'dentp'.  On error return
169          * -errno.  See fs_readdir().
170          */
171         int (*readdir)(struct fs_dir_stream *dirs, struct fs_dirent **dentp);
172         /* see fs_closedir() */
173         void (*closedir)(struct fs_dir_stream *dirs);
174         int (*unlink)(const char *filename);
175         int (*mkdir)(const char *dirname);
176         int (*ln)(const char *filename, const char *target);
177 };
178
179 static struct fstype_info fstypes[] = {
180 #if CONFIG_IS_ENABLED(FS_FAT)
181         {
182                 .fstype = FS_TYPE_FAT,
183                 .name = "fat",
184                 .null_dev_desc_ok = false,
185                 .probe = fat_set_blk_dev,
186                 .close = fat_close,
187                 .ls = fs_ls_generic,
188                 .exists = fat_exists,
189                 .size = fat_size,
190                 .read = fat_read_file,
191 #if CONFIG_IS_ENABLED(FAT_WRITE)
192                 .write = file_fat_write,
193                 .unlink = fat_unlink,
194                 .mkdir = fat_mkdir,
195 #else
196                 .write = fs_write_unsupported,
197                 .unlink = fs_unlink_unsupported,
198                 .mkdir = fs_mkdir_unsupported,
199 #endif
200                 .uuid = fat_uuid,
201                 .opendir = fat_opendir,
202                 .readdir = fat_readdir,
203                 .closedir = fat_closedir,
204                 .ln = fs_ln_unsupported,
205         },
206 #endif
207
208 #if CONFIG_IS_ENABLED(FS_EXT4)
209         {
210                 .fstype = FS_TYPE_EXT,
211                 .name = "ext4",
212                 .null_dev_desc_ok = false,
213                 .probe = ext4fs_probe,
214                 .close = ext4fs_close,
215                 .ls = ext4fs_ls,
216                 .exists = ext4fs_exists,
217                 .size = ext4fs_size,
218                 .read = ext4_read_file,
219 #ifdef CONFIG_CMD_EXT4_WRITE
220                 .write = ext4_write_file,
221                 .ln = ext4fs_create_link,
222 #else
223                 .write = fs_write_unsupported,
224                 .ln = fs_ln_unsupported,
225 #endif
226                 .uuid = ext4fs_uuid,
227                 .opendir = fs_opendir_unsupported,
228                 .unlink = fs_unlink_unsupported,
229                 .mkdir = fs_mkdir_unsupported,
230         },
231 #endif
232 #ifdef CONFIG_SANDBOX
233         {
234                 .fstype = FS_TYPE_SANDBOX,
235                 .name = "sandbox",
236                 .null_dev_desc_ok = true,
237                 .probe = sandbox_fs_set_blk_dev,
238                 .close = sandbox_fs_close,
239                 .ls = sandbox_fs_ls,
240                 .exists = sandbox_fs_exists,
241                 .size = sandbox_fs_size,
242                 .read = fs_read_sandbox,
243                 .write = fs_write_sandbox,
244                 .uuid = fs_uuid_unsupported,
245                 .opendir = fs_opendir_unsupported,
246                 .unlink = fs_unlink_unsupported,
247                 .mkdir = fs_mkdir_unsupported,
248                 .ln = fs_ln_unsupported,
249         },
250 #endif
251 #ifdef CONFIG_SEMIHOSTING
252         {
253                 .fstype = FS_TYPE_SEMIHOSTING,
254                 .name = "semihosting",
255                 .null_dev_desc_ok = true,
256                 .probe = smh_fs_set_blk_dev,
257                 .close = fs_close_unsupported,
258                 .ls = fs_ls_unsupported,
259                 .exists = fs_exists_unsupported,
260                 .size = smh_fs_size,
261                 .read = smh_fs_read,
262                 .write = smh_fs_write,
263                 .uuid = fs_uuid_unsupported,
264                 .opendir = fs_opendir_unsupported,
265                 .unlink = fs_unlink_unsupported,
266                 .mkdir = fs_mkdir_unsupported,
267                 .ln = fs_ln_unsupported,
268         },
269 #endif
270 #ifndef CONFIG_SPL_BUILD
271 #ifdef CONFIG_CMD_UBIFS
272         {
273                 .fstype = FS_TYPE_UBIFS,
274                 .name = "ubifs",
275                 .null_dev_desc_ok = true,
276                 .probe = ubifs_set_blk_dev,
277                 .close = ubifs_close,
278                 .ls = ubifs_ls,
279                 .exists = ubifs_exists,
280                 .size = ubifs_size,
281                 .read = ubifs_read,
282                 .write = fs_write_unsupported,
283                 .uuid = fs_uuid_unsupported,
284                 .opendir = fs_opendir_unsupported,
285                 .unlink = fs_unlink_unsupported,
286                 .mkdir = fs_mkdir_unsupported,
287                 .ln = fs_ln_unsupported,
288         },
289 #endif
290 #endif
291 #ifndef CONFIG_SPL_BUILD
292 #ifdef CONFIG_FS_BTRFS
293         {
294                 .fstype = FS_TYPE_BTRFS,
295                 .name = "btrfs",
296                 .null_dev_desc_ok = false,
297                 .probe = btrfs_probe,
298                 .close = btrfs_close,
299                 .ls = btrfs_ls,
300                 .exists = btrfs_exists,
301                 .size = btrfs_size,
302                 .read = btrfs_read,
303                 .write = fs_write_unsupported,
304                 .uuid = btrfs_uuid,
305                 .opendir = fs_opendir_unsupported,
306                 .unlink = fs_unlink_unsupported,
307                 .mkdir = fs_mkdir_unsupported,
308                 .ln = fs_ln_unsupported,
309         },
310 #endif
311 #endif
312 #if IS_ENABLED(CONFIG_FS_SQUASHFS)
313         {
314                 .fstype = FS_TYPE_SQUASHFS,
315                 .name = "squashfs",
316                 .null_dev_desc_ok = false,
317                 .probe = sqfs_probe,
318                 .opendir = sqfs_opendir,
319                 .readdir = sqfs_readdir,
320                 .ls = fs_ls_generic,
321                 .read = sqfs_read,
322                 .size = sqfs_size,
323                 .close = sqfs_close,
324                 .closedir = sqfs_closedir,
325                 .exists = sqfs_exists,
326                 .uuid = fs_uuid_unsupported,
327                 .write = fs_write_unsupported,
328                 .ln = fs_ln_unsupported,
329                 .unlink = fs_unlink_unsupported,
330                 .mkdir = fs_mkdir_unsupported,
331         },
332 #endif
333 #if IS_ENABLED(CONFIG_FS_EROFS)
334         {
335                 .fstype = FS_TYPE_EROFS,
336                 .name = "erofs",
337                 .null_dev_desc_ok = false,
338                 .probe = erofs_probe,
339                 .opendir = erofs_opendir,
340                 .readdir = erofs_readdir,
341                 .ls = fs_ls_generic,
342                 .read = erofs_read,
343                 .size = erofs_size,
344                 .close = erofs_close,
345                 .closedir = erofs_closedir,
346                 .exists = erofs_exists,
347                 .uuid = fs_uuid_unsupported,
348                 .write = fs_write_unsupported,
349                 .ln = fs_ln_unsupported,
350                 .unlink = fs_unlink_unsupported,
351                 .mkdir = fs_mkdir_unsupported,
352         },
353 #endif
354         {
355                 .fstype = FS_TYPE_ANY,
356                 .name = "unsupported",
357                 .null_dev_desc_ok = true,
358                 .probe = fs_probe_unsupported,
359                 .close = fs_close_unsupported,
360                 .ls = fs_ls_unsupported,
361                 .exists = fs_exists_unsupported,
362                 .size = fs_size_unsupported,
363                 .read = fs_read_unsupported,
364                 .write = fs_write_unsupported,
365                 .uuid = fs_uuid_unsupported,
366                 .opendir = fs_opendir_unsupported,
367                 .unlink = fs_unlink_unsupported,
368                 .mkdir = fs_mkdir_unsupported,
369                 .ln = fs_ln_unsupported,
370         },
371 };
372
373 static struct fstype_info *fs_get_info(int fstype)
374 {
375         struct fstype_info *info;
376         int i;
377
378         for (i = 0, info = fstypes; i < ARRAY_SIZE(fstypes) - 1; i++, info++) {
379                 if (fstype == info->fstype)
380                         return info;
381         }
382
383         /* Return the 'unsupported' sentinel */
384         return info;
385 }
386
387 /**
388  * fs_get_type() - Get type of current filesystem
389  *
390  * Return: filesystem type
391  *
392  * Returns filesystem type representing the current filesystem, or
393  * FS_TYPE_ANY for any unrecognised filesystem.
394  */
395 int fs_get_type(void)
396 {
397         return fs_type;
398 }
399
400 /**
401  * fs_get_type_name() - Get type of current filesystem
402  *
403  * Return: Pointer to filesystem name
404  *
405  * Returns a string describing the current filesystem, or the sentinel
406  * "unsupported" for any unrecognised filesystem.
407  */
408 const char *fs_get_type_name(void)
409 {
410         return fs_get_info(fs_type)->name;
411 }
412
413 int fs_set_blk_dev(const char *ifname, const char *dev_part_str, int fstype)
414 {
415         struct fstype_info *info;
416         int part, i;
417 #ifdef CONFIG_NEEDS_MANUAL_RELOC
418         static int relocated;
419
420         if (!relocated) {
421                 for (i = 0, info = fstypes; i < ARRAY_SIZE(fstypes);
422                                 i++, info++) {
423                         info->name += gd->reloc_off;
424                         info->probe += gd->reloc_off;
425                         info->close += gd->reloc_off;
426                         info->ls += gd->reloc_off;
427                         info->read += gd->reloc_off;
428                         info->write += gd->reloc_off;
429                 }
430                 relocated = 1;
431         }
432 #endif
433
434         part = part_get_info_by_dev_and_name_or_num(ifname, dev_part_str, &fs_dev_desc,
435                                                     &fs_partition, 1);
436         if (part < 0)
437                 return -1;
438
439         for (i = 0, info = fstypes; i < ARRAY_SIZE(fstypes); i++, info++) {
440                 if (fstype != FS_TYPE_ANY && info->fstype != FS_TYPE_ANY &&
441                                 fstype != info->fstype)
442                         continue;
443
444                 if (!fs_dev_desc && !info->null_dev_desc_ok)
445                         continue;
446
447                 if (!info->probe(fs_dev_desc, &fs_partition)) {
448                         fs_type = info->fstype;
449                         fs_dev_part = part;
450                         return 0;
451                 }
452         }
453
454         return -1;
455 }
456
457 /* set current blk device w/ blk_desc + partition # */
458 int fs_set_blk_dev_with_part(struct blk_desc *desc, int part)
459 {
460         struct fstype_info *info;
461         int ret, i;
462
463         if (part >= 1)
464                 ret = part_get_info(desc, part, &fs_partition);
465         else
466                 ret = part_get_info_whole_disk(desc, &fs_partition);
467         if (ret)
468                 return ret;
469         fs_dev_desc = desc;
470
471         for (i = 0, info = fstypes; i < ARRAY_SIZE(fstypes); i++, info++) {
472                 if (!info->probe(fs_dev_desc, &fs_partition)) {
473                         fs_type = info->fstype;
474                         fs_dev_part = part;
475                         return 0;
476                 }
477         }
478
479         return -1;
480 }
481
482 void fs_close(void)
483 {
484         struct fstype_info *info = fs_get_info(fs_type);
485
486         info->close();
487
488         fs_type = FS_TYPE_ANY;
489 }
490
491 int fs_uuid(char *uuid_str)
492 {
493         struct fstype_info *info = fs_get_info(fs_type);
494
495         return info->uuid(uuid_str);
496 }
497
498 int fs_ls(const char *dirname)
499 {
500         int ret;
501
502         struct fstype_info *info = fs_get_info(fs_type);
503
504         ret = info->ls(dirname);
505
506         fs_close();
507
508         return ret;
509 }
510
511 int fs_exists(const char *filename)
512 {
513         int ret;
514
515         struct fstype_info *info = fs_get_info(fs_type);
516
517         ret = info->exists(filename);
518
519         fs_close();
520
521         return ret;
522 }
523
524 int fs_size(const char *filename, loff_t *size)
525 {
526         int ret;
527
528         struct fstype_info *info = fs_get_info(fs_type);
529
530         ret = info->size(filename, size);
531
532         fs_close();
533
534         return ret;
535 }
536
537 #ifdef CONFIG_LMB
538 /* Check if a file may be read to the given address */
539 static int fs_read_lmb_check(const char *filename, ulong addr, loff_t offset,
540                              loff_t len, struct fstype_info *info)
541 {
542         struct lmb lmb;
543         int ret;
544         loff_t size;
545         loff_t read_len;
546
547         /* get the actual size of the file */
548         ret = info->size(filename, &size);
549         if (ret)
550                 return ret;
551         if (offset >= size) {
552                 /* offset >= EOF, no bytes will be written */
553                 return 0;
554         }
555         read_len = size - offset;
556
557         /* limit to 'len' if it is smaller */
558         if (len && len < read_len)
559                 read_len = len;
560
561         lmb_init_and_reserve(&lmb, gd->bd, (void *)gd->fdt_blob);
562         lmb_dump_all(&lmb);
563
564         if (lmb_alloc_addr(&lmb, addr, read_len) == addr)
565                 return 0;
566
567         log_err("** Reading file would overwrite reserved memory **\n");
568         return -ENOSPC;
569 }
570 #endif
571
572 static int _fs_read(const char *filename, ulong addr, loff_t offset, loff_t len,
573                     int do_lmb_check, loff_t *actread)
574 {
575         struct fstype_info *info = fs_get_info(fs_type);
576         void *buf;
577         int ret;
578
579 #ifdef CONFIG_LMB
580         if (do_lmb_check) {
581                 ret = fs_read_lmb_check(filename, addr, offset, len, info);
582                 if (ret)
583                         return ret;
584         }
585 #endif
586
587         /*
588          * We don't actually know how many bytes are being read, since len==0
589          * means read the whole file.
590          */
591         buf = map_sysmem(addr, len);
592         ret = info->read(filename, buf, offset, len, actread);
593         unmap_sysmem(buf);
594
595         /* If we requested a specific number of bytes, check we got it */
596         if (ret == 0 && len && *actread != len)
597                 log_debug("** %s shorter than offset + len **\n", filename);
598         fs_close();
599
600         return ret;
601 }
602
603 int fs_read(const char *filename, ulong addr, loff_t offset, loff_t len,
604             loff_t *actread)
605 {
606         return _fs_read(filename, addr, offset, len, 0, actread);
607 }
608
609 int fs_write(const char *filename, ulong addr, loff_t offset, loff_t len,
610              loff_t *actwrite)
611 {
612         struct fstype_info *info = fs_get_info(fs_type);
613         void *buf;
614         int ret;
615
616         buf = map_sysmem(addr, len);
617         ret = info->write(filename, buf, offset, len, actwrite);
618         unmap_sysmem(buf);
619
620         if (ret < 0 && len != *actwrite) {
621                 log_err("** Unable to write file %s **\n", filename);
622                 ret = -1;
623         }
624         fs_close();
625
626         return ret;
627 }
628
629 struct fs_dir_stream *fs_opendir(const char *filename)
630 {
631         struct fstype_info *info = fs_get_info(fs_type);
632         struct fs_dir_stream *dirs = NULL;
633         int ret;
634
635         ret = info->opendir(filename, &dirs);
636         fs_close();
637         if (ret) {
638                 errno = -ret;
639                 return NULL;
640         }
641
642         dirs->desc = fs_dev_desc;
643         dirs->part = fs_dev_part;
644
645         return dirs;
646 }
647
648 struct fs_dirent *fs_readdir(struct fs_dir_stream *dirs)
649 {
650         struct fstype_info *info;
651         struct fs_dirent *dirent;
652         int ret;
653
654         fs_set_blk_dev_with_part(dirs->desc, dirs->part);
655         info = fs_get_info(fs_type);
656
657         ret = info->readdir(dirs, &dirent);
658         fs_close();
659         if (ret) {
660                 errno = -ret;
661                 return NULL;
662         }
663
664         return dirent;
665 }
666
667 void fs_closedir(struct fs_dir_stream *dirs)
668 {
669         struct fstype_info *info;
670
671         if (!dirs)
672                 return;
673
674         fs_set_blk_dev_with_part(dirs->desc, dirs->part);
675         info = fs_get_info(fs_type);
676
677         info->closedir(dirs);
678         fs_close();
679 }
680
681 int fs_unlink(const char *filename)
682 {
683         int ret;
684
685         struct fstype_info *info = fs_get_info(fs_type);
686
687         ret = info->unlink(filename);
688
689         fs_close();
690
691         return ret;
692 }
693
694 int fs_mkdir(const char *dirname)
695 {
696         int ret;
697
698         struct fstype_info *info = fs_get_info(fs_type);
699
700         ret = info->mkdir(dirname);
701
702         fs_close();
703
704         return ret;
705 }
706
707 int fs_ln(const char *fname, const char *target)
708 {
709         struct fstype_info *info = fs_get_info(fs_type);
710         int ret;
711
712         ret = info->ln(fname, target);
713
714         if (ret < 0) {
715                 log_err("** Unable to create link %s -> %s **\n", fname, target);
716                 ret = -1;
717         }
718         fs_close();
719
720         return ret;
721 }
722
723 int do_size(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
724             int fstype)
725 {
726         loff_t size;
727
728         if (argc != 4)
729                 return CMD_RET_USAGE;
730
731         if (fs_set_blk_dev(argv[1], argv[2], fstype))
732                 return 1;
733
734         if (fs_size(argv[3], &size) < 0)
735                 return CMD_RET_FAILURE;
736
737         env_set_hex("filesize", size);
738
739         return 0;
740 }
741
742 int do_load(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
743             int fstype)
744 {
745         unsigned long addr;
746         const char *addr_str;
747         const char *filename;
748         loff_t bytes;
749         loff_t pos;
750         loff_t len_read;
751         int ret;
752         unsigned long time;
753         char *ep;
754
755         if (argc < 2)
756                 return CMD_RET_USAGE;
757         if (argc > 7)
758                 return CMD_RET_USAGE;
759
760         if (fs_set_blk_dev(argv[1], (argc >= 3) ? argv[2] : NULL, fstype)) {
761                 log_err("Can't set block device\n");
762                 return 1;
763         }
764
765         if (argc >= 4) {
766                 addr = hextoul(argv[3], &ep);
767                 if (ep == argv[3] || *ep != '\0')
768                         return CMD_RET_USAGE;
769         } else {
770                 addr_str = env_get("loadaddr");
771                 if (addr_str != NULL)
772                         addr = hextoul(addr_str, NULL);
773                 else
774                         addr = CONFIG_SYS_LOAD_ADDR;
775         }
776         if (argc >= 5) {
777                 filename = argv[4];
778         } else {
779                 filename = env_get("bootfile");
780                 if (!filename) {
781                         puts("** No boot file defined **\n");
782                         return 1;
783                 }
784         }
785         if (argc >= 6)
786                 bytes = hextoul(argv[5], NULL);
787         else
788                 bytes = 0;
789         if (argc >= 7)
790                 pos = hextoul(argv[6], NULL);
791         else
792                 pos = 0;
793
794         time = get_timer(0);
795         ret = _fs_read(filename, addr, pos, bytes, 1, &len_read);
796         time = get_timer(time);
797         if (ret < 0) {
798                 log_err("Failed to load '%s'\n", filename);
799                 return 1;
800         }
801
802         if (IS_ENABLED(CONFIG_CMD_BOOTEFI))
803                 efi_set_bootdev(argv[1], (argc > 2) ? argv[2] : "",
804                                 (argc > 4) ? argv[4] : "", map_sysmem(addr, 0),
805                                 len_read);
806
807         printf("%llu bytes read in %lu ms", len_read, time);
808         if (time > 0) {
809                 puts(" (");
810                 print_size(div_u64(len_read, time) * 1000, "/s");
811                 puts(")");
812         }
813         puts("\n");
814
815         env_set_hex("fileaddr", addr);
816         env_set_hex("filesize", len_read);
817
818         return 0;
819 }
820
821 int do_ls(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
822           int fstype)
823 {
824         if (argc < 2)
825                 return CMD_RET_USAGE;
826         if (argc > 4)
827                 return CMD_RET_USAGE;
828
829         if (fs_set_blk_dev(argv[1], (argc >= 3) ? argv[2] : NULL, fstype))
830                 return 1;
831
832         if (fs_ls(argc >= 4 ? argv[3] : "/"))
833                 return 1;
834
835         return 0;
836 }
837
838 int file_exists(const char *dev_type, const char *dev_part, const char *file,
839                 int fstype)
840 {
841         if (fs_set_blk_dev(dev_type, dev_part, fstype))
842                 return 0;
843
844         return fs_exists(file);
845 }
846
847 int do_save(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
848             int fstype)
849 {
850         unsigned long addr;
851         const char *filename;
852         loff_t bytes;
853         loff_t pos;
854         loff_t len;
855         int ret;
856         unsigned long time;
857
858         if (argc < 6 || argc > 7)
859                 return CMD_RET_USAGE;
860
861         if (fs_set_blk_dev(argv[1], argv[2], fstype))
862                 return 1;
863
864         addr = hextoul(argv[3], NULL);
865         filename = argv[4];
866         bytes = hextoul(argv[5], NULL);
867         if (argc >= 7)
868                 pos = hextoul(argv[6], NULL);
869         else
870                 pos = 0;
871
872         time = get_timer(0);
873         ret = fs_write(filename, addr, pos, bytes, &len);
874         time = get_timer(time);
875         if (ret < 0)
876                 return 1;
877
878         printf("%llu bytes written in %lu ms", len, time);
879         if (time > 0) {
880                 puts(" (");
881                 print_size(div_u64(len, time) * 1000, "/s");
882                 puts(")");
883         }
884         puts("\n");
885
886         return 0;
887 }
888
889 int do_fs_uuid(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
890                int fstype)
891 {
892         int ret;
893         char uuid[37];
894         memset(uuid, 0, sizeof(uuid));
895
896         if (argc < 3 || argc > 4)
897                 return CMD_RET_USAGE;
898
899         if (fs_set_blk_dev(argv[1], argv[2], fstype))
900                 return 1;
901
902         ret = fs_uuid(uuid);
903         if (ret)
904                 return CMD_RET_FAILURE;
905
906         if (argc == 4)
907                 env_set(argv[3], uuid);
908         else
909                 printf("%s\n", uuid);
910
911         return CMD_RET_SUCCESS;
912 }
913
914 int do_fs_type(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
915 {
916         struct fstype_info *info;
917
918         if (argc < 3 || argc > 4)
919                 return CMD_RET_USAGE;
920
921         if (fs_set_blk_dev(argv[1], argv[2], FS_TYPE_ANY))
922                 return 1;
923
924         info = fs_get_info(fs_type);
925
926         if (argc == 4)
927                 env_set(argv[3], info->name);
928         else
929                 printf("%s\n", info->name);
930
931         fs_close();
932
933         return CMD_RET_SUCCESS;
934 }
935
936 int do_rm(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
937           int fstype)
938 {
939         if (argc != 4)
940                 return CMD_RET_USAGE;
941
942         if (fs_set_blk_dev(argv[1], argv[2], fstype))
943                 return 1;
944
945         if (fs_unlink(argv[3]))
946                 return 1;
947
948         return 0;
949 }
950
951 int do_mkdir(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
952              int fstype)
953 {
954         int ret;
955
956         if (argc != 4)
957                 return CMD_RET_USAGE;
958
959         if (fs_set_blk_dev(argv[1], argv[2], fstype))
960                 return 1;
961
962         ret = fs_mkdir(argv[3]);
963         if (ret) {
964                 log_err("** Unable to create a directory \"%s\" **\n", argv[3]);
965                 return 1;
966         }
967
968         return 0;
969 }
970
971 int do_ln(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[],
972           int fstype)
973 {
974         if (argc != 5)
975                 return CMD_RET_USAGE;
976
977         if (fs_set_blk_dev(argv[1], argv[2], fstype))
978                 return 1;
979
980         if (fs_ln(argv[3], argv[4]))
981                 return 1;
982
983         return 0;
984 }
985
986 int do_fs_types(struct cmd_tbl *cmdtp, int flag, int argc, char * const argv[])
987 {
988         struct fstype_info *drv = fstypes;
989         const int n_ents = ARRAY_SIZE(fstypes);
990         struct fstype_info *entry;
991         int i = 0;
992
993         puts("Supported filesystems");
994         for (entry = drv; entry != drv + n_ents; entry++) {
995                 if (entry->fstype != FS_TYPE_ANY) {
996                         printf("%c %s", i ? ',' : ':', entry->name);
997                         i++;
998                 }
999         }
1000         if (!i)
1001                 puts(": <none>");
1002         puts("\n");
1003         return CMD_RET_SUCCESS;
1004 }