Exemple #1
0
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;
}
Exemple #2
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;
}
Exemple #3
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;
}