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 } 791