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