10:34 a.m.
The first round. For some reasons, I am still unable to hotplug any king of
chardev. For instance:
<console type='pty'>
<source path='/dev/pts/4'/>
<target port='0'/>
</console>
Doesn't work. On the other hand, any domain with such device coldpluged refuse
to start anyway :)
Michal Privoznik (8):
domain_conf: Introduce chardev hotplug helpers
qemu: Implement chardev hotplug on config level
qemu_monitor_json: Move InetSocketAddress build to a separate function
qemu_monitor: Introduce qemuMonitorAttachCharDev
qemu_monitor: Introduce qemuMonitorDetachCharDev
qemu_command: Honour chardev alias assignment with a function
qemu: Introduce qemuBuildChrDeviceStr
qemu: Implement chardev hotplug on live level
src/conf/domain_conf.c | 174 +++++++++++++++++++++++++++-
src/conf/domain_conf.h | 11 ++
src/libvirt_private.syms | 4 +
src/qemu/qemu_command.c | 262 +++++++++++++++++++++++++++++++++++--------
src/qemu/qemu_command.h | 14 ++-
src/qemu/qemu_driver.c | 43 ++++++-
src/qemu/qemu_hotplug.c | 97 ++++++++++++++++
src/qemu/qemu_hotplug.h | 6 +
src/qemu/qemu_monitor.c | 41 +++++++
src/qemu/qemu_monitor.h | 5 +
src/qemu/qemu_monitor_json.c | 261 +++++++++++++++++++++++++++++++++++++++---
src/qemu/qemu_monitor_json.h | 5 +
12 files changed, 850 insertions(+), 73 deletions(-)
--
1.8.1.5
10:34 a.m.
New subject: [libvirt] [PATCH v1 1/8] domain_conf: Introduce chardev hotplug helpers
For now, only these three helpers are needed:
virDomainChrFind - to find a duplicate chardev within VM def
virDomainChrInsert - wrapper for inserting a new chardev into VM def
virDomainChrRemove - wrapper for removing chardev from VM def
There is, however, one internal helper as well:
virDomainChrGetDomainPtrs which sets given pointers to one of
vmdef->{parallels,serials,consoles,channels} based on passed
chardev type.
---
src/conf/domain_conf.c | 152 +++++++++++++++++++++++++++++++++++++++++++++++
src/conf/domain_conf.h | 11 ++++
src/libvirt_private.syms | 4 ++
3 files changed, 167 insertions(+)
diff --git a/src/conf/domain_conf.c b/src/conf/domain_conf.c
index fe97c02..63f4daf 100644
--- a/src/conf/domain_conf.c
+++ b/src/conf/domain_conf.c
@@ -9650,6 +9650,158 @@ virDomainLeaseRemove(virDomainDefPtr def,
return virDomainLeaseRemoveAt(def, i);
}
+static bool
+virDomainChrEquals(virDomainChrDefPtr src,
+ virDomainChrDefPtr tgt)
+{
+ if (!src || !tgt)
+ return src == tgt;
+
+ if (!virDomainChrSourceDefIsEqual(&src->source, &tgt->source))
+ return false;
+
+ switch ((enum virDomainChrChannelTargetType) src->targetType) {
+ case VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_VIRTIO:
+ return STREQ_NULLABLE(src->target.name, tgt->target.name);
+ break;
+ case VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_GUESTFWD:
+ return memcmp(src->target.addr, tgt->target.addr,
+ sizeof(*src->target.addr)) == 0;
+ break;
+
+ case VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_NONE:
+ case VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_LAST:
+ default:
+ return true;
+ }
+}
+
+virDomainChrDefPtr
+virDomainChrFind(virDomainDefPtr def,
+ virDomainChrDefPtr target)
+{
+ size_t i;
+
+ for (i = 0; i < def->nparallels; i++) {
+ virDomainChrDefPtr chr = def->parallels[i];
+
+ if (virDomainChrEquals(chr, target))
+ return chr;
+ }
+
+ for (i = 0; i < def->nserials; i++) {
+ virDomainChrDefPtr chr = def->serials[i];
+
+ if (virDomainChrEquals(chr, target))
+ return chr;
+ }
+
+
+ for (i = 0; i < def->nconsoles; i++) {
+ virDomainChrDefPtr chr = def->consoles[i];
+
+ if (virDomainChrEquals(chr, target))
+ return chr;
+ }
+
+ for (i = 0; i < def->nchannels; i++) {
+ virDomainChrDefPtr chr = def->channels[i];
+
+ if (virDomainChrEquals(chr, target))
+ return chr;
+ }
+
+ return NULL;
+}
+
+int
+virDomainChrGetDomainPtrs(virDomainDefPtr vmdef,
+ virDomainChrDefPtr chr,
+ virDomainChrDefPtr ***arrPtr,
+ size_t **cntPtr)
+{
+ switch ((enum virDomainChrDeviceType) chr->deviceType) {
+ case VIR_DOMAIN_CHR_DEVICE_TYPE_PARALLEL:
+ *arrPtr = &vmdef->parallels;
+ *cntPtr = &vmdef->nparallels;
+ break;
+
+ case VIR_DOMAIN_CHR_DEVICE_TYPE_SERIAL:
+ *arrPtr = &vmdef->serials;
+ *cntPtr = &vmdef->nserials;
+ break;
+
+ case VIR_DOMAIN_CHR_DEVICE_TYPE_CONSOLE:
+ *arrPtr = &vmdef->consoles;
+ *cntPtr = &vmdef->nconsoles;
+ break;
+
+ case VIR_DOMAIN_CHR_DEVICE_TYPE_CHANNEL:
+ *arrPtr = &vmdef->channels;
+ *cntPtr = &vmdef->nchannels;
+ break;
+
+ default:
+ virReportError(VIR_ERR_OPERATION_INVALID,
+ _("Unsupported device type '%d'"),
+ chr->deviceType);
+ return -1;
+ }
+ return 0;
+}
+
+int virDomainChrInsert(virDomainDefPtr vmdef,
+ virDomainChrDefPtr chr)
+{
+ virDomainChrDefPtr **arrPtr;
+ size_t *cntPtr;
+
+ if (virDomainChrGetDomainPtrs(vmdef, chr, &arrPtr, &cntPtr) < 0)
+ return -1;
+
+ if (VIR_REALLOC_N(*arrPtr, *cntPtr + 1) < 0) {
+ virReportOOMError();
+ return -1;
+ }
+
+ (*arrPtr)[*cntPtr] = chr;
+ (*cntPtr)++;
+
+ return 0;
+}
+
+int virDomainChrRemove(virDomainDefPtr vmdef,
+ virDomainChrDefPtr chr)
+{
+ virDomainChrDefPtr **arrPtr;
+ size_t i, *cntPtr;
+
+ if (virDomainChrGetDomainPtrs(vmdef, chr, &arrPtr, &cntPtr) < 0)
+ return -1;
+
+ for (i = 0; i < *cntPtr; i++) {
+ virDomainChrDefPtr tmp = (*arrPtr)[i];
+
+ if (virDomainChrEquals(tmp, chr))
+ break;
+ }
+
+ if (i == *cntPtr)
+ return -1;
+
+ virDomainChrDefFree((*arrPtr)[i]);
+ if (*cntPtr > 1) {
+ memmove(*arrPtr + i,
+ *arrPtr + i + 1,
+ sizeof(**arrPtr) * (*cntPtr - (i + 1)));
+ ignore_value(VIR_REALLOC_N(*arrPtr, *cntPtr - 1));
+ } else {
+ VIR_FREE(*arrPtr);
+ }
+ (*cntPtr)--;
+
+ return 0;
+}
char *
virDomainDefGetDefaultEmulator(virDomainDefPtr def,
diff --git a/src/conf/domain_conf.h b/src/conf/domain_conf.h
index 21f7ce2..3325fcf 100644
--- a/src/conf/domain_conf.h
+++ b/src/conf/domain_conf.h
@@ -2315,6 +2315,17 @@ virDomainLeaseDefPtr
virDomainLeaseRemove(virDomainDefPtr def,
virDomainLeaseDefPtr lease);
+int virDomainChrGetDomainPtrs(virDomainDefPtr vmdef,
+ virDomainChrDefPtr chr,
+ virDomainChrDefPtr ***arrPtr,
+ size_t **cntPtr);
+virDomainChrDefPtr virDomainChrFind(virDomainDefPtr def,
+ virDomainChrDefPtr target);
+int virDomainChrInsert(virDomainDefPtr vmdef,
+ virDomainChrDefPtr chr);
+int virDomainChrRemove(virDomainDefPtr vmdef,
+ virDomainChrDefPtr chr);
+
int virDomainSaveXML(const char *configDir,
virDomainDefPtr def,
const char *xml);
diff --git a/src/libvirt_private.syms b/src/libvirt_private.syms
index d4cb4a3..6abba6e 100644
--- a/src/libvirt_private.syms
+++ b/src/libvirt_private.syms
@@ -77,6 +77,10 @@ virDomainChrConsoleTargetTypeToString;
virDomainChrDefForeach;
virDomainChrDefFree;
virDomainChrDefNew;
+virDomainChrFind;
+virDomainChrGetDomainPtrs;
+virDomainChrInsert;
+virDomainChrRemove;
virDomainChrSerialTargetTypeFromString;
virDomainChrSerialTargetTypeToString;
virDomainChrSourceDefCopy;
--
1.8.1.5
10:34 a.m.
New subject: [libvirt] [PATCH v1 2/8] qemu: Implement chardev hotplug on config level
There are two levels on which a device may be hotplugged: config
and live. The config level requires just an insert or remove from
internal domain definition structure, which is what this patch
exactly does. There is currently no implementation for a chardev
update action, as there's not much to be updated. But more
importantly, the only thing that can be updated is path or socket
address by which chardevs are distinguished. So the update action
is currently not supported.
---
src/conf/domain_conf.c | 22 ++++++++++++++++++++--
src/qemu/qemu_driver.c | 33 ++++++++++++++++++++++++++++++---
2 files changed, 50 insertions(+), 5 deletions(-)
diff --git a/src/conf/domain_conf.c b/src/conf/domain_conf.c
index 63f4daf..dcf4740 100644
--- a/src/conf/domain_conf.c
+++ b/src/conf/domain_conf.c
@@ -1760,10 +1760,12 @@ void virDomainDeviceDefFree(virDomainDeviceDefPtr def)
case VIR_DOMAIN_DEVICE_RNG:
virDomainRNGDefFree(def->data.rng);
break;
+ case VIR_DOMAIN_DEVICE_CHR:
+ virDomainChrDefFree(def->data.chr);
+ break;
case VIR_DOMAIN_DEVICE_NONE:
case VIR_DOMAIN_DEVICE_FS:
case VIR_DOMAIN_DEVICE_SMARTCARD:
- case VIR_DOMAIN_DEVICE_CHR:
case VIR_DOMAIN_DEVICE_MEMBALLOON:
case VIR_DOMAIN_DEVICE_NVRAM:
case VIR_DOMAIN_DEVICE_LAST:
@@ -9040,6 +9042,20 @@ virDomainDeviceDefParse(const char *xmlStr,
dev->type = VIR_DOMAIN_DEVICE_RNG;
if (!(dev->data.rng = virDomainRNGDefParseXML(node, ctxt, flags)))
goto error;
+ } else if (xmlStrEqual(node->name, BAD_CAST "channel") ||
+ xmlStrEqual(node->name, BAD_CAST "console") ||
+ xmlStrEqual(node->name, BAD_CAST "parallel") ||
+ xmlStrEqual(node->name, BAD_CAST "serial")) {
+ dev->type = VIR_DOMAIN_DEVICE_CHR;
+ /* In case of serial chardev we want to parse <source> as it is the only
+ * thing distinguishing two serial chardevs */
+ flags &= ~VIR_DOMAIN_XML_INACTIVE;
+ if (!(dev->data.chr = virDomainChrDefParseXML(ctxt,
+ node,
+ def->seclabels,
+ def->nseclabels,
+ flags)))
+ goto error;
} else {
virReportError(VIR_ERR_XML_ERROR, "%s", _("unknown device
type"));
goto error;
@@ -17354,9 +17370,11 @@ virDomainDeviceDefCopy(virDomainDeviceDefPtr src,
case VIR_DOMAIN_DEVICE_RNG:
rc = virDomainRNGDefFormat(&buf, src->data.rng, flags);
break;
+ case VIR_DOMAIN_DEVICE_CHR:
+ rc = virDomainChrDefFormat(&buf, src->data.chr, flags);
+ break;
case VIR_DOMAIN_DEVICE_NONE:
case VIR_DOMAIN_DEVICE_SMARTCARD:
- case VIR_DOMAIN_DEVICE_CHR:
case VIR_DOMAIN_DEVICE_MEMBALLOON:
case VIR_DOMAIN_DEVICE_NVRAM:
case VIR_DOMAIN_DEVICE_LAST:
diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c
index d5d7de3..1900c4a 100644
--- a/src/qemu/qemu_driver.c
+++ b/src/qemu/qemu_driver.c
@@ -6027,6 +6027,7 @@ qemuDomainAttachDeviceConfig(virQEMUCapsPtr qemuCaps,
virDomainHostdevDefPtr hostdev;
virDomainLeaseDefPtr lease;
virDomainControllerDefPtr controller;
+ virDomainChrDefPtr chr;
switch (dev->type) {
case VIR_DOMAIN_DEVICE_DISK:
@@ -6108,10 +6109,23 @@ qemuDomainAttachDeviceConfig(virQEMUCapsPtr qemuCaps,
return -1;
break;
+ case VIR_DOMAIN_DEVICE_CHR:
+ chr = dev->data.chr;
+ if (virDomainChrFind(vmdef, chr)) {
+ virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+ _("chardev already exists"));
+ return -1;
+ }
+
+ if (virDomainChrInsert(vmdef, chr) < 0)
+ return -1;
+ dev->data.chr = NULL;
+ break;
+
default:
- virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
- _("persistent attach of device is not supported"));
- return -1;
+ virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
+ _("persistent attach of device is not supported"));
+ return -1;
}
return 0;
}
@@ -6126,6 +6140,7 @@ qemuDomainDetachDeviceConfig(virDomainDefPtr vmdef,
virDomainHostdevDefPtr hostdev, det_hostdev;
virDomainLeaseDefPtr lease, det_lease;
virDomainControllerDefPtr cont, det_cont;
+ virDomainChrDefPtr chr;
int idx;
char mac[VIR_MAC_STRING_BUFLEN];
@@ -6193,6 +6208,18 @@ qemuDomainDetachDeviceConfig(virDomainDefPtr vmdef,
break;
+ case VIR_DOMAIN_DEVICE_CHR:
+ chr = dev->data.chr;
+ if (virDomainChrRemove(vmdef, chr) < 0) {
+ virReportError(VIR_ERR_INVALID_ARG, "%s",
+ _("device not present in domain configuration"));
+ return -1;
+ }
+
+ virDomainChrDefFree(chr);
+ dev->data.chr = NULL;
+ break;
+
default:
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("persistent detach of device is not supported"));
--
1.8.1.5
10:34 a.m.
New subject: [libvirt] [PATCH v1 3/8] qemu_monitor_json: Move InetSocketAddress build to a separate function
Currently, we are building InetSocketAddress qemu json type
within the qemuMonitorJSONNBDServerStart function. However, other
future functions may profit from the code as well. So it should
be moved into a static function.
---
src/qemu/qemu_monitor_json.c | 47 ++++++++++++++++++++++++++++----------------
1 file changed, 30 insertions(+), 17 deletions(-)
diff --git a/src/qemu/qemu_monitor_json.c b/src/qemu/qemu_monitor_json.c
index 6fdd650..5544a66 100644
--- a/src/qemu/qemu_monitor_json.c
+++ b/src/qemu/qemu_monitor_json.c
@@ -4652,6 +4652,32 @@ no_memory:
goto cleanup;
}
+static virJSONValuePtr
+qemuMonitorJSONBuildInetSocketAddress(const char *host,
+ const char *port)
+{
+ virJSONValuePtr addr = NULL;
+ virJSONValuePtr data = NULL;
+
+ if (!(data = virJSONValueNewObject()) ||
+ !(addr = virJSONValueNewObject()))
+ goto error;
+
+ /* port is really expected as a string here by qemu */
+ if (virJSONValueObjectAppendString(data, "host", host) < 0 ||
+ virJSONValueObjectAppendString(data, "port", port) < 0 ||
+ virJSONValueObjectAppendString(addr, "type", "inet") < 0
||
+ virJSONValueObjectAppend(addr, "data", data) < 0)
+ goto error;
+
+ return addr;
+error:
+ virReportOOMError();
+ virJSONValueFree(data);
+ virJSONValueFree(addr);
+ return NULL;
+}
+
int
qemuMonitorJSONNBDServerStart(qemuMonitorPtr mon,
const char *host,
@@ -4660,28 +4686,16 @@ qemuMonitorJSONNBDServerStart(qemuMonitorPtr mon,
int ret = -1;
virJSONValuePtr cmd = NULL;
virJSONValuePtr reply = NULL;
- virJSONValuePtr data = NULL;
virJSONValuePtr addr = NULL;
char *port_str = NULL;
- if (!(data = virJSONValueNewObject()) ||
- !(addr = virJSONValueNewObject()) ||
- (virAsprintf(&port_str, "%u", port) < 0)) {
- virReportOOMError();
- goto cleanup;
- }
-
- /* port is really expected as a string here by qemu */
- if (virJSONValueObjectAppendString(data, "host", host) < 0 ||
- virJSONValueObjectAppendString(data, "port", port_str) < 0 ||
- virJSONValueObjectAppendString(addr, "type", "inet") < 0
||
- virJSONValueObjectAppend(addr, "data", data) < 0) {
+ if (virAsprintf(&port_str, "%u", port) < 0) {
virReportOOMError();
- goto cleanup;
+ return ret;
}
- /* From now on, @data is part of @addr */
- data = NULL;
+ if (!(addr = qemuMonitorJSONBuildInetSocketAddress(host, port_str)))
+ return ret;
if (!(cmd = qemuMonitorJSONMakeCommand("nbd-server-start",
"a:addr", addr,
@@ -4704,7 +4718,6 @@ cleanup:
virJSONValueFree(reply);
virJSONValueFree(cmd);
virJSONValueFree(addr);
- virJSONValueFree(data);
return ret;
}
--
1.8.1.5
10:34 a.m.
New subject: [libvirt] [PATCH v1 4/8] qemu_monitor: Introduce qemuMonitorAttachCharDev
The function being introduced is responsible for preparing and
executing 'chardev-add' qemu monitor command. Moreover, in case
of PTY chardev, the corresponding pty path is updated.
---
src/qemu/qemu_monitor.c | 21 +++++
src/qemu/qemu_monitor.h | 3 +
src/qemu/qemu_monitor_json.c | 191 +++++++++++++++++++++++++++++++++++++++++++
src/qemu/qemu_monitor_json.h | 3 +
4 files changed, 218 insertions(+)
diff --git a/src/qemu/qemu_monitor.c b/src/qemu/qemu_monitor.c
index 4deb2d6..1025e50 100644
--- a/src/qemu/qemu_monitor.c
+++ b/src/qemu/qemu_monitor.c
@@ -3570,3 +3570,24 @@ int qemuMonitorGetTPMTypes(qemuMonitorPtr mon,
return qemuMonitorJSONGetTPMTypes(mon, tpmtypes);
}
+
+int qemuMonitorAttachCharDev(qemuMonitorPtr mon,
+ const char *chrID,
+ virDomainChrSourceDefPtr chr)
+{
+ VIR_DEBUG("mon=%p chrID=%s chr=%p", mon, chrID, chr);
+
+ if (!mon) {
+ virReportError(VIR_ERR_INVALID_ARG, "%s",
+ _("monitor must not be NULL"));
+ return -1;
+ }
+
+ if (!mon->json) {
+ virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
+ _("JSON monitor is required"));
+ return -1;
+ }
+
+ return qemuMonitorJSONAttachCharDev(mon, chrID, chr);
+}
diff --git a/src/qemu/qemu_monitor.h b/src/qemu/qemu_monitor.h
index f39f009..77de325 100644
--- a/src/qemu/qemu_monitor.h
+++ b/src/qemu/qemu_monitor.h
@@ -689,6 +689,9 @@ int qemuMonitorGetTPMModels(qemuMonitorPtr mon,
int qemuMonitorGetTPMTypes(qemuMonitorPtr mon,
char ***tpmtypes);
+int qemuMonitorAttachCharDev(qemuMonitorPtr mon,
+ const char *chrID,
+ virDomainChrSourceDefPtr chr);
/**
* When running two dd process and using <> redirection, we need a
* shell that will not truncate files. These two strings serve that
diff --git a/src/qemu/qemu_monitor_json.c b/src/qemu/qemu_monitor_json.c
index 5544a66..d944d01 100644
--- a/src/qemu/qemu_monitor_json.c
+++ b/src/qemu/qemu_monitor_json.c
@@ -4678,6 +4678,30 @@ error:
return NULL;
}
+static virJSONValuePtr
+qemuMonitorJSONBuildUnixSocketAddress(const char *path)
+{
+ virJSONValuePtr addr = NULL;
+ virJSONValuePtr data = NULL;
+
+ if (!(data = virJSONValueNewObject()) ||
+ !(addr = virJSONValueNewObject()))
+ goto error;
+
+ /* port is really expected as a string here by qemu */
+ if (virJSONValueObjectAppendString(data, "path", path) < 0 ||
+ virJSONValueObjectAppendString(addr, "type", "unix") < 0
||
+ virJSONValueObjectAppend(addr, "data", data) < 0)
+ goto error;
+
+ return addr;
+error:
+ virReportOOMError();
+ virJSONValueFree(data);
+ virJSONValueFree(addr);
+ return NULL;
+}
+
int
qemuMonitorJSONNBDServerStart(qemuMonitorPtr mon,
const char *host,
@@ -4859,3 +4883,170 @@ int qemuMonitorJSONGetTPMTypes(qemuMonitorPtr mon,
{
return qemuMonitorJSONGetStringArray(mon, "query-tpm-types", tpmtypes);
}
+
+static virJSONValuePtr
+qemuMonitorJSONAttachCharDevCommand(const char *chrID,
+ const virDomainChrSourceDefPtr chr)
+{
+ virJSONValuePtr ret;
+ virJSONValuePtr backend;
+ virJSONValuePtr data = NULL;
+ virJSONValuePtr addr = NULL;
+ const char *backend_type;
+ bool telnet;
+
+ if (!(backend = virJSONValueNewObject()) ||
+ !(data = virJSONValueNewObject())) {
+ goto no_memory;
+ }
+
+ switch ((enum virDomainChrType) chr->type) {
+ case VIR_DOMAIN_CHR_TYPE_NULL:
+ case VIR_DOMAIN_CHR_TYPE_VC:
+ backend_type = "null";
+ break;
+
+ case VIR_DOMAIN_CHR_TYPE_PTY:
+ backend_type = "pty";
+ break;
+
+ case VIR_DOMAIN_CHR_TYPE_FILE:
+ backend_type = "file";
+ if (virJSONValueObjectAppendString(data, "out", chr->data.file.path)
< 0)
+ goto no_memory;
+ break;
+
+ case VIR_DOMAIN_CHR_TYPE_DEV:
+ backend_type = STRPREFIX(chrID, "parallel") ? "parallel" :
"serial";
+ if (virJSONValueObjectAppendString(data, "device",
+ chr->data.file.path) < 0)
+ goto no_memory;
+ break;
+
+ case VIR_DOMAIN_CHR_TYPE_TCP:
+ backend_type = "socket";
+ addr = qemuMonitorJSONBuildInetSocketAddress(chr->data.tcp.host,
+ chr->data.tcp.service);
+ if (!addr ||
+ virJSONValueObjectAppend(data, "addr", addr) < 0)
+ goto no_memory;
+ addr = NULL;
+
+ telnet = chr->data.tcp.protocol == VIR_DOMAIN_CHR_TCP_PROTOCOL_TELNET;
+
+ if (virJSONValueObjectAppendBoolean(data, "wait", false) < 0 ||
+ virJSONValueObjectAppendBoolean(data, "telnet", telnet) < 0 ||
+ virJSONValueObjectAppendBoolean(data, "server",
chr->data.tcp.listen) < 0)
+ goto no_memory;
+ break;
+
+ case VIR_DOMAIN_CHR_TYPE_UDP:
+ backend_type = "socket";
+ addr = qemuMonitorJSONBuildInetSocketAddress(chr->data.udp.connectHost,
+ chr->data.udp.connectService);
+ if (!addr ||
+ virJSONValueObjectAppend(data, "addr", addr) < 0)
+ goto no_memory;
+ addr = NULL;
+ break;
+
+ case VIR_DOMAIN_CHR_TYPE_UNIX:
+ backend_type = "socket";
+ addr = qemuMonitorJSONBuildUnixSocketAddress(chr->data.nix.path);
+
+ if (!addr ||
+ virJSONValueObjectAppend(data, "addr", addr) < 0)
+ goto no_memory;
+ addr = NULL;
+
+ if (virJSONValueObjectAppendBoolean(data, "wait", false) < 0 ||
+ virJSONValueObjectAppendBoolean(data, "server",
chr->data.nix.listen) < 0)
+ goto no_memory;
+ break;
+
+ case VIR_DOMAIN_CHR_TYPE_SPICEVMC:
+ case VIR_DOMAIN_CHR_TYPE_PIPE:
+ case VIR_DOMAIN_CHR_TYPE_STDIO:
+ case VIR_DOMAIN_CHR_TYPE_LAST:
+ default:
+ virReportError(VIR_ERR_OPERATION_FAILED,
+ _("Unsupported char device type '%d'"),
+ chr->type);
+ goto error;
+ }
+
+ if (virJSONValueObjectAppendString(backend, "type", backend_type) < 0
||
+ virJSONValueObjectAppend(backend, "data", data) < 0)
+ goto no_memory;
+ data = NULL;
+
+ if (!(ret = qemuMonitorJSONMakeCommand("chardev-add",
+ "s:id", chrID,
+ "a:backend", backend,
+ NULL)))
+ goto error;
+
+ return ret;
+
+no_memory:
+ virReportOOMError();
+error:
+ virJSONValueFree(addr);
+ virJSONValueFree(data);
+ virJSONValueFree(backend);
+ return NULL;
+}
+
+static int
+qemuMonitorJSONAttachCharDevInfo(virJSONValuePtr reply,
+ virDomainChrSourceDefPtr chr)
+{
+ virJSONValuePtr data;
+ const char *path;
+
+ if (chr->type != VIR_DOMAIN_CHR_TYPE_PTY)
+ return 0;
+
+ if (!(data = virJSONValueObjectGet(reply, "return"))) {
+ virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+ _("chardev-add reply was missing return data"));
+ return -1;
+ }
+
+ if (!(path = virJSONValueObjectGetString(data, "pty"))) {
+ virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+ _("chardev-add reply was missing pty path"));
+ return -1;
+ }
+
+ if (!(chr->data.file.path = strdup(path))) {
+ virReportOOMError();
+ return -1;
+ }
+ return 0;
+}
+
+int
+qemuMonitorJSONAttachCharDev(qemuMonitorPtr mon,
+ const char *chrID,
+ virDomainChrSourceDefPtr chr)
+{
+ int ret = -1;
+ virJSONValuePtr cmd;
+ virJSONValuePtr reply = NULL;
+
+ if (!(cmd = qemuMonitorJSONAttachCharDevCommand(chrID, chr)))
+ return ret;
+
+ ret = qemuMonitorJSONCommand(mon, cmd, &reply);
+
+ if (ret == 0)
+ ret = qemuMonitorJSONCheckError(cmd, reply);
+
+ if (ret == 0)
+ ret = qemuMonitorJSONAttachCharDevInfo(reply, chr);
+
+ virJSONValueFree(cmd);
+ virJSONValueFree(reply);
+ return ret;
+}
diff --git a/src/qemu/qemu_monitor_json.h b/src/qemu/qemu_monitor_json.h
index 5ee0d84..8996e02 100644
--- a/src/qemu/qemu_monitor_json.h
+++ b/src/qemu/qemu_monitor_json.h
@@ -349,4 +349,7 @@ int qemuMonitorJSONGetTPMTypes(qemuMonitorPtr mon,
char ***tpmtypes)
ATTRIBUTE_NONNULL(2);
+int qemuMonitorJSONAttachCharDev(qemuMonitorPtr mon,
+ const char *chrID,
+ virDomainChrSourceDefPtr chr);
#endif /* QEMU_MONITOR_JSON_H */
--
1.8.1.5
10:34 a.m.
New subject: [libvirt] [PATCH v1 5/8] qemu_monitor: Introduce qemuMonitorDetachCharDev
This function wraps 'chardev-remove' qemu monitor command around.
It takes chardev alias as its single argument besides qemu monitor
pointer.
---
src/qemu/qemu_monitor.c | 20 ++++++++++++++++++++
src/qemu/qemu_monitor.h | 2 ++
src/qemu/qemu_monitor_json.c | 23 +++++++++++++++++++++++
src/qemu/qemu_monitor_json.h | 2 ++
4 files changed, 47 insertions(+)
diff --git a/src/qemu/qemu_monitor.c b/src/qemu/qemu_monitor.c
index 1025e50..187d46d 100644
--- a/src/qemu/qemu_monitor.c
+++ b/src/qemu/qemu_monitor.c
@@ -3591,3 +3591,23 @@ int qemuMonitorAttachCharDev(qemuMonitorPtr mon,
return qemuMonitorJSONAttachCharDev(mon, chrID, chr);
}
+
+int qemuMonitorDetachCharDev(qemuMonitorPtr mon,
+ const char *chrID)
+{
+ VIR_DEBUG("mon=%p chrID=%s", mon, chrID);
+
+ if (!mon) {
+ virReportError(VIR_ERR_INVALID_ARG, "%s",
+ _("monitor must not be NULL"));
+ return -1;
+ }
+
+ if (!mon->json) {
+ virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
+ _("JSON monitor is required"));
+ return -1;
+ }
+
+ return qemuMonitorJSONDetachCharDev(mon, chrID);
+}
diff --git a/src/qemu/qemu_monitor.h b/src/qemu/qemu_monitor.h
index 77de325..f0c5aef 100644
--- a/src/qemu/qemu_monitor.h
+++ b/src/qemu/qemu_monitor.h
@@ -692,6 +692,8 @@ int qemuMonitorGetTPMTypes(qemuMonitorPtr mon,
int qemuMonitorAttachCharDev(qemuMonitorPtr mon,
const char *chrID,
virDomainChrSourceDefPtr chr);
+int qemuMonitorDetachCharDev(qemuMonitorPtr mon,
+ const char *chrID);
/**
* When running two dd process and using <> redirection, we need a
* shell that will not truncate files. These two strings serve that
diff --git a/src/qemu/qemu_monitor_json.c b/src/qemu/qemu_monitor_json.c
index d944d01..382cbc3 100644
--- a/src/qemu/qemu_monitor_json.c
+++ b/src/qemu/qemu_monitor_json.c
@@ -5050,3 +5050,26 @@ qemuMonitorJSONAttachCharDev(qemuMonitorPtr mon,
virJSONValueFree(reply);
return ret;
}
+
+int
+qemuMonitorJSONDetachCharDev(qemuMonitorPtr mon,
+ const char *chrID)
+{
+ int ret = -1;
+ virJSONValuePtr cmd;
+ virJSONValuePtr reply = NULL;
+
+ if (!(cmd = qemuMonitorJSONMakeCommand("chardev-remove",
+ "s:id", chrID,
+ NULL)))
+ return ret;
+
+ ret = qemuMonitorJSONCommand(mon, cmd, &reply);
+
+ if (ret == 0)
+ ret = qemuMonitorJSONCheckError(cmd, reply);
+
+ virJSONValueFree(cmd);
+ virJSONValueFree(reply);
+ return ret;
+}
diff --git a/src/qemu/qemu_monitor_json.h b/src/qemu/qemu_monitor_json.h
index 8996e02..d25c1b7 100644
--- a/src/qemu/qemu_monitor_json.h
+++ b/src/qemu/qemu_monitor_json.h
@@ -352,4 +352,6 @@ int qemuMonitorJSONGetTPMTypes(qemuMonitorPtr mon,
int qemuMonitorJSONAttachCharDev(qemuMonitorPtr mon,
const char *chrID,
virDomainChrSourceDefPtr chr);
+int qemuMonitorJSONDetachCharDev(qemuMonitorPtr mon,
+ const char *chrID);
#endif /* QEMU_MONITOR_JSON_H */
--
1.8.1.5
10:34 a.m.
New subject: [libvirt] [PATCH v1 6/8] qemu_command: Honour chardev alias assignment with a function
The chardev alias assignment is going to be needed in a separate
places, so it should be moved into a separate function rather
than copying code randomly around.
---
src/qemu/qemu_command.c | 66 ++++++++++++++++++++++++++++++++++++++++++++++---
src/qemu/qemu_command.h | 3 +++
2 files changed, 65 insertions(+), 4 deletions(-)
diff --git a/src/qemu/qemu_command.c b/src/qemu/qemu_command.c
index 144620c..9f4041c 100644
--- a/src/qemu/qemu_command.c
+++ b/src/qemu/qemu_command.c
@@ -795,6 +795,64 @@ qemuAssignDeviceControllerAlias(virDomainControllerDefPtr
controller)
return 0;
}
+int
+qemuAssignDeviceChrAlias(virDomainDefPtr def,
+ virDomainChrDefPtr chr,
+ size_t idx)
+{
+ virDomainChrDefPtr **arrPtr;
+ size_t *cntPtr;
+ const char *prefix;
+
+ if (virDomainChrGetDomainPtrs(def, chr, &arrPtr, &cntPtr) < 0)
+ return -1;
+
+ switch ((enum virDomainChrDeviceType) chr->deviceType) {
+ case VIR_DOMAIN_CHR_DEVICE_TYPE_PARALLEL:
+ prefix = "parallel";
+ break;
+
+ case VIR_DOMAIN_CHR_DEVICE_TYPE_SERIAL:
+ prefix = "serial";
+ break;
+
+ case VIR_DOMAIN_CHR_DEVICE_TYPE_CONSOLE:
+ prefix = "console";
+ break;
+
+ case VIR_DOMAIN_CHR_DEVICE_TYPE_CHANNEL:
+ prefix = "channel";
+ break;
+
+ default:
+ virReportError(VIR_ERR_OPERATION_INVALID,
+ _("Unsupported device type '%d'"),
+ chr->deviceType);
+ return -1;
+ }
+
+ if (idx == -1) {
+ size_t i;
+ idx = 0;
+ for (i = 0; i < *cntPtr; i++) {
+ int thisidx;
+ if ((thisidx = qemuDomainDeviceAliasIndex(&(*arrPtr)[i]->info,
prefix)) < 0) {
+ virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
+ _("Unable to determine device index for character
device"));
+ return -1;
+ }
+ if (thisidx >= idx)
+ idx = thisidx + 1;
+ }
+ }
+
+ if (virAsprintf(&chr->info.alias, "%s%zu", prefix, idx) < 0) {
+ virReportOOMError();
+ return -1;
+ }
+
+ return 0;
+}
int
qemuAssignDeviceAliases(virDomainDefPtr def, virQEMUCapsPtr qemuCaps)
@@ -850,19 +908,19 @@ qemuAssignDeviceAliases(virDomainDefPtr def, virQEMUCapsPtr
qemuCaps)
goto no_memory;
}
for (i = 0; i < def->nparallels ; i++) {
- if (virAsprintf(&def->parallels[i]->info.alias, "parallel%d",
i) < 0)
+ if (qemuAssignDeviceChrAlias(def, def->parallels[i], i) < 0)
goto no_memory;
}
for (i = 0; i < def->nserials ; i++) {
- if (virAsprintf(&def->serials[i]->info.alias, "serial%d", i)
< 0)
+ if (qemuAssignDeviceChrAlias(def, def->serials[i], i) < 0)
goto no_memory;
}
for (i = 0; i < def->nchannels ; i++) {
- if (virAsprintf(&def->channels[i]->info.alias, "channel%d",
i) < 0)
+ if (qemuAssignDeviceChrAlias(def, def->channels[i], i) < 0)
goto no_memory;
}
for (i = 0; i < def->nconsoles ; i++) {
- if (virAsprintf(&def->consoles[i]->info.alias, "console%d",
i) < 0)
+ if (qemuAssignDeviceChrAlias(def, def->consoles[i], i) < 0)
goto no_memory;
}
for (i = 0; i < def->nhubs ; i++) {
diff --git a/src/qemu/qemu_command.h b/src/qemu/qemu_command.h
index a706942..ba8ea8e 100644
--- a/src/qemu/qemu_command.h
+++ b/src/qemu/qemu_command.h
@@ -231,6 +231,9 @@ int qemuAssignDeviceDiskAlias(virDomainDefPtr vmdef,
int qemuAssignDeviceHostdevAlias(virDomainDefPtr def, virDomainHostdevDefPtr hostdev, int
idx);
int qemuAssignDeviceControllerAlias(virDomainControllerDefPtr controller);
int qemuAssignDeviceRedirdevAlias(virDomainDefPtr def, virDomainRedirdevDefPtr redirdev,
int idx);
+int qemuAssignDeviceChrAlias(virDomainDefPtr def,
+ virDomainChrDefPtr chr,
+ size_t idx);
int
qemuParseKeywords(const char *str,
--
1.8.1.5
10:34 a.m.
New subject: [libvirt] [PATCH v1 7/8] qemu: Introduce qemuBuildChrDeviceStr
The function being introduced is responsible for creating command
line argument for '-device' for given character device. Based on
the chardev type, it calls appropriate qemuBuild.*ChrDeviceStr(),
e.g. qemuBuildSerialChrDeviceStr() for serial chardev and so on.
---
src/qemu/qemu_command.c | 196 ++++++++++++++++++++++++++++++++++++++----------
src/qemu/qemu_command.h | 11 ++-
2 files changed, 160 insertions(+), 47 deletions(-)
diff --git a/src/qemu/qemu_command.c b/src/qemu/qemu_command.c
index 9f4041c..215e6e4 100644
--- a/src/qemu/qemu_command.c
+++ b/src/qemu/qemu_command.c
@@ -7437,12 +7437,9 @@ qemuBuildCommandLine(virConnectPtr conn,
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
- virCommandAddArg(cmd, "-device");
- if (!(devstr = qemuBuildChrDeviceStr(serial, qemuCaps,
- def->os.arch,
- def->os.machine)))
+ if (qemuBuildChrDeviceStr(&devstr, def, serial, qemuCaps) < 0)
goto error;
- virCommandAddArg(cmd, devstr);
+ virCommandAddArgList(cmd, "-device", devstr, NULL);
VIR_FREE(devstr);
} else {
virCommandAddArg(cmd, "-serial");
@@ -7474,10 +7471,10 @@ qemuBuildCommandLine(virConnectPtr conn,
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
- virCommandAddArg(cmd, "-device");
- virCommandAddArgFormat(cmd,
"isa-parallel,chardev=char%s,id=%s",
- parallel->info.alias,
- parallel->info.alias);
+ if (qemuBuildChrDeviceStr(&devstr, def, parallel, qemuCaps) < 0)
+ goto error;
+ virCommandAddArgList(cmd, "-device", devstr, NULL);
+ VIR_FREE(devstr);
} else {
virCommandAddArg(cmd, "-parallel");
if (!(devstr = qemuBuildChrArgStr(¶llel->source, NULL)))
@@ -7491,8 +7488,6 @@ qemuBuildCommandLine(virConnectPtr conn,
for (i = 0 ; i < def->nchannels ; i++) {
virDomainChrDefPtr channel = def->channels[i];
char *devstr;
- char *addr;
- int port;
switch (channel->targetType) {
case VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_GUESTFWD:
@@ -7511,17 +7506,10 @@ qemuBuildCommandLine(virConnectPtr conn,
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
- addr = virSocketAddrFormat(channel->target.addr);
- if (!addr)
+ if (qemuBuildChrDeviceStr(&devstr, def, channel, qemuCaps) < 0)
goto error;
- port = virSocketAddrGetPort(channel->target.addr);
-
- virCommandAddArg(cmd, "-netdev");
- virCommandAddArgFormat(cmd,
-
"user,guestfwd=tcp:%s:%i,chardev=char%s,id=user-%s",
- addr, port, channel->info.alias,
- channel->info.alias);
- VIR_FREE(addr);
+ virCommandAddArgList(cmd, "-netdev", devstr, NULL);
+ VIR_FREE(devstr);
break;
case VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_VIRTIO:
@@ -7547,11 +7535,9 @@ qemuBuildCommandLine(virConnectPtr conn,
VIR_FREE(devstr);
}
- virCommandAddArg(cmd, "-device");
- if (!(devstr = qemuBuildVirtioSerialPortDevStr(channel,
- qemuCaps)))
+ if (qemuBuildChrDeviceStr(&devstr, def, channel, qemuCaps) < 0)
goto error;
- virCommandAddArg(cmd, devstr);
+ virCommandAddArgList(cmd, "-device", devstr, NULL);
VIR_FREE(devstr);
break;
}
@@ -7584,10 +7570,9 @@ qemuBuildCommandLine(virConnectPtr conn,
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
- virCommandAddArg(cmd, "-device");
- if (!(devstr = qemuBuildSclpDevStr(console)))
+ if (qemuBuildChrDeviceStr(&devstr, def, console, qemuCaps) < 0)
goto error;
- virCommandAddArg(cmd, devstr);
+ virCommandAddArgList(cmd, "-device", devstr, NULL);
VIR_FREE(devstr);
break;
@@ -7606,11 +7591,9 @@ qemuBuildCommandLine(virConnectPtr conn,
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
- virCommandAddArg(cmd, "-device");
- if (!(devstr = qemuBuildVirtioSerialPortDevStr(console,
- qemuCaps)))
+ if (qemuBuildChrDeviceStr(&devstr, def, console, qemuCaps) < 0)
goto error;
- virCommandAddArg(cmd, devstr);
+ virCommandAddArgList(cmd, "-device", devstr, NULL);
VIR_FREE(devstr);
break;
@@ -8273,11 +8256,12 @@ error:
/* This function generates the correct '-device' string for character
* devices of each architecture.
*/
-char *
-qemuBuildChrDeviceStr(virDomainChrDefPtr serial,
- virQEMUCapsPtr qemuCaps,
- virArch arch,
- char *machine)
+static int
+qemuBuildSerialChrDeviceStr(char **deviceStr,
+ virDomainChrDefPtr serial,
+ virQEMUCapsPtr qemuCaps,
+ virArch arch,
+ char *machine)
{
virBuffer cmd = VIR_BUFFER_INITIALIZER;
@@ -8309,7 +8293,7 @@ qemuBuildChrDeviceStr(virDomainChrDefPtr serial,
}
if (qemuBuildDeviceAddressStr(&cmd, &serial->info, qemuCaps) <
0)
- goto error;
+ goto error;
}
}
@@ -8318,13 +8302,143 @@ qemuBuildChrDeviceStr(virDomainChrDefPtr serial,
goto error;
}
- return virBufferContentAndReset(&cmd);
+ *deviceStr = virBufferContentAndReset(&cmd);
+ return 0;
- error:
+error:
virBufferFreeAndReset(&cmd);
- return NULL;
+ return -1;
+}
+
+static int
+qemuBuildParallelChrDeviceStr(char **deviceStr,
+ virDomainChrDefPtr chr)
+{
+ if (virAsprintf(deviceStr, "isa-parallel,chardev=char%s,id=%s",
+ chr->info.alias, chr->info.alias) < 0) {
+ virReportOOMError();
+ return -1;
+ }
+ return 0;
+}
+
+static int
+qemuBuildChannelChrDeviceStr(char **deviceStr,
+ virDomainChrDefPtr chr,
+ virQEMUCapsPtr qemuCaps)
+{
+ int ret = -1;
+ char *addr = NULL;
+ int port;
+
+ switch ((enum virDomainChrChannelTargetType) chr->targetType) {
+ case VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_GUESTFWD:
+
+ addr = virSocketAddrFormat(chr->target.addr);
+ if (!addr)
+ return ret;
+ port = virSocketAddrGetPort(chr->target.addr);
+
+ if (virAsprintf(deviceStr,
+ "user,guestfwd=tcp:%s:%i,chardev=char%s,id=user-%s",
+ addr, port, chr->info.alias, chr->info.alias) < 0) {
+ virReportOOMError();
+ goto cleanup;
+ }
+ break;
+
+ case VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_VIRTIO:
+ if (!(*deviceStr = qemuBuildVirtioSerialPortDevStr(chr, qemuCaps)))
+ goto cleanup;
+ break;
+
+ case VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_NONE:
+ case VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_LAST:
+ default:
+ virReportError(VIR_ERR_INTERNAL_ERROR,
+ _("Unsupported channel target type %d"),
+ chr->targetType);
+ goto cleanup;
+ }
+
+ ret = 0;
+cleanup:
+ VIR_FREE(addr);
+ return ret;
+}
+
+static int
+qemuBuildConsoleChrDeviceStr(char **deviceStr,
+ virDomainChrDefPtr chr,
+ virQEMUCapsPtr qemuCaps)
+{
+ int ret = -1;
+
+ switch (chr->targetType) {
+ case VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_SCLP:
+ case VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_SCLPLM:
+ if (!(*deviceStr = qemuBuildSclpDevStr(chr)))
+ goto cleanup;
+ break;
+
+ case VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_VIRTIO:
+ if (!(*deviceStr = qemuBuildVirtioSerialPortDevStr(chr, qemuCaps)))
+ goto cleanup;
+ break;
+
+ case VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_SERIAL:
+ break;
+
+ default:
+ virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
+ _("unsupported console target type %d"),
+ chr->targetType);
+ goto cleanup;
+ }
+
+ ret = 0;
+cleanup:
+ return ret;
+}
+
+int
+qemuBuildChrDeviceStr(char **deviceStr,
+ virDomainDefPtr vmdef,
+ virDomainChrDefPtr chr,
+ virQEMUCapsPtr qemuCaps)
+{
+ int ret = -1;
+
+ switch ((enum virDomainChrDeviceType) chr->deviceType) {
+ case VIR_DOMAIN_CHR_DEVICE_TYPE_SERIAL:
+ ret = qemuBuildSerialChrDeviceStr(deviceStr, chr, qemuCaps,
+ vmdef->os.arch,
+ vmdef->os.machine);
+ break;
+
+ case VIR_DOMAIN_CHR_DEVICE_TYPE_PARALLEL:
+ ret = qemuBuildParallelChrDeviceStr(deviceStr, chr);
+ break;
+
+ case VIR_DOMAIN_CHR_DEVICE_TYPE_CHANNEL:
+ ret = qemuBuildChannelChrDeviceStr(deviceStr, chr, qemuCaps);
+ break;
+
+ case VIR_DOMAIN_CHR_DEVICE_TYPE_CONSOLE:
+ ret = qemuBuildConsoleChrDeviceStr(deviceStr, chr, qemuCaps);
+ break;
+
+ default:
+ virReportError(VIR_ERR_INTERNAL_ERROR,
+ _("Chardev deviceType %d is not handled"),
+ chr->deviceType);
+ break;
+ }
+
+ return ret;
}
+
/*
* This method takes a string representing a QEMU command line ARGV set
* optionally prefixed by a list of environment variables. It then tries
diff --git a/src/qemu/qemu_command.h b/src/qemu/qemu_command.h
index ba8ea8e..140b007 100644
--- a/src/qemu/qemu_command.h
+++ b/src/qemu/qemu_command.h
@@ -61,12 +61,11 @@ virCommandPtr qemuBuildCommandLine(virConnectPtr conn,
enum virNetDevVPortProfileOp vmop)
ATTRIBUTE_NONNULL(1);
-/* Generate string for arch-specific '-device' parameter */
-char *
-qemuBuildChrDeviceStr (virDomainChrDefPtr serial,
- virQEMUCapsPtr qemuCaps,
- virArch arch,
- char *machine);
+/* Generate '-device' string for chardev device */
+int qemuBuildChrDeviceStr(char **deviceStr,
+ virDomainDefPtr vmdef,
+ virDomainChrDefPtr chr,
+ virQEMUCapsPtr qemuCaps);
/* With vlan == -1, use netdev syntax, else old hostnet */
char * qemuBuildHostNetStr(virDomainNetDefPtr net,
--
1.8.1.5
10:34 a.m.
New subject: [libvirt] [PATCH v1 8/8] qemu: Implement chardev hotplug on live level
Since previous patches has prepared everything for us, we may now
implement live hotplug of a character device.
---
src/qemu/qemu_driver.c | 10 +++++
src/qemu/qemu_hotplug.c | 97 +++++++++++++++++++++++++++++++++++++++++++++++++
src/qemu/qemu_hotplug.h | 6 +++
3 files changed, 113 insertions(+)
diff --git a/src/qemu/qemu_driver.c b/src/qemu/qemu_driver.c
index 1900c4a..c7481ea 100644
--- a/src/qemu/qemu_driver.c
+++ b/src/qemu/qemu_driver.c
@@ -5807,6 +5807,13 @@ qemuDomainAttachDeviceLive(virDomainObjPtr vm,
dev->data.redirdev = NULL;
break;
+ case VIR_DOMAIN_DEVICE_CHR:
+ ret = qemuDomainAttachChrDevice(driver, vm,
+ dev->data.chr);
+ if (!ret)
+ dev->data.chr = NULL;
+ break;
+
default:
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("device type '%s' cannot be attached"),
@@ -5894,6 +5901,9 @@ qemuDomainDetachDeviceLive(virDomainObjPtr vm,
case VIR_DOMAIN_DEVICE_HOSTDEV:
ret = qemuDomainDetachHostDevice(driver, vm, dev);
break;
+ case VIR_DOMAIN_DEVICE_CHR:
+ ret = qemuDomainDetachChrDevice(driver, vm, dev->data.chr);
+ break;
default:
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("This type of device cannot be hot
unplugged"));
diff --git a/src/qemu/qemu_hotplug.c b/src/qemu/qemu_hotplug.c
index a4f48b0..0535ef6 100644
--- a/src/qemu/qemu_hotplug.c
+++ b/src/qemu/qemu_hotplug.c
@@ -1132,6 +1132,63 @@ error:
}
+int qemuDomainAttachChrDevice(virQEMUDriverPtr driver,
+ virDomainObjPtr vm,
+ virDomainChrDefPtr chr)
+{
+ int ret = -1;
+ qemuDomainObjPrivatePtr priv = vm->privateData;
+ virDomainDefPtr vmdef = vm->def;
+ char *devstr = NULL;
+ char *charAlias = NULL;
+
+ if (virDomainChrFind(vmdef, chr)) {
+ virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+ _("chardev already exists"));
+ return ret;
+ }
+
+ if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+ _("qemu does not support -device"));
+ return ret;
+ }
+
+ if (qemuAssignDeviceChrAlias(vmdef, chr, -1) < 0)
+ return ret;
+
+ if (qemuBuildChrDeviceStr(&devstr, vm->def, chr, priv->qemuCaps) < 0)
+ return ret;
+
+ if (virAsprintf(&charAlias, "char%s", chr->info.alias) < 0) {
+ virReportOOMError();
+ goto cleanup;
+ }
+
+ qemuDomainObjEnterMonitor(driver, vm);
+ if (qemuMonitorAttachCharDev(priv->mon, charAlias, &chr->source) < 0) {
+ qemuDomainObjExitMonitor(driver, vm);
+ goto cleanup;
+ }
+
+ if (devstr && qemuMonitorAddDevice(priv->mon, devstr) < 0) {
+ /* detach associated chardev on error */
+ qemuMonitorDetachCharDev(priv->mon, charAlias);
+ qemuDomainObjExitMonitor(driver, vm);
+ goto cleanup;
+ }
+ qemuDomainObjExitMonitor(driver, vm);
+
+ if (virDomainChrInsert(vmdef, chr) < 0)
+ goto cleanup;
+
+ ret = 0;
+cleanup:
+ VIR_FREE(charAlias);
+ VIR_FREE(devstr);
+ return ret;
+}
+
int qemuDomainAttachHostUsbDevice(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainHostdevDefPtr hostdev)
@@ -2828,3 +2885,43 @@ int qemuDomainDetachLease(virQEMUDriverPtr driver,
virDomainLeaseDefFree(det_lease);
return 0;
}
+
+int qemuDomainDetachChrDevice(virQEMUDriverPtr driver,
+ virDomainObjPtr vm,
+ virDomainChrDefPtr chr)
+{
+ int ret = -1;
+ qemuDomainObjPrivatePtr priv = vm->privateData;
+ virDomainDefPtr vmdef = vm->def;
+ virDomainChrDefPtr tmpChr;
+ char *charAlias = NULL;
+
+ if (!(tmpChr = virDomainChrFind(vmdef, chr))) {
+ virReportError(VIR_ERR_OPERATION_INVALID, "%s",
+ _("device not present in domain configuration"));
+ return ret;
+ }
+
+ if (virAsprintf(&charAlias, "char%s", tmpChr->info.alias) < 0) {
+ virReportOOMError();
+ return ret;
+ }
+
+ qemuDomainObjEnterMonitor(driver, vm);
+ if (qemuMonitorDelDevice(priv->mon, tmpChr->info.alias) < 0) {
+ qemuDomainObjExitMonitor(driver, vm);
+ goto cleanup;
+ }
+
+ if (qemuMonitorDetachCharDev(priv->mon, charAlias) < 0) {
+ qemuDomainObjExitMonitor(driver, vm);
+ goto cleanup;
+ }
+ qemuDomainObjExitMonitor(driver, vm);
+
+ ret = virDomainChrRemove(vmdef, tmpChr);
+
+cleanup:
+ VIR_FREE(charAlias);
+ return ret;
+}
diff --git a/src/qemu/qemu_hotplug.h b/src/qemu/qemu_hotplug.h
index da20eb1..46cd129 100644
--- a/src/qemu/qemu_hotplug.h
+++ b/src/qemu/qemu_hotplug.h
@@ -104,6 +104,12 @@ int qemuDomainAttachLease(virQEMUDriverPtr driver,
int qemuDomainDetachLease(virQEMUDriverPtr driver,
virDomainObjPtr vm,
virDomainLeaseDefPtr lease);
+int qemuDomainAttachChrDevice(virQEMUDriverPtr driver,
+ virDomainObjPtr vm,
+ virDomainChrDefPtr chr);
+int qemuDomainDetachChrDevice(virQEMUDriverPtr driver,
+ virDomainObjPtr vm,
+ virDomainChrDefPtr chr);
#endif /* __QEMU_HOTPLUG_H__ */
--
1.8.1.5
4248
days inactive
4248
days old
8 comments
1 participants
participants (1)
-
Michal Privoznik