- Devel - libvirt List Archives

Re: [libvirt] [libvirt-php] [PATCH v1] update snapshot api
by Vasiliy Tolstov 09 Jun '15

09 Jun '15

2015-05-07 17:21 GMT+03:00 Vasiliy Tolstov <v.tolstov(a)selfip.ru>: > * add constants from libvirt to snapshots api > * add flags to snapshot functions This is for php libvirt binding -- Vasiliy Tolstov, e-mail: v.tolstov(a)selfip.ru jabber: vase(a)selfip.ru

1 2

[libvirt] Build failed in Jenkins: libvirt-syntax-check #3577
by Jenkins CI 09 Jun '15

09 Jun '15

See <http://honk.sigxcpu.org:8001/job/libvirt-syntax-check/3577/> ------------------------------------------ Started by upstream project "libvirt-build" build number 4064 Started by upstream project "libvirt-build" build number 4065 Building on master in workspace <http://honk.sigxcpu.org:8001/job/libvirt-syntax-check/ws/> [workspace] $ /bin/sh -xe /tmp/hudson282348035376735129.sh + make syntax-check GEN bracket-spacing-check GFDL_version 0.73 GFDL_version TAB_in_indentation 0.54 TAB_in_indentation Wundef_boolean 0.31 Wundef_boolean avoid_attribute_unused_in_header 0.39 avoid_attribute_unused_in_header avoid_ctype_macros 1.01 avoid_ctype_macros avoid_if_before_free 7.25 avoid_if_before_free avoid_strcase 0.84 avoid_strcase avoid_write 0.42 avoid_write bindtextdomain 0.39 bindtextdomain cast_of_argument_to_free 0.68 cast_of_argument_to_free cast_of_x_alloc_return_value 0.74 cast_of_x_alloc_return_value changelog 0.31 changelog const_long_option 0.77 const_long_option copyright_check 1.08 copyright_check copyright_format 2.18 copyright_format copyright_usage 2.05 copyright_usage correct_id_types 0.84 correct_id_types curly_braces_style 1.51 curly_braces_style error_message_period 0.67 error_message_period error_message_warn_fatal 0.61 error_message_warn_fatal flags_debug 1.64 flags_debug flags_usage 1.38 flags_usage forbid_const_pointer_typedef 1.51 forbid_const_pointer_typedef forbid_manual_xml_indent 0.75 forbid_manual_xml_indent libvirt_unmarked_diagnostics 2.20 libvirt_unmarked_diagnostics m4_quote_check 0.42 m4_quote_check makefile_TAB_only_indentation 0.46 makefile_TAB_only_indentation makefile_at_at_check 0.56 makefile_at_at_check makefile_conditionals 0.47 makefile_conditionals po_check 15.54 po_check preprocessor_indentation cppi: src/parallels/parallels_driver.c: line 1255: not properly formatted; there must be exactly one SPACE character after each #if, #elif, and #define directive cppi: src/parallels/parallels_utils.h: line 122: not properly indented maint.mk: incorrect preprocessor indentation make: *** [sc_preprocessor_indentation] Error 1 Build step 'Execute shell' marked build as failure

2 2

[libvirt] [PATCH] parallels: fix formatting errors in parallels driver
by Dmitry Guryanov 09 Jun '15

09 Jun '15

This patch fixes several formatting errors, which I missed before pushing previous patches. Mostly because of missing cppi package. Signed-off-by: Dmitry Guryanov <dguryanov(a)parallels.com> --- src/parallels/parallels_driver.c | 8 ++++---- src/parallels/parallels_sdk.c | 4 ++-- src/parallels/parallels_utils.h | 10 +++++----- 3 files changed, 11 insertions(+), 11 deletions(-) diff --git a/src/parallels/parallels_driver.c b/src/parallels/parallels_driver.c index fdba0db..706229d 100644 --- a/src/parallels/parallels_driver.c +++ b/src/parallels/parallels_driver.c @@ -1252,13 +1252,13 @@ parallelsDomainBlockStats(virDomainPtr domain, const char *path, if (prlsdkGetBlockStats(dom, dom->def->disks[i], &s) < 0) goto cleanup; -#define PARALLELS_SUM_STATS(VAR, TYPE, NAME) \ - if (s.VAR != -1) \ - stats->VAR += s.VAR; +#define PARALLELS_SUM_STATS(VAR, TYPE, NAME) \ + if (s.VAR != -1) \ + stats->VAR += s.VAR; PARALLELS_BLOCK_STATS_FOREACH(PARALLELS_SUM_STATS) -#undef PARALLELS_SUM_STATS +#undef PARALLELS_SUM_STATS } } stats->errs = -1; diff --git a/src/parallels/parallels_sdk.c b/src/parallels/parallels_sdk.c index 4d5099c..104c905 100644 --- a/src/parallels/parallels_sdk.c +++ b/src/parallels/parallels_sdk.c @@ -501,9 +501,9 @@ prlsdkGetDiskInfo(PRL_HANDLE prldisk, goto cleanup; /* Let physical devices added to CT look like SATA disks */ - if (isCt) + if (isCt) { ifType = PMS_SATA_DEVICE; - else { + } else { pret = PrlVmDev_GetIfaceType(prldisk, &ifType); prlsdkCheckRetGoto(pret, cleanup); } diff --git a/src/parallels/parallels_utils.h b/src/parallels/parallels_utils.h index 84bef24..5db65bd 100644 --- a/src/parallels/parallels_utils.h +++ b/src/parallels/parallels_utils.h @@ -119,10 +119,10 @@ virStorageVolPtr parallelsStorageVolLookupByPathLocked(virConnectPtr conn, int parallelsStorageVolDefRemove(virStoragePoolObjPtr privpool, virStorageVolDefPtr privvol); -#define PARALLELS_BLOCK_STATS_FOREACH(OP) \ - OP(rd_req, VIR_DOMAIN_BLOCK_STATS_READ_REQ, "read_requests") \ - OP(rd_bytes, VIR_DOMAIN_BLOCK_STATS_READ_BYTES, "read_total") \ - OP(wr_req, VIR_DOMAIN_BLOCK_STATS_WRITE_REQ, "write_requests") \ - OP(wr_bytes, VIR_DOMAIN_BLOCK_STATS_WRITE_BYTES, "write_total") +# define PARALLELS_BLOCK_STATS_FOREACH(OP) \ + OP(rd_req, VIR_DOMAIN_BLOCK_STATS_READ_REQ, "read_requests") \ + OP(rd_bytes, VIR_DOMAIN_BLOCK_STATS_READ_BYTES, "read_total") \ + OP(wr_req, VIR_DOMAIN_BLOCK_STATS_WRITE_REQ, "write_requests") \ + OP(wr_bytes, VIR_DOMAIN_BLOCK_STATS_WRITE_BYTES, "write_total") #endif -- 2.1.0

1 1

[libvirt] [PATCH v5] parallels: add block device statistics to driver
by Nikolay Shirokovskiy 09 Jun '15

09 Jun '15

Statistics provided through PCS SDK. As we have only async interface in SDK we need to be subscribed to statistics in order to get it. Trivial solution on every stat request to subscribe, wait event and then unsubscribe will lead to significant delays in case of a number of successive requests, as the event will be delivered on next PCS server notify cycle. On the other hand we don't want to keep unnesessary subscribtion. So we take an hibrid solution to subcsribe on first request and then keep a subscription while requests are active. We populate cache of statistics on subscribtion events and use this cache to serve libvirts requests. * Cache details. Cache is just handle to last arrived event, we call this cache as if this handle is valid it is used to serve synchronous statistics requests. We use number of successive events count to detect that user lost interest to statistics. We reset this count to 0 on every request. If more than PARALLELS_STATISTICS_DROP_COUNT successive events arrive we unsubscribe. Special value of -1 of this counter is used to differentiate between subscribed/unsubscribed state to protect from delayed events. Values of PARALLELS_STATISTICS_DROP_COUNT and PARALLELS_STATISTICS_TIMEOUT are just drop-ins, choosen without special consideration. * Thread safety issues Use parallelsDomObjFromDomainRef in parallelsDomainBlockStats as we could wait on domain lock down on stack in prlsdkGetStatsParam and if we won't keep reference we could get dangling pointer on return from wait. Signed-off-by: Nikolay Shirokovskiy <nshirokovskiy(a)parallels.com> --- src/parallels/parallels_driver.c | 106 ++++++++++++++++++++ src/parallels/parallels_sdk.c | 200 +++++++++++++++++++++++++++++++++++++- src/parallels/parallels_sdk.h | 2 + src/parallels/parallels_utils.c | 28 ++++++ src/parallels/parallels_utils.h | 18 ++++ 5 files changed, 350 insertions(+), 4 deletions(-) diff --git a/src/parallels/parallels_driver.c b/src/parallels/parallels_driver.c index 4b87213..33c112e 100644 --- a/src/parallels/parallels_driver.c +++ b/src/parallels/parallels_driver.c @@ -51,6 +51,7 @@ #include "nodeinfo.h" #include "virstring.h" #include "cpu/cpu.h" +#include "virtypedparam.h" #include "parallels_driver.h" #include "parallels_utils.h" @@ -1179,6 +1180,109 @@ parallelsDomainGetMaxMemory(virDomainPtr domain) return ret; } +static int +parallelsDomainBlockStats(virDomainPtr domain, const char *path, + virDomainBlockStatsPtr stats) +{ + virDomainObjPtr dom = NULL; + int ret = -1; + size_t i; + int idx; + + if (!(dom = parallelsDomObjFromDomainRef(domain))) + return -1; + + if (*path) { + if ((idx = virDomainDiskIndexByName(dom->def, path, false)) < 0) { + virReportError(VIR_ERR_INVALID_ARG, _("invalid path: %s"), path); + goto cleanup; + } + if (prlsdkGetBlockStats(dom, dom->def->disks[idx], stats) < 0) + goto cleanup; + } else { + virDomainBlockStatsStruct s; + +#define PARALLELS_ZERO_STATS(VAR, TYPE, NAME) \ + stats->VAR = 0; + + PARALLELS_BLOCK_STATS_FOREACH(PARALLELS_ZERO_STATS) + +#undef PARALLELS_ZERO_STATS + + for (i = 0; i < dom->def->ndisks; i++) { + if (prlsdkGetBlockStats(dom, dom->def->disks[i], &s) < 0) + goto cleanup; + +#define PARALLELS_SUM_STATS(VAR, TYPE, NAME) \ + if (s.VAR != -1) \ + stats->VAR += s.VAR; + + PARALLELS_BLOCK_STATS_FOREACH(PARALLELS_SUM_STATS) + +#undef PARALLELS_SUM_STATS + } + } + stats->errs = -1; + ret = 0; + + cleanup: + if (dom) + virDomainObjEndAPI(&dom); + + return ret; +} + +static int +parallelsDomainBlockStatsFlags(virDomainPtr domain, + const char *path, + virTypedParameterPtr params, + int *nparams, + unsigned int flags) +{ + virDomainBlockStatsStruct stats; + int ret = -1; + size_t i; + + virCheckFlags(VIR_TYPED_PARAM_STRING_OKAY, -1); + /* We don't return strings, and thus trivially support this flag. */ + flags &= ~VIR_TYPED_PARAM_STRING_OKAY; + + if (parallelsDomainBlockStats(domain, path, &stats) < 0) + goto cleanup; + + if (*nparams == 0) { +#define PARALLELS_COUNT_STATS(VAR, TYPE, NAME) \ + if ((stats.VAR) != -1) \ + ++*nparams; + + PARALLELS_BLOCK_STATS_FOREACH(PARALLELS_COUNT_STATS) + +#undef PARALLELS_COUNT_STATS + ret = 0; + goto cleanup; + } + + i = 0; +#define PARALLELS_BLOCK_STATS_ASSIGN_PARAM(VAR, TYPE, NAME) \ + if (i < *nparams && (stats.VAR) != -1) { \ + if (virTypedParameterAssign(params + i, TYPE, \ + VIR_TYPED_PARAM_LLONG, (stats.VAR)) < 0) \ + goto cleanup; \ + i++; \ + } + + PARALLELS_BLOCK_STATS_FOREACH(PARALLELS_BLOCK_STATS_ASSIGN_PARAM) + +#undef PARALLELS_BLOCK_STATS_ASSIGN_PARAM + + *nparams = i; + ret = 0; + + cleanup: + return ret; +} + + static virHypervisorDriver parallelsDriver = { .name = "Parallels", .connectOpen = parallelsConnectOpen, /* 0.10.0 */ @@ -1228,6 +1332,8 @@ static virHypervisorDriver parallelsDriver = { .domainManagedSave = parallelsDomainManagedSave, /* 1.2.14 */ .domainManagedSaveRemove = parallelsDomainManagedSaveRemove, /* 1.2.14 */ .domainGetMaxMemory = parallelsDomainGetMaxMemory, /* 1.2.15 */ + .domainBlockStats = parallelsDomainBlockStats, /* 1.2.17 */ + .domainBlockStatsFlags = parallelsDomainBlockStatsFlags, /* 1.2.17 */ }; static virConnectDriver parallelsConnectDriver = { diff --git a/src/parallels/parallels_sdk.c b/src/parallels/parallels_sdk.c index 6d63759..00e51f4 100644 --- a/src/parallels/parallels_sdk.c +++ b/src/parallels/parallels_sdk.c @@ -21,6 +21,7 @@ */ #include <config.h> +#include <stdarg.h> #include "virerror.h" #include "viralloc.h" @@ -29,6 +30,7 @@ #include "virlog.h" #include "datatypes.h" #include "domain_conf.h" +#include "virtime.h" #include "parallels_sdk.h" @@ -407,6 +409,8 @@ prlsdkDomObjFreePrivate(void *p) return; PrlHandle_Free(pdom->sdkdom); + PrlHandle_Free(pdom->cache.stats); + virCondDestroy(&pdom->cache.cond); VIR_FREE(pdom->uuid); VIR_FREE(pdom->home); VIR_FREE(p); @@ -1260,6 +1264,13 @@ prlsdkLoadDomain(parallelsConnPtr privconn, * to NULL temporarily */ pdom->uuid = NULL; + pdom->cache.stats = PRL_INVALID_HANDLE; + pdom->cache.count = -1; + if (virCondInit(&pdom->cache.cond) < 0) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("cannot initialize condition")); + goto error; + } + if (prlsdkGetDomainIds(sdkdom, &def->name, def->uuid) < 0) goto error; @@ -1611,6 +1622,51 @@ prlsdkHandleVmRemovedEvent(parallelsConnPtr privconn, return; } +#define PARALLELS_STATISTICS_DROP_COUNT 3 + +static PRL_RESULT +prlsdkHandlePerfEvent(parallelsConnPtr privconn, + PRL_HANDLE event, + unsigned char *uuid) +{ + virDomainObjPtr dom = NULL; + parallelsDomObjPtr privdom = NULL; + PRL_HANDLE job = PRL_INVALID_HANDLE; + + dom = virDomainObjListFindByUUID(privconn->domains, uuid); + if (dom == NULL) + goto cleanup; + privdom = dom->privateData; + + // delayed event after unsubscribe + if (privdom->cache.count == -1) + goto cleanup; + + PrlHandle_Free(privdom->cache.stats); + privdom->cache.stats = PRL_INVALID_HANDLE; + + if (privdom->cache.count > PARALLELS_STATISTICS_DROP_COUNT) { + job = PrlVm_UnsubscribeFromPerfStats(privdom->sdkdom); + if (PRL_FAILED(waitJob(job))) + goto cleanup; + // change state to unsubscribed + privdom->cache.count = -1; + } else { + ++privdom->cache.count; + privdom->cache.stats = event; + // thus we get own of event handle + event = PRL_INVALID_HANDLE; + virCondSignal(&privdom->cache.cond); + } + + cleanup: + PrlHandle_Free(event); + if (dom) + virObjectUnlock(dom); + + return PRL_ERR_SUCCESS; +} + static void prlsdkHandleVmEvent(parallelsConnPtr privconn, PRL_HANDLE prlEvent) { @@ -1621,13 +1677,13 @@ prlsdkHandleVmEvent(parallelsConnPtr privconn, PRL_HANDLE prlEvent) PRL_EVENT_TYPE prlEventType; pret = PrlEvent_GetType(prlEvent, &prlEventType); - prlsdkCheckRetGoto(pret, error); + prlsdkCheckRetGoto(pret, cleanup); pret = PrlEvent_GetIssuerId(prlEvent, uuidstr, &bufsize); - prlsdkCheckRetGoto(pret, error); + prlsdkCheckRetGoto(pret, cleanup); if (prlsdkUUIDParse(uuidstr, uuid) < 0) - return; + goto cleanup; switch (prlEventType) { case PET_DSP_EVT_VM_STATE_CHANGED: @@ -1644,12 +1700,18 @@ prlsdkHandleVmEvent(parallelsConnPtr privconn, PRL_HANDLE prlEvent) case PET_DSP_EVT_VM_UNREGISTERED: prlsdkHandleVmRemovedEvent(privconn, uuid); break; + case PET_DSP_EVT_VM_PERFSTATS: + prlsdkHandlePerfEvent(privconn, prlEvent, uuid); + // above function takes own of event + prlEvent = PRL_INVALID_HANDLE; + break; default: virReportError(VIR_ERR_INTERNAL_ERROR, _("Can't handle event of type %d"), prlEventType); } - error: + cleanup: + PrlHandle_Free(prlEvent); return; } @@ -1677,6 +1739,8 @@ prlsdkEventsHandler(PRL_HANDLE prlEvent, PRL_VOID_PTR opaque) switch (prlIssuerType) { case PIE_VIRTUAL_MACHINE: prlsdkHandleVmEvent(privconn, prlEvent); + // above function takes own of event + prlEvent = PRL_INVALID_HANDLE; break; default: VIR_DEBUG("Skipping event of issuer type %d", prlIssuerType); @@ -1687,6 +1751,7 @@ prlsdkEventsHandler(PRL_HANDLE prlEvent, PRL_VOID_PTR opaque) return PRL_ERR_SUCCESS; } + int prlsdkSubscribeToPCSEvents(parallelsConnPtr privconn) { PRL_RESULT pret = PRL_ERR_UNINITIALIZED; @@ -3423,3 +3488,130 @@ prlsdkDomainManagedSaveRemove(virDomainObjPtr dom) return 0; } + +static int +prlsdkExtractStatsParam(PRL_HANDLE sdkstats, const char *name, long long *val) +{ + PRL_HANDLE param = PRL_INVALID_HANDLE; + PRL_RESULT pret; + PRL_INT64 pval = 0; + int ret = -1; + + pret = PrlEvent_GetParamByName(sdkstats, name, &param); + if (pret == PRL_ERR_NO_DATA) { + *val = -1; + ret = 0; + goto cleanup; + } else if (PRL_FAILED(pret)) { + logPrlError(pret); + goto cleanup; + } + pret = PrlEvtPrm_ToInt64(param, &pval); + prlsdkCheckRetGoto(pret, cleanup); + + *val = pval; + ret = 0; + + cleanup: + PrlHandle_Free(param); + return ret; +} + +#define PARALLELS_STATISTICS_TIMEOUT (60 * 1000) + +static int +prlsdkGetStatsParam(virDomainObjPtr dom, const char *name, long long *val) +{ + parallelsDomObjPtr privdom = dom->privateData; + PRL_HANDLE job = PRL_INVALID_HANDLE; + unsigned long long now; + + if (privdom->cache.stats != PRL_INVALID_HANDLE) { + // reset count to keep subscribtion + privdom->cache.count = 0; + return prlsdkExtractStatsParam(privdom->cache.stats, name, val); + } + + if (privdom->cache.count == -1) { + job = PrlVm_SubscribeToPerfStats(privdom->sdkdom, NULL); + if (PRL_FAILED(waitJob(job))) + goto error; + } + + // change state to subscribed in case of unsubscribed + // or reset count so we stop unsubscribe attempts + privdom->cache.count = 0; + + if (virTimeMillisNow(&now) < 0) { + virReportSystemError(errno, "%s", _("Unable to get current time")); + goto error; + } + + while (privdom->cache.stats == PRL_INVALID_HANDLE) { + if (virCondWaitUntil(&privdom->cache.cond, &dom->parent.lock, + now + PARALLELS_STATISTICS_TIMEOUT) < 0) { + if (errno == ETIMEDOUT) { + virReportError(VIR_ERR_OPERATION_TIMEOUT, "%s", + _("Timeout on waiting statistics event.")); + goto error; + } else { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("Unable to wait on monitor condition")); + goto error; + } + } + } + + return prlsdkExtractStatsParam(privdom->cache.stats, name, val); + error: + return -1; +} + +int +prlsdkGetBlockStats(virDomainObjPtr dom, virDomainDiskDefPtr disk, virDomainBlockStatsPtr stats) +{ + virDomainDeviceDriveAddressPtr address; + int idx; + const char *prefix; + int ret = -1; + char *name = NULL; + + address = &disk->info.addr.drive; + switch (disk->bus) { + case VIR_DOMAIN_DISK_BUS_IDE: + prefix = "ide"; + idx = address->bus * 2 + address->unit; + break; + case VIR_DOMAIN_DISK_BUS_SATA: + prefix = "sata"; + idx = address->unit; + break; + case VIR_DOMAIN_DISK_BUS_SCSI: + prefix = "scsi"; + idx = address->unit; + break; + default: + virReportError(VIR_ERR_INTERNAL_ERROR, + _("Unknown disk bus: %X"), disk->bus); + goto cleanup; + } + + +#define PRLSDK_GET_STAT_PARAM(VAL, TYPE, NAME) \ + if (virAsprintf(&name, "devices.%s%d.%s", prefix, idx, NAME) < 0) \ + goto cleanup; \ + if (prlsdkGetStatsParam(dom, name, &stats->VAL) < 0) \ + goto cleanup; \ + VIR_FREE(name); + + PARALLELS_BLOCK_STATS_FOREACH(PRLSDK_GET_STAT_PARAM) + +#undef PRLSDK_GET_STAT_PARAM + + ret = 0; + + cleanup: + + VIR_FREE(name); + return ret; +} diff --git a/src/parallels/parallels_sdk.h b/src/parallels/parallels_sdk.h index 3f17fc8..afa6745 100644 --- a/src/parallels/parallels_sdk.h +++ b/src/parallels/parallels_sdk.h @@ -64,3 +64,5 @@ int prlsdkAttachVolume(virDomainObjPtr dom, virDomainDiskDefPtr disk); int prlsdkDetachVolume(virDomainObjPtr dom, virDomainDiskDefPtr disk); +int +prlsdkGetBlockStats(virDomainObjPtr dom, virDomainDiskDefPtr disk, virDomainBlockStatsPtr stats); diff --git a/src/parallels/parallels_utils.c b/src/parallels/parallels_utils.c index ff9d47d..540986b 100644 --- a/src/parallels/parallels_utils.c +++ b/src/parallels/parallels_utils.c @@ -64,6 +64,34 @@ parallelsDomObjFromDomain(virDomainPtr domain) } +/** + * parallelsDomObjFromDomainRef: + * @domain: Domain pointer that has to be looked up + * + * This function looks up @domain and returns the appropriate virDomainObjPtr + * that has to be released by calling virDomainObjEndAPI(). + * + * Returns the domain object with incremented reference counter which is locked + * on success, NULL otherwise. + */ +virDomainObjPtr +parallelsDomObjFromDomainRef(virDomainPtr domain) +{ + virDomainObjPtr vm; + parallelsConnPtr privconn = domain->conn->privateData; + char uuidstr[VIR_UUID_STRING_BUFLEN]; + + vm = virDomainObjListFindByUUIDRef(privconn->domains, domain->uuid); + if (!vm) { + virUUIDFormat(domain->uuid, uuidstr); + virReportError(VIR_ERR_NO_DOMAIN, + _("no domain with matching uuid '%s' (%s)"), + uuidstr, domain->name); + return NULL; + } + + return vm; +} static int parallelsDoCmdRun(char **outbuf, const char *binary, va_list list) diff --git a/src/parallels/parallels_utils.h b/src/parallels/parallels_utils.h index 2d1d405..6268882 100644 --- a/src/parallels/parallels_utils.h +++ b/src/parallels/parallels_utils.h @@ -73,11 +73,22 @@ struct _parallelsConn { typedef struct _parallelsConn parallelsConn; typedef struct _parallelsConn *parallelsConnPtr; +struct _parallelsCountersCache { + PRL_HANDLE stats; + virCond cond; + // -1 - unsubscribed + // > -1 - subscribed + int count; +}; + +typedef struct _parallelsCountersCache parallelsCountersCache; + struct parallelsDomObj { int id; char *uuid; char *home; PRL_HANDLE sdkdom; + parallelsCountersCache cache; }; typedef struct parallelsDomObj *parallelsDomObjPtr; @@ -91,6 +102,7 @@ int parallelsNetworkClose(virConnectPtr conn); extern virNetworkDriver parallelsNetworkDriver; virDomainObjPtr parallelsDomObjFromDomain(virDomainPtr domain); +virDomainObjPtr parallelsDomObjFromDomainRef(virDomainPtr domain); virJSONValuePtr parallelsParseOutput(const char *binary, ...) ATTRIBUTE_NONNULL(1) ATTRIBUTE_SENTINEL; @@ -106,4 +118,10 @@ virStorageVolPtr parallelsStorageVolLookupByPathLocked(virConnectPtr conn, int parallelsStorageVolDefRemove(virStoragePoolObjPtr privpool, virStorageVolDefPtr privvol); +#define PARALLELS_BLOCK_STATS_FOREACH(OP) \ + OP(rd_req, VIR_DOMAIN_BLOCK_STATS_READ_REQ, "read_requests") \ + OP(rd_bytes, VIR_DOMAIN_BLOCK_STATS_READ_BYTES, "read_total") \ + OP(wr_req, VIR_DOMAIN_BLOCK_STATS_WRITE_REQ, "write_requests") \ + OP(wr_bytes, VIR_DOMAIN_BLOCK_STATS_WRITE_BYTES, "write_total") + #endif -- 1.7.1

2 1

[libvirt] [PATCH] virsh: change-media: Fix behavior with --update without a source
by Peter Krempa 09 Jun '15

09 Jun '15

Docs state that it should behave like eject. Currently the code does not do that. This is a regression since f4b5f53027da4fed2250628e11bac4019. Resolves: https://bugzilla.redhat.com/show_bug.cgi?id=1229592 --- tools/virsh-domain.c | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/tools/virsh-domain.c b/tools/virsh-domain.c index a25b7ba..4c47473 100644 --- a/tools/virsh-domain.c +++ b/tools/virsh-domain.c @@ -12411,6 +12411,15 @@ cmdChangeMedia(vshControl *ctl, const vshCmd *cmd) VSH_EXCLUSIVE_OPTIONS_VAR(eject, block); + if (vshCommandOptStringReq(ctl, cmd, "source", &source) < 0) + return false; + + /* Docs state that update without source is eject */ + if (update && !source) { + update = false; + eject = true; + } + if (eject) { update_type = VSH_UPDATE_DISK_XML_EJECT; action = "eject"; @@ -12445,9 +12454,6 @@ cmdChangeMedia(vshControl *ctl, const vshCmd *cmd) if (vshCommandOptStringReq(ctl, cmd, "path", &path) < 0) goto cleanup; - if (vshCommandOptStringReq(ctl, cmd, "source", &source) < 0) - goto cleanup; - if (flags & VIR_DOMAIN_AFFECT_CONFIG) doc = virDomainGetXMLDesc(dom, VIR_DOMAIN_XML_INACTIVE); else -- 2.4.1

2 2

[libvirt] [PATCH] qemu: Capitalize "storage" in qemuDomainAttachUSBMassStorageDevice()
by Andrea Bolognani 09 Jun '15

09 Jun '15

--- src/qemu/qemu_hotplug.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/qemu/qemu_hotplug.c b/src/qemu/qemu_hotplug.c index 94ebe35..3562de6 100644 --- a/src/qemu/qemu_hotplug.c +++ b/src/qemu/qemu_hotplug.c @@ -680,7 +680,7 @@ qemuDomainAttachSCSIDisk(virConnectPtr conn, static int -qemuDomainAttachUSBMassstorageDevice(virConnectPtr conn, +qemuDomainAttachUSBMassStorageDevice(virConnectPtr conn, virQEMUDriverPtr driver, virDomainObjPtr vm, virDomainDiskDefPtr disk) @@ -823,7 +823,7 @@ qemuDomainAttachDeviceDiskLive(virConnectPtr conn, _("disk device='lun' is not supported for usb bus")); break; } - ret = qemuDomainAttachUSBMassstorageDevice(conn, driver, vm, + ret = qemuDomainAttachUSBMassStorageDevice(conn, driver, vm, disk); } else if (disk->bus == VIR_DOMAIN_DISK_BUS_VIRTIO) { ret = qemuDomainAttachVirtioDiskDevice(conn, driver, vm, disk); -- 2.4.2

2 1

[libvirt] Qemu-Libgfapi: periodical shutdown of virtual machines.
by Igor Yakovlev 09 Jun '15

09 Jun '15

Hello, Would you so kind to help me with my problem concerning libgfapi. My host operating system is Ubuntu 14.04 LTS, version of glusterfs is 3.6.2, and version of qemu is 2.0.0. We use libfgapi library to connect to glusterfs. In our environment virtual machines sometimes go to power-off state 'Powered Off'(Shutdown) with ERROR in /var/log/syslog like: kernel: [5346607.988173] qemu-system-x86[29564]: segfault at 128 ip 00007f930a90b48c sp 00007f931296fd70 error 4 in qemu-system-x86_64[7f930a57f000+4b1000] Please help me to understand possible reasons of the qemu-system segfault. Maybe glusterfs tuning is required or tuning of libvirt. Do you have any ideas?... Best regards, Igor.

1 0

[libvirt] [PATCH v4] parallels: add block device statistics to driver
by Nikolay Shirokovskiy 09 Jun '15

09 Jun '15

Statistics provided through PCS SDK. As we have only async interface in SDK we need to be subscribed to statistics in order to get it. Trivial solution on every stat request to subscribe, wait event and then unsubscribe will lead to significant delays in case of a number of successive requests, as the event will be delivered on next PCS server notify cycle. On the other hand we don't want to keep unnesessary subscribtion. So we take an hibrid solution to subcsribe on first request and then keep a subscription while requests are active. We populate cache of statistics on subscribtion events and use this cache to serve libvirts requests. * Cache details. Cache is just handle to last arrived event, we call this cache as if this handle is valid it is used to serve synchronous statistics requests. We use number of successive events count to detect that user lost interest to statistics. We reset this count to 0 on every request. If more than PARALLELS_STATISTICS_DROP_COUNT successive events arrive we unsubscribe. Special value of -1 of this counter is used to differentiate between subscribed/unsubscribed state to protect from delayed events. Values of PARALLELS_STATISTICS_DROP_COUNT and PARALLELS_STATISTICS_TIMEOUT are just drop-ins, choosen without special consideration. * Thread safety issues Use parallelsDomObjFromDomainRef in parallelsDomainBlockStats as we could wait on domain lock down on stack in prlsdkGetStatsParam and if we won't keep reference we could get dangling pointer on return from wait. Signed-off-by: Nikolay Shirokovskiy <nshirokovskiy(a)parallels.com> --- src/parallels/parallels_driver.c | 106 ++++++++++++++++++++ src/parallels/parallels_sdk.c | 200 +++++++++++++++++++++++++++++++++++++- src/parallels/parallels_sdk.h | 2 + src/parallels/parallels_utils.c | 28 ++++++ src/parallels/parallels_utils.h | 18 ++++ 5 files changed, 350 insertions(+), 4 deletions(-) diff --git a/src/parallels/parallels_driver.c b/src/parallels/parallels_driver.c index 4b87213..33c112e 100644 --- a/src/parallels/parallels_driver.c +++ b/src/parallels/parallels_driver.c @@ -51,6 +51,7 @@ #include "nodeinfo.h" #include "virstring.h" #include "cpu/cpu.h" +#include "virtypedparam.h" #include "parallels_driver.h" #include "parallels_utils.h" @@ -1179,6 +1180,109 @@ parallelsDomainGetMaxMemory(virDomainPtr domain) return ret; } +static int +parallelsDomainBlockStats(virDomainPtr domain, const char *path, + virDomainBlockStatsPtr stats) +{ + virDomainObjPtr dom = NULL; + int ret = -1; + size_t i; + int idx; + + if (!(dom = parallelsDomObjFromDomainRef(domain))) + return -1; + + if (*path) { + if ((idx = virDomainDiskIndexByName(dom->def, path, false)) < 0) { + virReportError(VIR_ERR_INVALID_ARG, _("invalid path: %s"), path); + goto cleanup; + } + if (prlsdkGetBlockStats(dom, dom->def->disks[idx], stats) < 0) + goto cleanup; + } else { + virDomainBlockStatsStruct s; + +#define PARALLELS_ZERO_STATS(VAR, TYPE, NAME) \ + stats->VAR = 0; + + PARALLELS_BLOCK_STATS_FOREACH(PARALLELS_ZERO_STATS) + +#undef PARALLELS_ZERO_STATS + + for (i = 0; i < dom->def->ndisks; i++) { + if (prlsdkGetBlockStats(dom, dom->def->disks[i], &s) < 0) + goto cleanup; + +#define PARALLELS_SUM_STATS(VAR, TYPE, NAME) \ + if (s.VAR != -1) \ + stats->VAR += s.VAR; + + PARALLELS_BLOCK_STATS_FOREACH(PARALLELS_SUM_STATS) + +#undef PARALLELS_SUM_STATS + } + } + stats->errs = -1; + ret = 0; + + cleanup: + if (dom) + virDomainObjEndAPI(&dom); + + return ret; +} + +static int +parallelsDomainBlockStatsFlags(virDomainPtr domain, + const char *path, + virTypedParameterPtr params, + int *nparams, + unsigned int flags) +{ + virDomainBlockStatsStruct stats; + int ret = -1; + size_t i; + + virCheckFlags(VIR_TYPED_PARAM_STRING_OKAY, -1); + /* We don't return strings, and thus trivially support this flag. */ + flags &= ~VIR_TYPED_PARAM_STRING_OKAY; + + if (parallelsDomainBlockStats(domain, path, &stats) < 0) + goto cleanup; + + if (*nparams == 0) { +#define PARALLELS_COUNT_STATS(VAR, TYPE, NAME) \ + if ((stats.VAR) != -1) \ + ++*nparams; + + PARALLELS_BLOCK_STATS_FOREACH(PARALLELS_COUNT_STATS) + +#undef PARALLELS_COUNT_STATS + ret = 0; + goto cleanup; + } + + i = 0; +#define PARALLELS_BLOCK_STATS_ASSIGN_PARAM(VAR, TYPE, NAME) \ + if (i < *nparams && (stats.VAR) != -1) { \ + if (virTypedParameterAssign(params + i, TYPE, \ + VIR_TYPED_PARAM_LLONG, (stats.VAR)) < 0) \ + goto cleanup; \ + i++; \ + } + + PARALLELS_BLOCK_STATS_FOREACH(PARALLELS_BLOCK_STATS_ASSIGN_PARAM) + +#undef PARALLELS_BLOCK_STATS_ASSIGN_PARAM + + *nparams = i; + ret = 0; + + cleanup: + return ret; +} + + static virHypervisorDriver parallelsDriver = { .name = "Parallels", .connectOpen = parallelsConnectOpen, /* 0.10.0 */ @@ -1228,6 +1332,8 @@ static virHypervisorDriver parallelsDriver = { .domainManagedSave = parallelsDomainManagedSave, /* 1.2.14 */ .domainManagedSaveRemove = parallelsDomainManagedSaveRemove, /* 1.2.14 */ .domainGetMaxMemory = parallelsDomainGetMaxMemory, /* 1.2.15 */ + .domainBlockStats = parallelsDomainBlockStats, /* 1.2.17 */ + .domainBlockStatsFlags = parallelsDomainBlockStatsFlags, /* 1.2.17 */ }; static virConnectDriver parallelsConnectDriver = { diff --git a/src/parallels/parallels_sdk.c b/src/parallels/parallels_sdk.c index 6d63759..00e51f4 100644 --- a/src/parallels/parallels_sdk.c +++ b/src/parallels/parallels_sdk.c @@ -21,6 +21,7 @@ */ #include <config.h> +#include <stdarg.h> #include "virerror.h" #include "viralloc.h" @@ -29,6 +30,7 @@ #include "virlog.h" #include "datatypes.h" #include "domain_conf.h" +#include "virtime.h" #include "parallels_sdk.h" @@ -407,6 +409,8 @@ prlsdkDomObjFreePrivate(void *p) return; PrlHandle_Free(pdom->sdkdom); + PrlHandle_Free(pdom->cache.stats); + virCondDestroy(&pdom->cache.cond); VIR_FREE(pdom->uuid); VIR_FREE(pdom->home); VIR_FREE(p); @@ -1260,6 +1264,13 @@ prlsdkLoadDomain(parallelsConnPtr privconn, * to NULL temporarily */ pdom->uuid = NULL; + pdom->cache.stats = PRL_INVALID_HANDLE; + pdom->cache.count = -1; + if (virCondInit(&pdom->cache.cond) < 0) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("cannot initialize condition")); + goto error; + } + if (prlsdkGetDomainIds(sdkdom, &def->name, def->uuid) < 0) goto error; @@ -1611,6 +1622,51 @@ prlsdkHandleVmRemovedEvent(parallelsConnPtr privconn, return; } +#define PARALLELS_STATISTICS_DROP_COUNT 3 + +static PRL_RESULT +prlsdkHandlePerfEvent(parallelsConnPtr privconn, + PRL_HANDLE event, + unsigned char *uuid) +{ + virDomainObjPtr dom = NULL; + parallelsDomObjPtr privdom = NULL; + PRL_HANDLE job = PRL_INVALID_HANDLE; + + dom = virDomainObjListFindByUUID(privconn->domains, uuid); + if (dom == NULL) + goto cleanup; + privdom = dom->privateData; + + // delayed event after unsubscribe + if (privdom->cache.count == -1) + goto cleanup; + + PrlHandle_Free(privdom->cache.stats); + privdom->cache.stats = PRL_INVALID_HANDLE; + + if (privdom->cache.count > PARALLELS_STATISTICS_DROP_COUNT) { + job = PrlVm_UnsubscribeFromPerfStats(privdom->sdkdom); + if (PRL_FAILED(waitJob(job))) + goto cleanup; + // change state to unsubscribed + privdom->cache.count = -1; + } else { + ++privdom->cache.count; + privdom->cache.stats = event; + // thus we get own of event handle + event = PRL_INVALID_HANDLE; + virCondSignal(&privdom->cache.cond); + } + + cleanup: + PrlHandle_Free(event); + if (dom) + virObjectUnlock(dom); + + return PRL_ERR_SUCCESS; +} + static void prlsdkHandleVmEvent(parallelsConnPtr privconn, PRL_HANDLE prlEvent) { @@ -1621,13 +1677,13 @@ prlsdkHandleVmEvent(parallelsConnPtr privconn, PRL_HANDLE prlEvent) PRL_EVENT_TYPE prlEventType; pret = PrlEvent_GetType(prlEvent, &prlEventType); - prlsdkCheckRetGoto(pret, error); + prlsdkCheckRetGoto(pret, cleanup); pret = PrlEvent_GetIssuerId(prlEvent, uuidstr, &bufsize); - prlsdkCheckRetGoto(pret, error); + prlsdkCheckRetGoto(pret, cleanup); if (prlsdkUUIDParse(uuidstr, uuid) < 0) - return; + goto cleanup; switch (prlEventType) { case PET_DSP_EVT_VM_STATE_CHANGED: @@ -1644,12 +1700,18 @@ prlsdkHandleVmEvent(parallelsConnPtr privconn, PRL_HANDLE prlEvent) case PET_DSP_EVT_VM_UNREGISTERED: prlsdkHandleVmRemovedEvent(privconn, uuid); break; + case PET_DSP_EVT_VM_PERFSTATS: + prlsdkHandlePerfEvent(privconn, prlEvent, uuid); + // above function takes own of event + prlEvent = PRL_INVALID_HANDLE; + break; default: virReportError(VIR_ERR_INTERNAL_ERROR, _("Can't handle event of type %d"), prlEventType); } - error: + cleanup: + PrlHandle_Free(prlEvent); return; } @@ -1677,6 +1739,8 @@ prlsdkEventsHandler(PRL_HANDLE prlEvent, PRL_VOID_PTR opaque) switch (prlIssuerType) { case PIE_VIRTUAL_MACHINE: prlsdkHandleVmEvent(privconn, prlEvent); + // above function takes own of event + prlEvent = PRL_INVALID_HANDLE; break; default: VIR_DEBUG("Skipping event of issuer type %d", prlIssuerType); @@ -1687,6 +1751,7 @@ prlsdkEventsHandler(PRL_HANDLE prlEvent, PRL_VOID_PTR opaque) return PRL_ERR_SUCCESS; } + int prlsdkSubscribeToPCSEvents(parallelsConnPtr privconn) { PRL_RESULT pret = PRL_ERR_UNINITIALIZED; @@ -3423,3 +3488,130 @@ prlsdkDomainManagedSaveRemove(virDomainObjPtr dom) return 0; } + +static int +prlsdkExtractStatsParam(PRL_HANDLE sdkstats, const char *name, long long *val) +{ + PRL_HANDLE param = PRL_INVALID_HANDLE; + PRL_RESULT pret; + PRL_INT64 pval = 0; + int ret = -1; + + pret = PrlEvent_GetParamByName(sdkstats, name, &param); + if (pret == PRL_ERR_NO_DATA) { + *val = -1; + ret = 0; + goto cleanup; + } else if (PRL_FAILED(pret)) { + logPrlError(pret); + goto cleanup; + } + pret = PrlEvtPrm_ToInt64(param, &pval); + prlsdkCheckRetGoto(pret, cleanup); + + *val = pval; + ret = 0; + + cleanup: + PrlHandle_Free(param); + return ret; +} + +#define PARALLELS_STATISTICS_TIMEOUT (60 * 1000) + +static int +prlsdkGetStatsParam(virDomainObjPtr dom, const char *name, long long *val) +{ + parallelsDomObjPtr privdom = dom->privateData; + PRL_HANDLE job = PRL_INVALID_HANDLE; + unsigned long long now; + + if (privdom->cache.stats != PRL_INVALID_HANDLE) { + // reset count to keep subscribtion + privdom->cache.count = 0; + return prlsdkExtractStatsParam(privdom->cache.stats, name, val); + } + + if (privdom->cache.count == -1) { + job = PrlVm_SubscribeToPerfStats(privdom->sdkdom, NULL); + if (PRL_FAILED(waitJob(job))) + goto error; + } + + // change state to subscribed in case of unsubscribed + // or reset count so we stop unsubscribe attempts + privdom->cache.count = 0; + + if (virTimeMillisNow(&now) < 0) { + virReportSystemError(errno, "%s", _("Unable to get current time")); + goto error; + } + + while (privdom->cache.stats == PRL_INVALID_HANDLE) { + if (virCondWaitUntil(&privdom->cache.cond, &dom->parent.lock, + now + PARALLELS_STATISTICS_TIMEOUT) < 0) { + if (errno == ETIMEDOUT) { + virReportError(VIR_ERR_OPERATION_TIMEOUT, "%s", + _("Timeout on waiting statistics event.")); + goto error; + } else { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("Unable to wait on monitor condition")); + goto error; + } + } + } + + return prlsdkExtractStatsParam(privdom->cache.stats, name, val); + error: + return -1; +} + +int +prlsdkGetBlockStats(virDomainObjPtr dom, virDomainDiskDefPtr disk, virDomainBlockStatsPtr stats) +{ + virDomainDeviceDriveAddressPtr address; + int idx; + const char *prefix; + int ret = -1; + char *name = NULL; + + address = &disk->info.addr.drive; + switch (disk->bus) { + case VIR_DOMAIN_DISK_BUS_IDE: + prefix = "ide"; + idx = address->bus * 2 + address->unit; + break; + case VIR_DOMAIN_DISK_BUS_SATA: + prefix = "sata"; + idx = address->unit; + break; + case VIR_DOMAIN_DISK_BUS_SCSI: + prefix = "scsi"; + idx = address->unit; + break; + default: + virReportError(VIR_ERR_INTERNAL_ERROR, + _("Unknown disk bus: %X"), disk->bus); + goto cleanup; + } + + +#define PRLSDK_GET_STAT_PARAM(VAL, TYPE, NAME) \ + if (virAsprintf(&name, "devices.%s%d.%s", prefix, idx, NAME) < 0) \ + goto cleanup; \ + if (prlsdkGetStatsParam(dom, name, &stats->VAL) < 0) \ + goto cleanup; \ + VIR_FREE(name); + + PARALLELS_BLOCK_STATS_FOREACH(PRLSDK_GET_STAT_PARAM) + +#undef PRLSDK_GET_STAT_PARAM + + ret = 0; + + cleanup: + + VIR_FREE(name); + return ret; +} diff --git a/src/parallels/parallels_sdk.h b/src/parallels/parallels_sdk.h index 3f17fc8..afa6745 100644 --- a/src/parallels/parallels_sdk.h +++ b/src/parallels/parallels_sdk.h @@ -64,3 +64,5 @@ int prlsdkAttachVolume(virDomainObjPtr dom, virDomainDiskDefPtr disk); int prlsdkDetachVolume(virDomainObjPtr dom, virDomainDiskDefPtr disk); +int +prlsdkGetBlockStats(virDomainObjPtr dom, virDomainDiskDefPtr disk, virDomainBlockStatsPtr stats); diff --git a/src/parallels/parallels_utils.c b/src/parallels/parallels_utils.c index ff9d47d..540986b 100644 --- a/src/parallels/parallels_utils.c +++ b/src/parallels/parallels_utils.c @@ -64,6 +64,34 @@ parallelsDomObjFromDomain(virDomainPtr domain) } +/** + * parallelsDomObjFromDomainRef: + * @domain: Domain pointer that has to be looked up + * + * This function looks up @domain and returns the appropriate virDomainObjPtr + * that has to be released by calling virDomainObjEndAPI(). + * + * Returns the domain object with incremented reference counter which is locked + * on success, NULL otherwise. + */ +virDomainObjPtr +parallelsDomObjFromDomainRef(virDomainPtr domain) +{ + virDomainObjPtr vm; + parallelsConnPtr privconn = domain->conn->privateData; + char uuidstr[VIR_UUID_STRING_BUFLEN]; + + vm = virDomainObjListFindByUUIDRef(privconn->domains, domain->uuid); + if (!vm) { + virUUIDFormat(domain->uuid, uuidstr); + virReportError(VIR_ERR_NO_DOMAIN, + _("no domain with matching uuid '%s' (%s)"), + uuidstr, domain->name); + return NULL; + } + + return vm; +} static int parallelsDoCmdRun(char **outbuf, const char *binary, va_list list) diff --git a/src/parallels/parallels_utils.h b/src/parallels/parallels_utils.h index 2d1d405..cdf6082 100644 --- a/src/parallels/parallels_utils.h +++ b/src/parallels/parallels_utils.h @@ -73,11 +73,22 @@ struct _parallelsConn { typedef struct _parallelsConn parallelsConn; typedef struct _parallelsConn *parallelsConnPtr; +struct _parallelsContersCache { + PRL_HANDLE stats; + virCond cond; + // -1 - unsubscribed + // > -1 - subscribed + int count; +}; + +typedef struct _parallelsContersCache parallelsContersCache; + struct parallelsDomObj { int id; char *uuid; char *home; PRL_HANDLE sdkdom; + parallelsContersCache cache; }; typedef struct parallelsDomObj *parallelsDomObjPtr; @@ -91,6 +102,7 @@ int parallelsNetworkClose(virConnectPtr conn); extern virNetworkDriver parallelsNetworkDriver; virDomainObjPtr parallelsDomObjFromDomain(virDomainPtr domain); +virDomainObjPtr parallelsDomObjFromDomainRef(virDomainPtr domain); virJSONValuePtr parallelsParseOutput(const char *binary, ...) ATTRIBUTE_NONNULL(1) ATTRIBUTE_SENTINEL; @@ -106,4 +118,10 @@ virStorageVolPtr parallelsStorageVolLookupByPathLocked(virConnectPtr conn, int parallelsStorageVolDefRemove(virStoragePoolObjPtr privpool, virStorageVolDefPtr privvol); +#define PARALLELS_BLOCK_STATS_FOREACH(OP) \ + OP(rd_req, VIR_DOMAIN_BLOCK_STATS_READ_REQ, "read_requests") \ + OP(rd_bytes, VIR_DOMAIN_BLOCK_STATS_READ_BYTES, "read_total") \ + OP(wr_req, VIR_DOMAIN_BLOCK_STATS_WRITE_REQ, "write_requests") \ + OP(wr_bytes, VIR_DOMAIN_BLOCK_STATS_WRITE_BYTES, "write_total") + #endif -- 1.7.1

2 2

[libvirt] [PATCH 0/3] qemu: Allow arm 32-on-64 KVM
by Cole Robinson 09 Jun '15

09 Jun '15

qemu 2.3.0 added support for enabling armv7l VMs to run on aarch64 hosts with KVM. First patch handles the special command line bit, last two patches are about advertising things in virsh capabilities. After these patches, 'virt-install --arch armv7l ...' on an aarch64 host with new enough qemu will automatically use KVM and generate a working config. Cole Robinson (3): qemu: command: Support arm 32-on-64 KVM with -cpu aarch64=off qemu: caps: qemu-system-aarch64 supports armv7l qemu: caps: Advertise arm 32-on-64 KVM option src/qemu/qemu_capabilities.c | 57 ++++++++++++++-------- src/qemu/qemu_capabilities.h | 1 + src/qemu/qemu_command.c | 13 +++++ .../qemuxml2argv-aarch64-kvm-32-on-64.args | 10 ++++ .../qemuxml2argv-aarch64-kvm-32-on-64.xml | 35 +++++++++++++ tests/qemuxml2argvtest.c | 9 ++++ 6 files changed, 105 insertions(+), 20 deletions(-) create mode 100644 tests/qemuxml2argvdata/qemuxml2argv-aarch64-kvm-32-on-64.args create mode 100644 tests/qemuxml2argvdata/qemuxml2argv-aarch64-kvm-32-on-64.xml -- 2.4.1

3 9

[libvirt] [PATCH] parallels: return only success from PCS event handler
by Nikolay Shirokovskiy 09 Jun '15

09 Jun '15

2 reasons to to this. 1. PCS SDK really don't care of handler return value. 2. It hard to imagine how notifier can handle subscriber failures. Even if there are some situations we probably will use some special error codes and not just throw error codes we get from SDK itself. Signed-off-by: Nikolay Shirokovskiy <nshirokovskiy(a)parallels.com> --- src/parallels/parallels_sdk.c | 121 ++++++++++++++++------------------------- 1 files changed, 47 insertions(+), 74 deletions(-) diff --git a/src/parallels/parallels_sdk.c b/src/parallels/parallels_sdk.c index d5a9790..6d63759 100644 --- a/src/parallels/parallels_sdk.c +++ b/src/parallels/parallels_sdk.c @@ -1516,7 +1516,7 @@ prlsdkNewStateToEvent(VIRTUAL_MACHINE_STATE domainState, } } -static PRL_RESULT +static void prlsdkHandleVmStateEvent(parallelsConnPtr privconn, PRL_HANDLE prlEvent, unsigned char *uuid) @@ -1529,18 +1529,16 @@ prlsdkHandleVmStateEvent(parallelsConnPtr privconn, virDomainEventType lvEventType = 0; int lvEventTypeDetails = 0; + dom = virDomainObjListFindByUUID(privconn->domains, uuid); + if (dom == NULL) + return; + pret = PrlEvent_GetParamByName(prlEvent, "vminfo_vm_state", &eventParam); prlsdkCheckRetGoto(pret, cleanup); pret = PrlEvtPrm_ToInt32(eventParam, &domainState); prlsdkCheckRetGoto(pret, cleanup); - dom = virDomainObjListFindByUUID(privconn->domains, uuid); - if (dom == NULL) { - pret = PRL_ERR_VM_UUID_NOT_FOUND; - goto cleanup; - } - pdom = dom->privateData; if (prlsdkConvertDomainState(domainState, pdom->id, dom) < 0) goto cleanup; @@ -1549,96 +1547,74 @@ prlsdkHandleVmStateEvent(parallelsConnPtr privconn, &lvEventType, &lvEventTypeDetails); - if (prlsdkSendEvent(privconn, dom, lvEventType, lvEventTypeDetails) < 0) { - pret = PRL_ERR_OUT_OF_MEMORY; - goto cleanup; - } + prlsdkSendEvent(privconn, dom, lvEventType, lvEventTypeDetails); cleanup: - if (dom) - virObjectUnlock(dom); - return pret; + virObjectUnlock(dom); + return; } -static PRL_RESULT +static void prlsdkHandleVmConfigEvent(parallelsConnPtr privconn, unsigned char *uuid) { - PRL_RESULT pret = PRL_ERR_FAILURE; virDomainObjPtr dom = NULL; dom = virDomainObjListFindByUUID(privconn->domains, uuid); - if (dom == NULL) { - pret = PRL_ERR_VM_UUID_NOT_FOUND; - goto cleanup; - } + if (dom == NULL) + return; if (prlsdkUpdateDomain(privconn, dom) < 0) goto cleanup; - if (prlsdkSendEvent(privconn, dom, VIR_DOMAIN_EVENT_DEFINED, - VIR_DOMAIN_EVENT_DEFINED_UPDATED) < 0) { - pret = PRL_ERR_OUT_OF_MEMORY; - goto cleanup; - } + prlsdkSendEvent(privconn, dom, VIR_DOMAIN_EVENT_DEFINED, + VIR_DOMAIN_EVENT_DEFINED_UPDATED); - pret = PRL_ERR_SUCCESS; cleanup: - if (dom) - virObjectUnlock(dom); - return pret; + virObjectUnlock(dom); + return; } -static PRL_RESULT +static void prlsdkHandleVmAddedEvent(parallelsConnPtr privconn, unsigned char *uuid) { - PRL_RESULT pret; virDomainObjPtr dom = NULL; dom = prlsdkAddDomain(privconn, uuid); - if (!dom) - return PRL_ERR_FAILURE; + if (dom == NULL) + return; - if (prlsdkSendEvent(privconn, dom, VIR_DOMAIN_EVENT_DEFINED, - VIR_DOMAIN_EVENT_DEFINED_ADDED) < 0) { - pret = PRL_ERR_OUT_OF_MEMORY; - goto cleanup; - } + prlsdkSendEvent(privconn, dom, VIR_DOMAIN_EVENT_DEFINED, + VIR_DOMAIN_EVENT_DEFINED_ADDED); - pret = PRL_ERR_SUCCESS; - cleanup: - if (dom) - virObjectUnlock(dom); - return pret; + virObjectUnlock(dom); + return; } -static PRL_RESULT +static void prlsdkHandleVmRemovedEvent(parallelsConnPtr privconn, unsigned char *uuid) { virDomainObjPtr dom = NULL; - PRL_RESULT pret = PRL_ERR_SUCCESS; dom = virDomainObjListFindByUUID(privconn->domains, uuid); - if (dom == NULL) { - /* domain was removed from the list from the libvirt - * API function in current connection */ - return PRL_ERR_SUCCESS; - } + /* domain was removed from the list from the libvirt + * API function in current connection */ + if (dom == NULL) + return; - if (prlsdkSendEvent(privconn, dom, VIR_DOMAIN_EVENT_UNDEFINED, - VIR_DOMAIN_EVENT_UNDEFINED_REMOVED) < 0) - pret = PRL_ERR_OUT_OF_MEMORY; + prlsdkSendEvent(privconn, dom, VIR_DOMAIN_EVENT_UNDEFINED, + VIR_DOMAIN_EVENT_UNDEFINED_REMOVED); virDomainObjListRemove(privconn->domains, dom); - return pret; + return; } -static PRL_RESULT +static void prlsdkHandleVmEvent(parallelsConnPtr privconn, PRL_HANDLE prlEvent) { - PRL_RESULT pret; + PRL_RESULT pret = PRL_ERR_FAILURE; char uuidstr[VIR_UUID_STRING_BUFLEN + 2]; unsigned char uuid[VIR_UUID_BUFLEN]; PRL_UINT32 bufsize = ARRAY_CARDINALITY(uuidstr); @@ -1651,67 +1627,64 @@ prlsdkHandleVmEvent(parallelsConnPtr privconn, PRL_HANDLE prlEvent) prlsdkCheckRetGoto(pret, error); if (prlsdkUUIDParse(uuidstr, uuid) < 0) - return PRL_ERR_FAILURE; + return; switch (prlEventType) { case PET_DSP_EVT_VM_STATE_CHANGED: - return prlsdkHandleVmStateEvent(privconn, prlEvent, uuid); + prlsdkHandleVmStateEvent(privconn, prlEvent, uuid); + break; case PET_DSP_EVT_VM_CONFIG_CHANGED: - return prlsdkHandleVmConfigEvent(privconn, uuid); + prlsdkHandleVmConfigEvent(privconn, uuid); + break; case PET_DSP_EVT_VM_CREATED: case PET_DSP_EVT_VM_ADDED: - return prlsdkHandleVmAddedEvent(privconn, uuid); + prlsdkHandleVmAddedEvent(privconn, uuid); + break; case PET_DSP_EVT_VM_DELETED: case PET_DSP_EVT_VM_UNREGISTERED: - return prlsdkHandleVmRemovedEvent(privconn, uuid); + prlsdkHandleVmRemovedEvent(privconn, uuid); break; default: virReportError(VIR_ERR_INTERNAL_ERROR, _("Can't handle event of type %d"), prlEventType); - return PRL_ERR_FAILURE; } error: - return PRL_ERR_FAILURE; + return; } static PRL_RESULT prlsdkEventsHandler(PRL_HANDLE prlEvent, PRL_VOID_PTR opaque) { parallelsConnPtr privconn = opaque; - PRL_RESULT pret = PRL_ERR_UNINITIALIZED; + PRL_RESULT pret = PRL_ERR_FAILURE; PRL_HANDLE_TYPE handleType; PRL_EVENT_ISSUER_TYPE prlIssuerType = PIE_UNKNOWN; pret = PrlHandle_GetType(prlEvent, &handleType); prlsdkCheckRetGoto(pret, cleanup); - if (handleType != PHT_EVENT) { - /* Currently, there is no need to handle anything but events */ - pret = PRL_ERR_SUCCESS; + /* Currently, there is no need to handle anything but events */ + if (handleType != PHT_EVENT) goto cleanup; - } - if (privconn == NULL) { - pret = PRL_ERR_INVALID_ARG; + if (privconn == NULL) goto cleanup; - } PrlEvent_GetIssuerType(prlEvent, &prlIssuerType); prlsdkCheckRetGoto(pret, cleanup); switch (prlIssuerType) { case PIE_VIRTUAL_MACHINE: - pret = prlsdkHandleVmEvent(privconn, prlEvent); + prlsdkHandleVmEvent(privconn, prlEvent); break; default: VIR_DEBUG("Skipping event of issuer type %d", prlIssuerType); } - pret = PRL_ERR_SUCCESS; cleanup: PrlHandle_Free(prlEvent); - return pret; + return PRL_ERR_SUCCESS; } int prlsdkSubscribeToPCSEvents(parallelsConnPtr privconn) -- 1.7.1

2 1

[libvirt] [PATCH v2] parallels: simplify event types discrimination
by Nikolay Shirokovskiy 09 Jun '15

09 Jun '15

Use issuer type instead of event type to group vm related events. This saves us from explicit enumeration of all vm event types in prlsdkHandleVmEvent. --- src/parallels/parallels_sdk.c | 15 +++++---------- 1 files changed, 5 insertions(+), 10 deletions(-) diff --git a/src/parallels/parallels_sdk.c b/src/parallels/parallels_sdk.c index 88ad59b..d5a9790 100644 --- a/src/parallels/parallels_sdk.c +++ b/src/parallels/parallels_sdk.c @@ -1681,7 +1681,7 @@ prlsdkEventsHandler(PRL_HANDLE prlEvent, PRL_VOID_PTR opaque) parallelsConnPtr privconn = opaque; PRL_RESULT pret = PRL_ERR_UNINITIALIZED; PRL_HANDLE_TYPE handleType; - PRL_EVENT_TYPE prlEventType; + PRL_EVENT_ISSUER_TYPE prlIssuerType = PIE_UNKNOWN; pret = PrlHandle_GetType(prlEvent, &handleType); prlsdkCheckRetGoto(pret, cleanup); @@ -1697,20 +1697,15 @@ prlsdkEventsHandler(PRL_HANDLE prlEvent, PRL_VOID_PTR opaque) goto cleanup; } - PrlEvent_GetType(prlEvent, &prlEventType); + PrlEvent_GetIssuerType(prlEvent, &prlIssuerType); prlsdkCheckRetGoto(pret, cleanup); - switch (prlEventType) { - case PET_DSP_EVT_VM_STATE_CHANGED: - case PET_DSP_EVT_VM_CONFIG_CHANGED: - case PET_DSP_EVT_VM_CREATED: - case PET_DSP_EVT_VM_ADDED: - case PET_DSP_EVT_VM_DELETED: - case PET_DSP_EVT_VM_UNREGISTERED: + switch (prlIssuerType) { + case PIE_VIRTUAL_MACHINE: pret = prlsdkHandleVmEvent(privconn, prlEvent); break; default: - VIR_DEBUG("Skipping event of type %d", prlEventType); + VIR_DEBUG("Skipping event of issuer type %d", prlIssuerType); } pret = PRL_ERR_SUCCESS; -- 1.7.1

2 1

[libvirt] [PATCH v2 0/3] Testing of RPC JSON (de)serialization
by Daniel P. Berrange 08 Jun '15

08 Jun '15

This is a re-post of the previous patch I sent: https://www.redhat.com/archives/libvir-list/2015-May/msg00812.html The only change is to actually send the 2 pre-requisite patches for it ! Daniel P. Berrange (3): rpc: allow selection of TCP address family rpc: add API for checking IPv4/6 availability rpc: add testing of RPC JSON (de)serialization daemon/libvirtd.c | 2 + src/libvirt_remote.syms | 2 + src/libxl/libxl_migration.c | 8 +- src/qemu/qemu_migration.c | 4 +- src/remote/remote_driver.c | 3 +- src/rpc/virnetclient.c | 12 +- src/rpc/virnetclient.h | 4 +- src/rpc/virnetserver.c | 4 +- src/rpc/virnetserver.h | 3 + src/rpc/virnetserverclient.c | 13 +- src/rpc/virnetserverservice.c | 8 +- src/rpc/virnetserverservice.h | 1 + src/rpc/virnetsocket.c | 74 +++++- src/rpc/virnetsocket.h | 6 + tests/Makefile.am | 7 + tests/virnetserverdata/README | 14 + .../virnetserverdata/input-data-anon-clients.json | 63 +++++ tests/virnetserverdata/input-data-initial.json | 62 +++++ .../virnetserverdata/output-data-anon-clients.json | 63 +++++ tests/virnetserverdata/output-data-initial.json | 63 +++++ tests/virnetservertest.c | 290 +++++++++++++++++++++ tests/virnetsockettest.c | 44 +--- 22 files changed, 695 insertions(+), 55 deletions(-) create mode 100644 tests/virnetserverdata/README create mode 100644 tests/virnetserverdata/input-data-anon-clients.json create mode 100644 tests/virnetserverdata/input-data-initial.json create mode 100644 tests/virnetserverdata/output-data-anon-clients.json create mode 100644 tests/virnetserverdata/output-data-initial.json create mode 100644 tests/virnetservertest.c -- 2.4.1

2 7

[libvirt] qemu commit 65207c59 broke libvirt's capability retrieval (apparently)
by Laszlo Ersek 08 Jun '15

08 Jun '15

Hi All, after pulling QEMU master today, my existent libvirt guests that have the following element: <pm> <suspend-to-mem enabled='yes'/> <suspend-to-disk enabled='no'/> </pm> started to barf the following message at me: ---------- Error starting domain: unsupported configuration: setting ACPI S3 not supported Traceback (most recent call last): File "/usr/share/virt-manager/virtManager/asyncjob.py", line 89, in cb_wrapper callback(asyncjob, *args, **kwargs) File "/usr/share/virt-manager/virtManager/asyncjob.py", line 125, in tmpcb callback(*args, **kwargs) File "/usr/share/virt-manager/virtManager/domain.py", line 1393, in startup self._backend.create() File "/usr/lib64/python2.7/site-packages/libvirt.py", line 966, in create if ret == -1: raise libvirtError ('virDomainCreate() failed', dom=self) libvirtError: unsupported configuration: setting ACPI S3 not supported ---------- Now, I'm using RHEL-7.1.z libvirt with bleeding edge upstream qemu, so you could say this is "kinda unsupported" :), but anyway, I reckon this might be a problem with upstream libvirt too. Sorry if it's a known problem. I found this qemu commit, ie. commit 65207c59d99f2260c5f1d3b9c491146616a522aa Author: Markus Armbruster <armbru(a)redhat.com> Date: Thu Mar 5 14:35:26 2015 +0100 monitor: Drop broken, unused asynchronous command interface with bisection. Unfortunately, the bisection was extremely painful, because between a working version and today's pull, part of the qemu history was uncompileable. It was ultimately fixed with commit 9e472263b07d53cb3401ee49ef1b45ef195ddb84 Author: Michael S. Tsirkin <mst(a)redhat.com> Date: Mon Jun 1 21:03:59 2015 +0200 acpi: add missing ssdt Luckily, that commit suggests to remove the "iasl" binary from one's system, after which I could indeed continue the bisection. If I remove the <pm> element from the domain XML, then libvirt barfs something else: -------------- Error starting domain: unsupported configuration: hypervisor lacks deviceboot feature Traceback (most recent call last): File "/usr/share/virt-manager/virtManager/asyncjob.py", line 89, in cb_wrapper callback(asyncjob, *args, **kwargs) File "/usr/share/virt-manager/virtManager/asyncjob.py", line 125, in tmpcb callback(*args, **kwargs) File "/usr/share/virt-manager/virtManager/domain.py", line 1393, in startup self._backend.create() File "/usr/lib64/python2.7/site-packages/libvirt.py", line 966, in create if ret == -1: raise libvirtError ('virDomainCreate() failed', dom=self) libvirtError: unsupported configuration: hypervisor lacks deviceboot feature -------------- Which tells me that it's not individual capabilities that are broken by qemu 65207c59, but the entire libvirt capability retrieval. Apparently libvirt is one user of that async monitor interface. (The message on commit 65207c59 itself mentions "qmp_capabilities".) Sorry about the substandard formatting in the email, I'm in a bit of a hurry. Bisection log attached. Thanks Laszlo

3 3

[libvirt] poor virtio-scsi performance
by Vasiliy Tolstov 08 Jun '15

08 Jun '15

Hi all! I suspected poor performance of virtio-scsi driver. I did a few tests: Host machine: linux 3.19.1, QEMU emulator version 2.3.0 Guest machine: linux 4.0.4 part of domain xml: <emulator>/usr/bin/kvm</emulator> <disk type='block' device='disk'> <driver name='qemu' type='raw' cache='none' io='native' discard='unmap'/> <source dev='/dev/ram0'/> <backingStore/> <target dev='sda' bus='scsi'/> <alias name='scsi0-0-0-1'/> <address type='drive' controller='0' bus='0' target='0' unit='1'/> </disk> /dev/ram0 I got by running `modprobe brd rd_size=$((5*1024*1024))` on host machine. fio conf: [readtest] blocksize=4k filename=/dev/sdb (/dev/ram0 whe test from host machine) rw=randread direct=1 buffered=0 ioengine=libaio iodepth=32 results: from host: bw=1594.6MB/s, iops=408196, clat=76usec from guest: bw=398MB/s, iops=99720, clat=316usec Both host and guest system I boot with `scsi_mod.use_blk_mq=Y`. Why difference in 4 times?! -- Vasiliy Tolstov, e-mail: v.tolstov(a)selfip.ru

2 1

[libvirt] [PATCH v2] utiltest: Use int8_t instead of char.
by Michal Privoznik 08 Jun '15

08 Jun '15

Not every architecture out there has 'char' signed by default. For instance, my arm box has it unsigned by default: $ gcc -dM -E - < /dev/null | grep __CHAR_UNSIGNED__ #define __CHAR_UNSIGNED__ 1 Therefore, after 65c61e50 the test if failing for me. Problem is, we are trying to assign couple of negative values into char assuming some will overflow and some don't. That can't be the case if 'char' is unsigned by default. Lets use more explicit types instead: int8_t and uint8_t where is no ambiguity. Signed-off-by: Michal Privoznik <mprivozn(a)redhat.com> --- tests/utiltest.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/utiltest.c b/tests/utiltest.c index 3a1f8eb..98c689d 100644 --- a/tests/utiltest.c +++ b/tests/utiltest.c @@ -184,8 +184,8 @@ static int testOverflowCheckMacro(const void *data ATTRIBUTE_UNUSED) { long long tmp; - unsigned char luchar; - char lchar; + uint8_t luchar; + int8_t lchar; TEST_OVERFLOW(luchar, 254, false); TEST_OVERFLOW(luchar, 255, false); -- 2.3.6

2 1

[libvirt] [PATCH] apibuild: Fix indentation
by Jiri Denemark 08 Jun '15

08 Jun '15

Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com> --- docs/apibuild.py | 48 ++++++++++++++++++++++++------------------------ 1 file changed, 24 insertions(+), 24 deletions(-) diff --git a/docs/apibuild.py b/docs/apibuild.py index 9fa9361..18278db 100755 --- a/docs/apibuild.py +++ b/docs/apibuild.py @@ -1356,32 +1356,32 @@ class CParser: token = self.token() return token elif token[0] == "name": - self.cleanupComment() - if name is not None: - if self.comment is not None: - comment = string.strip(self.comment) - self.comment = None - self.enums.append((name, value, comment)) - name = token[1] - comment = "" + self.cleanupComment() + if name is not None: + if self.comment is not None: + comment = string.strip(self.comment) + self.comment = None + self.enums.append((name, value, comment)) + name = token[1] + comment = "" + token = self.token() + if token[0] == "op" and token[1][0] == "=": + value = "" + if len(token[1]) > 1: + value = token[1][1:] token = self.token() - if token[0] == "op" and token[1][0] == "=": - value = "" - if len(token[1]) > 1: - value = token[1][1:] - token = self.token() - while token[0] != "sep" or (token[1] != ',' and - token[1] != '}'): - value = value + token[1] - token = self.token() - else: - try: - value = "%d" % (int(value) + 1) - except: - self.warning("Failed to compute value of enum %s" % (name)) - value="" - if token[0] == "sep" and token[1] == ",": + while token[0] != "sep" or (token[1] != ',' and + token[1] != '}'): + value = value + token[1] token = self.token() + else: + try: + value = "%d" % (int(value) + 1) + except: + self.warning("Failed to compute value of enum %s" % (name)) + value="" + if token[0] == "sep" and token[1] == ",": + token = self.token() else: token = self.token() return token -- 2.4.2

2 1

[libvirt] [PATCH 0/2] Couple of unrelated fixes
by Michal Privoznik 08 Jun '15

08 Jun '15

*** BLURB HERE *** Michal Privoznik (2): utils: Return proper value for virGet{User,Group}ID utiltest: Don't assume 'char' is always signed src/util/virutil.c | 4 ++-- tests/utiltest.c | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) -- 2.3.6

3 5

[libvirt] the error is bug？
by cloudbuglist 08 Jun '15

08 Jun '15

Hi dear! Today I came across a problem, the following is a log and software versions. soft version: os:centos 6.5 libvirt:0.10.29 qemu:0.12.415 2015-05-28 03:28:58.001+0000: 20919: error : qemuDomainObjBeginJobInternal:843 : Timed out during operation: cannot acquire state change lock 2015-05-28 03:30:37.000+0000: 20918: warning : qemuDomainObjBeginJobInternal:839 : Cannot start job (query, none) for domain i-2-437-VM; current job is (query, none) owned by (20917, 0) 2015-05-28 03:30:37.000+0000: 20918: error : qemuDomainObjBeginJobInternal:843 : Timed out during operation: cannot acquire state change lock 2015-05-28 03:31:01.000+0000: 20919: warning : qemuDomainObjBeginJobInternal:839 : Cannot start job (query, none) for domain i-2-437-VM; current job is (query, none) owned by (20917, 0) 2015-05-28 03:31:01.000+0000: 20919: error : qemuDomainObjBeginJobInternal:843 : Timed out during operation: cannot acquire state change lock 2015-05-28 03:32:40.000+0000: 20921: warning : qemuDomainObjBeginJobInternal:839 : Cannot start job (query, none) for domain i-2-437-VM; current job is (query, none) owned by (20917, 0) 2015-05-28 03:32:40.000+0000: 20921: error : qemuDomainObjBeginJobInternal:843 : Timed out during operation: cannot acquire state change lock 2015-05-28 03:33:06.000+0000: 20918: warning : qemuDomainObjBeginJobInternal:839 : Cannot start job (query, none) for domain i-2-437-VM; current job is (query, none) owned by (20917, 0) 2015-05-28 03:33:06.000+0000: 20918: error : qemuDomainObjBeginJobInternal:843 : Timed out during operation: cannot acquire state change lock 2015-05-28 03:33:42.009+0000: 20916: error : virNetSocketReadWire:1194 : End of file while reading data: Input/output error 2015-05-28 03:34:02.000+0000: 20921: warning : qemuDomainObjBeginJobInternal:839 : Cannot start job (query, none) for domain i-2-437-VM; current job is (query, none) owned by (20917, 0) 2015-05-28 03:34:02.000+0000: 20921: error : qemuDomainObjBeginJobInternal:843 : Timed out during operation: cannot acquire state change lock 2015-05-28 03:34:19.001+0000: 20920: warning : qemuDomainObjBeginJobInternal:839 : Cannot start job (query, none) for domain i-2-437-VM; current job is (query, none) owned by (20917, 0) 2015-05-28 03:34:19.001+0000: 20920: error : qemuDomainObjBeginJobInternal:843 : Timed out during operation: cannot acquire state change lock 2015-05-28 03:34:43.384+0000: 20916: error : virNetSocketReadWire:1194 : End of file while reading data: Input/output error 2015-05-28 03:34:47.000+0000: 20918: warning : qemuDomainObjBeginJobInternal:839 : Cannot start job (query, none) for domain i-2-437-VM; current job is (query, none) owned by (20917, 0) 2015-05-28 03:34:47.000+0000: 20918: error : qemuDomainObjBeginJobInternal:843 : Timed out during operation: cannot acquire state change lock 2015-05-28 03:34:52.000+0000: 20920: warning : qemuDomainObjBeginJobInternal:839 : Cannot start job (query, none) for domain i-2-437-VM; current job is (query, none) owned by (20917, 0) 2015-05-28 03:34:52.000+0000: 20920: error : qemuDomainObjBeginJobInternal:843 : Timed out during operation: cannot acquire state change lock 2015-05-28 03:35:09.001+0000: 20921: warning : qemuDomainObjBeginJobInternal:839 : Cannot start job (query, none) for domain i-2-437-VM; current job is (query, none) owned by (20917, 0) 2015-05-28 03:35:09.001+0000: 20921: error : qemuDomainObjBeginJobInternal:843 : Timed out during operation: cannot acquire state change lock

2 1

[libvirt] [PATCH] util: Properly return error from virGetUserID and virGetGroupID stubs
by Peter Krempa 08 Jun '15

08 Jun '15

The stubs for the two functions that are compiled on platforms that don't have HAVE_GETPWUID_R and friends defined do not return error but report an error message. The calling code then assumes that the @uid or @gid arguments were filled, which is not the case in the stubs. --- This should fix the mingw build that complains that @theuid in one of the callers is not initialized. src/util/virutil.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/util/virutil.c b/src/util/virutil.c index e479cce..cddc78a 100644 --- a/src/util/virutil.c +++ b/src/util/virutil.c @@ -1316,7 +1316,7 @@ int virGetUserID(const char *name ATTRIBUTE_UNUSED, virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("virGetUserID is not available")); - return 0; + return -1; } @@ -1326,7 +1326,7 @@ int virGetGroupID(const char *name ATTRIBUTE_UNUSED, virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("virGetGroupID is not available")); - return 0; + return -1; } int -- 2.4.1

2 1

[libvirt] [PATCH] util: process: fix build on FreeBSD
by Roman Bogorodskiy 08 Jun '15

08 Jun '15

Commit 825df8c3 refactored virProcess{Set,Get}Affinity routines, however broke BSD implementation because of the incorrect variable name. Fix build by using a proper variable name. Pushing as trivial and build break fix. --- src/util/virprocess.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/util/virprocess.c b/src/util/virprocess.c index a38cb75..59598ed 100644 --- a/src/util/virprocess.c +++ b/src/util/virprocess.c @@ -566,7 +566,7 @@ virProcessGetAffinity(pid_t pid) return NULL; } - if (!(*map = virBitmapNew(sizeof(mask) * 8))) + if (!(ret = virBitmapNew(sizeof(mask) * 8))) return NULL; for (i = 0; i < sizeof(mask) * 8; i++) -- 2.4.2

1 0

[libvirt] bulk stats for block and cpu
by Vasiliy Tolstov 08 Jun '15

08 Jun '15

Hi. Is i remember sometimes ago someone implements bulk stats for libvirt (cpu, block, network..?) to able to get all needed info with one api call. But i can't find api in libvirt docs, does anybody helps me and send link to docs, ii want to get info about block stats for 100-200 domains. -- Vasiliy Tolstov, e-mail: v.tolstov(a)selfip.ru

2 2

[libvirt] ANNOUNCE: virt-manager 1.2.1 released
by Cole Robinson 07 Jun '15

07 Jun '15

I'm happy to announce the release of virt-manager 1.2.1! virt-manager is a desktop application for managing KVM, Xen, and LXC virtualization via libvirt. The release can be downloaded from: http://virt-manager.org/download/ The direct download links are: http://virt-manager.org/download/sources/virt-manager/virt-manager-1.2.1.ta… This release is mostly for bug scooping up some bugfixes. Including: - Fix connecting to older libvirt versions (Michał Kępień) - Fix connecting to VM console with non-IP hostname (Giuseppe Scrivano) - Fix addhardware/create wizard errors when a nodedev disappears - Fix adding a second cdrom via customize dialog Thanks to everyone who has contributed to this release through testing, bug reporting, submitting patches, and otherwise sending in feedback! Thanks, Cole

1 0

[libvirt] [RFC] driver's persistent connection closed event
by Nikolay Shirokovskiy 06 Jun '15

06 Jun '15

Hello. I have a question concerning hypervisor driver "persistent connection closed" event mechanics. Currently the only driver that have such a connection (or at least notify of such event) is the remote driver. Accordingly we don't have interface for this event at driver level. Parallels driver actually have a persistent connection. Imagine we have a libvirt connection to parallels driver through remote driver, if parallels internal connection is closed we can catch it in daemon but the only option to notify remote driver of this event would be closing of remote driver to daemon connection which will in turn trigger connection closed event deliver to client. Thus event will be delivered but at cost of forcedly closed connection to daemon. I suspect the described solution have architectural flaws so i suggest move interface of "persistent connection closed" event to driver level which will give us a chance to deliver this event without side effects. We don't need to implement this interface for most drivers and clients could handle this well as in this case "unimplemented" would be a synonym of "have not persistent connection". Alternatively we could silently do nothing if driver does not support this interface so clients would not break.

1 0

[libvirt] [PATCH 00/10] qemu: balloon QOM-path related cleanups
by Ján Tomko 05 Jun '15

05 Jun '15

While reviewing the patch adding virtio-balloon-ccw, I found that we are not reporting errors consistently. This turned out to be on purpose. This series * moves the object path search into qemu_monitor_json * reduces the number of allocations during search (more a cosmetic chagne than optimization) * moves the balloon model checking out of the monitor code * vm->def should not be accessed without a virDomainObj lock * this should also get rid of the errors on dommemstat with 'none' balloon reported by: https://www.redhat.com/archives/libvir-list/2015-May/msg01110.html * changes qemuMonitorFindBalloonObjectPath to void to make it obvious that errors are ignored Ján Tomko (10): Move qemuMonitorFindObjectPath to qemu_monitor_json Introduce qemuMonitorJSONFindLinkPath Remove path argument from qemuMonitorJSONFindLinkPath Add endjob label to qemuDomainMemoryStats Invert the condition in qemuDomainMemoryStats Only call qemuMonitorGetMemoryStats for virtio memballoon Check for balloon model in qemuDomainSetMemoryStatsPeriod Only call SetMemoryStatsPeriod for virtio memballoon Do not access the domain definition in qemuMonitorFindBalloonObjectPath Turn qemuMonitorFindBalloonObjectPath into a void function src/qemu/qemu_driver.c | 49 +++++++++++++----- src/qemu/qemu_monitor.c | 116 +++++-------------------------------------- src/qemu/qemu_monitor_json.c | 92 ++++++++++++++++++++++++++++++++++ src/qemu/qemu_monitor_json.h | 3 ++ src/qemu/qemu_process.c | 4 +- 5 files changed, 146 insertions(+), 118 deletions(-) -- 2.3.6

2 19

[libvirt] [PATCH v3] parallels: add block device statistics to driver
by Nikolay Shirokovskiy 05 Jun '15

05 Jun '15

Statistics provided through PCS SDK. As we have only async interface in SDK we need to be subscribed to statistics in order to get it. Trivial solution on every stat request to subscribe, wait event and then unsubscribe will lead to significant delays in case of a number of successive requests, as the event will be delivered on next PCS server notify cycle. On the other hand we don't want to keep unnesessary subscribtion. So we take an hibrid solution to subcsribe on first request and then keep a subscription while requests are active. We populate cache of statistics on subscribtion events and use this cache to serve libvirts requests. * Cache details. Cache is just handle to last arrived event, we call this cache as if this handle is valid it is used to serve synchronous statistics requests. We use number of successive events count to detect that user lost interest to statistics. We reset this count to 0 on every request. If more than PARALLELS_STATISTICS_DROP_COUNT successive events arrive we unsubscribe. Special value of -1 of this counter is used to differentiate between subscribed/unsubscribed state to protect from delayed events. Values of PARALLELS_STATISTICS_DROP_COUNT and PARALLELS_STATISTICS_TIMEOUT are just drop-ins, choosen without special consideration. * Thread safety issues Use parallelsDomObjFromDomainRef in parallelsDomainBlockStats as we could wait on domain lock down on stack in prlsdkGetStatsParam and if we won't keep reference we could get dangling pointer on return from wait. Signed-off-by: Nikolay Shirokovskiy <nshirokovskiy(a)parallels.com> --- src/parallels/parallels_driver.c | 106 +++++++++++++++++++++ src/parallels/parallels_sdk.c | 189 ++++++++++++++++++++++++++++++++++++++ src/parallels/parallels_sdk.h | 2 + src/parallels/parallels_utils.c | 28 ++++++ src/parallels/parallels_utils.h | 18 ++++ 5 files changed, 343 insertions(+), 0 deletions(-) diff --git a/src/parallels/parallels_driver.c b/src/parallels/parallels_driver.c index 4b87213..33c112e 100644 --- a/src/parallels/parallels_driver.c +++ b/src/parallels/parallels_driver.c @@ -51,6 +51,7 @@ #include "nodeinfo.h" #include "virstring.h" #include "cpu/cpu.h" +#include "virtypedparam.h" #include "parallels_driver.h" #include "parallels_utils.h" @@ -1179,6 +1180,109 @@ parallelsDomainGetMaxMemory(virDomainPtr domain) return ret; } +static int +parallelsDomainBlockStats(virDomainPtr domain, const char *path, + virDomainBlockStatsPtr stats) +{ + virDomainObjPtr dom = NULL; + int ret = -1; + size_t i; + int idx; + + if (!(dom = parallelsDomObjFromDomainRef(domain))) + return -1; + + if (*path) { + if ((idx = virDomainDiskIndexByName(dom->def, path, false)) < 0) { + virReportError(VIR_ERR_INVALID_ARG, _("invalid path: %s"), path); + goto cleanup; + } + if (prlsdkGetBlockStats(dom, dom->def->disks[idx], stats) < 0) + goto cleanup; + } else { + virDomainBlockStatsStruct s; + +#define PARALLELS_ZERO_STATS(VAR, TYPE, NAME) \ + stats->VAR = 0; + + PARALLELS_BLOCK_STATS_FOREACH(PARALLELS_ZERO_STATS) + +#undef PARALLELS_ZERO_STATS + + for (i = 0; i < dom->def->ndisks; i++) { + if (prlsdkGetBlockStats(dom, dom->def->disks[i], &s) < 0) + goto cleanup; + +#define PARALLELS_SUM_STATS(VAR, TYPE, NAME) \ + if (s.VAR != -1) \ + stats->VAR += s.VAR; + + PARALLELS_BLOCK_STATS_FOREACH(PARALLELS_SUM_STATS) + +#undef PARALLELS_SUM_STATS + } + } + stats->errs = -1; + ret = 0; + + cleanup: + if (dom) + virDomainObjEndAPI(&dom); + + return ret; +} + +static int +parallelsDomainBlockStatsFlags(virDomainPtr domain, + const char *path, + virTypedParameterPtr params, + int *nparams, + unsigned int flags) +{ + virDomainBlockStatsStruct stats; + int ret = -1; + size_t i; + + virCheckFlags(VIR_TYPED_PARAM_STRING_OKAY, -1); + /* We don't return strings, and thus trivially support this flag. */ + flags &= ~VIR_TYPED_PARAM_STRING_OKAY; + + if (parallelsDomainBlockStats(domain, path, &stats) < 0) + goto cleanup; + + if (*nparams == 0) { +#define PARALLELS_COUNT_STATS(VAR, TYPE, NAME) \ + if ((stats.VAR) != -1) \ + ++*nparams; + + PARALLELS_BLOCK_STATS_FOREACH(PARALLELS_COUNT_STATS) + +#undef PARALLELS_COUNT_STATS + ret = 0; + goto cleanup; + } + + i = 0; +#define PARALLELS_BLOCK_STATS_ASSIGN_PARAM(VAR, TYPE, NAME) \ + if (i < *nparams && (stats.VAR) != -1) { \ + if (virTypedParameterAssign(params + i, TYPE, \ + VIR_TYPED_PARAM_LLONG, (stats.VAR)) < 0) \ + goto cleanup; \ + i++; \ + } + + PARALLELS_BLOCK_STATS_FOREACH(PARALLELS_BLOCK_STATS_ASSIGN_PARAM) + +#undef PARALLELS_BLOCK_STATS_ASSIGN_PARAM + + *nparams = i; + ret = 0; + + cleanup: + return ret; +} + + static virHypervisorDriver parallelsDriver = { .name = "Parallels", .connectOpen = parallelsConnectOpen, /* 0.10.0 */ @@ -1228,6 +1332,8 @@ static virHypervisorDriver parallelsDriver = { .domainManagedSave = parallelsDomainManagedSave, /* 1.2.14 */ .domainManagedSaveRemove = parallelsDomainManagedSaveRemove, /* 1.2.14 */ .domainGetMaxMemory = parallelsDomainGetMaxMemory, /* 1.2.15 */ + .domainBlockStats = parallelsDomainBlockStats, /* 1.2.17 */ + .domainBlockStatsFlags = parallelsDomainBlockStatsFlags, /* 1.2.17 */ }; static virConnectDriver parallelsConnectDriver = { diff --git a/src/parallels/parallels_sdk.c b/src/parallels/parallels_sdk.c index d5a9790..8c52fce 100644 --- a/src/parallels/parallels_sdk.c +++ b/src/parallels/parallels_sdk.c @@ -21,6 +21,7 @@ */ #include <config.h> +#include <stdarg.h> #include "virerror.h" #include "viralloc.h" @@ -29,6 +30,7 @@ #include "virlog.h" #include "datatypes.h" #include "domain_conf.h" +#include "virtime.h" #include "parallels_sdk.h" @@ -407,6 +409,8 @@ prlsdkDomObjFreePrivate(void *p) return; PrlHandle_Free(pdom->sdkdom); + PrlHandle_Free(pdom->cache.stats); + virCondDestroy(&pdom->cache.cond); VIR_FREE(pdom->uuid); VIR_FREE(pdom->home); VIR_FREE(p); @@ -1260,6 +1264,13 @@ prlsdkLoadDomain(parallelsConnPtr privconn, * to NULL temporarily */ pdom->uuid = NULL; + pdom->cache.stats = PRL_INVALID_HANDLE; + pdom->cache.count = -1; + if (virCondInit(&pdom->cache.cond) < 0) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("cannot initialize condition")); + goto error; + } + if (prlsdkGetDomainIds(sdkdom, &def->name, def->uuid) < 0) goto error; @@ -1635,6 +1646,51 @@ prlsdkHandleVmRemovedEvent(parallelsConnPtr privconn, return pret; } +#define PARALLELS_STATISTICS_DROP_COUNT 3 + +static PRL_RESULT +prlsdkHandlePerfEvent(parallelsConnPtr privconn, + PRL_HANDLE event, + unsigned char *uuid) +{ + virDomainObjPtr dom = NULL; + parallelsDomObjPtr privdom = NULL; + PRL_HANDLE job = PRL_INVALID_HANDLE; + + dom = virDomainObjListFindByUUID(privconn->domains, uuid); + if (dom == NULL) + goto cleanup; + privdom = dom->privateData; + + // delayed event after unsubscribe + if (privdom->cache.count == -1) + goto cleanup; + + PrlHandle_Free(privdom->cache.stats); + privdom->cache.stats = PRL_INVALID_HANDLE; + + if (privdom->cache.count > PARALLELS_STATISTICS_DROP_COUNT) { + job = PrlVm_UnsubscribeFromPerfStats(privdom->sdkdom); + if (PRL_FAILED(waitJob(job))) + goto cleanup; + // change state to unsubscribed + privdom->cache.count = -1; + } else { + ++privdom->cache.count; + privdom->cache.stats = event; + // thus we get own of event handle + event = PRL_INVALID_HANDLE; + virCondSignal(&privdom->cache.cond); + } + + cleanup: + PrlHandle_Free(event); + if (dom) + virObjectUnlock(dom); + + return PRL_ERR_SUCCESS; +} + static PRL_RESULT prlsdkHandleVmEvent(parallelsConnPtr privconn, PRL_HANDLE prlEvent) { @@ -1665,6 +1721,11 @@ prlsdkHandleVmEvent(parallelsConnPtr privconn, PRL_HANDLE prlEvent) case PET_DSP_EVT_VM_UNREGISTERED: return prlsdkHandleVmRemovedEvent(privconn, uuid); break; + case PET_DSP_EVT_VM_PERFSTATS: + prlsdkHandlePerfEvent(privconn, prlEvent, uuid); + // above function takes own of event + prlEvent = PRL_INVALID_HANDLE; + break; default: virReportError(VIR_ERR_INTERNAL_ERROR, _("Can't handle event of type %d"), prlEventType); @@ -1714,6 +1775,7 @@ prlsdkEventsHandler(PRL_HANDLE prlEvent, PRL_VOID_PTR opaque) return pret; } + int prlsdkSubscribeToPCSEvents(parallelsConnPtr privconn) { PRL_RESULT pret = PRL_ERR_UNINITIALIZED; @@ -3450,3 +3512,130 @@ prlsdkDomainManagedSaveRemove(virDomainObjPtr dom) return 0; } + +static int +prlsdkExtractStatsParam(PRL_HANDLE sdkstats, const char *name, long long *val) +{ + PRL_HANDLE param = PRL_INVALID_HANDLE; + PRL_RESULT pret; + PRL_INT64 pval = 0; + int ret = -1; + + pret = PrlEvent_GetParamByName(sdkstats, name, &param); + if (pret == PRL_ERR_NO_DATA) { + *val = -1; + ret = 0; + goto cleanup; + } else if (PRL_FAILED(pret)) { + logPrlError(pret); + goto cleanup; + } + pret = PrlEvtPrm_ToInt64(param, &pval); + prlsdkCheckRetGoto(pret, cleanup); + + *val = pval; + ret = 0; + + cleanup: + PrlHandle_Free(param); + return ret; +} + +#define PARALLELS_STATISTICS_TIMEOUT (60 * 1000) + +static int +prlsdkGetStatsParam(virDomainObjPtr dom, const char *name, long long *val) +{ + parallelsDomObjPtr privdom = dom->privateData; + PRL_HANDLE job = PRL_INVALID_HANDLE; + unsigned long long now; + + if (privdom->cache.stats != PRL_INVALID_HANDLE) { + // reset count to keep subscribtion + privdom->cache.count = 0; + return prlsdkExtractStatsParam(privdom->cache.stats, name, val); + } + + if (privdom->cache.count == -1) { + job = PrlVm_SubscribeToPerfStats(privdom->sdkdom, NULL); + if (PRL_FAILED(waitJob(job))) + goto error; + } + + // change state to subscribed in case of unsubscribed + // or reset count so we stop unsubscribe attempts + privdom->cache.count = 0; + + if (virTimeMillisNow(&now) < 0) { + virReportSystemError(errno, "%s", _("Unable to get current time")); + goto error; + } + + while (privdom->cache.stats == PRL_INVALID_HANDLE) { + if (virCondWaitUntil(&privdom->cache.cond, &dom->parent.lock, + now + PARALLELS_STATISTICS_TIMEOUT) < 0) { + if (errno == ETIMEDOUT) { + virReportError(VIR_ERR_OPERATION_TIMEOUT, "%s", + _("Timeout on waiting statistics event.")); + goto error; + } else { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("Unable to wait on monitor condition")); + goto error; + } + } + } + + return prlsdkExtractStatsParam(privdom->cache.stats, name, val); + error: + return -1; +} + +int +prlsdkGetBlockStats(virDomainObjPtr dom, virDomainDiskDefPtr disk, virDomainBlockStatsPtr stats) +{ + virDomainDeviceDriveAddressPtr address; + int idx; + const char *prefix; + int ret = -1; + char *name = NULL; + + address = &disk->info.addr.drive; + switch (disk->bus) { + case VIR_DOMAIN_DISK_BUS_IDE: + prefix = "ide"; + idx = address->bus * 2 + address->unit; + break; + case VIR_DOMAIN_DISK_BUS_SATA: + prefix = "sata"; + idx = address->unit; + break; + case VIR_DOMAIN_DISK_BUS_SCSI: + prefix = "scsi"; + idx = address->unit; + break; + default: + virReportError(VIR_ERR_INTERNAL_ERROR, + _("Unknown disk bus: %X"), disk->bus); + goto cleanup; + } + + +#define PRLSDK_GET_STAT_PARAM(VAL, TYPE, NAME) \ + if (virAsprintf(&name, "devices.%s%d.%s", prefix, idx, NAME) < 0) \ + goto cleanup; \ + if (prlsdkGetStatsParam(dom, name, &stats->VAL) < 0) \ + goto cleanup; \ + VIR_FREE(name); + + PARALLELS_BLOCK_STATS_FOREACH(PRLSDK_GET_STAT_PARAM) + +#undef PRLSDK_GET_STAT_PARAM + + ret = 0; + + cleanup: + + VIR_FREE(name); + return ret; +} diff --git a/src/parallels/parallels_sdk.h b/src/parallels/parallels_sdk.h index 3f17fc8..afa6745 100644 --- a/src/parallels/parallels_sdk.h +++ b/src/parallels/parallels_sdk.h @@ -64,3 +64,5 @@ int prlsdkAttachVolume(virDomainObjPtr dom, virDomainDiskDefPtr disk); int prlsdkDetachVolume(virDomainObjPtr dom, virDomainDiskDefPtr disk); +int +prlsdkGetBlockStats(virDomainObjPtr dom, virDomainDiskDefPtr disk, virDomainBlockStatsPtr stats); diff --git a/src/parallels/parallels_utils.c b/src/parallels/parallels_utils.c index ff9d47d..540986b 100644 --- a/src/parallels/parallels_utils.c +++ b/src/parallels/parallels_utils.c @@ -64,6 +64,34 @@ parallelsDomObjFromDomain(virDomainPtr domain) } +/** + * parallelsDomObjFromDomainRef: + * @domain: Domain pointer that has to be looked up + * + * This function looks up @domain and returns the appropriate virDomainObjPtr + * that has to be released by calling virDomainObjEndAPI(). + * + * Returns the domain object with incremented reference counter which is locked + * on success, NULL otherwise. + */ +virDomainObjPtr +parallelsDomObjFromDomainRef(virDomainPtr domain) +{ + virDomainObjPtr vm; + parallelsConnPtr privconn = domain->conn->privateData; + char uuidstr[VIR_UUID_STRING_BUFLEN]; + + vm = virDomainObjListFindByUUIDRef(privconn->domains, domain->uuid); + if (!vm) { + virUUIDFormat(domain->uuid, uuidstr); + virReportError(VIR_ERR_NO_DOMAIN, + _("no domain with matching uuid '%s' (%s)"), + uuidstr, domain->name); + return NULL; + } + + return vm; +} static int parallelsDoCmdRun(char **outbuf, const char *binary, va_list list) diff --git a/src/parallels/parallels_utils.h b/src/parallels/parallels_utils.h index 2d1d405..cdf6082 100644 --- a/src/parallels/parallels_utils.h +++ b/src/parallels/parallels_utils.h @@ -73,11 +73,22 @@ struct _parallelsConn { typedef struct _parallelsConn parallelsConn; typedef struct _parallelsConn *parallelsConnPtr; +struct _parallelsContersCache { + PRL_HANDLE stats; + virCond cond; + // -1 - unsubscribed + // > -1 - subscribed + int count; +}; + +typedef struct _parallelsContersCache parallelsContersCache; + struct parallelsDomObj { int id; char *uuid; char *home; PRL_HANDLE sdkdom; + parallelsContersCache cache; }; typedef struct parallelsDomObj *parallelsDomObjPtr; @@ -91,6 +102,7 @@ int parallelsNetworkClose(virConnectPtr conn); extern virNetworkDriver parallelsNetworkDriver; virDomainObjPtr parallelsDomObjFromDomain(virDomainPtr domain); +virDomainObjPtr parallelsDomObjFromDomainRef(virDomainPtr domain); virJSONValuePtr parallelsParseOutput(const char *binary, ...) ATTRIBUTE_NONNULL(1) ATTRIBUTE_SENTINEL; @@ -106,4 +118,10 @@ virStorageVolPtr parallelsStorageVolLookupByPathLocked(virConnectPtr conn, int parallelsStorageVolDefRemove(virStoragePoolObjPtr privpool, virStorageVolDefPtr privvol); +#define PARALLELS_BLOCK_STATS_FOREACH(OP) \ + OP(rd_req, VIR_DOMAIN_BLOCK_STATS_READ_REQ, "read_requests") \ + OP(rd_bytes, VIR_DOMAIN_BLOCK_STATS_READ_BYTES, "read_total") \ + OP(wr_req, VIR_DOMAIN_BLOCK_STATS_WRITE_REQ, "write_requests") \ + OP(wr_bytes, VIR_DOMAIN_BLOCK_STATS_WRITE_BYTES, "write_total") + #endif -- 1.7.1

1 1

[libvirt] [PATCH v2 0/5] RPC JSON (de)serialization and fixes
by Martin Kletzander 05 Jun '15

05 Jun '15

I took the liberty of changing Daniel's version and fix it up a bit. I've split it into multiple patches, removed unneeded functions, and fixed it for building without avahi. First version here: https://www.redhat.com/archives/libvir-list/2015-May/msg00812.html Daniel P. Berrange (4): rpc: add testing of RPC JSON (de)serialization rpc: Make virNetServerAddClient function dynamic rpc: Don't use unrelated value as privateData of client rpc: Fix reference counting around virNetSocketAddIOCallback Martin Kletzander (1): mdns: Set error when failing due to missing avahi src/libvirt_remote.syms | 1 + src/rpc/virnetserver.c | 4 +- src/rpc/virnetserver.h | 3 + src/rpc/virnetserverclient.c | 13 +- src/rpc/virnetservermdns.c | 8 +- src/rpc/virnetserverservice.c | 6 +- tests/Makefile.am | 7 + tests/virnetserverdata/README | 14 + .../virnetserverdata/input-data-anon-clients.json | 62 +++++ .../input-data-initial-nomdns.json | 61 +++++ tests/virnetserverdata/input-data-initial.json | 62 +++++ .../virnetserverdata/output-data-anon-clients.json | 62 +++++ .../output-data-initial-nomdns.json | 62 +++++ tests/virnetserverdata/output-data-initial.json | 63 +++++ tests/virnetservertest.c | 284 +++++++++++++++++++++ 15 files changed, 698 insertions(+), 14 deletions(-) create mode 100644 tests/virnetserverdata/README create mode 100644 tests/virnetserverdata/input-data-anon-clients.json create mode 100644 tests/virnetserverdata/input-data-initial-nomdns.json create mode 100644 tests/virnetserverdata/input-data-initial.json create mode 100644 tests/virnetserverdata/output-data-anon-clients.json create mode 100644 tests/virnetserverdata/output-data-initial-nomdns.json create mode 100644 tests/virnetserverdata/output-data-initial.json create mode 100644 tests/virnetservertest.c -- 2.4.2

2 11

[libvirt] [PATCH 0/4] Fix some issues is FS backend
by John Ferlan 05 Jun '15

05 Jun '15

https://bugzilla.redhat.com/show_bug.cgi?id=1181087 Patch 1 was just found by inspection Patch 2 sets up for the the eventual fix Patch 3 Adjusts the error message to make it clearer what the problem is Patch 4 Adds a check in the checkPool path for valid FS storage pool config before checking for IsMounted and declaring "isActive = true" John Ferlan (4): storage: Remove extraneous @conn from function comments storage: Refactor storage pool type checks storage: FS backend adjust error message on error path storage: Add check for valid FS types in checkPool callback src/storage/storage_backend_fs.c | 97 ++++++++++++++++++++-------------------- 1 file changed, 48 insertions(+), 49 deletions(-) -- 2.1.0

2 9

[libvirt] [PATCH] qemu: monitor: Add memory balloon support for virtio-ccw
by Boris Fiuczynski 05 Jun '15

05 Jun '15

The search for the memory ballon driver object is extended by a second known name "virtio-ballon-ccw" in support for virtio-ccw. Signed-off-by: Boris Fiuczynski <fiuczy(a)linux.vnet.ibm.com> Reviewed-by: Christian Borntraeger <borntraeger(a)de.ibm.com> --- src/qemu/qemu_monitor.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/qemu/qemu_monitor.c b/src/qemu/qemu_monitor.c index f959b74..1a88329 100644 --- a/src/qemu/qemu_monitor.c +++ b/src/qemu/qemu_monitor.c @@ -1141,9 +1141,9 @@ qemuMonitorFindObjectPath(qemuMonitorPtr mon, /** - * Search the qom objects for the balloon driver object by it's known name - * of "virtio-balloon-pci". The entry for the driver will be found by using - * function "qemuMonitorFindObjectPath". + * Search the qom objects for the balloon driver object by it's known names + * of "virtio-balloon-pci" or "virtio-ballon-ccw". The entry for the driver + * will be found by using function "qemuMonitorFindObjectPath". * * Once found, check the entry to ensure it has the correct property listed. * If it does not, then obtaining statistics from QEMU will not be possible. @@ -1183,7 +1183,8 @@ qemuMonitorFindBalloonObjectPath(qemuMonitorPtr mon, return -1; } - if (qemuMonitorFindObjectPath(mon, curpath, "virtio-balloon-pci", &path) < 0) + if (qemuMonitorFindObjectPath(mon, curpath, "virtio-balloon-pci", &path) < 0 && + qemuMonitorFindObjectPath(mon, curpath, "virtio-balloon-ccw", &path) < 0) return -1; nprops = qemuMonitorJSONGetObjectListPaths(mon, path, &bprops); -- 2.3.0

2 3

[libvirt] [PATCH] remote: fix odd comma operator
by Eric Blake 05 Jun '15

05 Jun '15

Commit 1882c0bd accidentally used ',' instead of ';'; oddly enough, the result was still syntactically valid (yes, C is a fun language). But it made me do a double take; it's better to use idiomatic syntax. * daemon/remote.c (remoteRelayDomainEventDeviceAdded): Fix harmless typo. Signed-off-by: Eric Blake <eblake(a)redhat.com> --- Pushing under the trivial rule. daemon/remote.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/daemon/remote.c b/daemon/remote.c index e259a76..e9e2dca 100644 --- a/daemon/remote.c +++ b/daemon/remote.c @@ -1068,7 +1068,7 @@ remoteRelayDomainEventDeviceAdded(virConnectPtr conn, return -1; make_nonnull_domain(&data.dom, dom); - data.callbackID = callback->callbackID, + data.callbackID = callback->callbackID; remoteDispatchObjectEventSend(callback->client, remoteProgram, REMOTE_PROC_DOMAIN_EVENT_CALLBACK_DEVICE_ADDED, -- 2.4.2

1 0

[libvirt] [PATCH 0/4] Add support for vhost-user with multi-queue
by Martin Kletzander 05 Jun '15

05 Jun '15

Also some tiny clean-up. Martin Kletzander (2): conf: Ignore multiqueue with one queue. qemu: Add capability for vhost-user multiqueue Maxime Leroy (2): docs: Clarify that attribute name is not used for vhostuser qemu: add multiqueue vhost-user support docs/formatdomain.html.in | 16 ++++++++++++++-- src/conf/domain_conf.c | 3 ++- src/qemu/qemu_capabilities.c | 6 ++++++ src/qemu/qemu_capabilities.h | 1 + src/qemu/qemu_command.c | 15 ++++++++++++++- ...tuser.args => qemuxml2argv-net-vhostuser-multiq.args} | 6 +++++- ...ostuser.xml => qemuxml2argv-net-vhostuser-multiq.xml} | 6 ++++++ .../qemuxml2argv-tap-vhost-incorrect.xml | 6 ++++++ tests/qemuxml2argvtest.c | 3 +++ .../qemuxml2xmlout-tap-vhost-incorrect.xml | 6 ++++++ 10 files changed, 63 insertions(+), 5 deletions(-) copy tests/qemuxml2argvdata/{qemuxml2argv-net-vhostuser.args => qemuxml2argv-net-vhostuser-multiq.args} (75%) copy tests/qemuxml2argvdata/{qemuxml2argv-net-vhostuser.xml => qemuxml2argv-net-vhostuser-multiq.xml} (87%) -- 2.4.2

2 10

[libvirt] [libvirt-glib v2] storage-pool: API to get/set autostart flag
by Zeeshan Ali (Khattak) 05 Jun '15

05 Jun '15

Add binding for virStoragePoolGetAutostart & virStoragePoolSetAutostart. --- libvirt-gobject/libvirt-gobject-storage-pool.c | 51 ++++++++++++++++++++++++++ libvirt-gobject/libvirt-gobject-storage-pool.h | 5 +++ libvirt-gobject/libvirt-gobject.sym | 6 +++ 3 files changed, 62 insertions(+) diff --git a/libvirt-gobject/libvirt-gobject-storage-pool.c b/libvirt-gobject/libvirt-gobject-storage-pool.c index f3eac0d..7f26b1b 100644 --- a/libvirt-gobject/libvirt-gobject-storage-pool.c +++ b/libvirt-gobject/libvirt-gobject-storage-pool.c @@ -1048,6 +1048,57 @@ gboolean gvir_storage_pool_delete (GVirStoragePool *pool, return TRUE; } +/** + * gvir_storage_pool_get_autostart: + * @pool: the storage pool + * @err: return location for any #GError + * + * Return value: #True if autostart is enabled, #False otherwise. + */ +gboolean gvir_storage_pool_get_autostart(GVirStoragePool *pool, + GError **err) +{ + int ret; + + g_return_val_if_fail(GVIR_IS_STORAGE_POOL(pool), FALSE); + g_return_val_if_fail(err == NULL || *err == NULL, FALSE); + + if (virStoragePoolGetAutostart(pool->priv->handle, &ret)) { + gvir_set_error_literal(err, GVIR_STORAGE_POOL_ERROR, + 0, + "Failed to get autostart flag from storage pool"); + } + + return !!ret; +} + +/** + * gvir_storage_pool_set_autostart: + * @pool: the storage pool + * @autostart: Whether or not to autostart + * @err: return location for any #GError + * + * Sets whether or not storage pool @pool is started automatically on boot. + * + * Return value: #TRUE on success, #FALSE otherwise. + */ +gboolean gvir_storage_pool_set_autostart(GVirStoragePool *pool, + gboolean autostart, + GError **err) +{ + g_return_val_if_fail(GVIR_IS_STORAGE_POOL(pool), FALSE); + g_return_val_if_fail(err == NULL || *err == NULL, FALSE); + + if (virStoragePoolSetAutostart(pool->priv->handle, autostart)) { + gvir_set_error_literal(err, GVIR_STORAGE_POOL_ERROR, + 0, + "Failed to set autostart flag on storage pool"); + return FALSE; + } + + return TRUE; +} + static void gvir_storage_pool_delete_helper(GSimpleAsyncResult *res, GObject *object, diff --git a/libvirt-gobject/libvirt-gobject-storage-pool.h b/libvirt-gobject/libvirt-gobject-storage-pool.h index f8529f0..f7f879c 100644 --- a/libvirt-gobject/libvirt-gobject-storage-pool.h +++ b/libvirt-gobject/libvirt-gobject-storage-pool.h @@ -166,6 +166,11 @@ void gvir_storage_pool_delete_async (GVirStoragePool *pool, gboolean gvir_storage_pool_delete_finish(GVirStoragePool *pool, GAsyncResult *result, GError **err); +gboolean gvir_storage_pool_get_autostart(GVirStoragePool *pool, + GError **err); +gboolean gvir_storage_pool_set_autostart(GVirStoragePool *pool, + gboolean autostart, + GError **err); G_END_DECLS diff --git a/libvirt-gobject/libvirt-gobject.sym b/libvirt-gobject/libvirt-gobject.sym index 927cad9..dcda675 100644 --- a/libvirt-gobject/libvirt-gobject.sym +++ b/libvirt-gobject/libvirt-gobject.sym @@ -265,4 +265,10 @@ LIBVIRT_GOBJECT_0.2.0 { gvir_domain_open_graphics_fd; } LIBVIRT_GOBJECT_0.1.9; +LIBVIRT_GOBJECT_0.2.1 { + global: + gvir_storage_pool_get_autostart; + gvir_storage_pool_set_autostart; +} LIBVIRT_GOBJECT_0.2.0; + # .... define new API here using predicted next version number .... -- 2.4.2

2 1

[libvirt] [PATCH v5 0/9] qemu: Add quorum support to libvirt
by Matthias Gatto 04 Jun '15

04 Jun '15

The purpose of these patches is to introduce quorum for libvirt I've try to follow this proposal: http://www.redhat.com/archives/libvir-list/2014-May/msg00533.html This feature ask for 6 task: 1) Allow a _virStorageSource to contain more than one backing store. Because all the actual libvirt code use the backingStore field as a pointer and we needs want to change that, I've decide to encapsulate the backingStore field to simplifie the array manipulation. 2) Add the missing field a quorum need in _virStorageSource and the VIR_STORAGE_TYPE_QUORUM and VIR_STORAGE_FILE_QUORUM in their respectives enums. 3) Parse and format the xml Because a quorum allows to have more than one backing store at the same level we need to change virDomainDiskDefFormat and virDomainDiskDefParseXML to call virDomainDiskBackingStoreFormat and virDomainDiskBackingStoreParse in a loop. virDomainDiskBackingStoreFormat and virDomainDiskBackingStoreParse can call themself recursively in a loop because a quorum can contain another quorum 4) Add nodename We need to add nodename support in _virStorageSource because qemu use them for their child. 5) Build qemu string As for the xml, we have to call the function which create quorum recursively. But this task have the problem explained here: http://www.redhat.com/archives/libvir-list/2014-October/msg00529.html The _virStorageSource missing some informations that can be passed to a child, and therefore this version of quorum is incomplet. 6) Allow to hotplug/change a disk in a quorum This part is not present in these patches because for this task we have to use blockdev-add, and currently libvirt use device_add for hotpluging that doesn't allow to hotplug quorum childs. There is 3 way to handle this problem: 1) create a virDomainBlockDevAdd function in libvirt witch call blockdev-add. 2) use blockdev-add instead of device_add in qemuMonitorJSONAddDevice 3) write a hack which uses blockdev-add when only attaching quorum (but i'm pretty sure this solution is not the good one) V2: -Rebase on master -Add Documentation V3: -Transforme the backingStore field in virStorageSource into an array of pointer instead of a pointer -Modify virStorageSourceSetBackingStore to allow it to expand the backingStore size. V4: -Rebase on master V5: -Rebase on master -patch 1-4/9: use patchs from John Ferlan -patch 4/9: check return of virStorageSourceSetBackingStore -patch 5/9: report type of error on virStorageSourceSetBackingStore Matthias Gatto (9): virstoragefile: Add virStorageSourceGetBackingStore virstoragefile: Always use virStorageSourceGetBackingStore to get backing store virstoragefile: Add virStorageSourceSetBackingStore virstoragefile: Always use virStorageSourceSetBackingStore to set backing store virstoragefile: change backingStore to backingStores. virstoragefile: Add quorum in virstoragefile domain_conf: Read and Write quorum config qemu: Add quorum support in qemuBuildDriveDevStr virstoragefile: Add node-name docs/formatdomain.html.in | 30 +++++- docs/schemas/domaincommon.rng | 26 ++++- docs/schemas/storagecommon.rng | 1 + docs/schemas/storagevol.rng | 1 + src/conf/domain_conf.c | 195 ++++++++++++++++++++++++++-------- src/conf/storage_conf.c | 23 ++-- src/libvirt_private.syms | 2 + src/qemu/qemu_cgroup.c | 4 +- src/qemu/qemu_command.c | 114 ++++++++++++++++++++ src/qemu/qemu_domain.c | 2 +- src/qemu/qemu_driver.c | 39 ++++--- src/qemu/qemu_migration.c | 1 + src/qemu/qemu_monitor_json.c | 4 +- src/security/security_dac.c | 2 +- src/security/security_selinux.c | 4 +- src/security/virt-aa-helper.c | 2 +- src/storage/storage_backend.c | 22 ++-- src/storage/storage_backend_fs.c | 38 ++++--- src/storage/storage_backend_gluster.c | 11 +- src/storage/storage_backend_logical.c | 15 ++- src/storage/storage_driver.c | 3 +- src/util/virstoragefile.c | 122 ++++++++++++++++++--- src/util/virstoragefile.h | 13 ++- tests/virstoragetest.c | 18 ++-- 24 files changed, 551 insertions(+), 141 deletions(-) -- 2.3.5

3 18

[libvirt] [PATCH] parallels: implement attach/detach network.
by Mikhail Feoktistov 04 Jun '15

04 Jun '15

Support nova commands interface-attach and interface-detach. For containers only. --- src/parallels/parallels_driver.c | 16 ++++ src/parallels/parallels_sdk.c | 144 +++++++++++++++++++++++++++++++++++++- src/parallels/parallels_sdk.h | 4 + 3 files changed, 161 insertions(+), 3 deletions(-) diff --git a/src/parallels/parallels_driver.c b/src/parallels/parallels_driver.c index e385f3d..a49a030 100644 --- a/src/parallels/parallels_driver.c +++ b/src/parallels/parallels_driver.c @@ -1050,6 +1050,14 @@ static int parallelsDomainAttachDeviceFlags(virDomainPtr dom, const char *xml, goto cleanup; } break; + case VIR_DOMAIN_DEVICE_NET: + ret = prlsdkAttachNet(privdom, privconn, dev->data.net) + if (ret) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("network attach failed")); + goto cleanup; + } + break; default: virReportError(VIR_ERR_OPERATION_UNSUPPORTED, _("device type '%s' cannot be attached"), @@ -1133,6 +1141,14 @@ static int parallelsDomainDetachDeviceFlags(virDomainPtr dom, const char *xml, goto cleanup; } break; + case VIR_DOMAIN_DEVICE_NET: + ret = prlsdkDetachNet(privdom, privconn, dev->data.net) + if (ret) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("network detach failed")); + goto cleanup; + } + break; default: virReportError(VIR_ERR_OPERATION_UNSUPPORTED, _("device type '%s' cannot be detached"), diff --git a/src/parallels/parallels_sdk.c b/src/parallels/parallels_sdk.c index 6e293f7..a1c9131 100644 --- a/src/parallels/parallels_sdk.c +++ b/src/parallels/parallels_sdk.c @@ -2751,6 +2751,12 @@ static int prlsdkAddNet(PRL_HANDLE sdkdom, pret = PrlVmDevNet_SetMacAddress(sdknet, macstr); prlsdkCheckRetGoto(pret, cleanup); + pret = PrlVmDevNet_SetConfigureWithDhcp(sdknet, true); + prlsdkCheckRetGoto(pret, cleanup); + + pret = PrlVmDevNet_SetAutoApply(sdknet, true); + prlsdkCheckRetGoto(pret, cleanup); + if (isCt) { if (net->model) VIR_WARN("Setting network adapter for containers is not " @@ -2821,14 +2827,15 @@ static int prlsdkAddNet(PRL_HANDLE sdkdom, return ret; } -static void prlsdkDelNet(parallelsConnPtr privconn, virDomainNetDefPtr net) +static int prlsdkDelNet(parallelsConnPtr privconn, virDomainNetDefPtr net) { + int ret = -1; PRL_RESULT pret; PRL_HANDLE vnet = PRL_INVALID_HANDLE; PRL_HANDLE job = PRL_INVALID_HANDLE; if (net->type != VIR_DOMAIN_NET_TYPE_BRIDGE) - return; + return 0; pret = PrlVirtNet_Create(&vnet); prlsdkCheckRetGoto(pret, cleanup); @@ -2836,12 +2843,142 @@ static void prlsdkDelNet(parallelsConnPtr privconn, virDomainNetDefPtr net) pret = PrlVirtNet_SetNetworkId(vnet, net->data.network.name); prlsdkCheckRetGoto(pret, cleanup); - PrlSrv_DeleteVirtualNetwork(privconn->server, vnet, 0); + job = PrlSrv_DeleteVirtualNetwork(privconn->server, vnet, 0); if (PRL_FAILED(pret = waitJob(job))) goto cleanup; + ret = 0; + cleanup: PrlHandle_Free(vnet); + return ret; +} + +int prlsdkAttachNet(virDomainObjPtr dom, parallelsConnPtr privconn, virDomainNetDefPtr net) +{ + int ret = -1; + parallelsDomObjPtr privdom = dom->privateData; + PRL_HANDLE job = PRL_INVALID_HANDLE; + + if (!IS_CT(dom->def)) { + virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s", + _("network device cannot be attached")); + goto cleanup; + } + + job = PrlVm_BeginEdit(privdom->sdkdom); + if (PRL_FAILED(waitJob(job))) + goto cleanup; + + ret = prlsdkAddNet(privdom->sdkdom, privconn, net, IS_CT(dom->def)); + if (ret == 0) { + job = PrlVm_CommitEx(privdom->sdkdom, PVCF_DETACH_HDD_BUNDLE); + if (PRL_FAILED(waitJob(job))) { + ret = -1; + goto cleanup; + } + } + + cleanup: + return ret; +} + +static int +prlsdkGetNetIndex(PRL_HANDLE sdkdom, virDomainNetDefPtr net) +{ + int idx = -1; + PRL_RESULT pret; + PRL_UINT32 netCount; + PRL_UINT32 i; + PRL_HANDLE adapter = PRL_INVALID_HANDLE; + PRL_UINT32 len; + char adapterMac[PRL_MAC_STRING_BUFNAME]; + char netMac[PRL_MAC_STRING_BUFNAME]; + + prlsdkFormatMac(&net->mac, netMac); + pret = PrlVmCfg_GetNetAdaptersCount(sdkdom, &netCount); + prlsdkCheckRetGoto(pret, cleanup); + + for (i = 0; i < netCount; ++i) { + + pret = PrlVmCfg_GetNetAdapter(sdkdom, i, &adapter); + prlsdkCheckRetGoto(pret, cleanup); + + len = sizeof(adapterMac); + memset(adapterMac, 0, sizeof(adapterMac)); + pret = PrlVmDevNet_GetMacAddress(adapter, adapterMac, &len); + prlsdkCheckRetGoto(pret, cleanup); + + if (memcmp(adapterMac, netMac, PRL_MAC_STRING_BUFNAME)) { + + PrlHandle_Free(adapter); + adapter = PRL_INVALID_HANDLE; + continue; + } + + idx = i; + break; + } + + cleanup: + PrlHandle_Free(adapter); + return idx; +} + +static int prlsdkDelNetAdapter(PRL_HANDLE sdkdom, int idx) +{ + int ret = -1; + PRL_RESULT pret; + PRL_HANDLE sdknet = PRL_INVALID_HANDLE; + + pret = PrlVmCfg_GetNetAdapter(sdkdom, idx, &sdknet); + prlsdkCheckRetGoto(pret, cleanup); + + pret = PrlVmDev_Remove(sdknet); + prlsdkCheckRetGoto(pret, cleanup); + + ret = 0; + + cleanup: + PrlHandle_Free(sdknet); + return ret; +} + +int prlsdkDetachNet(virDomainObjPtr dom, parallelsConnPtr privconn, virDomainNetDefPtr net) +{ + int ret = -1, idx = -1; + parallelsDomObjPtr privdom = dom->privateData; + PRL_HANDLE job = PRL_INVALID_HANDLE; + + if (!IS_CT(dom->def)) { + virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s", + _("network device cannot be detached")); + goto cleanup; + } + + idx = prlsdkGetNetIndex(privdom->sdkdom, net); + if (idx < 0) + goto cleanup; + + job = PrlVm_BeginEdit(privdom->sdkdom); + if (PRL_FAILED(waitJob(job))) + goto cleanup; + + ret = prlsdkDelNet(privconn, net); + if (ret != 0) + goto cleanup; + + ret = prlsdkDelNetAdapter(privdom->sdkdom, idx); + if (ret == 0) { + job = PrlVm_CommitEx(privdom->sdkdom, PVCF_DETACH_HDD_BUNDLE); + if (PRL_FAILED(waitJob(job))) { + ret = -1; + goto cleanup; + } + } + + cleanup: + return ret; } static int prlsdkDelDisk(PRL_HANDLE sdkdom, int idx) @@ -3076,6 +3213,7 @@ prlsdkGetDiskIndex(PRL_HANDLE sdkdom, virDomainDiskDefPtr disk) pret = PrlVmCfg_GetHardDisk(sdkdom, i, &hdd); prlsdkCheckRetGoto(pret, cleanup); + buflen = 0; pret = PrlVmDev_GetFriendlyName(hdd, 0, &buflen); prlsdkCheckRetGoto(pret, cleanup); diff --git a/src/parallels/parallels_sdk.h b/src/parallels/parallels_sdk.h index 3f17fc8..a2c156e 100644 --- a/src/parallels/parallels_sdk.h +++ b/src/parallels/parallels_sdk.h @@ -64,3 +64,7 @@ int prlsdkAttachVolume(virDomainObjPtr dom, virDomainDiskDefPtr disk); int prlsdkDetachVolume(virDomainObjPtr dom, virDomainDiskDefPtr disk); +int +prlsdkAttachNet(virDomainObjPtr dom, parallelsConnPtr privconn, virDomainNetDefPtr net); +int +prlsdkDetachNet(virDomainObjPtr dom, parallelsConnPtr privconn, virDomainNetDefPtr net); -- 1.7.1

1 0

[libvirt] [PATCHv3] qemu: fix unsuitable error report when get memory stats
by Wang Yufei 04 Jun '15

04 Jun '15

From: Zhang Bo <oscar.zhangbo(a)huawei.com> when we run the command 'virsh dommemstat xxx', althrough memballoon's model is set 'none' in vm's XML, it still reports an error in libvirtd.log. error : qemuMonitorFindBalloonObjectPath:1042 : internal error: Cannot determine balloon device path Apparently, if we don't set memballoon, we don't need to set balloon device path. Signed-off-by: Wang Yufei <james.wangyufei(a)huawei.com> Signed-off-by: Zhang Bo <oscar.zhangbo(a)huawei.com> --- src/qemu/qemu_monitor.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/qemu/qemu_monitor.c b/src/qemu/qemu_monitor.c index f959b74..8c3c6f3 100644 --- a/src/qemu/qemu_monitor.c +++ b/src/qemu/qemu_monitor.c @@ -1169,8 +1169,10 @@ qemuMonitorFindBalloonObjectPath(qemuMonitorPtr mon, if (mon->balloonpath) { return 0; } else if (mon->ballooninit) { - virReportError(VIR_ERR_INTERNAL_ERROR, "%s", - _("Cannot determine balloon device path")); + if (vm->def->memballoon && + vm->def->memballoon->model != VIR_DOMAIN_MEMBALLOON_MODEL_NONE) + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("Cannot determine balloon device path")); return -1; } -- 1.7.12.4

3 2

[libvirt] [PATCHv2 0/2] Fix code after the vcpupin series
by Peter Krempa 04 Jun '15

04 Jun '15

Both patches are pushed as trivial. Peter Krempa (2): conf: Fix mistakes in pointer usage in virDomainObjGetDefs qemu: Update balloon info only if job is allowed src/conf/domain_conf.c | 4 ++-- src/qemu/qemu_domain.c | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) -- 2.4.1

2 3

[libvirt] [PATCH v2] parallels: add block device statistics to driver
by Nikolay Shirokovskiy 04 Jun '15

04 Jun '15

Statistics provided through PCS SDK. As we have only async interface in SDK we need to be subscribed to statistics in order to get it. Trivial solution on every stat request to subscribe, wait event and then unsubscribe will lead to significant delays in case of a number of successive requests, as the event will be delivered on next PCS server notify cycle. On the other hand we don't want to keep unnesessary subscribtion. So we take an hibrid solution to subcsribe on first request and then keep a subscription while requests are active. We populate cache of statistics on subscribtion events and use this cache to serve libvirts requests. * Cache details. Cache is just handle to last arrived event, we call this cache as if this handle is valid it is used to serve synchronous statistics requests. We use number of successive events count to detect that user lost interest to statistics. We reset this count to 0 on every request. If more than PARALLELS_STATISTICS_DROP_COUNT successive events arrive we unsubscribe. Special value of -1 of this counter is used to differentiate between subscribed/unsubscribed state to protect from delayed events. Values of RALLELS_STATISTICS_DROP_COUNT and PARALLELS_STATISTICS_TIMEOUT are just drop-ins, choosen without special consideration. * Thread safety issues Use parallelsDomObjFromDomainRef in parallelsDomainBlockStats as we could wait on domain lock down on stack in prlsdkGetStatsParam and if we won't keep reference we could get dangling pointer on return from wait. Signed-off-by: Nikolay Shirokovskiy <nshirokovskiy(a)parallels.com> --- src/parallels/parallels_driver.c | 106 ++++++++++++++++++++++ src/parallels/parallels_sdk.c | 183 ++++++++++++++++++++++++++++++++++++++ src/parallels/parallels_sdk.h | 2 + src/parallels/parallels_utils.c | 28 ++++++ src/parallels/parallels_utils.h | 18 ++++ 5 files changed, 337 insertions(+), 0 deletions(-) diff --git a/src/parallels/parallels_driver.c b/src/parallels/parallels_driver.c index 4b87213..33c112e 100644 --- a/src/parallels/parallels_driver.c +++ b/src/parallels/parallels_driver.c @@ -51,6 +51,7 @@ #include "nodeinfo.h" #include "virstring.h" #include "cpu/cpu.h" +#include "virtypedparam.h" #include "parallels_driver.h" #include "parallels_utils.h" @@ -1179,6 +1180,109 @@ parallelsDomainGetMaxMemory(virDomainPtr domain) return ret; } +static int +parallelsDomainBlockStats(virDomainPtr domain, const char *path, + virDomainBlockStatsPtr stats) +{ + virDomainObjPtr dom = NULL; + int ret = -1; + size_t i; + int idx; + + if (!(dom = parallelsDomObjFromDomainRef(domain))) + return -1; + + if (*path) { + if ((idx = virDomainDiskIndexByName(dom->def, path, false)) < 0) { + virReportError(VIR_ERR_INVALID_ARG, _("invalid path: %s"), path); + goto cleanup; + } + if (prlsdkGetBlockStats(dom, dom->def->disks[idx], stats) < 0) + goto cleanup; + } else { + virDomainBlockStatsStruct s; + +#define PARALLELS_ZERO_STATS(VAR, TYPE, NAME) \ + stats->VAR = 0; + + PARALLELS_BLOCK_STATS_FOREACH(PARALLELS_ZERO_STATS) + +#undef PARALLELS_ZERO_STATS + + for (i = 0; i < dom->def->ndisks; i++) { + if (prlsdkGetBlockStats(dom, dom->def->disks[i], &s) < 0) + goto cleanup; + +#define PARALLELS_SUM_STATS(VAR, TYPE, NAME) \ + if (s.VAR != -1) \ + stats->VAR += s.VAR; + + PARALLELS_BLOCK_STATS_FOREACH(PARALLELS_SUM_STATS) + +#undef PARALLELS_SUM_STATS + } + } + stats->errs = -1; + ret = 0; + + cleanup: + if (dom) + virDomainObjEndAPI(&dom); + + return ret; +} + +static int +parallelsDomainBlockStatsFlags(virDomainPtr domain, + const char *path, + virTypedParameterPtr params, + int *nparams, + unsigned int flags) +{ + virDomainBlockStatsStruct stats; + int ret = -1; + size_t i; + + virCheckFlags(VIR_TYPED_PARAM_STRING_OKAY, -1); + /* We don't return strings, and thus trivially support this flag. */ + flags &= ~VIR_TYPED_PARAM_STRING_OKAY; + + if (parallelsDomainBlockStats(domain, path, &stats) < 0) + goto cleanup; + + if (*nparams == 0) { +#define PARALLELS_COUNT_STATS(VAR, TYPE, NAME) \ + if ((stats.VAR) != -1) \ + ++*nparams; + + PARALLELS_BLOCK_STATS_FOREACH(PARALLELS_COUNT_STATS) + +#undef PARALLELS_COUNT_STATS + ret = 0; + goto cleanup; + } + + i = 0; +#define PARALLELS_BLOCK_STATS_ASSIGN_PARAM(VAR, TYPE, NAME) \ + if (i < *nparams && (stats.VAR) != -1) { \ + if (virTypedParameterAssign(params + i, TYPE, \ + VIR_TYPED_PARAM_LLONG, (stats.VAR)) < 0) \ + goto cleanup; \ + i++; \ + } + + PARALLELS_BLOCK_STATS_FOREACH(PARALLELS_BLOCK_STATS_ASSIGN_PARAM) + +#undef PARALLELS_BLOCK_STATS_ASSIGN_PARAM + + *nparams = i; + ret = 0; + + cleanup: + return ret; +} + + static virHypervisorDriver parallelsDriver = { .name = "Parallels", .connectOpen = parallelsConnectOpen, /* 0.10.0 */ @@ -1228,6 +1332,8 @@ static virHypervisorDriver parallelsDriver = { .domainManagedSave = parallelsDomainManagedSave, /* 1.2.14 */ .domainManagedSaveRemove = parallelsDomainManagedSaveRemove, /* 1.2.14 */ .domainGetMaxMemory = parallelsDomainGetMaxMemory, /* 1.2.15 */ + .domainBlockStats = parallelsDomainBlockStats, /* 1.2.17 */ + .domainBlockStatsFlags = parallelsDomainBlockStatsFlags, /* 1.2.17 */ }; static virConnectDriver parallelsConnectDriver = { diff --git a/src/parallels/parallels_sdk.c b/src/parallels/parallels_sdk.c index d5a9790..c2aae3b 100644 --- a/src/parallels/parallels_sdk.c +++ b/src/parallels/parallels_sdk.c @@ -21,6 +21,7 @@ */ #include <config.h> +#include <stdarg.h> #include "virerror.h" #include "viralloc.h" @@ -29,6 +30,7 @@ #include "virlog.h" #include "datatypes.h" #include "domain_conf.h" +#include "virtime.h" #include "parallels_sdk.h" @@ -407,6 +409,8 @@ prlsdkDomObjFreePrivate(void *p) return; PrlHandle_Free(pdom->sdkdom); + PrlHandle_Free(pdom->cache.stats); + virCondDestroy(&pdom->cache.cond); VIR_FREE(pdom->uuid); VIR_FREE(pdom->home); VIR_FREE(p); @@ -1260,6 +1264,13 @@ prlsdkLoadDomain(parallelsConnPtr privconn, * to NULL temporarily */ pdom->uuid = NULL; + pdom->cache.stats = PRL_INVALID_HANDLE; + pdom->cache.count = -1; + if (virCondInit(&pdom->cache.cond) < 0) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("cannot initialize condition")); + goto error; + } + if (prlsdkGetDomainIds(sdkdom, &def->name, def->uuid) < 0) goto error; @@ -1636,6 +1647,49 @@ prlsdkHandleVmRemovedEvent(parallelsConnPtr privconn, } static PRL_RESULT +prlsdkHandlePerfEvent(parallelsConnPtr privconn, + PRL_HANDLE event, + unsigned char *uuid) +{ + virDomainObjPtr dom = NULL; + parallelsDomObjPtr privdom = NULL; + PRL_HANDLE job = PRL_INVALID_HANDLE; + + dom = virDomainObjListFindByUUID(privconn->domains, uuid); + if (dom == NULL) + goto cleanup; + privdom = dom->privateData; + + // delayed event after unsubscribe + if (privdom->cache.count == -1) + goto cleanup; + + PrlHandle_Free(privdom->cache.stats); + privdom->cache.stats = PRL_INVALID_HANDLE; + + if (privdom->cache.count > 3) { + job = PrlVm_UnsubscribeFromPerfStats(privdom->sdkdom); + if (PRL_FAILED(waitJob(job))) + goto cleanup; + // change state to unsubscribed + privdom->cache.count = -1; + } else { + ++privdom->cache.count; + privdom->cache.stats = event; + // thus we get own of event handle + event = PRL_INVALID_HANDLE; + virCondSignal(&privdom->cache.cond); + } + + cleanup: + PrlHandle_Free(event); + if (dom) + virObjectUnlock(dom); + + return PRL_ERR_SUCCESS; +} + +static PRL_RESULT prlsdkHandleVmEvent(parallelsConnPtr privconn, PRL_HANDLE prlEvent) { PRL_RESULT pret; @@ -1665,6 +1719,11 @@ prlsdkHandleVmEvent(parallelsConnPtr privconn, PRL_HANDLE prlEvent) case PET_DSP_EVT_VM_UNREGISTERED: return prlsdkHandleVmRemovedEvent(privconn, uuid); break; + case PET_DSP_EVT_VM_PERFSTATS: + prlsdkHandlePerfEvent(privconn, prlEvent, uuid); + // above function takes own of event + prlEvent = PRL_INVALID_HANDLE; + break; default: virReportError(VIR_ERR_INTERNAL_ERROR, _("Can't handle event of type %d"), prlEventType); @@ -1714,6 +1773,7 @@ prlsdkEventsHandler(PRL_HANDLE prlEvent, PRL_VOID_PTR opaque) return pret; } + int prlsdkSubscribeToPCSEvents(parallelsConnPtr privconn) { PRL_RESULT pret = PRL_ERR_UNINITIALIZED; @@ -3450,3 +3510,126 @@ prlsdkDomainManagedSaveRemove(virDomainObjPtr dom) return 0; } + +static int +prlsdkExtractStatsParam(PRL_HANDLE sdkstats, const char *name, long long *val) +{ + PRL_HANDLE param = PRL_INVALID_HANDLE; + PRL_RESULT pret; + PRL_INT64 pval = 0; + int ret = -1; + + pret = PrlEvent_GetParamByName(sdkstats, name, &param); + if (pret == PRL_ERR_NO_DATA) { + *val = -1; + ret = 0; + goto cleanup; + } else if (PRL_FAILED(pret)) { + logPrlError(pret); + goto cleanup; + } + pret = PrlEvtPrm_ToInt64(param, &pval); + prlsdkCheckRetGoto(pret, cleanup); + + *val = pval; + ret = 0; + + cleanup: + PrlHandle_Free(param); + return ret; +} + +#define PARALLELS_STATISTICS_TIMEOUT (60 * 1000) + +static int +prlsdkGetStatsParam(virDomainObjPtr dom, const char *name, long long *val) +{ + parallelsDomObjPtr privdom = dom->privateData; + PRL_HANDLE job = PRL_INVALID_HANDLE; + unsigned long long now; + + if (privdom->cache.stats != PRL_INVALID_HANDLE) { + // reset count to keep subscribtion + privdom->cache.count = 0; + return prlsdkExtractStatsParam(privdom->cache.stats, name, val); + } + + job = PrlVm_SubscribeToPerfStats(privdom->sdkdom, NULL); + if (PRL_FAILED(waitJob(job))) + goto error; + + // change state to subscribed + privdom->cache.count = 0; + if (virTimeMillisNow(&now) < 0) { + virReportSystemError(errno, "%s", _("Unable to get current time")); + goto error; + } + + while (privdom->cache.stats == PRL_INVALID_HANDLE) { + if (virCondWaitUntil(&privdom->cache.cond, &dom->parent.lock, + now + PARALLELS_STATISTICS_TIMEOUT) < 0) { + if (errno == ETIMEDOUT) { + virReportError(VIR_ERR_OPERATION_TIMEOUT, "%s", + _("Timeout on waiting statistics event.")); + goto error; + } else { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("Unable to wait on monitor condition")); + goto error; + } + } + } + + return prlsdkExtractStatsParam(privdom->cache.stats, name, val); + error: + return -1; +} + +int +prlsdkGetBlockStats(virDomainObjPtr dom, virDomainDiskDefPtr disk, virDomainBlockStatsPtr stats) +{ + virDomainDeviceDriveAddressPtr address; + int idx; + const char *prefix; + int ret = -1; + char *name = NULL; + + address = &disk->info.addr.drive; + switch (disk->bus) { + case VIR_DOMAIN_DISK_BUS_IDE: + prefix = "ide"; + idx = address->bus * 2 + address->unit; + break; + case VIR_DOMAIN_DISK_BUS_SATA: + prefix = "sata"; + idx = address->unit; + break; + case VIR_DOMAIN_DISK_BUS_SCSI: + prefix = "scsi"; + idx = address->unit; + break; + default: + virReportError(VIR_ERR_INTERNAL_ERROR, + _("Unknown disk bus: %X"), disk->bus); + goto cleanup; + } + + +#define PRLSDK_GET_STAT_PARAM(VAL, TYPE, NAME) \ + if (virAsprintf(&name, "devices.%s%d.%s", prefix, idx, NAME) < 0) \ + goto cleanup; \ + if (prlsdkGetStatsParam(dom, name, &stats->VAL) < 0) \ + goto cleanup; \ + VIR_FREE(name); + + PARALLELS_BLOCK_STATS_FOREACH(PRLSDK_GET_STAT_PARAM) + +#undef PRLSDK_GET_STAT_PARAM + + ret = 0; + + cleanup: + + VIR_FREE(name); + return ret; +} diff --git a/src/parallels/parallels_sdk.h b/src/parallels/parallels_sdk.h index 3f17fc8..afa6745 100644 --- a/src/parallels/parallels_sdk.h +++ b/src/parallels/parallels_sdk.h @@ -64,3 +64,5 @@ int prlsdkAttachVolume(virDomainObjPtr dom, virDomainDiskDefPtr disk); int prlsdkDetachVolume(virDomainObjPtr dom, virDomainDiskDefPtr disk); +int +prlsdkGetBlockStats(virDomainObjPtr dom, virDomainDiskDefPtr disk, virDomainBlockStatsPtr stats); diff --git a/src/parallels/parallels_utils.c b/src/parallels/parallels_utils.c index ff9d47d..540986b 100644 --- a/src/parallels/parallels_utils.c +++ b/src/parallels/parallels_utils.c @@ -64,6 +64,34 @@ parallelsDomObjFromDomain(virDomainPtr domain) } +/** + * parallelsDomObjFromDomainRef: + * @domain: Domain pointer that has to be looked up + * + * This function looks up @domain and returns the appropriate virDomainObjPtr + * that has to be released by calling virDomainObjEndAPI(). + * + * Returns the domain object with incremented reference counter which is locked + * on success, NULL otherwise. + */ +virDomainObjPtr +parallelsDomObjFromDomainRef(virDomainPtr domain) +{ + virDomainObjPtr vm; + parallelsConnPtr privconn = domain->conn->privateData; + char uuidstr[VIR_UUID_STRING_BUFLEN]; + + vm = virDomainObjListFindByUUIDRef(privconn->domains, domain->uuid); + if (!vm) { + virUUIDFormat(domain->uuid, uuidstr); + virReportError(VIR_ERR_NO_DOMAIN, + _("no domain with matching uuid '%s' (%s)"), + uuidstr, domain->name); + return NULL; + } + + return vm; +} static int parallelsDoCmdRun(char **outbuf, const char *binary, va_list list) diff --git a/src/parallels/parallels_utils.h b/src/parallels/parallels_utils.h index 2d1d405..cdf6082 100644 --- a/src/parallels/parallels_utils.h +++ b/src/parallels/parallels_utils.h @@ -73,11 +73,22 @@ struct _parallelsConn { typedef struct _parallelsConn parallelsConn; typedef struct _parallelsConn *parallelsConnPtr; +struct _parallelsContersCache { + PRL_HANDLE stats; + virCond cond; + // -1 - unsubscribed + // > -1 - subscribed + int count; +}; + +typedef struct _parallelsContersCache parallelsContersCache; + struct parallelsDomObj { int id; char *uuid; char *home; PRL_HANDLE sdkdom; + parallelsContersCache cache; }; typedef struct parallelsDomObj *parallelsDomObjPtr; @@ -91,6 +102,7 @@ int parallelsNetworkClose(virConnectPtr conn); extern virNetworkDriver parallelsNetworkDriver; virDomainObjPtr parallelsDomObjFromDomain(virDomainPtr domain); +virDomainObjPtr parallelsDomObjFromDomainRef(virDomainPtr domain); virJSONValuePtr parallelsParseOutput(const char *binary, ...) ATTRIBUTE_NONNULL(1) ATTRIBUTE_SENTINEL; @@ -106,4 +118,10 @@ virStorageVolPtr parallelsStorageVolLookupByPathLocked(virConnectPtr conn, int parallelsStorageVolDefRemove(virStoragePoolObjPtr privpool, virStorageVolDefPtr privvol); +#define PARALLELS_BLOCK_STATS_FOREACH(OP) \ + OP(rd_req, VIR_DOMAIN_BLOCK_STATS_READ_REQ, "read_requests") \ + OP(rd_bytes, VIR_DOMAIN_BLOCK_STATS_READ_BYTES, "read_total") \ + OP(wr_req, VIR_DOMAIN_BLOCK_STATS_WRITE_REQ, "write_requests") \ + OP(wr_bytes, VIR_DOMAIN_BLOCK_STATS_WRITE_BYTES, "write_total") + #endif -- 1.7.1

1 1

[libvirt] [PATCH] conf: Fix invalid pointer check in virDomainObjGetDefs
by Peter Krempa 04 Jun '15

04 Jun '15

Coverity rightfully determined that in commit 3d021381c71221e563182f03 I made a mistake in the first check if @persDef is not NULL is dereferencing it rather than checking. --- Pushed as trivial. src/conf/domain_conf.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/conf/domain_conf.c b/src/conf/domain_conf.c index 77e198c..68d28f6 100644 --- a/src/conf/domain_conf.c +++ b/src/conf/domain_conf.c @@ -2927,7 +2927,7 @@ virDomainObjGetDefs(virDomainObjPtr vm, if (liveDef) *liveDef = NULL; - if (*persDef) + if (persDef) *persDef = NULL; if (virDomainObjUpdateModificationImpact(vm, &flags) < 0) -- 2.4.1

2 3

[libvirt] [PATCH 00/35] vCPU pinning and related refactors - Part 1
by Peter Krempa 04 Jun '15

04 Jun '15

These are preliminary refactors that will simplify the code base. The ultimate goal of this refactoring is to aggregate all vCPU information (pinning, scheduler,...) into a separate structure rather than storing them in multiple places. This will then in turn help in making a saner implementation of the still-planned specific vCPU API. Peter Krempa (35): qemu: Fix possible crash in qemuProcessSetVcpuAffinities conf: Refactor emulatorpin handling conf: Move pinning information definition closer to the usage place util: bitmap: Add virBitmapToDataBuf that does not allocate the buffer qemu: Use virBitmapToDataBuf in qemuDomainGetVcpuPinInfo qemu: Reuse virBitmapToDataBuf in qemuDomainGetEmulatorPinInfo qemu: Refactor qemuDomainHelperGetVcpus by reusing virBitmapToDataBuf libxl: Reuse virBitmapToData in libxlDomainSetVcpuAffinities libxl: Unbreak vcpu pinning libxl: Refactor libxlDomainGetVcpuPinInfo util: Add macro to overflow check integer assignments monitor: Move documentation for qemuMonitorGetBalloonInfo qemu: monitor: Make qemuMonitorSetBalloon operate on unsinged long long qemu: process: Refactor setup of memory ballooning qemu: process: Update current balloon state to maximum on vm startup qemu: Add helper to update domain balloon size and refactor usage places qemu: Refactor qemuDomainGetInfo conf: Store cpu count as unsigned int lib: virDomainPinIOThread: Remove spurious overflow check qemu: libxl: vcpupin: Don't reset pinning when pinning to all pcpus Revert "cputune: Support cputune for xend driver" libxl: Don't remove vcpu pin definition in libxlDomainCleanup conf: Add new helpers to resolve virDomainModificationImpact to domain defs qemu: Refactor qemuDomainSetMemoryFlags by reusing virDomainObjGetDefs qemu: Refactor qemuDomainSetMemoryStatsPeriod by reusing virDomainObjGetDefs qemu: Refactor qemuDomainGetVcpusFlags by reusing virDomainObjGetDefs qemu: Refactor qemuDomainGetIOThreadInfo by reusing virDomainObjGetDefs qemu: Refactor qemuDomainPinIOThread by reusing virDomainObjGetDefs qemu: Refactor qemuDomainChgIOThread by reusing virDomainObjGetDefs qemu: Refactor qemuDomainSetBlkioParameters by reusing virDomainObjGetDefs qemu: Refactor qemuDomainPinVcpuFlags by reusing virDomainObjGetDefs qemu: Refactor qemuDomainGetVcpuPinInfo by reusing virDomainObjGetDefs qemu: Refactor qemuDomainPinEmulator by reusing virDomainObjGetDefs qemu: Refactor qemuDomainGetEmulatorPinInfo by reusing virDomainObjGetDefs qemu: Refactor qemuDomainSetVcpusFlags by reusing virDomainObjGetDefs src/conf/domain_conf.c | 229 ++++++++--------- src/conf/domain_conf.h | 78 +++--- src/libvirt-domain.c | 19 -- src/libvirt_private.syms | 5 +- src/libxl/libxl_domain.c | 44 +--- src/libxl/libxl_driver.c | 57 ++--- src/qemu/qemu_cgroup.c | 2 +- src/qemu/qemu_domain.c | 64 +++++ src/qemu/qemu_domain.h | 3 + src/qemu/qemu_driver.c | 593 ++++++++++++------------------------------- src/qemu/qemu_monitor.c | 12 +- src/qemu/qemu_monitor.h | 2 +- src/qemu/qemu_monitor_json.c | 21 +- src/qemu/qemu_monitor_json.h | 2 +- src/qemu/qemu_monitor_text.c | 21 +- src/qemu/qemu_monitor_text.h | 2 +- src/qemu/qemu_process.c | 47 ++-- src/util/virbitmap.c | 33 ++- src/util/virbitmap.h | 3 + src/util/virutil.h | 11 + src/xen/xend_internal.c | 34 +-- tests/utiltest.c | 30 +++ tools/virsh.pod | 3 +- 23 files changed, 553 insertions(+), 762 deletions(-) -- 2.4.1

4 56

[libvirt] [libvirt-php PATCH] docs: remove reference to Red Hat
by Ján Tomko 04 Jun '15

04 Jun '15

--- docs/index.html.in | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/index.html.in b/docs/index.html.in index da40d7a..bb03d65 100644 --- a/docs/index.html.in +++ b/docs/index.html.in @@ -4,7 +4,7 @@ <h1>Libvirt-php</h1> <p>libvirt-php, originally called php-libvirt, is a project that was started by Radek Hladik in 2010 to integrate libvirt support to PHP.</p> - <p>In February 2011 the binding has been moved to libvirt.org site and it's currently maintained by Red Hat.</p> + <p>In February 2011 the binding was moved to libvirt.org.</p> <p> <b>This project is not affiliated with The PHP Group and the PHP project itself.</b> </p> -- 2.3.6

2 1

[libvirt] [PATCH] parallels: simplify event types discrimination
by Nikolay Shirokovskiy 04 Jun '15

04 Jun '15

Use issue type instead of event type to group vm related events. This saves us from explicit enumeration of all vm even types in prlsdkHandleVmEvent. --- src/parallels/parallels_sdk.c | 15 +++++---------- 1 files changed, 5 insertions(+), 10 deletions(-) diff --git a/src/parallels/parallels_sdk.c b/src/parallels/parallels_sdk.c index 88ad59b..d5a9790 100644 --- a/src/parallels/parallels_sdk.c +++ b/src/parallels/parallels_sdk.c @@ -1681,7 +1681,7 @@ prlsdkEventsHandler(PRL_HANDLE prlEvent, PRL_VOID_PTR opaque) parallelsConnPtr privconn = opaque; PRL_RESULT pret = PRL_ERR_UNINITIALIZED; PRL_HANDLE_TYPE handleType; - PRL_EVENT_TYPE prlEventType; + PRL_EVENT_ISSUER_TYPE prlIssuerType = PIE_UNKNOWN; pret = PrlHandle_GetType(prlEvent, &handleType); prlsdkCheckRetGoto(pret, cleanup); @@ -1697,20 +1697,15 @@ prlsdkEventsHandler(PRL_HANDLE prlEvent, PRL_VOID_PTR opaque) goto cleanup; } - PrlEvent_GetType(prlEvent, &prlEventType); + PrlEvent_GetIssuerType(prlEvent, &prlIssuerType); prlsdkCheckRetGoto(pret, cleanup); - switch (prlEventType) { - case PET_DSP_EVT_VM_STATE_CHANGED: - case PET_DSP_EVT_VM_CONFIG_CHANGED: - case PET_DSP_EVT_VM_CREATED: - case PET_DSP_EVT_VM_ADDED: - case PET_DSP_EVT_VM_DELETED: - case PET_DSP_EVT_VM_UNREGISTERED: + switch (prlIssuerType) { + case PIE_VIRTUAL_MACHINE: pret = prlsdkHandleVmEvent(privconn, prlEvent); break; default: - VIR_DEBUG("Skipping event of type %d", prlEventType); + VIR_DEBUG("Skipping event of issuer type %d", prlIssuerType); } pret = PRL_ERR_SUCCESS; -- 1.7.1

2 2

[libvirt] [PATCH] parallels: add block device statistics to driver
by Nikolay Shirokovskiy 04 Jun '15

04 Jun '15

Statistics provided through PCS SDK. As we have only async interface in SDK we need to be subscribed to statistics in order to get it. Trivial solution on every stat request to subscribe, wait event and then unsubscribe will lead to significant delays in case of a number of successive requests, as the event will be delivered on next PCS server notify cycle. On the other hand we don't want to keep unnesessary subscribtion. So we take an hibrid solution to subcsribe on first request and then keep a subscription while requests are active. We populate cache of statistics on subscribtion events and use this cache to serve libvirts requests. Signed-off-by: Nikolay Shirokovskiy <nshirokovskiy(a)parallels.com> --- src/parallels/parallels_driver.c | 106 +++++++++++++++++++++ src/parallels/parallels_sdk.c | 193 ++++++++++++++++++++++++++++++++------ src/parallels/parallels_sdk.h | 2 + src/parallels/parallels_utils.h | 15 +++ 4 files changed, 285 insertions(+), 31 deletions(-) diff --git a/src/parallels/parallels_driver.c b/src/parallels/parallels_driver.c index 4b87213..ce59e00 100644 --- a/src/parallels/parallels_driver.c +++ b/src/parallels/parallels_driver.c @@ -51,6 +51,7 @@ #include "nodeinfo.h" #include "virstring.h" #include "cpu/cpu.h" +#include "virtypedparam.h" #include "parallels_driver.h" #include "parallels_utils.h" @@ -1179,6 +1180,109 @@ parallelsDomainGetMaxMemory(virDomainPtr domain) return ret; } +static int +parallelsDomainBlockStats(virDomainPtr domain, const char *path, + virDomainBlockStatsPtr stats) +{ + virDomainObjPtr dom = NULL; + int ret = -1; + size_t i; + int idx; + + if (!(dom = parallelsDomObjFromDomain(domain))) + return -1; + + if (*path) { + if ((idx = virDomainDiskIndexByName(dom->def, path, false)) < 0) { + virReportError(VIR_ERR_INVALID_ARG, _("invalid path: %s"), path); + goto cleanup; + } + if (prlsdkGetBlockStats(dom, dom->def->disks[idx], stats) < 0) + goto cleanup; + } else { + virDomainBlockStatsStruct s; + +#define PARALLELS_ZERO_STATS(VAR, TYPE, NAME) \ + stats->VAR = 0; + + PARALLELS_BLOCK_STATS_FOREACH(PARALLELS_ZERO_STATS) + +#undef PARALLELS_ZERO_STATS + + for (i = 0; i < dom->def->ndisks; i++) { + if (prlsdkGetBlockStats(dom, dom->def->disks[i], &s) < 0) + goto cleanup; + +#define PARALLELS_SUM_STATS(VAR, TYPE, NAME) \ + if (s.VAR != -1) \ + stats->VAR += s.VAR; + + PARALLELS_BLOCK_STATS_FOREACH(PARALLELS_SUM_STATS) + +#undef PARALLELS_SUM_STATS + } + } + stats->errs = -1; + ret = 0; + + cleanup: + if (dom) + virObjectUnlock(dom); + + return ret; +} + +static int +parallelsDomainBlockStatsFlags(virDomainPtr domain, + const char *path, + virTypedParameterPtr params, + int *nparams, + unsigned int flags) +{ + virDomainBlockStatsStruct stats; + int ret = -1; + size_t i; + + virCheckFlags(VIR_TYPED_PARAM_STRING_OKAY, -1); + /* We don't return strings, and thus trivially support this flag. */ + flags &= ~VIR_TYPED_PARAM_STRING_OKAY; + + if (parallelsDomainBlockStats(domain, path, &stats) < 0) + goto cleanup; + + if (*nparams == 0) { +#define PARALLELS_COUNT_STATS(VAR, TYPE, NAME) \ + if ((stats.VAR) != -1) \ + ++*nparams; + + PARALLELS_BLOCK_STATS_FOREACH(PARALLELS_COUNT_STATS) + +#undef PARALLELS_COUNT_STATS + ret = 0; + goto cleanup; + } + + i = 0; +#define PARALLELS_BLOCK_STATS_ASSIGN_PARAM(VAR, TYPE, NAME) \ + if (i < *nparams && (stats.VAR) != -1) { \ + if (virTypedParameterAssign(params + i, TYPE, \ + VIR_TYPED_PARAM_LLONG, (stats.VAR)) < 0) \ + goto cleanup; \ + i++; \ + } + + PARALLELS_BLOCK_STATS_FOREACH(PARALLELS_BLOCK_STATS_ASSIGN_PARAM) + +#undef PARALLELS_BLOCK_STATS_ASSIGN_PARAM + + *nparams = i; + ret = 0; + + cleanup: + return ret; +} + + static virHypervisorDriver parallelsDriver = { .name = "Parallels", .connectOpen = parallelsConnectOpen, /* 0.10.0 */ @@ -1228,6 +1332,8 @@ static virHypervisorDriver parallelsDriver = { .domainManagedSave = parallelsDomainManagedSave, /* 1.2.14 */ .domainManagedSaveRemove = parallelsDomainManagedSaveRemove, /* 1.2.14 */ .domainGetMaxMemory = parallelsDomainGetMaxMemory, /* 1.2.15 */ + .domainBlockStats = parallelsDomainBlockStats, /* 1.2.16 */ + .domainBlockStatsFlags = parallelsDomainBlockStatsFlags, /* 1.2.16 */ }; static virConnectDriver parallelsConnectDriver = { diff --git a/src/parallels/parallels_sdk.c b/src/parallels/parallels_sdk.c index 88ad59b..eb8d965 100644 --- a/src/parallels/parallels_sdk.c +++ b/src/parallels/parallels_sdk.c @@ -21,6 +21,7 @@ */ #include <config.h> +#include <stdarg.h> #include "virerror.h" #include "viralloc.h" @@ -407,6 +408,8 @@ prlsdkDomObjFreePrivate(void *p) return; PrlHandle_Free(pdom->sdkdom); + PrlHandle_Free(pdom->cache.stats); + virCondDestroy(&pdom->cache.cond); VIR_FREE(pdom->uuid); VIR_FREE(pdom->home); VIR_FREE(p); @@ -1260,6 +1263,13 @@ prlsdkLoadDomain(parallelsConnPtr privconn, * to NULL temporarily */ pdom->uuid = NULL; + pdom->cache.stats = PRL_INVALID_HANDLE; + pdom->cache.count = 0; + if (virCondInit(&pdom->cache.cond) < 0) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("cannot initialize condition")); + goto error; + } + if (prlsdkGetDomainIds(sdkdom, &def->name, def->uuid) < 0) goto error; @@ -1636,43 +1646,39 @@ prlsdkHandleVmRemovedEvent(parallelsConnPtr privconn, } static PRL_RESULT -prlsdkHandleVmEvent(parallelsConnPtr privconn, PRL_HANDLE prlEvent) +prlsdkHandlePerfEvent(parallelsConnPtr privconn, + PRL_HANDLE event, + unsigned char *uuid) { - PRL_RESULT pret; - char uuidstr[VIR_UUID_STRING_BUFLEN + 2]; - unsigned char uuid[VIR_UUID_BUFLEN]; - PRL_UINT32 bufsize = ARRAY_CARDINALITY(uuidstr); - PRL_EVENT_TYPE prlEventType; + virDomainObjPtr dom = NULL; + parallelsDomObjPtr privdom = NULL; + PRL_HANDLE job = PRL_INVALID_HANDLE; - pret = PrlEvent_GetType(prlEvent, &prlEventType); - prlsdkCheckRetGoto(pret, error); + dom = virDomainObjListFindByUUID(privconn->domains, uuid); + if (dom == NULL) + goto cleanup; - pret = PrlEvent_GetIssuerId(prlEvent, uuidstr, &bufsize); - prlsdkCheckRetGoto(pret, error); + privdom = dom->privateData; - if (prlsdkUUIDParse(uuidstr, uuid) < 0) - return PRL_ERR_FAILURE; + PrlHandle_Free(privdom->cache.stats); + privdom->cache.stats = event; + virCondSignal(&privdom->cache.cond); - switch (prlEventType) { - case PET_DSP_EVT_VM_STATE_CHANGED: - return prlsdkHandleVmStateEvent(privconn, prlEvent, uuid); - case PET_DSP_EVT_VM_CONFIG_CHANGED: - return prlsdkHandleVmConfigEvent(privconn, uuid); - case PET_DSP_EVT_VM_CREATED: - case PET_DSP_EVT_VM_ADDED: - return prlsdkHandleVmAddedEvent(privconn, uuid); - case PET_DSP_EVT_VM_DELETED: - case PET_DSP_EVT_VM_UNREGISTERED: - return prlsdkHandleVmRemovedEvent(privconn, uuid); - break; - default: - virReportError(VIR_ERR_INTERNAL_ERROR, - _("Can't handle event of type %d"), prlEventType); - return PRL_ERR_FAILURE; + ++privdom->cache.count; + + if (privdom->cache.count > 3) { + job = PrlVm_UnsubscribeFromPerfStats(privdom->sdkdom); + if (PRL_FAILED(waitJob(job))) + goto cleanup; + privdom->cache.count = 0; + privdom->cache.stats = PRL_INVALID_HANDLE; } - error: - return PRL_ERR_FAILURE; + cleanup: + if (dom) + virObjectUnlock(dom); + + return PRL_ERR_SUCCESS; } static PRL_RESULT @@ -1682,6 +1688,9 @@ prlsdkEventsHandler(PRL_HANDLE prlEvent, PRL_VOID_PTR opaque) PRL_RESULT pret = PRL_ERR_UNINITIALIZED; PRL_HANDLE_TYPE handleType; PRL_EVENT_TYPE prlEventType; + char uuidstr[VIR_UUID_STRING_BUFLEN + 2]; + unsigned char uuid[VIR_UUID_BUFLEN]; + PRL_UINT32 bufsize = ARRAY_CARDINALITY(uuidstr); pret = PrlHandle_GetType(prlEvent, &handleType); prlsdkCheckRetGoto(pret, cleanup); @@ -1700,14 +1709,31 @@ prlsdkEventsHandler(PRL_HANDLE prlEvent, PRL_VOID_PTR opaque) PrlEvent_GetType(prlEvent, &prlEventType); prlsdkCheckRetGoto(pret, cleanup); + pret = PrlEvent_GetIssuerId(prlEvent, uuidstr, &bufsize); + prlsdkCheckRetGoto(pret, cleanup); + + if (prlsdkUUIDParse(uuidstr, uuid) < 0) + goto cleanup; + switch (prlEventType) { case PET_DSP_EVT_VM_STATE_CHANGED: + prlsdkHandleVmStateEvent(privconn, prlEvent, uuid); + break; case PET_DSP_EVT_VM_CONFIG_CHANGED: + prlsdkHandleVmConfigEvent(privconn, uuid); + break; case PET_DSP_EVT_VM_CREATED: case PET_DSP_EVT_VM_ADDED: + prlsdkHandleVmAddedEvent(privconn, uuid); + break; case PET_DSP_EVT_VM_DELETED: case PET_DSP_EVT_VM_UNREGISTERED: - pret = prlsdkHandleVmEvent(privconn, prlEvent); + prlsdkHandleVmRemovedEvent(privconn, uuid); + break; + case PET_DSP_EVT_VM_PERFSTATS: + prlsdkHandlePerfEvent(privconn, prlEvent, uuid); + // above function takes own of event + prlEvent = PRL_INVALID_HANDLE; break; default: VIR_DEBUG("Skipping event of type %d", prlEventType); @@ -3455,3 +3481,108 @@ prlsdkDomainManagedSaveRemove(virDomainObjPtr dom) return 0; } + +static int +prlsdkExtractStatsParam(PRL_HANDLE sdkstats, const char *name, long long *val) +{ + PRL_HANDLE param = PRL_INVALID_HANDLE; + PRL_RESULT pret; + PRL_INT64 pval = 0; + int ret = -1; + + pret = PrlEvent_GetParamByName(sdkstats, name, &param); + if (pret == PRL_ERR_NO_DATA) { + *val = -1; + ret = 0; + goto cleanup; + } else if (PRL_FAILED(pret)) { + logPrlError(pret); + goto cleanup; + } + pret = PrlEvtPrm_ToInt64(param, &pval); + prlsdkCheckRetGoto(pret, cleanup); + + *val = pval; + ret = 0; + + cleanup: + PrlHandle_Free(param); + return ret; +} + +static int +prlsdkGetStatsParam(virDomainObjPtr dom, const char *name, long long *val) +{ + parallelsDomObjPtr privdom = dom->privateData; + PRL_HANDLE job = PRL_INVALID_HANDLE; + + if (privdom->cache.stats != PRL_INVALID_HANDLE) { + privdom->cache.count = 0; + return prlsdkExtractStatsParam(privdom->cache.stats, name, val); + } + + job = PrlVm_SubscribeToPerfStats(privdom->sdkdom, NULL); + if (PRL_FAILED(waitJob(job))) + goto error; + + while (privdom->cache.stats == PRL_INVALID_HANDLE) { + if (virCondWait(&privdom->cache.cond, &dom->parent.lock) < 0) { + virReportError(VIR_ERR_INTERNAL_ERROR, "%s", + _("Unable to wait on monitor condition")); + goto error; + } + } + + return prlsdkExtractStatsParam(privdom->cache.stats, name, val); + error: + return -1; +} + +int +prlsdkGetBlockStats(virDomainObjPtr dom, virDomainDiskDefPtr disk, virDomainBlockStatsPtr stats) +{ + virDomainDeviceDriveAddressPtr address; + int idx; + const char *prefix; + int ret = -1; + char *name = NULL; + + address = &disk->info.addr.drive; + switch (disk->bus) { + case VIR_DOMAIN_DISK_BUS_IDE: + prefix = "ide"; + idx = address->bus * 2 + address->unit; + break; + case VIR_DOMAIN_DISK_BUS_SATA: + prefix = "sata"; + idx = address->unit; + break; + case VIR_DOMAIN_DISK_BUS_SCSI: + prefix = "scsi"; + idx = address->unit; + break; + default: + virReportError(VIR_ERR_INTERNAL_ERROR, + _("Unknown disk bus: %X"), disk->bus); + goto cleanup; + } + + +#define PRLSDK_GET_STAT_PARAM(VAL, TYPE, NAME) \ + if (virAsprintf(&name, "devices.%s%d.%s", prefix, idx, NAME) < 0) \ + goto cleanup; \ + if (prlsdkGetStatsParam(dom, name, &stats->VAL) < 0) \ + goto cleanup; \ + VIR_FREE(name); + + PARALLELS_BLOCK_STATS_FOREACH(PRLSDK_GET_STAT_PARAM) + +#undef PRLSDK_GET_STAT_PARAM + + ret = 0; + + cleanup: + + VIR_FREE(name); + return ret; +} diff --git a/src/parallels/parallels_sdk.h b/src/parallels/parallels_sdk.h index 3f17fc8..afa6745 100644 --- a/src/parallels/parallels_sdk.h +++ b/src/parallels/parallels_sdk.h @@ -64,3 +64,5 @@ int prlsdkAttachVolume(virDomainObjPtr dom, virDomainDiskDefPtr disk); int prlsdkDetachVolume(virDomainObjPtr dom, virDomainDiskDefPtr disk); +int +prlsdkGetBlockStats(virDomainObjPtr dom, virDomainDiskDefPtr disk, virDomainBlockStatsPtr stats); diff --git a/src/parallels/parallels_utils.h b/src/parallels/parallels_utils.h index 2d1d405..e424405 100644 --- a/src/parallels/parallels_utils.h +++ b/src/parallels/parallels_utils.h @@ -73,11 +73,20 @@ struct _parallelsConn { typedef struct _parallelsConn parallelsConn; typedef struct _parallelsConn *parallelsConnPtr; +struct _parallelsContersCache { + PRL_HANDLE stats; + virCond cond; + int count; +}; + +typedef struct _parallelsContersCache parallelsContersCache; + struct parallelsDomObj { int id; char *uuid; char *home; PRL_HANDLE sdkdom; + parallelsContersCache cache; }; typedef struct parallelsDomObj *parallelsDomObjPtr; @@ -106,4 +115,10 @@ virStorageVolPtr parallelsStorageVolLookupByPathLocked(virConnectPtr conn, int parallelsStorageVolDefRemove(virStoragePoolObjPtr privpool, virStorageVolDefPtr privvol); +#define PARALLELS_BLOCK_STATS_FOREACH(OP) \ + OP(rd_req, VIR_DOMAIN_BLOCK_STATS_READ_REQ, "read_requests") \ + OP(rd_bytes, VIR_DOMAIN_BLOCK_STATS_READ_BYTES, "read_total") \ + OP(wr_req, VIR_DOMAIN_BLOCK_STATS_WRITE_REQ, "write_requests") \ + OP(wr_bytes, VIR_DOMAIN_BLOCK_STATS_WRITE_BYTES, "write_total") + #endif -- 1.7.1

2 2

[libvirt] [PATCH] qemu: Check for qemu capability when calling virDomainGetBlockIoTune()
by Martin Kletzander 04 Jun '15

04 Jun '15

When getting block device I/O tuning data there is no check for whether QEMU supports such options and the call fails on qemuMonitorGetBlockIoThrottle() when getting the particular throttle data. So try reporting a better error when blkdeviotune is not supported. Resolves: https://bugzilla.redhat.com/show_bug.cgi?id=1224053 Signed-off-by: Martin Kletzander <mkletzan(a)redhat.com> --- src/qemu/qemu_driver.c | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index d1b00a2014ba..8f8ad8ba5bf5 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -18065,6 +18065,12 @@ qemuDomainGetBlockIoTune(virDomainPtr dom, * because we need vm->privateData which need * virDomainLiveConfigHelperMethod to do so. */ priv = vm->privateData; + if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DRIVE_IOTUNE)) { + virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s", + _("block I/O throttling not supported with this " + "QEMU binary")); + goto endjob; + } supportMaxOptions = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DRIVE_IOTUNE_MAX); } -- 2.4.2

2 2

[libvirt] [PATCH] docs: php: remove reference to Red Hat
by Ján Tomko 04 Jun '15

04 Jun '15

Also remove the redudant apostrophe from "it's". --- docs/php.html.in | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/docs/php.html.in b/docs/php.html.in index d9a3c1b..c10b0aa 100644 --- a/docs/php.html.in +++ b/docs/php.html.in @@ -6,8 +6,7 @@ <h2>Presentation</h2> <p>The libvirt-php, originally called php-libvirt, is the PHP API bindings for - the libvirt virtualization toolkit originally developed by Radek Hladik but - currently maintained by Red Hat.</p> + the libvirt virtualization toolkit originally developed by Radek Hladik.</p> <h2>Getting the source</h2> <p> The PHP bindings code source is now maintained in a <a @@ -26,7 +25,7 @@ It can also be browsed at <p></p> <h2>Project pages</h2> -<p>Since February 2011 the project have it's own pages hosted at libvirt.org. For more information on the project +<p>Since February 2011 the project has its own pages hosted at libvirt.org. For more information on the project please refer to <a href="http://libvirt.org/php">http://libvirt.org/php</a>. </p> -- 2.3.6

2 2

[libvirt] [PATCH] maint: remove redundant apostrophes from 'its'
by Ján Tomko 04 Jun '15

04 Jun '15

--- docs/formatnode.html.in | 2 +- src/conf/storage_conf.c | 2 +- src/esx/esx_driver.c | 2 +- src/esx/esx_network_driver.c | 2 +- src/esx/esx_storage_backend_iscsi.c | 2 +- src/esx/esx_storage_backend_vmfs.c | 2 +- src/libxl/libxl_domain.c | 2 +- src/network/bridge_driver.c | 2 +- src/parallels/parallels_storage.c | 2 +- src/qemu/qemu_driver.c | 4 ++-- src/qemu/qemu_migration.c | 2 +- src/vbox/vbox_common.c | 2 +- 12 files changed, 13 insertions(+), 13 deletions(-) diff --git a/docs/formatnode.html.in b/docs/formatnode.html.in index ba9a0f8..3ff1bef 100644 --- a/docs/formatnode.html.in +++ b/docs/formatnode.html.in @@ -122,7 +122,7 @@ This optional element contains information on PCI Express part of the device. For example, it can contain a child element <code>link</code> which addresses the PCI Express device's link. - While a device has it's own capabilities + While a device has its own capabilities (<code>validity='cap'</code>), the actual run time capabilities are negotiated on the device initialization (<code>validity='sta'</code>). The <code>link</code> element then diff --git a/src/conf/storage_conf.c b/src/conf/storage_conf.c index df536d4..4bbed4f 100644 --- a/src/conf/storage_conf.c +++ b/src/conf/storage_conf.c @@ -2335,7 +2335,7 @@ matchFCHostToSCSIHost(virConnectPtr conn, char *parent_name = NULL; unsigned int fc_hostnum; - /* If we have a parent defined, get it's hostnum, and compare to the + /* If we have a parent defined, get its hostnum, and compare to the * scsi_hostnum. If they are the same, then we have a match */ if (fc_adapter.data.fchost.parent && diff --git a/src/esx/esx_driver.c b/src/esx/esx_driver.c index bf51213..c304ff3 100644 --- a/src/esx/esx_driver.c +++ b/src/esx/esx_driver.c @@ -267,7 +267,7 @@ esxParseVMXFileName(const char *fileName, void *opaque) * in the documentation of esxParseVMXFileName. * * Firstly parse the datastore path. Then use the datastore name to lookup the - * datastore and it's mount path. Finally concatenate the mount path, directory + * datastore and its mount path. Finally concatenate the mount path, directory * and file name to an absolute path and return it. Detect the separator type * based on the mount path. */ diff --git a/src/esx/esx_network_driver.c b/src/esx/esx_network_driver.c index 6793b80..b19c06a 100644 --- a/src/esx/esx_network_driver.c +++ b/src/esx/esx_network_driver.c @@ -38,7 +38,7 @@ #define VIR_FROM_THIS VIR_FROM_ESX /* - * The UUID of a network is the MD5 sum of it's key. Therefore, verify that + * The UUID of a network is the MD5 sum of its key. Therefore, verify that * UUID and MD5 sum match in size, because we rely on that. */ verify(MD5_DIGEST_SIZE == VIR_UUID_BUFLEN); diff --git a/src/esx/esx_storage_backend_iscsi.c b/src/esx/esx_storage_backend_iscsi.c index e4d2692..a9a19cf 100644 --- a/src/esx/esx_storage_backend_iscsi.c +++ b/src/esx/esx_storage_backend_iscsi.c @@ -42,7 +42,7 @@ #define VIR_FROM_THIS VIR_FROM_ESX /* - * The UUID of a storage pool is the MD5 sum of it's mount path. Therefore, + * The UUID of a storage pool is the MD5 sum of its mount path. Therefore, * verify that UUID and MD5 sum match in size, because we rely on that. */ verify(MD5_DIGEST_SIZE == VIR_UUID_BUFLEN); diff --git a/src/esx/esx_storage_backend_vmfs.c b/src/esx/esx_storage_backend_vmfs.c index 0dcf419..d03d33a 100644 --- a/src/esx/esx_storage_backend_vmfs.c +++ b/src/esx/esx_storage_backend_vmfs.c @@ -48,7 +48,7 @@ VIR_LOG_INIT("esx.esx_storage_backend_vmfs"); /* - * The UUID of a storage pool is the MD5 sum of it's mount path. Therefore, + * The UUID of a storage pool is the MD5 sum of its mount path. Therefore, * verify that UUID and MD5 sum match in size, because we rely on that. */ verify(MD5_DIGEST_SIZE == VIR_UUID_BUFLEN); diff --git a/src/libxl/libxl_domain.c b/src/libxl/libxl_domain.c index f339d9c..d925917 100644 --- a/src/libxl/libxl_domain.c +++ b/src/libxl/libxl_domain.c @@ -518,7 +518,7 @@ libxlDomainEventHandler(void *data, VIR_LIBXL_EVENT_CONST libxl_event *event) /* * Similar to the xl implementation, ignore SUSPEND. Any actions needed - * after calling libxl_domain_suspend() are handled by it's callers. + * after calling libxl_domain_suspend() are handled by its callers. */ if (xl_reason == LIBXL_SHUTDOWN_REASON_SUSPEND) goto error; diff --git a/src/network/bridge_driver.c b/src/network/bridge_driver.c index 72be51e..3d6721b 100644 --- a/src/network/bridge_driver.c +++ b/src/network/bridge_driver.c @@ -1601,7 +1601,7 @@ networkRadvdConfContents(virNetworkObjPtr network, char **configstr) return ret; } -/* write file and return it's name (which must be freed by caller) */ +/* write file and return its name (which must be freed by caller) */ static int networkRadvdConfWrite(virNetworkDriverStatePtr driver, virNetworkObjPtr network, diff --git a/src/parallels/parallels_storage.c b/src/parallels/parallels_storage.c index 3dcc44d..ff3d0fa 100644 --- a/src/parallels/parallels_storage.c +++ b/src/parallels/parallels_storage.c @@ -212,7 +212,7 @@ parallelsPoolCreateByPath(virConnectPtr conn, const char *path) /* * Create pool of type VIR_STORAGE_POOL_DIR with - * path to the VM, if it's not exists. + * path to the VM, if it does not exist. */ static virStoragePoolObjPtr parallelsPoolAddByDomain(virConnectPtr conn, virDomainObjPtr dom) diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index 63001b1..84e0568 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -2959,7 +2959,7 @@ qemuOpenFileAs(uid_t fallback_uid, gid_t fallback_gid, is_reg = !!S_ISREG(sb.st_mode); /* If the path is regular file which exists * already and dynamic_ownership is off, we don't - * want to change it's ownership, just open it as-is */ + * want to change its ownership, just open it as-is */ if (is_reg && !dynamicOwnership) { uid = sb.st_uid; gid = sb.st_gid; @@ -16396,7 +16396,7 @@ qemuDomainBlockPivot(virQEMUDriverPtr driver, * XXX On libvirtd restarts, if we missed the qemu event, we need * to double check what state qemu is in. * XXX We should be using qemu's rerror flag to make sure the job - * remains alive until we know it's final state. + * remains alive until we know its final state. * XXX If the abort command is synchronous but the qemu event says * that pivot failed, we need to reflect that failure into the * overall return value. */ diff --git a/src/qemu/qemu_migration.c b/src/qemu/qemu_migration.c index f7432e8..70400f3 100644 --- a/src/qemu/qemu_migration.c +++ b/src/qemu/qemu_migration.c @@ -125,7 +125,7 @@ struct _qemuMigrationCookieNetData { int vporttype; /* enum virNetDevVPortProfile */ /* - * Array of pointers to saved data. Each VIF will have it's own + * Array of pointers to saved data. Each VIF will have its own * data to transfer. */ char *portdata; diff --git a/src/vbox/vbox_common.c b/src/vbox/vbox_common.c index ba0b039..813a171 100644 --- a/src/vbox/vbox_common.c +++ b/src/vbox/vbox_common.c @@ -4603,7 +4603,7 @@ vboxSnapshotRedefine(virDomainPtr dom, readWriteDisk->location = realReadWriteDisksPath[it]; /* * We get the current snapshot's read-only disk uuid in order to add the - * read-write disk to the media registry as it's child. The read-only disk + * read-write disk to the media registry as its child. The read-only disk * is already in the media registry because it is the fake disk's parent. */ parentUuid = virVBoxSnapshotConfHardDiskUuidByLocation(snapshotMachineDesc, -- 2.3.6

3 4

[libvirt] [v2] storage-pool: API to get/set autostart flag
by Zeeshan Ali (Khattak) 04 Jun '15

04 Jun '15

Add binding for virStoragePoolGetAutostart & virStoragePoolSetAutostart. --- libvirt-gobject/libvirt-gobject-storage-pool.c | 51 ++++++++++++++++++++++++++ libvirt-gobject/libvirt-gobject-storage-pool.h | 5 +++ libvirt-gobject/libvirt-gobject.sym | 6 +++ 3 files changed, 62 insertions(+) diff --git a/libvirt-gobject/libvirt-gobject-storage-pool.c b/libvirt-gobject/libvirt-gobject-storage-pool.c index f3eac0d..7f26b1b 100644 --- a/libvirt-gobject/libvirt-gobject-storage-pool.c +++ b/libvirt-gobject/libvirt-gobject-storage-pool.c @@ -1048,6 +1048,57 @@ gboolean gvir_storage_pool_delete (GVirStoragePool *pool, return TRUE; } +/** + * gvir_storage_pool_get_autostart: + * @pool: the storage pool + * @err: return location for any #GError + * + * Return value: #True if autostart is enabled, #False otherwise. + */ +gboolean gvir_storage_pool_get_autostart(GVirStoragePool *pool, + GError **err) +{ + int ret; + + g_return_val_if_fail(GVIR_IS_STORAGE_POOL(pool), FALSE); + g_return_val_if_fail(err == NULL || *err == NULL, FALSE); + + if (virStoragePoolGetAutostart(pool->priv->handle, &ret)) { + gvir_set_error_literal(err, GVIR_STORAGE_POOL_ERROR, + 0, + "Failed to get autostart flag from storage pool"); + } + + return !!ret; +} + +/** + * gvir_storage_pool_set_autostart: + * @pool: the storage pool + * @autostart: Whether or not to autostart + * @err: return location for any #GError + * + * Sets whether or not storage pool @pool is started automatically on boot. + * + * Return value: #TRUE on success, #FALSE otherwise. + */ +gboolean gvir_storage_pool_set_autostart(GVirStoragePool *pool, + gboolean autostart, + GError **err) +{ + g_return_val_if_fail(GVIR_IS_STORAGE_POOL(pool), FALSE); + g_return_val_if_fail(err == NULL || *err == NULL, FALSE); + + if (virStoragePoolSetAutostart(pool->priv->handle, autostart)) { + gvir_set_error_literal(err, GVIR_STORAGE_POOL_ERROR, + 0, + "Failed to set autostart flag on storage pool"); + return FALSE; + } + + return TRUE; +} + static void gvir_storage_pool_delete_helper(GSimpleAsyncResult *res, GObject *object, diff --git a/libvirt-gobject/libvirt-gobject-storage-pool.h b/libvirt-gobject/libvirt-gobject-storage-pool.h index f8529f0..f7f879c 100644 --- a/libvirt-gobject/libvirt-gobject-storage-pool.h +++ b/libvirt-gobject/libvirt-gobject-storage-pool.h @@ -166,6 +166,11 @@ void gvir_storage_pool_delete_async (GVirStoragePool *pool, gboolean gvir_storage_pool_delete_finish(GVirStoragePool *pool, GAsyncResult *result, GError **err); +gboolean gvir_storage_pool_get_autostart(GVirStoragePool *pool, + GError **err); +gboolean gvir_storage_pool_set_autostart(GVirStoragePool *pool, + gboolean autostart, + GError **err); G_END_DECLS diff --git a/libvirt-gobject/libvirt-gobject.sym b/libvirt-gobject/libvirt-gobject.sym index 927cad9..dcda675 100644 --- a/libvirt-gobject/libvirt-gobject.sym +++ b/libvirt-gobject/libvirt-gobject.sym @@ -265,4 +265,10 @@ LIBVIRT_GOBJECT_0.2.0 { gvir_domain_open_graphics_fd; } LIBVIRT_GOBJECT_0.1.9; +LIBVIRT_GOBJECT_0.2.1 { + global: + gvir_storage_pool_get_autostart; + gvir_storage_pool_set_autostart; +} LIBVIRT_GOBJECT_0.2.0; + # .... define new API here using predicted next version number .... -- 2.4.2

1 1

[libvirt] [PATCH v2] check if console/channel PTY is null before attempting to open
by Shivaprasad G Bhat 04 Jun '15

04 Jun '15

Console/channel devices have their pty devices assigned when the emulator is actually started. If time is spent in guest preparation, someone attempts to open the console/channel, the libvirt crashes in virChrdevLockFilePath(). The patch attempts to fix the crash by adding a check before attempting to open. Signed-off-by: Shivaprasad G Bhat <sbhat(a)linux.vnet.ibm.com> --- src/conf/virchrdev.c | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/conf/virchrdev.c b/src/conf/virchrdev.c index 5f28f29..701b326 100644 --- a/src/conf/virchrdev.c +++ b/src/conf/virchrdev.c @@ -350,6 +350,11 @@ int virChrdevOpen(virChrdevsPtr devs, switch (source->type) { case VIR_DOMAIN_CHR_TYPE_PTY: path = source->data.file.path; + if (!path) { + virReportError(VIR_ERR_OPERATION_FAILED, "%s", + _("PTY device is not yet assigned")); + return -1; + } break; case VIR_DOMAIN_CHR_TYPE_UNIX: path = source->data.nix.path;

2 1

[libvirt] [PATCH 0/2] lxc: allow using 802.11 wireless interfaces in LXC domains
by Lubomir Rintel 04 Jun '15

04 Jun '15

Hi, I'm using libvirt-lxc with mac80211_hwsim to construct virtual wireless network for NetworkManager testing. Currently, I have to move the interfaces to the domains manually, as sharing wan 802.11 wireless link with a LXC namespace does not work: <hostdev mode='capabilities' type='net'> <source><interface>wlan0</interface></source> </hostdev> The wireless links can only be associated to namespaces by moving the underlying PHY instead of the network interface. I'm following up with patches that fix the problem for me; please take a look. Thank you Lubo

2 7

[libvirt] [PATCH] util: Clear output broadcast address before filling it in
by Martin Kletzander 03 Jun '15

03 Jun '15

Since commit 55ace7c4789c8a7408139460f4b639cee00e5125, the sockettest fails without VIR_TEST_DEBUG set. The problem is found by test number 42 (co-incidence?), which tests range '192.168.122.1' - '192.168.122.255' in network '192.168.122.0/24'. That is supposed to fail because the end address is equal to the broadcast address. When comparing these two in 'virSocketAddrEqual(end, &broadcast)', there is a check for sin_addr as well as for sin_port. That port, however, is different when we do not enable test debugging. With the testing enabled, the port is 0 (correctly initialized), but without that it has a random number there. And that's because the structure is not initialized anywhere. By zeroing the structure before filling in the info, we make sure we return only the address and not any information that was not requested. And the test work once again. Signed-off-by: Martin Kletzander <mkletzan(a)redhat.com> --- Notes: Pushed as a build-breaker. src/util/virsocketaddr.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/util/virsocketaddr.c b/src/util/virsocketaddr.c index 34f2af31b2e7..81539b3730d4 100644 --- a/src/util/virsocketaddr.c +++ b/src/util/virsocketaddr.c @@ -505,6 +505,8 @@ virSocketAddrBroadcast(const virSocketAddr *addr, const virSocketAddr *netmask, virSocketAddrPtr broadcast) { + memset(broadcast, 0, sizeof(*broadcast)); + if ((addr->data.stor.ss_family != AF_INET) || (netmask->data.stor.ss_family != AF_INET)) { broadcast->data.stor.ss_family = AF_UNSPEC; -- 2.4.2

2 1

[libvirt] [PATCH] util: process: Refactor and fix virProcessSetAffinity
by Peter Krempa 03 Jun '15

03 Jun '15

Refactor the function to return the bitmap instead of an integer and the inner workings so that they make more sense. This patch also fixes possible segfault on old systems that was introduced by commit: commit f1a43a8e4139b028257ef4ed05a81cfb5f8a8741 Author: Hu Tao <hutao(a)cn.fujitsu.com> Date: Fri Sep 14 15:46:59 2012 +0800 use virBitmap to store cpu affinity info --- Pushed after review on the libvirt-security list. src/qemu/qemu_driver.c | 5 +-- src/util/virprocess.c | 102 ++++++++++++++++++++++--------------------------- src/util/virprocess.h | 4 +- 3 files changed, 48 insertions(+), 63 deletions(-) diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index f32b87e..63001b1 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -1457,8 +1457,7 @@ qemuDomainHelperGetVcpus(virDomainObjPtr vm, virVcpuInfoPtr info, int maxinfo, unsigned char *cpumap = VIR_GET_CPUMAP(cpumaps, maplen, v); virBitmapPtr map = NULL; - if (virProcessGetAffinity(priv->vcpupids[v], - &map, hostcpus) < 0) + if (!(map = virProcessGetAffinity(priv->vcpupids[v]))) return -1; virBitmapToDataBuf(map, cpumap, maplen); @@ -5727,7 +5726,7 @@ qemuDomainGetIOThreadsLive(virQEMUDriverPtr driver, goto endjob; info_ret[i]->iothread_id = iothreads[i]->iothread_id; - if (virProcessGetAffinity(iothreads[i]->thread_id, &map, hostcpus) < 0) + if (!(map = virProcessGetAffinity(iothreads[i]->thread_id))) goto endjob; if (virBitmapToData(map, &info_ret[i]->cpumap, diff --git a/src/util/virprocess.c b/src/util/virprocess.c index 501569f..a38cb75 100644 --- a/src/util/virprocess.c +++ b/src/util/virprocess.c @@ -468,71 +468,60 @@ int virProcessSetAffinity(pid_t pid, virBitmapPtr map) return 0; } -int virProcessGetAffinity(pid_t pid, - virBitmapPtr *map, - int maxcpu) +virBitmapPtr +virProcessGetAffinity(pid_t pid) { size_t i; -# ifdef CPU_ALLOC - /* New method dynamically allocates cpu mask, allowing unlimted cpus */ - int numcpus = 1024; - size_t masklen; cpu_set_t *mask; + size_t masklen; + virBitmapPtr ret = NULL; - /* Not only may the statically allocated cpu_set_t be too small, - * but there is no way to ask the kernel what size is large enough. - * So you have no option but to pick a size, try, catch EINVAL, - * enlarge, and re-try. - * - * http://lkml.org/lkml/2009/7/28/620 - */ - realloc: - masklen = CPU_ALLOC_SIZE(numcpus); - mask = CPU_ALLOC(numcpus); +# ifdef CPU_ALLOC + /* 262144 cpus ought to be enough for anyone */ + masklen = CPU_ALLOC_SIZE(1024 << 8); + mask = CPU_ALLOC(1024 << 8); if (!mask) { virReportOOMError(); - return -1; + return NULL; } CPU_ZERO_S(masklen, mask); +# else + if (VIR_ALLOC(mask) < 0) + return NULL; + + masklen = sizeof(*mask); + CPU_ZERO(mask); +# endif + if (sched_getaffinity(pid, masklen, mask) < 0) { - CPU_FREE(mask); - if (errno == EINVAL && - numcpus < (1024 << 8)) { /* 262144 cpus ought to be enough for anyone */ - numcpus = numcpus << 2; - goto realloc; - } virReportSystemError(errno, _("cannot get CPU affinity of process %d"), pid); - return -1; + goto cleanup; } - *map = virBitmapNew(maxcpu); - if (!*map) - return -1; + if (!(ret = virBitmapNew(masklen * 8))) + goto cleanup; - for (i = 0; i < maxcpu; i++) + for (i = 0; i < masklen * 8; i++) { +# ifdef CPU_ALLOC if (CPU_ISSET_S(i, masklen, mask)) - ignore_value(virBitmapSetBit(*map, i)); - CPU_FREE(mask); + ignore_value(virBitmapSetBit(ret, i)); # else - /* Legacy method uses a fixed size cpu mask, only allows up to 1024 cpus */ - cpu_set_t mask; - - CPU_ZERO(&mask); - if (sched_getaffinity(pid, sizeof(mask), &mask) < 0) { - virReportSystemError(errno, - _("cannot get CPU affinity of process %d"), pid); - return -1; + if (CPU_ISSET(i, mask)) + ignore_value(virBitmapSetBit(ret, i)); +# endif } - for (i = 0; i < maxcpu; i++) - if (CPU_ISSET(i, &mask)) - ignore_value(virBitmapSetBit(*map, i)); + cleanup: +# ifdef CPU_ALLOC + CPU_FREE(mask); +# else + VIR_FREE(mask); # endif - return 0; + return ret; } #elif defined(HAVE_BSD_CPU_AFFINITY) @@ -562,29 +551,29 @@ int virProcessSetAffinity(pid_t pid, return 0; } -int virProcessGetAffinity(pid_t pid, - virBitmapPtr *map, - int maxcpu) +virBitmapPtr +virProcessGetAffinity(pid_t pid) { size_t i; cpuset_t mask; - - if (!(*map = virBitmapNew(maxcpu))) - return -1; + virBitmapPtr ret = NULL; CPU_ZERO(&mask); if (cpuset_getaffinity(CPU_LEVEL_WHICH, CPU_WHICH_PID, pid, sizeof(mask), &mask) != 0) { virReportSystemError(errno, _("cannot get CPU affinity of process %d"), pid); - return -1; + return NULL; } - for (i = 0; i < maxcpu; i++) + if (!(*map = virBitmapNew(sizeof(mask) * 8))) + return NULL; + + for (i = 0; i < sizeof(mask) * 8; i++) if (CPU_ISSET(i, &mask)) - ignore_value(virBitmapSetBit(*map, i)); + ignore_value(virBitmapSetBit(ret, i)); - return 0; + return ret; } #else /* HAVE_SCHED_GETAFFINITY */ @@ -597,13 +586,12 @@ int virProcessSetAffinity(pid_t pid ATTRIBUTE_UNUSED, return -1; } -int virProcessGetAffinity(pid_t pid ATTRIBUTE_UNUSED, - virBitmapPtr *map ATTRIBUTE_UNUSED, - int maxcpu ATTRIBUTE_UNUSED) +virBitmapPtr +virProcessGetAffinity(pid_t pid ATTRIBUTE_UNUSED) { virReportSystemError(ENOSYS, "%s", _("Process CPU affinity is not supported on this platform")); - return -1; + return NULL; } #endif /* HAVE_SCHED_GETAFFINITY */ diff --git a/src/util/virprocess.h b/src/util/virprocess.h index c812882..1b98493 100644 --- a/src/util/virprocess.h +++ b/src/util/virprocess.h @@ -58,9 +58,7 @@ int virProcessKillPainfully(pid_t pid, bool force); int virProcessSetAffinity(pid_t pid, virBitmapPtr map); -int virProcessGetAffinity(pid_t pid, - virBitmapPtr *map, - int maxcpu); +virBitmapPtr virProcessGetAffinity(pid_t pid); int virProcessGetStartTime(pid_t pid, unsigned long long *timestamp); -- 2.4.1

1 0

[libvirt] [PATCH] virsh: Fix Ctrl-C behavior when watching a job
by Jiri Denemark 03 Jun '15

03 Jun '15

When watching a job (save, managedsave, dump, migrate) virsh spawns a thread to call the appropriate API and waits for the result while watching for interruption signals (SIGINT, Ctrl-C on the terminal). Whenever such signal is caught, virsh calls virDomainAbortJob, stops waiting for the job, and returns the result of virDomainAbortJob. This is wrong because the job might have finished in the meantime or it might have been cancelled by someone else and virsh would just report the failure to abort the job. However, we are not interested in the virDomainAbortJob's result at all, we need to keep waiting for the main job to finish and report its result instead. https://bugzilla.redhat.com/show_bug.cgi?id=1131755 Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com> --- tools/virsh-domain.c | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/tools/virsh-domain.c b/tools/virsh-domain.c index fc4d1fc..044b088 100644 --- a/tools/virsh-domain.c +++ b/tools/virsh-domain.c @@ -4234,12 +4234,9 @@ vshWatchJob(vshControl *ctl, if (ret > 0) { if (pollfd[1].revents & POLLIN && saferead(STDIN_FILENO, &retchar, sizeof(retchar)) > 0) { - if (vshTTYIsInterruptCharacter(ctl, retchar)) { + if (vshTTYIsInterruptCharacter(ctl, retchar)) virDomainAbortJob(dom); - goto cleanup; - } else { - continue; - } + continue; } if (pollfd[0].revents & POLLIN && @@ -4259,9 +4256,8 @@ vshWatchJob(vshControl *ctl, if (intCaught) { virDomainAbortJob(dom); intCaught = 0; - } else { - continue; } + continue; } goto cleanup; } -- 2.4.1

2 2