From fed57d13b5e402e6d385189acb78aa5f84343fe4 Mon Sep 17 00:00:00 2001

From: Max Reitz <mreitz@redhat.com>

Date: Mon, 25 Jun 2018 13:09:51 +0200

Subject: [PATCH 049/268] qemu-io: Drop command functions' return values

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

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

Patchwork-id: 80778

O-Subject: [RHV-7.6 qemu-kvm-rhev PATCH 1/5] qemu-io: Drop command functions' return values

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>

For qemu-io, a function returns an integer with two possible values: 0

for "qemu-io may continue execution", or 1 for "qemu-io should exit".

However, there is only a single command that returns 1, and that is

"quit".

So let's turn this case into a global variable instead so we can make

better use of the return value in a later patch.

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

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

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

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

(cherry picked from commit b444d0e9d1ae323fed1ef7c35a359ce064f36b32)

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

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

---

 include/qemu-io.h |   6 +-

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

 qemu-io.c         |  36 +++----

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

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

index 196fde0..06cdfbf 100644

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

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

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

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

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

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

 typedef void (*helpfunc_t)(void);

 typedef struct cmdinfo {

@@ -41,10 +41,10 @@ typedef struct cmdinfo {

 extern bool qemuio_misalign;

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

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

 void qemuio_add_command(const cmdinfo_t *ci);

-int qemuio_command_usage(const cmdinfo_t *ci);

+void qemuio_command_usage(const cmdinfo_t *ci);

 void qemuio_complete_command(const char *input,

                              void (*fn)(const char *cmd, void *opaque),

                              void *opaque);

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

index 9b3cd00..c2fbaae 100644

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

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

@@ -48,10 +48,9 @@ void qemuio_add_command(const cmdinfo_t *ci)

     qsort(cmdtab, ncmds, sizeof(*cmdtab), compare_cmdname);

 }

-int qemuio_command_usage(const cmdinfo_t *ci)

+void qemuio_command_usage(const cmdinfo_t *ci)

 {

     printf("%s %s -- %s\n", ci->name, ci->args, ci->oneline);

-    return 0;

 }

 static int init_check_command(BlockBackend *blk, const cmdinfo_t *ct)

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

     return 1;

 }

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

-                   char **argv)

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

+                    char **argv)

 {

     char *cmd = argv[0];

     if (!init_check_command(blk, ct)) {

-        return 0;

+        return;

     }

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

@@ -89,7 +88,7 @@ static int 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 0;

+        return;

     }

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

@@ -109,13 +108,13 @@ static int 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 0;

+                return;

             }

         }

     }

     optind = 0;

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

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

 }

 static const cmdinfo_t *find_command(const char *cmd)

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

 "\n");

 }

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

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

 static const cmdinfo_t read_cmd = {

     .name       = "read",

@@ -647,7 +646,7 @@ static const cmdinfo_t read_cmd = {

     .help       = read_help,

 };

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

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

 {

     struct timeval t1, t2;

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

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

             pattern_count = cvtnum(optarg);

             if (pattern_count < 0) {

                 print_cvtnum_err(pattern_count, optarg);

-                return 0;

+                return;

             }

             break;

         case 'p':

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

             Pflag = true;

             pattern = parse_pattern(optarg);

             if (pattern < 0) {

-                return 0;

+                return;

             }

             break;

         case 'q':

@@ -695,40 +694,43 @@ static int read_f(BlockBackend *blk, int argc, char **argv)

             pattern_offset = cvtnum(optarg);

             if (pattern_offset < 0) {

                 print_cvtnum_err(pattern_offset, optarg);

-                return 0;

+                return;

             }

             break;

         case 'v':

             vflag = true;

             break;

         default:

-            return qemuio_command_usage(&read_cmd);

+            qemuio_command_usage(&read_cmd);

+            return;

         }

     }

     if (optind != argc - 2) {

-        return qemuio_command_usage(&read_cmd);

+        qemuio_command_usage(&read_cmd);

+        return;

     }

     offset = cvtnum(argv[optind]);

     if (offset < 0) {

         print_cvtnum_err(offset, argv[optind]);

-        return 0;

+        return;

     }

     optind++;

     count = cvtnum(argv[optind]);

     if (count < 0) {

         print_cvtnum_err(count, argv[optind]);

-        return 0;

+        return;

     } else if (count > BDRV_REQUEST_MAX_BYTES) {

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

                (uint64_t)BDRV_REQUEST_MAX_BYTES, argv[optind]);

-        return 0;

+        return;

     }

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

-        return qemuio_command_usage(&read_cmd);

+        qemuio_command_usage(&read_cmd);

+        return;

     }

     if (!lflag) {

@@ -737,19 +739,19 @@ static int 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 0;

+        return;

     }

     if (bflag) {

         if (!QEMU_IS_ALIGNED(offset, BDRV_SECTOR_SIZE)) {

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

                    offset);

-            return 0;

+            return;

         }

         if (!QEMU_IS_ALIGNED(count, BDRV_SECTOR_SIZE)) {

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

                    count);

-            return 0;

+            return;

         }

     }

@@ -793,8 +795,6 @@ static int read_f(BlockBackend *blk, int argc, char **argv)

 out:

     qemu_io_free(buf);

-

-    return 0;

 }

 static void readv_help(void)

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

 "\n");

 }

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

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

 static const cmdinfo_t readv_cmd = {

     .name       = "readv",

@@ -828,7 +828,7 @@ static const cmdinfo_t readv_cmd = {

     .help       = readv_help,

 };

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

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

 {

     struct timeval t1, t2;

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

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

             Pflag = true;

             pattern = parse_pattern(optarg);

             if (pattern < 0) {

-                return 0;

+                return;

             }

             break;

         case 'q':

@@ -861,26 +861,28 @@ static int readv_f(BlockBackend *blk, int argc, char **argv)

             vflag = true;

             break;

         default:

-            return qemuio_command_usage(&readv_cmd);

+            qemuio_command_usage(&readv_cmd);

+            return;

         }

     }

     if (optind > argc - 2) {

-        return qemuio_command_usage(&readv_cmd);

+        qemuio_command_usage(&readv_cmd);

+        return;

     }

     offset = cvtnum(argv[optind]);

     if (offset < 0) {

         print_cvtnum_err(offset, argv[optind]);

-        return 0;

+        return;

     }

     optind++;

     nr_iov = argc - optind;

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

     if (buf == NULL) {

-        return 0;

+        return;

     }

     gettimeofday(&t1, NULL);

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

 out:

     qemu_iovec_destroy(&qiov);

     qemu_io_free(buf);

-    return 0;

 }

 static void write_help(void)

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

 "\n");

 }

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

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

 static const cmdinfo_t write_cmd = {

     .name       = "write",

@@ -957,7 +958,7 @@ static const cmdinfo_t write_cmd = {

     .help       = write_help,

 };

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

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

 {

     struct timeval t1, t2;

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

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

             Pflag = true;

             pattern = parse_pattern(optarg);

             if (pattern < 0) {

-                return 0;

+                return;

             }

             break;

         case 'q':

@@ -1005,62 +1006,64 @@ static int write_f(BlockBackend *blk, int argc, char **argv)

             zflag = true;

             break;

         default:

-            return qemuio_command_usage(&write_cmd);

+            qemuio_command_usage(&write_cmd);

+            return;

         }

     }

     if (optind != argc - 2) {

-        return qemuio_command_usage(&write_cmd);

+        qemuio_command_usage(&write_cmd);

+        return;

     }

     if (bflag && zflag) {

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

-        return 0;

+        return;

     }

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

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

-        return 0;

+        return;

     }

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

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

-        return 0;

+        return;

     }

     if (zflag && Pflag) {

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

-        return 0;

+        return;

     }

     offset = cvtnum(argv[optind]);

     if (offset < 0) {

         print_cvtnum_err(offset, argv[optind]);

-        return 0;

+        return;

     }

     optind++;

     count = cvtnum(argv[optind]);

     if (count < 0) {

         print_cvtnum_err(count, argv[optind]);

-        return 0;

+        return;

     } else if (count > BDRV_REQUEST_MAX_BYTES) {

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

                (uint64_t)BDRV_REQUEST_MAX_BYTES, argv[optind]);

-        return 0;

+        return;

     }

     if (bflag || cflag) {

         if (!QEMU_IS_ALIGNED(offset, BDRV_SECTOR_SIZE)) {

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

                    offset);

-            return 0;

+            return;

         }

         if (!QEMU_IS_ALIGNED(count, BDRV_SECTOR_SIZE)) {

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

                    count);

-            return 0;

+            return;

         }

     }

@@ -1097,8 +1100,6 @@ out:

     if (!zflag) {

         qemu_io_free(buf);

     }

-

-    return 0;

 }

 static void

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

 "\n");

 }

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

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

 static const cmdinfo_t writev_cmd = {

     .name       = "writev",

@@ -1133,7 +1134,7 @@ static const cmdinfo_t writev_cmd = {

     .help       = writev_help,

 };

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

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

 {

     struct timeval t1, t2;

     bool Cflag = false, qflag = false;

@@ -1161,29 +1162,31 @@ static int writev_f(BlockBackend *blk, int argc, char **argv)

         case 'P':

             pattern = parse_pattern(optarg);

             if (pattern < 0) {

-                return 0;

+                return;

             }

             break;

         default:

-            return qemuio_command_usage(&writev_cmd);

+            qemuio_command_usage(&writev_cmd);

+            return;

         }

     }

     if (optind > argc - 2) {

-        return qemuio_command_usage(&writev_cmd);

+        qemuio_command_usage(&writev_cmd);

+        return;

     }

     offset = cvtnum(argv[optind]);

     if (offset < 0) {

         print_cvtnum_err(offset, argv[optind]);

-        return 0;

+        return;

     }

     optind++;

     nr_iov = argc - optind;

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

     if (buf == NULL) {

-        return 0;

+        return;

     }

     gettimeofday(&t1, NULL);

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

 out:

     qemu_iovec_destroy(&qiov);

     qemu_io_free(buf);

-    return 0;

 }

 struct aio_ctx {

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

 "\n");

 }

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

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

 static const cmdinfo_t aio_read_cmd = {

     .name       = "aio_read",

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

     .help       = aio_read_help,

 };

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

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

 {

     int nr_iov, c;

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

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

             ctx->pattern = parse_pattern(optarg);

             if (ctx->pattern < 0) {

                 g_free(ctx);

-                return 0;

+                return;

             }

             break;

         case 'i':

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

             block_acct_invalid(blk_get_stats(blk), BLOCK_ACCT_READ);

             g_free(ctx);

-            return 0;

+            return;

         case 'q':

             ctx->qflag = true;

             break;

@@ -1364,20 +1366,22 @@ static int aio_read_f(BlockBackend *blk, int argc, char **argv)

             break;

         default:

             g_free(ctx);

-            return qemuio_command_usage(&aio_read_cmd);

+            qemuio_command_usage(&aio_read_cmd);

+            return;

         }

     }

     if (optind > argc - 2) {

         g_free(ctx);

-        return qemuio_command_usage(&aio_read_cmd);

+        qemuio_command_usage(&aio_read_cmd);

+        return;

     }

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

     if (ctx->offset < 0) {

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

         g_free(ctx);

-        return 0;

+        return;

     }

     optind++;

@@ -1386,14 +1390,13 @@ static int 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 0;

+        return;

     }

     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)

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

 "\n");

 }

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

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

 static const cmdinfo_t aio_write_cmd = {

     .name       = "aio_write",

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

     .help       = aio_write_help,

 };

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

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

 {

     int nr_iov, c;

     int pattern = 0xcd;

@@ -1459,51 +1462,53 @@ static int aio_write_f(BlockBackend *blk, int argc, char **argv)

             pattern = parse_pattern(optarg);

             if (pattern < 0) {

                 g_free(ctx);

-                return 0;

+                return;

             }

             break;

         case 'i':

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

             block_acct_invalid(blk_get_stats(blk), BLOCK_ACCT_WRITE);

             g_free(ctx);

-            return 0;

+            return;

         case 'z':

             ctx->zflag = true;

             break;

         default:

             g_free(ctx);

-            return qemuio_command_usage(&aio_write_cmd);

+            qemuio_command_usage(&aio_write_cmd);

+            return;

         }

     }

     if (optind > argc - 2) {

         g_free(ctx);

-        return qemuio_command_usage(&aio_write_cmd);

+        qemuio_command_usage(&aio_write_cmd);

+        return;

     }

     if (ctx->zflag && optind != argc - 2) {

         printf("-z supports only a single length parameter\n");

         g_free(ctx);

-        return 0;

+        return;

     }

     if ((flags & BDRV_REQ_MAY_UNMAP) && !ctx->zflag) {

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

         g_free(ctx);

-        return 0;

+        return;

     }

     if (ctx->zflag && ctx->Pflag) {

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

         g_free(ctx);

-        return 0;

+        return;

     }

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

     if (ctx->offset < 0) {

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

         g_free(ctx);

-        return 0;

+        return;

     }

     optind++;

@@ -1512,7 +1517,7 @@ static int aio_write_f(BlockBackend *blk, int argc, char **argv)

         if (count < 0) {

             print_cvtnum_err(count, argv[optind]);

             g_free(ctx);

-            return 0;

+            return;

         }

         ctx->qiov.size = count;

@@ -1525,7 +1530,7 @@ static int aio_write_f(BlockBackend *blk, int argc, char **argv)

         if (ctx->buf == NULL) {

             block_acct_invalid(blk_get_stats(blk), BLOCK_ACCT_WRITE);

             g_free(ctx);

-            return 0;

+            return;

         }

         gettimeofday(&ctx->t1, NULL);

@@ -1535,16 +1540,14 @@ static int aio_write_f(BlockBackend *blk, int argc, char **argv)

         blk_aio_pwritev(blk, ctx->offset, &ctx->qiov, flags, aio_write_done,

                         ctx);

     }

-    return 0;

 }

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

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

 {

     BlockAcctCookie cookie;

     block_acct_start(blk_get_stats(blk), &cookie, 0, BLOCK_ACCT_FLUSH);

     blk_drain_all();

     block_acct_done(blk_get_stats(blk), &cookie);

-    return 0;

 }

 static const cmdinfo_t aio_flush_cmd = {

@@ -1553,10 +1556,9 @@ static const cmdinfo_t aio_flush_cmd = {

     .oneline    = "completes all outstanding aio requests"

 };

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

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

 {

     blk_flush(blk);

-    return 0;

 }

 static const cmdinfo_t flush_cmd = {

@@ -1566,7 +1568,7 @@ static const cmdinfo_t flush_cmd = {

     .oneline    = "flush all in-core file state to disk",

 };

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

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

 {

     Error *local_err = NULL;

     int64_t offset;

@@ -1575,16 +1577,14 @@ static int truncate_f(BlockBackend *blk, int argc, char **argv)

     offset = cvtnum(argv[1]);

     if (offset < 0) {

         print_cvtnum_err(offset, argv[1]);

-        return 0;

+        return;

     }

     ret = blk_truncate(blk, offset, PREALLOC_MODE_OFF, &local_err);

     if (ret < 0) {

         error_report_err(local_err);

-        return 0;

+        return;

     }

-

-    return 0;

 }

 static const cmdinfo_t truncate_cmd = {

@@ -1598,7 +1598,7 @@ static const cmdinfo_t truncate_cmd = {

     .oneline    = "truncates the current file at the given offset",

 };

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