Add support for the suspend event

This patch introduces a new event type for the QMP event
SUSPEND:

    VIR_DOMAIN_EVENT_ID_PMSUSPEND

The event doesn't take any data, but considering there might
be reason for wakeup in future, the callback definition is:

typedef void
(*virConnectDomainEventSuspendCallback)(virConnectPtr conn,
                                        virDomainPtr dom,
                                        int reason,
                                        void *opaque);

"reason" is unused currently, always passes "0".

daemon/remote.c

@@ -538,7 +538,6 @@ static int remoteRelayDomainEventTrayChange(virConnectPtr conn ATTRIBUTE_UNUSED,
     return 0;
 }
 
-
 static int remoteRelayDomainEventPMWakeup(virConnectPtr conn ATTRIBUTE_UNUSED,
                                           virDomainPtr dom,
                                           void *opaque) {
@@ -561,6 +560,28 @@ static int remoteRelayDomainEventPMWakeup(virConnectPtr conn ATTRIBUTE_UNUSED,
     return 0;
 }
 
+static int remoteRelayDomainEventPMSuspend(virConnectPtr conn ATTRIBUTE_UNUSED,
+                                           virDomainPtr dom,
+                                           void *opaque) {
+    virNetServerClientPtr client = opaque;
+    remote_domain_event_pmsuspend_msg data;
+
+    if (!client)
+        return -1;
+
+    VIR_DEBUG("Relaying domain %s %d system pmsuspend", 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_PMSUSPEND,
+                                  (xdrproc_t)xdr_remote_domain_event_pmsuspend_msg, &data);
+
+    return 0;
+}
+
 static virConnectDomainEventGenericCallback domainEventCallbacks[] = {
     VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventLifecycle),
     VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventReboot),
@@ -574,6 +595,7 @@ static virConnectDomainEventGenericCallback domainEventCallbacks[] = {
     VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventDiskChange),
     VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventTrayChange),
     VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventPMWakeup),
+    VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventPMSuspend),
 };
 
 verify(ARRAY_CARDINALITY(domainEventCallbacks) == VIR_DOMAIN_EVENT_ID_LAST);

examples/domain-events/events-c/event-test.c

@@ -340,6 +340,16 @@ static int myDomainEventPMWakeupCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
     return 0;
 }
 
+static int myDomainEventPMSuspendCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
+                                          virDomainPtr dom,
+                                          int reason ATTRIBUTE_UNUSED,
+                                          void *opaque ATTRIBUTE_UNUSED)
+{
+    printf("%s EVENT: Domain %s(%d) system pmsuspend",
+           __func__, virDomainGetName(dom), virDomainGetID(dom));
+    return 0;
+}
+
 static void myFreeFunc(void *opaque)
 {
     char *str = opaque;
@@ -377,6 +387,7 @@ int main(int argc, char **argv)
     int callback9ret = -1;
     int callback10ret = -1;
     int callback11ret = -1;
+    int callback12ret = -1;
     struct sigaction action_stop;
 
     memset(&action_stop, 0, sizeof action_stop);
@@ -457,6 +468,11 @@ int main(int argc, char **argv)
                                                      VIR_DOMAIN_EVENT_ID_PMWAKEUP,
                                                      VIR_DOMAIN_EVENT_CALLBACK(myDomainEventPMWakeupCallback),
                                                      strdup("pmwakeup"), myFreeFunc);
+    callback12ret = virConnectDomainEventRegisterAny(dconn,
+                                                     NULL,
+                                                     VIR_DOMAIN_EVENT_ID_PMSUSPEND,
+                                                     VIR_DOMAIN_EVENT_CALLBACK(myDomainEventPMSuspendCallback),
+                                                     strdup("pmsuspend"), myFreeFunc);
     if ((callback1ret != -1) &&
         (callback2ret != -1) &&
         (callback3ret != -1) &&
@@ -466,7 +482,8 @@ int main(int argc, char **argv)
         (callback7ret != -1) &&
         (callback9ret != -1) &&
         (callback10ret != -1) &&
-        (callback11ret != -1)) {
+        (callback11ret != -1) &&
+        (callback12ret != -1)) {
         if (virConnectSetKeepAlive(dconn, 5, 3) < 0) {
             virErrorPtr err = virGetLastError();
             fprintf(stderr, "Failed to start keepalive protocol: %s\n",
@@ -493,6 +510,7 @@ int main(int argc, char **argv)
         virConnectDomainEventDeregisterAny(dconn, callback9ret);
         virConnectDomainEventDeregisterAny(dconn, callback10ret);
         virConnectDomainEventDeregisterAny(dconn, callback11ret);
+        virConnectDomainEventDeregisterAny(dconn, callback12ret);
         if (callback8ret != -1)
             virConnectDomainEventDeregisterAny(dconn, callback8ret);
     }

examples/domain-events/events-python/event-test.py

@@ -480,6 +480,9 @@ def myDomainEventTrayChangeCallback(conn, dom, devAlias, reason, opaque):
 def myDomainEventPMWakeupCallback(conn, dom, reason, opaque):
     print "myDomainEventPMWakeupCallback: Domain %s(%s) system pmwakeup" % (
             dom.name(), dom.ID())
+def myDomainEventPMSuspendCallback(conn, dom, reason, opaque):
+    print "myDomainEventPMSuspendCallback: Domain %s(%s) system pmsuspend" % (
+            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"
@@ -540,6 +543,7 @@ def main():
     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.domainEventRegisterAny(None, libvirt.VIR_DOMAIN_EVENT_ID_PMSUSPEND, myDomainEventPMSuspendCallback, None)
 
     vc.setKeepAlive(5, 3)
 

include/libvirt/libvirt.h.in

@@ -3718,6 +3718,24 @@ typedef void (*virConnectDomainEventPMWakeupCallback)(virConnectPtr conn,
                                                       int reason,
                                                       void *opaque);
 
+/**
+ * virConnectDomainEventPMSuspendCallback:
+ * @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_PMSuspend with virConnectDomainEventRegisterAny()
+ */
+typedef void (*virConnectDomainEventPMSuspendCallback)(virConnectPtr conn,
+                                                       virDomainPtr dom,
+                                                       int reason,
+                                                       void *opaque);
+
 /**
  * VIR_DOMAIN_EVENT_CALLBACK:
  *
@@ -3740,6 +3758,7 @@ typedef enum {
     VIR_DOMAIN_EVENT_ID_DISK_CHANGE = 9,     /* virConnectDomainEventDiskChangeCallback */
     VIR_DOMAIN_EVENT_ID_TRAY_CHANGE = 10,    /* virConnectDomainEventTrayChangeCallback */
     VIR_DOMAIN_EVENT_ID_PMWAKEUP = 11,       /* virConnectDomainEventPMWakeupCallback */
+    VIR_DOMAIN_EVENT_ID_PMSUSPEND = 12,      /* virConnectDomainEventPMSuspendCallback */
 
 #ifdef VIR_ENUM_SENTINELS
     /*

python/libvirt-override-virConnect.py

@@ -152,6 +152,15 @@
         cb(self, virDomain(self, _obj=dom), reason, opaque)
         return 0;
 
+    def _dispatchDomainEventPMSuspendCallback(self, dom, reason, cbData):
+        """Dispatches event to python user domain pmsuspend 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
            domain callback will disable delivery of this event type """

python/libvirt-override.c

@@ -5199,6 +5199,53 @@ libvirt_virConnectDomainEventPMWakeupCallback(virConnectPtr conn ATTRIBUTE_UNUSE
     return ret;
 }
 
+static int
+libvirt_virConnectDomainEventPMSuspendCallback(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*)"_dispatchDomainEventPMSuspendCallback",
+                                    (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)
@@ -5265,6 +5312,9 @@ libvirt_virConnectDomainEventRegisterAny(ATTRIBUTE_UNUSED PyObject * self,
     case VIR_DOMAIN_EVENT_ID_PMWAKEUP:
         cb = VIR_DOMAIN_EVENT_CALLBACK(libvirt_virConnectDomainEventPMWakeupCallback);
         break;
+    case VIR_DOMAIN_EVENT_ID_PMSUSPEND:
+        cb = VIR_DOMAIN_EVENT_CALLBACK(libvirt_virConnectDomainEventPMSuspendCallback);
+        break;
     }
 
     if (!cb) {

src/conf/domain_event.c

@@ -1119,6 +1119,31 @@ virDomainEventPMWakeupNewFromDom(virDomainPtr dom)
     return virDomainEventPMWakeupNew(dom->id, dom->name, dom->uuid);
 }
 
+static virDomainEventPtr
+virDomainEventPMSuspendNew(int id, const char *name,
+                           unsigned char *uuid)
+{
+    virDomainEventPtr ev =
+        virDomainEventNewInternal(VIR_DOMAIN_EVENT_ID_PMSUSPEND,
+                                  id, name, uuid);
+
+    return ev;
+}
+
+virDomainEventPtr
+virDomainEventPMSuspendNewFromObj(virDomainObjPtr obj)
+{
+    return virDomainEventPMSuspendNew(obj->def->id,
+                                      obj->def->name,
+                                      obj->def->uuid);
+}
+
+virDomainEventPtr
+virDomainEventPMSuspendNewFromDom(virDomainPtr dom)
+{
+    return virDomainEventPMSuspendNew(dom->id, dom->name, dom->uuid);
+}
+
 /**
  * virDomainEventQueuePush:
  * @evtQueue: the dom event queue
@@ -1253,6 +1278,10 @@ virDomainEventDispatchDefaultFunc(virConnectPtr conn,
         ((virConnectDomainEventPMWakeupCallback)cb)(conn, dom, 0, cbopaque);
         break;
 
+    case VIR_DOMAIN_EVENT_ID_PMSUSPEND:
+        ((virConnectDomainEventPMSuspendCallback)cb)(conn, dom, 0, cbopaque);
+        break;
+
     default:
         VIR_WARN("Unexpected event ID %d", event->eventID);
         break;

src/conf/domain_event.h

@@ -122,6 +122,8 @@ virDomainEventPtr virDomainEventTrayChangeNewFromDom(virDomainPtr dom,
                                                      int reason);
 virDomainEventPtr virDomainEventPMWakeupNewFromObj(virDomainObjPtr obj);
 virDomainEventPtr virDomainEventPMWakeupNewFromDom(virDomainPtr dom);
+virDomainEventPtr virDomainEventPMSuspendNewFromObj(virDomainObjPtr obj);
+virDomainEventPtr virDomainEventPMSuspendNewFromDom(virDomainPtr dom);
 
 void virDomainEventFree(virDomainEventPtr event);
 

src/libvirt_private.syms

@@ -508,6 +508,8 @@ virDomainEventNew;
 virDomainEventNewFromDef;
 virDomainEventNewFromDom;
 virDomainEventNewFromObj;
+virDomainEventPMSuspendNewFromDom;
+virDomainEventPMSuspendNewFromObj;
 virDomainEventPMWakeupNewFromDom;
 virDomainEventPMWakeupNewFromObj;
 virDomainEventRTCChangeNewFromDom;

src/qemu/qemu_monitor.c

@@ -1063,6 +1063,16 @@ int qemuMonitorEmitPMWakeup(qemuMonitorPtr mon)
     return ret;
 }
 
+int qemuMonitorEmitPMSuspend(qemuMonitorPtr mon)
+{
+    int ret = -1;
+    VIR_DEBUG("mon=%p", mon);
+
+    QEMU_MONITOR_CALLBACK(mon, ret, domainPMSuspend, mon->vm);
+
+    return ret;
+}
+
 int qemuMonitorEmitBlockJob(qemuMonitorPtr mon,
                             const char *diskAlias,
                             int type,

src/qemu/qemu_monitor.h

@@ -130,6 +130,8 @@ struct _qemuMonitorCallbacks {
                             int reason);
     int (*domainPMWakeup)(qemuMonitorPtr mon,
                           virDomainObjPtr vm);
+    int (*domainPMSuspend)(qemuMonitorPtr mon,
+                           virDomainObjPtr vm);
 };
 
 char *qemuMonitorEscapeArg(const char *in);
@@ -200,6 +202,7 @@ int qemuMonitorEmitTrayChange(qemuMonitorPtr mon,
                               const char *devAlias,
                               int reason);
 int qemuMonitorEmitPMWakeup(qemuMonitorPtr mon);
+int qemuMonitorEmitPMSuspend(qemuMonitorPtr mon);
 int qemuMonitorEmitBlockJob(qemuMonitorPtr mon,
                             const char *diskAlias,
                             int type,

src/qemu/qemu_monitor_json.c

@@ -64,6 +64,7 @@ static void qemuMonitorJSONHandleSPICEInitialize(qemuMonitorPtr mon, virJSONValu
 static void qemuMonitorJSONHandleSPICEDisconnect(qemuMonitorPtr mon, virJSONValuePtr data);
 static void qemuMonitorJSONHandleTrayChange(qemuMonitorPtr mon, virJSONValuePtr data);
 static void qemuMonitorJSONHandlePMWakeup(qemuMonitorPtr mon, virJSONValuePtr data);
+static void qemuMonitorJSONHandlePMSuspend(qemuMonitorPtr mon, virJSONValuePtr data);
 
 static struct {
     const char *type;
@@ -85,6 +86,7 @@ static struct {
     { "SPICE_DISCONNECTED", qemuMonitorJSONHandleSPICEDisconnect, },
     { "DEVICE_TRAY_MOVED", qemuMonitorJSONHandleTrayChange, },
     { "WAKEUP", qemuMonitorJSONHandlePMWakeup, },
+    { "SUSPEND", qemuMonitorJSONHandlePMSuspend, },
 };
 
 
@@ -810,6 +812,13 @@ qemuMonitorJSONHandlePMWakeup(qemuMonitorPtr mon,
     qemuMonitorEmitPMWakeup(mon);
 }
 
+static void
+qemuMonitorJSONHandlePMSuspend(qemuMonitorPtr mon,
+                               virJSONValuePtr data ATTRIBUTE_UNUSED)
+{
+    qemuMonitorEmitPMSuspend(mon);
+}
+
 int
 qemuMonitorJSONHumanCommandWithFd(qemuMonitorPtr mon,
                                   const char *cmd_str,

src/qemu/qemu_process.c

@@ -1082,6 +1082,27 @@ qemuProcessHandlePMWakeup(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
     return 0;
 }
 
+static int
+qemuProcessHandlePMSuspend(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
+                           virDomainObjPtr vm)
+{
+    struct qemud_driver *driver = qemu_driver;
+    virDomainEventPtr event = NULL;
+
+    virDomainObjLock(vm);
+    event = virDomainEventPMSuspendNewFromObj(vm);
+
+    virDomainObjUnlock(vm);
+
+    if (event) {
+        qemuDriverLock(driver);
+        qemuDomainEventQueue(driver, event);
+        qemuDriverUnlock(driver);
+    }
+
+    return 0;
+}
+
 static qemuMonitorCallbacks monitorCallbacks = {
     .destroy = qemuProcessHandleMonitorDestroy,
     .eofNotify = qemuProcessHandleMonitorEOF,
@@ -1097,6 +1118,7 @@ static qemuMonitorCallbacks monitorCallbacks = {
     .domainBlockJob = qemuProcessHandleBlockJob,
     .domainTrayChange = qemuProcessHandleTrayChange,
     .domainPMWakeup = qemuProcessHandlePMWakeup,
+    .domainPMSuspend = qemuProcessHandlePMSuspend,
 };
 
 static int

src/remote/remote_driver.c

@@ -249,6 +249,11 @@ remoteDomainBuildEventPMWakeup(virNetClientProgramPtr prog,
                                virNetClientPtr client,
                                void *evdata, void *opaque);
 
+static void
+remoteDomainBuildEventPMSuspend(virNetClientProgramPtr prog,
+                                virNetClientPtr client,
+                                void *evdata, void *opaque);
+
 static virNetClientProgramEvent remoteDomainEvents[] = {
     { REMOTE_PROC_DOMAIN_EVENT_RTC_CHANGE,
       remoteDomainBuildEventRTCChange,
@@ -298,6 +303,10 @@ static virNetClientProgramEvent remoteDomainEvents[] = {
       remoteDomainBuildEventPMWakeup,
       sizeof(remote_domain_event_pmwakeup_msg),
       (xdrproc_t)xdr_remote_domain_event_pmwakeup_msg },
+    { REMOTE_PROC_DOMAIN_EVENT_PMSUSPEND,
+      remoteDomainBuildEventPMSuspend,
+      sizeof(remote_domain_event_pmsuspend_msg),
+      (xdrproc_t)xdr_remote_domain_event_pmsuspend_msg },
 };
 
 enum virDrvOpenRemoteFlags {
@@ -3795,6 +3804,28 @@ remoteDomainBuildEventPMWakeup(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
     remoteDomainEventQueue(priv, event);
 }
 
+static void
+remoteDomainBuildEventPMSuspend(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+                                virNetClientPtr client ATTRIBUTE_UNUSED,
+                                void *evdata, void *opaque)
+{
+    virConnectPtr conn = opaque;
+    struct private_data *priv = conn->privateData;
+    remote_domain_event_pmsuspend_msg *msg = evdata;
+    virDomainPtr dom;
+    virDomainEventPtr event = NULL;
+
+    dom = get_nonnull_domain(conn, msg->dom);
+    if (!dom)
+        return;
+
+    event = virDomainEventPMSuspendNewFromDom(dom);
+
+    virDomainFree(dom);
+
+    remoteDomainEventQueue(priv, event);
+}
+
 static virDrvOpenStatus ATTRIBUTE_NONNULL (1)
 remoteSecretOpen(virConnectPtr conn, virConnectAuthPtr auth,
                  unsigned int flags)

src/remote/remote_protocol.x

@@ -2188,6 +2188,10 @@ struct remote_domain_event_pmwakeup_msg {
     remote_nonnull_domain dom;
 };
 
+struct remote_domain_event_pmsuspend_msg {
+    remote_nonnull_domain dom;
+};
+
 struct remote_domain_managed_save_args {
     remote_nonnull_domain dom;
     unsigned int flags;
@@ -2777,7 +2781,8 @@ enum remote_procedure {
     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_PMWAKEUP = 269 /* autogen autogen */
+    REMOTE_PROC_DOMAIN_EVENT_PMWAKEUP = 269, /* autogen autogen */
+    REMOTE_PROC_DOMAIN_EVENT_PMSUSPEND = 270 /* autogen autogen */
 
     /*
      * Notice how the entries are grouped in sets of 10 ?

src/remote_protocol-structs

@@ -1658,6 +1658,9 @@ struct remote_domain_event_tray_change_msg {
 struct remote_domain_event_pmwakeup_msg {
         remote_nonnull_domain      dom;
 }
+struct remote_domain_event_pmsuspend_msg {
+        remote_nonnull_domain      dom;
+}
 struct remote_domain_managed_save_args {
         remote_nonnull_domain      dom;
         u_int                      flags;
@@ -2188,4 +2191,5 @@ enum remote_procedure {
         REMOTE_PROC_DOMAIN_PM_WAKEUP = 267,
         REMOTE_PROC_DOMAIN_TRAY_CHANGE = 268,
         REMOTE_PROC_DOMAIN_PMWAKEUP = 269,
+        REMOTE_PROC_DOMAIN_PMSUSPEND = 270,
 };