External/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2025-02-08 12:41:29 +00:00
Code Issues Packages Projects Releases Wiki Activity

qemu: Rename qemuMonitorMigrationStatus struct

Browse Source 
The structure actually contains migration statistics rather than just
the status as the name suggests. Renaming it as
qemuMonitorMigrationStats removes the confusion.

Signed-off-by: Jiri Denemark <jdenemar@redhat.com>
This commit is contained in:
Jiri Denemark 2015-11-26 13:23:08 +01:00
parent 5fed699a2d
commit 09bbd96239
12 changed files with 176 additions and 176 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

84
src/qemu/qemu_domain.c
View File

@ -262,8 +262,8 @@ qemuDomainJobInfoUpdateDowntime(qemuDomainJobInfoPtr jobInfo)
return 0; return 0;
} }
jobInfo->status.downtime = now - jobInfo->stopped; jobInfo->stats.downtime = now - jobInfo->stopped;
jobInfo->status.downtime_set = true; jobInfo->stats.downtime_set = true;
return 0; return 0;
} }
@ -275,13 +275,13 @@ qemuDomainJobInfoToInfo(qemuDomainJobInfoPtr jobInfo,
info->timeElapsed = jobInfo->timeElapsed; info->timeElapsed = jobInfo->timeElapsed;
info->timeRemaining = jobInfo->timeRemaining; info->timeRemaining = jobInfo->timeRemaining;
info->memTotal = jobInfo->status.ram_total; info->memTotal = jobInfo->stats.ram_total;
info->memRemaining = jobInfo->status.ram_remaining; info->memRemaining = jobInfo->stats.ram_remaining;
info->memProcessed = jobInfo->status.ram_transferred; info->memProcessed = jobInfo->stats.ram_transferred;
info->fileTotal = jobInfo->status.disk_total; info->fileTotal = jobInfo->stats.disk_total;
info->fileRemaining = jobInfo->status.disk_remaining; info->fileRemaining = jobInfo->stats.disk_remaining;
info->fileProcessed = jobInfo->status.disk_transferred; info->fileProcessed = jobInfo->stats.disk_transferred;
info->dataTotal = info->memTotal + info->fileTotal; info->dataTotal = info->memTotal + info->fileTotal;
info->dataRemaining = info->memRemaining + info->fileRemaining; info->dataRemaining = info->memRemaining + info->fileRemaining;
@ -296,7 +296,7 @@ qemuDomainJobInfoToParams(qemuDomainJobInfoPtr jobInfo,
virTypedParameterPtr *params, virTypedParameterPtr *params,
int *nparams) int *nparams)
{ {
qemuMonitorMigrationStatus *status = &jobInfo->status; qemuMonitorMigrationStats *stats = &jobInfo->stats;
virTypedParameterPtr par = NULL; virTypedParameterPtr par = NULL;
int maxpar = 0; int maxpar = 0;
int npar = 0; int npar = 0;
@ -319,103 +319,103 @@ qemuDomainJobInfoToParams(qemuDomainJobInfoPtr jobInfo,
jobInfo->timeRemaining) < 0) jobInfo->timeRemaining) < 0)
goto error; goto error;
if (status->downtime_set && if (stats->downtime_set &&
virTypedParamsAddULLong(&par, &npar, &maxpar, virTypedParamsAddULLong(&par, &npar, &maxpar,
VIR_DOMAIN_JOB_DOWNTIME, VIR_DOMAIN_JOB_DOWNTIME,
status->downtime) < 0) stats->downtime) < 0)
goto error; goto error;
if (status->downtime_set && if (stats->downtime_set &&
jobInfo->timeDeltaSet && jobInfo->timeDeltaSet &&
status->downtime > jobInfo->timeDelta && stats->downtime > jobInfo->timeDelta &&
virTypedParamsAddULLong(&par, &npar, &maxpar, virTypedParamsAddULLong(&par, &npar, &maxpar,
VIR_DOMAIN_JOB_DOWNTIME_NET, VIR_DOMAIN_JOB_DOWNTIME_NET,
status->downtime - jobInfo->timeDelta) < 0) stats->downtime - jobInfo->timeDelta) < 0)
goto error; goto error;
if (status->setup_time_set && if (stats->setup_time_set &&
virTypedParamsAddULLong(&par, &npar, &maxpar, virTypedParamsAddULLong(&par, &npar, &maxpar,
VIR_DOMAIN_JOB_SETUP_TIME, VIR_DOMAIN_JOB_SETUP_TIME,
status->setup_time) < 0) stats->setup_time) < 0)
goto error; goto error;
if (virTypedParamsAddULLong(&par, &npar, &maxpar, if (virTypedParamsAddULLong(&par, &npar, &maxpar,
VIR_DOMAIN_JOB_DATA_TOTAL, VIR_DOMAIN_JOB_DATA_TOTAL,
status->ram_total + stats->ram_total +
status->disk_total) < 0 || stats->disk_total) < 0 ||
virTypedParamsAddULLong(&par, &npar, &maxpar, virTypedParamsAddULLong(&par, &npar, &maxpar,
VIR_DOMAIN_JOB_DATA_PROCESSED, VIR_DOMAIN_JOB_DATA_PROCESSED,
status->ram_transferred + stats->ram_transferred +
status->disk_transferred) < 0 || stats->disk_transferred) < 0 ||
virTypedParamsAddULLong(&par, &npar, &maxpar, virTypedParamsAddULLong(&par, &npar, &maxpar,
VIR_DOMAIN_JOB_DATA_REMAINING, VIR_DOMAIN_JOB_DATA_REMAINING,
status->ram_remaining + stats->ram_remaining +
status->disk_remaining) < 0) stats->disk_remaining) < 0)
goto error; goto error;
if (virTypedParamsAddULLong(&par, &npar, &maxpar, if (virTypedParamsAddULLong(&par, &npar, &maxpar,
VIR_DOMAIN_JOB_MEMORY_TOTAL, VIR_DOMAIN_JOB_MEMORY_TOTAL,
status->ram_total) < 0 || stats->ram_total) < 0 ||
virTypedParamsAddULLong(&par, &npar, &maxpar, virTypedParamsAddULLong(&par, &npar, &maxpar,
VIR_DOMAIN_JOB_MEMORY_PROCESSED, VIR_DOMAIN_JOB_MEMORY_PROCESSED,
status->ram_transferred) < 0 || stats->ram_transferred) < 0 ||
virTypedParamsAddULLong(&par, &npar, &maxpar, virTypedParamsAddULLong(&par, &npar, &maxpar,
VIR_DOMAIN_JOB_MEMORY_REMAINING, VIR_DOMAIN_JOB_MEMORY_REMAINING,
status->ram_remaining) < 0) stats->ram_remaining) < 0)
goto error; goto error;
if (status->ram_bps && if (stats->ram_bps &&
virTypedParamsAddULLong(&par, &npar, &maxpar, virTypedParamsAddULLong(&par, &npar, &maxpar,
VIR_DOMAIN_JOB_MEMORY_BPS, VIR_DOMAIN_JOB_MEMORY_BPS,
status->ram_bps) < 0) stats->ram_bps) < 0)
goto error; goto error;
if (status->ram_duplicate_set) { if (stats->ram_duplicate_set) {
if (virTypedParamsAddULLong(&par, &npar, &maxpar, if (virTypedParamsAddULLong(&par, &npar, &maxpar,
VIR_DOMAIN_JOB_MEMORY_CONSTANT, VIR_DOMAIN_JOB_MEMORY_CONSTANT,
status->ram_duplicate) < 0 || stats->ram_duplicate) < 0 ||
virTypedParamsAddULLong(&par, &npar, &maxpar, virTypedParamsAddULLong(&par, &npar, &maxpar,
VIR_DOMAIN_JOB_MEMORY_NORMAL, VIR_DOMAIN_JOB_MEMORY_NORMAL,
status->ram_normal) < 0 || stats->ram_normal) < 0 ||
virTypedParamsAddULLong(&par, &npar, &maxpar, virTypedParamsAddULLong(&par, &npar, &maxpar,
VIR_DOMAIN_JOB_MEMORY_NORMAL_BYTES, VIR_DOMAIN_JOB_MEMORY_NORMAL_BYTES,
status->ram_normal_bytes) < 0) stats->ram_normal_bytes) < 0)
goto error; goto error;
} }
if (virTypedParamsAddULLong(&par, &npar, &maxpar, if (virTypedParamsAddULLong(&par, &npar, &maxpar,
VIR_DOMAIN_JOB_DISK_TOTAL, VIR_DOMAIN_JOB_DISK_TOTAL,
status->disk_total) < 0 || stats->disk_total) < 0 ||
virTypedParamsAddULLong(&par, &npar, &maxpar, virTypedParamsAddULLong(&par, &npar, &maxpar,
VIR_DOMAIN_JOB_DISK_PROCESSED, VIR_DOMAIN_JOB_DISK_PROCESSED,
status->disk_transferred) < 0 || stats->disk_transferred) < 0 ||
virTypedParamsAddULLong(&par, &npar, &maxpar, virTypedParamsAddULLong(&par, &npar, &maxpar,
VIR_DOMAIN_JOB_DISK_REMAINING, VIR_DOMAIN_JOB_DISK_REMAINING,
status->disk_remaining) < 0) stats->disk_remaining) < 0)
goto error; goto error;
if (status->disk_bps && if (stats->disk_bps &&
virTypedParamsAddULLong(&par, &npar, &maxpar, virTypedParamsAddULLong(&par, &npar, &maxpar,
VIR_DOMAIN_JOB_DISK_BPS, VIR_DOMAIN_JOB_DISK_BPS,
status->disk_bps) < 0) stats->disk_bps) < 0)
goto error; goto error;
if (status->xbzrle_set) { if (stats->xbzrle_set) {
if (virTypedParamsAddULLong(&par, &npar, &maxpar, if (virTypedParamsAddULLong(&par, &npar, &maxpar,
VIR_DOMAIN_JOB_COMPRESSION_CACHE, VIR_DOMAIN_JOB_COMPRESSION_CACHE,
status->xbzrle_cache_size) < 0 || stats->xbzrle_cache_size) < 0 ||
virTypedParamsAddULLong(&par, &npar, &maxpar, virTypedParamsAddULLong(&par, &npar, &maxpar,
VIR_DOMAIN_JOB_COMPRESSION_BYTES, VIR_DOMAIN_JOB_COMPRESSION_BYTES,
status->xbzrle_bytes) < 0 || stats->xbzrle_bytes) < 0 ||
virTypedParamsAddULLong(&par, &npar, &maxpar, virTypedParamsAddULLong(&par, &npar, &maxpar,
VIR_DOMAIN_JOB_COMPRESSION_PAGES, VIR_DOMAIN_JOB_COMPRESSION_PAGES,
status->xbzrle_pages) < 0 || stats->xbzrle_pages) < 0 ||
virTypedParamsAddULLong(&par, &npar, &maxpar, virTypedParamsAddULLong(&par, &npar, &maxpar,
VIR_DOMAIN_JOB_COMPRESSION_CACHE_MISSES, VIR_DOMAIN_JOB_COMPRESSION_CACHE_MISSES,
status->xbzrle_cache_miss) < 0 || stats->xbzrle_cache_miss) < 0 ||
virTypedParamsAddULLong(&par, &npar, &maxpar, virTypedParamsAddULLong(&par, &npar, &maxpar,
VIR_DOMAIN_JOB_COMPRESSION_OVERFLOW, VIR_DOMAIN_JOB_COMPRESSION_OVERFLOW,
status->xbzrle_overflow) < 0) stats->xbzrle_overflow) < 0)
goto error; goto error;
} }

2
src/qemu/qemu_domain.h
View File

@ -116,7 +116,7 @@ struct _qemuDomainJobInfo {
destination. */ destination. */
bool timeDeltaSet; bool timeDeltaSet;
/* Raw values from QEMU */ /* Raw values from QEMU */
qemuMonitorMigrationStatus status; qemuMonitorMigrationStats stats;
}; };
struct qemuDomainJobObj { struct qemuDomainJobObj {

2
src/qemu/qemu_driver.c
View File

@ -13042,7 +13042,7 @@ qemuDomainGetJobStatsInternal(virQEMUDriverPtr driver,
fetch = false; fetch = false;
/* Do not ask QEMU if migration is not even running yet */ /* Do not ask QEMU if migration is not even running yet */
if (!priv->job.current || !priv->job.current->status.status) if (!priv->job.current || !priv->job.current->stats.status)
fetch = false; fetch = false;
if (fetch && if (fetch &&

100
src/qemu/qemu_migration.c
View File

@ -699,7 +699,7 @@ static void
qemuMigrationCookieStatisticsXMLFormat(virBufferPtr buf, qemuMigrationCookieStatisticsXMLFormat(virBufferPtr buf,
qemuDomainJobInfoPtr jobInfo) qemuDomainJobInfoPtr jobInfo)
{ {
qemuMonitorMigrationStatus *status = &jobInfo->status; qemuMonitorMigrationStats *stats = &jobInfo->stats;
virBufferAddLit(buf, "<statistics>\n"); virBufferAddLit(buf, "<statistics>\n");
virBufferAdjustIndent(buf, 2); virBufferAdjustIndent(buf, 2);
@ -716,69 +716,69 @@ qemuMigrationCookieStatisticsXMLFormat(virBufferPtr buf,
virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n", virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n",
VIR_DOMAIN_JOB_TIME_REMAINING, VIR_DOMAIN_JOB_TIME_REMAINING,
jobInfo->timeRemaining); jobInfo->timeRemaining);
if (status->downtime_set) if (stats->downtime_set)
virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n", virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n",
VIR_DOMAIN_JOB_DOWNTIME, VIR_DOMAIN_JOB_DOWNTIME,
status->downtime); stats->downtime);
if (status->setup_time_set) if (stats->setup_time_set)
virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n", virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n",
VIR_DOMAIN_JOB_SETUP_TIME, VIR_DOMAIN_JOB_SETUP_TIME,
status->setup_time); stats->setup_time);
virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n", virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n",
VIR_DOMAIN_JOB_MEMORY_TOTAL, VIR_DOMAIN_JOB_MEMORY_TOTAL,
status->ram_total); stats->ram_total);
virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n", virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n",
VIR_DOMAIN_JOB_MEMORY_PROCESSED, VIR_DOMAIN_JOB_MEMORY_PROCESSED,
status->ram_transferred); stats->ram_transferred);
virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n", virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n",
VIR_DOMAIN_JOB_MEMORY_REMAINING, VIR_DOMAIN_JOB_MEMORY_REMAINING,
status->ram_remaining); stats->ram_remaining);
virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n", virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n",
VIR_DOMAIN_JOB_MEMORY_BPS, VIR_DOMAIN_JOB_MEMORY_BPS,
status->ram_bps); stats->ram_bps);
if (status->ram_duplicate_set) { if (stats->ram_duplicate_set) {
virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n", virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n",
VIR_DOMAIN_JOB_MEMORY_CONSTANT, VIR_DOMAIN_JOB_MEMORY_CONSTANT,
status->ram_duplicate); stats->ram_duplicate);
virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n", virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n",
VIR_DOMAIN_JOB_MEMORY_NORMAL, VIR_DOMAIN_JOB_MEMORY_NORMAL,
status->ram_normal); stats->ram_normal);
virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n", virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n",
VIR_DOMAIN_JOB_MEMORY_NORMAL_BYTES, VIR_DOMAIN_JOB_MEMORY_NORMAL_BYTES,
status->ram_normal_bytes); stats->ram_normal_bytes);
} }
virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n", virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n",
VIR_DOMAIN_JOB_DISK_TOTAL, VIR_DOMAIN_JOB_DISK_TOTAL,
status->disk_total); stats->disk_total);
virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n", virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n",
VIR_DOMAIN_JOB_DISK_PROCESSED, VIR_DOMAIN_JOB_DISK_PROCESSED,
status->disk_transferred); stats->disk_transferred);
virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n", virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n",
VIR_DOMAIN_JOB_DISK_REMAINING, VIR_DOMAIN_JOB_DISK_REMAINING,
status->disk_remaining); stats->disk_remaining);
virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n", virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n",
VIR_DOMAIN_JOB_DISK_BPS, VIR_DOMAIN_JOB_DISK_BPS,
status->disk_bps); stats->disk_bps);
if (status->xbzrle_set) { if (stats->xbzrle_set) {
virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n", virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n",
VIR_DOMAIN_JOB_COMPRESSION_CACHE, VIR_DOMAIN_JOB_COMPRESSION_CACHE,
status->xbzrle_cache_size); stats->xbzrle_cache_size);
virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n", virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n",
VIR_DOMAIN_JOB_COMPRESSION_BYTES, VIR_DOMAIN_JOB_COMPRESSION_BYTES,
status->xbzrle_bytes); stats->xbzrle_bytes);
virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n", virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n",
VIR_DOMAIN_JOB_COMPRESSION_PAGES, VIR_DOMAIN_JOB_COMPRESSION_PAGES,
status->xbzrle_pages); stats->xbzrle_pages);
virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n", virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n",
VIR_DOMAIN_JOB_COMPRESSION_CACHE_MISSES, VIR_DOMAIN_JOB_COMPRESSION_CACHE_MISSES,
status->xbzrle_cache_miss); stats->xbzrle_cache_miss);
virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n", virBufferAsprintf(buf, "<%1$s>%2$llu</%1$s>\n",
VIR_DOMAIN_JOB_COMPRESSION_OVERFLOW, VIR_DOMAIN_JOB_COMPRESSION_OVERFLOW,
status->xbzrle_overflow); stats->xbzrle_overflow);
} }
virBufferAdjustIndent(buf, -2); virBufferAdjustIndent(buf, -2);
@ -1053,7 +1053,7 @@ static qemuDomainJobInfoPtr
qemuMigrationCookieStatisticsXMLParse(xmlXPathContextPtr ctxt) qemuMigrationCookieStatisticsXMLParse(xmlXPathContextPtr ctxt)
{ {
qemuDomainJobInfoPtr jobInfo = NULL; qemuDomainJobInfoPtr jobInfo = NULL;
qemuMonitorMigrationStatus *status; qemuMonitorMigrationStats *stats;
xmlNodePtr save_ctxt = ctxt->node; xmlNodePtr save_ctxt = ctxt->node;
if (!(ctxt->node = virXPathNode("./statistics", ctxt))) if (!(ctxt->node = virXPathNode("./statistics", ctxt)))
@ -1062,7 +1062,7 @@ qemuMigrationCookieStatisticsXMLParse(xmlXPathContextPtr ctxt)
if (VIR_ALLOC(jobInfo) < 0) if (VIR_ALLOC(jobInfo) < 0)
goto cleanup; goto cleanup;
status = &jobInfo->status; stats = &jobInfo->stats;
jobInfo->type = VIR_DOMAIN_JOB_COMPLETED; jobInfo->type = VIR_DOMAIN_JOB_COMPLETED;
virXPathULongLong("string(./started[1])", ctxt, &jobInfo->started); virXPathULongLong("string(./started[1])", ctxt, &jobInfo->started);
@ -1077,49 +1077,49 @@ qemuMigrationCookieStatisticsXMLParse(xmlXPathContextPtr ctxt)
ctxt, &jobInfo->timeRemaining); ctxt, &jobInfo->timeRemaining);
if (virXPathULongLong("string(./" VIR_DOMAIN_JOB_DOWNTIME "[1])", if (virXPathULongLong("string(./" VIR_DOMAIN_JOB_DOWNTIME "[1])",
ctxt, &status->downtime) == 0) ctxt, &stats->downtime) == 0)
status->downtime_set = true; stats->downtime_set = true;
if (virXPathULongLong("string(./" VIR_DOMAIN_JOB_SETUP_TIME "[1])", if (virXPathULongLong("string(./" VIR_DOMAIN_JOB_SETUP_TIME "[1])",
ctxt, &status->setup_time) == 0) ctxt, &stats->setup_time) == 0)
status->setup_time_set = true; stats->setup_time_set = true;
virXPathULongLong("string(./" VIR_DOMAIN_JOB_MEMORY_TOTAL "[1])", virXPathULongLong("string(./" VIR_DOMAIN_JOB_MEMORY_TOTAL "[1])",
ctxt, &status->ram_total); ctxt, &stats->ram_total);
virXPathULongLong("string(./" VIR_DOMAIN_JOB_MEMORY_PROCESSED "[1])", virXPathULongLong("string(./" VIR_DOMAIN_JOB_MEMORY_PROCESSED "[1])",
ctxt, &status->ram_transferred); ctxt, &stats->ram_transferred);
virXPathULongLong("string(./" VIR_DOMAIN_JOB_MEMORY_REMAINING "[1])", virXPathULongLong("string(./" VIR_DOMAIN_JOB_MEMORY_REMAINING "[1])",
ctxt, &status->ram_remaining); ctxt, &stats->ram_remaining);
virXPathULongLong("string(./" VIR_DOMAIN_JOB_MEMORY_BPS "[1])", virXPathULongLong("string(./" VIR_DOMAIN_JOB_MEMORY_BPS "[1])",
ctxt, &status->ram_bps); ctxt, &stats->ram_bps);
if (virXPathULongLong("string(./" VIR_DOMAIN_JOB_MEMORY_CONSTANT "[1])", if (virXPathULongLong("string(./" VIR_DOMAIN_JOB_MEMORY_CONSTANT "[1])",
ctxt, &status->ram_duplicate) == 0) ctxt, &stats->ram_duplicate) == 0)
status->ram_duplicate_set = true; stats->ram_duplicate_set = true;
virXPathULongLong("string(./" VIR_DOMAIN_JOB_MEMORY_NORMAL "[1])", virXPathULongLong("string(./" VIR_DOMAIN_JOB_MEMORY_NORMAL "[1])",
ctxt, &status->ram_normal); ctxt, &stats->ram_normal);
virXPathULongLong("string(./" VIR_DOMAIN_JOB_MEMORY_NORMAL_BYTES "[1])", virXPathULongLong("string(./" VIR_DOMAIN_JOB_MEMORY_NORMAL_BYTES "[1])",
ctxt, &status->ram_normal_bytes); ctxt, &stats->ram_normal_bytes);
virXPathULongLong("string(./" VIR_DOMAIN_JOB_DISK_TOTAL "[1])", virXPathULongLong("string(./" VIR_DOMAIN_JOB_DISK_TOTAL "[1])",
ctxt, &status->disk_total); ctxt, &stats->disk_total);
virXPathULongLong("string(./" VIR_DOMAIN_JOB_DISK_PROCESSED "[1])", virXPathULongLong("string(./" VIR_DOMAIN_JOB_DISK_PROCESSED "[1])",
ctxt, &status->disk_transferred); ctxt, &stats->disk_transferred);
virXPathULongLong("string(./" VIR_DOMAIN_JOB_DISK_REMAINING "[1])", virXPathULongLong("string(./" VIR_DOMAIN_JOB_DISK_REMAINING "[1])",
ctxt, &status->disk_remaining); ctxt, &stats->disk_remaining);
virXPathULongLong("string(./" VIR_DOMAIN_JOB_DISK_BPS "[1])", virXPathULongLong("string(./" VIR_DOMAIN_JOB_DISK_BPS "[1])",
ctxt, &status->disk_bps); ctxt, &stats->disk_bps);
if (virXPathULongLong("string(./" VIR_DOMAIN_JOB_COMPRESSION_CACHE "[1])", if (virXPathULongLong("string(./" VIR_DOMAIN_JOB_COMPRESSION_CACHE "[1])",
ctxt, &status->xbzrle_cache_size) == 0) ctxt, &stats->xbzrle_cache_size) == 0)
status->xbzrle_set = true; stats->xbzrle_set = true;
virXPathULongLong("string(./" VIR_DOMAIN_JOB_COMPRESSION_BYTES "[1])", virXPathULongLong("string(./" VIR_DOMAIN_JOB_COMPRESSION_BYTES "[1])",
ctxt, &status->xbzrle_bytes); ctxt, &stats->xbzrle_bytes);
virXPathULongLong("string(./" VIR_DOMAIN_JOB_COMPRESSION_PAGES "[1])", virXPathULongLong("string(./" VIR_DOMAIN_JOB_COMPRESSION_PAGES "[1])",
ctxt, &status->xbzrle_pages); ctxt, &stats->xbzrle_pages);
virXPathULongLong("string(./" VIR_DOMAIN_JOB_COMPRESSION_CACHE_MISSES "[1])", virXPathULongLong("string(./" VIR_DOMAIN_JOB_COMPRESSION_CACHE_MISSES "[1])",
ctxt, &status->xbzrle_cache_miss); ctxt, &stats->xbzrle_cache_miss);
virXPathULongLong("string(./" VIR_DOMAIN_JOB_COMPRESSION_OVERFLOW "[1])", virXPathULongLong("string(./" VIR_DOMAIN_JOB_COMPRESSION_OVERFLOW "[1])",
ctxt, &status->xbzrle_overflow); ctxt, &stats->xbzrle_overflow);
cleanup: cleanup:
ctxt->node = save_ctxt; ctxt->node = save_ctxt;
@ -2518,7 +2518,7 @@ qemuMigrationWaitForSpice(virDomainObjPtr vm)
static void static void
qemuMigrationUpdateJobType(qemuDomainJobInfoPtr jobInfo) qemuMigrationUpdateJobType(qemuDomainJobInfoPtr jobInfo)
{ {
switch (jobInfo->status.status) { switch (jobInfo->stats.status) {
case QEMU_MONITOR_MIGRATION_STATUS_COMPLETED: case QEMU_MONITOR_MIGRATION_STATUS_COMPLETED:
jobInfo->type = VIR_DOMAIN_JOB_COMPLETED; jobInfo->type = VIR_DOMAIN_JOB_COMPLETED;
break; break;
@ -2555,8 +2555,8 @@ qemuMigrationFetchJobStatus(virQEMUDriverPtr driver,
if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0) if (qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob) < 0)
return -1; return -1;
memset(&jobInfo->status, 0, sizeof(jobInfo->status)); memset(&jobInfo->stats, 0, sizeof(jobInfo->stats));
rv = qemuMonitorGetMigrationStatus(priv->mon, &jobInfo->status); rv = qemuMonitorGetMigrationStats(priv->mon, &jobInfo->stats);
if (qemuDomainObjExitMonitor(driver, vm) < 0 || rv < 0) if (qemuDomainObjExitMonitor(driver, vm) < 0 || rv < 0)
return -1; return -1;

8
src/qemu/qemu_monitor.c
View File

@ -2103,15 +2103,15 @@ qemuMonitorSetMigrationCacheSize(qemuMonitorPtr mon,
int int
qemuMonitorGetMigrationStatus(qemuMonitorPtr mon, qemuMonitorGetMigrationStats(qemuMonitorPtr mon,
qemuMonitorMigrationStatusPtr status) qemuMonitorMigrationStatsPtr stats)
{ {
QEMU_CHECK_MONITOR(mon); QEMU_CHECK_MONITOR(mon);
if (mon->json) if (mon->json)
return qemuMonitorJSONGetMigrationStatus(mon, status); return qemuMonitorJSONGetMigrationStats(mon, stats);
else else
return qemuMonitorTextGetMigrationStatus(mon, status); return qemuMonitorTextGetMigrationStats(mon, stats);
} }

10
src/qemu/qemu_monitor.h
View File

@ -469,9 +469,9 @@ enum {
VIR_ENUM_DECL(qemuMonitorMigrationStatus) VIR_ENUM_DECL(qemuMonitorMigrationStatus)
typedef struct _qemuMonitorMigrationStatus qemuMonitorMigrationStatus; typedef struct _qemuMonitorMigrationStats qemuMonitorMigrationStats;
typedef qemuMonitorMigrationStatus *qemuMonitorMigrationStatusPtr; typedef qemuMonitorMigrationStats *qemuMonitorMigrationStatsPtr;
struct _qemuMonitorMigrationStatus { struct _qemuMonitorMigrationStats {
int status; int status;
unsigned long long total_time; unsigned long long total_time;
/* total or expected depending on status */ /* total or expected depending on status */
@ -507,8 +507,8 @@ struct _qemuMonitorMigrationStatus {
unsigned long long xbzrle_overflow; unsigned long long xbzrle_overflow;
}; };
int qemuMonitorGetMigrationStatus(qemuMonitorPtr mon, int qemuMonitorGetMigrationStats(qemuMonitorPtr mon,
qemuMonitorMigrationStatusPtr status); qemuMonitorMigrationStatsPtr stats);
typedef enum { typedef enum {
QEMU_MONITOR_MIGRATION_CAPS_XBZRLE, QEMU_MONITOR_MIGRATION_CAPS_XBZRLE,

74
src/qemu/qemu_monitor_json.c
View File

@ -2421,8 +2421,8 @@ qemuMonitorJSONSetMigrationCacheSize(qemuMonitorPtr mon,
static int static int
qemuMonitorJSONGetMigrationStatusReply(virJSONValuePtr reply, qemuMonitorJSONGetMigrationStatsReply(virJSONValuePtr reply,
qemuMonitorMigrationStatusPtr status) qemuMonitorMigrationStatsPtr stats)
{ {
virJSONValuePtr ret; virJSONValuePtr ret;
const char *statusstr; const char *statusstr;
@ -2441,32 +2441,32 @@ qemuMonitorJSONGetMigrationStatusReply(virJSONValuePtr reply,
return -1; return -1;
} }
status->status = qemuMonitorMigrationStatusTypeFromString(statusstr); stats->status = qemuMonitorMigrationStatusTypeFromString(statusstr);
if (status->status < 0) { if (stats->status < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("unexpected migration status in %s"), statusstr); _("unexpected migration status in %s"), statusstr);
return -1; return -1;
} }
ignore_value(virJSONValueObjectGetNumberUlong(ret, "total-time", ignore_value(virJSONValueObjectGetNumberUlong(ret, "total-time",
&status->total_time)); &stats->total_time));
if (status->status == QEMU_MONITOR_MIGRATION_STATUS_COMPLETED) { if (stats->status == QEMU_MONITOR_MIGRATION_STATUS_COMPLETED) {
rc = virJSONValueObjectGetNumberUlong(ret, "downtime", rc = virJSONValueObjectGetNumberUlong(ret, "downtime",
&status->downtime); &stats->downtime);
} else { } else {
rc = virJSONValueObjectGetNumberUlong(ret, "expected-downtime", rc = virJSONValueObjectGetNumberUlong(ret, "expected-downtime",
&status->downtime); &stats->downtime);
} }
if (rc == 0) if (rc == 0)
status->downtime_set = true; stats->downtime_set = true;
if (virJSONValueObjectGetNumberUlong(ret, "setup-time", if (virJSONValueObjectGetNumberUlong(ret, "setup-time",
&status->setup_time) == 0) &stats->setup_time) == 0)
status->setup_time_set = true; stats->setup_time_set = true;
if (status->status == QEMU_MONITOR_MIGRATION_STATUS_ACTIVE || if (stats->status == QEMU_MONITOR_MIGRATION_STATUS_ACTIVE ||
status->status == QEMU_MONITOR_MIGRATION_STATUS_CANCELLING || stats->status == QEMU_MONITOR_MIGRATION_STATUS_CANCELLING ||
status->status == QEMU_MONITOR_MIGRATION_STATUS_COMPLETED) { stats->status == QEMU_MONITOR_MIGRATION_STATUS_COMPLETED) {
virJSONValuePtr ram = virJSONValueObjectGetObject(ret, "ram"); virJSONValuePtr ram = virJSONValueObjectGetObject(ret, "ram");
if (!ram) { if (!ram) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
@ -2475,21 +2475,21 @@ qemuMonitorJSONGetMigrationStatusReply(virJSONValuePtr reply,
} }
if (virJSONValueObjectGetNumberUlong(ram, "transferred", if (virJSONValueObjectGetNumberUlong(ram, "transferred",
&status->ram_transferred) < 0) { &stats->ram_transferred) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("migration was active, but RAM 'transferred' " _("migration was active, but RAM 'transferred' "
"data was missing")); "data was missing"));
return -1; return -1;
} }
if (virJSONValueObjectGetNumberUlong(ram, "remaining", if (virJSONValueObjectGetNumberUlong(ram, "remaining",
&status->ram_remaining) < 0) { &stats->ram_remaining) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("migration was active, but RAM 'remaining' " _("migration was active, but RAM 'remaining' "
"data was missing")); "data was missing"));
return -1; return -1;
} }
if (virJSONValueObjectGetNumberUlong(ram, "total", if (virJSONValueObjectGetNumberUlong(ram, "total",
&status->ram_total) < 0) { &stats->ram_total) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("migration was active, but RAM 'total' " _("migration was active, but RAM 'total' "
"data was missing")); "data was missing"));
@ -2499,21 +2499,21 @@ qemuMonitorJSONGetMigrationStatusReply(virJSONValuePtr reply,
if (virJSONValueObjectGetNumberDouble(ram, "mbps", &mbps) == 0 && if (virJSONValueObjectGetNumberDouble(ram, "mbps", &mbps) == 0 &&
mbps > 0) { mbps > 0) {
/* mpbs from QEMU reports Mbits/s (M as in 10^6 not Mi as 2^20) */ /* mpbs from QEMU reports Mbits/s (M as in 10^6 not Mi as 2^20) */
status->ram_bps = mbps * (1000 * 1000 / 8); stats->ram_bps = mbps * (1000 * 1000 / 8);
} }
if (virJSONValueObjectGetNumberUlong(ram, "duplicate", if (virJSONValueObjectGetNumberUlong(ram, "duplicate",
&status->ram_duplicate) == 0) &stats->ram_duplicate) == 0)
status->ram_duplicate_set = true; stats->ram_duplicate_set = true;
ignore_value(virJSONValueObjectGetNumberUlong(ram, "normal", ignore_value(virJSONValueObjectGetNumberUlong(ram, "normal",
&status->ram_normal)); &stats->ram_normal));
ignore_value(virJSONValueObjectGetNumberUlong(ram, "normal-bytes", ignore_value(virJSONValueObjectGetNumberUlong(ram, "normal-bytes",
&status->ram_normal_bytes)); &stats->ram_normal_bytes));
virJSONValuePtr disk = virJSONValueObjectGetObject(ret, "disk"); virJSONValuePtr disk = virJSONValueObjectGetObject(ret, "disk");
if (disk) { if (disk) {
rc = virJSONValueObjectGetNumberUlong(disk, "transferred", rc = virJSONValueObjectGetNumberUlong(disk, "transferred",
&status->disk_transferred); &stats->disk_transferred);
if (rc < 0) { if (rc < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("disk migration was active, but " _("disk migration was active, but "
@ -2522,7 +2522,7 @@ qemuMonitorJSONGetMigrationStatusReply(virJSONValuePtr reply,
} }
rc = virJSONValueObjectGetNumberUlong(disk, "remaining", rc = virJSONValueObjectGetNumberUlong(disk, "remaining",
&status->disk_remaining); &stats->disk_remaining);
if (rc < 0) { if (rc < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("disk migration was active, but 'remaining' " _("disk migration was active, but 'remaining' "
@ -2531,7 +2531,7 @@ qemuMonitorJSONGetMigrationStatusReply(virJSONValuePtr reply,
} }
rc = virJSONValueObjectGetNumberUlong(disk, "total", rc = virJSONValueObjectGetNumberUlong(disk, "total",
&status->disk_total); &stats->disk_total);
if (rc < 0) { if (rc < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("disk migration was active, but 'total' " _("disk migration was active, but 'total' "
@ -2542,15 +2542,15 @@ qemuMonitorJSONGetMigrationStatusReply(virJSONValuePtr reply,
if (virJSONValueObjectGetNumberDouble(disk, "mbps", &mbps) == 0 && if (virJSONValueObjectGetNumberDouble(disk, "mbps", &mbps) == 0 &&
mbps > 0) { mbps > 0) {
/* mpbs from QEMU reports Mbits/s (M as in 10^6 not Mi as 2^20) */ /* mpbs from QEMU reports Mbits/s (M as in 10^6 not Mi as 2^20) */
status->disk_bps = mbps * (1000 * 1000 / 8); stats->disk_bps = mbps * (1000 * 1000 / 8);
} }
} }
virJSONValuePtr comp = virJSONValueObjectGetObject(ret, "xbzrle-cache"); virJSONValuePtr comp = virJSONValueObjectGetObject(ret, "xbzrle-cache");
if (comp) { if (comp) {
status->xbzrle_set = true; stats->xbzrle_set = true;
rc = virJSONValueObjectGetNumberUlong(comp, "cache-size", rc = virJSONValueObjectGetNumberUlong(comp, "cache-size",
&status->xbzrle_cache_size); &stats->xbzrle_cache_size);
if (rc < 0) { if (rc < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("XBZRLE is active, but 'cache-size' data " _("XBZRLE is active, but 'cache-size' data "
@ -2559,7 +2559,7 @@ qemuMonitorJSONGetMigrationStatusReply(virJSONValuePtr reply,
} }
rc = virJSONValueObjectGetNumberUlong(comp, "bytes", rc = virJSONValueObjectGetNumberUlong(comp, "bytes",
&status->xbzrle_bytes); &stats->xbzrle_bytes);
if (rc < 0) { if (rc < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("XBZRLE is active, but 'bytes' data " _("XBZRLE is active, but 'bytes' data "
@ -2568,7 +2568,7 @@ qemuMonitorJSONGetMigrationStatusReply(virJSONValuePtr reply,
} }
rc = virJSONValueObjectGetNumberUlong(comp, "pages", rc = virJSONValueObjectGetNumberUlong(comp, "pages",
&status->xbzrle_pages); &stats->xbzrle_pages);
if (rc < 0) { if (rc < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("XBZRLE is active, but 'pages' data " _("XBZRLE is active, but 'pages' data "
@ -2577,7 +2577,7 @@ qemuMonitorJSONGetMigrationStatusReply(virJSONValuePtr reply,
} }
rc = virJSONValueObjectGetNumberUlong(comp, "cache-miss", rc = virJSONValueObjectGetNumberUlong(comp, "cache-miss",
&status->xbzrle_cache_miss); &stats->xbzrle_cache_miss);
if (rc < 0) { if (rc < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("XBZRLE is active, but 'cache-miss' data " _("XBZRLE is active, but 'cache-miss' data "
@ -2586,7 +2586,7 @@ qemuMonitorJSONGetMigrationStatusReply(virJSONValuePtr reply,
} }
rc = virJSONValueObjectGetNumberUlong(comp, "overflow", rc = virJSONValueObjectGetNumberUlong(comp, "overflow",
&status->xbzrle_overflow); &stats->xbzrle_overflow);
if (rc < 0) { if (rc < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("XBZRLE is active, but 'overflow' data " _("XBZRLE is active, but 'overflow' data "
@ -2600,15 +2600,15 @@ qemuMonitorJSONGetMigrationStatusReply(virJSONValuePtr reply,
} }
int qemuMonitorJSONGetMigrationStatus(qemuMonitorPtr mon, int qemuMonitorJSONGetMigrationStats(qemuMonitorPtr mon,
qemuMonitorMigrationStatusPtr status) qemuMonitorMigrationStatsPtr stats)
{ {
int ret; int ret;
virJSONValuePtr cmd = qemuMonitorJSONMakeCommand("query-migrate", virJSONValuePtr cmd = qemuMonitorJSONMakeCommand("query-migrate",
NULL); NULL);
virJSONValuePtr reply = NULL; virJSONValuePtr reply = NULL;
memset(status, 0, sizeof(*status)); memset(stats, 0, sizeof(*stats));
if (!cmd) if (!cmd)
return -1; return -1;
@ -2619,11 +2619,11 @@ int qemuMonitorJSONGetMigrationStatus(qemuMonitorPtr mon,
ret = qemuMonitorJSONCheckError(cmd, reply); ret = qemuMonitorJSONCheckError(cmd, reply);
if (ret == 0 && if (ret == 0 &&
qemuMonitorJSONGetMigrationStatusReply(reply, status) < 0) qemuMonitorJSONGetMigrationStatsReply(reply, stats) < 0)
ret = -1; ret = -1;
if (ret < 0) if (ret < 0)
memset(status, 0, sizeof(*status)); memset(stats, 0, sizeof(*stats));
virJSONValueFree(cmd); virJSONValueFree(cmd);
virJSONValueFree(reply); virJSONValueFree(reply);
return ret; return ret;

4
src/qemu/qemu_monitor_json.h
View File

@ -123,8 +123,8 @@ int qemuMonitorJSONGetMigrationCacheSize(qemuMonitorPtr mon,
int qemuMonitorJSONSetMigrationCacheSize(qemuMonitorPtr mon, int qemuMonitorJSONSetMigrationCacheSize(qemuMonitorPtr mon,
unsigned long long cacheSize); unsigned long long cacheSize);
int qemuMonitorJSONGetMigrationStatus(qemuMonitorPtr mon, int qemuMonitorJSONGetMigrationStats(qemuMonitorPtr mon,
qemuMonitorMigrationStatusPtr status); qemuMonitorMigrationStatsPtr stats);
int qemuMonitorJSONGetMigrationCapabilities(qemuMonitorPtr mon, int qemuMonitorJSONGetMigrationCapabilities(qemuMonitorPtr mon,
char ***capabilities); char ***capabilities);

40
src/qemu/qemu_monitor_text.c
View File

@ -1353,15 +1353,15 @@ int qemuMonitorTextSetMigrationDowntime(qemuMonitorPtr mon,
#define MIGRATION_DISK_REMAINING_PREFIX "remaining disk: " #define MIGRATION_DISK_REMAINING_PREFIX "remaining disk: "
#define MIGRATION_DISK_TOTAL_PREFIX "total disk: " #define MIGRATION_DISK_TOTAL_PREFIX "total disk: "
int qemuMonitorTextGetMigrationStatus(qemuMonitorPtr mon, int qemuMonitorTextGetMigrationStats(qemuMonitorPtr mon,
qemuMonitorMigrationStatusPtr status) qemuMonitorMigrationStatsPtr stats)
{ {
char *reply; char *reply;
char *tmp; char *tmp;
char *end; char *end;
int ret = -1; int ret = -1;
memset(status, 0, sizeof(*status)); memset(stats, 0, sizeof(*stats));
if (qemuMonitorHMPCommand(mon, "info migrate", &reply) < 0) if (qemuMonitorHMPCommand(mon, "info migrate", &reply) < 0)
return -1; return -1;
@ -1376,14 +1376,14 @@ int qemuMonitorTextGetMigrationStatus(qemuMonitorPtr mon,
} }
*end = '\0'; *end = '\0';
status->status = qemuMonitorMigrationStatusTypeFromString(tmp); stats->status = qemuMonitorMigrationStatusTypeFromString(tmp);
if (status->status < 0) { if (stats->status < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("unexpected migration status in %s"), reply); _("unexpected migration status in %s"), reply);
goto cleanup; goto cleanup;
} }
if (status->status == QEMU_MONITOR_MIGRATION_STATUS_ACTIVE) { if (stats->status == QEMU_MONITOR_MIGRATION_STATUS_ACTIVE) {
tmp = end + 1; tmp = end + 1;
if (!(tmp = strstr(tmp, MIGRATION_TRANSFER_PREFIX))) if (!(tmp = strstr(tmp, MIGRATION_TRANSFER_PREFIX)))
@ -1391,82 +1391,82 @@ int qemuMonitorTextGetMigrationStatus(qemuMonitorPtr mon,
tmp += strlen(MIGRATION_TRANSFER_PREFIX); tmp += strlen(MIGRATION_TRANSFER_PREFIX);
if (virStrToLong_ull(tmp, &end, 10, if (virStrToLong_ull(tmp, &end, 10,
&status->ram_transferred) < 0) { &stats->ram_transferred) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("cannot parse migration data transferred " _("cannot parse migration data transferred "
"statistic %s"), tmp); "statistic %s"), tmp);
goto cleanup; goto cleanup;
} }
status->ram_transferred *= 1024; stats->ram_transferred *= 1024;
tmp = end; tmp = end;
if (!(tmp = strstr(tmp, MIGRATION_REMAINING_PREFIX))) if (!(tmp = strstr(tmp, MIGRATION_REMAINING_PREFIX)))
goto done; goto done;
tmp += strlen(MIGRATION_REMAINING_PREFIX); tmp += strlen(MIGRATION_REMAINING_PREFIX);
if (virStrToLong_ull(tmp, &end, 10, &status->ram_remaining) < 0) { if (virStrToLong_ull(tmp, &end, 10, &stats->ram_remaining) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("cannot parse migration data remaining " _("cannot parse migration data remaining "
"statistic %s"), tmp); "statistic %s"), tmp);
goto cleanup; goto cleanup;
} }
status->ram_remaining *= 1024; stats->ram_remaining *= 1024;
tmp = end; tmp = end;
if (!(tmp = strstr(tmp, MIGRATION_TOTAL_PREFIX))) if (!(tmp = strstr(tmp, MIGRATION_TOTAL_PREFIX)))
goto done; goto done;
tmp += strlen(MIGRATION_TOTAL_PREFIX); tmp += strlen(MIGRATION_TOTAL_PREFIX);
if (virStrToLong_ull(tmp, &end, 10, &status->ram_total) < 0) { if (virStrToLong_ull(tmp, &end, 10, &stats->ram_total) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("cannot parse migration data total " _("cannot parse migration data total "
"statistic %s"), tmp); "statistic %s"), tmp);
goto cleanup; goto cleanup;
} }
status->ram_total *= 1024; stats->ram_total *= 1024;
tmp = end; tmp = end;
/* /*
* Check for Optional Disk Migration status * Check for Optional Disk Migration stats
*/ */
if (!(tmp = strstr(tmp, MIGRATION_DISK_TRANSFER_PREFIX))) if (!(tmp = strstr(tmp, MIGRATION_DISK_TRANSFER_PREFIX)))
goto done; goto done;
tmp += strlen(MIGRATION_DISK_TRANSFER_PREFIX); tmp += strlen(MIGRATION_DISK_TRANSFER_PREFIX);
if (virStrToLong_ull(tmp, &end, 10, if (virStrToLong_ull(tmp, &end, 10,
&status->disk_transferred) < 0) { &stats->disk_transferred) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("cannot parse disk migration data " _("cannot parse disk migration data "
"transferred statistic %s"), tmp); "transferred statistic %s"), tmp);
goto cleanup; goto cleanup;
} }
status->disk_transferred *= 1024; stats->disk_transferred *= 1024;
tmp = end; tmp = end;
if (!(tmp = strstr(tmp, MIGRATION_DISK_REMAINING_PREFIX))) if (!(tmp = strstr(tmp, MIGRATION_DISK_REMAINING_PREFIX)))
goto done; goto done;
tmp += strlen(MIGRATION_DISK_REMAINING_PREFIX); tmp += strlen(MIGRATION_DISK_REMAINING_PREFIX);
if (virStrToLong_ull(tmp, &end, 10, &status->disk_remaining) < 0) { if (virStrToLong_ull(tmp, &end, 10, &stats->disk_remaining) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("cannot parse disk migration data remaining " _("cannot parse disk migration data remaining "
"statistic %s"), tmp); "statistic %s"), tmp);
goto cleanup; goto cleanup;
} }
status->disk_remaining *= 1024; stats->disk_remaining *= 1024;
tmp = end; tmp = end;
if (!(tmp = strstr(tmp, MIGRATION_DISK_TOTAL_PREFIX))) if (!(tmp = strstr(tmp, MIGRATION_DISK_TOTAL_PREFIX)))
goto done; goto done;
tmp += strlen(MIGRATION_DISK_TOTAL_PREFIX); tmp += strlen(MIGRATION_DISK_TOTAL_PREFIX);
if (virStrToLong_ull(tmp, &end, 10, &status->disk_total) < 0) { if (virStrToLong_ull(tmp, &end, 10, &stats->disk_total) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, virReportError(VIR_ERR_INTERNAL_ERROR,
_("cannot parse disk migration data total " _("cannot parse disk migration data total "
"statistic %s"), tmp); "statistic %s"), tmp);
goto cleanup; goto cleanup;
} }
status->disk_total *= 1024; stats->disk_total *= 1024;
} }
} }
@ -1476,7 +1476,7 @@ int qemuMonitorTextGetMigrationStatus(qemuMonitorPtr mon,
cleanup: cleanup:
VIR_FREE(reply); VIR_FREE(reply);
if (ret < 0) if (ret < 0)
memset(status, 0, sizeof(*status)); memset(stats, 0, sizeof(*stats));
return ret; return ret;
} }

4
src/qemu/qemu_monitor_text.h
View File

@ -103,8 +103,8 @@ int qemuMonitorTextSetMigrationSpeed(qemuMonitorPtr mon,
int qemuMonitorTextSetMigrationDowntime(qemuMonitorPtr mon, int qemuMonitorTextSetMigrationDowntime(qemuMonitorPtr mon,
unsigned long long downtime); unsigned long long downtime);
int qemuMonitorTextGetMigrationStatus(qemuMonitorPtr mon, int qemuMonitorTextGetMigrationStats(qemuMonitorPtr mon,
qemuMonitorMigrationStatusPtr status); qemuMonitorMigrationStatsPtr stats);
int qemuMonitorTextMigrate(qemuMonitorPtr mon, int qemuMonitorTextMigrate(qemuMonitorPtr mon,
unsigned int flags, unsigned int flags,

2
src/qemu/qemu_process.c
View File

@ -1507,7 +1507,7 @@ qemuProcessHandleMigrationStatus(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
goto cleanup; goto cleanup;
} }
priv->job.current->status.status = status; priv->job.current->stats.status = status;
virDomainObjBroadcast(vm); virDomainObjBroadcast(vm);
cleanup: cleanup:

22
tests/qemumonitorjsontest.c
View File

@ -1629,23 +1629,23 @@ testQemuMonitorJSONqemuMonitorJSONGetMigrationCacheSize(const void *data)
} }
static int static int
testQemuMonitorJSONqemuMonitorJSONGetMigrationStatus(const void *data) testQemuMonitorJSONqemuMonitorJSONGetMigrationStats(const void *data)
{ {
virDomainXMLOptionPtr xmlopt = (virDomainXMLOptionPtr)data; virDomainXMLOptionPtr xmlopt = (virDomainXMLOptionPtr)data;
qemuMonitorTestPtr test = qemuMonitorTestNewSimple(true, xmlopt); qemuMonitorTestPtr test = qemuMonitorTestNewSimple(true, xmlopt);
int ret = -1; int ret = -1;
qemuMonitorMigrationStatus status, expectedStatus; qemuMonitorMigrationStats stats, expectedStats;
if (!test) if (!test)
return -1; return -1;
memset(&expectedStatus, 0, sizeof(expectedStatus)); memset(&expectedStats, 0, sizeof(expectedStats));
expectedStatus.status = QEMU_MONITOR_MIGRATION_STATUS_ACTIVE; expectedStats.status = QEMU_MONITOR_MIGRATION_STATUS_ACTIVE;
expectedStatus.total_time = 47; expectedStats.total_time = 47;
expectedStatus.ram_total = 1611038720; expectedStats.ram_total = 1611038720;
expectedStatus.ram_remaining = 1605013504; expectedStats.ram_remaining = 1605013504;
expectedStatus.ram_transferred = 3625548; expectedStats.ram_transferred = 3625548;
if (qemuMonitorTestAddItem(test, "query-migrate", if (qemuMonitorTestAddItem(test, "query-migrate",
"{" "{"
@ -1662,10 +1662,10 @@ testQemuMonitorJSONqemuMonitorJSONGetMigrationStatus(const void *data)
"}") < 0) "}") < 0)
goto cleanup; goto cleanup;
if (qemuMonitorJSONGetMigrationStatus(qemuMonitorTestGetMonitor(test), &status) < 0) if (qemuMonitorJSONGetMigrationStats(qemuMonitorTestGetMonitor(test), &stats) < 0)
goto cleanup; goto cleanup;
if (memcmp(&status, &expectedStatus, sizeof(status)) != 0) { if (memcmp(&stats, &expectedStats, sizeof(stats)) != 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s", virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
"Invalid migration status"); "Invalid migration status");
goto cleanup; goto cleanup;
@ -2333,7 +2333,7 @@ mymain(void)
DO_TEST(qemuMonitorJSONGetBlockInfo); DO_TEST(qemuMonitorJSONGetBlockInfo);
DO_TEST(qemuMonitorJSONGetBlockStatsInfo); DO_TEST(qemuMonitorJSONGetBlockStatsInfo);
DO_TEST(qemuMonitorJSONGetMigrationCacheSize); DO_TEST(qemuMonitorJSONGetMigrationCacheSize);
DO_TEST(qemuMonitorJSONGetMigrationStatus); DO_TEST(qemuMonitorJSONGetMigrationStats);
DO_TEST(qemuMonitorJSONGetChardevInfo); DO_TEST(qemuMonitorJSONGetChardevInfo);
DO_TEST(qemuMonitorJSONSetBlockIoThrottle); DO_TEST(qemuMonitorJSONSetBlockIoThrottle);
DO_TEST(qemuMonitorJSONGetTargetArch); DO_TEST(qemuMonitorJSONGetTargetArch);