On 25.07.2016 07:58, Reda Sallahi wrote:
> This patch adds a basic dd subcommand analogous to dd(1) to qemu-img.
>
> For the start, this implements the bs, if, of and count options and requires
> both if and of to be specified (no stdin/stdout if not specified) and doesn't
> support tty, pipes, etc.
>
> The image format must be specified with -O for the output if the raw format
> is not the intended one.
>
> Two tests are added to test qemu-img dd.
>
> Signed-off-by: Reda Sallahi <fullma...@gmail.com>
> ---
> Changes from v5:
> * Add dd sections on qemu-img.texi.
> Changes from v4:
> * Fix the exit status.
> Changes from v3:
> * Delete an unused (so far) field in DdIo.
> Changes from v2:
> * Add copyright headers to new files.
> Changes from v1:
> * Removal of dead code.
> * Fix a memory leak.
> * Complete the cleanup function in the test cases.
>
> qemu-img-cmds.hx | 6 +
> qemu-img.c | 363
> ++++++++++++++++++++++++++++++++++++++-
> qemu-img.texi | 25 +++
> tests/qemu-iotests/158 | 68 ++++++++
> tests/qemu-iotests/158.out | 15 ++
> tests/qemu-iotests/159 | 70 ++++++++
> tests/qemu-iotests/159.out | 87 ++++++++++
> tests/qemu-iotests/common.filter | 9 +
> tests/qemu-iotests/group | 2 +
> 9 files changed, 644 insertions(+), 1 deletion(-)
> create mode 100755 tests/qemu-iotests/158
> create mode 100644 tests/qemu-iotests/158.out
> create mode 100755 tests/qemu-iotests/159
> create mode 100644 tests/qemu-iotests/159.out
>
> diff --git a/qemu-img-cmds.hx b/qemu-img-cmds.hx
> index 7e95b2d..03bdd7a 100644
> --- a/qemu-img-cmds.hx
> +++ b/qemu-img-cmds.hx
> @@ -45,6 +45,12 @@ STEXI
> @item convert [--object @var{objectdef}] [--image-opts] [-c] [-p] [-q] [-n]
> [-f @var{fmt}] [-t @var{cache}] [-T @var{src_cache}] [-O @var{output_fmt}]
> [-o @var{options}] [-s @var{snapshot_id_or_name}] [-l @var{snapshot_param}]
> [-S @var{sparse_size}] @var{filename} [@var{filename2} [...]]
> @var{output_filename}
> ETEXI
>
> +DEF("dd", img_dd,
> + "dd [--image-opts] [-f fmt] [-O output_fmt] [bs=block_size]
> [count=blocks] if=input of=output")
> +STEXI
> +@item dd [--image-opts] [-f @var{fmt}] [-O @var{output_fmt}]
> [bs=@var{block_size}] [count=@var{blocks}] if=@var{input} of=@var{output}
> +ETEXI
> +
> DEF("info", img_info,
> "info [--object objectdef] [--image-opts] [-f fmt] [--output=ofmt]
> [--backing-chain] filename")
> STEXI
> diff --git a/qemu-img.c b/qemu-img.c
> index 2e40e1f..498626b 100644
> --- a/qemu-img.c
> +++ b/qemu-img.c
> @@ -166,7 +166,14 @@ static void QEMU_NORETURN help(void)
> "Parameters to compare subcommand:\n"
> " '-f' first image format\n"
> " '-F' second image format\n"
> - " '-s' run in Strict mode - fail on different image size or
> sector allocation\n";
> + " '-s' run in Strict mode - fail on different image size or
> sector allocation\n"
> + "\n"
> + "Parameters to dd subcommand:\n"
> + " 'bs=BYTES' read and write up to BYTES bytes at a time "
> + "(default: 512)\n"
> + " 'count=N' copy only N input blocks\n"
> + " 'if=FILE' read from FILE\n"
> + " 'of=FILE' write to FILE\n";
>
> printf("%s\nSupported formats:", help_msg);
> bdrv_iterate_format(format_print, NULL);
> @@ -3794,6 +3801,360 @@ out:
> return 0;
> }
>
> +#define C_BS 01
> +#define C_COUNT 02
> +#define C_IF 04
> +#define C_OF 010
Not sure why you used octal here, but since two people already gave
their R-b, I guess it at least has some novelty value. ;-)
Also, I think I'd personally use an enum for this, but that is very much
personal taste.
> +
> +struct DdInfo {
> + unsigned int flags;
> + size_t count;
I'd strongly suggest using uint64_t because the width of size_t depends
on the platform.
> +};
> +
> +struct DdIo {
> + size_t bsz; /* Block size */
I wouldn't use size_t here because of the above reason. However, I would
not use uint64_t here, since you will be passing this value to g_new()
and also to blk_pread(), so I'd use the type of the latter's parameter,
which is int.
> + char *filename;
> + uint8_t *buf;
> +};
> +
> +struct DdOpts {
> + const char *name;
> + int (*f)(const char *, struct DdIo *, struct DdIo *, struct DdInfo *);
> + unsigned int flag;
> +};
> +
> +/*
> + * get_size() was needed for the size syntax dd(1) supports which is
> + * different from qemu_strtosz_suffix()
> + *
> + */
> +static size_t get_size(const char *str)
This function should return a uint64_t, otherwise you won't be able to
go beyond 4 GB on 32 bit machines.
Also, I'd strongly suggest giving this function an Error **errp
parameter, because I really don't like doing internal error handling
using errno.
> +{
> + /* XXX: handle {k,m,g}B notations */
> + unsigned long num;
> + size_t res = 0;
> + const char *buf;
> + int ret;
> +
> + errno = 0;
> + if (strchr(str, '-')) {
> + error_report("invalid number: '%s'", str);
> + errno = EINVAL;
> + return res;
> + }
Not sure what this test is for since qemu_strtoul() will reject negative
numbers anyway, as far as I understand.
> + ret = qemu_strtoul(str, &buf, 0, &num);
> +
> + if (ret < 0) {
> + error_report("invalid number: '%s'", str);
With an Error ** parameter, you'd use the following here:
error_setg_errno(errp, -ret, "invalid number '%s', str);
> + return res;
> + }
> +
> + switch (*buf) {
> + case '\0':
> + case 'c':
> + res = num;
> + break;
> + case 'w':
> + res = num * 2;
> + break;
> + case 'b':
> + res = num * 512;
> + break;
> + case 'K':
> + res = num * 1024;
> + break;
> + case 'M':
> + res = num * 1024 * 1024;
> + break;
> + case 'G':
> + res = num * 1024 * 1024 * 1024;
> + break;
> + case 'T':
> + res = num * 1024 * 1024 * 1024 * 1024;
Starting from here, these multiplications will overflow on systems where
sizeof(size_t) <= 4, i.e. on 32 bit platforms. I suggest using uint64_t
for num and qemu_strtoull() above.
> + break;
> + case 'P':
> + res = num * 1024 * 1024 * 1024 * 1024 * 1024;
> + break;
> + case 'E':
> + res = num * 1024 * 1024 * 1024 * 1024 * 1024 * 1024;
> + break;
> + case 'Z':
> + res = num * 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024;
> + break;
> + case 'Y':
> + res = num * 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024;
> + break;
> + default:
> + error_report("invalid number: '%s'", str);
> + errno = EINVAL;
> + }
> +
> + return res;
> +}
> +
> +static int img_dd_bs(const char *arg,
> + struct DdIo *in, struct DdIo *out,
> + struct DdInfo *dd)
If you give get_size() an Error ** parameter, I'd suggest giving these
error evaluation functions one, too. You could then pass errors from
get_size() on to the caller.
> +{
> + in->bsz = out->bsz = get_size(arg);
If you make get_size() return a uint64_t and bsz an int, you will have
to check for overflows here.
> +
> + if (in->bsz == 0 && (errno == EINVAL || errno == ERANGE)) {
> + return 1;
> + }
> + if (in->bsz == 0) {
> + error_report("invalid number: '%s'", arg);
It's not an invalid number, it's just an invalid block size. In my
understanding, those are two different things.
> + return 1;
> + }
> +
> + return 0;
> +}
> +
> +static int img_dd_count(const char *arg,
> + struct DdIo *in, struct DdIo *out,
> + struct DdInfo *dd)
> +{
> + dd->count = get_size(arg);
> +
> + if (dd->count == 0 && (errno == EINVAL || errno == ERANGE)) {
> + return 1;
> + }
> +
> + return 0;
> +}
> +
> +static int img_dd_if(const char *arg,
> + struct DdIo *in, struct DdIo *out,
> + struct DdInfo *dd)
> +{
> + in->filename = g_strdup(arg);
> +
> + return 0;
> +}
> +
> +static int img_dd_of(const char *arg,
> + struct DdIo *in, struct DdIo *out,
> + struct DdInfo *dd)
> +{
> + out->filename = g_strdup(arg);
> +
> + return 0;
> +}
> +
> +static int img_dd(int argc, char **argv)
> +{
> + int ret = 0;
> + char *arg = NULL;
> + char *tmp;
> + BlockDriver *drv = NULL, *proto_drv = NULL;
> + BlockBackend *blk1 = NULL, *blk2 = NULL;
> + QemuOpts *opts = NULL;
> + QemuOptsList *create_opts = NULL;
> + Error *local_err = NULL;
> + bool image_opts = false;
> + int c;
> + const char *out_fmt = "raw";
> + const char *fmt = NULL;
> + int64_t size = 0;
> + int64_t block_count = 0, incount = 0, outcount = 0;
> + struct DdInfo dd = {
> + .flags = 0,
> + .count = 0,
> + };
> + struct DdIo in = {
> + .bsz = 512, /* Block size is by default 512 bytes */
> + .filename = NULL,
> + .buf = NULL
> + };
> + struct DdIo out = {
> + .bsz = 512,
> + .filename = NULL,
> + .buf = NULL
> + };
> +
> + const struct DdOpts options[] = {
> + { "bs", img_dd_bs, C_BS },
> + { "count", img_dd_count, C_COUNT },
> + { "if", img_dd_if, C_IF },
> + { "of", img_dd_of, C_OF },
> + { NULL, NULL, 0 }
> + };
> + const struct option long_options[] = {
> + { "help", no_argument, 0, 'h'},
> + { "image-opts", no_argument, 0, OPTION_IMAGE_OPTS},
> + { 0, 0, 0, 0 }
> + };
> +
> + while ((c = getopt_long(argc, argv, "hf:O:", long_options, NULL))) {
> + if (c == EOF) {
> + break;
> + }
> + switch (c) {
> + case 'O':
> + out_fmt = optarg;
> + break;
> + case 'f':
> + fmt = optarg;
> + break;
> + case '?':
> + error_report("Try 'qemu-img --help' for more information.");
> + ret = -1;
> + goto out;
> + break;
The break is rather unnecessary with the goto in front of it.
> + case 'h':
> + help();
> + break;
> + case OPTION_IMAGE_OPTS:
> + image_opts = true;
> + break;
> + }
> + }
> +
> + for (int i = optind; i < argc; i++) {
> + int j;
> + arg = g_strdup(argv[i]);
> +
> + tmp = strchr(arg, '=');
FYI, strtok() is a neat function for exactly this. I'm not saying you
need to use it, though.
> + if (tmp == NULL) {
> + error_report("unrecognized operand %s", arg);
> + ret = -1;
> + goto out;
> + }
> +
> + *tmp++ = '\0';
> +
> + for (j = 0; options[j].name != NULL; j++) {
> + if (!strcmp(arg, options[j].name)) {
> + break;
> + }
> + }
> + if (options[j].name == NULL) {
> + error_report("unrecognized operand %s", arg);
> + ret = -1;
> + goto out;
> + }
> +
> + if (options[j].f(tmp, &in, &out, &dd) != 0) {
> + ret = -1;
> + goto out;
> + }
> + dd.flags |= options[j].flag;
> + g_free(arg);
> + arg = NULL;
> + }
> +
> + if (!(dd.flags & C_IF && dd.flags & C_OF)) {
> + error_report("Must specify both input and output files");
> + ret = -1;
> + goto out;
> + }
> + blk1 = img_open(image_opts, in.filename, fmt, 0, false, true);
I'm not quite sure why you're passing true for quiet here.
> +
> + if (!blk1) {
> + ret = -1;
> + goto out;
> + }
> +
> + drv = bdrv_find_format(out_fmt);
> + if (!drv) {
> + error_report("Unknown file format");
> + ret = -1;
> + goto out;
> + }
> + proto_drv = bdrv_find_protocol(out.filename, true, &local_err);
> +
> + if (!proto_drv) {
> + error_report_err(local_err);
> + ret = -1;
> + goto out;
> + }
> + if (!drv->create_opts) {
> + error_report("Format driver '%s' does not support image creation",
> + drv->format_name);
> + ret = -1;
> + goto out;
> + }
> + if (!proto_drv->create_opts) {
> + error_report("Protocol driver '%s' does not support image creation",
> + proto_drv->format_name);
> + ret = -1;
> + goto out;
> + }
> + create_opts = qemu_opts_append(create_opts, drv->create_opts);
> + create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
> +
> + opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
> +
> + size = blk_getlength(blk1);
There's a superfluous space after the equal sign. Also, blk_getlength()
may fail, you should catch that case.
> +
> + if (dd.flags & C_COUNT && dd.count * in.bsz < size) {
> + size = dd.count * in.bsz;
> + }
> +
> + qemu_opt_set_number(opts, BLOCK_OPT_SIZE, size, &error_abort);
> +
> + ret = bdrv_create(drv, out.filename, opts, &local_err);
> + if (ret < 0) {
> + error_reportf_err(local_err,
> + "%s: error while creating output image: ",
> + out.filename);
> + ret = -1;
> + goto out;
> + }
> +
> + blk2 = img_open(image_opts, out.filename, out_fmt, BDRV_O_RDWR,
> + false, true);
Again, not sure why quiet is true.
> +
> + if (!blk2) {
> + ret = -1;
> + goto out;
> + }
> +
> + in.buf = g_new(uint8_t, in.bsz);
> +
> + for (; incount < size; block_count++) {
Please do not initialize incount above but here. Having to jump more
than a hundred lines up to find out what a variable is set to makes code
very hard to read.
Also, I'd rename incount to in_offset or something, because "incount" to
me sounds like it counts a number of blocks, whereas it actually counts
a number of bytes, independently of the block size.
> + int in_ret, out_ret;
> +
> + if (in.bsz + incount > size) {
Not wrong, but I'd turn the summands around, i.e. "incount + in.bsz" (or
"in_offset + in.bsz"). That makes more sense intuitively, since you're
adding the new block you want to read to the offset where you already are.
Max
> + in_ret = blk_pread(blk1, incount, in.buf, size - incount);
> + } else {
> + in_ret = blk_pread(blk1, incount, in.buf, in.bsz);
> + }
> + if (in_ret < 0) {
> + error_report("error while reading from input image file: %s",
> + strerror(-in_ret));
> + ret = -1;
> + goto out;
> + }
> + incount += in_ret;
> +
> + out_ret = blk_pwrite(blk2, outcount, in.buf, in_ret, 0);
> +
> + if (out_ret < 0) {
> + error_report("error while writing to output image file: %s",
> + strerror(-out_ret));
> + ret = -1;
> + goto out;
> + }
> + outcount += out_ret;
> + }
> +
> +out:
> + g_free(arg);
> + qemu_opts_del(opts);
> + qemu_opts_free(create_opts);
> + blk_unref(blk1);
> + blk_unref(blk2);
> + g_free(in.filename);
> + g_free(out.filename);
> + g_free(in.buf);
> + g_free(out.buf);
> +
> + if (ret) {
> + return 1;
> + }
> + return 0;
> +}
> +
>
> static const img_cmd_t img_cmds[] = {
> #define DEF(option, callback, arg_string) \
signature.asc
Description: OpenPGP digital signature
