From cc8c7cffb3786855de0032b376c7b22c461b695c Mon Sep 17 00:00:00 2001

From: Max Reitz <mreitz@redhat.com>

Date: Mon, 25 Jun 2018 13:12:14 +0200

Subject: [PATCH 41/54] qemu-io: Let command functions return error code

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

Message-id: <20180618164312.24423-3-mreitz@redhat.com>

Patchwork-id: 80781

O-Subject: [RHV-7.6 qemu-kvm-rhev PATCH 2/5] qemu-io: Let command functions return error code

Bugzilla: 1519617

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

RH-Acked-by: Kevin Wolf <kwolf@redhat.com>

RH-Acked-by: Miroslav Rezanina <mrezanin@redhat.com>

This is basically what everything else in the qemu code base does, so we

can do it here, too.

Signed-off-by: Max Reitz <mreitz@redhat.com>

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

Message-id: 20180509194302.21585-3-mreitz@redhat.com

Signed-off-by: Max Reitz <mreitz@redhat.com>

(cherry picked from commit b32d7a39af488d280ce5f02a2ed94871d696f87a)

Signed-off-by: Max Reitz <mreitz@redhat.com>

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

---

 include/qemu-io.h |   9 +-

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

 qemu-io.c         |  34 ++++--

 3 files changed, 232 insertions(+), 157 deletions(-)

diff --git a/include/qemu-io.h b/include/qemu-io.h

index 06cdfbf..7433239 100644

--- a/include/qemu-io.h

+++ b/include/qemu-io.h

@@ -22,7 +22,12 @@

 #define CMD_FLAG_GLOBAL ((int)0x80000000) /* don't iterate "args" */

-typedef void (*cfunc_t)(BlockBackend *blk, int argc, char **argv);

+/* Implement a qemu-io command.

+ * Operate on @blk using @argc/@argv as the command's arguments, and

+ * return 0 on success or negative errno on failure.

+ */

+typedef int (*cfunc_t)(BlockBackend *blk, int argc, char **argv);

+

 typedef void (*helpfunc_t)(void);

 typedef struct cmdinfo {

@@ -41,7 +46,7 @@ typedef struct cmdinfo {

 extern bool qemuio_misalign;

-void qemuio_command(BlockBackend *blk, const char *cmd);

+int qemuio_command(BlockBackend *blk, const char *cmd);

 void qemuio_add_command(const cmdinfo_t *ci);

 void qemuio_command_usage(const cmdinfo_t *ci);

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

index c2fbaae..5bf5f28 100644

--- a/qemu-io-cmds.c

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

@@ -65,13 +65,13 @@ static int init_check_command(BlockBackend *blk, const cmdinfo_t *ct)

     return 1;

 }

-static void command(BlockBackend *blk, const cmdinfo_t *ct, int argc,

-                    char **argv)

+static int command(BlockBackend *blk, const cmdinfo_t *ct, int argc,

+                   char **argv)

 {

     char *cmd = argv[0];

     if (!init_check_command(blk, ct)) {

-        return;

+        return -EINVAL;

     }

     if (argc - 1 < ct->argmin || (ct->argmax != -1 && argc - 1 > ct->argmax)) {

@@ -88,7 +88,7 @@ static void command(BlockBackend *blk, const cmdinfo_t *ct, int argc,

                     "bad argument count %d to %s, expected between %d and %d arguments\n",

                     argc-1, cmd, ct->argmin, ct->argmax);

         }

-        return;

+        return -EINVAL;

     }

     /* Request additional permissions if necessary for this command. The caller

@@ -108,13 +108,13 @@ static void command(BlockBackend *blk, const cmdinfo_t *ct, int argc,

             ret = blk_set_perm(blk, new_perm, orig_shared_perm, &local_err);

             if (ret < 0) {

                 error_report_err(local_err);

-                return;

+                return ret;

             }

         }

     }

     optind = 0;

-    ct->cfunc(blk, argc, argv);

+    return ct->cfunc(blk, argc, argv);

 }

 static const cmdinfo_t *find_command(const char *cmd)

@@ -633,7 +633,7 @@ static void read_help(void)

 "\n");

 }

-static void read_f(BlockBackend *blk, int argc, char **argv);

+static int read_f(BlockBackend *blk, int argc, char **argv);

 static const cmdinfo_t read_cmd = {

     .name       = "read",

@@ -646,12 +646,12 @@ static const cmdinfo_t read_cmd = {

     .help       = read_help,

 };

-static void read_f(BlockBackend *blk, int argc, char **argv)

+static int read_f(BlockBackend *blk, int argc, char **argv)

 {

     struct timeval t1, t2;

     bool Cflag = false, qflag = false, vflag = false;

     bool Pflag = false, sflag = false, lflag = false, bflag = false;

-    int c, cnt;

+    int c, cnt, ret;

     char *buf;

     int64_t offset;

     int64_t count;

@@ -673,7 +673,7 @@ static void read_f(BlockBackend *blk, int argc, char **argv)

             pattern_count = cvtnum(optarg);

             if (pattern_count < 0) {

                 print_cvtnum_err(pattern_count, optarg);

-                return;

+                return pattern_count;

             }

             break;

         case 'p':

@@ -683,7 +683,7 @@ static void read_f(BlockBackend *blk, int argc, char **argv)

             Pflag = true;

             pattern = parse_pattern(optarg);

             if (pattern < 0) {

-                return;

+                return -EINVAL;

             }

             break;

         case 'q':

@@ -694,7 +694,7 @@ static void read_f(BlockBackend *blk, int argc, char **argv)

             pattern_offset = cvtnum(optarg);

             if (pattern_offset < 0) {

                 print_cvtnum_err(pattern_offset, optarg);

-                return;

+                return pattern_offset;

             }

             break;

         case 'v':

@@ -702,35 +702,35 @@ static void read_f(BlockBackend *blk, int argc, char **argv)

             break;

         default:

             qemuio_command_usage(&read_cmd);

-            return;

+            return -EINVAL;

         }

     }

     if (optind != argc - 2) {

         qemuio_command_usage(&read_cmd);

-        return;

+        return -EINVAL;

     }

     offset = cvtnum(argv[optind]);

     if (offset < 0) {

         print_cvtnum_err(offset, argv[optind]);

-        return;

+        return offset;

     }

     optind++;

     count = cvtnum(argv[optind]);

     if (count < 0) {

         print_cvtnum_err(count, argv[optind]);

-        return;

+        return count;

     } else if (count > BDRV_REQUEST_MAX_BYTES) {

         printf("length cannot exceed %" PRIu64 ", given %s\n",

                (uint64_t)BDRV_REQUEST_MAX_BYTES, argv[optind]);

-        return;

+        return -EINVAL;

     }

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

         qemuio_command_usage(&read_cmd);

-        return;

+        return -EINVAL;

     }

     if (!lflag) {

@@ -739,19 +739,19 @@ static void read_f(BlockBackend *blk, int argc, char **argv)

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

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

-        return;

+        return -EINVAL;

     }

     if (bflag) {

         if (!QEMU_IS_ALIGNED(offset, BDRV_SECTOR_SIZE)) {

             printf("%" PRId64 " is not a sector-aligned value for 'offset'\n",

                    offset);

-            return;

+            return -EINVAL;

         }

         if (!QEMU_IS_ALIGNED(count, BDRV_SECTOR_SIZE)) {

             printf("%"PRId64" is not a sector-aligned value for 'count'\n",

                    count);

-            return;

+            return -EINVAL;

         }

     }

@@ -759,16 +759,19 @@ static void read_f(BlockBackend *blk, int argc, char **argv)

     gettimeofday(&t1, NULL);

     if (bflag) {

-        cnt = do_load_vmstate(blk, buf, offset, count, &total);

+        ret = do_load_vmstate(blk, buf, offset, count, &total);

     } else {

-        cnt = do_pread(blk, buf, offset, count, &total);

+        ret = do_pread(blk, buf, offset, count, &total);

     }

     gettimeofday(&t2, NULL);

-    if (cnt < 0) {

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

+    if (ret < 0) {

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

         goto out;

     }

+    cnt = ret;

+

+    ret = 0;

     if (Pflag) {

         void *cmp_buf = g_malloc(pattern_count);

@@ -777,6 +780,7 @@ static void read_f(BlockBackend *blk, int argc, char **argv)

             printf("Pattern verification failed at offset %"

                    PRId64 ", %"PRId64" bytes\n",

                    offset + pattern_offset, pattern_count);

+            ret = -EINVAL;

         }

         g_free(cmp_buf);

     }

@@ -795,6 +799,7 @@ static void read_f(BlockBackend *blk, int argc, char **argv)

 out:

     qemu_io_free(buf);

+    return ret;

 }

 static void readv_help(void)

@@ -816,7 +821,7 @@ static void readv_help(void)

 "\n");

 }

-static void readv_f(BlockBackend *blk, int argc, char **argv);

+static int readv_f(BlockBackend *blk, int argc, char **argv);

 static const cmdinfo_t readv_cmd = {

     .name       = "readv",

@@ -828,11 +833,11 @@ static const cmdinfo_t readv_cmd = {

     .help       = readv_help,

 };

-static void readv_f(BlockBackend *blk, int argc, char **argv)

+static int readv_f(BlockBackend *blk, int argc, char **argv)

 {

     struct timeval t1, t2;

     bool Cflag = false, qflag = false, vflag = false;

-    int c, cnt;

+    int c, cnt, ret;

     char *buf;

     int64_t offset;

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

@@ -851,7 +856,7 @@ static void readv_f(BlockBackend *blk, int argc, char **argv)

             Pflag = true;

             pattern = parse_pattern(optarg);

             if (pattern < 0) {

-                return;

+                return -EINVAL;

             }

             break;

         case 'q':

@@ -862,37 +867,40 @@ static void readv_f(BlockBackend *blk, int argc, char **argv)

             break;

         default:

             qemuio_command_usage(&readv_cmd);

-            return;

+            return -EINVAL;

         }

     }

     if (optind > argc - 2) {

         qemuio_command_usage(&readv_cmd);

-        return;

+        return -EINVAL;

     }

     offset = cvtnum(argv[optind]);

     if (offset < 0) {

         print_cvtnum_err(offset, argv[optind]);

-        return;

+        return offset;

     }

     optind++;

     nr_iov = argc - optind;

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

     if (buf == NULL) {

-        return;

+        return -EINVAL;

     }

     gettimeofday(&t1, NULL);

-    cnt = do_aio_readv(blk, &qiov, offset, &total);

+    ret = do_aio_readv(blk, &qiov, offset, &total);

     gettimeofday(&t2, NULL);

-    if (cnt < 0) {

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

+    if (ret < 0) {

+        printf("readv failed: %s\n", strerror(-ret));

         goto out;

     }

+    cnt = ret;

+

+    ret = 0;

     if (Pflag) {

         void *cmp_buf = g_malloc(qiov.size);

@@ -900,6 +908,7 @@ static void readv_f(BlockBackend *blk, int argc, char **argv)

         if (memcmp(buf, cmp_buf, qiov.size)) {

             printf("Pattern verification failed at offset %"

                    PRId64 ", %zd bytes\n", offset, qiov.size);

+            ret = -EINVAL;

         }

         g_free(cmp_buf);

     }

@@ -919,6 +928,7 @@ static void readv_f(BlockBackend *blk, int argc, char **argv)

 out:

     qemu_iovec_destroy(&qiov);

     qemu_io_free(buf);

+    return ret;

 }

 static void write_help(void)

@@ -944,7 +954,7 @@ static void write_help(void)

 "\n");

 }

-static void write_f(BlockBackend *blk, int argc, char **argv);

+static int write_f(BlockBackend *blk, int argc, char **argv);

 static const cmdinfo_t write_cmd = {

     .name       = "write",

@@ -958,13 +968,13 @@ static const cmdinfo_t write_cmd = {

     .help       = write_help,

 };

-static void write_f(BlockBackend *blk, int argc, char **argv)

+static int write_f(BlockBackend *blk, int argc, char **argv)

 {

     struct timeval t1, t2;

     bool Cflag = false, qflag = false, bflag = false;

     bool Pflag = false, zflag = false, cflag = false;

     int flags = 0;

-    int c, cnt;

+    int c, cnt, ret;

     char *buf = NULL;

     int64_t offset;

     int64_t count;

@@ -993,7 +1003,7 @@ static void write_f(BlockBackend *blk, int argc, char **argv)

             Pflag = true;

             pattern = parse_pattern(optarg);

             if (pattern < 0) {

-                return;

+                return -EINVAL;

             }

             break;

         case 'q':

@@ -1007,63 +1017,63 @@ static void write_f(BlockBackend *blk, int argc, char **argv)

             break;

         default:

             qemuio_command_usage(&write_cmd);

-            return;

+            return -EINVAL;

         }

     }

     if (optind != argc - 2) {

         qemuio_command_usage(&write_cmd);

-        return;

+        return -EINVAL;

     }

     if (bflag && zflag) {

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

-        return;

+        return -EINVAL;

     }

     if ((flags & BDRV_REQ_FUA) && (bflag || cflag)) {

         printf("-f and -b or -c cannot be specified at the same time\n");

-        return;

+        return -EINVAL;

     }

     if ((flags & BDRV_REQ_MAY_UNMAP) && !zflag) {

         printf("-u requires -z to be specified\n");

-        return;

+        return -EINVAL;

     }

     if (zflag && Pflag) {

         printf("-z and -P cannot be specified at the same time\n");

-        return;

+        return -EINVAL;

     }

     offset = cvtnum(argv[optind]);

     if (offset < 0) {

         print_cvtnum_err(offset, argv[optind]);

-        return;

+        return offset;

     }

     optind++;

     count = cvtnum(argv[optind]);

     if (count < 0) {

         print_cvtnum_err(count, argv[optind]);

-        return;

+        return count;

     } else if (count > BDRV_REQUEST_MAX_BYTES) {

         printf("length cannot exceed %" PRIu64 ", given %s\n",

                (uint64_t)BDRV_REQUEST_MAX_BYTES, argv[optind]);

-        return;

+        return -EINVAL;

     }

     if (bflag || cflag) {

         if (!QEMU_IS_ALIGNED(offset, BDRV_SECTOR_SIZE)) {

             printf("%" PRId64 " is not a sector-aligned value for 'offset'\n",

                    offset);

-            return;

+            return -EINVAL;

         }

         if (!QEMU_IS_ALIGNED(count, BDRV_SECTOR_SIZE)) {

             printf("%"PRId64" is not a sector-aligned value for 'count'\n",

                    count);

-            return;

+            return -EINVAL;

         }

     }

@@ -1073,20 +1083,23 @@ static void write_f(BlockBackend *blk, int argc, char **argv)

     gettimeofday(&t1, NULL);

     if (bflag) {

-        cnt = do_save_vmstate(blk, buf, offset, count, &total);

+        ret = do_save_vmstate(blk, buf, offset, count, &total);

     } else if (zflag) {

-        cnt = do_co_pwrite_zeroes(blk, offset, count, flags, &total);

+        ret = do_co_pwrite_zeroes(blk, offset, count, flags, &total);

     } else if (cflag) {

-        cnt = do_write_compressed(blk, buf, offset, count, &total);

+        ret = do_write_compressed(blk, buf, offset, count, &total);

     } else {

-        cnt = do_pwrite(blk, buf, offset, count, flags, &total);

+        ret = do_pwrite(blk, buf, offset, count, flags, &total);

     }

     gettimeofday(&t2, NULL);

-    if (cnt < 0) {

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

+    if (ret < 0) {

+        printf("write failed: %s\n", strerror(-ret));

         goto out;

     }

+    cnt = ret;

+

+    ret = 0;

     if (qflag) {

         goto out;

@@ -1100,6 +1113,7 @@ out:

     if (!zflag) {

         qemu_io_free(buf);

     }

+    return ret;

 }

 static void

@@ -1121,7 +1135,7 @@ writev_help(void)

 "\n");

 }

-static void writev_f(BlockBackend *blk, int argc, char **argv);

+static int writev_f(BlockBackend *blk, int argc, char **argv);

 static const cmdinfo_t writev_cmd = {

     .name       = "writev",

@@ -1134,12 +1148,12 @@ static const cmdinfo_t writev_cmd = {

     .help       = writev_help,

 };

-static void writev_f(BlockBackend *blk, int argc, char **argv)

+static int writev_f(BlockBackend *blk, int argc, char **argv)

 {

     struct timeval t1, t2;

     bool Cflag = false, qflag = false;

     int flags = 0;

-    int c, cnt;

+    int c, cnt, ret;

     char *buf;

     int64_t offset;

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

@@ -1162,41 +1176,44 @@ static void writev_f(BlockBackend *blk, int argc, char **argv)

         case 'P':

             pattern = parse_pattern(optarg);

             if (pattern < 0) {

-                return;

+                return -EINVAL;

             }

             break;

         default:

             qemuio_command_usage(&writev_cmd);

-            return;

+            return -EINVAL;

         }

     }

     if (optind > argc - 2) {

         qemuio_command_usage(&writev_cmd);

-        return;

+        return -EINVAL;

     }

     offset = cvtnum(argv[optind]);

     if (offset < 0) {

         print_cvtnum_err(offset, argv[optind]);

-        return;

+        return offset;

     }

     optind++;

     nr_iov = argc - optind;

     buf = create_iovec(blk, &qiov, &argv[optind], nr_iov, pattern);

     if (buf == NULL) {

-        return;

+        return -EINVAL;

     }

     gettimeofday(&t1, NULL);

-    cnt = do_aio_writev(blk, &qiov, offset, flags, &total);

+    ret = do_aio_writev(blk, &qiov, offset, flags, &total);

     gettimeofday(&t2, NULL);

-    if (cnt < 0) {

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

+    if (ret < 0) {

+        printf("writev failed: %s\n", strerror(-ret));

         goto out;

     }

+    cnt = ret;

+

+    ret = 0;

     if (qflag) {

         goto out;

@@ -1208,6 +1225,7 @@ static void writev_f(BlockBackend *blk, int argc, char **argv)

 out:

     qemu_iovec_destroy(&qiov);

     qemu_io_free(buf);

+    return ret;

 }

 struct aio_ctx {

@@ -1314,6 +1332,9 @@ static void aio_read_help(void)

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

 " The read is performed asynchronously and the aio_flush command must be\n"

 " used to ensure all outstanding aio requests have been completed.\n"

+" Note that due to its asynchronous nature, this command will be\n"

+" considered successful once the request is submitted, independently\n"

+" of potential I/O errors or pattern mismatches.\n"

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

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

 " -i, -- treat request as invalid, for exercising stats\n"

@@ -1322,7 +1343,7 @@ static void aio_read_help(void)

 "\n");

 }

-static void aio_read_f(BlockBackend *blk, int argc, char **argv);

+static int aio_read_f(BlockBackend *blk, int argc, char **argv);

 static const cmdinfo_t aio_read_cmd = {

     .name       = "aio_read",

@@ -1334,7 +1355,7 @@ static const cmdinfo_t aio_read_cmd = {

     .help       = aio_read_help,

 };

-static void aio_read_f(BlockBackend *blk, int argc, char **argv)

+static int aio_read_f(BlockBackend *blk, int argc, char **argv)

 {

     int nr_iov, c;

     struct aio_ctx *ctx = g_new0(struct aio_ctx, 1);

@@ -1350,14 +1371,14 @@ static void aio_read_f(BlockBackend *blk, int argc, char **argv)

             ctx->pattern = parse_pattern(optarg);

             if (ctx->pattern < 0) {

                 g_free(ctx);

-                return;

+                return -EINVAL;

             }

             break;

         case 'i':

             printf("injecting invalid read request\n");

             block_acct_invalid(blk_get_stats(blk), BLOCK_ACCT_READ);

             g_free(ctx);

-            return;

+            return 0;

         case 'q':

             ctx->qflag = true;

             break;

@@ -1367,21 +1388,22 @@ static void aio_read_f(BlockBackend *blk, int argc, char **argv)

         default:

             g_free(ctx);

             qemuio_command_usage(&aio_read_cmd);

-            return;

+            return -EINVAL;

         }

     }

     if (optind > argc - 2) {

         g_free(ctx);

         qemuio_command_usage(&aio_read_cmd);

-        return;

+        return -EINVAL;

     }

     ctx->offset = cvtnum(argv[optind]);

     if (ctx->offset < 0) {

-        print_cvtnum_err(ctx->offset, argv[optind]);

+        int ret = ctx->offset;

+        print_cvtnum_err(ret, argv[optind]);

         g_free(ctx);

-        return;

+        return ret;

     }

     optind++;

@@ -1390,13 +1412,14 @@ static void aio_read_f(BlockBackend *blk, int argc, char **argv)

     if (ctx->buf == NULL) {

         block_acct_invalid(blk_get_stats(blk), BLOCK_ACCT_READ);

         g_free(ctx);

-        return;

+        return -EINVAL;

     }

     gettimeofday(&ctx->t1, NULL);

     block_acct_start(blk_get_stats(blk), &ctx->acct, ctx->qiov.size,

                      BLOCK_ACCT_READ);

     blk_aio_preadv(blk, ctx->offset, &ctx->qiov, 0, aio_read_done, ctx);

+    return 0;

 }

 static void aio_write_help(void)

@@ -1413,6 +1436,9 @@ static void aio_write_help(void)

 " filled with a set pattern (0xcdcdcdcd).\n"

 " The write is performed asynchronously and the aio_flush command must be\n"

 " used to ensure all outstanding aio requests have been completed.\n"

+" Note that due to its asynchronous nature, this command will be\n"

+" considered successful once the request is submitted, independently\n"

+" of potential I/O errors or pattern mismatches.\n"

 " -P, -- use different pattern to fill file\n"

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

 " -f, -- use Force Unit Access semantics\n"

@@ -1423,7 +1449,7 @@ static void aio_write_help(void)

 "\n");

 }

-static void aio_write_f(BlockBackend *blk, int argc, char **argv);

+static int aio_write_f(BlockBackend *blk, int argc, char **argv);

 static const cmdinfo_t aio_write_cmd = {

     .name       = "aio_write",

@@ -1436,7 +1462,7 @@ static const cmdinfo_t aio_write_cmd = {

     .help       = aio_write_help,

 };

-static void aio_write_f(BlockBackend *blk, int argc, char **argv)

+static int aio_write_f(BlockBackend *blk, int argc, char **argv)

 {

     int nr_iov, c;

     int pattern = 0xcd;

@@ -1462,53 +1488,54 @@ static void aio_write_f(BlockBackend *blk, int argc, char **argv)

             pattern = parse_pattern(optarg);

             if (pattern < 0) {

                 g_free(ctx);

-                return;

+                return -EINVAL;

             }

             break;

         case 'i':

             printf("injecting invalid write request\n");

             block_acct_invalid(blk_get_stats(blk), BLOCK_ACCT_WRITE);

             g_free(ctx);

-            return;

+            return 0;

         case 'z':

             ctx->zflag = true;

             break;