Any new API deserves a good virsh wrapper :) qemu-monitor-event [<domain>] [<event>] [--pretty] [--loop] [--timeout <number>] Very similar to the previous work on 'virsh event'. For an example session: $ virsh -c qemu:///system qemu-monitor-event --event SHUTDOWN& $ virsh -c qemu:///system start f18-live Domain f18-live started $ virsh -c qemu:///system destroy f18-live Domain f18-live destroyed event SHUTDOWN at 1391212552.026544 for domain f18-live: (null) events received: 1 [1]+ Done virsh -c qemu:///system qemu-monitor-event --event SHUTDOWN $ * tools/virsh-domain.c (cmdQemuMonitorEvent): New command. * tools/virsh.pod (qemu-monitor-event): Document it. Signed-off-by: Eric Blake <eblake(a)redhat.com&gt; --- tools/virsh-domain.c | 135 +++++++++++++++++++++++++++++++++++++++++++++++++++ tools/virsh.pod | 27 +++++++++-- 2 files changed, 158 insertions(+), 4 deletions(-) diff --git a/tools/virsh-domain.c b/tools/virsh-domain.c index 1d3c5f0..a5808d8 100644 --- a/tools/virsh-domain.c +++ b/tools/virsh-domain.c @@ -7912,6 +7912,135 @@ cleanup: } /* + * "qemu-monitor-event" command + */ + +struct vshQemuEventData { + vshControl *ctl; + bool loop; + bool pretty; + int count; +}; +typedef struct vshQemuEventData vshQemuEventData; + +static void +vshEventPrint(virConnectPtr conn ATTRIBUTE_UNUSED, virDomainPtr dom, + const char *event, long long seconds, unsigned int micros, + const char *details, void *opaque) +{ + vshQemuEventData *data = opaque; + virJSONValuePtr pretty = NULL; + char *str = NULL; + + if (!data->loop && data->count) + return; + if (data->pretty && details) { + pretty = virJSONValueFromString(details); + if (pretty && (str = virJSONValueToString(pretty, true))) + details = str; + } + vshPrint(data->ctl, "event %s at %lld.%06u for domain %s: %s\n", + event, seconds, micros, virDomainGetName(dom), NULLSTR(details)); + data->count++; + if (!data->loop) + vshEventDone(data->ctl); + + VIR_FREE(str); +} + +static const vshCmdInfo info_qemu_monitor_event[] = { + {.name = "help", + .data = N_("QEMU Monitor Events") + }, + {.name = "desc", + .data = N_("Listen for QEMU Monitor Events") + }, + {.name = NULL} +}; + +static const vshCmdOptDef opts_qemu_monitor_event[] = { + {.name = "domain", + .type = VSH_OT_DATA, + .help = N_("filter by domain name, id or uuid") + }, + {.name = "event", + .type = VSH_OT_DATA, + .help = N_("filter by event name") + }, + {.name = "pretty", + .type = VSH_OT_BOOL, + .help = N_("pretty-print any JSON output") + }, + {.name = "loop", + .type = VSH_OT_BOOL, + .help = N_("loop until timeout or interrupt, rather than one-shot") + }, + {.name = "timeout", + .type = VSH_OT_INT, + .help = N_("timeout seconds") + }, + {.name = NULL} +}; + +static bool +cmdQemuMonitorEvent(vshControl *ctl, const vshCmd *cmd) +{ + virDomainPtr dom = NULL; + bool ret = false; + unsigned int flags = 0; + int eventId = -1; + int timeout = 0; + const char *event = NULL; + vshQemuEventData data; + + data.ctl = ctl; + data.loop = vshCommandOptBool(cmd, "loop"); + data.pretty = vshCommandOptBool(cmd, "pretty"); + data.count = 0; + if (vshCommandOptTimeoutToMs(ctl, cmd, &timeout) < 0) + return false; + if (vshCommandOptString(cmd, "event", &event) < 0) + return false; + + if (vshCommandOptBool(cmd, "domain")) + dom = vshCommandOptDomain(ctl, cmd, NULL); + if (vshEventStart(ctl, timeout) < 0) + goto cleanup; + + if ((eventId = virConnectDomainQemuMonitorEventRegister(ctl->conn, dom, + event, + vshEventPrint, + &data, NULL, + flags)) < 0) + goto cleanup; + switch (vshEventWait(ctl)) { + case VSH_EVENT_INTERRUPT: + vshPrint(ctl, _("event loop interrupted\n")); + break; + case VSH_EVENT_TIMEOUT: + vshPrint(ctl, _("event loop timed out\n")); + break; + case VSH_EVENT_DONE: + break; + default: + goto cleanup; + } + vshPrint(ctl, _("events received: %d\n"), data.count); + if (data.count) + ret = true; + +cleanup: + vshEventCleanup(ctl); + if (eventId >= 0 && + virConnectDomainQemuMonitorEventDeregister(ctl->conn, eventId) < 0) + ret = false; + if (dom) + virDomainFree(dom); + + return ret; +} + +/* * "qemu-attach" command */ static const vshCmdInfo info_qemu_attach[] = { @@ -11546,6 +11675,12 @@ const vshCmdDef domManagementCmds[] = { .info = info_qemu_monitor_command, .flags = 0 }, + {.name = "qemu-monitor-event", + .handler = cmdQemuMonitorEvent, + .opts = opts_qemu_monitor_event, + .info = info_qemu_monitor_event, + .flags = 0 + }, {.name = "qemu-agent-command", .handler = cmdQemuAgentCommand, .opts = opts_qemu_agent_command, diff --git a/tools/virsh.pod b/tools/virsh.pod index cefce1b..35acd96 100644 --- a/tools/virsh.pod +++ b/tools/virsh.pod @@ -3311,12 +3311,15 @@ variables, and defaults to C<vi>. =back -=head1 QEMU-SPECIFIC COMMANDS +=head1 HYPERVISOR-SPECIFIC COMMANDS NOTE: Use of the following commands is B<strongly> discouraged. They can cause libvirt to become confused and do the wrong thing on subsequent -operations. Once you have used this command, please do not report -problems to the libvirt developers; the reports will be ignored. +operations. Once you have used these commands, please do not report +problems to the libvirt developers; the reports will be ignored. If +you find that these commands are the only way to accomplish something, +then it is better to request that the feature be added as a first-class +citizen in the regular libvirt library. =over 4 @@ -3355,7 +3358,8 @@ and the monitor uses QMP, then the output will be pretty-printed. If more than one argument is provided for I<command>, they are concatenated with a space in between before passing the single command to the monitor. -=item B<qemu-agent-command> I<domain> [I<--timeout> I<seconds> | I<--async> | I<--block>] I<command>... +=item B<qemu-agent-command> I<domain> [I<--timeout> I<seconds> | I<--async> | +I<--block>] I<command>... Send an arbitrary guest agent command I<command> to domain I<domain> through qemu agent. @@ -3365,6 +3369,21 @@ When I<--aysnc> is given, the command waits for timeout whether success or failed. And when I<--block> is given, the command waits forever with blocking timeout. +=item B<qemu-monitor-event> [I<domain>] [I<--event> I<event-name>] [I<--loop>] +[I<--timeout> I<seconds>] [I<--pretty>] + +Wait for arbitrary QEMU monitor events to occur, and print out the +details of events as they happen. The events can optionally be filtered +by I<domain> or I<event-name>. The 'query-events' QMP command can be +used via I<qemu-monitor-command> to learn what events are supported. + +By default, this command is one-shot, and returns success once an event +occurs; you can send SIGINT (usually via C<Ctrl-C>) to quit immediately. +If I<--timeout> is specified, the command gives up waiting for events +after I<seconds> have elapsed. With I<--loop>, the command prints all +events until a timeout or interrupt key. If I<--pretty> is specified, +any JSON event details are pretty-printed for better legibility. + =item B<lxc-enter-namespace> I<domain> -- /path/to/binary [arg1, [arg2, ...]] Enter the namespace of I<domain> and execute the command C</path/to/binary> -- 1.8.5.3

These are the first async events in the qemu protocol, so this patch looks rather big compared to most RPC additions. However, a large majority of this patch is just mechanical copy-and-paste from recently-added network events. It didn't help that this is also the first virConnect rather than virDomain prefix associated with a qemu-specific API. * src/remote/qemu_protocol.x (qemu_*_domain_monitor_event_*): New structs and RPC messages. * src/rpc/gendispatch.pl: Adjust naming conventions. * daemon/libvirtd.h (daemonClientPrivate): Track qemu events. * daemon/remote.c (remoteClientFreeFunc): Likewise. (remoteRelayDomainQemuMonitorEvent) (qemuDispatchConnectDomainMonitorEventRegister) (qemuDispatchConnectDomainMonitorEventDeregister): New functions. * src/remote/remote_driver.c (qemuEvents): Handle qemu events. (doRemoteOpen): Register for events. (remoteNetworkBuildEventLifecycle) (remoteConnectDomainQemuMonitorEventRegister) (remoteConnectDomainQemuMonitorEventDeregister): New functions. * src/qemu_protocol-structs: Regenerate. Signed-off-by: Eric Blake <eblake(a)redhat.com&gt; --- daemon/libvirtd.h | 2 + daemon/remote.c | 209 +++++++++++++++++++++++++++++++++++++++++++++ src/qemu_protocol-structs | 22 +++++ src/remote/qemu_protocol.x | 50 ++++++++++- src/remote/remote_driver.c | 143 ++++++++++++++++++++++++++++++- src/rpc/gendispatch.pl | 13 +-- 6 files changed, 428 insertions(+), 11 deletions(-) diff --git a/daemon/libvirtd.h b/daemon/libvirtd.h index c4f1f27..49df33e 100644 --- a/daemon/libvirtd.h +++ b/daemon/libvirtd.h @@ -55,6 +55,8 @@ struct daemonClientPrivate { size_t ndomainEventCallbacks; daemonClientEventCallbackPtr *networkEventCallbacks; size_t nnetworkEventCallbacks; + daemonClientEventCallbackPtr *qemuEventCallbacks; + size_t nqemuEventCallbacks; # if WITH_SASL virNetSASLSessionPtr sasl; diff --git a/daemon/remote.c b/daemon/remote.c index b48d456..f18ce6b 100644 --- a/daemon/remote.c +++ b/daemon/remote.c @@ -53,6 +53,7 @@ #include "domain_conf.h" #include "network_conf.h" #include "viraccessapicheck.h" +#include "viraccessapicheckqemu.h" #define VIR_FROM_THIS VIR_FROM_RPC @@ -186,6 +187,33 @@ cleanup: } +static bool +remoteRelayDomainQemuMonitorEventCheckACL(virNetServerClientPtr client, + virConnectPtr conn, virDomainPtr dom) +{ + virDomainDef def; + virIdentityPtr identity = NULL; + bool ret = false; + + /* For now, we just create a virDomainDef with enough contents to + * satisfy what viraccessdriverpolkit.c references. This is a bit + * fragile, but I don't know of anything better. */ + def.name = dom->name; + memcpy(def.uuid, dom->uuid, VIR_UUID_BUFLEN); + + if (!(identity = virNetServerClientGetIdentity(client))) + goto cleanup; + if (virIdentitySetCurrent(identity) < 0) + goto cleanup; + ret = virConnectDomainQemuMonitorEventRegisterCheckACL(conn, &def); + +cleanup: + ignore_value(virIdentitySetCurrent(NULL)); + virObjectUnref(identity); + return ret; +} + + static int remoteRelayDomainEventLifecycle(virConnectPtr conn, virDomainPtr dom, @@ -958,6 +986,52 @@ static virConnectNetworkEventGenericCallback networkEventCallbacks[] = { verify(ARRAY_CARDINALITY(networkEventCallbacks) == VIR_NETWORK_EVENT_ID_LAST); +static void +remoteRelayDomainQemuMonitorEvent(virConnectPtr conn, + virDomainPtr dom, + const char *event, + long long seconds, + unsigned int micros, + const char *details, + void *opaque) +{ + daemonClientEventCallbackPtr callback = opaque; + qemu_domain_monitor_event_msg data; + char **details_p = NULL; + + if (callback->callbackID < 0 || + !remoteRelayDomainQemuMonitorEventCheckACL(callback->client, conn, + dom)) + return; + + VIR_DEBUG("Relaying qemu monitor event %s %s, callback %d", + event, details, callback->callbackID); + + /* build return data */ + memset(&data, 0, sizeof(data)); + data.callbackID = callback->callbackID; + if (VIR_STRDUP(data.event, event) < 0) + goto error; + data.seconds = seconds; + data.micros = micros; + if (details && + ((VIR_ALLOC(details_p) < 0) || + VIR_STRDUP(*details_p, details) < 0)) + goto error; + data.details = details_p; + make_nonnull_domain(&data.dom, dom); + + remoteDispatchObjectEventSend(callback->client, qemuProgram, + QEMU_PROC_DOMAIN_MONITOR_EVENT, + (xdrproc_t)xdr_qemu_domain_monitor_event_msg, + &data); + return; + +error: + VIR_FREE(data.event); + VIR_FREE(details_p); +} + /* * You must hold lock for at least the client * We don't free stuff here, merely disconnect the client's @@ -1005,6 +1079,21 @@ void remoteClientFreeFunc(void *data) } VIR_FREE(priv->networkEventCallbacks); + for (i = 0; i < priv->nqemuEventCallbacks; i++) { + int callbackID = priv->qemuEventCallbacks[i]->callbackID; + if (callbackID < 0) { + VIR_WARN("unexpected incomplete qemu monitor callback %zu", i); + continue; + } + VIR_DEBUG("Deregistering remote qemu monitor event relay %d", + callbackID); + priv->qemuEventCallbacks[i]->callbackID = -1; + if (virConnectDomainQemuMonitorEventDeregister(priv->conn, + callbackID) < 0) + VIR_WARN("unexpected qemu monitor event deregister failure"); + } + VIR_FREE(priv->qemuEventCallbacks); + virConnectClose(priv->conn); virIdentitySetCurrent(NULL); @@ -5861,6 +5950,126 @@ cleanup: } +static int +qemuDispatchConnectDomainMonitorEventRegister(virNetServerPtr server ATTRIBUTE_UNUSED, + virNetServerClientPtr client, + virNetMessagePtr msg ATTRIBUTE_UNUSED, + virNetMessageErrorPtr rerr ATTRIBUTE_UNUSED, + qemu_connect_domain_monitor_event_register_args *args, + qemu_connect_domain_monitor_event_register_ret *ret) +{ + int callbackID; + int rv = -1; + daemonClientEventCallbackPtr callback = NULL; + daemonClientEventCallbackPtr ref; + struct daemonClientPrivate *priv = + virNetServerClientGetPrivateData(client); + virDomainPtr dom = NULL; + const char *event = args->event ? *args->event : NULL; + + if (!priv->conn) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open")); + goto cleanup; + } + + virMutexLock(&priv->lock); + + if (args->dom && + !(dom = get_nonnull_domain(priv->conn, *args->dom))) + goto cleanup; + + /* If we call register first, we could append a complete callback + * to our array, but on OOM append failure, we'd have to then hope + * deregister works to undo our register. So instead we append an + * incomplete callback to our array, then register, then fix up + * our callback; but since VIR_APPEND_ELEMENT clears 'callback' on + * success, we use 'ref' to save a copy of the pointer. */ + if (VIR_ALLOC(callback) < 0) + goto cleanup; + callback->client = client; + callback->callbackID = -1; + ref = callback; + if (VIR_APPEND_ELEMENT(priv->qemuEventCallbacks, + priv->nqemuEventCallbacks, + callback) < 0) + goto cleanup; + + if ((callbackID = virConnectDomainQemuMonitorEventRegister(priv->conn, + dom, + event, + remoteRelayDomainQemuMonitorEvent, + ref, + remoteEventCallbackFree, + args->flags)) < 0) { + VIR_SHRINK_N(priv->qemuEventCallbacks, + priv->nqemuEventCallbacks, 1); + callback = ref; + goto cleanup; + } + + ref->callbackID = callbackID; + ret->callbackID = callbackID; + + rv = 0; + +cleanup: + VIR_FREE(callback); + if (rv < 0) + virNetMessageSaveError(rerr); + if (dom) + virDomainFree(dom); + virMutexUnlock(&priv->lock); + return rv; +} + + +static int +qemuDispatchConnectDomainMonitorEventDeregister(virNetServerPtr server ATTRIBUTE_UNUSED, + virNetServerClientPtr client, + virNetMessagePtr msg ATTRIBUTE_UNUSED, + virNetMessageErrorPtr rerr ATTRIBUTE_UNUSED, + qemu_connect_domain_monitor_event_deregister_args *args) +{ + int rv = -1; + size_t i; + struct daemonClientPrivate *priv = + virNetServerClientGetPrivateData(client); + + if (!priv->conn) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open")); + goto cleanup; + } + + virMutexLock(&priv->lock); + + for (i = 0; i < priv->nqemuEventCallbacks; i++) { + if (priv->qemuEventCallbacks[i]->callbackID == args->callbackID) + break; + } + if (i == priv->nqemuEventCallbacks) { + virReportError(VIR_ERR_INTERNAL_ERROR, + _("qemu monitor event callback %d not registered"), + args->callbackID); + goto cleanup; + } + + if (virConnectDomainQemuMonitorEventDeregister(priv->conn, + args->callbackID) < 0) + goto cleanup; + + VIR_DELETE_ELEMENT(priv->qemuEventCallbacks, i, + priv->nqemuEventCallbacks); + + rv = 0; + +cleanup: + if (rv < 0) + virNetMessageSaveError(rerr); + virMutexUnlock(&priv->lock); + return rv; +} + + /*----- Helpers. -----*/ /* get_nonnull_domain and get_nonnull_network turn an on-wire diff --git a/src/qemu_protocol-structs b/src/qemu_protocol-structs index 0dcd2c6..8501543 100644 --- a/src/qemu_protocol-structs +++ b/src/qemu_protocol-structs @@ -28,8 +28,30 @@ struct qemu_domain_agent_command_args { struct qemu_domain_agent_command_ret { remote_string result; }; +struct qemu_connect_domain_monitor_event_register_args { + remote_domain dom; + remote_string event; + u_int flags; +}; +struct qemu_connect_domain_monitor_event_register_ret { + int callbackID; +}; +struct qemu_connect_domain_monitor_event_deregister_args { + int callbackID; +}; +struct qemu_domain_monitor_event_msg { + int callbackID; + remote_nonnull_domain dom; + remote_nonnull_string event; + int64_t seconds; + u_int micros; + remote_string details; +}; enum qemu_procedure { QEMU_PROC_DOMAIN_MONITOR_COMMAND = 1, QEMU_PROC_DOMAIN_ATTACH = 2, QEMU_PROC_DOMAIN_AGENT_COMMAND = 3, + QEMU_PROC_CONNECT_DOMAIN_MONITOR_EVENT_REGISTER = 4, + QEMU_PROC_CONNECT_DOMAIN_MONITOR_EVENT_DEREGISTER = 5, + QEMU_PROC_DOMAIN_MONITOR_EVENT = 6, }; diff --git a/src/remote/qemu_protocol.x b/src/remote/qemu_protocol.x index 1e7cf7c..f6b88a9 100644 --- a/src/remote/qemu_protocol.x +++ b/src/remote/qemu_protocol.x @@ -3,7 +3,7 @@ * remote_internal driver and libvirtd. This protocol is * internal and may change at any time. * - * Copyright (C) 2010-2012 Red Hat, Inc. + * Copyright (C) 2010-2014 Red Hat, Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -58,6 +58,30 @@ struct qemu_domain_agent_command_ret { remote_string result; }; + +struct qemu_connect_domain_monitor_event_register_args { + remote_domain dom; + remote_string event; + unsigned int flags; +}; + +struct qemu_connect_domain_monitor_event_register_ret { + int callbackID; +}; + +struct qemu_connect_domain_monitor_event_deregister_args { + int callbackID; +}; + +struct qemu_domain_monitor_event_msg { + int callbackID; + remote_nonnull_domain dom; + remote_nonnull_string event; + hyper seconds; + unsigned int micros; + remote_string details; +}; + /* Define the program number, protocol version and procedure numbers here. */ const QEMU_PROGRAM = 0x20008087; const QEMU_PROTOCOL_VERSION = 1; @@ -108,5 +132,27 @@ enum qemu_procedure { * @priority: low * @acl: domain:write */ - QEMU_PROC_DOMAIN_AGENT_COMMAND = 3 + QEMU_PROC_DOMAIN_AGENT_COMMAND = 3, + + /** + * @generate: none + * @priority: high + * @acl: connect:search_domains + * @acl: connect:write + * @aclfilter: domain:getattr + */ + QEMU_PROC_CONNECT_DOMAIN_MONITOR_EVENT_REGISTER = 4, + + /** + * @generate: none + * @priority: high + * @acl: connect:write + */ + QEMU_PROC_CONNECT_DOMAIN_MONITOR_EVENT_DEREGISTER = 5, + + /** + * @generate: both + * @acl: none + */ + QEMU_PROC_DOMAIN_MONITOR_EVENT = 6 }; diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c index 955465a..50745fa 100644 --- a/src/remote/remote_driver.c +++ b/src/remote/remote_driver.c @@ -498,6 +498,19 @@ static virNetClientProgramEvent remoteEvents[] = { (xdrproc_t)xdr_remote_domain_event_callback_device_removed_msg }, }; + +static void +remoteDomainBuildQemuMonitorEvent(virNetClientProgramPtr prog ATTRIBUTE_UNUSED, + virNetClientPtr client ATTRIBUTE_UNUSED, + void *evdata, void *opaque); + +static virNetClientProgramEvent qemuEvents[] = { + { QEMU_PROC_DOMAIN_MONITOR_EVENT, + remoteDomainBuildQemuMonitorEvent, + sizeof(qemu_domain_monitor_event_msg), + (xdrproc_t)xdr_qemu_domain_monitor_event_msg }, +}; + enum virDrvOpenRemoteFlags { VIR_DRV_OPEN_REMOTE_RO = (1 << 0), VIR_DRV_OPEN_REMOTE_USER = (1 << 1), /* Use the per-user socket path */ @@ -975,9 +988,9 @@ doRemoteOpen(virConnectPtr conn, goto failed; if (!(priv->qemuProgram = virNetClientProgramNew(QEMU_PROGRAM, QEMU_PROTOCOL_VERSION, - NULL, - 0, - NULL))) + qemuEvents, + ARRAY_CARDINALITY(qemuEvents), + conn))) goto failed; if (virNetClientAddProgram(priv->client, priv->remoteProgram) < 0 || @@ -3174,6 +3187,103 @@ done: static int +remoteConnectDomainQemuMonitorEventRegister(virConnectPtr conn, + virDomainPtr dom, + const char *event, + virConnectDomainQemuMonitorEventCallback callback, + void *opaque, + virFreeCallback freecb, + unsigned int flags) +{ + int rv = -1; + struct private_data *priv = conn->privateData; + qemu_connect_domain_monitor_event_register_args args; + qemu_connect_domain_monitor_event_register_ret ret; + int callbackID; + int count; + remote_nonnull_domain domain; + + remoteDriverLock(priv); + + if ((count = virDomainQemuMonitorEventStateRegisterID(conn, + priv->eventState, + dom, event, callback, + opaque, freecb, -1, + &callbackID)) < 0) + goto done; + + /* If this is the first callback for this event, we need to enable + * events on the server */ + if (count == 1) { + if (dom) { + make_nonnull_domain(&domain, dom); + args.dom = &domain; + } else { + args.dom = NULL; + } + args.event = event ? (char **) &event : NULL; + args.flags = flags; + + memset(&ret, 0, sizeof(ret)); + if (call(conn, priv, REMOTE_CALL_QEMU, QEMU_PROC_CONNECT_DOMAIN_MONITOR_EVENT_REGISTER, + (xdrproc_t) xdr_qemu_connect_domain_monitor_event_register_args, (char *) &args, + (xdrproc_t) xdr_qemu_connect_domain_monitor_event_register_ret, (char *) &ret) == -1) { + virObjectEventStateDeregisterID(conn, priv->eventState, + callbackID); + goto done; + } + virObjectEventStateSetRemote(conn, priv->eventState, callbackID, + ret.callbackID); + } + + rv = callbackID; + +done: + remoteDriverUnlock(priv); + return rv; +} + + +static int +remoteConnectDomainQemuMonitorEventDeregister(virConnectPtr conn, + int callbackID) +{ + struct private_data *priv = conn->privateData; + int rv = -1; + qemu_connect_domain_monitor_event_deregister_args args; + int remoteID; + int count; + + remoteDriverLock(priv); + + if (virObjectEventStateEventID(conn, priv->eventState, + callbackID, &remoteID) < 0) + goto done; + + if ((count = virObjectEventStateDeregisterID(conn, priv->eventState, + callbackID)) < 0) + goto done; + + /* If that was the last callback for this event, we need to disable + * events on the server */ + if (count == 0) { + args.callbackID = remoteID; + + if (call(conn, priv, REMOTE_CALL_QEMU, QEMU_PROC_CONNECT_DOMAIN_MONITOR_EVENT_DEREGISTER, + (xdrproc_t) xdr_qemu_connect_domain_monitor_event_deregister_args, (char *) &args, + (xdrproc_t) xdr_void, (char *) NULL) == -1) + goto done; + } + + rv = 0; + +done: + remoteDriverUnlock(priv); + return rv; +} + + +static int remoteConnectListAllInterfaces(virConnectPtr conn, virInterfacePtr **ifaces, unsigned int flags) @@ -5408,6 +5518,31 @@ remoteNetworkBuildEventLifecycle(virNetClientProgramPtr prog ATTRIBUTE_UNUSED, } +static void +remoteDomainBuildQemuMonitorEvent(virNetClientProgramPtr prog ATTRIBUTE_UNUSED, + virNetClientPtr client ATTRIBUTE_UNUSED, + void *evdata, void *opaque) +{ + virConnectPtr conn = opaque; + struct private_data *priv = conn->privateData; + qemu_domain_monitor_event_msg *msg = evdata; + virDomainPtr dom; + virObjectEventPtr event = NULL; + + dom = get_nonnull_domain(conn, msg->dom); + if (!dom) + return; + + event = virDomainQemuMonitorEventNew(dom->id, dom->name, dom->uuid, + msg->event, msg->seconds, + msg->micros, + msg->details ? *msg->details : NULL); + virDomainFree(dom); + + remoteEventQueue(priv, event, msg->callbackID); +} + + static virDrvOpenStatus ATTRIBUTE_NONNULL(1) remoteSecretOpen(virConnectPtr conn, virConnectAuthPtr auth, unsigned int flags) @@ -7618,6 +7753,8 @@ static virDriver remote_driver = { .domainQemuMonitorCommand = remoteDomainQemuMonitorCommand, /* 0.8.3 */ .domainQemuAttach = remoteDomainQemuAttach, /* 0.9.4 */ .domainQemuAgentCommand = remoteDomainQemuAgentCommand, /* 0.10.0 */ + .connectDomainQemuMonitorEventRegister = remoteConnectDomainQemuMonitorEventRegister, /* 1.2.3 */ + .connectDomainQemuMonitorEventDeregister = remoteConnectDomainQemuMonitorEventDeregister, /* 1.2.3 */ .domainOpenConsole = remoteDomainOpenConsole, /* 0.8.6 */ .domainOpenChannel = remoteDomainOpenChannel, /* 1.0.2 */ .domainOpenGraphics = remoteDomainOpenGraphics, /* 0.9.7 */ diff --git a/src/rpc/gendispatch.pl b/src/rpc/gendispatch.pl index ceb1ad8..b76bbac 100755 --- a/src/rpc/gendispatch.pl +++ b/src/rpc/gendispatch.pl @@ -1,6 +1,6 @@ #!/usr/bin/perl -w # -# Copyright (C) 2010-2013 Red Hat, Inc. +# Copyright (C) 2010-2014 Red Hat, Inc. # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public @@ -927,8 +927,9 @@ elsif ($mode eq "server") { push(@args_list, "priv->conn"); } - if ($structprefix eq "qemu" && $call->{ProcName} =~ /^Domain/) { - $proc_name =~ s/^(Domain)/${1}Qemu/; + if ($structprefix eq "qemu" && + $call->{ProcName} =~ /^(Connect)?Domain/) { + $proc_name =~ s/^((Connect)?Domain)/${1}Qemu/; } if ($structprefix eq "lxc" && $call->{ProcName} =~ /^Domain/) { $proc_name =~ s/^(Domain)/${1}Lxc/; @@ -1704,7 +1705,7 @@ elsif ($mode eq "client") { if ($mode eq "aclsym") { my $apiname = "vir" . $call->{ProcName}; if ($structprefix eq "qemu") { - $apiname =~ s/virDomain/virDomainQemu/; + $apiname =~ s/(vir(Connect)?Domain)/${1}Qemu/; } elsif ($structprefix eq "lxc") { $apiname =~ s/virDomain/virDomainLxc/; } @@ -1744,7 +1745,7 @@ elsif ($mode eq "client") { my $apiname = "vir" . $call->{ProcName}; if ($structprefix eq "qemu") { - $apiname =~ s/virDomain/virDomainQemu/; + $apiname =~ s/(vir(Connect)?Domain)/${1}Qemu/; } elsif ($structprefix eq "lxc") { $apiname =~ s/virDomain/virDomainLxc/; } @@ -1856,7 +1857,7 @@ elsif ($mode eq "client") { my $apiname = "vir" . $call->{ProcName}; if ($structprefix eq "qemu") { - $apiname =~ s/virDomain/virDomainQemu/; + $apiname =~ s/(vir(Connect)?Domain)/${1}Qemu/; } elsif ($structprefix eq "lxc") { $apiname =~ s/virDomain/virDomainLxc/; } -- 1.8.5.3

Filtering monitor events by name requires tracking the name for the duration of the filtering. In order to free the name, I found it easiest to just piggyback on the user's freecb function, which gets called when the event is deregistered. For events without a name filter, we have the design of multiple client registrations sharing a common server registration, because the server side uses the same callback function and we reject duplicate use of the same function. But with events in the mix, we want to be able to allow the same function pointer to be used with more than one event name. The solution is to tweak the duplicate detection code to only act when there is no additional filtering; if name filtering is in use, there is exactly one client registration per server registration. Yes, this means that there is no longer a bound on the number of server registrations possible, so a malicious client could repeatedly register for the same name event to exhaust server memory. On the other hand, we already restricted monitor events to require write access (compared to normal events only needing read access), and separated it into the intentionally unsupported libvirt-qemu.so, with documentation that using this function is for debug purposes only; so it is not a security risk worth worrying about a client trying to abuse multiple registrations. * src/conf/domain_event.c (virDomainQemuMonitorEventData): New struct. (virDomainQemuMonitorEventFilter) (virDomainQemuMonitorEventCleanup): New functions. (virDomainQemuMonitorEventDispatchFunc) (virDomainQemuMonitorEventStateRegisterID): Use new struct. * src/conf/object_event.c (virObjectEventCallbackListCount) (virObjectEventCallbackListAddID) (virObjectEventCallbackListRemoveID) (virObjectEventCallbackListMarkDeleteID): Drop duplicate detection when filtering is in effect. Signed-off-by: Eric Blake <eblake(a)redhat.com&gt; --- src/conf/domain_event.c | 71 +++++++++++++++++++++++++++++++++++++++++++------ src/conf/object_event.c | 40 ++++++++++++++++++---------- 2 files changed, 89 insertions(+), 22 deletions(-) diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index 01c0ae6..a2880fd 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -1383,6 +1383,18 @@ error: } +/* In order to filter by event name, we need to store a copy of the + * name to filter on. By wrapping the caller's freecb, we can + * piggyback our cleanup to happen at the same time the caller + * deregisters. */ +struct virDomainQemuMonitorEventData { + char *event; + void *opaque; + virFreeCallback freecb; +}; +typedef struct virDomainQemuMonitorEventData virDomainQemuMonitorEventData; + + static void virDomainQemuMonitorEventDispatchFunc(virConnectPtr conn, virObjectEventPtr event, @@ -1391,6 +1403,7 @@ virDomainQemuMonitorEventDispatchFunc(virConnectPtr conn, { virDomainPtr dom = virGetDomain(conn, event->meta.name, event->meta.uuid); virDomainQemuMonitorEventPtr qemuMonitorEvent; + virDomainQemuMonitorEventData *data = cbopaque; if (!dom) return; @@ -1402,7 +1415,7 @@ virDomainQemuMonitorEventDispatchFunc(virConnectPtr conn, qemuMonitorEvent->seconds, qemuMonitorEvent->micros, qemuMonitorEvent->details, - cbopaque); + data->opaque); virDomainFree(dom); } @@ -1577,6 +1590,41 @@ virDomainEventStateDeregister(virConnectPtr conn, /** + * virDomainQemuMonitorEventFilter: + * @conn: the connection pointer + * @event: the event about to be dispatched + * @opaque: the opaque data registered with the filter + * + * Callback for filtering based on event names. Returns true if the + * event should be dispatched. + */ +static bool +virDomainQemuMonitorEventFilter(virConnectPtr conn ATTRIBUTE_UNUSED, + virObjectEventPtr event, + void *opaque) +{ + virDomainQemuMonitorEventData *data = opaque; + virDomainQemuMonitorEventPtr monitorEvent; + + monitorEvent = (virDomainQemuMonitorEventPtr) event; + + return STREQ(monitorEvent->event, data->event); +} + + +static void +virDomainQemuMonitorEventCleanup(void *opaque) +{ + virDomainQemuMonitorEventData *data = opaque; + + VIR_FREE(data->event); + if (data->freecb) + (data->freecb)(data->opaque); + VIR_FREE(data); +} + + +/** * virDomainQemuMonitorEventStateRegisterID: * @conn: connection to associate with callback * @state: object event state @@ -1604,23 +1652,30 @@ virDomainQemuMonitorEventStateRegisterID(virConnectPtr conn, unsigned int flags, int *callbackID) { + virDomainQemuMonitorEventData *data = NULL; + virObjectEventCallbackFilter filter = NULL; + if (virDomainEventsInitialize() < 0) return -1; - /* FIXME support event filtering */ if (flags != -1) virCheckFlags(0, -1); - if (event) { - virReportError(VIR_ERR_INTERNAL_ERROR, - _("event filtering on '%s' not implemented yet"), - event); + if (VIR_ALLOC(data) < 0) + return -1; + if (VIR_STRDUP(data->event, event) < 0) { + VIR_FREE(data); return -1; } + data->opaque = opaque; + data->freecb = freecb; + if (event) + filter = virDomainQemuMonitorEventFilter; + freecb = virDomainQemuMonitorEventCleanup; return virObjectEventStateRegisterID(conn, state, dom ? dom->uuid : NULL, - NULL, NULL, + filter, data, virDomainQemuMonitorEventClass, 0, VIR_OBJECT_EVENT_CALLBACK(cb), - opaque, freecb, + data, freecb, false, callbackID, false); } diff --git a/src/conf/object_event.c b/src/conf/object_event.c index 5ceca8a..1a78fb8 100644 --- a/src/conf/object_event.c +++ b/src/conf/object_event.c @@ -181,6 +181,8 @@ virObjectEventCallbackListCount(virConnectPtr conn, for (i = 0; i < cbList->count; i++) { virObjectEventCallbackPtr cb = cbList->callbacks[i]; + if (cb->filter) + continue; if (cb->klass == klass && cb->eventID == eventID && cb->conn == conn && @@ -216,10 +218,11 @@ virObjectEventCallbackListRemoveID(virConnectPtr conn, if (cb->callbackID == callbackID && cb->conn == conn) { int ret; - ret = virObjectEventCallbackListCount(conn, cbList, cb->klass, - cb->eventID, - cb->uuid_filter ? cb->uuid : NULL, - cb->remoteID >= 0) - 1; + ret = cb->filter ? 0 : + (virObjectEventCallbackListCount(conn, cbList, cb->klass, + cb->eventID, + cb->uuid_filter ? cb->uuid : NULL, + cb->remoteID >= 0) - 1); if (cb->freecb) (*cb->freecb)(cb->opaque); @@ -249,10 +252,11 @@ virObjectEventCallbackListMarkDeleteID(virConnectPtr conn, if (cb->callbackID == callbackID && cb->conn == conn) { cb->deleted = true; - return virObjectEventCallbackListCount(conn, cbList, cb->klass, - cb->eventID, - cb->uuid_filter ? cb->uuid : NULL, - cb->remoteID >= 0); + return cb->filter ? 0 : + virObjectEventCallbackListCount(conn, cbList, cb->klass, + cb->eventID, + cb->uuid_filter ? cb->uuid : NULL, + cb->remoteID >= 0); } } @@ -386,8 +390,10 @@ virObjectEventCallbackListAddID(virConnectPtr conn, return -1; } - /* check if we already have this callback on our list */ - if (virObjectEventCallbackLookup(conn, cbList, uuid, + /* If there is no additional filtering, then check if we already + * have this callback on our list. */ + if (!filter && + virObjectEventCallbackLookup(conn, cbList, uuid, klass, eventID, callback, legacy, serverFilter ? &remoteID : NULL) != -1) { virReportError(VIR_ERR_INVALID_ARG, "%s", @@ -420,10 +426,16 @@ virObjectEventCallbackListAddID(virConnectPtr conn, if (VIR_APPEND_ELEMENT(cbList->callbacks, cbList->count, event) < 0) goto cleanup; - ret = virObjectEventCallbackListCount(conn, cbList, klass, eventID, - uuid, serverFilter); - if (serverFilter && remoteID < 0) - ret++; + /* When additional filtering is being done, every client callback + * is matched to exactly one server callback. */ + if (filter) { + ret = 1; + } else { + ret = virObjectEventCallbackListCount(conn, cbList, klass, eventID, + uuid, serverFilter); + if (serverFilter && remoteID < 0) + ret++; + } cleanup: if (event) -- 1.8.5.3