fs/fs.c

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