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.

diff --git a/tools/virsh-domain-monitor.c b/tools/virsh-domain-monitor.c
index a42c15072f20a49f88d685a57e6887f378cddd39..d8b217bf3d502d2edda3611a208a390cf141268f 100644 (file)
--- 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 fc4d1fc9f41e9faa9f90721c813eb5256d17cc3b..79a9a9bec819acf99a0f629400a83c031efc9926 100644 (file)
--- 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 a72fd051fe66e477c108c50b533adce212963fb9..b90782fae8805d79d1c3b0dbce8980dd296315f7 100644 (file)
--- 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 7122bc542a082af18f250da734b977923166617e..a6ae3b385d31eba6a6439b9c2435894abba44154 100644 (file)
--- 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 a45367a5bf0af0c9f27d6b3fb09fd0445a508582..24250dd8d30956d9a36ed5b0e958bb28bac6efb6 100644 (file)
--- 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 0d7315c02e6ca23aa9bb12765e53d39de1455fbf..8c578d1741208961600d03c74d42cbe081ad9132 100644 (file)
--- 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 459a8a895b1cfde25979aa19b89d4361d7489625..de8417519a9080e110335bfb0fcaef468e634220 100644 (file)
--- 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 989ce87af429174d5927d1f0ffdad78f63ce6a28..9df1d81013c88de2bcaab84969ee7e4a67fbfc5f 100644 (file)
--- 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 cd2bfef5a717d8cc3a1d9531a8ef59ac4d937534..dcdbe03718304bac6c9e83d3f6b0e17ff896ba2c 100644 (file)
--- 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;
 
@@ -1504,6 +1504,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 +1516,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,7 +1532,8 @@ vshCommandOptInt(const vshCmd *cmd, const char *name, int *value)
 }
 
 static int
-vshCommandOptUIntInternal(const vshCmd *cmd,
+vshCommandOptUIntInternal(vshControl *ctl ATTRIBUTE_UNUSED,
+                          const vshCmd *cmd,
                           const char *name,
                           unsigned int *value,
                           bool wrap)
@@ -1554,6 +1557,7 @@ vshCommandOptUIntInternal(const vshCmd *cmd,
 
 /**
  * vshCommandOptUInt:
+ * @ctl virsh control structure
  * @cmd command reference
  * @name option name
  * @value result
@@ -1562,13 +1566,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,13 +1583,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,
+vshCommandOptULInternal(vshControl *ctl ATTRIBUTE_UNUSED,
+                        const vshCmd *cmd,
                         const char *name,
                         unsigned long *value,
                         bool wrap)
@@ -1607,6 +1615,7 @@ vshCommandOptULInternal(const vshCmd *cmd,
 
 /*
  * vshCommandOptUL:
+ * @ctl virsh control structure
  * @cmd command reference
  * @name option name
  * @value result
@@ -1615,13 +1624,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 +1641,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 +1661,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;
@@ -1710,6 +1724,7 @@ vshCommandOptStringReq(vshControl *ctl,
 
 /**
  * vshCommandOptLongLong:
+ * @ctl virsh control structure
  * @cmd command reference
  * @name option name
  * @value result
@@ -1718,8 +1733,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,7 +1749,8 @@ vshCommandOptLongLong(const vshCmd *cmd, const char *name,
 }
 
 static int
-vshCommandOptULongLongInternal(const vshCmd *cmd,
+vshCommandOptULongLongInternal(vshControl *ctl ATTRIBUTE_UNUSED,
+                               const vshCmd *cmd,
                                const char *name,
                                unsigned long long *value,
                                bool wrap)
@@ -1758,6 +1774,7 @@ vshCommandOptULongLongInternal(const vshCmd *cmd,
 
 /**
  * vshCommandOptULongLong:
+ * @ctl virsh control structure
  * @cmd command reference
  * @name option name
  * @value result
@@ -1766,14 +1783,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 +1800,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 +1819,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 +1857,7 @@ vshCommandOptBool(const vshCmd *cmd, const char *name)
 
 /**
  * vshCommandOptArgv:
+ * @ctl virsh control structure
  * @cmd command reference
  * @opt starting point for the search
  *
@@ -1848,7 +1868,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;
 
@@ -1876,7 +1897,7 @@ 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 32b1c9165c75e099a0adaf5ee3801b0c4109639a..977b0fce1ac40e67bb8c407d27b7dccf8e3ae31c 100644 (file)
--- a/tools/virsh.h
+++ b/tools/virsh.h
@@ -279,42 +279,43 @@ 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);