From 9bd448e0f256ac9327363a0f370b9616d967e986 Mon Sep 17 00:00:00 2001

From: John Snow <jsnow@redhat.com>

Date: Mon, 23 Nov 2015 17:38:25 +0100

Subject: [PATCH 06/27] qemu-io: Split off commands to qemu-io-cmds.c

RH-Author: John Snow <jsnow@redhat.com>

Message-id: <1448300320-7772-7-git-send-email-jsnow@redhat.com>

Patchwork-id: 68434

O-Subject: [RHEL-7.3 qemu-kvm PATCH v2 06/21] qemu-io: Split off commands to qemu-io-cmds.c

Bugzilla: 1272523

RH-Acked-by: Thomas Huth <thuth@redhat.com>

RH-Acked-by: Laszlo Ersek <lersek@redhat.com>

RH-Acked-by: Max Reitz <mreitz@redhat.com>

From: Kevin Wolf <kwolf@redhat.com>

This is the implementation of all qemu-io commands that make sense to be

called from the qemu monitor, i.e. everything except open, close and

quit.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>

Reviewed-by: Eric Blake <eblake@redhat.com>

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>

(cherry picked from commit 797ac58cb2093ab9192d8998a1fef85d87cc8661)

Signed-off-by: John Snow <jsnow@redhat.com>

Signed-off-by: Miroslav Rezanina <mrezanin@redhat.com>

Conflicts:

  qemu-io.c: Minor differences, but as this is code motion,

             The code motion had to be re-done to preserve

             any backported changes.

  qemu-io-cmds.c: re-created from downstream qemu-io.c.

Signed-off-by: John Snow <jsnow@redhat.com>

---

 Makefile       |    2 +-

 qemu-io-cmds.c | 1853 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++

 qemu-io.c      | 1831 +------------------------------------------------------

 3 files changed, 1856 insertions(+), 1830 deletions(-)

 create mode 100644 qemu-io-cmds.c

diff --git a/Makefile b/Makefile

index 8407945..f28ce29 100644

--- a/Makefile

+++ b/Makefile

@@ -205,7 +205,7 @@ qemu-img.o: qemu-img-cmds.h

 qemu-img$(EXESUF): qemu-img.o $(block-obj-y) libqemuutil.a libqemustub.a

 qemu-nbd$(EXESUF): qemu-nbd.o $(block-obj-y) libqemuutil.a libqemustub.a

-qemu-io$(EXESUF): qemu-io.o cmd.o $(block-obj-y) libqemuutil.a libqemustub.a

+qemu-io$(EXESUF): qemu-io.o qemu-io-cmds.o cmd.o $(block-obj-y) libqemuutil.a libqemustub.a

 qemu-bridge-helper$(EXESUF): qemu-bridge-helper.o

diff --git a/qemu-io-cmds.c b/qemu-io-cmds.c

new file mode 100644

index 0000000..efa6070

--- /dev/null

+++ b/qemu-io-cmds.c

@@ -0,0 +1,1853 @@

+/*

+ * Command line utility to exercise the QEMU I/O path.

+ *

+ * Copyright (C) 2009 Red Hat, Inc.

+ * Copyright (c) 2003-2005 Silicon Graphics, Inc.

+ *

+ * This work is licensed under the terms of the GNU GPL, version 2 or later.

+ * See the COPYING file in the top-level directory.

+ */

+

+#include "qemu-common.h"

+#include "block/block_int.h"

+#include "block/qapi.h"

+#include "cmd.h"

+

+#define CMD_NOFILE_OK   0x01

+

+int qemuio_misalign;

+

+static int64_t cvtnum(const char *s)

+{

+    char *end;

+    return strtosz_suffix(s, &end, STRTOSZ_DEFSUFFIX_B);

+}

+

+/*

+ * Parse the pattern argument to various sub-commands.

+ *

+ * Because the pattern is used as an argument to memset it must evaluate

+ * to an unsigned integer that fits into a single byte.

+ */

+static int parse_pattern(const char *arg)

+{

+    char *endptr = NULL;

+    long pattern;

+

+    pattern = strtol(arg, &endptr, 0);

+    if (pattern < 0 || pattern > UCHAR_MAX || *endptr != '\0') {

+        printf("%s is not a valid pattern byte\n", arg);

+        return -1;

+    }

+

+    return pattern;

+}

+

+/*

+ * Memory allocation helpers.

+ *

+ * Make sure memory is aligned by default, or purposefully misaligned if

+ * that is specified on the command line.

+ */

+

+#define MISALIGN_OFFSET     16

+static void *qemu_io_alloc(BlockDriverState *bs, size_t len, int pattern)

+{

+    void *buf;

+

+    if (qemuio_misalign) {

+        len += MISALIGN_OFFSET;

+    }

+    buf = qemu_blockalign(bs, len);

+    memset(buf, pattern, len);

+    if (qemuio_misalign) {

+        buf += MISALIGN_OFFSET;

+    }

+    return buf;

+}

+

+static void qemu_io_free(void *p)

+{

+    if (qemuio_misalign) {

+        p -= MISALIGN_OFFSET;

+    }

+    qemu_vfree(p);

+}

+

+static void dump_buffer(const void *buffer, int64_t offset, int len)

+{

+    int i, j;

+    const uint8_t *p;

+

+    for (i = 0, p = buffer; i < len; i += 16) {

+        const uint8_t *s = p;

+

+        printf("%08" PRIx64 ":  ", offset + i);

+        for (j = 0; j < 16 && i + j < len; j++, p++) {

+            printf("%02x ", *p);

+        }

+        printf(" ");

+        for (j = 0; j < 16 && i + j < len; j++, s++) {

+            if (isalnum(*s)) {

+                printf("%c", *s);

+            } else {

+                printf(".");

+            }

+        }

+        printf("\n");

+    }

+}

+

+static void print_report(const char *op, struct timeval *t, int64_t offset,

+                         int count, int total, int cnt, int Cflag)

+{

+    char s1[64], s2[64], ts[64];

+

+    timestr(t, ts, sizeof(ts), Cflag ? VERBOSE_FIXED_TIME : 0);

+    if (!Cflag) {

+        cvtstr((double)total, s1, sizeof(s1));

+        cvtstr(tdiv((double)total, *t), s2, sizeof(s2));

+        printf("%s %d/%d bytes at offset %" PRId64 "\n",

+               op, total, count, offset);

+        printf("%s, %d ops; %s (%s/sec and %.4f ops/sec)\n",

+               s1, cnt, ts, s2, tdiv((double)cnt, *t));

+    } else {/* bytes,ops,time,bytes/sec,ops/sec */

+        printf("%d,%d,%s,%.3f,%.3f\n",

+            total, cnt, ts,

+            tdiv((double)total, *t),

+            tdiv((double)cnt, *t));

+    }

+}

+

+/*

+ * Parse multiple length statements for vectored I/O, and construct an I/O

+ * vector matching it.

+ */

+static void *

+create_iovec(BlockDriverState *bs, QEMUIOVector *qiov, char **argv, int nr_iov,

+             int pattern)

+{

+    size_t *sizes = g_new0(size_t, nr_iov);

+    size_t count = 0;

+    void *buf = NULL;

+    void *p;

+    int i;

+

+    for (i = 0; i < nr_iov; i++) {

+        char *arg = argv[i];

+        int64_t len;

+

+        len = cvtnum(arg);

+        if (len < 0) {

+            printf("non-numeric length argument -- %s\n", arg);

+            goto fail;

+        }

+

+        /* should be SIZE_T_MAX, but that doesn't exist */

+        if (len > INT_MAX) {

+            printf("too large length argument -- %s\n", arg);

+            goto fail;

+        }

+

+        if (len & 0x1ff) {

+            printf("length argument %" PRId64

+                   " is not sector aligned\n", len);

+            goto fail;

+        }

+

+        sizes[i] = len;

+        count += len;

+    }

+

+    qemu_iovec_init(qiov, nr_iov);

+

+    buf = p = qemu_io_alloc(bs, count, pattern);

+

+    for (i = 0; i < nr_iov; i++) {

+        qemu_iovec_add(qiov, p, sizes[i]);

+        p += sizes[i];

+    }

+

+fail:

+    g_free(sizes);

+    return buf;

+}

+

+static int do_read(BlockDriverState *bs, char *buf, int64_t offset, int count,

+                   int *total)

+{

+    int ret;

+

+    ret = bdrv_read(bs, offset >> 9, (uint8_t *)buf, count >> 9);

+    if (ret < 0) {

+        return ret;

+    }

+    *total = count;

+    return 1;

+}

+

+static int do_write(BlockDriverState *bs, char *buf, int64_t offset, int count,

+                    int *total)

+{

+    int ret;

+

+    ret = bdrv_write(bs, offset >> 9, (uint8_t *)buf, count >> 9);

+    if (ret < 0) {

+        return ret;

+    }

+    *total = count;

+    return 1;

+}

+

+static int do_pread(BlockDriverState *bs, char *buf, int64_t offset, int count,

+                    int *total)

+{

+    *total = bdrv_pread(bs, offset, (uint8_t *)buf, count);

+    if (*total < 0) {

+        return *total;

+    }

+    return 1;

+}

+

+static int do_pwrite(BlockDriverState *bs, char *buf, int64_t offset, int count,

+                     int *total)

+{

+    *total = bdrv_pwrite(bs, offset, (uint8_t *)buf, count);

+    if (*total < 0) {

+        return *total;

+    }

+    return 1;

+}

+

+typedef struct {

+    BlockDriverState *bs;

+    int64_t offset;

+    int count;

+    int *total;

+    int ret;

+    bool done;

+} CoWriteZeroes;

+

+static void coroutine_fn co_write_zeroes_entry(void *opaque)

+{

+    CoWriteZeroes *data = opaque;

+

+    data->ret = bdrv_co_write_zeroes(data->bs, data->offset / BDRV_SECTOR_SIZE,

+                                     data->count / BDRV_SECTOR_SIZE, 0);

+    data->done = true;

+    if (data->ret < 0) {

+        *data->total = data->ret;

+        return;

+    }

+

+    *data->total = data->count;

+}

+

+static int do_co_write_zeroes(BlockDriverState *bs, int64_t offset, int count,

+                              int *total)

+{

+    Coroutine *co;

+    CoWriteZeroes data = {

+        .bs     = bs,

+        .offset = offset,

+        .count  = count,

+        .total  = total,

+        .done   = false,

+    };

+

+    co = qemu_coroutine_create(co_write_zeroes_entry);

+    qemu_coroutine_enter(co, &data);

+    while (!data.done) {

+        qemu_aio_wait();

+    }

+    if (data.ret < 0) {

+        return data.ret;

+    } else {

+        return 1;

+    }

+}

+

+static int do_write_compressed(BlockDriverState *bs, char *buf, int64_t offset,

+                               int count, int *total)

+{

+    int ret;

+

+    ret = bdrv_write_compressed(bs, offset >> 9, (uint8_t *)buf, count >> 9);

+    if (ret < 0) {

+        return ret;

+    }

+    *total = count;

+    return 1;

+}

+

+static int do_load_vmstate(BlockDriverState *bs, char *buf, int64_t offset,

+                           int count, int *total)

+{

+    *total = bdrv_load_vmstate(bs, (uint8_t *)buf, offset, count);

+    if (*total < 0) {

+        return *total;

+    }

+    return 1;

+}

+

+static int do_save_vmstate(BlockDriverState *bs, char *buf, int64_t offset,

+                           int count, int *total)

+{

+    *total = bdrv_save_vmstate(bs, (uint8_t *)buf, offset, count);

+    if (*total < 0) {

+        return *total;

+    }

+    return 1;

+}

+

+#define NOT_DONE 0x7fffffff

+static void aio_rw_done(void *opaque, int ret)

+{

+    *(int *)opaque = ret;

+}

+

+static int do_aio_readv(BlockDriverState *bs, QEMUIOVector *qiov,

+                        int64_t offset, int *total)

+{

+    int async_ret = NOT_DONE;

+

+    bdrv_aio_readv(bs, offset >> 9, qiov, qiov->size >> 9,

+                   aio_rw_done, &async_ret);

+    while (async_ret == NOT_DONE) {

+        main_loop_wait(false);

+    }

+

+    *total = qiov->size;

+    return async_ret < 0 ? async_ret : 1;

+}

+

+static int do_aio_writev(BlockDriverState *bs, QEMUIOVector *qiov,

+                         int64_t offset, int *total)

+{

+    int async_ret = NOT_DONE;

+

+    bdrv_aio_writev(bs, offset >> 9, qiov, qiov->size >> 9,

+                    aio_rw_done, &async_ret);

+    while (async_ret == NOT_DONE) {

+        main_loop_wait(false);

+    }

+

+    *total = qiov->size;

+    return async_ret < 0 ? async_ret : 1;

+}

+

+struct multiwrite_async_ret {

+    int num_done;

+    int error;

+};

+

+static void multiwrite_cb(void *opaque, int ret)

+{

+    struct multiwrite_async_ret *async_ret = opaque;

+

+    async_ret->num_done++;

+    if (ret < 0) {

+        async_ret->error = ret;

+    }

+}

+

+static int do_aio_multiwrite(BlockDriverState *bs, BlockRequest* reqs,

+                             int num_reqs, int *total)

+{

+    int i, ret;

+    struct multiwrite_async_ret async_ret = {

+        .num_done = 0,

+        .error = 0,

+    };

+

+    *total = 0;

+    for (i = 0; i < num_reqs; i++) {

+        reqs[i].cb = multiwrite_cb;

+        reqs[i].opaque = &async_ret;

+        *total += reqs[i].qiov->size;

+    }

+

+    ret = bdrv_aio_multiwrite(bs, reqs, num_reqs);

+    if (ret < 0) {

+        return ret;

+    }

+

+    while (async_ret.num_done < num_reqs) {

+        main_loop_wait(false);

+    }

+

+    return async_ret.error < 0 ? async_ret.error : 1;

+}

+

+static void read_help(void)

+{

+    printf(

+"\n"

+" reads a range of bytes from the given offset\n"

+"\n"

+" Example:\n"

+" 'read -v 512 1k' - dumps 1 kilobyte read from 512 bytes into the file\n"

+"\n"

+" Reads a segment of the currently open file, optionally dumping it to the\n"

+" standard output stream (with -v option) for subsequent inspection.\n"

+" -b, -- read from the VM state rather than the virtual disk\n"

+" -C, -- report statistics in a machine parsable format\n"

+" -l, -- length for pattern verification (only with -P)\n"

+" -p, -- use bdrv_pread to read the file\n"

+" -P, -- use a pattern to verify read data\n"

+" -q, -- quiet mode, do not show I/O statistics\n"

+" -s, -- start offset for pattern verification (only with -P)\n"

+" -v, -- dump buffer to standard output\n"

+"\n");

+}

+

+static int read_f(BlockDriverState *bs, int argc, char **argv);

+

+static const cmdinfo_t read_cmd = {

+    .name       = "read",

+    .altname    = "r",

+    .cfunc      = read_f,

+    .argmin     = 2,

+    .argmax     = -1,

+    .args       = "[-abCpqv] [-P pattern [-s off] [-l len]] off len",

+    .oneline    = "reads a number of bytes at a specified offset",

+    .help       = read_help,

+};

+

+static int read_f(BlockDriverState *bs, int argc, char **argv)

+{

+    struct timeval t1, t2;

+    int Cflag = 0, pflag = 0, qflag = 0, vflag = 0;

+    int Pflag = 0, sflag = 0, lflag = 0, bflag = 0;

+    int c, cnt;

+    char *buf;

+    int64_t offset;

+    int count;

+    /* Some compilers get confused and warn if this is not initialized.  */

+    int total = 0;

+    int pattern = 0, pattern_offset = 0, pattern_count = 0;

+

+    while ((c = getopt(argc, argv, "bCl:pP:qs:v")) != EOF) {

+        switch (c) {

+        case 'b':

+            bflag = 1;

+            break;

+        case 'C':

+            Cflag = 1;

+            break;

+        case 'l':

+            lflag = 1;

+            pattern_count = cvtnum(optarg);

+            if (pattern_count < 0) {

+                printf("non-numeric length argument -- %s\n", optarg);

+                return 0;

+            }

+            break;

+        case 'p':

+            pflag = 1;

+            break;

+        case 'P':

+            Pflag = 1;

+            pattern = parse_pattern(optarg);

+            if (pattern < 0) {

+                return 0;

+            }

+            break;

+        case 'q':

+            qflag = 1;

+            break;

+        case 's':

+            sflag = 1;

+            pattern_offset = cvtnum(optarg);

+            if (pattern_offset < 0) {

+                printf("non-numeric length argument -- %s\n", optarg);

+                return 0;

+            }

+            break;

+        case 'v':

+            vflag = 1;

+            break;

+        default:

+            return command_usage(&read_cmd);

+        }

+    }

+

+    if (optind != argc - 2) {

+        return command_usage(&read_cmd);

+    }

+

+    if (bflag && pflag) {

+        printf("-b and -p cannot be specified at the same time\n");

+        return 0;

+    }

+

+    offset = cvtnum(argv[optind]);

+    if (offset < 0) {

+        printf("non-numeric length argument -- %s\n", argv[optind]);

+        return 0;

+    }

+

+    optind++;

+    count = cvtnum(argv[optind]);

+    if (count < 0) {

+        printf("non-numeric length argument -- %s\n", argv[optind]);

+        return 0;

+    }

+

+    if (!Pflag && (lflag || sflag)) {

+        return command_usage(&read_cmd);

+    }

+

+    if (!lflag) {

+        pattern_count = count - pattern_offset;

+    }

+

+    if ((pattern_count < 0) || (pattern_count + pattern_offset > count))  {

+        printf("pattern verification range exceeds end of read data\n");

+        return 0;

+    }

+

+    if (!pflag) {

+        if (offset & 0x1ff) {

+            printf("offset %" PRId64 " is not sector aligned\n",

+                   offset);

+            return 0;

+        }

+        if (count & 0x1ff) {

+            printf("count %d is not sector aligned\n",

+                   count);

+            return 0;

+        }

+    }

+

+    buf = qemu_io_alloc(bs, count, 0xab);

+

+    gettimeofday(&t1, NULL);

+    if (pflag) {

+        cnt = do_pread(bs, buf, offset, count, &total);

+    } else if (bflag) {

+        cnt = do_load_vmstate(bs, buf, offset, count, &total);

+    } else {

+        cnt = do_read(bs, buf, offset, count, &total);

+    }

+    gettimeofday(&t2, NULL);

+

+    if (cnt < 0) {

+        printf("read failed: %s\n", strerror(-cnt));

+        goto out;

+    }

+

+    if (Pflag) {

+        void *cmp_buf = g_malloc(pattern_count);

+        memset(cmp_buf, pattern, pattern_count);

+        if (memcmp(buf + pattern_offset, cmp_buf, pattern_count)) {

+            printf("Pattern verification failed at offset %"

+                   PRId64 ", %d bytes\n",

+                   offset + pattern_offset, pattern_count);

+        }

+        g_free(cmp_buf);

+    }

+

+    if (qflag) {

+        goto out;

+    }

+

+    if (vflag) {

+        dump_buffer(buf, offset, count);

+    }

+

+    /* Finally, report back -- -C gives a parsable format */

+    t2 = tsub(t2, t1);

+    print_report("read", &t2, offset, count, total, cnt, Cflag);

+

+out:

+    qemu_io_free(buf);

+

+    return 0;

+}

+

+static void readv_help(void)

+{

+    printf(

+"\n"

+" reads a range of bytes from the given offset into multiple buffers\n"

+"\n"

+" Example:\n"

+" 'readv -v 512 1k 1k ' - dumps 2 kilobytes read from 512 bytes into the file\n"

+"\n"

+" Reads a segment of the currently open file, optionally dumping it to the\n"

+" standard output stream (with -v option) for subsequent inspection.\n"

+" Uses multiple iovec buffers if more than one byte range is specified.\n"

+" -C, -- report statistics in a machine parsable format\n"

+" -P, -- use a pattern to verify read data\n"

+" -v, -- dump buffer to standard output\n"

+" -q, -- quiet mode, do not show I/O statistics\n"

+"\n");

+}

+

+static int readv_f(BlockDriverState *bs, int argc, char **argv);

+

+static const cmdinfo_t readv_cmd = {

+    .name       = "readv",

+    .cfunc      = readv_f,

+    .argmin     = 2,

+    .argmax     = -1,

+    .args       = "[-Cqv] [-P pattern ] off len [len..]",

+    .oneline    = "reads a number of bytes at a specified offset",

+    .help       = readv_help,

+};

+

+static int readv_f(BlockDriverState *bs, int argc, char **argv)

+{

+    struct timeval t1, t2;

+    int Cflag = 0, qflag = 0, vflag = 0;

+    int c, cnt;

+    char *buf;

+    int64_t offset;

+    /* Some compilers get confused and warn if this is not initialized.  */

+    int total = 0;

+    int nr_iov;

+    QEMUIOVector qiov;

+    int pattern = 0;

+    int Pflag = 0;

+

+    while ((c = getopt(argc, argv, "CP:qv")) != EOF) {

+        switch (c) {

+        case 'C':

+            Cflag = 1;

+            break;

+        case 'P':

+            Pflag = 1;

+            pattern = parse_pattern(optarg);

+            if (pattern < 0) {

+                return 0;

+            }

+            break;

+        case 'q':

+            qflag = 1;

+            break;

+        case 'v':

+            vflag = 1;

+            break;

+        default:

+            return command_usage(&readv_cmd);

+        }

+    }

+

+    if (optind > argc - 2) {

+        return command_usage(&readv_cmd);

+    }

+

+

+    offset = cvtnum(argv[optind]);

+    if (offset < 0) {

+        printf("non-numeric length argument -- %s\n", argv[optind]);

+        return 0;

+    }

+    optind++;

+

+    if (offset & 0x1ff) {

+        printf("offset %" PRId64 " is not sector aligned\n",

+               offset);

+        return 0;

+    }

+

+    nr_iov = argc - optind;

+    buf = create_iovec(bs, &qiov, &argv[optind], nr_iov, 0xab);

+    if (buf == NULL) {

+        return 0;

+    }