[PATCH 1/3] qemu: use generalized virDomainJobData instead of qemuDomainJobInfo

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

 



This patch includes:
* introducing new files: src/hypervisor/domain_job.c and src/hypervisor/domain_job.h
* new struct virDomainJobData, which is almost the same as
  qemuDomainJobInfo - the only differences are moving qemu specific
  job stats into the qemuDomainJobDataPrivate and adding jobType
  (possibly more attributes in the future if needed).
* moving qemuDomainJobStatus to the domain_job.h and renaming it
  as virDomainJobStatus
* moving and renaming qemuDomainJobStatusToType
* adding callback struct virDomainJobDataPrivateDataCallbacks
  taking care of allocation, copying and freeing of private data
  of virDomainJobData
* adding functions for virDomainJobDataPrivateDataCallbacks for
  qemu hypervisor
* adding 'public' (public between the different hypervisors) functions
  taking care of init, copy, free of virDomainJobData
* renaming every occurrence of qemuDomainJobInfo *info to
  virDomainJobData *data

Signed-off-by: Kristina Hanicova <khanicov@xxxxxxxxxx>
---
 src/hypervisor/domain_job.c      |  78 +++++++++++
 src/hypervisor/domain_job.h      |  72 ++++++++++
 src/hypervisor/meson.build       |   1 +
 src/libvirt_private.syms         |   7 +
 src/qemu/qemu_backup.c           |  40 +++---
 src/qemu/qemu_backup.h           |   4 +-
 src/qemu/qemu_domainjob.c        | 227 +++++++++++++++----------------
 src/qemu/qemu_domainjob.h        |  54 ++------
 src/qemu/qemu_driver.c           | 111 ++++++++-------
 src/qemu/qemu_migration.c        | 188 +++++++++++++------------
 src/qemu/qemu_migration.h        |   4 +-
 src/qemu/qemu_migration_cookie.c |  60 ++++----
 src/qemu/qemu_migration_cookie.h |   2 +-
 src/qemu/qemu_process.c          |  24 ++--
 src/qemu/qemu_snapshot.c         |   4 +-
 15 files changed, 517 insertions(+), 359 deletions(-)
 create mode 100644 src/hypervisor/domain_job.c
 create mode 100644 src/hypervisor/domain_job.h

diff --git a/src/hypervisor/domain_job.c b/src/hypervisor/domain_job.c
new file mode 100644
index 0000000000..daccbe4a69
--- /dev/null
+++ b/src/hypervisor/domain_job.c
@@ -0,0 +1,78 @@
+/*
+ * Copyright (C) 2022 Red Hat, Inc.
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ */
+
+#include <config.h>
+#include <string.h>
+
+#include "domain_job.h"
+
+
+virDomainJobData *
+virDomainJobDataInit(virDomainJobDataPrivateDataCallbacks *cb)
+{
+    virDomainJobData *ret = g_new0(virDomainJobData, 1);
+
+    ret->privateDataCb = cb;
+
+    if (ret->privateDataCb && ret->privateDataCb->allocPrivateData)
+        ret->privateData = ret->privateDataCb->allocPrivateData();
+
+    return ret;
+}
+
+virDomainJobData *
+virDomainJobDataCopy(virDomainJobData *data)
+{
+    virDomainJobData *ret = g_new0(virDomainJobData, 1);
+
+    memcpy(ret, data, sizeof(*data));
+
+    if (ret->privateDataCb && data->privateDataCb->copyPrivateData)
+        ret->privateData = data->privateDataCb->copyPrivateData(data->privateData);
+
+    ret->errmsg = g_strdup(data->errmsg);
+
+    return ret;
+}
+
+void
+virDomainJobDataFree(virDomainJobData *data)
+{
+    if (!data)
+        return;
+
+    if (data->privateDataCb && data->privateDataCb->freePrivateData)
+        data->privateDataCb->freePrivateData(data->privateData);
+
+    g_free(data->errmsg);
+    g_free(data);
+}
+
+virDomainJobType
+virDomainJobStatusToType(virDomainJobStatus status)
+{
+    switch (status) {
+    case VIR_DOMAIN_JOB_STATUS_NONE:
+        break;
+
+    case VIR_DOMAIN_JOB_STATUS_ACTIVE:
+    case VIR_DOMAIN_JOB_STATUS_MIGRATING:
+    case VIR_DOMAIN_JOB_STATUS_HYPERVISOR_COMPLETED:
+    case VIR_DOMAIN_JOB_STATUS_POSTCOPY:
+    case VIR_DOMAIN_JOB_STATUS_PAUSED:
+        return VIR_DOMAIN_JOB_UNBOUNDED;
+
+    case VIR_DOMAIN_JOB_STATUS_COMPLETED:
+        return VIR_DOMAIN_JOB_COMPLETED;
+
+    case VIR_DOMAIN_JOB_STATUS_FAILED:
+        return VIR_DOMAIN_JOB_FAILED;
+
+    case VIR_DOMAIN_JOB_STATUS_CANCELED:
+        return VIR_DOMAIN_JOB_CANCELLED;
+    }
+
+    return VIR_DOMAIN_JOB_NONE;
+}
diff --git a/src/hypervisor/domain_job.h b/src/hypervisor/domain_job.h
new file mode 100644
index 0000000000..257ef067e4
--- /dev/null
+++ b/src/hypervisor/domain_job.h
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2022 Red Hat, Inc.
+ * SPDX-License-Identifier: LGPL-2.1-or-later
+ */
+
+#pragma once
+
+#include "internal.h"
+
+typedef enum {
+    VIR_DOMAIN_JOB_STATUS_NONE = 0,
+    VIR_DOMAIN_JOB_STATUS_ACTIVE,
+    VIR_DOMAIN_JOB_STATUS_MIGRATING,
+    VIR_DOMAIN_JOB_STATUS_HYPERVISOR_COMPLETED,
+    VIR_DOMAIN_JOB_STATUS_PAUSED,
+    VIR_DOMAIN_JOB_STATUS_POSTCOPY,
+    VIR_DOMAIN_JOB_STATUS_COMPLETED,
+    VIR_DOMAIN_JOB_STATUS_FAILED,
+    VIR_DOMAIN_JOB_STATUS_CANCELED,
+} virDomainJobStatus;
+
+typedef void *(*virDomainJobDataPrivateDataAlloc) (void);
+typedef void *(*virDomainJobDataPrivateDataCopy) (void *);
+typedef void (*virDomainJobDataPrivateDataFree) (void *);
+
+typedef struct _virDomainJobDataPrivateDataCallbacks virDomainJobDataPrivateDataCallbacks;
+struct _virDomainJobDataPrivateDataCallbacks {
+    virDomainJobDataPrivateDataAlloc allocPrivateData;
+    virDomainJobDataPrivateDataCopy copyPrivateData;
+    virDomainJobDataPrivateDataFree freePrivateData;
+};
+
+typedef struct _virDomainJobData virDomainJobData;
+struct _virDomainJobData {
+    virDomainJobType jobType;
+
+    virDomainJobStatus status;
+    virDomainJobOperation operation;
+    unsigned long long started; /* When the async job started */
+    unsigned long long stopped; /* When the domain's CPUs were stopped */
+    unsigned long long sent; /* When the source sent status info to the
+                                destination (only for migrations). */
+    unsigned long long received; /* When the destination host received status
+                                    info from the source (migrations only). */
+    /* Computed values */
+    unsigned long long timeElapsed;
+    long long timeDelta; /* delta = received - sent, i.e., the difference between
+                            the source and the destination time plus the time
+                            between the end of Perform phase on the source and
+                            the beginning of Finish phase on the destination. */
+    bool timeDeltaSet;
+
+    char *errmsg; /* optional error message for failed completed jobs */
+
+    void *privateData; /* private data of hypervisors */
+    virDomainJobDataPrivateDataCallbacks *privateDataCb; /* callbacks of private data, hypervisor based */
+};
+
+
+virDomainJobData *
+virDomainJobDataInit(virDomainJobDataPrivateDataCallbacks *cb);
+
+void
+virDomainJobDataFree(virDomainJobData *data);
+
+G_DEFINE_AUTOPTR_CLEANUP_FUNC(virDomainJobData, virDomainJobDataFree);
+
+virDomainJobData *
+virDomainJobDataCopy(virDomainJobData *data);
+
+virDomainJobType
+virDomainJobStatusToType(virDomainJobStatus status);
diff --git a/src/hypervisor/meson.build b/src/hypervisor/meson.build
index 70801c0820..ec11ec0cd8 100644
--- a/src/hypervisor/meson.build
+++ b/src/hypervisor/meson.build
@@ -3,6 +3,7 @@ hypervisor_sources = [
   'domain_driver.c',
   'virclosecallbacks.c',
   'virhostdev.c',
+  'domain_job.c',
 ]
 
 stateful_driver_source_files += files(hypervisor_sources)
diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms
index ba3462d849..d648059e16 100644
--- a/src/libvirt_private.syms
+++ b/src/libvirt_private.syms
@@ -1565,6 +1565,13 @@ virDomainDriverParseBlkioDeviceStr;
 virDomainDriverSetupPersistentDefBlkioParams;
 
 
+# hypervisor/domain_job.h
+virDomainJobDataCopy;
+virDomainJobDataFree;
+virDomainJobDataInit;
+virDomainJobStatusToType;
+
+
 # hypervisor/virclosecallbacks.h
 virCloseCallbacksGet;
 virCloseCallbacksGetConn;
diff --git a/src/qemu/qemu_backup.c b/src/qemu/qemu_backup.c
index 304a0d5a4f..081c4d023f 100644
--- a/src/qemu/qemu_backup.c
+++ b/src/qemu/qemu_backup.c
@@ -555,7 +555,7 @@ qemuBackupBeginPullExportDisks(virDomainObj *vm,
 
 void
 qemuBackupJobTerminate(virDomainObj *vm,
-                       qemuDomainJobStatus jobstatus)
+                       virDomainJobStatus jobstatus)
 
 {
     qemuDomainObjPrivate *priv = vm->privateData;
@@ -583,7 +583,7 @@ qemuBackupJobTerminate(virDomainObj *vm,
             !(priv->backup->apiFlags & VIR_DOMAIN_BACKUP_BEGIN_REUSE_EXTERNAL) &&
             (priv->backup->type == VIR_DOMAIN_BACKUP_TYPE_PULL ||
              (priv->backup->type == VIR_DOMAIN_BACKUP_TYPE_PUSH &&
-              jobstatus != QEMU_DOMAIN_JOB_STATUS_COMPLETED))) {
+              jobstatus != VIR_DOMAIN_JOB_STATUS_COMPLETED))) {
 
             uid_t uid;
             gid_t gid;
@@ -600,15 +600,19 @@ qemuBackupJobTerminate(virDomainObj *vm,
     }
 
     if (priv->job.current) {
+        qemuDomainJobDataPrivate *privData = NULL;
+
         qemuDomainJobInfoUpdateTime(priv->job.current);
 
-        g_clear_pointer(&priv->job.completed, qemuDomainJobInfoFree);
-        priv->job.completed = qemuDomainJobInfoCopy(priv->job.current);
+        g_clear_pointer(&priv->job.completed, virDomainJobDataFree);
+        priv->job.completed = virDomainJobDataCopy(priv->job.current);
+
+        privData = priv->job.completed->privateData;
 
-        priv->job.completed->stats.backup.total = priv->backup->push_total;
-        priv->job.completed->stats.backup.transferred = priv->backup->push_transferred;
-        priv->job.completed->stats.backup.tmp_used = priv->backup->pull_tmp_used;
-        priv->job.completed->stats.backup.tmp_total = priv->backup->pull_tmp_total;
+        privData->stats.backup.total = priv->backup->push_total;
+        privData->stats.backup.transferred = priv->backup->push_transferred;
+        privData->stats.backup.tmp_used = priv->backup->pull_tmp_used;
+        privData->stats.backup.tmp_total = priv->backup->pull_tmp_total;
 
         priv->job.completed->status = jobstatus;
         priv->job.completed->errmsg = g_strdup(priv->backup->errmsg);
@@ -687,7 +691,7 @@ qemuBackupJobCancelBlockjobs(virDomainObj *vm,
     }
 
     if (terminatebackup && !has_active)
-        qemuBackupJobTerminate(vm, QEMU_DOMAIN_JOB_STATUS_CANCELED);
+        qemuBackupJobTerminate(vm, VIR_DOMAIN_JOB_STATUS_CANCELED);
 }
 
 
@@ -742,6 +746,7 @@ qemuBackupBegin(virDomainObj *vm,
                 unsigned int flags)
 {
     qemuDomainObjPrivate *priv = vm->privateData;
+    qemuDomainJobDataPrivate *privData = priv->job.current->privateData;
     g_autoptr(virQEMUDriverConfig) cfg = virQEMUDriverGetConfig(priv->driver);
     g_autoptr(virDomainBackupDef) def = NULL;
     g_autofree char *suffix = NULL;
@@ -795,7 +800,7 @@ qemuBackupBegin(virDomainObj *vm,
     qemuDomainObjSetAsyncJobMask(vm, (QEMU_JOB_DEFAULT_MASK |
                                       JOB_MASK(QEMU_JOB_SUSPEND) |
                                       JOB_MASK(QEMU_JOB_MODIFY)));
-    priv->job.current->statsType = QEMU_DOMAIN_JOB_STATS_TYPE_BACKUP;
+    privData->statsType = QEMU_DOMAIN_JOB_STATS_TYPE_BACKUP;
 
     if (!virDomainObjIsActive(vm)) {
         virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
@@ -985,7 +990,7 @@ qemuBackupNotifyBlockjobEnd(virDomainObj *vm,
     bool has_cancelling = false;
     bool has_cancelled = false;
     bool has_failed = false;
-    qemuDomainJobStatus jobstatus = QEMU_DOMAIN_JOB_STATUS_COMPLETED;
+    virDomainJobStatus jobstatus = VIR_DOMAIN_JOB_STATUS_COMPLETED;
     virDomainBackupDef *backup = priv->backup;
     size_t i;
 
@@ -1082,9 +1087,9 @@ qemuBackupNotifyBlockjobEnd(virDomainObj *vm,
         /* all sub-jobs have stopped */
 
         if (has_failed)
-            jobstatus = QEMU_DOMAIN_JOB_STATUS_FAILED;
+            jobstatus = VIR_DOMAIN_JOB_STATUS_FAILED;
         else if (has_cancelled && backup->type == VIR_DOMAIN_BACKUP_TYPE_PUSH)
-            jobstatus = QEMU_DOMAIN_JOB_STATUS_CANCELED;
+            jobstatus = VIR_DOMAIN_JOB_STATUS_CANCELED;
 
         qemuBackupJobTerminate(vm, jobstatus);
     }
@@ -1135,9 +1140,10 @@ qemuBackupGetJobInfoStatsUpdateOne(virDomainObj *vm,
 int
 qemuBackupGetJobInfoStats(virQEMUDriver *driver,
                           virDomainObj *vm,
-                          qemuDomainJobInfo *jobInfo)
+                          virDomainJobData *jobData)
 {
-    qemuDomainBackupStats *stats = &jobInfo->stats.backup;
+    qemuDomainJobDataPrivate *privJob = jobData->privateData;
+    qemuDomainBackupStats *stats = &privJob->stats.backup;
     qemuDomainObjPrivate *priv = vm->privateData;
     qemuMonitorJobInfo **blockjobs = NULL;
     size_t nblockjobs = 0;
@@ -1151,10 +1157,10 @@ qemuBackupGetJobInfoStats(virQEMUDriver *driver,
         return -1;
     }
 
-    if (qemuDomainJobInfoUpdateTime(jobInfo) < 0)
+    if (qemuDomainJobInfoUpdateTime(jobData) < 0)
         return -1;
 
-    jobInfo->status = QEMU_DOMAIN_JOB_STATUS_ACTIVE;
+    jobData->status = VIR_DOMAIN_JOB_STATUS_ACTIVE;
 
     qemuDomainObjEnterMonitor(driver, vm);
 
diff --git a/src/qemu/qemu_backup.h b/src/qemu/qemu_backup.h
index ebb3154516..de4dff9357 100644
--- a/src/qemu/qemu_backup.h
+++ b/src/qemu/qemu_backup.h
@@ -45,12 +45,12 @@ qemuBackupNotifyBlockjobEnd(virDomainObj *vm,
 
 void
 qemuBackupJobTerminate(virDomainObj *vm,
-                       qemuDomainJobStatus jobstatus);
+                       virDomainJobStatus jobstatus);
 
 int
 qemuBackupGetJobInfoStats(virQEMUDriver *driver,
                           virDomainObj *vm,
-                          qemuDomainJobInfo *jobInfo);
+                          virDomainJobData *jobData);
 
 /* exported for testing */
 int
diff --git a/src/qemu/qemu_domainjob.c b/src/qemu/qemu_domainjob.c
index 1ecde5af86..1d9bec2cfd 100644
--- a/src/qemu/qemu_domainjob.c
+++ b/src/qemu/qemu_domainjob.c
@@ -63,6 +63,38 @@ VIR_ENUM_IMPL(qemuDomainAsyncJob,
               "backup",
 );
 
+static void *
+qemuJobDataAllocPrivateData(void)
+{
+    return g_new0(qemuDomainJobDataPrivate, 1);
+}
+
+
+static void *
+qemuJobDataCopyPrivateData(void *data)
+{
+    qemuDomainJobDataPrivate *ret = g_new0(qemuDomainJobDataPrivate, 1);
+
+    memcpy(ret, data, sizeof(qemuDomainJobDataPrivate));
+
+    return ret;
+}
+
+
+static void
+qemuJobDataFreePrivateData(void *data)
+{
+    g_free(data);
+}
+
+
+virDomainJobDataPrivateDataCallbacks qemuJobDataPrivateDataCallbacks = {
+    .allocPrivateData = qemuJobDataAllocPrivateData,
+    .copyPrivateData = qemuJobDataCopyPrivateData,
+    .freePrivateData = qemuJobDataFreePrivateData,
+};
+
+
 const char *
 qemuDomainAsyncJobPhaseToString(qemuDomainAsyncJob job,
                                 int phase G_GNUC_UNUSED)
@@ -116,26 +148,6 @@ qemuDomainAsyncJobPhaseFromString(qemuDomainAsyncJob job,
 }
 
 
-void
-qemuDomainJobInfoFree(qemuDomainJobInfo *info)
-{
-    g_free(info->errmsg);
-    g_free(info);
-}
-
-
-qemuDomainJobInfo *
-qemuDomainJobInfoCopy(qemuDomainJobInfo *info)
-{
-    qemuDomainJobInfo *ret = g_new0(qemuDomainJobInfo, 1);
-
-    memcpy(ret, info, sizeof(*info));
-
-    ret->errmsg = g_strdup(info->errmsg);
-
-    return ret;
-}
-
 void
 qemuDomainEventEmitJobCompleted(virQEMUDriver *driver,
                                 virDomainObj *vm)
@@ -149,7 +161,7 @@ qemuDomainEventEmitJobCompleted(virQEMUDriver *driver,
     if (!priv->job.completed)
         return;
 
-    if (qemuDomainJobInfoToParams(priv->job.completed, &type,
+    if (qemuDomainJobDataToParams(priv->job.completed, &type,
                                   &params, &nparams) < 0) {
         VIR_WARN("Could not get stats for completed job; domain %s",
                  vm->def->name);
@@ -216,7 +228,7 @@ qemuDomainObjResetAsyncJob(qemuDomainJobObj *job)
     job->mask = QEMU_JOB_DEFAULT_MASK;
     job->abortJob = false;
     VIR_FREE(job->error);
-    g_clear_pointer(&job->current, qemuDomainJobInfoFree);
+    g_clear_pointer(&job->current, virDomainJobDataFree);
     job->cb->resetJobPrivate(job->privateData);
     job->apiFlags = 0;
 }
@@ -254,8 +266,8 @@ qemuDomainObjClearJob(qemuDomainJobObj *job)
     qemuDomainObjResetJob(job);
     qemuDomainObjResetAsyncJob(job);
     g_clear_pointer(&job->privateData, job->cb->freeJobPrivate);
-    g_clear_pointer(&job->current, qemuDomainJobInfoFree);
-    g_clear_pointer(&job->completed, qemuDomainJobInfoFree);
+    g_clear_pointer(&job->current, virDomainJobDataFree);
+    g_clear_pointer(&job->completed, virDomainJobDataFree);
     virCondDestroy(&job->cond);
     virCondDestroy(&job->asyncCond);
 }
@@ -268,111 +280,87 @@ qemuDomainTrackJob(qemuDomainJob job)
 
 
 int
-qemuDomainJobInfoUpdateTime(qemuDomainJobInfo *jobInfo)
+qemuDomainJobInfoUpdateTime(virDomainJobData *jobData)
 {
     unsigned long long now;
 
-    if (!jobInfo->started)
+    if (!jobData->started)
         return 0;
 
     if (virTimeMillisNow(&now) < 0)
         return -1;
 
-    if (now < jobInfo->started) {
+    if (now < jobData->started) {
         VIR_WARN("Async job starts in the future");
-        jobInfo->started = 0;
+        jobData->started = 0;
         return 0;
     }
 
-    jobInfo->timeElapsed = now - jobInfo->started;
+    jobData->timeElapsed = now - jobData->started;
     return 0;
 }
 
 int
-qemuDomainJobInfoUpdateDowntime(qemuDomainJobInfo *jobInfo)
+qemuDomainJobInfoUpdateDowntime(virDomainJobData *jobData)
 {
     unsigned long long now;
+    qemuDomainJobDataPrivate *priv = jobData->privateData;
 
-    if (!jobInfo->stopped)
+    if (!jobData->stopped)
         return 0;
 
     if (virTimeMillisNow(&now) < 0)
         return -1;
 
-    if (now < jobInfo->stopped) {
+    if (now < jobData->stopped) {
         VIR_WARN("Guest's CPUs stopped in the future");
-        jobInfo->stopped = 0;
+        jobData->stopped = 0;
         return 0;
     }
 
-    jobInfo->stats.mig.downtime = now - jobInfo->stopped;
-    jobInfo->stats.mig.downtime_set = true;
+    priv->stats.mig.downtime = now - jobData->stopped;
+    priv->stats.mig.downtime_set = true;
     return 0;
 }
 
-static virDomainJobType
-qemuDomainJobStatusToType(qemuDomainJobStatus status)
-{
-    switch (status) {
-    case QEMU_DOMAIN_JOB_STATUS_NONE:
-        break;
-
-    case QEMU_DOMAIN_JOB_STATUS_ACTIVE:
-    case QEMU_DOMAIN_JOB_STATUS_MIGRATING:
-    case QEMU_DOMAIN_JOB_STATUS_QEMU_COMPLETED:
-    case QEMU_DOMAIN_JOB_STATUS_POSTCOPY:
-    case QEMU_DOMAIN_JOB_STATUS_PAUSED:
-        return VIR_DOMAIN_JOB_UNBOUNDED;
-
-    case QEMU_DOMAIN_JOB_STATUS_COMPLETED:
-        return VIR_DOMAIN_JOB_COMPLETED;
-
-    case QEMU_DOMAIN_JOB_STATUS_FAILED:
-        return VIR_DOMAIN_JOB_FAILED;
-
-    case QEMU_DOMAIN_JOB_STATUS_CANCELED:
-        return VIR_DOMAIN_JOB_CANCELLED;
-    }
-
-    return VIR_DOMAIN_JOB_NONE;
-}
 
 int
-qemuDomainJobInfoToInfo(qemuDomainJobInfo *jobInfo,
+qemuDomainJobInfoToInfo(virDomainJobData *jobData,
                         virDomainJobInfoPtr info)
 {
-    info->type = qemuDomainJobStatusToType(jobInfo->status);
-    info->timeElapsed = jobInfo->timeElapsed;
+    qemuDomainJobDataPrivate *priv = jobData->privateData;
+    info->type = virDomainJobStatusToType(jobData->status);
+    info->timeElapsed = jobData->timeElapsed;
 
-    switch (jobInfo->statsType) {
+    switch (priv->statsType) {
     case QEMU_DOMAIN_JOB_STATS_TYPE_MIGRATION:
-        info->memTotal = jobInfo->stats.mig.ram_total;
-        info->memRemaining = jobInfo->stats.mig.ram_remaining;
-        info->memProcessed = jobInfo->stats.mig.ram_transferred;
-        info->fileTotal = jobInfo->stats.mig.disk_total +
-                          jobInfo->mirrorStats.total;
-        info->fileRemaining = jobInfo->stats.mig.disk_remaining +
-                              (jobInfo->mirrorStats.total -
-                               jobInfo->mirrorStats.transferred);
-        info->fileProcessed = jobInfo->stats.mig.disk_transferred +
-                              jobInfo->mirrorStats.transferred;
+        info->memTotal = priv->stats.mig.ram_total;
+        info->memRemaining = priv->stats.mig.ram_remaining;
+        info->memProcessed = priv->stats.mig.ram_transferred;
+        info->fileTotal = priv->stats.mig.disk_total +
+                          priv->mirrorStats.total;
+        info->fileRemaining = priv->stats.mig.disk_remaining +
+                              (priv->mirrorStats.total -
+                               priv->mirrorStats.transferred);
+        info->fileProcessed = priv->stats.mig.disk_transferred +
+                              priv->mirrorStats.transferred;
         break;
 
     case QEMU_DOMAIN_JOB_STATS_TYPE_SAVEDUMP:
-        info->memTotal = jobInfo->stats.mig.ram_total;
-        info->memRemaining = jobInfo->stats.mig.ram_remaining;
-        info->memProcessed = jobInfo->stats.mig.ram_transferred;
+        info->memTotal = priv->stats.mig.ram_total;
+        info->memRemaining = priv->stats.mig.ram_remaining;
+        info->memProcessed = priv->stats.mig.ram_transferred;
         break;
 
     case QEMU_DOMAIN_JOB_STATS_TYPE_MEMDUMP:
-        info->memTotal = jobInfo->stats.dump.total;
-        info->memProcessed = jobInfo->stats.dump.completed;
+        info->memTotal = priv->stats.dump.total;
+        info->memProcessed = priv->stats.dump.completed;
         info->memRemaining = info->memTotal - info->memProcessed;
         break;
 
     case QEMU_DOMAIN_JOB_STATS_TYPE_BACKUP:
-        info->fileTotal = jobInfo->stats.backup.total;
-        info->fileProcessed = jobInfo->stats.backup.transferred;
+        info->fileTotal = priv->stats.backup.total;
+        info->fileProcessed = priv->stats.backup.transferred;
         info->fileRemaining = info->fileTotal - info->fileProcessed;
         break;
 
@@ -389,13 +377,14 @@ qemuDomainJobInfoToInfo(qemuDomainJobInfo *jobInfo,
 
 
 static int
-qemuDomainMigrationJobInfoToParams(qemuDomainJobInfo *jobInfo,
+qemuDomainMigrationJobDataToParams(virDomainJobData *jobData,
                                    int *type,
                                    virTypedParameterPtr *params,
                                    int *nparams)
 {
-    qemuMonitorMigrationStats *stats = &jobInfo->stats.mig;
-    qemuDomainMirrorStats *mirrorStats = &jobInfo->mirrorStats;
+    qemuDomainJobDataPrivate *priv = jobData->privateData;
+    qemuMonitorMigrationStats *stats = &priv->stats.mig;
+    qemuDomainMirrorStats *mirrorStats = &priv->mirrorStats;
     virTypedParameterPtr par = NULL;
     int maxpar = 0;
     int npar = 0;
@@ -404,19 +393,19 @@ qemuDomainMigrationJobInfoToParams(qemuDomainJobInfo *jobInfo,
 
     if (virTypedParamsAddInt(&par, &npar, &maxpar,
                              VIR_DOMAIN_JOB_OPERATION,
-                             jobInfo->operation) < 0)
+                             jobData->operation) < 0)
         goto error;
 
     if (virTypedParamsAddULLong(&par, &npar, &maxpar,
                                 VIR_DOMAIN_JOB_TIME_ELAPSED,
-                                jobInfo->timeElapsed) < 0)
+                                jobData->timeElapsed) < 0)
         goto error;
 
-    if (jobInfo->timeDeltaSet &&
-        jobInfo->timeElapsed > jobInfo->timeDelta &&
+    if (jobData->timeDeltaSet &&
+        jobData->timeElapsed > jobData->timeDelta &&
         virTypedParamsAddULLong(&par, &npar, &maxpar,
                                 VIR_DOMAIN_JOB_TIME_ELAPSED_NET,
-                                jobInfo->timeElapsed - jobInfo->timeDelta) < 0)
+                                jobData->timeElapsed - jobData->timeDelta) < 0)
         goto error;
 
     if (stats->downtime_set &&
@@ -426,11 +415,11 @@ qemuDomainMigrationJobInfoToParams(qemuDomainJobInfo *jobInfo,
         goto error;
 
     if (stats->downtime_set &&
-        jobInfo->timeDeltaSet &&
-        stats->downtime > jobInfo->timeDelta &&
+        jobData->timeDeltaSet &&
+        stats->downtime > jobData->timeDelta &&
         virTypedParamsAddULLong(&par, &npar, &maxpar,
                                 VIR_DOMAIN_JOB_DOWNTIME_NET,
-                                stats->downtime - jobInfo->timeDelta) < 0)
+                                stats->downtime - jobData->timeDelta) < 0)
         goto error;
 
     if (stats->setup_time_set &&
@@ -505,7 +494,7 @@ qemuDomainMigrationJobInfoToParams(qemuDomainJobInfo *jobInfo,
 
     /* The remaining stats are disk, mirror, or migration specific
      * so if this is a SAVEDUMP, we can just skip them */
-    if (jobInfo->statsType == QEMU_DOMAIN_JOB_STATS_TYPE_SAVEDUMP)
+    if (priv->statsType == QEMU_DOMAIN_JOB_STATS_TYPE_SAVEDUMP)
         goto done;
 
     if (virTypedParamsAddULLong(&par, &npar, &maxpar,
@@ -554,7 +543,7 @@ qemuDomainMigrationJobInfoToParams(qemuDomainJobInfo *jobInfo,
         goto error;
 
  done:
-    *type = qemuDomainJobStatusToType(jobInfo->status);
+    *type = virDomainJobStatusToType(jobData->status);
     *params = par;
     *nparams = npar;
     return 0;
@@ -566,24 +555,25 @@ qemuDomainMigrationJobInfoToParams(qemuDomainJobInfo *jobInfo,
 
 
 static int
-qemuDomainDumpJobInfoToParams(qemuDomainJobInfo *jobInfo,
+qemuDomainDumpJobDataToParams(virDomainJobData *jobData,
                               int *type,
                               virTypedParameterPtr *params,
                               int *nparams)
 {
-    qemuMonitorDumpStats *stats = &jobInfo->stats.dump;
+    qemuDomainJobDataPrivate *priv = jobData->privateData;
+    qemuMonitorDumpStats *stats = &priv->stats.dump;
     virTypedParameterPtr par = NULL;
     int maxpar = 0;
     int npar = 0;
 
     if (virTypedParamsAddInt(&par, &npar, &maxpar,
                              VIR_DOMAIN_JOB_OPERATION,
-                             jobInfo->operation) < 0)
+                             jobData->operation) < 0)
         goto error;
 
     if (virTypedParamsAddULLong(&par, &npar, &maxpar,
                                 VIR_DOMAIN_JOB_TIME_ELAPSED,
-                                jobInfo->timeElapsed) < 0)
+                                jobData->timeElapsed) < 0)
         goto error;
 
     if (virTypedParamsAddULLong(&par, &npar, &maxpar,
@@ -597,7 +587,7 @@ qemuDomainDumpJobInfoToParams(qemuDomainJobInfo *jobInfo,
                                 stats->total - stats->completed) < 0)
         goto error;
 
-    *type = qemuDomainJobStatusToType(jobInfo->status);
+    *type = virDomainJobStatusToType(jobData->status);
     *params = par;
     *nparams = npar;
     return 0;
@@ -609,19 +599,20 @@ qemuDomainDumpJobInfoToParams(qemuDomainJobInfo *jobInfo,
 
 
 static int
-qemuDomainBackupJobInfoToParams(qemuDomainJobInfo *jobInfo,
+qemuDomainBackupJobDataToParams(virDomainJobData *jobData,
                                 int *type,
                                 virTypedParameterPtr *params,
                                 int *nparams)
 {
-    qemuDomainBackupStats *stats = &jobInfo->stats.backup;
+    qemuDomainJobDataPrivate *priv = jobData->privateData;
+    qemuDomainBackupStats *stats = &priv->stats.backup;
     g_autoptr(virTypedParamList) par = g_new0(virTypedParamList, 1);
 
-    if (virTypedParamListAddInt(par, jobInfo->operation,
+    if (virTypedParamListAddInt(par, jobData->operation,
                                 VIR_DOMAIN_JOB_OPERATION) < 0)
         return -1;
 
-    if (virTypedParamListAddULLong(par, jobInfo->timeElapsed,
+    if (virTypedParamListAddULLong(par, jobData->timeElapsed,
                                    VIR_DOMAIN_JOB_TIME_ELAPSED) < 0)
         return -1;
 
@@ -649,38 +640,40 @@ qemuDomainBackupJobInfoToParams(qemuDomainJobInfo *jobInfo,
             return -1;
     }
 
-    if (jobInfo->status != QEMU_DOMAIN_JOB_STATUS_ACTIVE &&
+    if (jobData->status != VIR_DOMAIN_JOB_STATUS_ACTIVE &&
         virTypedParamListAddBoolean(par,
-                                    jobInfo->status == QEMU_DOMAIN_JOB_STATUS_COMPLETED,
+                                    jobData->status == VIR_DOMAIN_JOB_STATUS_COMPLETED,
                                     VIR_DOMAIN_JOB_SUCCESS) < 0)
         return -1;
 
-    if (jobInfo->errmsg &&
-        virTypedParamListAddString(par, jobInfo->errmsg, VIR_DOMAIN_JOB_ERRMSG) < 0)
+    if (jobData->errmsg &&
+        virTypedParamListAddString(par, jobData->errmsg, VIR_DOMAIN_JOB_ERRMSG) < 0)
         return -1;
 
     *nparams = virTypedParamListStealParams(par, params);
-    *type = qemuDomainJobStatusToType(jobInfo->status);
+    *type = virDomainJobStatusToType(jobData->status);
     return 0;
 }
 
 
 int
-qemuDomainJobInfoToParams(qemuDomainJobInfo *jobInfo,
+qemuDomainJobDataToParams(virDomainJobData *jobData,
                           int *type,
                           virTypedParameterPtr *params,
                           int *nparams)
 {
-    switch (jobInfo->statsType) {
+    qemuDomainJobDataPrivate *priv = jobData->privateData;
+
+    switch (priv->statsType) {
     case QEMU_DOMAIN_JOB_STATS_TYPE_MIGRATION:
     case QEMU_DOMAIN_JOB_STATS_TYPE_SAVEDUMP:
-        return qemuDomainMigrationJobInfoToParams(jobInfo, type, params, nparams);
+        return qemuDomainMigrationJobDataToParams(jobData, type, params, nparams);
 
     case QEMU_DOMAIN_JOB_STATS_TYPE_MEMDUMP:
-        return qemuDomainDumpJobInfoToParams(jobInfo, type, params, nparams);
+        return qemuDomainDumpJobDataToParams(jobData, type, params, nparams);
 
     case QEMU_DOMAIN_JOB_STATS_TYPE_BACKUP:
-        return qemuDomainBackupJobInfoToParams(jobInfo, type, params, nparams);
+        return qemuDomainBackupJobDataToParams(jobData, type, params, nparams);
 
     case QEMU_DOMAIN_JOB_STATS_TYPE_NONE:
         virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
@@ -688,7 +681,7 @@ qemuDomainJobInfoToParams(qemuDomainJobInfo *jobInfo,
         break;
 
     default:
-        virReportEnumRangeError(qemuDomainJobStatsType, jobInfo->statsType);
+        virReportEnumRangeError(qemuDomainJobStatsType, priv->statsType);
         break;
     }
 
@@ -895,8 +888,8 @@ qemuDomainObjBeginJobInternal(virQEMUDriver *driver,
                       qemuDomainAsyncJobTypeToString(asyncJob),
                       obj, obj->def->name);
             qemuDomainObjResetAsyncJob(&priv->job);
-            priv->job.current = g_new0(qemuDomainJobInfo, 1);
-            priv->job.current->status = QEMU_DOMAIN_JOB_STATUS_ACTIVE;
+            priv->job.current = virDomainJobDataInit(&qemuJobDataPrivateDataCallbacks);
+            priv->job.current->status = VIR_DOMAIN_JOB_STATUS_ACTIVE;
             priv->job.asyncJob = asyncJob;
             priv->job.asyncOwner = virThreadSelfID();
             priv->job.asyncOwnerAPI = g_strdup(virThreadJobGet());
diff --git a/src/qemu/qemu_domainjob.h b/src/qemu/qemu_domainjob.h
index f904bd49c2..5de82ee016 100644
--- a/src/qemu/qemu_domainjob.h
+++ b/src/qemu/qemu_domainjob.h
@@ -20,6 +20,7 @@
 
 #include <glib-object.h>
 #include "qemu_monitor.h"
+#include "domain_job.h"
 
 #define JOB_MASK(job)                  (job == 0 ? 0 : 1 << (job - 1))
 #define QEMU_JOB_DEFAULT_MASK \
@@ -79,17 +80,6 @@ typedef enum {
 } qemuDomainAsyncJob;
 VIR_ENUM_DECL(qemuDomainAsyncJob);
 
-typedef enum {
-    QEMU_DOMAIN_JOB_STATUS_NONE = 0,
-    QEMU_DOMAIN_JOB_STATUS_ACTIVE,
-    QEMU_DOMAIN_JOB_STATUS_MIGRATING,
-    QEMU_DOMAIN_JOB_STATUS_QEMU_COMPLETED,
-    QEMU_DOMAIN_JOB_STATUS_PAUSED,
-    QEMU_DOMAIN_JOB_STATUS_POSTCOPY,
-    QEMU_DOMAIN_JOB_STATUS_COMPLETED,
-    QEMU_DOMAIN_JOB_STATUS_FAILED,
-    QEMU_DOMAIN_JOB_STATUS_CANCELED,
-} qemuDomainJobStatus;
 
 typedef enum {
     QEMU_DOMAIN_JOB_STATS_TYPE_NONE = 0,
@@ -114,24 +104,8 @@ struct _qemuDomainBackupStats {
     unsigned long long tmp_total;
 };
 
-typedef struct _qemuDomainJobInfo qemuDomainJobInfo;
-struct _qemuDomainJobInfo {
-    qemuDomainJobStatus status;
-    virDomainJobOperation operation;
-    unsigned long long started; /* When the async job started */
-    unsigned long long stopped; /* When the domain's CPUs were stopped */
-    unsigned long long sent; /* When the source sent status info to the
-                                destination (only for migrations). */
-    unsigned long long received; /* When the destination host received status
-                                    info from the source (migrations only). */
-    /* Computed values */
-    unsigned long long timeElapsed;
-    long long timeDelta; /* delta = received - sent, i.e., the difference
-                            between the source and the destination time plus
-                            the time between the end of Perform phase on the
-                            source and the beginning of Finish phase on the
-                            destination. */
-    bool timeDeltaSet;
+typedef struct _qemuDomainJobDataPrivate qemuDomainJobDataPrivate;
+struct _qemuDomainJobDataPrivate {
     /* Raw values from QEMU */
     qemuDomainJobStatsType statsType;
     union {
@@ -140,17 +114,9 @@ struct _qemuDomainJobInfo {
         qemuDomainBackupStats backup;
     } stats;
     qemuDomainMirrorStats mirrorStats;
-
-    char *errmsg; /* optional error message for failed completed jobs */
 };
 
-void
-qemuDomainJobInfoFree(qemuDomainJobInfo *info);
-
-G_DEFINE_AUTOPTR_CLEANUP_FUNC(qemuDomainJobInfo, qemuDomainJobInfoFree);
-
-qemuDomainJobInfo *
-qemuDomainJobInfoCopy(qemuDomainJobInfo *info);
+extern virDomainJobDataPrivateDataCallbacks qemuJobDataPrivateDataCallbacks;
 
 typedef struct _qemuDomainJobObj qemuDomainJobObj;
 
@@ -198,8 +164,8 @@ struct _qemuDomainJobObj {
     unsigned long long asyncStarted;    /* When the current async job started */
     int phase;                          /* Job phase (mainly for migrations) */
     unsigned long long mask;            /* Jobs allowed during async job */
-    qemuDomainJobInfo *current;       /* async job progress data */
-    qemuDomainJobInfo *completed;     /* statistics data of a recently completed job */
+    virDomainJobData *current;       /* async job progress data */
+    virDomainJobData *completed;     /* statistics data of a recently completed job */
     bool abortJob;                      /* abort of the job requested */
     char *error;                        /* job event completion error */
     unsigned long apiFlags; /* flags passed to the API which started the async job */
@@ -256,14 +222,14 @@ void qemuDomainObjDiscardAsyncJob(virQEMUDriver *driver,
                                   virDomainObj *obj);
 void qemuDomainObjReleaseAsyncJob(virDomainObj *obj);
 
-int qemuDomainJobInfoUpdateTime(qemuDomainJobInfo *jobInfo)
+int qemuDomainJobInfoUpdateTime(virDomainJobData *jobData)
     ATTRIBUTE_NONNULL(1);
-int qemuDomainJobInfoUpdateDowntime(qemuDomainJobInfo *jobInfo)
+int qemuDomainJobInfoUpdateDowntime(virDomainJobData *jobData)
     ATTRIBUTE_NONNULL(1);
-int qemuDomainJobInfoToInfo(qemuDomainJobInfo *jobInfo,
+int qemuDomainJobInfoToInfo(virDomainJobData *jobData,
                             virDomainJobInfoPtr info)
     ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
-int qemuDomainJobInfoToParams(qemuDomainJobInfo *jobInfo,
+int qemuDomainJobDataToParams(virDomainJobData *jobData,
                               int *type,
                               virTypedParameterPtr *params,
                               int *nparams)
diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c
index 83cc7a04ea..800db34a4b 100644
--- a/src/qemu/qemu_driver.c
+++ b/src/qemu/qemu_driver.c
@@ -2630,6 +2630,7 @@ qemuDomainSaveInternal(virQEMUDriver *driver,
     int ret = -1;
     virObjectEvent *event = NULL;
     qemuDomainObjPrivate *priv = vm->privateData;
+    qemuDomainJobDataPrivate *privJobCurrent = priv->job.current->privateData;
     virQEMUSaveData *data = NULL;
     g_autoptr(qemuDomainSaveCookie) cookie = NULL;
 
@@ -2646,7 +2647,7 @@ qemuDomainSaveInternal(virQEMUDriver *driver,
         goto endjob;
     }
 
-    priv->job.current->statsType = QEMU_DOMAIN_JOB_STATS_TYPE_SAVEDUMP;
+    privJobCurrent->statsType = QEMU_DOMAIN_JOB_STATS_TYPE_SAVEDUMP;
 
     /* Pause */
     if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING) {
@@ -2939,6 +2940,7 @@ qemuDumpWaitForCompletion(virDomainObj *vm)
 {
     qemuDomainObjPrivate *priv = vm->privateData;
     qemuDomainJobPrivate *jobPriv = priv->job.privateData;
+    qemuDomainJobDataPrivate *privJobCurrent = priv->job.current->privateData;
 
     VIR_DEBUG("Waiting for dump completion");
     while (!jobPriv->dumpCompleted && !priv->job.abortJob) {
@@ -2946,7 +2948,7 @@ qemuDumpWaitForCompletion(virDomainObj *vm)
             return -1;
     }
 
-    if (priv->job.current->stats.dump.status == QEMU_MONITOR_DUMP_STATUS_FAILED) {
+    if (privJobCurrent->stats.dump.status == QEMU_MONITOR_DUMP_STATUS_FAILED) {
         if (priv->job.error)
             virReportError(VIR_ERR_OPERATION_FAILED,
                            _("memory-only dump failed: %s"),
@@ -2985,10 +2987,13 @@ qemuDumpToFd(virQEMUDriver *driver,
     if (qemuSecuritySetImageFDLabel(driver->securityManager, vm->def, fd) < 0)
         return -1;
 
-    if (detach)
-        priv->job.current->statsType = QEMU_DOMAIN_JOB_STATS_TYPE_MEMDUMP;
-    else
-        g_clear_pointer(&priv->job.current, qemuDomainJobInfoFree);
+    if (detach) {
+        qemuDomainJobDataPrivate *privStats = priv->job.current->privateData;
+
+        privStats->statsType = QEMU_DOMAIN_JOB_STATS_TYPE_MEMDUMP;
+    } else {
+        g_clear_pointer(&priv->job.current, virDomainJobDataFree);
+    }
 
     if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
         return -1;
@@ -3123,6 +3128,7 @@ qemuDomainCoreDumpWithFormat(virDomainPtr dom,
     virQEMUDriver *driver = dom->conn->privateData;
     virDomainObj *vm;
     qemuDomainObjPrivate *priv = NULL;
+    qemuDomainJobDataPrivate *privJobCurrent = NULL;
     bool resume = false, paused = false;
     int ret = -1;
     virObjectEvent *event = NULL;
@@ -3147,7 +3153,8 @@ qemuDomainCoreDumpWithFormat(virDomainPtr dom,
         goto endjob;
 
     priv = vm->privateData;
-    priv->job.current->statsType = QEMU_DOMAIN_JOB_STATS_TYPE_SAVEDUMP;
+    privJobCurrent = priv->job.current->privateData;
+    privJobCurrent->statsType = QEMU_DOMAIN_JOB_STATS_TYPE_SAVEDUMP;
 
     /* Migrate will always stop the VM, so the resume condition is
        independent of whether the stop command is issued.  */
@@ -12409,28 +12416,30 @@ qemuConnectBaselineHypervisorCPU(virConnectPtr conn,
 static int
 qemuDomainGetJobInfoMigrationStats(virQEMUDriver *driver,
                                    virDomainObj *vm,
-                                   qemuDomainJobInfo *jobInfo)
+                                   virDomainJobData *jobData)
 {
     qemuDomainObjPrivate *priv = vm->privateData;
+    qemuDomainJobDataPrivate *privStats = jobData->privateData;
+
     bool events = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATION_EVENT);
 
-    if (jobInfo->status == QEMU_DOMAIN_JOB_STATUS_ACTIVE ||
-        jobInfo->status == QEMU_DOMAIN_JOB_STATUS_MIGRATING ||
-        jobInfo->status == QEMU_DOMAIN_JOB_STATUS_QEMU_COMPLETED ||
-        jobInfo->status == QEMU_DOMAIN_JOB_STATUS_POSTCOPY) {
+    if (jobData->status == VIR_DOMAIN_JOB_STATUS_ACTIVE ||
+        jobData->status == VIR_DOMAIN_JOB_STATUS_MIGRATING ||
+        jobData->status == VIR_DOMAIN_JOB_STATUS_HYPERVISOR_COMPLETED ||
+        jobData->status == VIR_DOMAIN_JOB_STATUS_POSTCOPY) {
         if (events &&
-            jobInfo->status != QEMU_DOMAIN_JOB_STATUS_ACTIVE &&
+            jobData->status != VIR_DOMAIN_JOB_STATUS_ACTIVE &&
             qemuMigrationAnyFetchStats(driver, vm, QEMU_ASYNC_JOB_NONE,
-                                       jobInfo, NULL) < 0)
+                                       jobData, NULL) < 0)
             return -1;
 
-        if (jobInfo->status == QEMU_DOMAIN_JOB_STATUS_ACTIVE &&
-            jobInfo->statsType == QEMU_DOMAIN_JOB_STATS_TYPE_MIGRATION &&
+        if (jobData->status == VIR_DOMAIN_JOB_STATUS_ACTIVE &&
+            privStats->statsType == QEMU_DOMAIN_JOB_STATS_TYPE_MIGRATION &&
             qemuMigrationSrcFetchMirrorStats(driver, vm, QEMU_ASYNC_JOB_NONE,
-                                             jobInfo) < 0)
+                                             jobData) < 0)
             return -1;
 
-        if (qemuDomainJobInfoUpdateTime(jobInfo) < 0)
+        if (qemuDomainJobInfoUpdateTime(jobData) < 0)
             return -1;
     }
 
@@ -12441,9 +12450,10 @@ qemuDomainGetJobInfoMigrationStats(virQEMUDriver *driver,
 static int
 qemuDomainGetJobInfoDumpStats(virQEMUDriver *driver,
                               virDomainObj *vm,
-                              qemuDomainJobInfo *jobInfo)
+                              virDomainJobData *jobData)
 {
     qemuDomainObjPrivate *priv = vm->privateData;
+    qemuDomainJobDataPrivate *privJob = jobData->privateData;
     qemuMonitorDumpStats stats = { 0 };
     int rc;
 
@@ -12456,33 +12466,33 @@ qemuDomainGetJobInfoDumpStats(virQEMUDriver *driver,
     if (rc < 0)
         return -1;
 
-    jobInfo->stats.dump = stats;
+    privJob->stats.dump = stats;
 
-    if (qemuDomainJobInfoUpdateTime(jobInfo) < 0)
+    if (qemuDomainJobInfoUpdateTime(jobData) < 0)
         return -1;
 
-    switch (jobInfo->stats.dump.status) {
+    switch (privJob->stats.dump.status) {
     case QEMU_MONITOR_DUMP_STATUS_NONE:
     case QEMU_MONITOR_DUMP_STATUS_FAILED:
     case QEMU_MONITOR_DUMP_STATUS_LAST:
         virReportError(VIR_ERR_OPERATION_FAILED,
                        _("dump query failed, status=%d"),
-                       jobInfo->stats.dump.status);
+                       privJob->stats.dump.status);
         return -1;
         break;
 
     case QEMU_MONITOR_DUMP_STATUS_ACTIVE:
-        jobInfo->status = QEMU_DOMAIN_JOB_STATUS_ACTIVE;
+        jobData->status = VIR_DOMAIN_JOB_STATUS_ACTIVE;
         VIR_DEBUG("dump active, bytes written='%llu' remaining='%llu'",
-                  jobInfo->stats.dump.completed,
-                  jobInfo->stats.dump.total -
-                  jobInfo->stats.dump.completed);
+                  privJob->stats.dump.completed,
+                  privJob->stats.dump.total -
+                  privJob->stats.dump.completed);
         break;
 
     case QEMU_MONITOR_DUMP_STATUS_COMPLETED:
-        jobInfo->status = QEMU_DOMAIN_JOB_STATUS_COMPLETED;
+        jobData->status = VIR_DOMAIN_JOB_STATUS_COMPLETED;
         VIR_DEBUG("dump completed, bytes written='%llu'",
-                  jobInfo->stats.dump.completed);
+                  privJob->stats.dump.completed);
         break;
     }
 
@@ -12494,16 +12504,17 @@ static int
 qemuDomainGetJobStatsInternal(virQEMUDriver *driver,
                               virDomainObj *vm,
                               bool completed,
-                              qemuDomainJobInfo **jobInfo)
+                              virDomainJobData **jobData)
 {
     qemuDomainObjPrivate *priv = vm->privateData;
+    qemuDomainJobDataPrivate *privStats = NULL;
     int ret = -1;
 
-    *jobInfo = NULL;
+    *jobData = NULL;
 
     if (completed) {
         if (priv->job.completed && !priv->job.current)
-            *jobInfo = qemuDomainJobInfoCopy(priv->job.completed);
+            *jobData = virDomainJobDataCopy(priv->job.completed);
 
         return 0;
     }
@@ -12525,22 +12536,24 @@ qemuDomainGetJobStatsInternal(virQEMUDriver *driver,
         ret = 0;
         goto cleanup;
     }
-    *jobInfo = qemuDomainJobInfoCopy(priv->job.current);
+    *jobData = virDomainJobDataCopy(priv->job.current);
+
+    privStats = (*jobData)->privateData;
 
-    switch ((*jobInfo)->statsType) {
+    switch (privStats->statsType) {
     case QEMU_DOMAIN_JOB_STATS_TYPE_MIGRATION:
     case QEMU_DOMAIN_JOB_STATS_TYPE_SAVEDUMP:
-        if (qemuDomainGetJobInfoMigrationStats(driver, vm, *jobInfo) < 0)
+        if (qemuDomainGetJobInfoMigrationStats(driver, vm, *jobData) < 0)
             goto cleanup;
         break;
 
     case QEMU_DOMAIN_JOB_STATS_TYPE_MEMDUMP:
-        if (qemuDomainGetJobInfoDumpStats(driver, vm, *jobInfo) < 0)
+        if (qemuDomainGetJobInfoDumpStats(driver, vm, *jobData) < 0)
             goto cleanup;
         break;
 
     case QEMU_DOMAIN_JOB_STATS_TYPE_BACKUP:
-        if (qemuBackupGetJobInfoStats(driver, vm, *jobInfo) < 0)
+        if (qemuBackupGetJobInfoStats(driver, vm, *jobData) < 0)
             goto cleanup;
         break;
 
@@ -12561,7 +12574,7 @@ qemuDomainGetJobInfo(virDomainPtr dom,
                      virDomainJobInfoPtr info)
 {
     virQEMUDriver *driver = dom->conn->privateData;
-    g_autoptr(qemuDomainJobInfo) jobInfo = NULL;
+    g_autoptr(virDomainJobData) jobData = NULL;
     virDomainObj *vm;
     int ret = -1;
 
@@ -12573,16 +12586,16 @@ qemuDomainGetJobInfo(virDomainPtr dom,
     if (virDomainGetJobInfoEnsureACL(dom->conn, vm->def) < 0)
         goto cleanup;
 
-    if (qemuDomainGetJobStatsInternal(driver, vm, false, &jobInfo) < 0)
+    if (qemuDomainGetJobStatsInternal(driver, vm, false, &jobData) < 0)
         goto cleanup;
 
-    if (!jobInfo ||
-        jobInfo->status == QEMU_DOMAIN_JOB_STATUS_NONE) {
+    if (!jobData ||
+        jobData->status == VIR_DOMAIN_JOB_STATUS_NONE) {
         ret = 0;
         goto cleanup;
     }
 
-    ret = qemuDomainJobInfoToInfo(jobInfo, info);
+    ret = qemuDomainJobInfoToInfo(jobData, info);
 
  cleanup:
     virDomainObjEndAPI(&vm);
@@ -12600,7 +12613,7 @@ qemuDomainGetJobStats(virDomainPtr dom,
     virQEMUDriver *driver = dom->conn->privateData;
     virDomainObj *vm;
     qemuDomainObjPrivate *priv;
-    g_autoptr(qemuDomainJobInfo) jobInfo = NULL;
+    g_autoptr(virDomainJobData) jobData = NULL;
     bool completed = !!(flags & VIR_DOMAIN_JOB_STATS_COMPLETED);
     int ret = -1;
 
@@ -12614,11 +12627,11 @@ qemuDomainGetJobStats(virDomainPtr dom,
         goto cleanup;
 
     priv = vm->privateData;
-    if (qemuDomainGetJobStatsInternal(driver, vm, completed, &jobInfo) < 0)
+    if (qemuDomainGetJobStatsInternal(driver, vm, completed, &jobData) < 0)
         goto cleanup;
 
-    if (!jobInfo ||
-        jobInfo->status == QEMU_DOMAIN_JOB_STATUS_NONE) {
+    if (!jobData ||
+        jobData->status == VIR_DOMAIN_JOB_STATUS_NONE) {
         *type = VIR_DOMAIN_JOB_NONE;
         *params = NULL;
         *nparams = 0;
@@ -12626,10 +12639,10 @@ qemuDomainGetJobStats(virDomainPtr dom,
         goto cleanup;
     }
 
-    ret = qemuDomainJobInfoToParams(jobInfo, type, params, nparams);
+    ret = qemuDomainJobDataToParams(jobData, type, params, nparams);
 
     if (completed && ret == 0 && !(flags & VIR_DOMAIN_JOB_STATS_KEEP_COMPLETED))
-        g_clear_pointer(&priv->job.completed, qemuDomainJobInfoFree);
+        g_clear_pointer(&priv->job.completed, virDomainJobDataFree);
 
  cleanup:
     virDomainObjEndAPI(&vm);
@@ -12695,7 +12708,7 @@ static int qemuDomainAbortJob(virDomainPtr dom)
         break;
 
     case QEMU_ASYNC_JOB_MIGRATION_OUT:
-        if ((priv->job.current->status == QEMU_DOMAIN_JOB_STATUS_POSTCOPY ||
+        if ((priv->job.current->status == VIR_DOMAIN_JOB_STATUS_POSTCOPY ||
              (virDomainObjGetState(vm, &reason) == VIR_DOMAIN_PAUSED &&
               reason == VIR_DOMAIN_PAUSED_POSTCOPY))) {
             virReportError(VIR_ERR_OPERATION_INVALID, "%s",
diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c
index 2635ef1162..7957b79fc2 100644
--- a/src/qemu/qemu_migration.c
+++ b/src/qemu/qemu_migration.c
@@ -1200,7 +1200,7 @@ qemuMigrationSrcNBDStorageCopy(virQEMUDriver *driver,
             return -1;
 
         if (priv->job.abortJob) {
-            priv->job.current->status = QEMU_DOMAIN_JOB_STATUS_CANCELED;
+            priv->job.current->status = VIR_DOMAIN_JOB_STATUS_CANCELED;
             virReportError(VIR_ERR_OPERATION_ABORTED, _("%s: %s"),
                            qemuDomainAsyncJobTypeToString(priv->job.asyncJob),
                            _("canceled by client"));
@@ -1623,35 +1623,37 @@ qemuMigrationSrcWaitForSpice(virDomainObj *vm)
 
 
 static void
-qemuMigrationUpdateJobType(qemuDomainJobInfo *jobInfo)
+qemuMigrationUpdateJobType(virDomainJobData *jobData)
 {
-    switch ((qemuMonitorMigrationStatus) jobInfo->stats.mig.status) {
+    qemuDomainJobDataPrivate *priv = jobData->privateData;
+
+    switch ((qemuMonitorMigrationStatus) priv->stats.mig.status) {
     case QEMU_MONITOR_MIGRATION_STATUS_POSTCOPY:
-        jobInfo->status = QEMU_DOMAIN_JOB_STATUS_POSTCOPY;
+        jobData->status = VIR_DOMAIN_JOB_STATUS_POSTCOPY;
         break;
 
     case QEMU_MONITOR_MIGRATION_STATUS_COMPLETED:
-        jobInfo->status = QEMU_DOMAIN_JOB_STATUS_QEMU_COMPLETED;
+        jobData->status = VIR_DOMAIN_JOB_STATUS_HYPERVISOR_COMPLETED;
         break;
 
     case QEMU_MONITOR_MIGRATION_STATUS_INACTIVE:
-        jobInfo->status = QEMU_DOMAIN_JOB_STATUS_NONE;
+        jobData->status = VIR_DOMAIN_JOB_STATUS_NONE;
         break;
 
     case QEMU_MONITOR_MIGRATION_STATUS_ERROR:
-        jobInfo->status = QEMU_DOMAIN_JOB_STATUS_FAILED;
+        jobData->status = VIR_DOMAIN_JOB_STATUS_FAILED;
         break;
 
     case QEMU_MONITOR_MIGRATION_STATUS_CANCELLED:
-        jobInfo->status = QEMU_DOMAIN_JOB_STATUS_CANCELED;
+        jobData->status = VIR_DOMAIN_JOB_STATUS_CANCELED;
         break;
 
     case QEMU_MONITOR_MIGRATION_STATUS_PRE_SWITCHOVER:
-        jobInfo->status = QEMU_DOMAIN_JOB_STATUS_PAUSED;
+        jobData->status = VIR_DOMAIN_JOB_STATUS_PAUSED;
         break;
 
     case QEMU_MONITOR_MIGRATION_STATUS_DEVICE:
-        jobInfo->status = QEMU_DOMAIN_JOB_STATUS_MIGRATING;
+        jobData->status = VIR_DOMAIN_JOB_STATUS_MIGRATING;
         break;
 
     case QEMU_MONITOR_MIGRATION_STATUS_SETUP:
@@ -1668,11 +1670,12 @@ int
 qemuMigrationAnyFetchStats(virQEMUDriver *driver,
                            virDomainObj *vm,
                            qemuDomainAsyncJob asyncJob,
-                           qemuDomainJobInfo *jobInfo,
+                           virDomainJobData *jobData,
                            char **error)
 {
     qemuDomainObjPrivate *priv = vm->privateData;
     qemuMonitorMigrationStats stats;
+    qemuDomainJobDataPrivate *privJob = jobData->privateData;
     int rv;
 
     if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
@@ -1684,7 +1687,7 @@ qemuMigrationAnyFetchStats(virQEMUDriver *driver,
     if (rv < 0)
         return -1;
 
-    jobInfo->stats.mig = stats;
+    privJob->stats.mig = stats;
 
     return 0;
 }
@@ -1725,41 +1728,42 @@ qemuMigrationJobCheckStatus(virQEMUDriver *driver,
                             qemuDomainAsyncJob asyncJob)
 {
     qemuDomainObjPrivate *priv = vm->privateData;
-    qemuDomainJobInfo *jobInfo = priv->job.current;
+    virDomainJobData *jobData = priv->job.current;
+    qemuDomainJobDataPrivate *privJob = jobData->privateData;
     g_autofree char *error = NULL;
     bool events = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATION_EVENT);
 
     if (!events ||
-        jobInfo->stats.mig.status == QEMU_MONITOR_MIGRATION_STATUS_ERROR) {
-        if (qemuMigrationAnyFetchStats(driver, vm, asyncJob, jobInfo, &error) < 0)
+        privJob->stats.mig.status == QEMU_MONITOR_MIGRATION_STATUS_ERROR) {
+        if (qemuMigrationAnyFetchStats(driver, vm, asyncJob, jobData, &error) < 0)
             return -1;
     }
 
-    qemuMigrationUpdateJobType(jobInfo);
+    qemuMigrationUpdateJobType(jobData);
 
-    switch (jobInfo->status) {
-    case QEMU_DOMAIN_JOB_STATUS_NONE:
+    switch (jobData->status) {
+    case VIR_DOMAIN_JOB_STATUS_NONE:
         virReportError(VIR_ERR_OPERATION_FAILED, _("%s: %s"),
                        qemuMigrationJobName(vm), _("is not active"));
         return -1;
 
-    case QEMU_DOMAIN_JOB_STATUS_FAILED:
+    case VIR_DOMAIN_JOB_STATUS_FAILED:
         virReportError(VIR_ERR_OPERATION_FAILED, _("%s: %s"),
                        qemuMigrationJobName(vm),
                        error ? error : _("unexpectedly failed"));
         return -1;
 
-    case QEMU_DOMAIN_JOB_STATUS_CANCELED:
+    case VIR_DOMAIN_JOB_STATUS_CANCELED:
         virReportError(VIR_ERR_OPERATION_ABORTED, _("%s: %s"),
                        qemuMigrationJobName(vm), _("canceled by client"));
         return -1;
 
-    case QEMU_DOMAIN_JOB_STATUS_COMPLETED:
-    case QEMU_DOMAIN_JOB_STATUS_ACTIVE:
-    case QEMU_DOMAIN_JOB_STATUS_MIGRATING:
-    case QEMU_DOMAIN_JOB_STATUS_QEMU_COMPLETED:
-    case QEMU_DOMAIN_JOB_STATUS_POSTCOPY:
-    case QEMU_DOMAIN_JOB_STATUS_PAUSED:
+    case VIR_DOMAIN_JOB_STATUS_COMPLETED:
+    case VIR_DOMAIN_JOB_STATUS_ACTIVE:
+    case VIR_DOMAIN_JOB_STATUS_MIGRATING:
+    case VIR_DOMAIN_JOB_STATUS_HYPERVISOR_COMPLETED:
+    case VIR_DOMAIN_JOB_STATUS_POSTCOPY:
+    case VIR_DOMAIN_JOB_STATUS_PAUSED:
         break;
     }
 
@@ -1790,7 +1794,7 @@ qemuMigrationAnyCompleted(virQEMUDriver *driver,
                           unsigned int flags)
 {
     qemuDomainObjPrivate *priv = vm->privateData;
-    qemuDomainJobInfo *jobInfo = priv->job.current;
+    virDomainJobData *jobData = priv->job.current;
     int pauseReason;
 
     if (qemuMigrationJobCheckStatus(driver, vm, asyncJob) < 0)
@@ -1820,7 +1824,7 @@ qemuMigrationAnyCompleted(virQEMUDriver *driver,
      * wait again for the real end of the migration.
      */
     if (flags & QEMU_MIGRATION_COMPLETED_PRE_SWITCHOVER &&
-        jobInfo->status == QEMU_DOMAIN_JOB_STATUS_PAUSED) {
+        jobData->status == VIR_DOMAIN_JOB_STATUS_PAUSED) {
         VIR_DEBUG("Migration paused before switchover");
         return 1;
     }
@@ -1830,38 +1834,38 @@ qemuMigrationAnyCompleted(virQEMUDriver *driver,
      * will continue waiting until the migrate state changes to completed.
      */
     if (flags & QEMU_MIGRATION_COMPLETED_POSTCOPY &&
-        jobInfo->status == QEMU_DOMAIN_JOB_STATUS_POSTCOPY) {
+        jobData->status == VIR_DOMAIN_JOB_STATUS_POSTCOPY) {
         VIR_DEBUG("Migration switched to post-copy");
         return 1;
     }
 
-    if (jobInfo->status == QEMU_DOMAIN_JOB_STATUS_QEMU_COMPLETED)
+    if (jobData->status == VIR_DOMAIN_JOB_STATUS_HYPERVISOR_COMPLETED)
         return 1;
     else
         return 0;
 
  error:
-    switch (jobInfo->status) {
-    case QEMU_DOMAIN_JOB_STATUS_MIGRATING:
-    case QEMU_DOMAIN_JOB_STATUS_POSTCOPY:
-    case QEMU_DOMAIN_JOB_STATUS_PAUSED:
+    switch (jobData->status) {
+    case VIR_DOMAIN_JOB_STATUS_MIGRATING:
+    case VIR_DOMAIN_JOB_STATUS_POSTCOPY:
+    case VIR_DOMAIN_JOB_STATUS_PAUSED:
         /* The migration was aborted by us rather than QEMU itself. */
-        jobInfo->status = QEMU_DOMAIN_JOB_STATUS_FAILED;
+        jobData->status = VIR_DOMAIN_JOB_STATUS_FAILED;
         return -2;
 
-    case QEMU_DOMAIN_JOB_STATUS_QEMU_COMPLETED:
+    case VIR_DOMAIN_JOB_STATUS_HYPERVISOR_COMPLETED:
         /* Something failed after QEMU already finished the migration. */
-        jobInfo->status = QEMU_DOMAIN_JOB_STATUS_FAILED;
+        jobData->status = VIR_DOMAIN_JOB_STATUS_FAILED;
         return -1;
 
-    case QEMU_DOMAIN_JOB_STATUS_FAILED:
-    case QEMU_DOMAIN_JOB_STATUS_CANCELED:
+    case VIR_DOMAIN_JOB_STATUS_FAILED:
+    case VIR_DOMAIN_JOB_STATUS_CANCELED:
         /* QEMU aborted the migration. */
         return -1;
 
-    case QEMU_DOMAIN_JOB_STATUS_ACTIVE:
-    case QEMU_DOMAIN_JOB_STATUS_COMPLETED:
-    case QEMU_DOMAIN_JOB_STATUS_NONE:
+    case VIR_DOMAIN_JOB_STATUS_ACTIVE:
+    case VIR_DOMAIN_JOB_STATUS_COMPLETED:
+    case VIR_DOMAIN_JOB_STATUS_NONE:
         /* Impossible. */
         break;
     }
@@ -1881,11 +1885,11 @@ qemuMigrationSrcWaitForCompletion(virQEMUDriver *driver,
                                   unsigned int flags)
 {
     qemuDomainObjPrivate *priv = vm->privateData;
-    qemuDomainJobInfo *jobInfo = priv->job.current;
+    virDomainJobData *jobData = priv->job.current;
     bool events = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATION_EVENT);
     int rv;
 
-    jobInfo->status = QEMU_DOMAIN_JOB_STATUS_MIGRATING;
+    jobData->status = VIR_DOMAIN_JOB_STATUS_MIGRATING;
 
     while ((rv = qemuMigrationAnyCompleted(driver, vm, asyncJob,
                                            dconn, flags)) != 1) {
@@ -1895,7 +1899,7 @@ qemuMigrationSrcWaitForCompletion(virQEMUDriver *driver,
         if (events) {
             if (virDomainObjWait(vm) < 0) {
                 if (virDomainObjIsActive(vm))
-                    jobInfo->status = QEMU_DOMAIN_JOB_STATUS_FAILED;
+                    jobData->status = VIR_DOMAIN_JOB_STATUS_FAILED;
                 return -2;
             }
         } else {
@@ -1909,17 +1913,17 @@ qemuMigrationSrcWaitForCompletion(virQEMUDriver *driver,
     }
 
     if (events)
-        ignore_value(qemuMigrationAnyFetchStats(driver, vm, asyncJob, jobInfo, NULL));
+        ignore_value(qemuMigrationAnyFetchStats(driver, vm, asyncJob, jobData, NULL));
 
-    qemuDomainJobInfoUpdateTime(jobInfo);
-    qemuDomainJobInfoUpdateDowntime(jobInfo);
-    g_clear_pointer(&priv->job.completed, qemuDomainJobInfoFree);
-    priv->job.completed = qemuDomainJobInfoCopy(jobInfo);
-    priv->job.completed->status = QEMU_DOMAIN_JOB_STATUS_COMPLETED;
+    qemuDomainJobInfoUpdateTime(jobData);
+    qemuDomainJobInfoUpdateDowntime(jobData);
+    g_clear_pointer(&priv->job.completed, virDomainJobDataFree);
+    priv->job.completed = virDomainJobDataCopy(jobData);
+    priv->job.completed->status = VIR_DOMAIN_JOB_STATUS_COMPLETED;
 
     if (asyncJob != QEMU_ASYNC_JOB_MIGRATION_OUT &&
-        jobInfo->status == QEMU_DOMAIN_JOB_STATUS_QEMU_COMPLETED)
-        jobInfo->status = QEMU_DOMAIN_JOB_STATUS_COMPLETED;
+        jobData->status == VIR_DOMAIN_JOB_STATUS_HYPERVISOR_COMPLETED)
+        jobData->status = VIR_DOMAIN_JOB_STATUS_COMPLETED;
 
     return 0;
 }
@@ -3385,7 +3389,7 @@ qemuMigrationSrcConfirmPhase(virQEMUDriver *driver,
     virObjectEvent *event;
     qemuDomainObjPrivate *priv = vm->privateData;
     qemuDomainJobPrivate *jobPriv = priv->job.privateData;
-    qemuDomainJobInfo *jobInfo = NULL;
+    virDomainJobData *jobData = NULL;
 
     VIR_DEBUG("driver=%p, vm=%p, cookiein=%s, cookieinlen=%d, "
               "flags=0x%x, retcode=%d",
@@ -3405,13 +3409,15 @@ qemuMigrationSrcConfirmPhase(virQEMUDriver *driver,
         return -1;
 
     if (retcode == 0)
-        jobInfo = priv->job.completed;
+        jobData = priv->job.completed;
     else
-        g_clear_pointer(&priv->job.completed, qemuDomainJobInfoFree);
+        g_clear_pointer(&priv->job.completed, virDomainJobDataFree);
 
     /* Update times with the values sent by the destination daemon */
-    if (mig->jobInfo && jobInfo) {
+    if (mig->jobData && jobData) {
         int reason;
+        qemuDomainJobDataPrivate *privJob = jobData->privateData;
+        qemuDomainJobDataPrivate *privMigJob = mig->jobData->privateData;
 
         /* We need to refresh migration statistics after a completed post-copy
          * migration since priv->job.completed contains obsolete data from the
@@ -3420,14 +3426,14 @@ qemuMigrationSrcConfirmPhase(virQEMUDriver *driver,
         if (virDomainObjGetState(vm, &reason) == VIR_DOMAIN_PAUSED &&
             reason == VIR_DOMAIN_PAUSED_POSTCOPY &&
             qemuMigrationAnyFetchStats(driver, vm, QEMU_ASYNC_JOB_MIGRATION_OUT,
-                                       jobInfo, NULL) < 0)
+                                       jobData, NULL) < 0)
             VIR_WARN("Could not refresh migration statistics");
 
-        qemuDomainJobInfoUpdateTime(jobInfo);
-        jobInfo->timeDeltaSet = mig->jobInfo->timeDeltaSet;
-        jobInfo->timeDelta = mig->jobInfo->timeDelta;
-        jobInfo->stats.mig.downtime_set = mig->jobInfo->stats.mig.downtime_set;
-        jobInfo->stats.mig.downtime = mig->jobInfo->stats.mig.downtime;
+        qemuDomainJobInfoUpdateTime(jobData);
+        jobData->timeDeltaSet = mig->jobData->timeDeltaSet;
+        jobData->timeDelta = mig->jobData->timeDelta;
+        privJob->stats.mig.downtime_set = privMigJob->stats.mig.downtime_set;
+        privJob->stats.mig.downtime = privMigJob->stats.mig.downtime;
     }
 
     if (flags & VIR_MIGRATE_OFFLINE)
@@ -4197,7 +4203,7 @@ qemuMigrationSrcRun(virQEMUDriver *driver,
         /* explicitly do this *after* we entered the monitor,
          * as this is a critical section so we are guaranteed
          * priv->job.abortJob will not change */
-        priv->job.current->status = QEMU_DOMAIN_JOB_STATUS_CANCELED;
+        priv->job.current->status = VIR_DOMAIN_JOB_STATUS_CANCELED;
         virReportError(VIR_ERR_OPERATION_ABORTED, _("%s: %s"),
                        qemuDomainAsyncJobTypeToString(priv->job.asyncJob),
                        _("canceled by client"));
@@ -4312,7 +4318,7 @@ qemuMigrationSrcRun(virQEMUDriver *driver,
      * resume it now once we finished all block jobs and wait for the real
      * end of the migration.
      */
-    if (priv->job.current->status == QEMU_DOMAIN_JOB_STATUS_PAUSED) {
+    if (priv->job.current->status == VIR_DOMAIN_JOB_STATUS_PAUSED) {
         if (qemuMigrationSrcContinue(driver, vm,
                                      QEMU_MONITOR_MIGRATION_STATUS_PRE_SWITCHOVER,
                                      QEMU_ASYNC_JOB_MIGRATION_OUT) < 0)
@@ -4373,7 +4379,7 @@ qemuMigrationSrcRun(virQEMUDriver *driver,
 
     if (virDomainObjIsActive(vm)) {
         if (cancel &&
-            priv->job.current->status != QEMU_DOMAIN_JOB_STATUS_QEMU_COMPLETED &&
+            priv->job.current->status != VIR_DOMAIN_JOB_STATUS_HYPERVISOR_COMPLETED &&
             qemuDomainObjEnterMonitorAsync(driver, vm,
                                            QEMU_ASYNC_JOB_MIGRATION_OUT) == 0) {
             qemuMonitorMigrateCancel(priv->mon);
@@ -4388,8 +4394,8 @@ qemuMigrationSrcRun(virQEMUDriver *driver,
 
         qemuMigrationSrcCancelRemoveTempBitmaps(vm, QEMU_ASYNC_JOB_MIGRATION_OUT);
 
-        if (priv->job.current->status != QEMU_DOMAIN_JOB_STATUS_CANCELED)
-            priv->job.current->status = QEMU_DOMAIN_JOB_STATUS_FAILED;
+        if (priv->job.current->status != VIR_DOMAIN_JOB_STATUS_CANCELED)
+            priv->job.current->status = VIR_DOMAIN_JOB_STATUS_FAILED;
     }
 
     if (iothread)
@@ -5625,7 +5631,7 @@ qemuMigrationDstFinish(virQEMUDriver *driver,
     unsigned short port;
     unsigned long long timeReceived = 0;
     virObjectEvent *event;
-    qemuDomainJobInfo *jobInfo = NULL;
+    virDomainJobData *jobData = NULL;
     bool inPostCopy = false;
     bool doKill = true;
 
@@ -5649,7 +5655,7 @@ qemuMigrationDstFinish(virQEMUDriver *driver,
                                        : QEMU_MIGRATION_PHASE_FINISH2);
 
     qemuDomainCleanupRemove(vm, qemuMigrationDstPrepareCleanup);
-    g_clear_pointer(&priv->job.completed, qemuDomainJobInfoFree);
+    g_clear_pointer(&priv->job.completed, virDomainJobDataFree);
 
     cookie_flags = QEMU_MIGRATION_COOKIE_NETWORK |
                    QEMU_MIGRATION_COOKIE_STATS |
@@ -5741,7 +5747,7 @@ qemuMigrationDstFinish(virQEMUDriver *driver,
             goto endjob;
     }
 
-    if (priv->job.current->status == QEMU_DOMAIN_JOB_STATUS_POSTCOPY)
+    if (priv->job.current->status == VIR_DOMAIN_JOB_STATUS_POSTCOPY)
         inPostCopy = true;
 
     if (!(flags & VIR_MIGRATE_PAUSED)) {
@@ -5777,17 +5783,17 @@ qemuMigrationDstFinish(virQEMUDriver *driver,
             doKill = false;
     }
 
-    if (mig->jobInfo) {
-        jobInfo = mig->jobInfo;
-        mig->jobInfo = NULL;
+    if (mig->jobData) {
+        jobData = mig->jobData;
+        mig->jobData = NULL;
 
-        if (jobInfo->sent && timeReceived) {
-            jobInfo->timeDelta = timeReceived - jobInfo->sent;
-            jobInfo->received = timeReceived;
-            jobInfo->timeDeltaSet = true;
+        if (jobData->sent && timeReceived) {
+            jobData->timeDelta = timeReceived - jobData->sent;
+            jobData->received = timeReceived;
+            jobData->timeDeltaSet = true;
         }
-        qemuDomainJobInfoUpdateTime(jobInfo);
-        qemuDomainJobInfoUpdateDowntime(jobInfo);
+        qemuDomainJobInfoUpdateTime(jobData);
+        qemuDomainJobInfoUpdateDowntime(jobData);
     }
 
     if (inPostCopy) {
@@ -5852,10 +5858,12 @@ qemuMigrationDstFinish(virQEMUDriver *driver,
     }
 
     if (dom) {
-        if (jobInfo) {
-            priv->job.completed = g_steal_pointer(&jobInfo);
-            priv->job.completed->status = QEMU_DOMAIN_JOB_STATUS_COMPLETED;
-            priv->job.completed->statsType = QEMU_DOMAIN_JOB_STATS_TYPE_MIGRATION;
+        if (jobData) {
+            qemuDomainJobDataPrivate *privJob = jobData->privateData;
+
+            priv->job.completed = g_steal_pointer(&jobData);
+            priv->job.completed->status = VIR_DOMAIN_JOB_STATUS_COMPLETED;
+            privJob->statsType = QEMU_DOMAIN_JOB_STATS_TYPE_MIGRATION;
         }
 
         if (qemuMigrationCookieFormat(mig, driver, vm,
@@ -5868,7 +5876,7 @@ qemuMigrationDstFinish(virQEMUDriver *driver,
          * is obsolete anyway.
          */
         if (inPostCopy)
-            g_clear_pointer(&priv->job.completed, qemuDomainJobInfoFree);
+            g_clear_pointer(&priv->job.completed, virDomainJobDataFree);
     }
 
     qemuMigrationParamsReset(driver, vm, QEMU_ASYNC_JOB_MIGRATION_IN,
@@ -5879,7 +5887,7 @@ qemuMigrationDstFinish(virQEMUDriver *driver,
         qemuDomainRemoveInactiveJob(driver, vm);
 
  cleanup:
-    g_clear_pointer(&jobInfo, qemuDomainJobInfoFree);
+    g_clear_pointer(&jobData, virDomainJobDataFree);
     virPortAllocatorRelease(port);
     if (priv->mon)
         qemuMonitorSetDomainLog(priv->mon, NULL, NULL, NULL);
@@ -6097,6 +6105,7 @@ qemuMigrationJobStart(virQEMUDriver *driver,
                       unsigned long apiFlags)
 {
     qemuDomainObjPrivate *priv = vm->privateData;
+    qemuDomainJobDataPrivate *privJob = priv->job.current->privateData;
     virDomainJobOperation op;
     unsigned long long mask;
 
@@ -6113,7 +6122,7 @@ qemuMigrationJobStart(virQEMUDriver *driver,
     if (qemuDomainObjBeginAsyncJob(driver, vm, job, op, apiFlags) < 0)
         return -1;
 
-    priv->job.current->statsType = QEMU_DOMAIN_JOB_STATS_TYPE_MIGRATION;
+    privJob->statsType = QEMU_DOMAIN_JOB_STATS_TYPE_MIGRATION;
 
     qemuDomainObjSetAsyncJobMask(vm, mask);
     return 0;
@@ -6233,13 +6242,14 @@ int
 qemuMigrationSrcFetchMirrorStats(virQEMUDriver *driver,
                                  virDomainObj *vm,
                                  qemuDomainAsyncJob asyncJob,
-                                 qemuDomainJobInfo *jobInfo)
+                                 virDomainJobData *jobData)
 {
     size_t i;
     qemuDomainObjPrivate *priv = vm->privateData;
+    qemuDomainJobDataPrivate *privJob = jobData->privateData;
     bool nbd = false;
     g_autoptr(GHashTable) blockinfo = NULL;
-    qemuDomainMirrorStats *stats = &jobInfo->mirrorStats;
+    qemuDomainMirrorStats *stats = &privJob->mirrorStats;
 
     for (i = 0; i < vm->def->ndisks; i++) {
         virDomainDiskDef *disk = vm->def->disks[i];
diff --git a/src/qemu/qemu_migration.h b/src/qemu/qemu_migration.h
index b233358a51..6b169f73c7 100644
--- a/src/qemu/qemu_migration.h
+++ b/src/qemu/qemu_migration.h
@@ -221,7 +221,7 @@ int
 qemuMigrationAnyFetchStats(virQEMUDriver *driver,
                            virDomainObj *vm,
                            qemuDomainAsyncJob asyncJob,
-                           qemuDomainJobInfo *jobInfo,
+                           virDomainJobData *jobData,
                            char **error);
 
 int
@@ -258,4 +258,4 @@ int
 qemuMigrationSrcFetchMirrorStats(virQEMUDriver *driver,
                                  virDomainObj *vm,
                                  qemuDomainAsyncJob asyncJob,
-                                 qemuDomainJobInfo *jobInfo);
+                                 virDomainJobData *jobData);
diff --git a/src/qemu/qemu_migration_cookie.c b/src/qemu/qemu_migration_cookie.c
index bffab7c13d..d1654b59c5 100644
--- a/src/qemu/qemu_migration_cookie.c
+++ b/src/qemu/qemu_migration_cookie.c
@@ -166,7 +166,7 @@ qemuMigrationCookieFree(qemuMigrationCookie *mig)
     g_free(mig->name);
     g_free(mig->lockState);
     g_free(mig->lockDriver);
-    g_clear_pointer(&mig->jobInfo, qemuDomainJobInfoFree);
+    g_clear_pointer(&mig->jobData, virDomainJobDataFree);
     virCPUDefFree(mig->cpu);
     qemuMigrationCookieCapsFree(mig->caps);
     if (mig->blockDirtyBitmaps)
@@ -531,8 +531,8 @@ qemuMigrationCookieAddStatistics(qemuMigrationCookie *mig,
     if (!priv->job.completed)
         return 0;
 
-    g_clear_pointer(&mig->jobInfo, qemuDomainJobInfoFree);
-    mig->jobInfo = qemuDomainJobInfoCopy(priv->job.completed);
+    g_clear_pointer(&mig->jobData, virDomainJobDataFree);
+    mig->jobData = virDomainJobDataCopy(priv->job.completed);
 
     mig->flags |= QEMU_MIGRATION_COOKIE_STATS;
 
@@ -632,22 +632,23 @@ qemuMigrationCookieNetworkXMLFormat(virBuffer *buf,
 
 static void
 qemuMigrationCookieStatisticsXMLFormat(virBuffer *buf,
-                                       qemuDomainJobInfo *jobInfo)
+                                       virDomainJobData *jobData)
 {
-    qemuMonitorMigrationStats *stats = &jobInfo->stats.mig;
+    qemuDomainJobDataPrivate *priv = jobData->privateData;
+    qemuMonitorMigrationStats *stats = &priv->stats.mig;
 
     virBufferAddLit(buf, "<statistics>\n");
     virBufferAdjustIndent(buf, 2);
 
-    virBufferAsprintf(buf, "<started>%llu</started>\n", jobInfo->started);
-    virBufferAsprintf(buf, "<stopped>%llu</stopped>\n", jobInfo->stopped);
-    virBufferAsprintf(buf, "<sent>%llu</sent>\n", jobInfo->sent);
-    if (jobInfo->timeDeltaSet)
-        virBufferAsprintf(buf, "<delta>%lld</delta>\n", jobInfo->timeDelta);
+    virBufferAsprintf(buf, "<started>%llu</started>\n", jobData->started);
+    virBufferAsprintf(buf, "<stopped>%llu</stopped>\n", jobData->stopped);
+    virBufferAsprintf(buf, "<sent>%llu</sent>\n", jobData->sent);
+    if (jobData->timeDeltaSet)
+        virBufferAsprintf(buf, "<delta>%lld</delta>\n", jobData->timeDelta);
 
     virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n",
                       VIR_DOMAIN_JOB_TIME_ELAPSED,
-                      jobInfo->timeElapsed);
+                      jobData->timeElapsed);
     if (stats->downtime_set)
         virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n",
                           VIR_DOMAIN_JOB_DOWNTIME,
@@ -884,8 +885,8 @@ qemuMigrationCookieXMLFormat(virQEMUDriver *driver,
     if ((mig->flags & QEMU_MIGRATION_COOKIE_NBD) && mig->nbd)
         qemuMigrationCookieNBDXMLFormat(mig->nbd, buf);
 
-    if (mig->flags & QEMU_MIGRATION_COOKIE_STATS && mig->jobInfo)
-        qemuMigrationCookieStatisticsXMLFormat(buf, mig->jobInfo);
+    if (mig->flags & QEMU_MIGRATION_COOKIE_STATS && mig->jobData)
+        qemuMigrationCookieStatisticsXMLFormat(buf, mig->jobData);
 
     if (mig->flags & QEMU_MIGRATION_COOKIE_CPU && mig->cpu)
         virCPUDefFormatBufFull(buf, mig->cpu, NULL);
@@ -1031,29 +1032,30 @@ qemuMigrationCookieNBDXMLParse(xmlXPathContextPtr ctxt)
 }
 
 
-static qemuDomainJobInfo *
+static virDomainJobData *
 qemuMigrationCookieStatisticsXMLParse(xmlXPathContextPtr ctxt)
 {
-    qemuDomainJobInfo *jobInfo = NULL;
+    virDomainJobData *jobData = NULL;
     qemuMonitorMigrationStats *stats;
+    qemuDomainJobDataPrivate *priv = NULL;
     VIR_XPATH_NODE_AUTORESTORE(ctxt)
 
     if (!(ctxt->node = virXPathNode("./statistics", ctxt)))
         return NULL;
 
-    jobInfo = g_new0(qemuDomainJobInfo, 1);
+    jobData = virDomainJobDataInit(&qemuJobDataPrivateDataCallbacks);
+    priv = jobData->privateData;
+    stats = &priv->stats.mig;
+    jobData->status = VIR_DOMAIN_JOB_STATUS_COMPLETED;
 
-    stats = &jobInfo->stats.mig;
-    jobInfo->status = QEMU_DOMAIN_JOB_STATUS_COMPLETED;
-
-    virXPathULongLong("string(./started[1])", ctxt, &jobInfo->started);
-    virXPathULongLong("string(./stopped[1])", ctxt, &jobInfo->stopped);
-    virXPathULongLong("string(./sent[1])", ctxt, &jobInfo->sent);
-    if (virXPathLongLong("string(./delta[1])", ctxt, &jobInfo->timeDelta) == 0)
-        jobInfo->timeDeltaSet = true;
+    virXPathULongLong("string(./started[1])", ctxt, &jobData->started);
+    virXPathULongLong("string(./stopped[1])", ctxt, &jobData->stopped);
+    virXPathULongLong("string(./sent[1])", ctxt, &jobData->sent);
+    if (virXPathLongLong("string(./delta[1])", ctxt, &jobData->timeDelta) == 0)
+        jobData->timeDeltaSet = true;
 
     virXPathULongLong("string(./" VIR_DOMAIN_JOB_TIME_ELAPSED "[1])",
-                      ctxt, &jobInfo->timeElapsed);
+                      ctxt, &jobData->timeElapsed);
 
     if (virXPathULongLong("string(./" VIR_DOMAIN_JOB_DOWNTIME "[1])",
                           ctxt, &stats->downtime) == 0)
@@ -1113,7 +1115,7 @@ qemuMigrationCookieStatisticsXMLParse(xmlXPathContextPtr ctxt)
     virXPathInt("string(./" VIR_DOMAIN_JOB_AUTO_CONVERGE_THROTTLE "[1])",
                 ctxt, &stats->cpu_throttle_percentage);
 
-    return jobInfo;
+    return jobData;
 }
 
 
@@ -1385,7 +1387,7 @@ qemuMigrationCookieXMLParse(qemuMigrationCookie *mig,
 
     if (flags & QEMU_MIGRATION_COOKIE_STATS &&
         virXPathBoolean("boolean(./statistics)", ctxt) &&
-        (!(mig->jobInfo = qemuMigrationCookieStatisticsXMLParse(ctxt))))
+        (!(mig->jobData = qemuMigrationCookieStatisticsXMLParse(ctxt))))
         return -1;
 
     if (flags & QEMU_MIGRATION_COOKIE_CPU &&
@@ -1546,8 +1548,8 @@ qemuMigrationCookieParse(virQEMUDriver *driver,
         }
     }
 
-    if (flags & QEMU_MIGRATION_COOKIE_STATS && mig->jobInfo && priv->job.current)
-        mig->jobInfo->operation = priv->job.current->operation;
+    if (flags & QEMU_MIGRATION_COOKIE_STATS && mig->jobData && priv->job.current)
+        mig->jobData->operation = priv->job.current->operation;
 
     return g_steal_pointer(&mig);
 }
diff --git a/src/qemu/qemu_migration_cookie.h b/src/qemu/qemu_migration_cookie.h
index 1726e5f2da..d9e1d949a8 100644
--- a/src/qemu/qemu_migration_cookie.h
+++ b/src/qemu/qemu_migration_cookie.h
@@ -162,7 +162,7 @@ struct _qemuMigrationCookie {
     qemuMigrationCookieNBD *nbd;
 
     /* If (flags & QEMU_MIGRATION_COOKIE_STATS) */
-    qemuDomainJobInfo *jobInfo;
+    virDomainJobData *jobData;
 
     /* If flags & QEMU_MIGRATION_COOKIE_CPU */
     virCPUDef *cpu;
diff --git a/src/qemu/qemu_process.c b/src/qemu/qemu_process.c
index 7ff4dc1835..fb7a04139a 100644
--- a/src/qemu/qemu_process.c
+++ b/src/qemu/qemu_process.c
@@ -650,7 +650,7 @@ qemuProcessHandleStop(qemuMonitor *mon G_GNUC_UNUSED,
     if (virDomainObjGetState(vm, NULL) == VIR_DOMAIN_RUNNING &&
         !priv->pausedShutdown) {
         if (priv->job.asyncJob == QEMU_ASYNC_JOB_MIGRATION_OUT) {
-            if (priv->job.current->status == QEMU_DOMAIN_JOB_STATUS_POSTCOPY)
+            if (priv->job.current->status == VIR_DOMAIN_JOB_STATUS_POSTCOPY)
                 reason = VIR_DOMAIN_PAUSED_POSTCOPY;
             else
                 reason = VIR_DOMAIN_PAUSED_MIGRATION;
@@ -1544,6 +1544,7 @@ qemuProcessHandleMigrationStatus(qemuMonitor *mon G_GNUC_UNUSED,
                                  void *opaque)
 {
     qemuDomainObjPrivate *priv;
+    qemuDomainJobDataPrivate *privJob = NULL;
     virQEMUDriver *driver = opaque;
     virObjectEvent *event = NULL;
     int reason;
@@ -1560,7 +1561,9 @@ qemuProcessHandleMigrationStatus(qemuMonitor *mon G_GNUC_UNUSED,
         goto cleanup;
     }
 
-    priv->job.current->stats.mig.status = status;
+    privJob = priv->job.current->privateData;
+
+    privJob->stats.mig.status = status;
     virDomainObjBroadcast(vm);
 
     if (status == QEMU_MONITOR_MIGRATION_STATUS_POSTCOPY &&
@@ -1622,6 +1625,7 @@ qemuProcessHandleDumpCompleted(qemuMonitor *mon G_GNUC_UNUSED,
 {
     qemuDomainObjPrivate *priv;
     qemuDomainJobPrivate *jobPriv;
+    qemuDomainJobDataPrivate *privJobCurrent = NULL;
 
     virObjectLock(vm);
 
@@ -1630,18 +1634,19 @@ qemuProcessHandleDumpCompleted(qemuMonitor *mon G_GNUC_UNUSED,
 
     priv = vm->privateData;
     jobPriv = priv->job.privateData;
+    privJobCurrent = priv->job.current->privateData;
     if (priv->job.asyncJob == QEMU_ASYNC_JOB_NONE) {
         VIR_DEBUG("got DUMP_COMPLETED event without a dump_completed job");
         goto cleanup;
     }
     jobPriv->dumpCompleted = true;
-    priv->job.current->stats.dump = *stats;
+    privJobCurrent->stats.dump = *stats;
     priv->job.error = g_strdup(error);
 
     /* Force error if extracting the DUMP_COMPLETED status failed */
     if (!error && status < 0) {
         priv->job.error = g_strdup(virGetLastErrorMessage());
-        priv->job.current->stats.dump.status = QEMU_MONITOR_DUMP_STATUS_FAILED;
+        privJobCurrent->stats.dump.status = QEMU_MONITOR_DUMP_STATUS_FAILED;
     }
 
     virDomainObjBroadcast(vm);
@@ -3592,6 +3597,7 @@ qemuProcessRecoverJob(virQEMUDriver *driver,
                       unsigned int *stopFlags)
 {
     qemuDomainObjPrivate *priv = vm->privateData;
+    qemuDomainJobDataPrivate *privDataJobCurrent = NULL;
     virDomainState state;
     int reason;
     unsigned long long now;
@@ -3659,10 +3665,12 @@ qemuProcessRecoverJob(virQEMUDriver *driver,
         /* We reset the job parameters for backup so that the job will look
          * active. This is possible because we are able to recover the state
          * of blockjobs and also the backup job allows all sub-job types */
-        priv->job.current = g_new0(qemuDomainJobInfo, 1);
+        priv->job.current = virDomainJobDataInit(&qemuJobDataPrivateDataCallbacks);
+        privDataJobCurrent = priv->job.current->privateData;
+
         priv->job.current->operation = VIR_DOMAIN_JOB_OPERATION_BACKUP;
-        priv->job.current->statsType = QEMU_DOMAIN_JOB_STATS_TYPE_BACKUP;
-        priv->job.current->status = QEMU_DOMAIN_JOB_STATUS_ACTIVE;
+        privDataJobCurrent->statsType = QEMU_DOMAIN_JOB_STATS_TYPE_BACKUP;
+        priv->job.current->status = VIR_DOMAIN_JOB_STATUS_ACTIVE;
         priv->job.current->started = now;
         break;
 
@@ -8280,7 +8288,7 @@ void qemuProcessStop(virQEMUDriver *driver,
 
     /* clean up a possible backup job */
     if (priv->backup)
-        qemuBackupJobTerminate(vm, QEMU_DOMAIN_JOB_STATUS_CANCELED);
+        qemuBackupJobTerminate(vm, VIR_DOMAIN_JOB_STATUS_CANCELED);
 
     /* Do this explicitly after vm->pid is reset so that security drivers don't
      * try to enter the domain's namespace which is non-existent by now as qemu
diff --git a/src/qemu/qemu_snapshot.c b/src/qemu/qemu_snapshot.c
index 1887c70708..6f9aedace7 100644
--- a/src/qemu/qemu_snapshot.c
+++ b/src/qemu/qemu_snapshot.c
@@ -1414,11 +1414,13 @@ qemuSnapshotCreateActiveExternal(virQEMUDriver *driver,
 
     /* do the memory snapshot if necessary */
     if (memory) {
+        qemuDomainJobDataPrivate *privJobCurrent = priv->job.current->privateData;
+
         /* check if migration is possible */
         if (!qemuMigrationSrcIsAllowed(driver, vm, false, 0))
             goto cleanup;
 
-        priv->job.current->statsType = QEMU_DOMAIN_JOB_STATS_TYPE_SAVEDUMP;
+        privJobCurrent->statsType = QEMU_DOMAIN_JOB_STATS_TYPE_SAVEDUMP;
 
         /* allow the migration job to be cancelled or the domain to be paused */
         qemuDomainObjSetAsyncJobMask(vm, (QEMU_JOB_DEFAULT_MASK |
-- 
2.34.1





[Index of Archives]     [Virt Tools]     [Libvirt Users]     [Lib OS Info]     [Fedora Users]     [Fedora Desktop]     [Fedora SELinux]     [Big List of Linux Books]     [Yosemite News]     [KDE Users]     [Fedora Tools]

  Powered by Linux