---
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
--
libvir-list mailing list
libvir-list@xxxxxxxxxx
https://www.redhat.com/mailman/listinfo/libvir-list