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

[libvirt] [PATCH 01/19] qemu: Separate job related data into a new object



---
 src/qemu/qemu_domain.c    |  104 +++++++++++++++++++++++++------------
 src/qemu/qemu_domain.h    |   25 +++++++---
 src/qemu/qemu_driver.c    |   82 +++++++++++++++---------------
 src/qemu/qemu_migration.c |  123 ++++++++++++++++++++++-----------------------
 src/qemu/qemu_process.c   |    5 +-
 5 files changed, 192 insertions(+), 147 deletions(-)

diff --git a/src/qemu/qemu_domain.c b/src/qemu/qemu_domain.c
index 4b65d87..bbdfdc4 100644
--- a/src/qemu/qemu_domain.c
+++ b/src/qemu/qemu_domain.c
@@ -79,6 +79,42 @@ void qemuDomainEventQueue(struct qemud_driver *driver,
 }
 
 
+static int
+qemuDomainObjInitJob(qemuDomainObjPrivatePtr priv)
+{
+    memset(&priv->job, 0, sizeof(priv->job));
+
+    if (virCondInit(&priv->job.cond) < 0)
+        return -1;
+
+    if (virCondInit(&priv->job.signalCond) < 0) {
+        ignore_value(virCondDestroy(&priv->job.cond));
+        return -1;
+    }
+
+    return 0;
+}
+
+static void
+qemuDomainObjResetJob(qemuDomainObjPrivatePtr priv)
+{
+    struct qemuDomainJobObj *job = &priv->job;
+
+    job->active = QEMU_JOB_NONE;
+    job->start = 0;
+    memset(&job->info, 0, sizeof(job->info));
+    job->signals = 0;
+    memset(&job->signalsData, 0, sizeof(job->signalsData));
+}
+
+static void
+qemuDomainObjFreeJob(qemuDomainObjPrivatePtr priv)
+{
+    ignore_value(virCondDestroy(&priv->job.cond));
+    ignore_value(virCondDestroy(&priv->job.signalCond));
+}
+
+
 static void *qemuDomainObjPrivateAlloc(void)
 {
     qemuDomainObjPrivatePtr priv;
@@ -86,19 +122,10 @@ static void *qemuDomainObjPrivateAlloc(void)
     if (VIR_ALLOC(priv) < 0)
         return NULL;
 
-    if (virCondInit(&priv->jobCond) < 0)
-        goto initfail;
-
-    if (virCondInit(&priv->signalCond) < 0) {
-        ignore_value(virCondDestroy(&priv->jobCond));
-        goto initfail;
-    }
+    if (qemuDomainObjInitJob(priv) < 0)
+        VIR_FREE(priv);
 
     return priv;
-
-initfail:
-    VIR_FREE(priv);
-    return NULL;
 }
 
 static void qemuDomainObjPrivateFree(void *data)
@@ -109,9 +136,8 @@ static void qemuDomainObjPrivateFree(void *data)
 
     qemuDomainPCIAddressSetFree(priv->pciaddrs);
     virDomainChrSourceDefFree(priv->monConfig);
+    qemuDomainObjFreeJob(priv);
     VIR_FREE(priv->vcpupids);
-    ignore_value(virCondDestroy(&priv->jobCond));
-    ignore_value(virCondDestroy(&priv->signalCond));
     VIR_FREE(priv->lockState);
 
     /* This should never be non-NULL if we get here, but just in case... */
@@ -473,6 +499,24 @@ void qemuDomainSetNamespaceHooks(virCapsPtr caps)
     caps->ns.href = qemuDomainDefNamespaceHref;
 }
 
+void
+qemuDomainObjSetJob(virDomainObjPtr obj,
+                    enum qemuDomainJob job)
+{
+    qemuDomainObjPrivatePtr priv = obj->privateData;
+
+    priv->job.active = job;
+}
+
+void
+qemuDomainObjDiscardJob(virDomainObjPtr obj)
+{
+    qemuDomainObjPrivatePtr priv = obj->privateData;
+
+    qemuDomainObjResetJob(priv);
+    qemuDomainObjSetJob(obj, QEMU_JOB_NONE);
+}
+
 /*
  * obj must be locked before calling, qemud_driver must NOT be locked
  *
@@ -498,8 +542,8 @@ int qemuDomainObjBeginJob(virDomainObjPtr obj)
 
     virDomainObjRef(obj);
 
-    while (priv->jobActive) {
-        if (virCondWaitUntil(&priv->jobCond, &obj->lock, then) < 0) {
+    while (priv->job.active) {
+        if (virCondWaitUntil(&priv->job.cond, &obj->lock, then) < 0) {
             /* Safe to ignore value since ref count was incremented above */
             ignore_value(virDomainObjUnref(obj));
             if (errno == ETIMEDOUT)
@@ -511,11 +555,9 @@ int qemuDomainObjBeginJob(virDomainObjPtr obj)
             return -1;
         }
     }
-    priv->jobActive = QEMU_JOB_UNSPECIFIED;
-    priv->jobSignals = 0;
-    memset(&priv->jobSignalsData, 0, sizeof(priv->jobSignalsData));
-    priv->jobStart = now;
-    memset(&priv->jobInfo, 0, sizeof(priv->jobInfo));
+    qemuDomainObjResetJob(priv);
+    qemuDomainObjSetJob(obj, QEMU_JOB_UNSPECIFIED);
+    priv->job.start = now;
 
     return 0;
 }
@@ -540,8 +582,8 @@ int qemuDomainObjBeginJobWithDriver(struct qemud_driver *driver,
     virDomainObjRef(obj);
     qemuDriverUnlock(driver);
 
-    while (priv->jobActive) {
-        if (virCondWaitUntil(&priv->jobCond, &obj->lock, then) < 0) {
+    while (priv->job.active) {
+        if (virCondWaitUntil(&priv->job.cond, &obj->lock, then) < 0) {
             if (errno == ETIMEDOUT)
                 qemuReportError(VIR_ERR_OPERATION_TIMEOUT,
                                 "%s", _("cannot acquire state change lock"));
@@ -556,11 +598,9 @@ int qemuDomainObjBeginJobWithDriver(struct qemud_driver *driver,
             return -1;
         }
     }
-    priv->jobActive = QEMU_JOB_UNSPECIFIED;
-    priv->jobSignals = 0;
-    memset(&priv->jobSignalsData, 0, sizeof(priv->jobSignalsData));
-    priv->jobStart = now;
-    memset(&priv->jobInfo, 0, sizeof(priv->jobInfo));
+    qemuDomainObjResetJob(priv);
+    qemuDomainObjSetJob(obj, QEMU_JOB_UNSPECIFIED);
+    priv->job.start = now;
 
     virDomainObjUnlock(obj);
     qemuDriverLock(driver);
@@ -582,17 +622,13 @@ int qemuDomainObjEndJob(virDomainObjPtr obj)
 {
     qemuDomainObjPrivatePtr priv = obj->privateData;
 
-    priv->jobActive = QEMU_JOB_NONE;
-    priv->jobSignals = 0;
-    memset(&priv->jobSignalsData, 0, sizeof(priv->jobSignalsData));
-    priv->jobStart = 0;
-    memset(&priv->jobInfo, 0, sizeof(priv->jobInfo));
-    virCondSignal(&priv->jobCond);
+    qemuDomainObjResetJob(priv);
+    qemuDomainObjSetJob(obj, QEMU_JOB_NONE);
+    virCondSignal(&priv->job.cond);
 
     return virDomainObjUnref(obj);
 }
 
-
 /*
  * obj must be locked before calling, qemud_driver must be unlocked
  *
diff --git a/src/qemu/qemu_domain.h b/src/qemu/qemu_domain.h
index f282df2..214e578 100644
--- a/src/qemu/qemu_domain.h
+++ b/src/qemu/qemu_domain.h
@@ -62,19 +62,26 @@ struct qemuDomainJobSignalsData {
     int *infoRetCode; /* Return code for the blkinfo calls */
 };
 
+struct qemuDomainJobObj {
+    virCond cond;       /* Use in conjunction with main virDomainObjPtr lock */
+    virCond signalCond; /* Use to coordinate the safe queries during migration */
+
+    enum qemuDomainJob active;  /* Currently running job */
+
+    unsigned long long start;   /* When the job started */
+    virDomainJobInfo info;      /* Progress data */
+
+    unsigned int signals;       /* Signals for running job */
+    struct qemuDomainJobSignalsData signalsData;    /* Signal specific data */
+};
+
 typedef struct _qemuDomainPCIAddressSet qemuDomainPCIAddressSet;
 typedef qemuDomainPCIAddressSet *qemuDomainPCIAddressSetPtr;
 
 typedef struct _qemuDomainObjPrivate qemuDomainObjPrivate;
 typedef qemuDomainObjPrivate *qemuDomainObjPrivatePtr;
 struct _qemuDomainObjPrivate {
-    virCond jobCond; /* Use in conjunction with main virDomainObjPtr lock */
-    virCond signalCond; /* Use to coordinate the safe queries during migration */
-    enum qemuDomainJob jobActive;   /* Currently running job */
-    unsigned int jobSignals;        /* Signals for running job */
-    struct qemuDomainJobSignalsData jobSignalsData; /* Signal specific data */
-    virDomainJobInfo jobInfo;
-    unsigned long long jobStart;
+    struct qemuDomainJobObj job;
 
     qemuMonitorPtr mon;
     virDomainChrSourceDefPtr monConfig;
@@ -114,6 +121,10 @@ int qemuDomainObjBeginJob(virDomainObjPtr obj) ATTRIBUTE_RETURN_CHECK;
 int qemuDomainObjBeginJobWithDriver(struct qemud_driver *driver,
                                     virDomainObjPtr obj) ATTRIBUTE_RETURN_CHECK;
 int qemuDomainObjEndJob(virDomainObjPtr obj) ATTRIBUTE_RETURN_CHECK;
+
+void qemuDomainObjSetJob(virDomainObjPtr obj, enum qemuDomainJob job);
+void qemuDomainObjDiscardJob(virDomainObjPtr obj);
+
 void qemuDomainObjEnterMonitor(virDomainObjPtr obj);
 void qemuDomainObjExitMonitor(virDomainObjPtr obj);
 void qemuDomainObjEnterMonitorWithDriver(struct qemud_driver *driver,
diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c
index 52b7dfd..e9cdcbe 100644
--- a/src/qemu/qemu_driver.c
+++ b/src/qemu/qemu_driver.c
@@ -1343,11 +1343,11 @@ static int qemudDomainSuspend(virDomainPtr dom) {
 
     priv = vm->privateData;
 
-    if (priv->jobActive == QEMU_JOB_MIGRATION_OUT) {
+    if (priv->job.active == QEMU_JOB_MIGRATION_OUT) {
         if (virDomainObjGetState(vm, NULL) != VIR_DOMAIN_PAUSED) {
             VIR_DEBUG("Requesting domain pause on %s",
                       vm->def->name);
-            priv->jobSignals |= QEMU_JOB_SIGNAL_SUSPEND;
+            priv->job.signals |= QEMU_JOB_SIGNAL_SUSPEND;
         }
         ret = 0;
         goto cleanup;
@@ -1878,7 +1878,7 @@ static int qemudDomainGetInfo(virDomainPtr dom,
         if ((vm->def->memballoon != NULL) &&
             (vm->def->memballoon->model == VIR_DOMAIN_MEMBALLOON_MODEL_NONE)) {
             info->memory = vm->def->mem.max_balloon;
-        } else if (!priv->jobActive) {
+        } else if (!priv->job.active) {
             if (qemuDomainObjBeginJob(vm) < 0)
                 goto cleanup;
             if (!virDomainObjIsActive(vm))
@@ -1985,12 +1985,12 @@ qemuDomainGetControlInfo(virDomainPtr dom,
 
     if (priv->monError) {
         info->state = VIR_DOMAIN_CONTROL_ERROR;
-    } else if (priv->jobActive) {
+    } else if (priv->job.active) {
         if (!priv->monStart) {
             info->state = VIR_DOMAIN_CONTROL_JOB;
             if (virTimeMs(&info->stateTime) < 0)
                 goto cleanup;
-            info->stateTime -= priv->jobStart;
+            info->stateTime -= priv->job.start;
         } else {
             info->state = VIR_DOMAIN_CONTROL_OCCUPIED;
             if (virTimeMs(&info->stateTime) < 0)
@@ -2125,10 +2125,10 @@ static int qemudDomainSaveFlag(struct qemud_driver *driver, virDomainPtr dom,
     if (qemuDomainObjBeginJobWithDriver(driver, vm) < 0)
         goto cleanup;
 
-    priv->jobActive = QEMU_JOB_SAVE;
+    qemuDomainObjSetJob(vm, QEMU_JOB_SAVE);
 
-    memset(&priv->jobInfo, 0, sizeof(priv->jobInfo));
-    priv->jobInfo.type = VIR_DOMAIN_JOB_UNBOUNDED;
+    memset(&priv->job.info, 0, sizeof(priv->job.info));
+    priv->job.info.type = VIR_DOMAIN_JOB_UNBOUNDED;
 
     /* Pause */
     if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING) {
@@ -2617,7 +2617,7 @@ static int qemudDomainCoreDump(virDomainPtr dom,
         goto endjob;
     }
 
-    priv->jobActive = QEMU_JOB_DUMP;
+    qemuDomainObjSetJob(vm, QEMU_JOB_DUMP);
 
     /* Migrate will always stop the VM, so the resume condition is
        independent of whether the stop command is issued.  */
@@ -3847,7 +3847,7 @@ static char *qemuDomainGetXMLDesc(virDomainPtr dom,
         qemuDomainObjPrivatePtr priv = vm->privateData;
         /* Don't delay if someone's using the monitor, just use
          * existing most recent data instead */
-        if (!priv->jobActive) {
+        if (!priv->job.active) {
             if (qemuDomainObjBeginJobWithDriver(driver, vm) < 0)
                 goto cleanup;
 
@@ -6006,19 +6006,19 @@ qemudDomainBlockStats (virDomainPtr dom,
     }
 
     priv = vm->privateData;
-    if ((priv->jobActive == QEMU_JOB_MIGRATION_OUT)
-        || (priv->jobActive == QEMU_JOB_SAVE)) {
+    if ((priv->job.active == QEMU_JOB_MIGRATION_OUT)
+        || (priv->job.active == QEMU_JOB_SAVE)) {
         virDomainObjRef(vm);
-        while (priv->jobSignals & QEMU_JOB_SIGNAL_BLKSTAT)
-            ignore_value(virCondWait(&priv->signalCond, &vm->lock));
+        while (priv->job.signals & QEMU_JOB_SIGNAL_BLKSTAT)
+            ignore_value(virCondWait(&priv->job.signalCond, &vm->lock));
 
-        priv->jobSignalsData.statDevName = disk->info.alias;
-        priv->jobSignalsData.blockStat = stats;
-        priv->jobSignalsData.statRetCode = &ret;
-        priv->jobSignals |= QEMU_JOB_SIGNAL_BLKSTAT;
+        priv->job.signalsData.statDevName = disk->info.alias;
+        priv->job.signalsData.blockStat = stats;
+        priv->job.signalsData.statRetCode = &ret;
+        priv->job.signals |= QEMU_JOB_SIGNAL_BLKSTAT;
 
-        while (priv->jobSignals & QEMU_JOB_SIGNAL_BLKSTAT)
-            ignore_value(virCondWait(&priv->signalCond, &vm->lock));
+        while (priv->job.signals & QEMU_JOB_SIGNAL_BLKSTAT)
+            ignore_value(virCondWait(&priv->job.signalCond, &vm->lock));
 
         if (virDomainObjUnref(vm) == 0)
             vm = NULL;
@@ -6453,19 +6453,19 @@ static int qemuDomainGetBlockInfo(virDomainPtr dom,
         virDomainObjIsActive(vm)) {
         qemuDomainObjPrivatePtr priv = vm->privateData;
 
-        if ((priv->jobActive == QEMU_JOB_MIGRATION_OUT)
-            || (priv->jobActive == QEMU_JOB_SAVE)) {
+        if ((priv->job.active == QEMU_JOB_MIGRATION_OUT)
+            || (priv->job.active == QEMU_JOB_SAVE)) {
             virDomainObjRef(vm);
-            while (priv->jobSignals & QEMU_JOB_SIGNAL_BLKINFO)
-                ignore_value(virCondWait(&priv->signalCond, &vm->lock));
+            while (priv->job.signals & QEMU_JOB_SIGNAL_BLKINFO)
+                ignore_value(virCondWait(&priv->job.signalCond, &vm->lock));
 
-            priv->jobSignalsData.infoDevName = disk->info.alias;
-            priv->jobSignalsData.blockInfo = info;
-            priv->jobSignalsData.infoRetCode = &ret;
-            priv->jobSignals |= QEMU_JOB_SIGNAL_BLKINFO;
+            priv->job.signalsData.infoDevName = disk->info.alias;
+            priv->job.signalsData.blockInfo = info;
+            priv->job.signalsData.infoRetCode = &ret;
+            priv->job.signals |= QEMU_JOB_SIGNAL_BLKINFO;
 
-            while (priv->jobSignals & QEMU_JOB_SIGNAL_BLKINFO)
-                ignore_value(virCondWait(&priv->signalCond, &vm->lock));
+            while (priv->job.signals & QEMU_JOB_SIGNAL_BLKINFO)
+                ignore_value(virCondWait(&priv->job.signalCond, &vm->lock));
 
             if (virDomainObjUnref(vm) == 0)
                 vm = NULL;
@@ -7293,8 +7293,8 @@ static int qemuDomainGetJobInfo(virDomainPtr dom,
     priv = vm->privateData;
 
     if (virDomainObjIsActive(vm)) {
-        if (priv->jobActive) {
-            memcpy(info, &priv->jobInfo, sizeof(*info));
+        if (priv->job.active) {
+            memcpy(info, &priv->job.info, sizeof(*info));
 
             /* Refresh elapsed time again just to ensure it
              * is fully updated. This is primarily for benefit
@@ -7303,7 +7303,7 @@ static int qemuDomainGetJobInfo(virDomainPtr dom,
              */
             if (virTimeMs(&info->timeElapsed) < 0)
                 goto cleanup;
-            info->timeElapsed -= priv->jobStart;
+            info->timeElapsed -= priv->job.start;
         } else {
             memset(info, 0, sizeof(*info));
             info->type = VIR_DOMAIN_JOB_NONE;
@@ -7343,9 +7343,9 @@ static int qemuDomainAbortJob(virDomainPtr dom) {
     priv = vm->privateData;
 
     if (virDomainObjIsActive(vm)) {
-        if (priv->jobActive) {
+        if (priv->job.active) {
             VIR_DEBUG("Requesting cancellation of job on vm %s", vm->def->name);
-            priv->jobSignals |= QEMU_JOB_SIGNAL_CANCEL;
+            priv->job.signals |= QEMU_JOB_SIGNAL_CANCEL;
         } else {
             qemuReportError(VIR_ERR_OPERATION_INVALID,
                             "%s", _("no job is active on the domain"));
@@ -7397,15 +7397,15 @@ qemuDomainMigrateSetMaxDowntime(virDomainPtr dom,
 
     priv = vm->privateData;
 
-    if (priv->jobActive != QEMU_JOB_MIGRATION_OUT) {
+    if (priv->job.active != QEMU_JOB_MIGRATION_OUT) {
         qemuReportError(VIR_ERR_OPERATION_INVALID,
                         "%s", _("domain is not being migrated"));
         goto cleanup;
     }
 
     VIR_DEBUG("Requesting migration downtime change to %llums", downtime);
-    priv->jobSignalsData.migrateDowntime = downtime;
-    priv->jobSignals |= QEMU_JOB_SIGNAL_MIGRATE_DOWNTIME;
+    priv->job.signalsData.migrateDowntime = downtime;
+    priv->job.signals |= QEMU_JOB_SIGNAL_MIGRATE_DOWNTIME;
     ret = 0;
 
 cleanup:
@@ -7446,15 +7446,15 @@ qemuDomainMigrateSetMaxSpeed(virDomainPtr dom,
 
     priv = vm->privateData;
 
-    if (priv->jobActive != QEMU_JOB_MIGRATION_OUT) {
+    if (priv->job.active != QEMU_JOB_MIGRATION_OUT) {
         qemuReportError(VIR_ERR_OPERATION_INVALID,
                         "%s", _("domain is not being migrated"));
         goto cleanup;
     }
 
     VIR_DEBUG("Requesting migration speed change to %luMbs", bandwidth);
-    priv->jobSignalsData.migrateBandwidth = bandwidth;
-    priv->jobSignals |= QEMU_JOB_SIGNAL_MIGRATE_SPEED;
+    priv->job.signalsData.migrateBandwidth = bandwidth;
+    priv->job.signals |= QEMU_JOB_SIGNAL_MIGRATE_SPEED;
     ret = 0;
 
 cleanup:
diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c
index d7b27a0..3634966 100644
--- a/src/qemu/qemu_migration.c
+++ b/src/qemu/qemu_migration.c
@@ -742,12 +742,12 @@ qemuMigrationProcessJobSignals(struct qemud_driver *driver,
         qemuReportError(VIR_ERR_INTERNAL_ERROR, _("%s: %s"),
                         job, _("guest unexpectedly quit"));
         if (cleanup)
-            priv->jobSignals = 0;
+            priv->job.signals = 0;
         return -1;
     }
 
-    if (priv->jobSignals & QEMU_JOB_SIGNAL_CANCEL) {
-        priv->jobSignals ^= QEMU_JOB_SIGNAL_CANCEL;
+    if (priv->job.signals & QEMU_JOB_SIGNAL_CANCEL) {
+        priv->job.signals ^= QEMU_JOB_SIGNAL_CANCEL;
         VIR_DEBUG("Cancelling job at client request");
         qemuDomainObjEnterMonitorWithDriver(driver, vm);
         ret = qemuMonitorMigrateCancel(priv->mon);
@@ -755,58 +755,58 @@ qemuMigrationProcessJobSignals(struct qemud_driver *driver,
         if (ret < 0) {
             VIR_WARN("Unable to cancel job");
         }
-    } else if (priv->jobSignals & QEMU_JOB_SIGNAL_SUSPEND) {
-        priv->jobSignals ^= QEMU_JOB_SIGNAL_SUSPEND;
+    } else if (priv->job.signals & QEMU_JOB_SIGNAL_SUSPEND) {
+        priv->job.signals ^= QEMU_JOB_SIGNAL_SUSPEND;
         VIR_DEBUG("Pausing domain for non-live migration");
         if (qemuMigrationSetOffline(driver, vm) < 0)
             VIR_WARN("Unable to pause domain");
-    } else if (priv->jobSignals & QEMU_JOB_SIGNAL_MIGRATE_DOWNTIME) {
-        unsigned long long ms = priv->jobSignalsData.migrateDowntime;
+    } else if (priv->job.signals & QEMU_JOB_SIGNAL_MIGRATE_DOWNTIME) {
+        unsigned long long ms = priv->job.signalsData.migrateDowntime;
 
-        priv->jobSignals ^= QEMU_JOB_SIGNAL_MIGRATE_DOWNTIME;
-        priv->jobSignalsData.migrateDowntime = 0;
+        priv->job.signals ^= QEMU_JOB_SIGNAL_MIGRATE_DOWNTIME;
+        priv->job.signalsData.migrateDowntime = 0;
         VIR_DEBUG("Setting migration downtime to %llums", ms);
         qemuDomainObjEnterMonitorWithDriver(driver, vm);
         ret = qemuMonitorSetMigrationDowntime(priv->mon, ms);
         qemuDomainObjExitMonitorWithDriver(driver, vm);
         if (ret < 0)
             VIR_WARN("Unable to set migration downtime");
-    } else if (priv->jobSignals & QEMU_JOB_SIGNAL_MIGRATE_SPEED) {
-        unsigned long bandwidth = priv->jobSignalsData.migrateBandwidth;
+    } else if (priv->job.signals & QEMU_JOB_SIGNAL_MIGRATE_SPEED) {
+        unsigned long bandwidth = priv->job.signalsData.migrateBandwidth;
 
-        priv->jobSignals ^= QEMU_JOB_SIGNAL_MIGRATE_SPEED;
-        priv->jobSignalsData.migrateBandwidth = 0;
+        priv->job.signals ^= QEMU_JOB_SIGNAL_MIGRATE_SPEED;
+        priv->job.signalsData.migrateBandwidth = 0;
         VIR_DEBUG("Setting migration bandwidth to %luMbs", bandwidth);
         qemuDomainObjEnterMonitorWithDriver(driver, vm);
         ret = qemuMonitorSetMigrationSpeed(priv->mon, bandwidth);
         qemuDomainObjExitMonitorWithDriver(driver, vm);
         if (ret < 0)
             VIR_WARN("Unable to set migration speed");
-    } else if (priv->jobSignals & QEMU_JOB_SIGNAL_BLKSTAT) {
+    } else if (priv->job.signals & QEMU_JOB_SIGNAL_BLKSTAT) {
         qemuDomainObjEnterMonitorWithDriver(driver, vm);
         ret = qemuMonitorGetBlockStatsInfo(priv->mon,
-                              priv->jobSignalsData.statDevName,
-                              &priv->jobSignalsData.blockStat->rd_req,
-                              &priv->jobSignalsData.blockStat->rd_bytes,
-                              &priv->jobSignalsData.blockStat->wr_req,
-                              &priv->jobSignalsData.blockStat->wr_bytes,
-                              &priv->jobSignalsData.blockStat->errs);
+                              priv->job.signalsData.statDevName,
+                              &priv->job.signalsData.blockStat->rd_req,
+                              &priv->job.signalsData.blockStat->rd_bytes,
+                              &priv->job.signalsData.blockStat->wr_req,
+                              &priv->job.signalsData.blockStat->wr_bytes,
+                              &priv->job.signalsData.blockStat->errs);
         qemuDomainObjExitMonitorWithDriver(driver, vm);
 
-        *priv->jobSignalsData.statRetCode = ret;
-        priv->jobSignals ^= QEMU_JOB_SIGNAL_BLKSTAT;
+        *priv->job.signalsData.statRetCode = ret;
+        priv->job.signals ^= QEMU_JOB_SIGNAL_BLKSTAT;
 
         if (ret < 0)
             VIR_WARN("Unable to get block statistics");
-    } else if (priv->jobSignals & QEMU_JOB_SIGNAL_BLKINFO) {
+    } else if (priv->job.signals & QEMU_JOB_SIGNAL_BLKINFO) {
         qemuDomainObjEnterMonitorWithDriver(driver, vm);
         ret = qemuMonitorGetBlockExtent(priv->mon,
-                           priv->jobSignalsData.infoDevName,
-                           &priv->jobSignalsData.blockInfo->allocation);
+                           priv->job.signalsData.infoDevName,
+                           &priv->job.signalsData.blockInfo->allocation);
         qemuDomainObjExitMonitorWithDriver(driver, vm);
 
-        *priv->jobSignalsData.infoRetCode = ret;
-        priv->jobSignals ^= QEMU_JOB_SIGNAL_BLKINFO;
+        *priv->job.signalsData.infoRetCode = ret;
+        priv->job.signals ^= QEMU_JOB_SIGNAL_BLKINFO;
 
         if (ret < 0)
             VIR_WARN("Unable to get block information");
@@ -844,44 +844,44 @@ qemuMigrationUpdateJobStatus(struct qemud_driver *driver,
                                         &memTotal);
     qemuDomainObjExitMonitorWithDriver(driver, vm);
 
-    if (ret < 0 || virTimeMs(&priv->jobInfo.timeElapsed) < 0) {
-        priv->jobInfo.type = VIR_DOMAIN_JOB_FAILED;
+    if (ret < 0 || virTimeMs(&priv->job.info.timeElapsed) < 0) {
+        priv->job.info.type = VIR_DOMAIN_JOB_FAILED;
         return -1;
     }
-    priv->jobInfo.timeElapsed -= priv->jobStart;
+    priv->job.info.timeElapsed -= priv->job.start;
 
     switch (status) {
     case QEMU_MONITOR_MIGRATION_STATUS_INACTIVE:
-        priv->jobInfo.type = VIR_DOMAIN_JOB_NONE;
+        priv->job.info.type = VIR_DOMAIN_JOB_NONE;
         qemuReportError(VIR_ERR_OPERATION_FAILED,
                         _("%s: %s"), job, _("is not active"));
         break;
 
     case QEMU_MONITOR_MIGRATION_STATUS_ACTIVE:
-        priv->jobInfo.dataTotal = memTotal;
-        priv->jobInfo.dataRemaining = memRemaining;
-        priv->jobInfo.dataProcessed = memProcessed;
+        priv->job.info.dataTotal = memTotal;
+        priv->job.info.dataRemaining = memRemaining;
+        priv->job.info.dataProcessed = memProcessed;
 
-        priv->jobInfo.memTotal = memTotal;
-        priv->jobInfo.memRemaining = memRemaining;
-        priv->jobInfo.memProcessed = memProcessed;
+        priv->job.info.memTotal = memTotal;
+        priv->job.info.memRemaining = memRemaining;
+        priv->job.info.memProcessed = memProcessed;
 
         ret = 0;
         break;
 
     case QEMU_MONITOR_MIGRATION_STATUS_COMPLETED:
-        priv->jobInfo.type = VIR_DOMAIN_JOB_COMPLETED;
+        priv->job.info.type = VIR_DOMAIN_JOB_COMPLETED;
         ret = 0;
         break;
 
     case QEMU_MONITOR_MIGRATION_STATUS_ERROR:
-        priv->jobInfo.type = VIR_DOMAIN_JOB_FAILED;
+        priv->job.info.type = VIR_DOMAIN_JOB_FAILED;
         qemuReportError(VIR_ERR_OPERATION_FAILED,
                         _("%s: %s"), job, _("unexpectedly failed"));
         break;
 
     case QEMU_MONITOR_MIGRATION_STATUS_CANCELLED:
-        priv->jobInfo.type = VIR_DOMAIN_JOB_CANCELLED;
+        priv->job.info.type = VIR_DOMAIN_JOB_CANCELLED;
         qemuReportError(VIR_ERR_OPERATION_FAILED,
                         _("%s: %s"), job, _("canceled by client"));
         break;
@@ -897,7 +897,7 @@ qemuMigrationWaitForCompletion(struct qemud_driver *driver, virDomainObjPtr vm)
     qemuDomainObjPrivatePtr priv = vm->privateData;
     const char *job;
 
-    switch (priv->jobActive) {
+    switch (priv->job.active) {
     case QEMU_JOB_MIGRATION_OUT:
         job = _("migration job");
         break;
@@ -911,17 +911,17 @@ qemuMigrationWaitForCompletion(struct qemud_driver *driver, virDomainObjPtr vm)
         job = _("job");
     }
 
-    priv->jobInfo.type = VIR_DOMAIN_JOB_UNBOUNDED;
+    priv->job.info.type = VIR_DOMAIN_JOB_UNBOUNDED;
 
-    while (priv->jobInfo.type == VIR_DOMAIN_JOB_UNBOUNDED) {
+    while (priv->job.info.type == VIR_DOMAIN_JOB_UNBOUNDED) {
         /* Poll every 50ms for progress & to allow cancellation */
         struct timespec ts = { .tv_sec = 0, .tv_nsec = 50 * 1000 * 1000ull };
-        while (priv->jobSignals) {
+        while (priv->job.signals) {
             if (qemuMigrationProcessJobSignals(driver, vm, job, false) < 0)
                 goto cleanup;
         }
 
-        virCondSignal(&priv->signalCond);
+        virCondSignal(&priv->job.signalCond);
 
         if (qemuMigrationUpdateJobStatus(driver, vm, job) < 0)
             goto cleanup;
@@ -937,12 +937,12 @@ qemuMigrationWaitForCompletion(struct qemud_driver *driver, virDomainObjPtr vm)
     }
 
 cleanup:
-    while (priv->jobSignals) {
+    while (priv->job.signals) {
         qemuMigrationProcessJobSignals(driver, vm, job, true);
     }
-    virCondBroadcast(&priv->signalCond);
+    virCondBroadcast(&priv->job.signalCond);
 
-    if (priv->jobInfo.type == VIR_DOMAIN_JOB_COMPLETED)
+    if (priv->job.info.type == VIR_DOMAIN_JOB_COMPLETED)
         return 0;
     else
         return -1;
@@ -1110,7 +1110,7 @@ qemuMigrationPrepareTunnel(struct qemud_driver *driver,
 
     if (qemuDomainObjBeginJobWithDriver(driver, vm) < 0)
         goto cleanup;
-    priv->jobActive = QEMU_JOB_MIGRATION_IN;
+    qemuDomainObjSetJob(vm, QEMU_JOB_MIGRATION_IN);
 
     /* Domain starts inactive, even if the domain XML had an id field. */
     vm->def->id = -1;
@@ -1183,9 +1183,9 @@ endjob:
      */
     if (vm &&
         virDomainObjIsActive(vm)) {
-        priv->jobActive = QEMU_JOB_MIGRATION_IN;
-        priv->jobInfo.type = VIR_DOMAIN_JOB_UNBOUNDED;
-        priv->jobStart = now;
+        qemuDomainObjSetJob(vm, QEMU_JOB_MIGRATION_IN);
+        priv->job.info.type = VIR_DOMAIN_JOB_UNBOUNDED;
+        priv->job.start = now;
     }
 
 cleanup:
@@ -1345,7 +1345,7 @@ qemuMigrationPrepareDirect(struct qemud_driver *driver,
 
     if (qemuDomainObjBeginJobWithDriver(driver, vm) < 0)
         goto cleanup;
-    priv->jobActive = QEMU_JOB_MIGRATION_IN;
+    qemuDomainObjSetJob(vm, QEMU_JOB_MIGRATION_IN);
 
     /* Domain starts inactive, even if the domain XML had an id field. */
     vm->def->id = -1;
@@ -1404,9 +1404,9 @@ endjob:
      */
     if (vm &&
         virDomainObjIsActive(vm)) {
-        priv->jobActive = QEMU_JOB_MIGRATION_IN;
-        priv->jobInfo.type = VIR_DOMAIN_JOB_UNBOUNDED;
-        priv->jobStart = now;
+        qemuDomainObjSetJob(vm, QEMU_JOB_MIGRATION_IN);
+        priv->job.info.type = VIR_DOMAIN_JOB_UNBOUNDED;
+        priv->job.start = now;
     }
 
 cleanup:
@@ -2286,7 +2286,7 @@ int qemuMigrationPerform(struct qemud_driver *driver,
 
     if (qemuDomainObjBeginJobWithDriver(driver, vm) < 0)
         goto cleanup;
-    priv->jobActive = QEMU_JOB_MIGRATION_OUT;
+    qemuDomainObjSetJob(vm, QEMU_JOB_MIGRATION_OUT);
 
     if (!virDomainObjIsActive(vm)) {
         qemuReportError(VIR_ERR_OPERATION_INVALID,
@@ -2300,8 +2300,8 @@ int qemuMigrationPerform(struct qemud_driver *driver,
         goto endjob;
     }
 
-    memset(&priv->jobInfo, 0, sizeof(priv->jobInfo));
-    priv->jobInfo.type = VIR_DOMAIN_JOB_UNBOUNDED;
+    memset(&priv->job.info, 0, sizeof(priv->job.info));
+    priv->job.info.type = VIR_DOMAIN_JOB_UNBOUNDED;
 
     resume = virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING;
 
@@ -2450,13 +2450,12 @@ qemuMigrationFinish(struct qemud_driver *driver,
     virErrorPtr orig_err = NULL;
 
     priv = vm->privateData;
-    if (priv->jobActive != QEMU_JOB_MIGRATION_IN) {
+    if (priv->job.active != QEMU_JOB_MIGRATION_IN) {
         qemuReportError(VIR_ERR_NO_DOMAIN,
                         _("domain '%s' is not processing incoming migration"), vm->def->name);
         goto cleanup;
     }
-    priv->jobActive = QEMU_JOB_NONE;
-    memset(&priv->jobInfo, 0, sizeof(priv->jobInfo));
+    qemuDomainObjDiscardJob(vm);
 
     if (!(mig = qemuMigrationEatCookie(driver, vm, cookiein, cookieinlen, 0)))
         goto cleanup;
diff --git a/src/qemu/qemu_process.c b/src/qemu/qemu_process.c
index c9145cb..56593c2 100644
--- a/src/qemu/qemu_process.c
+++ b/src/qemu/qemu_process.c
@@ -3013,11 +3013,10 @@ static void qemuProcessAutoDestroyDom(void *payload,
     }
 
     priv = dom->privateData;
-    if (priv->jobActive == QEMU_JOB_MIGRATION_IN) {
+    if (priv->job.active == QEMU_JOB_MIGRATION_IN) {
         VIR_DEBUG("vm=%s has incoming migration active, cancelling",
                   dom->def->name);
-        priv->jobActive = QEMU_JOB_NONE;
-        memset(&priv->jobInfo, 0, sizeof(priv->jobInfo));
+        qemuDomainObjDiscardJob(dom);
     }
 
     if (qemuDomainObjBeginJobWithDriver(data->driver, dom) < 0)
-- 
1.7.6


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