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