shaba/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2024-12-25 01:34:11 +03:00
Code Releases Activity

Add support for the suspend event

Browse Source 
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".
This commit is contained in:
Osier Yang 2012-03-23 22:50:36 +08:00
parent 57ddcc235a
commit 487c063381
16 changed files with 242 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
daemon/remote.c
View File

@ -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);

20
examples/domain-events/events-c/event-test.c
View File

@ -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);
}

4
examples/domain-events/events-python/event-test.py
View File

@ -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)

19
include/libvirt/libvirt.h.in
View File

@ -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
/*

9
python/libvirt-override-virConnect.py
View File

@ -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 """

50
python/libvirt-override.c
View File

@ -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) {

29
src/conf/domain_event.c
View File

@ -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;

2
src/conf/domain_event.h
View File

@ -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);

2
src/libvirt_private.syms
View File

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

10
src/qemu/qemu_monitor.c
View File

@ -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,

3
src/qemu/qemu_monitor.h
View File

@ -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,

9
src/qemu/qemu_monitor_json.c
View File

@ -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,

22
src/qemu/qemu_process.c
View File

@ -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

31
src/remote/remote_driver.c
View File

@ -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)

7
src/remote/remote_protocol.x
View File

@ -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 ?

4
src/remote_protocol-structs
View File

@ -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,
};