Introduce migration iteration event

The VIR_DOMAIN_EVENT_ID_MIGRATION_ITERATION event will be triggered
whenever VIR_DOMAIN_JOB_MEMORY_ITERATION changes its value, i.e.,
whenever a new iteration over guest memory pages is started during
migration.

Signed-off-by: Jiri Denemark <jdenemar@redhat.com>

diff --git a/daemon/remote.c b/daemon/remote.c
index 3a3eb091308894cc087a7b1766e67867626d878d..370f44288582d8e95dad956d16ead614d81a947c 100644 (file)
--- a/daemon/remote.c
+++ b/daemon/remote.c
@@ -1079,6 +1079,37 @@ remoteRelayDomainEventDeviceAdded(virConnectPtr conn,
 }
 
 
+static int
+remoteRelayDomainEventMigrationIteration(virConnectPtr conn,
+                                         virDomainPtr dom,
+                                         int iteration,
+                                         void *opaque)
+{
+    daemonClientEventCallbackPtr callback = opaque;
+    remote_domain_event_callback_migration_iteration_msg data;
+
+    if (callback->callbackID < 0 ||
+        !remoteRelayDomainEventCheckACL(callback->client, conn, dom))
+        return -1;
+
+    VIR_DEBUG("Relaying domain migration pass event %s %d, "
+              "callback %d, iteration %d",
+              dom->name, dom->id, callback->callbackID, iteration);
+
+    /* build return data */
+    memset(&data, 0, sizeof(data));
+    data.callbackID = callback->callbackID;
+    make_nonnull_domain(&data.dom, dom);
+
+    data.iteration = iteration;
+
+    remoteDispatchObjectEventSend(callback->client, remoteProgram,
+                                  REMOTE_PROC_DOMAIN_EVENT_CALLBACK_MIGRATION_ITERATION,
+                                  (xdrproc_t)xdr_remote_domain_event_callback_migration_iteration_msg,
+                                  &data);
+
+    return 0;
+}
 
 
 static virConnectDomainEventGenericCallback domainEventCallbacks[] = {
@@ -1102,6 +1133,7 @@ static virConnectDomainEventGenericCallback domainEventCallbacks[] = {
     VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventTunable),
     VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventAgentLifecycle),
     VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventDeviceAdded),
+    VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventMigrationIteration),
 };
 
 verify(ARRAY_CARDINALITY(domainEventCallbacks) == VIR_DOMAIN_EVENT_ID_LAST);

diff --git a/include/libvirt/libvirt-domain.h b/include/libvirt/libvirt-domain.h
index d26faa5db689cd98a8bda38050eb8cc14145d0e6..65f1618af38731c14ebf5b428c04c31c5cb4da3d 100644 (file)
--- a/include/libvirt/libvirt-domain.h
+++ b/include/libvirt/libvirt-domain.h
@@ -3283,6 +3283,27 @@ typedef void (*virConnectDomainEventDeviceAddedCallback)(virConnectPtr conn,
                                                          const char *devAlias,
                                                          void *opaque);
 
+/**
+ * virConnectDomainEventMigrationIterationCallback:
+ * @conn: connection object
+ * @dom: domain on which the event occurred
+ * @iteration: current iteration over domain's memory
+ * @opaque: application specific data
+ *
+ * This callback occurs during live migration when a new iteration over
+ * domain's memory starts. The @iteration value is increased by one every
+ * time a new iteration is started to transfer memory pages dirtied since
+ * the last iteration.
+ *
+ * The callback signature to use when registering for an event of type
+ * VIR_DOMAIN_EVENT_ID_MIGRATION_ITERATION with
+ * virConnectDomainEventRegisterAny().
+ */
+typedef void (*virConnectDomainEventMigrationIterationCallback)(virConnectPtr conn,
+                                                                virDomainPtr dom,
+                                                                int iteration,
+                                                                void *opaque);
+
 /**
  * VIR_DOMAIN_TUNABLE_CPU_VCPUPIN:
  *
@@ -3566,6 +3587,7 @@ typedef enum {
     VIR_DOMAIN_EVENT_ID_TUNABLE = 17,        /* virConnectDomainEventTunableCallback */
     VIR_DOMAIN_EVENT_ID_AGENT_LIFECYCLE = 18,/* virConnectDomainEventAgentLifecycleCallback */
     VIR_DOMAIN_EVENT_ID_DEVICE_ADDED = 19,   /* virConnectDomainEventDeviceAddedCallback */
+    VIR_DOMAIN_EVENT_ID_MIGRATION_ITERATION = 20, /* virConnectDomainEventMigrationIterationCallback */
 
 # ifdef VIR_ENUM_SENTINELS
     VIR_DOMAIN_EVENT_ID_LAST

diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c
index 20d66e11c886843c9ad7644a1fb5fbaa4c2239d5..5cb3ccd5b4f3de25ca35d111335a98d7a4c8ff6a 100644 (file)
--- a/src/conf/domain_event.c
+++ b/src/conf/domain_event.c
@@ -56,6 +56,7 @@ static virClassPtr virDomainQemuMonitorEventClass;
 static virClassPtr virDomainEventTunableClass;
 static virClassPtr virDomainEventAgentLifecycleClass;
 static virClassPtr virDomainEventDeviceAddedClass;
+static virClassPtr virDomainEventMigrationIterationClass;
 
 
 static void virDomainEventDispose(void *obj);
@@ -74,6 +75,7 @@ static void virDomainQemuMonitorEventDispose(void *obj);
 static void virDomainEventTunableDispose(void *obj);
 static void virDomainEventAgentLifecycleDispose(void *obj);
 static void virDomainEventDeviceAddedDispose(void *obj);
+static void virDomainEventMigrationIterationDispose(void *obj);
 
 static void
 virDomainEventDispatchDefaultFunc(virConnectPtr conn,
@@ -236,6 +238,14 @@ struct _virDomainEventAgentLifecycle {
 typedef struct _virDomainEventAgentLifecycle virDomainEventAgentLifecycle;
 typedef virDomainEventAgentLifecycle *virDomainEventAgentLifecyclePtr;
 
+struct _virDomainEventMigrationIteration {
+    virDomainEvent parent;
+
+    int iteration;
+};
+typedef struct _virDomainEventMigrationIteration virDomainEventMigrationIteration;
+typedef virDomainEventMigrationIteration *virDomainEventMigrationIterationPtr;
+
 
 static int
 virDomainEventsOnceInit(void)
@@ -336,6 +346,12 @@ virDomainEventsOnceInit(void)
                       sizeof(virDomainEventAgentLifecycle),
                       virDomainEventAgentLifecycleDispose)))
         return -1;
+    if (!(virDomainEventMigrationIterationClass =
+          virClassNew(virDomainEventClass,
+                      "virDomainEventMigrationIteration",
+                      sizeof(virDomainEventMigrationIteration),
+                      virDomainEventMigrationIterationDispose)))
+        return -1;
     return 0;
 }
 
@@ -496,6 +512,13 @@ virDomainEventAgentLifecycleDispose(void *obj)
     VIR_DEBUG("obj=%p", event);
 };
 
+static void
+virDomainEventMigrationIterationDispose(void *obj)
+{
+    virDomainEventMigrationIterationPtr event = obj;
+    VIR_DEBUG("obj=%p", event);
+};
+
 
 static void *
 virDomainEventNew(virClassPtr klass,
@@ -1334,6 +1357,43 @@ virDomainEventAgentLifecycleNewFromDom(virDomainPtr dom,
                                            state, reason);
 }
 
+static virObjectEventPtr
+virDomainEventMigrationIterationNew(int id,
+                                    const char *name,
+                                    const unsigned char *uuid,
+                                    int iteration)
+{
+    virDomainEventMigrationIterationPtr ev;
+
+    if (virDomainEventsInitialize() < 0)
+        return NULL;
+
+    if (!(ev = virDomainEventNew(virDomainEventMigrationIterationClass,
+                                 VIR_DOMAIN_EVENT_ID_MIGRATION_ITERATION,
+                                 id, name, uuid)))
+        return NULL;
+
+    ev->iteration = iteration;
+
+    return (virObjectEventPtr)ev;
+}
+
+virObjectEventPtr
+virDomainEventMigrationIterationNewFromObj(virDomainObjPtr obj,
+                                           int iteration)
+{
+    return virDomainEventMigrationIterationNew(obj->def->id, obj->def->name,
+                                               obj->def->uuid, iteration);
+}
+
+virObjectEventPtr
+virDomainEventMigrationIterationNewFromDom(virDomainPtr dom,
+                                           int iteration)
+{
+    return virDomainEventMigrationIterationNew(dom->id, dom->name, dom->uuid,
+                                               iteration);
+}
+
 
 /* This function consumes the params so caller don't have to care about
  * freeing it even if error occurs. The reason is to not have to do deep
@@ -1614,6 +1674,17 @@ virDomainEventDispatchDefaultFunc(virConnectPtr conn,
             goto cleanup;
         }
 
+    case VIR_DOMAIN_EVENT_ID_MIGRATION_ITERATION:
+        {
+            virDomainEventMigrationIterationPtr ev;
+
+            ev = (virDomainEventMigrationIterationPtr) event;
+            ((virConnectDomainEventMigrationIterationCallback)cb)(conn, dom,
+                                                                  ev->iteration,
+                                                                  cbopaque);
+            goto cleanup;
+        }
+
     case VIR_DOMAIN_EVENT_ID_LAST:
         break;
     }

diff --git a/src/conf/domain_event.h b/src/conf/domain_event.h
index afbed89616a3f5b89976737668d3c0e10fb7bc6b..b7cddb5a509b07a7433b1033ddbc983f3d027c18 100644 (file)
--- a/src/conf/domain_event.h
+++ b/src/conf/domain_event.h
@@ -209,6 +209,14 @@ virDomainEventAgentLifecycleNewFromDom(virDomainPtr dom,
                                        int state,
                                        int reason);
 
+virObjectEventPtr
+virDomainEventMigrationIterationNewFromObj(virDomainObjPtr obj,
+                                           int iteration);
+
+virObjectEventPtr
+virDomainEventMigrationIterationNewFromDom(virDomainPtr dom,
+                                           int iteration);
+
 int
 virDomainEventStateRegister(virConnectPtr conn,
                             virObjectEventStatePtr state,

diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms
index 83f6e2ca7bc6bf10a504b1bfe9e39d931efd19b9..5e05a98b81cd5146a9583a036f66b9fc13b51beb 100644 (file)
--- a/src/libvirt_private.syms
+++ b/src/libvirt_private.syms
@@ -514,6 +514,8 @@ virDomainEventLifecycleNew;
 virDomainEventLifecycleNewFromDef;
 virDomainEventLifecycleNewFromDom;
 virDomainEventLifecycleNewFromObj;
+virDomainEventMigrationIterationNewFromDom;
+virDomainEventMigrationIterationNewFromObj;
 virDomainEventPMSuspendDiskNewFromDom;
 virDomainEventPMSuspendDiskNewFromObj;
 virDomainEventPMSuspendNewFromDom;

diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c
index a1dd64087b3bca2178d8c81d39ca1add566702b0..d9d7ec8ece34a2caab82bfc374cc871716f6142d 100644 (file)
--- a/src/remote/remote_driver.c
+++ b/src/remote/remote_driver.c
@@ -341,6 +341,11 @@ remoteDomainBuildEventCallbackAgentLifecycle(virNetClientProgramPtr prog,
                                              virNetClientPtr client,
                                              void *evdata, void *opaque);
 
+static void
+remoteDomainBuildEventCallbackMigrationIteration(virNetClientProgramPtr prog,
+                                                 virNetClientPtr client,
+                                                 void *evdata, void *opaque);
+
 static void
 remoteNetworkBuildEventLifecycle(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
                                  virNetClientPtr client ATTRIBUTE_UNUSED,
@@ -504,6 +509,10 @@ static virNetClientProgramEvent remoteEvents[] = {
       remoteDomainBuildEventCallbackDeviceAdded,
       sizeof(remote_domain_event_callback_device_added_msg),
       (xdrproc_t)xdr_remote_domain_event_callback_device_added_msg },
+    { REMOTE_PROC_DOMAIN_EVENT_CALLBACK_MIGRATION_ITERATION,
+      remoteDomainBuildEventCallbackMigrationIteration,
+      sizeof(remote_domain_event_callback_migration_iteration_msg),
+      (xdrproc_t)xdr_remote_domain_event_callback_migration_iteration_msg },
 };
 
 
@@ -5513,6 +5522,30 @@ remoteDomainBuildEventCallbackAgentLifecycle(virNetClientProgramPtr prog ATTRIBU
     remoteEventQueue(priv, event, msg->callbackID);
 }
 
+
+static void
+remoteDomainBuildEventCallbackMigrationIteration(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
+                                                 virNetClientPtr client ATTRIBUTE_UNUSED,
+                                                 void *evdata,
+                                                 void *opaque)
+{
+    virConnectPtr conn = opaque;
+    remote_domain_event_callback_migration_iteration_msg *msg = evdata;
+    struct private_data *priv = conn->privateData;
+    virDomainPtr dom;
+    virObjectEventPtr event = NULL;
+
+    if (!(dom = get_nonnull_domain(conn, msg->dom)))
+        return;
+
+    event = virDomainEventMigrationIterationNewFromDom(dom, msg->iteration);
+
+    virObjectUnref(dom);
+
+    remoteEventQueue(priv, event, msg->callbackID);
+}
+
+
 static void
 remoteNetworkBuildEventLifecycle(virNetClientProgramPtr prog ATTRIBUTE_UNUSED,
                                  virNetClientPtr client ATTRIBUTE_UNUSED,

diff --git a/src/remote/remote_protocol.x b/src/remote/remote_protocol.x
index 9f131f87fbb0039da9133376b9937f3a3ab2d3f1..bfdbce729fb7b1adcdce7273f23f2e6d2360e4a7 100644 (file)
--- a/src/remote/remote_protocol.x
+++ b/src/remote/remote_protocol.x
@@ -3222,6 +3222,12 @@ struct remote_domain_rename_ret {
     int retcode;
 };
 
+struct remote_domain_event_callback_migration_iteration_msg {
+    int callbackID;
+    remote_nonnull_domain dom;
+    int iteration;
+};
+
 /*----- Protocol. -----*/
 
 /* Define the program number, protocol version and procedure numbers here. */
@@ -5694,5 +5700,11 @@ enum remote_procedure {
      * @acl: domain:write
      * @acl: domain:save
      */
-    REMOTE_PROC_DOMAIN_RENAME = 358
+    REMOTE_PROC_DOMAIN_RENAME = 358,
+
+    /**
+     * @generate: both
+     * @acl: none
+     */
+    REMOTE_PROC_DOMAIN_EVENT_CALLBACK_MIGRATION_ITERATION = 359
 };

diff --git a/src/remote_protocol-structs b/src/remote_protocol-structs
index ff99c00969418d99ec7cced9adeeda87f4d26155..dff54e85a0ed7942a2be8080f725881c62ce0d85 100644 (file)
--- a/src/remote_protocol-structs
+++ b/src/remote_protocol-structs
@@ -2692,6 +2692,11 @@ struct remote_domain_rename_args {
 struct remote_domain_rename_ret {
         int                        retcode;
 };
+struct remote_domain_event_callback_migration_iteration_msg {
+        int                        callbackID;
+        remote_nonnull_domain      dom;
+        int                        iteration;
+};
 enum remote_procedure {
         REMOTE_PROC_CONNECT_OPEN = 1,
         REMOTE_PROC_CONNECT_CLOSE = 2,
@@ -3051,4 +3056,5 @@ enum remote_procedure {
         REMOTE_PROC_DOMAIN_DEL_IOTHREAD = 356,
         REMOTE_PROC_DOMAIN_SET_USER_PASSWORD = 357,
         REMOTE_PROC_DOMAIN_RENAME = 358,
+        REMOTE_PROC_DOMAIN_EVENT_CALLBACK_MIGRATION_ITERATION = 359,
 };

diff --git a/tools/virsh-domain.c b/tools/virsh-domain.c
index 62acecb17f1c8be2001de6eb3ddeca184b0a980f..828ba4201e646fac50ad06c40afd9acded38df9a 100644 (file)
--- a/tools/virsh-domain.c
+++ b/tools/virsh-domain.c
@@ -11924,6 +11924,22 @@ virshEventAgentLifecyclePrint(virConnectPtr conn ATTRIBUTE_UNUSED,
     virshEventPrint(opaque, &buf);
 }
 
+static void
+virshEventMigrationIterationPrint(virConnectPtr conn ATTRIBUTE_UNUSED,
+                                  virDomainPtr dom,
+                                  int iteration,
+                                  void *opaque)
+{
+    virBuffer buf = VIR_BUFFER_INITIALIZER;
+
+    virBufferAsprintf(&buf, _("event 'migration-iteration' for domain %s: "
+                              "iteration: '%d'\n"),
+                      virDomainGetName(dom),
+                      iteration);
+
+    virshEventPrint(opaque, &buf);
+}
+
 static vshEventCallback vshEventCallbacks[] = {
     { "lifecycle",
       VIR_DOMAIN_EVENT_CALLBACK(virshEventLifecyclePrint), },
@@ -11963,6 +11979,8 @@ static vshEventCallback vshEventCallbacks[] = {
       VIR_DOMAIN_EVENT_CALLBACK(virshEventAgentLifecyclePrint), },
     { "device-added",
       VIR_DOMAIN_EVENT_CALLBACK(virshEventDeviceAddedPrint), },
+    { "migration-iteration",
+      VIR_DOMAIN_EVENT_CALLBACK(virshEventMigrationIterationPrint), },
 };
 verify(VIR_DOMAIN_EVENT_ID_LAST == ARRAY_CARDINALITY(vshEventCallbacks));