2
* qemu_command.c: QEMU command generation
4
* Copyright (C) 2006-2011 Red Hat, Inc.
5
* Copyright (C) 2006 Daniel P. Berrange
7
* This library is free software; you can redistribute it and/or
8
* modify it under the terms of the GNU Lesser General Public
9
* License as published by the Free Software Foundation; either
10
* version 2.1 of the License, or (at your option) any later version.
12
* This library is distributed in the hope that it will be useful,
13
* but WITHOUT ANY WARRANTY; without even the implied warranty of
14
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15
* Lesser General Public License for more details.
17
* You should have received a copy of the GNU Lesser General Public
18
* License along with this library; if not, write to the Free Software
19
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21
* Author: Daniel P. Berrange <berrange@redhat.com>
26
#include "qemu_command.h"
27
#include "qemu_capabilities.h"
28
#include "qemu_bridge_filter.h"
32
#include "virterror_internal.h"
37
#include "domain_nwfilter.h"
38
#include "domain_audit.h"
39
#include "domain_conf.h"
40
#include "network/bridge_driver.h"
41
#include "virnetdevtap.h"
44
#include <sys/utsname.h>
48
#define VIR_FROM_THIS VIR_FROM_QEMU
51
VIR_ENUM_DECL(virDomainDiskQEMUBus)
52
VIR_ENUM_IMPL(virDomainDiskQEMUBus, VIR_DOMAIN_DISK_BUS_LAST,
63
VIR_ENUM_DECL(qemuDiskCacheV1)
64
VIR_ENUM_DECL(qemuDiskCacheV2)
66
VIR_ENUM_IMPL(qemuDiskCacheV1, VIR_DOMAIN_DISK_CACHE_LAST,
69
"off", /* writethrough not supported, so for safety, disable */
70
"on", /* Old 'on' was equivalent to 'writeback' */
71
"off", /* directsync not supported, for safety, disable */
72
"off"); /* unsafe not supported, for safety, disable */
74
VIR_ENUM_IMPL(qemuDiskCacheV2, VIR_DOMAIN_DISK_CACHE_LAST,
82
VIR_ENUM_DECL(qemuVideo)
84
VIR_ENUM_IMPL(qemuVideo, VIR_DOMAIN_VIDEO_TYPE_LAST,
88
"", /* no arg needed for xen */
89
"", /* don't support vbox */
92
VIR_ENUM_DECL(qemuControllerModelUSB)
94
VIR_ENUM_IMPL(qemuControllerModelUSB, VIR_DOMAIN_CONTROLLER_MODEL_USB_LAST,
102
"vt82c686b-usb-uhci",
105
VIR_ENUM_DECL(qemuDomainFSDriver)
106
VIR_ENUM_IMPL(qemuDomainFSDriver, VIR_DOMAIN_FS_DRIVER_TYPE_LAST,
113
uname_normalize (struct utsname *ut)
117
/* Map i386, i486, i586 to i686. */
118
if (ut->machine[0] == 'i' &&
119
ut->machine[1] != '\0' &&
120
ut->machine[2] == '8' &&
121
ut->machine[3] == '6' &&
122
ut->machine[4] == '\0')
123
ut->machine[1] = '6';
128
* qemuPhysIfaceConnect:
129
* @def: the definition of the VM (needed by 802.1Qbh and audit)
130
* @driver: pointer to the qemud_driver
131
* @net: pointer to he VM's interface description with direct device type
132
* @qemuCaps: flags for qemu
133
* @vmop: VM operation type
135
* Returns a filedescriptor on success or -1 in case of error.
138
qemuPhysIfaceConnect(virDomainDefPtr def,
139
struct qemud_driver *driver,
140
virDomainNetDefPtr net,
141
virBitmapPtr qemuCaps,
142
enum virNetDevVPortProfileOp vmop)
145
char *res_ifname = NULL;
148
if (qemuCapsGet(qemuCaps, QEMU_CAPS_VNET_HDR) &&
149
net->model && STREQ(net->model, "virtio"))
152
rc = virNetDevMacVLanCreateWithVPortProfile(
153
net->ifname, net->mac,
154
virDomainNetGetActualDirectDev(net),
155
virDomainNetGetActualDirectMode(net),
156
true, vnet_hdr, def->uuid,
157
virDomainNetGetActualDirectVirtPortProfile(net),
159
vmop, driver->stateDir,
160
virDomainNetGetActualBandwidth(net));
162
virDomainAuditNetDevice(def, net, res_ifname, true);
163
VIR_FREE(net->ifname);
164
net->ifname = res_ifname;
172
qemuNetworkIfaceConnect(virDomainDefPtr def,
174
struct qemud_driver *driver,
175
virDomainNetDefPtr net,
176
virBitmapPtr qemuCaps)
182
bool template_ifname = false;
183
unsigned char tapmac[VIR_MAC_BUFLEN];
184
int actualType = virDomainNetGetActualType(net);
186
if (actualType == VIR_DOMAIN_NET_TYPE_NETWORK) {
187
int active, fail = 0;
189
virNetworkPtr network = virNetworkLookupByName(conn,
190
net->data.network.name);
194
active = virNetworkIsActive(network);
199
qemuReportError(VIR_ERR_INTERNAL_ERROR,
200
_("Network '%s' is not active."),
201
net->data.network.name);
205
brname = virNetworkGetBridgeName(network);
210
/* Make sure any above failure is preserved */
211
errobj = virSaveLastError();
212
virNetworkFree(network);
214
virFreeError(errobj);
219
} else if (actualType == VIR_DOMAIN_NET_TYPE_BRIDGE) {
220
if (!(brname = strdup(virDomainNetGetActualBridgeName(net)))) {
225
qemuReportError(VIR_ERR_INTERNAL_ERROR,
226
_("Network type %d is not supported"),
227
virDomainNetGetActualType(net));
232
STRPREFIX(net->ifname, VIR_NET_GENERATED_PREFIX) ||
233
strchr(net->ifname, '%')) {
234
VIR_FREE(net->ifname);
235
if (!(net->ifname = strdup(VIR_NET_GENERATED_PREFIX "%d"))) {
239
/* avoid exposing vnet%d in getXMLDesc or error outputs */
240
template_ifname = true;
243
if (qemuCapsGet(qemuCaps, QEMU_CAPS_VNET_HDR) &&
244
net->model && STREQ(net->model, "virtio"))
247
memcpy(tapmac, net->mac, VIR_MAC_BUFLEN);
248
tapmac[0] = 0xFE; /* Discourage bridge from using TAP dev MAC */
249
err = virNetDevTapCreateInBridgePort(brname, &net->ifname, tapmac,
250
vnet_hdr, true, &tapfd);
251
virDomainAuditNetDevice(def, net, "/dev/net/tun", tapfd >= 0);
254
VIR_FREE(net->ifname);
258
if (driver->macFilter) {
259
if ((err = networkAllowMacOnPort(driver, net->ifname, net->mac))) {
260
virReportSystemError(err,
261
_("failed to add ebtables rule to allow MAC address on '%s'"),
267
virNetDevBandwidthSet(net->ifname,
268
virDomainNetGetActualBandwidth(net)) < 0) {
269
qemuReportError(VIR_ERR_INTERNAL_ERROR,
270
_("cannot set bandwidth limits on %s"),
272
VIR_FORCE_CLOSE(tapfd);
277
if ((net->filter) && (net->ifname)) {
278
err = virDomainConfNWFilterInstantiate(conn, net);
280
VIR_FORCE_CLOSE(tapfd);
292
qemuOpenVhostNet(virDomainDefPtr def,
293
virDomainNetDefPtr net,
294
virBitmapPtr qemuCaps,
297
*vhostfd = -1; /* assume we won't use vhost */
299
/* If the config says explicitly to not use vhost, return now */
300
if (net->driver.virtio.name == VIR_DOMAIN_NET_BACKEND_TYPE_QEMU) {
304
/* If qemu doesn't support vhost-net mode (including the -netdev command
305
* option), don't try to open the device.
307
if (!(qemuCapsGet(qemuCaps, QEMU_CAPS_VHOST_NET) &&
308
qemuCapsGet(qemuCaps, QEMU_CAPS_NETDEV) &&
309
qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE))) {
310
if (net->driver.virtio.name == VIR_DOMAIN_NET_BACKEND_TYPE_VHOST) {
311
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
312
"%s", _("vhost-net is not supported with "
313
"this QEMU binary"));
319
/* If the nic model isn't virtio, don't try to open. */
320
if (!(net->model && STREQ(net->model, "virtio"))) {
321
if (net->driver.virtio.name == VIR_DOMAIN_NET_BACKEND_TYPE_VHOST) {
322
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
323
"%s", _("vhost-net is only supported for "
324
"virtio network interfaces"));
330
*vhostfd = open("/dev/vhost-net", O_RDWR);
331
virDomainAuditNetDevice(def, net, "/dev/vhost-net", *vhostfd >= 0);
333
/* If the config says explicitly to use vhost and we couldn't open it,
336
if ((*vhostfd < 0) &&
337
(net->driver.virtio.name == VIR_DOMAIN_NET_BACKEND_TYPE_VHOST)) {
338
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
339
"%s", _("vhost-net was requested for an interface, "
340
"but is unavailable"));
347
static int qemuDomainDeviceAliasIndex(virDomainDeviceInfoPtr info,
354
if (!STRPREFIX(info->alias, prefix))
357
if (virStrToLong_i(info->alias + strlen(prefix), NULL, 10, &idx) < 0)
364
int qemuDomainNetVLAN(virDomainNetDefPtr def)
366
return qemuDomainDeviceAliasIndex(&def->info, "net");
370
/* Names used before -drive existed */
371
static int qemuAssignDeviceDiskAliasLegacy(virDomainDiskDefPtr disk)
375
if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM &&
376
STREQ(disk->dst, "hdc"))
377
dev_name = strdup("cdrom");
379
dev_name = strdup(disk->dst);
386
disk->info.alias = dev_name;
391
char *qemuDeviceDriveHostAlias(virDomainDiskDefPtr disk,
392
virBitmapPtr qemuCaps)
396
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
397
if (virAsprintf(&ret, "%s%s", QEMU_DRIVE_HOST_PREFIX, disk->info.alias) < 0) {
402
if (!(ret = strdup(disk->info.alias))) {
411
/* Names used before -drive supported the id= option */
412
static int qemuAssignDeviceDiskAliasFixed(virDomainDiskDefPtr disk)
418
if (virDiskNameToBusDeviceIndex(disk, &busid, &devid) < 0) {
419
qemuReportError(VIR_ERR_INTERNAL_ERROR,
420
_("cannot convert disk '%s' to bus/device index"),
426
case VIR_DOMAIN_DISK_BUS_IDE:
427
if (disk->device== VIR_DOMAIN_DISK_DEVICE_DISK)
428
ret = virAsprintf(&dev_name, "ide%d-hd%d", busid, devid);
430
ret = virAsprintf(&dev_name, "ide%d-cd%d", busid, devid);
432
case VIR_DOMAIN_DISK_BUS_SCSI:
433
if (disk->device == VIR_DOMAIN_DISK_DEVICE_DISK)
434
ret = virAsprintf(&dev_name, "scsi%d-hd%d", busid, devid);
436
ret = virAsprintf(&dev_name, "scsi%d-cd%d", busid, devid);
438
case VIR_DOMAIN_DISK_BUS_FDC:
439
ret = virAsprintf(&dev_name, "floppy%d", devid);
441
case VIR_DOMAIN_DISK_BUS_VIRTIO:
442
ret = virAsprintf(&dev_name, "virtio%d", devid);
444
case VIR_DOMAIN_DISK_BUS_XEN:
445
ret = virAsprintf(&dev_name, "xenblk%d", devid);
448
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
449
_("Unsupported disk name mapping for bus '%s'"),
450
virDomainDiskBusTypeToString(disk->bus));
459
disk->info.alias = dev_name;
465
/* Our custom -drive naming scheme used with id= */
466
static int qemuAssignDeviceDiskAliasCustom(virDomainDiskDefPtr disk)
468
const char *prefix = virDomainDiskBusTypeToString(disk->bus);
469
if (disk->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE) {
470
if (virAsprintf(&disk->info.alias, "%s%d-%d-%d", prefix,
471
disk->info.addr.drive.controller,
472
disk->info.addr.drive.bus,
473
disk->info.addr.drive.unit) < 0)
476
int idx = virDiskNameToIndex(disk->dst);
477
if (virAsprintf(&disk->info.alias, "%s-disk%d", prefix, idx) < 0)
490
qemuAssignDeviceDiskAlias(virDomainDiskDefPtr def, virBitmapPtr qemuCaps)
492
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE)) {
493
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
494
return qemuAssignDeviceDiskAliasCustom(def);
496
return qemuAssignDeviceDiskAliasFixed(def);
498
return qemuAssignDeviceDiskAliasLegacy(def);
504
qemuAssignDeviceNetAlias(virDomainDefPtr def, virDomainNetDefPtr net, int idx)
509
for (i = 0 ; i < def->nnets ; i++) {
511
if ((thisidx = qemuDomainDeviceAliasIndex(&def->nets[i]->info, "net")) < 0) {
512
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
513
_("Unable to determine device index for network device"));
521
if (virAsprintf(&net->info.alias, "net%d", idx) < 0) {
531
qemuAssignDeviceHostdevAlias(virDomainDefPtr def, virDomainHostdevDefPtr hostdev, int idx)
536
for (i = 0 ; i < def->nhostdevs ; i++) {
538
if ((thisidx = qemuDomainDeviceAliasIndex(&def->hostdevs[i]->info, "hostdev")) < 0) {
539
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
540
_("Unable to determine device index for hostdev device"));
548
if (virAsprintf(&hostdev->info.alias, "hostdev%d", idx) < 0) {
558
qemuAssignDeviceRedirdevAlias(virDomainDefPtr def, virDomainRedirdevDefPtr redirdev, int idx)
563
for (i = 0 ; i < def->nredirdevs ; i++) {
565
if ((thisidx = qemuDomainDeviceAliasIndex(&def->redirdevs[i]->info, "redir")) < 0) {
566
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
567
_("Unable to determine device index for redirected device"));
575
if (virAsprintf(&redirdev->info.alias, "redir%d", idx) < 0) {
585
qemuAssignDeviceControllerAlias(virDomainControllerDefPtr controller)
587
const char *prefix = virDomainControllerTypeToString(controller->type);
589
if (virAsprintf(&controller->info.alias, "%s%d", prefix,
590
controller->idx) < 0) {
600
qemuAssignDeviceAliases(virDomainDefPtr def, virBitmapPtr qemuCaps)
604
for (i = 0; i < def->ndisks ; i++) {
605
if (qemuAssignDeviceDiskAlias(def->disks[i], qemuCaps) < 0)
608
if (qemuCapsGet(qemuCaps, QEMU_CAPS_NET_NAME) ||
609
qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
610
for (i = 0; i < def->nnets ; i++) {
611
if (qemuAssignDeviceNetAlias(def, def->nets[i], i) < 0)
616
if (!qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
619
for (i = 0; i < def->nfss ; i++) {
620
if (virAsprintf(&def->fss[i]->info.alias, "fs%d", i) < 0)
623
for (i = 0; i < def->nsounds ; i++) {
624
if (virAsprintf(&def->sounds[i]->info.alias, "sound%d", i) < 0)
627
for (i = 0; i < def->nhostdevs ; i++) {
628
if (qemuAssignDeviceHostdevAlias(def, def->hostdevs[i], i) < 0)
631
for (i = 0; i < def->nredirdevs ; i++) {
632
if (qemuAssignDeviceRedirdevAlias(def, def->redirdevs[i], i) < 0)
635
for (i = 0; i < def->nvideos ; i++) {
636
if (virAsprintf(&def->videos[i]->info.alias, "video%d", i) < 0)
639
for (i = 0; i < def->ncontrollers ; i++) {
640
if (qemuAssignDeviceControllerAlias(def->controllers[i]) < 0)
643
for (i = 0; i < def->ninputs ; i++) {
644
if (virAsprintf(&def->inputs[i]->info.alias, "input%d", i) < 0)
647
for (i = 0; i < def->nparallels ; i++) {
648
if (virAsprintf(&def->parallels[i]->info.alias, "parallel%d", i) < 0)
651
for (i = 0; i < def->nserials ; i++) {
652
if (virAsprintf(&def->serials[i]->info.alias, "serial%d", i) < 0)
655
for (i = 0; i < def->nchannels ; i++) {
656
if (virAsprintf(&def->channels[i]->info.alias, "channel%d", i) < 0)
659
for (i = 0; i < def->nconsoles ; i++) {
660
if (virAsprintf(&def->consoles[i]->info.alias, "console%d", i) < 0)
663
for (i = 0; i < def->nhubs ; i++) {
664
if (virAsprintf(&def->hubs[i]->info.alias, "hub%d", i) < 0)
667
for (i = 0; i < def->nsmartcards ; i++) {
668
if (virAsprintf(&def->smartcards[i]->info.alias, "smartcard%d", i) < 0)
672
if (virAsprintf(&def->watchdog->info.alias, "watchdog%d", 0) < 0)
675
if (def->memballoon) {
676
if (virAsprintf(&def->memballoon->info.alias, "balloon%d", 0) < 0)
688
#define QEMU_PCI_ADDRESS_LAST_SLOT 31
689
#define QEMU_PCI_ADDRESS_LAST_FUNCTION 8
690
struct _qemuDomainPCIAddressSet {
691
virHashTablePtr used;
696
static char *qemuPCIAddressAsString(virDomainDeviceInfoPtr dev)
700
if (dev->addr.pci.domain != 0 ||
701
dev->addr.pci.bus != 0) {
702
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
703
_("Only PCI domain 0 and bus 0 are available"));
707
if (virAsprintf(&addr, "%d:%d:%d.%d",
708
dev->addr.pci.domain,
711
dev->addr.pci.function) < 0) {
719
static int qemuCollectPCIAddress(virDomainDefPtr def ATTRIBUTE_UNUSED,
720
virDomainDeviceInfoPtr dev,
725
qemuDomainPCIAddressSetPtr addrs = opaque;
727
if (dev->type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)
730
addr = qemuPCIAddressAsString(dev);
734
if (virHashLookup(addrs->used, addr)) {
735
if (dev->addr.pci.function != 0) {
736
qemuReportError(VIR_ERR_XML_ERROR,
737
_("Attempted double use of PCI Address '%s' "
738
"(may need \"multifunction='on'\" for device on function 0"),
741
qemuReportError(VIR_ERR_XML_ERROR,
742
_("Attempted double use of PCI Address '%s'"), addr);
747
VIR_DEBUG("Remembering PCI addr %s", addr);
748
if (virHashAddEntry(addrs->used, addr, addr) < 0)
752
if ((dev->addr.pci.function == 0) &&
753
(dev->addr.pci.multi != VIR_DOMAIN_DEVICE_ADDRESS_PCI_MULTI_ON)) {
754
/* a function 0 w/o multifunction=on must reserve the entire slot */
756
virDomainDeviceInfo temp_dev = *dev;
758
for (function = 1; function < QEMU_PCI_ADDRESS_LAST_FUNCTION; function++) {
759
temp_dev.addr.pci.function = function;
760
addr = qemuPCIAddressAsString(&temp_dev);
764
if (virHashLookup(addrs->used, addr)) {
765
qemuReportError(VIR_ERR_XML_ERROR,
766
_("Attempted double use of PCI Address '%s'"
767
"(need \"multifunction='off'\" for device on function 0)"),
772
VIR_DEBUG("Remembering PCI addr %s (multifunction=off for function 0)", addr);
773
if (virHashAddEntry(addrs->used, addr, addr))
786
qemuDomainAssignPCIAddresses(virDomainDefPtr def)
789
virBitmapPtr qemuCaps = NULL;
790
qemuDomainPCIAddressSetPtr addrs = NULL;
792
if (qemuCapsExtractVersionInfo(def->emulator, def->os.arch,
797
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
798
if (!(addrs = qemuDomainPCIAddressSetCreate(def)))
801
if (qemuAssignDevicePCISlots(def, addrs) < 0)
808
qemuCapsFree(qemuCaps);
809
qemuDomainPCIAddressSetFree(addrs);
816
qemuDomainPCIAddressSetFreeEntry(void *payload,
817
const void *name ATTRIBUTE_UNUSED)
822
qemuDomainPCIAddressSetPtr qemuDomainPCIAddressSetCreate(virDomainDefPtr def)
824
qemuDomainPCIAddressSetPtr addrs;
826
if (VIR_ALLOC(addrs) < 0)
829
if (!(addrs->used = virHashCreate(10, qemuDomainPCIAddressSetFreeEntry)))
832
if (virDomainDeviceInfoIterate(def, qemuCollectPCIAddress, addrs) < 0)
840
qemuDomainPCIAddressSetFree(addrs);
844
/* check whether the slot is used by the other device
845
* Return 0 if the slot is not used by the other device, or -1 if the slot
846
* is used by the other device.
848
static int qemuDomainPCIAddressCheckSlot(qemuDomainPCIAddressSetPtr addrs,
849
virDomainDeviceInfoPtr dev)
852
virDomainDeviceInfo temp_dev;
856
for (function = 0; function < QEMU_PCI_ADDRESS_LAST_FUNCTION; function++) {
857
temp_dev.addr.pci.function = function;
858
addr = qemuPCIAddressAsString(&temp_dev);
862
if (virHashLookup(addrs->used, addr)) {
873
int qemuDomainPCIAddressReserveAddr(qemuDomainPCIAddressSetPtr addrs,
874
virDomainDeviceInfoPtr dev)
878
addr = qemuPCIAddressAsString(dev);
882
VIR_DEBUG("Reserving PCI addr %s", addr);
884
if (virHashLookup(addrs->used, addr)) {
885
qemuReportError(VIR_ERR_INTERNAL_ERROR,
886
_("unable to reserve PCI address %s"), addr);
891
if (virHashAddEntry(addrs->used, addr, addr)) {
896
if (dev->addr.pci.slot > addrs->nextslot) {
897
addrs->nextslot = dev->addr.pci.slot + 1;
898
if (QEMU_PCI_ADDRESS_LAST_SLOT < addrs->nextslot)
905
int qemuDomainPCIAddressReserveFunction(qemuDomainPCIAddressSetPtr addrs,
906
int slot, int function)
908
virDomainDeviceInfo dev;
910
dev.addr.pci.domain = 0;
911
dev.addr.pci.bus = 0;
912
dev.addr.pci.slot = slot;
913
dev.addr.pci.function = function;
915
return qemuDomainPCIAddressReserveAddr(addrs, &dev);
918
int qemuDomainPCIAddressReserveSlot(qemuDomainPCIAddressSetPtr addrs,
923
for (function = 0; function < QEMU_PCI_ADDRESS_LAST_FUNCTION; function++) {
924
if (qemuDomainPCIAddressReserveFunction(addrs, slot, function) < 0)
931
for (function--; function >= 0; function--) {
932
qemuDomainPCIAddressReleaseFunction(addrs, slot, function);
937
int qemuDomainPCIAddressEnsureAddr(qemuDomainPCIAddressSetPtr addrs,
938
virDomainDeviceInfoPtr dev)
941
if (dev->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
942
/* We do not support hotplug multi-function PCI device now, so we should
943
* reserve the whole slot. The function of the PCI device must be 0.
945
if (dev->addr.pci.function != 0) {
946
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
947
_("Only PCI device addresses with function=0"
952
ret = qemuDomainPCIAddressReserveSlot(addrs, dev->addr.pci.slot);
954
ret = qemuDomainPCIAddressSetNextAddr(addrs, dev);
960
int qemuDomainPCIAddressReleaseAddr(qemuDomainPCIAddressSetPtr addrs,
961
virDomainDeviceInfoPtr dev)
966
addr = qemuPCIAddressAsString(dev);
970
ret = virHashRemoveEntry(addrs->used, addr);
977
int qemuDomainPCIAddressReleaseFunction(qemuDomainPCIAddressSetPtr addrs,
978
int slot, int function)
980
virDomainDeviceInfo dev;
982
dev.addr.pci.domain = 0;
983
dev.addr.pci.bus = 0;
984
dev.addr.pci.slot = slot;
985
dev.addr.pci.function = function;
987
return qemuDomainPCIAddressReleaseAddr(addrs, &dev);
990
int qemuDomainPCIAddressReleaseSlot(qemuDomainPCIAddressSetPtr addrs, int slot)
992
virDomainDeviceInfo dev;
995
unsigned int *function = &dev.addr.pci.function;
997
dev.addr.pci.domain = 0;
998
dev.addr.pci.bus = 0;
999
dev.addr.pci.slot = slot;
1001
for (*function = 0; *function < QEMU_PCI_ADDRESS_LAST_FUNCTION; (*function)++) {
1002
addr = qemuPCIAddressAsString(&dev);
1006
if (!virHashLookup(addrs->used, addr)) {
1013
if (qemuDomainPCIAddressReleaseFunction(addrs, slot, *function) < 0)
1020
void qemuDomainPCIAddressSetFree(qemuDomainPCIAddressSetPtr addrs)
1025
virHashFree(addrs->used);
1030
int qemuDomainPCIAddressSetNextAddr(qemuDomainPCIAddressSetPtr addrs,
1031
virDomainDeviceInfoPtr dev)
1036
for (i = addrs->nextslot, iteration = 0;
1037
iteration <= QEMU_PCI_ADDRESS_LAST_SLOT; i++, iteration++) {
1038
virDomainDeviceInfo maybe;
1041
if (QEMU_PCI_ADDRESS_LAST_SLOT < i)
1043
memset(&maybe, 0, sizeof(maybe));
1044
maybe.addr.pci.domain = 0;
1045
maybe.addr.pci.bus = 0;
1046
maybe.addr.pci.slot = i;
1047
maybe.addr.pci.function = 0;
1049
if (!(addr = qemuPCIAddressAsString(&maybe)))
1052
if (qemuDomainPCIAddressCheckSlot(addrs, &maybe) < 0) {
1053
VIR_DEBUG("PCI addr %s already in use", addr);
1058
VIR_DEBUG("Allocating PCI addr %s", addr);
1061
if (qemuDomainPCIAddressReserveSlot(addrs, i) < 0)
1064
dev->type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
1065
dev->addr.pci = maybe.addr.pci;
1067
addrs->nextslot = i + 1;
1068
if (QEMU_PCI_ADDRESS_LAST_SLOT < addrs->nextslot)
1069
addrs->nextslot = 0;
1074
qemuReportError(VIR_ERR_INTERNAL_ERROR,
1075
"%s", _("No more available PCI addresses"));
1080
* This assigns static PCI slots to all configured devices.
1081
* The ordering here is chosen to match the ordering used
1082
* with old QEMU < 0.12, so that if a user updates a QEMU
1083
* host from old QEMU to QEMU >= 0.12, their guests should
1084
* get PCI addresses in the same order as before.
1086
* NB, if they previously hotplugged devices then all bets
1087
* are off. Hotplug for old QEMU was unfixably broken wrt
1088
* to stable PCI addressing.
1092
* - Host bridge (slot 0)
1093
* - PIIX3 ISA bridge, IDE controller, something else unknown, USB controller (slot 1)
1096
* Incrementally assign slots from 3 onwards:
1100
* - SCSI controllers
1103
* - Host device passthrough
1104
* - Watchdog (not IB700)
1106
* Prior to this function being invoked, qemuCollectPCIAddress() will have
1107
* added all existing PCI addresses from the 'def' to 'addrs'. Thus this
1108
* function must only try to reserve addresses if info.type == NONE and
1109
* skip over info.type == PCI
1112
qemuAssignDevicePCISlots(virDomainDefPtr def, qemuDomainPCIAddressSetPtr addrs)
1115
bool reservedIDE = false;
1116
bool reservedUSB = false;
1117
bool reservedVGA = false;
1121
if (qemuDomainPCIAddressReserveSlot(addrs, 0) < 0)
1124
/* Verify that first IDE and USB controllers (if any) is on the PIIX3, fn 1 */
1125
for (i = 0; i < def->ncontrollers ; i++) {
1126
/* First IDE controller lives on the PIIX3 at slot=1, function=1 */
1127
if (def->controllers[i]->type == VIR_DOMAIN_CONTROLLER_TYPE_IDE &&
1128
def->controllers[i]->idx == 0) {
1129
if (def->controllers[i]->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
1130
if (def->controllers[i]->info.addr.pci.domain != 0 ||
1131
def->controllers[i]->info.addr.pci.bus != 0 ||
1132
def->controllers[i]->info.addr.pci.slot != 1 ||
1133
def->controllers[i]->info.addr.pci.function != 1) {
1134
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1135
_("Primary IDE controller must have PCI address 0:0:1.1"));
1138
/* If TYPE==PCI, then qemuCollectPCIAddress() function
1139
* has already reserved the address, so we must skip */
1142
def->controllers[i]->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
1143
def->controllers[i]->info.addr.pci.domain = 0;
1144
def->controllers[i]->info.addr.pci.bus = 0;
1145
def->controllers[i]->info.addr.pci.slot = 1;
1146
def->controllers[i]->info.addr.pci.function = 1;
1148
} else if (def->controllers[i]->type == VIR_DOMAIN_CONTROLLER_TYPE_USB &&
1149
def->controllers[i]->idx == 0 &&
1150
(def->controllers[i]->model == VIR_DOMAIN_CONTROLLER_MODEL_USB_PIIX3_UHCI ||
1151
def->controllers[i]->model == -1)) {
1152
if (def->controllers[i]->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
1153
if (def->controllers[i]->info.addr.pci.domain != 0 ||
1154
def->controllers[i]->info.addr.pci.bus != 0 ||
1155
def->controllers[i]->info.addr.pci.slot != 1 ||
1156
def->controllers[i]->info.addr.pci.function != 2) {
1157
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1158
_("PIIX3 USB controller must have PCI address 0:0:1.2"));
1163
def->controllers[i]->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
1164
def->controllers[i]->info.addr.pci.domain = 0;
1165
def->controllers[i]->info.addr.pci.bus = 0;
1166
def->controllers[i]->info.addr.pci.slot = 1;
1167
def->controllers[i]->info.addr.pci.function = 2;
1172
/* PIIX3 (ISA bridge, IDE controller, something else unknown, USB controller)
1173
* hardcoded slot=1, multifunction device
1175
for (function = 0; function < QEMU_PCI_ADDRESS_LAST_FUNCTION; function++) {
1176
if ((function == 1 && reservedIDE) ||
1177
(function == 2 && reservedUSB))
1178
/* we have reserved this pci address */
1181
if (qemuDomainPCIAddressReserveFunction(addrs, 1, function) < 0)
1185
/* First VGA is hardcoded slot=2 */
1186
if (def->nvideos > 0) {
1187
if (def->videos[0]->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
1188
if (def->videos[0]->info.addr.pci.domain != 0 ||
1189
def->videos[0]->info.addr.pci.bus != 0 ||
1190
def->videos[0]->info.addr.pci.slot != 2 ||
1191
def->videos[0]->info.addr.pci.function != 0) {
1192
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1193
_("Primary video card must have PCI address 0:0:2.0"));
1196
/* If TYPE==PCI, then qemuCollectPCIAddress() function
1197
* has already reserved the address, so we must skip */
1200
def->videos[0]->info.type = VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI;
1201
def->videos[0]->info.addr.pci.domain = 0;
1202
def->videos[0]->info.addr.pci.bus = 0;
1203
def->videos[0]->info.addr.pci.slot = 2;
1204
def->videos[0]->info.addr.pci.function = 0;
1209
&& qemuDomainPCIAddressReserveSlot(addrs, 2) < 0)
1212
for (i = 0; i < def->nfss ; i++) {
1213
if (def->fss[i]->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE)
1216
/* Only support VirtIO-9p-pci so far. If that changes,
1217
* we might need to skip devices here */
1218
if (qemuDomainPCIAddressSetNextAddr(addrs, &def->fss[i]->info) < 0)
1222
/* Network interfaces */
1223
for (i = 0; i < def->nnets ; i++) {
1224
if (def->nets[i]->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE)
1226
if (qemuDomainPCIAddressSetNextAddr(addrs, &def->nets[i]->info) < 0)
1231
for (i = 0; i < def->nsounds ; i++) {
1232
if (def->sounds[i]->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE)
1234
/* Skip ISA sound card, and PCSPK */
1235
if (def->sounds[i]->model == VIR_DOMAIN_SOUND_MODEL_SB16 ||
1236
def->sounds[i]->model == VIR_DOMAIN_SOUND_MODEL_PCSPK)
1239
if (qemuDomainPCIAddressSetNextAddr(addrs, &def->sounds[i]->info) < 0)
1243
/* Disk controllers (SCSI only for now) */
1244
for (i = 0; i < def->ncontrollers ; i++) {
1245
/* FDC lives behind the ISA bridge; CCID is a usb device */
1246
if (def->controllers[i]->type == VIR_DOMAIN_CONTROLLER_TYPE_FDC ||
1247
def->controllers[i]->type == VIR_DOMAIN_CONTROLLER_TYPE_CCID)
1250
/* First IDE controller lives on the PIIX3 at slot=1, function=1,
1251
dealt with earlier on*/
1252
if (def->controllers[i]->type == VIR_DOMAIN_CONTROLLER_TYPE_IDE &&
1253
def->controllers[i]->idx == 0)
1256
if (def->controllers[i]->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE)
1258
if (qemuDomainPCIAddressSetNextAddr(addrs, &def->controllers[i]->info) < 0)
1262
/* Disks (VirtIO only for now) */
1263
for (i = 0; i < def->ndisks ; i++) {
1264
/* Only VirtIO disks use PCI addrs */
1265
if (def->disks[i]->bus != VIR_DOMAIN_DISK_BUS_VIRTIO)
1268
if (def->disks[i]->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI)
1271
if (def->disks[i]->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE) {
1272
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
1273
_("virtio only support device address type 'PCI'"));
1277
if (qemuDomainPCIAddressSetNextAddr(addrs, &def->disks[i]->info) < 0)
1281
/* Host PCI devices */
1282
for (i = 0; i < def->nhostdevs ; i++) {
1283
if (def->hostdevs[i]->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE)
1285
if (def->hostdevs[i]->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS ||
1286
def->hostdevs[i]->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI)
1289
if (qemuDomainPCIAddressSetNextAddr(addrs, &def->hostdevs[i]->info) < 0)
1293
/* VirtIO balloon */
1294
if (def->memballoon &&
1295
def->memballoon->model == VIR_DOMAIN_MEMBALLOON_MODEL_VIRTIO &&
1296
def->memballoon->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE) {
1297
if (qemuDomainPCIAddressSetNextAddr(addrs, &def->memballoon->info) < 0)
1301
/* A watchdog - skip IB700, it is not a PCI device */
1302
if (def->watchdog &&
1303
def->watchdog->model != VIR_DOMAIN_WATCHDOG_MODEL_IB700 &&
1304
def->watchdog->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE) {
1305
if (qemuDomainPCIAddressSetNextAddr(addrs, &def->watchdog->info) < 0)
1309
/* Further non-primary video cards */
1310
for (i = 1; i < def->nvideos ; i++) {
1311
if (def->videos[i]->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE)
1313
if (qemuDomainPCIAddressSetNextAddr(addrs, &def->videos[i]->info) < 0)
1316
for (i = 0; i < def->ninputs ; i++) {
1317
/* Nada - none are PCI based (yet) */
1319
for (i = 0; i < def->nparallels ; i++) {
1320
/* Nada - none are PCI based (yet) */
1322
for (i = 0; i < def->nserials ; i++) {
1323
/* Nada - none are PCI based (yet) */
1325
for (i = 0; i < def->nchannels ; i++) {
1326
/* Nada - none are PCI based (yet) */
1328
for (i = 0; i < def->nhubs ; i++) {
1329
/* Nada - none are PCI based (yet) */
1339
qemuUsbId(virBufferPtr buf, int idx)
1342
virBufferAsprintf(buf, "usb");
1344
virBufferAsprintf(buf, "usb%d", idx);
1348
qemuBuildDeviceAddressStr(virBufferPtr buf,
1349
virDomainDeviceInfoPtr info,
1350
virBitmapPtr qemuCaps)
1352
if (info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
1353
if (info->addr.pci.domain != 0) {
1354
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1355
_("Only PCI device addresses with domain=0 are supported"));
1358
if (info->addr.pci.bus != 0) {
1359
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1360
_("Only PCI device addresses with bus=0 are supported"));
1363
if (qemuCapsGet(qemuCaps, QEMU_CAPS_PCI_MULTIFUNCTION)) {
1364
if (info->addr.pci.function > 7) {
1365
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1366
_("The function of PCI device addresses must "
1371
if (info->addr.pci.function != 0) {
1372
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1373
_("Only PCI device addresses with function=0 "
1374
"are supported with this QEMU binary"));
1377
if (info->addr.pci.multi == VIR_DOMAIN_DEVICE_ADDRESS_PCI_MULTI_ON) {
1378
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
1379
_("'multifunction=on' is not supported with "
1380
"this QEMU binary"));
1386
* When QEMU grows support for > 1 PCI bus, then pci.0 changes
1387
* to pci.1, pci.2, etc
1388
* When QEMU grows support for > 1 PCI domain, then pci.0 change
1389
* to pciNN.0 where NN is the domain number
1391
if (qemuCapsGet(qemuCaps, QEMU_CAPS_PCI_MULTIBUS))
1392
virBufferAsprintf(buf, ",bus=pci.0");
1394
virBufferAsprintf(buf, ",bus=pci");
1395
if (info->addr.pci.multi == VIR_DOMAIN_DEVICE_ADDRESS_PCI_MULTI_ON)
1396
virBufferAddLit(buf, ",multifunction=on");
1397
else if (info->addr.pci.multi == VIR_DOMAIN_DEVICE_ADDRESS_PCI_MULTI_OFF)
1398
virBufferAddLit(buf, ",multifunction=off");
1399
virBufferAsprintf(buf, ",addr=0x%x", info->addr.pci.slot);
1400
if (info->addr.pci.function != 0)
1401
virBufferAsprintf(buf, ".0x%x", info->addr.pci.function);
1402
} else if (info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_USB) {
1403
virBufferAsprintf(buf, ",bus=");
1404
qemuUsbId(buf, info->addr.usb.bus);
1405
virBufferAsprintf(buf, ".0,port=%s", info->addr.usb.port);
1412
qemuBuildIoEventFdStr(virBufferPtr buf,
1413
enum virDomainIoEventFd use,
1414
virBitmapPtr qemuCaps)
1416
if (use && qemuCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_IOEVENTFD))
1417
virBufferAsprintf(buf, ",ioeventfd=%s",
1418
virDomainIoEventFdTypeToString(use));
1422
#define QEMU_SERIAL_PARAM_ACCEPTED_CHARS \
1423
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_"
1426
qemuSafeSerialParamValue(const char *value)
1428
if (strspn(value, QEMU_SERIAL_PARAM_ACCEPTED_CHARS) != strlen (value)) {
1429
qemuReportError(VIR_ERR_INTERNAL_ERROR,
1430
_("driver serial '%s' contains unsafe characters"),
1439
qemuBuildRBDString(virConnectPtr conn,
1440
virDomainDiskDefPtr disk,
1444
virSecretPtr sec = NULL;
1445
char *secret = NULL;
1448
virBufferAsprintf(opt, "rbd:%s", disk->src);
1449
if (disk->auth.username) {
1450
virBufferEscape(opt, ":", ":id=%s", disk->auth.username);
1451
/* look up secret */
1452
switch (disk->auth.secretType) {
1453
case VIR_DOMAIN_DISK_SECRET_TYPE_UUID:
1454
sec = virSecretLookupByUUID(conn,
1455
disk->auth.secret.uuid);
1457
case VIR_DOMAIN_DISK_SECRET_TYPE_USAGE:
1458
sec = virSecretLookupByUsage(conn,
1459
VIR_SECRET_USAGE_TYPE_CEPH,
1460
disk->auth.secret.usage);
1465
char *base64 = NULL;
1467
secret = (char *)conn->secretDriver->getValue(sec, &secret_size, 0,
1468
VIR_SECRET_GET_VALUE_INTERNAL_CALL);
1469
if (secret == NULL) {
1470
qemuReportError(VIR_ERR_INTERNAL_ERROR,
1471
_("could not get the value of the secret for username %s"),
1472
disk->auth.username);
1475
/* qemu/librbd wants it base64 encoded */
1476
base64_encode_alloc(secret, secret_size, &base64);
1478
virReportOOMError();
1481
virBufferEscape(opt, ":", ":key=%s:auth_supported=cephx none",
1485
qemuReportError(VIR_ERR_INTERNAL_ERROR,
1486
_("rbd username '%s' specified but secret not found"),
1487
disk->auth.username);
1492
if (disk->nhosts > 0) {
1493
virBufferAddLit(opt, ":mon_host=");
1494
for (i = 0; i < disk->nhosts; ++i) {
1496
virBufferAddLit(opt, "\\;");
1498
if (disk->hosts[i].port) {
1499
virBufferAsprintf(opt, "%s\\:%s",
1500
disk->hosts[i].name,
1501
disk->hosts[i].port);
1503
virBufferAsprintf(opt, "%s", disk->hosts[i].name);
1511
virUnrefSecret(sec);
1520
static int qemuAddRBDHost(virDomainDiskDefPtr disk, char *hostport)
1525
if (VIR_REALLOC_N(disk->hosts, disk->nhosts) < 0)
1528
port = strstr(hostport, "\\:");
1532
disk->hosts[disk->nhosts-1].port = strdup(port);
1533
if (!disk->hosts[disk->nhosts-1].port)
1536
disk->hosts[disk->nhosts-1].port = strdup("6789");
1537
if (!disk->hosts[disk->nhosts-1].port)
1540
disk->hosts[disk->nhosts-1].name = strdup(hostport);
1541
if (!disk->hosts[disk->nhosts-1].name)
1546
virReportOOMError();
1547
VIR_FREE(disk->hosts[disk->nhosts-1].port);
1548
VIR_FREE(disk->hosts[disk->nhosts-1].name);
1552
/* disk->src initially has everything after the rbd: prefix */
1553
static int qemuParseRBDString(virDomainDiskDefPtr disk)
1555
char *options = NULL;
1558
p = strchr(disk->src, ':');
1560
options = strdup(p + 1);
1568
return 0; /* all done */
1572
/* find : delimiter or end of string */
1573
for (e = p; *e && *e != ':'; ++e) {
1581
next = e; /* last kv pair */
1587
if (STRPREFIX(p, "id=")) {
1588
disk->auth.username = strdup(p + strlen("id="));
1589
if (!disk->auth.username)
1592
if (STRPREFIX(p, "mon_host=")) {
1595
h = p + strlen("mon_host=");
1597
for (sep = h; sep < e; ++sep) {
1598
if (*sep == '\\' && (sep[1] == ',' ||
1606
if (qemuAddRBDHost(disk, h) < 0) {
1618
virReportOOMError();
1623
qemuBuildDriveStr(virConnectPtr conn ATTRIBUTE_UNUSED,
1624
virDomainDiskDefPtr disk,
1626
virBitmapPtr qemuCaps)
1628
virBuffer opt = VIR_BUFFER_INITIALIZER;
1629
const char *bus = virDomainDiskQEMUBusTypeToString(disk->bus);
1630
int idx = virDiskNameToIndex(disk->dst);
1631
int busid = -1, unitid = -1;
1634
qemuReportError(VIR_ERR_INTERNAL_ERROR,
1635
_("unsupported disk type '%s'"), disk->dst);
1639
switch (disk->bus) {
1640
case VIR_DOMAIN_DISK_BUS_SCSI:
1641
if (disk->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE) {
1642
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1643
_("unexpected address type for scsi disk"));
1647
/* Setting bus= attr for SCSI drives, causes a controller
1648
* to be created. Yes this is slightly odd. It is not possible
1649
* to have > 1 bus on a SCSI controller (yet). */
1650
if (disk->info.addr.drive.bus != 0) {
1651
qemuReportError(VIR_ERR_INTERNAL_ERROR,
1652
"%s", _("SCSI controller only supports 1 bus"));
1655
busid = disk->info.addr.drive.controller;
1656
unitid = disk->info.addr.drive.unit;
1659
case VIR_DOMAIN_DISK_BUS_IDE:
1660
if (disk->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE) {
1661
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1662
_("unexpected address type for ide disk"));
1665
/* We can only have 1 IDE controller (currently) */
1666
if (disk->info.addr.drive.controller != 0) {
1667
qemuReportError(VIR_ERR_INTERNAL_ERROR,
1668
_("Only 1 %s controller is supported"), bus);
1671
busid = disk->info.addr.drive.bus;
1672
unitid = disk->info.addr.drive.unit;
1675
case VIR_DOMAIN_DISK_BUS_FDC:
1676
if (disk->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_DRIVE) {
1677
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1678
_("unexpected address type for fdc disk"));
1681
/* We can only have 1 FDC controller (currently) */
1682
if (disk->info.addr.drive.controller != 0) {
1683
qemuReportError(VIR_ERR_INTERNAL_ERROR,
1684
_("Only 1 %s controller is supported"), bus);
1687
/* We can only have 1 FDC bus (currently) */
1688
if (disk->info.addr.drive.bus != 0) {
1689
qemuReportError(VIR_ERR_INTERNAL_ERROR,
1690
_("Only 1 %s bus is supported"), bus);
1693
unitid = disk->info.addr.drive.unit;
1697
case VIR_DOMAIN_DISK_BUS_VIRTIO:
1698
/* Each virtio drive is a separate PCI device, no unit/busid or index */
1702
case VIR_DOMAIN_DISK_BUS_XEN:
1703
/* Xen has no address type currently, so assign based on index */
1707
/* disk->src is NULL when we use nbd disks */
1708
if (disk->src || (disk->type == VIR_DOMAIN_DISK_TYPE_NETWORK &&
1709
disk->protocol == VIR_DOMAIN_DISK_PROTOCOL_NBD)) {
1710
if (disk->type == VIR_DOMAIN_DISK_TYPE_DIR) {
1711
/* QEMU only supports magic FAT format for now */
1712
if (disk->driverType &&
1713
STRNEQ(disk->driverType, "fat")) {
1714
qemuReportError(VIR_ERR_INTERNAL_ERROR,
1715
_("unsupported disk driver type for '%s'"),
1719
if (!disk->readonly) {
1720
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1721
_("cannot create virtual FAT disks in read-write mode"));
1724
if (disk->device == VIR_DOMAIN_DISK_DEVICE_FLOPPY)
1725
virBufferAsprintf(&opt, "file=fat:floppy:%s,", disk->src);
1727
virBufferAsprintf(&opt, "file=fat:%s,", disk->src);
1728
} else if (disk->type == VIR_DOMAIN_DISK_TYPE_NETWORK) {
1729
switch (disk->protocol) {
1730
case VIR_DOMAIN_DISK_PROTOCOL_NBD:
1731
if (disk->nhosts != 1) {
1732
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1733
_("NBD accepts only one host"));
1736
virBufferAsprintf(&opt, "file=nbd:%s:%s,",
1737
disk->hosts->name, disk->hosts->port);
1739
case VIR_DOMAIN_DISK_PROTOCOL_RBD:
1740
virBufferAddLit(&opt, "file=");
1741
if (qemuBuildRBDString(conn, disk, &opt) < 0)
1743
virBufferAddChar(&opt, ',');
1745
case VIR_DOMAIN_DISK_PROTOCOL_SHEEPDOG:
1746
if (disk->nhosts == 0)
1747
virBufferAsprintf(&opt, "file=sheepdog:%s,", disk->src);
1749
/* only one host is supported now */
1750
virBufferAsprintf(&opt, "file=sheepdog:%s:%s:%s,",
1751
disk->hosts->name, disk->hosts->port,
1756
virBufferAsprintf(&opt, "file=%s,", disk->src);
1759
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
1760
virBufferAddLit(&opt, "if=none");
1762
virBufferAsprintf(&opt, "if=%s", bus);
1764
if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM)
1765
virBufferAddLit(&opt, ",media=cdrom");
1767
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
1768
virBufferAsprintf(&opt, ",id=%s%s", QEMU_DRIVE_HOST_PREFIX, disk->info.alias);
1770
if (busid == -1 && unitid == -1) {
1772
virBufferAsprintf(&opt, ",index=%d", idx);
1775
virBufferAsprintf(&opt, ",bus=%d", busid);
1777
virBufferAsprintf(&opt, ",unit=%d", unitid);
1781
qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE_BOOT) &&
1782
disk->device == VIR_DOMAIN_DISK_DEVICE_DISK &&
1783
disk->bus != VIR_DOMAIN_DISK_BUS_IDE)
1784
virBufferAddLit(&opt, ",boot=on");
1785
if (disk->readonly &&
1786
qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE_READONLY))
1787
virBufferAddLit(&opt, ",readonly=on");
1788
if (disk->transient) {
1789
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
1790
_("transient disks not supported yet"));
1793
if (disk->driverType && *disk->driverType != '\0' &&
1794
disk->type != VIR_DOMAIN_DISK_TYPE_DIR &&
1795
qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE_FORMAT))
1796
virBufferAsprintf(&opt, ",format=%s", disk->driverType);
1798
qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE_SERIAL)) {
1799
if (qemuSafeSerialParamValue(disk->serial) < 0)
1801
virBufferAsprintf(&opt, ",serial=%s", disk->serial);
1804
if (disk->cachemode) {
1805
const char *mode = NULL;
1807
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_V2)) {
1808
mode = qemuDiskCacheV2TypeToString(disk->cachemode);
1810
if (disk->cachemode == VIR_DOMAIN_DISK_CACHE_DIRECTSYNC &&
1811
!qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_DIRECTSYNC)) {
1812
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
1813
_("disk cache mode 'directsync' is not "
1814
"supported by this QEMU"));
1816
} else if (disk->cachemode == VIR_DOMAIN_DISK_CACHE_UNSAFE &&
1817
!qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_UNSAFE)) {
1818
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
1819
_("disk cache mode 'unsafe' is not "
1820
"supported by this QEMU"));
1824
mode = qemuDiskCacheV1TypeToString(disk->cachemode);
1827
virBufferAsprintf(&opt, ",cache=%s", mode);
1828
} else if (disk->shared && !disk->readonly) {
1829
virBufferAddLit(&opt, ",cache=off");
1832
if (qemuCapsGet(qemuCaps, QEMU_CAPS_MONITOR_JSON)) {
1833
const char *wpolicy = NULL, *rpolicy = NULL;
1835
if (disk->error_policy)
1836
wpolicy = virDomainDiskErrorPolicyTypeToString(disk->error_policy);
1837
if (disk->rerror_policy)
1838
rpolicy = virDomainDiskErrorPolicyTypeToString(disk->rerror_policy);
1840
if (disk->error_policy == VIR_DOMAIN_DISK_ERROR_POLICY_ENOSPACE) {
1841
/* in the case of enospace, the option is spelled
1842
* differently in qemu, and it's only valid for werror,
1843
* not for rerror, so leave leave rerror NULL.
1846
} else if (!rpolicy) {
1847
/* for other policies, rpolicy can match wpolicy */
1852
virBufferAsprintf(&opt, ",werror=%s", wpolicy);
1854
virBufferAsprintf(&opt, ",rerror=%s", rpolicy);
1858
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE_AIO)) {
1859
virBufferAsprintf(&opt, ",aio=%s",
1860
virDomainDiskIoTypeToString(disk->iomode));
1862
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
1863
_("disk aio mode not supported with this "
1869
/* block I/O throttling */
1870
if (disk->blkdeviotune.total_bytes_sec) {
1871
virBufferAsprintf(&opt, ",bps=%llu",
1872
disk->blkdeviotune.total_bytes_sec);
1875
if (disk->blkdeviotune.read_bytes_sec) {
1876
virBufferAsprintf(&opt, ",bps_rd=%llu",
1877
disk->blkdeviotune.read_bytes_sec);
1880
if (disk->blkdeviotune.write_bytes_sec) {
1881
virBufferAsprintf(&opt, ",bps_wr=%llu",
1882
disk->blkdeviotune.write_bytes_sec);
1885
if (disk->blkdeviotune.total_iops_sec) {
1886
virBufferAsprintf(&opt, ",iops=%llu",
1887
disk->blkdeviotune.total_iops_sec);
1890
if (disk->blkdeviotune.read_iops_sec) {
1891
virBufferAsprintf(&opt, ",iops_rd=%llu",
1892
disk->blkdeviotune.read_iops_sec);
1895
if (disk->blkdeviotune.write_iops_sec) {
1896
virBufferAsprintf(&opt, ",iops_wr=%llu",
1897
disk->blkdeviotune.write_iops_sec);
1900
if (virBufferError(&opt)) {
1901
virReportOOMError();
1905
return virBufferContentAndReset(&opt);
1908
virBufferFreeAndReset(&opt);
1914
qemuBuildDriveDevStr(virDomainDiskDefPtr disk,
1916
virBitmapPtr qemuCaps)
1918
virBuffer opt = VIR_BUFFER_INITIALIZER;
1919
const char *bus = virDomainDiskQEMUBusTypeToString(disk->bus);
1920
int idx = virDiskNameToIndex(disk->dst);
1923
qemuReportError(VIR_ERR_INTERNAL_ERROR,
1924
_("unsupported disk type '%s'"), disk->dst);
1928
switch (disk->bus) {
1929
case VIR_DOMAIN_DISK_BUS_IDE:
1930
virBufferAddLit(&opt, "ide-drive");
1931
virBufferAsprintf(&opt, ",bus=ide.%d,unit=%d",
1932
disk->info.addr.drive.bus,
1933
disk->info.addr.drive.unit);
1935
case VIR_DOMAIN_DISK_BUS_SCSI:
1936
virBufferAddLit(&opt, "scsi-disk");
1937
virBufferAsprintf(&opt, ",bus=scsi%d.%d,scsi-id=%d",
1938
disk->info.addr.drive.controller,
1939
disk->info.addr.drive.bus,
1940
disk->info.addr.drive.unit);
1942
case VIR_DOMAIN_DISK_BUS_SATA:
1943
virBufferAddLit(&opt, "ide-drive");
1944
virBufferAsprintf(&opt, ",bus=ahci%d.%d",
1945
disk->info.addr.drive.controller,
1946
disk->info.addr.drive.unit);
1948
case VIR_DOMAIN_DISK_BUS_VIRTIO:
1949
virBufferAddLit(&opt, "virtio-blk-pci");
1950
qemuBuildIoEventFdStr(&opt, disk->ioeventfd, qemuCaps);
1951
if (disk->event_idx &&
1952
qemuCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_BLK_EVENT_IDX)) {
1953
virBufferAsprintf(&opt, ",event_idx=%s",
1954
virDomainVirtioEventIdxTypeToString(disk->event_idx));
1956
if (qemuBuildDeviceAddressStr(&opt, &disk->info, qemuCaps) < 0)
1959
case VIR_DOMAIN_DISK_BUS_USB:
1960
virBufferAddLit(&opt, "usb-storage");
1963
qemuReportError(VIR_ERR_INTERNAL_ERROR,
1964
_("unsupported disk bus '%s' with device setup"), bus);
1967
virBufferAsprintf(&opt, ",drive=%s%s", QEMU_DRIVE_HOST_PREFIX, disk->info.alias);
1968
virBufferAsprintf(&opt, ",id=%s", disk->info.alias);
1969
if (bootindex && qemuCapsGet(qemuCaps, QEMU_CAPS_BOOTINDEX))
1970
virBufferAsprintf(&opt, ",bootindex=%d", bootindex);
1972
if (virBufferError(&opt)) {
1973
virReportOOMError();
1977
return virBufferContentAndReset(&opt);
1980
virBufferFreeAndReset(&opt);
1985
char *qemuBuildFSStr(virDomainFSDefPtr fs,
1986
virBitmapPtr qemuCaps ATTRIBUTE_UNUSED)
1988
virBuffer opt = VIR_BUFFER_INITIALIZER;
1989
const char *driver = qemuDomainFSDriverTypeToString(fs->fsdriver);
1991
if (fs->type != VIR_DOMAIN_FS_TYPE_MOUNT) {
1992
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
1993
_("only supports mount filesystem type"));
1998
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
1999
_("Filesystem driver type not supported"));
2002
virBufferAdd(&opt, driver, -1);
2004
if (fs->accessmode == VIR_DOMAIN_FS_ACCESSMODE_MAPPED) {
2005
virBufferAddLit(&opt, ",security_model=mapped");
2006
} else if(fs->accessmode == VIR_DOMAIN_FS_ACCESSMODE_PASSTHROUGH) {
2007
virBufferAddLit(&opt, ",security_model=passthrough");
2008
} else if(fs->accessmode == VIR_DOMAIN_FS_ACCESSMODE_SQUASH) {
2009
virBufferAddLit(&opt, ",security_model=none");
2011
virBufferAsprintf(&opt, ",id=%s%s", QEMU_FSDEV_HOST_PREFIX, fs->info.alias);
2012
virBufferAsprintf(&opt, ",path=%s", fs->src);
2014
if (virBufferError(&opt)) {
2015
virReportOOMError();
2019
return virBufferContentAndReset(&opt);
2022
virBufferFreeAndReset(&opt);
2028
qemuBuildFSDevStr(virDomainFSDefPtr fs,
2029
virBitmapPtr qemuCaps)
2031
virBuffer opt = VIR_BUFFER_INITIALIZER;
2033
if (fs->type != VIR_DOMAIN_FS_TYPE_MOUNT) {
2034
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
2035
_("can only passthrough directories"));
2039
virBufferAddLit(&opt, "virtio-9p-pci");
2040
virBufferAsprintf(&opt, ",id=%s", fs->info.alias);
2041
virBufferAsprintf(&opt, ",fsdev=%s%s", QEMU_FSDEV_HOST_PREFIX, fs->info.alias);
2042
virBufferAsprintf(&opt, ",mount_tag=%s", fs->dst);
2044
if (qemuBuildDeviceAddressStr(&opt, &fs->info, qemuCaps) < 0)
2047
if (virBufferError(&opt)) {
2048
virReportOOMError();
2052
return virBufferContentAndReset(&opt);
2055
virBufferFreeAndReset(&opt);
2061
qemuControllerModelUSBToCaps(int model)
2064
case VIR_DOMAIN_CONTROLLER_MODEL_USB_PIIX3_UHCI:
2065
return QEMU_CAPS_PIIX3_USB_UHCI;
2066
case VIR_DOMAIN_CONTROLLER_MODEL_USB_PIIX4_UHCI:
2067
return QEMU_CAPS_PIIX4_USB_UHCI;
2068
case VIR_DOMAIN_CONTROLLER_MODEL_USB_EHCI:
2069
return QEMU_CAPS_USB_EHCI;
2070
case VIR_DOMAIN_CONTROLLER_MODEL_USB_ICH9_EHCI1:
2071
case VIR_DOMAIN_CONTROLLER_MODEL_USB_ICH9_UHCI1:
2072
case VIR_DOMAIN_CONTROLLER_MODEL_USB_ICH9_UHCI2:
2073
case VIR_DOMAIN_CONTROLLER_MODEL_USB_ICH9_UHCI3:
2074
return QEMU_CAPS_ICH9_USB_EHCI1;
2075
case VIR_DOMAIN_CONTROLLER_MODEL_USB_VT82C686B_UHCI:
2076
return QEMU_CAPS_VT82C686B_USB_UHCI;
2077
case VIR_DOMAIN_CONTROLLER_MODEL_USB_PCI_OHCI:
2078
return QEMU_CAPS_PCI_OHCI;
2086
qemuBuildUSBControllerDevStr(virDomainControllerDefPtr def,
2087
virBitmapPtr qemuCaps,
2095
model = VIR_DOMAIN_CONTROLLER_MODEL_USB_PIIX3_UHCI;
2097
smodel = qemuControllerModelUSBTypeToString(model);
2098
caps = qemuControllerModelUSBToCaps(model);
2100
if (caps == -1 || !qemuCapsGet(qemuCaps, caps)) {
2101
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
2102
_("%s not supported in this QEMU binary"), smodel);
2106
virBufferAsprintf(buf, "%s", smodel);
2108
if (def->info.mastertype == VIR_DOMAIN_CONTROLLER_MASTER_USB) {
2109
virBufferAsprintf(buf, ",masterbus=");
2110
qemuUsbId(buf, def->idx);
2111
virBufferAsprintf(buf, ".0,firstport=%d", def->info.master.usb.startport);
2113
virBufferAsprintf(buf, ",id=");
2114
qemuUsbId(buf, def->idx);
2121
qemuBuildControllerDevStr(virDomainControllerDefPtr def,
2122
virBitmapPtr qemuCaps,
2123
int *nusbcontroller)
2125
virBuffer buf = VIR_BUFFER_INITIALIZER;
2127
switch (def->type) {
2128
case VIR_DOMAIN_CONTROLLER_TYPE_SCSI:
2129
virBufferAddLit(&buf, "lsi");
2130
virBufferAsprintf(&buf, ",id=scsi%d", def->idx);
2133
case VIR_DOMAIN_CONTROLLER_TYPE_VIRTIO_SERIAL:
2134
if (def->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
2135
virBufferAddLit(&buf, "virtio-serial-pci");
2137
virBufferAddLit(&buf, "virtio-serial");
2139
virBufferAsprintf(&buf, ",id=" QEMU_VIRTIO_SERIAL_PREFIX "%d",
2141
if (def->opts.vioserial.ports != -1) {
2142
virBufferAsprintf(&buf, ",max_ports=%d",
2143
def->opts.vioserial.ports);
2145
if (def->opts.vioserial.vectors != -1) {
2146
virBufferAsprintf(&buf, ",vectors=%d",
2147
def->opts.vioserial.vectors);
2151
case VIR_DOMAIN_CONTROLLER_TYPE_CCID:
2152
virBufferAsprintf(&buf, "usb-ccid,id=ccid%d", def->idx);
2155
case VIR_DOMAIN_CONTROLLER_TYPE_SATA:
2156
virBufferAsprintf(&buf, "ahci,id=ahci%d", def->idx);
2159
case VIR_DOMAIN_CONTROLLER_TYPE_USB:
2160
if (qemuBuildUSBControllerDevStr(def, qemuCaps, &buf) == -1)
2164
*nusbcontroller += 1;
2168
/* We always get an IDE controller, whether we want it or not. */
2169
case VIR_DOMAIN_CONTROLLER_TYPE_IDE:
2171
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
2172
_("Unknown controller type: %s"),
2173
virDomainControllerTypeToString(def->type));
2177
if (qemuBuildDeviceAddressStr(&buf, &def->info, qemuCaps) < 0)
2180
if (virBufferError(&buf)) {
2181
virReportOOMError();
2185
return virBufferContentAndReset(&buf);
2188
virBufferFreeAndReset(&buf);
2194
qemuBuildNicStr(virDomainNetDefPtr net,
2199
if (virAsprintf(&str,
2200
"%smacaddr=%02x:%02x:%02x:%02x:%02x:%02x,vlan=%d%s%s%s%s",
2201
prefix ? prefix : "",
2202
net->mac[0], net->mac[1],
2203
net->mac[2], net->mac[3],
2204
net->mac[4], net->mac[5],
2206
(net->model ? ",model=" : ""),
2207
(net->model ? net->model : ""),
2208
(net->info.alias ? ",name=" : ""),
2209
(net->info.alias ? net->info.alias : "")) < 0) {
2210
virReportOOMError();
2219
qemuBuildNicDevStr(virDomainNetDefPtr net,
2222
virBitmapPtr qemuCaps)
2224
virBuffer buf = VIR_BUFFER_INITIALIZER;
2226
bool usingVirtio = false;
2230
} else if (STREQ(net->model, "virtio")) {
2231
nic = "virtio-net-pci";
2237
virBufferAdd(&buf, nic, strlen(nic));
2238
if (usingVirtio && net->driver.virtio.txmode) {
2239
if (qemuCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_TX_ALG)) {
2240
virBufferAddLit(&buf, ",tx=");
2241
switch (net->driver.virtio.txmode) {
2242
case VIR_DOMAIN_NET_VIRTIO_TX_MODE_IOTHREAD:
2243
virBufferAddLit(&buf, "bh");
2246
case VIR_DOMAIN_NET_VIRTIO_TX_MODE_TIMER:
2247
virBufferAddLit(&buf, "timer");
2250
/* this should never happen, if it does, we need
2251
* to add another case to this switch.
2253
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
2254
_("unrecognized virtio-net-pci 'tx' option"));
2258
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
2259
_("virtio-net-pci 'tx' option not supported in this QEMU binary"));
2264
qemuBuildIoEventFdStr(&buf, net->driver.virtio.ioeventfd, qemuCaps);
2265
if (net->driver.virtio.event_idx &&
2266
qemuCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_NET_EVENT_IDX)) {
2267
virBufferAsprintf(&buf, ",event_idx=%s",
2268
virDomainVirtioEventIdxTypeToString(net->driver.virtio.event_idx));
2272
virBufferAsprintf(&buf, ",netdev=host%s", net->info.alias);
2274
virBufferAsprintf(&buf, ",vlan=%d", vlan);
2275
virBufferAsprintf(&buf, ",id=%s", net->info.alias);
2276
virBufferAsprintf(&buf, ",mac=%02x:%02x:%02x:%02x:%02x:%02x",
2277
net->mac[0], net->mac[1],
2278
net->mac[2], net->mac[3],
2279
net->mac[4], net->mac[5]);
2280
if (qemuBuildDeviceAddressStr(&buf, &net->info, qemuCaps) < 0)
2282
if (bootindex && qemuCapsGet(qemuCaps, QEMU_CAPS_BOOTINDEX))
2283
virBufferAsprintf(&buf, ",bootindex=%d", bootindex);
2285
if (virBufferError(&buf)) {
2286
virReportOOMError();
2290
return virBufferContentAndReset(&buf);
2293
virBufferFreeAndReset(&buf);
2299
qemuBuildHostNetStr(virDomainNetDefPtr net,
2303
const char *vhostfd)
2305
bool is_tap = false;
2306
virBuffer buf = VIR_BUFFER_INITIALIZER;
2308
switch (virDomainNetGetActualType(net)) {
2309
case VIR_DOMAIN_NET_TYPE_NETWORK:
2310
case VIR_DOMAIN_NET_TYPE_BRIDGE:
2311
case VIR_DOMAIN_NET_TYPE_DIRECT:
2312
virBufferAddLit(&buf, "tap");
2313
virBufferAsprintf(&buf, "%cfd=%s", type_sep, tapfd);
2318
case VIR_DOMAIN_NET_TYPE_ETHERNET:
2319
virBufferAddLit(&buf, "tap");
2321
virBufferAsprintf(&buf, "%cifname=%s", type_sep, net->ifname);
2324
if (net->data.ethernet.script) {
2325
virBufferAsprintf(&buf, "%cscript=%s", type_sep,
2326
net->data.ethernet.script);
2332
case VIR_DOMAIN_NET_TYPE_CLIENT:
2333
case VIR_DOMAIN_NET_TYPE_SERVER:
2334
case VIR_DOMAIN_NET_TYPE_MCAST:
2335
virBufferAddLit(&buf, "socket");
2336
switch (virDomainNetGetActualType(net)) {
2337
case VIR_DOMAIN_NET_TYPE_CLIENT:
2338
virBufferAsprintf(&buf, "%cconnect=%s:%d",
2340
net->data.socket.address,
2341
net->data.socket.port);
2343
case VIR_DOMAIN_NET_TYPE_SERVER:
2344
virBufferAsprintf(&buf, "%clisten=%s:%d",
2346
net->data.socket.address,
2347
net->data.socket.port);
2349
case VIR_DOMAIN_NET_TYPE_MCAST:
2350
virBufferAsprintf(&buf, "%cmcast=%s:%d",
2352
net->data.socket.address,
2353
net->data.socket.port);
2355
case VIR_DOMAIN_NET_TYPE_USER:
2356
case VIR_DOMAIN_NET_TYPE_ETHERNET:
2357
case VIR_DOMAIN_NET_TYPE_NETWORK:
2358
case VIR_DOMAIN_NET_TYPE_BRIDGE:
2359
case VIR_DOMAIN_NET_TYPE_INTERNAL:
2360
case VIR_DOMAIN_NET_TYPE_DIRECT:
2361
case VIR_DOMAIN_NET_TYPE_LAST:
2367
case VIR_DOMAIN_NET_TYPE_USER:
2369
virBufferAddLit(&buf, "user");
2374
virBufferAsprintf(&buf, "%cvlan=%d", type_sep, vlan);
2375
if (net->info.alias)
2376
virBufferAsprintf(&buf, ",name=host%s",
2379
virBufferAsprintf(&buf, "%cid=host%s",
2380
type_sep, net->info.alias);
2384
if (vhostfd && *vhostfd)
2385
virBufferAsprintf(&buf, ",vhost=on,vhostfd=%s", vhostfd);
2386
if (net->tune.sndbuf_specified)
2387
virBufferAsprintf(&buf, ",sndbuf=%lu", net->tune.sndbuf);
2390
if (virBufferError(&buf)) {
2391
virBufferFreeAndReset(&buf);
2392
virReportOOMError();
2396
return virBufferContentAndReset(&buf);
2401
qemuBuildWatchdogDevStr(virDomainWatchdogDefPtr dev,
2402
virBitmapPtr qemuCaps)
2404
virBuffer buf = VIR_BUFFER_INITIALIZER;
2406
const char *model = virDomainWatchdogModelTypeToString(dev->model);
2408
qemuReportError(VIR_ERR_INTERNAL_ERROR,
2409
"%s", _("missing watchdog model"));
2413
virBufferAsprintf(&buf, "%s,id=%s", model, dev->info.alias);
2414
if (qemuBuildDeviceAddressStr(&buf, &dev->info, qemuCaps) < 0)
2417
if (virBufferError(&buf)) {
2418
virReportOOMError();
2422
return virBufferContentAndReset(&buf);
2425
virBufferFreeAndReset(&buf);
2431
qemuBuildMemballoonDevStr(virDomainMemballoonDefPtr dev,
2432
virBitmapPtr qemuCaps)
2434
virBuffer buf = VIR_BUFFER_INITIALIZER;
2436
virBufferAddLit(&buf, "virtio-balloon-pci");
2437
virBufferAsprintf(&buf, ",id=%s", dev->info.alias);
2438
if (qemuBuildDeviceAddressStr(&buf, &dev->info, qemuCaps) < 0)
2441
if (virBufferError(&buf)) {
2442
virReportOOMError();
2446
return virBufferContentAndReset(&buf);
2449
virBufferFreeAndReset(&buf);
2455
qemuBuildUSBInputDevStr(virDomainInputDefPtr dev,
2456
virBitmapPtr qemuCaps)
2458
virBuffer buf = VIR_BUFFER_INITIALIZER;
2460
virBufferAsprintf(&buf, "%s,id=%s",
2461
dev->type == VIR_DOMAIN_INPUT_TYPE_MOUSE ?
2462
"usb-mouse" : "usb-tablet", dev->info.alias);
2464
if (qemuBuildDeviceAddressStr(&buf, &dev->info, qemuCaps) < 0)
2467
if (virBufferError(&buf)) {
2468
virReportOOMError();
2472
return virBufferContentAndReset(&buf);
2475
virBufferFreeAndReset(&buf);
2481
qemuBuildSoundDevStr(virDomainSoundDefPtr sound,
2482
virBitmapPtr qemuCaps)
2484
virBuffer buf = VIR_BUFFER_INITIALIZER;
2485
const char *model = virDomainSoundModelTypeToString(sound->model);
2488
qemuReportError(VIR_ERR_INTERNAL_ERROR,
2489
"%s", _("invalid sound model"));
2493
/* Hack for weirdly unusual devices name in QEMU */
2494
if (STREQ(model, "es1370"))
2496
else if (STREQ(model, "ac97"))
2498
else if (STREQ(model, "ich6"))
2499
model = "intel-hda";
2501
virBufferAsprintf(&buf, "%s,id=%s", model, sound->info.alias);
2502
if (qemuBuildDeviceAddressStr(&buf, &sound->info, qemuCaps) < 0)
2505
if (virBufferError(&buf)) {
2506
virReportOOMError();
2510
return virBufferContentAndReset(&buf);
2513
virBufferFreeAndReset(&buf);
2518
qemuBuildSoundCodecStr(virDomainSoundDefPtr sound,
2521
virBuffer buf = VIR_BUFFER_INITIALIZER;
2524
virBufferAsprintf(&buf, "%s,id=%s-codec%d,bus=%s.0,cad=%d",
2525
codec, sound->info.alias, cad, sound->info.alias, cad);
2527
if (virBufferError(&buf)) {
2528
virReportOOMError();
2532
return virBufferContentAndReset(&buf);
2535
virBufferFreeAndReset(&buf);
2540
qemuBuildVideoDevStr(virDomainVideoDefPtr video,
2541
virBitmapPtr qemuCaps)
2543
virBuffer buf = VIR_BUFFER_INITIALIZER;
2544
const char *model = qemuVideoTypeToString(video->type);
2547
qemuReportError(VIR_ERR_INTERNAL_ERROR,
2548
"%s", _("invalid video model"));
2552
virBufferAsprintf(&buf, "%s,id=%s", model, video->info.alias);
2554
if (video->type == VIR_DOMAIN_VIDEO_TYPE_QXL) {
2555
if (video->vram > (UINT_MAX / 1024)) {
2556
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
2557
_("value for 'vram' must be less than '%u'"),
2562
/* QEMU accepts bytes for vram_size. */
2563
virBufferAsprintf(&buf, ",vram_size=%u", video->vram * 1024);
2566
if (qemuBuildDeviceAddressStr(&buf, &video->info, qemuCaps) < 0)
2569
if (virBufferError(&buf)) {
2570
virReportOOMError();
2574
return virBufferContentAndReset(&buf);
2577
virBufferFreeAndReset(&buf);
2583
qemuOpenPCIConfig(virDomainHostdevDefPtr dev)
2588
if (virAsprintf(&path, "/sys/bus/pci/devices/%04x:%02x:%02x.%01x/config",
2589
dev->source.subsys.u.pci.domain,
2590
dev->source.subsys.u.pci.bus,
2591
dev->source.subsys.u.pci.slot,
2592
dev->source.subsys.u.pci.function) < 0) {
2593
virReportOOMError();
2597
configfd = open(path, O_RDWR, 0);
2600
virReportSystemError(errno, _("Failed opening %s"), path);
2608
qemuBuildPCIHostdevDevStr(virDomainHostdevDefPtr dev, const char *configfd,
2609
virBitmapPtr qemuCaps)
2611
virBuffer buf = VIR_BUFFER_INITIALIZER;
2613
virBufferAddLit(&buf, "pci-assign");
2614
virBufferAsprintf(&buf, ",host=%.2x:%.2x.%.1x",
2615
dev->source.subsys.u.pci.bus,
2616
dev->source.subsys.u.pci.slot,
2617
dev->source.subsys.u.pci.function);
2618
virBufferAsprintf(&buf, ",id=%s", dev->info.alias);
2619
if (configfd && *configfd)
2620
virBufferAsprintf(&buf, ",configfd=%s", configfd);
2622
virBufferAsprintf(&buf, ",bootindex=%d", dev->bootIndex);
2623
if (qemuBuildDeviceAddressStr(&buf, &dev->info, qemuCaps) < 0)
2627
if (!qemuCapsGet(qemuCaps, QEMU_CAPS_PCI_ROMBAR)) {
2628
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
2629
"%s", _("rombar not supported in this QEMU binary"));
2633
switch (dev->rombar) {
2634
case VIR_DOMAIN_PCI_ROMBAR_OFF:
2635
virBufferAddLit(&buf, ",rombar=0");
2637
case VIR_DOMAIN_PCI_ROMBAR_ON:
2638
virBufferAddLit(&buf, ",rombar=1");
2645
if (virBufferError(&buf)) {
2646
virReportOOMError();
2650
return virBufferContentAndReset(&buf);
2653
virBufferFreeAndReset(&buf);
2659
qemuBuildPCIHostdevPCIDevStr(virDomainHostdevDefPtr dev)
2663
if (virAsprintf(&ret, "host=%.2x:%.2x.%.1x",
2664
dev->source.subsys.u.pci.bus,
2665
dev->source.subsys.u.pci.slot,
2666
dev->source.subsys.u.pci.function) < 0)
2667
virReportOOMError();
2674
qemuBuildRedirdevDevStr(virDomainRedirdevDefPtr dev,
2675
virBitmapPtr qemuCaps)
2677
virBuffer buf = VIR_BUFFER_INITIALIZER;
2679
if (dev->bus != VIR_DOMAIN_REDIRDEV_BUS_USB) {
2680
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
2681
_("Redirection bus %s is not supported by QEMU"),
2682
virDomainRedirdevBusTypeToString(dev->bus));
2686
if (!qemuCapsGet(qemuCaps, QEMU_CAPS_USB_REDIR)) {
2687
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
2688
_("USB redirection is not supported "
2689
"by this version of QEMU"));
2693
virBufferAsprintf(&buf, "usb-redir,chardev=char%s,id=%s",
2697
if (qemuBuildDeviceAddressStr(&buf, &dev->info, qemuCaps) < 0)
2700
if (virBufferError(&buf)) {
2701
virReportOOMError();
2705
return virBufferContentAndReset(&buf);
2708
virBufferFreeAndReset(&buf);
2713
qemuBuildUSBHostdevDevStr(virDomainHostdevDefPtr dev,
2714
virBitmapPtr qemuCaps)
2716
virBuffer buf = VIR_BUFFER_INITIALIZER;
2718
if (!dev->source.subsys.u.usb.bus &&
2719
!dev->source.subsys.u.usb.device) {
2720
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
2721
_("USB host device is missing bus/device information"));
2725
virBufferAsprintf(&buf, "usb-host,hostbus=%d,hostaddr=%d,id=%s",
2726
dev->source.subsys.u.usb.bus,
2727
dev->source.subsys.u.usb.device,
2730
if (qemuBuildDeviceAddressStr(&buf, &dev->info, qemuCaps) < 0)
2733
if (virBufferError(&buf)) {
2734
virReportOOMError();
2738
return virBufferContentAndReset(&buf);
2741
virBufferFreeAndReset(&buf);
2747
qemuBuildHubDevStr(virDomainHubDefPtr dev,
2748
virBitmapPtr qemuCaps)
2750
virBuffer buf = VIR_BUFFER_INITIALIZER;
2752
if (dev->type != VIR_DOMAIN_HUB_TYPE_USB) {
2753
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
2754
_("hub type %s not supported"),
2755
virDomainHubTypeToString(dev->type));
2759
if (!qemuCapsGet(qemuCaps, QEMU_CAPS_USB_HUB)) {
2760
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
2761
_("usb-hub not supported by QEMU binary"));
2765
virBufferAddLit(&buf, "usb-hub");
2766
virBufferAsprintf(&buf, ",id=%s", dev->info.alias);
2767
if (qemuBuildDeviceAddressStr(&buf, &dev->info, qemuCaps) < 0)
2770
if (virBufferError(&buf)) {
2771
virReportOOMError();
2775
return virBufferContentAndReset(&buf);
2778
virBufferFreeAndReset(&buf);
2784
qemuBuildUSBHostdevUsbDevStr(virDomainHostdevDefPtr dev)
2788
if (!dev->source.subsys.u.usb.bus &&
2789
!dev->source.subsys.u.usb.device) {
2790
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
2791
_("USB host device is missing bus/device information"));
2795
if (virAsprintf(&ret, "host:%d.%d",
2796
dev->source.subsys.u.usb.bus,
2797
dev->source.subsys.u.usb.device) < 0)
2798
virReportOOMError();
2805
/* This function outputs a -chardev command line option which describes only the
2806
* host side of the character device */
2808
qemuBuildChrChardevStr(virDomainChrSourceDefPtr dev, const char *alias,
2809
virBitmapPtr qemuCaps)
2811
virBuffer buf = VIR_BUFFER_INITIALIZER;
2815
case VIR_DOMAIN_CHR_TYPE_NULL:
2816
virBufferAsprintf(&buf, "null,id=char%s", alias);
2819
case VIR_DOMAIN_CHR_TYPE_VC:
2820
virBufferAsprintf(&buf, "vc,id=char%s", alias);
2823
case VIR_DOMAIN_CHR_TYPE_PTY:
2824
virBufferAsprintf(&buf, "pty,id=char%s", alias);
2827
case VIR_DOMAIN_CHR_TYPE_DEV:
2828
virBufferAsprintf(&buf, "tty,id=char%s,path=%s", alias,
2829
dev->data.file.path);
2832
case VIR_DOMAIN_CHR_TYPE_FILE:
2833
virBufferAsprintf(&buf, "file,id=char%s,path=%s", alias,
2834
dev->data.file.path);
2837
case VIR_DOMAIN_CHR_TYPE_PIPE:
2838
virBufferAsprintf(&buf, "pipe,id=char%s,path=%s", alias,
2839
dev->data.file.path);
2842
case VIR_DOMAIN_CHR_TYPE_STDIO:
2843
virBufferAsprintf(&buf, "stdio,id=char%s", alias);
2846
case VIR_DOMAIN_CHR_TYPE_UDP: {
2847
const char *connectHost = dev->data.udp.connectHost;
2848
const char *bindHost = dev->data.udp.bindHost;
2849
const char *bindService = dev->data.udp.bindService;
2851
if (connectHost == NULL)
2853
if (bindHost == NULL)
2855
if (bindService == NULL)
2858
virBufferAsprintf(&buf,
2859
"udp,id=char%s,host=%s,port=%s,localaddr=%s,"
2863
dev->data.udp.connectService,
2864
bindHost, bindService);
2867
case VIR_DOMAIN_CHR_TYPE_TCP:
2868
telnet = dev->data.tcp.protocol == VIR_DOMAIN_CHR_TCP_PROTOCOL_TELNET;
2869
virBufferAsprintf(&buf,
2870
"socket,id=char%s,host=%s,port=%s%s%s",
2873
dev->data.tcp.service,
2874
telnet ? ",telnet" : "",
2875
dev->data.tcp.listen ? ",server,nowait" : "");
2878
case VIR_DOMAIN_CHR_TYPE_UNIX:
2879
virBufferAsprintf(&buf,
2880
"socket,id=char%s,path=%s%s",
2883
dev->data.nix.listen ? ",server,nowait" : "");
2886
case VIR_DOMAIN_CHR_TYPE_SPICEVMC:
2887
if (!qemuCapsGet(qemuCaps, QEMU_CAPS_CHARDEV_SPICEVMC)) {
2888
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
2889
_("spicevmc not supported in this QEMU binary"));
2892
virBufferAsprintf(&buf, "spicevmc,id=char%s,name=%s", alias,
2893
virDomainChrSpicevmcTypeToString(dev->data.spicevmc));
2897
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
2898
_("unsupported chardev '%s'"),
2899
virDomainChrTypeToString(dev->type));
2903
if (virBufferError(&buf)) {
2904
virReportOOMError();
2908
return virBufferContentAndReset(&buf);
2911
virBufferFreeAndReset(&buf);
2917
qemuBuildChrArgStr(virDomainChrSourceDefPtr dev, const char *prefix)
2919
virBuffer buf = VIR_BUFFER_INITIALIZER;
2922
virBufferAdd(&buf, prefix, strlen(prefix));
2924
switch (dev->type) {
2925
case VIR_DOMAIN_CHR_TYPE_NULL:
2926
virBufferAddLit(&buf, "null");
2929
case VIR_DOMAIN_CHR_TYPE_VC:
2930
virBufferAddLit(&buf, "vc");
2933
case VIR_DOMAIN_CHR_TYPE_PTY:
2934
virBufferAddLit(&buf, "pty");
2937
case VIR_DOMAIN_CHR_TYPE_DEV:
2938
virBufferStrcat(&buf, dev->data.file.path, NULL);
2941
case VIR_DOMAIN_CHR_TYPE_FILE:
2942
virBufferAsprintf(&buf, "file:%s", dev->data.file.path);
2945
case VIR_DOMAIN_CHR_TYPE_PIPE:
2946
virBufferAsprintf(&buf, "pipe:%s", dev->data.file.path);
2949
case VIR_DOMAIN_CHR_TYPE_STDIO:
2950
virBufferAddLit(&buf, "stdio");
2953
case VIR_DOMAIN_CHR_TYPE_UDP: {
2954
const char *connectHost = dev->data.udp.connectHost;
2955
const char *bindHost = dev->data.udp.bindHost;
2956
const char *bindService = dev->data.udp.bindService;
2958
if (connectHost == NULL)
2960
if (bindHost == NULL)
2962
if (bindService == NULL)
2965
virBufferAsprintf(&buf, "udp:%s:%s@%s:%s",
2967
dev->data.udp.connectService,
2972
case VIR_DOMAIN_CHR_TYPE_TCP:
2973
if (dev->data.tcp.protocol == VIR_DOMAIN_CHR_TCP_PROTOCOL_TELNET) {
2974
virBufferAsprintf(&buf, "telnet:%s:%s%s",
2976
dev->data.tcp.service,
2977
dev->data.tcp.listen ? ",server,nowait" : "");
2979
virBufferAsprintf(&buf, "tcp:%s:%s%s",
2981
dev->data.tcp.service,
2982
dev->data.tcp.listen ? ",server,nowait" : "");
2986
case VIR_DOMAIN_CHR_TYPE_UNIX:
2987
virBufferAsprintf(&buf, "unix:%s%s",
2989
dev->data.nix.listen ? ",server,nowait" : "");
2993
if (virBufferError(&buf)) {
2994
virReportOOMError();
2998
return virBufferContentAndReset(&buf);
3001
virBufferFreeAndReset(&buf);
3007
qemuBuildVirtioSerialPortDevStr(virDomainChrDefPtr dev,
3008
virBitmapPtr qemuCaps)
3010
virBuffer buf = VIR_BUFFER_INITIALIZER;
3011
switch (dev->deviceType) {
3012
case VIR_DOMAIN_CHR_DEVICE_TYPE_CONSOLE:
3013
virBufferAddLit(&buf, "virtconsole");
3015
case VIR_DOMAIN_CHR_DEVICE_TYPE_CHANNEL:
3016
/* Legacy syntax '-device spicevmc' */
3017
if (dev->source.type == VIR_DOMAIN_CHR_TYPE_SPICEVMC &&
3018
qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE_SPICEVMC)) {
3019
virBufferAddLit(&buf, "spicevmc");
3021
virBufferAddLit(&buf, "virtserialport");
3025
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
3026
_("Cannot use virtio serial for parallel/serial devices"));
3030
if (dev->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_NONE) {
3031
/* Check it's a virtio-serial address */
3032
if (dev->info.type !=
3033
VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_SERIAL)
3035
qemuReportError(VIR_ERR_INTERNAL_ERROR,
3036
"%s", _("virtio serial device has invalid address type"));
3040
virBufferAsprintf(&buf,
3041
",bus=" QEMU_VIRTIO_SERIAL_PREFIX "%d.%d",
3042
dev->info.addr.vioserial.controller,
3043
dev->info.addr.vioserial.bus);
3044
virBufferAsprintf(&buf,
3046
dev->info.addr.vioserial.port);
3049
if (dev->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CHANNEL &&
3050
dev->source.type == VIR_DOMAIN_CHR_TYPE_SPICEVMC &&
3052
STRNEQ(dev->target.name, "com.redhat.spice.0")) {
3053
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
3054
_("Unsupported spicevmc target name '%s'"),
3059
if (!(dev->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CHANNEL &&
3060
dev->source.type == VIR_DOMAIN_CHR_TYPE_SPICEVMC &&
3061
qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE_SPICEVMC))) {
3062
virBufferAsprintf(&buf, ",chardev=char%s,id=%s",
3063
dev->info.alias, dev->info.alias);
3064
if (dev->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CHANNEL &&
3066
virBufferAsprintf(&buf, ",name=%s", dev->target.name);
3069
virBufferAsprintf(&buf, ",id=%s", dev->info.alias);
3071
if (virBufferError(&buf)) {
3072
virReportOOMError();
3076
return virBufferContentAndReset(&buf);
3079
virBufferFreeAndReset(&buf);
3083
static char *qemuBuildSmbiosBiosStr(virSysinfoDefPtr def)
3085
virBuffer buf = VIR_BUFFER_INITIALIZER;
3087
if ((def->bios_vendor == NULL) && (def->bios_version == NULL) &&
3088
(def->bios_date == NULL) && (def->bios_release == NULL))
3091
virBufferAddLit(&buf, "type=0");
3094
if (def->bios_vendor)
3095
virBufferAsprintf(&buf, ",vendor=%s", def->bios_vendor);
3096
/* 0:BIOS Version */
3097
if (def->bios_version)
3098
virBufferAsprintf(&buf, ",version=%s", def->bios_version);
3099
/* 0:BIOS Release Date */
3101
virBufferAsprintf(&buf, ",date=%s", def->bios_date);
3102
/* 0:System BIOS Major Release and 0:System BIOS Minor Release */
3103
if (def->bios_release)
3104
virBufferAsprintf(&buf, ",release=%s", def->bios_release);
3106
if (virBufferError(&buf)) {
3107
virReportOOMError();
3111
return virBufferContentAndReset(&buf);
3114
virBufferFreeAndReset(&buf);
3118
static char *qemuBuildSmbiosSystemStr(virSysinfoDefPtr def, bool skip_uuid)
3120
virBuffer buf = VIR_BUFFER_INITIALIZER;
3122
if ((def->system_manufacturer == NULL) && (def->system_sku == NULL) &&
3123
(def->system_product == NULL) && (def->system_version == NULL) &&
3124
(def->system_serial == NULL) && (def->system_family == NULL) &&
3125
(def->system_uuid == NULL || skip_uuid))
3128
virBufferAddLit(&buf, "type=1");
3130
/* 1:Manufacturer */
3131
if (def->system_manufacturer)
3132
virBufferAsprintf(&buf, ",manufacturer=%s",
3133
def->system_manufacturer);
3134
/* 1:Product Name */
3135
if (def->system_product)
3136
virBufferAsprintf(&buf, ",product=%s", def->system_product);
3138
if (def->system_version)
3139
virBufferAsprintf(&buf, ",version=%s", def->system_version);
3140
/* 1:Serial Number */
3141
if (def->system_serial)
3142
virBufferAsprintf(&buf, ",serial=%s", def->system_serial);
3144
if (def->system_uuid && !skip_uuid)
3145
virBufferAsprintf(&buf, ",uuid=%s", def->system_uuid);
3147
if (def->system_sku)
3148
virBufferAsprintf(&buf, ",sku=%s", def->system_sku);
3150
if (def->system_family)
3151
virBufferAsprintf(&buf, ",family=%s", def->system_family);
3153
if (virBufferError(&buf)) {
3154
virReportOOMError();
3158
return virBufferContentAndReset(&buf);
3161
virBufferFreeAndReset(&buf);
3166
qemuBuildClockArgStr(virDomainClockDefPtr def)
3168
virBuffer buf = VIR_BUFFER_INITIALIZER;
3170
switch (def->offset) {
3171
case VIR_DOMAIN_CLOCK_OFFSET_UTC:
3172
virBufferAddLit(&buf, "base=utc");
3175
case VIR_DOMAIN_CLOCK_OFFSET_LOCALTIME:
3176
case VIR_DOMAIN_CLOCK_OFFSET_TIMEZONE:
3177
virBufferAddLit(&buf, "base=localtime");
3180
case VIR_DOMAIN_CLOCK_OFFSET_VARIABLE: {
3181
time_t now = time(NULL);
3184
now += def->data.adjustment;
3185
gmtime_r(&now, &nowbits);
3187
virBufferAsprintf(&buf, "base=%d-%02d-%02dT%02d:%02d:%02d",
3188
nowbits.tm_year + 1900,
3197
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
3198
_("unsupported clock offset '%s'"),
3199
virDomainClockOffsetTypeToString(def->offset));
3203
/* Look for an 'rtc' timer element, and add in appropriate clock= and driftfix= */
3205
for (i = 0; i < def->ntimers; i++) {
3206
if (def->timers[i]->name == VIR_DOMAIN_TIMER_NAME_RTC) {
3207
switch (def->timers[i]->track) {
3208
case -1: /* unspecified - use hypervisor default */
3210
case VIR_DOMAIN_TIMER_TRACK_BOOT:
3211
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
3212
_("unsupported rtc timer track '%s'"),
3213
virDomainTimerTrackTypeToString(def->timers[i]->track));
3215
case VIR_DOMAIN_TIMER_TRACK_GUEST:
3216
virBufferAddLit(&buf, ",clock=vm");
3218
case VIR_DOMAIN_TIMER_TRACK_WALL:
3219
virBufferAddLit(&buf, ",clock=host");
3223
switch (def->timers[i]->tickpolicy) {
3225
case VIR_DOMAIN_TIMER_TICKPOLICY_DELAY:
3226
/* This is the default - missed ticks delivered when
3227
next scheduled, at normal rate */
3229
case VIR_DOMAIN_TIMER_TICKPOLICY_CATCHUP:
3230
/* deliver ticks at a faster rate until caught up */
3231
virBufferAddLit(&buf, ",driftfix=slew");
3233
case VIR_DOMAIN_TIMER_TICKPOLICY_MERGE:
3234
case VIR_DOMAIN_TIMER_TICKPOLICY_DISCARD:
3235
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
3236
_("unsupported rtc timer tickpolicy '%s'"),
3237
virDomainTimerTickpolicyTypeToString(def->timers[i]->tickpolicy));
3240
break; /* no need to check other timers - there is only one rtc */
3244
if (virBufferError(&buf)) {
3245
virReportOOMError();
3249
return virBufferContentAndReset(&buf);
3252
virBufferFreeAndReset(&buf);
3258
qemuBuildCpuArgStr(const struct qemud_driver *driver,
3259
const virDomainDefPtr def,
3260
const char *emulator,
3261
virBitmapPtr qemuCaps,
3262
const struct utsname *ut,
3266
const virCPUDefPtr host = driver->caps->host.cpu;
3267
virCPUDefPtr guest = NULL;
3268
unsigned int ncpus = 0;
3269
const char **cpus = NULL;
3270
union cpuData *data = NULL;
3272
virBuffer buf = VIR_BUFFER_INITIALIZER;
3277
if (def->cpu && def->cpu->model) {
3279
qemuCapsProbeCPUModels(emulator, qemuCaps, host->arch,
3283
if (!ncpus || !host) {
3284
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
3285
_("CPU specification not supported by hypervisor"));
3290
if (ncpus > 0 && host) {
3291
virCPUCompareResult cmp;
3292
const char *preferred;
3295
cmp = cpuGuestData(host, def->cpu, &data);
3297
case VIR_CPU_COMPARE_INCOMPATIBLE:
3298
qemuReportError(VIR_ERR_INTERNAL_ERROR,
3299
"%s", _("guest CPU is not compatible with host CPU"));
3301
case VIR_CPU_COMPARE_ERROR:
3308
if (VIR_ALLOC(guest) < 0 || !(guest->arch = strdup(host->arch)))
3311
if (def->cpu->match == VIR_CPU_MATCH_MINIMUM)
3312
preferred = host->model;
3314
preferred = def->cpu->model;
3316
guest->type = VIR_CPU_TYPE_GUEST;
3317
if (cpuDecode(guest, data, cpus, ncpus, preferred) < 0)
3320
/* Only 'svm' requires --enable-nesting. The nested
3321
* 'vmx' patches now simply hook off the CPU features
3323
hasSVM = cpuHasFeature(guest->arch, data, "svm");
3326
*hasHwVirt = hasSVM > 0 ? true : false;
3328
virBufferAdd(&buf, guest->model, -1);
3329
for (i = 0; i < guest->nfeatures; i++) {
3331
if (guest->features[i].policy == VIR_CPU_FEATURE_DISABLE)
3336
virBufferAsprintf(&buf, ",%c%s", sign, guest->features[i].name);
3341
* Need to force a 32-bit guest CPU type if
3343
* 1. guest OS is i686
3344
* 2. host OS is x86_64
3345
* 3. emulator is qemu-kvm or kvm
3349
* 1. guest OS is i686
3350
* 2. emulator is qemu-system-x86_64
3352
if (STREQ(def->os.arch, "i686") &&
3353
((STREQ(ut->machine, "x86_64") &&
3354
strstr(emulator, "kvm")) ||
3355
strstr(emulator, "x86_64")))
3356
virBufferAddLit(&buf, "qemu32");
3359
if (virBufferError(&buf))
3362
*opt = virBufferContentAndReset(&buf);
3368
cpuDataFree(guest->arch, data);
3369
virCPUDefFree(guest);
3372
for (i = 0; i < ncpus; i++)
3380
virReportOOMError();
3385
qemuBuildSmpArgStr(const virDomainDefPtr def,
3386
virBitmapPtr qemuCaps)
3388
virBuffer buf = VIR_BUFFER_INITIALIZER;
3390
virBufferAsprintf(&buf, "%u", def->vcpus);
3392
if (qemuCapsGet(qemuCaps, QEMU_CAPS_SMP_TOPOLOGY)) {
3393
if (def->vcpus != def->maxvcpus)
3394
virBufferAsprintf(&buf, ",maxcpus=%u", def->maxvcpus);
3395
/* sockets, cores, and threads are either all zero
3396
* or all non-zero, thus checking one of them is enough */
3397
if (def->cpu && def->cpu->sockets) {
3398
virBufferAsprintf(&buf, ",sockets=%u", def->cpu->sockets);
3399
virBufferAsprintf(&buf, ",cores=%u", def->cpu->cores);
3400
virBufferAsprintf(&buf, ",threads=%u", def->cpu->threads);
3403
virBufferAsprintf(&buf, ",sockets=%u", def->maxvcpus);
3404
virBufferAsprintf(&buf, ",cores=%u", 1);
3405
virBufferAsprintf(&buf, ",threads=%u", 1);
3407
} else if (def->vcpus != def->maxvcpus) {
3408
virBufferFreeAndReset(&buf);
3409
/* FIXME - consider hot-unplugging cpus after boot for older qemu */
3410
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
3411
_("setting current vcpu count less than maximum is "
3412
"not supported with this QEMU binary"));
3416
if (virBufferError(&buf)) {
3417
virBufferFreeAndReset(&buf);
3418
virReportOOMError();
3422
return virBufferContentAndReset(&buf);
3426
qemuBuildNumaCPUArgStr(char *cpumask, virBufferPtr buf)
3432
for (i = 0; i < VIR_DOMAIN_CPUMASK_LEN; i++) {
3444
virBufferAsprintf(buf, "%d,", first);
3446
virBufferAsprintf(buf, "%d-%d,", first, last);
3453
virBufferAsprintf(buf, "%d,", first);
3455
virBufferAsprintf(buf, "%d-%d,", first, last);
3460
qemuBuildNumaArgStr(const virDomainDefPtr def, virCommandPtr cmd)
3463
virBuffer buf = VIR_BUFFER_INITIALIZER;
3465
for (i = 0; i < def->cpu->ncells; i++) {
3466
virCommandAddArg(cmd, "-numa");
3467
virBufferAsprintf(&buf, "node,nodeid=%d", def->cpu->cells[i].cellid);
3468
virBufferAddLit(&buf, ",cpus=");
3469
qemuBuildNumaCPUArgStr(def->cpu->cells[i].cpumask, &buf);
3470
virBufferAsprintf(&buf, "mem=%d",
3471
VIR_DIV_UP(def->cpu->cells[i].mem, 1024));
3473
if (virBufferError(&buf))
3476
virCommandAddArgBuffer(cmd, &buf);
3481
virBufferFreeAndReset(&buf);
3482
virReportOOMError();
3487
* Constructs a argv suitable for launching qemu with config defined
3488
* for a given virtual machine.
3490
* XXX 'conn' is only required to resolve network -> bridge name
3491
* figure out how to remove this requirement some day
3494
qemuBuildCommandLine(virConnectPtr conn,
3495
struct qemud_driver *driver,
3496
virDomainDefPtr def,
3497
virDomainChrSourceDefPtr monitor_chr,
3499
virBitmapPtr qemuCaps,
3500
const char *migrateFrom,
3502
virDomainSnapshotObjPtr snapshot,
3503
enum virNetDevVPortProfileOp vmop)
3507
int disableKQEMU = 0;
3508
int enableKQEMU = 0;
3511
const char *emulator;
3512
char uuid[VIR_UUID_STRING_BUFLEN];
3515
int last_good_net = -1;
3516
bool hasHwVirt = false;
3518
bool emitBootindex = false;
3519
int usbcontroller = 0;
3520
bool usblegacy = false;
3521
uname_normalize(&ut);
3523
virUUIDFormat(def->uuid, uuid);
3525
emulator = def->emulator;
3528
* do not use boot=on for drives when not using KVM since this
3529
* is not supported at all in upstream QEmu.
3531
if (qemuCapsGet(qemuCaps, QEMU_CAPS_KVM) &&
3532
(def->virtType == VIR_DOMAIN_VIRT_QEMU))
3533
qemuCapsClear(qemuCaps, QEMU_CAPS_DRIVE_BOOT);
3535
switch (def->virtType) {
3536
case VIR_DOMAIN_VIRT_QEMU:
3537
if (qemuCapsGet(qemuCaps, QEMU_CAPS_KQEMU))
3539
if (qemuCapsGet(qemuCaps, QEMU_CAPS_KVM))
3543
case VIR_DOMAIN_VIRT_KQEMU:
3544
if (qemuCapsGet(qemuCaps, QEMU_CAPS_KVM))
3547
if (qemuCapsGet(qemuCaps, QEMU_CAPS_ENABLE_KQEMU)) {
3549
} else if (!qemuCapsGet(qemuCaps, QEMU_CAPS_KQEMU)) {
3550
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
3551
_("the QEMU binary %s does not support kqemu"),
3556
case VIR_DOMAIN_VIRT_KVM:
3557
if (qemuCapsGet(qemuCaps, QEMU_CAPS_KQEMU))
3560
if (qemuCapsGet(qemuCaps, QEMU_CAPS_ENABLE_KVM)) {
3562
} else if (!qemuCapsGet(qemuCaps, QEMU_CAPS_KVM)) {
3563
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
3564
_("the QEMU binary %s does not support kvm"),
3569
case VIR_DOMAIN_VIRT_XEN:
3570
/* XXX better check for xenner */
3574
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
3575
_("the QEMU binary %s does not support %s"),
3576
emulator, virDomainVirtTypeToString(def->virtType));
3580
cmd = virCommandNewArgList(emulator, "-S", NULL);
3582
virCommandAddEnvPassCommon(cmd);
3584
/* This should *never* be NULL, since we always provide
3585
* a machine in the capabilities data for QEMU. So this
3586
* check is just here as a safety in case the unexpected
3588
if (def->os.machine)
3589
virCommandAddArgList(cmd, "-M", def->os.machine, NULL);
3591
if (qemuBuildCpuArgStr(driver, def, emulator, qemuCaps,
3592
&ut, &cpu, &hasHwVirt) < 0)
3596
virCommandAddArgList(cmd, "-cpu", cpu, NULL);
3599
if (qemuCapsGet(qemuCaps, QEMU_CAPS_NESTING) &&
3601
virCommandAddArg(cmd, "-enable-nesting");
3605
virCommandAddArg(cmd, "-no-kqemu");
3606
else if (enableKQEMU)
3607
virCommandAddArgList(cmd, "-enable-kqemu", "-kernel-kqemu", NULL);
3609
virCommandAddArg(cmd, "-no-kvm");
3611
virCommandAddArg(cmd, "-enable-kvm");
3613
/* Set '-m MB' based on maxmem, because the lower 'memory' limit
3614
* is set post-startup using the balloon driver. If balloon driver
3615
* is not supported, then they're out of luck anyway
3617
virCommandAddArg(cmd, "-m");
3618
virCommandAddArgFormat(cmd, "%lu", VIR_DIV_UP(def->mem.max_balloon, 1024));
3619
if (def->mem.hugepage_backed) {
3620
if (!driver->hugetlbfs_mount) {
3621
qemuReportError(VIR_ERR_INTERNAL_ERROR,
3622
"%s", _("hugetlbfs filesystem is not mounted"));
3625
if (!driver->hugepage_path) {
3626
qemuReportError(VIR_ERR_INTERNAL_ERROR,
3627
"%s", _("hugepages are disabled by administrator config"));
3630
if (!qemuCapsGet(qemuCaps, QEMU_CAPS_MEM_PATH)) {
3631
qemuReportError(VIR_ERR_INTERNAL_ERROR,
3632
_("hugepage backing not supported by '%s'"),
3636
virCommandAddArgList(cmd, "-mem-prealloc", "-mem-path",
3637
driver->hugepage_path, NULL);
3640
virCommandAddArg(cmd, "-smp");
3641
if (!(smp = qemuBuildSmpArgStr(def, qemuCaps)))
3643
virCommandAddArg(cmd, smp);
3646
if (def->cpu && def->cpu->ncells)
3647
if (qemuBuildNumaArgStr(def, cmd) < 0)
3650
if (qemuCapsGet(qemuCaps, QEMU_CAPS_NAME)) {
3651
virCommandAddArg(cmd, "-name");
3652
if (driver->setProcessName &&
3653
qemuCapsGet(qemuCaps, QEMU_CAPS_NAME_PROCESS)) {
3654
virCommandAddArgFormat(cmd, "%s,process=qemu:%s",
3655
def->name, def->name);
3657
virCommandAddArg(cmd, def->name);
3660
if (qemuCapsGet(qemuCaps, QEMU_CAPS_UUID))
3661
virCommandAddArgList(cmd, "-uuid", uuid, NULL);
3662
if (def->virtType == VIR_DOMAIN_VIRT_XEN ||
3663
STREQ(def->os.type, "xen") ||
3664
STREQ(def->os.type, "linux")) {
3665
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DOMID)) {
3666
virCommandAddArg(cmd, "-domid");
3667
virCommandAddArgFormat(cmd, "%d", def->id);
3668
} else if (qemuCapsGet(qemuCaps, QEMU_CAPS_XEN_DOMID)) {
3669
virCommandAddArg(cmd, "-xen-attach");
3670
virCommandAddArg(cmd, "-xen-domid");
3671
virCommandAddArgFormat(cmd, "%d", def->id);
3673
qemuReportError(VIR_ERR_INTERNAL_ERROR,
3674
_("qemu emulator '%s' does not support xen"),
3680
if ((def->os.smbios_mode != VIR_DOMAIN_SMBIOS_NONE) &&
3681
(def->os.smbios_mode != VIR_DOMAIN_SMBIOS_EMULATE)) {
3682
virSysinfoDefPtr source = NULL;
3683
bool skip_uuid = false;
3685
if (!qemuCapsGet(qemuCaps, QEMU_CAPS_SMBIOS_TYPE)) {
3686
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
3687
_("the QEMU binary %s does not support smbios settings"),
3692
/* should we really error out or just warn in those cases ? */
3693
if (def->os.smbios_mode == VIR_DOMAIN_SMBIOS_HOST) {
3694
if (driver->hostsysinfo == NULL) {
3695
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
3696
_("Host SMBIOS information is not available"));
3699
source = driver->hostsysinfo;
3700
/* Host and guest uuid must differ, by definition of UUID. */
3702
} else if (def->os.smbios_mode == VIR_DOMAIN_SMBIOS_SYSINFO) {
3703
if (def->sysinfo == NULL) {
3704
qemuReportError(VIR_ERR_XML_ERROR,
3705
_("Domain '%s' sysinfo are not available"),
3709
source = def->sysinfo;
3710
/* domain_conf guaranteed that system_uuid matches guest uuid. */
3712
if (source != NULL) {
3715
smbioscmd = qemuBuildSmbiosBiosStr(source);
3716
if (smbioscmd != NULL) {
3717
virCommandAddArgList(cmd, "-smbios", smbioscmd, NULL);
3718
VIR_FREE(smbioscmd);
3720
smbioscmd = qemuBuildSmbiosSystemStr(source, skip_uuid);
3721
if (smbioscmd != NULL) {
3722
virCommandAddArgList(cmd, "-smbios", smbioscmd, NULL);
3723
VIR_FREE(smbioscmd);
3729
* NB, -nographic *MUST* come before any serial, or monitor
3730
* or parallel port flags due to QEMU craziness, where it
3731
* decides to change the serial port & monitor to be on stdout
3732
* if you ask for nographic. So we have to make sure we override
3733
* these defaults ourselves...
3736
virCommandAddArg(cmd, "-nographic");
3738
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
3739
if (qemuCapsGet(qemuCaps, QEMU_CAPS_NODEFCONFIG))
3740
virCommandAddArg(cmd,
3741
"-nodefconfig"); /* Disable global config files */
3742
virCommandAddArg(cmd,
3743
"-nodefaults"); /* Disable default guest devices */
3746
/* Serial graphics adapter */
3747
if (def->os.bios.useserial == VIR_DOMAIN_BIOS_USESERIAL_YES) {
3748
if (!qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
3749
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
3750
_("qemu does not support -device"));
3753
if (!qemuCapsGet(qemuCaps, QEMU_CAPS_SGA)) {
3754
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
3755
_("qemu does not support SGA"));
3758
if (!def->nserials) {
3759
qemuReportError(VIR_ERR_XML_ERROR, "%s",
3760
_("need at least one serial port to use SGA"));
3763
virCommandAddArgList(cmd, "-device", "sga", NULL);
3768
/* Use -chardev if it's available */
3769
if (qemuCapsGet(qemuCaps, QEMU_CAPS_CHARDEV)) {
3771
virCommandAddArg(cmd, "-chardev");
3772
if (!(chrdev = qemuBuildChrChardevStr(monitor_chr, "monitor",
3775
virCommandAddArg(cmd, chrdev);
3778
virCommandAddArg(cmd, "-mon");
3779
virCommandAddArgFormat(cmd,
3780
"chardev=charmonitor,id=monitor,mode=%s",
3781
monitor_json ? "control" : "readline");
3783
const char *prefix = NULL;
3785
prefix = "control,";
3787
virCommandAddArg(cmd, "-monitor");
3788
if (!(chrdev = qemuBuildChrArgStr(monitor_chr, prefix)))
3790
virCommandAddArg(cmd, chrdev);
3795
if (qemuCapsGet(qemuCaps, QEMU_CAPS_RTC)) {
3797
virCommandAddArg(cmd, "-rtc");
3798
if (!(rtcopt = qemuBuildClockArgStr(&def->clock)))
3800
virCommandAddArg(cmd, rtcopt);
3803
switch (def->clock.offset) {
3804
case VIR_DOMAIN_CLOCK_OFFSET_LOCALTIME:
3805
case VIR_DOMAIN_CLOCK_OFFSET_TIMEZONE:
3806
virCommandAddArg(cmd, "-localtime");
3809
case VIR_DOMAIN_CLOCK_OFFSET_UTC:
3810
/* Nothing, its the default */
3814
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
3815
_("unsupported clock offset '%s'"),
3816
virDomainClockOffsetTypeToString(def->clock.offset));
3820
if (def->clock.offset == VIR_DOMAIN_CLOCK_OFFSET_TIMEZONE &&
3821
def->clock.data.timezone) {
3822
virCommandAddEnvPair(cmd, "TZ", def->clock.data.timezone);
3825
for (i = 0; i < def->clock.ntimers; i++) {
3826
switch (def->clock.timers[i]->name) {
3828
case VIR_DOMAIN_TIMER_NAME_PLATFORM:
3829
case VIR_DOMAIN_TIMER_NAME_TSC:
3830
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
3831
_("unsupported timer type (name) '%s'"),
3832
virDomainTimerNameTypeToString(def->clock.timers[i]->name));
3835
case VIR_DOMAIN_TIMER_NAME_RTC:
3836
/* This has already been taken care of (in qemuBuildClockArgStr)
3837
if QEMU_CAPS_RTC is set (mutually exclusive with
3838
QEMUD_FLAG_RTC_TD_HACK) */
3839
if (qemuCapsGet(qemuCaps, QEMU_CAPS_RTC_TD_HACK)) {
3840
switch (def->clock.timers[i]->tickpolicy) {
3842
case VIR_DOMAIN_TIMER_TICKPOLICY_DELAY:
3843
/* the default - do nothing */
3845
case VIR_DOMAIN_TIMER_TICKPOLICY_CATCHUP:
3846
virCommandAddArg(cmd, "-rtc-td-hack");
3848
case VIR_DOMAIN_TIMER_TICKPOLICY_MERGE:
3849
case VIR_DOMAIN_TIMER_TICKPOLICY_DISCARD:
3850
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
3851
_("unsupported rtc tickpolicy '%s'"),
3852
virDomainTimerTickpolicyTypeToString(def->clock.timers[i]->tickpolicy));
3855
} else if (!qemuCapsGet(qemuCaps, QEMU_CAPS_RTC)
3856
&& (def->clock.timers[i]->tickpolicy
3857
!= VIR_DOMAIN_TIMER_TICKPOLICY_DELAY)
3858
&& (def->clock.timers[i]->tickpolicy != -1)) {
3859
/* a non-default rtc policy was given, but there is no
3860
way to implement it in this version of qemu */
3861
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
3862
_("unsupported rtc tickpolicy '%s'"),
3863
virDomainTimerTickpolicyTypeToString(def->clock.timers[i]->tickpolicy));
3868
case VIR_DOMAIN_TIMER_NAME_PIT:
3869
switch (def->clock.timers[i]->tickpolicy) {
3871
case VIR_DOMAIN_TIMER_TICKPOLICY_DELAY:
3872
/* delay is the default if we don't have kernel
3873
(-no-kvm-pit), otherwise, the default is catchup. */
3874
if (qemuCapsGet(qemuCaps, QEMU_CAPS_NO_KVM_PIT))
3875
virCommandAddArg(cmd, "-no-kvm-pit-reinjection");
3877
case VIR_DOMAIN_TIMER_TICKPOLICY_CATCHUP:
3878
if (qemuCapsGet(qemuCaps, QEMU_CAPS_NO_KVM_PIT)) {
3879
/* do nothing - this is default for kvm-pit */
3880
} else if (qemuCapsGet(qemuCaps, QEMU_CAPS_TDF)) {
3881
/* -tdf switches to 'catchup' with userspace pit. */
3882
virCommandAddArg(cmd, "-tdf");
3884
/* can't catchup if we have neither pit mode */
3885
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
3886
_("unsupported pit tickpolicy '%s'"),
3887
virDomainTimerTickpolicyTypeToString(def->clock.timers[i]->tickpolicy));
3891
case VIR_DOMAIN_TIMER_TICKPOLICY_MERGE:
3892
case VIR_DOMAIN_TIMER_TICKPOLICY_DISCARD:
3893
/* no way to support these modes for pit in qemu */
3894
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
3895
_("unsupported pit tickpolicy '%s'"),
3896
virDomainTimerTickpolicyTypeToString(def->clock.timers[i]->tickpolicy));
3901
case VIR_DOMAIN_TIMER_NAME_HPET:
3902
/* the only meaningful attribute for hpet is "present". If
3903
* present is -1, that means it wasn't specified, and
3904
* should be left at the default for the
3905
* hypervisor. "default" when -no-hpet exists is "yes",
3906
* and when -no-hpet doesn't exist is "no". "confusing"?
3909
if (qemuCapsGet(qemuCaps, QEMU_CAPS_NO_HPET)) {
3910
if (def->clock.timers[i]->present == 0)
3911
virCommandAddArg(cmd, "-no-hpet");
3913
/* no hpet timer available. The only possible action
3914
is to raise an error if present="yes" */
3915
if (def->clock.timers[i]->present == 1) {
3916
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
3917
"%s", _("pit timer is not supported"));
3924
if (qemuCapsGet(qemuCaps, QEMU_CAPS_NO_REBOOT) &&
3925
def->onReboot != VIR_DOMAIN_LIFECYCLE_RESTART)
3926
virCommandAddArg(cmd, "-no-reboot");
3928
/* If JSON monitor is enabled, we can receive an event
3929
* when QEMU stops. If we use no-shutdown, then we can
3930
* watch for this event and do a soft/warm reboot.
3932
if (monitor_json && qemuCapsGet(qemuCaps, QEMU_CAPS_NO_SHUTDOWN))
3933
virCommandAddArg(cmd, "-no-shutdown");
3935
if (!(def->features & (1 << VIR_DOMAIN_FEATURE_ACPI)))
3936
virCommandAddArg(cmd, "-no-acpi");
3938
if (!def->os.bootloader) {
3940
* We prefer using explicit bootindex=N parameters for predictable
3941
* results even though domain XML doesn't use per device boot elements.
3942
* However, we can't use bootindex if boot menu was requested.
3944
if (!def->os.nBootDevs) {
3945
/* def->os.nBootDevs is guaranteed to be > 0 unless per-device boot
3946
* configuration is used
3948
if (!qemuCapsGet(qemuCaps, QEMU_CAPS_BOOTINDEX)) {
3949
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
3950
_("hypervisor lacks deviceboot feature"));
3953
emitBootindex = true;
3954
} else if (qemuCapsGet(qemuCaps, QEMU_CAPS_BOOTINDEX) &&
3955
(def->os.bootmenu != VIR_DOMAIN_BOOT_MENU_ENABLED ||
3956
!qemuCapsGet(qemuCaps, QEMU_CAPS_BOOT_MENU))) {
3957
emitBootindex = true;
3960
if (!emitBootindex) {
3961
virBuffer boot_buf = VIR_BUFFER_INITIALIZER;
3962
char boot[VIR_DOMAIN_BOOT_LAST+1];
3964
for (i = 0 ; i < def->os.nBootDevs ; i++) {
3965
switch (def->os.bootDevs[i]) {
3966
case VIR_DOMAIN_BOOT_CDROM:
3969
case VIR_DOMAIN_BOOT_FLOPPY:
3972
case VIR_DOMAIN_BOOT_DISK:
3975
case VIR_DOMAIN_BOOT_NET:
3983
boot[def->os.nBootDevs] = '\0';
3985
virCommandAddArg(cmd, "-boot");
3987
if (qemuCapsGet(qemuCaps, QEMU_CAPS_BOOT_MENU) &&
3988
def->os.bootmenu != VIR_DOMAIN_BOOT_MENU_DEFAULT) {
3989
if (def->os.bootmenu == VIR_DOMAIN_BOOT_MENU_ENABLED)
3990
virBufferAsprintf(&boot_buf, "order=%s,menu=on", boot);
3991
else if (def->os.bootmenu == VIR_DOMAIN_BOOT_MENU_DISABLED)
3992
virBufferAsprintf(&boot_buf, "order=%s,menu=off", boot);
3994
virBufferAdd(&boot_buf, boot, -1);
3997
virCommandAddArgBuffer(cmd, &boot_buf);
4001
virCommandAddArgList(cmd, "-kernel", def->os.kernel, NULL);
4003
virCommandAddArgList(cmd, "-initrd", def->os.initrd, NULL);
4004
if (def->os.cmdline)
4005
virCommandAddArgList(cmd, "-append", def->os.cmdline, NULL);
4007
virCommandAddArgList(cmd, "-bootloader", def->os.bootloader, NULL);
4010
for (i = 0 ; i < def->ndisks ; i++) {
4011
virDomainDiskDefPtr disk = def->disks[i];
4013
if (disk->driverName != NULL &&
4014
!STREQ(disk->driverName, "qemu")) {
4015
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
4016
_("unsupported driver name '%s' for disk '%s'"),
4017
disk->driverName, disk->src);
4022
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
4023
for (i = 0 ; i < def->ncontrollers ; i++) {
4024
virDomainControllerDefPtr cont = def->controllers[i];
4026
/* We don't add an explicit IDE or FD controller because the
4027
* provided PIIX4 device already includes one. It isn't possible to
4028
* remove the PIIX4. */
4029
if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_IDE ||
4030
cont->type == VIR_DOMAIN_CONTROLLER_TYPE_FDC)
4033
/* Only recent QEMU implements a SATA (AHCI) controller */
4034
if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_SATA) {
4035
if (!qemuCapsGet(qemuCaps, QEMU_CAPS_ICH9_AHCI)) {
4036
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
4037
"%s", _("SATA is not supported with this QEMU binary"));
4042
virCommandAddArg(cmd, "-device");
4043
if (!(devstr = qemuBuildControllerDevStr(cont, qemuCaps, NULL)))
4046
virCommandAddArg(cmd, devstr);
4049
} else if (def->controllers[i]->type == VIR_DOMAIN_CONTROLLER_TYPE_USB &&
4050
def->controllers[i]->model == -1 &&
4051
!qemuCapsGet(qemuCaps, QEMU_CAPS_PIIX3_USB_UHCI)) {
4053
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
4054
_("Multiple legacy USB controller not supported"));
4059
virCommandAddArg(cmd, "-device");
4062
if (!(devstr = qemuBuildControllerDevStr(def->controllers[i], qemuCaps,
4066
virCommandAddArg(cmd, devstr);
4072
/* If QEMU supports -drive param instead of old -hda, -hdb, -cdrom .. */
4073
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE)) {
4074
int bootCD = 0, bootFloppy = 0, bootDisk = 0;
4076
if ((qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE_BOOT) || emitBootindex) &&
4078
/* bootDevs will get translated into either bootindex=N or boot=on
4079
* depending on what qemu supports */
4080
for (i = 0 ; i < def->os.nBootDevs ; i++) {
4081
switch (def->os.bootDevs[i]) {
4082
case VIR_DOMAIN_BOOT_CDROM:
4085
case VIR_DOMAIN_BOOT_FLOPPY:
4088
case VIR_DOMAIN_BOOT_DISK:
4095
for (i = 0 ; i < def->ndisks ; i++) {
4098
virDomainDiskDefPtr disk = def->disks[i];
4099
int withDeviceArg = 0;
4100
bool deviceFlagMasked = false;
4102
/* Unless we have -device, then USB disks need special
4104
if ((disk->bus == VIR_DOMAIN_DISK_BUS_USB) &&
4105
!qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
4106
if (disk->device == VIR_DOMAIN_DISK_DEVICE_DISK) {
4107
virCommandAddArg(cmd, "-usbdevice");
4108
virCommandAddArgFormat(cmd, "disk:%s", disk->src);
4110
qemuReportError(VIR_ERR_INTERNAL_ERROR,
4111
_("unsupported usb disk type for '%s'"),
4118
switch (disk->device) {
4119
case VIR_DOMAIN_DISK_DEVICE_CDROM:
4123
case VIR_DOMAIN_DISK_DEVICE_FLOPPY:
4124
bootindex = bootFloppy;
4127
case VIR_DOMAIN_DISK_DEVICE_DISK:
4128
bootindex = bootDisk;
4133
virCommandAddArg(cmd, "-drive");
4135
/* Unfortunately it is not possible to use
4136
-device for floppies, or Xen paravirt
4137
devices. Fortunately, those don't need
4138
static PCI addresses, so we don't really
4139
care that we can't use -device */
4140
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
4141
if (disk->bus != VIR_DOMAIN_DISK_BUS_XEN) {
4144
qemuCapsClear(qemuCaps, QEMU_CAPS_DEVICE);
4145
deviceFlagMasked = true;
4148
optstr = qemuBuildDriveStr(conn, disk,
4149
emitBootindex ? false : !!bootindex,
4151
if (deviceFlagMasked)
4152
qemuCapsSet(qemuCaps, QEMU_CAPS_DEVICE);
4155
virCommandAddArg(cmd, optstr);
4160
else if (disk->bootIndex)
4161
bootindex = disk->bootIndex;
4163
if (withDeviceArg) {
4164
if (disk->bus == VIR_DOMAIN_DISK_BUS_FDC) {
4165
virCommandAddArg(cmd, "-global");
4166
virCommandAddArgFormat(cmd, "isa-fdc.drive%c=drive-%s",
4167
disk->info.addr.drive.unit
4172
virCommandAddArg(cmd, "-global");
4173
virCommandAddArgFormat(cmd, "isa-fdc.bootindex%c=%d",
4174
disk->info.addr.drive.unit
4179
virCommandAddArg(cmd, "-device");
4181
if (!(optstr = qemuBuildDriveDevStr(disk, bootindex,
4184
virCommandAddArg(cmd, optstr);
4190
for (i = 0 ; i < def->ndisks ; i++) {
4194
virDomainDiskDefPtr disk = def->disks[i];
4196
if (disk->bus == VIR_DOMAIN_DISK_BUS_USB) {
4197
if (disk->device == VIR_DOMAIN_DISK_DEVICE_DISK) {
4198
virCommandAddArg(cmd, "-usbdevice");
4199
virCommandAddArgFormat(cmd, "disk:%s", disk->src);
4201
qemuReportError(VIR_ERR_INTERNAL_ERROR,
4202
_("unsupported usb disk type for '%s'"),
4209
if (STREQ(disk->dst, "hdc") &&
4210
disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM) {
4212
snprintf(dev, NAME_MAX, "-%s", "cdrom");
4217
if (STRPREFIX(disk->dst, "hd") ||
4218
STRPREFIX(disk->dst, "fd")) {
4219
snprintf(dev, NAME_MAX, "-%s", disk->dst);
4221
qemuReportError(VIR_ERR_INTERNAL_ERROR,
4222
_("unsupported disk type '%s'"), disk->dst);
4227
if (disk->type == VIR_DOMAIN_DISK_TYPE_DIR) {
4228
/* QEMU only supports magic FAT format for now */
4229
if (disk->driverType &&
4230
STRNEQ(disk->driverType, "fat")) {
4231
qemuReportError(VIR_ERR_INTERNAL_ERROR,
4232
_("unsupported disk driver type for '%s'"),
4236
if (!disk->readonly) {
4237
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
4238
_("cannot create virtual FAT disks in read-write mode"));
4241
if (disk->device == VIR_DOMAIN_DISK_DEVICE_FLOPPY)
4242
fmt = "fat:floppy:%s";
4246
if (virAsprintf(&file, fmt, disk->src) < 0) {
4249
} else if (disk->type == VIR_DOMAIN_DISK_TYPE_NETWORK) {
4250
switch (disk->protocol) {
4251
case VIR_DOMAIN_DISK_PROTOCOL_NBD:
4252
if (disk->nhosts != 1) {
4253
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
4254
_("NBD accepts only one host"));
4257
if (virAsprintf(&file, "nbd:%s:%s,", disk->hosts->name,
4258
disk->hosts->port) < 0) {
4262
case VIR_DOMAIN_DISK_PROTOCOL_RBD:
4264
virBuffer opt = VIR_BUFFER_INITIALIZER;
4265
if (qemuBuildRBDString(conn, disk, &opt) < 0)
4267
if (virBufferError(&opt)) {
4268
virReportOOMError();
4271
file = virBufferContentAndReset(&opt);
4274
case VIR_DOMAIN_DISK_PROTOCOL_SHEEPDOG:
4275
if (disk->nhosts == 0) {
4276
if (virAsprintf(&file, "sheepdog:%s,", disk->src) < 0) {
4280
/* only one host is supported now */
4281
if (virAsprintf(&file, "sheepdog:%s:%s:%s,",
4282
disk->hosts->name, disk->hosts->port,
4290
if (!(file = strdup(disk->src))) {
4295
virCommandAddArgList(cmd, dev, file, NULL);
4300
if (qemuCapsGet(qemuCaps, QEMU_CAPS_FSDEV)) {
4301
for (i = 0 ; i < def->nfss ; i++) {
4303
virDomainFSDefPtr fs = def->fss[i];
4305
virCommandAddArg(cmd, "-fsdev");
4306
if (!(optstr = qemuBuildFSStr(fs, qemuCaps)))
4308
virCommandAddArg(cmd, optstr);
4311
virCommandAddArg(cmd, "-device");
4312
if (!(optstr = qemuBuildFSDevStr(fs, qemuCaps)))
4314
virCommandAddArg(cmd, optstr);
4319
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
4320
_("filesystem passthrough not supported by this QEMU"));
4326
/* If we have -device, then we set -nodefault already */
4327
if (!qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
4328
virCommandAddArgList(cmd, "-net", "none", NULL);
4332
if (emitBootindex) {
4333
/* convert <boot dev='network'/> to bootindex since we didn't emit
4336
for (i = 0 ; i < def->os.nBootDevs ; i++) {
4337
if (def->os.bootDevs[i] == VIR_DOMAIN_BOOT_NET) {
4344
for (i = 0 ; i < def->nnets ; i++) {
4345
virDomainNetDefPtr net = def->nets[i];
4347
char tapfd_name[50];
4348
char vhostfd_name[50] = "";
4350
int bootindex = bootNet;
4355
bootindex = net->bootIndex;
4357
/* VLANs are not used with -netdev, so don't record them */
4358
if (qemuCapsGet(qemuCaps, QEMU_CAPS_NETDEV) &&
4359
qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
4364
/* If appropriate, grab a physical device from the configured
4365
* network's pool of devices, or resolve bridge device name
4366
* to the one defined in the network definition.
4368
if (networkAllocateActualDevice(net) < 0)
4371
actualType = virDomainNetGetActualType(net);
4372
if (actualType == VIR_DOMAIN_NET_TYPE_NETWORK ||
4373
actualType == VIR_DOMAIN_NET_TYPE_BRIDGE) {
4374
int tapfd = qemuNetworkIfaceConnect(def, conn, driver, net,
4380
virCommandTransferFD(cmd, tapfd);
4382
if (snprintf(tapfd_name, sizeof(tapfd_name), "%d",
4383
tapfd) >= sizeof(tapfd_name))
4385
} else if (actualType == VIR_DOMAIN_NET_TYPE_DIRECT) {
4386
int tapfd = qemuPhysIfaceConnect(def, driver, net,
4392
virCommandTransferFD(cmd, tapfd);
4394
if (snprintf(tapfd_name, sizeof(tapfd_name), "%d",
4395
tapfd) >= sizeof(tapfd_name))
4399
if (actualType == VIR_DOMAIN_NET_TYPE_NETWORK ||
4400
actualType == VIR_DOMAIN_NET_TYPE_BRIDGE ||
4401
actualType == VIR_DOMAIN_NET_TYPE_DIRECT) {
4402
/* Attempt to use vhost-net mode for these types of
4406
if (qemuOpenVhostNet(def, net, qemuCaps, &vhostfd) < 0)
4409
virCommandTransferFD(cmd, vhostfd);
4411
if (snprintf(vhostfd_name, sizeof(vhostfd_name), "%d",
4412
vhostfd) >= sizeof(vhostfd_name))
4416
/* Possible combinations:
4418
* 1. Old way: -net nic,model=e1000,vlan=1 -net tap,vlan=1
4419
* 2. Semi-new: -device e1000,vlan=1 -net tap,vlan=1
4420
* 3. Best way: -netdev type=tap,id=netdev1 -device e1000,id=netdev1
4422
* NB, no support for -netdev without use of -device
4424
if (qemuCapsGet(qemuCaps, QEMU_CAPS_NETDEV) &&
4425
qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
4426
virCommandAddArg(cmd, "-netdev");
4427
if (!(host = qemuBuildHostNetStr(net, ',', vlan,
4428
tapfd_name, vhostfd_name)))
4430
virCommandAddArg(cmd, host);
4433
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
4434
virCommandAddArg(cmd, "-device");
4435
nic = qemuBuildNicDevStr(net, vlan, bootindex, qemuCaps);
4438
virCommandAddArg(cmd, nic);
4441
virCommandAddArg(cmd, "-net");
4442
if (!(nic = qemuBuildNicStr(net, "nic,", vlan)))
4444
virCommandAddArg(cmd, nic);
4447
if (!(qemuCapsGet(qemuCaps, QEMU_CAPS_NETDEV) &&
4448
qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE))) {
4449
virCommandAddArg(cmd, "-net");
4450
if (!(host = qemuBuildHostNetStr(net, ',', vlan,
4451
tapfd_name, vhostfd_name)))
4453
virCommandAddArg(cmd, host);
4459
if (def->nsmartcards) {
4460
/* -device usb-ccid was already emitted along with other
4461
* controllers. For now, qemu handles only one smartcard. */
4462
virDomainSmartcardDefPtr smartcard = def->smartcards[0];
4464
virBuffer opt = VIR_BUFFER_INITIALIZER;
4466
const char *database;
4468
if (def->nsmartcards > 1 ||
4469
smartcard->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCID ||
4470
smartcard->info.addr.ccid.controller != 0 ||
4471
smartcard->info.addr.ccid.slot != 0) {
4472
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
4473
_("this QEMU binary lacks multiple smartcard "
4475
virBufferFreeAndReset(&opt);
4479
switch (smartcard->type) {
4480
case VIR_DOMAIN_SMARTCARD_TYPE_HOST:
4481
if (!qemuCapsGet(qemuCaps, QEMU_CAPS_CHARDEV) ||
4482
!qemuCapsGet(qemuCaps, QEMU_CAPS_CCID_EMULATED)) {
4483
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
4484
_("this QEMU binary lacks smartcard host "
4489
virBufferAddLit(&opt, "ccid-card-emulated,backend=nss-emulated");
4492
case VIR_DOMAIN_SMARTCARD_TYPE_HOST_CERTIFICATES:
4493
if (!qemuCapsGet(qemuCaps, QEMU_CAPS_CHARDEV) ||
4494
!qemuCapsGet(qemuCaps, QEMU_CAPS_CCID_EMULATED)) {
4495
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
4496
_("this QEMU binary lacks smartcard host "
4501
virBufferAddLit(&opt, "ccid-card-emulated,backend=certificates");
4502
for (j = 0; j < VIR_DOMAIN_SMARTCARD_NUM_CERTIFICATES; j++) {
4503
if (strchr(smartcard->data.cert.file[j], ',')) {
4504
virBufferFreeAndReset(&opt);
4505
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
4506
_("invalid certificate name: %s"),
4507
smartcard->data.cert.file[j]);
4510
virBufferAsprintf(&opt, ",cert%d=%s", j + 1,
4511
smartcard->data.cert.file[j]);
4513
if (smartcard->data.cert.database) {
4514
if (strchr(smartcard->data.cert.database, ',')) {
4515
virBufferFreeAndReset(&opt);
4516
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
4517
_("invalid database name: %s"),
4518
smartcard->data.cert.database);
4521
database = smartcard->data.cert.database;
4523
database = VIR_DOMAIN_SMARTCARD_DEFAULT_DATABASE;
4525
virBufferAsprintf(&opt, ",database=%s", database);
4528
case VIR_DOMAIN_SMARTCARD_TYPE_PASSTHROUGH:
4529
if (!qemuCapsGet(qemuCaps, QEMU_CAPS_CHARDEV) ||
4530
!qemuCapsGet(qemuCaps, QEMU_CAPS_CCID_PASSTHRU)) {
4531
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
4532
_("this QEMU binary lacks smartcard "
4533
"passthrough mode support"));
4537
virCommandAddArg(cmd, "-chardev");
4538
if (!(devstr = qemuBuildChrChardevStr(&smartcard->data.passthru,
4539
smartcard->info.alias,
4541
virBufferFreeAndReset(&opt);
4544
virCommandAddArg(cmd, devstr);
4547
virBufferAsprintf(&opt, "ccid-card-passthru,chardev=char%s",
4548
smartcard->info.alias);
4552
qemuReportError(VIR_ERR_INTERNAL_ERROR,
4553
_("unexpected smartcard type %d"),
4555
virBufferFreeAndReset(&opt);
4558
virCommandAddArg(cmd, "-device");
4559
virBufferAsprintf(&opt, ",id=%s,bus=ccid0.0", smartcard->info.alias);
4560
virCommandAddArgBuffer(cmd, &opt);
4563
if (!def->nserials) {
4564
/* If we have -device, then we set -nodefault already */
4565
if (!qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
4566
virCommandAddArgList(cmd, "-serial", "none", NULL);
4568
for (i = 0 ; i < def->nserials ; i++) {
4569
virDomainChrDefPtr serial = def->serials[i];
4572
/* Use -chardev with -device if they are available */
4573
if (qemuCapsGet(qemuCaps, QEMU_CAPS_CHARDEV) &&
4574
qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
4575
virCommandAddArg(cmd, "-chardev");
4576
if (!(devstr = qemuBuildChrChardevStr(&serial->source,
4580
virCommandAddArg(cmd, devstr);
4583
virCommandAddArg(cmd, "-device");
4584
virCommandAddArgFormat(cmd, "isa-serial,chardev=char%s,id=%s",
4585
serial->info.alias, serial->info.alias);
4587
virCommandAddArg(cmd, "-serial");
4588
if (!(devstr = qemuBuildChrArgStr(&serial->source, NULL)))
4590
virCommandAddArg(cmd, devstr);
4596
if (!def->nparallels) {
4597
/* If we have -device, then we set -nodefault already */
4598
if (!qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
4599
virCommandAddArgList(cmd, "-parallel", "none", NULL);
4601
for (i = 0 ; i < def->nparallels ; i++) {
4602
virDomainChrDefPtr parallel = def->parallels[i];
4605
/* Use -chardev with -device if they are available */
4606
if (qemuCapsGet(qemuCaps, QEMU_CAPS_CHARDEV) &&
4607
qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
4608
virCommandAddArg(cmd, "-chardev");
4609
if (!(devstr = qemuBuildChrChardevStr(¶llel->source,
4610
parallel->info.alias,
4613
virCommandAddArg(cmd, devstr);
4616
virCommandAddArg(cmd, "-device");
4617
virCommandAddArgFormat(cmd, "isa-parallel,chardev=char%s,id=%s",
4618
parallel->info.alias,
4619
parallel->info.alias);
4621
virCommandAddArg(cmd, "-parallel");
4622
if (!(devstr = qemuBuildChrArgStr(¶llel->source, NULL)))
4624
virCommandAddArg(cmd, devstr);
4630
for (i = 0 ; i < def->nchannels ; i++) {
4631
virDomainChrDefPtr channel = def->channels[i];
4636
switch(channel->targetType) {
4637
case VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_GUESTFWD:
4638
if (!qemuCapsGet(qemuCaps, QEMU_CAPS_CHARDEV) ||
4639
!qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
4640
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
4641
"%s", _("guestfwd requires QEMU to support -chardev & -device"));
4645
virCommandAddArg(cmd, "-chardev");
4646
if (!(devstr = qemuBuildChrChardevStr(&channel->source,
4647
channel->info.alias,
4650
virCommandAddArg(cmd, devstr);
4653
addr = virSocketAddrFormat(channel->target.addr);
4656
port = virSocketAddrGetPort(channel->target.addr);
4658
virCommandAddArg(cmd, "-netdev");
4659
virCommandAddArgFormat(cmd,
4660
"user,guestfwd=tcp:%s:%i,chardev=char%s,id=user-%s",
4661
addr, port, channel->info.alias,
4662
channel->info.alias);
4666
case VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_VIRTIO:
4667
if (!qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
4668
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
4669
_("virtio channel requires QEMU to support -device"));
4673
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE_SPICEVMC) &&
4674
channel->source.type == VIR_DOMAIN_CHR_TYPE_SPICEVMC) {
4675
/* spicevmc was originally introduced via a -device
4676
* with a backend internal to qemu; although we prefer
4677
* the newer -chardev interface. */
4680
virCommandAddArg(cmd, "-chardev");
4681
if (!(devstr = qemuBuildChrChardevStr(&channel->source,
4682
channel->info.alias,
4685
virCommandAddArg(cmd, devstr);
4689
virCommandAddArg(cmd, "-device");
4690
if (!(devstr = qemuBuildVirtioSerialPortDevStr(channel,
4693
virCommandAddArg(cmd, devstr);
4699
/* Explicit console devices */
4700
for (i = 0 ; i < def->nconsoles ; i++) {
4701
virDomainChrDefPtr console = def->consoles[i];
4704
switch(console->targetType) {
4705
case VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_VIRTIO:
4706
if (!qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
4707
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
4708
_("virtio channel requires QEMU to support -device"));
4712
virCommandAddArg(cmd, "-chardev");
4713
if (!(devstr = qemuBuildChrChardevStr(&console->source,
4714
console->info.alias,
4717
virCommandAddArg(cmd, devstr);
4720
virCommandAddArg(cmd, "-device");
4721
if (!(devstr = qemuBuildVirtioSerialPortDevStr(console,
4724
virCommandAddArg(cmd, devstr);
4728
case VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_SERIAL:
4732
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
4733
_("unsupported console target type %s"),
4734
NULLSTR(virDomainChrConsoleTargetTypeToString(console->targetType)));
4739
if (usbcontroller == 0)
4740
virCommandAddArg(cmd, "-usb");
4742
for (i = 0 ; i < def->nhubs ; i++) {
4743
virDomainHubDefPtr hub = def->hubs[i];
4746
virCommandAddArg(cmd, "-device");
4747
if (!(optstr = qemuBuildHubDevStr(hub, qemuCaps)))
4749
virCommandAddArg(cmd, optstr);
4753
for (i = 0 ; i < def->ninputs ; i++) {
4754
virDomainInputDefPtr input = def->inputs[i];
4756
if (input->bus == VIR_DOMAIN_INPUT_BUS_USB) {
4757
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
4759
virCommandAddArg(cmd, "-device");
4760
if (!(optstr = qemuBuildUSBInputDevStr(input, qemuCaps)))
4762
virCommandAddArg(cmd, optstr);
4765
virCommandAddArgList(cmd, "-usbdevice",
4766
input->type == VIR_DOMAIN_INPUT_TYPE_MOUSE
4767
? "mouse" : "tablet", NULL);
4772
if (def->ngraphics > 1) {
4773
qemuReportError(VIR_ERR_INTERNAL_ERROR,
4774
"%s", _("only 1 graphics device is supported"));
4778
if ((def->ngraphics == 1) &&
4779
def->graphics[0]->type == VIR_DOMAIN_GRAPHICS_TYPE_VNC) {
4780
virBuffer opt = VIR_BUFFER_INITIALIZER;
4782
if (def->graphics[0]->data.vnc.socket ||
4783
driver->vncAutoUnixSocket) {
4785
if (!def->graphics[0]->data.vnc.socket &&
4786
virAsprintf(&def->graphics[0]->data.vnc.socket,
4787
"%s/%s.vnc", driver->libDir, def->name) == -1) {
4791
virBufferAsprintf(&opt, "unix:%s",
4792
def->graphics[0]->data.vnc.socket);
4794
} else if (qemuCapsGet(qemuCaps, QEMU_CAPS_VNC_COLON)) {
4795
const char *listenNetwork;
4796
const char *listenAddr = NULL;
4797
char *netAddr = NULL;
4801
switch (virDomainGraphicsListenGetType(def->graphics[0], 0)) {
4802
case VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_ADDRESS:
4803
listenAddr = virDomainGraphicsListenGetAddress(def->graphics[0], 0);
4806
case VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_NETWORK:
4807
listenNetwork = virDomainGraphicsListenGetNetwork(def->graphics[0], 0);
4810
ret = networkGetNetworkAddress(listenNetwork, &netAddr);
4812
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
4813
"%s", _("network-based listen not possible, "
4814
"network driver not present"));
4818
qemuReportError(VIR_ERR_XML_ERROR,
4819
_("listen network '%s' had no usable address"),
4823
listenAddr = netAddr;
4824
/* store the address we found in the <graphics> element so it will
4825
* show up in status. */
4826
if (virDomainGraphicsListenSetAddress(def->graphics[0], 0,
4827
listenAddr, -1, false) < 0)
4833
listenAddr = driver->vncListen;
4835
escapeAddr = strchr(listenAddr, ':') != NULL;
4837
virBufferAsprintf(&opt, "[%s]", listenAddr);
4839
virBufferAdd(&opt, listenAddr, -1);
4840
virBufferAsprintf(&opt, ":%d",
4841
def->graphics[0]->data.vnc.port - 5900);
4845
virBufferAsprintf(&opt, "%d",
4846
def->graphics[0]->data.vnc.port - 5900);
4849
if (qemuCapsGet(qemuCaps, QEMU_CAPS_VNC_COLON)) {
4850
if (def->graphics[0]->data.vnc.auth.passwd ||
4851
driver->vncPassword)
4852
virBufferAddLit(&opt, ",password");
4854
if (driver->vncTLS) {
4855
virBufferAddLit(&opt, ",tls");
4856
if (driver->vncTLSx509verify) {
4857
virBufferAsprintf(&opt, ",x509verify=%s",
4858
driver->vncTLSx509certdir);
4860
virBufferAsprintf(&opt, ",x509=%s",
4861
driver->vncTLSx509certdir);
4865
if (driver->vncSASL) {
4866
virBufferAddLit(&opt, ",sasl");
4868
if (driver->vncSASLdir)
4869
virCommandAddEnvPair(cmd, "SASL_CONF_DIR",
4870
driver->vncSASLdir);
4872
/* TODO: Support ACLs later */
4876
virCommandAddArg(cmd, "-vnc");
4877
virCommandAddArgBuffer(cmd, &opt);
4878
if (def->graphics[0]->data.vnc.keymap) {
4879
virCommandAddArgList(cmd, "-k", def->graphics[0]->data.vnc.keymap,
4883
/* Unless user requested it, set the audio backend to none, to
4884
* prevent it opening the host OS audio devices, since that causes
4885
* security issues and might not work when using VNC.
4887
if (driver->vncAllowHostAudio) {
4888
virCommandAddEnvPass(cmd, "QEMU_AUDIO_DRV");
4890
virCommandAddEnvString(cmd, "QEMU_AUDIO_DRV=none");
4892
} else if ((def->ngraphics == 1) &&
4893
def->graphics[0]->type == VIR_DOMAIN_GRAPHICS_TYPE_SDL) {
4894
if (qemuCapsGet(qemuCaps, QEMU_CAPS_0_10) &&
4895
!qemuCapsGet(qemuCaps, QEMU_CAPS_SDL)) {
4896
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
4897
_("sdl not supported by '%s'"),
4902
if (def->graphics[0]->data.sdl.xauth)
4903
virCommandAddEnvPair(cmd, "XAUTHORITY",
4904
def->graphics[0]->data.sdl.xauth);
4905
if (def->graphics[0]->data.sdl.display)
4906
virCommandAddEnvPair(cmd, "DISPLAY",
4907
def->graphics[0]->data.sdl.display);
4908
if (def->graphics[0]->data.sdl.fullscreen)
4909
virCommandAddArg(cmd, "-full-screen");
4911
/* If using SDL for video, then we should just let it
4912
* use QEMU's host audio drivers, possibly SDL too
4913
* User can set these two before starting libvirtd
4915
virCommandAddEnvPass(cmd, "QEMU_AUDIO_DRV");
4916
virCommandAddEnvPass(cmd, "SDL_AUDIODRIVER");
4918
/* New QEMU has this flag to let us explicitly ask for
4919
* SDL graphics. This is better than relying on the
4920
* default, since the default changes :-( */
4921
if (qemuCapsGet(qemuCaps, QEMU_CAPS_SDL))
4922
virCommandAddArg(cmd, "-sdl");
4924
} else if ((def->ngraphics == 1) &&
4925
def->graphics[0]->type == VIR_DOMAIN_GRAPHICS_TYPE_SPICE) {
4926
virBuffer opt = VIR_BUFFER_INITIALIZER;
4927
const char *listenNetwork;
4928
const char *listenAddr = NULL;
4929
char *netAddr = NULL;
4932
if (!qemuCapsGet(qemuCaps, QEMU_CAPS_SPICE)) {
4933
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
4934
_("spice graphics are not supported with this QEMU"));
4938
virBufferAsprintf(&opt, "port=%u", def->graphics[0]->data.spice.port);
4940
if (driver->spiceTLS && def->graphics[0]->data.spice.tlsPort != -1)
4941
virBufferAsprintf(&opt, ",tls-port=%u", def->graphics[0]->data.spice.tlsPort);
4943
switch (virDomainGraphicsListenGetType(def->graphics[0], 0)) {
4944
case VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_ADDRESS:
4945
listenAddr = virDomainGraphicsListenGetAddress(def->graphics[0], 0);
4948
case VIR_DOMAIN_GRAPHICS_LISTEN_TYPE_NETWORK:
4949
listenNetwork = virDomainGraphicsListenGetNetwork(def->graphics[0], 0);
4952
ret = networkGetNetworkAddress(listenNetwork, &netAddr);
4954
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
4955
"%s", _("network-based listen not possible, "
4956
"network driver not present"));
4960
qemuReportError(VIR_ERR_XML_ERROR,
4961
_("listen network '%s' had no usable address"),
4965
listenAddr = netAddr;
4966
/* store the address we found in the <graphics> element so it will
4967
* show up in status. */
4968
if (virDomainGraphicsListenSetAddress(def->graphics[0], 0,
4969
listenAddr, -1, false) < 0)
4975
listenAddr = driver->spiceListen;
4977
virBufferAsprintf(&opt, ",addr=%s", listenAddr);
4981
/* In the password case we set it via monitor command, to avoid
4982
* making it visible on CLI, so there's no use of password=XXX
4983
* in this bit of the code */
4984
if (!def->graphics[0]->data.spice.auth.passwd &&
4985
!driver->spicePassword)
4986
virBufferAddLit(&opt, ",disable-ticketing");
4988
if (driver->spiceTLS)
4989
virBufferAsprintf(&opt, ",x509-dir=%s",
4990
driver->spiceTLSx509certdir);
4992
for (i = 0 ; i < VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_LAST ; i++) {
4993
int mode = def->graphics[0]->data.spice.channels[i];
4995
case VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_MODE_SECURE:
4996
virBufferAsprintf(&opt, ",tls-channel=%s",
4997
virDomainGraphicsSpiceChannelNameTypeToString(i));
4999
case VIR_DOMAIN_GRAPHICS_SPICE_CHANNEL_MODE_INSECURE:
5000
virBufferAsprintf(&opt, ",plaintext-channel=%s",
5001
virDomainGraphicsSpiceChannelNameTypeToString(i));
5005
if (def->graphics[0]->data.spice.image)
5006
virBufferAsprintf(&opt, ",image-compression=%s",
5007
virDomainGraphicsSpiceImageCompressionTypeToString(def->graphics[0]->data.spice.image));
5008
if (def->graphics[0]->data.spice.jpeg)
5009
virBufferAsprintf(&opt, ",jpeg-wan-compression=%s",
5010
virDomainGraphicsSpiceJpegCompressionTypeToString(def->graphics[0]->data.spice.jpeg));
5011
if (def->graphics[0]->data.spice.zlib)
5012
virBufferAsprintf(&opt, ",zlib-glz-wan-compression=%s",
5013
virDomainGraphicsSpiceZlibCompressionTypeToString(def->graphics[0]->data.spice.zlib));
5014
if (def->graphics[0]->data.spice.playback)
5015
virBufferAsprintf(&opt, ",playback-compression=%s",
5016
virDomainGraphicsSpicePlaybackCompressionTypeToString(def->graphics[0]->data.spice.playback));
5017
if (def->graphics[0]->data.spice.streaming)
5018
virBufferAsprintf(&opt, ",streaming-video=%s",
5019
virDomainGraphicsSpiceStreamingModeTypeToString(def->graphics[0]->data.spice.streaming));
5020
if (def->graphics[0]->data.spice.copypaste == VIR_DOMAIN_GRAPHICS_SPICE_CLIPBOARD_COPYPASTE_NO)
5021
virBufferAddLit(&opt, ",disable-copy-paste");
5023
virCommandAddArg(cmd, "-spice");
5024
virCommandAddArgBuffer(cmd, &opt);
5025
if (def->graphics[0]->data.spice.keymap)
5026
virCommandAddArgList(cmd, "-k",
5027
def->graphics[0]->data.spice.keymap, NULL);
5028
/* SPICE includes native support for tunnelling audio, so we
5029
* set the audio backend to point at SPICE's own driver
5031
virCommandAddEnvString(cmd, "QEMU_AUDIO_DRV=spice");
5033
} else if ((def->ngraphics == 1)) {
5034
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
5035
_("unsupported graphics type '%s'"),
5036
virDomainGraphicsTypeToString(def->graphics[0]->type));
5040
if (def->nvideos > 0) {
5041
if (qemuCapsGet(qemuCaps, QEMU_CAPS_VGA)) {
5042
if (def->videos[0]->type == VIR_DOMAIN_VIDEO_TYPE_XEN) {
5043
/* nothing - vga has no effect on Xen pvfb */
5045
if ((def->videos[0]->type == VIR_DOMAIN_VIDEO_TYPE_QXL) &&
5046
!qemuCapsGet(qemuCaps, QEMU_CAPS_VGA_QXL)) {
5047
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
5048
_("This QEMU does not support QXL graphics adapters"));
5052
const char *vgastr = qemuVideoTypeToString(def->videos[0]->type);
5053
if (!vgastr || STREQ(vgastr, "")) {
5054
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
5055
_("video type %s is not supported with QEMU"),
5056
virDomainVideoTypeToString(def->videos[0]->type));
5060
virCommandAddArgList(cmd, "-vga", vgastr, NULL);
5062
if (def->videos[0]->type == VIR_DOMAIN_VIDEO_TYPE_QXL) {
5063
if (def->videos[0]->vram &&
5064
qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
5065
if (def->videos[0]->vram > (UINT_MAX / 1024)) {
5066
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
5067
_("value for 'vram' must be less than '%u'"),
5072
virCommandAddArg(cmd, "-global");
5074
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE_QXL_VGA))
5075
virCommandAddArgFormat(cmd, "qxl-vga.vram_size=%u",
5076
def->videos[0]->vram * 1024);
5078
virCommandAddArgFormat(cmd, "qxl.vram_size=%u",
5079
def->videos[0]->vram * 1024);
5085
switch (def->videos[0]->type) {
5086
case VIR_DOMAIN_VIDEO_TYPE_VGA:
5087
virCommandAddArg(cmd, "-std-vga");
5090
case VIR_DOMAIN_VIDEO_TYPE_VMVGA:
5091
virCommandAddArg(cmd, "-vmwarevga");
5094
case VIR_DOMAIN_VIDEO_TYPE_XEN:
5095
case VIR_DOMAIN_VIDEO_TYPE_CIRRUS:
5096
/* No special args - this is the default */
5100
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
5101
_("video type %s is not supported with this QEMU"),
5102
virDomainVideoTypeToString(def->videos[0]->type));
5107
if (def->nvideos > 1) {
5108
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
5109
for (i = 1 ; i < def->nvideos ; i++) {
5111
if (def->videos[i]->type != VIR_DOMAIN_VIDEO_TYPE_QXL) {
5112
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
5113
_("video type %s is only valid as primary video card"),
5114
virDomainVideoTypeToString(def->videos[0]->type));
5118
virCommandAddArg(cmd, "-device");
5120
if (!(str = qemuBuildVideoDevStr(def->videos[i], qemuCaps)))
5123
virCommandAddArg(cmd, str);
5127
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
5128
"%s", _("only one video card is currently supported"));
5134
/* If we have -device, then we set -nodefault already */
5135
if (!qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE) &&
5136
qemuCapsGet(qemuCaps, QEMU_CAPS_VGA) &&
5137
qemuCapsGet(qemuCaps, QEMU_CAPS_VGA_NONE))
5138
virCommandAddArgList(cmd, "-vga", "none", NULL);
5141
/* Add sound hardware */
5143
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
5144
for (i = 0 ; i < def->nsounds ; i++) {
5145
virDomainSoundDefPtr sound = def->sounds[i];
5148
/* Sadly pcspk device doesn't use -device syntax. Fortunately
5149
* we don't need to set any PCI address on it, so we don't
5151
if (sound->model == VIR_DOMAIN_SOUND_MODEL_PCSPK) {
5152
virCommandAddArgList(cmd, "-soundhw", "pcspk", NULL);
5154
virCommandAddArg(cmd, "-device");
5155
if (!(str = qemuBuildSoundDevStr(sound, qemuCaps)))
5158
virCommandAddArg(cmd, str);
5160
if (sound->model == VIR_DOMAIN_SOUND_MODEL_ICH6) {
5161
char *codecstr = NULL;
5162
if (!qemuCapsGet(qemuCaps, QEMU_CAPS_HDA_DUPLEX)) {
5163
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
5164
_("this QEMU binary lacks hda support"));
5168
virCommandAddArg(cmd, "-device");
5169
if (!(codecstr = qemuBuildSoundCodecStr(sound,
5174
virCommandAddArg(cmd, codecstr);
5184
if (VIR_ALLOC_N(modstr, size+1) < 0)
5187
for (i = 0 ; i < def->nsounds && size > 0 ; i++) {
5188
virDomainSoundDefPtr sound = def->sounds[i];
5189
const char *model = virDomainSoundModelTypeToString(sound->model);
5192
qemuReportError(VIR_ERR_INTERNAL_ERROR,
5193
"%s", _("invalid sound model"));
5197
if (sound->model == VIR_DOMAIN_SOUND_MODEL_ICH6) {
5199
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
5200
_("this QEMU binary lacks hda support"));
5204
strncat(modstr, model, size);
5205
size -= strlen(model);
5206
if (i < (def->nsounds - 1))
5207
strncat(modstr, ",", size--);
5209
virCommandAddArgList(cmd, "-soundhw", modstr, NULL);
5214
/* Add watchdog hardware */
5215
if (def->watchdog) {
5216
virDomainWatchdogDefPtr watchdog = def->watchdog;
5219
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
5220
virCommandAddArg(cmd, "-device");
5222
optstr = qemuBuildWatchdogDevStr(watchdog, qemuCaps);
5226
virCommandAddArg(cmd, "-watchdog");
5228
const char *model = virDomainWatchdogModelTypeToString(watchdog->model);
5230
qemuReportError(VIR_ERR_INTERNAL_ERROR,
5231
"%s", _("missing watchdog model"));
5235
if (!(optstr = strdup(model)))
5238
virCommandAddArg(cmd, optstr);
5241
int act = watchdog->action;
5242
if (act == VIR_DOMAIN_WATCHDOG_ACTION_DUMP)
5243
act = VIR_DOMAIN_WATCHDOG_ACTION_PAUSE;
5244
const char *action = virDomainWatchdogActionTypeToString(act);
5246
qemuReportError(VIR_ERR_INTERNAL_ERROR,
5247
"%s", _("invalid watchdog action"));
5250
virCommandAddArgList(cmd, "-watchdog-action", action, NULL);
5253
/* Add redirected devices */
5254
for (i = 0 ; i < def->nredirdevs ; i++) {
5255
virDomainRedirdevDefPtr redirdev = def->redirdevs[i];
5258
virCommandAddArg(cmd, "-chardev");
5259
if (!(devstr = qemuBuildChrChardevStr(&redirdev->source.chr,
5260
redirdev->info.alias,
5265
virCommandAddArg(cmd, devstr);
5268
if (!qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
5271
virCommandAddArg(cmd, "-device");
5272
if (!(devstr = qemuBuildRedirdevDevStr(redirdev, qemuCaps)))
5274
virCommandAddArg(cmd, devstr);
5279
/* Add host passthrough hardware */
5280
for (i = 0 ; i < def->nhostdevs ; i++) {
5281
virDomainHostdevDefPtr hostdev = def->hostdevs[i];
5284
if (hostdev->bootIndex) {
5285
if (hostdev->mode != VIR_DOMAIN_HOSTDEV_MODE_SUBSYS ||
5286
hostdev->source.subsys.type != VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI) {
5287
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
5288
_("booting from assigned devices is only"
5289
" supported for PCI devices"));
5291
} else if (!qemuCapsGet(qemuCaps, QEMU_CAPS_PCI_BOOTINDEX)) {
5292
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
5293
_("booting from assigned PCI devices is not"
5294
" supported with this version of qemu"));
5300
if (hostdev->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS &&
5301
hostdev->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB) {
5303
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
5304
virCommandAddArg(cmd, "-device");
5305
if (!(devstr = qemuBuildUSBHostdevDevStr(hostdev, qemuCaps)))
5307
virCommandAddArg(cmd, devstr);
5310
virCommandAddArg(cmd, "-usbdevice");
5311
if (!(devstr = qemuBuildUSBHostdevUsbDevStr(hostdev)))
5313
virCommandAddArg(cmd, devstr);
5319
if (hostdev->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS &&
5320
hostdev->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI) {
5321
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
5322
char *configfd_name = NULL;
5323
if (qemuCapsGet(qemuCaps, QEMU_CAPS_PCI_CONFIGFD)) {
5324
int configfd = qemuOpenPCIConfig(hostdev);
5326
if (configfd >= 0) {
5327
if (virAsprintf(&configfd_name, "%d", configfd) < 0) {
5328
VIR_FORCE_CLOSE(configfd);
5332
virCommandTransferFD(cmd, configfd);
5335
virCommandAddArg(cmd, "-device");
5336
devstr = qemuBuildPCIHostdevDevStr(hostdev, configfd_name, qemuCaps);
5337
VIR_FREE(configfd_name);
5340
virCommandAddArg(cmd, devstr);
5342
} else if (qemuCapsGet(qemuCaps, QEMU_CAPS_PCIDEVICE)) {
5343
virCommandAddArg(cmd, "-pcidevice");
5344
if (!(devstr = qemuBuildPCIHostdevPCIDevStr(hostdev)))
5346
virCommandAddArg(cmd, devstr);
5349
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
5350
_("PCI device assignment is not supported by this version of qemu"));
5356
/* Migration is very annoying due to wildly varying syntax &
5357
* capabilities over time of KVM / QEMU codebases.
5360
virCommandAddArg(cmd, "-incoming");
5361
if (STRPREFIX(migrateFrom, "tcp")) {
5362
if (!qemuCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_TCP)) {
5363
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
5364
"%s", _("TCP migration is not supported with "
5365
"this QEMU binary"));
5368
virCommandAddArg(cmd, migrateFrom);
5369
} else if (STREQ(migrateFrom, "stdio")) {
5370
if (qemuCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_FD)) {
5371
virCommandAddArgFormat(cmd, "fd:%d", migrateFd);
5372
virCommandPreserveFD(cmd, migrateFd);
5373
} else if (qemuCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_EXEC)) {
5374
virCommandAddArg(cmd, "exec:cat");
5375
virCommandSetInputFD(cmd, migrateFd);
5376
} else if (qemuCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_KVM_STDIO)) {
5377
virCommandAddArg(cmd, migrateFrom);
5378
virCommandSetInputFD(cmd, migrateFd);
5380
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
5381
"%s", _("STDIO migration is not supported "
5382
"with this QEMU binary"));
5385
} else if (STRPREFIX(migrateFrom, "exec")) {
5386
if (!qemuCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_EXEC)) {
5387
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
5388
"%s", _("EXEC migration is not supported "
5389
"with this QEMU binary"));
5392
virCommandAddArg(cmd, migrateFrom);
5393
} else if (STRPREFIX(migrateFrom, "fd")) {
5394
if (!qemuCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_FD)) {
5395
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
5396
"%s", _("FD migration is not supported "
5397
"with this QEMU binary"));
5400
virCommandAddArg(cmd, migrateFrom);
5401
virCommandPreserveFD(cmd, migrateFd);
5402
} else if (STRPREFIX(migrateFrom, "unix")) {
5403
if (!qemuCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_UNIX)) {
5404
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
5405
"%s", _("UNIX migration is not supported "
5406
"with this QEMU binary"));
5409
virCommandAddArg(cmd, migrateFrom);
5411
qemuReportError(VIR_ERR_INTERNAL_ERROR,
5412
"%s", _("unknown migration protocol"));
5417
/* QEMU changed its default behavior to not include the virtio balloon
5418
* device. Explicitly request it to ensure it will be present.
5420
* NB: Earlier we declared that VirtIO balloon will always be in
5421
* slot 0x3 on bus 0x0
5423
if ((def->memballoon) &&
5424
(def->memballoon->model != VIR_DOMAIN_MEMBALLOON_MODEL_NONE)) {
5425
if (def->memballoon->model != VIR_DOMAIN_MEMBALLOON_MODEL_VIRTIO) {
5426
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
5427
_("Memory balloon device type '%s' is not supported by this version of qemu"),
5428
virDomainMemballoonModelTypeToString(def->memballoon->model));
5431
if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
5433
virCommandAddArg(cmd, "-device");
5435
optstr = qemuBuildMemballoonDevStr(def->memballoon, qemuCaps);
5438
virCommandAddArg(cmd, optstr);
5440
} else if (qemuCapsGet(qemuCaps, QEMU_CAPS_BALLOON)) {
5441
virCommandAddArgList(cmd, "-balloon", "virtio", NULL);
5446
virCommandAddArgList(cmd, "-loadvm", snapshot->def->name, NULL);
5448
if (def->namespaceData) {
5449
qemuDomainCmdlineDefPtr qemucmd;
5451
qemucmd = def->namespaceData;
5452
for (i = 0; i < qemucmd->num_args; i++)
5453
virCommandAddArg(cmd, qemucmd->args[i]);
5454
for (i = 0; i < qemucmd->num_env; i++)
5455
virCommandAddEnvPair(cmd, qemucmd->env_name[i],
5456
qemucmd->env_value[i]
5457
? qemucmd->env_value[i] : "");
5463
virReportOOMError();
5465
/* free up any resources in the network driver */
5466
for (i = 0; i <= last_good_net; i++)
5467
virDomainConfNWFilterTeardown(def->nets[i]);
5468
virCommandFree(cmd);
5474
* This method takes a string representing a QEMU command line ARGV set
5475
* optionally prefixed by a list of environment variables. It then tries
5476
* to split it up into a NULL terminated list of env & argv, splitting
5479
static int qemuStringToArgvEnv(const char *args,
5480
const char ***retenv,
5481
const char ***retargv)
5483
char **arglist = NULL;
5488
const char *curr = args;
5490
const char **progenv = NULL;
5491
const char **progargv = NULL;
5493
/* Iterate over string, splitting on sequences of ' ' */
5494
while (curr && *curr != '\0') {
5499
/* accept a space in CEPH_ARGS */
5500
if (STRPREFIX(curr, "CEPH_ARGS=-m ")) {
5501
start += strlen("CEPH_ARGS=-m ");
5503
if (*start == '\'') {
5506
next = strchr(start + 1, '\'');
5507
} else if (*start == '"') {
5510
next = strchr(start + 1, '"');
5512
next = strchr(start, ' ');
5515
next = strchr(curr, '\n');
5518
arg = strndup(curr, next-curr);
5519
if (*next == '\'' ||
5529
if (argalloc == argcount) {
5530
if (VIR_REALLOC_N(arglist, argalloc+10) < 0) {
5537
arglist[argcount++] = arg;
5539
while (next && c_isspace(*next))
5545
/* Iterate over list of args, finding first arg not containing
5546
* the '=' character (eg, skip over env vars FOO=bar) */
5547
for (envend = 0 ; ((envend < argcount) &&
5548
(strchr(arglist[envend], '=') != NULL));
5552
/* Copy the list of env vars */
5554
if (VIR_REALLOC_N(progenv, envend+1) < 0)
5556
for (i = 0 ; i < envend ; i++) {
5557
progenv[i] = arglist[i];
5563
/* Copy the list of argv */
5564
if (VIR_REALLOC_N(progargv, argcount-envend + 1) < 0)
5566
for (i = envend ; i < argcount ; i++)
5567
progargv[i-envend] = arglist[i];
5568
progargv[i-envend] = NULL;
5573
*retargv = progargv;
5578
for (i = 0 ; progenv && progenv[i] ; i++)
5579
VIR_FREE(progenv[i]);
5581
for (i = 0 ; i < argcount ; i++)
5582
VIR_FREE(arglist[i]);
5584
virReportOOMError();
5590
* Search for a named env variable, and return the value part
5592
static const char *qemuFindEnv(const char **progenv,
5596
int len = strlen(name);
5598
for (i = 0 ; progenv && progenv[i] ; i++) {
5599
if (STREQLEN(progenv[i], name, len) &&
5600
progenv[i][len] == '=')
5601
return progenv[i] + len + 1;
5607
* Takes a string containing a set of key=value,key=value,key...
5608
* parameters and splits them up, returning two arrays with
5609
* the individual keys and values. If allowEmptyValue is nonzero,
5610
* the "=value" part is optional and if a key with no value is found,
5611
* NULL is be placed into corresponding place in retvalues.
5614
qemuParseKeywords(const char *str,
5615
char ***retkeywords,
5617
int allowEmptyValue)
5619
int keywordCount = 0;
5620
int keywordAlloc = 0;
5621
char **keywords = NULL;
5622
char **values = NULL;
5623
const char *start = str;
5627
*retkeywords = NULL;
5629
end = start + strlen(str);
5632
const char *separator;
5633
const char *endmark;
5637
if (!(endmark = strchr(start, ',')))
5639
if (!(separator = strchr(start, '=')))
5642
if (separator >= endmark) {
5643
if (!allowEmptyValue) {
5644
qemuReportError(VIR_ERR_INTERNAL_ERROR,
5645
_("malformed keyword arguments in '%s'"), str);
5648
separator = endmark;
5651
if (!(keyword = strndup(start, separator - start)))
5654
if (separator < endmark) {
5656
if (!(value = strndup(separator, endmark - separator))) {
5662
if (keywordAlloc == keywordCount) {
5663
if (VIR_REALLOC_N(keywords, keywordAlloc + 10) < 0 ||
5664
VIR_REALLOC_N(values, keywordAlloc + 10) < 0) {
5672
keywords[keywordCount] = keyword;
5673
values[keywordCount] = value;
5676
start = endmark < end ? endmark + 1 : NULL;
5679
*retkeywords = keywords;
5680
*retvalues = values;
5682
return keywordCount;
5685
virReportOOMError();
5687
for (i = 0 ; i < keywordCount ; i++) {
5688
VIR_FREE(keywords[i]);
5689
VIR_FREE(values[i]);
5697
* Tries to parse new style QEMU -drive args.
5699
* eg -drive file=/dev/HostVG/VirtData1,if=ide,index=1
5701
* Will fail if not using the 'index' keyword
5703
static virDomainDiskDefPtr
5704
qemuParseCommandLineDisk(virCapsPtr caps,
5707
bool old_style_ceph_args)
5709
virDomainDiskDefPtr def = NULL;
5718
if ((nkeywords = qemuParseKeywords(val,
5723
if (VIR_ALLOC(def) < 0) {
5724
virReportOOMError();
5728
def->bus = VIR_DOMAIN_DISK_BUS_IDE;
5729
def->device = VIR_DOMAIN_DISK_DEVICE_DISK;
5730
def->type = VIR_DOMAIN_DISK_TYPE_FILE;
5732
for (i = 0 ; i < nkeywords ; i++) {
5733
if (STREQ(keywords[i], "file")) {
5734
if (values[i] && STRNEQ(values[i], "")) {
5735
def->src = values[i];
5737
if (STRPREFIX(def->src, "/dev/"))
5738
def->type = VIR_DOMAIN_DISK_TYPE_BLOCK;
5739
else if (STRPREFIX(def->src, "nbd:")) {
5742
def->type = VIR_DOMAIN_DISK_TYPE_NETWORK;
5743
def->protocol = VIR_DOMAIN_DISK_PROTOCOL_NBD;
5744
host = def->src + strlen("nbd:");
5745
port = strchr(host, ':');
5747
qemuReportError(VIR_ERR_INTERNAL_ERROR,
5748
_("cannot parse nbd filename '%s'"),
5754
if (VIR_ALLOC(def->hosts) < 0) {
5755
virReportOOMError();
5759
def->hosts->name = strdup(host);
5760
if (!def->hosts->name) {
5761
virReportOOMError();
5764
def->hosts->port = strdup(port);
5765
if (!def->hosts->port) {
5766
virReportOOMError();
5772
} else if (STRPREFIX(def->src, "rbd:")) {
5775
def->type = VIR_DOMAIN_DISK_TYPE_NETWORK;
5776
def->protocol = VIR_DOMAIN_DISK_PROTOCOL_RBD;
5777
def->src = strdup(p + strlen("rbd:"));
5779
virReportOOMError();
5782
/* old-style CEPH_ARGS env variable is parsed later */
5783
if (!old_style_ceph_args && qemuParseRBDString(def) < 0)
5787
} else if (STRPREFIX(def->src, "sheepdog:")) {
5791
def->type = VIR_DOMAIN_DISK_TYPE_NETWORK;
5792
def->protocol = VIR_DOMAIN_DISK_PROTOCOL_SHEEPDOG;
5793
def->src = strdup(p + strlen("sheepdog:"));
5795
virReportOOMError();
5799
/* def->src must be [vdiname] or [host]:[port]:[vdiname] */
5800
port = strchr(def->src, ':');
5803
vdi = strchr(port, ':');
5806
qemuReportError(VIR_ERR_INTERNAL_ERROR,
5807
_("cannot parse sheepdog filename '%s'"), p);
5811
if (VIR_ALLOC(def->hosts) < 0) {
5812
virReportOOMError();
5816
def->hosts->name = def->src;
5817
def->hosts->port = strdup(port);
5818
if (!def->hosts->port) {
5819
virReportOOMError();
5822
def->src = strdup(vdi);
5824
virReportOOMError();
5831
def->type = VIR_DOMAIN_DISK_TYPE_FILE;
5833
def->type = VIR_DOMAIN_DISK_TYPE_FILE;
5835
} else if (STREQ(keywords[i], "if")) {
5836
if (STREQ(values[i], "ide"))
5837
def->bus = VIR_DOMAIN_DISK_BUS_IDE;
5838
else if (STREQ(values[i], "scsi"))
5839
def->bus = VIR_DOMAIN_DISK_BUS_SCSI;
5840
else if (STREQ(values[i], "virtio"))
5841
def->bus = VIR_DOMAIN_DISK_BUS_VIRTIO;
5842
else if (STREQ(values[i], "xen"))
5843
def->bus = VIR_DOMAIN_DISK_BUS_XEN;
5844
} else if (STREQ(keywords[i], "media")) {
5845
if (STREQ(values[i], "cdrom")) {
5846
def->device = VIR_DOMAIN_DISK_DEVICE_CDROM;
5848
} else if (STREQ(values[i], "floppy"))
5849
def->device = VIR_DOMAIN_DISK_DEVICE_FLOPPY;
5850
} else if (STREQ(keywords[i], "format")) {
5851
def->driverName = strdup("qemu");
5852
if (!def->driverName) {
5853
virDomainDiskDefFree(def);
5855
virReportOOMError();
5858
def->driverType = values[i];
5860
} else if (STREQ(keywords[i], "cache")) {
5861
if (STREQ(values[i], "off") ||
5862
STREQ(values[i], "none"))
5863
def->cachemode = VIR_DOMAIN_DISK_CACHE_DISABLE;
5864
else if (STREQ(values[i], "writeback") ||
5865
STREQ(values[i], "on"))
5866
def->cachemode = VIR_DOMAIN_DISK_CACHE_WRITEBACK;
5867
else if (STREQ(values[i], "writethrough"))
5868
def->cachemode = VIR_DOMAIN_DISK_CACHE_WRITETHRU;
5869
else if (STREQ(values[i], "directsync"))
5870
def->cachemode = VIR_DOMAIN_DISK_CACHE_DIRECTSYNC;
5871
else if (STREQ(values[i], "unsafe"))
5872
def->cachemode = VIR_DOMAIN_DISK_CACHE_UNSAFE;
5873
} else if (STREQ(keywords[i], "werror")) {
5874
if (STREQ(values[i], "stop"))
5875
def->error_policy = VIR_DOMAIN_DISK_ERROR_POLICY_STOP;
5876
else if (STREQ(values[i], "report"))
5877
def->error_policy = VIR_DOMAIN_DISK_ERROR_POLICY_REPORT;
5878
else if (STREQ(values[i], "ignore"))
5879
def->error_policy = VIR_DOMAIN_DISK_ERROR_POLICY_IGNORE;
5880
else if (STREQ(values[i], "enospc"))
5881
def->error_policy = VIR_DOMAIN_DISK_ERROR_POLICY_ENOSPACE;
5882
} else if (STREQ(keywords[i], "rerror")) {
5883
if (STREQ(values[i], "stop"))
5884
def->rerror_policy = VIR_DOMAIN_DISK_ERROR_POLICY_STOP;
5885
else if (STREQ(values[i], "report"))
5886
def->rerror_policy = VIR_DOMAIN_DISK_ERROR_POLICY_REPORT;
5887
else if (STREQ(values[i], "ignore"))
5888
def->rerror_policy = VIR_DOMAIN_DISK_ERROR_POLICY_IGNORE;
5889
} else if (STREQ(keywords[i], "index")) {
5890
if (virStrToLong_i(values[i], NULL, 10, &idx) < 0) {
5891
virDomainDiskDefFree(def);
5893
qemuReportError(VIR_ERR_INTERNAL_ERROR,
5894
_("cannot parse drive index '%s'"), val);
5897
} else if (STREQ(keywords[i], "bus")) {
5898
if (virStrToLong_i(values[i], NULL, 10, &busid) < 0) {
5899
virDomainDiskDefFree(def);
5901
qemuReportError(VIR_ERR_INTERNAL_ERROR,
5902
_("cannot parse drive bus '%s'"), val);
5905
} else if (STREQ(keywords[i], "unit")) {
5906
if (virStrToLong_i(values[i], NULL, 10, &unitid) < 0) {
5907
virDomainDiskDefFree(def);
5909
qemuReportError(VIR_ERR_INTERNAL_ERROR,
5910
_("cannot parse drive unit '%s'"), val);
5913
} else if (STREQ(keywords[i], "readonly")) {
5914
if ((values[i] == NULL) || STREQ(values[i], "on"))
5916
} else if (STREQ(keywords[i], "aio")) {
5917
if ((def->iomode = virDomainDiskIoTypeFromString(values[i])) < 0) {
5918
qemuReportError(VIR_ERR_INTERNAL_ERROR,
5919
_("cannot parse io mode '%s'"), values[i]);
5924
if (def->rerror_policy == def->error_policy)
5925
def->rerror_policy = 0;
5928
def->device == VIR_DOMAIN_DISK_DEVICE_DISK &&
5929
def->type != VIR_DOMAIN_DISK_TYPE_NETWORK) {
5930
qemuReportError(VIR_ERR_INTERNAL_ERROR,
5931
_("missing file parameter in drive '%s'"), val);
5932
virDomainDiskDefFree(def);
5937
def->bus == VIR_DOMAIN_DISK_BUS_VIRTIO)
5943
qemuReportError(VIR_ERR_INTERNAL_ERROR,
5944
_("missing index/unit/bus parameter in drive '%s'"), val);
5945
virDomainDiskDefFree(def);
5956
case VIR_DOMAIN_DISK_BUS_IDE:
5957
idx = (busid * 2) + unitid;
5959
case VIR_DOMAIN_DISK_BUS_SCSI:
5960
idx = (busid * 7) + unitid;
5968
if (def->bus == VIR_DOMAIN_DISK_BUS_IDE) {
5969
def->dst = strdup("hda");
5970
} else if (def->bus == VIR_DOMAIN_DISK_BUS_SCSI) {
5971
def->dst = strdup("sda");
5972
} else if (def->bus == VIR_DOMAIN_DISK_BUS_VIRTIO) {
5973
def->dst = strdup("vda");
5974
} else if (def->bus == VIR_DOMAIN_DISK_BUS_XEN) {
5975
def->dst = strdup("xvda");
5977
def->dst = strdup("hda");
5981
virDomainDiskDefFree(def);
5983
virReportOOMError();
5986
if (STREQ(def->dst, "xvda"))
5987
def->dst[3] = 'a' + idx;
5989
def->dst[2] = 'a' + idx;
5991
if (virDomainDiskDefAssignAddress(caps, def) < 0) {
5992
qemuReportError(VIR_ERR_INTERNAL_ERROR,
5993
_("invalid device name '%s'"), def->dst);
5994
virDomainDiskDefFree(def);
5996
/* fall through to "cleanup" */
6000
for (i = 0 ; i < nkeywords ; i++) {
6001
VIR_FREE(keywords[i]);
6002
VIR_FREE(values[i]);
6010
* Tries to find a NIC definition matching a vlan we want
6013
qemuFindNICForVLAN(int nnics,
6018
for (i = 0 ; i < nnics ; i++) {
6020
const char *tmp = strstr(nics[i], "vlan=");
6025
tmp += strlen("vlan=");
6027
if (virStrToLong_i(tmp, &end, 10, &gotvlan) < 0) {
6028
qemuReportError(VIR_ERR_INTERNAL_ERROR,
6029
_("cannot parse NIC vlan in '%s'"), nics[i]);
6033
if (gotvlan == wantvlan)
6037
if (wantvlan == 0 && nnics > 0)
6040
qemuReportError(VIR_ERR_INTERNAL_ERROR,
6041
_("cannot find NIC definition for vlan %d"), wantvlan);
6047
* Tries to parse a QEMU -net backend argument. Gets given
6048
* a list of all known -net frontend arguments to try and
6049
* match up against. Horribly complicated stuff
6051
static virDomainNetDefPtr
6052
qemuParseCommandLineNet(virCapsPtr caps,
6057
virDomainNetDefPtr def = NULL;
6058
char **keywords = NULL;
6059
char **values = NULL;
6067
tmp = strchr(val, ',');
6070
if ((nkeywords = qemuParseKeywords(tmp+1,
6078
if (VIR_ALLOC(def) < 0) {
6079
virReportOOMError();
6083
/* 'tap' could turn into libvirt type=ethernet, type=bridge or
6084
* type=network, but we can't tell, so use the generic config */
6085
if (STRPREFIX(val, "tap,"))
6086
def->type = VIR_DOMAIN_NET_TYPE_ETHERNET;
6087
else if (STRPREFIX(val, "socket"))
6088
def->type = VIR_DOMAIN_NET_TYPE_CLIENT;
6089
else if (STRPREFIX(val, "user"))
6090
def->type = VIR_DOMAIN_NET_TYPE_USER;
6092
def->type = VIR_DOMAIN_NET_TYPE_ETHERNET;
6094
for (i = 0 ; i < nkeywords ; i++) {
6095
if (STREQ(keywords[i], "vlan")) {
6096
if (virStrToLong_i(values[i], NULL, 10, &wantvlan) < 0) {
6097
qemuReportError(VIR_ERR_INTERNAL_ERROR,
6098
_("cannot parse vlan in '%s'"), val);
6099
virDomainNetDefFree(def);
6103
} else if (def->type == VIR_DOMAIN_NET_TYPE_ETHERNET &&
6104
STREQ(keywords[i], "script") && STRNEQ(values[i], "")) {
6105
def->data.ethernet.script = values[i];
6107
} else if (def->type == VIR_DOMAIN_NET_TYPE_ETHERNET &&
6108
STREQ(keywords[i], "ifname")) {
6109
def->ifname = values[i];
6115
/* Done parsing the nic backend. Now to try and find corresponding
6116
* frontend, based off vlan number. NB this assumes a 1-1 mapping
6119
nic = qemuFindNICForVLAN(nnics, nics, wantvlan);
6121
virDomainNetDefFree(def);
6126
if (!STRPREFIX(nic, "nic")) {
6127
qemuReportError(VIR_ERR_INTERNAL_ERROR,
6128
_("cannot parse NIC definition '%s'"), nic);
6129
virDomainNetDefFree(def);
6134
for (i = 0 ; i < nkeywords ; i++) {
6135
VIR_FREE(keywords[i]);
6136
VIR_FREE(values[i]);
6141
if (STRPREFIX(nic, "nic,")) {
6142
if ((nkeywords = qemuParseKeywords(nic + strlen("nic,"),
6145
virDomainNetDefFree(def);
6153
for (i = 0 ; i < nkeywords ; i++) {
6154
if (STREQ(keywords[i], "macaddr")) {
6156
if (virParseMacAddr(values[i], def->mac) < 0) {
6157
qemuReportError(VIR_ERR_INTERNAL_ERROR,
6158
_("unable to parse mac address '%s'"),
6160
virDomainNetDefFree(def);
6164
} else if (STREQ(keywords[i], "model")) {
6165
def->model = values[i];
6167
} else if (STREQ(keywords[i], "vhost")) {
6168
if ((values[i] == NULL) || STREQ(values[i], "on")) {
6169
def->driver.virtio.name = VIR_DOMAIN_NET_BACKEND_TYPE_VHOST;
6170
} else if (STREQ(keywords[i], "off")) {
6171
def->driver.virtio.name = VIR_DOMAIN_NET_BACKEND_TYPE_QEMU;
6173
} else if (STREQ(keywords[i], "sndbuf") && values[i]) {
6174
if (virStrToLong_ul(values[i], NULL, 10, &def->tune.sndbuf) < 0) {
6175
qemuReportError(VIR_ERR_INTERNAL_ERROR,
6176
_("cannot parse sndbuf size in '%s'"), val);
6177
virDomainNetDefFree(def);
6181
def->tune.sndbuf_specified = true;
6186
virCapabilitiesGenerateMac(caps, def->mac);
6189
for (i = 0 ; i < nkeywords ; i++) {
6190
VIR_FREE(keywords[i]);
6191
VIR_FREE(values[i]);
6200
* Tries to parse a QEMU PCI device
6202
static virDomainHostdevDefPtr
6203
qemuParseCommandLinePCI(const char *val)
6205
virDomainHostdevDefPtr def = NULL;
6206
int bus = 0, slot = 0, func = 0;
6210
if (!STRPREFIX(val, "host=")) {
6211
qemuReportError(VIR_ERR_INTERNAL_ERROR,
6212
_("unknown PCI device syntax '%s'"), val);
6217
start = val + strlen("host=");
6218
if (virStrToLong_i(start, &end, 16, &bus) < 0 || *end != ':') {
6219
qemuReportError(VIR_ERR_INTERNAL_ERROR,
6220
_("cannot extract PCI device bus '%s'"), val);
6225
if (virStrToLong_i(start, &end, 16, &slot) < 0 || *end != '.') {
6226
qemuReportError(VIR_ERR_INTERNAL_ERROR,
6227
_("cannot extract PCI device slot '%s'"), val);
6232
if (virStrToLong_i(start, NULL, 16, &func) < 0) {
6233
qemuReportError(VIR_ERR_INTERNAL_ERROR,
6234
_("cannot extract PCI device function '%s'"), val);
6239
if (VIR_ALLOC(def) < 0) {
6240
virReportOOMError();
6244
def->mode = VIR_DOMAIN_HOSTDEV_MODE_SUBSYS;
6246
def->source.subsys.type = VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI;
6247
def->source.subsys.u.pci.bus = bus;
6248
def->source.subsys.u.pci.slot = slot;
6249
def->source.subsys.u.pci.function = func;
6257
* Tries to parse a QEMU USB device
6259
static virDomainHostdevDefPtr
6260
qemuParseCommandLineUSB(const char *val)
6262
virDomainHostdevDefPtr def = NULL;
6263
int first = 0, second = 0;
6267
if (!STRPREFIX(val, "host:")) {
6268
qemuReportError(VIR_ERR_INTERNAL_ERROR,
6269
_("unknown USB device syntax '%s'"), val);
6274
start = val + strlen("host:");
6275
if (strchr(start, ':')) {
6276
if (virStrToLong_i(start, &end, 16, &first) < 0 || *end != ':') {
6277
qemuReportError(VIR_ERR_INTERNAL_ERROR,
6278
_("cannot extract USB device vendor '%s'"), val);
6283
if (virStrToLong_i(start, NULL, 16, &second) < 0) {
6284
qemuReportError(VIR_ERR_INTERNAL_ERROR,
6285
_("cannot extract USB device product '%s'"), val);
6290
if (virStrToLong_i(start, &end, 10, &first) < 0 || *end != '.') {
6291
qemuReportError(VIR_ERR_INTERNAL_ERROR,
6292
_("cannot extract USB device bus '%s'"), val);
6297
if (virStrToLong_i(start, NULL, 10, &second) < 0) {
6298
qemuReportError(VIR_ERR_INTERNAL_ERROR,
6299
_("cannot extract USB device address '%s'"), val);
6305
if (VIR_ALLOC(def) < 0) {
6306
virReportOOMError();
6310
def->mode = VIR_DOMAIN_HOSTDEV_MODE_SUBSYS;
6312
def->source.subsys.type = VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB;
6314
def->source.subsys.u.usb.bus = first;
6315
def->source.subsys.u.usb.device = second;
6317
def->source.subsys.u.usb.vendor = first;
6318
def->source.subsys.u.usb.product = second;
6327
* Tries to parse a QEMU serial/parallel device
6330
qemuParseCommandLineChr(virDomainChrSourceDefPtr source,
6333
if (STREQ(val, "null")) {
6334
source->type = VIR_DOMAIN_CHR_TYPE_NULL;
6335
} else if (STREQ(val, "vc")) {
6336
source->type = VIR_DOMAIN_CHR_TYPE_VC;
6337
} else if (STREQ(val, "pty")) {
6338
source->type = VIR_DOMAIN_CHR_TYPE_PTY;
6339
} else if (STRPREFIX(val, "file:")) {
6340
source->type = VIR_DOMAIN_CHR_TYPE_FILE;
6341
source->data.file.path = strdup(val+strlen("file:"));
6342
if (!source->data.file.path)
6344
} else if (STRPREFIX(val, "pipe:")) {
6345
source->type = VIR_DOMAIN_CHR_TYPE_PIPE;
6346
source->data.file.path = strdup(val+strlen("pipe:"));
6347
if (!source->data.file.path)
6349
} else if (STREQ(val, "stdio")) {
6350
source->type = VIR_DOMAIN_CHR_TYPE_STDIO;
6351
} else if (STRPREFIX(val, "udp:")) {
6352
const char *svc1, *host2, *svc2;
6353
source->type = VIR_DOMAIN_CHR_TYPE_UDP;
6354
val += strlen("udp:");
6355
svc1 = strchr(val, ':');
6356
host2 = svc1 ? strchr(svc1, '@') : NULL;
6357
svc2 = host2 ? strchr(host2, ':') : NULL;
6359
if (svc1 && (svc1 != val)) {
6360
source->data.udp.connectHost = strndup(val, svc1-val);
6362
if (!source->data.udp.connectHost)
6369
source->data.udp.connectService = strndup(svc1, host2-svc1);
6371
source->data.udp.connectService = strdup(svc1);
6373
if (!source->data.udp.connectService)
6379
if (svc2 && (svc2 != host2)) {
6380
source->data.udp.bindHost = strndup(host2, svc2-host2);
6382
if (!source->data.udp.bindHost)
6389
if (STRNEQ(svc2, "0")) {
6390
source->data.udp.bindService = strdup(svc2);
6391
if (!source->data.udp.bindService)
6395
} else if (STRPREFIX(val, "tcp:") ||
6396
STRPREFIX(val, "telnet:")) {
6397
const char *opt, *svc;
6398
source->type = VIR_DOMAIN_CHR_TYPE_TCP;
6399
if (STRPREFIX(val, "tcp:")) {
6400
val += strlen("tcp:");
6402
val += strlen("telnet:");
6403
source->data.tcp.protocol = VIR_DOMAIN_CHR_TCP_PROTOCOL_TELNET;
6405
svc = strchr(val, ':');
6407
qemuReportError(VIR_ERR_INTERNAL_ERROR,
6408
_("cannot find port number in character device %s"), val);
6411
opt = strchr(svc, ',');
6412
if (opt && strstr(opt, "server"))
6413
source->data.tcp.listen = true;
6415
source->data.tcp.host = strndup(val, svc-val);
6416
if (!source->data.tcp.host)
6420
source->data.tcp.service = strndup(svc, opt-svc);
6422
source->data.tcp.service = strdup(svc);
6424
if (!source->data.tcp.service)
6426
} else if (STRPREFIX(val, "unix:")) {
6428
val += strlen("unix:");
6429
opt = strchr(val, ',');
6430
source->type = VIR_DOMAIN_CHR_TYPE_UNIX;
6432
if (strstr(opt, "listen"))
6433
source->data.nix.listen = true;
6434
source->data.nix.path = strndup(val, opt-val);
6436
source->data.nix.path = strdup(val);
6438
if (!source->data.nix.path)
6441
} else if (STRPREFIX(val, "/dev")) {
6442
source->type = VIR_DOMAIN_CHR_TYPE_DEV;
6443
source->data.file.path = strdup(val);
6444
if (!source->data.file.path)
6447
qemuReportError(VIR_ERR_INTERNAL_ERROR,
6448
_("unknown character device syntax %s"), val);
6455
virReportOOMError();
6462
qemuInitGuestCPU(virDomainDefPtr dom)
6467
if (VIR_ALLOC(cpu) < 0) {
6468
virReportOOMError();
6472
cpu->type = VIR_CPU_TYPE_GUEST;
6473
cpu->match = VIR_CPU_MATCH_EXACT;
6482
qemuParseCommandLineCPU(virDomainDefPtr dom,
6486
const char *p = val;
6489
if (!(cpu = qemuInitGuestCPU(dom)))
6493
if (*p == '\0' || *p == ',')
6496
if ((next = strchr(p, ',')))
6501
cpu->model = strndup(p, next - p - 1);
6503
cpu->model = strdup(p);
6508
else if (*p == '+' || *p == '-') {
6514
policy = VIR_CPU_FEATURE_REQUIRE;
6516
policy = VIR_CPU_FEATURE_DISABLE;
6519
if (*p == '\0' || *p == ',')
6523
feature = strndup(p, next - p - 1);
6525
feature = strdup(p);
6530
ret = virCPUDefAddFeature(cpu, feature, policy);
6535
} while ((p = next));
6540
qemuReportError(VIR_ERR_INTERNAL_ERROR,
6541
_("unknown CPU syntax '%s'"), val);
6545
virReportOOMError();
6552
qemuParseCommandLineSmp(virDomainDefPtr dom,
6555
unsigned int sockets = 0;
6556
unsigned int cores = 0;
6557
unsigned int threads = 0;
6558
unsigned int maxcpus = 0;
6567
nkws = qemuParseKeywords(val, &kws, &vals, 1);
6571
for (i = 0; i < nkws; i++) {
6572
if (vals[i] == NULL) {
6574
virStrToLong_i(kws[i], &end, 10, &n) < 0 || *end != '\0')
6578
if (virStrToLong_i(vals[i], &end, 10, &n) < 0 || *end != '\0')
6580
if (STREQ(kws[i], "sockets"))
6582
else if (STREQ(kws[i], "cores"))
6584
else if (STREQ(kws[i], "threads"))
6586
else if (STREQ(kws[i], "maxcpus"))
6593
dom->maxvcpus = maxcpus ? maxcpus : dom->vcpus;
6595
if (sockets && cores && threads) {
6598
if (!(cpu = qemuInitGuestCPU(dom)))
6600
cpu->sockets = sockets;
6602
cpu->threads = threads;
6603
} else if (sockets || cores || threads)
6609
for (i = 0; i < nkws; i++) {
6619
qemuReportError(VIR_ERR_INTERNAL_ERROR,
6620
_("cannot parse CPU topology '%s'"), val);
6628
* Analyse the env and argv settings and reconstruct a
6629
* virDomainDefPtr representing these settings as closely
6630
* as is practical. This is not an exact science....
6632
virDomainDefPtr qemuParseCommandLine(virCapsPtr caps,
6633
const char **progenv,
6634
const char **progargv,
6636
virDomainChrSourceDefPtr *monConfig,
6639
virDomainDefPtr def;
6645
const char **nics = NULL;
6646
int video = VIR_DOMAIN_VIDEO_TYPE_CIRRUS;
6647
int nvirtiodisk = 0;
6648
qemuDomainCmdlineDefPtr cmd = NULL;
6649
virDomainDiskDefPtr disk = NULL;
6650
const char *ceph_args = qemuFindEnv(progenv, "CEPH_ARGS");
6660
qemuReportError(VIR_ERR_INTERNAL_ERROR,
6661
"%s", _("no emulator path found"));
6665
if (VIR_ALLOC(def) < 0)
6668
/* allocate the cmdlinedef up-front; if it's unused, we'll free it later */
6669
if (VIR_ALLOC(cmd) < 0)
6672
if (virUUIDGenerate(def->uuid) < 0) {
6673
qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
6674
_("failed to generate uuid"));
6679
def->mem.cur_balloon = def->mem.max_balloon = 64 * 1024;
6682
def->clock.offset = VIR_DOMAIN_CLOCK_OFFSET_UTC;
6683
def->features = (1 << VIR_DOMAIN_FEATURE_ACPI)
6684
/*| (1 << VIR_DOMAIN_FEATURE_APIC)*/;
6685
def->onReboot = VIR_DOMAIN_LIFECYCLE_RESTART;
6686
def->onCrash = VIR_DOMAIN_LIFECYCLE_DESTROY;
6687
def->onPoweroff = VIR_DOMAIN_LIFECYCLE_DESTROY;
6688
def->virtType = VIR_DOMAIN_VIRT_QEMU;
6689
if (!(def->emulator = strdup(progargv[0])))
6692
if (strstr(def->emulator, "kvm")) {
6693
def->virtType = VIR_DOMAIN_VIRT_KVM;
6694
def->features |= (1 << VIR_DOMAIN_FEATURE_PAE);
6698
if (strstr(def->emulator, "xenner")) {
6699
def->virtType = VIR_DOMAIN_VIRT_KVM;
6700
def->os.type = strdup("xen");
6702
def->os.type = strdup("hvm");
6707
if (STRPREFIX(def->emulator, "qemu"))
6708
path = def->emulator;
6710
path = strstr(def->emulator, "qemu");
6712
STRPREFIX(path, "qemu-system-"))
6713
def->os.arch = strdup(path + strlen("qemu-system-"));
6715
def->os.arch = strdup("i686");
6719
#define WANT_VALUE() \
6720
const char *val = progargv[++i]; \
6722
qemuReportError(VIR_ERR_INTERNAL_ERROR, \
6723
_("missing value for %s argument"), arg); \
6727
/* One initial loop to get list of NICs, so we
6728
* can correlate them later */
6729
for (i = 1 ; progargv[i] ; i++) {
6730
const char *arg = progargv[i];
6731
/* Make sure we have a single - for all options to
6732
simplify next logic */
6733
if (STRPREFIX(arg, "--"))
6736
if (STREQ(arg, "-net")) {
6738
if (STRPREFIX(val, "nic")) {
6739
if (VIR_REALLOC_N(nics, nnics+1) < 0)
6741
nics[nnics++] = val;
6746
/* Now the real processing loop */
6747
for (i = 1 ; progargv[i] ; i++) {
6748
const char *arg = progargv[i];
6749
/* Make sure we have a single - for all options to
6750
simplify next logic */
6751
if (STRPREFIX(arg, "--"))
6754
if (STREQ(arg, "-vnc")) {
6755
virDomainGraphicsDefPtr vnc;
6758
if (VIR_ALLOC(vnc) < 0)
6760
vnc->type = VIR_DOMAIN_GRAPHICS_TYPE_VNC;
6762
if (STRPREFIX(val, "unix:")) {
6763
/* -vnc unix:/some/big/path */
6764
vnc->data.vnc.socket = strdup(val + 5);
6765
if (!vnc->data.vnc.socket) {
6766
virDomainGraphicsDefFree(vnc);
6772
* -vnc [2001:1:2:3:4:5:1234:1234]:4
6773
* -vnc some.host.name:4
6776
const char *sep = ":";
6779
tmp = strstr(val, sep);
6781
virDomainGraphicsDefFree(vnc);
6782
qemuReportError(VIR_ERR_INTERNAL_ERROR,
6783
_("missing VNC port number in '%s'"), val);
6786
if (virStrToLong_i(tmp+strlen(sep), &opts, 10,
6787
&vnc->data.vnc.port) < 0) {
6788
virDomainGraphicsDefFree(vnc);
6789
qemuReportError(VIR_ERR_INTERNAL_ERROR,
6790
_("cannot parse VNC port '%s'"), tmp+1);
6794
virDomainGraphicsListenSetAddress(vnc, 0,
6795
val+1, tmp-(val+1), true);
6797
virDomainGraphicsListenSetAddress(vnc, 0,
6798
val, tmp-val, true);
6799
if (!virDomainGraphicsListenGetAddress(vnc, 0)) {
6800
virDomainGraphicsDefFree(vnc);
6803
vnc->data.vnc.port += 5900;
6804
vnc->data.vnc.autoport = 0;
6807
if (VIR_REALLOC_N(def->graphics, def->ngraphics+1) < 0) {
6808
virDomainGraphicsDefFree(vnc);
6811
def->graphics[def->ngraphics++] = vnc;
6812
} else if (STREQ(arg, "-m")) {
6815
if (virStrToLong_i(val, NULL, 10, &mem) < 0) {
6816
qemuReportError(VIR_ERR_INTERNAL_ERROR, \
6817
_("cannot parse memory level '%s'"), val);
6820
def->mem.cur_balloon = def->mem.max_balloon = mem * 1024;
6821
} else if (STREQ(arg, "-smp")) {
6823
if (qemuParseCommandLineSmp(def, val) < 0)
6825
} else if (STREQ(arg, "-uuid")) {
6827
if (virUUIDParse(val, def->uuid) < 0) {
6828
qemuReportError(VIR_ERR_INTERNAL_ERROR, \
6829
_("cannot parse UUID '%s'"), val);
6832
} else if (STRPREFIX(arg, "-hd") ||
6833
STRPREFIX(arg, "-sd") ||
6834
STRPREFIX(arg, "-fd") ||
6835
STREQ(arg, "-cdrom")) {
6837
if (VIR_ALLOC(disk) < 0)
6840
if (STRPREFIX(val, "/dev/"))
6841
disk->type = VIR_DOMAIN_DISK_TYPE_BLOCK;
6842
else if (STRPREFIX(val, "nbd:")) {
6843
disk->type = VIR_DOMAIN_DISK_TYPE_NETWORK;
6844
disk->protocol = VIR_DOMAIN_DISK_PROTOCOL_NBD;
6845
val += strlen("nbd:");
6846
} else if (STRPREFIX(val, "rbd:")) {
6847
disk->type = VIR_DOMAIN_DISK_TYPE_NETWORK;
6848
disk->protocol = VIR_DOMAIN_DISK_PROTOCOL_RBD;
6849
val += strlen("rbd:");
6850
} else if (STRPREFIX(val, "sheepdog:")) {
6851
disk->type = VIR_DOMAIN_DISK_TYPE_NETWORK;
6852
disk->protocol = VIR_DOMAIN_DISK_PROTOCOL_SHEEPDOG;
6853
val += strlen("sheepdog:");
6855
disk->type = VIR_DOMAIN_DISK_TYPE_FILE;
6856
if (STREQ(arg, "-cdrom")) {
6857
disk->device = VIR_DOMAIN_DISK_DEVICE_CDROM;
6858
disk->dst = strdup("hdc");
6863
if (STRPREFIX(arg, "-fd")) {
6864
disk->device = VIR_DOMAIN_DISK_DEVICE_FLOPPY;
6865
disk->bus = VIR_DOMAIN_DISK_BUS_FDC;
6867
disk->device = VIR_DOMAIN_DISK_DEVICE_DISK;
6868
if (STRPREFIX(arg, "-hd"))
6869
disk->bus = VIR_DOMAIN_DISK_BUS_IDE;
6871
disk->bus = VIR_DOMAIN_DISK_BUS_SCSI;
6873
disk->dst = strdup(arg + 1);
6877
disk->src = strdup(val);
6881
if (disk->type == VIR_DOMAIN_DISK_TYPE_NETWORK) {
6884
switch (disk->protocol) {
6885
case VIR_DOMAIN_DISK_PROTOCOL_NBD:
6887
port = strchr(host, ':');
6889
qemuReportError(VIR_ERR_INTERNAL_ERROR,
6890
_("cannot parse nbd filename '%s'"), disk->src);
6894
if (VIR_ALLOC(disk->hosts) < 0)
6897
disk->hosts->name = host;
6898
disk->hosts->port = strdup(port);
6899
if (!disk->hosts->port)
6901
VIR_FREE(disk->src);
6904
case VIR_DOMAIN_DISK_PROTOCOL_RBD:
6905
/* old-style CEPH_ARGS env variable is parsed later */
6906
if (!ceph_args && qemuParseRBDString(disk) < 0)
6909
case VIR_DOMAIN_DISK_PROTOCOL_SHEEPDOG:
6910
/* disk->src must be [vdiname] or [host]:[port]:[vdiname] */
6911
port = strchr(disk->src, ':');
6916
vdi = strchr(port, ':');
6918
qemuReportError(VIR_ERR_INTERNAL_ERROR,
6919
_("cannot parse sheepdog filename '%s'"), val);
6923
if (VIR_ALLOC(disk->hosts) < 0)
6926
disk->hosts->name = disk->src;
6927
disk->hosts->port = strdup(port);
6928
if (!disk->hosts->port)
6930
disk->src = strdup(vdi);
6938
if (!(disk->src || disk->nhosts > 0) ||
6942
if (virDomainDiskDefAssignAddress(caps, disk) < 0)
6945
if (VIR_REALLOC_N(def->disks, def->ndisks+1) < 0)
6947
def->disks[def->ndisks++] = disk;
6949
} else if (STREQ(arg, "-no-acpi")) {
6950
def->features &= ~(1 << VIR_DOMAIN_FEATURE_ACPI);
6951
} else if (STREQ(arg, "-no-reboot")) {
6952
def->onReboot = VIR_DOMAIN_LIFECYCLE_DESTROY;
6953
} else if (STREQ(arg, "-no-kvm")) {
6954
def->virtType = VIR_DOMAIN_VIRT_QEMU;
6955
} else if (STREQ(arg, "-nographic")) {
6957
} else if (STREQ(arg, "-full-screen")) {
6959
} else if (STREQ(arg, "-localtime")) {
6960
def->clock.offset = VIR_DOMAIN_CLOCK_OFFSET_LOCALTIME;
6961
} else if (STREQ(arg, "-kernel")) {
6963
if (!(def->os.kernel = strdup(val)))
6965
} else if (STREQ(arg, "-initrd")) {
6967
if (!(def->os.initrd = strdup(val)))
6969
} else if (STREQ(arg, "-append")) {
6971
if (!(def->os.cmdline = strdup(val)))
6973
} else if (STREQ(arg, "-boot")) {
6976
for (n = 0 ; val[n] && b < VIR_DOMAIN_BOOT_LAST ; n++) {
6978
def->os.bootDevs[b++] = VIR_DOMAIN_BOOT_FLOPPY;
6979
else if (val[n] == 'c')
6980
def->os.bootDevs[b++] = VIR_DOMAIN_BOOT_DISK;
6981
else if (val[n] == 'd')
6982
def->os.bootDevs[b++] = VIR_DOMAIN_BOOT_CDROM;
6983
else if (val[n] == 'n')
6984
def->os.bootDevs[b++] = VIR_DOMAIN_BOOT_NET;
6985
else if (val[n] == ',')
6988
def->os.nBootDevs = b;
6990
if (strstr(val, "menu=on"))
6991
def->os.bootmenu = 1;
6992
} else if (STREQ(arg, "-name")) {
6995
process = strstr(val, ",process=");
6996
if (process == NULL) {
6997
if (!(def->name = strdup(val)))
7000
if (!(def->name = strndup(val, process - val)))
7003
if (STREQ(def->name, ""))
7004
VIR_FREE(def->name);
7005
} else if (STREQ(arg, "-M")) {
7007
if (!(def->os.machine = strdup(val)))
7009
} else if (STREQ(arg, "-serial")) {
7011
if (STRNEQ(val, "none")) {
7012
virDomainChrDefPtr chr;
7014
if (!(chr = virDomainChrDefNew()))
7017
if (qemuParseCommandLineChr(&chr->source, val) < 0) {
7018
virDomainChrDefFree(chr);
7021
if (VIR_REALLOC_N(def->serials, def->nserials+1) < 0) {
7022
virDomainChrDefFree(chr);
7025
chr->deviceType = VIR_DOMAIN_CHR_DEVICE_TYPE_SERIAL;
7026
chr->target.port = def->nserials;
7027
def->serials[def->nserials++] = chr;
7029
} else if (STREQ(arg, "-parallel")) {
7031
if (STRNEQ(val, "none")) {
7032
virDomainChrDefPtr chr;
7034
if (!(chr = virDomainChrDefNew()))
7037
if (qemuParseCommandLineChr(&chr->source, val) < 0) {
7038
virDomainChrDefFree(chr);
7041
if (VIR_REALLOC_N(def->parallels, def->nparallels+1) < 0) {
7042
virDomainChrDefFree(chr);
7045
chr->deviceType = VIR_DOMAIN_CHR_DEVICE_TYPE_PARALLEL;
7046
chr->target.port = def->nparallels;
7047
def->parallels[def->nparallels++] = chr;
7049
} else if (STREQ(arg, "-usbdevice")) {
7051
if (STREQ(val, "tablet") ||
7052
STREQ(val, "mouse")) {
7053
virDomainInputDefPtr input;
7054
if (VIR_ALLOC(input) < 0)
7056
input->bus = VIR_DOMAIN_INPUT_BUS_USB;
7057
if (STREQ(val, "tablet"))
7058
input->type = VIR_DOMAIN_INPUT_TYPE_TABLET;
7060
input->type = VIR_DOMAIN_INPUT_TYPE_MOUSE;
7061
if (VIR_REALLOC_N(def->inputs, def->ninputs+1) < 0) {
7062
virDomainInputDefFree(input);
7065
def->inputs[def->ninputs++] = input;
7066
} else if (STRPREFIX(val, "disk:")) {
7067
if (VIR_ALLOC(disk) < 0)
7069
disk->src = strdup(val + strlen("disk:"));
7072
if (STRPREFIX(disk->src, "/dev/"))
7073
disk->type = VIR_DOMAIN_DISK_TYPE_BLOCK;
7075
disk->type = VIR_DOMAIN_DISK_TYPE_FILE;
7076
disk->device = VIR_DOMAIN_DISK_DEVICE_DISK;
7077
disk->bus = VIR_DOMAIN_DISK_BUS_USB;
7078
if (!(disk->dst = strdup("sda")) ||
7079
VIR_REALLOC_N(def->disks, def->ndisks+1) < 0)
7081
def->disks[def->ndisks++] = disk;
7084
virDomainHostdevDefPtr hostdev;
7085
if (!(hostdev = qemuParseCommandLineUSB(val)))
7087
if (VIR_REALLOC_N(def->hostdevs, def->nhostdevs+1) < 0) {
7088
virDomainHostdevDefFree(hostdev);
7091
def->hostdevs[def->nhostdevs++] = hostdev;
7093
} else if (STREQ(arg, "-net")) {
7095
if (!STRPREFIX(val, "nic") && STRNEQ(val, "none")) {
7096
virDomainNetDefPtr net;
7097
if (!(net = qemuParseCommandLineNet(caps, val, nnics, nics)))
7099
if (VIR_REALLOC_N(def->nets, def->nnets+1) < 0) {
7100
virDomainNetDefFree(net);
7103
def->nets[def->nnets++] = net;
7105
} else if (STREQ(arg, "-drive")) {
7107
if (!(disk = qemuParseCommandLineDisk(caps, val, nvirtiodisk,
7108
ceph_args != NULL)))
7110
if (VIR_REALLOC_N(def->disks, def->ndisks+1) < 0)
7112
if (disk->bus == VIR_DOMAIN_DISK_BUS_VIRTIO)
7115
def->disks[def->ndisks++] = disk;
7117
} else if (STREQ(arg, "-pcidevice")) {
7118
virDomainHostdevDefPtr hostdev;
7120
if (!(hostdev = qemuParseCommandLinePCI(val)))
7122
if (VIR_REALLOC_N(def->hostdevs, def->nhostdevs+1) < 0) {
7123
virDomainHostdevDefFree(hostdev);
7126
def->hostdevs[def->nhostdevs++] = hostdev;
7127
} else if (STREQ(arg, "-soundhw")) {
7132
const char *tmp = strchr(start, ',');
7134
if (STRPREFIX(start, "pcspk")) {
7135
type = VIR_DOMAIN_SOUND_MODEL_PCSPK;
7136
} else if (STRPREFIX(start, "sb16")) {
7137
type = VIR_DOMAIN_SOUND_MODEL_SB16;
7138
} else if (STRPREFIX(start, "es1370")) {
7139
type = VIR_DOMAIN_SOUND_MODEL_ES1370;
7140
} else if (STRPREFIX(start, "ac97")) {
7141
type = VIR_DOMAIN_SOUND_MODEL_AC97;
7142
} else if (STRPREFIX(start, "hda")) {
7143
type = VIR_DOMAIN_SOUND_MODEL_ICH6;
7147
virDomainSoundDefPtr snd;
7148
if (VIR_ALLOC(snd) < 0)
7151
if (VIR_REALLOC_N(def->sounds, def->nsounds+1) < 0) {
7155
def->sounds[def->nsounds++] = snd;
7158
start = tmp ? tmp + 1 : NULL;
7160
} else if (STREQ(arg, "-watchdog")) {
7162
int model = virDomainWatchdogModelTypeFromString (val);
7165
virDomainWatchdogDefPtr wd;
7166
if (VIR_ALLOC(wd) < 0)
7169
wd->action = VIR_DOMAIN_WATCHDOG_ACTION_RESET;
7172
} else if (STREQ(arg, "-watchdog-action") && def->watchdog) {
7174
int action = virDomainWatchdogActionTypeFromString (val);
7177
def->watchdog->action = action;
7178
} else if (STREQ(arg, "-bootloader")) {
7180
def->os.bootloader = strdup(val);
7181
if (!def->os.bootloader)
7183
} else if (STREQ(arg, "-vmwarevga")) {
7184
video = VIR_DOMAIN_VIDEO_TYPE_VMVGA;
7185
} else if (STREQ(arg, "-std-vga")) {
7186
video = VIR_DOMAIN_VIDEO_TYPE_VGA;
7187
} else if (STREQ(arg, "-vga")) {
7189
if (STRNEQ(val, "none")) {
7190
video = qemuVideoTypeFromString(val);
7192
qemuReportError(VIR_ERR_INTERNAL_ERROR,
7193
_("unknown video adapter type '%s'"), val);
7197
} else if (STREQ(arg, "-cpu")) {
7199
if (qemuParseCommandLineCPU(def, val) < 0)
7201
} else if (STREQ(arg, "-domid")) {
7203
/* ignore, generted on the fly */
7204
} else if (STREQ(arg, "-usb")) {
7205
/* ignore, always added by libvirt */
7206
} else if (STREQ(arg, "-pidfile")) {
7209
if (!(*pidfile = strdup(val)))
7211
} else if (STREQ(arg, "-incoming")) {
7213
/* ignore, used via restore/migrate APIs */
7214
} else if (STREQ(arg, "-monitor")) {
7217
virDomainChrSourceDefPtr chr;
7219
if (VIR_ALLOC(chr) < 0)
7222
if (qemuParseCommandLineChr(chr, val) < 0) {
7223
virDomainChrSourceDefFree(chr);
7229
} else if (STREQ(arg, "-S")) {
7230
/* ignore, always added by libvirt */
7232
/* something we can't yet parse. Add it to the qemu namespace
7233
* cmdline/environment advanced options and hope for the best
7235
VIR_WARN("unknown QEMU argument '%s', adding to the qemu namespace",
7237
if (VIR_REALLOC_N(cmd->args, cmd->num_args+1) < 0)
7239
cmd->args[cmd->num_args] = strdup(arg);
7240
if (cmd->args[cmd->num_args] == NULL)
7247
if (def->ndisks > 0 && ceph_args) {
7248
char *hosts, *port, *saveptr = NULL, *token;
7249
virDomainDiskDefPtr first_rbd_disk = NULL;
7250
for (i = 0 ; i < def->ndisks ; i++) {
7251
if (def->disks[i]->type == VIR_DOMAIN_DISK_TYPE_NETWORK &&
7252
def->disks[i]->protocol == VIR_DOMAIN_DISK_PROTOCOL_RBD) {
7253
first_rbd_disk = def->disks[i];
7258
if (!first_rbd_disk) {
7259
qemuReportError(VIR_ERR_INTERNAL_ERROR,
7260
_("CEPH_ARGS was set without an rbd disk"));
7264
/* CEPH_ARGS should be: -m host1[:port1][,host2[:port2]]... */
7265
if (!STRPREFIX(ceph_args, "-m ")) {
7266
qemuReportError(VIR_ERR_INTERNAL_ERROR,
7267
_("could not parse CEPH_ARGS '%s'"), ceph_args);
7270
hosts = strdup(strchr(ceph_args, ' ') + 1);
7273
first_rbd_disk->nhosts = 0;
7274
token = strtok_r(hosts, ",", &saveptr);
7275
while (token != NULL) {
7276
if (VIR_REALLOC_N(first_rbd_disk->hosts, first_rbd_disk->nhosts + 1) < 0) {
7280
port = strchr(token, ':');
7283
port = strdup(port);
7289
first_rbd_disk->hosts[first_rbd_disk->nhosts].port = port;
7290
first_rbd_disk->hosts[first_rbd_disk->nhosts].name = strdup(token);
7291
if (!first_rbd_disk->hosts[first_rbd_disk->nhosts].name) {
7295
first_rbd_disk->nhosts++;
7296
token = strtok_r(NULL, ",", &saveptr);
7300
if (first_rbd_disk->nhosts == 0) {
7301
qemuReportError(VIR_ERR_INTERNAL_ERROR,
7302
_("found no rbd hosts in CEPH_ARGS '%s'"), ceph_args);
7307
if (!nographics && def->ngraphics == 0) {
7308
virDomainGraphicsDefPtr sdl;
7309
const char *display = qemuFindEnv(progenv, "DISPLAY");
7310
const char *xauth = qemuFindEnv(progenv, "XAUTHORITY");
7311
if (VIR_ALLOC(sdl) < 0)
7313
sdl->type = VIR_DOMAIN_GRAPHICS_TYPE_SDL;
7314
sdl->data.sdl.fullscreen = fullscreen;
7316
!(sdl->data.sdl.display = strdup(display))) {
7321
!(sdl->data.sdl.xauth = strdup(xauth))) {
7326
if (VIR_REALLOC_N(def->graphics, def->ngraphics+1) < 0) {
7327
virDomainGraphicsDefFree(sdl);
7330
def->graphics[def->ngraphics++] = sdl;
7333
if (def->ngraphics) {
7334
virDomainVideoDefPtr vid;
7335
if (VIR_ALLOC(vid) < 0)
7337
if (def->virtType == VIR_DOMAIN_VIRT_XEN)
7338
vid->type = VIR_DOMAIN_VIDEO_TYPE_XEN;
7341
vid->vram = virDomainVideoDefaultRAM(def, vid->type);
7344
if (VIR_REALLOC_N(def->videos, def->nvideos+1) < 0) {
7345
virDomainVideoDefFree(vid);
7348
def->videos[def->nvideos++] = vid;
7352
* having a balloon is the default, define one with type="none" to avoid it
7354
if (!def->memballoon) {
7355
virDomainMemballoonDefPtr memballoon;
7356
if (VIR_ALLOC(memballoon) < 0)
7358
memballoon->model = VIR_DOMAIN_MEMBALLOON_MODEL_VIRTIO;
7360
def->memballoon = memballoon;
7365
if (virDomainDefAddImplicitControllers(def) < 0)
7368
if (cmd->num_args || cmd->num_env) {
7370
def->namespaceData = cmd;
7378
virReportOOMError();
7380
virDomainDiskDefFree(disk);
7382
virDomainDefFree(def);
7385
virDomainChrSourceDefFree(*monConfig);
7394
virDomainDefPtr qemuParseCommandLineString(virCapsPtr caps,
7397
virDomainChrSourceDefPtr *monConfig,
7400
const char **progenv = NULL;
7401
const char **progargv = NULL;
7402
virDomainDefPtr def = NULL;
7405
if (qemuStringToArgvEnv(args, &progenv, &progargv) < 0)
7408
def = qemuParseCommandLine(caps, progenv, progargv,
7409
pidfile, monConfig, monJSON);
7412
for (i = 0 ; progargv && progargv[i] ; i++)
7413
VIR_FREE(progargv[i]);
7416
for (i = 0 ; progenv && progenv[i] ; i++)
7417
VIR_FREE(progenv[i]);
7424
static int qemuParseProcFileStrings(unsigned int pid,
7434
const char **str = NULL;
7437
if (virAsprintf(&path, "/proc/%u/%s", pid, name) < 0) {
7438
virReportOOMError();
7442
if ((len = virFileReadAll(path, 1024*128, &data)) < 0)
7446
while (tmp < (data + len)) {
7447
if (VIR_EXPAND_N(str, nstr, 1) < 0) {
7448
virReportOOMError();
7452
if (!(str[nstr-1] = strdup(tmp))) {
7453
virReportOOMError();
7458
/* Skip \0 separator */
7462
if (VIR_EXPAND_N(str, nstr, 1) < 0) {
7463
virReportOOMError();
7474
for (i = 0 ; str && str[i] ; i++)
7483
virDomainDefPtr qemuParseCommandLinePid(virCapsPtr caps,
7486
virDomainChrSourceDefPtr *monConfig,
7489
virDomainDefPtr def = NULL;
7490
const char **progargv = NULL;
7491
const char **progenv = NULL;
7492
char *exepath = NULL;
7496
if (qemuParseProcFileStrings(pid, "cmdline", &progargv) < 0 ||
7497
qemuParseProcFileStrings(pid, "environ", &progenv) < 0)
7500
if (!(def = qemuParseCommandLine(caps, progenv, progargv,
7501
pidfile, monConfig, monJSON)))
7504
if (virAsprintf(&exepath, "/proc/%u/exe", pid) < 0) {
7505
virReportOOMError();
7509
if (virFileResolveLink(exepath, &emulator) < 0) {
7510
virReportSystemError(errno,
7511
_("Unable to resolve %s for pid %u"),
7515
VIR_FREE(def->emulator);
7516
def->emulator = emulator;
7520
for (i = 0 ; progargv && progargv[i] ; i++)
7521
VIR_FREE(progargv[i]);
7523
for (i = 0 ; progenv && progenv[i] ; i++)
7524
VIR_FREE(progenv[i]);
added
removed
.pc/ubuntu/9023-qemu-change-rbd-auth_supported-separation-character-.patch/src/qemu/qemu_command.c
