11:49 a.m.
v1 was here: https://www.redhat.com/archives/libvir-list/2014-January/msg00689.html
Since then, I've rebased it on top of this patch which still
needs review: https://www.redhat.com/archives/libvir-list/2014-January/msg01406.html
as well as added patch 6 so that we don't have to repeat the
exercise of adding a new RPC down the road.
Eric Blake (6):
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
event: pass reason for PM events
daemon/libvirtd.h | 3 +-
daemon/remote.c | 665 ++++++++++++++++++++++++++-------
src/conf/domain_event.c | 184 ++++++++--
src/conf/domain_event.h | 28 +-
src/conf/network_event.c | 6 +-
src/conf/object_event.c | 35 +-
src/conf/object_event_private.h | 6 +-
src/libvirt_internal.h | 7 +-
src/remote/remote_driver.c | 796 ++++++++++++++++++++++++++++++++--------
src/remote/remote_protocol.x | 195 +++++++++-
src/remote_protocol-structs | 95 +++++
11 files changed, 1679 insertions(+), 341 deletions(-)
--
1.8.5.3
11:49 a.m.
New subject: [libvirt] [PATCHv2 1/6] 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 | 294 +++++++++++++++++++++++++++++++++++-------------------
2 files changed, 194 insertions(+), 103 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 5baf0b6..be0af3d 100644
--- a/daemon/remote.c
+++ b/daemon/remote.c
@@ -192,13 +192,15 @@ remoteRelayDomainEventLifecycle(virConnectPtr conn,
int detail,
void *opaque)
{
- virNetServerClientPtr client = opaque;
+ daemonClientEventCallbackPtr callback = opaque;
remote_domain_event_lifecycle_msg data;
- if (!client || !remoteRelayDomainEventCheckACL(client, conn, dom))
+ if (callback->callbackID < 0 ||
+ !remoteRelayDomainEventCheckACL(callback->client, conn, dom))
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));
@@ -206,7 +208,7 @@ remoteRelayDomainEventLifecycle(virConnectPtr conn,
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);
@@ -218,19 +220,21 @@ remoteRelayDomainEventReboot(virConnectPtr conn,
virDomainPtr dom,
void *opaque)
{
- virNetServerClientPtr client = opaque;
+ daemonClientEventCallbackPtr callback = opaque;
remote_domain_event_reboot_msg data;
- if (!client || !remoteRelayDomainEventCheckACL(client, conn, dom))
+ if (callback->callbackID < 0 ||
+ !remoteRelayDomainEventCheckACL(callback->client, conn, dom))
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);
@@ -244,20 +248,22 @@ remoteRelayDomainEventRTCChange(virConnectPtr conn,
long long offset,
void *opaque)
{
- virNetServerClientPtr client = opaque;
+ daemonClientEventCallbackPtr callback = opaque;
remote_domain_event_rtc_change_msg data;
- if (!client || !remoteRelayDomainEventCheckACL(client, conn, dom))
+ if (callback->callbackID < 0 ||
+ !remoteRelayDomainEventCheckACL(callback->client, conn, dom))
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);
@@ -271,20 +277,22 @@ remoteRelayDomainEventWatchdog(virConnectPtr conn,
int action,
void *opaque)
{
- virNetServerClientPtr client = opaque;
+ daemonClientEventCallbackPtr callback = opaque;
remote_domain_event_watchdog_msg data;
- if (!client || !remoteRelayDomainEventCheckACL(client, conn, dom))
+ if (callback->callbackID < 0 ||
+ !remoteRelayDomainEventCheckACL(callback->client, conn, dom))
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);
@@ -300,13 +308,16 @@ remoteRelayDomainEventIOError(virConnectPtr conn,
int action,
void *opaque)
{
- virNetServerClientPtr client = opaque;
+ daemonClientEventCallbackPtr callback = opaque;
remote_domain_event_io_error_msg data;
- if (!client || !remoteRelayDomainEventCheckACL(client, conn, dom))
+ if (callback->callbackID < 0 ||
+ !remoteRelayDomainEventCheckACL(callback->client, conn, dom))
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));
@@ -316,7 +327,7 @@ remoteRelayDomainEventIOError(virConnectPtr conn,
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);
@@ -337,14 +348,16 @@ remoteRelayDomainEventIOErrorReason(virConnectPtr conn,
const char *reason,
void *opaque)
{
- virNetServerClientPtr client = opaque;
+ daemonClientEventCallbackPtr callback = opaque;
remote_domain_event_io_error_reason_msg data;
- if (!client || !remoteRelayDomainEventCheckACL(client, conn, dom))
+ if (callback->callbackID < 0 ||
+ !remoteRelayDomainEventCheckACL(callback->client, conn, dom))
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));
@@ -356,7 +369,7 @@ remoteRelayDomainEventIOErrorReason(virConnectPtr conn,
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);
@@ -380,17 +393,19 @@ remoteRelayDomainEventGraphics(virConnectPtr conn,
virDomainEventGraphicsSubjectPtr subject,
void *opaque)
{
- virNetServerClientPtr client = opaque;
+ daemonClientEventCallbackPtr callback = opaque;
remote_domain_event_graphics_msg data;
size_t i;
- if (!client || !remoteRelayDomainEventCheckACL(client, conn, dom))
+ if (callback->callbackID < 0 ||
+ !remoteRelayDomainEventCheckACL(callback->client, conn, dom))
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++) {
@@ -420,7 +435,7 @@ remoteRelayDomainEventGraphics(virConnectPtr conn,
}
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);
@@ -450,14 +465,15 @@ remoteRelayDomainEventBlockJob(virConnectPtr conn,
int status,
void *opaque)
{
- virNetServerClientPtr client = opaque;
+ daemonClientEventCallbackPtr callback = opaque;
remote_domain_event_block_job_msg data;
- if (!client || !remoteRelayDomainEventCheckACL(client, conn, dom))
+ if (callback->callbackID < 0 ||
+ !remoteRelayDomainEventCheckACL(callback->client, conn, dom))
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));
@@ -467,7 +483,7 @@ remoteRelayDomainEventBlockJob(virConnectPtr conn,
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);
@@ -483,19 +499,21 @@ remoteRelayDomainEventControlError(virConnectPtr conn,
virDomainPtr dom,
void *opaque)
{
- virNetServerClientPtr client = opaque;
+ daemonClientEventCallbackPtr callback = opaque;
remote_domain_event_control_error_msg data;
- if (!client || !remoteRelayDomainEventCheckACL(client, conn, dom))
+ if (callback->callbackID < 0 ||
+ !remoteRelayDomainEventCheckACL(callback->client, conn, dom))
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);
@@ -512,15 +530,17 @@ remoteRelayDomainEventDiskChange(virConnectPtr conn,
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 || !remoteRelayDomainEventCheckACL(client, conn, dom))
+ if (callback->callbackID < 0 ||
+ !remoteRelayDomainEventCheckACL(callback->client, conn, dom))
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));
@@ -542,7 +562,7 @@ remoteRelayDomainEventDiskChange(virConnectPtr conn,
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);
@@ -562,14 +582,15 @@ remoteRelayDomainEventTrayChange(virConnectPtr conn,
int reason,
void *opaque)
{
- virNetServerClientPtr client = opaque;
+ daemonClientEventCallbackPtr callback = opaque;
remote_domain_event_tray_change_msg data;
- if (!client || !remoteRelayDomainEventCheckACL(client, conn, dom))
+ if (callback->callbackID < 0 ||
+ !remoteRelayDomainEventCheckACL(callback->client, conn, dom))
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));
@@ -580,7 +601,7 @@ remoteRelayDomainEventTrayChange(virConnectPtr conn,
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);
@@ -593,19 +614,21 @@ remoteRelayDomainEventPMWakeup(virConnectPtr conn,
int reason ATTRIBUTE_UNUSED,
void *opaque)
{
- virNetServerClientPtr client = opaque;
+ daemonClientEventCallbackPtr callback = opaque;
remote_domain_event_pmwakeup_msg data;
- if (!client || !remoteRelayDomainEventCheckACL(client, conn, dom))
+ if (callback->callbackID < 0 ||
+ !remoteRelayDomainEventCheckACL(callback->client, conn, dom))
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);
@@ -618,19 +641,21 @@ remoteRelayDomainEventPMSuspend(virConnectPtr conn,
int reason ATTRIBUTE_UNUSED,
void *opaque)
{
- virNetServerClientPtr client = opaque;
+ daemonClientEventCallbackPtr callback = opaque;
remote_domain_event_pmsuspend_msg data;
- if (!client || !remoteRelayDomainEventCheckACL(client, conn, dom))
+ if (callback->callbackID < 0 ||
+ !remoteRelayDomainEventCheckACL(callback->client, conn, dom))
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);
@@ -643,20 +668,22 @@ remoteRelayDomainEventBalloonChange(virConnectPtr conn,
unsigned long long actual,
void *opaque)
{
- virNetServerClientPtr client = opaque;
+ daemonClientEventCallbackPtr callback = opaque;
remote_domain_event_balloon_change_msg data;
- if (!client || !remoteRelayDomainEventCheckACL(client, conn, dom))
+ if (callback->callbackID < 0 ||
+ !remoteRelayDomainEventCheckACL(callback->client, conn, dom))
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);
@@ -670,19 +697,21 @@ remoteRelayDomainEventPMSuspendDisk(virConnectPtr conn,
int reason ATTRIBUTE_UNUSED,
void *opaque)
{
- virNetServerClientPtr client = opaque;
+ daemonClientEventCallbackPtr callback = opaque;
remote_domain_event_pmsuspend_disk_msg data;
- if (!client || !remoteRelayDomainEventCheckACL(client, conn, dom))
+ if (callback->callbackID < 0 ||
+ !remoteRelayDomainEventCheckACL(callback->client, conn, dom))
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);
@@ -695,14 +724,15 @@ remoteRelayDomainEventDeviceRemoved(virConnectPtr conn,
const char *devAlias,
void *opaque)
{
- virNetServerClientPtr client = opaque;
+ daemonClientEventCallbackPtr callback = opaque;
remote_domain_event_device_removed_msg data;
- if (!client || !remoteRelayDomainEventCheckACL(client, conn, dom))
+ if (callback->callbackID < 0 ||
+ !remoteRelayDomainEventCheckACL(callback->client, conn, dom))
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));
@@ -712,7 +742,7 @@ remoteRelayDomainEventDeviceRemoved(virConnectPtr conn,
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);
@@ -797,14 +827,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;
@@ -843,7 +878,6 @@ void *remoteClientInitHook(virNetServerClientPtr client,
void *opaque ATTRIBUTE_UNUSED)
{
struct daemonClientPrivate *priv;
- size_t i;
if (VIR_ALLOC(priv) < 0)
return NULL;
@@ -854,9 +888,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;
}
@@ -3220,13 +3251,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);
@@ -3237,23 +3270,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);
@@ -3262,12 +3313,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);
@@ -3278,16 +3331,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;
@@ -3409,13 +3471,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);
@@ -3432,23 +3496,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);
@@ -3458,13 +3540,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);
@@ -3481,16 +3564,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.5.3
9:30 a.m.
New subject: [libvirt] [PATCHv2 1/6] event: dynamically manage server-side RPC domain events
On Wed, Jan 29, 2014 at 10:49:21AM -0700, Eric Blake wrote:
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 | 294 +++++++++++++++++++++++++++++++++++-------------------
2 files changed, 194 insertions(+), 103 deletions(-)
ACK
Daniel
--
|: http://berrange.com -o- http://www.flickr.com/photos/dberrange/ :|
|: http://libvirt.org -o- http://virt-manager.org :|
|: http://autobuild.org -o- http://search.cpan.org/~danberr/ :|
|: http://entangle-photo.org -o- http://live.gnome.org/gtk-vnc :|
11:49 a.m.
New subject: [libvirt] [PATCHv2 2/6] 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 be0af3d..1dfcb65 100644
--- a/daemon/remote.c
+++ b/daemon/remote.c
@@ -79,6 +79,7 @@ struct daemonClientEventCallback {
virNetServerClientPtr client;
int eventID;
int callbackID;
+ bool legacy;
};
static virDomainPtr get_nonnull_domain(virConnectPtr conn, remote_nonnull_domain
domain);
@@ -199,8 +200,8 @@ remoteRelayDomainEventLifecycle(virConnectPtr conn,
!remoteRelayDomainEventCheckACL(callback->client, conn, dom))
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));
@@ -208,9 +209,20 @@ remoteRelayDomainEventLifecycle(virConnectPtr conn,
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;
}
@@ -3281,6 +3293,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,
@@ -3469,6 +3482,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,
@@ -3490,9 +3509,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;
}
@@ -3507,6 +3530,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,
@@ -3539,6 +3563,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,
@@ -3558,9 +3661,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;
}
@@ -3591,6 +3698,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,
@@ -3911,6 +4065,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 790a020..982ab1f 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;
};
@@ -5068,5 +5085,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.5.3
9:57 a.m.
New subject: [libvirt] [PATCHv2 2/6] event: server RPC protocol tweaks for domain lifecycle events
On Wed, Jan 29, 2014 at 10:49:22AM -0700, Eric Blake wrote:
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(-)
ACK
@@ -5068,5 +5085,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,
I believe these ACLs need to be non-none now
Daniel
--
|: http://berrange.com -o- http://www.flickr.com/photos/dberrange/ :|
|: http://libvirt.org -o- http://virt-manager.org :|
|: http://autobuild.org -o- http://search.cpan.org/~danberr/ :|
|: http://entangle-photo.org -o- http://live.gnome.org/gtk-vnc :|
3:07 p.m.
New subject: [libvirt] [PATCHv2 2/6] event: server RPC protocol tweaks for domain lifecycle events
On 02/11/2014 08:57 AM, Daniel P. Berrange wrote:
On Wed, Jan 29, 2014 at 10:49:22AM -0700, Eric Blake wrote:
> 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
ACK
Thanks for the review.
> @@ -5068,5 +5085,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,
I believe these ACLs need to be non-none now
The way 'make -C src check-aclrules' works is by correlating all RPC
calls back into their API names - but I'm not inventing any new API
names. These new RPC calls are already covered by existing APIs, and
the ACL checks performed there are already sufficient. But it turns out
that it doesn't hurt to make these ACLs match the other register RPC
numbers, so I'm inclined to squash this in, unless you think that
generating unused functions in src/access/viraccessapicheck.c is not
worth the pollution:
diff --git i/src/remote/remote_protocol.x w/src/remote/remote_protocol.x
index 982ab1f..26abcdd 100644
--- i/src/remote/remote_protocol.x
+++ w/src/remote/remote_protocol.x
@@ -5090,14 +5090,15 @@ enum remote_procedure {
/**
* @generate: none
* @priority: high
- * @acl: none
+ * @acl: connect:search_domains
+ * @aclfilter: domain:getattr
*/
REMOTE_PROC_CONNECT_DOMAIN_EVENT_CALLBACK_REGISTER_ANY = 316,
/**
* @generate: none
* @priority: high
- * @acl: none
+ * @acl: connect:read
*/
REMOTE_PROC_CONNECT_DOMAIN_EVENT_CALLBACK_DEREGISTER_ANY = 317,
--
Eric Blake eblake redhat com +1-919-301-3266
Libvirt virtualization library http://libvirt.org
4:23 a.m.
New subject: [libvirt] [PATCHv2 2/6] event: server RPC protocol tweaks for domain lifecycle events
On Tue, Feb 11, 2014 at 02:07:06PM -0700, Eric Blake wrote:
On 02/11/2014 08:57 AM, Daniel P. Berrange wrote:
> On Wed, Jan 29, 2014 at 10:49:22AM -0700, Eric Blake wrote:
>> 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
>
> ACK
>
Thanks for the review.
>
>
>> @@ -5068,5 +5085,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,
>
> I believe these ACLs need to be non-none now
The way 'make -C src check-aclrules' works is by correlating all RPC
calls back into their API names - but I'm not inventing any new API
names. These new RPC calls are already covered by existing APIs, and
the ACL checks performed there are already sufficient. But it turns out
that it doesn't hurt to make these ACLs match the other register RPC
numbers, so I'm inclined to squash this in, unless you think that
generating unused functions in src/access/viraccessapicheck.c is not
worth the pollution:
diff --git i/src/remote/remote_protocol.x w/src/remote/remote_protocol.x
index 982ab1f..26abcdd 100644
--- i/src/remote/remote_protocol.x
+++ w/src/remote/remote_protocol.x
@@ -5090,14 +5090,15 @@ enum remote_procedure {
/**
* @generate: none
* @priority: high
- * @acl: none
+ * @acl: connect:search_domains
+ * @aclfilter: domain:getattr
*/
REMOTE_PROC_CONNECT_DOMAIN_EVENT_CALLBACK_REGISTER_ANY = 316,
/**
* @generate: none
* @priority: high
- * @acl: none
+ * @acl: connect:read
*/
REMOTE_PROC_CONNECT_DOMAIN_EVENT_CALLBACK_DEREGISTER_ANY = 317,
ACK to this - it makes it clearer i think
Daniel
--
|: http://berrange.com -o- http://www.flickr.com/photos/dberrange/ :|
|: http://libvirt.org -o- http://virt-manager.org :|
|: http://autobuild.org -o- http://search.cpan.org/~danberr/ :|
|: http://entangle-photo.org -o- http://live.gnome.org/gtk-vnc :|
11:50 a.m.
New subject: [libvirt] [PATCHv2 2/6] event: server RPC protocol tweaks for domain lifecycle events
On 02/12/2014 03:23 AM, Daniel P. Berrange wrote:
On Tue, Feb 11, 2014 at 02:07:06PM -0700, Eric Blake wrote:
> On 02/11/2014 08:57 AM, Daniel P. Berrange wrote:
>> On Wed, Jan 29, 2014 at 10:49:22AM -0700, Eric Blake wrote:
>>> 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
>
>>
>> ACK
>>
>
> Thanks for the review.
> /**
> * @generate: none
> * @priority: high
> - * @acl: none
> + * @acl: connect:read
> */
> REMOTE_PROC_CONNECT_DOMAIN_EVENT_CALLBACK_DEREGISTER_ANY = 317,
ACK to this - it makes it clearer i think
Series now pushed with this in.
--
Eric Blake eblake redhat com +1-919-301-3266
Libvirt virtualization library http://libvirt.org
11:49 a.m.
New subject: [libvirt] [PATCHv2 3/6] 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.
(virObjectEventCallbackLookup): Let legacy and global domain
lifecycle events share a common remoteID.
* 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 | 35 +++++++++---------
src/conf/object_event_private.h | 6 ++--
src/remote/remote_driver.c | 36 +++++++++++++++----
6 files changed, 154 insertions(+), 29 deletions(-)
diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c
index 8639a01..a490fe5 100644
--- a/src/conf/domain_event.c
+++ b/src/conf/domain_event.c
@@ -1281,6 +1281,8 @@ virDomainEventStateRegister(virConnectPtr conn,
void *opaque,
virFreeCallback freecb)
{
+ int callbackID;
+
if (virDomainEventsInitialize() < 0)
return -1;
@@ -1288,7 +1290,8 @@ virDomainEventStateRegister(virConnectPtr conn,
NULL, NULL, virDomainEventClass,
VIR_DOMAIN_EVENT_ID_LIFECYCLE,
VIR_OBJECT_EVENT_CALLBACK(callback),
- opaque, freecb, NULL, false);
+ opaque, freecb,
+ true, &callbackID, false);
}
@@ -1326,7 +1329,75 @@ virDomainEventStateRegisterID(virConnectPtr conn,
NULL, NULL,
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);
}
@@ -1351,7 +1422,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 b033b23..be577e9 100644
--- a/src/conf/domain_event.h
+++ b/src/conf/domain_event.h
@@ -192,6 +192,28 @@ virDomainEventStateRegisterID(virConnectPtr conn,
int *callbackID)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2) ATTRIBUTE_NONNULL(5);
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 4c59356..f2cfefe 100644
--- a/src/conf/network_event.c
+++ b/src/conf/network_event.c
@@ -155,7 +155,8 @@ virNetworkEventStateRegisterID(virConnectPtr conn,
NULL, NULL,
virNetworkEventClass, eventID,
VIR_OBJECT_EVENT_CALLBACK(cb),
- opaque, freecb, callbackID, false);
+ opaque, freecb,
+ false, callbackID, false);
}
@@ -194,7 +195,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..de45257 100644
--- a/src/conf/object_event.c
+++ b/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;
}
}
@@ -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 18eb454..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,
- 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,
- 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.5.3
9:58 a.m.
New subject: [libvirt] [PATCHv2 3/6] event: prepare client to track domain callbackID
On Wed, Jan 29, 2014 at 10:49:23AM -0700, 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.
(virObjectEventCallbackLookup): Let legacy and global domain
lifecycle events share a common remoteID.
* 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 | 35 +++++++++---------
src/conf/object_event_private.h | 6 ++--
src/remote/remote_driver.c | 36 +++++++++++++++----
6 files changed, 154 insertions(+), 29 deletions(-)
ACK
Daniel
--
|: http://berrange.com -o- http://www.flickr.com/photos/dberrange/ :|
|: http://libvirt.org -o- http://virt-manager.org :|
|: http://autobuild.org -o- http://search.cpan.org/~danberr/ :|
|: http://entangle-photo.org -o- http://live.gnome.org/gtk-vnc :|
11:49 a.m.
New subject: [libvirt] [PATCHv2 4/6] 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.5.3
10 a.m.
New subject: [libvirt] [PATCHv2 4/6] event: client RPC protocol tweaks for domain lifecycle events
On Wed, Jan 29, 2014 at 10:49:24AM -0700, Eric Blake wrote:
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.
ACK
Daniel
--
|: http://berrange.com -o- http://www.flickr.com/photos/dberrange/ :|
|: http://libvirt.org -o- http://virt-manager.org :|
|: http://autobuild.org -o- http://search.cpan.org/~danberr/ :|
|: http://entangle-photo.org -o- http://live.gnome.org/gtk-vnc :|
11:49 a.m.
New subject: [libvirt] [PATCHv2 5/6] 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 1dfcb65..48c707d 100644
--- a/daemon/remote.c
+++ b/daemon/remote.c
@@ -239,16 +239,25 @@ remoteRelayDomainEventReboot(virConnectPtr conn,
!remoteRelayDomainEventCheckACL(callback->client, conn, dom))
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;
}
@@ -267,17 +276,27 @@ remoteRelayDomainEventRTCChange(virConnectPtr conn,
!remoteRelayDomainEventCheckACL(callback->client, conn, dom))
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;
}
@@ -304,9 +323,18 @@ remoteRelayDomainEventWatchdog(virConnectPtr conn,
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;
}
@@ -339,9 +367,18 @@ remoteRelayDomainEventIOError(virConnectPtr conn,
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:
@@ -381,9 +418,18 @@ remoteRelayDomainEventIOErrorReason(virConnectPtr conn,
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;
@@ -447,9 +493,18 @@ remoteRelayDomainEventGraphics(virConnectPtr conn,
}
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;
@@ -495,9 +550,18 @@ remoteRelayDomainEventBlockJob(virConnectPtr conn,
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:
@@ -525,9 +589,18 @@ remoteRelayDomainEventControlError(virConnectPtr conn,
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;
}
@@ -574,9 +647,18 @@ remoteRelayDomainEventDiskChange(virConnectPtr conn,
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;
@@ -613,9 +695,18 @@ remoteRelayDomainEventTrayChange(virConnectPtr conn,
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;
}
@@ -640,9 +731,18 @@ remoteRelayDomainEventPMWakeup(virConnectPtr conn,
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;
}
@@ -667,9 +767,18 @@ remoteRelayDomainEventPMSuspend(virConnectPtr conn,
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;
}
@@ -695,9 +804,18 @@ remoteRelayDomainEventBalloonChange(virConnectPtr conn,
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;
}
@@ -723,9 +841,18 @@ remoteRelayDomainEventPMSuspendDisk(virConnectPtr conn,
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;
}
@@ -754,10 +881,20 @@ remoteRelayDomainEventDeviceRemoved(virConnectPtr conn,
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;
}
@@ -3589,8 +3726,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 982ab1f..8238405 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;
@@ -5105,5 +5168,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.5.3
10:03 a.m.
New subject: [libvirt] [PATCHv2 5/6] event: convert remaining domain events to new style
On Wed, Jan 29, 2014 at 10:49:25AM -0700, Eric Blake wrote:
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(-)
ACK
Daniel
--
|: http://berrange.com -o- http://www.flickr.com/photos/dberrange/ :|
|: http://libvirt.org -o- http://virt-manager.org :|
|: http://autobuild.org -o- http://search.cpan.org/~danberr/ :|
|: http://entangle-photo.org -o- http://live.gnome.org/gtk-vnc :|
11:49 a.m.
New subject: [libvirt] [PATCHv2 6/6] event: pass reason for PM events
Commit 57ddcc23 (v0.9.11) introduced the pmwakeup event, with
an optional 'reason' field reserved for possible future expansion.
But it failed to wire the field through RPC, so even if we do
add a reason in the future, we will be unable to get it back
to the user.
Worse, commit 7ba5defb (v1.0.0) repeated the same mistake with
the pmsuspend_disk event.
As long as we are adding new RPC calls, we might as well fix
the events to actually match the signature so that we don't have
to add yet another RPC in the future if we do decide to start
using the reason field.
* src/remote/remote_protocol.x
(remote_domain_event_callback_pmwakeup_msg)
(remote_domain_event_callback_pmsuspend_msg)
(remote_domain_event_callback_pmsuspend_disk_msg): Add reason
field.
* daemon/remote.c (remoteRelayDomainEventPMWakeup)
(remoteRelayDomainEventPMSuspend)
(remoteRelayDomainEventPMSuspendDisk): Pass reason to client.
* src/conf/domain_event.h (virDomainEventPMWakeupNewFromDom)
(virDomainEventPMSuspendNewFromDom)
(virDomainEventPMSuspendDiskNewFromDom): Require additional
parameter.
* src/conf/domain_event.c (virDomainEventPMClass): New class.
(virDomainEventPMDispose): New function.
(virDomainEventPMWakeupNew*, virDomainEventPMSuspendNew*)
(virDomainEventPMSuspendDiskNew*)
(virDomainEventDispatchDefaultFunc): Use new class.
* src/remote/remote_driver.c (remoteDomainBuildEvent*PM*): Pass
reason through.
* src/remote_protocol-structs: Regenerate.
Signed-off-by: Eric Blake <eblake(a)redhat.com>
---
daemon/remote.c | 12 ++---
src/conf/domain_event.c | 106 ++++++++++++++++++++++++++++++++-----------
src/conf/domain_event.h | 6 +--
src/remote/remote_driver.c | 30 +++++++-----
src/remote/remote_protocol.x | 3 ++
src/remote_protocol-structs | 3 ++
6 files changed, 112 insertions(+), 48 deletions(-)
diff --git a/daemon/remote.c b/daemon/remote.c
index 48c707d..932f65f 100644
--- a/daemon/remote.c
+++ b/daemon/remote.c
@@ -714,7 +714,7 @@ remoteRelayDomainEventTrayChange(virConnectPtr conn,
static int
remoteRelayDomainEventPMWakeup(virConnectPtr conn,
virDomainPtr dom,
- int reason ATTRIBUTE_UNUSED,
+ int reason,
void *opaque)
{
daemonClientEventCallbackPtr callback = opaque;
@@ -737,7 +737,7 @@ remoteRelayDomainEventPMWakeup(virConnectPtr conn,
(xdrproc_t)xdr_remote_domain_event_pmwakeup_msg,
&data);
} else {
remote_domain_event_callback_pmwakeup_msg msg = { callback->callbackID,
- data };
+ reason, data };
remoteDispatchObjectEventSend(callback->client, remoteProgram,
REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMWAKEUP,
@@ -750,7 +750,7 @@ remoteRelayDomainEventPMWakeup(virConnectPtr conn,
static int
remoteRelayDomainEventPMSuspend(virConnectPtr conn,
virDomainPtr dom,
- int reason ATTRIBUTE_UNUSED,
+ int reason,
void *opaque)
{
daemonClientEventCallbackPtr callback = opaque;
@@ -773,7 +773,7 @@ remoteRelayDomainEventPMSuspend(virConnectPtr conn,
(xdrproc_t)xdr_remote_domain_event_pmsuspend_msg,
&data);
} else {
remote_domain_event_callback_pmsuspend_msg msg = { callback->callbackID,
- data };
+ reason, data };
remoteDispatchObjectEventSend(callback->client, remoteProgram,
REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMSUSPEND,
@@ -824,7 +824,7 @@ remoteRelayDomainEventBalloonChange(virConnectPtr conn,
static int
remoteRelayDomainEventPMSuspendDisk(virConnectPtr conn,
virDomainPtr dom,
- int reason ATTRIBUTE_UNUSED,
+ int reason,
void *opaque)
{
daemonClientEventCallbackPtr callback = opaque;
@@ -847,7 +847,7 @@ remoteRelayDomainEventPMSuspendDisk(virConnectPtr conn,
(xdrproc_t)xdr_remote_domain_event_pmsuspend_disk_msg, &data);
} else {
remote_domain_event_callback_pmsuspend_disk_msg msg = { callback->callbackID,
- data };
+ reason, data };
remoteDispatchObjectEventSend(callback->client, remoteProgram,
REMOTE_PROC_DOMAIN_EVENT_CALLBACK_PMSUSPEND_DISK,
diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c
index a490fe5..9c18922 100644
--- a/src/conf/domain_event.c
+++ b/src/conf/domain_event.c
@@ -47,6 +47,7 @@ static virClassPtr virDomainEventDiskChangeClass;
static virClassPtr virDomainEventTrayChangeClass;
static virClassPtr virDomainEventBalloonChangeClass;
static virClassPtr virDomainEventDeviceRemovedClass;
+static virClassPtr virDomainEventPMClass;
static void virDomainEventDispose(void *obj);
@@ -60,6 +61,7 @@ static void virDomainEventDiskChangeDispose(void *obj);
static void virDomainEventTrayChangeDispose(void *obj);
static void virDomainEventBalloonChangeDispose(void *obj);
static void virDomainEventDeviceRemovedDispose(void *obj);
+static void virDomainEventPMDispose(void *obj);
static void
virDomainEventDispatchDefaultFunc(virConnectPtr conn,
@@ -171,6 +173,14 @@ struct _virDomainEventDeviceRemoved {
typedef struct _virDomainEventDeviceRemoved virDomainEventDeviceRemoved;
typedef virDomainEventDeviceRemoved *virDomainEventDeviceRemovedPtr;
+struct _virDomainEventPM {
+ virDomainEvent parent;
+
+ int reason;
+};
+typedef struct _virDomainEventPM virDomainEventPM;
+typedef virDomainEventPM *virDomainEventPMPtr;
+
static int
virDomainEventsOnceInit(void)
@@ -241,6 +251,12 @@ virDomainEventsOnceInit(void)
sizeof(virDomainEventDeviceRemoved),
virDomainEventDeviceRemovedDispose)))
return -1;
+ if (!(virDomainEventPMClass =
+ virClassNew(virDomainEventClass,
+ "virDomainEventPM",
+ sizeof(virDomainEventPM),
+ virDomainEventPMDispose)))
+ return -1;
return 0;
}
@@ -359,6 +375,13 @@ virDomainEventDeviceRemovedDispose(void *obj)
VIR_FREE(event->devAlias);
}
+static void
+virDomainEventPMDispose(void *obj)
+{
+ virDomainEventPMPtr event = obj;
+ VIR_DEBUG("obj=%p", event);
+}
+
static void *
virDomainEventNew(virClassPtr klass,
@@ -907,19 +930,21 @@ virDomainEventTrayChangeNewFromDom(virDomainPtr dom,
static virObjectEventPtr
virDomainEventPMWakeupNew(int id,
const char *name,
- unsigned char *uuid)
+ unsigned char *uuid,
+ int reason)
{
- virObjectEventPtr ev;
+ virDomainEventPMPtr ev;
if (virDomainEventsInitialize() < 0)
return NULL;
- if (!(ev = virDomainEventNew(virDomainEventClass,
+ if (!(ev = virDomainEventNew(virDomainEventPMClass,
VIR_DOMAIN_EVENT_ID_PMWAKEUP,
id, name, uuid)))
return NULL;
- return ev;
+ ev->reason = reason;
+ return (virObjectEventPtr)ev;
}
virObjectEventPtr
@@ -927,31 +952,34 @@ virDomainEventPMWakeupNewFromObj(virDomainObjPtr obj)
{
return virDomainEventPMWakeupNew(obj->def->id,
obj->def->name,
- obj->def->uuid);
+ obj->def->uuid,
+ 0);
}
virObjectEventPtr
-virDomainEventPMWakeupNewFromDom(virDomainPtr dom)
+virDomainEventPMWakeupNewFromDom(virDomainPtr dom, int reason)
{
- return virDomainEventPMWakeupNew(dom->id, dom->name, dom->uuid);
+ return virDomainEventPMWakeupNew(dom->id, dom->name, dom->uuid, reason);
}
static virObjectEventPtr
virDomainEventPMSuspendNew(int id,
const char *name,
- unsigned char *uuid)
+ unsigned char *uuid,
+ int reason)
{
- virObjectEventPtr ev;
+ virDomainEventPMPtr ev;
if (virDomainEventsInitialize() < 0)
return NULL;
- if (!(ev = virDomainEventNew(virDomainEventClass,
+ if (!(ev = virDomainEventNew(virDomainEventPMClass,
VIR_DOMAIN_EVENT_ID_PMSUSPEND,
id, name, uuid)))
return NULL;
- return ev;
+ ev->reason = reason;
+ return (virObjectEventPtr)ev;
}
virObjectEventPtr
@@ -959,30 +987,34 @@ virDomainEventPMSuspendNewFromObj(virDomainObjPtr obj)
{
return virDomainEventPMSuspendNew(obj->def->id,
obj->def->name,
- obj->def->uuid);
+ obj->def->uuid,
+ 0);
}
virObjectEventPtr
-virDomainEventPMSuspendNewFromDom(virDomainPtr dom)
+virDomainEventPMSuspendNewFromDom(virDomainPtr dom, int reason)
{
- return virDomainEventPMSuspendNew(dom->id, dom->name, dom->uuid);
+ return virDomainEventPMSuspendNew(dom->id, dom->name, dom->uuid, reason);
}
static virObjectEventPtr
virDomainEventPMSuspendDiskNew(int id,
const char *name,
- unsigned char *uuid)
+ unsigned char *uuid,
+ int reason)
{
- virObjectEventPtr ev;
+ virDomainEventPMPtr ev;
if (virDomainEventsInitialize() < 0)
return NULL;
- if (!(ev = virDomainEventNew(virDomainEventClass,
+ if (!(ev = virDomainEventNew(virDomainEventPMClass,
VIR_DOMAIN_EVENT_ID_PMSUSPEND_DISK,
id, name, uuid)))
return NULL;
- return ev;
+
+ ev->reason = reason;
+ return (virObjectEventPtr)ev;
}
virObjectEventPtr
@@ -990,13 +1022,15 @@ virDomainEventPMSuspendDiskNewFromObj(virDomainObjPtr obj)
{
return virDomainEventPMSuspendDiskNew(obj->def->id,
obj->def->name,
- obj->def->uuid);
+ obj->def->uuid,
+ 0);
}
virObjectEventPtr
-virDomainEventPMSuspendDiskNewFromDom(virDomainPtr dom)
+virDomainEventPMSuspendDiskNewFromDom(virDomainPtr dom, int reason)
{
- return virDomainEventPMSuspendDiskNew(dom->id, dom->name, dom->uuid);
+ return virDomainEventPMSuspendDiskNew(dom->id, dom->name, dom->uuid,
+ reason);
}
virObjectEventPtr
@@ -1217,12 +1251,24 @@ virDomainEventDispatchDefaultFunc(virConnectPtr conn,
}
case VIR_DOMAIN_EVENT_ID_PMWAKEUP:
- ((virConnectDomainEventPMWakeupCallback)cb)(conn, dom, 0, cbopaque);
- goto cleanup;
+ {
+ virDomainEventPMPtr pmEvent = (virDomainEventPMPtr)event;
+
+ ((virConnectDomainEventPMWakeupCallback)cb)(conn, dom,
+ pmEvent->reason,
+ cbopaque);
+ goto cleanup;
+ }
case VIR_DOMAIN_EVENT_ID_PMSUSPEND:
- ((virConnectDomainEventPMSuspendCallback)cb)(conn, dom, 0, cbopaque);
- goto cleanup;
+ {
+ virDomainEventPMPtr pmEvent = (virDomainEventPMPtr)event;
+
+ ((virConnectDomainEventPMSuspendCallback)cb)(conn, dom,
+ pmEvent->reason,
+ cbopaque);
+ goto cleanup;
+ }
case VIR_DOMAIN_EVENT_ID_BALLOON_CHANGE:
{
@@ -1236,8 +1282,14 @@ virDomainEventDispatchDefaultFunc(virConnectPtr conn,
}
case VIR_DOMAIN_EVENT_ID_PMSUSPEND_DISK:
- ((virConnectDomainEventPMSuspendDiskCallback)cb)(conn, dom, 0, cbopaque);
- goto cleanup;
+ {
+ virDomainEventPMPtr pmEvent = (virDomainEventPMPtr)event;
+
+ ((virConnectDomainEventPMSuspendDiskCallback)cb)(conn, dom,
+ pmEvent->reason,
+ cbopaque);
+ goto cleanup;
+ }
case VIR_DOMAIN_EVENT_ID_DEVICE_REMOVED:
{
diff --git a/src/conf/domain_event.h b/src/conf/domain_event.h
index be577e9..300c41b 100644
--- a/src/conf/domain_event.h
+++ b/src/conf/domain_event.h
@@ -149,11 +149,11 @@ virDomainEventTrayChangeNewFromDom(virDomainPtr dom,
virObjectEventPtr
virDomainEventPMWakeupNewFromObj(virDomainObjPtr obj);
virObjectEventPtr
-virDomainEventPMWakeupNewFromDom(virDomainPtr dom);
+virDomainEventPMWakeupNewFromDom(virDomainPtr dom, int reason);
virObjectEventPtr
virDomainEventPMSuspendNewFromObj(virDomainObjPtr obj);
virObjectEventPtr
-virDomainEventPMSuspendNewFromDom(virDomainPtr dom);
+virDomainEventPMSuspendNewFromDom(virDomainPtr dom, int reason);
virObjectEventPtr
virDomainEventBalloonChangeNewFromDom(virDomainPtr dom,
@@ -165,7 +165,7 @@ virDomainEventBalloonChangeNewFromObj(virDomainObjPtr obj,
virObjectEventPtr
virDomainEventPMSuspendDiskNewFromObj(virDomainObjPtr obj);
virObjectEventPtr
-virDomainEventPMSuspendDiskNewFromDom(virDomainPtr dom);
+virDomainEventPMSuspendDiskNewFromDom(virDomainPtr dom, int reason);
virObjectEventPtr
virDomainEventDeviceRemovedNewFromObj(virDomainObjPtr obj,
diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c
index 4cdce81..955465a 100644
--- a/src/remote/remote_driver.c
+++ b/src/remote/remote_driver.c
@@ -5189,7 +5189,8 @@ remoteDomainBuildEventCallbackTrayChange(virNetClientProgramPtr prog
ATTRIBUTE_U
static void
remoteDomainBuildEventPMWakeupHelper(virConnectPtr conn,
remote_domain_event_pmwakeup_msg *msg,
- int callbackID)
+ int callbackID,
+ int reason)
{
struct private_data *priv = conn->privateData;
virDomainPtr dom;
@@ -5199,7 +5200,7 @@ remoteDomainBuildEventPMWakeupHelper(virConnectPtr conn,
if (!dom)
return;
- event = virDomainEventPMWakeupNewFromDom(dom);
+ event = virDomainEventPMWakeupNewFromDom(dom, reason);
virDomainFree(dom);
@@ -5212,7 +5213,7 @@ remoteDomainBuildEventPMWakeup(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,
{
virConnectPtr conn = opaque;
remote_domain_event_pmwakeup_msg *msg = evdata;
- remoteDomainBuildEventPMWakeupHelper(conn, msg, -1);
+ remoteDomainBuildEventPMWakeupHelper(conn, msg, -1, 0);
}
static void
remoteDomainBuildEventCallbackPMWakeup(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
@@ -5221,13 +5222,15 @@ remoteDomainBuildEventCallbackPMWakeup(virNetClientProgramPtr prog
ATTRIBUTE_UNU
{
virConnectPtr conn = opaque;
remote_domain_event_callback_pmwakeup_msg *msg = evdata;
- remoteDomainBuildEventPMWakeupHelper(conn, &msg->msg, msg->callbackID);
+ remoteDomainBuildEventPMWakeupHelper(conn, &msg->msg, msg->callbackID,
+ msg->reason);
}
static void
remoteDomainBuildEventPMSuspendHelper(virConnectPtr conn,
remote_domain_event_pmsuspend_msg *msg,
- int callbackID)
+ int callbackID,
+ int reason)
{
struct private_data *priv = conn->privateData;
virDomainPtr dom;
@@ -5237,7 +5240,7 @@ remoteDomainBuildEventPMSuspendHelper(virConnectPtr conn,
if (!dom)
return;
- event = virDomainEventPMSuspendNewFromDom(dom);
+ event = virDomainEventPMSuspendNewFromDom(dom, reason);
virDomainFree(dom);
@@ -5250,7 +5253,7 @@ remoteDomainBuildEventPMSuspend(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,
{
virConnectPtr conn = opaque;
remote_domain_event_pmsuspend_msg *msg = evdata;
- remoteDomainBuildEventPMSuspendHelper(conn, msg, -1);
+ remoteDomainBuildEventPMSuspendHelper(conn, msg, -1, 0);
}
static void
remoteDomainBuildEventCallbackPMSuspend(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
@@ -5259,7 +5262,8 @@ remoteDomainBuildEventCallbackPMSuspend(virNetClientProgramPtr prog
ATTRIBUTE_UN
{
virConnectPtr conn = opaque;
remote_domain_event_callback_pmsuspend_msg *msg = evdata;
- remoteDomainBuildEventPMSuspendHelper(conn, &msg->msg, msg->callbackID);
+ remoteDomainBuildEventPMSuspendHelper(conn, &msg->msg, msg->callbackID,
+ msg->reason);
}
@@ -5304,7 +5308,8 @@ remoteDomainBuildEventCallbackBalloonChange(virNetClientProgramPtr
prog ATTRIBUT
static void
remoteDomainBuildEventPMSuspendDiskHelper(virConnectPtr conn,
remote_domain_event_pmsuspend_disk_msg *msg,
- int callbackID)
+ int callbackID,
+ int reason)
{
struct private_data *priv = conn->privateData;
virDomainPtr dom;
@@ -5314,7 +5319,7 @@ remoteDomainBuildEventPMSuspendDiskHelper(virConnectPtr conn,
if (!dom)
return;
- event = virDomainEventPMSuspendDiskNewFromDom(dom);
+ event = virDomainEventPMSuspendDiskNewFromDom(dom, reason);
virDomainFree(dom);
@@ -5327,7 +5332,7 @@ remoteDomainBuildEventPMSuspendDisk(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED
{
virConnectPtr conn = opaque;
remote_domain_event_pmsuspend_disk_msg *msg = evdata;
- remoteDomainBuildEventPMSuspendDiskHelper(conn, msg, -1);
+ remoteDomainBuildEventPMSuspendDiskHelper(conn, msg, -1, 0);
}
static void
remoteDomainBuildEventCallbackPMSuspendDisk(virNetClientProgramPtr prog
ATTRIBUTE_UNUSED,
@@ -5336,7 +5341,8 @@ remoteDomainBuildEventCallbackPMSuspendDisk(virNetClientProgramPtr
prog ATTRIBUT
{
virConnectPtr conn = opaque;
remote_domain_event_callback_pmsuspend_disk_msg *msg = evdata;
- remoteDomainBuildEventPMSuspendDiskHelper(conn, &msg->msg,
msg->callbackID);
+ remoteDomainBuildEventPMSuspendDiskHelper(conn, &msg->msg,
msg->callbackID,
+ msg->reason);
}
diff --git a/src/remote/remote_protocol.x b/src/remote/remote_protocol.x
index 8238405..9dc8253 100644
--- a/src/remote/remote_protocol.x
+++ b/src/remote/remote_protocol.x
@@ -2378,6 +2378,7 @@ struct remote_domain_event_pmwakeup_msg {
};
struct remote_domain_event_callback_pmwakeup_msg {
int callbackID;
+ int reason;
remote_domain_event_pmwakeup_msg msg;
};
@@ -2386,6 +2387,7 @@ struct remote_domain_event_pmsuspend_msg {
};
struct remote_domain_event_callback_pmsuspend_msg {
int callbackID;
+ int reason;
remote_domain_event_pmsuspend_msg msg;
};
@@ -2403,6 +2405,7 @@ struct remote_domain_event_pmsuspend_disk_msg {
};
struct remote_domain_event_callback_pmsuspend_disk_msg {
int callbackID;
+ int reason;
remote_domain_event_pmsuspend_disk_msg msg;
};
diff --git a/src/remote_protocol-structs b/src/remote_protocol-structs
index fdff787..5636d55 100644
--- a/src/remote_protocol-structs
+++ b/src/remote_protocol-structs
@@ -1824,6 +1824,7 @@ struct remote_domain_event_pmwakeup_msg {
};
struct remote_domain_event_callback_pmwakeup_msg {
int callbackID;
+ int reason;
remote_domain_event_pmwakeup_msg msg;
};
struct remote_domain_event_pmsuspend_msg {
@@ -1831,6 +1832,7 @@ struct remote_domain_event_pmsuspend_msg {
};
struct remote_domain_event_callback_pmsuspend_msg {
int callbackID;
+ int reason;
remote_domain_event_pmsuspend_msg msg;
};
struct remote_domain_event_balloon_change_msg {
@@ -1846,6 +1848,7 @@ struct remote_domain_event_pmsuspend_disk_msg {
};
struct remote_domain_event_callback_pmsuspend_disk_msg {
int callbackID;
+ int reason;
remote_domain_event_pmsuspend_disk_msg msg;
};
struct remote_domain_managed_save_args {
--
1.8.5.3
10:04 a.m.
New subject: [libvirt] [PATCHv2 6/6] event: pass reason for PM events
On Wed, Jan 29, 2014 at 10:49:26AM -0700, Eric Blake wrote:
Commit 57ddcc23 (v0.9.11) introduced the pmwakeup event, with
an optional 'reason' field reserved for possible future expansion.
But it failed to wire the field through RPC, so even if we do
add a reason in the future, we will be unable to get it back
to the user.
Worse, commit 7ba5defb (v1.0.0) repeated the same mistake with
the pmsuspend_disk event.
Urgh I've caught cases of new events not doing that before
and fixed it, guess i missed this one.
As long as we are adding new RPC calls, we might as well fix
the events to actually match the signature so that we don't have
to add yet another RPC in the future if we do decide to start
using the reason field.
* src/remote/remote_protocol.x
(remote_domain_event_callback_pmwakeup_msg)
(remote_domain_event_callback_pmsuspend_msg)
(remote_domain_event_callback_pmsuspend_disk_msg): Add reason
field.
* daemon/remote.c (remoteRelayDomainEventPMWakeup)
(remoteRelayDomainEventPMSuspend)
(remoteRelayDomainEventPMSuspendDisk): Pass reason to client.
* src/conf/domain_event.h (virDomainEventPMWakeupNewFromDom)
(virDomainEventPMSuspendNewFromDom)
(virDomainEventPMSuspendDiskNewFromDom): Require additional
parameter.
* src/conf/domain_event.c (virDomainEventPMClass): New class.
(virDomainEventPMDispose): New function.
(virDomainEventPMWakeupNew*, virDomainEventPMSuspendNew*)
(virDomainEventPMSuspendDiskNew*)
(virDomainEventDispatchDefaultFunc): Use new class.
* src/remote/remote_driver.c (remoteDomainBuildEvent*PM*): Pass
reason through.
* src/remote_protocol-structs: Regenerate.
ACK
Daniel
--
|: http://berrange.com -o- http://www.flickr.com/photos/dberrange/ :|
|: http://libvirt.org -o- http://virt-manager.org :|
|: http://autobuild.org -o- http://search.cpan.org/~danberr/ :|
|: http://entangle-photo.org -o- http://live.gnome.org/gtk-vnc :|
3940
days inactive
3954
days old
15 comments
2 participants
participants (2)
-
Daniel P. Berrange -
Eric Blake