Exemple #1
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;
}
Exemple #2
0
int saveenv(void)
{
	env_t	env_new;
	ssize_t	len;
	char	*res;
	block_dev_desc_t *dev_desc = NULL;
	int dev = EXT4_ENV_DEVICE;
	int part = EXT4_ENV_PART;
	int err;

	res = (char *)&env_new.data;
	len = hexport_r(&env_htab, '\0', 0, &res, ENV_SIZE, 0, NULL);
	if (len < 0) {
		error("Cannot export environment: errno = %d\n", errno);
		return 1;
	}

	dev_desc = get_dev(EXT4_ENV_INTERFACE, dev);
	if (dev_desc == NULL) {
		printf("Failed to find %s%d\n",
			EXT4_ENV_INTERFACE, dev);
		return 1;
	}

	err = ext4_register_device(dev_desc, part);
	if (err) {
		printf("Failed to register %s%d:%d\n",
			EXT4_ENV_INTERFACE, dev, part);
		return 1;
	}

	env_new.crc = crc32(0, env_new.data, ENV_SIZE);
	err = ext4fs_write(EXT4_ENV_FILE, (void *)&env_new, sizeof(env_t));
	ext4fs_close();
	if (err == -1) {
		printf("\n** Unable to write \"%s\" from %s%d:%d **\n",
			EXT4_ENV_FILE, EXT4_ENV_INTERFACE, dev, part);
		return 1;
	}

	puts("done\n");
	return 0;
}
Exemple #3
0
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;
}
Exemple #4
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;
}