Re: [Qemu-block] [PATCH v6] qemu-img: add the 'dd' subcommand

[Max Reitz]

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 <address@hidden>
> ---
> 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} address@hidden [...]] 
> @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
> address@hidden dd [--image-opts] [-f @var{fmt}] [-O @var{output_fmt}] 
> address@hidden address@hidden address@hidden address@hidden
> +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