- Devel - libvirt List Archives

[libvirt] [PATCH v2 0/3] libxl: tunnelled migration support
by Joao Martins 15 Feb '17

15 Feb '17

Hey! Presented herewith is take 2 from tunnelled migration addressing all previous comments. Changelog in individual patches (patch 1 and 2 are small refactorings suggested in v1) Despite being functional changes mostly I had a quick round of testing too. Thanks, Joao Bob Liu (1): libxl: add tunnelled migration support Joao Martins (2): libxl: refactor libxlDomainMigrationPrepare libxl: streamline top-level migrate functions src/libxl/libxl_driver.c | 79 ++++++++-- src/libxl/libxl_migration.c | 372 +++++++++++++++++++++++++++++++++++++------- src/libxl/libxl_migration.h | 9 ++ 3 files changed, 393 insertions(+), 67 deletions(-) -- 2.1.4

2 9

[libvirt] [PATCH go] domain.go: construct cpumaps correctly for CPU pinning verbs
by Leonid Podolny 14 Feb '17

14 Feb '17

In PinVcpu(), PinVcpuFlags(), PinEmulator() and PinIOThread() there is an almost identical code that converts []bool into a bitmask. It calculates the location in the bitmask and then sets it always to 1, instead of looking at the actual bool value. --- domain.go | 16 ++++++++++++---- 1 file changed, 12 insertions(+), 4 deletions(-) diff --git a/domain.go b/domain.go index 5482f1a..9a24bc5 100644 --- a/domain.go +++ b/domain.go @@ -1750,7 +1750,9 @@ func (d *Domain) PinVcpu(vcpu uint, cpuMap []bool) error { if cpuMap[i] { byte := i / 8 bit := i % 8 - ccpumap[byte] |= (1 << uint(bit)) + if cpuMap[i] { + ccpumap[byte] |= (1 << uint(bit)) + } } } @@ -1770,7 +1772,9 @@ func (d *Domain) PinVcpuFlags(vcpu uint, cpuMap []bool, flags DomainModification if cpuMap[i] { byte := (i + 7) / 8 bit := i % 8 - ccpumap[byte] |= (1 << uint(bit)) + if cpuMap[i] { + ccpumap[byte] |= (1 << uint(bit)) + } } } @@ -3970,7 +3974,9 @@ func (d *Domain) PinEmulator(cpumap []bool, flags DomainModificationImpact) erro byte := i / 8 bit := i % 8 - ccpumaps[byte] |= (1 << uint(bit)) + if cpumap[i] { + ccpumaps[byte] |= (1 << uint(bit)) + } } ret := C.virDomainPinEmulator(d.ptr, &ccpumaps[0], C.int(maplen), C.uint(flags)) @@ -3992,7 +3998,9 @@ func (d *Domain) PinIOThread(iothreadid uint, cpumap []bool, flags DomainModific byte := i / 8 bit := i % 8 - ccpumaps[byte] |= (1 << uint(bit)) + if cpumap[i] { + ccpumaps[byte] |= (1 << uint(bit)) + } } ret := C.virDomainPinIOThreadCompat(d.ptr, C.uint(iothreadid), &ccpumaps[0], C.int(maplen), C.uint(flags)) -- 2.11.0

1 1

[libvirt] [PATCH 0/4] Fix private /dev file access issues
by Andrea Bolognani 14 Feb '17

14 Feb '17

Several heads were banged against several walls while trying to figure this out. No animals were harmed in the writing of this series, though. Andrea Bolognani (4): configure: Move ACL checks to a separate file configure: Make ACL mandatory when building the QEMU driver spec: Require libacl and its headers qemu: Call chmod() after mknod() configure.ac | 12 +++--------- libvirt.spec.in | 4 ++++ m4/virt-acl.m4 | 39 +++++++++++++++++++++++++++++++++++++++ src/qemu/qemu_domain.c | 10 ++++++++++ 4 files changed, 56 insertions(+), 9 deletions(-) create mode 100644 m4/virt-acl.m4 -- 2.7.4

3 16

[libvirt] [v5 0/9] Support cache tune in libvirt
by Eli Qiao 14 Feb '17

14 Feb '17

Addressed comment from v4 -> v5: Marcelo: * Several typos * Use flock instead of virFileLock Addressed comment from v3 -> v4: Daniel & Marcelo: * Added concurrence support Addressed comment from v2 -> v3: Daniel: * Fixed coding style, passed `make check` and `make syntax-check` * Variables renaming and move from header file to c file. * For locking/mutex support, no progress. There are some discussion from mailing list, but I can not find a better way to add locking support without performance impact. I'll explain the process and please help to advice what shoud we do. VM create: 1) Get the cache left value on each bank of the host. This should be shared amount all VMs. 2) Calculate the schemata on the bank based on all created resctrl domain's schemata 3) Calculate the default schemata by scaning all domain's schemata. 4) Flush default schemata to /sys/fs/resctrl/schemata VM destroy: 1) Remove the resctrl domain of that VM 2) Recalculate default schemata 3) Flush default schemata to /sys/fs/resctrl/schemata The key point is that all VMs shares /sys/fs/resctrl/schemata, and when a VM create a resctrl domain, the schemata of that VM depends on the default schemata and all other exsited schematas. So a global mutex is reqired. Before calculate a schemata or update default schemata, libvirt should gain this global mutex. I will try to think more about how to support this gracefully in next patch set. Marcelo: * Added vcpu support for cachetune, this will allow user to define which vcpu using which cache allocation bank. <cachetune id='0' host_id=0 size='3072' unit='KiB' vcpus='0,1'/> vcpus is a cpumap, the vcpu pids will be added to tasks file * Added cdp compatible, user can specify l3 cache even host enable cdp. See patch 8. On a cdp enabled host, specify l3code/l3data by <cachetune id='0' host_id='0' type='l3' size='3072' unit='KiB'/> This will create a schemata like: L3data:0=0xff00;... L3code:0=0xff00;... * Would you please help to test if the functions work. Martin: * Xml test case, I have no time to work on this yet, would you please show me an example, would like to amend it later. This series patches are for supportting CAT featues, which also called cache tune in libvirt. First to expose cache information which could be tuned in capabilites XML. Then add new domain xml element support to add cacahe bank which will apply on this libvirt domain. This series patches add a util file `resctrl.c/h`, an interface to talk with linux kernel's system fs. There are still one TODO left: 1. Expose a new public interface to get free cache information. 2. Expose a new public interface to set cachetune lively. Some discussion about this feature support can be found from: https://www.redhat.com/archives/libvir-list/2017-January/msg00644.html Eli Qiao (9): Resctrl: Add some utils functions Resctrl: expose cache information to capabilities Resctrl: Add new xml element to support cache tune Resctrl: Add private interface to set cachebanks Qemu: Set cache banks Resctrl: enable l3code/l3data Resctrl: Make sure l3data/l3code are pairs Resctrl: Compatible mode for cdp enabled Resctrl: concurrence support docs/schemas/domaincommon.rng | 46 ++ include/libvirt/virterror.h | 1 + po/POTFILES.in | 1 + src/Makefile.am | 1 + src/conf/capabilities.c | 56 ++ src/conf/capabilities.h | 23 + src/conf/domain_conf.c | 182 +++++++ src/conf/domain_conf.h | 19 + src/libvirt_private.syms | 11 + src/nodeinfo.c | 64 +++ src/nodeinfo.h | 1 + src/qemu/qemu_capabilities.c | 8 + src/qemu/qemu_driver.c | 6 + src/qemu/qemu_process.c | 53 ++ src/util/virerror.c | 1 + src/util/virresctrl.c | 1157 +++++++++++++++++++++++++++++++++++++++++ src/util/virresctrl.h | 88 ++++ 17 files changed, 1718 insertions(+) create mode 100644 src/util/virresctrl.c create mode 100644 src/util/virresctrl.h -- 1.9.1

2 10

[libvirt] [PATCH] Ensure disk names follow the disk name regex
by Nitesh Konkar 14 Feb '17

14 Feb '17

Currently disk names do not follow the (regex) /^[fhv]d[a-z]+[0-9]*$/ completely and hence one can assign disk names like vd2 etc. This patch ensures that the disk names follow the regex mentioned. Signed-off-by: Nitesh Konkar <nitkon12(a)linux.vnet.ibm.com> --- src/util/virutil.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/util/virutil.c b/src/util/virutil.c index 91178d1..2796671 100644 --- a/src/util/virutil.c +++ b/src/util/virutil.c @@ -563,7 +563,7 @@ int virDiskNameParse(const char *name, int *disk, int *partition) } } - if (!ptr) + if (!ptr || !c_islower(*ptr)) return -1; for (i = 0; *ptr; i++) { -- 2.1.0

2 3

[libvirt] [PATCHv2] util: fix off-by-one when expanding a bitmap
by Ján Tomko 14 Feb '17

14 Feb '17

To make sure bit 'b' fits into the bitmap, we need to allocate b+1 bits, since we number from 0. Adjust the bitmap test to set a bit at a multiple of 16. That way the test fails without this fix, because the VIR_REALLOC call clears the newly added memory even if the original pointer has not changed. --- src/util/virbitmap.c | 2 +- tests/virbitmaptest.c | 6 +++--- 2 files changed, 4 insertions(+), 4 deletions(-) v2: use a multiple of 16 instead of just 8 to actually reproduce the failure in the test. diff --git a/src/util/virbitmap.c b/src/util/virbitmap.c index 0c04f1a..1b47d74 100644 --- a/src/util/virbitmap.c +++ b/src/util/virbitmap.c @@ -187,7 +187,7 @@ int virBitmapSetBit(virBitmapPtr bitmap, size_t b) */ static int virBitmapExpand(virBitmapPtr map, size_t b) { - size_t new_len = VIR_DIV_UP(b, VIR_BITMAP_BITS_PER_UNIT); + size_t new_len = VIR_DIV_UP(b + 1, VIR_BITMAP_BITS_PER_UNIT); /* resize the memory if necessary */ if (map->map_len < new_len) { diff --git a/tests/virbitmaptest.c b/tests/virbitmaptest.c index a17ef82..3ee07ff 100644 --- a/tests/virbitmaptest.c +++ b/tests/virbitmaptest.c @@ -639,15 +639,15 @@ test12(const void *opaque ATTRIBUTE_UNUSED) TEST_MAP(0, ""); - if (virBitmapSetBitExpand(map, 100) < 0) + if (virBitmapSetBitExpand(map, 128) < 0) goto cleanup; - TEST_MAP(101, "100"); + TEST_MAP(129, "128"); if (virBitmapClearBitExpand(map, 150) < 0) goto cleanup; - TEST_MAP(151, "100"); + TEST_MAP(151, "128"); virBitmapFree(map); if (virBitmapParseUnlimited("34,1023", &map) < 0) -- 2.10.2

2 1

[libvirt] [PATCH] qemu_monitor_json: Properly check GetArray return value
by Jiri Denemark 14 Feb '17

14 Feb '17

Commit 2a8d40f4ec refactored qemuMonitorJSONGetCPUx86Data and replaced virJSONValueObjectGet(reply, "return") with virJSONValueObjectGetArray. While the former is guaranteed to always return non-NULL pointer the latter may return NULL if the returned JSON object is not an array. Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com> --- src/qemu/qemu_monitor_json.c | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/src/qemu/qemu_monitor_json.c b/src/qemu/qemu_monitor_json.c index e30b72cd4..1d281af48 100644 --- a/src/qemu/qemu_monitor_json.c +++ b/src/qemu/qemu_monitor_json.c @@ -6554,7 +6554,7 @@ qemuMonitorJSONParseCPUx86Features(virJSONValuePtr data, ssize_t n; int ret = -1; - if ((n = virJSONValueArraySize(data)) < 0) { + if (!data || (n = virJSONValueArraySize(data)) < 0) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("invalid array of CPUID features")); return -1; @@ -6644,9 +6644,8 @@ qemuMonitorJSONCheckCPUx86(qemuMonitorPtr mon) if (qemuMonitorJSONCheckError(cmd, reply)) goto cleanup; - data = virJSONValueObjectGetArray(reply, "return"); - - if ((n = virJSONValueArraySize(data)) < 0) { + if (!(data = virJSONValueObjectGetArray(reply, "return")) || + (n = virJSONValueArraySize(data)) < 0) { virReportError(VIR_ERR_INTERNAL_ERROR, "%s", _("qom-list reply data was not an array")); goto cleanup; -- 2.11.1

2 1

[libvirt] [PATCH] qemu: Filter ARAT CPU feature from host-model
by Jiri Denemark 14 Feb '17

14 Feb '17

ARAT feature was first introduced in QEMU 2.4.0, which means host-model CPU mode is unusable with QEMU < 2.4.0 on any host CPU which supports ARAT. Let's not include this feature in host-model CPUs unless a user explicitly asks for it. Signed-off-by: Jiri Denemark <jdenemar(a)redhat.com> --- Notes: We will do this properly in the future since we will ask QEMU what CPU features it understands and what it thinks about host CPU. However, the required QMP interface is not upstream yet. src/qemu/qemu_capabilities.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/qemu/qemu_capabilities.c b/src/qemu/qemu_capabilities.c index cfd090c3f..2da4c76ab 100644 --- a/src/qemu/qemu_capabilities.c +++ b/src/qemu/qemu_capabilities.c @@ -2959,7 +2959,8 @@ virQEMUCapsCPUFilterFeatures(const char *name, { if (STREQ(name, "cmt") || STREQ(name, "mbm_total") || - STREQ(name, "mbm_local")) + STREQ(name, "mbm_local") || + STREQ(name, "arat")) return false; return true; -- 2.11.0.rc2

2 1

[libvirt] [PATCHv2] qemu: Emit domain events for all virtio-serial channels
by Matt Broadstone 14 Feb '17

14 Feb '17

Presently domain events are emitted for the "agent lifecycle" which is a specialization on virtio-serial events specific to the channel named "org.qemu.guest_agent.0". This patch adds a generic event for "channel lifecycles", which emit state change events for all attached channels. --- daemon/remote.c | 42 +++++++++++++++++ examples/object-events/event-test.c | 57 ++++++++++++++++++++++++ include/libvirt/libvirt-domain.h | 44 ++++++++++++++++++ src/conf/domain_event.c | 89 +++++++++++++++++++++++++++++++++++++ src/conf/domain_event.h | 12 +++++ src/libvirt_private.syms | 2 + src/qemu/qemu_driver.c | 5 +++ src/qemu/qemu_process.c | 6 +++ src/remote/remote_driver.c | 32 +++++++++++++ src/remote/remote_protocol.x | 17 ++++++- src/remote_protocol-structs | 7 +++ tools/virsh-domain.c | 35 +++++++++++++++ 12 files changed, 347 insertions(+), 1 deletion(-) diff --git a/daemon/remote.c b/daemon/remote.c index e414f92..25b32f2 100644 --- a/daemon/remote.c +++ b/daemon/remote.c @@ -1086,6 +1086,47 @@ remoteRelayDomainEventAgentLifecycle(virConnectPtr conn, static int +remoteRelayDomainEventChannelLifecycle(virConnectPtr conn, + virDomainPtr dom, + const char *channelName, + int state, + int reason, + void *opaque) +{ + daemonClientEventCallbackPtr callback = opaque; + remote_domain_event_callback_channel_lifecycle_msg data; + + if (callback->callbackID < 0 || + !remoteRelayDomainEventCheckACL(callback->client, conn, dom)) + return -1; + + VIR_DEBUG("Relaying domain channel lifecycle event %s %d, callback %d, " + " name: %s, state %d, reason %d", + dom->name, dom->id, callback->callbackID, channelName, state, reason); + + /* build return data */ + memset(&data, 0, sizeof(data)); + data.callbackID = callback->callbackID; + make_nonnull_domain(&data.dom, dom); + + if (VIR_STRDUP(data.channelName, channelName) < 0) + goto error; + data.state = state; + data.reason = reason; + + remoteDispatchObjectEventSend(callback->client, remoteProgram, + REMOTE_PROC_DOMAIN_EVENT_CALLBACK_CHANNEL_LIFECYCLE, + (xdrproc_t)xdr_remote_domain_event_callback_channel_lifecycle_msg, + &data); + + return 0; + error: + VIR_FREE(data.channelName); + return -1; +} + + +static int remoteRelayDomainEventDeviceAdded(virConnectPtr conn, virDomainPtr dom, const char *devAlias, @@ -1248,6 +1289,7 @@ static virConnectDomainEventGenericCallback domainEventCallbacks[] = { VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventMigrationIteration), VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventJobCompleted), VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventDeviceRemovalFailed), + VIR_DOMAIN_EVENT_CALLBACK(remoteRelayDomainEventChannelLifecycle) }; verify(ARRAY_CARDINALITY(domainEventCallbacks) == VIR_DOMAIN_EVENT_ID_LAST); diff --git a/examples/object-events/event-test.c b/examples/object-events/event-test.c index 730cb8b..da023eb 100644 --- a/examples/object-events/event-test.c +++ b/examples/object-events/event-test.c @@ -337,6 +337,46 @@ guestAgentLifecycleEventReasonToString(int event) return "unknown"; } + +static const char * +guestChannelLifecycleEventStateToString(int event) +{ + switch ((virConnectDomainEventChannelLifecycleState) event) { + case VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_STATE_DISCONNECTED: + return "Disconnected"; + + case VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_STATE_CONNECTED: + return "Connected"; + + case VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_STATE_LAST: + break; + } + + return "unknown"; +} + + +static const char * +guestChannelLifecycleEventReasonToString(int event) +{ + switch ((virConnectDomainEventChannelLifecycleReason) event) { + case VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_REASON_UNKNOWN: + return "Unknown"; + + case VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_REASON_DOMAIN_STARTED: + return "Domain started"; + + case VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_REASON_CHANNEL: + return "Channel event"; + + case VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_REASON_LAST: + break; + } + + return "unknown"; +} + + static const char * storagePoolEventToString(int event) { @@ -797,6 +837,22 @@ myDomainEventAgentLifecycleCallback(virConnectPtr conn ATTRIBUTE_UNUSED, return 0; } +static int +myDomainEventChannelLifecycleCallback(virConnectPtr conn ATTRIBUTE_UNUSED, + virDomainPtr dom, + const char *channelName, + int state, + int reason, + void *opaque ATTRIBUTE_UNUSED) +{ + printf("%s EVENT: Domain %s(%d) guest channel(%s) state changed: %s reason: %s\n", + __func__, virDomainGetName(dom), virDomainGetID(dom), channelName, + guestChannelLifecycleEventStateToString(state), + guestChannelLifecycleEventReasonToString(reason)); + + return 0; +} + static int myDomainEventDeviceAddedCallback(virConnectPtr conn ATTRIBUTE_UNUSED, @@ -971,6 +1027,7 @@ struct domainEventData domainEvents[] = { DOMAIN_EVENT(VIR_DOMAIN_EVENT_ID_MIGRATION_ITERATION, myDomainEventMigrationIterationCallback), DOMAIN_EVENT(VIR_DOMAIN_EVENT_ID_JOB_COMPLETED, myDomainEventJobCompletedCallback), DOMAIN_EVENT(VIR_DOMAIN_EVENT_ID_DEVICE_REMOVAL_FAILED, myDomainEventDeviceRemovalFailedCallback), + DOMAIN_EVENT(VIR_DOMAIN_EVENT_ID_CHANNEL_LIFECYCLE, myDomainEventChannelLifecycleCallback) }; struct storagePoolEventData { diff --git a/include/libvirt/libvirt-domain.h b/include/libvirt/libvirt-domain.h index 5f50660..9a5c664 100644 --- a/include/libvirt/libvirt-domain.h +++ b/include/libvirt/libvirt-domain.h @@ -3965,6 +3965,49 @@ typedef void (*virConnectDomainEventAgentLifecycleCallback)(virConnectPtr conn, int reason, void *opaque); +typedef enum { + VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_STATE_CONNECTED = 1, /* channel connected */ + VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_STATE_DISCONNECTED = 2, /* channel disconnected */ + +# ifdef VIR_ENUM_SENTINELS + VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_STATE_LAST +# endif +} virConnectDomainEventChannelLifecycleState; + +typedef enum { + VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_REASON_UNKNOWN = 0, /* unknown state change reason */ + VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_REASON_DOMAIN_STARTED = + VIR_CONNECT_DOMAIN_EVENT_AGENT_LIFECYCLE_REASON_DOMAIN_STARTED, /* state changed due to domain start */ + VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_REASON_CHANNEL = + VIR_CONNECT_DOMAIN_EVENT_AGENT_LIFECYCLE_REASON_CHANNEL, /* channel state changed */ + +# ifdef VIR_ENUM_SENTINELS + VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_REASON_LAST +# endif +} virConnectDomainEventChannelLifecycleReason; + +/** + * virConnectDomainEventChannelLifecycleCallback: + * @conn: connection object + * @dom: domain on which the event occurred + * @channelName: the name of the channel on which the event occurred + * @state: new state of the guest channel, one of virConnectDomainEventChannelLifecycleState + * @reason: reason for state change; one of virConnectDomainEventChannelLifecycleReason + * @opaque: application specified data + * + * This callback occurs when libvirt detects a change in the state of a guest + * serial channel. The hypervisor must support serial notification, and this is + * currently limited to modern versions of qemu. + * + * The callback signature to use when registering for an event of type + * VIR_DOMAIN_EVENT_ID_CHANNEL_LIFECYCLE with virConnectDomainEventRegisterAny() + */ +typedef void (*virConnectDomainEventChannelLifecycleCallback)(virConnectPtr conn, + virDomainPtr dom, + const char *channelName, + int state, + int reason, + void *opaque); /** * VIR_DOMAIN_EVENT_CALLBACK: @@ -4006,6 +4049,7 @@ typedef enum { VIR_DOMAIN_EVENT_ID_MIGRATION_ITERATION = 20, /* virConnectDomainEventMigrationIterationCallback */ VIR_DOMAIN_EVENT_ID_JOB_COMPLETED = 21, /* virConnectDomainEventJobCompletedCallback */ VIR_DOMAIN_EVENT_ID_DEVICE_REMOVAL_FAILED = 22, /* virConnectDomainEventDeviceRemovalFailedCallback */ + VIR_DOMAIN_EVENT_ID_CHANNEL_LIFECYCLE = 23, /* virConnectDomainEventChannelLifecycleCallback */ # ifdef VIR_ENUM_SENTINELS VIR_DOMAIN_EVENT_ID_LAST diff --git a/src/conf/domain_event.c b/src/conf/domain_event.c index 63ae9e1..f971a0d 100644 --- a/src/conf/domain_event.c +++ b/src/conf/domain_event.c @@ -55,6 +55,7 @@ static virClassPtr virDomainEventPMClass; static virClassPtr virDomainQemuMonitorEventClass; static virClassPtr virDomainEventTunableClass; static virClassPtr virDomainEventAgentLifecycleClass; +static virClassPtr virDomainEventChannelLifecycleClass; static virClassPtr virDomainEventDeviceAddedClass; static virClassPtr virDomainEventMigrationIterationClass; static virClassPtr virDomainEventJobCompletedClass; @@ -75,6 +76,7 @@ static void virDomainEventPMDispose(void *obj); static void virDomainQemuMonitorEventDispose(void *obj); static void virDomainEventTunableDispose(void *obj); static void virDomainEventAgentLifecycleDispose(void *obj); +static void virDomainEventChannelLifecycleDispose(void *obj); static void virDomainEventDeviceAddedDispose(void *obj); static void virDomainEventMigrationIterationDispose(void *obj); static void virDomainEventJobCompletedDispose(void *obj); @@ -241,6 +243,16 @@ struct _virDomainEventAgentLifecycle { typedef struct _virDomainEventAgentLifecycle virDomainEventAgentLifecycle; typedef virDomainEventAgentLifecycle *virDomainEventAgentLifecyclePtr; +struct _virDomainEventChannelLifecycle { + virDomainEvent parent; + + char *channelName; + int state; + int reason; +}; +typedef struct _virDomainEventChannelLifecycle virDomainEventChannelLifecycle; +typedef virDomainEventChannelLifecycle *virDomainEventChannelLifecyclePtr; + struct _virDomainEventMigrationIteration { virDomainEvent parent; @@ -367,6 +379,12 @@ virDomainEventsOnceInit(void) sizeof(virDomainEventAgentLifecycle), virDomainEventAgentLifecycleDispose))) return -1; + if (!(virDomainEventChannelLifecycleClass = + virClassNew(virDomainEventClass, + "virDomainEventChannelLifecycle", + sizeof(virDomainEventChannelLifecycle), + virDomainEventChannelLifecycleDispose))) + return -1; if (!(virDomainEventMigrationIterationClass = virClassNew(virDomainEventClass, "virDomainEventMigrationIteration", @@ -557,6 +575,15 @@ virDomainEventAgentLifecycleDispose(void *obj) }; static void +virDomainEventChannelLifecycleDispose(void *obj) +{ + virDomainEventChannelLifecyclePtr event = obj; + VIR_DEBUG("obj=%p", event); + + VIR_FREE(event->channelName); +}; + +static void virDomainEventMigrationIterationDispose(void *obj) { virDomainEventMigrationIterationPtr event = obj; @@ -1460,6 +1487,56 @@ virDomainEventAgentLifecycleNewFromDom(virDomainPtr dom, } static virObjectEventPtr +virDomainEventChannelLifecycleNew(int id, + const char *name, + const unsigned char *uuid, + const char *channelName, + int state, + int reason) +{ + virDomainEventChannelLifecyclePtr ev; + + if (virDomainEventsInitialize() < 0) + return NULL; + + if (!(ev = virDomainEventNew(virDomainEventChannelLifecycleClass, + VIR_DOMAIN_EVENT_ID_CHANNEL_LIFECYCLE, + id, name, uuid))) + return NULL; + + if (VIR_STRDUP(ev->channelName, channelName) < 0) { + virObjectUnref(ev); + return NULL; + } + + ev->state = state; + ev->reason = reason; + + return (virObjectEventPtr)ev; +} + +virObjectEventPtr +virDomainEventChannelLifecycleNewFromObj(virDomainObjPtr obj, + const char *channelName, + int state, + int reason) +{ + return virDomainEventChannelLifecycleNew(obj->def->id, obj->def->name, + obj->def->uuid, channelName, state, reason); +} + +virObjectEventPtr +virDomainEventChannelLifecycleNewFromDom(virDomainPtr dom, + const char *channelName, + int state, + int reason) +{ + return virDomainEventChannelLifecycleNew(dom->id, dom->name, dom->uuid, + channelName, state, reason); +} + + +static virObjectEventPtr virDomainEventMigrationIterationNew(int id, const char *name, const unsigned char *uuid, @@ -1812,6 +1889,18 @@ virDomainEventDispatchDefaultFunc(virConnectPtr conn, goto cleanup; } + case VIR_DOMAIN_EVENT_ID_CHANNEL_LIFECYCLE: + { + virDomainEventChannelLifecyclePtr channelLifecycleEvent; + channelLifecycleEvent = (virDomainEventChannelLifecyclePtr)event; + ((virConnectDomainEventChannelLifecycleCallback)cb)(conn, dom, + channelLifecycleEvent->channelName, + channelLifecycleEvent->state, + channelLifecycleEvent->reason, + cbopaque); + goto cleanup; + } + case VIR_DOMAIN_EVENT_ID_DEVICE_ADDED: { virDomainEventDeviceAddedPtr deviceAddedEvent; diff --git a/src/conf/domain_event.h b/src/conf/domain_event.h index 54fa879..3a689b3 100644 --- a/src/conf/domain_event.h +++ b/src/conf/domain_event.h @@ -217,6 +217,18 @@ virDomainEventAgentLifecycleNewFromDom(virDomainPtr dom, int reason); virObjectEventPtr +virDomainEventChannelLifecycleNewFromObj(virDomainObjPtr obj, + const char *channelName, + int state, + int reason); + +virObjectEventPtr +virDomainEventChannelLifecycleNewFromDom(virDomainPtr dom, + const char *channelName, + int state, + int reason); + +virObjectEventPtr virDomainEventMigrationIterationNewFromObj(virDomainObjPtr obj, int iteration); diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms index 74dd527..e259687 100644 --- a/src/libvirt_private.syms +++ b/src/libvirt_private.syms @@ -535,6 +535,8 @@ virDomainEventBlockJob2NewFromDom; virDomainEventBlockJob2NewFromObj; virDomainEventBlockJobNewFromDom; virDomainEventBlockJobNewFromObj; +virDomainEventChannelLifecycleNewFromDom; +virDomainEventChannelLifecycleNewFromObj; virDomainEventControlErrorNewFromDom; virDomainEventControlErrorNewFromObj; virDomainEventDeviceAddedNewFromDom; diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c index 38c8414..b464412 100644 --- a/src/qemu/qemu_driver.c +++ b/src/qemu/qemu_driver.c @@ -4407,6 +4407,7 @@ processSerialChangedEvent(virQEMUDriverPtr driver, virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver); virDomainChrDeviceState newstate; virObjectEventPtr event = NULL; + virObjectEventPtr channelEvent = NULL; virDomainDeviceDef dev; qemuDomainObjPrivatePtr priv = vm->privateData; int rc; @@ -4482,6 +4483,10 @@ processSerialChangedEvent(virQEMUDriverPtr driver, qemuDomainEventQueue(driver, event); } + channelEvent = virDomainEventChannelLifecycleNewFromObj(vm, dev.data.chr->target.name, newstate, + VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_REASON_CHANNEL); + qemuDomainEventQueue(driver, channelEvent); + endjob: qemuDomainObjEndJob(driver, vm); diff --git a/src/qemu/qemu_process.c b/src/qemu/qemu_process.c index 1b67aee..31b5028 100644 --- a/src/qemu/qemu_process.c +++ b/src/qemu/qemu_process.c @@ -1931,6 +1931,7 @@ qemuProcessRefreshChannelVirtioState(virQEMUDriverPtr driver, int agentReason = VIR_CONNECT_DOMAIN_EVENT_AGENT_LIFECYCLE_REASON_CHANNEL; qemuMonitorChardevInfoPtr entry; virObjectEventPtr event = NULL; + virObjectEventPtr channelEvent = NULL; char id[32]; if (booted) @@ -1958,6 +1959,11 @@ qemuProcessRefreshChannelVirtioState(virQEMUDriverPtr driver, agentReason))) qemuDomainEventQueue(driver, event); + + channelEvent = + virDomainEventChannelLifecycleNewFromObj(vm, chr->target.name, entry->state, agentReason); + qemuDomainEventQueue(driver, channelEvent); + chr->state = entry->state; } } diff --git a/src/remote/remote_driver.c b/src/remote/remote_driver.c index a3cd7cd..eb783cb 100644 --- a/src/remote/remote_driver.c +++ b/src/remote/remote_driver.c @@ -345,6 +345,11 @@ remoteDomainBuildEventCallbackAgentLifecycle(virNetClientProgramPtr prog, void *evdata, void *opaque); static void +remoteDomainBuildEventCallbackChannelLifecycle(virNetClientProgramPtr prog, + virNetClientPtr client, + void *evdata, void *opaque); + +static void remoteDomainBuildEventCallbackMigrationIteration(virNetClientProgramPtr prog, virNetClientPtr client, void *evdata, void *opaque); @@ -574,6 +579,10 @@ static virNetClientProgramEvent remoteEvents[] = { remoteNodeDeviceBuildEventUpdate, sizeof(remote_node_device_event_update_msg), (xdrproc_t)xdr_remote_node_device_event_update_msg }, + { REMOTE_PROC_DOMAIN_EVENT_CALLBACK_CHANNEL_LIFECYCLE, + remoteDomainBuildEventCallbackChannelLifecycle, + sizeof(remote_domain_event_callback_channel_lifecycle_msg), + (xdrproc_t)xdr_remote_domain_event_callback_channel_lifecycle_msg }, }; static void @@ -5152,6 +5161,29 @@ remoteDomainBuildEventCallbackAgentLifecycle(virNetClientProgramPtr prog ATTRIBU static void +remoteDomainBuildEventCallbackChannelLifecycle(virNetClientProgramPtr prog ATTRIBUTE_UNUSED, + virNetClientPtr client ATTRIBUTE_UNUSED, + void *evdata, void *opaque) +{ + virConnectPtr conn = opaque; + remote_domain_event_callback_channel_lifecycle_msg *msg = evdata; + struct private_data *priv = conn->privateData; + virDomainPtr dom; + virObjectEventPtr event = NULL; + + if (!(dom = get_nonnull_domain(conn, msg->dom))) + return; + + event = virDomainEventChannelLifecycleNewFromDom(dom, msg->channelName, msg->state, + msg->reason); + + virObjectUnref(dom); + + remoteEventQueue(priv, event, msg->callbackID); +} + + +static void remoteDomainBuildEventCallbackMigrationIteration(virNetClientProgramPtr prog ATTRIBUTE_UNUSED, virNetClientPtr client ATTRIBUTE_UNUSED, void *evdata, diff --git a/src/remote/remote_protocol.x b/src/remote/remote_protocol.x index e8382dc..e5227c4 100644 --- a/src/remote/remote_protocol.x +++ b/src/remote/remote_protocol.x @@ -3242,6 +3242,15 @@ struct remote_domain_event_callback_agent_lifecycle_msg { int reason; }; +struct remote_domain_event_callback_channel_lifecycle_msg { + int callbackID; + remote_nonnull_domain dom; + + char *channelName; + int state; + int reason; +}; + struct remote_connect_get_all_domain_stats_ret { remote_domain_stats_record retStats<REMOTE_DOMAIN_LIST_MAX>; }; @@ -5934,5 +5943,11 @@ enum remote_procedure { * @generate: both * @acl: none */ - REMOTE_PROC_NODE_DEVICE_EVENT_UPDATE = 377 + REMOTE_PROC_NODE_DEVICE_EVENT_UPDATE = 377, + + /** + * @generate: both + * @acl: none + */ + REMOTE_PROC_DOMAIN_EVENT_CALLBACK_CHANNEL_LIFECYCLE = 378 }; diff --git a/src/remote_protocol-structs b/src/remote_protocol-structs index b71accc..7921016 100644 --- a/src/remote_protocol-structs +++ b/src/remote_protocol-structs @@ -2689,6 +2689,13 @@ struct remote_domain_event_callback_agent_lifecycle_msg { int state; int reason; }; +struct remote_domain_event_callback_channel_lifecycle_msg { + int callbackID; + remote_nonnull_domain dom; + remote_string channelName; + int state; + int reason; +}; struct remote_connect_get_all_domain_stats_ret { struct { u_int retStats_len; diff --git a/tools/virsh-domain.c b/tools/virsh-domain.c index 184f64d..e085358 100644 --- a/tools/virsh-domain.c +++ b/tools/virsh-domain.c @@ -12637,6 +12637,20 @@ VIR_ENUM_IMPL(virshEventAgentLifecycleReason, N_("domain started"), N_("channel event")) +VIR_ENUM_DECL(virshEventChannelLifecycleState) +VIR_ENUM_IMPL(virshEventChannelLifecycleState, + VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_STATE_LAST, + N_("unknown"), + N_("connected"), + N_("disconnected")) + +VIR_ENUM_DECL(virshEventChannelLifecycleReason) +VIR_ENUM_IMPL(virshEventChannelLifecycleReason, + VIR_CONNECT_DOMAIN_EVENT_CHANNEL_LIFECYCLE_REASON_LAST, + N_("unknown"), + N_("domain started"), + N_("channel event")) + #define UNKNOWNSTR(str) (str ? str : N_("unsupported value")) static void virshEventAgentLifecyclePrint(virConnectPtr conn ATTRIBUTE_UNUSED, @@ -12656,6 +12670,25 @@ virshEventAgentLifecyclePrint(virConnectPtr conn ATTRIBUTE_UNUSED, } static void +virshEventChannelLifecyclePrint(virConnectPtr conn ATTRIBUTE_UNUSED, + virDomainPtr dom, + const char *channelName, + int state, + int reason, + void *opaque) +{ + virBuffer buf = VIR_BUFFER_INITIALIZER; + + virBufferAsprintf(&buf, _("event 'channel-lifecycle' for domain %s: name: '%s', " + "state: '%s' reason: '%s'\n"), + virDomainGetName(dom), + channelName, + UNKNOWNSTR(virshEventChannelLifecycleStateTypeToString(state)), + UNKNOWNSTR(virshEventChannelLifecycleReasonTypeToString(reason))); + virshEventPrint(opaque, &buf); +} + +static void virshEventMigrationIterationPrint(virConnectPtr conn ATTRIBUTE_UNUSED, virDomainPtr dom, int iteration, @@ -12755,6 +12788,8 @@ static vshEventCallback vshEventCallbacks[] = { VIR_DOMAIN_EVENT_CALLBACK(virshEventJobCompletedPrint), }, { "device-removal-failed", VIR_DOMAIN_EVENT_CALLBACK(virshEventDeviceRemovalFailedPrint), }, + { "channel-lifecycle", + VIR_DOMAIN_EVENT_CALLBACK(virshEventChannelLifecyclePrint), }, }; verify(VIR_DOMAIN_EVENT_ID_LAST == ARRAY_CARDINALITY(vshEventCallbacks)); -- 2.7.4 (Apple Git-66)

2 1

[libvirt] [PATCH] qemu: Set umask before calling mknod()
by Andrea Bolognani 14 Feb '17

14 Feb '17

When we populate the private /dev that's going to be used by an isolated QEMU process, we take care all metadata matches what's in the top-level namespace: in particular, we copy the file permissions directly. However, since the permissions passed to mknod() are still affected by the active umask, we need to set it to a very permissive value before creating device nodes to avoid file access issues. Resolves: https://bugzilla.redhat.com/show_bug.cgi?id=1421036 --- src/qemu/qemu_domain.c | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/qemu/qemu_domain.c b/src/qemu/qemu_domain.c index f62bf8f..7993acc 100644 --- a/src/qemu/qemu_domain.c +++ b/src/qemu/qemu_domain.c @@ -7040,6 +7040,7 @@ qemuDomainCreateDeviceRecursive(const char *device, #ifdef WITH_SELINUX char *tcon = NULL; #endif + mode_t oldUmask = umask((mode_t) 0); if (!ttl) { virReportSystemError(ELOOP, @@ -7205,6 +7206,7 @@ qemuDomainCreateDeviceRecursive(const char *device, #ifdef WITH_SELINUX freecon(tcon); #endif + umask(oldUmask); return ret; } @@ -7678,6 +7680,7 @@ qemuDomainAttachDeviceMknodHelper(pid_t pid ATTRIBUTE_UNUSED, int ret = -1; bool delDevice = false; bool isLink = S_ISLNK(data->sb.st_mode); + mode_t oldUmask = umask((mode_t) 0); virSecurityManagerPostFork(data->driver->securityManager); @@ -7756,6 +7759,7 @@ qemuDomainAttachDeviceMknodHelper(pid_t pid ATTRIBUTE_UNUSED, freecon(data->tcon); #endif virFileFreeACLs(&data->acl); + umask(oldUmask); return ret; } -- 2.7.4

2 2