5:23 p.m.
This work was originally done with the thought that the fix
for CVE-2014-0028 would require server-side filtering to
make the check of connect:search_domains conditional on
whether the user passed NULL or a domain when registering
for an event. The final version of the CVE fix no longer
needs the conditional behavior, so there is no longer a rush
to get this in to 1.2.1; but for 1.2.2, the code changes
offer a nice efficiency gain for the use case of libvirtd
managing lots of domains while a client only cares about
events from a small subset of domains.
While this will not be in 1.2.1 proper, I also tested that
the entire series can be backported without breaking the .so
versioning, if any downstream distro wants to include the
efficiency gain as part of their value added maintenance of
an older version.
Eric Blake (5):
event: dynamically manage server-side RPC domain events
event: server RPC protocol tweaks for domain lifecycle events
event: prepare client to track domain callbackID
event: client RPC protocol tweaks for domain lifecycle events
event: convert remaining domain events to new style
daemon/libvirtd.h | 3 +-
daemon/remote.c | 801 +++++++++++++++++++++++++++++-----------
src/conf/domain_event.c | 78 +++-
src/conf/domain_event.h | 22 ++
src/conf/network_event.c | 6 +-
src/conf/object_event.c | 31 +-
src/conf/object_event_private.h | 6 +-
src/libvirt_internal.h | 7 +-
src/remote/remote_driver.c | 784 ++++++++++++++++++++++++++++++++-------
src/remote/remote_protocol.x | 192 +++++++++-
src/remote_protocol-structs | 92 +++++
11 files changed, 1649 insertions(+), 373 deletions(-)
--
1.8.4.2
5:23 p.m.
New subject: [libvirt] [PATCH 1/5] event: dynamically manage server-side RPC domain events
This patch continues the earlier conversion made for network
events, with a goal of introducing server-side event filtering
in a later patch. Actual behavior is unchanged without
further RPC changes.
* daemon/libvirtd.h (daemonClientPrivate): Alter the tracking of
domain events.
* daemon/remote.c (remoteClientInitHook, remoteClientFreeFunc)
(remoteRelayDomainEvent*)
(remoteDispatchConnectDomainEventRegister)
(remoteDispatchConnectDomainEventRegisterAny): Track domain
callbacks dynamically.
---
daemon/libvirtd.h | 3 +-
daemon/remote.c | 436 +++++++++++++++++++++++++++++++++---------------------
2 files changed, 266 insertions(+), 173 deletions(-)
diff --git a/daemon/libvirtd.h b/daemon/libvirtd.h
index a260ea1..c4f1f27 100644
--- a/daemon/libvirtd.h
+++ b/daemon/libvirtd.h
@@ -51,7 +51,8 @@ struct daemonClientPrivate {
/* Hold while accessing any data except conn */
virMutex lock;
- int domainEventCallbackID[VIR_DOMAIN_EVENT_ID_LAST];
+ daemonClientEventCallbackPtr *domainEventCallbacks;
+ size_t ndomainEventCallbacks;
daemonClientEventCallbackPtr *networkEventCallbacks;
size_t nnetworkEventCallbacks;
diff --git a/daemon/remote.c b/daemon/remote.c
index d2aafbe..f0b9922 100644
--- a/daemon/remote.c
+++ b/daemon/remote.c
@@ -127,19 +127,21 @@ remoteEventCallbackFree(void *opaque)
VIR_FREE(opaque);
}
-static int remoteRelayDomainEventLifecycle(virConnectPtr conn ATTRIBUTE_UNUSED,
- virDomainPtr dom,
- int event,
- int detail,
- void *opaque)
+static int
+remoteRelayDomainEventLifecycle(virConnectPtr conn ATTRIBUTE_UNUSED,
+ virDomainPtr dom,
+ int event,
+ int detail,
+ void *opaque)
{
- virNetServerClientPtr client = opaque;
+ daemonClientEventCallbackPtr callback = opaque;
remote_domain_event_lifecycle_msg data;
- if (!client)
+ if (callback->callbackID < 0)
return -1;
- VIR_DEBUG("Relaying domain lifecycle event %d %d", event, detail);
+ VIR_DEBUG("Relaying domain lifecycle event %d %d, callback %d",
+ event, detail, callback->callbackID);
/* build return data */
memset(&data, 0, sizeof(data));
@@ -147,30 +149,32 @@ static int remoteRelayDomainEventLifecycle(virConnectPtr conn
ATTRIBUTE_UNUSED,
data.event = event;
data.detail = detail;
- remoteDispatchObjectEventSend(client, remoteProgram,
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
REMOTE_PROC_DOMAIN_EVENT_LIFECYCLE,
(xdrproc_t)xdr_remote_domain_event_lifecycle_msg,
&data);
return 0;
}
-static int remoteRelayDomainEventReboot(virConnectPtr conn ATTRIBUTE_UNUSED,
- virDomainPtr dom,
- void *opaque)
+static int
+remoteRelayDomainEventReboot(virConnectPtr conn ATTRIBUTE_UNUSED,
+ virDomainPtr dom,
+ void *opaque)
{
- virNetServerClientPtr client = opaque;
+ daemonClientEventCallbackPtr callback = opaque;
remote_domain_event_reboot_msg data;
- if (!client)
+ if (callback->callbackID < 0)
return -1;
- VIR_DEBUG("Relaying domain reboot event %s %d", dom->name, dom->id);
+ VIR_DEBUG("Relaying domain reboot event %s %d, callback %d",
+ dom->name, dom->id, callback->callbackID);
/* build return data */
memset(&data, 0, sizeof(data));
make_nonnull_domain(&data.dom, dom);
- remoteDispatchObjectEventSend(client, remoteProgram,
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
REMOTE_PROC_DOMAIN_EVENT_REBOOT,
(xdrproc_t)xdr_remote_domain_event_reboot_msg,
&data);
@@ -178,25 +182,27 @@ static int remoteRelayDomainEventReboot(virConnectPtr conn
ATTRIBUTE_UNUSED,
}
-static int remoteRelayDomainEventRTCChange(virConnectPtr conn ATTRIBUTE_UNUSED,
- virDomainPtr dom,
- long long offset,
- void *opaque)
+static int
+remoteRelayDomainEventRTCChange(virConnectPtr conn ATTRIBUTE_UNUSED,
+ virDomainPtr dom,
+ long long offset,
+ void *opaque)
{
- virNetServerClientPtr client = opaque;
+ daemonClientEventCallbackPtr callback = opaque;
remote_domain_event_rtc_change_msg data;
- if (!client)
+ if (callback->callbackID < 0)
return -1;
- VIR_DEBUG("Relaying domain rtc change event %s %d %lld", dom->name,
dom->id, offset);
+ VIR_DEBUG("Relaying domain rtc change event %s %d %lld, callback %d",
+ dom->name, dom->id, offset, callback->callbackID);
/* build return data */
memset(&data, 0, sizeof(data));
make_nonnull_domain(&data.dom, dom);
data.offset = offset;
- remoteDispatchObjectEventSend(client, remoteProgram,
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
REMOTE_PROC_DOMAIN_EVENT_RTC_CHANGE,
(xdrproc_t)xdr_remote_domain_event_rtc_change_msg,
&data);
@@ -204,25 +210,27 @@ static int remoteRelayDomainEventRTCChange(virConnectPtr conn
ATTRIBUTE_UNUSED,
}
-static int remoteRelayDomainEventWatchdog(virConnectPtr conn ATTRIBUTE_UNUSED,
- virDomainPtr dom,
- int action,
- void *opaque)
+static int
+remoteRelayDomainEventWatchdog(virConnectPtr conn ATTRIBUTE_UNUSED,
+ virDomainPtr dom,
+ int action,
+ void *opaque)
{
- virNetServerClientPtr client = opaque;
+ daemonClientEventCallbackPtr callback = opaque;
remote_domain_event_watchdog_msg data;
- if (!client)
+ if (callback->callbackID < 0)
return -1;
- VIR_DEBUG("Relaying domain watchdog event %s %d %d", dom->name,
dom->id, action);
+ VIR_DEBUG("Relaying domain watchdog event %s %d %d, callback %d",
+ dom->name, dom->id, action, callback->callbackID);
/* build return data */
memset(&data, 0, sizeof(data));
make_nonnull_domain(&data.dom, dom);
data.action = action;
- remoteDispatchObjectEventSend(client, remoteProgram,
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
REMOTE_PROC_DOMAIN_EVENT_WATCHDOG,
(xdrproc_t)xdr_remote_domain_event_watchdog_msg,
&data);
@@ -230,20 +238,23 @@ static int remoteRelayDomainEventWatchdog(virConnectPtr conn
ATTRIBUTE_UNUSED,
}
-static int remoteRelayDomainEventIOError(virConnectPtr conn ATTRIBUTE_UNUSED,
- virDomainPtr dom,
- const char *srcPath,
- const char *devAlias,
- int action,
- void *opaque)
+static int
+remoteRelayDomainEventIOError(virConnectPtr conn ATTRIBUTE_UNUSED,
+ virDomainPtr dom,
+ const char *srcPath,
+ const char *devAlias,
+ int action,
+ void *opaque)
{
- virNetServerClientPtr client = opaque;
+ daemonClientEventCallbackPtr callback = opaque;
remote_domain_event_io_error_msg data;
- if (!client)
+ if (callback->callbackID < 0)
return -1;
- VIR_DEBUG("Relaying domain io error %s %d %s %s %d", dom->name,
dom->id, srcPath, devAlias, action);
+ VIR_DEBUG("Relaying domain io error %s %d %s %s %d, callback %d",
+ dom->name, dom->id, srcPath, devAlias, action,
+ callback->callbackID);
/* build return data */
memset(&data, 0, sizeof(data));
@@ -253,7 +264,7 @@ static int remoteRelayDomainEventIOError(virConnectPtr conn
ATTRIBUTE_UNUSED,
make_nonnull_domain(&data.dom, dom);
data.action = action;
- remoteDispatchObjectEventSend(client, remoteProgram,
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
REMOTE_PROC_DOMAIN_EVENT_IO_ERROR,
(xdrproc_t)xdr_remote_domain_event_io_error_msg,
&data);
@@ -265,22 +276,24 @@ error:
}
-static int remoteRelayDomainEventIOErrorReason(virConnectPtr conn ATTRIBUTE_UNUSED,
- virDomainPtr dom,
- const char *srcPath,
- const char *devAlias,
- int action,
- const char *reason,
- void *opaque)
+static int
+remoteRelayDomainEventIOErrorReason(virConnectPtr conn ATTRIBUTE_UNUSED,
+ virDomainPtr dom,
+ const char *srcPath,
+ const char *devAlias,
+ int action,
+ const char *reason,
+ void *opaque)
{
- virNetServerClientPtr client = opaque;
+ daemonClientEventCallbackPtr callback = opaque;
remote_domain_event_io_error_reason_msg data;
- if (!client)
+ if (callback->callbackID < 0)
return -1;
- VIR_DEBUG("Relaying domain io error %s %d %s %s %d %s",
- dom->name, dom->id, srcPath, devAlias, action, reason);
+ VIR_DEBUG("Relaying domain io error %s %d %s %s %d %s, callback %d",
+ dom->name, dom->id, srcPath, devAlias, action, reason,
+ callback->callbackID);
/* build return data */
memset(&data, 0, sizeof(data));
@@ -292,7 +305,7 @@ static int remoteRelayDomainEventIOErrorReason(virConnectPtr conn
ATTRIBUTE_UNUS
make_nonnull_domain(&data.dom, dom);
- remoteDispatchObjectEventSend(client, remoteProgram,
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
REMOTE_PROC_DOMAIN_EVENT_IO_ERROR_REASON,
(xdrproc_t)xdr_remote_domain_event_io_error_reason_msg,
&data);
@@ -306,26 +319,28 @@ error:
}
-static int remoteRelayDomainEventGraphics(virConnectPtr conn ATTRIBUTE_UNUSED,
- virDomainPtr dom,
- int phase,
- virDomainEventGraphicsAddressPtr local,
- virDomainEventGraphicsAddressPtr remote,
- const char *authScheme,
- virDomainEventGraphicsSubjectPtr subject,
- void *opaque)
+static int
+remoteRelayDomainEventGraphics(virConnectPtr conn ATTRIBUTE_UNUSED,
+ virDomainPtr dom,
+ int phase,
+ virDomainEventGraphicsAddressPtr local,
+ virDomainEventGraphicsAddressPtr remote,
+ const char *authScheme,
+ virDomainEventGraphicsSubjectPtr subject,
+ void *opaque)
{
- virNetServerClientPtr client = opaque;
+ daemonClientEventCallbackPtr callback = opaque;
remote_domain_event_graphics_msg data;
size_t i;
- if (!client)
+ if (callback->callbackID < 0)
return -1;
- VIR_DEBUG("Relaying domain graphics event %s %d %d - %d %s %s - %d %s %s -
%s", dom->name, dom->id, phase,
+ VIR_DEBUG("Relaying domain graphics event %s %d %d - %d %s %s - %d %s %s - %s,
callback %d",
+ dom->name, dom->id, phase,
local->family, local->service, local->node,
remote->family, remote->service, remote->node,
- authScheme);
+ authScheme, callback->callbackID);
VIR_DEBUG("Subject %d", subject->nidentity);
for (i = 0; i < subject->nidentity; i++) {
@@ -355,7 +370,7 @@ static int remoteRelayDomainEventGraphics(virConnectPtr conn
ATTRIBUTE_UNUSED,
}
make_nonnull_domain(&data.dom, dom);
- remoteDispatchObjectEventSend(client, remoteProgram,
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
REMOTE_PROC_DOMAIN_EVENT_GRAPHICS,
(xdrproc_t)xdr_remote_domain_event_graphics_msg,
&data);
@@ -377,21 +392,22 @@ error:
return -1;
}
-static int remoteRelayDomainEventBlockJob(virConnectPtr conn ATTRIBUTE_UNUSED,
- virDomainPtr dom,
- const char *path,
- int type,
- int status,
- void *opaque)
+static int
+remoteRelayDomainEventBlockJob(virConnectPtr conn ATTRIBUTE_UNUSED,
+ virDomainPtr dom,
+ const char *path,
+ int type,
+ int status,
+ void *opaque)
{
- virNetServerClientPtr client = opaque;
+ daemonClientEventCallbackPtr callback = opaque;
remote_domain_event_block_job_msg data;
- if (!client)
+ if (callback->callbackID < 0)
return -1;
- VIR_DEBUG("Relaying domain block job event %s %d %s %i, %i",
- dom->name, dom->id, path, type, status);
+ VIR_DEBUG("Relaying domain block job event %s %d %s %i, %i, callback %d",
+ dom->name, dom->id, path, type, status, callback->callbackID);
/* build return data */
memset(&data, 0, sizeof(data));
@@ -401,7 +417,7 @@ static int remoteRelayDomainEventBlockJob(virConnectPtr conn
ATTRIBUTE_UNUSED,
data.status = status;
make_nonnull_domain(&data.dom, dom);
- remoteDispatchObjectEventSend(client, remoteProgram,
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
REMOTE_PROC_DOMAIN_EVENT_BLOCK_JOB,
(xdrproc_t)xdr_remote_domain_event_block_job_msg,
&data);
@@ -412,23 +428,25 @@ error:
}
-static int remoteRelayDomainEventControlError(virConnectPtr conn ATTRIBUTE_UNUSED,
- virDomainPtr dom,
- void *opaque)
+static int
+remoteRelayDomainEventControlError(virConnectPtr conn ATTRIBUTE_UNUSED,
+ virDomainPtr dom,
+ void *opaque)
{
- virNetServerClientPtr client = opaque;
+ daemonClientEventCallbackPtr callback = opaque;
remote_domain_event_control_error_msg data;
- if (!client)
+ if (callback->callbackID < 0)
return -1;
- VIR_DEBUG("Relaying domain control error %s %d", dom->name,
dom->id);
+ VIR_DEBUG("Relaying domain control error %s %d, callback %d",
+ dom->name, dom->id, callback->callbackID);
/* build return data */
memset(&data, 0, sizeof(data));
make_nonnull_domain(&data.dom, dom);
- remoteDispatchObjectEventSend(client, remoteProgram,
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
REMOTE_PROC_DOMAIN_EVENT_CONTROL_ERROR,
(xdrproc_t)xdr_remote_domain_event_control_error_msg,
&data);
@@ -436,23 +454,25 @@ static int remoteRelayDomainEventControlError(virConnectPtr conn
ATTRIBUTE_UNUSE
}
-static int remoteRelayDomainEventDiskChange(virConnectPtr conn ATTRIBUTE_UNUSED,
- virDomainPtr dom,
- const char *oldSrcPath,
- const char *newSrcPath,
- const char *devAlias,
- int reason,
- void *opaque)
+static int
+remoteRelayDomainEventDiskChange(virConnectPtr conn ATTRIBUTE_UNUSED,
+ virDomainPtr dom,
+ const char *oldSrcPath,
+ const char *newSrcPath,
+ const char *devAlias,
+ int reason,
+ void *opaque)
{
- virNetServerClientPtr client = opaque;
+ daemonClientEventCallbackPtr callback = opaque;
remote_domain_event_disk_change_msg data;
char **oldSrcPath_p = NULL, **newSrcPath_p = NULL;
- if (!client)
+ if (callback->callbackID < 0)
return -1;
- VIR_DEBUG("Relaying domain %s %d disk change %s %s %s %d",
- dom->name, dom->id, oldSrcPath, newSrcPath, devAlias, reason);
+ VIR_DEBUG("Relaying domain %s %d disk change %s %s %s %d, callback %d",
+ dom->name, dom->id, oldSrcPath, newSrcPath, devAlias, reason,
+ callback->callbackID);
/* build return data */
memset(&data, 0, sizeof(data));
@@ -474,7 +494,7 @@ static int remoteRelayDomainEventDiskChange(virConnectPtr conn
ATTRIBUTE_UNUSED,
make_nonnull_domain(&data.dom, dom);
- remoteDispatchObjectEventSend(client, remoteProgram,
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
REMOTE_PROC_DOMAIN_EVENT_DISK_CHANGE,
(xdrproc_t)xdr_remote_domain_event_disk_change_msg,
&data);
@@ -487,19 +507,21 @@ error:
}
-static int remoteRelayDomainEventTrayChange(virConnectPtr conn ATTRIBUTE_UNUSED,
- virDomainPtr dom,
- const char *devAlias,
- int reason,
- void *opaque) {
- virNetServerClientPtr client = opaque;
+static int
+remoteRelayDomainEventTrayChange(virConnectPtr conn ATTRIBUTE_UNUSED,
+ virDomainPtr dom,
+ const char *devAlias,
+ int reason,
+ void *opaque)
+{
+ daemonClientEventCallbackPtr callback = opaque;
remote_domain_event_tray_change_msg data;
- if (!client)
+ if (callback->callbackID < 0)
return -1;
- VIR_DEBUG("Relaying domain %s %d tray change devAlias: %s reason: %d",
- dom->name, dom->id, devAlias, reason);
+ VIR_DEBUG("Relaying domain %s %d tray change devAlias: %s reason: %d, callback
%d",
+ dom->name, dom->id, devAlias, reason, callback->callbackID);
/* build return data */
memset(&data, 0, sizeof(data));
@@ -510,53 +532,59 @@ static int remoteRelayDomainEventTrayChange(virConnectPtr conn
ATTRIBUTE_UNUSED,
make_nonnull_domain(&data.dom, dom);
- remoteDispatchObjectEventSend(client, remoteProgram,
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
REMOTE_PROC_DOMAIN_EVENT_TRAY_CHANGE,
(xdrproc_t)xdr_remote_domain_event_tray_change_msg,
&data);
return 0;
}
-static int remoteRelayDomainEventPMWakeup(virConnectPtr conn ATTRIBUTE_UNUSED,
- virDomainPtr dom,
- int reason ATTRIBUTE_UNUSED,
- void *opaque) {
- virNetServerClientPtr client = opaque;
+static int
+remoteRelayDomainEventPMWakeup(virConnectPtr conn ATTRIBUTE_UNUSED,
+ virDomainPtr dom,
+ int reason ATTRIBUTE_UNUSED,
+ void *opaque)
+{
+ daemonClientEventCallbackPtr callback = opaque;
remote_domain_event_pmwakeup_msg data;
- if (!client)
+ if (callback->callbackID < 0)
return -1;
- VIR_DEBUG("Relaying domain %s %d system pmwakeup", dom->name,
dom->id);
+ VIR_DEBUG("Relaying domain %s %d system pmwakeup, callback %d",
+ dom->name, dom->id, callback->callbackID);
/* build return data */
memset(&data, 0, sizeof(data));
make_nonnull_domain(&data.dom, dom);
- remoteDispatchObjectEventSend(client, remoteProgram,
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
REMOTE_PROC_DOMAIN_EVENT_PMWAKEUP,
(xdrproc_t)xdr_remote_domain_event_pmwakeup_msg,
&data);
return 0;
}
-static int remoteRelayDomainEventPMSuspend(virConnectPtr conn ATTRIBUTE_UNUSED,
- virDomainPtr dom,
- int reason ATTRIBUTE_UNUSED,
- void *opaque) {
- virNetServerClientPtr client = opaque;
+static int
+remoteRelayDomainEventPMSuspend(virConnectPtr conn ATTRIBUTE_UNUSED,
+ virDomainPtr dom,
+ int reason ATTRIBUTE_UNUSED,
+ void *opaque)
+{
+ daemonClientEventCallbackPtr callback = opaque;
remote_domain_event_pmsuspend_msg data;
- if (!client)
+ if (callback->callbackID < 0)
return -1;
- VIR_DEBUG("Relaying domain %s %d system pmsuspend", dom->name,
dom->id);
+ VIR_DEBUG("Relaying domain %s %d system pmsuspend, callback %d",
+ dom->name, dom->id, callback->callbackID);
/* build return data */
memset(&data, 0, sizeof(data));
make_nonnull_domain(&data.dom, dom);
- remoteDispatchObjectEventSend(client, remoteProgram,
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
REMOTE_PROC_DOMAIN_EVENT_PMSUSPEND,
(xdrproc_t)xdr_remote_domain_event_pmsuspend_msg,
&data);
@@ -569,20 +597,21 @@ remoteRelayDomainEventBalloonChange(virConnectPtr conn
ATTRIBUTE_UNUSED,
unsigned long long actual,
void *opaque)
{
- virNetServerClientPtr client = opaque;
+ daemonClientEventCallbackPtr callback = opaque;
remote_domain_event_balloon_change_msg data;
- if (!client)
+ if (callback->callbackID < 0)
return -1;
- VIR_DEBUG("Relaying domain balloon change event %s %d %lld", dom->name,
dom->id, actual);
+ VIR_DEBUG("Relaying domain balloon change event %s %d %lld, callback %d",
+ dom->name, dom->id, actual, callback->callbackID);
/* build return data */
memset(&data, 0, sizeof(data));
make_nonnull_domain(&data.dom, dom);
data.actual = actual;
- remoteDispatchObjectEventSend(client, remoteProgram,
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
REMOTE_PROC_DOMAIN_EVENT_BALLOON_CHANGE,
(xdrproc_t)xdr_remote_domain_event_balloon_change_msg,
&data);
@@ -590,23 +619,26 @@ remoteRelayDomainEventBalloonChange(virConnectPtr conn
ATTRIBUTE_UNUSED,
}
-static int remoteRelayDomainEventPMSuspendDisk(virConnectPtr conn ATTRIBUTE_UNUSED,
- virDomainPtr dom,
- int reason ATTRIBUTE_UNUSED,
- void *opaque) {
- virNetServerClientPtr client = opaque;
+static int
+remoteRelayDomainEventPMSuspendDisk(virConnectPtr conn ATTRIBUTE_UNUSED,
+ virDomainPtr dom,
+ int reason ATTRIBUTE_UNUSED,
+ void *opaque)
+{
+ daemonClientEventCallbackPtr callback = opaque;
remote_domain_event_pmsuspend_disk_msg data;
- if (!client)
+ if (callback->callbackID < 0)
return -1;
- VIR_DEBUG("Relaying domain %s %d system pmsuspend-disk", dom->name,
dom->id);
+ VIR_DEBUG("Relaying domain %s %d system pmsuspend-disk, callback %d",
+ dom->name, dom->id, callback->callbackID);
/* build return data */
memset(&data, 0, sizeof(data));
make_nonnull_domain(&data.dom, dom);
- remoteDispatchObjectEventSend(client, remoteProgram,
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
REMOTE_PROC_DOMAIN_EVENT_PMSUSPEND_DISK,
(xdrproc_t)xdr_remote_domain_event_pmsuspend_disk_msg,
&data);
@@ -619,14 +651,14 @@ remoteRelayDomainEventDeviceRemoved(virConnectPtr conn
ATTRIBUTE_UNUSED,
const char *devAlias,
void *opaque)
{
- virNetServerClientPtr client = opaque;
+ daemonClientEventCallbackPtr callback = opaque;
remote_domain_event_device_removed_msg data;
- if (!client)
+ if (callback->callbackID < 0)
return -1;
- VIR_DEBUG("Relaying domain device removed event %s %d %s",
- dom->name, dom->id, devAlias);
+ VIR_DEBUG("Relaying domain device removed event %s %d %s, callback %d",
+ dom->name, dom->id, devAlias, callback->callbackID);
/* build return data */
memset(&data, 0, sizeof(data));
@@ -636,7 +668,7 @@ remoteRelayDomainEventDeviceRemoved(virConnectPtr conn
ATTRIBUTE_UNUSED,
make_nonnull_domain(&data.dom, dom);
- remoteDispatchObjectEventSend(client, remoteProgram,
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
REMOTE_PROC_DOMAIN_EVENT_DEVICE_REMOVED,
(xdrproc_t)xdr_remote_domain_event_device_removed_msg,
&data);
@@ -720,14 +752,19 @@ void remoteClientFreeFunc(void *data)
virIdentitySetCurrent(sysident);
- for (i = 0; i < VIR_DOMAIN_EVENT_ID_LAST; i++) {
- if (priv->domainEventCallbackID[i] != -1) {
- VIR_DEBUG("Deregistering to relay remote events %zu", i);
- virConnectDomainEventDeregisterAny(priv->conn,
- priv->domainEventCallbackID[i]);
+ for (i = 0; i < priv->ndomainEventCallbacks; i++) {
+ int callbackID = priv->domainEventCallbacks[i]->callbackID;
+ if (callbackID < 0) {
+ VIR_WARN("unexpected incomplete domain callback %zu", i);
+ continue;
}
- priv->domainEventCallbackID[i] = -1;
+ VIR_DEBUG("Deregistering remote domain event relay %d",
+ callbackID);
+ priv->domainEventCallbacks[i]->callbackID = -1;
+ if (virConnectDomainEventDeregisterAny(priv->conn, callbackID) < 0)
+ VIR_WARN("unexpected domain event deregister failure");
}
+ VIR_FREE(priv->domainEventCallbacks);
for (i = 0; i < priv->nnetworkEventCallbacks; i++) {
int callbackID = priv->networkEventCallbacks[i]->callbackID;
@@ -766,7 +803,6 @@ void *remoteClientInitHook(virNetServerClientPtr client,
void *opaque ATTRIBUTE_UNUSED)
{
struct daemonClientPrivate *priv;
- size_t i;
if (VIR_ALLOC(priv) < 0)
return NULL;
@@ -777,9 +813,6 @@ void *remoteClientInitHook(virNetServerClientPtr client,
return NULL;
}
- for (i = 0; i < VIR_DOMAIN_EVENT_ID_LAST; i++)
- priv->domainEventCallbackID[i] = -1;
-
virNetServerClientSetCloseHook(client, remoteClientCloseFunc);
return priv;
}
@@ -3143,13 +3176,15 @@ cleanup:
***************************/
static int
remoteDispatchConnectDomainEventRegister(virNetServerPtr server ATTRIBUTE_UNUSED,
- virNetServerClientPtr client ATTRIBUTE_UNUSED,
+ virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr ATTRIBUTE_UNUSED,
remote_connect_domain_event_register_ret *ret
ATTRIBUTE_UNUSED)
{
int callbackID;
int rv = -1;
+ daemonClientEventCallbackPtr callback = NULL;
+ daemonClientEventCallbackPtr ref;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
@@ -3160,23 +3195,41 @@ remoteDispatchConnectDomainEventRegister(virNetServerPtr server
ATTRIBUTE_UNUSED
virMutexLock(&priv->lock);
- if (priv->domainEventCallbackID[VIR_DOMAIN_EVENT_ID_LIFECYCLE] != -1) {
- virReportError(VIR_ERR_INTERNAL_ERROR, _("domain event %d already
registered"), VIR_DOMAIN_EVENT_ID_LIFECYCLE);
+ /* 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->eventID = VIR_DOMAIN_EVENT_ID_LIFECYCLE;
+ callback->callbackID = -1;
+ ref = callback;
+ if (VIR_APPEND_ELEMENT(priv->domainEventCallbacks,
+ priv->ndomainEventCallbacks,
+ callback) < 0)
goto cleanup;
- }
if ((callbackID = virConnectDomainEventRegisterAny(priv->conn,
NULL,
VIR_DOMAIN_EVENT_ID_LIFECYCLE,
VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventLifecycle),
- client, NULL)) < 0)
+ ref,
+ remoteEventCallbackFree)) < 0)
{
+ VIR_SHRINK_N(priv->domainEventCallbacks,
+ priv->ndomainEventCallbacks, 1);
+ callback = ref;
goto cleanup;
+ }
- priv->domainEventCallbackID[VIR_DOMAIN_EVENT_ID_LIFECYCLE] = callbackID;
+ ref->callbackID = callbackID;
rv = 0;
cleanup:
+ VIR_FREE(callback);
if (rv < 0)
virNetMessageSaveError(rerr);
virMutexUnlock(&priv->lock);
@@ -3185,12 +3238,14 @@ cleanup:
static int
remoteDispatchConnectDomainEventDeregister(virNetServerPtr server ATTRIBUTE_UNUSED,
- virNetServerClientPtr client
ATTRIBUTE_UNUSED,
+ virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr ATTRIBUTE_UNUSED,
remote_connect_domain_event_deregister_ret
*ret ATTRIBUTE_UNUSED)
{
+ int callbackID = -1;
int rv = -1;
+ size_t i;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
@@ -3201,16 +3256,25 @@ remoteDispatchConnectDomainEventDeregister(virNetServerPtr server
ATTRIBUTE_UNUS
virMutexLock(&priv->lock);
- if (priv->domainEventCallbackID[VIR_DOMAIN_EVENT_ID_LIFECYCLE] < 0) {
- virReportError(VIR_ERR_INTERNAL_ERROR, _("domain event %d not
registered"), VIR_DOMAIN_EVENT_ID_LIFECYCLE);
+ for (i = 0; i < priv->ndomainEventCallbacks; i++) {
+ if (priv->domainEventCallbacks[i]->eventID ==
VIR_DOMAIN_EVENT_ID_LIFECYCLE) {
+ callbackID = priv->domainEventCallbacks[i]->callbackID;
+ break;
+ }
+ }
+
+ if (callbackID < 0) {
+ virReportError(VIR_ERR_INTERNAL_ERROR,
+ _("domain event %d not registered"),
+ VIR_DOMAIN_EVENT_ID_LIFECYCLE);
goto cleanup;
}
- if (virConnectDomainEventDeregisterAny(priv->conn,
-
priv->domainEventCallbackID[VIR_DOMAIN_EVENT_ID_LIFECYCLE]) < 0)
+ if (virConnectDomainEventDeregisterAny(priv->conn, callbackID) < 0)
goto cleanup;
- priv->domainEventCallbackID[VIR_DOMAIN_EVENT_ID_LIFECYCLE] = -1;
+ VIR_DELETE_ELEMENT(priv->domainEventCallbacks, i,
+ priv->ndomainEventCallbacks);
rv = 0;
@@ -3332,13 +3396,15 @@ cleanup:
static int
remoteDispatchConnectDomainEventRegisterAny(virNetServerPtr server ATTRIBUTE_UNUSED,
- virNetServerClientPtr client
ATTRIBUTE_UNUSED,
+ virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr ATTRIBUTE_UNUSED,
remote_connect_domain_event_register_any_args
*args)
{
int callbackID;
int rv = -1;
+ daemonClientEventCallbackPtr callback = NULL;
+ daemonClientEventCallbackPtr ref;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
@@ -3355,23 +3421,41 @@ remoteDispatchConnectDomainEventRegisterAny(virNetServerPtr server
ATTRIBUTE_UNU
goto cleanup;
}
- if (priv->domainEventCallbackID[args->eventID] != -1) {
- virReportError(VIR_ERR_INTERNAL_ERROR, _("domain event %d already
registered"), args->eventID);
+ /* 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->eventID = args->eventID;
+ callback->callbackID = -1;
+ ref = callback;
+ if (VIR_APPEND_ELEMENT(priv->domainEventCallbacks,
+ priv->ndomainEventCallbacks,
+ callback) < 0)
goto cleanup;
- }
if ((callbackID = virConnectDomainEventRegisterAny(priv->conn,
NULL,
args->eventID,
domainEventCallbacks[args->eventID],
- client, NULL)) < 0)
+ ref,
+ remoteEventCallbackFree)) < 0)
{
+ VIR_SHRINK_N(priv->domainEventCallbacks,
+ priv->ndomainEventCallbacks, 1);
+ callback = ref;
goto cleanup;
+ }
- priv->domainEventCallbackID[args->eventID] = callbackID;
+ ref->callbackID = callbackID;
rv = 0;
cleanup:
+ VIR_FREE(callback);
if (rv < 0)
virNetMessageSaveError(rerr);
virMutexUnlock(&priv->lock);
@@ -3381,13 +3465,14 @@ cleanup:
static int
remoteDispatchConnectDomainEventDeregisterAny(virNetServerPtr server ATTRIBUTE_UNUSED,
- virNetServerClientPtr client
ATTRIBUTE_UNUSED,
+ virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
virNetMessageErrorPtr rerr
ATTRIBUTE_UNUSED,
remote_connect_domain_event_deregister_any_args *args)
{
int callbackID = -1;
int rv = -1;
+ size_t i;
struct daemonClientPrivate *priv =
virNetServerClientGetPrivateData(client);
@@ -3404,16 +3489,23 @@ remoteDispatchConnectDomainEventDeregisterAny(virNetServerPtr
server ATTRIBUTE_U
goto cleanup;
}
- callbackID = priv->domainEventCallbackID[args->eventID];
+ for (i = 0; i < priv->ndomainEventCallbacks; i++) {
+ if (priv->domainEventCallbacks[i]->eventID == args->eventID) {
+ callbackID = priv->domainEventCallbacks[i]->callbackID;
+ break;
+ }
+ }
if (callbackID < 0) {
- virReportError(VIR_ERR_INTERNAL_ERROR, _("domain event %d not
registered"), args->eventID);
+ virReportError(VIR_ERR_INTERNAL_ERROR,
+ _("domain event %d not registered"), args->eventID);
goto cleanup;
}
if (virConnectDomainEventDeregisterAny(priv->conn, callbackID) < 0)
goto cleanup;
- priv->domainEventCallbackID[args->eventID] = -1;
+ VIR_DELETE_ELEMENT(priv->domainEventCallbacks, i,
+ priv->ndomainEventCallbacks);
rv = 0;
--
1.8.4.2
5:23 p.m.
New subject: [libvirt] [PATCH 2/5] event: server RPC protocol tweaks for domain lifecycle events
This patch adds some new RPC call numbers, but for ease of review,
they sit idle until a later patch adds the client counterpart to
drive the new RPCs. Also for ease of review, I limited this patch
to just the lifecycle event; although converting the remaining
15 domain events will be quite mechanical. On the server side,
we have to have a function per RPC call, largely with duplicated
bodies (the key difference being that we store in our callback
opaque pointer whether events should be fired with old or new
style); meanwhile, a single function can drive multiple RPC
messages, along with a strategic choice of XDR struct layout,
makes the event generation code for both styles fairly compact.
I debated about adding a tri-state witness variable per
connection (values 'unknown', 'legacy', 'modern'). It would
start
as 'unknown', move to 'legacy' if any RPC call is made to a legacy
event call, and move to 'modern' if the feature probe is made;
then the event code could issue an error if the witness state is
incorrect (a legacy RPC call while in 'modern', a modern RPC call
while in 'unknown' or 'legacy', and a feature probe while in
'legacy' or 'modern'). But while it might prevent odd behavior
caused by protocol fuzzing, I don't see that it would prevent
any security holes, so I considered it bloat.
* src/libvirt_internal.h (VIR_DRV_FEATURE_REMOTE_EVENT_CALLBACK):
New feature.
* src/remote/remote_protocol.x
(REMOTE_PROC_CONNECT_DOMAIN_EVENT_CALLBACK_REGISTER_ANY)
(REMOTE_PROC_CONNECT_DOMAIN_EVENT_CALLBACK_DEREGISTER_ANY)
(REMOTE_PROC_DOMAIN_EVENT_CALLBACK_LIFECYCLE): New RPCs.
* daemon/remote.c (daemonClientCallback): Add field.
(remoteDispatchConnectDomainEventCallbackRegisterAny)
(remoteDispatchConnectDomainEventCallbackDeregisterAny): New
functions.
(remoteDispatchConnectDomainEventRegisterAny)
(remoteDispatchConnectDomainEventDeregisterAny): Mark legacy use.
(remoteRelayDomainEventLifecycle): Change message based on legacy
or new use.
(remoteDispatchConnectSupportsFeature): Advertise new feature.
* src/remote_protocol-structs: Regenerate.
Signed-off-by: Eric Blake <eblake(a)redhat.com>
---
daemon/remote.c | 173 ++++++++++++++++++++++++++++++++++++++++---
src/libvirt_internal.h | 7 +-
src/remote/remote_protocol.x | 39 +++++++++-
src/remote_protocol-structs | 17 +++++
4 files changed, 225 insertions(+), 11 deletions(-)
diff --git a/daemon/remote.c b/daemon/remote.c
index f0b9922..05fb708 100644
--- a/daemon/remote.c
+++ b/daemon/remote.c
@@ -76,6 +76,7 @@ struct daemonClientEventCallback {
virNetServerClientPtr client;
int eventID;
int callbackID;
+ bool legacy;
};
static virDomainPtr get_nonnull_domain(virConnectPtr conn, remote_nonnull_domain
domain);
@@ -140,8 +141,8 @@ remoteRelayDomainEventLifecycle(virConnectPtr conn ATTRIBUTE_UNUSED,
if (callback->callbackID < 0)
return -1;
- VIR_DEBUG("Relaying domain lifecycle event %d %d, callback %d",
- event, detail, callback->callbackID);
+ VIR_DEBUG("Relaying domain lifecycle event %d %d, callback %d legacy %d",
+ event, detail, callback->callbackID, callback->legacy);
/* build return data */
memset(&data, 0, sizeof(data));
@@ -149,9 +150,20 @@ remoteRelayDomainEventLifecycle(virConnectPtr conn ATTRIBUTE_UNUSED,
data.event = event;
data.detail = detail;
- remoteDispatchObjectEventSend(callback->client, remoteProgram,
- REMOTE_PROC_DOMAIN_EVENT_LIFECYCLE,
- (xdrproc_t)xdr_remote_domain_event_lifecycle_msg,
&data);
+ if (callback->legacy) {
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
+ REMOTE_PROC_DOMAIN_EVENT_LIFECYCLE,
+ (xdrproc_t)xdr_remote_domain_event_lifecycle_msg,
+ &data);
+ } else {
+ remote_domain_event_callback_lifecycle_msg msg = { callback->callbackID,
+ data };
+
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_LIFECYCLE,
+
(xdrproc_t)xdr_remote_domain_event_callback_lifecycle_msg,
+ &msg);
+ }
return 0;
}
@@ -3206,6 +3218,7 @@ remoteDispatchConnectDomainEventRegister(virNetServerPtr server
ATTRIBUTE_UNUSED
callback->client = client;
callback->eventID = VIR_DOMAIN_EVENT_ID_LIFECYCLE;
callback->callbackID = -1;
+ callback->legacy = true;
ref = callback;
if (VIR_APPEND_ELEMENT(priv->domainEventCallbacks,
priv->ndomainEventCallbacks,
@@ -3394,6 +3407,12 @@ cleanup:
return rv;
}
+
+/* Due to back-compat reasons, two RPC calls map to the same libvirt
+ * API of virConnectDomainEventRegisterAny. A client should only use
+ * the new call if they have probed
+ * VIR_DRV_SUPPORTS_FEATURE(VIR_DRV_FEATURE_REMOTE_EVENT_CALLBACK),
+ * and must not mix the two styles. */
static int
remoteDispatchConnectDomainEventRegisterAny(virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
@@ -3415,9 +3434,13 @@ remoteDispatchConnectDomainEventRegisterAny(virNetServerPtr server
ATTRIBUTE_UNU
virMutexLock(&priv->lock);
- if (args->eventID >= VIR_DOMAIN_EVENT_ID_LAST ||
+ /* We intentionally do not use VIR_DOMAIN_EVENT_ID_LAST here; any
+ * new domain events added after this point should only use the
+ * modern callback style of RPC. */
+ if (args->eventID > VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED ||
args->eventID < 0) {
- virReportError(VIR_ERR_INTERNAL_ERROR, _("unsupported event ID %d"),
args->eventID);
+ virReportError(VIR_ERR_INTERNAL_ERROR, _("unsupported event ID %d"),
+ args->eventID);
goto cleanup;
}
@@ -3432,6 +3455,7 @@ remoteDispatchConnectDomainEventRegisterAny(virNetServerPtr server
ATTRIBUTE_UNU
callback->client = client;
callback->eventID = args->eventID;
callback->callbackID = -1;
+ callback->legacy = true;
ref = callback;
if (VIR_APPEND_ELEMENT(priv->domainEventCallbacks,
priv->ndomainEventCallbacks,
@@ -3464,6 +3488,85 @@ cleanup:
static int
+remoteDispatchConnectDomainEventCallbackRegisterAny(virNetServerPtr server
ATTRIBUTE_UNUSED,
+ virNetServerClientPtr client,
+ virNetMessagePtr msg
ATTRIBUTE_UNUSED,
+ virNetMessageErrorPtr rerr
ATTRIBUTE_UNUSED,
+
remote_connect_domain_event_callback_register_any_args *args,
+
remote_connect_domain_event_callback_register_any_ret *ret)
+{
+ int callbackID;
+ int rv = -1;
+ daemonClientEventCallbackPtr callback = NULL;
+ daemonClientEventCallbackPtr ref;
+ struct daemonClientPrivate *priv =
+ virNetServerClientGetPrivateData(client);
+ virDomainPtr dom = 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;
+
+ /* FIXME: support all domain events */
+ if (args->eventID != VIR_DOMAIN_EVENT_ID_LIFECYCLE) {
+ virReportError(VIR_ERR_INTERNAL_ERROR, _("unsupported event ID %d"),
+ args->eventID);
+ 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->eventID = args->eventID;
+ callback->callbackID = -1;
+ ref = callback;
+ if (VIR_APPEND_ELEMENT(priv->domainEventCallbacks,
+ priv->ndomainEventCallbacks,
+ callback) < 0)
+ goto cleanup;
+
+ if ((callbackID = virConnectDomainEventRegisterAny(priv->conn,
+ dom,
+ args->eventID,
+
domainEventCallbacks[args->eventID],
+ ref,
+ remoteEventCallbackFree)) < 0)
{
+ VIR_SHRINK_N(priv->domainEventCallbacks,
+ priv->ndomainEventCallbacks, 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
remoteDispatchConnectDomainEventDeregisterAny(virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client,
virNetMessagePtr msg ATTRIBUTE_UNUSED,
@@ -3483,9 +3586,13 @@ remoteDispatchConnectDomainEventDeregisterAny(virNetServerPtr
server ATTRIBUTE_U
virMutexLock(&priv->lock);
- if (args->eventID >= VIR_DOMAIN_EVENT_ID_LAST ||
+ /* We intentionally do not use VIR_DOMAIN_EVENT_ID_LAST here; any
+ * new domain events added after this point should only use the
+ * modern callback style of RPC. */
+ if (args->eventID > VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED ||
args->eventID < 0) {
- virReportError(VIR_ERR_INTERNAL_ERROR, _("unsupported event ID %d"),
args->eventID);
+ virReportError(VIR_ERR_INTERNAL_ERROR, _("unsupported event ID %d"),
+ args->eventID);
goto cleanup;
}
@@ -3516,6 +3623,53 @@ cleanup:
return rv;
}
+
+static int
+remoteDispatchConnectDomainEventCallbackDeregisterAny(virNetServerPtr server
ATTRIBUTE_UNUSED,
+ virNetServerClientPtr client,
+ virNetMessagePtr msg
ATTRIBUTE_UNUSED,
+ virNetMessageErrorPtr rerr
ATTRIBUTE_UNUSED,
+
remote_connect_domain_event_callback_deregister_any_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->ndomainEventCallbacks; i++) {
+ if (priv->domainEventCallbacks[i]->callbackID == args->callbackID)
+ break;
+ }
+ if (i == priv->ndomainEventCallbacks) {
+ virReportError(VIR_ERR_INTERNAL_ERROR,
+ _("domain event callback %d not registered"),
+ args->callbackID);
+ goto cleanup;
+ }
+
+ if (virConnectDomainEventDeregisterAny(priv->conn, args->callbackID) < 0)
+ goto cleanup;
+
+ VIR_DELETE_ELEMENT(priv->domainEventCallbacks, i,
+ priv->ndomainEventCallbacks);
+
+ rv = 0;
+
+cleanup:
+ if (rv < 0)
+ virNetMessageSaveError(rerr);
+ virMutexUnlock(&priv->lock);
+ return rv;
+}
+
+
static int
qemuDispatchDomainMonitorCommand(virNetServerPtr server ATTRIBUTE_UNUSED,
virNetServerClientPtr client ATTRIBUTE_UNUSED,
@@ -3836,6 +3990,7 @@ static int remoteDispatchConnectSupportsFeature(virNetServerPtr
server ATTRIBUTE
switch (args->feature) {
case VIR_DRV_FEATURE_FD_PASSING:
+ case VIR_DRV_FEATURE_REMOTE_EVENT_CALLBACK:
supported = 1;
break;
diff --git a/src/libvirt_internal.h b/src/libvirt_internal.h
index 115d8d1..ebf2acf 100644
--- a/src/libvirt_internal.h
+++ b/src/libvirt_internal.h
@@ -1,7 +1,7 @@
/*
* libvirt_internal.h: internally exported APIs, not for public use
*
- * Copyright (C) 2006-2013 Red Hat, Inc.
+ * Copyright (C) 2006-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
@@ -115,6 +115,11 @@ enum {
* Support for migration parameters.
*/
VIR_DRV_FEATURE_MIGRATION_PARAMS = 13,
+
+ /*
+ * Support for server-side event filtering via callback ids in events.
+ */
+ VIR_DRV_FEATURE_REMOTE_EVENT_CALLBACK = 14,
};
diff --git a/src/remote/remote_protocol.x b/src/remote/remote_protocol.x
index f94a38a..96838ba 100644
--- a/src/remote/remote_protocol.x
+++ b/src/remote/remote_protocol.x
@@ -1972,6 +1972,10 @@ struct remote_domain_event_lifecycle_msg {
int event;
int detail;
};
+struct remote_domain_event_callback_lifecycle_msg {
+ int callbackID;
+ remote_domain_event_lifecycle_msg msg;
+};
struct remote_connect_domain_xml_from_native_args {
@@ -2248,6 +2252,19 @@ struct remote_connect_domain_event_deregister_any_args {
int eventID;
};
+struct remote_connect_domain_event_callback_register_any_args {
+ int eventID;
+ remote_domain dom;
+};
+
+struct remote_connect_domain_event_callback_register_any_ret {
+ int callbackID;
+};
+
+struct remote_connect_domain_event_callback_deregister_any_args {
+ int callbackID;
+};
+
struct remote_domain_event_reboot_msg {
remote_nonnull_domain dom;
};
@@ -5063,5 +5080,25 @@ enum remote_procedure {
* @generate: both
* @acl: none
*/
- REMOTE_PROC_NETWORK_EVENT_LIFECYCLE = 315
+ REMOTE_PROC_NETWORK_EVENT_LIFECYCLE = 315,
+
+ /**
+ * @generate: none
+ * @priority: high
+ * @acl: none
+ */
+ REMOTE_PROC_CONNECT_DOMAIN_EVENT_CALLBACK_REGISTER_ANY = 316,
+
+ /**
+ * @generate: none
+ * @priority: high
+ * @acl: none
+ */
+ REMOTE_PROC_CONNECT_DOMAIN_EVENT_CALLBACK_DEREGISTER_ANY = 317,
+
+ /**
+ * @generate: both
+ * @acl: none
+ */
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_LIFECYCLE = 318
};
diff --git a/src/remote_protocol-structs b/src/remote_protocol-structs
index e58482e..39d3981 100644
--- a/src/remote_protocol-structs
+++ b/src/remote_protocol-structs
@@ -1491,6 +1491,10 @@ struct remote_domain_event_lifecycle_msg {
int event;
int detail;
};
+struct remote_domain_event_callback_lifecycle_msg {
+ int callbackID;
+ remote_domain_event_lifecycle_msg msg;
+};
struct remote_connect_domain_xml_from_native_args {
remote_nonnull_string nativeFormat;
remote_nonnull_string nativeConfig;
@@ -1707,6 +1711,16 @@ struct remote_connect_domain_event_register_any_args {
struct remote_connect_domain_event_deregister_any_args {
int eventID;
};
+struct remote_connect_domain_event_callback_register_any_args {
+ int eventID;
+ remote_domain dom;
+};
+struct remote_connect_domain_event_callback_register_any_ret {
+ int callbackID;
+};
+struct remote_connect_domain_event_callback_deregister_any_args {
+ int callbackID;
+};
struct remote_domain_event_reboot_msg {
remote_nonnull_domain dom;
};
@@ -2660,4 +2674,7 @@ enum remote_procedure {
REMOTE_PROC_CONNECT_NETWORK_EVENT_REGISTER_ANY = 313,
REMOTE_PROC_CONNECT_NETWORK_EVENT_DEREGISTER_ANY = 314,
REMOTE_PROC_NETWORK_EVENT_LIFECYCLE = 315,
+ REMOTE_PROC_CONNECT_DOMAIN_EVENT_CALLBACK_REGISTER_ANY = 316,
+ REMOTE_PROC_CONNECT_DOMAIN_EVENT_CALLBACK_DEREGISTER_ANY = 317,
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_LIFECYCLE = 318,
};
--
1.8.4.2
5:23 p.m.
New subject: [libvirt] [PATCH 3/5] event: prepare client to track domain callbackID
We want to convert over to server-side events, even for older
APIs. To do that, the client side of the remote driver wants
to distinguish between legacy virConnectDomainEventRegister and
normal virConnectDomainEventRegisterAny, while knowing the
client callbackID and the server's serverID for both types of
registration. The client also needs to probe whether the
server supports server-side filtering. However, for ease of
review, we don't actually use the new RPCs until a later patch.
* src/conf/object_event_private.h (virObjectEventStateCallbackID):
Add parameter.
* src/conf/object_event.c (virObjectEventCallbackListAddID)
(virObjectEventStateRegisterID): Separate legacy from callbackID.
(virObjectEventStateCallbackID): Pass through parameter.
* src/conf/network_event.c (virNetworkEventStateRegisterID):
Update caller.
* src/conf/domain_event.c (virDomainEventStateRegister)
(virDomainEventStateRegisterID, virDomainEventStateDeregister):
Likewise.
(virDomainEventStateRegisterClient)
(virDomainEventStateCallbackID): Implement new functions.
* src/conf/domain_event.h (virDomainEventStateRegisterClient)
(virDomainEventStateCallbackID): New prototypes.
* src/remote/remote_driver.c (private_data): Add field.
(doRemoteOpen): Probe server feature.
(remoteConnectDomainEventRegister)
(remoteConnectDomainEventRegisterAny): Use new function.
Signed-off-by: Eric Blake <eblake(a)redhat.com>
---
src/conf/domain_event.c | 78 +++++++++++++++++++++++++++++++++++++++--
src/conf/domain_event.h | 22 ++++++++++++
src/conf/network_event.c | 6 ++--
src/conf/object_event.c | 31 ++++++++--------
src/conf/object_event_private.h | 6 ++--
src/remote/remote_driver.c | 36 +++++++++++++++----
6 files changed, 152 insertions(+), 27 deletions(-)
diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c
index f56aed3..29fc525 100644
--- a/src/conf/domain_event.c
+++ b/src/conf/domain_event.c
@@ -1307,6 +1307,8 @@ virDomainEventStateRegister(virConnectPtr conn,
void *opaque,
virFreeCallback freecb)
{
+ int callbackID;
+
if (virDomainEventsInitialize() < 0)
return -1;
@@ -1315,7 +1317,8 @@ virDomainEventStateRegister(virConnectPtr conn,
filter, virDomainEventClass,
VIR_DOMAIN_EVENT_ID_LIFECYCLE,
VIR_OBJECT_EVENT_CALLBACK(callback),
- opaque, freecb, NULL, false);
+ opaque, freecb,
+ true, &callbackID, false);
}
@@ -1355,7 +1358,75 @@ virDomainEventStateRegisterID(virConnectPtr conn,
filter ? virDomainEventFilter : NULL,
filter, virDomainEventClass, eventID,
VIR_OBJECT_EVENT_CALLBACK(cb),
- opaque, freecb, callbackID, false);
+ opaque, freecb,
+ false, callbackID, false);
+}
+
+
+/**
+ * virDomainEventStateRegisterClient:
+ * @conn: connection to associate with callback
+ * @state: object event state
+ * @dom: optional domain for filtering the event
+ * @eventID: ID of the event type to register for
+ * @cb: function to invoke when event fires
+ * @opaque: data blob to pass to @callback
+ * @freecb: callback to free @opaque
+ * @legacy: true if callback is tracked by function instead of callbackID
+ * @callbackID: filled with callback ID
+ * @remoteID: true if server supports filtering
+ *
+ * Register the function @cb with connection @conn, from @state, for
+ * events of type @eventID, and return the registration handle in
+ * @callbackID. This version is intended for use on the client side
+ * of RPC.
+ *
+ * Returns: the number of callbacks now registered, or -1 on error
+ */
+int
+virDomainEventStateRegisterClient(virConnectPtr conn,
+ virObjectEventStatePtr state,
+ virDomainPtr dom,
+ int eventID,
+ virConnectDomainEventGenericCallback cb,
+ void *opaque,
+ virFreeCallback freecb,
+ bool legacy,
+ int *callbackID,
+ bool remoteID)
+{
+ if (virDomainEventsInitialize() < 0)
+ return -1;
+
+ return virObjectEventStateRegisterID(conn, state, dom ? dom->uuid : NULL,
+ NULL, NULL,
+ virDomainEventClass, eventID,
+ VIR_OBJECT_EVENT_CALLBACK(cb),
+ opaque, freecb,
+ legacy, callbackID, remoteID);
+}
+
+
+/**
+ * virDomainEventStateCallbackID:
+ * @conn: connection associated with callback
+ * @state: object event state
+ * @cb: function registered as a callback with virDomainEventStateRegister()
+ * @remoteID: associated remote id of the callback
+ *
+ * Returns the callbackID of @cb, or -1 with an error issued if the
+ * function is not currently registered.
+ */
+int
+virDomainEventStateCallbackID(virConnectPtr conn,
+ virObjectEventStatePtr state,
+ virConnectDomainEventCallback cb,
+ int *remoteID)
+{
+ return virObjectEventStateCallbackID(conn, state, virDomainEventClass,
+ VIR_DOMAIN_EVENT_ID_LIFECYCLE,
+ VIR_OBJECT_EVENT_CALLBACK(cb),
+ remoteID);
}
@@ -1380,7 +1451,8 @@ virDomainEventStateDeregister(virConnectPtr conn,
callbackID = virObjectEventStateCallbackID(conn, state,
virDomainEventClass,
VIR_DOMAIN_EVENT_ID_LIFECYCLE,
- VIR_OBJECT_EVENT_CALLBACK(cb));
+ VIR_OBJECT_EVENT_CALLBACK(cb),
+ NULL);
if (callbackID < 0)
return -1;
return virObjectEventStateDeregisterID(conn, state, callbackID);
diff --git a/src/conf/domain_event.h b/src/conf/domain_event.h
index b39d5cd..011bb04 100644
--- a/src/conf/domain_event.h
+++ b/src/conf/domain_event.h
@@ -196,6 +196,28 @@ virDomainEventStateRegisterID(virConnectPtr conn,
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(6);
int
+virDomainEventStateRegisterClient(virConnectPtr conn,
+ virObjectEventStatePtr state,
+ virDomainPtr dom,
+ int eventID,
+ virConnectDomainEventGenericCallback cb,
+ void *opaque,
+ virFreeCallback freecb,
+ bool legacy,
+ int *callbackID,
+ bool remoteID)
+ ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(5)
+ ATTRIBUTE_NONNULL(9);
+
+int
+virDomainEventStateCallbackID(virConnectPtr conn,
+ virObjectEventStatePtr state,
+ virConnectDomainEventCallback callback,
+ int *remoteID)
+ ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3)
+ ATTRIBUTE_NONNULL(4);
+
+int
virDomainEventStateDeregister(virConnectPtr conn,
virObjectEventStatePtr state,
virConnectDomainEventCallback callback)
diff --git a/src/conf/network_event.c b/src/conf/network_event.c
index f27b7e9..d919ec2 100644
--- a/src/conf/network_event.c
+++ b/src/conf/network_event.c
@@ -182,7 +182,8 @@ virNetworkEventStateRegisterID(virConnectPtr conn,
filter ? virNetworkEventFilter : NULL,
filter, virNetworkEventClass, eventID,
VIR_OBJECT_EVENT_CALLBACK(cb),
- opaque, freecb, callbackID, false);
+ opaque, freecb,
+ false, callbackID, false);
}
@@ -221,7 +222,8 @@ virNetworkEventStateRegisterClient(virConnectPtr conn,
NULL, NULL,
virNetworkEventClass, eventID,
VIR_OBJECT_EVENT_CALLBACK(cb),
- opaque, freecb, callbackID, true);
+ opaque, freecb,
+ false, callbackID, true);
}
diff --git a/src/conf/object_event.c b/src/conf/object_event.c
index aff4956..c5770bf 100644
--- a/src/conf/object_event.c
+++ b/src/conf/object_event.c
@@ -360,6 +360,7 @@ virObjectEventCallbackLookup(virConnectPtr conn,
* @callback: the callback to add
* @opaque: opaque data to pass to @callback
* @freecb: callback to free @opaque
+ * @legacy: true if callback is tracked by function instead of callbackID
* @callbackID: filled with callback ID
* @serverFilter: true if server supports object filtering
*
@@ -376,6 +377,7 @@ virObjectEventCallbackListAddID(virConnectPtr conn,
virConnectObjectEventGenericCallback callback,
void *opaque,
virFreeCallback freecb,
+ bool legacy,
int *callbackID,
bool serverFilter)
{
@@ -384,9 +386,10 @@ virObjectEventCallbackListAddID(virConnectPtr conn,
int remoteID = -1;
VIR_DEBUG("conn=%p cblist=%p uuid=%p filter=%p filter_opaque=%p "
- "klass=%p eventID=%d callback=%p opaque=%p",
- conn, cbList, uuid, filter, filter_opaque,
- klass, eventID, callback, opaque);
+ "klass=%p eventID=%d callback=%p opaque=%p "
+ "legacy=%d callbackID=%p serverFilter=%d",
+ conn, cbList, uuid, filter, filter_opaque, klass, eventID,
+ callback, opaque, legacy, callbackID, serverFilter);
/* Check incoming */
if (!cbList) {
@@ -395,8 +398,7 @@ virObjectEventCallbackListAddID(virConnectPtr conn,
/* check if we already have this callback on our list */
if (virObjectEventCallbackLookup(conn, cbList, uuid,
- klass, eventID, callback,
- !callbackID,
+ klass, eventID, callback, legacy,
serverFilter ? &remoteID : NULL) != -1) {
virReportError(VIR_ERR_INVALID_ARG, "%s",
_("event callback already tracked"));
@@ -406,7 +408,7 @@ virObjectEventCallbackListAddID(virConnectPtr conn,
if (VIR_ALLOC(event) < 0)
goto cleanup;
event->conn = virObjectRef(conn);
- event->callbackID = cbList->nextID++;
+ *callbackID = event->callbackID = cbList->nextID++;
event->cb = callback;
event->klass = klass;
event->eventID = eventID;
@@ -423,11 +425,7 @@ virObjectEventCallbackListAddID(virConnectPtr conn,
}
event->filter = filter;
event->filter_opaque = filter_opaque;
-
- if (callbackID)
- *callbackID = event->callbackID;
- else
- event->legacy = true;
+ event->legacy = legacy;
if (VIR_APPEND_ELEMENT(cbList->callbacks, cbList->count, event) < 0)
goto cleanup;
@@ -833,6 +831,7 @@ virObjectEventStateFlush(virObjectEventStatePtr state)
* @cb: function to invoke when event occurs
* @opaque: data blob to pass to @callback
* @freecb: callback to free @opaque
+ * @legacy: true if callback is tracked by function instead of callbackID
* @callbackID: filled with callback ID
* @serverFilter: true if server supports object filtering
*
@@ -867,6 +866,7 @@ virObjectEventStateRegisterID(virConnectPtr conn,
virConnectObjectEventGenericCallback cb,
void *opaque,
virFreeCallback freecb,
+ bool legacy,
int *callbackID,
bool serverFilter)
{
@@ -889,7 +889,7 @@ virObjectEventStateRegisterID(virConnectPtr conn,
uuid, filter, filter_opaque,
klass, eventID,
cb, opaque, freecb,
- callbackID, serverFilter);
+ legacy, callbackID, serverFilter);
if (ret == -1 &&
state->callbacks->count == 0 &&
@@ -949,6 +949,7 @@ virObjectEventStateDeregisterID(virConnectPtr conn,
* @klass: the base event class
* @eventID: the event ID
* @callback: function registered as a callback
+ * @remoteID: optional output, containing resulting remote id
*
* Returns the callbackID of @callback, or -1 with an error issued if the
* function is not currently registered. This only finds functions
@@ -960,13 +961,15 @@ virObjectEventStateCallbackID(virConnectPtr conn,
virObjectEventStatePtr state,
virClassPtr klass,
int eventID,
- virConnectObjectEventGenericCallback callback)
+ virConnectObjectEventGenericCallback callback,
+ int *remoteID)
{
int ret = -1;
virObjectEventStateLock(state);
ret = virObjectEventCallbackLookup(conn, state->callbacks, NULL,
- klass, eventID, callback, true, NULL);
+ klass, eventID, callback, true,
+ remoteID);
virObjectEventStateUnlock(state);
if (ret < 0)
diff --git a/src/conf/object_event_private.h b/src/conf/object_event_private.h
index 8e265f9..a19a0d3 100644
--- a/src/conf/object_event_private.h
+++ b/src/conf/object_event_private.h
@@ -80,17 +80,19 @@ virObjectEventStateRegisterID(virConnectPtr conn,
virConnectObjectEventGenericCallback cb,
void *opaque,
virFreeCallback freecb,
+ bool legacy,
int *callbackID,
bool remoteFilter)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(6)
- ATTRIBUTE_NONNULL(8);
+ ATTRIBUTE_NONNULL(8) ATTRIBUTE_NONNULL(12);
int
virObjectEventStateCallbackID(virConnectPtr conn,
virObjectEventStatePtr state,
virClassPtr klass,
int eventID,
- virConnectObjectEventGenericCallback callback)
+ virConnectObjectEventGenericCallback callback,
+ int *remoteID)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(3)
ATTRIBUTE_NONNULL(5);
diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c
index ca86e3c..b0257c2 100644
--- a/src/remote/remote_driver.c
+++ b/src/remote/remote_driver.c
@@ -92,6 +92,7 @@ struct private_data {
int localUses; /* Ref count for private data */
char *hostname; /* Original hostname */
bool serverKeepAlive; /* Does server support keepalive protocol? */
+ bool serverEventFilter; /* Does server support modern event filtering */
virObjectEventStatePtr eventState;
};
@@ -890,8 +891,26 @@ doRemoteOpen(virConnectPtr conn,
goto failed;
}
+ /* Set up events */
if (!(priv->eventState = virObjectEventStateNew()))
goto failed;
+ {
+ remote_connect_supports_feature_args args =
+ { VIR_DRV_FEATURE_REMOTE_EVENT_CALLBACK };
+ remote_connect_supports_feature_ret ret = { 0 };
+ int rc;
+
+ rc = call(conn, priv, 0, REMOTE_PROC_CONNECT_SUPPORTS_FEATURE,
+ (xdrproc_t)xdr_remote_connect_supports_feature_args, (char *)
&args,
+ (xdrproc_t)xdr_remote_connect_supports_feature_ret, (char *)
&ret);
+
+ if (rc != -1 && ret.supported) {
+ priv->serverEventFilter = true;
+ } else {
+ VIR_INFO("Avoiding server event filtering since it is not "
+ "supported by the server");
+ }
+ }
/* Successful. */
retcode = VIR_DRV_OPEN_SUCCESS;
@@ -4421,14 +4440,19 @@ remoteConnectDomainEventRegister(virConnectPtr conn,
void *opaque,
virFreeCallback freecb)
{
+ int callbackID;
int rv = -1;
struct private_data *priv = conn->privateData;
int count;
remoteDriverLock(priv);
- if ((count = virDomainEventStateRegister(conn, priv->eventState, NULL,
- callback, opaque, freecb)) < 0)
+ if ((count = virDomainEventStateRegisterClient(conn, priv->eventState,
+ NULL,
+ VIR_DOMAIN_EVENT_ID_LIFECYCLE,
+ VIR_DOMAIN_EVENT_CALLBACK(callback),
+ opaque, freecb, true,
+ &callbackID, false)) < 0)
goto done;
if (count == 1) {
@@ -5245,10 +5269,10 @@ remoteConnectDomainEventRegisterAny(virConnectPtr conn,
remoteDriverLock(priv);
- if ((count = virDomainEventStateRegisterID(conn, priv->eventState, NULL,
- dom, eventID,
- callback, opaque, freecb,
- &callbackID)) < 0)
+ if ((count = virDomainEventStateRegisterClient(conn, priv->eventState,
+ dom, eventID, callback,
+ opaque, freecb, false,
+ &callbackID, false)) < 0)
goto done;
/* If this is the first callback for this eventID, we need to enable
--
1.8.4.2
5:54 p.m.
New subject: [libvirt] [PATCH 3/5] event: prepare client to track domain callbackID
On 01/15/2014 04:23 PM, Eric Blake wrote:
We want to convert over to server-side events, even for older
APIs. To do that, the client side of the remote driver wants
to distinguish between legacy virConnectDomainEventRegister and
normal virConnectDomainEventRegisterAny, while knowing the
client callbackID and the server's serverID for both types of
registration. The client also needs to probe whether the
server supports server-side filtering. However, for ease of
review, we don't actually use the new RPCs until a later patch.
* src/conf/object_event_private.h (virObjectEventStateCallbackID):
Add parameter.
* src/conf/object_event.c (virObjectEventCallbackListAddID)
(virObjectEventStateRegisterID): Separate legacy from callbackID.
(virObjectEventStateCallbackID): Pass through parameter.
* src/conf/network_event.c (virNetworkEventStateRegisterID):
Update caller.
* src/conf/domain_event.c (virDomainEventStateRegister)
(virDomainEventStateRegisterID, virDomainEventStateDeregister):
Likewise.
(virDomainEventStateRegisterClient)
(virDomainEventStateCallbackID): Implement new functions.
* src/conf/domain_event.h (virDomainEventStateRegisterClient)
(virDomainEventStateCallbackID): New prototypes.
* src/remote/remote_driver.c (private_data): Add field.
(doRemoteOpen): Probe server feature.
(remoteConnectDomainEventRegister)
(remoteConnectDomainEventRegisterAny): Use new function.
Based on my additional testing, I need to squash this in for global
domain lifecycle events (lookup of a remoteID should match the same
conditions as virObjectEventCallbackListCount, which ignores legacy).
Thankfully, no impact to 1.2.1 (network events are never marked legacy).
diff --git i/src/conf/object_event.c w/src/conf/object_event.c
index c5770bf..de45257 100644
--- i/src/conf/object_event.c
+++ w/src/conf/object_event.c
@@ -334,13 +334,13 @@ virObjectEventCallbackLookup(virConnectPtr conn,
if (cb->klass == klass &&
cb->eventID == eventID &&
cb->conn == conn &&
- cb->legacy == legacy &&
((uuid && cb->uuid_filter &&
memcmp(cb->uuid, uuid, VIR_UUID_BUFLEN) == 0) ||
(!uuid && !cb->uuid_filter))) {
if (remoteID)
*remoteID = cb->remoteID;
- if (cb->cb == callback)
+ if (cb->legacy == legacy &&
+ cb->cb == callback)
return cb->callbackID;
}
}
--
Eric Blake eblake redhat com +1-919-301-3266
Libvirt virtualization library http://libvirt.org
5:23 p.m.
New subject: [libvirt] [PATCH 4/5] event: client RPC protocol tweaks for domain lifecycle events
The counterpart to the server RPC additions; here, a single
function can serve both old and new calls, while incoming
events must be serviced by two different functions. Again,
some wise choices in our XDR makes event sharing easier.
While this only supports lifecycle events, it covers the
harder part of how Register and RegisterAny interact; the
remaining 15 events will be a mechanical change in a later
patch. For Register, we now have a callbackID locally for
more efficient cleanup if the RPC fails; we also prefer to
use the newer RPC where we know it is supported (the older
RPC must be used if we don't know if RegisterAny is
supported).
* src/remote/remote_driver.c (remoteEvents): Register new RPC
event handler.
(remoteDomainBuildEventLifecycle): Move guts...
(remoteDomainBuildEventLifecycleHelper): ...here.
(remoteDomainBuildEventCallbackLifecycle): New function.
(remoteConnectDomainEventRegister)
(remoteConnectDomainEventDeregister)
(remoteConnectDomainEventRegisterAny)
(remoteConnectDomainEventDeregisterAny): Use new RPC when supported.
---
src/remote/remote_driver.c | 191 +++++++++++++++++++++++++++++++++++++--------
1 file changed, 157 insertions(+), 34 deletions(-)
diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c
index b0257c2..35baaeb 100644
--- a/src/remote/remote_driver.c
+++ b/src/remote/remote_driver.c
@@ -209,6 +209,11 @@ remoteDomainBuildEventLifecycle(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,
virNetClientPtr client ATTRIBUTE_UNUSED,
void *evdata, void *opaque);
static void
+remoteDomainBuildEventCallbackLifecycle(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+ virNetClientPtr client ATTRIBUTE_UNUSED,
+ void *evdata, void *opaque);
+
+static void
remoteDomainBuildEventReboot(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
virNetClientPtr client ATTRIBUTE_UNUSED,
void *evdata, void *opaque);
@@ -345,10 +350,23 @@ static virNetClientProgramEvent remoteEvents[] = {
remoteDomainBuildEventDeviceRemoved,
sizeof(remote_domain_event_device_removed_msg),
(xdrproc_t)xdr_remote_domain_event_device_removed_msg },
+ /* All events above here are legacy events, missing the callback
+ * ID, which means the server has a single global registration and
+ * we do full filtering in the client. If the server lacks
+ * VIR_DRV_FEATURE_REMOTE_EVENT_CALLBACK, those are the only
+ * events we should ever receive. Conversely, all events below
+ * here should only be triggered by modern servers, and all
+ * contain a callbackID. Although we have to duplicate the first
+ * 16 domain events in both styles for back-compat, any future
+ * domain event additions should only use the modern style. */
{ REMOTE_PROC_NETWORK_EVENT_LIFECYCLE,
remoteNetworkBuildEventLifecycle,
sizeof(remote_network_event_lifecycle_msg),
(xdrproc_t)xdr_remote_network_event_lifecycle_msg },
+ { REMOTE_PROC_DOMAIN_EVENT_CALLBACK_LIFECYCLE,
+ remoteDomainBuildEventCallbackLifecycle,
+ sizeof(remote_domain_event_callback_lifecycle_msg),
+ (xdrproc_t)xdr_remote_domain_event_callback_lifecycle_msg },
};
enum virDrvOpenRemoteFlags {
@@ -4452,16 +4470,38 @@ remoteConnectDomainEventRegister(virConnectPtr conn,
VIR_DOMAIN_EVENT_ID_LIFECYCLE,
VIR_DOMAIN_EVENT_CALLBACK(callback),
opaque, freecb, true,
- &callbackID, false)) < 0)
+ &callbackID,
+ priv->serverEventFilter)) < 0)
goto done;
if (count == 1) {
/* Tell the server when we are the first callback registering */
- if (call(conn, priv, 0, REMOTE_PROC_CONNECT_DOMAIN_EVENT_REGISTER,
- (xdrproc_t) xdr_void, (char *) NULL,
- (xdrproc_t) xdr_void, (char *) NULL) == -1) {
- virDomainEventStateDeregister(conn, priv->eventState, callback);
- goto done;
+ if (priv->serverEventFilter) {
+ remote_connect_domain_event_callback_register_any_args args;
+ remote_connect_domain_event_callback_register_any_ret ret;
+
+ args.eventID = VIR_DOMAIN_EVENT_ID_LIFECYCLE;
+ args.dom = NULL;
+
+ memset(&ret, 0, sizeof(ret));
+ if (call(conn, priv, 0,
+ REMOTE_PROC_CONNECT_DOMAIN_EVENT_CALLBACK_REGISTER_ANY,
+ (xdrproc_t)
xdr_remote_connect_domain_event_callback_register_any_args, (char *) &args,
+ (xdrproc_t)
xdr_remote_connect_domain_event_callback_register_any_ret, (char *) &ret) == -1) {
+ virObjectEventStateDeregisterID(conn, priv->eventState,
+ callbackID);
+ goto done;
+ }
+ virObjectEventStateSetRemote(conn, priv->eventState, callbackID,
+ ret.callbackID);
+ } else {
+ if (call(conn, priv, 0, REMOTE_PROC_CONNECT_DOMAIN_EVENT_REGISTER,
+ (xdrproc_t) xdr_void, (char *) NULL,
+ (xdrproc_t) xdr_void, (char *) NULL) == -1) {
+ virObjectEventStateDeregisterID(conn, priv->eventState,
+ callbackID);
+ goto done;
+ }
}
}
@@ -4472,26 +4512,45 @@ done:
return rv;
}
+
static int
remoteConnectDomainEventDeregister(virConnectPtr conn,
virConnectDomainEventCallback callback)
{
struct private_data *priv = conn->privateData;
int rv = -1;
+ remote_connect_domain_event_callback_deregister_any_args args;
+ int callbackID;
+ int remoteID;
int count;
remoteDriverLock(priv);
- if ((count = virDomainEventStateDeregister(conn, priv->eventState,
- callback)) < 0)
+ if ((callbackID = virDomainEventStateCallbackID(conn, priv->eventState,
+ callback,
+ &remoteID)) < 0)
+ goto done;
+
+ if ((count = virObjectEventStateDeregisterID(conn, priv->eventState,
+ callbackID)) < 0)
goto done;
if (count == 0) {
/* Tell the server when we are the last callback deregistering */
- if (call(conn, priv, 0, REMOTE_PROC_CONNECT_DOMAIN_EVENT_DEREGISTER,
- (xdrproc_t) xdr_void, (char *) NULL,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
+ if (priv->serverEventFilter) {
+ args.callbackID = remoteID;
+
+ if (call(conn, priv, 0,
+ REMOTE_PROC_CONNECT_DOMAIN_EVENT_CALLBACK_DEREGISTER_ANY,
+ (xdrproc_t)
xdr_remote_connect_domain_event_callback_deregister_any_args, (char *) &args,
+ (xdrproc_t) xdr_void, (char *) NULL) == -1)
+ goto done;
+ } else {
+ if (call(conn, priv, 0, REMOTE_PROC_CONNECT_DOMAIN_EVENT_DEREGISTER,
+ (xdrproc_t) xdr_void, (char *) NULL,
+ (xdrproc_t) xdr_void, (char *) NULL) == -1)
+ goto done;
+ }
}
rv = 0;
@@ -4512,13 +4571,11 @@ remoteEventQueue(struct private_data *priv, virObjectEventPtr
event,
static void
-remoteDomainBuildEventLifecycle(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
- virNetClientPtr client ATTRIBUTE_UNUSED,
- void *evdata, void *opaque)
+remoteDomainBuildEventLifecycleHelper(virConnectPtr conn,
+ remote_domain_event_lifecycle_msg *msg,
+ int callbackID)
{
- virConnectPtr conn = opaque;
struct private_data *priv = conn->privateData;
- remote_domain_event_lifecycle_msg *msg = evdata;
virDomainPtr dom;
virObjectEventPtr event = NULL;
@@ -4529,7 +4586,25 @@ remoteDomainBuildEventLifecycle(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,
event = virDomainEventLifecycleNewFromDom(dom, msg->event, msg->detail);
virDomainFree(dom);
- remoteEventQueue(priv, event, -1);
+ remoteEventQueue(priv, event, callbackID);
+}
+static void
+remoteDomainBuildEventLifecycle(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+ virNetClientPtr client ATTRIBUTE_UNUSED,
+ void *evdata, void *opaque)
+{
+ virConnectPtr conn = opaque;
+ remote_domain_event_lifecycle_msg *msg = evdata;
+ remoteDomainBuildEventLifecycleHelper(conn, msg, -1);
+}
+static void
+remoteDomainBuildEventCallbackLifecycle(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+ virNetClientPtr client ATTRIBUTE_UNUSED,
+ void *evdata, void *opaque)
+{
+ virConnectPtr conn = opaque;
+ remote_domain_event_callback_lifecycle_msg *msg = evdata;
+ remoteDomainBuildEventLifecycleHelper(conn, &msg->msg, msg->callbackID);
}
@@ -5263,29 +5338,61 @@ remoteConnectDomainEventRegisterAny(virConnectPtr conn,
{
int rv = -1;
struct private_data *priv = conn->privateData;
- remote_connect_domain_event_register_any_args args;
int callbackID;
int count;
+ remote_nonnull_domain domain;
+ bool serverFilter;
remoteDriverLock(priv);
+ serverFilter = priv->serverEventFilter;
+ /* FIXME support more than just lifecycle events */
+ serverFilter &= eventID == VIR_DOMAIN_EVENT_ID_LIFECYCLE;
+
if ((count = virDomainEventStateRegisterClient(conn, priv->eventState,
dom, eventID, callback,
opaque, freecb, false,
- &callbackID, false)) < 0)
+ &callbackID,
+ serverFilter)) < 0)
goto done;
/* If this is the first callback for this eventID, we need to enable
* events on the server */
if (count == 1) {
- args.eventID = eventID;
+ if (serverFilter) {
+ remote_connect_domain_event_callback_register_any_args args;
+ remote_connect_domain_event_callback_register_any_ret ret;
+
+ args.eventID = eventID;
+ if (dom) {
+ make_nonnull_domain(&domain, dom);
+ args.dom = &domain;
+ } else {
+ args.dom = NULL;
+ }
- if (call(conn, priv, 0, REMOTE_PROC_CONNECT_DOMAIN_EVENT_REGISTER_ANY,
- (xdrproc_t) xdr_remote_connect_domain_event_register_any_args, (char *)
&args,
- (xdrproc_t) xdr_void, (char *)NULL) == -1) {
- virObjectEventStateDeregisterID(conn, priv->eventState,
- callbackID);
- goto done;
+ memset(&ret, 0, sizeof(ret));
+ if (call(conn, priv, 0,
REMOTE_PROC_CONNECT_DOMAIN_EVENT_CALLBACK_REGISTER_ANY,
+ (xdrproc_t)
xdr_remote_connect_domain_event_callback_register_any_args, (char *) &args,
+ (xdrproc_t)
xdr_remote_connect_domain_event_callback_register_any_ret, (char *) &ret) == -1) {
+ virObjectEventStateDeregisterID(conn, priv->eventState,
+ callbackID);
+ goto done;
+ }
+ virObjectEventStateSetRemote(conn, priv->eventState, callbackID,
+ ret.callbackID);
+ } else {
+ remote_connect_domain_event_register_any_args args;
+
+ args.eventID = eventID;
+
+ if (call(conn, priv, 0, REMOTE_PROC_CONNECT_DOMAIN_EVENT_REGISTER_ANY,
+ (xdrproc_t) xdr_remote_connect_domain_event_register_any_args, (char
*) &args,
+ (xdrproc_t) xdr_void, (char *)NULL) == -1) {
+ virObjectEventStateDeregisterID(conn, priv->eventState,
+ callbackID);
+ goto done;
+ }
}
}
@@ -5303,14 +5410,14 @@ remoteConnectDomainEventDeregisterAny(virConnectPtr conn,
{
struct private_data *priv = conn->privateData;
int rv = -1;
- remote_connect_domain_event_deregister_any_args args;
int eventID;
+ int remoteID;
int count;
remoteDriverLock(priv);
if ((eventID = virObjectEventStateEventID(conn, priv->eventState,
- callbackID, NULL)) < 0)
+ callbackID, &remoteID)) < 0)
goto done;
if ((count = virObjectEventStateDeregisterID(conn, priv->eventState,
@@ -5319,13 +5426,29 @@ remoteConnectDomainEventDeregisterAny(virConnectPtr conn,
/* If that was the last callback for this eventID, we need to disable
* events on the server */
+ /* FIXME support more than just lifecycle events */
if (count == 0) {
- args.eventID = eventID;
+ if (priv->serverEventFilter &&
+ eventID == VIR_DOMAIN_EVENT_ID_LIFECYCLE) {
+ remote_connect_domain_event_callback_deregister_any_args args;
- if (call(conn, priv, 0, REMOTE_PROC_CONNECT_DOMAIN_EVENT_DEREGISTER_ANY,
- (xdrproc_t) xdr_remote_connect_domain_event_deregister_any_args, (char
*) &args,
- (xdrproc_t) xdr_void, (char *) NULL) == -1)
- goto done;
+ args.callbackID = remoteID;
+
+ if (call(conn, priv, 0,
+ REMOTE_PROC_CONNECT_DOMAIN_EVENT_CALLBACK_DEREGISTER_ANY,
+ (xdrproc_t)
xdr_remote_connect_domain_event_callback_deregister_any_args, (char *) &args,
+ (xdrproc_t) xdr_void, (char *) NULL) == -1)
+ goto done;
+ } else {
+ remote_connect_domain_event_deregister_any_args args;
+
+ args.eventID = eventID;
+
+ if (call(conn, priv, 0, REMOTE_PROC_CONNECT_DOMAIN_EVENT_DEREGISTER_ANY,
+ (xdrproc_t) xdr_remote_connect_domain_event_deregister_any_args,
(char *) &args,
+ (xdrproc_t) xdr_void, (char *) NULL) == -1)
+ goto done;
+ }
}
rv = 0;
--
1.8.4.2
5:23 p.m.
New subject: [libvirt] [PATCH 5/5] event: convert remaining domain events to new style
Following the patterns established by lifecycle events, this
creates all the new RPC calls needed to pass callback IDs
for every domain event, and changes the limits in client and
server codes to use modern style when possible.
I've tested all combinations: both 'old client and new server'
and 'new client and old server' continue to work with the old
RPCs, and 'new client and new server' benefit from server-side
filtering with the new RPCs.
* src/remote/remote_protocol.x (REMOTE_PROC_DOMAIN_EVENT_*): Add
REMOTE_PROC_DOMAIN_EVENT_CALLBACK_* counterparts.
* daemon/remote.c (remoteRelayDomainEvent*): Send callbackID via
newer RPC when used with new-style registration.
(remoteDispatchConnectDomainEventCallbackRegisterAny): Extend to
cover all domain events.
* src/remote/remote_driver.c (remoteDomainBuildEvent*): Add new
Callback and Helper functions.
(remoteEvents): Match order of RPC numbers, register new handlers.
(remoteConnectDomainEventRegisterAny)
(remoteConnectDomainEventDeregisterAny): Extend to cover all
domain events.
* src/remote_protocol-structs: Regenerate.
Signed-off-by: Eric Blake <eblake(a)redhat.com>
---
daemon/remote.c | 240 ++++++++++++++----
src/remote/remote_driver.c | 581 ++++++++++++++++++++++++++++++++++---------
src/remote/remote_protocol.x | 155 +++++++++++-
src/remote_protocol-structs | 75 ++++++
4 files changed, 886 insertions(+), 165 deletions(-)
diff --git a/daemon/remote.c b/daemon/remote.c
index 05fb708..2d5c9d1 100644
--- a/daemon/remote.c
+++ b/daemon/remote.c
@@ -179,16 +179,25 @@ remoteRelayDomainEventReboot(virConnectPtr conn ATTRIBUTE_UNUSED,
if (callback->callbackID < 0)
return -1;
- VIR_DEBUG("Relaying domain reboot event %s %d, callback %d",
- dom->name, dom->id, callback->callbackID);
+ VIR_DEBUG("Relaying domain reboot event %s %d, callback %d legacy %d",
+ dom->name, dom->id, callback->callbackID, callback->legacy);
/* build return data */
memset(&data, 0, sizeof(data));
make_nonnull_domain(&data.dom, dom);
- remoteDispatchObjectEventSend(callback->client, remoteProgram,
- REMOTE_PROC_DOMAIN_EVENT_REBOOT,
- (xdrproc_t)xdr_remote_domain_event_reboot_msg,
&data);
+ if (callback->legacy) {
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
+ REMOTE_PROC_DOMAIN_EVENT_REBOOT,
+ (xdrproc_t)xdr_remote_domain_event_reboot_msg,
&data);
+ } else {
+ remote_domain_event_callback_reboot_msg msg = { callback->callbackID,
+ data };
+
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_REBOOT,
+
(xdrproc_t)xdr_remote_domain_event_callback_reboot_msg, &msg);
+ }
return 0;
}
@@ -206,17 +215,27 @@ remoteRelayDomainEventRTCChange(virConnectPtr conn
ATTRIBUTE_UNUSED,
if (callback->callbackID < 0)
return -1;
- VIR_DEBUG("Relaying domain rtc change event %s %d %lld, callback %d",
- dom->name, dom->id, offset, callback->callbackID);
+ VIR_DEBUG("Relaying domain rtc change event %s %d %lld, callback %d legacy
%d",
+ dom->name, dom->id, offset,
+ callback->callbackID, callback->legacy);
/* build return data */
memset(&data, 0, sizeof(data));
make_nonnull_domain(&data.dom, dom);
data.offset = offset;
- remoteDispatchObjectEventSend(callback->client, remoteProgram,
- REMOTE_PROC_DOMAIN_EVENT_RTC_CHANGE,
- (xdrproc_t)xdr_remote_domain_event_rtc_change_msg,
&data);
+ if (callback->legacy) {
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
+ REMOTE_PROC_DOMAIN_EVENT_RTC_CHANGE,
+ (xdrproc_t)xdr_remote_domain_event_rtc_change_msg,
&data);
+ } else {
+ remote_domain_event_callback_rtc_change_msg msg = { callback->callbackID,
+ data };
+
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_RTC_CHANGE,
+
(xdrproc_t)xdr_remote_domain_event_callback_rtc_change_msg, &msg);
+ }
return 0;
}
@@ -242,9 +261,18 @@ remoteRelayDomainEventWatchdog(virConnectPtr conn ATTRIBUTE_UNUSED,
make_nonnull_domain(&data.dom, dom);
data.action = action;
- remoteDispatchObjectEventSend(callback->client, remoteProgram,
- REMOTE_PROC_DOMAIN_EVENT_WATCHDOG,
- (xdrproc_t)xdr_remote_domain_event_watchdog_msg,
&data);
+ if (callback->legacy) {
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
+ REMOTE_PROC_DOMAIN_EVENT_WATCHDOG,
+ (xdrproc_t)xdr_remote_domain_event_watchdog_msg,
&data);
+ } else {
+ remote_domain_event_callback_watchdog_msg msg = { callback->callbackID,
+ data };
+
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_WATCHDOG,
+
(xdrproc_t)xdr_remote_domain_event_callback_watchdog_msg, &msg);
+ }
return 0;
}
@@ -276,9 +304,18 @@ remoteRelayDomainEventIOError(virConnectPtr conn ATTRIBUTE_UNUSED,
make_nonnull_domain(&data.dom, dom);
data.action = action;
- remoteDispatchObjectEventSend(callback->client, remoteProgram,
- REMOTE_PROC_DOMAIN_EVENT_IO_ERROR,
- (xdrproc_t)xdr_remote_domain_event_io_error_msg,
&data);
+ if (callback->legacy) {
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
+ REMOTE_PROC_DOMAIN_EVENT_IO_ERROR,
+ (xdrproc_t)xdr_remote_domain_event_io_error_msg,
&data);
+ } else {
+ remote_domain_event_callback_io_error_msg msg = { callback->callbackID,
+ data };
+
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_IO_ERROR,
+
(xdrproc_t)xdr_remote_domain_event_callback_io_error_msg, &msg);
+ }
return 0;
error:
@@ -317,9 +354,18 @@ remoteRelayDomainEventIOErrorReason(virConnectPtr conn
ATTRIBUTE_UNUSED,
make_nonnull_domain(&data.dom, dom);
- remoteDispatchObjectEventSend(callback->client, remoteProgram,
- REMOTE_PROC_DOMAIN_EVENT_IO_ERROR_REASON,
- (xdrproc_t)xdr_remote_domain_event_io_error_reason_msg,
&data);
+ if (callback->legacy) {
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
+ REMOTE_PROC_DOMAIN_EVENT_IO_ERROR_REASON,
+
(xdrproc_t)xdr_remote_domain_event_io_error_reason_msg, &data);
+ } else {
+ remote_domain_event_callback_io_error_reason_msg msg = {
callback->callbackID,
+ data };
+
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_IO_ERROR_REASON,
+
(xdrproc_t)xdr_remote_domain_event_callback_io_error_reason_msg, &msg);
+ }
return 0;
@@ -382,9 +428,18 @@ remoteRelayDomainEventGraphics(virConnectPtr conn ATTRIBUTE_UNUSED,
}
make_nonnull_domain(&data.dom, dom);
- remoteDispatchObjectEventSend(callback->client, remoteProgram,
- REMOTE_PROC_DOMAIN_EVENT_GRAPHICS,
- (xdrproc_t)xdr_remote_domain_event_graphics_msg,
&data);
+ if (callback->legacy) {
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
+ REMOTE_PROC_DOMAIN_EVENT_GRAPHICS,
+ (xdrproc_t)xdr_remote_domain_event_graphics_msg,
&data);
+ } else {
+ remote_domain_event_callback_graphics_msg msg = { callback->callbackID,
+ data };
+
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_GRAPHICS,
+
(xdrproc_t)xdr_remote_domain_event_callback_graphics_msg, &msg);
+ }
return 0;
@@ -429,9 +484,18 @@ remoteRelayDomainEventBlockJob(virConnectPtr conn ATTRIBUTE_UNUSED,
data.status = status;
make_nonnull_domain(&data.dom, dom);
- remoteDispatchObjectEventSend(callback->client, remoteProgram,
- REMOTE_PROC_DOMAIN_EVENT_BLOCK_JOB,
- (xdrproc_t)xdr_remote_domain_event_block_job_msg,
&data);
+ if (callback->legacy) {
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
+ REMOTE_PROC_DOMAIN_EVENT_BLOCK_JOB,
+ (xdrproc_t)xdr_remote_domain_event_block_job_msg,
&data);
+ } else {
+ remote_domain_event_callback_block_job_msg msg = { callback->callbackID,
+ data };
+
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_BLOCK_JOB,
+
(xdrproc_t)xdr_remote_domain_event_callback_block_job_msg, &msg);
+ }
return 0;
error:
@@ -458,9 +522,18 @@ remoteRelayDomainEventControlError(virConnectPtr conn
ATTRIBUTE_UNUSED,
memset(&data, 0, sizeof(data));
make_nonnull_domain(&data.dom, dom);
- remoteDispatchObjectEventSend(callback->client, remoteProgram,
- REMOTE_PROC_DOMAIN_EVENT_CONTROL_ERROR,
- (xdrproc_t)xdr_remote_domain_event_control_error_msg,
&data);
+ if (callback->legacy) {
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
+ REMOTE_PROC_DOMAIN_EVENT_CONTROL_ERROR,
+
(xdrproc_t)xdr_remote_domain_event_control_error_msg, &data);
+ } else {
+ remote_domain_event_callback_control_error_msg msg = { callback->callbackID,
+ data };
+
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_CONTROL_ERROR,
+
(xdrproc_t)xdr_remote_domain_event_callback_control_error_msg, &msg);
+ }
return 0;
}
@@ -506,9 +579,18 @@ remoteRelayDomainEventDiskChange(virConnectPtr conn
ATTRIBUTE_UNUSED,
make_nonnull_domain(&data.dom, dom);
- remoteDispatchObjectEventSend(callback->client, remoteProgram,
- REMOTE_PROC_DOMAIN_EVENT_DISK_CHANGE,
- (xdrproc_t)xdr_remote_domain_event_disk_change_msg,
&data);
+ if (callback->legacy) {
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
+ REMOTE_PROC_DOMAIN_EVENT_DISK_CHANGE,
+ (xdrproc_t)xdr_remote_domain_event_disk_change_msg,
&data);
+ } else {
+ remote_domain_event_callback_disk_change_msg msg = { callback->callbackID,
+ data };
+
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_DISK_CHANGE,
+
(xdrproc_t)xdr_remote_domain_event_callback_disk_change_msg, &msg);
+ }
return 0;
@@ -544,9 +626,18 @@ remoteRelayDomainEventTrayChange(virConnectPtr conn
ATTRIBUTE_UNUSED,
make_nonnull_domain(&data.dom, dom);
- remoteDispatchObjectEventSend(callback->client, remoteProgram,
- REMOTE_PROC_DOMAIN_EVENT_TRAY_CHANGE,
- (xdrproc_t)xdr_remote_domain_event_tray_change_msg,
&data);
+ if (callback->legacy) {
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
+ REMOTE_PROC_DOMAIN_EVENT_TRAY_CHANGE,
+ (xdrproc_t)xdr_remote_domain_event_tray_change_msg,
&data);
+ } else {
+ remote_domain_event_callback_tray_change_msg msg = { callback->callbackID,
+ data };
+
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_TRAY_CHANGE,
+
(xdrproc_t)xdr_remote_domain_event_callback_tray_change_msg, &msg);
+ }
return 0;
}
@@ -570,9 +661,18 @@ remoteRelayDomainEventPMWakeup(virConnectPtr conn ATTRIBUTE_UNUSED,
memset(&data, 0, sizeof(data));
make_nonnull_domain(&data.dom, dom);
- remoteDispatchObjectEventSend(callback->client, remoteProgram,
- REMOTE_PROC_DOMAIN_EVENT_PMWAKEUP,
- (xdrproc_t)xdr_remote_domain_event_pmwakeup_msg,
&data);
+ if (callback->legacy) {
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
+ REMOTE_PROC_DOMAIN_EVENT_PMWAKEUP,
+ (xdrproc_t)xdr_remote_domain_event_pmwakeup_msg,
&data);
+ } else {
+ remote_domain_event_callback_pmwakeup_msg msg = { callback->callbackID,
+ data };
+
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMWAKEUP,
+
(xdrproc_t)xdr_remote_domain_event_callback_pmwakeup_msg, &msg);
+ }
return 0;
}
@@ -596,9 +696,18 @@ remoteRelayDomainEventPMSuspend(virConnectPtr conn ATTRIBUTE_UNUSED,
memset(&data, 0, sizeof(data));
make_nonnull_domain(&data.dom, dom);
- remoteDispatchObjectEventSend(callback->client, remoteProgram,
- REMOTE_PROC_DOMAIN_EVENT_PMSUSPEND,
- (xdrproc_t)xdr_remote_domain_event_pmsuspend_msg,
&data);
+ if (callback->legacy) {
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
+ REMOTE_PROC_DOMAIN_EVENT_PMSUSPEND,
+ (xdrproc_t)xdr_remote_domain_event_pmsuspend_msg,
&data);
+ } else {
+ remote_domain_event_callback_pmsuspend_msg msg = { callback->callbackID,
+ data };
+
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMSUSPEND,
+
(xdrproc_t)xdr_remote_domain_event_callback_pmsuspend_msg, &msg);
+ }
return 0;
}
@@ -623,9 +732,18 @@ remoteRelayDomainEventBalloonChange(virConnectPtr conn
ATTRIBUTE_UNUSED,
make_nonnull_domain(&data.dom, dom);
data.actual = actual;
- remoteDispatchObjectEventSend(callback->client, remoteProgram,
- REMOTE_PROC_DOMAIN_EVENT_BALLOON_CHANGE,
- (xdrproc_t)xdr_remote_domain_event_balloon_change_msg,
&data);
+ if (callback->legacy) {
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
+ REMOTE_PROC_DOMAIN_EVENT_BALLOON_CHANGE,
+
(xdrproc_t)xdr_remote_domain_event_balloon_change_msg, &data);
+ } else {
+ remote_domain_event_callback_balloon_change_msg msg = { callback->callbackID,
+ data };
+
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_BALLOON_CHANGE,
+
(xdrproc_t)xdr_remote_domain_event_callback_balloon_change_msg, &msg);
+ }
return 0;
}
@@ -650,9 +768,18 @@ remoteRelayDomainEventPMSuspendDisk(virConnectPtr conn
ATTRIBUTE_UNUSED,
memset(&data, 0, sizeof(data));
make_nonnull_domain(&data.dom, dom);
- remoteDispatchObjectEventSend(callback->client, remoteProgram,
- REMOTE_PROC_DOMAIN_EVENT_PMSUSPEND_DISK,
- (xdrproc_t)xdr_remote_domain_event_pmsuspend_disk_msg,
&data);
+ if (callback->legacy) {
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
+ REMOTE_PROC_DOMAIN_EVENT_PMSUSPEND_DISK,
+
(xdrproc_t)xdr_remote_domain_event_pmsuspend_disk_msg, &data);
+ } else {
+ remote_domain_event_callback_pmsuspend_disk_msg msg = { callback->callbackID,
+ data };
+
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMSUSPEND_DISK,
+
(xdrproc_t)xdr_remote_domain_event_callback_pmsuspend_disk_msg, &msg);
+ }
return 0;
}
@@ -680,10 +807,20 @@ remoteRelayDomainEventDeviceRemoved(virConnectPtr conn
ATTRIBUTE_UNUSED,
make_nonnull_domain(&data.dom, dom);
- remoteDispatchObjectEventSend(callback->client, remoteProgram,
- REMOTE_PROC_DOMAIN_EVENT_DEVICE_REMOVED,
- (xdrproc_t)xdr_remote_domain_event_device_removed_msg,
- &data);
+ if (callback->legacy) {
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
+ REMOTE_PROC_DOMAIN_EVENT_DEVICE_REMOVED,
+
(xdrproc_t)xdr_remote_domain_event_device_removed_msg,
+ &data);
+ } else {
+ remote_domain_event_callback_device_removed_msg msg = { callback->callbackID,
+ data };
+
+ remoteDispatchObjectEventSend(callback->client, remoteProgram,
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_DEVICE_REMOVED,
+
(xdrproc_t)xdr_remote_domain_event_callback_device_removed_msg,
+ &msg);
+ }
return 0;
}
@@ -3514,8 +3651,7 @@ remoteDispatchConnectDomainEventCallbackRegisterAny(virNetServerPtr
server ATTRI
!(dom = get_nonnull_domain(priv->conn, *args->dom)))
goto cleanup;
- /* FIXME: support all domain events */
- if (args->eventID != VIR_DOMAIN_EVENT_ID_LIFECYCLE) {
+ if (args->eventID >= VIR_DOMAIN_EVENT_ID_LAST || args->eventID < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, _("unsupported event ID %d"),
args->eventID);
goto cleanup;
diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c
index 35baaeb..4cdce81 100644
--- a/src/remote/remote_driver.c
+++ b/src/remote/remote_driver.c
@@ -218,67 +218,136 @@ remoteDomainBuildEventReboot(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,
virNetClientPtr client ATTRIBUTE_UNUSED,
void *evdata, void *opaque);
static void
+remoteDomainBuildEventCallbackReboot(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+ virNetClientPtr client ATTRIBUTE_UNUSED,
+ void *evdata, void *opaque);
+
+static void
remoteDomainBuildEventRTCChange(virNetClientProgramPtr prog,
virNetClientPtr client,
void *evdata, void *opaque);
static void
+remoteDomainBuildEventCallbackRTCChange(virNetClientProgramPtr prog,
+ virNetClientPtr client,
+ void *evdata, void *opaque);
+
+static void
remoteDomainBuildEventWatchdog(virNetClientProgramPtr prog,
virNetClientPtr client,
void *evdata, void *opaque);
static void
+remoteDomainBuildEventCallbackWatchdog(virNetClientProgramPtr prog,
+ virNetClientPtr client,
+ void *evdata, void *opaque);
+
+static void
remoteDomainBuildEventIOError(virNetClientProgramPtr prog,
virNetClientPtr client,
void *evdata, void *opaque);
static void
+remoteDomainBuildEventCallbackIOError(virNetClientProgramPtr prog,
+ virNetClientPtr client,
+ void *evdata, void *opaque);
+
+static void
remoteDomainBuildEventIOErrorReason(virNetClientProgramPtr prog,
virNetClientPtr client,
void *evdata, void *opaque);
static void
+remoteDomainBuildEventCallbackIOErrorReason(virNetClientProgramPtr prog,
+ virNetClientPtr client,
+ void *evdata, void *opaque);
+
+static void
remoteDomainBuildEventGraphics(virNetClientProgramPtr prog,
virNetClientPtr client,
void *evdata, void *opaque);
static void
+remoteDomainBuildEventCallbackGraphics(virNetClientProgramPtr prog,
+ virNetClientPtr client,
+ void *evdata, void *opaque);
+
+static void
remoteDomainBuildEventControlError(virNetClientProgramPtr prog,
virNetClientPtr client,
void *evdata, void *opaque);
+static void
+remoteDomainBuildEventCallbackControlError(virNetClientProgramPtr prog,
+ virNetClientPtr client,
+ void *evdata, void *opaque);
static void
remoteDomainBuildEventBlockJob(virNetClientProgramPtr prog,
virNetClientPtr client,
void *evdata, void *opaque);
+static void
+remoteDomainBuildEventCallbackBlockJob(virNetClientProgramPtr prog,
+ virNetClientPtr client,
+ void *evdata, void *opaque);
+
static void
remoteDomainBuildEventDiskChange(virNetClientProgramPtr prog,
virNetClientPtr client,
void *evdata, void *opaque);
+static void
+remoteDomainBuildEventCallbackDiskChange(virNetClientProgramPtr prog,
+ virNetClientPtr client,
+ void *evdata, void *opaque);
static void
remoteDomainBuildEventTrayChange(virNetClientProgramPtr prog,
virNetClientPtr client,
void *evdata, void *opaque);
+static void
+remoteDomainBuildEventCallbackTrayChange(virNetClientProgramPtr prog,
+ virNetClientPtr client,
+ void *evdata, void *opaque);
static void
remoteDomainBuildEventPMWakeup(virNetClientProgramPtr prog,
virNetClientPtr client,
void *evdata, void *opaque);
+static void
+remoteDomainBuildEventCallbackPMWakeup(virNetClientProgramPtr prog,
+ virNetClientPtr client,
+ void *evdata, void *opaque);
static void
remoteDomainBuildEventPMSuspend(virNetClientProgramPtr prog,
virNetClientPtr client,
void *evdata, void *opaque);
static void
+remoteDomainBuildEventCallbackPMSuspend(virNetClientProgramPtr prog,
+ virNetClientPtr client,
+ void *evdata, void *opaque);
+
+static void
remoteDomainBuildEventBalloonChange(virNetClientProgramPtr prog,
virNetClientPtr client,
void *evdata, void *opaque);
static void
+remoteDomainBuildEventCallbackBalloonChange(virNetClientProgramPtr prog,
+ virNetClientPtr client,
+ void *evdata, void *opaque);
+
+static void
remoteDomainBuildEventPMSuspendDisk(virNetClientProgramPtr prog,
virNetClientPtr client,
void *evdata, void *opaque);
+static void
+remoteDomainBuildEventCallbackPMSuspendDisk(virNetClientProgramPtr prog,
+ virNetClientPtr client,
+ void *evdata, void *opaque);
static void
remoteDomainBuildEventDeviceRemoved(virNetClientProgramPtr prog,
virNetClientPtr client,
void *evdata, void *opaque);
+static void
+remoteDomainBuildEventCallbackDeviceRemoved(virNetClientProgramPtr prog,
+ virNetClientPtr client,
+ void *evdata, void *opaque);
static void
remoteNetworkBuildEventLifecycle(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
@@ -286,18 +355,18 @@ remoteNetworkBuildEventLifecycle(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,
void *evdata, void *opaque);
static virNetClientProgramEvent remoteEvents[] = {
- { REMOTE_PROC_DOMAIN_EVENT_RTC_CHANGE,
- remoteDomainBuildEventRTCChange,
- sizeof(remote_domain_event_rtc_change_msg),
- (xdrproc_t)xdr_remote_domain_event_rtc_change_msg },
- { REMOTE_PROC_DOMAIN_EVENT_REBOOT,
- remoteDomainBuildEventReboot,
- sizeof(remote_domain_event_reboot_msg),
- (xdrproc_t)xdr_remote_domain_event_reboot_msg },
{ REMOTE_PROC_DOMAIN_EVENT_LIFECYCLE,
remoteDomainBuildEventLifecycle,
sizeof(remote_domain_event_lifecycle_msg),
(xdrproc_t)xdr_remote_domain_event_lifecycle_msg },
+ { REMOTE_PROC_DOMAIN_EVENT_REBOOT,
+ remoteDomainBuildEventReboot,
+ sizeof(remote_domain_event_reboot_msg),
+ (xdrproc_t)xdr_remote_domain_event_reboot_msg },
+ { REMOTE_PROC_DOMAIN_EVENT_RTC_CHANGE,
+ remoteDomainBuildEventRTCChange,
+ sizeof(remote_domain_event_rtc_change_msg),
+ (xdrproc_t)xdr_remote_domain_event_rtc_change_msg },
{ REMOTE_PROC_DOMAIN_EVENT_WATCHDOG,
remoteDomainBuildEventWatchdog,
sizeof(remote_domain_event_watchdog_msg),
@@ -306,14 +375,14 @@ static virNetClientProgramEvent remoteEvents[] = {
remoteDomainBuildEventIOError,
sizeof(remote_domain_event_io_error_msg),
(xdrproc_t)xdr_remote_domain_event_io_error_msg },
- { REMOTE_PROC_DOMAIN_EVENT_IO_ERROR_REASON,
- remoteDomainBuildEventIOErrorReason,
- sizeof(remote_domain_event_io_error_reason_msg),
- (xdrproc_t)xdr_remote_domain_event_io_error_reason_msg },
{ REMOTE_PROC_DOMAIN_EVENT_GRAPHICS,
remoteDomainBuildEventGraphics,
sizeof(remote_domain_event_graphics_msg),
(xdrproc_t)xdr_remote_domain_event_graphics_msg },
+ { REMOTE_PROC_DOMAIN_EVENT_IO_ERROR_REASON,
+ remoteDomainBuildEventIOErrorReason,
+ sizeof(remote_domain_event_io_error_reason_msg),
+ (xdrproc_t)xdr_remote_domain_event_io_error_reason_msg },
{ REMOTE_PROC_DOMAIN_EVENT_CONTROL_ERROR,
remoteDomainBuildEventControlError,
sizeof(remote_domain_event_control_error_msg),
@@ -367,6 +436,66 @@ static virNetClientProgramEvent remoteEvents[] = {
remoteDomainBuildEventCallbackLifecycle,
sizeof(remote_domain_event_callback_lifecycle_msg),
(xdrproc_t)xdr_remote_domain_event_callback_lifecycle_msg },
+ { REMOTE_PROC_DOMAIN_EVENT_CALLBACK_REBOOT,
+ remoteDomainBuildEventCallbackReboot,
+ sizeof(remote_domain_event_callback_reboot_msg),
+ (xdrproc_t)xdr_remote_domain_event_callback_reboot_msg },
+ { REMOTE_PROC_DOMAIN_EVENT_CALLBACK_RTC_CHANGE,
+ remoteDomainBuildEventCallbackRTCChange,
+ sizeof(remote_domain_event_callback_rtc_change_msg),
+ (xdrproc_t)xdr_remote_domain_event_callback_rtc_change_msg },
+ { REMOTE_PROC_DOMAIN_EVENT_CALLBACK_WATCHDOG,
+ remoteDomainBuildEventCallbackWatchdog,
+ sizeof(remote_domain_event_callback_watchdog_msg),
+ (xdrproc_t)xdr_remote_domain_event_callback_watchdog_msg},
+ { REMOTE_PROC_DOMAIN_EVENT_CALLBACK_IO_ERROR,
+ remoteDomainBuildEventCallbackIOError,
+ sizeof(remote_domain_event_callback_io_error_msg),
+ (xdrproc_t)xdr_remote_domain_event_callback_io_error_msg },
+ { REMOTE_PROC_DOMAIN_EVENT_CALLBACK_GRAPHICS,
+ remoteDomainBuildEventCallbackGraphics,
+ sizeof(remote_domain_event_callback_graphics_msg),
+ (xdrproc_t)xdr_remote_domain_event_callback_graphics_msg },
+ { REMOTE_PROC_DOMAIN_EVENT_CALLBACK_IO_ERROR_REASON,
+ remoteDomainBuildEventCallbackIOErrorReason,
+ sizeof(remote_domain_event_callback_io_error_reason_msg),
+ (xdrproc_t)xdr_remote_domain_event_callback_io_error_reason_msg },
+ { REMOTE_PROC_DOMAIN_EVENT_CALLBACK_CONTROL_ERROR,
+ remoteDomainBuildEventCallbackControlError,
+ sizeof(remote_domain_event_callback_control_error_msg),
+ (xdrproc_t)xdr_remote_domain_event_callback_control_error_msg },
+ { REMOTE_PROC_DOMAIN_EVENT_CALLBACK_BLOCK_JOB,
+ remoteDomainBuildEventCallbackBlockJob,
+ sizeof(remote_domain_event_callback_block_job_msg),
+ (xdrproc_t)xdr_remote_domain_event_callback_block_job_msg },
+ { REMOTE_PROC_DOMAIN_EVENT_CALLBACK_DISK_CHANGE,
+ remoteDomainBuildEventCallbackDiskChange,
+ sizeof(remote_domain_event_callback_disk_change_msg),
+ (xdrproc_t)xdr_remote_domain_event_callback_disk_change_msg },
+ { REMOTE_PROC_DOMAIN_EVENT_CALLBACK_TRAY_CHANGE,
+ remoteDomainBuildEventCallbackTrayChange,
+ sizeof(remote_domain_event_callback_tray_change_msg),
+ (xdrproc_t)xdr_remote_domain_event_callback_tray_change_msg },
+ { REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMWAKEUP,
+ remoteDomainBuildEventCallbackPMWakeup,
+ sizeof(remote_domain_event_callback_pmwakeup_msg),
+ (xdrproc_t)xdr_remote_domain_event_callback_pmwakeup_msg },
+ { REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMSUSPEND,
+ remoteDomainBuildEventCallbackPMSuspend,
+ sizeof(remote_domain_event_callback_pmsuspend_msg),
+ (xdrproc_t)xdr_remote_domain_event_callback_pmsuspend_msg },
+ { REMOTE_PROC_DOMAIN_EVENT_CALLBACK_BALLOON_CHANGE,
+ remoteDomainBuildEventCallbackBalloonChange,
+ sizeof(remote_domain_event_callback_balloon_change_msg),
+ (xdrproc_t)xdr_remote_domain_event_callback_balloon_change_msg },
+ { REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMSUSPEND_DISK,
+ remoteDomainBuildEventCallbackPMSuspendDisk,
+ sizeof(remote_domain_event_callback_pmsuspend_disk_msg),
+ (xdrproc_t)xdr_remote_domain_event_callback_pmsuspend_disk_msg },
+ { REMOTE_PROC_DOMAIN_EVENT_CALLBACK_DEVICE_REMOVED,
+ remoteDomainBuildEventCallbackDeviceRemoved,
+ sizeof(remote_domain_event_callback_device_removed_msg),
+ (xdrproc_t)xdr_remote_domain_event_callback_device_removed_msg },
};
enum virDrvOpenRemoteFlags {
@@ -4609,13 +4738,11 @@ remoteDomainBuildEventCallbackLifecycle(virNetClientProgramPtr
prog ATTRIBUTE_UN
static void
-remoteDomainBuildEventReboot(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
- virNetClientPtr client ATTRIBUTE_UNUSED,
- void *evdata, void *opaque)
+remoteDomainBuildEventRebootHelper(virConnectPtr conn,
+ remote_domain_event_reboot_msg *msg,
+ int callbackID)
{
- virConnectPtr conn = opaque;
struct private_data *priv = conn->privateData;
- remote_domain_event_reboot_msg *msg = evdata;
virDomainPtr dom;
virObjectEventPtr event = NULL;
@@ -4626,18 +4753,33 @@ remoteDomainBuildEventReboot(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,
event = virDomainEventRebootNewFromDom(dom);
virDomainFree(dom);
- remoteEventQueue(priv, event, -1);
+ remoteEventQueue(priv, event, callbackID);
}
-
-
static void
-remoteDomainBuildEventRTCChange(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
- virNetClientPtr client ATTRIBUTE_UNUSED,
- void *evdata, void *opaque)
+remoteDomainBuildEventReboot(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+ virNetClientPtr client ATTRIBUTE_UNUSED,
+ void *evdata, void *opaque)
+{
+ virConnectPtr conn = opaque;
+ remote_domain_event_reboot_msg *msg = evdata;
+ remoteDomainBuildEventRebootHelper(conn, msg, -1);
+}
+static void
+remoteDomainBuildEventCallbackReboot(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+ virNetClientPtr client ATTRIBUTE_UNUSED,
+ void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
+ remote_domain_event_callback_reboot_msg *msg = evdata;
+ remoteDomainBuildEventRebootHelper(conn, &msg->msg, msg->callbackID);
+}
+
+static void
+remoteDomainBuildEventRTCChangeHelper(virConnectPtr conn,
+ remote_domain_event_rtc_change_msg *msg,
+ int callbackID)
+{
struct private_data *priv = conn->privateData;
- remote_domain_event_rtc_change_msg *msg = evdata;
virDomainPtr dom;
virObjectEventPtr event = NULL;
@@ -4648,18 +4790,33 @@ remoteDomainBuildEventRTCChange(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,
event = virDomainEventRTCChangeNewFromDom(dom, msg->offset);
virDomainFree(dom);
- remoteEventQueue(priv, event, -1);
+ remoteEventQueue(priv, event, callbackID);
}
-
-
static void
-remoteDomainBuildEventWatchdog(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
- virNetClientPtr client ATTRIBUTE_UNUSED,
- void *evdata, void *opaque)
+remoteDomainBuildEventRTCChange(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+ virNetClientPtr client ATTRIBUTE_UNUSED,
+ void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
+ remote_domain_event_rtc_change_msg *msg = evdata;
+ remoteDomainBuildEventRTCChangeHelper(conn, msg, -1);
+}
+static void
+remoteDomainBuildEventCallbackRTCChange(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+ virNetClientPtr client ATTRIBUTE_UNUSED,
+ void *evdata, void *opaque)
+{
+ virConnectPtr conn = opaque;
+ remote_domain_event_callback_rtc_change_msg *msg = evdata;
+ remoteDomainBuildEventRTCChangeHelper(conn, &msg->msg, msg->callbackID);
+}
+
+static void
+remoteDomainBuildEventWatchdogHelper(virConnectPtr conn,
+ remote_domain_event_watchdog_msg *msg,
+ int callbackID)
+{
struct private_data *priv = conn->privateData;
- remote_domain_event_watchdog_msg *msg = evdata;
virDomainPtr dom;
virObjectEventPtr event = NULL;
@@ -4670,18 +4827,33 @@ remoteDomainBuildEventWatchdog(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,
event = virDomainEventWatchdogNewFromDom(dom, msg->action);
virDomainFree(dom);
- remoteEventQueue(priv, event, -1);
+ remoteEventQueue(priv, event, callbackID);
}
-
-
static void
-remoteDomainBuildEventIOError(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
- virNetClientPtr client ATTRIBUTE_UNUSED,
- void *evdata, void *opaque)
+remoteDomainBuildEventWatchdog(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+ virNetClientPtr client ATTRIBUTE_UNUSED,
+ void *evdata, void *opaque)
+{
+ virConnectPtr conn = opaque;
+ remote_domain_event_watchdog_msg *msg = evdata;
+ remoteDomainBuildEventWatchdogHelper(conn, msg, -1);
+}
+static void
+remoteDomainBuildEventCallbackWatchdog(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+ virNetClientPtr client ATTRIBUTE_UNUSED,
+ void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
+ remote_domain_event_callback_watchdog_msg *msg = evdata;
+ remoteDomainBuildEventWatchdogHelper(conn, &msg->msg, msg->callbackID);
+}
+
+static void
+remoteDomainBuildEventIOErrorHelper(virConnectPtr conn,
+ remote_domain_event_io_error_msg *msg,
+ int callbackID)
+{
struct private_data *priv = conn->privateData;
- remote_domain_event_io_error_msg *msg = evdata;
virDomainPtr dom;
virObjectEventPtr event = NULL;
@@ -4695,18 +4867,33 @@ remoteDomainBuildEventIOError(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,
msg->action);
virDomainFree(dom);
- remoteEventQueue(priv, event, -1);
+ remoteEventQueue(priv, event, callbackID);
}
-
-
static void
-remoteDomainBuildEventIOErrorReason(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
- virNetClientPtr client ATTRIBUTE_UNUSED,
- void *evdata, void *opaque)
+remoteDomainBuildEventIOError(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+ virNetClientPtr client ATTRIBUTE_UNUSED,
+ void *evdata, void *opaque)
+{
+ virConnectPtr conn = opaque;
+ remote_domain_event_io_error_msg *msg = evdata;
+ remoteDomainBuildEventIOErrorHelper(conn, msg, -1);
+}
+static void
+remoteDomainBuildEventCallbackIOError(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+ virNetClientPtr client ATTRIBUTE_UNUSED,
+ void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
+ remote_domain_event_callback_io_error_msg *msg = evdata;
+ remoteDomainBuildEventIOErrorHelper(conn, &msg->msg, msg->callbackID);
+}
+
+static void
+remoteDomainBuildEventIOErrorReasonHelper(virConnectPtr conn,
+ remote_domain_event_io_error_reason_msg *msg,
+ int callbackID)
+{
struct private_data *priv = conn->privateData;
- remote_domain_event_io_error_reason_msg *msg = evdata;
virDomainPtr dom;
virObjectEventPtr event = NULL;
@@ -4722,17 +4909,33 @@ remoteDomainBuildEventIOErrorReason(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED
virDomainFree(dom);
- remoteEventQueue(priv, event, -1);
+ remoteEventQueue(priv, event, callbackID);
}
-
static void
-remoteDomainBuildEventBlockJob(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
- virNetClientPtr client ATTRIBUTE_UNUSED,
- void *evdata, void *opaque)
+remoteDomainBuildEventIOErrorReason(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+ virNetClientPtr client ATTRIBUTE_UNUSED,
+ void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
+ remote_domain_event_io_error_reason_msg *msg = evdata;
+ remoteDomainBuildEventIOErrorReasonHelper(conn, msg, -1);
+}
+static void
+remoteDomainBuildEventCallbackIOErrorReason(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,
+ virNetClientPtr client ATTRIBUTE_UNUSED,
+ void *evdata, void *opaque)
+{
+ virConnectPtr conn = opaque;
+ remote_domain_event_callback_io_error_reason_msg *msg = evdata;
+ remoteDomainBuildEventIOErrorReasonHelper(conn, &msg->msg,
msg->callbackID);
+}
+
+static void
+remoteDomainBuildEventBlockJobHelper(virConnectPtr conn,
+ remote_domain_event_block_job_msg *msg,
+ int callbackID)
+{
struct private_data *priv = conn->privateData;
- remote_domain_event_block_job_msg *msg = evdata;
virDomainPtr dom;
virObjectEventPtr event = NULL;
@@ -4745,17 +4948,33 @@ remoteDomainBuildEventBlockJob(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,
virDomainFree(dom);
- remoteEventQueue(priv, event, -1);
+ remoteEventQueue(priv, event, callbackID);
}
-
static void
-remoteDomainBuildEventGraphics(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+remoteDomainBuildEventBlockJob(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
virNetClientPtr client ATTRIBUTE_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
+ remote_domain_event_block_job_msg *msg = evdata;
+ remoteDomainBuildEventBlockJobHelper(conn, msg, -1);
+}
+static void
+remoteDomainBuildEventCallbackBlockJob(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+ virNetClientPtr client ATTRIBUTE_UNUSED,
+ void *evdata, void *opaque)
+{
+ virConnectPtr conn = opaque;
+ remote_domain_event_callback_block_job_msg *msg = evdata;
+ remoteDomainBuildEventBlockJobHelper(conn, &msg->msg, msg->callbackID);
+}
+
+static void
+remoteDomainBuildEventGraphicsHelper(virConnectPtr conn,
+ remote_domain_event_graphics_msg *msg,
+ int callbackID)
+{
struct private_data *priv = conn->privateData;
- remote_domain_event_graphics_msg *msg = evdata;
virDomainPtr dom;
virObjectEventPtr event = NULL;
virDomainEventGraphicsAddressPtr localAddr = NULL;
@@ -4801,7 +5020,7 @@ remoteDomainBuildEventGraphics(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,
virDomainFree(dom);
- remoteEventQueue(priv, event, -1);
+ remoteEventQueue(priv, event, callbackID);
return;
error:
@@ -4826,16 +5045,31 @@ error:
virDomainFree(dom);
return;
}
-
-
static void
-remoteDomainBuildEventControlError(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
- virNetClientPtr client ATTRIBUTE_UNUSED,
- void *evdata, void *opaque)
+remoteDomainBuildEventGraphics(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+ virNetClientPtr client ATTRIBUTE_UNUSED,
+ void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
+ remote_domain_event_graphics_msg *msg = evdata;
+ remoteDomainBuildEventGraphicsHelper(conn, msg, -1);
+}
+static void
+remoteDomainBuildEventCallbackGraphics(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+ virNetClientPtr client ATTRIBUTE_UNUSED,
+ void *evdata, void *opaque)
+{
+ virConnectPtr conn = opaque;
+ remote_domain_event_callback_graphics_msg *msg = evdata;
+ remoteDomainBuildEventGraphicsHelper(conn, &msg->msg, msg->callbackID);
+}
+
+static void
+remoteDomainBuildEventControlErrorHelper(virConnectPtr conn,
+ remote_domain_event_control_error_msg *msg,
+ int callbackID)
+{
struct private_data *priv = conn->privateData;
- remote_domain_event_control_error_msg *msg = evdata;
virDomainPtr dom;
virObjectEventPtr event = NULL;
@@ -4847,18 +5081,34 @@ remoteDomainBuildEventControlError(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,
virDomainFree(dom);
- remoteEventQueue(priv, event, -1);
+ remoteEventQueue(priv, event, callbackID);
+}
+static void
+remoteDomainBuildEventControlError(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+ virNetClientPtr client ATTRIBUTE_UNUSED,
+ void *evdata, void *opaque)
+{
+ virConnectPtr conn = opaque;
+ remote_domain_event_control_error_msg *msg = evdata;
+ remoteDomainBuildEventControlErrorHelper(conn, msg, -1);
+}
+static void
+remoteDomainBuildEventCallbackControlError(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+ virNetClientPtr client ATTRIBUTE_UNUSED,
+ void *evdata, void *opaque)
+{
+ virConnectPtr conn = opaque;
+ remote_domain_event_callback_control_error_msg *msg = evdata;
+ remoteDomainBuildEventControlErrorHelper(conn, &msg->msg,
msg->callbackID);
}
static void
-remoteDomainBuildEventDiskChange(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
- virNetClientPtr client ATTRIBUTE_UNUSED,
- void *evdata, void *opaque)
+remoteDomainBuildEventDiskChangeHelper(virConnectPtr conn,
+ remote_domain_event_disk_change_msg *msg,
+ int callbackID)
{
- virConnectPtr conn = opaque;
struct private_data *priv = conn->privateData;
- remote_domain_event_disk_change_msg *msg = evdata;
virDomainPtr dom;
virObjectEventPtr event = NULL;
@@ -4874,18 +5124,34 @@ remoteDomainBuildEventDiskChange(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,
virDomainFree(dom);
- remoteEventQueue(priv, event, -1);
+ remoteEventQueue(priv, event, callbackID);
}
-
-
static void
-remoteDomainBuildEventTrayChange(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+remoteDomainBuildEventDiskChange(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
virNetClientPtr client ATTRIBUTE_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
+ remote_domain_event_disk_change_msg *msg = evdata;
+ remoteDomainBuildEventDiskChangeHelper(conn, msg, -1);
+}
+static void
+remoteDomainBuildEventCallbackDiskChange(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+ virNetClientPtr client ATTRIBUTE_UNUSED,
+ void *evdata, void *opaque)
+{
+ virConnectPtr conn = opaque;
+ remote_domain_event_callback_disk_change_msg *msg = evdata;
+ remoteDomainBuildEventDiskChangeHelper(conn, &msg->msg, msg->callbackID);
+}
+
+
+static void
+remoteDomainBuildEventTrayChangeHelper(virConnectPtr conn,
+ remote_domain_event_tray_change_msg *msg,
+ int callbackID)
+{
struct private_data *priv = conn->privateData;
- remote_domain_event_tray_change_msg *msg = evdata;
virDomainPtr dom;
virObjectEventPtr event = NULL;
@@ -4899,17 +5165,33 @@ remoteDomainBuildEventTrayChange(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,
virDomainFree(dom);
- remoteEventQueue(priv, event, -1);
+ remoteEventQueue(priv, event, callbackID);
}
-
static void
-remoteDomainBuildEventPMWakeup(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
- virNetClientPtr client ATTRIBUTE_UNUSED,
- void *evdata, void *opaque)
+remoteDomainBuildEventTrayChange(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+ virNetClientPtr client ATTRIBUTE_UNUSED,
+ void *evdata, void *opaque)
+{
+ virConnectPtr conn = opaque;
+ remote_domain_event_tray_change_msg *msg = evdata;
+ remoteDomainBuildEventTrayChangeHelper(conn, msg, -1);
+}
+static void
+remoteDomainBuildEventCallbackTrayChange(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+ virNetClientPtr client ATTRIBUTE_UNUSED,
+ void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
+ remote_domain_event_callback_tray_change_msg *msg = evdata;
+ remoteDomainBuildEventTrayChangeHelper(conn, &msg->msg, msg->callbackID);
+}
+
+static void
+remoteDomainBuildEventPMWakeupHelper(virConnectPtr conn,
+ remote_domain_event_pmwakeup_msg *msg,
+ int callbackID)
+{
struct private_data *priv = conn->privateData;
- remote_domain_event_pmwakeup_msg *msg = evdata;
virDomainPtr dom;
virObjectEventPtr event = NULL;
@@ -4921,17 +5203,33 @@ remoteDomainBuildEventPMWakeup(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,
virDomainFree(dom);
- remoteEventQueue(priv, event, -1);
+ remoteEventQueue(priv, event, callbackID);
}
-
static void
-remoteDomainBuildEventPMSuspend(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
- virNetClientPtr client ATTRIBUTE_UNUSED,
- void *evdata, void *opaque)
+remoteDomainBuildEventPMWakeup(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+ virNetClientPtr client ATTRIBUTE_UNUSED,
+ void *evdata, void *opaque)
+{
+ virConnectPtr conn = opaque;
+ remote_domain_event_pmwakeup_msg *msg = evdata;
+ remoteDomainBuildEventPMWakeupHelper(conn, msg, -1);
+}
+static void
+remoteDomainBuildEventCallbackPMWakeup(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+ virNetClientPtr client ATTRIBUTE_UNUSED,
+ void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
+ remote_domain_event_callback_pmwakeup_msg *msg = evdata;
+ remoteDomainBuildEventPMWakeupHelper(conn, &msg->msg, msg->callbackID);
+}
+
+static void
+remoteDomainBuildEventPMSuspendHelper(virConnectPtr conn,
+ remote_domain_event_pmsuspend_msg *msg,
+ int callbackID)
+{
struct private_data *priv = conn->privateData;
- remote_domain_event_pmsuspend_msg *msg = evdata;
virDomainPtr dom;
virObjectEventPtr event = NULL;
@@ -4943,18 +5241,34 @@ remoteDomainBuildEventPMSuspend(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,
virDomainFree(dom);
- remoteEventQueue(priv, event, -1);
+ remoteEventQueue(priv, event, callbackID);
+}
+static void
+remoteDomainBuildEventPMSuspend(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+ virNetClientPtr client ATTRIBUTE_UNUSED,
+ void *evdata, void *opaque)
+{
+ virConnectPtr conn = opaque;
+ remote_domain_event_pmsuspend_msg *msg = evdata;
+ remoteDomainBuildEventPMSuspendHelper(conn, msg, -1);
+}
+static void
+remoteDomainBuildEventCallbackPMSuspend(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+ virNetClientPtr client ATTRIBUTE_UNUSED,
+ void *evdata, void *opaque)
+{
+ virConnectPtr conn = opaque;
+ remote_domain_event_callback_pmsuspend_msg *msg = evdata;
+ remoteDomainBuildEventPMSuspendHelper(conn, &msg->msg, msg->callbackID);
}
static void
-remoteDomainBuildEventBalloonChange(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
- virNetClientPtr client ATTRIBUTE_UNUSED,
- void *evdata, void *opaque)
+remoteDomainBuildEventBalloonChangeHelper(virConnectPtr conn,
+ remote_domain_event_balloon_change_msg *msg,
+ int callbackID)
{
- virConnectPtr conn = opaque;
struct private_data *priv = conn->privateData;
- remote_domain_event_balloon_change_msg *msg = evdata;
virDomainPtr dom;
virObjectEventPtr event = NULL;
@@ -4965,18 +5279,34 @@ remoteDomainBuildEventBalloonChange(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED
event = virDomainEventBalloonChangeNewFromDom(dom, msg->actual);
virDomainFree(dom);
- remoteEventQueue(priv, event, -1);
+ remoteEventQueue(priv, event, callbackID);
}
-
-
static void
-remoteDomainBuildEventPMSuspendDisk(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+remoteDomainBuildEventBalloonChange(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
virNetClientPtr client ATTRIBUTE_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
+ remote_domain_event_balloon_change_msg *msg = evdata;
+ remoteDomainBuildEventBalloonChangeHelper(conn, msg, -1);
+}
+static void
+remoteDomainBuildEventCallbackBalloonChange(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,
+ virNetClientPtr client ATTRIBUTE_UNUSED,
+ void *evdata, void *opaque)
+{
+ virConnectPtr conn = opaque;
+ remote_domain_event_callback_balloon_change_msg *msg = evdata;
+ remoteDomainBuildEventBalloonChangeHelper(conn, &msg->msg,
msg->callbackID);
+}
+
+
+static void
+remoteDomainBuildEventPMSuspendDiskHelper(virConnectPtr conn,
+ remote_domain_event_pmsuspend_disk_msg *msg,
+ int callbackID)
+{
struct private_data *priv = conn->privateData;
- remote_domain_event_pmsuspend_disk_msg *msg = evdata;
virDomainPtr dom;
virObjectEventPtr event = NULL;
@@ -4988,18 +5318,34 @@ remoteDomainBuildEventPMSuspendDisk(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED
virDomainFree(dom);
- remoteEventQueue(priv, event, -1);
+ remoteEventQueue(priv, event, callbackID);
}
-
-
static void
-remoteDomainBuildEventDeviceRemoved(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+remoteDomainBuildEventPMSuspendDisk(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
virNetClientPtr client ATTRIBUTE_UNUSED,
void *evdata, void *opaque)
{
virConnectPtr conn = opaque;
+ remote_domain_event_pmsuspend_disk_msg *msg = evdata;
+ remoteDomainBuildEventPMSuspendDiskHelper(conn, msg, -1);
+}
+static void
+remoteDomainBuildEventCallbackPMSuspendDisk(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,
+ virNetClientPtr client ATTRIBUTE_UNUSED,
+ void *evdata, void *opaque)
+{
+ virConnectPtr conn = opaque;
+ remote_domain_event_callback_pmsuspend_disk_msg *msg = evdata;
+ remoteDomainBuildEventPMSuspendDiskHelper(conn, &msg->msg,
msg->callbackID);
+}
+
+
+static void
+remoteDomainBuildEventDeviceRemovedHelper(virConnectPtr conn,
+ remote_domain_event_device_removed_msg *msg,
+ int callbackID)
+{
struct private_data *priv = conn->privateData;
- remote_domain_event_device_removed_msg *msg = evdata;
virDomainPtr dom;
virObjectEventPtr event = NULL;
@@ -5011,7 +5357,25 @@ remoteDomainBuildEventDeviceRemoved(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED
virDomainFree(dom);
- remoteEventQueue(priv, event, -1);
+ remoteEventQueue(priv, event, callbackID);
+}
+static void
+remoteDomainBuildEventDeviceRemoved(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+ virNetClientPtr client ATTRIBUTE_UNUSED,
+ void *evdata, void *opaque)
+{
+ virConnectPtr conn = opaque;
+ remote_domain_event_device_removed_msg *msg = evdata;
+ remoteDomainBuildEventDeviceRemovedHelper(conn, msg, -1);
+}
+static void
+remoteDomainBuildEventCallbackDeviceRemoved(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,
+ virNetClientPtr client ATTRIBUTE_UNUSED,
+ void *evdata, void *opaque)
+{
+ virConnectPtr conn = opaque;
+ remote_domain_event_callback_device_removed_msg *msg = evdata;
+ remoteDomainBuildEventDeviceRemovedHelper(conn, &msg->msg,
msg->callbackID);
}
@@ -5341,25 +5705,20 @@ remoteConnectDomainEventRegisterAny(virConnectPtr conn,
int callbackID;
int count;
remote_nonnull_domain domain;
- bool serverFilter;
remoteDriverLock(priv);
- serverFilter = priv->serverEventFilter;
- /* FIXME support more than just lifecycle events */
- serverFilter &= eventID == VIR_DOMAIN_EVENT_ID_LIFECYCLE;
-
if ((count = virDomainEventStateRegisterClient(conn, priv->eventState,
dom, eventID, callback,
opaque, freecb, false,
&callbackID,
- serverFilter)) < 0)
+ priv->serverEventFilter)) < 0)
goto done;
/* If this is the first callback for this eventID, we need to enable
* events on the server */
if (count == 1) {
- if (serverFilter) {
+ if (priv->serverEventFilter) {
remote_connect_domain_event_callback_register_any_args args;
remote_connect_domain_event_callback_register_any_ret ret;
@@ -5426,10 +5785,8 @@ remoteConnectDomainEventDeregisterAny(virConnectPtr conn,
/* If that was the last callback for this eventID, we need to disable
* events on the server */
- /* FIXME support more than just lifecycle events */
if (count == 0) {
- if (priv->serverEventFilter &&
- eventID == VIR_DOMAIN_EVENT_ID_LIFECYCLE) {
+ if (priv->serverEventFilter) {
remote_connect_domain_event_callback_deregister_any_args args;
args.callbackID = remoteID;
diff --git a/src/remote/remote_protocol.x b/src/remote/remote_protocol.x
index 96838ba..5a82395 100644
--- a/src/remote/remote_protocol.x
+++ b/src/remote/remote_protocol.x
@@ -2268,16 +2268,28 @@ struct remote_connect_domain_event_callback_deregister_any_args {
struct remote_domain_event_reboot_msg {
remote_nonnull_domain dom;
};
+struct remote_domain_event_callback_reboot_msg {
+ int callbackID;
+ remote_domain_event_reboot_msg msg;
+};
struct remote_domain_event_rtc_change_msg {
remote_nonnull_domain dom;
hyper offset;
};
+struct remote_domain_event_callback_rtc_change_msg {
+ int callbackID;
+ remote_domain_event_rtc_change_msg msg;
+};
struct remote_domain_event_watchdog_msg {
remote_nonnull_domain dom;
int action;
};
+struct remote_domain_event_callback_watchdog_msg {
+ int callbackID;
+ remote_domain_event_watchdog_msg msg;
+};
struct remote_domain_event_io_error_msg {
remote_nonnull_domain dom;
@@ -2285,6 +2297,10 @@ struct remote_domain_event_io_error_msg {
remote_nonnull_string devAlias;
int action;
};
+struct remote_domain_event_callback_io_error_msg {
+ int callbackID;
+ remote_domain_event_io_error_msg msg;
+};
struct remote_domain_event_io_error_reason_msg {
remote_nonnull_domain dom;
@@ -2293,6 +2309,10 @@ struct remote_domain_event_io_error_reason_msg {
int action;
remote_nonnull_string reason;
};
+struct remote_domain_event_callback_io_error_reason_msg {
+ int callbackID;
+ remote_domain_event_io_error_reason_msg msg;
+};
struct remote_domain_event_graphics_address {
int family;
@@ -2315,6 +2335,10 @@ struct remote_domain_event_graphics_msg {
remote_nonnull_string authScheme;
remote_domain_event_graphics_identity
subject<REMOTE_DOMAIN_EVENT_GRAPHICS_IDENTITY_MAX>;
};
+struct remote_domain_event_callback_graphics_msg {
+ int callbackID;
+ remote_domain_event_graphics_msg msg;
+};
struct remote_domain_event_block_job_msg {
remote_nonnull_domain dom;
@@ -2322,6 +2346,10 @@ struct remote_domain_event_block_job_msg {
int type;
int status;
};
+struct remote_domain_event_callback_block_job_msg {
+ int callbackID;
+ remote_domain_event_block_job_msg msg;
+};
struct remote_domain_event_disk_change_msg {
remote_nonnull_domain dom;
@@ -2330,29 +2358,53 @@ struct remote_domain_event_disk_change_msg {
remote_nonnull_string devAlias;
int reason;
};
+struct remote_domain_event_callback_disk_change_msg {
+ int callbackID;
+ remote_domain_event_disk_change_msg msg;
+};
struct remote_domain_event_tray_change_msg {
remote_nonnull_domain dom;
remote_nonnull_string devAlias;
int reason;
};
+struct remote_domain_event_callback_tray_change_msg {
+ int callbackID;
+ remote_domain_event_tray_change_msg msg;
+};
struct remote_domain_event_pmwakeup_msg {
remote_nonnull_domain dom;
};
+struct remote_domain_event_callback_pmwakeup_msg {
+ int callbackID;
+ remote_domain_event_pmwakeup_msg msg;
+};
struct remote_domain_event_pmsuspend_msg {
remote_nonnull_domain dom;
};
+struct remote_domain_event_callback_pmsuspend_msg {
+ int callbackID;
+ remote_domain_event_pmsuspend_msg msg;
+};
struct remote_domain_event_balloon_change_msg {
remote_nonnull_domain dom;
unsigned hyper actual;
};
+struct remote_domain_event_callback_balloon_change_msg {
+ int callbackID;
+ remote_domain_event_balloon_change_msg msg;
+};
struct remote_domain_event_pmsuspend_disk_msg {
remote_nonnull_domain dom;
};
+struct remote_domain_event_callback_pmsuspend_disk_msg {
+ int callbackID;
+ remote_domain_event_pmsuspend_disk_msg msg;
+};
struct remote_domain_managed_save_args {
remote_nonnull_domain dom;
@@ -2631,6 +2683,10 @@ struct remote_domain_migrate_confirm3_args {
struct remote_domain_event_control_error_msg {
remote_nonnull_domain dom;
};
+struct remote_domain_event_callback_control_error_msg {
+ int callbackID;
+ remote_domain_event_control_error_msg msg;
+};
struct remote_domain_get_control_info_args {
remote_nonnull_domain dom;
@@ -2850,10 +2906,17 @@ struct remote_domain_migrate_confirm3_params_args {
int cancelled;
};
+/* The device removed event is the last event where we have to support
+ * dual forms for back-compat to older clients; all future events can
+ * use just the modern form with callbackID. */
struct remote_domain_event_device_removed_msg {
remote_nonnull_domain dom;
remote_nonnull_string devAlias;
};
+struct remote_domain_event_callback_device_removed_msg {
+ int callbackID;
+ remote_domain_event_device_removed_msg msg;
+};
struct remote_connect_get_cpu_model_names_args {
remote_nonnull_string arch;
@@ -5100,5 +5163,95 @@ enum remote_procedure {
* @generate: both
* @acl: none
*/
- REMOTE_PROC_DOMAIN_EVENT_CALLBACK_LIFECYCLE = 318
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_LIFECYCLE = 318,
+
+ /**
+ * @generate: both
+ * @acl: none
+ */
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_REBOOT = 319,
+
+ /**
+ * @generate: both
+ * @acl: none
+ */
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_RTC_CHANGE = 320,
+
+ /**
+ * @generate: both
+ * @acl: none
+ */
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_WATCHDOG = 321,
+
+ /**
+ * @generate: both
+ * @acl: none
+ */
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_IO_ERROR = 322,
+
+ /**
+ * @generate: both
+ * @acl: none
+ */
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_GRAPHICS = 323,
+
+ /**
+ * @generate: both
+ * @acl: none
+ */
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_IO_ERROR_REASON = 324,
+
+ /**
+ * @generate: both
+ * @acl: none
+ */
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_CONTROL_ERROR = 325,
+
+ /**
+ * @generate: both
+ * @acl: none
+ */
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_BLOCK_JOB = 326,
+
+ /**
+ * @generate: both
+ * @acl: none
+ */
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_DISK_CHANGE = 327,
+
+ /**
+ * @generate: both
+ * @acl: none
+ */
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_TRAY_CHANGE = 328,
+
+ /**
+ * @generate: both
+ * @acl: none
+ */
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMWAKEUP = 329,
+
+ /**
+ * @generate: both
+ * @acl: none
+ */
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMSUSPEND = 330,
+
+ /**
+ * @generate: both
+ * @acl: none
+ */
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_BALLOON_CHANGE = 331,
+
+ /**
+ * @generate: both
+ * @acl: none
+ */
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMSUSPEND_DISK = 332,
+
+ /**
+ * @generate: both
+ * @acl: none
+ */
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_DEVICE_REMOVED = 333
};
diff --git a/src/remote_protocol-structs b/src/remote_protocol-structs
index 39d3981..fdff787 100644
--- a/src/remote_protocol-structs
+++ b/src/remote_protocol-structs
@@ -1724,20 +1724,36 @@ struct remote_connect_domain_event_callback_deregister_any_args {
struct remote_domain_event_reboot_msg {
remote_nonnull_domain dom;
};
+struct remote_domain_event_callback_reboot_msg {
+ int callbackID;
+ remote_domain_event_reboot_msg msg;
+};
struct remote_domain_event_rtc_change_msg {
remote_nonnull_domain dom;
int64_t offset;
};
+struct remote_domain_event_callback_rtc_change_msg {
+ int callbackID;
+ remote_domain_event_rtc_change_msg msg;
+};
struct remote_domain_event_watchdog_msg {
remote_nonnull_domain dom;
int action;
};
+struct remote_domain_event_callback_watchdog_msg {
+ int callbackID;
+ remote_domain_event_watchdog_msg msg;
+};
struct remote_domain_event_io_error_msg {
remote_nonnull_domain dom;
remote_nonnull_string srcPath;
remote_nonnull_string devAlias;
int action;
};
+struct remote_domain_event_callback_io_error_msg {
+ int callbackID;
+ remote_domain_event_io_error_msg msg;
+};
struct remote_domain_event_io_error_reason_msg {
remote_nonnull_domain dom;
remote_nonnull_string srcPath;
@@ -1745,6 +1761,10 @@ struct remote_domain_event_io_error_reason_msg {
int action;
remote_nonnull_string reason;
};
+struct remote_domain_event_callback_io_error_reason_msg {
+ int callbackID;
+ remote_domain_event_io_error_reason_msg msg;
+};
struct remote_domain_event_graphics_address {
int family;
remote_nonnull_string node;
@@ -1765,12 +1785,20 @@ struct remote_domain_event_graphics_msg {
remote_domain_event_graphics_identity * subject_val;
} subject;
};
+struct remote_domain_event_callback_graphics_msg {
+ int callbackID;
+ remote_domain_event_graphics_msg msg;
+};
struct remote_domain_event_block_job_msg {
remote_nonnull_domain dom;
remote_nonnull_string path;
int type;
int status;
};
+struct remote_domain_event_callback_block_job_msg {
+ int callbackID;
+ remote_domain_event_block_job_msg msg;
+};
struct remote_domain_event_disk_change_msg {
remote_nonnull_domain dom;
remote_string oldSrcPath;
@@ -1778,24 +1806,48 @@ struct remote_domain_event_disk_change_msg {
remote_nonnull_string devAlias;
int reason;
};
+struct remote_domain_event_callback_disk_change_msg {
+ int callbackID;
+ remote_domain_event_disk_change_msg msg;
+};
struct remote_domain_event_tray_change_msg {
remote_nonnull_domain dom;
remote_nonnull_string devAlias;
int reason;
};
+struct remote_domain_event_callback_tray_change_msg {
+ int callbackID;
+ remote_domain_event_tray_change_msg msg;
+};
struct remote_domain_event_pmwakeup_msg {
remote_nonnull_domain dom;
};
+struct remote_domain_event_callback_pmwakeup_msg {
+ int callbackID;
+ remote_domain_event_pmwakeup_msg msg;
+};
struct remote_domain_event_pmsuspend_msg {
remote_nonnull_domain dom;
};
+struct remote_domain_event_callback_pmsuspend_msg {
+ int callbackID;
+ remote_domain_event_pmsuspend_msg msg;
+};
struct remote_domain_event_balloon_change_msg {
remote_nonnull_domain dom;
uint64_t actual;
};
+struct remote_domain_event_callback_balloon_change_msg {
+ int callbackID;
+ remote_domain_event_balloon_change_msg msg;
+};
struct remote_domain_event_pmsuspend_disk_msg {
remote_nonnull_domain dom;
};
+struct remote_domain_event_callback_pmsuspend_disk_msg {
+ int callbackID;
+ remote_domain_event_pmsuspend_disk_msg msg;
+};
struct remote_domain_managed_save_args {
remote_nonnull_domain dom;
u_int flags;
@@ -2064,6 +2116,10 @@ struct remote_domain_migrate_confirm3_args {
struct remote_domain_event_control_error_msg {
remote_nonnull_domain dom;
};
+struct remote_domain_event_callback_control_error_msg {
+ int callbackID;
+ remote_domain_event_control_error_msg msg;
+};
struct remote_domain_get_control_info_args {
remote_nonnull_domain dom;
u_int flags;
@@ -2330,6 +2386,10 @@ struct remote_domain_event_device_removed_msg {
remote_nonnull_domain dom;
remote_nonnull_string devAlias;
};
+struct remote_domain_event_callback_device_removed_msg {
+ int callbackID;
+ remote_domain_event_device_removed_msg msg;
+};
struct remote_connect_get_cpu_model_names_args {
remote_nonnull_string arch;
int need_results;
@@ -2677,4 +2737,19 @@ enum remote_procedure {
REMOTE_PROC_CONNECT_DOMAIN_EVENT_CALLBACK_REGISTER_ANY = 316,
REMOTE_PROC_CONNECT_DOMAIN_EVENT_CALLBACK_DEREGISTER_ANY = 317,
REMOTE_PROC_DOMAIN_EVENT_CALLBACK_LIFECYCLE = 318,
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_REBOOT = 319,
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_RTC_CHANGE = 320,
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_WATCHDOG = 321,
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_IO_ERROR = 322,
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_GRAPHICS = 323,
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_IO_ERROR_REASON = 324,
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_CONTROL_ERROR = 325,
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_BLOCK_JOB = 326,
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_DISK_CHANGE = 327,
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_TRAY_CHANGE = 328,
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMWAKEUP = 329,
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMSUSPEND = 330,
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_BALLOON_CHANGE = 331,
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMSUSPEND_DISK = 332,
+ REMOTE_PROC_DOMAIN_EVENT_CALLBACK_DEVICE_REMOVED = 333,
};
--
1.8.4.2
3937
days inactive
3937
days old
6 comments
1 participants
participants (1)
-
Eric Blake