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 CONFIG_IS_ENABLED(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 }