"usb-redir.filter",
);
+struct _qemuCaps {
+ virObject object;
+
+ virBitmapPtr flags;
+};
+
+
+static virClassPtr qemuCapsClass;
+static void qemuCapsDispose(void *obj);
+
+static int qemuCapsOnceInit(void)
+{
+ if (!(qemuCapsClass = virClassNew("qemuCaps",
+ sizeof(qemuCaps),
+ qemuCapsDispose)))
+ return -1;
+
+ return 0;
+}
+
+VIR_ONCE_GLOBAL_INIT(qemuCaps)
+
struct qemu_feature_flags {
const char *name;
const int default_on;
int
qemuCapsProbeMachineTypes(const char *binary,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
virCapsGuestMachinePtr **machines,
int *nmachines)
{
return -1;
}
- cmd = qemuCapsProbeCommand(binary, qemuCaps);
+ cmd = qemuCapsProbeCommand(binary, caps);
virCommandAddArgList(cmd, "-M", "?", NULL);
virCommandSetOutputBuffer(cmd, &output);
int
qemuCapsProbeCPUModels(const char *qemu,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
const char *arch,
unsigned int *count,
const char ***cpus)
return 0;
}
- cmd = qemuCapsProbeCommand(qemu, qemuCaps);
+ cmd = qemuCapsProbeCommand(qemu, caps);
virCommandAddArgList(cmd, "-cpu", "?", NULL);
virCommandSetOutputBuffer(cmd, &output);
int nmachines = 0;
struct stat st;
unsigned int ncpus;
- virBitmapPtr qemuCaps = NULL;
- virBitmapPtr kvmCaps = NULL;
+ qemuCapsPtr qemubinCaps = NULL;
+ qemuCapsPtr kvmbinCaps = NULL;
int ret = -1;
/* Check for existance of base emulator, or alternate base
/* Ignore binary if extracting version info fails */
if (binary &&
qemuCapsExtractVersionInfo(binary, info->arch,
- false, NULL, &qemuCaps) < 0)
+ false, NULL, &qemubinCaps) < 0)
VIR_FREE(binary);
/* qemu-kvm/kvm binaries can only be used if
if (qemuCapsExtractVersionInfo(kvmbin, info->arch,
false, NULL,
- &kvmCaps) < 0) {
+ &kvmbinCaps) < 0) {
VIR_FREE(kvmbin);
continue;
}
if (!binary) {
binary = kvmbin;
- qemuCaps = kvmCaps;
+ qemubinCaps = kvmbinCaps;
kvmbin = NULL;
- kvmCaps = NULL;
+ kvmbinCaps = NULL;
}
break;
}
return 0;
if (access("/dev/kvm", F_OK) == 0 &&
- (qemuCapsGet(qemuCaps, QEMU_CAPS_KVM) ||
- qemuCapsGet(qemuCaps, QEMU_CAPS_ENABLE_KVM) ||
+ (qemuCapsGet(qemubinCaps, QEMU_CAPS_KVM) ||
+ qemuCapsGet(qemubinCaps, QEMU_CAPS_ENABLE_KVM) ||
kvmbin))
haskvm = 1;
if (access("/dev/kqemu", F_OK) == 0 &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_KQEMU))
+ qemuCapsGet(qemubinCaps, QEMU_CAPS_KQEMU))
haskqemu = 1;
if (stat(binary, &st) == 0) {
info->wordsize, binary, binary_mtime,
old_caps, &machines, &nmachines);
if (probe &&
- qemuCapsProbeMachineTypes(binary, qemuCaps,
+ qemuCapsProbeMachineTypes(binary, qemubinCaps,
&machines, &nmachines) < 0)
goto error;
}
!virCapabilitiesAddGuestFeature(guest, "cpuselection", 1, 0))
goto error;
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_BOOTINDEX) &&
+ if (qemuCapsGet(qemubinCaps, QEMU_CAPS_BOOTINDEX) &&
!virCapabilitiesAddGuestFeature(guest, "deviceboot", 1, 0))
goto error;
binary_mtime, old_caps,
&machines, &nmachines);
if (probe &&
- qemuCapsProbeMachineTypes(kvmbin, qemuCaps,
+ qemuCapsProbeMachineTypes(kvmbin, kvmbinCaps,
&machines, &nmachines) < 0)
goto error;
}
cleanup:
VIR_FREE(binary);
VIR_FREE(kvmbin);
- qemuCapsFree(qemuCaps);
- qemuCapsFree(kvmCaps);
+ virObjectUnref(qemubinCaps);
+ virObjectUnref(kvmbinCaps);
return ret;
unsigned int version,
unsigned int is_kvm,
unsigned int kvm_version,
- virBitmapPtr flags,
+ qemuCapsPtr caps,
bool check_yajl ATTRIBUTE_UNUSED)
{
const char *p;
const char *fsdev, *netdev;
if (strstr(help, "-no-kqemu"))
- qemuCapsSet(flags, QEMU_CAPS_KQEMU);
+ qemuCapsSet(caps, QEMU_CAPS_KQEMU);
if (strstr(help, "-enable-kqemu"))
- qemuCapsSet(flags, QEMU_CAPS_ENABLE_KQEMU);
+ qemuCapsSet(caps, QEMU_CAPS_ENABLE_KQEMU);
if (strstr(help, "-no-kvm"))
- qemuCapsSet(flags, QEMU_CAPS_KVM);
+ qemuCapsSet(caps, QEMU_CAPS_KVM);
if (strstr(help, "-enable-kvm"))
- qemuCapsSet(flags, QEMU_CAPS_ENABLE_KVM);
+ qemuCapsSet(caps, QEMU_CAPS_ENABLE_KVM);
if (strstr(help, "-no-reboot"))
- qemuCapsSet(flags, QEMU_CAPS_NO_REBOOT);
+ qemuCapsSet(caps, QEMU_CAPS_NO_REBOOT);
if (strstr(help, "-name")) {
- qemuCapsSet(flags, QEMU_CAPS_NAME);
+ qemuCapsSet(caps, QEMU_CAPS_NAME);
if (strstr(help, ",process="))
- qemuCapsSet(flags, QEMU_CAPS_NAME_PROCESS);
+ qemuCapsSet(caps, QEMU_CAPS_NAME_PROCESS);
}
if (strstr(help, "-uuid"))
- qemuCapsSet(flags, QEMU_CAPS_UUID);
+ qemuCapsSet(caps, QEMU_CAPS_UUID);
if (strstr(help, "-xen-domid"))
- qemuCapsSet(flags, QEMU_CAPS_XEN_DOMID);
+ qemuCapsSet(caps, QEMU_CAPS_XEN_DOMID);
else if (strstr(help, "-domid"))
- qemuCapsSet(flags, QEMU_CAPS_DOMID);
+ qemuCapsSet(caps, QEMU_CAPS_DOMID);
if (strstr(help, "-drive")) {
const char *cache = strstr(help, "cache=");
- qemuCapsSet(flags, QEMU_CAPS_DRIVE);
+ qemuCapsSet(caps, QEMU_CAPS_DRIVE);
if (cache && (p = strchr(cache, ']'))) {
if (memmem(cache, p - cache, "on|off", sizeof("on|off") - 1) == NULL)
- qemuCapsSet(flags, QEMU_CAPS_DRIVE_CACHE_V2);
+ qemuCapsSet(caps, QEMU_CAPS_DRIVE_CACHE_V2);
if (memmem(cache, p - cache, "directsync", sizeof("directsync") - 1))
- qemuCapsSet(flags, QEMU_CAPS_DRIVE_CACHE_DIRECTSYNC);
+ qemuCapsSet(caps, QEMU_CAPS_DRIVE_CACHE_DIRECTSYNC);
if (memmem(cache, p - cache, "unsafe", sizeof("unsafe") - 1))
- qemuCapsSet(flags, QEMU_CAPS_DRIVE_CACHE_UNSAFE);
+ qemuCapsSet(caps, QEMU_CAPS_DRIVE_CACHE_UNSAFE);
}
if (strstr(help, "format="))
- qemuCapsSet(flags, QEMU_CAPS_DRIVE_FORMAT);
+ qemuCapsSet(caps, QEMU_CAPS_DRIVE_FORMAT);
if (strstr(help, "readonly="))
- qemuCapsSet(flags, QEMU_CAPS_DRIVE_READONLY);
+ qemuCapsSet(caps, QEMU_CAPS_DRIVE_READONLY);
if (strstr(help, "aio=threads|native"))
- qemuCapsSet(flags, QEMU_CAPS_DRIVE_AIO);
+ qemuCapsSet(caps, QEMU_CAPS_DRIVE_AIO);
if (strstr(help, "copy-on-read=on|off"))
- qemuCapsSet(flags, QEMU_CAPS_DRIVE_COPY_ON_READ);
+ qemuCapsSet(caps, QEMU_CAPS_DRIVE_COPY_ON_READ);
if (strstr(help, "bps="))
- qemuCapsSet(flags, QEMU_CAPS_DRIVE_IOTUNE);
+ qemuCapsSet(caps, QEMU_CAPS_DRIVE_IOTUNE);
}
if ((p = strstr(help, "-vga")) && !strstr(help, "-std-vga")) {
const char *nl = strstr(p, "\n");
- qemuCapsSet(flags, QEMU_CAPS_VGA);
+ qemuCapsSet(caps, QEMU_CAPS_VGA);
if (strstr(p, "|qxl"))
- qemuCapsSet(flags, QEMU_CAPS_VGA_QXL);
+ qemuCapsSet(caps, QEMU_CAPS_VGA_QXL);
if ((p = strstr(p, "|none")) && p < nl)
- qemuCapsSet(flags, QEMU_CAPS_VGA_NONE);
+ qemuCapsSet(caps, QEMU_CAPS_VGA_NONE);
}
if (strstr(help, "-spice"))
- qemuCapsSet(flags, QEMU_CAPS_SPICE);
+ qemuCapsSet(caps, QEMU_CAPS_SPICE);
if (strstr(help, "boot=on"))
- qemuCapsSet(flags, QEMU_CAPS_DRIVE_BOOT);
+ qemuCapsSet(caps, QEMU_CAPS_DRIVE_BOOT);
if (strstr(help, "serial=s"))
- qemuCapsSet(flags, QEMU_CAPS_DRIVE_SERIAL);
+ qemuCapsSet(caps, QEMU_CAPS_DRIVE_SERIAL);
if (strstr(help, "-pcidevice"))
- qemuCapsSet(flags, QEMU_CAPS_PCIDEVICE);
+ qemuCapsSet(caps, QEMU_CAPS_PCIDEVICE);
if (strstr(help, "-mem-path"))
- qemuCapsSet(flags, QEMU_CAPS_MEM_PATH);
+ qemuCapsSet(caps, QEMU_CAPS_MEM_PATH);
if (strstr(help, "-chardev")) {
- qemuCapsSet(flags, QEMU_CAPS_CHARDEV);
+ qemuCapsSet(caps, QEMU_CAPS_CHARDEV);
if (strstr(help, "-chardev spicevmc"))
- qemuCapsSet(flags, QEMU_CAPS_CHARDEV_SPICEVMC);
+ qemuCapsSet(caps, QEMU_CAPS_CHARDEV_SPICEVMC);
}
if (strstr(help, "-balloon"))
- qemuCapsSet(flags, QEMU_CAPS_BALLOON);
+ qemuCapsSet(caps, QEMU_CAPS_BALLOON);
if (strstr(help, "-device")) {
- qemuCapsSet(flags, QEMU_CAPS_DEVICE);
+ qemuCapsSet(caps, QEMU_CAPS_DEVICE);
/*
* When -device was introduced, qemu already supported drive's
* readonly option but didn't advertise that.
*/
- qemuCapsSet(flags, QEMU_CAPS_DRIVE_READONLY);
+ qemuCapsSet(caps, QEMU_CAPS_DRIVE_READONLY);
}
if (strstr(help, "-nodefconfig"))
- qemuCapsSet(flags, QEMU_CAPS_NODEFCONFIG);
+ qemuCapsSet(caps, QEMU_CAPS_NODEFCONFIG);
if (strstr(help, "-no-user-config"))
- qemuCapsSet(flags, QEMU_CAPS_NO_USER_CONFIG);
+ qemuCapsSet(caps, QEMU_CAPS_NO_USER_CONFIG);
/* The trailing ' ' is important to avoid a bogus match */
if (strstr(help, "-rtc "))
- qemuCapsSet(flags, QEMU_CAPS_RTC);
+ qemuCapsSet(caps, QEMU_CAPS_RTC);
/* to wit */
if (strstr(help, "-rtc-td-hack"))
- qemuCapsSet(flags, QEMU_CAPS_RTC_TD_HACK);
+ qemuCapsSet(caps, QEMU_CAPS_RTC_TD_HACK);
if (strstr(help, "-no-hpet"))
- qemuCapsSet(flags, QEMU_CAPS_NO_HPET);
+ qemuCapsSet(caps, QEMU_CAPS_NO_HPET);
if (strstr(help, "-no-acpi"))
- qemuCapsSet(flags, QEMU_CAPS_NO_ACPI);
+ qemuCapsSet(caps, QEMU_CAPS_NO_ACPI);
if (strstr(help, "-no-kvm-pit-reinjection"))
- qemuCapsSet(flags, QEMU_CAPS_NO_KVM_PIT);
+ qemuCapsSet(caps, QEMU_CAPS_NO_KVM_PIT);
if (strstr(help, "-tdf"))
- qemuCapsSet(flags, QEMU_CAPS_TDF);
+ qemuCapsSet(caps, QEMU_CAPS_TDF);
if (strstr(help, "-enable-nesting"))
- qemuCapsSet(flags, QEMU_CAPS_NESTING);
+ qemuCapsSet(caps, QEMU_CAPS_NESTING);
if (strstr(help, ",menu=on"))
- qemuCapsSet(flags, QEMU_CAPS_BOOT_MENU);
+ qemuCapsSet(caps, QEMU_CAPS_BOOT_MENU);
if ((fsdev = strstr(help, "-fsdev"))) {
- qemuCapsSet(flags, QEMU_CAPS_FSDEV);
+ qemuCapsSet(caps, QEMU_CAPS_FSDEV);
if (strstr(fsdev, "readonly"))
- qemuCapsSet(flags, QEMU_CAPS_FSDEV_READONLY);
+ qemuCapsSet(caps, QEMU_CAPS_FSDEV_READONLY);
if (strstr(fsdev, "writeout"))
- qemuCapsSet(flags, QEMU_CAPS_FSDEV_WRITEOUT);
+ qemuCapsSet(caps, QEMU_CAPS_FSDEV_WRITEOUT);
}
if (strstr(help, "-smbios type"))
- qemuCapsSet(flags, QEMU_CAPS_SMBIOS_TYPE);
+ qemuCapsSet(caps, QEMU_CAPS_SMBIOS_TYPE);
if ((netdev = strstr(help, "-netdev"))) {
/* Disable -netdev on 0.12 since although it exists,
* But see below about RHEL build. */
if (version >= 13000) {
if (strstr(netdev, "bridge"))
- qemuCapsSet(flags, QEMU_CAPS_NETDEV_BRIDGE);
- qemuCapsSet(flags, QEMU_CAPS_NETDEV);
+ qemuCapsSet(caps, QEMU_CAPS_NETDEV_BRIDGE);
+ qemuCapsSet(caps, QEMU_CAPS_NETDEV);
}
}
if (strstr(help, "-sdl"))
- qemuCapsSet(flags, QEMU_CAPS_SDL);
+ qemuCapsSet(caps, QEMU_CAPS_SDL);
if (strstr(help, "cores=") &&
strstr(help, "threads=") &&
strstr(help, "sockets="))
- qemuCapsSet(flags, QEMU_CAPS_SMP_TOPOLOGY);
+ qemuCapsSet(caps, QEMU_CAPS_SMP_TOPOLOGY);
if (version >= 9000)
- qemuCapsSet(flags, QEMU_CAPS_VNC_COLON);
+ qemuCapsSet(caps, QEMU_CAPS_VNC_COLON);
if (is_kvm && (version >= 10000 || kvm_version >= 74))
- qemuCapsSet(flags, QEMU_CAPS_VNET_HDR);
+ qemuCapsSet(caps, QEMU_CAPS_VNET_HDR);
if (strstr(help, ",vhost=")) {
- qemuCapsSet(flags, QEMU_CAPS_VHOST_NET);
+ qemuCapsSet(caps, QEMU_CAPS_VHOST_NET);
}
/* Do not use -no-shutdown if qemu doesn't support it or SIGTERM handling
* 0.14.* and 0.15.0)
*/
if (strstr(help, "-no-shutdown") && (version < 14000 || version > 15000))
- qemuCapsSet(flags, QEMU_CAPS_NO_SHUTDOWN);
+ qemuCapsSet(caps, QEMU_CAPS_NO_SHUTDOWN);
/*
* Handling of -incoming arg with varying features
* while waiting for data, so pretend it doesn't exist
*/
if (version >= 10000) {
- qemuCapsSet(flags, QEMU_CAPS_MIGRATE_QEMU_TCP);
- qemuCapsSet(flags, QEMU_CAPS_MIGRATE_QEMU_EXEC);
+ qemuCapsSet(caps, QEMU_CAPS_MIGRATE_QEMU_TCP);
+ qemuCapsSet(caps, QEMU_CAPS_MIGRATE_QEMU_EXEC);
if (version >= 12000) {
- qemuCapsSet(flags, QEMU_CAPS_MIGRATE_QEMU_UNIX);
- qemuCapsSet(flags, QEMU_CAPS_MIGRATE_QEMU_FD);
+ qemuCapsSet(caps, QEMU_CAPS_MIGRATE_QEMU_UNIX);
+ qemuCapsSet(caps, QEMU_CAPS_MIGRATE_QEMU_FD);
}
} else if (kvm_version >= 79) {
- qemuCapsSet(flags, QEMU_CAPS_MIGRATE_QEMU_TCP);
+ qemuCapsSet(caps, QEMU_CAPS_MIGRATE_QEMU_TCP);
if (kvm_version >= 80)
- qemuCapsSet(flags, QEMU_CAPS_MIGRATE_QEMU_EXEC);
+ qemuCapsSet(caps, QEMU_CAPS_MIGRATE_QEMU_EXEC);
} else if (kvm_version > 0) {
- qemuCapsSet(flags, QEMU_CAPS_MIGRATE_KVM_STDIO);
+ qemuCapsSet(caps, QEMU_CAPS_MIGRATE_KVM_STDIO);
}
if (version >= 10000)
- qemuCapsSet(flags, QEMU_CAPS_0_10);
+ qemuCapsSet(caps, QEMU_CAPS_0_10);
if (version >= 11000)
- qemuCapsSet(flags, QEMU_CAPS_VIRTIO_BLK_SG_IO);
+ qemuCapsSet(caps, QEMU_CAPS_VIRTIO_BLK_SG_IO);
/* While JSON mode was available in 0.12.0, it was too
* incomplete to contemplate using. The 0.13.0 release
*/
#if HAVE_YAJL
if (version >= 13000) {
- qemuCapsSet(flags, QEMU_CAPS_MONITOR_JSON);
+ qemuCapsSet(caps, QEMU_CAPS_MONITOR_JSON);
} else if (version >= 12000 &&
strstr(help, "libvirt")) {
- qemuCapsSet(flags, QEMU_CAPS_MONITOR_JSON);
- qemuCapsSet(flags, QEMU_CAPS_NETDEV);
+ qemuCapsSet(caps, QEMU_CAPS_MONITOR_JSON);
+ qemuCapsSet(caps, QEMU_CAPS_NETDEV);
}
#else
/* Starting with qemu 0.15 and newer, upstream qemu no longer
"compiled with yajl"));
return -1;
}
- qemuCapsSet(flags, QEMU_CAPS_NETDEV);
+ qemuCapsSet(caps, QEMU_CAPS_NETDEV);
}
#endif
if (version >= 13000)
- qemuCapsSet(flags, QEMU_CAPS_PCI_MULTIFUNCTION);
+ qemuCapsSet(caps, QEMU_CAPS_PCI_MULTIFUNCTION);
/* Although very new versions of qemu advertise the presence of
* the rombar option in the output of "qemu -device pci-assign,?",
* log and refuse to start, so it would be immediately obvious).
*/
if (version >= 12000)
- qemuCapsSet(flags, QEMU_CAPS_PCI_ROMBAR);
+ qemuCapsSet(caps, QEMU_CAPS_PCI_ROMBAR);
if (version >= 11000)
- qemuCapsSet(flags, QEMU_CAPS_CPU_HOST);
+ qemuCapsSet(caps, QEMU_CAPS_CPU_HOST);
return 0;
}
int qemuCapsParseHelpStr(const char *qemu,
const char *help,
- virBitmapPtr flags,
+ qemuCapsPtr caps,
unsigned int *version,
unsigned int *is_kvm,
unsigned int *kvm_version,
*version = (major * 1000 * 1000) + (minor * 1000) + micro;
if (qemuCapsComputeCmdFlags(help, *version, *is_kvm, *kvm_version,
- flags, check_yajl) < 0)
+ caps, check_yajl) < 0)
goto cleanup;
- strflags = virBitmapString(flags);
+ strflags = virBitmapString(caps->flags);
VIR_DEBUG("Version %u.%u.%u, cooked version %u, flags %s",
major, minor, micro, *version, NULLSTR(strflags));
VIR_FREE(strflags);
static int
qemuCapsExtractDeviceStr(const char *qemu,
- virBitmapPtr flags)
+ qemuCapsPtr caps)
{
char *output = NULL;
virCommandPtr cmd;
* understand '-device name,?', and always exits with status 1 for
* the simpler '-device ?', so this function is really only useful
* if -help includes "device driver,?". */
- cmd = qemuCapsProbeCommand(qemu, flags);
+ cmd = qemuCapsProbeCommand(qemu, caps);
virCommandAddArgList(cmd,
"-device", "?",
"-device", "pci-assign,?",
if (virCommandRun(cmd, NULL) < 0)
goto cleanup;
- ret = qemuCapsParseDeviceStr(output, flags);
+ ret = qemuCapsParseDeviceStr(output, caps);
cleanup:
VIR_FREE(output);
int
-qemuCapsParseDeviceStr(const char *str, virBitmapPtr flags)
+qemuCapsParseDeviceStr(const char *str, qemuCapsPtr caps)
{
/* Which devices exist. */
if (strstr(str, "name \"hda-duplex\""))
- qemuCapsSet(flags, QEMU_CAPS_HDA_DUPLEX);
+ qemuCapsSet(caps, QEMU_CAPS_HDA_DUPLEX);
if (strstr(str, "name \"hda-micro\""))
- qemuCapsSet(flags, QEMU_CAPS_HDA_MICRO);
+ qemuCapsSet(caps, QEMU_CAPS_HDA_MICRO);
if (strstr(str, "name \"ccid-card-emulated\""))
- qemuCapsSet(flags, QEMU_CAPS_CCID_EMULATED);
+ qemuCapsSet(caps, QEMU_CAPS_CCID_EMULATED);
if (strstr(str, "name \"ccid-card-passthru\""))
- qemuCapsSet(flags, QEMU_CAPS_CCID_PASSTHRU);
+ qemuCapsSet(caps, QEMU_CAPS_CCID_PASSTHRU);
if (strstr(str, "name \"piix3-usb-uhci\""))
- qemuCapsSet(flags, QEMU_CAPS_PIIX3_USB_UHCI);
+ qemuCapsSet(caps, QEMU_CAPS_PIIX3_USB_UHCI);
if (strstr(str, "name \"piix4-usb-uhci\""))
- qemuCapsSet(flags, QEMU_CAPS_PIIX4_USB_UHCI);
+ qemuCapsSet(caps, QEMU_CAPS_PIIX4_USB_UHCI);
if (strstr(str, "name \"usb-ehci\""))
- qemuCapsSet(flags, QEMU_CAPS_USB_EHCI);
+ qemuCapsSet(caps, QEMU_CAPS_USB_EHCI);
if (strstr(str, "name \"ich9-usb-ehci1\""))
- qemuCapsSet(flags, QEMU_CAPS_ICH9_USB_EHCI1);
+ qemuCapsSet(caps, QEMU_CAPS_ICH9_USB_EHCI1);
if (strstr(str, "name \"vt82c686b-usb-uhci\""))
- qemuCapsSet(flags, QEMU_CAPS_VT82C686B_USB_UHCI);
+ qemuCapsSet(caps, QEMU_CAPS_VT82C686B_USB_UHCI);
if (strstr(str, "name \"pci-ohci\""))
- qemuCapsSet(flags, QEMU_CAPS_PCI_OHCI);
+ qemuCapsSet(caps, QEMU_CAPS_PCI_OHCI);
if (strstr(str, "name \"nec-usb-xhci\""))
- qemuCapsSet(flags, QEMU_CAPS_NEC_USB_XHCI);
+ qemuCapsSet(caps, QEMU_CAPS_NEC_USB_XHCI);
if (strstr(str, "name \"usb-redir\""))
- qemuCapsSet(flags, QEMU_CAPS_USB_REDIR);
+ qemuCapsSet(caps, QEMU_CAPS_USB_REDIR);
if (strstr(str, "usb-redir.filter"))
- qemuCapsSet(flags, QEMU_CAPS_USB_REDIR_FILTER);
+ qemuCapsSet(caps, QEMU_CAPS_USB_REDIR_FILTER);
if (strstr(str, "name \"usb-hub\""))
- qemuCapsSet(flags, QEMU_CAPS_USB_HUB);
+ qemuCapsSet(caps, QEMU_CAPS_USB_HUB);
if (strstr(str, "name \"ich9-ahci\""))
- qemuCapsSet(flags, QEMU_CAPS_ICH9_AHCI);
+ qemuCapsSet(caps, QEMU_CAPS_ICH9_AHCI);
if (strstr(str, "name \"virtio-blk-s390\"") ||
strstr(str, "name \"virtio-net-s390\"") ||
strstr(str, "name \"virtio-serial-s390\""))
- qemuCapsSet(flags, QEMU_CAPS_VIRTIO_S390);
+ qemuCapsSet(caps, QEMU_CAPS_VIRTIO_S390);
if (strstr(str, "name \"lsi53c895a\""))
- qemuCapsSet(flags, QEMU_CAPS_SCSI_LSI);
+ qemuCapsSet(caps, QEMU_CAPS_SCSI_LSI);
if (strstr(str, "name \"virtio-scsi-pci\""))
- qemuCapsSet(flags, QEMU_CAPS_VIRTIO_SCSI_PCI);
+ qemuCapsSet(caps, QEMU_CAPS_VIRTIO_SCSI_PCI);
/* Prefer -chardev spicevmc (detected earlier) over -device spicevmc */
- if (!qemuCapsGet(flags, QEMU_CAPS_CHARDEV_SPICEVMC) &&
+ if (!qemuCapsGet(caps, QEMU_CAPS_CHARDEV_SPICEVMC) &&
strstr(str, "name \"spicevmc\""))
- qemuCapsSet(flags, QEMU_CAPS_DEVICE_SPICEVMC);
+ qemuCapsSet(caps, QEMU_CAPS_DEVICE_SPICEVMC);
/* Features of given devices. */
if (strstr(str, "pci-assign.configfd"))
- qemuCapsSet(flags, QEMU_CAPS_PCI_CONFIGFD);
+ qemuCapsSet(caps, QEMU_CAPS_PCI_CONFIGFD);
if (strstr(str, "virtio-blk-pci.multifunction"))
- qemuCapsSet(flags, QEMU_CAPS_PCI_MULTIFUNCTION);
+ qemuCapsSet(caps, QEMU_CAPS_PCI_MULTIFUNCTION);
if (strstr(str, "virtio-blk-pci.bootindex")) {
- qemuCapsSet(flags, QEMU_CAPS_BOOTINDEX);
+ qemuCapsSet(caps, QEMU_CAPS_BOOTINDEX);
if (strstr(str, "pci-assign.bootindex"))
- qemuCapsSet(flags, QEMU_CAPS_PCI_BOOTINDEX);
+ qemuCapsSet(caps, QEMU_CAPS_PCI_BOOTINDEX);
}
if (strstr(str, "virtio-net-pci.tx="))
- qemuCapsSet(flags, QEMU_CAPS_VIRTIO_TX_ALG);
+ qemuCapsSet(caps, QEMU_CAPS_VIRTIO_TX_ALG);
if (strstr(str, "name \"qxl-vga\""))
- qemuCapsSet(flags, QEMU_CAPS_DEVICE_QXL_VGA);
+ qemuCapsSet(caps, QEMU_CAPS_DEVICE_QXL_VGA);
if (strstr(str, "virtio-blk-pci.ioeventfd"))
- qemuCapsSet(flags, QEMU_CAPS_VIRTIO_IOEVENTFD);
+ qemuCapsSet(caps, QEMU_CAPS_VIRTIO_IOEVENTFD);
if (strstr(str, "name \"sga\""))
- qemuCapsSet(flags, QEMU_CAPS_SGA);
+ qemuCapsSet(caps, QEMU_CAPS_SGA);
if (strstr(str, "virtio-blk-pci.event_idx"))
- qemuCapsSet(flags, QEMU_CAPS_VIRTIO_BLK_EVENT_IDX);
+ qemuCapsSet(caps, QEMU_CAPS_VIRTIO_BLK_EVENT_IDX);
if (strstr(str, "virtio-net-pci.event_idx"))
- qemuCapsSet(flags, QEMU_CAPS_VIRTIO_NET_EVENT_IDX);
+ qemuCapsSet(caps, QEMU_CAPS_VIRTIO_NET_EVENT_IDX);
if (strstr(str, "virtio-blk-pci.scsi"))
- qemuCapsSet(flags, QEMU_CAPS_VIRTIO_BLK_SCSI);
+ qemuCapsSet(caps, QEMU_CAPS_VIRTIO_BLK_SCSI);
if (strstr(str, "scsi-disk.channel"))
- qemuCapsSet(flags, QEMU_CAPS_SCSI_DISK_CHANNEL);
+ qemuCapsSet(caps, QEMU_CAPS_SCSI_DISK_CHANNEL);
if (strstr(str, "scsi-block"))
- qemuCapsSet(flags, QEMU_CAPS_SCSI_BLOCK);
+ qemuCapsSet(caps, QEMU_CAPS_SCSI_BLOCK);
if (strstr(str, "scsi-cd"))
- qemuCapsSet(flags, QEMU_CAPS_SCSI_CD);
+ qemuCapsSet(caps, QEMU_CAPS_SCSI_CD);
if (strstr(str, "ide-cd"))
- qemuCapsSet(flags, QEMU_CAPS_IDE_CD);
+ qemuCapsSet(caps, QEMU_CAPS_IDE_CD);
/*
* the iolimit detection is not really straight forward:
* in qemu this is a capability of the block layer, if
*/
if (strstr(str, ".logical_block_size") &&
strstr(str, ".physical_block_size"))
- qemuCapsSet(flags, QEMU_CAPS_BLOCKIO);
+ qemuCapsSet(caps, QEMU_CAPS_BLOCKIO);
if (strstr(str, "PIIX4_PM.disable_s3="))
- qemuCapsSet(flags, QEMU_CAPS_DISABLE_S3);
+ qemuCapsSet(caps, QEMU_CAPS_DISABLE_S3);
if (strstr(str, "PIIX4_PM.disable_s4="))
- qemuCapsSet(flags, QEMU_CAPS_DISABLE_S4);
+ qemuCapsSet(caps, QEMU_CAPS_DISABLE_S4);
return 0;
}
const char *arch,
bool check_yajl,
unsigned int *retversion,
- virBitmapPtr *retflags)
+ qemuCapsPtr *retcaps)
{
int ret = -1;
unsigned int version, is_kvm, kvm_version;
- virBitmapPtr flags = NULL;
+ qemuCapsPtr caps = NULL;
char *help = NULL;
virCommandPtr cmd;
- if (retflags)
- *retflags = NULL;
+ if (retcaps)
+ *retcaps = NULL;
if (retversion)
*retversion = 0;
if (virCommandRun(cmd, NULL) < 0)
goto cleanup;
- if (!(flags = qemuCapsNew()) ||
- qemuCapsParseHelpStr(qemu, help, flags,
+ if (!(caps = qemuCapsNew()) ||
+ qemuCapsParseHelpStr(qemu, help, caps,
&version, &is_kvm, &kvm_version,
check_yajl) == -1)
goto cleanup;
/* Currently only x86_64 and i686 support PCI-multibus. */
if (STREQLEN(arch, "x86_64", 6) ||
STREQLEN(arch, "i686", 4)) {
- qemuCapsSet(flags, QEMU_CAPS_PCI_MULTIBUS);
+ qemuCapsSet(caps, QEMU_CAPS_PCI_MULTIBUS);
}
/* S390 and probably other archs do not support no-acpi -
maybe the qemu option parsing should be re-thought. */
if (STRPREFIX(arch, "s390"))
- qemuCapsClear(flags, QEMU_CAPS_NO_ACPI);
+ qemuCapsClear(caps, QEMU_CAPS_NO_ACPI);
- /* qemuCapsExtractDeviceStr will only set additional flags if qemu
+ /* qemuCapsExtractDeviceStr will only set additional caps if qemu
* understands the 0.13.0+ notion of "-device driver,". */
- if (qemuCapsGet(flags, QEMU_CAPS_DEVICE) &&
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE) &&
strstr(help, "-device driver,?") &&
- qemuCapsExtractDeviceStr(qemu, flags) < 0)
+ qemuCapsExtractDeviceStr(qemu, caps) < 0)
goto cleanup;
if (retversion)
*retversion = version;
- if (retflags) {
- *retflags = flags;
- flags = NULL;
+ if (retcaps) {
+ *retcaps = caps;
+ caps = NULL;
}
ret = 0;
cleanup:
VIR_FREE(help);
virCommandFree(cmd);
- qemuCapsFree(flags);
+ virObjectUnref(caps);
return ret;
}
}
-virBitmapPtr
+
+
+qemuCapsPtr
qemuCapsNew(void)
{
- virBitmapPtr caps;
+ qemuCapsPtr caps;
- if (!(caps = virBitmapAlloc(QEMU_CAPS_LAST)))
- virReportOOMError();
+ if (qemuCapsInitialize() < 0)
+ return NULL;
+
+ if (!(caps = virObjectNew(qemuCapsClass)))
+ return NULL;
+
+ if (!(caps->flags = virBitmapAlloc(QEMU_CAPS_LAST)))
+ goto no_memory;
return caps;
+
+no_memory:
+ virReportOOMError();
+ virObjectUnref(caps);
+ return NULL;
}
+void qemuCapsDispose(void *obj)
+{
+ qemuCapsPtr caps = obj;
+
+ virBitmapFree(caps->flags);
+}
+
void
-qemuCapsSet(virBitmapPtr caps,
+qemuCapsSet(qemuCapsPtr caps,
enum qemuCapsFlags flag)
{
- ignore_value(virBitmapSetBit(caps, flag));
+ ignore_value(virBitmapSetBit(caps->flags, flag));
}
void
-qemuCapsSetList(virBitmapPtr caps, ...)
+qemuCapsSetList(qemuCapsPtr caps, ...)
{
va_list list;
int flag;
va_start(list, caps);
while ((flag = va_arg(list, int)) < QEMU_CAPS_LAST)
- ignore_value(virBitmapSetBit(caps, flag));
+ ignore_value(virBitmapSetBit(caps->flags, flag));
va_end(list);
}
void
-qemuCapsClear(virBitmapPtr caps,
+qemuCapsClear(qemuCapsPtr caps,
enum qemuCapsFlags flag)
{
- ignore_value(virBitmapClearBit(caps, flag));
+ ignore_value(virBitmapClearBit(caps->flags, flag));
+}
+
+
+char *qemuCapsFlagsString(qemuCapsPtr caps)
+{
+ return virBitmapString(caps->flags);
}
bool
-qemuCapsGet(virBitmapPtr caps,
+qemuCapsGet(qemuCapsPtr caps,
enum qemuCapsFlags flag)
{
bool b;
- if (!caps || virBitmapGetBit(caps, flag, &b) < 0)
+ if (!caps || virBitmapGetBit(caps->flags, flag, &b) < 0)
return false;
else
return b;
virCommandPtr
qemuCapsProbeCommand(const char *qemu,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
virCommandPtr cmd = virCommandNew(qemu);
- if (qemuCaps) {
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_NO_USER_CONFIG))
+ if (caps) {
+ if (qemuCapsGet(caps, QEMU_CAPS_NO_USER_CONFIG))
virCommandAddArg(cmd, "-no-user-config");
- else if (qemuCapsGet(qemuCaps, QEMU_CAPS_NODEFCONFIG))
+ else if (qemuCapsGet(caps, QEMU_CAPS_NODEFCONFIG))
virCommandAddArg(cmd, "-nodefconfig");
}
#ifndef __QEMU_CAPABILITIES_H__
# define __QEMU_CAPABILITIES_H__
-# include "bitmap.h"
+# include "virobject.h"
# include "capabilities.h"
# include "command.h"
QEMU_CAPS_LAST, /* this must always be the last item */
};
-virBitmapPtr qemuCapsNew(void);
+typedef struct _qemuCaps qemuCaps;
+typedef qemuCaps *qemuCapsPtr;
-# define qemuCapsFree(caps) virBitmapFree(caps)
+qemuCapsPtr qemuCapsNew(void);
-void qemuCapsSet(virBitmapPtr caps,
+void qemuCapsSet(qemuCapsPtr caps,
enum qemuCapsFlags flag) ATTRIBUTE_NONNULL(1);
-void qemuCapsSetList(virBitmapPtr caps, ...) ATTRIBUTE_NONNULL(1);
+void qemuCapsSetList(qemuCapsPtr caps, ...) ATTRIBUTE_NONNULL(1);
-void qemuCapsClear(virBitmapPtr caps,
+void qemuCapsClear(qemuCapsPtr caps,
enum qemuCapsFlags flag) ATTRIBUTE_NONNULL(1);
-bool qemuCapsGet(virBitmapPtr caps,
+bool qemuCapsGet(qemuCapsPtr caps,
enum qemuCapsFlags flag);
+char *qemuCapsFlagsString(qemuCapsPtr caps);
+
virCapsPtr qemuCapsInit(virCapsPtr old_caps);
int qemuCapsProbeMachineTypes(const char *binary,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
virCapsGuestMachinePtr **machines,
int *nmachines);
int qemuCapsProbeCPUModels(const char *qemu,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
const char *arch,
unsigned int *count,
const char ***cpus);
const char *arch,
bool check_yajl,
unsigned int *version,
- virBitmapPtr *qemuCaps);
+ qemuCapsPtr *retcaps);
int qemuCapsParseHelpStr(const char *qemu,
const char *str,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
unsigned int *version,
unsigned int *is_kvm,
unsigned int *kvm_version,
bool check_yajl);
int qemuCapsParseDeviceStr(const char *str,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
virCommandPtr qemuCapsProbeCommand(const char *qemu,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
VIR_ENUM_DECL(qemuCaps);
qemuPhysIfaceConnect(virDomainDefPtr def,
struct qemud_driver *driver,
virDomainNetDefPtr net,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
enum virNetDevVPortProfileOp vmop)
{
int rc;
char *res_ifname = NULL;
int vnet_hdr = 0;
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_VNET_HDR) &&
+ if (qemuCapsGet(caps, QEMU_CAPS_VNET_HDR) &&
net->model && STREQ(net->model, "virtio"))
vnet_hdr = 1;
virConnectPtr conn,
struct qemud_driver *driver,
virDomainNetDefPtr net,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
char *brname = NULL;
int err;
template_ifname = true;
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_VNET_HDR) &&
+ if (qemuCapsGet(caps, QEMU_CAPS_VNET_HDR) &&
net->model && STREQ(net->model, "virtio")) {
tap_create_flags |= VIR_NETDEV_TAP_CREATE_VNET_HDR;
}
int
qemuOpenVhostNet(virDomainDefPtr def,
virDomainNetDefPtr net,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
int *vhostfd)
{
*vhostfd = -1; /* assume we won't use vhost */
/* If qemu doesn't support vhost-net mode (including the -netdev command
* option), don't try to open the device.
*/
- if (!(qemuCapsGet(qemuCaps, QEMU_CAPS_VHOST_NET) &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_NETDEV) &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE))) {
+ if (!(qemuCapsGet(caps, QEMU_CAPS_VHOST_NET) &&
+ qemuCapsGet(caps, QEMU_CAPS_NETDEV) &&
+ qemuCapsGet(caps, QEMU_CAPS_DEVICE))) {
if (net->driver.virtio.name == VIR_DOMAIN_NET_BACKEND_TYPE_VHOST) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("vhost-net is not supported with "
char *qemuDeviceDriveHostAlias(virDomainDiskDefPtr disk,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
char *ret;
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
if (virAsprintf(&ret, "%s%s", QEMU_DRIVE_HOST_PREFIX, disk->info.alias) < 0) {
virReportOOMError();
return NULL;
static int
qemuSetScsiControllerModel(virDomainDefPtr def,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
int *model)
{
if (*model > 0) {
switch (*model) {
case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_LSILOGIC:
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_SCSI_LSI)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_SCSI_LSI)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("This QEMU doesn't support "
"lsi scsi controller"));
}
break;
case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_VIRTIO_SCSI:
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_SCSI_PCI)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_VIRTIO_SCSI_PCI)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("This QEMU doesn't support "
"virtio scsi controller"));
if (STREQ(def->os.arch, "ppc64") &&
STREQ(def->os.machine, "pseries")) {
*model = VIR_DOMAIN_CONTROLLER_MODEL_SCSI_IBMVSCSI;
- } else if (qemuCapsGet(qemuCaps, QEMU_CAPS_SCSI_LSI)) {
+ } else if (qemuCapsGet(caps, QEMU_CAPS_SCSI_LSI)) {
*model = VIR_DOMAIN_CONTROLLER_MODEL_SCSI_LSILOGIC;
} else {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
static int
qemuAssignDeviceDiskAliasCustom(virDomainDefPtr def,
virDomainDiskDefPtr disk,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
const char *prefix = virDomainDiskBusTypeToString(disk->bus);
int controllerModel = -1;
virDomainDiskFindControllerModel(def, disk,
VIR_DOMAIN_CONTROLLER_TYPE_SCSI);
- if ((qemuSetScsiControllerModel(def, qemuCaps, &controllerModel)) < 0)
+ if ((qemuSetScsiControllerModel(def, caps, &controllerModel)) < 0)
return -1;
}
int
qemuAssignDeviceDiskAlias(virDomainDefPtr vmdef,
virDomainDiskDefPtr def,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE)) {
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
- return qemuAssignDeviceDiskAliasCustom(vmdef, def, qemuCaps);
+ if (qemuCapsGet(caps, QEMU_CAPS_DRIVE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE))
+ return qemuAssignDeviceDiskAliasCustom(vmdef, def, caps);
else
return qemuAssignDeviceDiskAliasFixed(def);
} else {
int
-qemuAssignDeviceAliases(virDomainDefPtr def, virBitmapPtr qemuCaps)
+qemuAssignDeviceAliases(virDomainDefPtr def, qemuCapsPtr caps)
{
int i;
for (i = 0; i < def->ndisks ; i++) {
- if (qemuAssignDeviceDiskAlias(def, def->disks[i], qemuCaps) < 0)
+ if (qemuAssignDeviceDiskAlias(def, def->disks[i], caps) < 0)
return -1;
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_NET_NAME) ||
- qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_NET_NAME) ||
+ qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
for (i = 0; i < def->nnets ; i++) {
/* type='hostdev' interfaces are also on the hostdevs list,
* and will have their alias assigned with other hostdevs.
}
}
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
+ if (!qemuCapsGet(caps, QEMU_CAPS_DEVICE))
return 0;
for (i = 0; i < def->nfss ; i++) {
}
static int
-qemuDomainAssignS390Addresses(virDomainDefPtr def, virBitmapPtr qemuCaps)
+qemuDomainAssignS390Addresses(virDomainDefPtr def, qemuCapsPtr caps)
{
int ret = -1;
- virBitmapPtr localCaps = NULL;
+ qemuCapsPtr localCaps = NULL;
- if (!qemuCaps) {
+ if (!caps) {
/* need to get information from real environment */
if (qemuCapsExtractVersionInfo(def->emulator, def->os.arch,
false, NULL,
&localCaps) < 0)
goto cleanup;
- qemuCaps = localCaps;
+ caps = localCaps;
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_S390)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_VIRTIO_S390)) {
/* deal with legacy virtio-s390 */
qemuDomainPrimeS390VirtioDevices(
def, VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_S390);
ret = 0;
cleanup:
- qemuCapsFree(localCaps);
+ virObjectUnref(localCaps);
return ret;
}
}
int qemuDomainAssignSpaprVIOAddresses(virDomainDefPtr def,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
int i, rc = -1;
int model;
- virBitmapPtr localCaps = NULL;
+ qemuCapsPtr localCaps = NULL;
/* Default values match QEMU. See spapr_(llan|vscsi|vty).c */
- if (!qemuCaps) {
+ if (!caps) {
/* need to get information from real environment */
if (qemuCapsExtractVersionInfo(def->emulator, def->os.arch,
false, NULL,
&localCaps) < 0)
goto cleanup;
- qemuCaps = localCaps;
+ caps = localCaps;
}
for (i = 0 ; i < def->nnets; i++) {
for (i = 0 ; i < def->ncontrollers; i++) {
model = def->controllers[i]->model;
if (def->controllers[i]->type == VIR_DOMAIN_CONTROLLER_TYPE_SCSI) {
- rc = qemuSetScsiControllerModel(def, qemuCaps, &model);
+ rc = qemuSetScsiControllerModel(def, caps, &model);
if (rc)
goto cleanup;
}
rc = 0;
cleanup:
- qemuCapsFree(localCaps);
+ virObjectUnref(localCaps);
return rc;
}
int
qemuDomainAssignPCIAddresses(virDomainDefPtr def,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
virDomainObjPtr obj)
{
int ret = -1;
- virBitmapPtr localCaps = NULL;
+ qemuCapsPtr localCaps = NULL;
qemuDomainPCIAddressSetPtr addrs = NULL;
qemuDomainObjPrivatePtr priv = NULL;
- if (!qemuCaps) {
+ if (!caps) {
/* need to get information from real environment */
if (qemuCapsExtractVersionInfo(def->emulator, def->os.arch,
false,
NULL,
&localCaps) < 0)
goto cleanup;
- qemuCaps = localCaps;
+ caps = localCaps;
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
if (!(addrs = qemuDomainPCIAddressSetCreate(def)))
goto cleanup;
ret = 0;
cleanup:
- qemuCapsFree(localCaps);
+ virObjectUnref(localCaps);
qemuDomainPCIAddressSetFree(addrs);
return ret;
}
int qemuDomainAssignAddresses(virDomainDefPtr def,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
virDomainObjPtr obj)
{
int rc;
- rc = qemuDomainAssignSpaprVIOAddresses(def, qemuCaps);
+ rc = qemuDomainAssignSpaprVIOAddresses(def, caps);
if (rc)
return rc;
- rc = qemuDomainAssignS390Addresses(def, qemuCaps);
+ rc = qemuDomainAssignS390Addresses(def, caps);
if (rc)
return rc;
- return qemuDomainAssignPCIAddresses(def, qemuCaps, obj);
+ return qemuDomainAssignPCIAddresses(def, caps, obj);
}
static void
static int
qemuBuildDeviceAddressStr(virBufferPtr buf,
virDomainDeviceInfoPtr info,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
if (info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
if (info->addr.pci.domain != 0) {
_("Only PCI device addresses with bus=0 are supported"));
return -1;
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_PCI_MULTIFUNCTION)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_PCI_MULTIFUNCTION)) {
if (info->addr.pci.function > 7) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("The function of PCI device addresses must "
* When QEMU grows support for > 1 PCI domain, then pci.0 change
* to pciNN.0 where NN is the domain number
*/
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_PCI_MULTIBUS))
+ if (qemuCapsGet(caps, QEMU_CAPS_PCI_MULTIBUS))
virBufferAsprintf(buf, ",bus=pci.0");
else
virBufferAsprintf(buf, ",bus=pci");
static int
qemuBuildRomStr(virBufferPtr buf,
virDomainDeviceInfoPtr info,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
if (info->rombar || info->romfile) {
if (info->type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
"%s", _("rombar and romfile are supported only for PCI devices"));
return -1;
}
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_PCI_ROMBAR)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_PCI_ROMBAR)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("rombar and romfile not supported in this QEMU binary"));
return -1;
static int
qemuBuildIoEventFdStr(virBufferPtr buf,
enum virDomainIoEventFd use,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
- if (use && qemuCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_IOEVENTFD))
+ if (use && qemuCapsGet(caps, QEMU_CAPS_VIRTIO_IOEVENTFD))
virBufferAsprintf(buf, ",ioeventfd=%s",
virDomainIoEventFdTypeToString(use));
return 0;
qemuBuildDriveStr(virConnectPtr conn ATTRIBUTE_UNUSED,
virDomainDiskDefPtr disk,
bool bootable,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
virBuffer opt = VIR_BUFFER_INITIALIZER;
const char *bus = virDomainDiskQEMUBusTypeToString(disk->bus);
break;
case VIR_DOMAIN_DISK_BUS_VIRTIO:
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_S390) &&
+ if (qemuCapsGet(caps, QEMU_CAPS_VIRTIO_S390) &&
(disk->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_S390)) {
/* Paranoia - leave in here for now */
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
virBufferEscape(&opt, ',', ",", "file=%s,", disk->src);
}
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE))
virBufferAddLit(&opt, "if=none");
else
virBufferAsprintf(&opt, "if=%s", bus);
if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM) {
if ((disk->bus == VIR_DOMAIN_DISK_BUS_SCSI)) {
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_SCSI_CD))
+ if (!qemuCapsGet(caps, QEMU_CAPS_SCSI_CD))
virBufferAddLit(&opt, ",media=cdrom");
} else if (disk->bus == VIR_DOMAIN_DISK_BUS_IDE) {
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_IDE_CD))
+ if (!qemuCapsGet(caps, QEMU_CAPS_IDE_CD))
virBufferAddLit(&opt, ",media=cdrom");
} else {
virBufferAddLit(&opt, ",media=cdrom");
}
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
virBufferAsprintf(&opt, ",id=%s%s", QEMU_DRIVE_HOST_PREFIX, disk->info.alias);
} else {
if (busid == -1 && unitid == -1) {
}
}
if (bootable &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE_BOOT) &&
+ qemuCapsGet(caps, QEMU_CAPS_DRIVE_BOOT) &&
(disk->device == VIR_DOMAIN_DISK_DEVICE_DISK ||
disk->device == VIR_DOMAIN_DISK_DEVICE_LUN) &&
disk->bus != VIR_DOMAIN_DISK_BUS_IDE)
virBufferAddLit(&opt, ",boot=on");
if (disk->readonly &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE_READONLY))
+ qemuCapsGet(caps, QEMU_CAPS_DRIVE_READONLY))
virBufferAddLit(&opt, ",readonly=on");
if (disk->transient) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
}
if (disk->driverType && *disk->driverType != '\0' &&
disk->type != VIR_DOMAIN_DISK_TYPE_DIR &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE_FORMAT))
+ qemuCapsGet(caps, QEMU_CAPS_DRIVE_FORMAT))
virBufferAsprintf(&opt, ",format=%s", disk->driverType);
/* generate geometry command string */
}
if (disk->serial &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE_SERIAL)) {
+ qemuCapsGet(caps, QEMU_CAPS_DRIVE_SERIAL)) {
if (qemuSafeSerialParamValue(disk->serial) < 0)
goto error;
virBufferAsprintf(&opt, ",serial=%s", disk->serial);
if (disk->cachemode) {
const char *mode = NULL;
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_V2)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DRIVE_CACHE_V2)) {
mode = qemuDiskCacheV2TypeToString(disk->cachemode);
if (disk->cachemode == VIR_DOMAIN_DISK_CACHE_DIRECTSYNC &&
- !qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_DIRECTSYNC)) {
+ !qemuCapsGet(caps, QEMU_CAPS_DRIVE_CACHE_DIRECTSYNC)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("disk cache mode 'directsync' is not "
"supported by this QEMU"));
goto error;
} else if (disk->cachemode == VIR_DOMAIN_DISK_CACHE_UNSAFE &&
- !qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_UNSAFE)) {
+ !qemuCapsGet(caps, QEMU_CAPS_DRIVE_CACHE_UNSAFE)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("disk cache mode 'unsafe' is not "
"supported by this QEMU"));
}
if (disk->copy_on_read) {
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE_COPY_ON_READ)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DRIVE_COPY_ON_READ)) {
virBufferAsprintf(&opt, ",copy-on-read=%s",
virDomainDiskCopyOnReadTypeToString(disk->copy_on_read));
} else {
}
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_MONITOR_JSON)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_MONITOR_JSON)) {
const char *wpolicy = NULL, *rpolicy = NULL;
if (disk->error_policy)
}
if (disk->iomode) {
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE_AIO)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DRIVE_AIO)) {
virBufferAsprintf(&opt, ",aio=%s",
virDomainDiskIoTypeToString(disk->iomode));
} else {
disk->blkdeviotune.total_iops_sec ||
disk->blkdeviotune.read_iops_sec ||
disk->blkdeviotune.write_iops_sec) &&
- !qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE_IOTUNE)) {
+ !qemuCapsGet(caps, QEMU_CAPS_DRIVE_IOTUNE)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("block I/O throttling not supported with this "
"QEMU binary"));
qemuBuildDriveDevStr(virDomainDefPtr def,
virDomainDiskDefPtr disk,
int bootindex,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
virBuffer opt = VIR_BUFFER_INITIALIZER;
const char *bus = virDomainDiskQEMUBusTypeToString(disk->bus);
virDomainDiskTypeToString(disk->type));
goto error;
}
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_BLK_SG_IO)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_VIRTIO_BLK_SG_IO)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("disk device='lun' is not supported by this QEMU"));
goto error;
goto error;
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_IDE_CD)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_IDE_CD)) {
if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM)
virBufferAddLit(&opt, "ide-cd");
else
break;
case VIR_DOMAIN_DISK_BUS_SCSI:
if (disk->device == VIR_DOMAIN_DISK_DEVICE_LUN) {
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_SCSI_BLOCK)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_SCSI_BLOCK)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("This QEMU doesn't support scsi-block for "
"lun passthrough"));
controllerModel =
virDomainDiskFindControllerModel(def, disk,
VIR_DOMAIN_CONTROLLER_TYPE_SCSI);
- if ((qemuSetScsiControllerModel(def, qemuCaps, &controllerModel)) < 0)
+ if ((qemuSetScsiControllerModel(def, caps, &controllerModel)) < 0)
goto error;
if (controllerModel == VIR_DOMAIN_CONTROLLER_MODEL_SCSI_LSILOGIC) {
if (disk->device == VIR_DOMAIN_DISK_DEVICE_LUN) {
virBufferAddLit(&opt, "scsi-block");
} else {
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_SCSI_CD)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_SCSI_CD)) {
if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM)
virBufferAddLit(&opt, "scsi-cd");
else
disk->info.addr.drive.bus,
disk->info.addr.drive.unit);
} else {
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_SCSI_DISK_CHANNEL)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_SCSI_DISK_CHANNEL)) {
if (disk->info.addr.drive.target > 7) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("This QEMU doesn't support target "
}
if (disk->device != VIR_DOMAIN_DISK_DEVICE_LUN) {
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_SCSI_CD)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_SCSI_CD)) {
if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM)
virBufferAddLit(&opt, "scsi-cd");
else
goto error;
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_IDE_CD)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_IDE_CD)) {
if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM)
virBufferAddLit(&opt, "ide-cd");
else
} else {
virBufferAddLit(&opt, "virtio-blk-pci");
}
- qemuBuildIoEventFdStr(&opt, disk->ioeventfd, qemuCaps);
+ qemuBuildIoEventFdStr(&opt, disk->ioeventfd, caps);
if (disk->event_idx &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_BLK_EVENT_IDX)) {
+ qemuCapsGet(caps, QEMU_CAPS_VIRTIO_BLK_EVENT_IDX)) {
virBufferAsprintf(&opt, ",event_idx=%s",
virDomainVirtioEventIdxTypeToString(disk->event_idx));
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_BLK_SCSI)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_VIRTIO_BLK_SCSI)) {
/* if sg_io is true but the scsi option isn't supported,
* that means it's just always on in this version of qemu.
*/
(disk->device == VIR_DOMAIN_DISK_DEVICE_LUN)
? "on" : "off");
}
- if (qemuBuildDeviceAddressStr(&opt, &disk->info, qemuCaps) < 0)
+ if (qemuBuildDeviceAddressStr(&opt, &disk->info, caps) < 0)
goto error;
break;
case VIR_DOMAIN_DISK_BUS_USB:
}
virBufferAsprintf(&opt, ",drive=%s%s", QEMU_DRIVE_HOST_PREFIX, disk->info.alias);
virBufferAsprintf(&opt, ",id=%s", disk->info.alias);
- if (bootindex && qemuCapsGet(qemuCaps, QEMU_CAPS_BOOTINDEX))
+ if (bootindex && qemuCapsGet(caps, QEMU_CAPS_BOOTINDEX))
virBufferAsprintf(&opt, ",bootindex=%d", bootindex);
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_BLOCKIO)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_BLOCKIO)) {
if (disk->blockio.logical_block_size > 0)
virBufferAsprintf(&opt, ",logical_block_size=%u",
disk->blockio.logical_block_size);
char *qemuBuildFSStr(virDomainFSDefPtr fs,
- virBitmapPtr qemuCaps ATTRIBUTE_UNUSED)
+ qemuCapsPtr caps ATTRIBUTE_UNUSED)
{
virBuffer opt = VIR_BUFFER_INITIALIZER;
const char *driver = qemuDomainFSDriverTypeToString(fs->fsdriver);
}
if (fs->wrpolicy) {
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_FSDEV_WRITEOUT)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_FSDEV_WRITEOUT)) {
virBufferAsprintf(&opt, ",writeout=%s", wrpolicy);
} else {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
virBufferAsprintf(&opt, ",path=%s", fs->src);
if (fs->readonly) {
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_FSDEV_READONLY)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_FSDEV_READONLY)) {
virBufferAddLit(&opt, ",readonly");
} else {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
char *
qemuBuildFSDevStr(virDomainFSDefPtr fs,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
virBuffer opt = VIR_BUFFER_INITIALIZER;
virBufferAsprintf(&opt, ",fsdev=%s%s", QEMU_FSDEV_HOST_PREFIX, fs->info.alias);
virBufferAsprintf(&opt, ",mount_tag=%s", fs->dst);
- if (qemuBuildDeviceAddressStr(&opt, &fs->info, qemuCaps) < 0)
+ if (qemuBuildDeviceAddressStr(&opt, &fs->info, caps) < 0)
goto error;
if (virBufferError(&opt)) {
static int
qemuBuildUSBControllerDevStr(virDomainDefPtr domainDef,
virDomainControllerDefPtr def,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
virBuffer *buf)
{
const char *smodel;
- int model, caps;
+ int model, flags;
model = def->model;
}
smodel = qemuControllerModelUSBTypeToString(model);
- caps = qemuControllerModelUSBToCaps(model);
+ flags = qemuControllerModelUSBToCaps(model);
- if (caps == -1 || !qemuCapsGet(qemuCaps, caps)) {
+ if (flags == -1 || !qemuCapsGet(caps, flags)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("%s not supported in this QEMU binary"), smodel);
return -1;
char *
qemuBuildControllerDevStr(virDomainDefPtr domainDef,
virDomainControllerDefPtr def,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
int *nusbcontroller)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
switch (def->type) {
case VIR_DOMAIN_CONTROLLER_TYPE_SCSI:
model = def->model;
- if ((qemuSetScsiControllerModel(domainDef, qemuCaps, &model)) < 0)
+ if ((qemuSetScsiControllerModel(domainDef, caps, &model)) < 0)
return NULL;
switch (model) {
break;
case VIR_DOMAIN_CONTROLLER_TYPE_USB:
- if (qemuBuildUSBControllerDevStr(domainDef, def, qemuCaps, &buf) == -1)
+ if (qemuBuildUSBControllerDevStr(domainDef, def, caps, &buf) == -1)
goto error;
if (nusbcontroller)
goto error;
}
- if (qemuBuildDeviceAddressStr(&buf, &def->info, qemuCaps) < 0)
+ if (qemuBuildDeviceAddressStr(&buf, &def->info, caps) < 0)
goto error;
if (virBufferError(&buf)) {
qemuBuildNicDevStr(virDomainNetDefPtr net,
int vlan,
int bootindex,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
const char *nic;
virBufferAdd(&buf, nic, strlen(nic));
if (usingVirtio && net->driver.virtio.txmode) {
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_TX_ALG)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_VIRTIO_TX_ALG)) {
virBufferAddLit(&buf, ",tx=");
switch (net->driver.virtio.txmode) {
case VIR_DOMAIN_NET_VIRTIO_TX_MODE_IOTHREAD:
}
}
if (usingVirtio) {
- qemuBuildIoEventFdStr(&buf, net->driver.virtio.ioeventfd, qemuCaps);
+ qemuBuildIoEventFdStr(&buf, net->driver.virtio.ioeventfd, caps);
if (net->driver.virtio.event_idx &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_NET_EVENT_IDX)) {
+ qemuCapsGet(caps, QEMU_CAPS_VIRTIO_NET_EVENT_IDX)) {
virBufferAsprintf(&buf, ",event_idx=%s",
virDomainVirtioEventIdxTypeToString(net->driver.virtio.event_idx));
}
net->mac.addr[0], net->mac.addr[1],
net->mac.addr[2], net->mac.addr[3],
net->mac.addr[4], net->mac.addr[5]);
- if (qemuBuildDeviceAddressStr(&buf, &net->info, qemuCaps) < 0)
+ if (qemuBuildDeviceAddressStr(&buf, &net->info, caps) < 0)
goto error;
- if (qemuBuildRomStr(&buf, &net->info, qemuCaps) < 0)
+ if (qemuBuildRomStr(&buf, &net->info, caps) < 0)
goto error;
- if (bootindex && qemuCapsGet(qemuCaps, QEMU_CAPS_BOOTINDEX))
+ if (bootindex && qemuCapsGet(caps, QEMU_CAPS_BOOTINDEX))
virBufferAsprintf(&buf, ",bootindex=%d", bootindex);
if (virBufferError(&buf)) {
char *
qemuBuildHostNetStr(virDomainNetDefPtr net,
struct qemud_driver *driver,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
char type_sep,
int vlan,
const char *tapfd,
*/
case VIR_DOMAIN_NET_TYPE_BRIDGE:
if (!driver->privileged &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_NETDEV_BRIDGE)) {
+ qemuCapsGet(caps, QEMU_CAPS_NETDEV_BRIDGE)) {
brname = virDomainNetGetActualBridgeName(net);
virBufferAsprintf(&buf, "bridge%cbr=%s", type_sep, brname);
type_sep = ',';
char *
qemuBuildWatchdogDevStr(virDomainWatchdogDefPtr dev,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
}
virBufferAsprintf(&buf, "%s,id=%s", model, dev->info.alias);
- if (qemuBuildDeviceAddressStr(&buf, &dev->info, qemuCaps) < 0)
+ if (qemuBuildDeviceAddressStr(&buf, &dev->info, caps) < 0)
goto error;
if (virBufferError(&buf)) {
char *
qemuBuildMemballoonDevStr(virDomainMemballoonDefPtr dev,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
virBufferAddLit(&buf, "virtio-balloon-pci");
virBufferAsprintf(&buf, ",id=%s", dev->info.alias);
- if (qemuBuildDeviceAddressStr(&buf, &dev->info, qemuCaps) < 0)
+ if (qemuBuildDeviceAddressStr(&buf, &dev->info, caps) < 0)
goto error;
if (virBufferError(&buf)) {
char *
qemuBuildUSBInputDevStr(virDomainInputDefPtr dev,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
dev->type == VIR_DOMAIN_INPUT_TYPE_MOUSE ?
"usb-mouse" : "usb-tablet", dev->info.alias);
- if (qemuBuildDeviceAddressStr(&buf, &dev->info, qemuCaps) < 0)
+ if (qemuBuildDeviceAddressStr(&buf, &dev->info, caps) < 0)
goto error;
if (virBufferError(&buf)) {
char *
qemuBuildSoundDevStr(virDomainSoundDefPtr sound,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
const char *model = virDomainSoundModelTypeToString(sound->model);
model = "intel-hda";
virBufferAsprintf(&buf, "%s,id=%s", model, sound->info.alias);
- if (qemuBuildDeviceAddressStr(&buf, &sound->info, qemuCaps) < 0)
+ if (qemuBuildDeviceAddressStr(&buf, &sound->info, caps) < 0)
goto error;
if (virBufferError(&buf)) {
static char *
qemuBuildSoundCodecStr(virDomainSoundDefPtr sound,
virDomainSoundCodecDefPtr codec,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
const char *stype;
- int type, caps;
+ int type, flags;
type = codec->type;
stype = qemuSoundCodecTypeToString(type);
- caps = qemuSoundCodecTypeToCaps(type);
+ flags = qemuSoundCodecTypeToCaps(type);
- if (caps == -1 || !qemuCapsGet(qemuCaps, caps)) {
+ if (flags == -1 || !qemuCapsGet(caps, flags)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("%s not supported in this QEMU binary"), stype);
goto error;
static char *
qemuBuildVideoDevStr(virDomainVideoDefPtr video,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
const char *model = qemuVideoTypeToString(video->type);
virBufferAsprintf(&buf, ",vram_size=%u", video->vram * 1024);
}
- if (qemuBuildDeviceAddressStr(&buf, &video->info, qemuCaps) < 0)
+ if (qemuBuildDeviceAddressStr(&buf, &video->info, caps) < 0)
goto error;
if (virBufferError(&buf)) {
char *
qemuBuildPCIHostdevDevStr(virDomainHostdevDefPtr dev, const char *configfd,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
virBufferAsprintf(&buf, ",configfd=%s", configfd);
if (dev->info->bootIndex)
virBufferAsprintf(&buf, ",bootindex=%d", dev->info->bootIndex);
- if (qemuBuildDeviceAddressStr(&buf, dev->info, qemuCaps) < 0)
+ if (qemuBuildDeviceAddressStr(&buf, dev->info, caps) < 0)
goto error;
- if (qemuBuildRomStr(&buf, dev->info, qemuCaps) < 0)
+ if (qemuBuildRomStr(&buf, dev->info, caps) < 0)
goto error;
if (virBufferError(&buf)) {
char *
qemuBuildRedirdevDevStr(virDomainDefPtr def,
virDomainRedirdevDefPtr dev,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
size_t i;
virBuffer buf = VIR_BUFFER_INITIALIZER;
goto error;
}
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_USB_REDIR)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_USB_REDIR)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("USB redirection is not supported "
"by this version of QEMU"));
dev->info.alias);
if (redirfilter && redirfilter->nusbdevs) {
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_USB_REDIR_FILTER)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_USB_REDIR_FILTER)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("USB redirection filter is not "
"supported by this version of QEMU"));
}
}
- if (qemuBuildDeviceAddressStr(&buf, &dev->info, qemuCaps) < 0)
+ if (qemuBuildDeviceAddressStr(&buf, &dev->info, caps) < 0)
goto error;
if (virBufferError(&buf)) {
char *
qemuBuildUSBHostdevDevStr(virDomainHostdevDefPtr dev,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
dev->source.subsys.u.usb.device,
dev->info->alias);
- if (qemuBuildDeviceAddressStr(&buf, dev->info, qemuCaps) < 0)
+ if (qemuBuildDeviceAddressStr(&buf, dev->info, caps) < 0)
goto error;
if (virBufferError(&buf)) {
char *
qemuBuildHubDevStr(virDomainHubDefPtr dev,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
goto error;
}
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_USB_HUB)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_USB_HUB)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("usb-hub not supported by QEMU binary"));
goto error;
virBufferAddLit(&buf, "usb-hub");
virBufferAsprintf(&buf, ",id=%s", dev->info.alias);
- if (qemuBuildDeviceAddressStr(&buf, &dev->info, qemuCaps) < 0)
+ if (qemuBuildDeviceAddressStr(&buf, &dev->info, caps) < 0)
goto error;
if (virBufferError(&buf)) {
* host side of the character device */
static char *
qemuBuildChrChardevStr(virDomainChrSourceDefPtr dev, const char *alias,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
bool telnet;
break;
case VIR_DOMAIN_CHR_TYPE_SPICEVMC:
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_CHARDEV_SPICEVMC)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_CHARDEV_SPICEVMC)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("spicevmc not supported in this QEMU binary"));
goto error;
static char *
qemuBuildVirtioSerialPortDevStr(virDomainChrDefPtr dev,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
switch (dev->deviceType) {
case VIR_DOMAIN_CHR_DEVICE_TYPE_CHANNEL:
/* Legacy syntax '-device spicevmc' */
if (dev->source.type == VIR_DOMAIN_CHR_TYPE_SPICEVMC &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE_SPICEVMC)) {
+ qemuCapsGet(caps, QEMU_CAPS_DEVICE_SPICEVMC)) {
virBufferAddLit(&buf, "spicevmc");
} else {
virBufferAddLit(&buf, "virtserialport");
if (!(dev->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CHANNEL &&
dev->source.type == VIR_DOMAIN_CHR_TYPE_SPICEVMC &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE_SPICEVMC))) {
+ qemuCapsGet(caps, QEMU_CAPS_DEVICE_SPICEVMC))) {
virBufferAsprintf(&buf, ",chardev=char%s,id=%s",
dev->info.alias, dev->info.alias);
if (dev->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CHANNEL) {
qemuBuildCpuArgStr(const struct qemud_driver *driver,
const virDomainDefPtr def,
const char *emulator,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
const struct utsname *ut,
char **opt,
bool *hasHwVirt,
int hasSVM;
if (host &&
- qemuCapsProbeCPUModels(emulator, qemuCaps, host->arch,
+ qemuCapsProbeCPUModels(emulator, caps, host->arch,
&ncpus, &cpus) < 0)
goto cleanup;
if (cpu->mode == VIR_CPU_MODE_HOST_PASSTHROUGH) {
const char *mode = virCPUModeTypeToString(cpu->mode);
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_CPU_HOST)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_CPU_HOST)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("CPU mode '%s' is not supported by QEMU"
" binary"), mode);
static char *
qemuBuildSmpArgStr(const virDomainDefPtr def,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
virBufferAsprintf(&buf, "%u", def->vcpus);
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_SMP_TOPOLOGY)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_SMP_TOPOLOGY)) {
if (def->vcpus != def->maxvcpus)
virBufferAsprintf(&buf, ",maxcpus=%u", def->maxvcpus);
/* sockets, cores, and threads are either all zero
virDomainDefPtr def,
virDomainChrSourceDefPtr monitor_chr,
bool monitor_json,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
const char *migrateFrom,
int migrateFd,
virDomainSnapshotObjPtr snapshot,
* do not use boot=on for drives when not using KVM since this
* is not supported at all in upstream QEmu.
*/
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_KVM) &&
+ if (qemuCapsGet(caps, QEMU_CAPS_KVM) &&
(def->virtType == VIR_DOMAIN_VIRT_QEMU))
- qemuCapsClear(qemuCaps, QEMU_CAPS_DRIVE_BOOT);
+ qemuCapsClear(caps, QEMU_CAPS_DRIVE_BOOT);
switch (def->virtType) {
case VIR_DOMAIN_VIRT_QEMU:
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_KQEMU))
+ if (qemuCapsGet(caps, QEMU_CAPS_KQEMU))
disableKQEMU = 1;
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_KVM))
+ if (qemuCapsGet(caps, QEMU_CAPS_KVM))
disableKVM = 1;
break;
case VIR_DOMAIN_VIRT_KQEMU:
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_KVM))
+ if (qemuCapsGet(caps, QEMU_CAPS_KVM))
disableKVM = 1;
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_ENABLE_KQEMU)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_ENABLE_KQEMU)) {
enableKQEMU = 1;
- } else if (!qemuCapsGet(qemuCaps, QEMU_CAPS_KQEMU)) {
+ } else if (!qemuCapsGet(caps, QEMU_CAPS_KQEMU)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("the QEMU binary %s does not support kqemu"),
emulator);
break;
case VIR_DOMAIN_VIRT_KVM:
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_KQEMU))
+ if (qemuCapsGet(caps, QEMU_CAPS_KQEMU))
disableKQEMU = 1;
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_ENABLE_KVM)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_ENABLE_KVM)) {
enableKVM = 1;
- } else if (!qemuCapsGet(qemuCaps, QEMU_CAPS_KVM)) {
+ } else if (!qemuCapsGet(caps, QEMU_CAPS_KVM)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("the QEMU binary %s does not support kvm"),
emulator);
virCommandAddEnvPassCommon(cmd);
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_NAME)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_NAME)) {
virCommandAddArg(cmd, "-name");
if (driver->setProcessName &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_NAME_PROCESS)) {
+ qemuCapsGet(caps, QEMU_CAPS_NAME_PROCESS)) {
virCommandAddArgFormat(cmd, "%s,process=qemu:%s",
def->name, def->name);
} else {
if (def->os.machine)
virCommandAddArgList(cmd, "-M", def->os.machine, NULL);
- if (qemuBuildCpuArgStr(driver, def, emulator, qemuCaps,
+ if (qemuBuildCpuArgStr(driver, def, emulator, caps,
&ut, &cpu, &hasHwVirt, !!migrateFrom) < 0)
goto error;
virCommandAddArgList(cmd, "-cpu", cpu, NULL);
VIR_FREE(cpu);
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_NESTING) &&
+ if (qemuCapsGet(caps, QEMU_CAPS_NESTING) &&
hasHwVirt)
virCommandAddArg(cmd, "-enable-nesting");
}
"%s", _("hugepages are disabled by administrator config"));
goto error;
}
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_MEM_PATH)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_MEM_PATH)) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("hugepage backing not supported by '%s'"),
def->emulator);
}
virCommandAddArg(cmd, "-smp");
- if (!(smp = qemuBuildSmpArgStr(def, qemuCaps)))
+ if (!(smp = qemuBuildSmpArgStr(def, caps)))
goto error;
virCommandAddArg(cmd, smp);
VIR_FREE(smp);
if (qemuBuildNumaArgStr(def, cmd) < 0)
goto error;
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_UUID))
+ if (qemuCapsGet(caps, QEMU_CAPS_UUID))
virCommandAddArgList(cmd, "-uuid", uuid, NULL);
if (def->virtType == VIR_DOMAIN_VIRT_XEN ||
STREQ(def->os.type, "xen") ||
STREQ(def->os.type, "linux")) {
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DOMID)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DOMID)) {
virCommandAddArg(cmd, "-domid");
virCommandAddArgFormat(cmd, "%d", def->id);
- } else if (qemuCapsGet(qemuCaps, QEMU_CAPS_XEN_DOMID)) {
+ } else if (qemuCapsGet(caps, QEMU_CAPS_XEN_DOMID)) {
virCommandAddArg(cmd, "-xen-attach");
virCommandAddArg(cmd, "-xen-domid");
virCommandAddArgFormat(cmd, "%d", def->id);
virSysinfoDefPtr source = NULL;
bool skip_uuid = false;
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_SMBIOS_TYPE)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_SMBIOS_TYPE)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("the QEMU binary %s does not support smbios settings"),
emulator);
if (!def->graphics)
virCommandAddArg(cmd, "-nographic");
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
/* Disable global config files and default devices */
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_NO_USER_CONFIG))
+ if (qemuCapsGet(caps, QEMU_CAPS_NO_USER_CONFIG))
virCommandAddArg(cmd, "-no-user-config");
- else if (qemuCapsGet(qemuCaps, QEMU_CAPS_NODEFCONFIG))
+ else if (qemuCapsGet(caps, QEMU_CAPS_NODEFCONFIG))
virCommandAddArg(cmd, "-nodefconfig");
virCommandAddArg(cmd, "-nodefaults");
}
/* Serial graphics adapter */
if (def->os.bios.useserial == VIR_DOMAIN_BIOS_USESERIAL_YES) {
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("qemu does not support -device"));
goto error;
}
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_SGA)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_SGA)) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("qemu does not support SGA"));
goto error;
if (monitor_chr) {
char *chrdev;
/* Use -chardev if it's available */
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_CHARDEV)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_CHARDEV)) {
virCommandAddArg(cmd, "-chardev");
if (!(chrdev = qemuBuildChrChardevStr(monitor_chr, "monitor",
- qemuCaps)))
+ caps)))
goto error;
virCommandAddArg(cmd, chrdev);
VIR_FREE(chrdev);
}
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_RTC)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_RTC)) {
const char *rtcopt;
virCommandAddArg(cmd, "-rtc");
if (!(rtcopt = qemuBuildClockArgStr(&def->clock)))
/* This has already been taken care of (in qemuBuildClockArgStr)
if QEMU_CAPS_RTC is set (mutually exclusive with
QEMUD_FLAG_RTC_TD_HACK) */
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_RTC_TD_HACK)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_RTC_TD_HACK)) {
switch (def->clock.timers[i]->tickpolicy) {
case -1:
case VIR_DOMAIN_TIMER_TICKPOLICY_DELAY:
virDomainTimerTickpolicyTypeToString(def->clock.timers[i]->tickpolicy));
goto error;
}
- } else if (!qemuCapsGet(qemuCaps, QEMU_CAPS_RTC)
+ } else if (!qemuCapsGet(caps, QEMU_CAPS_RTC)
&& (def->clock.timers[i]->tickpolicy
!= VIR_DOMAIN_TIMER_TICKPOLICY_DELAY)
&& (def->clock.timers[i]->tickpolicy != -1)) {
case VIR_DOMAIN_TIMER_TICKPOLICY_DELAY:
/* delay is the default if we don't have kernel
(-no-kvm-pit), otherwise, the default is catchup. */
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_NO_KVM_PIT))
+ if (qemuCapsGet(caps, QEMU_CAPS_NO_KVM_PIT))
virCommandAddArg(cmd, "-no-kvm-pit-reinjection");
break;
case VIR_DOMAIN_TIMER_TICKPOLICY_CATCHUP:
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_NO_KVM_PIT)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_NO_KVM_PIT)) {
/* do nothing - this is default for kvm-pit */
- } else if (qemuCapsGet(qemuCaps, QEMU_CAPS_TDF)) {
+ } else if (qemuCapsGet(caps, QEMU_CAPS_TDF)) {
/* -tdf switches to 'catchup' with userspace pit. */
virCommandAddArg(cmd, "-tdf");
} else {
* and when -no-hpet doesn't exist is "no". "confusing"?
* "yes"! */
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_NO_HPET)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_NO_HPET)) {
if (def->clock.timers[i]->present == 0)
virCommandAddArg(cmd, "-no-hpet");
} else {
}
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_NO_REBOOT) &&
+ if (qemuCapsGet(caps, QEMU_CAPS_NO_REBOOT) &&
def->onReboot != VIR_DOMAIN_LIFECYCLE_RESTART)
virCommandAddArg(cmd, "-no-reboot");
* when QEMU stops. If we use no-shutdown, then we can
* watch for this event and do a soft/warm reboot.
*/
- if (monitor_json && qemuCapsGet(qemuCaps, QEMU_CAPS_NO_SHUTDOWN))
+ if (monitor_json && qemuCapsGet(caps, QEMU_CAPS_NO_SHUTDOWN))
virCommandAddArg(cmd, "-no-shutdown");
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_NO_ACPI)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_NO_ACPI)) {
if (!(def->features & (1 << VIR_DOMAIN_FEATURE_ACPI)))
virCommandAddArg(cmd, "-no-acpi");
}
if (def->pm.s3) {
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_DISABLE_S3)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_DISABLE_S3)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("setting ACPI S3 not supported"));
goto error;
}
if (def->pm.s4) {
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_DISABLE_S4)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_DISABLE_S4)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("setting ACPI S4 not supported"));
goto error;
/* def->os.nBootDevs is guaranteed to be > 0 unless per-device boot
* configuration is used
*/
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_BOOTINDEX)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_BOOTINDEX)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("hypervisor lacks deviceboot feature"));
goto error;
}
emitBootindex = true;
- } else if (qemuCapsGet(qemuCaps, QEMU_CAPS_BOOTINDEX) &&
+ } else if (qemuCapsGet(caps, QEMU_CAPS_BOOTINDEX) &&
(def->os.bootmenu != VIR_DOMAIN_BOOT_MENU_ENABLED ||
- !qemuCapsGet(qemuCaps, QEMU_CAPS_BOOT_MENU))) {
+ !qemuCapsGet(caps, QEMU_CAPS_BOOT_MENU))) {
emitBootindex = true;
}
virCommandAddArg(cmd, "-boot");
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_BOOT_MENU) &&
+ if (qemuCapsGet(caps, QEMU_CAPS_BOOT_MENU) &&
def->os.bootmenu != VIR_DOMAIN_BOOT_MENU_DEFAULT) {
if (def->os.bootmenu == VIR_DOMAIN_BOOT_MENU_ENABLED)
virBufferAsprintf(&boot_buf, "order=%s,menu=on", boot);
}
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
for (i = 0 ; i < def->ncontrollers ; i++) {
virDomainControllerDefPtr cont = def->controllers[i];
/* Only recent QEMU implements a SATA (AHCI) controller */
if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_SATA) {
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_ICH9_AHCI)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_ICH9_AHCI)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("SATA is not supported with this "
"QEMU binary"));
virCommandAddArg(cmd, "-device");
if (!(devstr = qemuBuildControllerDevStr(def, cont,
- qemuCaps, NULL)))
+ caps, NULL)))
goto error;
virCommandAddArg(cmd, devstr);
}
} else if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_USB &&
cont->model == -1 &&
- !qemuCapsGet(qemuCaps, QEMU_CAPS_PIIX3_USB_UHCI)) {
+ !qemuCapsGet(caps, QEMU_CAPS_PIIX3_USB_UHCI)) {
if (usblegacy) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("Multiple legacy USB controllers are "
virCommandAddArg(cmd, "-device");
char *devstr;
- if (!(devstr = qemuBuildControllerDevStr(def, cont, qemuCaps,
+ if (!(devstr = qemuBuildControllerDevStr(def, cont, caps,
&usbcontroller)))
goto error;
}
/* If QEMU supports -drive param instead of old -hda, -hdb, -cdrom .. */
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DRIVE)) {
int bootCD = 0, bootFloppy = 0, bootDisk = 0;
- if ((qemuCapsGet(qemuCaps, QEMU_CAPS_DRIVE_BOOT) || emitBootindex)) {
+ if ((qemuCapsGet(caps, QEMU_CAPS_DRIVE_BOOT) || emitBootindex)) {
/* bootDevs will get translated into either bootindex=N or boot=on
* depending on what qemu supports */
for (i = 0 ; i < def->os.nBootDevs ; i++) {
/* Unless we have -device, then USB disks need special
handling */
if ((disk->bus == VIR_DOMAIN_DISK_BUS_USB) &&
- !qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ !qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
if (disk->device == VIR_DOMAIN_DISK_DEVICE_DISK) {
virCommandAddArg(cmd, "-usbdevice");
virCommandAddArgFormat(cmd, "disk:%s", disk->src);
devices. Fortunately, those don't need
static PCI addresses, so we don't really
care that we can't use -device */
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
if (disk->bus != VIR_DOMAIN_DISK_BUS_XEN) {
withDeviceArg = 1;
} else {
- qemuCapsClear(qemuCaps, QEMU_CAPS_DEVICE);
+ qemuCapsClear(caps, QEMU_CAPS_DEVICE);
deviceFlagMasked = true;
}
}
optstr = qemuBuildDriveStr(conn, disk,
emitBootindex ? false : !!bootindex,
- qemuCaps);
+ caps);
if (deviceFlagMasked)
- qemuCapsSet(qemuCaps, QEMU_CAPS_DEVICE);
+ qemuCapsSet(caps, QEMU_CAPS_DEVICE);
if (!optstr)
goto error;
virCommandAddArg(cmd, optstr);
virCommandAddArg(cmd, "-device");
if (!(optstr = qemuBuildDriveDevStr(def, disk, bootindex,
- qemuCaps)))
+ caps)))
goto error;
virCommandAddArg(cmd, optstr);
VIR_FREE(optstr);
}
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_FSDEV)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_FSDEV)) {
for (i = 0 ; i < def->nfss ; i++) {
char *optstr;
virDomainFSDefPtr fs = def->fss[i];
virCommandAddArg(cmd, "-fsdev");
- if (!(optstr = qemuBuildFSStr(fs, qemuCaps)))
+ if (!(optstr = qemuBuildFSStr(fs, caps)))
goto error;
virCommandAddArg(cmd, optstr);
VIR_FREE(optstr);
virCommandAddArg(cmd, "-device");
- if (!(optstr = qemuBuildFSDevStr(fs, qemuCaps)))
+ if (!(optstr = qemuBuildFSDevStr(fs, caps)))
goto error;
virCommandAddArg(cmd, optstr);
VIR_FREE(optstr);
if (!def->nnets) {
/* If we have -device, then we set -nodefault already */
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
+ if (!qemuCapsGet(caps, QEMU_CAPS_DEVICE))
virCommandAddArgList(cmd, "-net", "none", NULL);
} else {
int bootNet = 0;
bootindex = net->info.bootIndex;
/* VLANs are not used with -netdev, so don't record them */
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_NETDEV) &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
+ if (qemuCapsGet(caps, QEMU_CAPS_NETDEV) &&
+ qemuCapsGet(caps, QEMU_CAPS_DEVICE))
vlan = -1;
else
vlan = i;
*/
if (actualType == VIR_DOMAIN_NET_TYPE_NETWORK ||
driver->privileged ||
- (!qemuCapsGet(qemuCaps, QEMU_CAPS_NETDEV_BRIDGE))) {
+ (!qemuCapsGet(caps, QEMU_CAPS_NETDEV_BRIDGE))) {
int tapfd = qemuNetworkIfaceConnect(def, conn, driver, net,
- qemuCaps);
+ caps);
if (tapfd < 0)
goto error;
}
} else if (actualType == VIR_DOMAIN_NET_TYPE_DIRECT) {
int tapfd = qemuPhysIfaceConnect(def, driver, net,
- qemuCaps, vmop);
+ caps, vmop);
if (tapfd < 0)
goto error;
network device */
int vhostfd;
- if (qemuOpenVhostNet(def, net, qemuCaps, &vhostfd) < 0)
+ if (qemuOpenVhostNet(def, net, caps, &vhostfd) < 0)
goto error;
if (vhostfd >= 0) {
virCommandTransferFD(cmd, vhostfd);
*
* NB, no support for -netdev without use of -device
*/
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_NETDEV) &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_NETDEV) &&
+ qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
virCommandAddArg(cmd, "-netdev");
- if (!(host = qemuBuildHostNetStr(net, driver, qemuCaps,
+ if (!(host = qemuBuildHostNetStr(net, driver, caps,
',', vlan, tapfd_name,
vhostfd_name)))
goto error;
virCommandAddArg(cmd, host);
VIR_FREE(host);
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
virCommandAddArg(cmd, "-device");
- nic = qemuBuildNicDevStr(net, vlan, bootindex, qemuCaps);
+ nic = qemuBuildNicDevStr(net, vlan, bootindex, caps);
if (!nic)
goto error;
virCommandAddArg(cmd, nic);
virCommandAddArg(cmd, nic);
VIR_FREE(nic);
}
- if (!(qemuCapsGet(qemuCaps, QEMU_CAPS_NETDEV) &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE))) {
+ if (!(qemuCapsGet(caps, QEMU_CAPS_NETDEV) &&
+ qemuCapsGet(caps, QEMU_CAPS_DEVICE))) {
virCommandAddArg(cmd, "-net");
- if (!(host = qemuBuildHostNetStr(net, driver, qemuCaps,
+ if (!(host = qemuBuildHostNetStr(net, driver, caps,
',', vlan, tapfd_name,
vhostfd_name)))
goto error;
switch (smartcard->type) {
case VIR_DOMAIN_SMARTCARD_TYPE_HOST:
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_CHARDEV) ||
- !qemuCapsGet(qemuCaps, QEMU_CAPS_CCID_EMULATED)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_CHARDEV) ||
+ !qemuCapsGet(caps, QEMU_CAPS_CCID_EMULATED)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("this QEMU binary lacks smartcard host "
"mode support"));
break;
case VIR_DOMAIN_SMARTCARD_TYPE_HOST_CERTIFICATES:
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_CHARDEV) ||
- !qemuCapsGet(qemuCaps, QEMU_CAPS_CCID_EMULATED)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_CHARDEV) ||
+ !qemuCapsGet(caps, QEMU_CAPS_CCID_EMULATED)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("this QEMU binary lacks smartcard host "
"mode support"));
break;
case VIR_DOMAIN_SMARTCARD_TYPE_PASSTHROUGH:
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_CHARDEV) ||
- !qemuCapsGet(qemuCaps, QEMU_CAPS_CCID_PASSTHRU)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_CHARDEV) ||
+ !qemuCapsGet(caps, QEMU_CAPS_CCID_PASSTHRU)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("this QEMU binary lacks smartcard "
"passthrough mode support"));
virCommandAddArg(cmd, "-chardev");
if (!(devstr = qemuBuildChrChardevStr(&smartcard->data.passthru,
smartcard->info.alias,
- qemuCaps))) {
+ caps))) {
virBufferFreeAndReset(&opt);
goto error;
}
if (!def->nserials) {
/* If we have -device, then we set -nodefault already */
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
+ if (!qemuCapsGet(caps, QEMU_CAPS_DEVICE))
virCommandAddArgList(cmd, "-serial", "none", NULL);
} else {
for (i = 0 ; i < def->nserials ; i++) {
char *devstr;
/* Use -chardev with -device if they are available */
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_CHARDEV) &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_CHARDEV) &&
+ qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
virCommandAddArg(cmd, "-chardev");
if (!(devstr = qemuBuildChrChardevStr(&serial->source,
serial->info.alias,
- qemuCaps)))
+ caps)))
goto error;
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
virCommandAddArg(cmd, "-device");
- if (!(devstr = qemuBuildChrDeviceStr(serial, qemuCaps,
+ if (!(devstr = qemuBuildChrDeviceStr(serial, caps,
def->os.arch,
def->os.machine)))
goto error;
if (!def->nparallels) {
/* If we have -device, then we set -nodefault already */
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
+ if (!qemuCapsGet(caps, QEMU_CAPS_DEVICE))
virCommandAddArgList(cmd, "-parallel", "none", NULL);
} else {
for (i = 0 ; i < def->nparallels ; i++) {
char *devstr;
/* Use -chardev with -device if they are available */
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_CHARDEV) &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_CHARDEV) &&
+ qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
virCommandAddArg(cmd, "-chardev");
if (!(devstr = qemuBuildChrChardevStr(¶llel->source,
parallel->info.alias,
- qemuCaps)))
+ caps)))
goto error;
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
switch(channel->targetType) {
case VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_GUESTFWD:
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_CHARDEV) ||
- !qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_CHARDEV) ||
+ !qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("guestfwd requires QEMU to support -chardev & -device"));
goto error;
virCommandAddArg(cmd, "-chardev");
if (!(devstr = qemuBuildChrChardevStr(&channel->source,
channel->info.alias,
- qemuCaps)))
+ caps)))
goto error;
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
break;
case VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_VIRTIO:
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("virtio channel requires QEMU to support -device"));
goto error;
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE_SPICEVMC) &&
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE_SPICEVMC) &&
channel->source.type == VIR_DOMAIN_CHR_TYPE_SPICEVMC) {
/* spicevmc was originally introduced via a -device
* with a backend internal to qemu; although we prefer
virCommandAddArg(cmd, "-chardev");
if (!(devstr = qemuBuildChrChardevStr(&channel->source,
channel->info.alias,
- qemuCaps)))
+ caps)))
goto error;
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
virCommandAddArg(cmd, "-device");
if (!(devstr = qemuBuildVirtioSerialPortDevStr(channel,
- qemuCaps)))
+ caps)))
goto error;
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
switch(console->targetType) {
case VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_VIRTIO:
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("virtio channel requires QEMU to support -device"));
goto error;
virCommandAddArg(cmd, "-chardev");
if (!(devstr = qemuBuildChrChardevStr(&console->source,
console->info.alias,
- qemuCaps)))
+ caps)))
goto error;
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
virCommandAddArg(cmd, "-device");
if (!(devstr = qemuBuildVirtioSerialPortDevStr(console,
- qemuCaps)))
+ caps)))
goto error;
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
char *optstr;
virCommandAddArg(cmd, "-device");
- if (!(optstr = qemuBuildHubDevStr(hub, qemuCaps)))
+ if (!(optstr = qemuBuildHubDevStr(hub, caps)))
goto error;
virCommandAddArg(cmd, optstr);
VIR_FREE(optstr);
virDomainInputDefPtr input = def->inputs[i];
if (input->bus == VIR_DOMAIN_INPUT_BUS_USB) {
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
char *optstr;
virCommandAddArg(cmd, "-device");
- if (!(optstr = qemuBuildUSBInputDevStr(input, qemuCaps)))
+ if (!(optstr = qemuBuildUSBInputDevStr(input, caps)))
goto error;
virCommandAddArg(cmd, optstr);
VIR_FREE(optstr);
virBufferAsprintf(&opt, "unix:%s",
def->graphics[0]->data.vnc.socket);
- } else if (qemuCapsGet(qemuCaps, QEMU_CAPS_VNC_COLON)) {
+ } else if (qemuCapsGet(caps, QEMU_CAPS_VNC_COLON)) {
const char *listenNetwork;
const char *listenAddr = NULL;
char *netAddr = NULL;
def->graphics[0]->data.vnc.port - 5900);
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_VNC_COLON)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_VNC_COLON)) {
if (def->graphics[0]->data.vnc.auth.passwd ||
driver->vncPassword)
virBufferAddLit(&opt, ",password");
}
} else if ((def->ngraphics == 1) &&
def->graphics[0]->type == VIR_DOMAIN_GRAPHICS_TYPE_SDL) {
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_0_10) &&
- !qemuCapsGet(qemuCaps, QEMU_CAPS_SDL)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_0_10) &&
+ !qemuCapsGet(caps, QEMU_CAPS_SDL)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("sdl not supported by '%s'"),
def->emulator);
/* New QEMU has this flag to let us explicitly ask for
* SDL graphics. This is better than relying on the
* default, since the default changes :-( */
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_SDL))
+ if (qemuCapsGet(caps, QEMU_CAPS_SDL))
virCommandAddArg(cmd, "-sdl");
} else if ((def->ngraphics == 1) &&
int ret;
int defaultMode = def->graphics[0]->data.spice.defaultMode;
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_SPICE)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_SPICE)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("spice graphics are not supported with this QEMU"));
goto error;
}
if (def->nvideos > 0) {
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_VGA)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_VGA)) {
if (def->videos[0]->type == VIR_DOMAIN_VIDEO_TYPE_XEN) {
/* nothing - vga has no effect on Xen pvfb */
} else {
if ((def->videos[0]->type == VIR_DOMAIN_VIDEO_TYPE_QXL) &&
- !qemuCapsGet(qemuCaps, QEMU_CAPS_VGA_QXL)) {
+ !qemuCapsGet(caps, QEMU_CAPS_VGA_QXL)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("This QEMU does not support QXL graphics adapters"));
goto error;
if (def->videos[0]->type == VIR_DOMAIN_VIDEO_TYPE_QXL) {
if (def->videos[0]->vram &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
if (def->videos[0]->vram > (UINT_MAX / 1024)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("value for 'vram' must be less than '%u'"),
virCommandAddArg(cmd, "-global");
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE_QXL_VGA))
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE_QXL_VGA))
virCommandAddArgFormat(cmd, "qxl-vga.vram_size=%u",
def->videos[0]->vram * 1024);
else
}
if (def->nvideos > 1) {
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
for (i = 1 ; i < def->nvideos ; i++) {
char *str;
if (def->videos[i]->type != VIR_DOMAIN_VIDEO_TYPE_QXL) {
virCommandAddArg(cmd, "-device");
- if (!(str = qemuBuildVideoDevStr(def->videos[i], qemuCaps)))
+ if (!(str = qemuBuildVideoDevStr(def->videos[i], caps)))
goto error;
virCommandAddArg(cmd, str);
} else {
/* If we have -device, then we set -nodefault already */
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE) &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_VGA) &&
- qemuCapsGet(qemuCaps, QEMU_CAPS_VGA_NONE))
+ if (!qemuCapsGet(caps, QEMU_CAPS_DEVICE) &&
+ qemuCapsGet(caps, QEMU_CAPS_VGA) &&
+ qemuCapsGet(caps, QEMU_CAPS_VGA_NONE))
virCommandAddArgList(cmd, "-vga", "none", NULL);
}
/* Add sound hardware */
if (def->nsounds) {
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
for (i = 0 ; i < def->nsounds ; i++) {
virDomainSoundDefPtr sound = def->sounds[i];
char *str = NULL;
virCommandAddArgList(cmd, "-soundhw", "pcspk", NULL);
} else {
virCommandAddArg(cmd, "-device");
- if (!(str = qemuBuildSoundDevStr(sound, qemuCaps)))
+ if (!(str = qemuBuildSoundDevStr(sound, caps)))
goto error;
virCommandAddArg(cmd, str);
for (ii = 0 ; ii < sound->ncodecs ; ii++) {
virCommandAddArg(cmd, "-device");
- if (!(codecstr = qemuBuildSoundCodecStr(sound, sound->codecs[ii], qemuCaps))) {
+ if (!(codecstr = qemuBuildSoundCodecStr(sound, sound->codecs[ii], caps))) {
goto error;
}
0
};
virCommandAddArg(cmd, "-device");
- if (!(codecstr = qemuBuildSoundCodecStr(sound, &codec, qemuCaps))) {
+ if (!(codecstr = qemuBuildSoundCodecStr(sound, &codec, caps))) {
goto error;
}
virDomainWatchdogDefPtr watchdog = def->watchdog;
char *optstr;
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
virCommandAddArg(cmd, "-device");
- optstr = qemuBuildWatchdogDevStr(watchdog, qemuCaps);
+ optstr = qemuBuildWatchdogDevStr(watchdog, caps);
if (!optstr)
goto error;
} else {
virCommandAddArg(cmd, "-chardev");
if (!(devstr = qemuBuildChrChardevStr(&redirdev->source.chr,
redirdev->info.alias,
- qemuCaps))) {
+ caps))) {
goto error;
}
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
+ if (!qemuCapsGet(caps, QEMU_CAPS_DEVICE))
goto error;
virCommandAddArg(cmd, "-device");
- if (!(devstr = qemuBuildRedirdevDevStr(def, redirdev, qemuCaps)))
+ if (!(devstr = qemuBuildRedirdevDevStr(def, redirdev, caps)))
goto error;
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
_("booting from assigned devices is only"
" supported for PCI devices"));
goto error;
- } else if (!qemuCapsGet(qemuCaps, QEMU_CAPS_PCI_BOOTINDEX)) {
+ } else if (!qemuCapsGet(caps, QEMU_CAPS_PCI_BOOTINDEX)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("booting from assigned PCI devices is not"
" supported with this version of qemu"));
if (hostdev->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS &&
hostdev->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB) {
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
virCommandAddArg(cmd, "-device");
- if (!(devstr = qemuBuildUSBHostdevDevStr(hostdev, qemuCaps)))
+ if (!(devstr = qemuBuildUSBHostdevDevStr(hostdev, caps)))
goto error;
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
/* PCI */
if (hostdev->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS &&
hostdev->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI) {
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
char *configfd_name = NULL;
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_PCI_CONFIGFD)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_PCI_CONFIGFD)) {
int configfd = qemuOpenPCIConfig(hostdev);
if (configfd >= 0) {
}
}
virCommandAddArg(cmd, "-device");
- devstr = qemuBuildPCIHostdevDevStr(hostdev, configfd_name, qemuCaps);
+ devstr = qemuBuildPCIHostdevDevStr(hostdev, configfd_name, caps);
VIR_FREE(configfd_name);
if (!devstr)
goto error;
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
- } else if (qemuCapsGet(qemuCaps, QEMU_CAPS_PCIDEVICE)) {
+ } else if (qemuCapsGet(caps, QEMU_CAPS_PCIDEVICE)) {
virCommandAddArg(cmd, "-pcidevice");
if (!(devstr = qemuBuildPCIHostdevPCIDevStr(hostdev)))
goto error;
if (migrateFrom) {
virCommandAddArg(cmd, "-incoming");
if (STRPREFIX(migrateFrom, "tcp")) {
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_TCP)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_MIGRATE_QEMU_TCP)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("TCP migration is not supported with "
"this QEMU binary"));
}
virCommandAddArg(cmd, migrateFrom);
} else if (STREQ(migrateFrom, "stdio")) {
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_FD)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_MIGRATE_QEMU_FD)) {
virCommandAddArgFormat(cmd, "fd:%d", migrateFd);
virCommandPreserveFD(cmd, migrateFd);
- } else if (qemuCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_EXEC)) {
+ } else if (qemuCapsGet(caps, QEMU_CAPS_MIGRATE_QEMU_EXEC)) {
virCommandAddArg(cmd, "exec:cat");
virCommandSetInputFD(cmd, migrateFd);
- } else if (qemuCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_KVM_STDIO)) {
+ } else if (qemuCapsGet(caps, QEMU_CAPS_MIGRATE_KVM_STDIO)) {
virCommandAddArg(cmd, migrateFrom);
virCommandSetInputFD(cmd, migrateFd);
} else {
goto error;
}
} else if (STRPREFIX(migrateFrom, "exec")) {
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_EXEC)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_MIGRATE_QEMU_EXEC)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("EXEC migration is not supported "
"with this QEMU binary"));
}
virCommandAddArg(cmd, migrateFrom);
} else if (STRPREFIX(migrateFrom, "fd")) {
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_FD)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_MIGRATE_QEMU_FD)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("FD migration is not supported "
"with this QEMU binary"));
virCommandAddArg(cmd, migrateFrom);
virCommandPreserveFD(cmd, migrateFd);
} else if (STRPREFIX(migrateFrom, "unix")) {
- if (!qemuCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_UNIX)) {
+ if (!qemuCapsGet(caps, QEMU_CAPS_MIGRATE_QEMU_UNIX)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("UNIX migration is not supported "
"with this QEMU binary"));
virDomainMemballoonModelTypeToString(def->memballoon->model));
goto error;
}
- if (qemuCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
char *optstr;
virCommandAddArg(cmd, "-device");
- optstr = qemuBuildMemballoonDevStr(def->memballoon, qemuCaps);
+ optstr = qemuBuildMemballoonDevStr(def->memballoon, caps);
if (!optstr)
goto error;
virCommandAddArg(cmd, optstr);
VIR_FREE(optstr);
- } else if (qemuCapsGet(qemuCaps, QEMU_CAPS_BALLOON)) {
+ } else if (qemuCapsGet(caps, QEMU_CAPS_BALLOON)) {
virCommandAddArgList(cmd, "-balloon", "virtio", NULL);
}
}
*/
char *
qemuBuildChrDeviceStr(virDomainChrDefPtr serial,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
char *os_arch,
char *machine)
{
serial->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_SPAPRVIO) {
virBufferAsprintf(&cmd, "spapr-vty,chardev=char%s",
serial->info.alias);
- if (qemuBuildDeviceAddressStr(&cmd, &serial->info, qemuCaps) < 0)
+ if (qemuBuildDeviceAddressStr(&cmd, &serial->info, caps) < 0)
goto error;
}
} else
# include "capabilities.h"
# include "qemu_conf.h"
# include "qemu_domain.h"
+# include "qemu_capabilities.h"
/* Config type for XML import/export conversions */
# define QEMU_CONFIG_FORMAT_ARGV "qemu-argv"
virDomainDefPtr def,
virDomainChrSourceDefPtr monitor_chr,
bool monitor_json,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
const char *migrateFrom,
int migrateFd,
virDomainSnapshotObjPtr current_snapshot,
/* Generate string for arch-specific '-device' parameter */
char *
qemuBuildChrDeviceStr (virDomainChrDefPtr serial,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
char *os_arch,
char *machine);
/* With vlan == -1, use netdev syntax, else old hostnet */
char * qemuBuildHostNetStr(virDomainNetDefPtr net,
struct qemud_driver *driver,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
char type_sep,
int vlan,
const char *tapfd,
char * qemuBuildNicDevStr(virDomainNetDefPtr net,
int vlan,
int bootindex,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
char *qemuDeviceDriveHostAlias(virDomainDiskDefPtr disk,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
/* Both legacy & current support */
char *qemuBuildDriveStr(virConnectPtr conn,
virDomainDiskDefPtr disk,
bool bootable,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
char *qemuBuildFSStr(virDomainFSDefPtr fs,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
/* Current, best practice */
char * qemuBuildDriveDevStr(virDomainDefPtr def,
virDomainDiskDefPtr disk,
int bootindex,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
char * qemuBuildFSDevStr(virDomainFSDefPtr fs,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
/* Current, best practice */
char * qemuBuildControllerDevStr(virDomainDefPtr domainDef,
virDomainControllerDefPtr def,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
int *nusbcontroller);
char * qemuBuildWatchdogDevStr(virDomainWatchdogDefPtr dev,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
char * qemuBuildMemballoonDevStr(virDomainMemballoonDefPtr dev,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
char * qemuBuildUSBInputDevStr(virDomainInputDefPtr dev,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
char * qemuBuildSoundDevStr(virDomainSoundDefPtr sound,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
/* Legacy, pre device support */
char * qemuBuildPCIHostdevPCIDevStr(virDomainHostdevDefPtr dev);
/* Current, best practice */
char * qemuBuildPCIHostdevDevStr(virDomainHostdevDefPtr dev,
const char *configfd,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
int qemuOpenPCIConfig(virDomainHostdevDefPtr dev);
char * qemuBuildUSBHostdevUsbDevStr(virDomainHostdevDefPtr dev);
/* Current, best practice */
char * qemuBuildUSBHostdevDevStr(virDomainHostdevDefPtr dev,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
-char * qemuBuildHubDevStr(virDomainHubDefPtr dev, virBitmapPtr qemuCaps);
+char * qemuBuildHubDevStr(virDomainHubDefPtr dev, qemuCapsPtr caps);
char * qemuBuildRedirdevDevStr(virDomainDefPtr def,
virDomainRedirdevDefPtr dev,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
int qemuNetworkIfaceConnect(virDomainDefPtr def,
virConnectPtr conn,
struct qemud_driver *driver,
virDomainNetDefPtr net,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
ATTRIBUTE_NONNULL(2);
int qemuPhysIfaceConnect(virDomainDefPtr def,
struct qemud_driver *driver,
virDomainNetDefPtr net,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
enum virNetDevVPortProfileOp vmop);
int qemuOpenVhostNet(virDomainDefPtr def,
virDomainNetDefPtr net,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
int *vhostfd);
int qemudCanonicalizeMachine(struct qemud_driver *driver,
bool *monJSON);
int qemuDomainAssignAddresses(virDomainDefPtr def,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
virDomainObjPtr);
int qemuDomainAssignSpaprVIOAddresses(virDomainDefPtr def,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
int qemuDomainAssignPCIAddresses(virDomainDefPtr def,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
virDomainObjPtr obj);
qemuDomainPCIAddressSetPtr qemuDomainPCIAddressSetCreate(virDomainDefPtr def);
int qemuDomainPCIAddressReserveFunction(qemuDomainPCIAddressSetPtr addrs,
void qemuDomainPCIAddressSetFree(qemuDomainPCIAddressSetPtr addrs);
int qemuAssignDevicePCISlots(virDomainDefPtr def, qemuDomainPCIAddressSetPtr addrs);
-int qemuAssignDeviceAliases(virDomainDefPtr def, virBitmapPtr qemuCaps);
+int qemuAssignDeviceAliases(virDomainDefPtr def, qemuCapsPtr caps);
int qemuDomainNetVLAN(virDomainNetDefPtr def);
int qemuAssignDeviceNetAlias(virDomainDefPtr def, virDomainNetDefPtr net, int idx);
int qemuAssignDeviceDiskAlias(virDomainDefPtr vmdef,
virDomainDiskDefPtr def,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
int qemuAssignDeviceHostdevAlias(virDomainDefPtr def, virDomainHostdevDefPtr hostdev, int idx);
int qemuAssignDeviceControllerAlias(virDomainControllerDefPtr controller);
int qemuAssignDeviceRedirdevAlias(virDomainDefPtr def, virDomainRedirdevDefPtr redirdev, int idx);
{
qemuDomainObjPrivatePtr priv = data;
- qemuCapsFree(priv->qemuCaps);
+ virObjectUnref(priv->caps);
qemuDomainPCIAddressSetFree(priv->pciaddrs);
virDomainChrSourceDefFree(priv->monConfig);
virBufferAddLit(buf, " </vcpus>\n");
}
- if (priv->qemuCaps) {
+ if (priv->caps) {
int i;
virBufferAddLit(buf, " <qemuCaps>\n");
for (i = 0 ; i < QEMU_CAPS_LAST ; i++) {
- if (qemuCapsGet(priv->qemuCaps, i)) {
+ if (qemuCapsGet(priv->caps, i)) {
virBufferAsprintf(buf, " <flag name='%s'/>\n",
qemuCapsTypeToString(i));
}
char *tmp;
int n, i;
xmlNodePtr *nodes = NULL;
- virBitmapPtr qemuCaps = NULL;
+ qemuCapsPtr caps = NULL;
if (VIR_ALLOC(priv->monConfig) < 0) {
virReportOOMError();
goto error;
}
if (n > 0) {
- if (!(qemuCaps = qemuCapsNew()))
+ if (!(caps = qemuCapsNew()))
goto error;
for (i = 0 ; i < n ; i++) {
goto error;
}
VIR_FREE(str);
- qemuCapsSet(qemuCaps, flag);
+ qemuCapsSet(caps, flag);
}
}
- priv->qemuCaps = qemuCaps;
+ priv->caps = caps;
}
VIR_FREE(nodes);
virDomainChrSourceDefFree(priv->monConfig);
priv->monConfig = NULL;
VIR_FREE(nodes);
- qemuCapsFree(qemuCaps);
+ virObjectUnref(caps);
return -1;
}
# include "qemu_monitor.h"
# include "qemu_agent.h"
# include "qemu_conf.h"
-# include "bitmap.h"
+# include "qemu_capabilities.h"
# include "virconsole.h"
# define QEMU_EXPECTED_VIRT_TYPES \
qemuDomainPCIAddressSetPtr pciaddrs;
int persistentAddrs;
- virBitmapPtr qemuCaps;
+ qemuCapsPtr caps;
char *lockState;
bool fakeReboot;
}
} else {
#if HAVE_YAJL
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_MONITOR_JSON)) {
- if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_NO_SHUTDOWN)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_MONITOR_JSON)) {
+ if (!qemuCapsGet(priv->caps, QEMU_CAPS_NO_SHUTDOWN)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("Reboot is not supported with this QEMU binary"));
goto cleanup;
if ((vm->def->memballoon != NULL) &&
(vm->def->memballoon->model == VIR_DOMAIN_MEMBALLOON_MODEL_NONE)) {
info->memory = vm->def->mem.max_balloon;
- } else if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_BALLOON_EVENT)) {
+ } else if (qemuCapsGet(priv->caps, QEMU_CAPS_BALLOON_EVENT)) {
info->memory = vm->def->mem.cur_balloon;
} else if (qemuDomainJobAllowed(priv, QEMU_JOB_QUERY)) {
if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_QUERY) < 0)
qemuDomainObjPrivatePtr priv = vm->privateData;
int ret = -1;
- if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DUMP_GUEST_MEMORY)) {
+ if (!qemuCapsGet(priv->caps, QEMU_CAPS_DUMP_GUEST_MEMORY)) {
virReportError(VIR_ERR_NO_SUPPORT, "%s",
_("dump-guest-memory is not supported"));
return -1;
/* Refresh current memory based on balloon info if supported */
if ((vm->def->memballoon != NULL) &&
(vm->def->memballoon->model != VIR_DOMAIN_MEMBALLOON_MODEL_NONE) &&
- !qemuCapsGet(priv->qemuCaps, QEMU_CAPS_BALLOON_EVENT) &&
+ !qemuCapsGet(priv->caps, QEMU_CAPS_BALLOON_EVENT) &&
(virDomainObjIsActive(vm))) {
/* Don't delay if someone's using the monitor, just use
* existing most recent data instead */
struct qemud_driver *driver = conn->privateData;
virDomainDefPtr def = NULL;
virDomainChrSourceDef monConfig;
- virBitmapPtr qemuCaps = NULL;
+ qemuCapsPtr caps = NULL;
bool monitor_json = false;
virCommandPtr cmd = NULL;
char *ret = NULL;
if (qemuCapsExtractVersionInfo(def->emulator, def->os.arch,
false,
NULL,
- &qemuCaps) < 0)
+ &caps) < 0)
goto cleanup;
- monitor_json = qemuCapsGet(qemuCaps, QEMU_CAPS_MONITOR_JSON);
+ monitor_json = qemuCapsGet(caps, QEMU_CAPS_MONITOR_JSON);
if (qemuProcessPrepareMonitorChr(driver, &monConfig, def->name) < 0)
goto cleanup;
- if (qemuAssignDeviceAliases(def, qemuCaps) < 0)
+ if (qemuAssignDeviceAliases(def, caps) < 0)
goto cleanup;
if (!(cmd = qemuBuildCommandLine(conn, driver, def,
- &monConfig, monitor_json, qemuCaps,
+ &monConfig, monitor_json, caps,
NULL, -1, NULL, VIR_NETDEV_VPORT_PROFILE_OP_NO_OP)))
goto cleanup;
cleanup:
qemuDriverUnlock(driver);
- qemuCapsFree(qemuCaps);
+ virObjectUnref(caps);
virCommandFree(cmd);
virDomainDefFree(def);
return ret;
int external = 0;
qemuDomainObjPrivatePtr priv = vm->privateData;
- if (allow_reuse && !qemuCapsGet(priv->qemuCaps, QEMU_CAPS_TRANSACTION)) {
+ if (allow_reuse && !qemuCapsGet(priv->caps, QEMU_CAPS_TRANSACTION)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("reuse is not supported with this QEMU binary"));
goto cleanup;
}
if (active) {
if (external == 1 ||
- qemuCapsGet(priv->qemuCaps, QEMU_CAPS_TRANSACTION)) {
+ qemuCapsGet(priv->caps, QEMU_CAPS_TRANSACTION)) {
*flags |= VIR_DOMAIN_SNAPSHOT_CREATE_ATOMIC;
} else if (atomic && external > 1) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
goto cleanup;
}
}
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_TRANSACTION)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_TRANSACTION)) {
actions = virJSONValueNewArray();
if (!actions) {
virReportOOMError();
}
if (vm && (ret == 0 ||
- !qemuCapsGet(priv->qemuCaps, QEMU_CAPS_TRANSACTION))) {
+ !qemuCapsGet(priv->caps, QEMU_CAPS_TRANSACTION))) {
if (virDomainSaveStatus(driver->caps, driver->stateDir, vm) < 0 ||
(persist &&
virDomainSaveConfig(driver->configDir, vm->newDef) < 0))
}
priv = vm->privateData;
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKJOB_ASYNC)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_BLOCKJOB_ASYNC)) {
async = true;
- } else if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKJOB_SYNC)) {
+ } else if (!qemuCapsGet(priv->caps, QEMU_CAPS_BLOCKJOB_SYNC)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("block jobs not supported with this QEMU binary"));
goto cleanup;
goto cleanup;
}
priv = vm->privateData;
- if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DRIVE_IOTUNE)) {
+ if (!qemuCapsGet(priv->caps, QEMU_CAPS_DRIVE_IOTUNE)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("block I/O throttling not supported with this "
"QEMU binary"));
goto cleanup;
}
- if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_WAKEUP) &&
+ if (!qemuCapsGet(priv->caps, QEMU_CAPS_WAKEUP) &&
(target == VIR_NODE_SUSPEND_TARGET_MEM ||
target == VIR_NODE_SUSPEND_TARGET_HYBRID)) {
virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s",
priv = vm->privateData;
- if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_WAKEUP)) {
+ if (!qemuCapsGet(priv->caps, QEMU_CAPS_WAKEUP)) {
virReportError(VIR_ERR_OPERATION_INVALID, "%s",
_("Unable to wake up domain due to "
"missing system_wakeup monitor command"));
return -1;
}
- if (!(driveAlias = qemuDeviceDriveHostAlias(origdisk, priv->qemuCaps)))
+ if (!(driveAlias = qemuDeviceDriveHostAlias(origdisk, priv->caps)))
goto error;
qemuDomainObjEnterMonitorWithDriver(driver, vm);
return -1;
}
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
if (qemuDomainPCIAddressEnsureAddr(priv->pciaddrs, &disk->info) < 0)
goto error;
releaseaddr = true;
- if (qemuAssignDeviceDiskAlias(vm->def, disk, priv->qemuCaps) < 0)
+ if (qemuAssignDeviceDiskAlias(vm->def, disk, priv->caps) < 0)
goto error;
- if (!(drivestr = qemuBuildDriveStr(conn, disk, false, priv->qemuCaps)))
+ if (!(drivestr = qemuBuildDriveStr(conn, disk, false, priv->caps)))
goto error;
- if (!(devstr = qemuBuildDriveDevStr(NULL, disk, 0, priv->qemuCaps)))
+ if (!(devstr = qemuBuildDriveDevStr(NULL, disk, 0, priv->caps)))
goto error;
}
}
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
ret = qemuMonitorAddDrive(priv->mon, drivestr);
if (ret == 0) {
ret = qemuMonitorAddDevice(priv->mon, devstr);
VIR_FREE(devstr);
VIR_FREE(drivestr);
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE) &&
(disk->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) &&
releaseaddr &&
qemuDomainPCIAddressReleaseSlot(priv->pciaddrs,
return -1;
}
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
if (qemuDomainPCIAddressEnsureAddr(priv->pciaddrs, &controller->info) < 0)
goto cleanup;
releaseaddr = true;
if (controller->type == VIR_DOMAIN_CONTROLLER_TYPE_USB &&
controller->model == -1 &&
- !qemuCapsGet(priv->qemuCaps, QEMU_CAPS_PIIX3_USB_UHCI)) {
+ !qemuCapsGet(priv->caps, QEMU_CAPS_PIIX3_USB_UHCI)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("USB controller hotplug unsupported in this QEMU binary"));
goto cleanup;
}
- if (!(devstr = qemuBuildControllerDevStr(vm->def, controller, priv->qemuCaps, NULL))) {
+ if (!(devstr = qemuBuildControllerDevStr(vm->def, controller, priv->caps, NULL))) {
goto cleanup;
}
}
}
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
ret = qemuMonitorAddDevice(priv->mon, devstr);
} else {
ret = qemuMonitorAttachPCIDiskController(priv->mon,
cleanup:
if ((ret != 0) &&
- qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
+ qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE) &&
(controller->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) &&
releaseaddr &&
qemuDomainPCIAddressReleaseSlot(priv->pciaddrs,
goto error;
}
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
- if (qemuAssignDeviceDiskAlias(vm->def, disk, priv->qemuCaps) < 0)
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
+ if (qemuAssignDeviceDiskAlias(vm->def, disk, priv->caps) < 0)
goto error;
- if (!(devstr = qemuBuildDriveDevStr(vm->def, disk, 0, priv->qemuCaps)))
+ if (!(devstr = qemuBuildDriveDevStr(vm->def, disk, 0, priv->caps)))
goto error;
}
- if (!(drivestr = qemuBuildDriveStr(conn, disk, false, priv->qemuCaps)))
+ if (!(drivestr = qemuBuildDriveStr(conn, disk, false, priv->caps)))
goto error;
for (i = 0 ; i <= disk->info.addr.drive.controller ; i++) {
}
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
ret = qemuMonitorAddDrive(priv->mon, drivestr);
if (ret == 0) {
ret = qemuMonitorAddDevice(priv->mon, devstr);
goto error;
}
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
- if (qemuAssignDeviceDiskAlias(vm->def, disk, priv->qemuCaps) < 0)
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
+ if (qemuAssignDeviceDiskAlias(vm->def, disk, priv->caps) < 0)
goto error;
- if (!(drivestr = qemuBuildDriveStr(conn, disk, false, priv->qemuCaps)))
+ if (!(drivestr = qemuBuildDriveStr(conn, disk, false, priv->caps)))
goto error;
- if (!(devstr = qemuBuildDriveDevStr(NULL, disk, 0, priv->qemuCaps)))
+ if (!(devstr = qemuBuildDriveDevStr(NULL, disk, 0, priv->caps)))
goto error;
}
}
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
ret = qemuMonitorAddDrive(priv->mon, drivestr);
if (ret == 0) {
ret = qemuMonitorAddDevice(priv->mon, devstr);
goto cleanup;
}
- if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_HOST_NET_ADD)) {
+ if (!qemuCapsGet(priv->caps, QEMU_CAPS_HOST_NET_ADD)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("installed qemu version does not support host_net_add"));
goto cleanup;
*/
if (actualType == VIR_DOMAIN_NET_TYPE_NETWORK ||
driver->privileged ||
- (!qemuCapsGet (priv->qemuCaps, QEMU_CAPS_NETDEV_BRIDGE))) {
+ (!qemuCapsGet (priv->caps, QEMU_CAPS_NETDEV_BRIDGE))) {
if ((tapfd = qemuNetworkIfaceConnect(vm->def, conn, driver, net,
- priv->qemuCaps)) < 0)
+ priv->caps)) < 0)
goto cleanup;
iface_connected = true;
- if (qemuOpenVhostNet(vm->def, net, priv->qemuCaps, &vhostfd) < 0)
+ if (qemuOpenVhostNet(vm->def, net, priv->caps, &vhostfd) < 0)
goto cleanup;
}
} else if (actualType == VIR_DOMAIN_NET_TYPE_DIRECT) {
if ((tapfd = qemuPhysIfaceConnect(vm->def, driver, net,
- priv->qemuCaps,
+ priv->caps,
VIR_NETDEV_VPORT_PROFILE_OP_CREATE)) < 0)
goto cleanup;
iface_connected = true;
- if (qemuOpenVhostNet(vm->def, net, priv->qemuCaps, &vhostfd) < 0)
+ if (qemuOpenVhostNet(vm->def, net, priv->caps, &vhostfd) < 0)
goto cleanup;
}
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_NET_NAME) ||
- qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_NET_NAME) ||
+ qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
if (qemuAssignDeviceNetAlias(vm->def, net, -1) < 0)
goto cleanup;
}
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE) &&
qemuDomainPCIAddressEnsureAddr(priv->pciaddrs, &net->info) < 0)
goto cleanup;
releaseaddr = true;
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV) &&
- qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_NETDEV) &&
+ qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
vlan = -1;
} else {
vlan = qemuDomainNetVLAN(net);
goto no_memory;
}
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV) &&
- qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
- if (!(netstr = qemuBuildHostNetStr(net, driver, priv->qemuCaps,
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_NETDEV) &&
+ qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
+ if (!(netstr = qemuBuildHostNetStr(net, driver, priv->caps,
',', -1, tapfd_name,
vhostfd_name)))
goto cleanup;
} else {
- if (!(netstr = qemuBuildHostNetStr(net, driver, priv->qemuCaps,
+ if (!(netstr = qemuBuildHostNetStr(net, driver, priv->caps,
' ', vlan, tapfd_name,
vhostfd_name)))
goto cleanup;
}
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV) &&
- qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_NETDEV) &&
+ qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
if (qemuMonitorAddNetdev(priv->mon, netstr, tapfd, tapfd_name,
vhostfd, vhostfd_name) < 0) {
qemuDomainObjExitMonitorWithDriver(driver, vm);
goto cleanup;
}
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
- if (!(nicstr = qemuBuildNicDevStr(net, vlan, 0, priv->qemuCaps)))
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
+ if (!(nicstr = qemuBuildNicDevStr(net, vlan, 0, priv->caps)))
goto try_remove;
} else {
if (!(nicstr = qemuBuildNicStr(net, NULL, vlan)))
}
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
if (qemuMonitorAddDevice(priv->mon, nicstr) < 0) {
qemuDomainObjExitMonitorWithDriver(driver, vm);
virDomainAuditNet(vm, NULL, net, "attach", false);
} else {
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_NETDEV)) {
if (qemuMonitorSetLink(priv->mon, net->info.alias, VIR_DOMAIN_NET_INTERFACE_LINK_STATE_DOWN) < 0) {
qemuDomainObjExitMonitorWithDriver(driver, vm);
virDomainAuditNet(vm, NULL, net, "attach", false);
if (!ret) {
vm->def->nets[vm->def->nnets++] = net;
} else {
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE) &&
(net->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) &&
releaseaddr &&
qemuDomainPCIAddressReleaseSlot(priv->pciaddrs,
goto cleanup;
if (vlan < 0) {
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV) &&
- qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_NETDEV) &&
+ qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
char *netdev_name;
if (virAsprintf(&netdev_name, "host%s", net->info.alias) < 0)
goto no_memory;
&hostdev, 1) < 0)
return -1;
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
if (qemuAssignDeviceHostdevAlias(vm->def, hostdev, -1) < 0)
goto error;
if (qemuDomainPCIAddressEnsureAddr(priv->pciaddrs, hostdev->info) < 0)
goto error;
releaseaddr = true;
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_PCI_CONFIGFD)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_PCI_CONFIGFD)) {
configfd = qemuOpenPCIConfig(hostdev);
if (configfd >= 0) {
if (virAsprintf(&configfd_name, "fd-%s",
}
if (!(devstr = qemuBuildPCIHostdevDevStr(hostdev, configfd_name,
- priv->qemuCaps)))
+ priv->caps)))
goto error;
qemuDomainObjEnterMonitorWithDriver(driver, vm);
return 0;
error:
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE) &&
(hostdev->info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) &&
releaseaddr &&
qemuDomainPCIAddressReleaseSlot(priv->pciaddrs,
virDomainDefPtr def = vm->def;
char *devstr = NULL;
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
if (qemuAssignDeviceRedirdevAlias(vm->def, redirdev, -1) < 0)
goto error;
- if (!(devstr = qemuBuildRedirdevDevStr(def, redirdev, priv->qemuCaps)))
+ if (!(devstr = qemuBuildRedirdevDevStr(def, redirdev, priv->caps)))
goto error;
}
}
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE))
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE))
ret = qemuMonitorAddDevice(priv->mon, devstr);
else
goto error;
qemuDomainObjPrivatePtr priv = vm->privateData;
char *devstr = NULL;
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
if (qemuAssignDeviceHostdevAlias(vm->def, hostdev, -1) < 0)
goto error;
- if (!(devstr = qemuBuildUSBHostdevDevStr(hostdev, priv->qemuCaps)))
+ if (!(devstr = qemuBuildUSBHostdevDevStr(hostdev, priv->caps)))
goto error;
}
}
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE))
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE))
ret = qemuMonitorAddDevice(priv->mon, devstr);
else
ret = qemuMonitorAddUSBDeviceExact(priv->mon,
}
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
if (qemuMonitorDelDevice(priv->mon, detach->info.alias) < 0) {
qemuDomainObjExitMonitorWithDriver(driver, vm);
virDomainAuditDisk(vm, detach->src, NULL, "detach", false);
virDomainAuditDisk(vm, detach->src, NULL, "detach", true);
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE) &&
qemuDomainPCIAddressReleaseSlot(priv->pciaddrs,
detach->info.addr.pci.slot) < 0)
VIR_WARN("Unable to release PCI address on %s", dev->data.disk->src);
goto cleanup;
}
- if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (!qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
virReportError(VIR_ERR_OPERATION_FAILED,
_("Underlying qemu does not support %s disk removal"),
virDomainDiskBusTypeToString(dev->data.disk->bus));
goto cleanup;
}
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
if (qemuAssignDeviceControllerAlias(detach) < 0)
goto cleanup;
}
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
if (qemuMonitorDelDevice(priv->mon, detach->info.alias)) {
qemuDomainObjExitMonitorWithDriver(driver, vm);
goto cleanup;
virDomainControllerRemove(vm->def, idx);
virDomainControllerDefFree(detach);
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE) &&
qemuDomainPCIAddressReleaseSlot(priv->pciaddrs,
detach->info.addr.pci.slot) < 0)
VIR_WARN("Unable to release PCI address on controller");
}
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
ret = qemuMonitorDelDevice(priv->mon, detach->info->alias);
} else {
ret = qemuMonitorRemovePCIDevice(priv->mon, &detach->info->addr.pci);
ret = -1;
}
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE) &&
qemuDomainPCIAddressReleaseSlot(priv->pciaddrs,
detach->info->addr.pci.slot) < 0)
VIR_WARN("Unable to release PCI address on host device");
return -1;
}
- if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (!qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
virReportError(VIR_ERR_OPERATION_FAILED,
"%s", _("device cannot be detached with this QEMU version"));
return -1;
}
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
if (qemuMonitorDelDevice(priv->mon, detach->info.alias) < 0) {
qemuDomainObjExitMonitorWithDriver(driver, vm);
virDomainAuditNet(vm, detach, NULL, "detach", false);
}
}
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV) &&
- qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_NETDEV) &&
+ qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
if (qemuMonitorRemoveNetdev(priv->mon, hostnet_name) < 0) {
qemuDomainObjExitMonitorWithDriver(driver, vm);
virDomainAuditNet(vm, detach, NULL, "detach", false);
virDomainAuditNet(vm, detach, NULL, "detach", true);
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE) &&
qemuDomainPCIAddressReleaseSlot(priv->pciaddrs,
detach->info.addr.pci.slot) < 0)
VIR_WARN("Unable to release PCI address on NIC");
break;
case MIGRATION_DEST_UNIX:
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATE_QEMU_UNIX)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_MIGRATE_QEMU_UNIX)) {
ret = qemuMonitorMigrateToUnix(priv->mon, migrate_flags,
spec->dest.unix_socket.file);
} else {
if (!uribits)
return -1;
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATE_QEMU_FD))
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_MIGRATE_QEMU_FD))
spec.destType = MIGRATION_DEST_CONNECT_HOST;
else
spec.destType = MIGRATION_DEST_HOST;
driver, vm, st, NULLSTR(cookiein), cookieinlen,
cookieout, cookieoutlen, flags, resource);
- if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATE_QEMU_FD) &&
- !qemuCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATE_QEMU_UNIX) &&
- !qemuCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATE_QEMU_EXEC)) {
+ if (!qemuCapsGet(priv->caps, QEMU_CAPS_MIGRATE_QEMU_FD) &&
+ !qemuCapsGet(priv->caps, QEMU_CAPS_MIGRATE_QEMU_UNIX) &&
+ !qemuCapsGet(priv->caps, QEMU_CAPS_MIGRATE_QEMU_EXEC)) {
virReportError(VIR_ERR_OPERATION_FAILED, "%s",
_("Source qemu is too old to support tunnelled migration"));
return -1;
spec.fwdType = MIGRATION_FWD_STREAM;
spec.fwd.stream = st;
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATE_QEMU_FD)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_MIGRATE_QEMU_FD)) {
int fds[2];
spec.destType = MIGRATION_DEST_FD;
qemuDomainObjExitMonitorWithDriver(driver, vm);
}
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATE_QEMU_FD) &&
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_MIGRATE_QEMU_FD) &&
(!compressor || pipe(pipeFD) == 0)) {
/* All right! We can use fd migration, which means that qemu
* doesn't have to open() the file, so while we still have to
if (!compressor) {
const char *args[] = { "cat", NULL };
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATE_QEMU_FD) &&
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_MIGRATE_QEMU_FD) &&
priv->monConfig->type == VIR_DOMAIN_CHR_TYPE_UNIX) {
rc = qemuMonitorMigrateToFd(priv->mon,
QEMU_MONITOR_MIGRATE_BACKGROUND,
int qemuMonitorSetCapabilities(qemuMonitorPtr mon,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
int ret;
int json_hmp;
if (ret < 0)
goto cleanup;
- ret = qemuMonitorJSONCheckCommands(mon, qemuCaps, &json_hmp);
+ ret = qemuMonitorJSONCheckCommands(mon, caps, &json_hmp);
if (ret < 0)
goto cleanup;
mon->json_hmp = json_hmp > 0;
- ret = qemuMonitorJSONCheckEvents(mon, qemuCaps);
+ ret = qemuMonitorJSONCheckEvents(mon, caps);
if (ret < 0)
goto cleanup;
} else {
# include "internal.h"
+# include "qemu_capabilities.h"
# include "domain_conf.h"
# include "qemu_conf.h"
# include "bitmap.h"
void qemuMonitorClose(qemuMonitorPtr mon);
int qemuMonitorSetCapabilities(qemuMonitorPtr mon,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
int qemuMonitorCheckHMP(qemuMonitorPtr mon, const char *cmd);
*/
int
qemuMonitorJSONCheckCommands(qemuMonitorPtr mon,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
int *json_hmp)
{
int ret = -1;
if (STREQ(name, "human-monitor-command"))
*json_hmp = 1;
else if (STREQ(name, "system_wakeup"))
- qemuCapsSet(qemuCaps, QEMU_CAPS_WAKEUP);
+ qemuCapsSet(caps, QEMU_CAPS_WAKEUP);
else if (STREQ(name, "transaction"))
- qemuCapsSet(qemuCaps, QEMU_CAPS_TRANSACTION);
+ qemuCapsSet(caps, QEMU_CAPS_TRANSACTION);
else if (STREQ(name, "block_job_cancel"))
- qemuCapsSet(qemuCaps, QEMU_CAPS_BLOCKJOB_SYNC);
+ qemuCapsSet(caps, QEMU_CAPS_BLOCKJOB_SYNC);
else if (STREQ(name, "block-job-cancel"))
- qemuCapsSet(qemuCaps, QEMU_CAPS_BLOCKJOB_ASYNC);
+ qemuCapsSet(caps, QEMU_CAPS_BLOCKJOB_ASYNC);
else if (STREQ(name, "dump-guest-memory"))
- qemuCapsSet(qemuCaps, QEMU_CAPS_DUMP_GUEST_MEMORY);
+ qemuCapsSet(caps, QEMU_CAPS_DUMP_GUEST_MEMORY);
}
ret = 0;
int
qemuMonitorJSONCheckEvents(qemuMonitorPtr mon,
- virBitmapPtr qemuCaps)
+ qemuCapsPtr caps)
{
int ret = -1;
virJSONValuePtr cmd = qemuMonitorJSONMakeCommand("query-events", NULL);
goto cleanup;
if (STREQ(name, "BALLOON_CHANGE"))
- qemuCapsSet(qemuCaps, QEMU_CAPS_BALLOON_EVENT);
+ qemuCapsSet(caps, QEMU_CAPS_BALLOON_EVENT);
}
ret = 0;
int qemuMonitorJSONSetCapabilities(qemuMonitorPtr mon);
int qemuMonitorJSONCheckCommands(qemuMonitorPtr mon,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
int *json_hmp);
int qemuMonitorJSONCheckEvents(qemuMonitorPtr mon,
- virBitmapPtr qemuCaps);
+ qemuCapsPtr caps);
int qemuMonitorJSONStartCPUs(qemuMonitorPtr mon,
virConnectPtr conn);
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- ret = qemuMonitorSetCapabilities(priv->mon, priv->qemuCaps);
+ ret = qemuMonitorSetCapabilities(priv->mon, priv->caps);
qemuDomainObjExitMonitorWithDriver(driver, vm);
error:
static int
qemuProcessFindCharDevicePTYsMonitor(virDomainObjPtr vm,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
virHashTablePtr paths)
{
- bool chardevfmt = qemuCapsGet(qemuCaps, QEMU_CAPS_CHARDEV);
+ bool chardevfmt = qemuCapsGet(caps, QEMU_CAPS_CHARDEV);
if (qemuProcessLookupPTYs(vm->def->serials, vm->def->nserials,
paths, chardevfmt) < 0)
static int
qemuProcessWaitForMonitor(struct qemud_driver* driver,
virDomainObjPtr vm,
- virBitmapPtr qemuCaps,
+ qemuCapsPtr caps,
off_t pos)
{
char *buf = NULL;
VIR_DEBUG("qemuMonitorGetPtyPaths returned %i", ret);
if (ret == 0)
- ret = qemuProcessFindCharDevicePTYsMonitor(vm, qemuCaps, paths);
+ ret = qemuProcessFindCharDevicePTYsMonitor(vm, caps, paths);
cleanup:
virHashFree(paths);
if (def->nets[i]->linkstate == VIR_DOMAIN_NET_INTERFACE_LINK_STATE_DOWN) {
VIR_DEBUG("Setting link state: %s", def->nets[i]->info.alias);
- if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV)) {
+ if (!qemuCapsGet(priv->caps, QEMU_CAPS_NETDEV)) {
virReportError(VIR_ERR_NO_SUPPORT, "%s",
_("Setting of link state is not supported by this qemu"));
return -1;
if (ret < 0)
goto cleanup;
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
int i;
for (i = 0 ; i < vm->def->ndisks ; i++) {
/* If upgrading from old libvirtd we won't have found any
* caps in the domain status, so re-query them
*/
- if (!priv->qemuCaps &&
+ if (!priv->caps &&
qemuCapsExtractVersionInfo(obj->def->emulator, obj->def->os.arch,
false,
NULL,
- &priv->qemuCaps) < 0)
+ &priv->caps) < 0)
goto error;
/* In case the domain shutdown while we were not running,
goto endjob;
}
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE))
- if ((qemuDomainAssignAddresses(obj->def, priv->qemuCaps, obj)) < 0)
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE))
+ if ((qemuDomainAssignAddresses(obj->def, priv->caps, obj)) < 0)
goto error;
if (virSecurityManagerReserveLabel(driver->securityManager, obj->def, obj->pid) < 0)
* to remove danger of it ending up running twice if
* user tries to start it again later
*/
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_NO_SHUTDOWN)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_NO_SHUTDOWN)) {
/* If we couldn't get the monitor and qemu supports
* no-shutdown, we can safely say that the domain
* crashed ... */
}
VIR_DEBUG("Determining emulator version");
- qemuCapsFree(priv->qemuCaps);
- priv->qemuCaps = NULL;
+ virObjectUnref(priv->caps);
+ priv->caps = NULL;
if (qemuCapsExtractVersionInfo(vm->def->emulator, vm->def->os.arch,
true,
NULL,
- &priv->qemuCaps) < 0)
+ &priv->caps) < 0)
goto cleanup;
- if (qemuAssignDeviceAliases(vm->def, priv->qemuCaps) < 0)
+ if (qemuAssignDeviceAliases(vm->def, priv->caps) < 0)
goto cleanup;
VIR_DEBUG("Checking for CDROM and floppy presence");
if (qemuProcessPrepareMonitorChr(driver, priv->monConfig, vm->def->name) < 0)
goto cleanup;
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_MONITOR_JSON))
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_MONITOR_JSON))
priv->monJSON = 1;
else
priv->monJSON = 0;
* we also need to populate the PCi address set cache for later
* use in hotplug
*/
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
VIR_DEBUG("Assigning domain PCI addresses");
- if ((qemuDomainAssignAddresses(vm->def, priv->qemuCaps, vm)) < 0)
+ if ((qemuDomainAssignAddresses(vm->def, priv->caps, vm)) < 0)
goto cleanup;
}
VIR_DEBUG("Building emulator command line");
if (!(cmd = qemuBuildCommandLine(conn, driver, vm->def, priv->monConfig,
- priv->monJSON != 0, priv->qemuCaps,
+ priv->monJSON != 0, priv->caps,
migrateFrom, stdin_fd, snapshot, vmop)))
goto cleanup;
goto cleanup;
VIR_DEBUG("Waiting for monitor to show up");
- if (qemuProcessWaitForMonitor(driver, vm, priv->qemuCaps, pos) < 0)
+ if (qemuProcessWaitForMonitor(driver, vm, priv->caps, pos) < 0)
goto cleanup;
/* Failure to connect to agent shouldn't be fatal */
/* If we have -device, then addresses are assigned explicitly.
* If not, then we have to detect dynamic ones here */
- if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (!qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
VIR_DEBUG("Determining domain device PCI addresses");
if (qemuProcessInitPCIAddresses(driver, vm) < 0)
goto cleanup;
virDomainObjSetState(vm, VIR_DOMAIN_SHUTOFF, reason);
VIR_FREE(priv->vcpupids);
priv->nvcpupids = 0;
- qemuCapsFree(priv->qemuCaps);
- priv->qemuCaps = NULL;
+ virObjectUnref(priv->caps);
+ priv->caps = NULL;
VIR_FREE(priv->pidfile);
/* The "release" hook cleans up additional resources */
goto cleanup;
VIR_DEBUG("Determining emulator version");
- qemuCapsFree(priv->qemuCaps);
- priv->qemuCaps = NULL;
+ virObjectUnref(priv->caps);
+ priv->caps = NULL;
if (qemuCapsExtractVersionInfo(vm->def->emulator,
vm->def->os.arch,
false,
NULL,
- &priv->qemuCaps) < 0)
+ &priv->caps) < 0)
goto cleanup;
VIR_DEBUG("Preparing monitor state");
* we also need to populate the PCi address set cache for later
* use in hotplug
*/
- if (qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
VIR_DEBUG("Assigning domain PCI addresses");
- if ((qemuDomainAssignAddresses(vm->def, priv->qemuCaps, vm)) < 0)
+ if ((qemuDomainAssignAddresses(vm->def, priv->caps, vm)) < 0)
goto cleanup;
}
vm->pid = pid;
VIR_DEBUG("Waiting for monitor to show up");
- if (qemuProcessWaitForMonitor(driver, vm, priv->qemuCaps, -1) < 0)
+ if (qemuProcessWaitForMonitor(driver, vm, priv->caps, -1) < 0)
goto cleanup;
/* Failure to connect to agent shouldn't be fatal */
/* If we have -device, then addresses are assigned explicitly.
* If not, then we have to detect dynamic ones here */
- if (!qemuCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (!qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
VIR_DEBUG("Determining domain device PCI addresses");
if (qemuProcessInitPCIAddresses(driver, vm) < 0)
goto cleanup;
struct testInfo {
const char *name;
- virBitmapPtr flags;
+ qemuCapsPtr flags;
unsigned int version;
unsigned int is_kvm;
unsigned int kvm_version;
};
-static void printMismatchedFlags(virBitmapPtr got,
- virBitmapPtr expect)
+static void printMismatchedFlags(qemuCapsPtr got,
+ qemuCapsPtr expect)
{
int i;
char *path = NULL;
char *help = NULL;
unsigned int version, is_kvm, kvm_version;
- virBitmapPtr flags = NULL;
+ qemuCapsPtr flags = NULL;
int ret = -1;
char *got = NULL;
char *expected = NULL;
goto cleanup;
}
- got = virBitmapString(flags);
- expected = virBitmapString(info->flags);
+ got = qemuCapsFlagsString(flags);
+ expected = qemuCapsFlagsString(info->flags);
if (!got || !expected)
goto cleanup;
cleanup:
VIR_FREE(path);
VIR_FREE(help);
- qemuCapsFree(flags);
+ virObjectUnref(flags);
VIR_FREE(got);
VIR_FREE(expected);
return ret;
if (virtTestRun("QEMU Help String Parsing " name, \
1, testHelpStrParsing, &info) < 0) \
ret = -1; \
- qemuCapsFree(info.flags); \
+ virObjectUnref(info.flags); \
} while (0)
DO_TEST("qemu-0.9.1", 9001, 0, 0,
static int testCompareXMLToArgvFiles(const char *xml,
const char *cmdline,
- virBitmapPtr extraFlags,
+ qemuCapsPtr extraFlags,
const char *migrateFrom,
int migrateFd,
virQemuXML2ArgvTestFlags flags)
struct testInfo {
const char *name;
- virBitmapPtr extraFlags;
+ qemuCapsPtr extraFlags;
const char *migrateFrom;
int migrateFd;
unsigned int flags;
if (virtTestRun("QEMU XML-2-ARGV " name, \
1, testCompareXMLToArgvHelper, &info) < 0) \
ret = -1; \
- qemuCapsFree(info.extraFlags); \
+ virObjectUnref(info.extraFlags); \
} while (0)
# define DO_TEST(name, ...) \
static int testCompareXMLToArgvFiles(const char *xml,
const char *cmdline,
- virBitmapPtr extraFlags,
+ qemuCapsPtr extraFlags,
const char *migrateFrom,
int migrateFd,
bool json,
struct testInfo {
const char *name;
- virBitmapPtr extraFlags;
+ qemuCapsPtr extraFlags;
const char *migrateFrom;
int migrateFd;
bool json;
if (virtTestRun("QEMU XML-2-ARGV " name, \
1, testCompareXMLToArgvHelper, &info) < 0) \
ret = -1; \
- qemuCapsFree(info.extraFlags); \
+ virObjectUnref(info.extraFlags); \
} while (0)
# define DO_TEST(name, expectError, ...) \
projects / people / liuw / libxenctrl-split / libvirt.git / commitdiff