[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]

Re: [libvirt] add a qemu-specific event register API, to passthough the new events come from qemu



there are are some thing wrong with the formate of my last mail, so I
resent it again.

and In this patch, I add the the register callback
_dispatchDomainEventUnknown Callback function as an attribute of the
virConnect class in libvirt.py, not in the libvirt_qemu.py.

should I make it as an attribute of an new subclass that inherits from
virConnect class in libvirt_qemu.py?
 
now, there will come an  "RESUME" events when qemu domains are started.

The attached 0002-for-testing-the-new-qemu-specific-regiater-API.patch
is used to start a qemu domain and to catch this event.
# ./tools/virsh -c qemu:///system
virsh# register-event RESUME
virsh# start domain

the attached python test case, is used to catch RESUME events, in order
to test the python register API.


, shaohef linux vnet ibm com wrote:
> From: Shao He Feng <shaohef linux vnet ibm com>
>
> Basically, this feature can go along with qemu monitor passthrough.
> That way, if we use new commands in the monitor that generate new events, we want some way to receive those new events too.
> In order to test this patch, see the attached python test case.  When domains are started, it will be able to catch RESUME events.
>
> Signed-off-by: Shao He Feng <shaohef linux vnet ibm com>
> ---
>  daemon/libvirtd.h                     |   12 +-
>  daemon/remote.c                       |  195 ++++++++++++++++++-
>  include/libvirt/libvirt-qemu.h        |   11 +
>  include/libvirt/libvirt.h.in          |   17 ++-
>  python/generator.py                   |   26 ++-
>  python/libvirt-override-virConnect.py |   14 ++-
>  python/libvirt-qemu-override.c        |  140 +++++++++++++
>  python/libvirt-qemu-override.py       |   41 ++++
>  src/conf/domain_event.c               |  347 +++++++++++++++++++++++++++++++--
>  src/conf/domain_event.h               |   49 +++++-
>  src/driver.h                          |   14 ++
>  src/libvirt-qemu.c                    |  190 ++++++++++++++++++
>  src/libvirt_private.syms              |    6 +
>  src/libvirt_qemu.syms                 |    5 +
>  src/qemu/qemu_driver.c                |   42 ++++
>  src/qemu/qemu_monitor.c               |   10 +
>  src/qemu/qemu_monitor.h               |    8 +
>  src/qemu/qemu_monitor_json.c          |   36 ++++
>  src/qemu/qemu_process.c               |   24 +++
>  src/remote/qemu_protocol.x            |   33 +++-
>  src/remote/remote_driver.c            |  153 ++++++++++++++-
>  src/remote/remote_protocol.x          |    9 +-
>  src/remote_protocol-structs           |    5 +
>  23 files changed, 1353 insertions(+), 34 deletions(-)
>  mode change 100644 => 100755 python/libvirt-override-virConnect.py
>  mode change 100644 => 100755 python/libvirt-override-virStream.py
>  mode change 100644 => 100755 python/libvirt-override.py
>  create mode 100644 python/libvirt-qemu-override.py
>
> diff --git a/daemon/libvirtd.h b/daemon/libvirtd.h
> index c8d3ca2..e3e1c40 100644
> --- a/daemon/libvirtd.h
> +++ b/daemon/libvirtd.h
> @@ -38,6 +38,16 @@
>  # endif
>  # include "virnetserverprogram.h"
>
> +/* limit the number unknow event of an conncet can register */
> +#define VIR_DOMAIN_EVENT_NAME_LAST  512
> +struct domainEventNameCallBackStatus {
> +    /* counter the number of unknow event registered */
> +    int eventNameCallBackCounter;
> +    /* Stores the ID of the unknow event registered */
> +    int eventNameCallback[VIR_DOMAIN_EVENT_NAME_LAST];
> +};
> +typedef struct domainEventNameCallBackStatus domainEventNameCallBackStatus;
> +
>  typedef struct daemonClientStream daemonClientStream;
>  typedef daemonClientStream *daemonClientStreamPtr;
>  typedef struct daemonClientPrivate daemonClientPrivate;
> @@ -49,7 +59,7 @@ struct daemonClientPrivate {
>      virMutex lock;
>
>      int domainEventCallbackID[VIR_DOMAIN_EVENT_ID_LAST];
> -
> +    domainEventNameCallBackStatus domainEventNameCallBack;
>  # if HAVE_SASL
>      virNetSASLSessionPtr sasl;
>  # endif
> diff --git a/daemon/remote.c b/daemon/remote.c
> index e1d208c..bc8455d 100644
> --- a/daemon/remote.c
> +++ b/daemon/remote.c
> @@ -421,6 +421,54 @@ mem_error:
>      return -1;
>  }
>
> +static int remoteRelayDomainEventUnknown(virConnectPtr conn ATTRIBUTE_UNUSED,
> +                                         virDomainPtr dom,
> +                                         const char *eventName, /* The JSON event name */
> +                                         const char *eventArgs, /* The JSON string of args */
> +                                         void *opaque)
> +{
> +    virNetServerClientPtr client = opaque;
> +    remote_domain_event_default_event_msg data;
> +
> +    if (!client)
> +        return -1;
> +
> +    VIR_DEBUG("Relaying domain: %s id: %d, unknown event: %s arguments: %s",
> +              dom->name, dom->id, eventName, eventArgs);
> +
> +    /* build return data */
> +    memset(&data, 0, sizeof data);
> +    if (eventName == NULL)
> +        goto mem_error3;
> +    data.eventName = (char *)strdup(eventName);
> +    if (data.eventName == NULL)
> +        goto mem_error2;
> +    if (eventArgs != NULL) {
> +        data.eventArgs = (char *)strdup(eventArgs);
> +        if (data.eventArgs == NULL)
> +            goto mem_error1;
> +    }
> +    else {
> +        data.eventArgs = (char *)strdup("NULL");
> +        if (data.eventArgs == NULL)
> +            goto mem_error1;
> +    }
> +    make_nonnull_domain(&data.dom, dom);
> +    remoteDispatchDomainEventSend(client, remoteProgram,
> +                                  REMOTE_PROC_QEMU_DOMAIN_EVENT_UNKNOWN_EVENT,
> +                                  (xdrproc_t)xdr_remote_domain_event_default_event_msg, &data);
> +
> +    return 0;
> +
> +mem_error1:
> +    VIR_FREE(data.eventArgs);
> +mem_error2:
> +    VIR_FREE(data.eventName);
> +mem_error3:
> +    virReportOOMError();
> +    return -1;
> +}
> +
>
>  static int remoteRelayDomainEventControlError(virConnectPtr conn ATTRIBUTE_UNUSED,
>                                                virDomainPtr dom,
> @@ -509,6 +557,7 @@ static virConnectDomainEventGenericCallback domainEventCallbacks[] = {
>      VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventControlError),
>      VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventBlockJob),
>      VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventDiskChange),
> +    VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventUnknown),
>  };
>
>  verify(ARRAY_CARDINALITY(domainEventCallbacks) == VIR_DOMAIN_EVENT_ID_LAST);
> @@ -526,10 +575,21 @@ static void remoteClientFreeFunc(void *data)
>
>      /* Deregister event delivery callback */
>      if (priv->conn) {
> -        int i;
> +        int i, j;
>
>          for (i = 0 ; i < VIR_DOMAIN_EVENT_ID_LAST ; i++) {
> -            if (priv->domainEventCallbackID[i] != -1) {
> +            if (i == VIR_QEMU_DOMAIN_EVENT_ID_UNKNOWN && priv->domainEventCallbackID[i] != -1) {
> +                for (j = 0 ; j < VIR_DOMAIN_EVENT_NAME_LAST ; j++){
> +                    if (priv->domainEventNameCallBack.eventNameCallback[j] != -1) {
> +                        VIR_DEBUG("Deregistering to relay remote events %d", i);
> +                        virConnectDomainQemuEventDeregister(priv->conn,
> +                                                            priv->domainEventNameCallBack.eventNameCallback[j]);
> +                    }
> +                    priv->domainEventNameCallBack.eventNameCallback[j] == -1;
> +                }
> +                priv->domainEventNameCallBack.eventNameCallBackCounter = 0;
> +	    }
> +            else if (priv->domainEventCallbackID[i] != -1) {
>                  VIR_DEBUG("Deregistering to relay remote events %d", i);
>                  virConnectDomainEventDeregisterAny(priv->conn,
>                                                     priv->domainEventCallbackID[i]);
> @@ -572,6 +632,10 @@ int remoteClientInitHook(virNetServerPtr srv ATTRIBUTE_UNUSED,
>      for (i = 0 ; i < VIR_DOMAIN_EVENT_ID_LAST ; i++)
>          priv->domainEventCallbackID[i] = -1;
>
> +    priv->domainEventNameCallBack.eventNameCallBackCounter = 0;
> +    for (i = 0 ; i < VIR_DOMAIN_EVENT_NAME_LAST ; i++)
> +        priv->domainEventNameCallBack.eventNameCallback[i] = -1;
> +
>      virNetServerClientSetPrivateData(client, priv,
>                                       remoteClientFreeFunc);
>      virNetServerClientSetCloseHook(client, remoteClientCloseFunc);
> @@ -2991,6 +3055,133 @@ cleanup:
>  }
>
>  static int
> +qemuDispatchDomainEventsRegister(virNetServerPtr server ATTRIBUTE_UNUSED,
> +                                 virNetServerClientPtr client ATTRIBUTE_UNUSED,
> +                                 virNetMessagePtr msg ATTRIBUTE_UNUSED,
> +                                 virNetMessageErrorPtr rerr,
> +                                 qemu_domain_events_register_args *args,
> +                                 qemu_domain_events_register_ret *ret ATTRIBUTE_UNUSED)
> +{
> +    int callbackID = -1;
> +    int rv = -1;
> +    int eventIdx = 0;
> +    struct daemonClientPrivate *priv =
> +        virNetServerClientGetPrivateData(client);
> +    if (!priv->conn) {
> +        virNetError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
> +        goto cleanup;
> +    }
> +
> +    virMutexLock(&priv->lock);
> +
> +    if (args->eventName == NULL) {
> +        virNetError(VIR_ERR_INTERNAL_ERROR, _("event Name is NULL"));
> +        goto cleanup;
> +    }
> +    if (priv->domainEventNameCallBack.eventNameCallBackCounter >= VIR_DOMAIN_EVENT_NAME_LAST) {
> +        virNetError(VIR_ERR_INTERNAL_ERROR,
> +                    _("domain event %s is not registered, the register number has exceeded limit number %d"),
> +                    args->eventName,
> +                    VIR_DOMAIN_EVENT_NAME_LAST);
> +        goto cleanup;
> +    }
> +
> +    if ((callbackID = virConnectDomainQemuEventRegister(priv->conn,
> +                                                        NULL,
> +                                                        args->eventName,
> +                                                        (virConnectDomainQemuEventCallback)remoteRelayDomainEventUnknown,
> +                                                        client,
> +                                                        NULL)) < 0)
> +        goto cleanup;
> +
> +    for (eventIdx = 0 ; eventIdx < VIR_DOMAIN_EVENT_NAME_LAST ; eventIdx++) {
> +        if (priv->domainEventNameCallBack.eventNameCallback[eventIdx] == -1) {
> +            priv->domainEventNameCallBack.eventNameCallback[eventIdx] = callbackID;
> +            priv->domainEventNameCallBack.eventNameCallBackCounter++;
> +            ret->callbackID = eventIdx;
> +            break;
> +        }
> +    }
> +    priv->domainEventCallbackID[VIR_QEMU_DOMAIN_EVENT_ID_UNKNOWN] = callbackID;
> +
> +    rv = 0;
> +
> +cleanup:
> +    if (rv < 0)
> +        virNetMessageSaveError(rerr);
> +    virMutexUnlock(&priv->lock);
> +    return rv;
> +}
> +
> +static int
> +remoteDispatchQemuDomainEventUnknownEvent(virNetServerPtr server,
> +                                          virNetServerClientPtr client,
> +                                          virNetMessagePtr msg,
> +                                          virNetMessageErrorPtr rerr)
> +{
> +    int rv = -1;
> +    return rv;
> +}
> +
> +static int
> +qemuDispatchDomainEventsUnknownEvent(virNetServerPtr server,
> +                                     virNetServerClientPtr client,
> +                                     virNetMessagePtr msg,
> +                                     virNetMessageErrorPtr rerr,
> +                                     qemu_domain_events_unknown_event_args *args,
> +                                     qemu_domain_events_unknown_event_ret *ret)
> +{
> +    int rv = -1;
> +    return rv;
> +}
> +
> +static int
> +qemuDispatchDomainEventsDeregister(virNetServerPtr server ATTRIBUTE_UNUSED,
> +                                   virNetServerClientPtr client ATTRIBUTE_UNUSED,
> +                                   virNetMessagePtr msg ATTRIBUTE_UNUSED,
> +                                   virNetMessageErrorPtr rerr,
> +                                   qemu_domain_events_deregister_args *args,
> +                                   qemu_domain_events_deregister_ret *ret ATTRIBUTE_UNUSED)
> +{
> +    int callbackID = -1;
> +    int rv = -1;
> +    int eventIdx = args->callbackID;
> +    struct daemonClientPrivate *priv =
> +        virNetServerClientGetPrivateData(client);
> +
> +    if (!priv->conn) {
> +        virNetError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open"));
> +        goto cleanup;
> +    }
> +
> +    virMutexLock(&priv->lock);
> +
> +    if (eventIdx >= VIR_DOMAIN_EVENT_NAME_LAST ||
> +        (callbackID = priv->domainEventNameCallBack.eventNameCallback[eventIdx]) < 0) {
> +
> +        virNetError(VIR_ERR_INTERNAL_ERROR, _("callbakcID %d is not register"), eventIdx);
> +        goto cleanup;
> +    }
> +
> +    if (virConnectDomainQemuEventDeregister(priv->conn, callbackID) < 0)
> +        goto cleanup;
> +    ret->cb_deregistered = callbackID;
> +
> +    priv->domainEventNameCallBack.eventNameCallback[eventIdx] = -1;
> +    priv->domainEventNameCallBack.eventNameCallBackCounter--;
> +    if (priv->domainEventNameCallBack.eventNameCallBackCounter == 0)
> +        priv->domainEventCallbackID[VIR_QEMU_DOMAIN_EVENT_ID_UNKNOWN] = -1;
> +
> +    rv = 0;
> +
> +cleanup:
> +    if (rv < 0)
> +        virNetMessageSaveError(rerr);
> +    virMutexUnlock(&priv->lock);
> +    return rv;
> +}
> +
> +static int
>  qemuDispatchMonitorCommand(virNetServerPtr server ATTRIBUTE_UNUSED,
>                             virNetServerClientPtr client ATTRIBUTE_UNUSED,
>                             virNetMessagePtr msg ATTRIBUTE_UNUSED,
> diff --git a/include/libvirt/libvirt-qemu.h b/include/libvirt/libvirt-qemu.h
> index 7f12e4f..74efe79 100644
> --- a/include/libvirt/libvirt-qemu.h
> +++ b/include/libvirt/libvirt-qemu.h
> @@ -32,6 +32,17 @@ virDomainPtr virDomainQemuAttach(virConnectPtr domain,
>                                   unsigned int pid,
>                                   unsigned int flags);
>
> +int
> +virConnectDomainQemuEventRegister(virConnectPtr conn,
> +                                  virDomainPtr dom, /* option to filter */
> +                                  const char *eventName,  /* JSON event name */
> +                                  virConnectDomainQemuEventCallback cb,
> +                                  void *opaque,
> +                                  virFreeCallback freecb);
> +int
> +virConnectDomainQemuEventDeregister(virConnectPtr conn,
> +                                    int callbackID);
> +
>  # ifdef __cplusplus
>  }
>  # endif
> diff --git a/include/libvirt/libvirt.h.in b/include/libvirt/libvirt.h.in
> index 2480add..99e1c5d 100644
> --- a/include/libvirt/libvirt.h.in
> +++ b/include/libvirt/libvirt.h.in
> @@ -3207,7 +3207,21 @@ typedef void (*virConnectDomainEventBlockJobCallback)(virConnectPtr conn,
>                                                        int type,
>                                                        int status,
>                                                        void *opaque);
> -
> +/**
> + * virConnectDomainQemuEventCallback:
> + * @conn: connection object
> + * @dom: domain on which the event occurred
> + * @eventName : the name of the unknow or un-implementation event
> + * @eventArgs: the content of the unknow or un-implementation event
> + *
> + * The callback signature to use when registering for an event of type
> + * VIR_QEMU_DOMAIN_EVENT_ID_UNKNOWN with virConnectDomainQemuEventRegister()
> + */
> +typedef void (*virConnectDomainQemuEventCallback)(virConnectPtr conn,
> +                                                  virDomainPtr dom,
> +                                                  const char *eventName, /* The JSON event name */
> +                                                  const char *eventArgs, /* The JSON string of args */
> +                                                  void *opaque);
>  /**
>   * virConnectDomainEventDiskChangeReason:
>   *
> @@ -3263,6 +3277,7 @@ typedef enum {
>      VIR_DOMAIN_EVENT_ID_CONTROL_ERROR = 7,   /* virConnectDomainEventGenericCallback */
>      VIR_DOMAIN_EVENT_ID_BLOCK_JOB = 8,       /* virConnectDomainEventBlockJobCallback */
>      VIR_DOMAIN_EVENT_ID_DISK_CHANGE = 9,     /* virConnectDomainEventDiskChangeCallback */
> +    VIR_QEMU_DOMAIN_EVENT_ID_UNKNOWN = 10,   /* virConnectDomainEventDefaultCallback */
>
>      /*
>       * NB: this enum value will increase over time as new events are
> diff --git a/python/generator.py b/python/generator.py
> index 88c52b9..3d13622 100755
> --- a/python/generator.py
> +++ b/python/generator.py
> @@ -234,6 +234,7 @@ skipped_types = {
>  #    'int *': "usually a return type",
>       'virConnectDomainEventCallback': "No function types in python",
>       'virConnectDomainEventGenericCallback': "No function types in python",
> +     'virConnectDomainQemuEventCallback': "No function types in python",
>       'virConnectDomainEventRTCChangeCallback': "No function types in python",
>       'virConnectDomainEventWatchdogCallback': "No function types in python",
>       'virConnectDomainEventIOErrorCallback': "No function types in python",
> @@ -476,6 +477,8 @@ skip_function = (
>
>  qemu_skip_function = (
>      #"virDomainQemuAttach",
> +    'virConnectDomainQemuEventRegister',   # overridden in libvirt_qemu_override.py
> +    'virConnectDomainQemuEventDeregister', # overridden in libvirt_qemu_override.py
>  )
>
>  # Generate C code, but skip python impl
> @@ -1656,17 +1659,18 @@ def qemuBuildWrappers(module):
>      if extra != None:
>          extra.close()
>
> -    fd.write("try:\n")
> -    fd.write("    import libvirtmod_qemu\n")
> -    fd.write("except ImportError, lib_e:\n")
> -    fd.write("    try:\n")
> -    fd.write("        import cygvirtmod_qemu as libvirtmod_qemu\n")
> -    fd.write("    except ImportError, cyg_e:\n")
> -    fd.write("        if str(cyg_e).count(\"No module named\"):\n")
> -    fd.write("            raise lib_e\n\n")
> -
> -    fd.write("import libvirt\n\n");
> -    fd.write("#\n# Functions from module %s\n#\n\n" % module)
> +    if extra == None:
> +        fd.write("try:\n")
> +        fd.write("    import libvirtmod_qemu\n")
> +        fd.write("except ImportError, lib_e:\n")
> +        fd.write("    try:\n")
> +        fd.write("        import cygvirtmod_qemu as libvirtmod_qemu\n")
> +        fd.write("    except ImportError, cyg_e:\n")
> +        fd.write("        if str(cyg_e).count(\"No module named\"):\n")
> +        fd.write("            raise lib_e\n\n")
> +
> +        fd.write("import libvirt\n\n");
> +        fd.write("#\n# Functions from module %s\n#\n\n" % module)
>      #
>      # Generate functions directly, no classes
>      #
> diff --git a/python/libvirt-override-virConnect.py b/python/libvirt-override-virConnect.py
> old mode 100644
> new mode 100755
> index b908b32..ce34bcf
> --- a/python/libvirt-override-virConnect.py
> +++ b/python/libvirt-override-virConnect.py
> @@ -134,8 +134,20 @@
>          cb(self, virDomain(self, _obj=dom), oldSrcPath, newSrcPath, devAlias, reason, opaque)
>          return 0;
>
> +    def _dispatchDomainEventUnknownCallback(self, dom, eventName, eventArgs, cbData):
> +        """Dispatches events to python user unknown event callbacks
> +        """
> +        try:
> +            cb = cbData["cb"]
> +            opaque = cbData["opaque"]
> +
> +            cb(self, virDomain(self, _obj=dom), eventName, eventArgs, opaque)
> +            return 0
> +        except AttributeError:
> +            pass
> +
>      def domainEventDeregisterAny(self, callbackID):
> -        """Removes a Domain Event Callback. De-registering for a
> +        """Removes a QEMU Domain Event Callback. De-registering for a
>             domain callback will disable delivery of this event type """
>          try:
>              ret = libvirtmod.virConnectDomainEventDeregisterAny(self._o, callbackID)
> diff --git a/python/libvirt-override-virStream.py b/python/libvirt-override-virStream.py
> old mode 100644
> new mode 100755
> diff --git a/python/libvirt-override.py b/python/libvirt-override.py
> old mode 100644
> new mode 100755
> diff --git a/python/libvirt-qemu-override.c b/python/libvirt-qemu-override.c
> index 485c809..f5a8c09 100644
> --- a/python/libvirt-qemu-override.c
> +++ b/python/libvirt-qemu-override.c
> @@ -18,6 +18,7 @@
>
>  #include <Python.h>
>  #include "libvirt/libvirt-qemu.h"
> +#include "libvirt/libvirt.h"
>  #include "libvirt/virterror.h"
>  #include "typewrappers.h"
>  #include "libvirt-qemu.h"
> @@ -96,6 +97,143 @@ libvirt_qemu_virDomainQemuMonitorCommand(PyObject *self ATTRIBUTE_UNUSED,
>      return(py_retval);
>  }
>
> +static void
> +libvirt_qemu_virConnectDomainEventFreeFunc(void *opaque)
> +{
> +    PyObject *pyobj_conn = (PyObject*)opaque;
> +    LIBVIRT_ENSURE_THREAD_STATE;
> +    Py_DECREF(pyobj_conn);
> +    LIBVIRT_RELEASE_THREAD_STATE;
> +}
> +
> +static int
> +libvirt_qemu_virConnectDomainEventUnknownCallback(virConnectPtr conn ATTRIBUTE_UNUSED,
> +                                                  virDomainPtr dom,
> +                                                  const char *eventName,
> +                                                  const char *eventArgs,
> +                                                  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*)"_dispatchDomainEventUnknownCallback",
> +                                    (char*)"OssO",
> +                                    pyobj_dom, eventName, eventArgs, pyobj_cbData);
> +
> +    Py_DECREF(pyobj_cbData);
> +    Py_DECREF(pyobj_dom);
> +
> +    if (!pyobj_ret) {
> +#if DEBUG_ERROR
> +        printf("%s - ret:%p\n", __FUNCTION__, pyobj_ret);
> +#endif
> +        PyErr_Print();
> +    } else {
> +        Py_DECREF(pyobj_ret);
> +        ret = 0;
> +    }
> +
> +    LIBVIRT_RELEASE_THREAD_STATE;
> +    return ret;
> +}
> +
> +static PyObject *
> +libvirt_qemu_virConnectDomainQemuEventRegister(ATTRIBUTE_UNUSED PyObject * self,
> +                                         PyObject * args)
> +{
> +    PyObject *py_retval;        /* return value */
> +    PyObject *pyobj_conn;       /* virConnectPtr */
> +    PyObject *pyobj_dom;
> +    PyObject *pyobj_cbData;     /* hash of callback data */
> +    char *eventName;
> +    virConnectPtr conn;
> +    int ret = 0;
> +
> +    virConnectDomainQemuEventCallback cb = NULL;
> +    virDomainPtr dom;
> +
> +    if (!PyArg_ParseTuple
> +        (args, (char *) "OOsO:virConnectDomainQemuEventRegister",
> +        &pyobj_conn, &pyobj_dom, &eventName, &pyobj_cbData)) {
> +        DEBUG("%s failed parsing tuple\n", __FUNCTION__);
> +        return VIR_PY_INT_FAIL;
> +    }
> +
> +    if (eventName == NULL)
> +        return VIR_PY_INT_FAIL;
> +
> +    DEBUG("libvirt_qemu_virConnectDomainQemuEventRegister(%p %p %s %p) called\n",
> +           pyobj_conn, pyobj_dom, eventName, pyobj_cbData);
> +    conn = PyvirConnect_Get(pyobj_conn);
> +    if (pyobj_dom == Py_None)
> +        dom = NULL;
> +    else
> +        dom = PyvirDomain_Get(pyobj_dom);
> +
> +    cb = (virConnectDomainQemuEventCallback)(libvirt_qemu_virConnectDomainEventUnknownCallback);
> +    if (!cb) {
> +        return VIR_PY_INT_FAIL;
> +    }
> +
> +    Py_INCREF(pyobj_cbData);
> +
> +    LIBVIRT_BEGIN_ALLOW_THREADS;
> +    ret = virConnectDomainQemuEventRegister(conn, dom, eventName,
> +                                           cb, pyobj_cbData,
> +                                           libvirt_qemu_virConnectDomainEventFreeFunc);
> +    LIBVIRT_END_ALLOW_THREADS;
> +    if (ret < 0) {
> +        Py_DECREF(pyobj_cbData);
> +    }
> +    py_retval = libvirt_intWrap(ret);
> +    return (py_retval);
> +}
> +
> +static PyObject *
> +libvirt_qemu_virConnectDomainQemuEventDeregister(ATTRIBUTE_UNUSED PyObject * self,
> +                                           PyObject * args)
> +{
> +    PyObject *py_retval;
> +    PyObject *pyobj_conn;
> +    int callbackID;
> +    virConnectPtr conn;
> +    int ret = 0;
> +
> +    if (!PyArg_ParseTuple
> +        (args, (char *) "Oi:virConnectDomainQemuEventDeregister",
> +        &pyobj_conn, &callbackID))
> +        return (NULL);
> +
> +    DEBUG("libvirt_qemu_virConnectDomainQemuEventDeregister(%p) called\n", pyobj_conn);
> +
> +    conn   = (virConnectPtr) PyvirConnect_Get(pyobj_conn);
> +
> +    LIBVIRT_BEGIN_ALLOW_THREADS;
> +
> +    ret = virConnectDomainQemuEventDeregister(conn, callbackID);
> +
> +    LIBVIRT_END_ALLOW_THREADS;
> +    py_retval = libvirt_intWrap(ret);
> +    return (py_retval);
> +}
> +
>  /************************************************************************
>   *									*
>   *			The registration stuff				*
> @@ -104,6 +242,8 @@ libvirt_qemu_virDomainQemuMonitorCommand(PyObject *self ATTRIBUTE_UNUSED,
>  static PyMethodDef libvirtQemuMethods[] = {
>  #include "libvirt-qemu-export.c"
>      {(char *) "virDomainQemuMonitorCommand", libvirt_qemu_virDomainQemuMonitorCommand, METH_VARARGS, NULL},
> +    {(char *) "virConnectDomainQemuEventRegister", libvirt_qemu_virConnectDomainQemuEventRegister, METH_VARARGS, NULL},
> +    {(char *) "virConnectDomainQemuEventDeregister", libvirt_qemu_virConnectDomainQemuEventDeregister, METH_VARARGS, NULL},
>      {NULL, NULL, 0, NULL}
>  };
>
> diff --git a/python/libvirt-qemu-override.py b/python/libvirt-qemu-override.py
> new file mode 100644
> index 0000000..0f5694c
> --- /dev/null
> +++ b/python/libvirt-qemu-override.py
> @@ -0,0 +1,41 @@
> +#
> +# Manually written part of python bindings for libvirt_qemu
> +#
> +
> +# On cygwin, the DLL is called cygvirtmod.dll
> +try:
> +    import libvirtmod_qemu
> +except ImportError, lib_e:
> +    try:
> +        import cygvirtmod_qemu as libvirtmod_qemu
> +    except ImportError, cyg_e:
> +        if str(cyg_e).count("No module named"):
> +            raise lib_e
> +
> +import libvirt
> +import types
> +
> +def domainQemuEventDeregister(conn, callbackID):
> +    """Removes a Domain Event Callback. De-registering for a
> +       domain callback will disable delivery of this event type """
> +    try:
> +        ret = libvirtmod_qemu.virConnectDomainQemuEventDeregister(conn._o, callbackID)
> +        if ret == -1: raise libvirt.libvirtError ('virConnectDomainQemuEventDeregister() failed', conn)
> +        del conn.domainEventCallbackID[callbackID]
> +    except AttributeError:
> +        pass
> +
> +def domainQemuEventRegister(conn, dom, eventName, cb, opaque):
> +    """Adds a Domain Event Callback. Registering for a domain
> +       callback will enable delivery of the events """
> +    if not hasattr(conn, 'domainEventCallbackID'):
> +        conn.domainEventCallbackID = {}
> +    cbData = { "cb": cb, "conn": conn, "opaque": opaque }
> +    if dom is None:
> +        ret = libvirtmod_qemu.virConnectDomainQemuEventRegister(conn._o, None, eventName, cbData)
> +    else:
> +        ret = libvirtmod_qemu.virConnectDomainQemuEventRegister(conn._o, dom._o, eventName, cbData)
> +    if ret == -1:
> +        raise libvirt.libvirtError ('virConnectDomainQemuEventRegister() failed', conn)
> +    conn.domainEventCallbackID[ret] = opaque
> +    return ret
> diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c
> index 614ab97..b6a763a 100644
> --- a/src/conf/domain_event.c
> +++ b/src/conf/domain_event.c
> @@ -45,7 +45,9 @@ typedef virDomainMeta *virDomainMetaPtr;
>
>  struct _virDomainEventCallback {
>      int callbackID;
> +    int qemuCallbackID;
>      int eventID;
> +    char *eventName;
>      virConnectPtr conn;
>      virDomainMetaPtr dom;
>      virConnectDomainEventGenericCallback cb;
> @@ -94,6 +96,10 @@ struct _virDomainEvent {
>              char *devAlias;
>              int reason;
>          } diskChange;
> +        struct {
> +            char *eventName;
> +            char *eventArgs;
> +        }qemuUnknownEvent;
>      } data;
>  };
>
> @@ -112,6 +118,8 @@ virDomainEventCallbackListFree(virDomainEventCallbackListPtr list)
>
>      for (i=0; i<list->count; i++) {
>          virFreeCallback freecb = list->callbacks[i]->freecb;
> +        if (list->callbacks[i]->eventName)
> +            VIR_FREE(list->callbacks[i]->eventName);
>          if (freecb)
>              (*freecb)(list->callbacks[i]->opaque);
>          VIR_FREE(list->callbacks[i]);
> @@ -143,7 +151,6 @@ virDomainEventCallbackListRemove(virConnectPtr conn,
>                  (*freecb)(cbList->callbacks[i]->opaque);
>              virUnrefConnect(cbList->callbacks[i]->conn);
>              VIR_FREE(cbList->callbacks[i]);
> -
>              if (i < (cbList->count - 1))
>                  memmove(cbList->callbacks + i,
>                          cbList->callbacks + i + 1,
> @@ -187,8 +194,11 @@ virDomainEventCallbackListRemoveID(virConnectPtr conn,
>              if (freecb)
>                  (*freecb)(cbList->callbacks[i]->opaque);
>              virUnrefConnect(cbList->callbacks[i]->conn);
> +            if (cbList->callbacks[i]->eventID == VIR_QEMU_DOMAIN_EVENT_ID_UNKNOWN) {
> +                if (cbList->callbacks[i]->eventName)
> +                    VIR_FREE(cbList->callbacks[i]->eventName);
> +            }
>              VIR_FREE(cbList->callbacks[i]);
> -
>              if (i < (cbList->count - 1))
>                  memmove(cbList->callbacks + i,
>                          cbList->callbacks + i + 1,
> @@ -212,6 +222,52 @@ virDomainEventCallbackListRemoveID(virConnectPtr conn,
>
>
>  /**
> + * virDomainQemuEventCallbackListRemoveID:
> + * @conn: pointer to the connection
> + * @cbList: the list
> + * @callback: the callback to remove
> + *
> + * Internal function to remove a callback from a virDomainEventCallbackListPtr
> + */
> +int
> +virDomainQemuEventCallbackListRemoveID(virConnectPtr conn,
> +                                       virDomainEventCallbackListPtr cbList,
> +                                       int callbackID)
> +{
> +    int i;
> +    for (i = 0 ; i < cbList->count ; i++) {
> +        if (cbList->callbacks[i]->callbackID == callbackID &&
> +            cbList->callbacks[i]->conn == conn &&
> +            cbList->callbacks[i]->eventID == VIR_QEMU_DOMAIN_EVENT_ID_UNKNOWN) {
> +            virFreeCallback freecb = cbList->callbacks[i]->freecb;
> +            if (freecb)
> +                (*freecb)(cbList->callbacks[i]->opaque);
> +            VIR_FREE(cbList->callbacks[i]->eventName);
> +            virUnrefConnect(cbList->callbacks[i]->conn);
> +            VIR_FREE(cbList->callbacks[i]);
> +
> +            if (i < (cbList->count - 1))
> +                memmove(cbList->callbacks + i,
> +                        cbList->callbacks + i + 1,
> +                        sizeof(*(cbList->callbacks)) *
> +                                (cbList->count - (i + 1)));
> +
> +            if (VIR_REALLOC_N(cbList->callbacks,
> +                              cbList->count - 1) < 0) {
> +                ; /* Failure to reduce memory allocation isn't fatal */
> +            }
> +            cbList->count--;
> +            return 0;
> +        }
> +    }
> +
> +    eventReportError(VIR_ERR_INTERNAL_ERROR, "%s",
> +                     _("could not find event callback for removal"));
> +    return -1;
> +}
> +
> +
> +/**
>   * virDomainEventCallbackListRemoveConn:
>   * @conn: pointer to the connection
>   * @cbList: the list
> @@ -231,8 +287,11 @@ virDomainEventCallbackListRemoveConn(virConnectPtr conn,
>              if (freecb)
>                  (*freecb)(cbList->callbacks[i]->opaque);
>              virUnrefConnect(cbList->callbacks[i]->conn);
> +            if (cbList->callbacks[i]->eventID == VIR_QEMU_DOMAIN_EVENT_ID_UNKNOWN) {
> +                if (cbList->callbacks[i]->eventName)
> +                    VIR_FREE(cbList->callbacks[i]->eventName);
> +            }
>              VIR_FREE(cbList->callbacks[i]);
> -
>              if (i < (cbList->count - 1))
>                  memmove(cbList->callbacks + i,
>                          cbList->callbacks + i + 1,
> @@ -299,8 +358,11 @@ int virDomainEventCallbackListPurgeMarked(virDomainEventCallbackListPtr cbList)
>              if (freecb)
>                  (*freecb)(cbList->callbacks[i]->opaque);
>              virUnrefConnect(cbList->callbacks[i]->conn);
> +            if (cbList->callbacks[i]->eventID == VIR_QEMU_DOMAIN_EVENT_ID_UNKNOWN) {
> +                if (cbList->callbacks[i]->eventName)
> +                    VIR_FREE(cbList->callbacks[i]->eventName);
> +            }
>              VIR_FREE(cbList->callbacks[i]);
> -
>              if (i < (cbList->count - 1))
>                  memmove(cbList->callbacks + i,
>                          cbList->callbacks + i + 1,
> @@ -404,7 +466,98 @@ virDomainEventCallbackListAddID(virConnectPtr conn,
>
>      cbList->callbacks[cbList->count] = event;
>      cbList->count++;
> +    event->callbackID = cbList->nextID++;
> +
> +    return event->callbackID;
> +
> +no_memory:
> +    virReportOOMError();
> +
> +    if (event) {
> +        if (event->dom)
> +            VIR_FREE(event->dom->name);
> +        VIR_FREE(event->dom);
> +    }
> +    VIR_FREE(event);
> +    return -1;
> +}
> +
> +
> +
> +/**
> + * virDomainEventCallbackListAddName:
> + * @conn: pointer to the connection
> + * @cbList: the list
> + * @eventName: the event eventName
> + * @callback: the callback to add
> + * @eventID: the specific eventID
> + * @opaque: opaque data tio pass to callback
> + *
> + * Internal function to add a callback from a virDomainEventCallbackListPtr
> + */
> +int
> +virDomainEventCallbackListAddName(virConnectPtr conn,
> +                                  virDomainEventCallbackListPtr cbList,
> +                                  virDomainPtr dom,
> +                                  const char* eventName,
> +                                  int eventID,
> +                                  virConnectDomainEventGenericCallback callback,
> +                                  void *opaque,
> +                                  virFreeCallback freecb)
> +{
> +    virDomainEventCallbackPtr event;
> +    int i;
> +
> +    /* Check incoming */
> +    if ( !cbList ) {
> +        return -1;
> +    }
> +
> +    /* check if we already have this callback on our list */
> +    for (i = 0 ; i < cbList->count ; i++) {
> +        if (cbList->callbacks[i]->cb == VIR_DOMAIN_EVENT_CALLBACK(callback) &&
> +            !strcmp(cbList->callbacks[i]->eventName, eventName) &&
> +            cbList->callbacks[i]->eventID == eventID &&
> +            cbList->callbacks[i]->conn == conn) {
> +            eventReportError(VIR_ERR_INTERNAL_ERROR, "%s",
> +                             _("event callback already tracked"));
> +            return -1;
> +        }
> +    }
> +    if (eventID > VIR_DOMAIN_EVENT_ID_LAST || eventID < VIR_DOMAIN_EVENT_ID_LIFECYCLE) {
> +        eventReportError(VIR_ERR_INTERNAL_ERROR, "%s: %d",
> +                         _("not suport this kind of eventID"), eventID);
> +     }
> +    /* Allocate new event */
> +    if (VIR_ALLOC(event) < 0)
> +        goto no_memory;
> +    event->conn = conn;
> +    event->cb = callback;
> +    if (eventName == NULL)
> +	goto no_memory;
> +    event->eventName = strdup(eventName);
> +    if ( event->eventName == NULL)
> +	goto no_memory;
> +    event->opaque = opaque;
> +    event->freecb = freecb;
> +    event->eventID = eventID;
> +    if (dom) {
> +        if (VIR_ALLOC(event->dom) < 0)
> +            goto no_memory;
> +        if (!(event->dom->name = strdup(dom->name)))
> +            goto no_memory;
> +        memcpy(event->dom->uuid, dom->uuid, VIR_UUID_BUFLEN);
> +        event->dom->id = dom->id;
> +    }
> +
> +    /* Make space on list */
> +    if (VIR_REALLOC_N(cbList->callbacks, cbList->count + 1) < 0)
> +        goto no_memory;
> +
> +    event->conn->refs++;
>
> +    cbList->callbacks[cbList->count] = event;
> +    cbList->count++;
>      event->callbackID = cbList->nextID++;
>
>      return event->callbackID;
> @@ -416,11 +569,41 @@ no_memory:
>          if (event->dom)
>              VIR_FREE(event->dom->name);
>          VIR_FREE(event->dom);
> +	if (event->eventName)
> +            VIR_FREE(event->eventName);
>      }
>      VIR_FREE(event);
>      return -1;
>  }
>
> +/**
> + * virDomainEventCallbackListAddQemuCallbackID:
> + * @conn: pointer to the connection
> + * @cbList: the list
> + * @callbackID: the libvirt callback ID
> + * @qemuCallbackID: the libvirtd callback ID to add
> + *
> + * Internal function to add a Daemon libvirtd callbackID
> + */
> +int
> +virDomainEventCallbackListAddQemuCallbackID(virConnectPtr conn,
> +                                            virDomainEventCallbackListPtr cbList,
> +                                            int callbackID,
> +                                            int qemuCallbackID)
> +{
> +    int i;
> +    for (i = 0 ; i < cbList->count ; i++) {
> +        if (cbList->callbacks[i]->callbackID == callbackID &&
> +            cbList->callbacks[i]->conn == conn) {
> +            cbList->callbacks[i]->qemuCallbackID = qemuCallbackID;
> +            return 0;
> +        }
> +    }
> +
> +    eventReportError(VIR_ERR_INTERNAL_ERROR, "%s",
> +                     _("could not find event callback for deletion"));
> +    return -1;
> +}
>
>  int virDomainEventCallbackListCountID(virConnectPtr conn,
>                                        virDomainEventCallbackListPtr cbList,
> @@ -442,6 +625,27 @@ int virDomainEventCallbackListCountID(virConnectPtr conn,
>  }
>
>
> +int
> +virDomainEventCallbackListCountName(virConnectPtr conn,
> +                                    virDomainEventCallbackListPtr cbList,
> +                                    const char *eventName)
> +{
> +    int i;
> +    int count = 0;
> +
> +    for (i = 0 ; i < cbList->count ; i++) {
> +        if (cbList->callbacks[i]->deleted)
> +            continue;
> +
> +        if (!strcmp(cbList->callbacks[i]->eventName,eventName) &&
> +            cbList->callbacks[i]->conn == conn)
> +            count++;
> +    }
> +
> +    return count;
> +}
> +
> +
>  int virDomainEventCallbackListEventID(virConnectPtr conn,
>                                        virDomainEventCallbackListPtr cbList,
>                                        int callbackID)
> @@ -461,6 +665,44 @@ int virDomainEventCallbackListEventID(virConnectPtr conn,
>  }
>
>
> +const char*
> +virDomainEventCallbackListEventName(virConnectPtr conn,
> +                                    virDomainEventCallbackListPtr cbList,
> +                                    int callbackID)
> +{
> +    int i;
> +
> +    for (i = 0 ; i < cbList->count ; i++) {
> +        if (cbList->callbacks[i]->deleted)
> +            continue;
> +
> +        if (cbList->callbacks[i]->callbackID == callbackID &&
> +            cbList->callbacks[i]->conn == conn)
> +            return cbList->callbacks[i]->eventName;
> +    }
> +
> +    return NULL;
> +}
> +
> +int
> +virDomainEventCallbackListEventQemuCallbackID(virConnectPtr conn,
> +                                              virDomainEventCallbackListPtr cbList,
> +                                              int callbackID)
> +{
> +    int i;
> +
> +    for (i = 0 ; i < cbList->count ; i++) {
> +        if (cbList->callbacks[i]->deleted)
> +            continue;
> +
> +        if (cbList->callbacks[i]->callbackID == callbackID &&
> +            cbList->callbacks[i]->conn == conn)
> +            return cbList->callbacks[i]->qemuCallbackID;
> +    }
> +
> +    return -1;
> +}
> +
>  int virDomainEventCallbackListCount(virDomainEventCallbackListPtr cbList)
>  {
>      int i;
> @@ -521,6 +763,11 @@ void virDomainEventFree(virDomainEventPtr event)
>          VIR_FREE(event->data.diskChange.newSrcPath);
>          VIR_FREE(event->data.diskChange.devAlias);
>          break;
> +
> +    case VIR_QEMU_DOMAIN_EVENT_ID_UNKNOWN:
> +        VIR_FREE(event->data.qemuUnknownEvent.eventName);
> +        VIR_FREE(event->data.qemuUnknownEvent.eventArgs);
> +        break;
>      }
>
>      VIR_FREE(event->dom.name);
> @@ -956,6 +1203,51 @@ virDomainEventPtr virDomainEventBlockJobNewFromDom(virDomainPtr dom,
>                                       path, type, status);
>  }
>
> +static virDomainEventPtr
> +virDomainEventUnknownNew(int id, const char *name, unsigned char *uuid,
> +                         const char *eventName, const char *eventArgs)
> +{
> +    virDomainEventPtr ev =
> +        virDomainEventNewInternal(VIR_QEMU_DOMAIN_EVENT_ID_UNKNOWN,
> +                                  id, name, uuid);
> +    if (ev) {
> +        if (!(ev->data.qemuUnknownEvent.eventName = strdup(eventName))) {
> +            virReportOOMError();
> +            VIR_FREE(ev->dom.name);
> +            VIR_FREE(ev);
> +            return NULL;
> +        }
> +	if (eventArgs) {
> +            if (!(ev->data.qemuUnknownEvent.eventArgs = strdup(eventArgs))) {
> +                virReportOOMError();
> +                VIR_FREE(ev->data.qemuUnknownEvent.eventName);
> +                VIR_FREE(ev->dom.name);
> +                VIR_FREE(ev);
> +                return NULL;
> +            }
> +       }
> +    }
> +
> +    return ev;
> +}
> +
> +virDomainEventPtr virDomainEventUnknownNewFromObj(virDomainObjPtr obj,
> +                                                  const char *eventName,
> +                                                  const char *eventArgs)
> +{
> +
> +    return virDomainEventUnknownNew(obj->def->id, obj->def->name,
> +                                    obj->def->uuid, eventName, eventArgs);
> +}
> +
> +virDomainEventPtr virDomainEventUnknownNewFromDom(virDomainPtr dom,
> +                                                  const char *eventName,
> +                                                  const char *eventArgs)
> +{
> +    return virDomainEventUnknownNew(dom->id, dom->name, dom->uuid,
> +                                    eventName, eventArgs);
> +}
> +
>  virDomainEventPtr virDomainEventControlErrorNewFromDom(virDomainPtr dom)
>  {
>      virDomainEventPtr ev =
> @@ -1095,11 +1387,12 @@ virDomainEventQueuePush(virDomainEventQueuePtr evtQueue,
>  }
>
>
> -void virDomainEventDispatchDefaultFunc(virConnectPtr conn,
> -                                       virDomainEventPtr event,
> -                                       virConnectDomainEventGenericCallback cb,
> -                                       void *cbopaque,
> -                                       void *opaque ATTRIBUTE_UNUSED)
> +void
> +virDomainEventDispatchDefaultFunc(virConnectPtr conn,
> +                                  virDomainEventPtr event,
> +                                  virConnectDomainEventGenericCallback cb,
> +                                  void *cbopaque,
> +                                  void *opaque ATTRIBUTE_UNUSED)
>  {
>      virDomainPtr dom = virGetDomain(conn, event->dom.name, event->dom.uuid);
>      if (!dom)
> @@ -1180,6 +1473,13 @@ void virDomainEventDispatchDefaultFunc(virConnectPtr conn,
>                                                        cbopaque);
>          break;
>
> +    case VIR_QEMU_DOMAIN_EVENT_ID_UNKNOWN:
> +        ((virConnectDomainQemuEventCallback)cb)(conn, dom,
> +                                                   event->data.qemuUnknownEvent.eventName,
> +                                                   event->data.qemuUnknownEvent.eventArgs,
> +                                                   cbopaque);
> +        break;
> +
>      default:
>          VIR_WARN("Unexpected event ID %d", event->eventID);
>          break;
> @@ -1189,8 +1489,9 @@ void virDomainEventDispatchDefaultFunc(virConnectPtr conn,
>  }
>
>
> -static int virDomainEventDispatchMatchCallback(virDomainEventPtr event,
> -                                               virDomainEventCallbackPtr cb)
> +static int
> +virDomainEventDispatchMatchCallback(virDomainEventPtr event,
> +                                    virDomainEventCallbackPtr cb)
>  {
>      if (!cb)
>          return 0;
> @@ -1198,7 +1499,12 @@ static int virDomainEventDispatchMatchCallback(virDomainEventPtr event,
>          return 0;
>      if (cb->eventID != event->eventID)
>          return 0;
> -
> +    if (event->eventID == VIR_QEMU_DOMAIN_EVENT_ID_UNKNOWN) {
> +	if(event->data.qemuUnknownEvent.eventName == NULL ||
> +           cb->eventName == NULL ||
> +           strcmp(cb->eventName, event->data.qemuUnknownEvent.eventName) != 0)
> +            return 0;
> +    }
>      if (cb->dom) {
>          /* Deliberately ignoring 'id' for matching, since that
>           * will cause problems when a domain switches between
> @@ -1341,3 +1647,20 @@ virDomainEventStateDeregisterAny(virConnectPtr conn,
>      virDomainEventStateUnlock(state);
>      return ret;
>  }
> +int
> +virDomainQemuEventStateDeregister(virConnectPtr conn,
> +                                 virDomainEventStatePtr state,
> +                                 int callbackID)
> +{
> +    int ret;
> +
> +    virDomainEventStateLock(state);
> +    if (state->isDispatching)
> +        ret = virDomainEventCallbackListMarkDeleteID(conn,
> +                                                     state->callbacks, callbackID);
> +    else
> +        ret = virDomainQemuEventCallbackListRemoveID(conn,
> +                                                     state->callbacks, callbackID);
> +    virDomainEventStateUnlock(state);
> +    return ret;
> +}
> diff --git a/src/conf/domain_event.h b/src/conf/domain_event.h
> index 3ba418e..c0edfac 100644
> --- a/src/conf/domain_event.h
> +++ b/src/conf/domain_event.h
> @@ -26,7 +26,6 @@
>  # define __DOMAIN_EVENT_H__
>
>  # include "domain_conf.h"
> -
>  typedef struct _virDomainEventCallback virDomainEventCallback;
>  typedef virDomainEventCallback *virDomainEventCallbackPtr;
>
> @@ -83,6 +82,15 @@ int virDomainEventCallbackListAddID(virConnectPtr conn,
>                                      virFreeCallback freecb)
>      ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(5);
>
> +int virDomainEventCallbackListAddName(virConnectPtr conn,
> +                                      virDomainEventCallbackListPtr cbList,
> +                                      virDomainPtr dom,
> +                                      const char* eventName,
> +                                      int eventID,
> +                                      virConnectDomainEventGenericCallback callback,
> +                                      void *opaque,
> +                                      virFreeCallback freecb)
> +    ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(4) ATTRIBUTE_NONNULL(6);
>
>  int virDomainEventCallbackListRemove(virConnectPtr conn,
>                                       virDomainEventCallbackListPtr cbList,
> @@ -92,6 +100,10 @@ int virDomainEventCallbackListRemoveID(virConnectPtr conn,
>                                         virDomainEventCallbackListPtr cbList,
>                                         int callbackID)
>      ATTRIBUTE_NONNULL(1);
> +int virDomainQemuEventCallbackListRemoveID(virConnectPtr conn,
> +                                           virDomainEventCallbackListPtr cbList,
> +                                           int callbackID)
> +    ATTRIBUTE_NONNULL(1);
>  int virDomainEventCallbackListRemoveConn(virConnectPtr conn,
>                                           virDomainEventCallbackListPtr cbList)
>      ATTRIBUTE_NONNULL(1);
> @@ -106,9 +118,14 @@ int virDomainEventCallbackListMarkDeleteID(virConnectPtr conn,
>                                             int callbackID)
>      ATTRIBUTE_NONNULL(1);
>
> -
>  int virDomainEventCallbackListPurgeMarked(virDomainEventCallbackListPtr cbList);
>
> +int virDomainEventCallbackListAddQemuCallbackID(virConnectPtr conn,
> +                                                virDomainEventCallbackListPtr cbList,
> +                                                int callbackID,
> +                                                int qemuCallbackID)
> +    ATTRIBUTE_NONNULL(1);
> +
>  int virDomainEventCallbackListCount(virDomainEventCallbackListPtr cbList);
>  int virDomainEventCallbackListCountID(virConnectPtr conn,
>                                        virDomainEventCallbackListPtr cbList,
> @@ -119,6 +136,21 @@ int virDomainEventCallbackListEventID(virConnectPtr conn,
>                                        int callbackID)
>      ATTRIBUTE_NONNULL(1);
>
> +int virDomainEventCallbackListCountName(virConnectPtr conn,
> +                                        virDomainEventCallbackListPtr cbList,
> +                                        const char *eventName)
> +    ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(3);
> +
> +int virDomainEventCallbackListEventQemuCallbackID(virConnectPtr conn,
> +                                                  virDomainEventCallbackListPtr cbList,
> +                                                  int callbackID)
> +    ATTRIBUTE_NONNULL(1);
> +
> +const char* virDomainEventCallbackListEventName(virConnectPtr conn,
> +                                                virDomainEventCallbackListPtr cbList,
> +                                                int callbackID)
> +    ATTRIBUTE_NONNULL(1);
> +
>  virDomainEventQueuePtr virDomainEventQueueNew(void);
>
>  virDomainEventPtr virDomainEventNew(int id, const char *name, const unsigned char *uuid, int type, int detail);
> @@ -190,6 +222,13 @@ virDomainEventPtr virDomainEventDiskChangeNewFromDom(virDomainPtr dom,
>                                                       const char *devAlias,
>                                                       int reason);
>
> +virDomainEventPtr virDomainEventUnknownNewFromObj(virDomainObjPtr obj,
> +                                                  const char *eventName,
> +                                                  const char *eventArgs);
> +virDomainEventPtr virDomainEventUnknownNewFromDom(virDomainPtr dom,
> +                                                  const char *eventName,
> +                                                  const char *eventArgs);
> +
>  int virDomainEventQueuePush(virDomainEventQueuePtr evtQueue,
>                              virDomainEventPtr event);
>
> @@ -246,5 +285,9 @@ virDomainEventStateDeregisterAny(virConnectPtr conn,
>                                   virDomainEventStatePtr state,
>                                   int callbackID)
>      ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
> -
> +int
> +virDomainQemuEventStateDeregister(virConnectPtr conn,
> +                                  virDomainEventStatePtr state,
> +                                  int callbackID)
> +    ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
>  #endif
> diff --git a/src/driver.h b/src/driver.h
> index 941ff51..51164a9 100644
> --- a/src/driver.h
> +++ b/src/driver.h
> @@ -635,6 +635,18 @@ typedef virDomainPtr
>                                unsigned int flags);
>
>  typedef int
> +    (*virDrvDomainQemuEventRegister)(virConnectPtr conn,
> +                                     virDomainPtr dom, /* option to filter */
> +                                     const char *eventName,  /* JSON event name */
> +                                     virConnectDomainEventGenericCallback cb,
> +                                     void *opaque,
> +                                     virFreeCallback freecb);
> +
> +typedef int
> +    (*virDrvDomainQemuEventDeregister)(virConnectPtr conn,
> +                                       int callbackID);
> +
> +typedef int
>      (*virDrvDomainOpenConsole)(virDomainPtr dom,
>                                 const char *dev_name,
>                                 virStreamPtr st,
> @@ -915,6 +927,8 @@ struct _virDriver {
>      virDrvDomainSnapshotDelete domainSnapshotDelete;
>      virDrvDomainQemuMonitorCommand qemuDomainMonitorCommand;
>      virDrvDomainQemuAttach qemuDomainAttach;
> +    virDrvDomainQemuEventRegister     qemuDomainQemuEventRegister;
> +    virDrvDomainQemuEventDeregister   qemuDomainQemuEventDeregister;
>      virDrvDomainOpenConsole domainOpenConsole;
>      virDrvDomainOpenGraphics domainOpenGraphics;
>      virDrvDomainInjectNMI domainInjectNMI;
> diff --git a/src/libvirt-qemu.c b/src/libvirt-qemu.c
> index 248cc33..c84375c 100644
> --- a/src/libvirt-qemu.c
> +++ b/src/libvirt-qemu.c
> @@ -36,6 +36,77 @@
>      virReportErrorHelper(VIR_FROM_DOM, error, NULL, __FUNCTION__,       \
>                           __LINE__, info)
>
> +/* Helper macros to implement VIR_DOMAIN_DEBUG using just C99.  This
> + * assumes you pass fewer than 15 arguments to VIR_DOMAIN_DEBUG, but
> + * can easily be expanded if needed.
> + *
> + * Note that gcc provides extensions of "define a(b...) b" or
> + * "define a(b,...) b,##__VA_ARGS__" as a means of eliding a comma
> + * when no var-args are present, but we don't want to require gcc.
> + */
> +#define VIR_ARG15(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, ...) _15
> +#define VIR_HAS_COMMA(...) VIR_ARG15(__VA_ARGS__, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0)
> +
> +/* Form the name VIR_DOMAIN_DEBUG_[01], then call that macro,
> + * according to how many arguments are present.  Two-phase due to
> + * macro expansion rules.  */
> +#define VIR_DOMAIN_DEBUG_EXPAND(a, b, ...)      \
> +    VIR_DOMAIN_DEBUG_PASTE(a, b, __VA_ARGS__)
> +#define VIR_DOMAIN_DEBUG_PASTE(a, b, ...)       \
> +    a##b(__VA_ARGS__)
> +
> +/* Internal use only, when VIR_DOMAIN_DEBUG has one argument.  */
> +#define VIR_DOMAIN_DEBUG_0(dom)                 \
> +    VIR_DOMAIN_DEBUG_2(dom, "%s", "")
> +
> +/* Internal use only, when VIR_DOMAIN_DEBUG has three or more arguments.  */
> +#define VIR_DOMAIN_DEBUG_1(dom, fmt, ...)       \
> +    VIR_DOMAIN_DEBUG_2(dom, ", " fmt, __VA_ARGS__)
> +
> +/* Internal use only, with final format.  */
> +#define VIR_DOMAIN_DEBUG_2(dom, fmt, ...)                               \
> +    do {                                                                \
> +        char _uuidstr[VIR_UUID_STRING_BUFLEN];                          \
> +        const char *_domname = NULL;                                    \
> +                                                                        \
> +        if (!VIR_IS_DOMAIN(dom)) {                                      \
> +            memset(_uuidstr, 0, sizeof(_uuidstr));                      \
> +        } else {                                                        \
> +            virUUIDFormat((dom)->uuid, _uuidstr);                       \
> +            _domname = (dom)->name;                                     \
> +        }                                                               \
> +                                                                        \
> +        VIR_DEBUG("dom=%p, (VM: name=%s, uuid=%s)" fmt,                 \
> +                  dom, NULLSTR(_domname), _uuidstr, __VA_ARGS__);       \
> +    } while (0)
> +
> +/**
> + * VIR_DOMAIN_DEBUG:
> + * @dom: domain
> + * @fmt: optional format for additional information
> + * @...: optional arguments corresponding to @fmt.
> + */
> +#define VIR_DOMAIN_DEBUG(...)                           \
> +    VIR_DOMAIN_DEBUG_EXPAND(VIR_DOMAIN_DEBUG_,          \
> +                            VIR_HAS_COMMA(__VA_ARGS__), \
> +                            __VA_ARGS__)
> +
> +/**
> + * VIR_UUID_DEBUG:
> + * @conn: connection
> + * @uuid: possibly null UUID array
> + */
> +#define VIR_UUID_DEBUG(conn, uuid)                              \
> +    do {                                                        \
> +        if (uuid) {                                             \
> +            char _uuidstr[VIR_UUID_STRING_BUFLEN];              \
> +            virUUIDFormat(uuid, _uuidstr);                      \
> +            VIR_DEBUG("conn=%p, uuid=%s", conn, _uuidstr);      \
> +        } else {                                                \
> +            VIR_DEBUG("conn=%p, uuid=(null)", conn);            \
> +        }                                                       \
> +    } while (0)
> +
>  /**
>   * virDomainQemuMonitorCommand:
>   * @domain: a domain object
> @@ -178,3 +249,122 @@ error:
>      virDispatchError(conn);
>      return NULL;
>  }
> +
> +/**
> + * virConnectDomainQemuEventRegister:
> + * @conn: pointer to the connection
> + * @dom: pointer to the domain
> + * @eventName: the event Name to receive
> + * @cb: callback to the function handling domain events
> + * @opaque: opaque data to pass on to the callback
> + * @freecb: optional function to deallocate opaque when not used anymore
> + *
> + * Adds a callback to receive notifications of arbitrary qemu domain events
> + * occurring on a domain.
> + *
> + * If dom is NULL, then events will be monitored for any domain. If dom
> + * is non-NULL, then only the specific domain will be monitored
> + *
> + * Most types of event have a callback providing a custom set of parameters
> + * for the event. When registering an event, it is thus neccessary to use
> + * the VIR_DOMAIN_EVENT_CALLBACK() macro to cast the supplied function pointer
> + * to match the signature of this method.
> + *
> + * The virDomainPtr object handle passed into the callback upon delivery
> + * of an event is only valid for the duration of execution of the callback.
> + * If the callback wishes to keep the domain object after the callback returns,
> + * it shall take a reference to it, by calling virDomainRef.
> + * The reference can be released once the object is no longer required
> + * by calling virDomainFree.
> + *
> + * The return value from this method is a positive integer identifier
> + * for the callback. To unregister a callback, this callback ID should
> + * be passed to the virConnectDomainQemuEventDeregister method
> + *
> + * Returns a callback identifier on success, -1 on failure
> + */
> +int
> +virConnectDomainQemuEventRegister(virConnectPtr conn,
> +                                  virDomainPtr dom, /* option to filter */
> +                                  const char *eventName,  /* JSON event name */
> +                                  virConnectDomainQemuEventCallback cb,
> +                                  void *opaque,
> +                                  virFreeCallback freecb)
> +{
> +    VIR_DOMAIN_DEBUG(dom, "conn=%p, eventName=%s, cb=%p, opaque=%p, freecb=%p",
> +                     conn, eventName, cb, opaque, freecb);
> +
> +    virResetLastError();
> +
> +    if (!VIR_IS_CONNECT(conn)) {
> +        virLibConnError(conn, VIR_ERR_INVALID_CONN, __FUNCTION__);
> +        virLibConnError(conn, VIR_ERR_INVALID_CONN, "my_test_fuction");
> +        virDispatchError(NULL);
> +        return -1;
> +    }
> +    if (dom != NULL &&
> +        !(VIR_IS_CONNECTED_DOMAIN(dom) && dom->conn == conn)) {
> +        virLibConnError(conn, VIR_ERR_INVALID_CONN, __FUNCTION__);
> +        virDispatchError(conn);
> +        return -1;
> +    }
> +    if (eventName == NULL || cb == NULL) {
> +        virLibConnError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
> +        goto error;
> +    }
> +
> +    if ((conn->driver) && (conn->driver->qemuDomainQemuEventRegister)) {
> +        int ret;
> +        ret = conn->driver->qemuDomainQemuEventRegister(conn, dom, eventName, cb, opaque, freecb);
> +        if (ret < 0)
> +            goto error;
> +        return ret;
> +    }
> +
> +    virLibConnError(conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
> +error:
> +    virDispatchError(conn);
> +    return -1;
> +}
> +
> +/**
> + * virConnectDomainQemuEventDeregister:
> + * @conn: pointer to the connection
> + * @callbackID: the callback identifier
> + *
> + * Removes an event callback. The callbackID parameter should be the
> + * vaule obtained from a previous virConnectDomainQemuEventDeregister method.
> + *
> + * Returns 0 on success, -1 on failure
> + */
> +int
> +virConnectDomainQemuEventDeregister(virConnectPtr conn,
> +                                    int callbackID)
> +{
> +
> +    VIR_DEBUG("conn=%p, callbackID=%d", conn, callbackID);
> +
> +    virResetLastError();
> +
> +    if (!VIR_IS_CONNECT(conn)) {
> +        virLibConnError(conn, VIR_ERR_INVALID_CONN, __FUNCTION__);
> +        virDispatchError(NULL);
> +        return -1;
> +    }
> +    if (callbackID < 0) {
> +        virLibConnError(conn, VIR_ERR_INVALID_ARG, __FUNCTION__);
> +        goto error;
> +    }
> +    if ((conn->driver) && (conn->driver->qemuDomainQemuEventDeregister)) {
> +        int ret;
> +        ret = conn->driver->qemuDomainQemuEventDeregister(conn, callbackID);
> +        if (ret < 0)
> +            goto error;
> +        return ret;
> +    }
> +
> +    virLibConnError(conn, VIR_ERR_NO_SUPPORT, __FUNCTION__);
> +error:
> +    virDispatchError(conn);
> +    return -1;
> +}
> diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms
> index a81c230..b92ce71 100644
> --- a/src/libvirt_private.syms
> +++ b/src/libvirt_private.syms
> @@ -470,11 +470,16 @@ virDomainWatchdogModelTypeToString;
>  # domain_event.h
>  virDomainEventBlockJobNewFromObj;
>  virDomainEventBlockJobNewFromDom;
> +virDomainEventUnknownNewFromObj;
> +virDomainEventunknownNewFromDom;
>  virDomainEventCallbackListAdd;
>  virDomainEventCallbackListAddID;
> +virDomainEventCallbackListAddName;
>  virDomainEventCallbackListCount;
>  virDomainEventCallbackListCountID;
> +virDomainEventCallbackListCountName;
>  virDomainEventCallbackListEventID;
> +virDomainEventCallbackListEventName;
>  virDomainEventCallbackListFree;
>  virDomainEventCallbackListMarkDelete;
>  virDomainEventCallbackListMarkDeleteID;
> @@ -511,6 +516,7 @@ virDomainEventRebootNewFromDom;
>  virDomainEventRebootNewFromObj;
>  virDomainEventStateDeregister;
>  virDomainEventStateDeregisterAny;
> +virDomainQemuEventStateDeregister;
>  virDomainEventStateFlush;
>  virDomainEventStateFree;
>  virDomainEventStateNew;
> diff --git a/src/libvirt_qemu.syms b/src/libvirt_qemu.syms
> index 8447730..a17e387 100644
> --- a/src/libvirt_qemu.syms
> +++ b/src/libvirt_qemu.syms
> @@ -19,3 +19,8 @@ LIBVIRT_QEMU_0.9.4 {
>      global:
>          virDomainQemuAttach;
>  } LIBVIRT_QEMU_0.8.3;
> +LIBVIRT_QEMU_0.9.9 {
> +    global:
> +        virConnectDomainQemuEventRegister;
> +        virConnectDomainQemuEventDeregister;
> +} LIBVIRT_QEMU_0.9.4;
> diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c
> index ceb9f47..31fe966 100644
> --- a/src/qemu/qemu_driver.c
> +++ b/src/qemu/qemu_driver.c
> @@ -8217,6 +8217,46 @@ qemuDomainEventDeregisterAny(virConnectPtr conn,
>  }
>
>
> +static int
> +qemuDomainQemuEventRegister(virConnectPtr conn,
> +                            virDomainPtr dom,
> +                            const char *eventName,
> +                            virConnectDomainEventGenericCallback callback,
> +                            void *opaque,
> +                            virFreeCallback freecb)
> +{
> +    struct qemud_driver *driver = conn->privateData;
> +    int ret;
> +
> +    qemuDriverLock(driver);
> +    ret = virDomainEventCallbackListAddName(conn,
> +                                            driver->domainEventState->callbacks,
> +                                            dom, eventName,
> +                                            VIR_QEMU_DOMAIN_EVENT_ID_UNKNOWN,
> +                                            callback, opaque, freecb);
> +    qemuDriverUnlock(driver);
> +
> +    return ret;
> +}
> +
> +
> +static int
> +qemuDomainQemuEventDeregister(virConnectPtr conn,
> +                              int callbackID)
> +{
> +    struct qemud_driver *driver = conn->privateData;
> +    int ret;
> +
> +    qemuDriverLock(driver);
> +    ret = virDomainQemuEventStateDeregister(conn,
> +                                            driver->domainEventState,
> +                                            callbackID);
> +    qemuDriverUnlock(driver);
> +
> +    return ret;
> +}
> +
> +
>  /*******************************************************************
>   * Migration Protocol Version 2
>   *******************************************************************/
> @@ -11564,6 +11604,8 @@ static virDriver qemuDriver = {
>      .domainMigrateGetMaxSpeed = qemuDomainMigrateGetMaxSpeed, /* 0.9.5 */
>      .domainEventRegisterAny = qemuDomainEventRegisterAny, /* 0.8.0 */
>      .domainEventDeregisterAny = qemuDomainEventDeregisterAny, /* 0.8.0 */
> +    .qemuDomainQemuEventRegister = qemuDomainQemuEventRegister, /* 0.9.9 */
> +    .qemuDomainQemuEventDeregister = qemuDomainQemuEventDeregister, /* 0.9.9 */
>      .domainManagedSave = qemuDomainManagedSave, /* 0.8.0 */
>      .domainHasManagedSaveImage = qemuDomainHasManagedSaveImage, /* 0.8.0 */
>      .domainManagedSaveRemove = qemuDomainManagedSaveRemove, /* 0.8.0 */
> diff --git a/src/qemu/qemu_monitor.c b/src/qemu/qemu_monitor.c
> index 4141fb7..e6cd39c 100644
> --- a/src/qemu/qemu_monitor.c
> +++ b/src/qemu/qemu_monitor.c
> @@ -959,6 +959,16 @@ int qemuMonitorEmitBlockJob(qemuMonitorPtr mon,
>      return ret;
>  }
>
> +int qemuMonitorEmitUnknownEvent(qemuMonitorPtr mon,
> +                                const char *eventName,
> +                                const char *eventArgs)
> +{
> +    int ret = -1;
> +    VIR_DEBUG("mon=%p", mon);
> +    QEMU_MONITOR_CALLBACK(mon, ret, domainUnknownEvent, mon->vm,
> +                          eventName, eventArgs);
> +    return ret;
> +}
>
>
>  int qemuMonitorSetCapabilities(qemuMonitorPtr mon)
> diff --git a/src/qemu/qemu_monitor.h b/src/qemu/qemu_monitor.h
> index 15acf8b..d3685b4 100644
> --- a/src/qemu/qemu_monitor.h
> +++ b/src/qemu/qemu_monitor.h
> @@ -123,6 +123,10 @@ struct _qemuMonitorCallbacks {
>                            const char *diskAlias,
>                            int type,
>                            int status);
> +    int (*domainUnknownEvent)(qemuMonitorPtr mon,
> +                              virDomainObjPtr vm,
> +                              const char *eventName,
> +                              const char *eventArgs);
>  };
>
>
> @@ -193,6 +197,10 @@ int qemuMonitorEmitBlockJob(qemuMonitorPtr mon,
>                              int type,
>                              int status);
>
> +int qemuMonitorEmitUnknownEvent(qemuMonitorPtr mon,
> +                                const char *eventName,
> +                                const char *eventArgs);
> +
>
>
>  int qemuMonitorStartCPUs(qemuMonitorPtr mon,
> diff --git a/src/qemu/qemu_monitor_json.c b/src/qemu/qemu_monitor_json.c
> index 1ef3e84..a5fc1e6 100644
> --- a/src/qemu/qemu_monitor_json.c
> +++ b/src/qemu/qemu_monitor_json.c
> @@ -58,6 +58,7 @@ static void qemuMonitorJSONHandleVNCConnect(qemuMonitorPtr mon, virJSONValuePtr
>  static void qemuMonitorJSONHandleVNCInitialize(qemuMonitorPtr mon, virJSONValuePtr data);
>  static void qemuMonitorJSONHandleVNCDisconnect(qemuMonitorPtr mon, virJSONValuePtr data);
>  static void qemuMonitorJSONHandleBlockJob(qemuMonitorPtr mon, virJSONValuePtr data);
> +static void qemuMonitorJSONHandleUnmatchedEvent(qemuMonitorPtr mon, virJSONValuePtr obj);
>
>  struct {
>      const char *type;
> @@ -74,6 +75,7 @@ struct {
>      { "VNC_INITIALIZED", qemuMonitorJSONHandleVNCInitialize, },
>      { "VNC_DISCONNECTED", qemuMonitorJSONHandleVNCDisconnect, },
>      { "BLOCK_JOB_COMPLETED", qemuMonitorJSONHandleBlockJob, },
> +    { "DEFAULT_UNKNOW_EVENT", qemuMonitorJSONHandleUnmatchedEvent, },
>  };
>
>
> @@ -83,6 +85,7 @@ qemuMonitorJSONIOProcessEvent(qemuMonitorPtr mon,
>  {
>      const char *type;
>      int i;
> +    int findEventFlag = -1;
>      VIR_DEBUG("mon=%p obj=%p", mon, obj);
>
>      type = virJSONValueObjectGetString(obj, "event");
> @@ -98,9 +101,24 @@ qemuMonitorJSONIOProcessEvent(qemuMonitorPtr mon,
>              VIR_DEBUG("handle %s handler=%p data=%p", type,
>                        eventHandlers[i].handler, data);
>              (eventHandlers[i].handler)(mon, data);
> +            findEventFlag = 0;
>              break;
>          }
>      }
> +    if (findEventFlag != 0) {
> +        if (!STREQ(eventHandlers[ARRAY_CARDINALITY(eventHandlers)-1].type, "DEFAULT_UNKNOW_EVENT")) {
> +            VIR_ERROR("the last element is not the default event handler");
> +        }
> +        else {
> +            char *event = NULL;
> +            event = virJSONValueToString(obj);
> +            if (event != NULL) {
> +                VIR_DEBUG("Unknow event,call default event handler %s",event);
> +                free(event);
> +            }
> +            (eventHandlers[ARRAY_CARDINALITY(eventHandlers)-1].handler)(mon, obj);
> +        }
> +    }
>      return 0;
>  }
>
> @@ -724,6 +742,24 @@ out:
>  }
>
>
> +static void
> +qemuMonitorJSONHandleUnmatchedEvent(qemuMonitorPtr mon, virJSONValuePtr obj)
> +{
> +    const char *eventArgsStr = NULL;
> +    const char *type = NULL;
> +    virJSONValuePtr data = NULL;
> +    type = virJSONValueObjectGetString(obj, "event");
> +    data  = virJSONValueObjectGet(obj, "data");
> +    if (data) {
> +        eventArgsStr = virJSONValueToString(data);
> +    }
> +    if (eventArgsStr == NULL) {
> +        VIR_ERROR("no data string from JSONValue");
> +    }
> +    qemuMonitorEmitUnknownEvent(mon, type, eventArgsStr);
> +}
> +
> +
>  int
>  qemuMonitorJSONHumanCommandWithFd(qemuMonitorPtr mon,
>                                    const char *cmd_str,
> diff --git a/src/qemu/qemu_process.c b/src/qemu/qemu_process.c
> index 9123f4c..55e5464 100644
> --- a/src/qemu/qemu_process.c
> +++ b/src/qemu/qemu_process.c
> @@ -755,6 +755,29 @@ qemuProcessHandleBlockJob(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
>  }
>
>  static int
> +qemuProcessHandleUnknownEvent(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
> +                              virDomainObjPtr vm,
> +                              const char *eventName,
> +                              const char *eventArgs)
> +{
> +    struct qemud_driver *driver = qemu_driver;
> +    virDomainEventPtr event = NULL;
> +
> +    virDomainObjLock(vm);
> +    event = virDomainEventUnknownNewFromObj(vm, eventName, eventArgs);
> +
> +    virDomainObjUnlock(vm);
> +
> +    if (event) {
> +        qemuDriverLock(driver);
> +        qemuDomainEventQueue(driver, event);
> +        qemuDriverUnlock(driver);
> +    }
> +
> +    return 0;
> +}
> +
> +static int
>  qemuProcessHandleGraphics(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
>                            virDomainObjPtr vm,
>                            int phase,
> @@ -871,6 +894,7 @@ static qemuMonitorCallbacks monitorCallbacks = {
>      .domainIOError = qemuProcessHandleIOError,
>      .domainGraphics = qemuProcessHandleGraphics,
>      .domainBlockJob = qemuProcessHandleBlockJob,
> +    .domainUnknownEvent = qemuProcessHandleUnknownEvent,
>  };
>
>  static int
> diff --git a/src/remote/qemu_protocol.x b/src/remote/qemu_protocol.x
> index 39f9adf..5f4ed61 100644
> --- a/src/remote/qemu_protocol.x
> +++ b/src/remote/qemu_protocol.x
> @@ -47,6 +47,34 @@ struct qemu_domain_attach_ret {
>      remote_nonnull_domain dom;
>  };
>
> +struct qemu_domain_events_register_args {
> +    remote_nonnull_string eventName;
> +};
> +
> +struct qemu_domain_events_deregister_args {
> +    remote_nonnull_string eventName;
> +    int callbackID;
> +};
> +
> +struct qemu_domain_events_register_ret {
> +    int callbackID;
> +};
> +
> +struct qemu_domain_events_deregister_ret {
> +    int cb_deregistered;
> +};
> +
> +struct qemu_domain_events_unknown_event_args {
> +    remote_nonnull_domain dom;
> +    remote_nonnull_string eventName;
> +    remote_nonnull_string eventArgs;
> +};
> +
> +struct qemu_domain_events_unknown_event_ret {
> +    int event_ret;
> +};
> +
> +
>  /* Define the program number, protocol version and procedure numbers here. */
>  const QEMU_PROGRAM = 0x20008087;
>  const QEMU_PROTOCOL_VERSION = 1;
> @@ -61,5 +89,8 @@ enum qemu_procedure {
>       * are some exceptions to this rule, e.g. domainDestroy. Other APIs MAY
>       * be marked as high priority. If in doubt, it's safe to choose low. */
>      QEMU_PROC_MONITOR_COMMAND = 1, /* skipgen skipgen priority:low */
> -    QEMU_PROC_DOMAIN_ATTACH = 2 /* autogen autogen priority:low */
> +    QEMU_PROC_DOMAIN_ATTACH = 2, /* autogen autogen priority:low */
> +    QEMU_PROC_DOMAIN_EVENTS_REGISTER = 3, /* skipgen skipgen priority:low */
> +    QEMU_PROC_DOMAIN_EVENTS_DEREGISTER = 4, /* skipgen skipgen priority:low */
> +    QEMU_PROC_DOMAIN_EVENTS_UNKNOWN_EVENT = 5 /* skipgen skipgen priority:low */
>  };
> diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c
> index ff2d4b4..1f7b25d 100644
> --- a/src/remote/remote_driver.c
> +++ b/src/remote/remote_driver.c
> @@ -238,6 +238,10 @@ static void
>  remoteDomainBuildEventDiskChange(virNetClientProgramPtr prog,
>                                   virNetClientPtr client,
>                                   void *evdata, void *opaque);
> +static void
> +remoteQemuDomainBuildEventDefaultEvent(virNetClientProgramPtr prog,
> +                                       virNetClientPtr client,
> +                                       void *evdata, void *opaque);
>
>  static virNetClientProgramEvent remoteDomainEvents[] = {
>      { REMOTE_PROC_DOMAIN_EVENT_RTC_CHANGE,
> @@ -280,6 +284,10 @@ static virNetClientProgramEvent remoteDomainEvents[] = {
>        remoteDomainBuildEventDiskChange,
>        sizeof(remote_domain_event_disk_change_msg),
>        (xdrproc_t)xdr_remote_domain_event_disk_change_msg },
> +    { REMOTE_PROC_QEMU_DOMAIN_EVENT_UNKNOWN_EVENT,
> +      remoteQemuDomainBuildEventDefaultEvent,
> +      sizeof(remote_domain_event_default_event_msg),
> +      (xdrproc_t)xdr_remote_domain_event_default_event_msg },
>  };
>
>  enum virDrvOpenRemoteFlags {
> @@ -3345,6 +3353,28 @@ remoteDomainBuildEventBlockJob(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
>  }
>
>  static void
> +remoteQemuDomainBuildEventDefaultEvent(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
> +                                       virNetClientPtr client ATTRIBUTE_UNUSED,
> +                                       void *evdata, void *opaque)
> +{
> +    virConnectPtr conn = opaque;
> +    struct private_data *priv = conn->privateData;
> +    remote_domain_event_default_event_msg *msg = evdata;
> +    virDomainPtr dom;
> +    virDomainEventPtr event = NULL;
> +
> +    dom = get_nonnull_domain(conn, msg->dom);
> +    if (!dom)
> +        return;
> +
> +    event = virDomainEventUnknownNewFromDom(dom, msg->eventName, msg->eventArgs);
> +
> +    virDomainFree(dom);
> +
> +    remoteDomainEventQueue(priv, event);
> +}
> +
> +static void
>  remoteDomainBuildEventGraphics(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
>                                 virNetClientPtr client ATTRIBUTE_UNUSED,
>                                 void *evdata, void *opaque)
> @@ -3800,7 +3830,6 @@ done:
>      return rv;
>  }
>
> -
>  static int remoteDomainEventDeregisterAny(virConnectPtr conn,
>                                            int callbackID)
>  {
> @@ -3843,6 +3872,126 @@ done:
>      return rv;
>  }
>
> +static int
> +remoteDomainQemuEventRegister(virConnectPtr conn,
> +                              virDomainPtr dom,
> +                              const char *eventName,
> +                              virConnectDomainEventGenericCallback callback,
> +                              void *opaque,
> +                              virFreeCallback freecb)
> +{
> +    int rv = -1;
> +    struct private_data *priv = conn->privateData;
> +    qemu_domain_events_register_args args;
> +    qemu_domain_events_register_ret ret;
> +    int callbackID;
> +
> +    remoteDriverLock(priv);
> +
> +    if (priv->domainEventState->timer < 0) {
> +         remoteError(VIR_ERR_NO_SUPPORT, "%s", _("no event support"));
> +         goto done;
> +    }
> +
> +    if ((callbackID = virDomainEventCallbackListAddName(conn,
> +                                                      priv->domainEventState->callbacks,
> +                                                      dom, eventName,
> +                                                      VIR_QEMU_DOMAIN_EVENT_ID_UNKNOWN,
> +                                                      callback, opaque, freecb)) < 0) {
> +         remoteError(VIR_ERR_RPC, "%s", _("adding cb to list"));
> +         goto done;
> +    }
> +
> +    /* If this is the first callback for this eventID, we need to enable
> +     * events on the server */
> +    if (virDomainEventCallbackListCountName(conn,
> +                                          priv->domainEventState->callbacks,
> +                                          eventName) == 1) {
> +        args.eventName= (char *)eventName;
> +
> +        if (call (conn, priv, REMOTE_CALL_QEMU, QEMU_PROC_DOMAIN_EVENTS_REGISTER,
> +                  (xdrproc_t) xdr_qemu_domain_events_register_args, (char *) &args,
> +                  (xdrproc_t) xdr_qemu_domain_events_register_ret, (char *) &ret) == -1) {
> +            virDomainEventCallbackListRemoveID(conn,
> +                                               priv->domainEventState->callbacks,
> +                                               callbackID);
> +            goto done;
> +        }
> +    }
> +    virDomainEventCallbackListAddQemuCallbackID(conn,
> +                                                priv->domainEventState->callbacks,
> +                                                callbackID,
> +					        ret.callbackID);
> +    rv = callbackID;
> +
> +done:
> +    remoteDriverUnlock(priv);
> +    return rv;
> +}
> +
> +static int remoteDomainQemuEventDeregister(virConnectPtr conn,
> +                                     int callbackID)
> +{
> +    struct private_data *priv = conn->privateData;
> +    int rv = -1;
> +    qemu_domain_events_deregister_args args;
> +    qemu_domain_events_deregister_ret ret;
> +    char *eventName = NULL;
> +    ret.cb_deregistered = -1;
> +
> +    remoteDriverLock(priv);
> +
> +    if ((eventName = (char *)virDomainEventCallbackListEventName(conn,
> +                                                         priv->domainEventState->callbacks,
> +                                                         callbackID)) == NULL) {
> +        remoteError(VIR_ERR_RPC, _("unable to find callback ID %d"), callbackID);
> +        goto done;
> +    }
> +    eventName = strdup(eventName);
> +    if (eventName == NULL)
> +	goto done;
> +
> +    if ((args.callbackID = virDomainEventCallbackListEventQemuCallbackID(conn,
> +                                                         priv->domainEventState->callbacks,
> +                                                         callbackID)) == -1) {
> +        remoteError(VIR_ERR_RPC, _("unable to find callback ID %d"), callbackID);
> +        goto done;
> +    }
> +
> +    if (virDomainQemuEventStateDeregister(conn,
> +                                          priv->domainEventState,
> +                                          callbackID) < 0)
> +        goto done;
> +
> +    /* If that was the last callback for this eventName, we need to disable
> +     * events on the server */
> +    if (virDomainEventCallbackListCountName(conn,
> +                                          priv->domainEventState->callbacks,
> +                                          eventName) == 0) {
> +        args.eventName = eventName;
> +
> +        if (call (conn, priv, REMOTE_CALL_QEMU, QEMU_PROC_DOMAIN_EVENTS_DEREGISTER,
> +                  (xdrproc_t) xdr_qemu_domain_events_deregister_args, (char *) &args,
> +                  (xdrproc_t) xdr_qemu_domain_events_deregister_ret, (char *) &ret) == -1) {
> +            goto done;
> +        }
> +
> +        if ( ret.cb_deregistered == -1 ) {
> +            remoteError(VIR_ERR_RPC, _("remote sever deregeiter remote callbackID:%d, and the client callbackID%d"),
> +                        args.callbackID,
> +                        callbackID);
> +            goto done;
> +        }
> +        rv = ret.cb_deregistered;
> +    }
> +
> +
> +done:
> +    remoteDriverUnlock(priv);
> +    if (eventName != NULL)
> +        VIR_FREE(eventName);
> +    return rv;
> +}
>
>  /*----------------------------------------------------------------------*/
>
> @@ -4627,6 +4776,8 @@ static virDriver remote_driver = {
>      .nodeGetFreeMemory = remoteNodeGetFreeMemory, /* 0.3.3 */
>      .domainEventRegister = remoteDomainEventRegister, /* 0.5.0 */
>      .domainEventDeregister = remoteDomainEventDeregister, /* 0.5.0 */
> +    .qemuDomainQemuEventRegister = remoteDomainQemuEventRegister, /* 0.9.9 */
> +    .qemuDomainQemuEventDeregister = remoteDomainQemuEventDeregister, /* 0.9.9 */
>      .domainMigratePrepare2 = remoteDomainMigratePrepare2, /* 0.5.0 */
>      .domainMigrateFinish2 = remoteDomainMigrateFinish2, /* 0.5.0 */
>      .nodeDeviceDettach = remoteNodeDeviceDettach, /* 0.6.1 */
> diff --git a/src/remote/remote_protocol.x b/src/remote/remote_protocol.x
> index 509a20b..4239db8 100644
> --- a/src/remote/remote_protocol.x
> +++ b/src/remote/remote_protocol.x
> @@ -2049,6 +2049,12 @@ struct remote_domain_event_disk_change_msg {
>      int reason;
>  };
>
> +struct remote_domain_event_default_event_msg {
> +    remote_nonnull_domain dom;
> +    remote_nonnull_string eventName;
> +    remote_nonnull_string eventArgs;
> +};
> +
>  struct remote_domain_managed_save_args {
>      remote_nonnull_domain dom;
>      unsigned int flags;
> @@ -2605,7 +2611,8 @@ enum remote_procedure {
>
>      REMOTE_PROC_DOMAIN_BLOCK_RESIZE = 251, /* autogen autogen */
>      REMOTE_PROC_DOMAIN_SET_BLOCK_IO_TUNE = 252, /* autogen autogen */
> -    REMOTE_PROC_DOMAIN_GET_BLOCK_IO_TUNE = 253 /* skipgen skipgen */
> +    REMOTE_PROC_DOMAIN_GET_BLOCK_IO_TUNE = 253, /* skipgen skipgen */
> +    REMOTE_PROC_QEMU_DOMAIN_EVENT_UNKNOWN_EVENT = 254 /* skipgen skipgen */
>
>      /*
>       * Notice how the entries are grouped in sets of 10 ?
> diff --git a/src/remote_protocol-structs b/src/remote_protocol-structs
> index a9d4296..17b3896 100644
> --- a/src/remote_protocol-structs
> +++ b/src/remote_protocol-structs
> @@ -1546,6 +1546,10 @@ struct remote_domain_event_disk_change_msg {
>          remote_nonnull_string      devAlias;
>          int                        reason;
>  };
> +struct remote_domain_event_default_event_msg {
> +        remote_nonnull_domain      dom;
> +        remote_nonnull_string      rawEvent;
> +};
>  struct remote_domain_managed_save_args {
>          remote_nonnull_domain      dom;
>          u_int                      flags;
> @@ -2044,4 +2048,5 @@ enum remote_procedure {
>          REMOTE_PROC_DOMAIN_BLOCK_RESIZE = 251,
>          REMOTE_PROC_DOMAIN_SET_BLOCK_IO_TUNE = 252,
>          REMOTE_PROC_DOMAIN_GET_BLOCK_IO_TUNE = 253,
> +        REMOTE_PROC_QEMU_DOMAIN_EVENT_UNKNOWN_EVENT = 254,
>  };

#!/usr/bin/env python

import libvirt
import libvirt_qemu
import threading
import time
import signal
import os
import sys

eventLoopThread = None

def eventLoopRun():
    while True:
        libvirt.virEventRunDefaultImpl()

def eventLoopStart():
    global eventLoopThread

    libvirt.virEventRegisterDefaultImpl()
    eventLoopThread = threading.Thread(target=eventLoopRun, name="libvirtEventLoop")
    eventLoopThread.setDaemon(True)
    eventLoopThread.start()


def reportDefault(conn, dom, eventName,eventArgs,opaque):
    print "DEFAULT EVENT: Domain %s(%s), pass the unknown event:%s, arguments is: %s" % (dom.name(), dom.ID(), eventName, eventArgs)

eventStrings = ( 
                 "RESUME",
                 "VNC_CONNECTED",
                 "VNC_DISCONNECTED",
                 "VNC_INITIALIZED",
                 "RESET",
                 "SHUTDOWN",
                 "HELLO" );
conn = libvirt.virConnect();
eventID = {};

def signal_handler(signal, frame):
    #print conn.getURI()
    if conn != None:
        print conn
        for i in eventID:
            print "deregister event: %d" %(i)
            #libvirt_qemu.domainQemuEventDeregister(conn1, i)
        print "test safely exit"
    else:
        print "conn is None"
    sys.exit(0)

def main():
    eventLoopStart()
    signal.signal(signal.SIGINT, signal_handler) 
    conn = libvirt.openReadOnly('qemu:///system')
    eventID[0] = libvirt_qemu.domainQemuEventRegister(conn, None, eventStrings[0], reportDefault, None)
    #eventID[1] = libvirt_qemu.domainQemuEventRegister(conn, None, eventStrings[1], reportDefault, None)
    #eventID[2] = libvirt_qemu.domainQemuEventRegister(conn, None, eventStrings[2], reportDefault, None)
    #eventID[3] = libvirt_qemu.domainQemuEventRegister(conn, None, eventStrings[3], reportDefault, None)
    #eventID[4] = libvirt_qemu.domainQemuEventRegister(conn, None, eventStrings[4], reportDefault, None)
    #eventID[5] = libvirt_qemu.domainQemuEventRegister(conn, None, eventStrings[5], reportDefault, None)
    #eventID[6] = libvirt_qemu.domainQemuEventRegister(conn, None, eventStrings[6], reportDefault, None)
    #eventID[7] = libvirt_qemu.domainQemuEventRegister(conn, None, 'SHUTDOWN', reportDefault, None)

    while 1:
        time.sleep(1)
        
if __name__ == "__main__":
    main()


>From 5454587749040dd028f7255259b28dce22253531 Mon Sep 17 00:00:00 2001
From: Shao He Feng <shaohef linux vnet ibm com>
Date: Tue, 13 Dec 2011 04:33:18 +0800
Subject: for testing the new qemu specific regiater API


Signed-off-by: Shao He Feng <shaohef linux vnet ibm com>
---
 tools/virsh.c |  107 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 107 insertions(+), 0 deletions(-)

diff --git a/tools/virsh.c b/tools/virsh.c
index d58b827..4c9a69d 100644
--- a/tools/virsh.c
+++ b/tools/virsh.c
@@ -36,6 +36,7 @@
 
 #include <libxml/parser.h>
 #include <libxml/tree.h>
+#include <libxml/uri.h>
 #include <libxml/xpath.h>
 #include <libxml/xmlsave.h>
 
@@ -53,6 +54,8 @@
 #include "memory.h"
 #include "xml.h"
 #include "libvirt/libvirt-qemu.h"
+#include "libvirt/libvirt.h"
+#include "datatypes.h"
 #include "virfile.h"
 #include "event_poll.h"
 #include "configmake.h"
@@ -11790,6 +11793,108 @@ cmdVNCDisplay(vshControl *ctl, const vshCmd *cmd)
     return ret;
 }
 
+static const vshCmdInfo info_deregevent[] = {
+    {"help", N_("deregister an qemu event")},
+    {"desc", N_("you please input you eventID, that the register-event returns.")},
+    {NULL, NULL}
+};
+static const vshCmdOptDef opts_deregevent[] = {
+    {"eventID", VSH_OT_INT, VSH_OFLAG_REQ, N_("deregister qemu spici eventID ")},
+    {NULL, 0, 0, NULL}
+};
+
+static bool
+cmdDeregisterEvent(vshControl *ctl, const vshCmd *cmd)
+{
+    virDomainPtr dom;
+    bool ret = false;
+    int eventID = -1;
+    int retEventID = -1;
+    if (!vshConnectionUsability(ctl, ctl->conn))
+        return false;
+
+    if (vshCommandOptInt(cmd, "eventID", &eventID) < 0) {
+        vshError(ctl, "%s", _("Please specify valid eventID"));
+        return false;
+    }
+    if (eventID < 0) {
+        fprintf(stdout, "please input a positive Int\n");
+        return false;
+    }
+
+    if ((retEventID = virConnectDomainQemuEventDeregister(ctl->conn, eventID)) < 0) {
+       fprintf(stdout, "eventID: %d Deregister error.\n", eventID);
+       return false;
+    }
+    fprintf(stdout, "event Deregister successi, the remote callbackID is %d.\n", retEventID);
+    ret = true;
+ cleanup:
+    return ret;
+}
+
+static const vshCmdInfo info_regevent[] = {
+    {"help", N_("register an qemu event")},
+    {"desc", N_("you please input you event name.")},
+    {NULL, NULL}
+};
+
+static const vshCmdOptDef opts_regevent[] = {
+    {"event", VSH_OT_DATA, VSH_OFLAG_REQ, N_("register qemu spici event ")},
+    {NULL, 0, 0, NULL}
+};
+
+void printRegistEvent(virConnectPtr conn,
+                      virDomainPtr dom,
+                      const char *eventName, /* The JSON event name */
+                      const char *eventArgs, /* The JSON string of args */
+                      void *opaque){
+    char *uriName = virConnectGetURI (conn);
+    fputc('\n', stdout);
+    if (uriName != NULL)
+       fprintf(stdout, "connect URI: %s, ",uriName);
+        //xmlPrintURI(stdout, conn->uri);
+
+    if (dom != NULL)
+       fprintf(stdout, "dom: %s(%d) receive an event:\n", dom->name, dom->id);
+
+    if (eventName != NULL)
+        fprintf(stdout, "{ event: %s", eventName);
+    if (eventArgs != NULL)
+        fprintf(stdout, ", data: %s }\n", eventArgs);
+    else
+        fprintf(stdout, " }\n");
+    fprintf(stdout, "----------------------------------------------");
+    fputc('\n', stdout);
+}
+
+static bool
+cmdRegisterEvent(vshControl *ctl, const vshCmd *cmd)
+{
+    const char *name = NULL;
+    virDomainPtr dom;
+    bool ret = false;
+    int eventID = -1;
+
+    if (!vshConnectionUsability(ctl, ctl->conn))
+        return false;
+
+    if (vshCommandOptString(cmd, "event", &name) < 0) {
+        vshError(ctl, "%s", _("Please specify valid event name"));
+        return false;
+    }
+
+    dom = vshCommandOptDomain(ctl, cmd, NULL);
+    eventID = virConnectDomainQemuEventRegister(ctl->conn, dom, name, printRegistEvent, NULL, NULL);
+    if (eventID < 0) {
+       fprintf(stdout, "%s event register error.\n", name);
+       return false;
+    }
+    fprintf(stdout, "%s event call back ID is %d, you can use it to deregister the event.\n", name, eventID);
+    ret = true;
+ cleanup:
+    return ret;
+}
+
 /*
  * "ttyconsole" command
  */
@@ -15172,6 +15277,8 @@ static const vshCmdDef domManagementCmds[] = {
     {"vcpupin", cmdVcpuPin, opts_vcpupin, info_vcpupin, 0},
     {"version", cmdVersion, opts_version, info_version, 0},
     {"vncdisplay", cmdVNCDisplay, opts_vncdisplay, info_vncdisplay, 0},
+    {"register-event", cmdRegisterEvent, opts_regevent, info_regevent, 0},
+    {"deregister-event", cmdDeregisterEvent, opts_deregevent, info_deregevent, 0},
     {NULL, NULL, NULL, NULL, 0}
 };
 
-- 
1.7.5.4


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]