[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]

[libvirt] [PATCH v3 4/5] virsh: Pass vshControl to all vshCommandOpt*() calls.



This will allow us to use vshError() to report errors from inside
vshCommandOpt*(), instead of replicating the same logic and error
messages all over the place.

We also have more context inside the vshCommandOpt*() functions,
for example the actual value used on the command line, which means
we can produce more detailed error messages.

vshCommandOptBool() is the exception here, because it's explicitly
designed not to report any error.
---
 tools/virsh-domain-monitor.c |  10 ++--
 tools/virsh-domain.c         | 128 +++++++++++++++++++++----------------------
 tools/virsh-host.c           |  24 ++++----
 tools/virsh-interface.c      |   2 +-
 tools/virsh-network.c        |   6 +-
 tools/virsh-nodedev.c        |   4 +-
 tools/virsh-snapshot.c       |   2 +-
 tools/virsh-volume.c         |  10 ++--
 tools/virsh.c                |  97 ++++++++++++++++++--------------
 tools/virsh.h                |  66 +++++++++++-----------
 10 files changed, 183 insertions(+), 166 deletions(-)

diff --git a/tools/virsh-domain-monitor.c b/tools/virsh-domain-monitor.c
index a42c150..d8b217b 100644
--- a/tools/virsh-domain-monitor.c
+++ b/tools/virsh-domain-monitor.c
@@ -340,7 +340,7 @@ cmdDomMemStat(vshControl *ctl, const vshCmd *cmd)
     /* Providing a period will adjust the balloon driver collection period.
      * This is not really an unsigned long, but it
      */
-    if ((rv = vshCommandOptInt(cmd, "period", &period)) < 0) {
+    if ((rv = vshCommandOptInt(ctl, cmd, "period", &period)) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "period");
@@ -1436,7 +1436,7 @@ cmdDomTime(vshControl *ctl, const vshCmd *cmd)
     if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
         return false;
 
-    rv = vshCommandOptLongLong(cmd, "time", &seconds);
+    rv = vshCommandOptLongLong(ctl, cmd, "time", &seconds);
 
     if (rv < 0) {
         /* invalid integer format */
@@ -2165,7 +2165,7 @@ cmdDomstats(vshControl *ctl, const vshCmd *cmd)
             goto cleanup;
         ndoms = 1;
 
-        while ((opt = vshCommandOptArgv(cmd, opt))) {
+        while ((opt = vshCommandOptArgv(ctl, cmd, opt))) {
             if (!(dom = vshLookupDomainBy(ctl, opt->data,
                                           VSH_BYID | VSH_BYUUID | VSH_BYNAME)))
                 goto cleanup;
@@ -2244,9 +2244,9 @@ cmdDomIfAddr(vshControl *ctl, const vshCmd *cmd)
     if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
         return false;
 
-    if (vshCommandOptString(cmd, "interface", &ifacestr) < 0)
+    if (vshCommandOptString(ctl, cmd, "interface", &ifacestr) < 0)
         goto cleanup;
-    if (vshCommandOptString(cmd, "source", &sourcestr) < 0)
+    if (vshCommandOptString(ctl, cmd, "source", &sourcestr) < 0)
         goto cleanup;
 
     if (sourcestr) {
diff --git a/tools/virsh-domain.c b/tools/virsh-domain.c
index 91a1ca2..233191a 100644
--- a/tools/virsh-domain.c
+++ b/tools/virsh-domain.c
@@ -1292,7 +1292,7 @@ cmdBlkdeviotune(vshControl *ctl, const vshCmd *cmd)
     if (vshCommandOptStringReq(ctl, cmd, "device", &disk) < 0)
         goto cleanup;
 
-    if ((rv = vshCommandOptULongLong(cmd, "total-bytes-sec", &value)) < 0) {
+    if ((rv = vshCommandOptULongLong(ctl, cmd, "total-bytes-sec", &value)) < 0) {
         goto interror;
     } else if (rv > 0) {
         if (virTypedParamsAddULLong(&params, &nparams, &maxparams,
@@ -1301,7 +1301,7 @@ cmdBlkdeviotune(vshControl *ctl, const vshCmd *cmd)
             goto save_error;
     }
 
-    if ((rv = vshCommandOptULongLong(cmd, "read-bytes-sec", &value)) < 0) {
+    if ((rv = vshCommandOptULongLong(ctl, cmd, "read-bytes-sec", &value)) < 0) {
         goto interror;
     } else if (rv > 0) {
         if (virTypedParamsAddULLong(&params, &nparams, &maxparams,
@@ -1310,7 +1310,7 @@ cmdBlkdeviotune(vshControl *ctl, const vshCmd *cmd)
             goto save_error;
     }
 
-    if ((rv = vshCommandOptULongLong(cmd, "write-bytes-sec", &value)) < 0) {
+    if ((rv = vshCommandOptULongLong(ctl, cmd, "write-bytes-sec", &value)) < 0) {
         goto interror;
     } else if (rv > 0) {
         if (virTypedParamsAddULLong(&params, &nparams, &maxparams,
@@ -1319,7 +1319,7 @@ cmdBlkdeviotune(vshControl *ctl, const vshCmd *cmd)
             goto save_error;
     }
 
-    if ((rv = vshCommandOptULongLong(cmd, "total-bytes-sec-max", &value)) < 0) {
+    if ((rv = vshCommandOptULongLong(ctl, cmd, "total-bytes-sec-max", &value)) < 0) {
         goto interror;
     } else if (rv > 0) {
         if (virTypedParamsAddULLong(&params, &nparams, &maxparams,
@@ -1328,7 +1328,7 @@ cmdBlkdeviotune(vshControl *ctl, const vshCmd *cmd)
             goto save_error;
     }
 
-    if ((rv = vshCommandOptULongLong(cmd, "read-bytes-sec-max", &value)) < 0) {
+    if ((rv = vshCommandOptULongLong(ctl, cmd, "read-bytes-sec-max", &value)) < 0) {
         goto interror;
     } else if (rv > 0) {
         if (virTypedParamsAddULLong(&params, &nparams, &maxparams,
@@ -1337,7 +1337,7 @@ cmdBlkdeviotune(vshControl *ctl, const vshCmd *cmd)
             goto save_error;
     }
 
-    if ((rv = vshCommandOptULongLong(cmd, "write-bytes-sec-max", &value)) < 0) {
+    if ((rv = vshCommandOptULongLong(ctl, cmd, "write-bytes-sec-max", &value)) < 0) {
         goto interror;
     } else if (rv > 0) {
         if (virTypedParamsAddULLong(&params, &nparams, &maxparams,
@@ -1346,7 +1346,7 @@ cmdBlkdeviotune(vshControl *ctl, const vshCmd *cmd)
             goto save_error;
     }
 
-    if ((rv = vshCommandOptULongLong(cmd, "total-iops-sec", &value)) < 0) {
+    if ((rv = vshCommandOptULongLong(ctl, cmd, "total-iops-sec", &value)) < 0) {
         goto interror;
     } else if (rv > 0) {
         if (virTypedParamsAddULLong(&params, &nparams, &maxparams,
@@ -1355,7 +1355,7 @@ cmdBlkdeviotune(vshControl *ctl, const vshCmd *cmd)
             goto save_error;
     }
 
-    if ((rv = vshCommandOptULongLong(cmd, "read-iops-sec", &value)) < 0) {
+    if ((rv = vshCommandOptULongLong(ctl, cmd, "read-iops-sec", &value)) < 0) {
         goto interror;
     } else if (rv > 0) {
         if (virTypedParamsAddULLong(&params, &nparams, &maxparams,
@@ -1364,7 +1364,7 @@ cmdBlkdeviotune(vshControl *ctl, const vshCmd *cmd)
             goto save_error;
     }
 
-    if ((rv = vshCommandOptULongLong(cmd, "write-iops-sec", &value)) < 0) {
+    if ((rv = vshCommandOptULongLong(ctl, cmd, "write-iops-sec", &value)) < 0) {
         goto interror;
     } else if (rv > 0) {
         if (virTypedParamsAddULLong(&params, &nparams, &maxparams,
@@ -1373,7 +1373,7 @@ cmdBlkdeviotune(vshControl *ctl, const vshCmd *cmd)
             goto save_error;
     }
 
-    if ((rv = vshCommandOptULongLong(cmd, "write-iops-sec-max", &value)) < 0) {
+    if ((rv = vshCommandOptULongLong(ctl, cmd, "write-iops-sec-max", &value)) < 0) {
         goto interror;
     } else if (rv > 0) {
         if (virTypedParamsAddULLong(&params, &nparams, &maxparams,
@@ -1382,7 +1382,7 @@ cmdBlkdeviotune(vshControl *ctl, const vshCmd *cmd)
             goto save_error;
     }
 
-    if ((rv = vshCommandOptULongLong(cmd, "read-iops-sec-max", &value)) < 0) {
+    if ((rv = vshCommandOptULongLong(ctl, cmd, "read-iops-sec-max", &value)) < 0) {
         goto interror;
     } else if (rv > 0) {
         if (virTypedParamsAddULLong(&params, &nparams, &maxparams,
@@ -1391,7 +1391,7 @@ cmdBlkdeviotune(vshControl *ctl, const vshCmd *cmd)
             goto save_error;
     }
 
-    if ((rv = vshCommandOptULongLong(cmd, "total-iops-sec-max", &value)) < 0) {
+    if ((rv = vshCommandOptULongLong(ctl, cmd, "total-iops-sec-max", &value)) < 0) {
         goto interror;
     } else if (rv > 0) {
         if (virTypedParamsAddULLong(&params, &nparams, &maxparams,
@@ -1400,7 +1400,7 @@ cmdBlkdeviotune(vshControl *ctl, const vshCmd *cmd)
             goto save_error;
     }
 
-    if ((rv = vshCommandOptULongLong(cmd, "size-iops-sec", &value)) < 0) {
+    if ((rv = vshCommandOptULongLong(ctl, cmd, "size-iops-sec", &value)) < 0) {
         goto interror;
     } else if (rv > 0) {
         if (virTypedParamsAddULLong(&params, &nparams, &maxparams,
@@ -1551,7 +1551,7 @@ cmdBlkiotune(vshControl * ctl, const vshCmd * cmd)
     if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
         return false;
 
-    if ((rv = vshCommandOptInt(cmd, "weight", &weight)) < 0) {
+    if ((rv = vshCommandOptInt(ctl, cmd, "weight", &weight)) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "weight");
@@ -1566,7 +1566,7 @@ cmdBlkiotune(vshControl * ctl, const vshCmd * cmd)
             goto save_error;
     }
 
-    rv = vshCommandOptString(cmd, "device-weights", &device_weight);
+    rv = vshCommandOptString(ctl, cmd, "device-weights", &device_weight);
     if (rv < 0) {
         vshError(ctl, "%s", _("Unable to parse string parameter"));
         goto cleanup;
@@ -1577,7 +1577,7 @@ cmdBlkiotune(vshControl * ctl, const vshCmd * cmd)
             goto save_error;
     }
 
-    rv = vshCommandOptString(cmd, "device-read-iops-sec", &device_riops);
+    rv = vshCommandOptString(ctl, cmd, "device-read-iops-sec", &device_riops);
     if (rv < 0) {
         vshError(ctl, "%s", _("Unable to parse string parameter"));
         goto cleanup;
@@ -1588,7 +1588,7 @@ cmdBlkiotune(vshControl * ctl, const vshCmd * cmd)
             goto save_error;
     }
 
-    rv = vshCommandOptString(cmd, "device-write-iops-sec", &device_wiops);
+    rv = vshCommandOptString(ctl, cmd, "device-write-iops-sec", &device_wiops);
     if (rv < 0) {
         vshError(ctl, "%s", _("Unable to parse string parameter"));
         goto cleanup;
@@ -1599,7 +1599,7 @@ cmdBlkiotune(vshControl * ctl, const vshCmd * cmd)
             goto save_error;
     }
 
-    rv = vshCommandOptString(cmd, "device-read-bytes-sec", &device_rbps);
+    rv = vshCommandOptString(ctl, cmd, "device-read-bytes-sec", &device_rbps);
     if (rv < 0) {
         vshError(ctl, "%s", _("Unable to parse string parameter"));
         goto cleanup;
@@ -1610,7 +1610,7 @@ cmdBlkiotune(vshControl * ctl, const vshCmd * cmd)
             goto save_error;
     }
 
-    rv = vshCommandOptString(cmd, "device-write-bytes-sec", &device_wbps);
+    rv = vshCommandOptString(ctl, cmd, "device-write-bytes-sec", &device_wbps);
     if (rv < 0) {
         vshError(ctl, "%s", _("Unable to parse string parameter"));
         goto cleanup;
@@ -1692,7 +1692,7 @@ blockJobImpl(vshControl *ctl, const vshCmd *cmd,
     if (vshCommandOptStringReq(ctl, cmd, "path", &path) < 0)
         goto cleanup;
 
-    if (vshCommandOptULWrap(cmd, "bandwidth", &bandwidth) < 0) {
+    if (vshCommandOptULWrap(ctl, cmd, "bandwidth", &bandwidth) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "bandwidth");
@@ -2161,11 +2161,11 @@ cmdBlockCopy(vshControl *ctl, const vshCmd *cmd)
 
     if (vshCommandOptStringReq(ctl, cmd, "path", &path) < 0)
         return false;
-    if (vshCommandOptString(cmd, "dest", &dest) < 0)
+    if (vshCommandOptString(ctl, cmd, "dest", &dest) < 0)
         return false;
-    if (vshCommandOptString(cmd, "xml", &xml) < 0)
+    if (vshCommandOptString(ctl, cmd, "xml", &xml) < 0)
         return false;
-    if (vshCommandOptString(cmd, "format", &format) < 0)
+    if (vshCommandOptString(ctl, cmd, "format", &format) < 0)
         return false;
 
     VSH_EXCLUSIVE_OPTIONS_VAR(dest, xml);
@@ -2216,19 +2216,19 @@ cmdBlockCopy(vshControl *ctl, const vshCmd *cmd)
      * MiB/s, and either reject negative input or treat it as 0 rather
      * than trying to guess which value will work well across both
      * APIs with their different sizes and scales.  */
-    if (vshCommandOptULWrap(cmd, "bandwidth", &bandwidth) < 0) {
+    if (vshCommandOptULWrap(ctl, cmd, "bandwidth", &bandwidth) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "bandwidth");
         goto cleanup;
     }
-    if (vshCommandOptUInt(cmd, "granularity", &granularity) < 0) {
+    if (vshCommandOptUInt(ctl, cmd, "granularity", &granularity) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "granularity");
         goto cleanup;
     }
-    if (vshCommandOptULongLong(cmd, "buf-size", &buf_size) < 0) {
+    if (vshCommandOptULongLong(ctl, cmd, "buf-size", &buf_size) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "buf-size");
@@ -2800,7 +2800,7 @@ cmdBlockResize(vshControl *ctl, const vshCmd *cmd)
     if (vshCommandOptStringReq(ctl, cmd, "path", (const char **) &path) < 0)
         return false;
 
-    if (vshCommandOptScaledInt(cmd, "size", &size, 1024, ULLONG_MAX) < 0) {
+    if (vshCommandOptScaledInt(ctl, cmd, "size", &size, 1024, ULLONG_MAX) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "size");
@@ -3406,7 +3406,7 @@ cmdDomPMSuspend(vshControl *ctl, const vshCmd *cmd)
     if (!(dom = vshCommandOptDomain(ctl, cmd, &name)))
         return false;
 
-    if (vshCommandOptULongLong(cmd, "duration", &duration) < 0) {
+    if (vshCommandOptULongLong(ctl, cmd, "duration", &duration) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "duration");
@@ -3587,7 +3587,7 @@ cmdUndefine(vshControl *ctl, const vshCmd *cmd)
     size_t i;
     size_t j;
 
-    ignore_value(vshCommandOptString(cmd, "storage", &vol_string));
+    ignore_value(vshCommandOptString(ctl, cmd, "storage", &vol_string));
 
     if (!(vol_string || remove_all_storage) && wipe_storage) {
         vshError(ctl,
@@ -3966,7 +3966,7 @@ cmdStartGetFDs(vshControl *ctl,
     *nfdsret = 0;
     *fdsret = NULL;
 
-    if (vshCommandOptString(cmd, "pass-fds", &fdopt) <= 0)
+    if (vshCommandOptString(ctl, cmd, "pass-fds", &fdopt) <= 0)
         return 0;
 
     if (!(fdlist = virStringSplit(fdopt, ",", -1))) {
@@ -4834,7 +4834,7 @@ cmdSchedInfoUpdate(vshControl *ctl, const vshCmd *cmd,
     int ret = -1;
     int rv;
 
-    while ((opt = vshCommandOptArgv(cmd, opt))) {
+    while ((opt = vshCommandOptArgv(ctl, cmd, opt))) {
         set_field = vshStrdup(ctl, opt->data);
         if (!(set_val = strchr(set_field, '='))) {
             vshError(ctl, "%s", _("Invalid syntax for --set, "
@@ -5161,7 +5161,7 @@ doDump(void *opaque)
             goto out;
         }
 
-        if (vshCommandOptString(cmd, "format", &format)) {
+        if (vshCommandOptString(ctl, cmd, "format", &format)) {
             if (STREQ(format, "kdump-zlib")) {
                 dumpformat = VIR_DOMAIN_CORE_DUMP_FORMAT_KDUMP_ZLIB;
             } else if (STREQ(format, "kdump-lzo")) {
@@ -5330,7 +5330,7 @@ cmdScreenshot(vshControl *ctl, const vshCmd *cmd)
     if (vshCommandOptStringReq(ctl, cmd, "file", (const char **) &file) < 0)
         return false;
 
-    if (vshCommandOptUInt(cmd, "screen", &screen) < 0) {
+    if (vshCommandOptUInt(ctl, cmd, "screen", &screen) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "screen");
@@ -6497,7 +6497,7 @@ cmdVcpuPin(vshControl *ctl, const vshCmd *cmd)
     if (!cpulist)
         VSH_EXCLUSIVE_OPTIONS_VAR(live, config);
 
-    if ((got_vcpu = vshCommandOptUInt(cmd, "vcpu", &vcpu)) < 0) {
+    if ((got_vcpu = vshCommandOptUInt(ctl, cmd, "vcpu", &vcpu)) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "vcpu");
@@ -6766,7 +6766,7 @@ cmdSetvcpus(vshControl *ctl, const vshCmd *cmd)
     if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
         return false;
 
-    if (vshCommandOptInt(cmd, "count", &count) < 0 || count <= 0) {
+    if (vshCommandOptInt(ctl, cmd, "count", &count) < 0 || count <= 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "count");
@@ -6946,14 +6946,14 @@ cmdIOThreadPin(vshControl *ctl, const vshCmd *cmd)
     if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
         return false;
 
-    if (vshCommandOptUInt(cmd, "iothread", &iothread_id) < 0) {
+    if (vshCommandOptUInt(ctl, cmd, "iothread", &iothread_id) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "iothread");
         goto cleanup;
     }
 
-    if (vshCommandOptString(cmd, "cpulist", &cpulist) < 0) {
+    if (vshCommandOptString(ctl, cmd, "cpulist", &cpulist) < 0) {
         vshError(ctl, "%s", _("iothreadpin: invalid cpulist."));
         goto cleanup;
     }
@@ -7037,7 +7037,7 @@ cmdIOThreadAdd(vshControl *ctl, const vshCmd *cmd)
     if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
         return false;
 
-    if (vshCommandOptInt(cmd, "id", &iothread_id) < 0) {
+    if (vshCommandOptInt(ctl, cmd, "id", &iothread_id) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "id");
@@ -7119,7 +7119,7 @@ cmdIOThreadDel(vshControl *ctl, const vshCmd *cmd)
     if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
         return false;
 
-    if (vshCommandOptInt(cmd, "id", &iothread_id) < 0) {
+    if (vshCommandOptInt(ctl, cmd, "id", &iothread_id) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "id");
@@ -7408,7 +7408,7 @@ cmdCPUStats(vshControl *ctl, const vshCmd *cmd)
 
     show_total = vshCommandOptBool(cmd, "total");
 
-    if ((rv = vshCommandOptInt(cmd, "start", &cpu)) < 0) {
+    if ((rv = vshCommandOptInt(ctl, cmd, "start", &cpu)) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "start");
@@ -7421,7 +7421,7 @@ cmdCPUStats(vshControl *ctl, const vshCmd *cmd)
         show_per_cpu = true;
     }
 
-    if ((rv = vshCommandOptInt(cmd, "count", &show_count)) < 0) {
+    if ((rv = vshCommandOptInt(ctl, cmd, "count", &show_count)) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "count");
@@ -7852,7 +7852,7 @@ cmdDesc(vshControl *ctl, const vshCmd *cmd)
     if ((state = vshDomainState(ctl, dom, NULL)) < 0)
         goto cleanup;
 
-    while ((opt = vshCommandOptArgv(cmd, opt))) {
+    while ((opt = vshCommandOptArgv(ctl, cmd, opt))) {
         if (pad)
             virBufferAddChar(&buf, ' ');
         pad = true;
@@ -8208,10 +8208,10 @@ cmdSendKey(vshControl *ctl, const vshCmd *cmd)
     if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
         return false;
 
-    if (vshCommandOptString(cmd, "codeset", &codeset_option) <= 0)
+    if (vshCommandOptString(ctl, cmd, "codeset", &codeset_option) <= 0)
         codeset_option = "linux";
 
-    if (vshCommandOptUInt(cmd, "holdtime", &holdtime) < 0) {
+    if (vshCommandOptUInt(ctl, cmd, "holdtime", &holdtime) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "holdtime");
@@ -8224,7 +8224,7 @@ cmdSendKey(vshControl *ctl, const vshCmd *cmd)
         goto cleanup;
     }
 
-    while ((opt = vshCommandOptArgv(cmd, opt))) {
+    while ((opt = vshCommandOptArgv(ctl, cmd, opt))) {
         if (count == VIR_DOMAIN_SEND_KEY_MAX_KEYS) {
             vshError(ctl, _("too many keycodes"));
             goto cleanup;
@@ -8337,7 +8337,7 @@ cmdSendProcessSignal(vshControl *ctl, const vshCmd *cmd)
     if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
         return false;
 
-    if (vshCommandOptLongLong(cmd, "pid", &pid_value) < 0) {
+    if (vshCommandOptLongLong(ctl, cmd, "pid", &pid_value) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "pid");
@@ -8438,7 +8438,7 @@ cmdSetmem(vshControl *ctl, const vshCmd *cmd)
         max = 1024ull * ULONG_MAX;
     else
         max = ULONG_MAX;
-    if (vshCommandOptScaledInt(cmd, "size", &bytes, 1024, max) < 0) {
+    if (vshCommandOptScaledInt(ctl, cmd, "size", &bytes, 1024, max) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "size");
@@ -8535,7 +8535,7 @@ cmdSetmaxmem(vshControl *ctl, const vshCmd *cmd)
         max = 1024ull * ULONG_MAX;
     else
         max = ULONG_MAX;
-    if (vshCommandOptScaledInt(cmd, "size", &bytes, 1024, max) < 0) {
+    if (vshCommandOptScaledInt(ctl, cmd, "size", &bytes, 1024, max) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "size");
@@ -8630,14 +8630,14 @@ static const vshCmdOptDef opts_memtune[] = {
  *  <0 in all other cases
  */
 static int
-vshMemtuneGetSize(const vshCmd *cmd, const char *name, long long *value)
+vshMemtuneGetSize(vshControl *ctl, const vshCmd *cmd, const char *name, long long *value)
 {
     int ret;
     unsigned long long tmp;
     const char *str;
     char *end;
 
-    ret = vshCommandOptString(cmd, name, &str);
+    ret = vshCommandOptString(ctl, cmd, name, &str);
     if (ret <= 0)
         return ret;
     if (virStrToLong_ll(str, &end, 10, value) < 0)
@@ -8681,7 +8681,7 @@ cmdMemtune(vshControl *ctl, const vshCmd *cmd)
         return false;
 
 #define PARSE_MEMTUNE_PARAM(NAME, FIELD)                                    \
-    if ((rc = vshMemtuneGetSize(cmd, NAME, &tmpVal)) < 0) {                 \
+    if ((rc = vshMemtuneGetSize(ctl, cmd, NAME, &tmpVal)) < 0) {            \
         vshError(ctl, _("Unable to parse integer parameter %s"), NAME);     \
         goto cleanup;                                                       \
     }                                                                       \
@@ -8952,7 +8952,7 @@ cmdQemuMonitorCommand(vshControl *ctl, const vshCmd *cmd)
     if (dom == NULL)
         goto cleanup;
 
-    while ((opt = vshCommandOptArgv(cmd, opt))) {
+    while ((opt = vshCommandOptArgv(ctl, cmd, opt))) {
         if (pad)
             virBufferAddChar(&buf, ' ');
         pad = true;
@@ -9100,7 +9100,7 @@ cmdQemuMonitorEvent(vshControl *ctl, const vshCmd *cmd)
     data.count = 0;
     if (vshCommandOptTimeoutToMs(ctl, cmd, &timeout) < 0)
         return false;
-    if (vshCommandOptString(cmd, "event", &event) < 0)
+    if (vshCommandOptString(ctl, cmd, "event", &event) < 0)
         return false;
 
     if (vshCommandOptBool(cmd, "domain"))
@@ -9171,7 +9171,7 @@ cmdQemuAttach(vshControl *ctl, const vshCmd *cmd)
     unsigned int flags = 0;
     unsigned int pid_value; /* API uses unsigned int, not pid_t */
 
-    if (vshCommandOptUInt(cmd, "pid", &pid_value) <= 0) {
+    if (vshCommandOptUInt(ctl, cmd, "pid", &pid_value) <= 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "pid");
@@ -9255,7 +9255,7 @@ cmdQemuAgentCommand(vshControl *ctl, const vshCmd *cmd)
     if (dom == NULL)
         goto cleanup;
 
-    while ((opt = vshCommandOptArgv(cmd, opt))) {
+    while ((opt = vshCommandOptArgv(ctl, cmd, opt))) {
         if (pad)
             virBufferAddChar(&buf, ' ');
         pad = true;
@@ -9267,7 +9267,7 @@ cmdQemuAgentCommand(vshControl *ctl, const vshCmd *cmd)
     }
     guest_agent_cmd = virBufferContentAndReset(&buf);
 
-    judge = vshCommandOptInt(cmd, "timeout", &timeout);
+    judge = vshCommandOptInt(ctl, cmd, "timeout", &timeout);
     if (judge < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
@@ -9377,7 +9377,7 @@ cmdLxcEnterNamespace(vshControl *ctl, const vshCmd *cmd)
     if (vshCommandOptBool(cmd, "noseclabel"))
         setlabel = false;
 
-    while ((opt = vshCommandOptArgv(cmd, opt))) {
+    while ((opt = vshCommandOptArgv(ctl, cmd, opt))) {
         if (VIR_EXPAND_N(cmdargv, ncmdargv, 1) < 0) {
             vshError(ctl, _("%s: %d: failed to allocate argv"),
                      __FILE__, __LINE__);
@@ -10153,7 +10153,7 @@ cmdMigrateSetMaxDowntime(vshControl *ctl, const vshCmd *cmd)
     if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
         return false;
 
-    if (vshCommandOptLongLong(cmd, "downtime", &downtime) < 0) {
+    if (vshCommandOptLongLong(ctl, cmd, "downtime", &downtime) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "downtime");
@@ -10215,7 +10215,7 @@ cmdMigrateCompCache(vshControl *ctl, const vshCmd *cmd)
     if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
         return false;
 
-    rc = vshCommandOptULongLong(cmd, "size", &size);
+    rc = vshCommandOptULongLong(ctl, cmd, "size", &size);
     if (rc < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
@@ -10276,7 +10276,7 @@ cmdMigrateSetMaxSpeed(vshControl *ctl, const vshCmd *cmd)
     if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
         return false;
 
-    if (vshCommandOptULWrap(cmd, "bandwidth", &bandwidth) < 0) {
+    if (vshCommandOptULWrap(ctl, cmd, "bandwidth", &bandwidth) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "bandwidth");
@@ -12317,7 +12317,7 @@ cmdEvent(vshControl *ctl, const vshCmd *cmd)
         return true;
     }
 
-    if (vshCommandOptString(cmd, "event", &eventName) < 0)
+    if (vshCommandOptString(ctl, cmd, "event", &eventName) < 0)
         return false;
     if (eventName) {
         for (event = 0; event < VIR_DOMAIN_EVENT_ID_LAST; event++)
@@ -12616,7 +12616,7 @@ cmdDomFSTrim(vshControl *ctl, const vshCmd *cmd)
     if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
         return ret;
 
-    if (vshCommandOptULongLong(cmd, "minimum", &minimum) < 0) {
+    if (vshCommandOptULongLong(ctl, cmd, "minimum", &minimum) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "minimum");
@@ -12672,7 +12672,7 @@ cmdDomFSFreeze(vshControl *ctl, const vshCmd *cmd)
     if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
         return false;
 
-    while ((opt = vshCommandOptArgv(cmd, opt))) {
+    while ((opt = vshCommandOptArgv(ctl, cmd, opt))) {
         if (VIR_EXPAND_N(mountpoints, nmountpoints, 1) < 0) {
             vshError(ctl, _("%s: %d: failed to allocate mountpoints"),
                      __FILE__, __LINE__);
@@ -12729,7 +12729,7 @@ cmdDomFSThaw(vshControl *ctl, const vshCmd *cmd)
     if (!(dom = vshCommandOptDomain(ctl, cmd, NULL)))
         return false;
 
-    while ((opt = vshCommandOptArgv(cmd, opt))) {
+    while ((opt = vshCommandOptArgv(ctl, cmd, opt))) {
         if (VIR_EXPAND_N(mountpoints, nmountpoints, 1) < 0) {
             vshError(ctl, _("%s: %d: failed to allocate mountpoints"),
                      __FILE__, __LINE__);
diff --git a/tools/virsh-host.c b/tools/virsh-host.c
index a72fd05..b90782f 100644
--- a/tools/virsh-host.c
+++ b/tools/virsh-host.c
@@ -176,7 +176,7 @@ cmdFreecell(vshControl *ctl, const vshCmd *cmd)
 
     VSH_EXCLUSIVE_OPTIONS_VAR(all, cellno);
 
-    if (cellno && vshCommandOptInt(cmd, "cellno", &cell) < 0) {
+    if (cellno && vshCommandOptInt(ctl, cmd, "cellno", &cell) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "cellno");
@@ -311,7 +311,7 @@ cmdFreepages(vshControl *ctl, const vshCmd *cmd)
 
     VSH_EXCLUSIVE_OPTIONS_VAR(all, cellno);
 
-    if (vshCommandOptScaledInt(cmd, "pagesize", &bytes, 1024, UINT_MAX) < 0) {
+    if (vshCommandOptScaledInt(ctl, cmd, "pagesize", &bytes, 1024, UINT_MAX) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "pagesize");
@@ -391,7 +391,7 @@ cmdFreepages(vshControl *ctl, const vshCmd *cmd)
             goto cleanup;
         }
 
-        if (vshCommandOptInt(cmd, "cellno", &cell) < 0) {
+        if (vshCommandOptInt(ctl, cmd, "cellno", &cell) < 0) {
             vshError(ctl,
                      _("Numeric value for <%s> option is malformed or out of range"),
                      "cellno");
@@ -490,14 +490,14 @@ cmdAllocpages(vshControl *ctl, const vshCmd *cmd)
 
     VSH_EXCLUSIVE_OPTIONS_VAR(all, cellno);
 
-    if (cellno && vshCommandOptInt(cmd, "cellno", &startCell) < 0) {
+    if (cellno && vshCommandOptInt(ctl, cmd, "cellno", &startCell) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "cellno");
         return false;
     }
 
-    if (vshCommandOptScaledInt(cmd, "pagesize", &tmp, 1024, UINT_MAX) < 0) {
+    if (vshCommandOptScaledInt(ctl, cmd, "pagesize", &tmp, 1024, UINT_MAX) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "cellno");
@@ -505,7 +505,7 @@ cmdAllocpages(vshControl *ctl, const vshCmd *cmd)
     }
     pageSizes[0] = VIR_DIV_UP(tmp, 1024);
 
-    if (vshCommandOptULongLong(cmd, "pagecount", &pageCounts[0]) < 0) {
+    if (vshCommandOptULongLong(ctl, cmd, "pagecount", &pageCounts[0]) < 0) {
         vshError(ctl, "%s", _("pagecount has to be a number"));
         return false;
     }
@@ -764,7 +764,7 @@ cmdNodeCpuStats(vshControl *ctl, const vshCmd *cmd)
     unsigned long long cpu_stats[VSH_CPU_LAST] = { 0 };
     bool present[VSH_CPU_LAST] = { false };
 
-    if (vshCommandOptInt(cmd, "cpu", &cpuNum) < 0) {
+    if (vshCommandOptInt(ctl, cmd, "cpu", &cpuNum) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "cpu");
@@ -875,7 +875,7 @@ cmdNodeMemStats(vshControl *ctl, const vshCmd *cmd)
     virNodeMemoryStatsPtr params = NULL;
     bool ret = false;
 
-    if (vshCommandOptInt(cmd, "cell", &cellNum) < 0) {
+    if (vshCommandOptInt(ctl, cmd, "cell", &cellNum) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "cell");
@@ -951,7 +951,7 @@ cmdNodeSuspend(vshControl *ctl, const vshCmd *cmd)
     if (vshCommandOptStringReq(ctl, cmd, "target", &target) < 0)
         return false;
 
-    if (vshCommandOptLongLong(cmd, "duration", &duration) < 0) {
+    if (vshCommandOptLongLong(ctl, cmd, "duration", &duration) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "duration");
@@ -1260,7 +1260,7 @@ cmdNodeMemoryTune(vshControl *ctl, const vshCmd *cmd)
     int rc = -1;
     size_t i;
 
-    if ((rc = vshCommandOptUInt(cmd, "shm-pages-to-scan", &value)) < 0) {
+    if ((rc = vshCommandOptUInt(ctl, cmd, "shm-pages-to-scan", &value)) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "shm-pages-to-scan");
@@ -1272,7 +1272,7 @@ cmdNodeMemoryTune(vshControl *ctl, const vshCmd *cmd)
             goto save_error;
     }
 
-    if ((rc = vshCommandOptUInt(cmd, "shm-sleep-millisecs", &value)) < 0) {
+    if ((rc = vshCommandOptUInt(ctl, cmd, "shm-sleep-millisecs", &value)) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "shm-sleep-millisecs");
@@ -1284,7 +1284,7 @@ cmdNodeMemoryTune(vshControl *ctl, const vshCmd *cmd)
             goto save_error;
     }
 
-    if ((rc = vshCommandOptUInt(cmd, "shm-merge-across-nodes", &value)) < 0) {
+    if ((rc = vshCommandOptUInt(ctl, cmd, "shm-merge-across-nodes", &value)) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "shm-merge-across-nodes");
diff --git a/tools/virsh-interface.c b/tools/virsh-interface.c
index 7122bc5..a6ae3b3 100644
--- a/tools/virsh-interface.c
+++ b/tools/virsh-interface.c
@@ -843,7 +843,7 @@ cmdInterfaceBridge(vshControl *ctl, const vshCmd *cmd)
     /* use "no-stp" because we want "stp" to default true */
     stp = !vshCommandOptBool(cmd, "no-stp");
 
-    if (vshCommandOptUInt(cmd, "delay", &delay) < 0) {
+    if (vshCommandOptUInt(ctl, cmd, "delay", &delay) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "delay");
diff --git a/tools/virsh-network.c b/tools/virsh-network.c
index a45367a..24250dd 100644
--- a/tools/virsh-network.c
+++ b/tools/virsh-network.c
@@ -936,7 +936,7 @@ cmdNetworkUpdate(vshControl *ctl, const vshCmd *cmd)
         goto cleanup;
     }
 
-    if (vshCommandOptInt(cmd, "parent-index", &parentIndex) < 0) {
+    if (vshCommandOptInt(ctl, cmd, "parent-index", &parentIndex) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "parent-index");
@@ -1227,7 +1227,7 @@ cmdNetworkEvent(vshControl *ctl, const vshCmd *cmd)
         return true;
     }
 
-    if (vshCommandOptString(cmd, "event", &eventName) < 0)
+    if (vshCommandOptString(ctl, cmd, "event", &eventName) < 0)
         return false;
     if (!eventName) {
         vshError(ctl, "%s", _("either --list or event type is required"));
@@ -1337,7 +1337,7 @@ cmdNetworkDHCPLeases(vshControl *ctl, const vshCmd *cmd)
     unsigned int flags = 0;
     virNetworkPtr network = NULL;
 
-    if (vshCommandOptString(cmd, "mac", &mac) < 0)
+    if (vshCommandOptString(ctl, cmd, "mac", &mac) < 0)
         return false;
 
     if (!(network = vshCommandOptNetwork(ctl, cmd, &name)))
diff --git a/tools/virsh-nodedev.c b/tools/virsh-nodedev.c
index 0d7315c..8c578d1 100644
--- a/tools/virsh-nodedev.c
+++ b/tools/virsh-nodedev.c
@@ -395,7 +395,7 @@ cmdNodeListDevices(vshControl *ctl, const vshCmd *cmd ATTRIBUTE_UNUSED)
     vshNodeDeviceListPtr list = NULL;
     int cap_type = -1;
 
-    ignore_value(vshCommandOptString(cmd, "cap", &cap_str));
+    ignore_value(vshCommandOptString(ctl, cmd, "cap", &cap_str));
 
     if (cap_str) {
         if (tree) {
@@ -610,7 +610,7 @@ cmdNodeDeviceDetach(vshControl *ctl, const vshCmd *cmd)
     if (vshCommandOptStringReq(ctl, cmd, "device", &name) < 0)
         return false;
 
-    ignore_value(vshCommandOptString(cmd, "driver", &driverName));
+    ignore_value(vshCommandOptString(ctl, cmd, "driver", &driverName));
 
     if (!(device = virNodeDeviceLookupByName(ctl->conn, name))) {
         vshError(ctl, _("Could not find matching device '%s'"), name);
diff --git a/tools/virsh-snapshot.c b/tools/virsh-snapshot.c
index 459a8a8..de84175 100644
--- a/tools/virsh-snapshot.c
+++ b/tools/virsh-snapshot.c
@@ -440,7 +440,7 @@ cmdSnapshotCreateAs(vshControl *ctl, const vshCmd *cmd)
     if (vshCommandOptBool(cmd, "diskspec")) {
         virBufferAddLit(&buf, "<disks>\n");
         virBufferAdjustIndent(&buf, 2);
-        while ((opt = vshCommandOptArgv(cmd, opt))) {
+        while ((opt = vshCommandOptArgv(ctl, cmd, opt))) {
             if (vshParseSnapshotDiskspec(ctl, &buf, opt->data) < 0)
                 goto cleanup;
         }
diff --git a/tools/virsh-volume.c b/tools/virsh-volume.c
index 5d6cc6a..08ee6a1 100644
--- a/tools/virsh-volume.c
+++ b/tools/virsh-volume.c
@@ -219,7 +219,7 @@ cmdVolCreateAs(vshControl *ctl, const vshCmd *cmd)
         goto cleanup;
     }
 
-    if (vshCommandOptString(cmd, "allocation", &allocationStr) > 0 &&
+    if (vshCommandOptString(ctl, cmd, "allocation", &allocationStr) > 0 &&
         vshVolSize(allocationStr, &allocation) < 0) {
         vshError(ctl, _("Malformed size %s"), allocationStr);
         goto cleanup;
@@ -693,14 +693,14 @@ cmdVolUpload(vshControl *ctl, const vshCmd *cmd)
     const char *name = NULL;
     unsigned long long offset = 0, length = 0;
 
-    if (vshCommandOptULongLong(cmd, "offset", &offset) < 0) {
+    if (vshCommandOptULongLong(ctl, cmd, "offset", &offset) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "offset");
         return false;
     }
 
-    if (vshCommandOptULongLongWrap(cmd, "length", &length) < 0) {
+    if (vshCommandOptULongLongWrap(ctl, cmd, "length", &length) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "length");
@@ -806,14 +806,14 @@ cmdVolDownload(vshControl *ctl, const vshCmd *cmd)
     unsigned long long offset = 0, length = 0;
     bool created = false;
 
-    if (vshCommandOptULongLong(cmd, "offset", &offset) < 0) {
+    if (vshCommandOptULongLong(ctl, cmd, "offset", &offset) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "offset");
         return false;
     }
 
-    if (vshCommandOptULongLongWrap(cmd, "length", &length) < 0) {
+    if (vshCommandOptULongLongWrap(ctl, cmd, "length", &length) < 0) {
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "length");
diff --git a/tools/virsh.c b/tools/virsh.c
index 720b715..07ef69e 100644
--- a/tools/virsh.c
+++ b/tools/virsh.c
@@ -607,7 +607,7 @@ cmdHelp(vshControl *ctl, const vshCmd *cmd)
  {
     const char *name = NULL;
 
-    if (vshCommandOptString(cmd, "command", &name) <= 0) {
+    if (vshCommandOptString(ctl, cmd, "command", &name) <= 0) {
         const vshCmdGrp *grp;
         const vshCmdDef *def;
 
@@ -875,7 +875,7 @@ cmdCd(vshControl *ctl, const vshCmd *cmd)
         return false;
     }
 
-    if (vshCommandOptString(cmd, "dir", &dir) <= 0)
+    if (vshCommandOptString(ctl, cmd, "dir", &dir) <= 0)
         dir = dir_malloced = virGetUserDirectory();
     if (!dir)
         dir = "/";
@@ -978,7 +978,7 @@ cmdEcho(vshControl *ctl, const vshCmd *cmd)
     if (vshCommandOptBool(cmd, "xml"))
         xml = true;
 
-    while ((opt = vshCommandOptArgv(cmd, opt))) {
+    while ((opt = vshCommandOptArgv(ctl, cmd, opt))) {
         char *str;
         virBuffer xmlbuf = VIR_BUFFER_INITIALIZER;
 
@@ -1471,7 +1471,8 @@ vshCommandFree(vshCmd *cmd)
  * issued if a value is returned.
  */
 static int
-vshCommandOpt(const vshCmd *cmd, const char *name, vshCmdOpt **opt,
+vshCommandOpt(const vshCmd *cmd,
+              const char *name, vshCmdOpt **opt,
               bool needData)
 {
     vshCmdOpt *candidate = cmd->opts;
@@ -1504,6 +1505,7 @@ vshCommandOpt(const vshCmd *cmd, const char *name, vshCmdOpt **opt,
 
 /**
  * vshCommandOptInt:
+ * @ctl virsh control structure
  * @cmd command reference
  * @name option name
  * @value result
@@ -1515,7 +1517,8 @@ vshCommandOpt(const vshCmd *cmd, const char *name, vshCmdOpt **opt,
  * <0 in all other cases (@value untouched)
  */
 int
-vshCommandOptInt(const vshCmd *cmd, const char *name, int *value)
+vshCommandOptInt(vshControl *ctl ATTRIBUTE_UNUSED, const vshCmd *cmd,
+                 const char *name, int *value)
 {
     vshCmdOpt *arg;
     int ret;
@@ -1530,9 +1533,8 @@ vshCommandOptInt(const vshCmd *cmd, const char *name, int *value)
 }
 
 static int
-vshCommandOptUIntInternal(const vshCmd *cmd,
-                          const char *name,
-                          unsigned int *value,
+vshCommandOptUIntInternal(vshControl *ctl ATTRIBUTE_UNUSED, const vshCmd *cmd,
+                          const char *name, unsigned int *value,
                           bool wrap)
 {
     vshCmdOpt *arg;
@@ -1554,6 +1556,7 @@ vshCommandOptUIntInternal(const vshCmd *cmd,
 
 /**
  * vshCommandOptUInt:
+ * @ctl virsh control structure
  * @cmd command reference
  * @name option name
  * @value result
@@ -1562,13 +1565,15 @@ vshCommandOptUIntInternal(const vshCmd *cmd,
  * See vshCommandOptInt()
  */
 int
-vshCommandOptUInt(const vshCmd *cmd, const char *name, unsigned int *value)
+vshCommandOptUInt(vshControl *ctl, const vshCmd *cmd,
+                  const char *name, unsigned int *value)
 {
-    return vshCommandOptUIntInternal(cmd, name, value, false);
+    return vshCommandOptUIntInternal(ctl, cmd, name, value, false);
 }
 
 /**
  * vshCommandOptUIntWrap:
+ * @ctl virsh control structure
  * @cmd command reference
  * @name option name
  * @value result
@@ -1577,15 +1582,15 @@ vshCommandOptUInt(const vshCmd *cmd, const char *name, unsigned int *value)
  * See vshCommandOptInt()
  */
 int
-vshCommandOptUIntWrap(const vshCmd *cmd, const char *name, unsigned int *value)
+vshCommandOptUIntWrap(vshControl *ctl, const vshCmd *cmd,
+                      const char *name, unsigned int *value)
 {
-    return vshCommandOptUIntInternal(cmd, name, value, true);
+    return vshCommandOptUIntInternal(ctl, cmd, name, value, true);
 }
 
 static int
-vshCommandOptULInternal(const vshCmd *cmd,
-                        const char *name,
-                        unsigned long *value,
+vshCommandOptULInternal(vshControl *ctl ATTRIBUTE_UNUSED, const vshCmd *cmd,
+                        const char *name, unsigned long *value,
                         bool wrap)
 {
     vshCmdOpt *arg;
@@ -1607,6 +1612,7 @@ vshCommandOptULInternal(const vshCmd *cmd,
 
 /*
  * vshCommandOptUL:
+ * @ctl virsh control structure
  * @cmd command reference
  * @name option name
  * @value result
@@ -1615,13 +1621,15 @@ vshCommandOptULInternal(const vshCmd *cmd,
  * See vshCommandOptInt()
  */
 int
-vshCommandOptUL(const vshCmd *cmd, const char *name, unsigned long *value)
+vshCommandOptUL(vshControl *ctl, const vshCmd *cmd,
+                const char *name, unsigned long *value)
 {
-    return vshCommandOptULInternal(cmd, name, value, false);
+    return vshCommandOptULInternal(ctl, cmd, name, value, false);
 }
 
 /**
  * vshCommandOptULWrap:
+ * @ctl virsh control structure
  * @cmd command reference
  * @name option name
  * @value result
@@ -1630,13 +1638,15 @@ vshCommandOptUL(const vshCmd *cmd, const char *name, unsigned long *value)
  * See vshCommandOptInt()
  */
 int
-vshCommandOptULWrap(const vshCmd *cmd, const char *name, unsigned long *value)
+vshCommandOptULWrap(vshControl *ctl, const vshCmd *cmd,
+                    const char *name, unsigned long *value)
 {
-    return vshCommandOptULInternal(cmd, name, value, true);
+    return vshCommandOptULInternal(ctl, cmd, name, value, true);
 }
 
 /**
  * vshCommandOptString:
+ * @ctl virsh control structure
  * @cmd command reference
  * @name option name
  * @value result
@@ -1648,7 +1658,8 @@ vshCommandOptULWrap(const vshCmd *cmd, const char *name, unsigned long *value)
  * <0 in all other cases (@value untouched)
  */
 int
-vshCommandOptString(const vshCmd *cmd, const char *name, const char **value)
+vshCommandOptString(vshControl *ctl ATTRIBUTE_UNUSED, const vshCmd *cmd,
+                    const char *name, const char **value)
 {
     vshCmdOpt *arg;
     int ret;
@@ -1677,10 +1688,8 @@ vshCommandOptString(const vshCmd *cmd, const char *name, const char **value)
  * returned and error message printed.
  */
 int
-vshCommandOptStringReq(vshControl *ctl,
-                       const vshCmd *cmd,
-                       const char *name,
-                       const char **value)
+vshCommandOptStringReq(vshControl *ctl, const vshCmd *cmd,
+                       const char *name, const char **value)
 {
     vshCmdOpt *arg;
     int ret;
@@ -1710,6 +1719,7 @@ vshCommandOptStringReq(vshControl *ctl,
 
 /**
  * vshCommandOptLongLong:
+ * @ctl virsh control structure
  * @cmd command reference
  * @name option name
  * @value result
@@ -1718,8 +1728,8 @@ vshCommandOptStringReq(vshControl *ctl,
  * See vshCommandOptInt()
  */
 int
-vshCommandOptLongLong(const vshCmd *cmd, const char *name,
-                      long long *value)
+vshCommandOptLongLong(vshControl *ctl ATTRIBUTE_UNUSED, const vshCmd *cmd,
+                      const char *name, long long *value)
 {
     vshCmdOpt *arg;
     int ret;
@@ -1734,9 +1744,8 @@ vshCommandOptLongLong(const vshCmd *cmd, const char *name,
 }
 
 static int
-vshCommandOptULongLongInternal(const vshCmd *cmd,
-                               const char *name,
-                               unsigned long long *value,
+vshCommandOptULongLongInternal(vshControl *ctl ATTRIBUTE_UNUSED, const vshCmd *cmd,
+                               const char *name, unsigned long long *value,
                                bool wrap)
 {
     vshCmdOpt *arg;
@@ -1758,6 +1767,7 @@ vshCommandOptULongLongInternal(const vshCmd *cmd,
 
 /**
  * vshCommandOptULongLong:
+ * @ctl virsh control structure
  * @cmd command reference
  * @name option name
  * @value result
@@ -1766,14 +1776,15 @@ vshCommandOptULongLongInternal(const vshCmd *cmd,
  * See vshCommandOptInt()
  */
 int
-vshCommandOptULongLong(const vshCmd *cmd, const char *name,
-                       unsigned long long *value)
+vshCommandOptULongLong(vshControl *ctl, const vshCmd *cmd,
+                       const char *name, unsigned long long *value)
 {
-    return vshCommandOptULongLongInternal(cmd, name, value, false);
+    return vshCommandOptULongLongInternal(ctl, cmd, name, value, false);
 }
 
 /**
  * vshCommandOptULongLongWrap:
+ * @ctl virsh control structure
  * @cmd command reference
  * @name option name
  * @value result
@@ -1782,14 +1793,15 @@ vshCommandOptULongLong(const vshCmd *cmd, const char *name,
  * See vshCommandOptInt()
  */
 int
-vshCommandOptULongLongWrap(const vshCmd *cmd, const char *name,
-                       unsigned long long *value)
+vshCommandOptULongLongWrap(vshControl *ctl, const vshCmd *cmd,
+                           const char *name, unsigned long long *value)
 {
-    return vshCommandOptULongLongInternal(cmd, name, value, true);
+    return vshCommandOptULongLongInternal(ctl, cmd, name, value, true);
 }
 
 /**
  * vshCommandOptScaledInt:
+ * @ctl virsh control structure
  * @cmd command reference
  * @name option name
  * @value result
@@ -1800,9 +1812,9 @@ vshCommandOptULongLongWrap(const vshCmd *cmd, const char *name,
  * See vshCommandOptInt()
  */
 int
-vshCommandOptScaledInt(const vshCmd *cmd, const char *name,
-                       unsigned long long *value, int scale,
-                       unsigned long long max)
+vshCommandOptScaledInt(vshControl *ctl ATTRIBUTE_UNUSED, const vshCmd *cmd,
+                       const char *name, unsigned long long *value,
+                       int scale, unsigned long long max)
 {
     vshCmdOpt *arg;
     char *end;
@@ -1838,6 +1850,7 @@ vshCommandOptBool(const vshCmd *cmd, const char *name)
 
 /**
  * vshCommandOptArgv:
+ * @ctl virsh control structure
  * @cmd command reference
  * @opt starting point for the search
  *
@@ -1848,7 +1861,8 @@ vshCommandOptBool(const vshCmd *cmd, const char *name)
  * list of supported options in CMD->def->opts.
  */
 const vshCmdOpt *
-vshCommandOptArgv(const vshCmd *cmd, const vshCmdOpt *opt)
+vshCommandOptArgv(vshControl *ctl ATTRIBUTE_UNUSED, const vshCmd *cmd,
+                  const vshCmdOpt *opt)
 {
     opt = opt ? opt->next : cmd->opts;
 
@@ -1871,12 +1885,13 @@ vshCommandOptArgv(const vshCmd *cmd, const vshCmdOpt *opt)
  * See vshCommandOptInt()
  */
 int
-vshCommandOptTimeoutToMs(vshControl *ctl, const vshCmd *cmd, int *timeout)
+vshCommandOptTimeoutToMs(vshControl *ctl, const vshCmd *cmd,
+                         int *timeout)
 {
     int ret;
     unsigned int utimeout;
 
-    if ((ret = vshCommandOptUInt(cmd, "timeout", &utimeout)) < 0)
+    if ((ret = vshCommandOptUInt(ctl, cmd, "timeout", &utimeout)) < 0)
         vshError(ctl,
                  _("Numeric value for <%s> option is malformed or out of range"),
                  "timeout");
diff --git a/tools/virsh.h b/tools/virsh.h
index 32b1c91..8e00792 100644
--- a/tools/virsh.h
+++ b/tools/virsh.h
@@ -279,44 +279,46 @@ bool vshCmddefHelp(vshControl *ctl, const char *name);
 const vshCmdGrp *vshCmdGrpSearch(const char *grpname);
 bool vshCmdGrpHelp(vshControl *ctl, const char *name);
 
-int vshCommandOptInt(const vshCmd *cmd, const char *name, int *value)
-    ATTRIBUTE_NONNULL(3) ATTRIBUTE_RETURN_CHECK;
-int vshCommandOptUInt(const vshCmd *cmd, const char *name,
-                      unsigned int *value)
-    ATTRIBUTE_NONNULL(3) ATTRIBUTE_RETURN_CHECK;
-int vshCommandOptUIntWrap(const vshCmd *cmd, const char *name,
-                          unsigned int *value)
-    ATTRIBUTE_NONNULL(3) ATTRIBUTE_RETURN_CHECK;
-int vshCommandOptUL(const vshCmd *cmd, const char *name,
-                    unsigned long *value)
-    ATTRIBUTE_NONNULL(3) ATTRIBUTE_RETURN_CHECK;
-int vshCommandOptULWrap(const vshCmd *cmd, const char *name,
-                        unsigned long *value)
-    ATTRIBUTE_NONNULL(3) ATTRIBUTE_RETURN_CHECK;
-int vshCommandOptString(const vshCmd *cmd, const char *name,
-                        const char **value)
-    ATTRIBUTE_NONNULL(3) ATTRIBUTE_RETURN_CHECK;
+int vshCommandOptInt(vshControl *ctl, const vshCmd *cmd,
+                     const char *name, int *value)
+    ATTRIBUTE_NONNULL(4) ATTRIBUTE_RETURN_CHECK;
+int vshCommandOptUInt(vshControl *ctl, const vshCmd *cmd,
+                      const char *name, unsigned int *value)
+    ATTRIBUTE_NONNULL(4) ATTRIBUTE_RETURN_CHECK;
+int vshCommandOptUIntWrap(vshControl *ctl, const vshCmd *cmd,
+                          const char *name, unsigned int *value)
+    ATTRIBUTE_NONNULL(4) ATTRIBUTE_RETURN_CHECK;
+int vshCommandOptUL(vshControl *ctl, const vshCmd *cmd,
+                    const char *name, unsigned long *value)
+    ATTRIBUTE_NONNULL(4) ATTRIBUTE_RETURN_CHECK;
+int vshCommandOptULWrap(vshControl *ctl, const vshCmd *cmd,
+                        const char *name, unsigned long *value)
+    ATTRIBUTE_NONNULL(4) ATTRIBUTE_RETURN_CHECK;
+int vshCommandOptString(vshControl *ctl, const vshCmd *cmd,
+                        const char *name, const char **value)
+    ATTRIBUTE_NONNULL(4) ATTRIBUTE_RETURN_CHECK;
 int vshCommandOptStringReq(vshControl *ctl, const vshCmd *cmd,
                            const char *name, const char **value)
     ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3)
     ATTRIBUTE_NONNULL(4) ATTRIBUTE_RETURN_CHECK;
-int vshCommandOptLongLong(const vshCmd *cmd, const char *name,
-                          long long *value)
-    ATTRIBUTE_NONNULL(3) ATTRIBUTE_RETURN_CHECK;
-int vshCommandOptULongLong(const vshCmd *cmd, const char *name,
-                           unsigned long long *value)
-    ATTRIBUTE_NONNULL(3) ATTRIBUTE_RETURN_CHECK;
-int vshCommandOptULongLongWrap(const vshCmd *cmd, const char *name,
-                               unsigned long long *value)
-    ATTRIBUTE_NONNULL(3) ATTRIBUTE_RETURN_CHECK;
-int vshCommandOptScaledInt(const vshCmd *cmd, const char *name,
-                           unsigned long long *value, int scale,
-                           unsigned long long max)
-    ATTRIBUTE_NONNULL(3) ATTRIBUTE_RETURN_CHECK;
+int vshCommandOptLongLong(vshControl *ctl, const vshCmd *cmd,
+                          const char *name, long long *value)
+    ATTRIBUTE_NONNULL(4) ATTRIBUTE_RETURN_CHECK;
+int vshCommandOptULongLong(vshControl *ctl, const vshCmd *cmd,
+                           const char *name, unsigned long long *value)
+    ATTRIBUTE_NONNULL(4) ATTRIBUTE_RETURN_CHECK;
+int vshCommandOptULongLongWrap(vshControl *ctl, const vshCmd *cmd,
+                               const char *name, unsigned long long *value)
+    ATTRIBUTE_NONNULL(4) ATTRIBUTE_RETURN_CHECK;
+int vshCommandOptScaledInt(vshControl *ctl, const vshCmd *cmd,
+                           const char *name, unsigned long long *value,
+                           int scale, unsigned long long max)
+    ATTRIBUTE_NONNULL(4) ATTRIBUTE_RETURN_CHECK;
 bool vshCommandOptBool(const vshCmd *cmd, const char *name);
-const vshCmdOpt *vshCommandOptArgv(const vshCmd *cmd,
+const vshCmdOpt *vshCommandOptArgv(vshControl *ctl, const vshCmd *cmd,
                                    const vshCmdOpt *opt);
-int vshCommandOptTimeoutToMs(vshControl *ctl, const vshCmd *cmd, int *timeout);
+int vshCommandOptTimeoutToMs(vshControl *ctl, const vshCmd *cmd,
+                             int *timeout);
 
 /* Filter flags for various vshCommandOpt*By() functions */
 typedef enum {
-- 
2.1.0


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]