static int do_ext4_ls(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]) { const char *filename = "/"; int dev; unsigned long part = 1; char *ep; struct ext_filesystem *fs; int part_length; if (argc < 3) return cmd_usage(cmdtp); dev = (int)simple_strtoul(argv[2], &ep, 16); ext4_dev_desc = get_dev(argv[1], dev); if (ext4_dev_desc == NULL) { printf("\n** Block device %s %d not supported\n", argv[1], dev); return 1; } if (init_fs(ext4_dev_desc)) return 1; fs = get_fs(); if (*ep) { if (*ep != ':') { puts("\n** Invalid boot device, use `dev[:part]' **\n"); return 1; } part = simple_strtoul(++ep, NULL, 16); } if (argc == 4) filename = argv[3]; part_length = ext4fs_set_blk_dev(fs->dev_desc, part); if (part_length == 0) { printf("** Bad partition - %s %d:%lu **\n", argv[1], dev, part); ext4fs_close(); return 1; } if (!ext4fs_mount(part_length)) { printf("** Bad ext2 partition or disk - %s %d:%lu **\n", argv[1], dev, part); ext4fs_close(); return 1; } if (ext4fs_ls(filename)) { printf("** Error ext2fs_ls() **\n"); ext4fs_close(); return 1; }; ext4fs_close(); deinit_fs(fs->dev_desc); return 0; }
int spl_load_image_ext(struct spl_image_info *spl_image, struct blk_desc *block_dev, int partition, const char *filename) { s32 err; struct image_header *header; loff_t filelen, actlen; disk_partition_t part_info = {}; header = (struct image_header *)(CONFIG_SYS_TEXT_BASE - sizeof(struct image_header)); if (part_get_info(block_dev, partition, &part_info)) { printf("spl: no partition table found\n"); return -1; } ext4fs_set_blk_dev(block_dev, &part_info); err = ext4fs_mount(0); if (!err) { #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT printf("%s: ext4fs mount err - %d\n", __func__, err); #endif goto end; } err = ext4fs_open(filename, &filelen); if (err < 0) { puts("spl: ext4fs_open failed\n"); goto end; } err = ext4fs_read((char *)header, 0, sizeof(struct image_header), &actlen); if (err < 0) { puts("spl: ext4fs_read failed\n"); goto end; } err = spl_parse_image_header(spl_image, header); if (err < 0) { puts("spl: ext: failed to parse image header\n"); goto end; } err = ext4fs_read((char *)spl_image->load_addr, 0, filelen, &actlen); end: #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT if (err < 0) printf("%s: error reading image %s, err - %d\n", __func__, filename, err); #endif return err < 0; }
int do_ext4_write(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]) { #if 0 const char *filename = "/"; int dev, part; unsigned long ram_address; unsigned long file_size; disk_partition_t info; block_dev_desc_t *dev_desc; if (argc < 6) return cmd_usage(cmdtp); part = get_device_and_partition(argv[1], argv[2], &dev_desc, &info, 1); if (part < 0) return 1; dev = dev_desc->dev; /* get the filename */ filename = argv[4]; /* get the address in hexadecimal format (string to int) */ ram_address = simple_strtoul(argv[3], NULL, 16); /* get the filesize in base 10 format */ file_size = simple_strtoul(argv[5], NULL, 10); /* set the device as block device */ ext4fs_set_blk_dev(dev_desc, &info); /* mount the filesystem */ if (!ext4fs_mount(info.size)) { printf("Bad ext4 partition %s %d:%d\n", argv[1], dev, part); goto fail; } /* start write */ if (ext4fs_write(filename, (unsigned char *)ram_address, file_size)) { printf("** Error ext4fs_write() **\n"); goto fail; } ext4fs_close(); return 0; fail: ext4fs_close(); return 1; #endif return 0; }
static int env_ext4_load(void) { ALLOC_CACHE_ALIGN_BUFFER(char, buf, CONFIG_ENV_SIZE); struct blk_desc *dev_desc = NULL; disk_partition_t info; int dev, part; int err; loff_t off; #ifdef CONFIG_MMC if (!strcmp(CONFIG_ENV_EXT4_INTERFACE, "mmc")) mmc_initialize(NULL); #endif part = blk_get_device_part_str(CONFIG_ENV_EXT4_INTERFACE, CONFIG_ENV_EXT4_DEVICE_AND_PART, &dev_desc, &info, 1); if (part < 0) goto err_env_relocate; dev = dev_desc->devnum; ext4fs_set_blk_dev(dev_desc, &info); if (!ext4fs_mount(info.size)) { printf("\n** Unable to use %s %s for loading the env **\n", CONFIG_ENV_EXT4_INTERFACE, CONFIG_ENV_EXT4_DEVICE_AND_PART); goto err_env_relocate; } err = ext4_read_file(CONFIG_ENV_EXT4_FILE, buf, 0, CONFIG_ENV_SIZE, &off); ext4fs_close(); if (err == -1) { printf("\n** Unable to read \"%s\" from %s%d:%d **\n", CONFIG_ENV_EXT4_FILE, CONFIG_ENV_EXT4_INTERFACE, dev, part); goto err_env_relocate; } return env_import(buf, 1); err_env_relocate: set_default_env(NULL, 0); return -EIO; }
static int env_ext4_save(void) { env_t env_new; struct blk_desc *dev_desc = NULL; disk_partition_t info; int dev, part; int err; err = env_export(&env_new); if (err) return err; part = blk_get_device_part_str(CONFIG_ENV_EXT4_INTERFACE, CONFIG_ENV_EXT4_DEVICE_AND_PART, &dev_desc, &info, 1); if (part < 0) return 1; dev = dev_desc->devnum; ext4fs_set_blk_dev(dev_desc, &info); if (!ext4fs_mount(info.size)) { printf("\n** Unable to use %s %s for saveenv **\n", CONFIG_ENV_EXT4_INTERFACE, CONFIG_ENV_EXT4_DEVICE_AND_PART); return 1; } err = ext4fs_write(CONFIG_ENV_EXT4_FILE, (void *)&env_new, sizeof(env_t)); ext4fs_close(); if (err == -1) { printf("\n** Unable to write \"%s\" from %s%d:%d **\n", CONFIG_ENV_EXT4_FILE, CONFIG_ENV_EXT4_INTERFACE, dev, part); return 1; } puts("done\n"); return 0; }
static int do_ext4_load(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]) { char *filename = NULL; char *ep; int dev; unsigned long part = 1; ulong addr = 0; ulong part_length; int filelen; disk_partition_t info; struct ext_filesystem *fs; char buf[12]; unsigned long count; const char *addr_str; count = 0; addr = simple_strtoul(argv[3], NULL, 16); filename = getenv("bootfile"); switch (argc) { case 3: addr_str = getenv("loadaddr"); if (addr_str != NULL) addr = simple_strtoul(addr_str, NULL, 16); else addr = CONFIG_SYS_LOAD_ADDR; break; case 4: break; case 5: filename = argv[4]; break; case 6: filename = argv[4]; count = simple_strtoul(argv[5], NULL, 16); break; default: return cmd_usage(cmdtp); } if (!filename) { puts("** No boot file defined **\n"); return 1; } dev = (int)simple_strtoul(argv[2], &ep, 16); ext4_dev_desc = get_dev(argv[1], dev); if (ext4_dev_desc == NULL) { printf("** Block device %s %d not supported\n", argv[1], dev); return 1; } if (init_fs(ext4_dev_desc)) return 1; fs = get_fs(); if (*ep) { if (*ep != ':') { puts("** Invalid boot device, use `dev[:part]' **\n"); return 1; } part = simple_strtoul(++ep, NULL, 16); } if (part != 0) { if (get_partition_info(fs->dev_desc, part, &info)) { printf("** Bad partition %lu **\n", part); return 1; } if (strncmp((char *)info.type, BOOT_PART_TYPE, strlen(BOOT_PART_TYPE)) != 0) { printf("** Invalid partition type \"%s\"" " (expect \"" BOOT_PART_TYPE "\")\n", info.type); return 1; } printf("Loading file \"%s\" " "from %s device %d:%lu %s\n", filename, argv[1], dev, part, info.name); } else { printf("Loading file \"%s\" from %s device %d\n", filename, argv[1], dev); } part_length = ext4fs_set_blk_dev(fs->dev_desc, part); if (part_length == 0) { printf("**Bad partition - %s %d:%lu **\n", argv[1], dev, part); ext4fs_close(); return 1; } if (!ext4fs_mount(part_length)) { printf("** Bad ext2 partition or disk - %s %d:%lu **\n", argv[1], dev, part); ext4fs_close(); return 1; } filelen = ext4fs_open(filename); if (filelen < 0) { printf("** File not found %s\n", filename); ext4fs_close(); return 1; } if ((count < filelen) && (count != 0)) filelen = count; if (ext4fs_read((char *)addr, filelen) != filelen) { printf("** Unable to read \"%s\" from %s %d:%lu **\n", filename, argv[1], dev, part); ext4fs_close(); return 1; } ext4fs_close(); deinit_fs(fs->dev_desc); /* Loading ok, update default load address */ load_addr = addr; printf("%d bytes read\n", filelen); sprintf(buf, "%X", filelen); setenv("filesize", buf); return 0; }
int do_ext4_write(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[]) { const char *filename = "/"; int part_length; unsigned long part = 1; int dev; char *ep; unsigned long ram_address; unsigned long file_size; disk_partition_t info; struct ext_filesystem *fs; if (argc < 6) return cmd_usage(cmdtp); dev = (int)simple_strtoul(argv[2], &ep, 16); ext4_dev_desc = get_dev(argv[1], dev); if (ext4_dev_desc == NULL) { printf("Block device %s %d not supported\n", argv[1], dev); return 1; } if (init_fs(ext4_dev_desc)) return 1; fs = get_fs(); if (*ep) { if (*ep != ':') { puts("Invalid boot device, use `dev[:part]'\n"); goto fail; } part = simple_strtoul(++ep, NULL, 16); } /* get the filename */ filename = argv[3]; /* get the address in hexadecimal format (string to int) */ ram_address = simple_strtoul(argv[4], NULL, 16); /* get the filesize in base 10 format */ file_size = simple_strtoul(argv[5], NULL, 10); /* set the device as block device */ part_length = ext4fs_set_blk_dev(fs->dev_desc, part); if (part_length == 0) { printf("Bad partition - %s %d:%lu\n", argv[1], dev, part); goto fail; } /* register the device and partition */ if (ext4_register_device(fs->dev_desc, part) != 0) { printf("Unable to use %s %d:%lu for fattable\n", argv[1], dev, part); goto fail; } /* get the partition information */ if (!get_partition_info(fs->dev_desc, part, &info)) { total_sector = (info.size * info.blksz) / SECTOR_SIZE; fs->total_sect = total_sector; } else { printf("error : get partition info\n"); goto fail; } /* mount the filesystem */ if (!ext4fs_mount(part_length)) { printf("Bad ext4 partition %s %d:%lu\n", argv[1], dev, part); goto fail; } /* start write */ if (ext4fs_write(filename, (unsigned char *)ram_address, file_size)) { printf("** Error ext4fs_write() **\n"); goto fail; } ext4fs_close(); deinit_fs(fs->dev_desc); return 0; fail: ext4fs_close(); deinit_fs(fs->dev_desc); return 1; }
static int check_recovery_cmd_file(void) { static disk_partition_t info; char buf[CONFIG_RECOVERYFILE_SIZE]; int err; block_dev_desc_t *dev_desc = NULL; int dev = 0; int part = EXT4_CACHE_PART; loff_t filelen; const char *ifname; debug("check_recovery_cmd_file\n"); ifname = getenv("devif"); if ( ifname == NULL) { ifname = "nand"; printf("get devif fail\n"); } dev = get_boot_dev_num(); dev_desc = get_dev(ifname, dev); if (dev_desc == NULL) { printf("Failed to find %s%d\n", ifname, dev); return 1; } debug("part = %d\n", part); if (get_partition_info(dev_desc, part, &info)) { printf("** get_partition_info %s%d:%d\n", ifname, dev, part); if (part != 0) { printf("** Partition %d not valid on device %d **\n", part, dev_desc->dev); return -1; } info.start = 0; info.size = dev_desc->lba; info.blksz = dev_desc->blksz; info.name[0] = 0; info.type[0] = 0; info.bootable = 0; #ifdef CONFIG_PARTITION_UUIDS info.uuid[0] = 0; #endif } ext4fs_set_blk_dev(dev_desc, &info); debug("info.size = %d\n", (int) info.size); if (!ext4fs_mount(info.size)) { printf("Failed to mount %s%d:%d\n", ifname, dev, part); ext4fs_close(); return 1; } err = ext4fs_open(CONFIG_ANDROID_RECOVERY_CMD_FILE, &filelen); if (err < 0) { printf("** File not found %s\n", CONFIG_ANDROID_RECOVERY_CMD_FILE); ext4fs_close(); return 1; } debug("filelen = %lld\n", filelen); err = ext4fs_read(buf, CONFIG_RECOVERYFILE_SIZE, &filelen); if (err < 0) { printf("** File read error: %s\n", CONFIG_ANDROID_RECOVERY_CMD_FILE); ext4fs_close(); return 1; } ext4fs_close(); return 0; }
int spl_load_image_ext_os(struct spl_image_info *spl_image, struct blk_desc *block_dev, int partition) { int err; __maybe_unused loff_t filelen, actlen; disk_partition_t part_info = {}; __maybe_unused char *file; if (part_get_info(block_dev, partition, &part_info)) { printf("spl: no partition table found\n"); return -1; } ext4fs_set_blk_dev(block_dev, &part_info); err = ext4fs_mount(0); if (!err) { #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT printf("%s: ext4fs mount err - %d\n", __func__, err); #endif return -1; } #if defined(CONFIG_SPL_ENV_SUPPORT) file = env_get("falcon_args_file"); if (file) { err = ext4fs_open(file, &filelen); if (err < 0) { puts("spl: ext4fs_open failed\n"); goto defaults; } err = ext4fs_read((void *)CONFIG_SYS_SPL_ARGS_ADDR, 0, filelen, &actlen); if (err < 0) { printf("spl: error reading image %s, err - %d, falling back to default\n", file, err); goto defaults; } file = env_get("falcon_image_file"); if (file) { err = spl_load_image_ext(spl_image, block_dev, partition, file); if (err != 0) { puts("spl: falling back to default\n"); goto defaults; } return 0; } else { puts("spl: falcon_image_file not set in environment, falling back to default\n"); } } else { puts("spl: falcon_args_file not set in environment, falling back to default\n"); } defaults: #endif err = ext4fs_open(CONFIG_SPL_FS_LOAD_ARGS_NAME, &filelen); if (err < 0) puts("spl: ext4fs_open failed\n"); err = ext4fs_read((void *)CONFIG_SYS_SPL_ARGS_ADDR, 0, filelen, &actlen); if (err < 0) { #ifdef CONFIG_SPL_LIBCOMMON_SUPPORT printf("%s: error reading image %s, err - %d\n", __func__, CONFIG_SPL_FS_LOAD_ARGS_NAME, err); #endif return -1; } return spl_load_image_ext(spl_image, block_dev, partition, CONFIG_SPL_FS_LOAD_KERNEL_NAME); }