--- src/qemu/qemu_migration.c | 59 ++++++++++++++++++++-- src/qemu/qemu_migration.h | 3 +- src/qemu/qemu_monitor.c | 43 ++++++++++++++++ src/qemu/qemu_monitor.h | 13 +++++ src/qemu/qemu_monitor_json.c | 118 +++++++++++++++++++++++++++++++++++++++++++ src/qemu/qemu_monitor_json.h | 5 ++ 6 files changed, 237 insertions(+), 4 deletions(-) diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c index 11d7d6c..de8dfec 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -1150,6 +1150,47 @@ qemuMigrationSetOffline(virQEMUDriverPtr driver, static int +qemuMigrationSetCompression(virQEMUDriverPtr driver, + virDomainObjPtr vm, + enum qemuDomainAsyncJob job) +{ + qemuDomainObjPrivatePtr priv = vm->privateData; + int ret; + + if (qemuDomainObjEnterMonitorAsync(driver, vm, job) < 0) + return -1; + + ret = qemuMonitorGetMigrationCapability( + priv->mon, + QEMU_MONITOR_MIGRATION_CAPS_XBZRLE); + + if (ret < 0) { + goto cleanup; + } else if (ret == 0) { + if (job == QEMU_ASYNC_JOB_MIGRATION_IN) { + virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s", + _("Compressed migration is not supported by " + "target QEMU binary")); + } else { + virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s", + _("Compressed migration is not supported by " + "source QEMU binary")); + } + ret = -1; + goto cleanup; + } + + ret = qemuMonitorSetMigrationCapability( + priv->mon, + QEMU_MONITOR_MIGRATION_CAPS_XBZRLE); + +cleanup: + qemuDomainObjExitMonitor(driver, vm); + return ret; +} + + +static int qemuMigrationUpdateJobStatus(virQEMUDriverPtr driver, virDomainObjPtr vm, const char *job, @@ -1704,13 +1745,16 @@ qemuMigrationPrepareAny(virQEMUDriverPtr driver, if (virFDStreamOpen(st, dataFD[1]) < 0) { virReportSystemError(errno, "%s", _("cannot pass pipe for tunnelled migration")); - virDomainAuditStart(vm, "migrated", false); - qemuProcessStop(driver, vm, VIR_DOMAIN_SHUTOFF_FAILED, 0); - goto endjob; + goto stop; } dataFD[1] = -1; /* 'st' owns the FD now & will close it */ } + if (flags & VIR_MIGRATE_COMPRESSED && + qemuMigrationSetCompression(driver, vm, + QEMU_ASYNC_JOB_MIGRATION_IN) < 0) + goto stop; + if (mig->lockState) { VIR_DEBUG("Received lockstate %s", mig->lockState); VIR_FREE(priv->lockState); @@ -1776,6 +1820,10 @@ cleanup: virObjectUnref(caps); return ret; +stop: + virDomainAuditStart(vm, "migrated", false); + qemuProcessStop(driver, vm, VIR_DOMAIN_SHUTOFF_FAILED, 0); + endjob: if (!qemuMigrationJobFinish(driver, vm)) { vm = NULL; @@ -2255,6 +2303,11 @@ qemuMigrationRun(virQEMUDriverPtr driver, goto cleanup; } + if (flags & VIR_MIGRATE_COMPRESSED && + qemuMigrationSetCompression(driver, vm, + QEMU_ASYNC_JOB_MIGRATION_OUT) < 0) + goto cleanup; + if (qemuDomainObjEnterMonitorAsync(driver, vm, QEMU_ASYNC_JOB_MIGRATION_OUT) < 0) goto cleanup; diff --git a/src/qemu/qemu_migration.h b/src/qemu/qemu_migration.h index 1729d73..505e911 100644 --- a/src/qemu/qemu_migration.h +++ b/src/qemu/qemu_migration.h @@ -37,7 +37,8 @@ VIR_MIGRATE_NON_SHARED_INC | \ VIR_MIGRATE_CHANGE_PROTECTION | \ VIR_MIGRATE_UNSAFE | \ - VIR_MIGRATE_OFFLINE) + VIR_MIGRATE_OFFLINE | \ + VIR_MIGRATE_COMPRESSED) enum qemuMigrationJobPhase { QEMU_MIGRATION_PHASE_NONE = 0, diff --git a/src/qemu/qemu_monitor.c b/src/qemu/qemu_monitor.c index 7af571d..631ff92 100644 --- a/src/qemu/qemu_monitor.c +++ b/src/qemu/qemu_monitor.c @@ -101,6 +101,10 @@ VIR_ENUM_IMPL(qemuMonitorMigrationStatus, QEMU_MONITOR_MIGRATION_STATUS_LAST, "inactive", "active", "completed", "failed", "cancelled") +VIR_ENUM_IMPL(qemuMonitorMigrationCaps, + QEMU_MONITOR_MIGRATION_CAPS_LAST, + "xbzrle") + VIR_ENUM_IMPL(qemuMonitorVMStatus, QEMU_MONITOR_VM_STATUS_LAST, "debug", "inmigrate", "internal-error", "io-error", "paused", @@ -3383,3 +3387,42 @@ char *qemuMonitorGetTargetArch(qemuMonitorPtr mon) return qemuMonitorJSONGetTargetArch(mon); } + + +int qemuMonitorGetMigrationCapability(qemuMonitorPtr mon, + qemuMonitorMigrationCaps capability) +{ + VIR_DEBUG("mon=%p capability=%d", mon, capability); + + if (!mon) { + virReportError(VIR_ERR_INVALID_ARG, "%s", + _("monitor must not be NULL")); + return -1; + } + + /* No capability is supported without JSON monitor */ + if (!mon->json) + return 0; + + return qemuMonitorJSONGetMigrationCapability(mon, capability); +} + +int qemuMonitorSetMigrationCapability(qemuMonitorPtr mon, + qemuMonitorMigrationCaps capability) +{ + VIR_DEBUG("mon=%p capability=%d", mon, capability); + + if (!mon) { + virReportError(VIR_ERR_INVALID_ARG, "%s", + _("monitor must not be NULL")); + return -1; + } + + if (!mon->json) { + virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s", + _("JSON monitor is required")); + return -1; + } + + return qemuMonitorJSONSetMigrationCapability(mon, capability); +} diff --git a/src/qemu/qemu_monitor.h b/src/qemu/qemu_monitor.h index ac77158..e3a4568 100644 --- a/src/qemu/qemu_monitor.h +++ b/src/qemu/qemu_monitor.h @@ -347,6 +347,19 @@ int qemuMonitorGetSpiceMigrationStatus(qemuMonitorPtr mon, bool *spice_migrated); typedef enum { + QEMU_MONITOR_MIGRATION_CAPS_XBZRLE, + + QEMU_MONITOR_MIGRATION_CAPS_LAST +} qemuMonitorMigrationCaps; + +VIR_ENUM_DECL(qemuMonitorMigrationCaps); + +int qemuMonitorGetMigrationCapability(qemuMonitorPtr mon, + qemuMonitorMigrationCaps capability); +int qemuMonitorSetMigrationCapability(qemuMonitorPtr mon, + qemuMonitorMigrationCaps capability); + +typedef enum { QEMU_MONITOR_MIGRATE_BACKGROUND = 1 << 0, QEMU_MONITOR_MIGRATE_NON_SHARED_DISK = 1 << 1, /* migration with non-shared storage with full disk copy */ QEMU_MONITOR_MIGRATE_NON_SHARED_INC = 1 << 2, /* migration with non-shared storage with incremental copy */ diff --git a/src/qemu/qemu_monitor_json.c b/src/qemu/qemu_monitor_json.c index a86d90c..545d4d4 100644 --- a/src/qemu/qemu_monitor_json.c +++ b/src/qemu/qemu_monitor_json.c @@ -4359,3 +4359,121 @@ cleanup: virJSONValueFree(reply); return ret; } + + +int +qemuMonitorJSONGetMigrationCapability(qemuMonitorPtr mon, + qemuMonitorMigrationCaps capability) +{ + int ret; + virJSONValuePtr cmd; + virJSONValuePtr reply = NULL; + virJSONValuePtr caps; + int i; + + if (!(cmd = qemuMonitorJSONMakeCommand("query-migrate-capabilities", + NULL))) + return -1; + + ret = qemuMonitorJSONCommand(mon, cmd, &reply); + + if (ret == 0) { + if (qemuMonitorJSONHasError(reply, "CommandNotFound")) + goto cleanup; + ret = qemuMonitorJSONCheckError(cmd, reply); + } + + if (ret < 0) + goto cleanup; + + ret = -1; + + caps = virJSONValueObjectGet(reply, "return"); + if (!caps || caps->type != VIR_JSON_TYPE_ARRAY) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("missing migration capabilities")); + goto cleanup; + } + + for (i = 0; i < virJSONValueArraySize(caps); i++) { + virJSONValuePtr cap = virJSONValueArrayGet(caps, i); + const char *name; + + if (!cap || cap->type != VIR_JSON_TYPE_OBJECT) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("missing entry in migration capabilities list")); + goto cleanup; + } + + if (!(name = virJSONValueObjectGetString(cap, "capability"))) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("missing migration capability name")); + goto cleanup; + } + + if (qemuMonitorMigrationCapsTypeFromString(name) == capability) { + ret = 1; + goto cleanup; + } + } + + ret = 0; + +cleanup: + virJSONValueFree(cmd); + virJSONValueFree(reply); + return ret; +} + + +int +qemuMonitorJSONSetMigrationCapability(qemuMonitorPtr mon, + qemuMonitorMigrationCaps capability) +{ + int ret = -1; + + virJSONValuePtr cmd = NULL; + virJSONValuePtr reply = NULL; + virJSONValuePtr cap = NULL; + virJSONValuePtr caps; + + if (!(caps = virJSONValueNewArray())) + goto cleanup; + + if (!(cap = virJSONValueNewObject())) + goto no_memory; + + if (virJSONValueObjectAppendString( + cap, "capability", + qemuMonitorMigrationCapsTypeToString(capability)) < 0) + goto no_memory; + + if (virJSONValueObjectAppendBoolean(cap, "state", 1) < 0) + goto no_memory; + + if (virJSONValueArrayAppend(caps, cap) < 0) + goto no_memory; + + cap = NULL; + + cmd = qemuMonitorJSONMakeCommand("migrate-set-capabilities", + "a:capabilities", caps, + NULL); + if (!cmd) + goto cleanup; + + if ((ret = qemuMonitorJSONCommand(mon, cmd, &reply)) < 0) + goto cleanup; + + ret = qemuMonitorJSONCheckError(cmd, reply); + +cleanup: + virJSONValueFree(cap); + virJSONValueFree(cmd); + virJSONValueFree(reply); + return ret; + +no_memory: + virReportOOMError(); + goto cleanup; +} diff --git a/src/qemu/qemu_monitor_json.h b/src/qemu/qemu_monitor_json.h index 925d937..356c10a 100644 --- a/src/qemu/qemu_monitor_json.h +++ b/src/qemu/qemu_monitor_json.h @@ -126,6 +126,11 @@ int qemuMonitorJSONGetMigrationStatus(qemuMonitorPtr mon, unsigned long long *remaining, unsigned long long *total); +int qemuMonitorJSONGetMigrationCapability(qemuMonitorPtr mon, + qemuMonitorMigrationCaps capability); +int qemuMonitorJSONSetMigrationCapability(qemuMonitorPtr mon, + qemuMonitorMigrationCaps capability); + int qemuMonitorJSONMigrate(qemuMonitorPtr mon, unsigned int flags, const char *uri); -- 1.8.1.2

This is an extensible version of virDomainGetJobInfo. --- include/libvirt/libvirt.h.in | 205 +++++++++++++++++++++++++++++++++++++++++++ python/generator.py | 1 + src/driver.h | 7 ++ src/libvirt.c | 58 ++++++++++++ src/libvirt_public.syms | 1 + 5 files changed, 272 insertions(+) diff --git a/include/libvirt/libvirt.h.in b/include/libvirt/libvirt.h.in index eda9e12..9d1c6ea 100644 --- a/include/libvirt/libvirt.h.in +++ b/include/libvirt/libvirt.h.in @@ -3945,9 +3945,214 @@ struct _virDomainJobInfo { int virDomainGetJobInfo(virDomainPtr dom, virDomainJobInfoPtr info); +int virDomainGetJobStats(virDomainPtr domain, + int *type, + virTypedParameterPtr *params, + int *nparams, + unsigned int flags); int virDomainAbortJob(virDomainPtr dom); /** + * VIR_DOMAIN_JOB_TIME_ELAPSED: + * + * virDomainGetJobStats field: time (ms) since the beginning of the + * job, as VIR_TYPED_PARAM_ULLONG. + * + * This field corresponds to timeElapsed field in virDomainJobInfo. + */ +#define VIR_DOMAIN_JOB_TIME_ELAPSED "time_elapsed" + +/** + * VIR_DOMAIN_JOB_TIME_REMAINING: + * + * virDomainGetJobStats field: remaining time (ms) for VIR_DOMAIN_JOB_BOUNDED + * jobs, as VIR_TYPED_PARAM_ULLONG. + * + * This field corresponds to timeRemaining field in virDomainJobInfo. + */ +#define VIR_DOMAIN_JOB_TIME_REMAINING "time_remaining" + +/** + * VIR_DOMAIN_JOB_DOWNTIME: + * + * virDomainGetJobStats field: downtime (ms) that is expected to happen + * during migration, as VIR_TYPED_PARAM_ULLONG. + */ +#define VIR_DOMAIN_JOB_DOWNTIME "downtime" + +/** + * VIR_DOMAIN_JOB_DATA_TOTAL: + * + * virDomainGetJobStats field: total number of bytes supposed to be + * transferred, as VIR_TYPED_PARAM_ULLONG. For VIR_DOMAIN_JOB_UNBOUNDED + * jobs, this may be less than the sum of VIR_DOMAIN_JOB_DATA_PROCESSED and + * VIR_DOMAIN_JOB_DATA_REMAINING in the event that the hypervisor has to + * repeat some data, e.g., due to dirtied pages during migration. For + * VIR_DOMAIN_JOB_BOUNDED jobs, VIR_DOMAIN_JOB_DATA_TOTAL shall always equal + * VIR_DOMAIN_JOB_DATA_PROCESSED + VIR_DOMAIN_JOB_DATA_REMAINING. + * + * This field corresponds to dataTotal field in virDomainJobInfo. + */ +#define VIR_DOMAIN_JOB_DATA_TOTAL "data_total" + +/** + * VIR_DOMAIN_JOB_DATA_PROCESSED: + * + * virDomainGetJobStats field: number of bytes transferred from the + * beginning of the job, as VIR_TYPED_PARAM_ULLONG. + * + * This field corresponds to dataProcessed field in virDomainJobInfo. + */ +#define VIR_DOMAIN_JOB_DATA_PROCESSED "data_processed" + +/** + * VIR_DOMAIN_JOB_DATA_REMAINING: + * + * virDomainGetJobStats field: number of bytes that still need to be + * transferred, as VIR_TYPED_PARAM_ULLONG. + * + * This field corresponds to dataRemaining field in virDomainJobInfo. + */ +#define VIR_DOMAIN_JOB_DATA_REMAINING "data_remaining" + +/** + * VIR_DOMAIN_JOB_MEMORY_TOTAL: + * + * virDomainGetJobStats field: as VIR_DOMAIN_JOB_DATA_TOTAL but only + * tracking guest memory progress, as VIR_TYPED_PARAM_ULLONG. + * + * This field corresponds to memTotal field in virDomainJobInfo. + */ +#define VIR_DOMAIN_JOB_MEMORY_TOTAL "memory_total" + +/** + * VIR_DOMAIN_JOB_MEMORY_PROCESSED: + * + * virDomainGetJobStats field: as VIR_DOMAIN_JOB_DATA_PROCESSED but only + * tracking guest memory progress, as VIR_TYPED_PARAM_ULLONG. + * + * This field corresponds to memProcessed field in virDomainJobInfo. + */ +#define VIR_DOMAIN_JOB_MEMORY_PROCESSED "memory_processed" + +/** + * VIR_DOMAIN_JOB_MEMORY_REMAINING: + * + * virDomainGetJobStats field: as VIR_DOMAIN_JOB_DATA_REMAINING but only + * tracking guest memory progress, as VIR_TYPED_PARAM_ULLONG. + * + * This field corresponds to memRemaining field in virDomainJobInfo. + */ +#define VIR_DOMAIN_JOB_MEMORY_REMAINING "memory_remaining" + +/** + * VIR_DOMAIN_JOB_MEMORY_CONSTANT: + * + * virDomainGetJobStats field: number of pages filled with a constant + * byte (all bytes in a single page are identical) transferred since the + * beginning of the migration job, as VIR_TYPED_PARAM_ULLONG. + * + * The most common example of such pages are zero pages, i.e., pages filled + * with zero bytes. + */ +#define VIR_DOMAIN_JOB_MEMORY_CONSTANT "memory_constant" + +/** + * VIR_DOMAIN_JOB_MEMORY_NORMAL: + * + * virDomainGetJobStats field: number of pages that were transferred without + * any kind of compression (i.e., pages which were not filled with a constant + * byte and which could not be compressed) transferred since the beginning + * of the migration job, as VIR_TYPED_PARAM_ULLONG. + */ +#define VIR_DOMAIN_JOB_MEMORY_NORMAL "memory_normal" + +/** + * VIR_DOMAIN_JOB_MEMORY_NORMAL_BYTES: + * + * virDomainGetJobStats field: number of bytes transferred as normal pages, + * as VIR_TYPED_PARAM_ULLONG. + * + * See VIR_DOMAIN_JOB_MEMORY_NORMAL for more details. + */ +#define VIR_DOMAIN_JOB_MEMORY_NORMAL_BYTES "memory_normal_bytes" + +/** + * VIR_DOMAIN_JOB_DISK_TOTAL: + * + * virDomainGetJobStats field: as VIR_DOMAIN_JOB_DATA_TOTAL but only + * tracking guest disk progress, as VIR_TYPED_PARAM_ULLONG. + * + * This field corresponds to fileTotal field in virDomainJobInfo. + */ +#define VIR_DOMAIN_JOB_DISK_TOTAL "disk_total" + +/** + * VIR_DOMAIN_JOB_DISK_PROCESSED: + * + * virDomainGetJobStats field: as VIR_DOMAIN_JOB_DATA_PROCESSED but only + * tracking guest memory progress, as VIR_TYPED_PARAM_ULLONG. + * + * This field corresponds to fileProcessed field in virDomainJobInfo. + */ +#define VIR_DOMAIN_JOB_DISK_PROCESSED "disk_processed" + +/** + * VIR_DOMAIN_JOB_DISK_REMAINING: + * + * virDomainGetJobStats field: as VIR_DOMAIN_JOB_DATA_REMAINING but only + * tracking guest memory progress, as VIR_TYPED_PARAM_ULLONG. + * + * This field corresponds to fileRemaining field in virDomainJobInfo. + */ +#define VIR_DOMAIN_JOB_DISK_REMAINING "disk_remaining" + +/** + * VIR_DOMAIN_JOB_COMPRESSION_CACHE: + * + * virDomainGetJobStats field: size of the cache (in bytes) used for + * compressing repeatedly transferred memory pages during live migration, + * as VIR_TYPED_PARAM_ULLONG. + */ +#define VIR_DOMAIN_JOB_COMPRESSION_CACHE "compression_cache" + +/** + * VIR_DOMAIN_JOB_COMPRESSION_BYTES: + * + * virDomainGetJobStats field: number of compressed bytes transferred + * since the beginning of migration, as VIR_TYPED_PARAM_ULLONG. + */ +#define VIR_DOMAIN_JOB_COMPRESSION_BYTES "compression_bytes" + +/** + * VIR_DOMAIN_JOB_COMPRESSION_PAGES: + * + * virDomainGetJobStats field: number of compressed pages transferred + * since the beginning of migration, as VIR_TYPED_PARAM_ULLONG. + */ +#define VIR_DOMAIN_JOB_COMPRESSION_PAGES "compression_pages" + +/** + * VIR_DOMAIN_JOB_COMPRESSION_CACHE_MISSES: + * + * virDomainGetJobStats field: number of repeatedly changing pages that + * were not found in compression cache and thus could not be compressed, + * as VIR_TYPED_PARAM_ULLONG. + */ +#define VIR_DOMAIN_JOB_COMPRESSION_CACHE_MISSES "compression_cache_misses" + +/** + * VIR_DOMAIN_JOB_COMPRESSION_OVERFLOW: + * + * virDomainGetJobStats field: number of repeatedly changing pages that + * were found in compression cache but were sent uncompressed because + * the result of compression was larger than the original page as a whole, + * as VIR_TYPED_PARAM_ULLONG. + */ +#define VIR_DOMAIN_JOB_COMPRESSION_OVERFLOW "compression_overflow" + + +/** * virDomainSnapshot: * * a virDomainSnapshot is a private structure representing a snapshot of diff --git a/python/generator.py b/python/generator.py index 02209f9..92a7f58 100755 --- a/python/generator.py +++ b/python/generator.py @@ -389,6 +389,7 @@ skip_impl = ( 'virDomainGetControlInfo', 'virDomainGetBlockInfo', 'virDomainGetJobInfo', + 'virDomainGetJobStats', 'virNodeGetInfo', 'virDomainGetUUID', 'virDomainGetUUIDString', diff --git a/src/driver.h b/src/driver.h index 8d0f0a5..71b71f6 100644 --- a/src/driver.h +++ b/src/driver.h @@ -590,6 +590,12 @@ typedef char * typedef int (*virDrvDomainGetJobInfo)(virDomainPtr domain, virDomainJobInfoPtr info); +typedef int + (*virDrvDomainGetJobStats)(virDomainPtr domain, + int *type, + virTypedParameterPtr *params, + int *nparams, + unsigned int flags); typedef int (*virDrvDomainAbortJob)(virDomainPtr domain); @@ -1060,6 +1066,7 @@ struct _virDriver { virDrvCompareCPU cpuCompare; virDrvBaselineCPU cpuBaseline; virDrvDomainGetJobInfo domainGetJobInfo; + virDrvDomainGetJobStats domainGetJobStats; virDrvDomainAbortJob domainAbortJob; virDrvDomainMigrateSetMaxDowntime domainMigrateSetMaxDowntime; virDrvDomainMigrateGetMaxSpeed domainMigrateGetMaxSpeed; diff --git a/src/libvirt.c b/src/libvirt.c index 1e78500..3611839 100644 --- a/src/libvirt.c +++ b/src/libvirt.c @@ -17399,6 +17399,64 @@ error: /** + * virDomainGetJobStats: + * @domain: a domain object + * @type: where to store the job type (one of virDomainJobType) + * @params: where to store job statistics + * @nparams: number of items in @params + * @flags: extra flags; not used yet, so callers should always pass 0 + * + * Extract information about progress of a background job on a domain. + * Will return an error if the domain is not active. The function returns + * a superset of progress information provided by virDomainGetJobInfo. + * Possible fields returned in @params are defined by VIR_DOMAIN_JOB_* + * macros. + * + * Returns 0 in case of success and -1 in case of failure. + */ +int +virDomainGetJobStats(virDomainPtr domain, + int *type, + virTypedParameterPtr *params, + int *nparams, + unsigned int flags) +{ + virConnectPtr conn; + + VIR_DOMAIN_DEBUG(domain, "type=%p, params=%p, nparams=%p, flags=%x", + type, params, nparams, flags); + + virResetLastError(); + + if (!VIR_IS_CONNECTED_DOMAIN(domain)) { + virLibDomainError(VIR_ERR_INVALID_DOMAIN, __FUNCTION__); + virDispatchError(NULL); + return -1; + } + virCheckNonNullArgGoto(type, error); + virCheckNonNullArgGoto(params, error); + virCheckNonNullArgGoto(nparams, error); + + conn = domain->conn; + + if (conn->driver->domainGetJobStats) { + int ret; + ret = conn->driver->domainGetJobStats(domain, type, params, + nparams, flags); + if (ret < 0) + goto error; + return ret; + } + + virLibConnError(VIR_ERR_NO_SUPPORT, __FUNCTION__); + +error: + virDispatchError(domain->conn); + return -1; +} + + +/** * virDomainAbortJob: * @domain: a domain object * diff --git a/src/libvirt_public.syms b/src/libvirt_public.syms index 3bdfd57..361408f 100644 --- a/src/libvirt_public.syms +++ b/src/libvirt_public.syms @@ -605,6 +605,7 @@ LIBVIRT_1.0.2 { LIBVIRT_1.0.3 { global: + virDomainGetJobStats; virNodeDeviceLookupSCSIHostByWWN; } LIBVIRT_1.0.2; -- 1.8.1.2

--- python/libvirt-override-api.xml | 6 ++++++ python/libvirt-override.c | 42 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 48 insertions(+) diff --git a/python/libvirt-override-api.xml b/python/libvirt-override-api.xml index a0e0496..446cdbd 100644 --- a/python/libvirt-override-api.xml +++ b/python/libvirt-override-api.xml @@ -84,6 +84,12 @@ <return type='int *' info='the list of information or None in case of error'/> <arg name='domain' type='virDomainPtr' info='a domain object'/> </function> + <function name='virDomainGetJobStats' file='python'> + <info>Extract information about an active job being processed for a domain.</info> + <return type='virDomainJobStats' info='dictionary mapping field names to values or None in case of error'/> + <arg name='domain' type='virDomainPtr' info='a domain object'/> + <arg name='flags' type='unsigned int' info='flags, currently unused, pass 0.'/> + </function> <function name='virNodeGetInfo' file='python'> <info>Extract hardware information about the Node.</info> <return type='int *' info='the list of information or None in case of error'/> diff --git a/python/libvirt-override.c b/python/libvirt-override.c index 8154024..ebd6878 100644 --- a/python/libvirt-override.c +++ b/python/libvirt-override.c @@ -4183,6 +4183,47 @@ libvirt_virDomainGetJobInfo(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) { } static PyObject * +libvirt_virDomainGetJobStats(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) +{ + PyObject *pyobj_domain; + virDomainPtr domain; + unsigned int flags; + virTypedParameterPtr params = NULL; + int nparams = 0; + int type; + PyObject *dict = NULL; + int rc; + + if (!PyArg_ParseTuple(args, (char *) "Oi:virDomainGetJobStats", + &pyobj_domain, &flags)) + goto cleanup; + domain = (virDomainPtr) PyvirDomain_Get(pyobj_domain); + + LIBVIRT_BEGIN_ALLOW_THREADS; + rc = virDomainGetJobStats(domain, &type, ¶ms, &nparams, flags); + LIBVIRT_END_ALLOW_THREADS; + if (rc < 0) + goto cleanup; + + if (!(dict = getPyVirTypedParameter(params, nparams))) + goto cleanup; + + if (PyDict_SetItem(dict, libvirt_constcharPtrWrap("type"), + libvirt_intWrap(type)) < 0) { + Py_DECREF(dict); + dict = NULL; + goto cleanup; + } + +cleanup: + virTypedParamsFree(params, nparams); + if (dict) + return dict; + else + return VIR_PY_NONE; +} + +static PyObject * libvirt_virDomainGetBlockJobInfo(PyObject *self ATTRIBUTE_UNUSED, PyObject *args) { @@ -6673,6 +6714,7 @@ static PyMethodDef libvirtMethods[] = { {(char *) "virConnectListAllInterfaces", libvirt_virConnectListAllInterfaces, METH_VARARGS, NULL}, {(char *) "virConnectBaselineCPU", libvirt_virConnectBaselineCPU, METH_VARARGS, NULL}, {(char *) "virDomainGetJobInfo", libvirt_virDomainGetJobInfo, METH_VARARGS, NULL}, + {(char *) "virDomainGetJobStats", libvirt_virDomainGetJobStats, METH_VARARGS, NULL}, {(char *) "virDomainSnapshotListNames", libvirt_virDomainSnapshotListNames, METH_VARARGS, NULL}, {(char *) "virDomainListAllSnapshots", libvirt_virDomainListAllSnapshots, METH_VARARGS, NULL}, {(char *) "virDomainSnapshotListChildrenNames", libvirt_virDomainSnapshotListChildrenNames, METH_VARARGS, NULL}, -- 1.8.1.2

remoteDeserializeTypedParameters can now be called with either preallocated params array (size of which is announced by nparams) or it can allocate params array according to the number of parameters received from the server. --- src/remote/remote_driver.c | 95 +++++++++++++++++++++++++++------------------- src/rpc/gendispatch.pl | 2 +- 2 files changed, 57 insertions(+), 40 deletions(-) diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c index feb372e..5a4b3c7 100644 --- a/src/remote/remote_driver.c +++ b/src/remote/remote_driver.c @@ -1543,67 +1543,78 @@ static int remoteDeserializeTypedParameters(remote_typed_param *ret_params_val, u_int ret_params_len, int limit, - virTypedParameterPtr params, + virTypedParameterPtr *params, int *nparams) { int i = 0; int rv = -1; + bool userAllocated = *params != NULL; - /* Check the length of the returned list carefully. */ - if (ret_params_len > limit || ret_params_len > *nparams) { - virReportError(VIR_ERR_RPC, "%s", - _("returned number of parameters exceeds limit")); - goto cleanup; + if (userAllocated) { + /* Check the length of the returned list carefully. */ + if (ret_params_len > limit || ret_params_len > *nparams) { + virReportError(VIR_ERR_RPC, "%s", + _("returned number of parameters exceeds limit")); + goto cleanup; + } + } else { + if (VIR_ALLOC_N(*params, ret_params_len) < 0) { + virReportOOMError(); + goto cleanup; + } } - *nparams = ret_params_len; /* Deserialise the result. */ for (i = 0; i < ret_params_len; ++i) { - if (virStrcpyStatic(params[i].field, - ret_params_val[i].field) == NULL) { + virTypedParameterPtr param = *params + i; + remote_typed_param *ret_param = ret_params_val + i; + + if (virStrcpyStatic(param->field, + ret_param->field) == NULL) { virReportError(VIR_ERR_INTERNAL_ERROR, _("Parameter %s too big for destination"), - ret_params_val[i].field); + ret_param->field); goto cleanup; } - params[i].type = ret_params_val[i].value.type; - switch (params[i].type) { + + param->type = ret_param->value.type; + switch (param->type) { case VIR_TYPED_PARAM_INT: - params[i].value.i = - ret_params_val[i].value.remote_typed_param_value_u.i; + param->value.i = + ret_param->value.remote_typed_param_value_u.i; break; case VIR_TYPED_PARAM_UINT: - params[i].value.ui = - ret_params_val[i].value.remote_typed_param_value_u.ui; + param->value.ui = + ret_param->value.remote_typed_param_value_u.ui; break; case VIR_TYPED_PARAM_LLONG: - params[i].value.l = - ret_params_val[i].value.remote_typed_param_value_u.l; + param->value.l = + ret_param->value.remote_typed_param_value_u.l; break; case VIR_TYPED_PARAM_ULLONG: - params[i].value.ul = - ret_params_val[i].value.remote_typed_param_value_u.ul; + param->value.ul = + ret_param->value.remote_typed_param_value_u.ul; break; case VIR_TYPED_PARAM_DOUBLE: - params[i].value.d = - ret_params_val[i].value.remote_typed_param_value_u.d; + param->value.d = + ret_param->value.remote_typed_param_value_u.d; break; case VIR_TYPED_PARAM_BOOLEAN: - params[i].value.b = - ret_params_val[i].value.remote_typed_param_value_u.b; + param->value.b = + ret_param->value.remote_typed_param_value_u.b; break; case VIR_TYPED_PARAM_STRING: - params[i].value.s = - strdup(ret_params_val[i].value.remote_typed_param_value_u.s); - if (params[i].value.s == NULL) { + param->value.s = + strdup(ret_param->value.remote_typed_param_value_u.s); + if (!param->value.s) { virReportOOMError(); goto cleanup; } break; default: virReportError(VIR_ERR_RPC, _("unknown parameter type: %d"), - params[i].type); + param->type); goto cleanup; } } @@ -1611,8 +1622,14 @@ remoteDeserializeTypedParameters(remote_typed_param *ret_params_val, rv = 0; cleanup: - if (rv < 0) - virTypedParamsClear(params, i); + if (rv < 0) { + if (userAllocated) { + virTypedParamsClear(*params, i); + } else { + virTypedParamsFree(*params, i); + *params = NULL; + } + } return rv; } @@ -1698,7 +1715,7 @@ remoteDomainBlockStatsFlags(virDomainPtr domain, if (remoteDeserializeTypedParameters(ret.params.params_val, ret.params.params_len, REMOTE_DOMAIN_MEMORY_PARAMETERS_MAX, - params, + ¶ms, nparams) < 0) goto cleanup; @@ -1746,7 +1763,7 @@ remoteDomainGetMemoryParameters(virDomainPtr domain, if (remoteDeserializeTypedParameters(ret.params.params_val, ret.params.params_len, REMOTE_DOMAIN_MEMORY_PARAMETERS_MAX, - params, + ¶ms, nparams) < 0) goto cleanup; @@ -1794,7 +1811,7 @@ remoteDomainGetNumaParameters(virDomainPtr domain, if (remoteDeserializeTypedParameters(ret.params.params_val, ret.params.params_len, REMOTE_DOMAIN_NUMA_PARAMETERS_MAX, - params, + ¶ms, nparams) < 0) goto cleanup; @@ -1842,7 +1859,7 @@ remoteDomainGetBlkioParameters(virDomainPtr domain, if (remoteDeserializeTypedParameters(ret.params.params_val, ret.params.params_len, REMOTE_DOMAIN_BLKIO_PARAMETERS_MAX, - params, + ¶ms, nparams) < 0) goto cleanup; @@ -2658,7 +2675,7 @@ static int remoteDomainGetBlockIoTune(virDomainPtr domain, if (remoteDeserializeTypedParameters(ret.params.params_val, ret.params.params_len, REMOTE_DOMAIN_MEMORY_PARAMETERS_MAX, - params, + ¶ms, nparams) < 0) goto cleanup; @@ -2742,12 +2759,12 @@ static int remoteDomainGetCPUStats(virDomainPtr domain, ncpus = ret.params.params_len / ret.nparams; for (cpu = 0; cpu < ncpus; cpu++) { int tmp = nparams; + virTypedParameterPtr cpu_params = ¶ms[cpu * nparams]; remote_typed_param *stride = &ret.params.params_val[cpu * ret.nparams]; if (remoteDeserializeTypedParameters(stride, ret.nparams, REMOTE_NODE_CPU_STATS_MAX, - ¶ms[cpu * nparams], - &tmp) < 0) + &cpu_params, &tmp) < 0) goto cleanup; } @@ -5648,7 +5665,7 @@ remoteDomainGetInterfaceParameters(virDomainPtr domain, if (remoteDeserializeTypedParameters(ret.params.params_val, ret.params.params_len, REMOTE_DOMAIN_INTERFACE_PARAMETERS_MAX, - params, + ¶ms, nparams) < 0) goto cleanup; @@ -5822,7 +5839,7 @@ remoteNodeGetMemoryParameters(virConnectPtr conn, if (remoteDeserializeTypedParameters(ret.params.params_val, ret.params.params_len, REMOTE_NODE_MEMORY_PARAMETERS_MAX, - params, + ¶ms, nparams) < 0) goto cleanup; diff --git a/src/rpc/gendispatch.pl b/src/rpc/gendispatch.pl index 1da28a4..ef387e0 100755 --- a/src/rpc/gendispatch.pl +++ b/src/rpc/gendispatch.pl @@ -1343,7 +1343,7 @@ elsif ($opt_k) { push(@ret_list2, "if (remoteDeserializeTypedParameters(ret.$1.$1_val,\n" . " ret.$1.$1_len,\n" . " $2,\n" . - " $1,\n" . + " &$1,\n" . " n$1) < 0)\n" . " goto cleanup;\n"); $single_ret_cleanup = 1; -- 1.8.1.2

--- daemon/remote.c | 44 ++++++++++++++++++++++++++++++++++++++++++++ src/remote/remote_driver.c | 41 +++++++++++++++++++++++++++++++++++++++++ src/remote/remote_protocol.x | 14 +++++++++++++- src/remote_protocol-structs | 12 ++++++++++++ 4 files changed, 110 insertions(+), 1 deletion(-) diff --git a/daemon/remote.c b/daemon/remote.c index 51dbd01..c92223e 100644 --- a/daemon/remote.c +++ b/daemon/remote.c @@ -4662,6 +4662,50 @@ cleanup: return rv; } +static int +remoteDispatchDomainGetJobStats(virNetServerPtr server ATTRIBUTE_UNUSED, + virNetServerClientPtr client, + virNetMessagePtr msg ATTRIBUTE_UNUSED, + virNetMessageErrorPtr rerr, + remote_domain_get_job_stats_args *args, + remote_domain_get_job_stats_ret *ret) +{ + virDomainPtr dom = NULL; + virTypedParameterPtr params = NULL; + int nparams = 0; + int rv = -1; + struct daemonClientPrivate *priv = + virNetServerClientGetPrivateData(client); + + if (!priv->conn) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("connection not open")); + goto cleanup; + } + + if (!(dom = get_nonnull_domain(priv->conn, args->dom))) + goto cleanup; + + if (virDomainGetJobStats(dom, &ret->type, ¶ms, + &nparams, args->flags) < 0) + goto cleanup; + + if (remoteSerializeTypedParameters(params, nparams, + &ret->params.params_val, + &ret->params.params_len, + 0) < 0) + goto cleanup; + + rv = 0; + +cleanup: + if (rv < 0) + virNetMessageSaveError(rerr); + virTypedParamsFree(params, nparams); + if (dom) + virDomainFree(dom); + return rv; +} + /*----- Helpers. -----*/ /* get_nonnull_domain and get_nonnull_network turn an on-wire diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c index 5a4b3c7..f35c44f 100644 --- a/src/remote/remote_driver.c +++ b/src/remote/remote_driver.c @@ -5934,6 +5934,46 @@ done: return rv; } +static int +remoteDomainGetJobStats(virDomainPtr domain, + int *type, + virTypedParameterPtr *params, + int *nparams, + unsigned int flags) +{ + int rv = -1; + remote_domain_get_job_stats_args args; + remote_domain_get_job_stats_ret ret; + struct private_data *priv = domain->conn->privateData; + + remoteDriverLock(priv); + + make_nonnull_domain(&args.dom, domain); + args.flags = flags; + + memset(&ret, 0, sizeof(ret)); + if (call(domain->conn, priv, 0, REMOTE_PROC_DOMAIN_GET_JOB_STATS, + (xdrproc_t) xdr_remote_domain_get_job_stats_args, (char *) &args, + (xdrproc_t) xdr_remote_domain_get_job_stats_ret, (char *) &ret) == -1) + goto done; + + *type = ret.type; + + if (remoteDeserializeTypedParameters(ret.params.params_val, + ret.params.params_len, + 0, params, nparams) < 0) + goto cleanup; + + rv = 0; + +cleanup: + xdr_free((xdrproc_t) xdr_remote_domain_get_job_stats_ret, + (char *) &ret); +done: + remoteDriverUnlock(priv); + return rv; +} + static void remoteDomainEventQueue(struct private_data *priv, virDomainEventPtr event) @@ -6193,6 +6233,7 @@ static virDriver remote_driver = { .cpuCompare = remoteCPUCompare, /* 0.7.5 */ .cpuBaseline = remoteCPUBaseline, /* 0.7.7 */ .domainGetJobInfo = remoteDomainGetJobInfo, /* 0.7.7 */ + .domainGetJobStats = remoteDomainGetJobStats, /* 1.0.3 */ .domainAbortJob = remoteDomainAbortJob, /* 0.7.7 */ .domainMigrateSetMaxDowntime = remoteDomainMigrateSetMaxDowntime, /* 0.8.0 */ .domainMigrateSetMaxSpeed = remoteDomainMigrateSetMaxSpeed, /* 0.9.0 */ diff --git a/src/remote/remote_protocol.x b/src/remote/remote_protocol.x index 5ace31f..306d6b2 100644 --- a/src/remote/remote_protocol.x +++ b/src/remote/remote_protocol.x @@ -2156,6 +2156,17 @@ struct remote_domain_get_job_info_ret { /* insert@1 */ }; +struct remote_domain_get_job_stats_args { + remote_nonnull_domain dom; + unsigned int flags; +}; + +struct remote_domain_get_job_stats_ret { + int type; + remote_typed_param params<>; +}; + + struct remote_domain_abort_job_args { remote_nonnull_domain dom; }; @@ -3060,7 +3071,8 @@ enum remote_procedure { REMOTE_PROC_DOMAIN_FSTRIM = 294, /* autogen autogen */ REMOTE_PROC_DOMAIN_SEND_PROCESS_SIGNAL = 295, /* autogen autogen */ REMOTE_PROC_DOMAIN_OPEN_CHANNEL = 296, /* autogen autogen | readstream@2 */ - REMOTE_PROC_NODE_DEVICE_LOOKUP_SCSI_HOST_BY_WWN = 297 /* autogen autogen priority:high */ + REMOTE_PROC_NODE_DEVICE_LOOKUP_SCSI_HOST_BY_WWN = 297, /* autogen autogen priority:high */ + REMOTE_PROC_DOMAIN_GET_JOB_STATS = 298 /* skipgen skipgen */ /* * Notice how the entries are grouped in sets of 10 ? diff --git a/src/remote_protocol-structs b/src/remote_protocol-structs index 7f5ff7a..54b6009 100644 --- a/src/remote_protocol-structs +++ b/src/remote_protocol-structs @@ -1634,6 +1634,17 @@ struct remote_domain_get_job_info_ret { uint64_t fileProcessed; uint64_t fileRemaining; }; +struct remote_domain_get_job_stats_args { + remote_nonnull_domain dom; + u_int flags; +}; +struct remote_domain_get_job_stats_ret { + int type; + struct { + u_int params_len; + remote_typed_param * params_val; + } params; +}; struct remote_domain_abort_job_args { remote_nonnull_domain dom; }; @@ -2462,4 +2473,5 @@ enum remote_procedure { REMOTE_PROC_DOMAIN_SEND_PROCESS_SIGNAL = 295, REMOTE_PROC_DOMAIN_OPEN_CHANNEL = 296, REMOTE_PROC_NODE_DEVICE_LOOKUP_SCSI_HOST_BY_WWN = 297, + REMOTE_PROC_DOMAIN_GET_JOB_STATS = 298, }; -- 1.8.1.2

--- tools/virsh-domain.c | 215 ++++++++++++++++++++++++++++++++++++++++----------- 1 file changed, 169 insertions(+), 46 deletions(-) diff --git a/tools/virsh-domain.c b/tools/virsh-domain.c index f8b0cec..ba05fa7 100644 --- a/tools/virsh-domain.c +++ b/tools/virsh-domain.c @@ -4914,64 +4914,187 @@ cmdDomjobinfo(vshControl *ctl, const vshCmd *cmd) { virDomainJobInfo info; virDomainPtr dom; - bool ret = true; + bool ret = false; + const char *unit; + double val; + virTypedParameterPtr params = NULL; + int nparams = 0; + unsigned long long value; + int rc; if (!(dom = vshCommandOptDomain(ctl, cmd, NULL))) return false; - if (virDomainGetJobInfo(dom, &info) == 0) { - const char *unit; - double val; + memset(&info, 0, sizeof(info)); - vshPrint(ctl, "%-17s ", _("Job type:")); - switch (info.type) { - case VIR_DOMAIN_JOB_BOUNDED: - vshPrint(ctl, "%-12s\n", _("Bounded")); - break; + rc = virDomainGetJobStats(dom, &info.type, ¶ms, &nparams, 0); + if (rc == 0) { + if (virTypedParamsGetULLong(params, nparams, + VIR_DOMAIN_JOB_TIME_ELAPSED, + &info.timeElapsed) < 0 || + virTypedParamsGetULLong(params, nparams, + VIR_DOMAIN_JOB_TIME_REMAINING, + &info.timeRemaining) < 0 || + virTypedParamsGetULLong(params, nparams, + VIR_DOMAIN_JOB_DATA_TOTAL, + &info.dataTotal) < 0 || + virTypedParamsGetULLong(params, nparams, + VIR_DOMAIN_JOB_DATA_PROCESSED, + &info.dataProcessed) < 0 || + virTypedParamsGetULLong(params, nparams, + VIR_DOMAIN_JOB_DATA_REMAINING, + &info.dataRemaining) < 0 || + virTypedParamsGetULLong(params, nparams, + VIR_DOMAIN_JOB_MEMORY_TOTAL, + &info.memTotal) < 0 || + virTypedParamsGetULLong(params, nparams, + VIR_DOMAIN_JOB_MEMORY_PROCESSED, + &info.memProcessed) < 0 || + virTypedParamsGetULLong(params, nparams, + VIR_DOMAIN_JOB_MEMORY_REMAINING, + &info.memRemaining) < 0 || + virTypedParamsGetULLong(params, nparams, + VIR_DOMAIN_JOB_DISK_TOTAL, + &info.fileTotal) < 0 || + virTypedParamsGetULLong(params, nparams, + VIR_DOMAIN_JOB_DISK_PROCESSED, + &info.fileProcessed) < 0 || + virTypedParamsGetULLong(params, nparams, + VIR_DOMAIN_JOB_DISK_REMAINING, + &info.fileRemaining) < 0) + goto save_error; + } else if (last_error->code == VIR_ERR_NO_SUPPORT) { + vshDebug(ctl, VSH_ERR_DEBUG, "detailed statistics not supported\n"); + vshResetLibvirtError(); + rc = virDomainGetJobInfo(dom, &info); + } + if (rc < 0) + goto cleanup; - case VIR_DOMAIN_JOB_UNBOUNDED: - vshPrint(ctl, "%-12s\n", _("Unbounded")); - break; + vshPrint(ctl, "%-17s ", _("Job type:")); + switch (info.type) { + case VIR_DOMAIN_JOB_BOUNDED: + vshPrint(ctl, "%-12s\n", _("Bounded")); + break; - case VIR_DOMAIN_JOB_NONE: - default: - vshPrint(ctl, "%-12s\n", _("None")); - goto cleanup; - } + case VIR_DOMAIN_JOB_UNBOUNDED: + vshPrint(ctl, "%-12s\n", _("Unbounded")); + break; - vshPrint(ctl, "%-17s %-12llu ms\n", _("Time elapsed:"), info.timeElapsed); - if (info.type == VIR_DOMAIN_JOB_BOUNDED) - vshPrint(ctl, "%-17s %-12llu ms\n", _("Time remaining:"), info.timeRemaining); - if (info.dataTotal || info.dataRemaining || info.dataProcessed) { - val = vshPrettyCapacity(info.dataProcessed, &unit); - vshPrint(ctl, "%-17s %-.3lf %s\n", _("Data processed:"), val, unit); - val = vshPrettyCapacity(info.dataRemaining, &unit); - vshPrint(ctl, "%-17s %-.3lf %s\n", _("Data remaining:"), val, unit); - val = vshPrettyCapacity(info.dataTotal, &unit); - vshPrint(ctl, "%-17s %-.3lf %s\n", _("Data total:"), val, unit); - } - if (info.memTotal || info.memRemaining || info.memProcessed) { - val = vshPrettyCapacity(info.memProcessed, &unit); - vshPrint(ctl, "%-17s %-.3lf %s\n", _("Memory processed:"), val, unit); - val = vshPrettyCapacity(info.memRemaining, &unit); - vshPrint(ctl, "%-17s %-.3lf %s\n", _("Memory remaining:"), val, unit); - val = vshPrettyCapacity(info.memTotal, &unit); - vshPrint(ctl, "%-17s %-.3lf %s\n", _("Memory total:"), val, unit); - } - if (info.fileTotal || info.fileRemaining || info.fileProcessed) { - val = vshPrettyCapacity(info.fileProcessed, &unit); - vshPrint(ctl, "%-17s %-.3lf %s\n", _("File processed:"), val, unit); - val = vshPrettyCapacity(info.fileRemaining, &unit); - vshPrint(ctl, "%-17s %-.3lf %s\n", _("File remaining:"), val, unit); - val = vshPrettyCapacity(info.fileTotal, &unit); - vshPrint(ctl, "%-17s %-.3lf %s\n", _("File total:"), val, unit); - } - } else { - ret = false; + case VIR_DOMAIN_JOB_NONE: + default: + vshPrint(ctl, "%-12s\n", _("None")); + goto cleanup; + } + + vshPrint(ctl, "%-17s %-12llu ms\n", _("Time elapsed:"), info.timeElapsed); + if (info.type == VIR_DOMAIN_JOB_BOUNDED) + vshPrint(ctl, "%-17s %-12llu ms\n", _("Time remaining:"), info.timeRemaining); + if (info.dataTotal || info.dataRemaining || info.dataProcessed) { + val = vshPrettyCapacity(info.dataProcessed, &unit); + vshPrint(ctl, "%-17s %-.3lf %s\n", _("Data processed:"), val, unit); + val = vshPrettyCapacity(info.dataRemaining, &unit); + vshPrint(ctl, "%-17s %-.3lf %s\n", _("Data remaining:"), val, unit); + val = vshPrettyCapacity(info.dataTotal, &unit); + vshPrint(ctl, "%-17s %-.3lf %s\n", _("Data total:"), val, unit); + } + + if (info.memTotal || info.memRemaining || info.memProcessed) { + val = vshPrettyCapacity(info.memProcessed, &unit); + vshPrint(ctl, "%-17s %-.3lf %s\n", _("Memory processed:"), val, unit); + val = vshPrettyCapacity(info.memRemaining, &unit); + vshPrint(ctl, "%-17s %-.3lf %s\n", _("Memory remaining:"), val, unit); + val = vshPrettyCapacity(info.memTotal, &unit); + vshPrint(ctl, "%-17s %-.3lf %s\n", _("Memory total:"), val, unit); + } + if (info.fileTotal || info.fileRemaining || info.fileProcessed) { + val = vshPrettyCapacity(info.fileProcessed, &unit); + vshPrint(ctl, "%-17s %-.3lf %s\n", _("File processed:"), val, unit); + val = vshPrettyCapacity(info.fileRemaining, &unit); + vshPrint(ctl, "%-17s %-.3lf %s\n", _("File remaining:"), val, unit); + val = vshPrettyCapacity(info.fileTotal, &unit); + vshPrint(ctl, "%-17s %-.3lf %s\n", _("File total:"), val, unit); + } + + if ((rc = virTypedParamsGetULLong(params, nparams, + VIR_DOMAIN_JOB_MEMORY_CONSTANT, + &value)) < 0) { + goto save_error; + } else if (rc) { + vshPrint(ctl, "%-17s %-12llu\n", _("Constant pages:"), value); + } + if ((rc = virTypedParamsGetULLong(params, nparams, + VIR_DOMAIN_JOB_MEMORY_NORMAL, + &value)) < 0) { + goto save_error; + } else if (rc) { + vshPrint(ctl, "%-17s %-12llu\n", _("Normal pages:"), value); } + if ((rc = virTypedParamsGetULLong(params, nparams, + VIR_DOMAIN_JOB_MEMORY_NORMAL_BYTES, + &value)) < 0) { + goto save_error; + } else if (rc) { + val = vshPrettyCapacity(value, &unit); + vshPrint(ctl, "%-17s %-.3lf %s\n", _("Normal data:"), val, unit); + } + + if ((rc = virTypedParamsGetULLong(params, nparams, + VIR_DOMAIN_JOB_DOWNTIME, + &value)) < 0) { + goto save_error; + } else if (rc) { + vshPrint(ctl, "%-17s %-12llu ms\n", _("Expected downtime:"), value); + } + + if ((rc = virTypedParamsGetULLong(params, nparams, + VIR_DOMAIN_JOB_COMPRESSION_CACHE, + &value)) < 0) { + goto save_error; + } else if (rc) { + val = vshPrettyCapacity(value, &unit); + vshPrint(ctl, "%-17s %-.3lf %s\n", _("Compression cache:"), val, unit); + } + if ((rc = virTypedParamsGetULLong(params, nparams, + VIR_DOMAIN_JOB_COMPRESSION_BYTES, + &value)) < 0) { + goto save_error; + } else if (rc) { + val = vshPrettyCapacity(value, &unit); + vshPrint(ctl, "%-17s %-.3lf %s\n", _("Compressed data:"), val, unit); + } + if ((rc = virTypedParamsGetULLong(params, nparams, + VIR_DOMAIN_JOB_COMPRESSION_PAGES, + &value)) < 0) { + goto save_error; + } else if (rc) { + vshPrint(ctl, "%-17s %-13llu\n", _("Compressed pages:"), value); + } + if ((rc = virTypedParamsGetULLong(params, nparams, + VIR_DOMAIN_JOB_COMPRESSION_CACHE_MISSES, + &value)) < 0) { + goto save_error; + } else if (rc) { + vshPrint(ctl, "%-17s %-13llu\n", _("Compression cache misses:"), value); + } + if ((rc = virTypedParamsGetULLong(params, nparams, + VIR_DOMAIN_JOB_COMPRESSION_OVERFLOW, + &value)) < 0) { + goto save_error; + } else if (rc) { + vshPrint(ctl, "%-17s %-13llu\n", _("Compression overflows:"), value); + } + + ret = true; + cleanup: virDomainFree(dom); + virTypedParamsFree(params, nparams); return ret; + +save_error: + vshSaveLibvirtError(); + goto cleanup; } /* -- 1.8.1.2

--- src/remote/remote_driver.c | 2 ++ src/remote/remote_protocol.x | 19 ++++++++++++++++++- src/remote_protocol-structs | 14 ++++++++++++++ 3 files changed, 34 insertions(+), 1 deletion(-) diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c index f35c44f..3721af9 100644 --- a/src/remote/remote_driver.c +++ b/src/remote/remote_driver.c @@ -6236,6 +6236,8 @@ static virDriver remote_driver = { .domainGetJobStats = remoteDomainGetJobStats, /* 1.0.3 */ .domainAbortJob = remoteDomainAbortJob, /* 0.7.7 */ .domainMigrateSetMaxDowntime = remoteDomainMigrateSetMaxDowntime, /* 0.8.0 */ + .domainMigrateGetCompressionCache = remoteDomainMigrateGetCompressionCache, /* 1.0.3 */ + .domainMigrateSetCompressionCache = remoteDomainMigrateSetCompressionCache, /* 1.0.3 */ .domainMigrateSetMaxSpeed = remoteDomainMigrateSetMaxSpeed, /* 0.9.0 */ .domainMigrateGetMaxSpeed = remoteDomainMigrateGetMaxSpeed, /* 0.9.5 */ .domainEventRegisterAny = remoteDomainEventRegisterAny, /* 0.8.0 */ diff --git a/src/remote/remote_protocol.x b/src/remote/remote_protocol.x index 306d6b2..b957b8e 100644 --- a/src/remote/remote_protocol.x +++ b/src/remote/remote_protocol.x @@ -2178,6 +2178,21 @@ struct remote_domain_migrate_set_max_downtime_args { unsigned int flags; }; +struct remote_domain_migrate_get_compression_cache_args { + remote_nonnull_domain dom; + unsigned int flags; +}; + +struct remote_domain_migrate_get_compression_cache_ret { + unsigned hyper cacheSize; /* insert@1 */ +}; + +struct remote_domain_migrate_set_compression_cache_args { + remote_nonnull_domain dom; + unsigned hyper cacheSize; + unsigned int flags; +}; + struct remote_domain_migrate_set_max_speed_args { remote_nonnull_domain dom; unsigned hyper bandwidth; @@ -3072,7 +3087,9 @@ enum remote_procedure { REMOTE_PROC_DOMAIN_SEND_PROCESS_SIGNAL = 295, /* autogen autogen */ REMOTE_PROC_DOMAIN_OPEN_CHANNEL = 296, /* autogen autogen | readstream@2 */ REMOTE_PROC_NODE_DEVICE_LOOKUP_SCSI_HOST_BY_WWN = 297, /* autogen autogen priority:high */ - REMOTE_PROC_DOMAIN_GET_JOB_STATS = 298 /* skipgen skipgen */ + REMOTE_PROC_DOMAIN_GET_JOB_STATS = 298, /* skipgen skipgen */ + REMOTE_PROC_DOMAIN_MIGRATE_GET_COMPRESSION_CACHE = 299, /* autogen autogen */ + REMOTE_PROC_DOMAIN_MIGRATE_SET_COMPRESSION_CACHE = 300 /* autogen autogen */ /* * Notice how the entries are grouped in sets of 10 ? diff --git a/src/remote_protocol-structs b/src/remote_protocol-structs index 54b6009..c85defd 100644 --- a/src/remote_protocol-structs +++ b/src/remote_protocol-structs @@ -1653,6 +1653,18 @@ struct remote_domain_migrate_set_max_downtime_args { uint64_t downtime; u_int flags; }; +struct remote_domain_migrate_get_compression_cache_args { + remote_nonnull_domain dom; + u_int flags; +}; +struct remote_domain_migrate_get_compression_cache_ret { + uint64_t cacheSize; +}; +struct remote_domain_migrate_set_compression_cache_args { + remote_nonnull_domain dom; + uint64_t cacheSize; + u_int flags; +}; struct remote_domain_migrate_set_max_speed_args { remote_nonnull_domain dom; uint64_t bandwidth; @@ -2474,4 +2486,6 @@ enum remote_procedure { REMOTE_PROC_DOMAIN_OPEN_CHANNEL = 296, REMOTE_PROC_NODE_DEVICE_LOOKUP_SCSI_HOST_BY_WWN = 297, REMOTE_PROC_DOMAIN_GET_JOB_STATS = 298, + REMOTE_PROC_DOMAIN_MIGRATE_GET_COMPRESSION_CACHE = 299, + REMOTE_PROC_DOMAIN_MIGRATE_SET_COMPRESSION_CACHE = 300, }; -- 1.8.1.2

This is a command wrapping virDomainMigrateGetCompressionCache and virDomainMigrateSetCompressionCache. --- tools/virsh-domain.c | 68 ++++++++++++++++++++++++++++++++++++++++++++++++++++ tools/virsh.pod | 12 ++++++++++ 2 files changed, 80 insertions(+) diff --git a/tools/virsh-domain.c b/tools/virsh-domain.c index ba05fa7..83885df 100644 --- a/tools/virsh-domain.c +++ b/tools/virsh-domain.c @@ -8734,6 +8734,68 @@ done: } /* + * "migrate-compcache" command + */ +static const vshCmdInfo info_migrate_compcache[] = { + {.name = "help", + .data = N_("get/set compression cache size") + }, + {.name = "desc", + .data = N_("Get/set size of the cache (in bytes) used for compressing " + "repeatedly transferred memory pages during live migration.") + }, + {.name = NULL} +}; + +static const vshCmdOptDef opts_migrate_compcache[] = { + {.name = "domain", + .type = VSH_OT_DATA, + .flags = VSH_OFLAG_REQ, + .help = N_("domain name, id or uuid") + }, + {.name = "size", + .type = VSH_OT_INT, + .flags = VSH_OFLAG_REQ_OPT, + .help = N_("requested size of the cache (in bytes) used for compression") + }, + {.name = NULL} +}; + +static bool +cmdMigrateCompCache(vshControl *ctl, const vshCmd *cmd) +{ + virDomainPtr dom = NULL; + unsigned long long size = 0; + bool ret = false; + const char *unit; + double value; + int rc; + + if (!(dom = vshCommandOptDomain(ctl, cmd, NULL))) + return false; + + rc = vshCommandOptULongLong(cmd, "size", &size); + if (rc < 0) { + vshError(ctl, "%s", _("Unable to parse size parameter")); + goto cleanup; + } else if (rc != 0) { + if (virDomainMigrateSetCompressionCache(dom, size, 0) < 0) + goto cleanup; + } + + if (virDomainMigrateGetCompressionCache(dom, &size, 0) < 0) + goto cleanup; + + value = vshPrettyCapacity(size, &unit); + vshPrint(ctl, _("Compression cache: %.3lf %s"), value, unit); + + ret = true; +cleanup: + virDomainFree(dom); + return ret; +} + +/* * "migrate-setspeed" command */ static const vshCmdInfo info_migrate_setspeed[] = { @@ -10677,6 +10739,12 @@ const vshCmdDef domManagementCmds[] = { .info = info_migrate_setmaxdowntime, .flags = 0 }, + {.name = "migrate-compcache", + .handler = cmdMigrateCompCache, + .opts = opts_migrate_compcache, + .info = info_migrate_compcache, + .flags = 0 + }, {.name = "migrate-setspeed", .handler = cmdMigrateSetMaxSpeed, .opts = opts_migrate_setspeed, diff --git a/tools/virsh.pod b/tools/virsh.pod index e675850..8f62378 100644 --- a/tools/virsh.pod +++ b/tools/virsh.pod @@ -1114,6 +1114,18 @@ Set maximum tolerable downtime for a domain which is being live-migrated to another host. The I<downtime> is a number of milliseconds the guest is allowed to be down at the end of live migration. +=item B<migrate-compcache> I<domain> [I<--size> B<bytes>] + +Sets and/or gets size of the cache (in bytes) used for compressing repeatedly +transferred memory pages during live migration. When called without I<size>, +the command just prints current size of the compression cache. When I<size> +is specified, the hypervisor is asked to change compression cache to I<size> +bytes and then the current size is printed (the result may differ from the +requested size due to rounding done by the hypervisor). With I<size> this +command is supposed to be called while the domain is being live-migrated as +a reaction to migration progress and increasing number of compression cache +misses obtained from domjobinfo. + =item B<migrate-setspeed> I<domain> I<bandwidth> Set the maximum migration bandwidth (in Mbps) for a domain which is being -- 1.8.1.2

--- src/qemu/qemu_driver.c | 94 ++++++++++++++++++++++++++++++++++++++++++++ src/qemu/qemu_monitor.c | 43 ++++++++++++++++++++ src/qemu/qemu_monitor.h | 5 +++ src/qemu/qemu_monitor_json.c | 63 +++++++++++++++++++++++++++++ src/qemu/qemu_monitor_json.h | 5 +++ 5 files changed, 210 insertions(+) diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index 07f7061..5aef22d 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -10359,6 +10359,98 @@ cleanup: } static int +qemuDomainMigrateGetCompressionCache(virDomainPtr dom, + unsigned long long *cacheSize, + unsigned int flags) +{ + virQEMUDriverPtr driver = dom->conn->privateData; + virDomainObjPtr vm; + qemuDomainObjPrivatePtr priv; + int ret = -1; + + virCheckFlags(0, -1); + + if (!(vm = qemuDomObjFromDomain(dom))) + goto cleanup; + + if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_QUERY) < 0) + goto cleanup; + + if (!virDomainObjIsActive(vm)) { + virReportError(VIR_ERR_OPERATION_INVALID, + "%s", _("domain is not running")); + goto endjob; + } + + priv = vm->privateData; + + qemuDomainObjEnterMonitor(driver, vm); + + ret = qemuMonitorGetMigrationCapability( + priv->mon, + QEMU_MONITOR_MIGRATION_CAPS_XBZRLE); + if (ret == 0) { + virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s", + _("Compressed migration is not supported by " + "QEMU binary")); + } else if (ret > 0) { + ret = qemuMonitorGetMigrationCacheSize(priv->mon, cacheSize); + } + + qemuDomainObjExitMonitor(driver, vm); + +endjob: + if (qemuDomainObjEndJob(driver, vm) == 0) + vm = NULL; + +cleanup: + if (vm) + virObjectUnlock(vm); + return ret; +} + +static int +qemuDomainMigrateSetCompressionCache(virDomainPtr dom, + unsigned long long cacheSize, + unsigned int flags) +{ + virQEMUDriverPtr driver = dom->conn->privateData; + virDomainObjPtr vm; + qemuDomainObjPrivatePtr priv; + int ret = -1; + + virCheckFlags(0, -1); + + if (!(vm = qemuDomObjFromDomain(dom))) + goto cleanup; + + if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_MIGRATION_OP) < 0) + goto cleanup; + + if (!virDomainObjIsActive(vm)) { + virReportError(VIR_ERR_OPERATION_INVALID, + "%s", _("domain is not running")); + goto endjob; + } + + priv = vm->privateData; + + VIR_DEBUG("Setting compression cache to %llu B", cacheSize); + qemuDomainObjEnterMonitor(driver, vm); + ret = qemuMonitorSetMigrationCacheSize(priv->mon, cacheSize); + qemuDomainObjExitMonitor(driver, vm); + +endjob: + if (qemuDomainObjEndJob(driver, vm) == 0) + vm = NULL; + +cleanup: + if (vm) + virObjectUnlock(vm); + return ret; +} + +static int qemuDomainMigrateSetMaxSpeed(virDomainPtr dom, unsigned long bandwidth, unsigned int flags) @@ -14919,6 +15011,8 @@ static virDriver qemuDriver = { .domainGetJobStats = qemuDomainGetJobStats, /* 1.0.3 */ .domainAbortJob = qemuDomainAbortJob, /* 0.7.7 */ .domainMigrateSetMaxDowntime = qemuDomainMigrateSetMaxDowntime, /* 0.8.0 */ + .domainMigrateGetCompressionCache = qemuDomainMigrateGetCompressionCache, /* 1.0.3 */ + .domainMigrateSetCompressionCache = qemuDomainMigrateSetCompressionCache, /* 1.0.3 */ .domainMigrateSetMaxSpeed = qemuDomainMigrateSetMaxSpeed, /* 0.9.0 */ .domainMigrateGetMaxSpeed = qemuDomainMigrateGetMaxSpeed, /* 0.9.5 */ .domainEventRegisterAny = qemuDomainEventRegisterAny, /* 0.8.0 */ diff --git a/src/qemu/qemu_monitor.c b/src/qemu/qemu_monitor.c index 21489fb..e14fad5 100644 --- a/src/qemu/qemu_monitor.c +++ b/src/qemu/qemu_monitor.c @@ -1804,6 +1804,49 @@ int qemuMonitorSetMigrationDowntime(qemuMonitorPtr mon, } +int +qemuMonitorGetMigrationCacheSize(qemuMonitorPtr mon, + unsigned long long *cacheSize) +{ + VIR_DEBUG("mon=%p cacheSize=%p", mon, cacheSize); + + if (!mon) { + virReportError(VIR_ERR_INVALID_ARG, "%s", + _("monitor must not be NULL")); + return -1; + } + + if (!mon->json) { + virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s", + _("JSON monitor is required")); + return -1; + } + + return qemuMonitorJSONGetMigrationCacheSize(mon, cacheSize); +} + +int +qemuMonitorSetMigrationCacheSize(qemuMonitorPtr mon, + unsigned long long cacheSize) +{ + VIR_DEBUG("mon=%p cacheSize=%llu", mon, cacheSize); + + if (!mon) { + virReportError(VIR_ERR_INVALID_ARG, "%s", + _("monitor must not be NULL")); + return -1; + } + + if (!mon->json) { + virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s", + _("JSON monitor is required")); + return -1; + } + + return qemuMonitorJSONSetMigrationCacheSize(mon, cacheSize); +} + + int qemuMonitorGetMigrationStatus(qemuMonitorPtr mon, qemuMonitorMigrationStatusPtr status) { diff --git a/src/qemu/qemu_monitor.h b/src/qemu/qemu_monitor.h index 40e635d..ffb17c2 100644 --- a/src/qemu/qemu_monitor.h +++ b/src/qemu/qemu_monitor.h @@ -326,6 +326,11 @@ int qemuMonitorSetMigrationSpeed(qemuMonitorPtr mon, int qemuMonitorSetMigrationDowntime(qemuMonitorPtr mon, unsigned long long downtime); +int qemuMonitorGetMigrationCacheSize(qemuMonitorPtr mon, + unsigned long long *cacheSize); +int qemuMonitorSetMigrationCacheSize(qemuMonitorPtr mon, + unsigned long long cacheSize); + enum { QEMU_MONITOR_MIGRATION_STATUS_INACTIVE, QEMU_MONITOR_MIGRATION_STATUS_ACTIVE, diff --git a/src/qemu/qemu_monitor_json.c b/src/qemu/qemu_monitor_json.c index e8c1f81..af6683d 100644 --- a/src/qemu/qemu_monitor_json.c +++ b/src/qemu/qemu_monitor_json.c @@ -2256,6 +2256,69 @@ int qemuMonitorJSONSetMigrationDowntime(qemuMonitorPtr mon, } +int +qemuMonitorJSONGetMigrationCacheSize(qemuMonitorPtr mon, + unsigned long long *cacheSize) +{ + int ret; + virJSONValuePtr cmd; + virJSONValuePtr reply = NULL; + + *cacheSize = 0; + + cmd = qemuMonitorJSONMakeCommand("query-migrate-cache-size", NULL); + if (!cmd) + return -1; + + ret = qemuMonitorJSONCommand(mon, cmd, &reply); + + if (ret == 0) + ret = qemuMonitorJSONCheckError(cmd, reply); + + if (ret < 0) + goto cleanup; + + ret = virJSONValueObjectGetNumberUlong(reply, "return", cacheSize); + if (ret < 0) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("query-migrate-cache-size reply was missing " + "'return' data")); + goto cleanup; + } + + ret = 0; +cleanup: + virJSONValueFree(cmd); + virJSONValueFree(reply); + return ret; +} + + +int +qemuMonitorJSONSetMigrationCacheSize(qemuMonitorPtr mon, + unsigned long long cacheSize) +{ + int ret; + virJSONValuePtr cmd; + virJSONValuePtr reply = NULL; + + cmd = qemuMonitorJSONMakeCommand("migrate-set-cache-size", + "U:value", cacheSize, + NULL); + if (!cmd) + return -1; + + ret = qemuMonitorJSONCommand(mon, cmd, &reply); + + if (ret == 0) + ret = qemuMonitorJSONCheckError(cmd, reply); + + virJSONValueFree(cmd); + virJSONValueFree(reply); + return ret; +} + + static int qemuMonitorJSONGetMigrationStatusReply(virJSONValuePtr reply, qemuMonitorMigrationStatusPtr status) diff --git a/src/qemu/qemu_monitor_json.h b/src/qemu/qemu_monitor_json.h index 66635fd..cfe9c19 100644 --- a/src/qemu/qemu_monitor_json.h +++ b/src/qemu/qemu_monitor_json.h @@ -120,6 +120,11 @@ int qemuMonitorJSONSetMigrationSpeed(qemuMonitorPtr mon, int qemuMonitorJSONSetMigrationDowntime(qemuMonitorPtr mon, unsigned long long downtime); +int qemuMonitorJSONGetMigrationCacheSize(qemuMonitorPtr mon, + unsigned long long *cacheSize); +int qemuMonitorJSONSetMigrationCacheSize(qemuMonitorPtr mon, + unsigned long long cacheSize); + int qemuMonitorJSONGetMigrationStatus(qemuMonitorPtr mon, qemuMonitorMigrationStatusPtr status); -- 1.8.1.2