Re: [libvirt] [PATCH 07/11] Add support for the wakeup event

This patch introduces a new event type for the QMP event WAKEUP: VIR_DOMAIN_EVENT_ID_PMWAKEUP The event doesn't take any data, but considering there might be reason for wakeup in future, the callback definition is: typedef void (*virConnectDomainEventWakeupCallback)(virConnectPtr conn, virDomainPtr dom, int reason, void *opaque); "reason" is unused currently, always passes "0". --- daemon/remote.c | 24 +++++++++ examples/domain-events/events-c/event-test.c | 21 +++++++- examples/domain-events/events-python/event-test.py | 4 ++ include/libvirt/libvirt.h.in | 18 +++++++ python/libvirt-override-virConnect.py | 8 +++ python/libvirt-override.c | 50 ++++++++++++++++++++ src/conf/domain_event.c | 28 +++++++++++ src/conf/domain_event.h | 2 + src/libvirt_private.syms | 2 + src/qemu/qemu_monitor.c | 10 ++++ src/qemu/qemu_monitor.h | 3 + src/qemu/qemu_monitor_json.c | 9 ++++ src/qemu/qemu_process.c | 21 ++++++++ src/remote/remote_driver.c | 30 ++++++++++++ src/remote/remote_protocol.x | 7 ++- src/remote_protocol-structs | 4 ++ 16 files changed, 238 insertions(+), 3 deletions(-) diff --git a/daemon/remote.c b/daemon/remote.c index 060f77b..db3b6bc 100644 --- a/daemon/remote.c +++ b/daemon/remote.c @@ -538,6 +538,29 @@ static int remoteRelayDomainEventTrayChange(virConnectPtr conn ATTRIBUTE_UNUSED, return 0; } + +static int remoteRelayDomainEventPMWakeup(virConnectPtr conn ATTRIBUTE_UNUSED, + virDomainPtr dom, + void *opaque) { + virNetServerClientPtr client = opaque; + remote_domain_event_pmwakeup_msg data; + + if (!client) + return -1; + + VIR_DEBUG("Relaying domain %s %d system pmwakeup", dom->name, dom->id); + + /* build return data */ + memset(&data, 0, sizeof data); + make_nonnull_domain(&data.dom, dom); + + remoteDispatchDomainEventSend(client, remoteProgram, + REMOTE_PROC_DOMAIN_EVENT_PMWAKEUP, + (xdrproc_t)xdr_remote_domain_event_pmwakeup_msg, &data); + + return 0; +} + static virConnectDomainEventGenericCallback domainEventCallbacks[] = { VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventLifecycle), VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventReboot), @@ -550,6 +573,7 @@ static virConnectDomainEventGenericCallback domainEventCallbacks[] = { VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventBlockJob), VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventDiskChange), VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventTrayChange), + VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventPMWakeup), }; verify(ARRAY_CARDINALITY(domainEventCallbacks) == VIR_DOMAIN_EVENT_ID_LAST); diff --git a/examples/domain-events/events-c/event-test.c b/examples/domain-events/events-c/event-test.c index cca9a1a..78cfa3b 100644 --- a/examples/domain-events/events-c/event-test.c +++ b/examples/domain-events/events-c/event-test.c @@ -330,6 +330,16 @@ static int myDomainEventTrayChangeCallback(virConnectPtr conn ATTRIBUTE_UNUSED, return 0; } +static int myDomainEventPMWakeupCallback(virConnectPtr conn ATTRIBUTE_UNUSED, + virDomainPtr dom, + int reason ATTRIBUTE_UNUSED, + void *opaque ATTRIBUTE_UNUSED) +{ + printf("%s EVENT: Domain %s(%d) system pmwakeup", + __func__, virDomainGetName(dom), virDomainGetID(dom)); + return 0; +} + static void myFreeFunc(void *opaque) { char *str = opaque; @@ -366,6 +376,7 @@ int main(int argc, char **argv) int callback8ret = -1; int callback9ret = -1; int callback10ret = -1; + int callback11ret = -1; struct sigaction action_stop; memset(&action_stop, 0, sizeof action_stop); @@ -441,7 +452,11 @@ int main(int argc, char **argv) VIR_DOMAIN_EVENT_ID_TRAY_CHANGE, VIR_DOMAIN_EVENT_CALLBACK(myDomainEventTrayChangeCallback), strdup("tray change"), myFreeFunc); - + callback11ret = virConnectDomainEventRegisterAny(dconn, + NULL, + VIR_DOMAIN_EVENT_ID_PMWAKEUP, + VIR_DOMAIN_EVENT_CALLBACK(myDomainEventPMWakeupCallback), + strdup("pmwakeup"), myFreeFunc); if ((callback1ret != -1) && (callback2ret != -1) && (callback3ret != -1) && @@ -450,7 +465,8 @@ int main(int argc, char **argv) (callback6ret != -1) && (callback7ret != -1) && (callback9ret != -1) && - (callback10ret != -1)) { + (callback10ret != -1) && + (callback11ret != -1)) { if (virConnectSetKeepAlive(dconn, 5, 3) < 0) { virErrorPtr err = virGetLastError(); fprintf(stderr, "Failed to start keepalive protocol: %s\n", @@ -476,6 +492,7 @@ int main(int argc, char **argv) virConnectDomainEventDeregisterAny(dconn, callback7ret); virConnectDomainEventDeregisterAny(dconn, callback9ret); virConnectDomainEventDeregisterAny(dconn, callback10ret); + virConnectDomainEventDeregisterAny(dconn, callback11ret); if (callback8ret != -1) virConnectDomainEventDeregisterAny(dconn, callback8ret); } diff --git a/examples/domain-events/events-python/event-test.py b/examples/domain-events/events-python/event-test.py index 6e0409d..249b590 100644 --- a/examples/domain-events/events-python/event-test.py +++ b/examples/domain-events/events-python/event-test.py @@ -477,6 +477,9 @@ def myDomainEventDiskChangeCallback(conn, dom, oldSrcPath, newSrcPath, devAlias, def myDomainEventTrayChangeCallback(conn, dom, devAlias, reason, opaque): print "myDomainEventTrayChangeCallback: Domain %s(%s) tray change devAlias: %s reason: %s" % ( dom.name(), dom.ID(), devAlias, reason) +def myDomainEventPMWakeupCallback(conn, dom, reason, opaque): + print "myDomainEventPMWakeupCallback: Domain %s(%s) system pmwakeup" % ( + dom.name(), dom.ID()) def usage(out=sys.stderr): print >>out, "usage: "+os.path.basename(sys.argv[0])+" [-hdl] [uri]" print >>out, " uri will default to qemu:///system" @@ -536,6 +539,7 @@ def main(): vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_GRAPHICS, myDomainEventGraphicsCallback, None) vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_DISK_CHANGE, myDomainEventDiskChangeCallback, None) vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_TRAY_CHANGE, myDomainEventTrayChangeCallback, None) + vc.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_PMWAKEUP, myDomainEventPMWakeupCallback, None) vc.setKeepAlive(5, 3) diff --git a/include/libvirt/libvirt.h.in b/include/libvirt/libvirt.h.in index 7bf1004..a9a15e1 100644 --- a/include/libvirt/libvirt.h.in +++ b/include/libvirt/libvirt.h.in @@ -3700,6 +3700,23 @@ typedef void (*virConnectDomainEventTrayChangeCallback)(virConnectPtr conn, int reason, void *opaque); +/** + * virConnectDomainEventPMWakeupCallback: + * @conn: connection object + * @dom: domain on which the event occurred + * @reason: reason why the callback was called, unused currently, + * always passes 0 + * @opaque: application specified data + * + * This callback occurs when the guest is waken up. + * + * The callback signature to use when registering for an event of type + * VIR_DOMAIN_EVENT_ID_PMWAKEUP with virConnectDomainEventRegisterAny() + */ +typedef void (*virConnectDomainEventPMWakeupCallback)(virConnectPtr conn, + virDomainPtr dom, + int reason, + void *opaque); /** * VIR_DOMAIN_EVENT_CALLBACK: @@ -3722,6 +3739,7 @@ typedef enum { VIR_DOMAIN_EVENT_ID_BLOCK_JOB = 8, /* virConnectDomainEventBlockJobCallback */ VIR_DOMAIN_EVENT_ID_DISK_CHANGE = 9, /* virConnectDomainEventDiskChangeCallback */ VIR_DOMAIN_EVENT_ID_TRAY_CHANGE = 10, /* virConnectDomainEventTrayChangeCallback */ + VIR_DOMAIN_EVENT_ID_PMWAKEUP = 11, /* virConnectDomainEventPMWakeupCallback */ #ifdef VIR_ENUM_SENTINELS /* diff --git a/python/libvirt-override-virConnect.py b/python/libvirt-override-virConnect.py index 82c2437..2d48828 100644 --- a/python/libvirt-override-virConnect.py +++ b/python/libvirt-override-virConnect.py @@ -143,6 +143,14 @@ cb(self, virDomain(self, _obj=dom), devAlias, reason, opaque) return 0; + def _dispatchDomainEventPMWakeupCallback(self, dom, reason, cbData): + """Dispatches event to python user domain pmwakeup event callbacks + """ + cb = cbData["cb"] + opaque = cbData["opaque"] + + cb(self, virDomain(self, _obj=dom), reason, opaque) + return 0; def domainEventDeregisterAny(self, callbackID): """Removes a Domain Event Callback. De-registering for a diff --git a/python/libvirt-override.c b/python/libvirt-override.c index 915ebd2..f604a16 100644 --- a/python/libvirt-override.c +++ b/python/libvirt-override.c @@ -4974,6 +4974,53 @@ libvirt_virConnectDomainEventTrayChangeCallback(virConnectPtr conn ATTRIBUTE_UNU return ret; } +static int +libvirt_virConnectDomainEventPMWakeupCallback(virConnectPtr conn ATTRIBUTE_UNUSED, + virDomainPtr dom, + int reason, + void *opaque) +{ + PyObject *pyobj_cbData = (PyObject*)opaque; + PyObject *pyobj_dom; + PyObject *pyobj_ret; + PyObject *pyobj_conn; + PyObject *dictKey; + int ret = -1; + + LIBVIRT_ENSURE_THREAD_STATE; + /* Create a python instance of this virDomainPtr */ + virDomainRef(dom); + + pyobj_dom = libvirt_virDomainPtrWrap(dom); + Py_INCREF(pyobj_cbData); + + dictKey = libvirt_constcharPtrWrap("conn"); + pyobj_conn = PyDict_GetItem(pyobj_cbData, dictKey); + Py_DECREF(dictKey); + + /* Call the Callback Dispatcher */ + pyobj_ret = PyObject_CallMethod(pyobj_conn, + (char*)"_dispatchDomainEventPMWakeupCallback", + (char*)"OO", + pyobj_dom, + reason, + pyobj_cbData); + + Py_DECREF(pyobj_cbData); + Py_DECREF(pyobj_dom); + + if(!pyobj_ret) { + DEBUG("%s - ret:%p\n", __FUNCTION__, pyobj_ret); + PyErr_Print(); + } else { + Py_DECREF(pyobj_ret); + ret = 0; + } + + LIBVIRT_RELEASE_THREAD_STATE; + return ret; +} + static PyObject * libvirt_virConnectDomainEventRegisterAny(ATTRIBUTE_UNUSED PyObject * self, PyObject * args) @@ -5037,6 +5084,9 @@ libvirt_virConnectDomainEventRegisterAny(ATTRIBUTE_UNUSED PyObject * self, case VIR_DOMAIN_EVENT_ID_TRAY_CHANGE: cb = VIR_DOMAIN_EVENT_CALLBACK(libvirt_virConnectDomainEventTrayChangeCallback); break; + case VIR_DOMAIN_EVENT_ID_PMWAKEUP: + cb = VIR_DOMAIN_EVENT_CALLBACK(libvirt_virConnectDomainEventPMWakeupCallback); + break; } if (!cb) { diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index 9c2a052..06a8e29 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -1094,6 +1094,30 @@ virDomainEventPtr virDomainEventTrayChangeNewFromDom(virDomainPtr dom, devAlias, reason); } +static virDomainEventPtr +virDomainEventPMWakeupNew(int id, const char *name, + unsigned char *uuid) +{ + virDomainEventPtr ev = + virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_PMWAKEUP, + id, name, uuid); + + return ev; +} + +virDomainEventPtr +virDomainEventPMWakeupNewFromObj(virDomainObjPtr obj) +{ + return virDomainEventPMWakeupNew(obj->def->id, + obj->def->name, + obj->def->uuid); +} + +virDomainEventPtr +virDomainEventPMWakeupNewFromDom(virDomainPtr dom) +{ + return virDomainEventPMWakeupNew(dom->id, dom->name, dom->uuid); +} /** * virDomainEventQueuePush: @@ -1225,6 +1249,10 @@ virDomainEventDispatchDefaultFunc(virConnectPtr conn, cbopaque); break; + case VIR_DOMAIN_EVENT_ID_PMWAKEUP: + ((virConnectDomainEventPMWakeupCallback)cb)(conn, dom, 0, cbopaque); + break; + default: VIR_WARN("Unexpected event ID %d", event->eventID); break; diff --git a/src/conf/domain_event.h b/src/conf/domain_event.h index e5010a3..7d39201 100644 --- a/src/conf/domain_event.h +++ b/src/conf/domain_event.h @@ -120,6 +120,8 @@ virDomainEventPtr virDomainEventTrayChangeNewFromObj(virDomainObjPtr obj, virDomainEventPtr virDomainEventTrayChangeNewFromDom(virDomainPtr dom, const char *devAlias, int reason); +virDomainEventPtr virDomainEventPMWakeupNewFromObj(virDomainObjPtr obj); +virDomainEventPtr virDomainEventPMWakeupNewFromDom(virDomainPtr dom); void virDomainEventFree(virDomainEventPtr event); diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index e247472..d591d04 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -511,6 +511,8 @@ virDomainEventNew; virDomainEventNewFromDef; virDomainEventNewFromDom; virDomainEventNewFromObj; +virDomainEventPMWakeupNewFromDom; +virDomainEventPMWakeupNewFromObj; virDomainEventRTCChangeNewFromDom; virDomainEventRTCChangeNewFromObj; virDomainEventRebootNew; diff --git a/src/qemu/qemu_monitor.c b/src/qemu/qemu_monitor.c index 90b8e12..adf3636 100644 --- a/src/qemu/qemu_monitor.c +++ b/src/qemu/qemu_monitor.c @@ -1053,6 +1053,16 @@ int qemuMonitorEmitTrayChange(qemuMonitorPtr mon, return ret; } +int qemuMonitorEmitPMWakeup(qemuMonitorPtr mon) +{ + int ret = -1; + VIR_DEBUG("mon=%p", mon); + + QEMU_MONITOR_CALLBACK(mon, ret, domainPMWakeup, mon->vm); + + return ret; +} + int qemuMonitorEmitBlockJob(qemuMonitorPtr mon, const char *diskAlias, int type, diff --git a/src/qemu/qemu_monitor.h b/src/qemu/qemu_monitor.h index b5a0c30..6919a66 100644 --- a/src/qemu/qemu_monitor.h +++ b/src/qemu/qemu_monitor.h @@ -128,6 +128,8 @@ struct _qemuMonitorCallbacks { virDomainObjPtr vm, const char *devAlias, int reason); + int (*domainPMWakeup)(qemuMonitorPtr mon, + virDomainObjPtr vm); }; char *qemuMonitorEscapeArg(const char *in); @@ -197,6 +199,7 @@ int qemuMonitorEmitGraphics(qemuMonitorPtr mon, int qemuMonitorEmitTrayChange(qemuMonitorPtr mon, const char *devAlias, int reason); +int qemuMonitorEmitPMWakeup(qemuMonitorPtr mon); int qemuMonitorEmitBlockJob(qemuMonitorPtr mon, const char *diskAlias, int type, diff --git a/src/qemu/qemu_monitor_json.c b/src/qemu/qemu_monitor_json.c index 0312ca7..7bb4410 100644 --- a/src/qemu/qemu_monitor_json.c +++ b/src/qemu/qemu_monitor_json.c @@ -60,6 +60,7 @@ static void qemuMonitorJSONHandleVNCInitialize(qemuMonitorPtr mon, virJSONValueP static void qemuMonitorJSONHandleVNCDisconnect(qemuMonitorPtr mon, virJSONValuePtr data); static void qemuMonitorJSONHandleBlockJob(qemuMonitorPtr mon, virJSONValuePtr data); static void qemuMonitorJSONHandleTrayChange(qemuMonitorPtr mon, virJSONValuePtr data); +static void qemuMonitorJSONHandlePMWakeup(qemuMonitorPtr mon, virJSONValuePtr data); static struct { const char *type; @@ -77,6 +78,7 @@ static struct { { "VNC_DISCONNECTED", qemuMonitorJSONHandleVNCDisconnect, }, { "BLOCK_JOB_COMPLETED", qemuMonitorJSONHandleBlockJob, }, { "DEVICE_TRAY_MOVED", qemuMonitorJSONHandleTrayChange, }, + { "WAKEUP", qemuMonitorJSONHandlePMWakeup, }, }; @@ -753,6 +755,13 @@ qemuMonitorJSONHandleTrayChange(qemuMonitorPtr mon, qemuMonitorEmitTrayChange(mon, devAlias, reason); } +static void +qemuMonitorJSONHandlePMWakeup(qemuMonitorPtr mon, + virJSONValuePtr data ATTRIBUTE_UNUSED) +{ + qemuMonitorEmitPMWakeup(mon); +} + int qemuMonitorJSONHumanCommandWithFd(qemuMonitorPtr mon, const char *cmd_str, diff --git a/src/qemu/qemu_process.c b/src/qemu/qemu_process.c index 7511d4e..7914a6a 100644 --- a/src/qemu/qemu_process.c +++ b/src/qemu/qemu_process.c @@ -1061,6 +1061,26 @@ qemuProcessHandleTrayChange(qemuMonitorPtr mon ATTRIBUTE_UNUSED, return 0; } +static int +qemuProcessHandlePMWakeup(qemuMonitorPtr mon ATTRIBUTE_UNUSED, + virDomainObjPtr vm) +{ + struct qemud_driver *driver = qemu_driver; + virDomainEventPtr event = NULL; + + virDomainObjLock(vm); + event = virDomainEventPMWakeupNewFromObj(vm); + + virDomainObjUnlock(vm); + + if (event) { + qemuDriverLock(driver); + qemuDomainEventQueue(driver, event); + qemuDriverUnlock(driver); + } + + return 0; +} static qemuMonitorCallbacks monitorCallbacks = { .destroy = qemuProcessHandleMonitorDestroy, @@ -1076,6 +1096,7 @@ static qemuMonitorCallbacks monitorCallbacks = { .domainGraphics = qemuProcessHandleGraphics, .domainBlockJob = qemuProcessHandleBlockJob, .domainTrayChange = qemuProcessHandleTrayChange, + .domainPMWakeup = qemuProcessHandlePMWakeup, }; static int diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c index ac95dcc..27eafa1 100644 --- a/src/remote/remote_driver.c +++ b/src/remote/remote_driver.c @@ -243,6 +243,11 @@ remoteDomainBuildEventTrayChange(virNetClientProgramPtr prog, virNetClientPtr client, void *evdata, void *opaque); +static void +remoteDomainBuildEventPMWakeup(virNetClientProgramPtr prog, + virNetClientPtr client, + void *evdata, void *opaque); + static virNetClientProgramEvent remoteDomainEvents[] = { { REMOTE_PROC_DOMAIN_EVENT_RTC_CHANGE, remoteDomainBuildEventRTCChange, @@ -288,6 +293,10 @@ static virNetClientProgramEvent remoteDomainEvents[] = { remoteDomainBuildEventTrayChange, sizeof(remote_domain_event_tray_change_msg), (xdrproc_t)xdr_remote_domain_event_tray_change_msg }, + { REMOTE_PROC_DOMAIN_EVENT_PMWAKEUP, + remoteDomainBuildEventPMWakeup, + sizeof(remote_domain_event_pmwakeup_msg), + (xdrproc_t)xdr_remote_domain_event_pmwakeup_msg }, }; enum virDrvOpenRemoteFlags { @@ -3678,6 +3687,27 @@ remoteDomainBuildEventTrayChange(virNetClientProgramPtr prog ATTRIBUTE_UNUSED, remoteDomainEventQueue(priv, event); } +static void +remoteDomainBuildEventPMWakeup(virNetClientProgramPtr prog ATTRIBUTE_UNUSED, + virNetClientPtr client ATTRIBUTE_UNUSED, + void *evdata, void *opaque) +{ + virConnectPtr conn = opaque; + struct private_data *priv = conn->privateData; + remote_domain_event_pmwakeup_msg *msg = evdata; + virDomainPtr dom; + virDomainEventPtr event = NULL; + + dom = get_nonnull_domain(conn, msg->dom); + if (!dom) + return; + + event = virDomainEventPMWakeupNewFromDom(dom); + + virDomainFree(dom); + + remoteDomainEventQueue(priv, event); +} static virDrvOpenStatus ATTRIBUTE_NONNULL (1) remoteSecretOpen(virConnectPtr conn, virConnectAuthPtr auth, diff --git a/src/remote/remote_protocol.x b/src/remote/remote_protocol.x index 6c8c497..f462b20 100644 --- a/src/remote/remote_protocol.x +++ b/src/remote/remote_protocol.x @@ -2184,6 +2184,10 @@ struct remote_domain_event_tray_change_msg { int reason; }; +struct remote_domain_event_pmwakeup_msg { + remote_nonnull_domain dom; +}; + struct remote_domain_managed_save_args { remote_nonnull_domain dom; unsigned int flags; @@ -2772,7 +2776,8 @@ enum remote_procedure { REMOTE_PROC_DOMAIN_GET_METADATA = 265, /* autogen autogen */ REMOTE_PROC_DOMAIN_BLOCK_REBASE = 266, /* autogen autogen */ REMOTE_PROC_DOMAIN_PM_WAKEUP = 267, /* autogen autogen */ - REMOTE_PROC_DOMAIN_EVENT_TRAY_CHANGE = 268 /* autogen autogen */ + REMOTE_PROC_DOMAIN_EVENT_TRAY_CHANGE = 268, /* autogen autogen */ + REMOTE_PROC_DOMAIN_EVENT_PMWAKEUP = 269 /* autogen autogen */ /* * Notice how the entries are grouped in sets of 10 ? diff --git a/src/remote_protocol-structs b/src/remote_protocol-structs index 0ce7c1c..5eb4df3 100644 --- a/src/remote_protocol-structs +++ b/src/remote_protocol-structs @@ -1655,6 +1655,9 @@ struct remote_domain_event_tray_change_msg { remote_nonnull_string devAlias; int reason; } +struct remote_domain_event_pmwakeup_msg { + remote_nonnull_domain dom; +} struct remote_domain_managed_save_args { remote_nonnull_domain dom; u_int flags; @@ -2184,4 +2187,5 @@ enum remote_procedure { REMOTE_PROC_DOMAIN_BLOCK_REBASE = 266, REMOTE_PROC_DOMAIN_PM_WAKEUP = 267, REMOTE_PROC_DOMAIN_TRAY_CHANGE = 268, + REMOTE_PROC_DOMAIN_PMWAKEUP = 269, };