From: Peter Krempa <pkrempa(a)redhat.com&gt; Add the automatic cleanup handler as well as static initializer to allow simple stack allocated conditions. Signed-off-by: Peter Krempa <pkrempa(a)redhat.com&gt; --- src/util/virthread.h | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/util/virthread.h b/src/util/virthread.h index a7ec6bf32c..9e4e8cdafe 100644 --- a/src/util/virthread.h +++ b/src/util/virthread.h @@ -73,6 +73,11 @@ struct virOnceControl { .once = PTHREAD_ONCE_INIT \ } +#define VIR_COND_INITIALIZER \ + { \ + .cond = PTHREAD_COND_INITIALIZER \ + } + typedef void (*virOnceFunc)(void); typedef void (*virThreadFunc)(void *opaque); @@ -142,6 +147,7 @@ void virRWLockUnlock(virRWLock *m); int virCondInit(virCond *c) G_GNUC_WARN_UNUSED_RESULT; int virCondDestroy(virCond *c); +G_DEFINE_AUTO_CLEANUP_CLEAR_FUNC(virCond, virCondDestroy); /* virCondWait, virCondWaitUntil: * These functions can return without the associated predicate -- 2.49.0

From: Peter Krempa <pkrempa(a)redhat.com&gt; Currently the handler functions in the virt shells return only a boolean signalling if the command was successful or not. In preparation for a command which will want to return another value (timeout) convert vshCommand run to actually return the requested exit code instead and document the conversion from boolean. Signed-off-by: Peter Krempa <pkrempa(a)redhat.com&gt; --- tools/virsh.c | 4 ++-- tools/virt-admin.c | 4 ++-- tools/vsh.c | 29 ++++++++++++++++++++--------- tools/vsh.h | 2 +- 4 files changed, 25 insertions(+), 14 deletions(-) diff --git a/tools/virsh.c b/tools/virsh.c index 244ca655ee..643ef6b453 100644 --- a/tools/virsh.c +++ b/tools/virsh.c @@ -836,7 +836,7 @@ main(int argc, char **argv) vshControl _ctl = { 0 }; vshControl *ctl = &_ctl; virshControl virshCtl = { 0 }; - bool ret = true; + int ret = EXIT_SUCCESS; ctl->name = "virsh"; /* hardcoded name of the binary */ ctl->env_prefix = "VIRSH"; @@ -930,5 +930,5 @@ main(int argc, char **argv) } virshDeinit(ctl); - exit(ret ? EXIT_SUCCESS : EXIT_FAILURE); + exit(ret); } diff --git a/tools/virt-admin.c b/tools/virt-admin.c index b701ed1fe4..ac8f3202b6 100644 --- a/tools/virt-admin.c +++ b/tools/virt-admin.c @@ -1530,7 +1530,7 @@ main(int argc, char **argv) vshControl _ctl = { 0 }; vshControl *ctl = &_ctl; vshAdmControl virtAdminCtl = { 0 }; - bool ret = true; + int ret = EXIT_SUCCESS; ctl->name = "virt-admin"; /* hardcoded name of the binary */ ctl->env_prefix = "VIRT_ADMIN"; @@ -1612,5 +1612,5 @@ main(int argc, char **argv) } vshAdmDeinit(ctl); - exit(ret ? EXIT_SUCCESS : EXIT_FAILURE); + exit(ret); } diff --git a/tools/vsh.c b/tools/vsh.c index e892cbca22..497b7ec631 100644 --- a/tools/vsh.c +++ b/tools/vsh.c @@ -1341,14 +1341,22 @@ vshBlockJobOptionBandwidth(vshControl *ctl, } -/* - * Executes command(s) and returns return code from last command +/** + * vshCommandRun: + * @ctl: virt shell data + * @cmd: command to execute + * + * Returns return code from last command. Return values from command handlers + * which return boolean are converted as: + * true -> EXIT_SUCCESS + * false -> EXIT_FAILURE */ -bool -vshCommandRun(vshControl *ctl, const vshCmd *cmd) +int +vshCommandRun(vshControl *ctl, + const vshCmd *cmd) { const vshClientHooks *hooks = ctl->hooks; - bool ret = true; + int ret = EXIT_SUCCESS; while (cmd) { gint64 before, after; @@ -1358,16 +1366,19 @@ vshCommandRun(vshControl *ctl, const vshCmd *cmd) if ((cmd->def->flags & VSH_CMD_FLAG_NOCONNECT) || (hooks && hooks->connHandler && hooks->connHandler(ctl))) { - ret = cmd->def->handler(ctl, cmd); + if (cmd->def->handler(ctl, cmd)) + ret = EXIT_SUCCESS; + else + ret = EXIT_FAILURE; } else { /* connection is not usable, return error */ - ret = false; + ret = EXIT_FAILURE; } after = g_get_real_time(); /* try to automatically catch disconnections */ - if (!ret && + if (ret != EXIT_SUCCESS && ((last_error != NULL) && (((last_error->code == VIR_ERR_SYSTEM_ERROR) && (last_error->domain == VIR_FROM_REMOTE)) || @@ -1376,7 +1387,7 @@ vshCommandRun(vshControl *ctl, const vshCmd *cmd) (last_error->code == VIR_ERR_INVALID_CONN)))) disconnected++; - if (!ret) + if (ret != EXIT_SUCCESS) vshReportError(ctl); if (STREQ(cmd->def->name, "quit") || diff --git a/tools/vsh.h b/tools/vsh.h index 3b75216e11..284da36e32 100644 --- a/tools/vsh.h +++ b/tools/vsh.h @@ -287,7 +287,7 @@ int vshBlockJobOptionBandwidth(vshControl *ctl, bool bytes, unsigned long *bandwidth); bool vshCommandOptBool(const vshCmd *cmd, const char *name); -bool vshCommandRun(vshControl *ctl, const vshCmd *cmd); +int vshCommandRun(vshControl *ctl, const vshCmd *cmd); bool vshCommandStringParse(vshControl *ctl, char *cmdstr, vshCmd **partial); -- 2.49.0

From: Peter Krempa <pkrempa(a)redhat.com&gt; The new command is meant as syntax sugar for event handling which blocks virsh until the requested state condition is reached. The initial implementation adds a condition 'domain-inactive' returning if the domain is/becomes inactive for whatever reason. This command is useful for simple scripts e.g. for debugging libvirt when it allows responding to target state in shell without the need to fuss too much with polling or writing handlers around 'virsh event'. Signed-off-by: Peter Krempa <pkrempa(a)redhat.com&gt; --- docs/manpages/virsh.rst | 25 ++++ tools/virsh-domain-event.c | 245 +++++++++++++++++++++++++++++++++++++ 2 files changed, 270 insertions(+) diff --git a/docs/manpages/virsh.rst b/docs/manpages/virsh.rst index 895a905b08..1515f84063 100644 --- a/docs/manpages/virsh.rst +++ b/docs/manpages/virsh.rst @@ -3062,6 +3062,31 @@ When *--timestamp* is used, a human-readable timestamp will be printed before the event. +await +----- + +**Syntax:** + +:: + + await <domain> --condition <string> [--timeout seconds] + +Wait until the *--condition* for <domain> is satisfied. Uses events for +efficient state updates. + +Supported conditions: + + *domain-inactive* + + domain is or becomes inactive + +If *--timeout* is specified, the command gives up waiting for the condition to +satisfy after *seconds* have elapsed. If SIGINT is delivered to virsh +(usually via ``Ctrl-C``) the wait is given up immediately. In non-interactive +mode virsh will return '2' if either of those cases instead of '1' which means +an error happened. + + get-user-sshkeys ---------------- diff --git a/tools/virsh-domain-event.c b/tools/virsh-domain-event.c index 9aa21b2e78..2cd52933c7 100644 --- a/tools/virsh-domain-event.c +++ b/tools/virsh-domain-event.c @@ -1064,6 +1064,245 @@ cmdEvent(vshControl *ctl, const vshCmd *cmd) } +/* virsh event-await */ + +struct virshDomEventAwaitConditionData; + +struct virshDomainEventAwaitCondition { + const char *name; + int event; + int (*handler)(struct virshDomEventAwaitConditionData *data); +}; + +struct virshDomEventAwaitConditionData { + vshControl *ctl; + virshDomain *dom; + const struct virshDomainEventAwaitCondition *cond; + + virMutex *m; /* synchronization to ensure clean shutdown */ + virCond *c; + bool done; +}; + + +static void +virshDomEventAwaitConditionDataUnregistered(struct virshDomEventAwaitConditionData *data) +{ + g_auto(virLockGuard) name = virLockGuardLock(data->m); + /* signal that the handler was unregistered */ + data->done = true; + virCondSignal(data->c); +} + + +static void +virshDomainEventAwaitCallbackLifecycle(virConnectPtr conn G_GNUC_UNUSED, + virDomainPtr dom G_GNUC_UNUSED, + int event G_GNUC_UNUSED, + int detail G_GNUC_UNUSED, + void *opaque) +{ + struct virshDomEventAwaitConditionData *data = opaque; + + if (data->cond->handler(data) < 1) + vshEventDone(data->ctl); +} + + +struct virshDomainEventAwaitCallbackTuple { + int event; + virConnectDomainEventGenericCallback eventCB; +}; + + +static const struct virshDomainEventAwaitCallbackTuple callbacks[] = +{ + { .event = VIR_DOMAIN_EVENT_ID_LIFECYCLE, + .eventCB = VIR_DOMAIN_EVENT_CALLBACK(virshDomainEventAwaitCallbackLifecycle), + }, +}; + + +static int +virshDomainEventAwaitConditionDomainInactive(struct virshDomEventAwaitConditionData *data) +{ + int state = -1; + + if (virDomainGetState(data->dom, &state, NULL, 0) < 0) { + vshError(data->ctl, "%s", _("failed to update domain state")); + return -1; + } + + switch ((virDomainState) state) { + case VIR_DOMAIN_SHUTOFF: + case VIR_DOMAIN_CRASHED: + return 0; + + case VIR_DOMAIN_NOSTATE: + case VIR_DOMAIN_RUNNING: + case VIR_DOMAIN_BLOCKED: + case VIR_DOMAIN_PAUSED: + case VIR_DOMAIN_SHUTDOWN: + case VIR_DOMAIN_PMSUSPENDED: + case VIR_DOMAIN_LAST: + break; + } + + return 1; +} + + +static const struct virshDomainEventAwaitCondition conditions[] = { + { .name = "domain-inactive", + .event = VIR_DOMAIN_EVENT_ID_LIFECYCLE, + .handler = virshDomainEventAwaitConditionDomainInactive, + }, +}; + + +static char ** +virshDomainAwaitConditionNameCompleter(vshControl *ctl G_GNUC_UNUSED, + const vshCmd *cmd G_GNUC_UNUSED, + unsigned int flags) +{ + size_t i = 0; + GStrv ret = NULL; + + virCheckFlags(0, NULL); + + ret = g_new0(char *, G_N_ELEMENTS(conditions) + 1); + + for (i = 0; i < G_N_ELEMENTS(conditions); i++) + ret[i] = g_strdup(conditions[i].name); + + return ret; +} + + +static const vshCmdInfo info_await = { + .help = N_("await a domain event"), + .desc = N_("waits for a certain domain event to happen and then terminates"), +}; + +static const vshCmdOptDef opts_await[] = { + VIRSH_COMMON_OPT_DOMAIN_FULL(0), + {.name = "condition", + .type = VSH_OT_STRING, + .required = true, + .completer = virshDomainAwaitConditionNameCompleter, + .help = N_("which condition to wait until") + }, + {.name = "timeout", + .type = VSH_OT_INT, + .help = N_("timeout seconds") + }, + {.name = NULL} +}; + + +static int +cmdAwait(vshControl *ctl, + const vshCmd *cmd) +{ + g_autoptr(virshDomain) dom = NULL; + int timeout = 0; + size_t i; + const char *conditionName = NULL; + virshControl *priv = ctl->privData; + const struct virshDomainEventAwaitCallbackTuple *callback = NULL; + int evid = -1; + g_auto(virMutex) m = VIR_MUTEX_INITIALIZER; + g_auto(virCond) c = VIR_COND_INITIALIZER; + struct virshDomEventAwaitConditionData data = { + .ctl = ctl, + .m = &m, + .c = &c, + }; + int ret = -1; + + if (vshCommandOptString(ctl, cmd, "condition", &conditionName) < 0) + return -1; + + for (i = 0; i < G_N_ELEMENTS(conditions); i++) { + if (STREQ(conditionName, conditions[i].name)) { + data.cond = conditions + i; + break; + } + } + + if (!data.cond) { + vshError(ctl, _("Unsupported await condition name '%1$s'"), conditionName); + return -1; + } + + for (i = 0; i < G_N_ELEMENTS(callbacks); i++) { + if (data.cond->event == callbacks[i].event) { + callback = callbacks + i; + break; + } + } + + if (!callback) { + vshError(ctl, _("Missing callback definition for event type '%1$d'"), data.cond->event); + return -1; + } + + if (vshCommandOptTimeoutToMs(ctl, cmd, &timeout) < 0) + return -1; + + if (!(data.dom = dom = virshCommandOptDomain(ctl, cmd, NULL))) + return -1; + + if (vshEventStart(ctl, timeout) < 0) + goto cleanup; + + if ((evid = virConnectDomainEventRegisterAny(priv->conn, dom, + callback->event, + callback->eventCB, + &data, + (virFreeCallback) virshDomEventAwaitConditionDataUnregistered)) < 0) + goto cleanup; + + /* invoke the handler to ensure initial state update */ + if ((ret = data.cond->handler(&data)) <= 0) + goto cleanup; + + switch (vshEventWait(ctl)) { + case VSH_EVENT_INTERRUPT: + vshPrintExtra(ctl, "%s", _("event loop interrupted\n")); + ret = 2; + break; + + case VSH_EVENT_TIMEOUT: + vshPrintExtra(ctl, "%s", _("event loop timed out\n")); + ret = 2; + break; + + case VSH_EVENT_DONE: + ret = 0; + break; + + default: + ret = -1; + goto cleanup; + } + + cleanup: + if (evid >= 0) { + virConnectDomainEventDeregisterAny(priv->conn, evid); + + virMutexLock(&m); + while (!data.done) { + if (virCondWait(&c, &m) < 0) + break; + } + virMutexUnlock(&m); + } + vshEventCleanup(ctl); + + return ret; +} + const vshCmdDef domEventCmds[] = { {.name = "event", .handler = cmdEvent, @@ -1071,5 +1310,11 @@ const vshCmdDef domEventCmds[] = { .info = &info_event, .flags = 0 }, + {.name = "await", + .handler_rv = cmdAwait, + .opts = opts_await, + .info = &info_await, + .flags = 0 + }, {.name = NULL} }; -- 2.49.0