External/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2025-03-07 17:28:15 +00:00
Code

qemu: Rename QEMUD_CMD_FLAG_* to QEMU_CAPS_*

Browse Source 
The new names comply more with the fact that they are all members of
enum qemuCapsFlags.
This commit is contained in:
Jiri Denemark 2011-02-07 15:54:08 +01:00
parent 40641f2a63
commit 21642e82b1
9 changed files with 788 additions and 788 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

132
src/qemu/qemu_capabilities.c
View File

@ -400,7 +400,7 @@ qemuCapsProbeCPUModels(const char *qemu,
} }
cmd = virCommandNewArgList(qemu, "-cpu", "?", NULL); cmd = virCommandNewArgList(qemu, "-cpu", "?", NULL);
if (qemuCmdFlags & QEMUD_CMD_FLAG_NODEFCONFIG) if (qemuCmdFlags & QEMU_CAPS_NODEFCONFIG)
virCommandAddArg(cmd, "-nodefconfig"); virCommandAddArg(cmd, "-nodefconfig");
virCommandAddEnvPassCommon(cmd); virCommandAddEnvPassCommon(cmd);
virCommandSetOutputBuffer(cmd, &output); virCommandSetOutputBuffer(cmd, &output);
@ -559,7 +559,7 @@ qemuCapsInitGuest(virCapsPtr caps,
goto error; goto error;
if (qemuCapsExtractVersionInfo(binary, info->arch, NULL, &qemuCmdFlags) < 0 || if (qemuCapsExtractVersionInfo(binary, info->arch, NULL, &qemuCmdFlags) < 0 ||
((qemuCmdFlags & QEMUD_CMD_FLAG_BOOTINDEX) && ((qemuCmdFlags & QEMU_CAPS_BOOTINDEX) &&
!virCapabilitiesAddGuestFeature(guest, "deviceboot", 1, 0))) !virCapabilitiesAddGuestFeature(guest, "deviceboot", 1, 0)))
goto error; goto error;
@ -791,119 +791,119 @@ qemuCapsComputeCmdFlags(const char *help,
const char *p; const char *p;
if (strstr(help, "-no-kqemu")) if (strstr(help, "-no-kqemu"))
flags |= QEMUD_CMD_FLAG_KQEMU; flags |= QEMU_CAPS_KQEMU;
if (strstr(help, "-enable-kqemu")) if (strstr(help, "-enable-kqemu"))
flags |= QEMUD_CMD_FLAG_ENABLE_KQEMU; flags |= QEMU_CAPS_ENABLE_KQEMU;
if (strstr(help, "-no-kvm")) if (strstr(help, "-no-kvm"))
flags |= QEMUD_CMD_FLAG_KVM; flags |= QEMU_CAPS_KVM;
if (strstr(help, "-enable-kvm")) if (strstr(help, "-enable-kvm"))
flags |= QEMUD_CMD_FLAG_ENABLE_KVM; flags |= QEMU_CAPS_ENABLE_KVM;
if (strstr(help, "-no-reboot")) if (strstr(help, "-no-reboot"))
flags |= QEMUD_CMD_FLAG_NO_REBOOT; flags |= QEMU_CAPS_NO_REBOOT;
if (strstr(help, "-name")) { if (strstr(help, "-name")) {
flags |= QEMUD_CMD_FLAG_NAME; flags |= QEMU_CAPS_NAME;
if (strstr(help, ",process=")) if (strstr(help, ",process="))
flags |= QEMUD_CMD_FLAG_NAME_PROCESS; flags |= QEMU_CAPS_NAME_PROCESS;
} }
if (strstr(help, "-uuid")) if (strstr(help, "-uuid"))
flags |= QEMUD_CMD_FLAG_UUID; flags |= QEMU_CAPS_UUID;
if (strstr(help, "-xen-domid")) if (strstr(help, "-xen-domid"))
flags |= QEMUD_CMD_FLAG_XEN_DOMID; flags |= QEMU_CAPS_XEN_DOMID;
else if (strstr(help, "-domid")) else if (strstr(help, "-domid"))
flags |= QEMUD_CMD_FLAG_DOMID; flags |= QEMU_CAPS_DOMID;
if (strstr(help, "-drive")) { if (strstr(help, "-drive")) {
flags |= QEMUD_CMD_FLAG_DRIVE; flags |= QEMU_CAPS_DRIVE;
if (strstr(help, "cache=") && if (strstr(help, "cache=") &&
!strstr(help, "cache=on|off")) !strstr(help, "cache=on|off"))
flags |= QEMUD_CMD_FLAG_DRIVE_CACHE_V2; flags |= QEMU_CAPS_DRIVE_CACHE_V2;
if (strstr(help, "format=")) if (strstr(help, "format="))
flags |= QEMUD_CMD_FLAG_DRIVE_FORMAT; flags |= QEMU_CAPS_DRIVE_FORMAT;
if (strstr(help, "readonly=")) if (strstr(help, "readonly="))
flags |= QEMUD_CMD_FLAG_DRIVE_READONLY; flags |= QEMU_CAPS_DRIVE_READONLY;
if (strstr(help, "aio=threads|native")) if (strstr(help, "aio=threads|native"))
flags |= QEMUD_CMD_FLAG_DRIVE_AIO; flags |= QEMU_CAPS_DRIVE_AIO;
} }
if ((p = strstr(help, "-vga")) && !strstr(help, "-std-vga")) { if ((p = strstr(help, "-vga")) && !strstr(help, "-std-vga")) {
const char *nl = strstr(p, "\n"); const char *nl = strstr(p, "\n");
flags |= QEMUD_CMD_FLAG_VGA; flags |= QEMU_CAPS_VGA;
if (strstr(p, "|qxl")) if (strstr(p, "|qxl"))
flags |= QEMUD_CMD_FLAG_VGA_QXL; flags |= QEMU_CAPS_VGA_QXL;
if ((p = strstr(p, "|none")) && p < nl) if ((p = strstr(p, "|none")) && p < nl)
flags |= QEMUD_CMD_FLAG_VGA_NONE; flags |= QEMU_CAPS_VGA_NONE;
} }
if (strstr(help, "-spice")) if (strstr(help, "-spice"))
flags |= QEMUD_CMD_FLAG_SPICE; flags |= QEMU_CAPS_SPICE;
if (strstr(help, "boot=on")) if (strstr(help, "boot=on"))
flags |= QEMUD_CMD_FLAG_DRIVE_BOOT; flags |= QEMU_CAPS_DRIVE_BOOT;
if (strstr(help, "serial=s")) if (strstr(help, "serial=s"))
flags |= QEMUD_CMD_FLAG_DRIVE_SERIAL; flags |= QEMU_CAPS_DRIVE_SERIAL;
if (strstr(help, "-pcidevice")) if (strstr(help, "-pcidevice"))
flags |= QEMUD_CMD_FLAG_PCIDEVICE; flags |= QEMU_CAPS_PCIDEVICE;
if (strstr(help, "-mem-path")) if (strstr(help, "-mem-path"))
flags |= QEMUD_CMD_FLAG_MEM_PATH; flags |= QEMU_CAPS_MEM_PATH;
if (strstr(help, "-chardev")) { if (strstr(help, "-chardev")) {
flags |= QEMUD_CMD_FLAG_CHARDEV; flags |= QEMU_CAPS_CHARDEV;
if (strstr(help, "-chardev spicevmc")) if (strstr(help, "-chardev spicevmc"))
flags |= QEMUD_CMD_FLAG_CHARDEV_SPICEVMC; flags |= QEMU_CAPS_CHARDEV_SPICEVMC;
} }
if (strstr(help, "-balloon")) if (strstr(help, "-balloon"))
flags |= QEMUD_CMD_FLAG_BALLOON; flags |= QEMU_CAPS_BALLOON;
if (strstr(help, "-device")) { if (strstr(help, "-device")) {
flags |= QEMUD_CMD_FLAG_DEVICE; flags |= QEMU_CAPS_DEVICE;
/* /*
* When -device was introduced, qemu already supported drive's * When -device was introduced, qemu already supported drive's
* readonly option but didn't advertise that. * readonly option but didn't advertise that.
*/ */
flags |= QEMUD_CMD_FLAG_DRIVE_READONLY; flags |= QEMU_CAPS_DRIVE_READONLY;
} }
if (strstr(help, "-nodefconfig")) if (strstr(help, "-nodefconfig"))
flags |= QEMUD_CMD_FLAG_NODEFCONFIG; flags |= QEMU_CAPS_NODEFCONFIG;
/* The trailing ' ' is important to avoid a bogus match */ /* The trailing ' ' is important to avoid a bogus match */
if (strstr(help, "-rtc ")) if (strstr(help, "-rtc "))
flags |= QEMUD_CMD_FLAG_RTC; flags |= QEMU_CAPS_RTC;
/* to wit */ /* to wit */
if (strstr(help, "-rtc-td-hack")) if (strstr(help, "-rtc-td-hack"))
flags |= QEMUD_CMD_FLAG_RTC_TD_HACK; flags |= QEMU_CAPS_RTC_TD_HACK;
if (strstr(help, "-no-hpet")) if (strstr(help, "-no-hpet"))
flags |= QEMUD_CMD_FLAG_NO_HPET; flags |= QEMU_CAPS_NO_HPET;
if (strstr(help, "-no-kvm-pit-reinjection")) if (strstr(help, "-no-kvm-pit-reinjection"))
flags |= QEMUD_CMD_FLAG_NO_KVM_PIT; flags |= QEMU_CAPS_NO_KVM_PIT;
if (strstr(help, "-tdf")) if (strstr(help, "-tdf"))
flags |= QEMUD_CMD_FLAG_TDF; flags |= QEMU_CAPS_TDF;
if (strstr(help, "-enable-nesting")) if (strstr(help, "-enable-nesting"))
flags |= QEMUD_CMD_FLAG_NESTING; flags |= QEMU_CAPS_NESTING;
if (strstr(help, ",menu=on")) if (strstr(help, ",menu=on"))
flags |= QEMUD_CMD_FLAG_BOOT_MENU; flags |= QEMU_CAPS_BOOT_MENU;
if (strstr(help, "-fsdev")) if (strstr(help, "-fsdev"))
flags |= QEMUD_CMD_FLAG_FSDEV; flags |= QEMU_CAPS_FSDEV;
if (strstr(help, "-smbios type")) if (strstr(help, "-smbios type"))
flags |= QEMUD_CMD_FLAG_SMBIOS_TYPE; flags |= QEMU_CAPS_SMBIOS_TYPE;
if (strstr(help, "-netdev")) { if (strstr(help, "-netdev")) {
/* Disable -netdev on 0.12 since although it exists, /* Disable -netdev on 0.12 since although it exists,
* the corresponding netdev_add/remove monitor commands * the corresponding netdev_add/remove monitor commands
* do not, and we need them to be able todo hotplug */ * do not, and we need them to be able todo hotplug */
if (version >= 13000) if (version >= 13000)
flags |= QEMUD_CMD_FLAG_NETDEV; flags |= QEMU_CAPS_NETDEV;
} }
if (strstr(help, "-sdl")) if (strstr(help, "-sdl"))
flags |= QEMUD_CMD_FLAG_SDL; flags |= QEMU_CAPS_SDL;
if (strstr(help, "cores=") && if (strstr(help, "cores=") &&
strstr(help, "threads=") && strstr(help, "threads=") &&
strstr(help, "sockets=")) strstr(help, "sockets="))
flags |= QEMUD_CMD_FLAG_SMP_TOPOLOGY; flags |= QEMU_CAPS_SMP_TOPOLOGY;
if (version >= 9000) if (version >= 9000)
flags |= QEMUD_CMD_FLAG_VNC_COLON; flags |= QEMU_CAPS_VNC_COLON;
if (is_kvm && (version >= 10000 || kvm_version >= 74)) if (is_kvm && (version >= 10000 || kvm_version >= 74))
flags |= QEMUD_CMD_FLAG_VNET_HDR; flags |= QEMU_CAPS_VNET_HDR;
if (is_kvm && strstr(help, ",vhost=")) { if (is_kvm && strstr(help, ",vhost=")) {
flags |= QEMUD_CMD_FLAG_VNET_HOST; flags |= QEMU_CAPS_VNET_HOST;
} }
/* /*
@ -919,22 +919,22 @@ qemuCapsComputeCmdFlags(const char *help,
* while waiting for data, so pretend it doesn't exist * while waiting for data, so pretend it doesn't exist
*/ */
if (version >= 10000) { if (version >= 10000) {
flags |= QEMUD_CMD_FLAG_MIGRATE_QEMU_TCP; flags |= QEMU_CAPS_MIGRATE_QEMU_TCP;
flags |= QEMUD_CMD_FLAG_MIGRATE_QEMU_EXEC; flags |= QEMU_CAPS_MIGRATE_QEMU_EXEC;
if (version >= 12000) { if (version >= 12000) {
flags |= QEMUD_CMD_FLAG_MIGRATE_QEMU_UNIX; flags |= QEMU_CAPS_MIGRATE_QEMU_UNIX;
flags |= QEMUD_CMD_FLAG_MIGRATE_QEMU_FD; flags |= QEMU_CAPS_MIGRATE_QEMU_FD;
} }
} else if (kvm_version >= 79) { } else if (kvm_version >= 79) {
flags |= QEMUD_CMD_FLAG_MIGRATE_QEMU_TCP; flags |= QEMU_CAPS_MIGRATE_QEMU_TCP;
if (kvm_version >= 80) if (kvm_version >= 80)
flags |= QEMUD_CMD_FLAG_MIGRATE_QEMU_EXEC; flags |= QEMU_CAPS_MIGRATE_QEMU_EXEC;
} else if (kvm_version > 0) { } else if (kvm_version > 0) {
flags |= QEMUD_CMD_FLAG_MIGRATE_KVM_STDIO; flags |= QEMU_CAPS_MIGRATE_KVM_STDIO;
} }
if (version >= 10000) if (version >= 10000)
flags |= QEMUD_CMD_FLAG_0_10; flags |= QEMU_CAPS_0_10;
/* While JSON mode was available in 0.12.0, it was too /* While JSON mode was available in 0.12.0, it was too
* incomplete to contemplate using. The 0.13.0 release * incomplete to contemplate using. The 0.13.0 release
@ -943,7 +943,7 @@ qemuCapsComputeCmdFlags(const char *help,
* the downside. * the downside.
*/ */
if (version >= 13000) if (version >= 13000)
flags |= QEMUD_CMD_FLAG_MONITOR_JSON; flags |= QEMU_CAPS_MONITOR_JSON;
return flags; return flags;
} }
@ -1098,26 +1098,26 @@ qemuCapsParseDeviceStr(const char *str, unsigned long long *flags)
{ {
/* Which devices exist. */ /* Which devices exist. */
if (strstr(str, "name \"hda-duplex\"")) if (strstr(str, "name \"hda-duplex\""))
*flags |= QEMUD_CMD_FLAG_HDA_DUPLEX; *flags |= QEMU_CAPS_HDA_DUPLEX;
if (strstr(str, "name \"ccid-card-emulated\"")) if (strstr(str, "name \"ccid-card-emulated\""))
*flags |= QEMUD_CMD_FLAG_CCID_EMULATED; *flags |= QEMU_CAPS_CCID_EMULATED;
if (strstr(str, "name \"ccid-card-passthru\"")) if (strstr(str, "name \"ccid-card-passthru\""))
*flags |= QEMUD_CMD_FLAG_CCID_PASSTHRU; *flags |= QEMU_CAPS_CCID_PASSTHRU;
/* Prefer -chardev spicevmc (detected earlier) over -device spicevmc */ /* Prefer -chardev spicevmc (detected earlier) over -device spicevmc */
if (!(*flags & QEMUD_CMD_FLAG_CHARDEV_SPICEVMC) && if (!(*flags & QEMU_CAPS_CHARDEV_SPICEVMC) &&
strstr(str, "name \"spicevmc\"")) strstr(str, "name \"spicevmc\""))
*flags |= QEMUD_CMD_FLAG_DEVICE_SPICEVMC; *flags |= QEMU_CAPS_DEVICE_SPICEVMC;
/* Features of given devices. */ /* Features of given devices. */
if (strstr(str, "pci-assign.configfd")) if (strstr(str, "pci-assign.configfd"))
*flags |= QEMUD_CMD_FLAG_PCI_CONFIGFD; *flags |= QEMU_CAPS_PCI_CONFIGFD;
if (strstr(str, "virtio-blk-pci.bootindex")) { if (strstr(str, "virtio-blk-pci.bootindex")) {
*flags |= QEMUD_CMD_FLAG_BOOTINDEX; *flags |= QEMU_CAPS_BOOTINDEX;
if (strstr(str, "pci-assign.bootindex")) if (strstr(str, "pci-assign.bootindex"))
*flags |= QEMUD_CMD_FLAG_PCI_BOOTINDEX; *flags |= QEMU_CAPS_PCI_BOOTINDEX;
} }
if (strstr(str, "virtio-net-pci.tx=")) if (strstr(str, "virtio-net-pci.tx="))
*flags |= QEMUD_CMD_FLAG_VIRTIO_TX_ALG; *flags |= QEMU_CAPS_VIRTIO_TX_ALG;
return 0; return 0;
} }
@ -1161,12 +1161,12 @@ int qemuCapsExtractVersionInfo(const char *qemu, const char *arch,
/* Currently only x86_64 and i686 support PCI-multibus. */ /* Currently only x86_64 and i686 support PCI-multibus. */
if (STREQLEN(arch, "x86_64", 6) || if (STREQLEN(arch, "x86_64", 6) ||
STREQLEN(arch, "i686", 4)) { STREQLEN(arch, "i686", 4)) {
flags |= QEMUD_CMD_FLAG_PCI_MULTIBUS; flags |= QEMU_CAPS_PCI_MULTIBUS;
} }
/* qemuCapsExtractDeviceStr will only set additional flags if qemu /* qemuCapsExtractDeviceStr will only set additional flags if qemu
* understands the 0.13.0+ notion of "-device driver,". */ * understands the 0.13.0+ notion of "-device driver,". */
if ((flags & QEMUD_CMD_FLAG_DEVICE) && if ((flags & QEMU_CAPS_DEVICE) &&
strstr(help, "-device driver,?") && strstr(help, "-device driver,?") &&
qemuCapsExtractDeviceStr(qemu, &flags) < 0) qemuCapsExtractDeviceStr(qemu, &flags) < 0)
goto cleanup; goto cleanup;

122
src/qemu/qemu_capabilities.h
View File

@ -28,71 +28,71 @@
/* Internal flags to keep track of qemu command line capabilities */ /* Internal flags to keep track of qemu command line capabilities */
enum qemuCapsFlags { enum qemuCapsFlags {
QEMUD_CMD_FLAG_KQEMU = (1 << 0), /* Whether KQEMU is compiled in */ QEMU_CAPS_KQEMU = (1 << 0), /* Whether KQEMU is compiled in */
QEMUD_CMD_FLAG_VNC_COLON = (1 << 1), /* Does the VNC take just port, or address + display */ QEMU_CAPS_VNC_COLON = (1 << 1), /* Does the VNC take just port, or address + display */
QEMUD_CMD_FLAG_NO_REBOOT = (1 << 2), /* Is the -no-reboot flag available */ QEMU_CAPS_NO_REBOOT = (1 << 2), /* Is the -no-reboot flag available */
QEMUD_CMD_FLAG_DRIVE = (1 << 3), /* Is the new -drive arg available */ QEMU_CAPS_DRIVE = (1 << 3), /* Is the new -drive arg available */
QEMUD_CMD_FLAG_DRIVE_BOOT = (1 << 4), /* Does -drive support boot=on */ QEMU_CAPS_DRIVE_BOOT = (1 << 4), /* Does -drive support boot=on */
QEMUD_CMD_FLAG_NAME = (1 << 5), /* Is the -name flag available */ QEMU_CAPS_NAME = (1 << 5), /* Is the -name flag available */
QEMUD_CMD_FLAG_UUID = (1 << 6), /* Is the -uuid flag available */ QEMU_CAPS_UUID = (1 << 6), /* Is the -uuid flag available */
QEMUD_CMD_FLAG_DOMID = (1 << 7), /* Xenner only, special -domid flag available */ QEMU_CAPS_DOMID = (1 << 7), /* Xenner only, special -domid flag available */
QEMUD_CMD_FLAG_VNET_HDR = (1 << 8), QEMU_CAPS_VNET_HDR = (1 << 8),
QEMUD_CMD_FLAG_MIGRATE_KVM_STDIO = (1 << 9), /* Original migration code from KVM. Also had tcp, but we can't use that QEMU_CAPS_MIGRATE_KVM_STDIO = (1 << 9), /* Original migration code from KVM. Also had tcp, but we can't use that
* since it had a design bug blocking the entire monitor console */ * since it had a design bug blocking the entire monitor console */
QEMUD_CMD_FLAG_MIGRATE_QEMU_TCP = (1 << 10), /* New migration syntax after merge to QEMU with TCP transport */ QEMU_CAPS_MIGRATE_QEMU_TCP = (1 << 10), /* New migration syntax after merge to QEMU with TCP transport */
QEMUD_CMD_FLAG_MIGRATE_QEMU_EXEC = (1 << 11), /* New migration syntax after merge to QEMU with EXEC transport */ QEMU_CAPS_MIGRATE_QEMU_EXEC = (1 << 11), /* New migration syntax after merge to QEMU with EXEC transport */
QEMUD_CMD_FLAG_DRIVE_CACHE_V2 = (1 << 12), /* Is the cache= flag wanting new v2 values */ QEMU_CAPS_DRIVE_CACHE_V2 = (1 << 12), /* Is the cache= flag wanting new v2 values */
QEMUD_CMD_FLAG_KVM = (1 << 13), /* Whether KVM is compiled in */ QEMU_CAPS_KVM = (1 << 13), /* Whether KVM is compiled in */
QEMUD_CMD_FLAG_DRIVE_FORMAT = (1 << 14), /* Is -drive format= avail */ QEMU_CAPS_DRIVE_FORMAT = (1 << 14), /* Is -drive format= avail */
QEMUD_CMD_FLAG_VGA = (1 << 15), /* Is -vga avail */ QEMU_CAPS_VGA = (1 << 15), /* Is -vga avail */
/* features added in qemu-0.10.0 or later */ /* features added in qemu-0.10.0 or later */
QEMUD_CMD_FLAG_0_10 = (1 << 16), QEMU_CAPS_0_10 = (1 << 16),
QEMUD_CMD_FLAG_NET_NAME = QEMUD_CMD_FLAG_0_10, /* -net ...,name=str */ QEMU_CAPS_NET_NAME = QEMU_CAPS_0_10, /* -net ...,name=str */
QEMUD_CMD_FLAG_HOST_NET_ADD = QEMUD_CMD_FLAG_0_10, /* host_net_add monitor command */ QEMU_CAPS_HOST_NET_ADD = QEMU_CAPS_0_10, /* host_net_add monitor command */
QEMUD_CMD_FLAG_PCIDEVICE = (1 << 17), /* PCI device assignment only supported by qemu-kvm */ QEMU_CAPS_PCIDEVICE = (1 << 17), /* PCI device assignment only supported by qemu-kvm */
QEMUD_CMD_FLAG_MEM_PATH = (1 << 18), /* mmap'ped guest backing supported */ QEMU_CAPS_MEM_PATH = (1 << 18), /* mmap'ped guest backing supported */
QEMUD_CMD_FLAG_DRIVE_SERIAL = (1 << 19), /* -driver serial= available */ QEMU_CAPS_DRIVE_SERIAL = (1 << 19), /* -driver serial= available */
QEMUD_CMD_FLAG_XEN_DOMID = (1 << 20), /* -xen-domid (new style xen integration) */ QEMU_CAPS_XEN_DOMID = (1 << 20), /* -xen-domid (new style xen integration) */
QEMUD_CMD_FLAG_MIGRATE_QEMU_UNIX = (1 << 21), /* Does qemu support unix domain sockets for migration? */ QEMU_CAPS_MIGRATE_QEMU_UNIX = (1 << 21), /* Does qemu support unix domain sockets for migration? */
QEMUD_CMD_FLAG_CHARDEV = (1 << 22), /* Is the new -chardev arg available */ QEMU_CAPS_CHARDEV = (1 << 22), /* Is the new -chardev arg available */
QEMUD_CMD_FLAG_ENABLE_KVM = (1 << 23), /* Is the -enable-kvm flag available to "enable KVM full virtualization support" */ QEMU_CAPS_ENABLE_KVM = (1 << 23), /* Is the -enable-kvm flag available to "enable KVM full virtualization support" */
QEMUD_CMD_FLAG_MONITOR_JSON = (1 << 24), /* JSON mode for monitor */ QEMU_CAPS_MONITOR_JSON = (1 << 24), /* JSON mode for monitor */
QEMUD_CMD_FLAG_BALLOON = (1 << 25), /* -balloon available */ QEMU_CAPS_BALLOON = (1 << 25), /* -balloon available */
QEMUD_CMD_FLAG_DEVICE = (1 << 26), /* Is the new -device arg available */ QEMU_CAPS_DEVICE = (1 << 26), /* Is the new -device arg available */
QEMUD_CMD_FLAG_SDL = (1 << 27), /* Is the new -sdl arg available */ QEMU_CAPS_SDL = (1 << 27), /* Is the new -sdl arg available */
QEMUD_CMD_FLAG_SMP_TOPOLOGY = (1 << 28), /* Is sockets=s,cores=c,threads=t available for -smp? */ QEMU_CAPS_SMP_TOPOLOGY = (1 << 28), /* Is sockets=s,cores=c,threads=t available for -smp? */
QEMUD_CMD_FLAG_NETDEV = (1 << 29), /* The -netdev flag & netdev_add/remove monitor commands */ QEMU_CAPS_NETDEV = (1 << 29), /* The -netdev flag & netdev_add/remove monitor commands */
QEMUD_CMD_FLAG_RTC = (1 << 30), /* The -rtc flag for clock options */ QEMU_CAPS_RTC = (1 << 30), /* The -rtc flag for clock options */
QEMUD_CMD_FLAG_VNET_HOST = (1LL << 31), /* vnet-host support is available in qemu */ QEMU_CAPS_VNET_HOST = (1LL << 31), /* vnet-host support is available in qemu */
QEMUD_CMD_FLAG_RTC_TD_HACK = (1LL << 32), /* -rtc-td-hack available */ QEMU_CAPS_RTC_TD_HACK = (1LL << 32), /* -rtc-td-hack available */
QEMUD_CMD_FLAG_NO_HPET = (1LL << 33), /* -no-hpet flag is supported */ QEMU_CAPS_NO_HPET = (1LL << 33), /* -no-hpet flag is supported */
QEMUD_CMD_FLAG_NO_KVM_PIT = (1LL << 34), /* -no-kvm-pit-reinjection supported */ QEMU_CAPS_NO_KVM_PIT = (1LL << 34), /* -no-kvm-pit-reinjection supported */
QEMUD_CMD_FLAG_TDF = (1LL << 35), /* -tdf flag (user-mode pit catchup) */ QEMU_CAPS_TDF = (1LL << 35), /* -tdf flag (user-mode pit catchup) */
QEMUD_CMD_FLAG_PCI_CONFIGFD = (1LL << 36), /* pci-assign.configfd */ QEMU_CAPS_PCI_CONFIGFD = (1LL << 36), /* pci-assign.configfd */
QEMUD_CMD_FLAG_NODEFCONFIG = (1LL << 37), /* -nodefconfig */ QEMU_CAPS_NODEFCONFIG = (1LL << 37), /* -nodefconfig */
QEMUD_CMD_FLAG_BOOT_MENU = (1LL << 38), /* -boot menu=on support */ QEMU_CAPS_BOOT_MENU = (1LL << 38), /* -boot menu=on support */
QEMUD_CMD_FLAG_ENABLE_KQEMU = (1LL << 39), /* -enable-kqemu flag */ QEMU_CAPS_ENABLE_KQEMU = (1LL << 39), /* -enable-kqemu flag */
QEMUD_CMD_FLAG_FSDEV = (1LL << 40), /* -fstype filesystem passthrough */ QEMU_CAPS_FSDEV = (1LL << 40), /* -fstype filesystem passthrough */
QEMUD_CMD_FLAG_NESTING = (1LL << 41), /* -enable-nesting (SVM/VMX) */ QEMU_CAPS_NESTING = (1LL << 41), /* -enable-nesting (SVM/VMX) */
QEMUD_CMD_FLAG_NAME_PROCESS = (1LL << 42), /* Is -name process= available */ QEMU_CAPS_NAME_PROCESS = (1LL << 42), /* Is -name process= available */
QEMUD_CMD_FLAG_DRIVE_READONLY= (1LL << 43), /* -drive readonly=on|off */ QEMU_CAPS_DRIVE_READONLY= (1LL << 43), /* -drive readonly=on|off */
QEMUD_CMD_FLAG_SMBIOS_TYPE = (1LL << 44), /* Is -smbios type= available */ QEMU_CAPS_SMBIOS_TYPE = (1LL << 44), /* Is -smbios type= available */
QEMUD_CMD_FLAG_VGA_QXL = (1LL << 45), /* The 'qxl' arg for '-vga' */ QEMU_CAPS_VGA_QXL = (1LL << 45), /* The 'qxl' arg for '-vga' */
QEMUD_CMD_FLAG_SPICE = (1LL << 46), /* Is -spice avail */ QEMU_CAPS_SPICE = (1LL << 46), /* Is -spice avail */
QEMUD_CMD_FLAG_VGA_NONE = (1LL << 47), /* The 'none' arg for '-vga' */ QEMU_CAPS_VGA_NONE = (1LL << 47), /* The 'none' arg for '-vga' */
QEMUD_CMD_FLAG_MIGRATE_QEMU_FD = (1LL << 48), /* -incoming fd:n */ QEMU_CAPS_MIGRATE_QEMU_FD = (1LL << 48), /* -incoming fd:n */
QEMUD_CMD_FLAG_BOOTINDEX = (1LL << 49), /* -device bootindex property */ QEMU_CAPS_BOOTINDEX = (1LL << 49), /* -device bootindex property */
QEMUD_CMD_FLAG_HDA_DUPLEX = (1LL << 50), /* -device hda-duplex */ QEMU_CAPS_HDA_DUPLEX = (1LL << 50), /* -device hda-duplex */
QEMUD_CMD_FLAG_DRIVE_AIO = (1LL << 51), /* -drive aio= supported */ QEMU_CAPS_DRIVE_AIO = (1LL << 51), /* -drive aio= supported */
QEMUD_CMD_FLAG_PCI_MULTIBUS = (1LL << 52), /* bus=pci.0 vs bus=pci */ QEMU_CAPS_PCI_MULTIBUS = (1LL << 52), /* bus=pci.0 vs bus=pci */
QEMUD_CMD_FLAG_PCI_BOOTINDEX = (1LL << 53), /* pci-assign.bootindex */ QEMU_CAPS_PCI_BOOTINDEX = (1LL << 53), /* pci-assign.bootindex */
QEMUD_CMD_FLAG_CCID_EMULATED = (1LL << 54), /* -device ccid-card-emulated */ QEMU_CAPS_CCID_EMULATED = (1LL << 54), /* -device ccid-card-emulated */
QEMUD_CMD_FLAG_CCID_PASSTHRU = (1LL << 55), /* -device ccid-card-passthru */ QEMU_CAPS_CCID_PASSTHRU = (1LL << 55), /* -device ccid-card-passthru */
QEMUD_CMD_FLAG_CHARDEV_SPICEVMC = (1LL << 56), /* newer -chardev spicevmc */ QEMU_CAPS_CHARDEV_SPICEVMC = (1LL << 56), /* newer -chardev spicevmc */
QEMUD_CMD_FLAG_DEVICE_SPICEVMC = (1LL << 57), /* older -device spicevmc*/ QEMU_CAPS_DEVICE_SPICEVMC = (1LL << 57), /* older -device spicevmc*/
QEMUD_CMD_FLAG_VIRTIO_TX_ALG = (1LL << 58), /* -device virtio-net-pci,tx=string */ QEMU_CAPS_VIRTIO_TX_ALG = (1LL << 58), /* -device virtio-net-pci,tx=string */
}; };
virCapsPtr qemuCapsInit(virCapsPtr old_caps); virCapsPtr qemuCapsInit(virCapsPtr old_caps);

248
src/qemu/qemu_command.c
View File

@ -119,7 +119,7 @@ qemuPhysIfaceConnect(virConnectPtr conn,
int vnet_hdr = 0; int vnet_hdr = 0;
int err; int err;
if (qemuCmdFlags & QEMUD_CMD_FLAG_VNET_HDR && if (qemuCmdFlags & QEMU_CAPS_VNET_HDR &&
net->model && STREQ(net->model, "virtio")) net->model && STREQ(net->model, "virtio"))
vnet_hdr = 1; vnet_hdr = 1;
@ -241,7 +241,7 @@ qemuNetworkIfaceConnect(virConnectPtr conn,
template_ifname = 1; template_ifname = 1;
} }
if (qemuCmdFlags & QEMUD_CMD_FLAG_VNET_HDR && if (qemuCmdFlags & QEMU_CAPS_VNET_HDR &&
net->model && STREQ(net->model, "virtio")) net->model && STREQ(net->model, "virtio"))
vnet_hdr = 1; vnet_hdr = 1;
@ -319,9 +319,9 @@ qemuOpenVhostNet(virDomainNetDefPtr net,
/* If qemu doesn't support vhost-net mode (including the -netdev command /* If qemu doesn't support vhost-net mode (including the -netdev command
* option), don't try to open the device. * option), don't try to open the device.
*/ */
if (!(qemuCmdFlags & QEMUD_CMD_FLAG_VNET_HOST && if (!(qemuCmdFlags & QEMU_CAPS_VNET_HOST &&
qemuCmdFlags & QEMUD_CMD_FLAG_NETDEV && qemuCmdFlags & QEMU_CAPS_NETDEV &&
qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE)) { qemuCmdFlags & QEMU_CAPS_DEVICE)) {
if (net->driver.virtio.name == VIR_DOMAIN_NET_BACKEND_TYPE_VHOST) { if (net->driver.virtio.name == VIR_DOMAIN_NET_BACKEND_TYPE_VHOST) {
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("vhost-net is not supported with " "%s", _("vhost-net is not supported with "
@ -407,7 +407,7 @@ char *qemuDeviceDriveHostAlias(virDomainDiskDefPtr disk,
{ {
char *ret; char *ret;
if (qemudCmdFlags & QEMUD_CMD_FLAG_DEVICE) { if (qemudCmdFlags & QEMU_CAPS_DEVICE) {
if (virAsprintf(&ret, "%s%s", QEMU_DRIVE_HOST_PREFIX, disk->info.alias) < 0) { if (virAsprintf(&ret, "%s%s", QEMU_DRIVE_HOST_PREFIX, disk->info.alias) < 0) {
virReportOOMError(); virReportOOMError();
return NULL; return NULL;
@ -503,8 +503,8 @@ no_memory:
int int
qemuAssignDeviceDiskAlias(virDomainDiskDefPtr def, unsigned long long qemuCmdFlags) qemuAssignDeviceDiskAlias(virDomainDiskDefPtr def, unsigned long long qemuCmdFlags)
{ {
if (qemuCmdFlags & QEMUD_CMD_FLAG_DRIVE) { if (qemuCmdFlags & QEMU_CAPS_DRIVE) {
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) if (qemuCmdFlags & QEMU_CAPS_DEVICE)
return qemuAssignDeviceDiskAliasCustom(def); return qemuAssignDeviceDiskAliasCustom(def);
else else
return qemuAssignDeviceDiskAliasFixed(def); return qemuAssignDeviceDiskAliasFixed(def);
@ -592,15 +592,15 @@ qemuAssignDeviceAliases(virDomainDefPtr def, unsigned long long qemuCmdFlags)
if (qemuAssignDeviceDiskAlias(def->disks[i], qemuCmdFlags) < 0) if (qemuAssignDeviceDiskAlias(def->disks[i], qemuCmdFlags) < 0)
return -1; return -1;
} }
if ((qemuCmdFlags & QEMUD_CMD_FLAG_NET_NAME) || if ((qemuCmdFlags & QEMU_CAPS_NET_NAME) ||
(qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE)) { (qemuCmdFlags & QEMU_CAPS_DEVICE)) {
for (i = 0; i < def->nnets ; i++) { for (i = 0; i < def->nnets ; i++) {
if (qemuAssignDeviceNetAlias(def, def->nets[i], i) < 0) if (qemuAssignDeviceNetAlias(def, def->nets[i], i) < 0)
return -1; return -1;
} }
} }
if (!(qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE)) if (!(qemuCmdFlags & QEMU_CAPS_DEVICE))
return 0; return 0;
for (i = 0; i < def->nfss ; i++) { for (i = 0; i < def->nfss ; i++) {
@ -728,7 +728,7 @@ qemuDomainAssignPCIAddresses(virDomainDefPtr def)
&qemuCmdFlags) < 0) &qemuCmdFlags) < 0)
goto cleanup; goto cleanup;
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) { if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
if (!(addrs = qemuDomainPCIAddressSetCreate(def))) if (!(addrs = qemuDomainPCIAddressSetCreate(def)))
goto cleanup; goto cleanup;
@ -1151,7 +1151,7 @@ qemuBuildDeviceAddressStr(virBufferPtr buf,
* When QEMU grows support for > 1 PCI domain, then pci.0 change * When QEMU grows support for > 1 PCI domain, then pci.0 change
* to pciNN.0 where NN is the domain number * to pciNN.0 where NN is the domain number
*/ */
if (qemuCmdFlags & QEMUD_CMD_FLAG_PCI_MULTIBUS) if (qemuCmdFlags & QEMU_CAPS_PCI_MULTIBUS)
virBufferVSprintf(buf, ",bus=pci.0,addr=0x%x", info->addr.pci.slot); virBufferVSprintf(buf, ",bus=pci.0,addr=0x%x", info->addr.pci.slot);
else else
virBufferVSprintf(buf, ",bus=pci,addr=0x%x", info->addr.pci.slot); virBufferVSprintf(buf, ",bus=pci,addr=0x%x", info->addr.pci.slot);
@ -1311,7 +1311,7 @@ qemuBuildDriveStr(virDomainDiskDefPtr disk,
virBufferVSprintf(&opt, "file=%s,", disk->src); virBufferVSprintf(&opt, "file=%s,", disk->src);
} }
} }
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) if (qemuCmdFlags & QEMU_CAPS_DEVICE)
virBufferAddLit(&opt, "if=none"); virBufferAddLit(&opt, "if=none");
else else
virBufferVSprintf(&opt, "if=%s", bus); virBufferVSprintf(&opt, "if=%s", bus);
@ -1319,7 +1319,7 @@ qemuBuildDriveStr(virDomainDiskDefPtr disk,
if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM) if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM)
virBufferAddLit(&opt, ",media=cdrom"); virBufferAddLit(&opt, ",media=cdrom");
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) { if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
virBufferVSprintf(&opt, ",id=%s%s", QEMU_DRIVE_HOST_PREFIX, disk->info.alias); virBufferVSprintf(&opt, ",id=%s%s", QEMU_DRIVE_HOST_PREFIX, disk->info.alias);
} else { } else {
if (busid == -1 && unitid == -1) { if (busid == -1 && unitid == -1) {
@ -1337,14 +1337,14 @@ qemuBuildDriveStr(virDomainDiskDefPtr disk,
disk->bus != VIR_DOMAIN_DISK_BUS_IDE) disk->bus != VIR_DOMAIN_DISK_BUS_IDE)
virBufferAddLit(&opt, ",boot=on"); virBufferAddLit(&opt, ",boot=on");
if (disk->readonly && if (disk->readonly &&
qemuCmdFlags & QEMUD_CMD_FLAG_DRIVE_READONLY) qemuCmdFlags & QEMU_CAPS_DRIVE_READONLY)
virBufferAddLit(&opt, ",readonly=on"); virBufferAddLit(&opt, ",readonly=on");
if (disk->driverType && *disk->driverType != '\0' && if (disk->driverType && *disk->driverType != '\0' &&
disk->type != VIR_DOMAIN_DISK_TYPE_DIR && disk->type != VIR_DOMAIN_DISK_TYPE_DIR &&
qemuCmdFlags & QEMUD_CMD_FLAG_DRIVE_FORMAT) qemuCmdFlags & QEMU_CAPS_DRIVE_FORMAT)
virBufferVSprintf(&opt, ",format=%s", disk->driverType); virBufferVSprintf(&opt, ",format=%s", disk->driverType);
if (disk->serial && if (disk->serial &&
(qemuCmdFlags & QEMUD_CMD_FLAG_DRIVE_SERIAL)) { (qemuCmdFlags & QEMU_CAPS_DRIVE_SERIAL)) {
if (qemuSafeSerialParamValue(disk->serial) < 0) if (qemuSafeSerialParamValue(disk->serial) < 0)
goto error; goto error;
virBufferVSprintf(&opt, ",serial=%s", disk->serial); virBufferVSprintf(&opt, ",serial=%s", disk->serial);
@ -1352,7 +1352,7 @@ qemuBuildDriveStr(virDomainDiskDefPtr disk,
if (disk->cachemode) { if (disk->cachemode) {
const char *mode = const char *mode =
(qemuCmdFlags & QEMUD_CMD_FLAG_DRIVE_CACHE_V2) ? (qemuCmdFlags & QEMU_CAPS_DRIVE_CACHE_V2) ?
qemuDiskCacheV2TypeToString(disk->cachemode) : qemuDiskCacheV2TypeToString(disk->cachemode) :
qemuDiskCacheV1TypeToString(disk->cachemode); qemuDiskCacheV1TypeToString(disk->cachemode);
@ -1361,7 +1361,7 @@ qemuBuildDriveStr(virDomainDiskDefPtr disk,
virBufferAddLit(&opt, ",cache=off"); virBufferAddLit(&opt, ",cache=off");
} }
if (qemuCmdFlags & QEMUD_CMD_FLAG_MONITOR_JSON) { if (qemuCmdFlags & QEMU_CAPS_MONITOR_JSON) {
if (disk->error_policy) { if (disk->error_policy) {
virBufferVSprintf(&opt, ",werror=%s,rerror=%s", virBufferVSprintf(&opt, ",werror=%s,rerror=%s",
virDomainDiskErrorPolicyTypeToString(disk->error_policy), virDomainDiskErrorPolicyTypeToString(disk->error_policy),
@ -1370,7 +1370,7 @@ qemuBuildDriveStr(virDomainDiskDefPtr disk,
} }
if (disk->iomode) { if (disk->iomode) {
if (qemuCmdFlags & QEMUD_CMD_FLAG_DRIVE_AIO) { if (qemuCmdFlags & QEMU_CAPS_DRIVE_AIO) {
virBufferVSprintf(&opt, ",aio=%s", virBufferVSprintf(&opt, ",aio=%s",
virDomainDiskIoTypeToString(disk->iomode)); virDomainDiskIoTypeToString(disk->iomode));
} else { } else {
@ -1436,7 +1436,7 @@ qemuBuildDriveDevStr(virDomainDiskDefPtr disk,
} }
virBufferVSprintf(&opt, ",drive=%s%s", QEMU_DRIVE_HOST_PREFIX, disk->info.alias); virBufferVSprintf(&opt, ",drive=%s%s", QEMU_DRIVE_HOST_PREFIX, disk->info.alias);
virBufferVSprintf(&opt, ",id=%s", disk->info.alias); virBufferVSprintf(&opt, ",id=%s", disk->info.alias);
if (disk->bootIndex && (qemuCmdFlags & QEMUD_CMD_FLAG_BOOTINDEX)) if (disk->bootIndex && (qemuCmdFlags & QEMU_CAPS_BOOTINDEX))
virBufferVSprintf(&opt, ",bootindex=%d", disk->bootIndex); virBufferVSprintf(&opt, ",bootindex=%d", disk->bootIndex);
if (virBufferError(&opt)) { if (virBufferError(&opt)) {
@ -1622,7 +1622,7 @@ qemuBuildNicDevStr(virDomainNetDefPtr net,
virBufferAdd(&buf, nic, strlen(nic)); virBufferAdd(&buf, nic, strlen(nic));
if (usingVirtio && net->driver.virtio.txmode) { if (usingVirtio && net->driver.virtio.txmode) {
if (qemuCmdFlags & QEMUD_CMD_FLAG_VIRTIO_TX_ALG) { if (qemuCmdFlags & QEMU_CAPS_VIRTIO_TX_ALG) {
virBufferAddLit(&buf, ",tx="); virBufferAddLit(&buf, ",tx=");
switch (net->driver.virtio.txmode) { switch (net->driver.virtio.txmode) {
case VIR_DOMAIN_NET_VIRTIO_TX_MODE_IOTHREAD: case VIR_DOMAIN_NET_VIRTIO_TX_MODE_IOTHREAD:
@ -1657,7 +1657,7 @@ qemuBuildNicDevStr(virDomainNetDefPtr net,
net->mac[4], net->mac[5]); net->mac[4], net->mac[5]);
if (qemuBuildDeviceAddressStr(&buf, &net->info, qemuCmdFlags) < 0) if (qemuBuildDeviceAddressStr(&buf, &net->info, qemuCmdFlags) < 0)
goto error; goto error;
if (net->bootIndex && (qemuCmdFlags & QEMUD_CMD_FLAG_BOOTINDEX)) if (net->bootIndex && (qemuCmdFlags & QEMU_CAPS_BOOTINDEX))
virBufferVSprintf(&buf, ",bootindex=%d", net->bootIndex); virBufferVSprintf(&buf, ",bootindex=%d", net->bootIndex);
if (virBufferError(&buf)) { if (virBufferError(&buf)) {
@ -2134,7 +2134,7 @@ qemuBuildChrChardevStr(virDomainChrSourceDefPtr dev, const char *alias,
break; break;
case VIR_DOMAIN_CHR_TYPE_SPICEVMC: case VIR_DOMAIN_CHR_TYPE_SPICEVMC:
if (!(qemuCmdFlags & QEMUD_CMD_FLAG_CHARDEV_SPICEVMC)) { if (!(qemuCmdFlags & QEMU_CAPS_CHARDEV_SPICEVMC)) {
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("spicevmc not supported in this QEMU binary")); _("spicevmc not supported in this QEMU binary"));
goto error; goto error;
@ -2249,7 +2249,7 @@ qemuBuildVirtioSerialPortDevStr(virDomainChrDefPtr dev,
virBuffer buf = VIR_BUFFER_INITIALIZER; virBuffer buf = VIR_BUFFER_INITIALIZER;
if (dev->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CONSOLE) if (dev->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CONSOLE)
virBufferAddLit(&buf, "virtconsole"); virBufferAddLit(&buf, "virtconsole");
else if ((qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE_SPICEVMC) && else if ((qemuCmdFlags & QEMU_CAPS_DEVICE_SPICEVMC) &&
dev->source.type == VIR_DOMAIN_CHR_TYPE_SPICEVMC) dev->source.type == VIR_DOMAIN_CHR_TYPE_SPICEVMC)
virBufferAddLit(&buf, "spicevmc"); virBufferAddLit(&buf, "spicevmc");
else else
@ -2282,7 +2282,7 @@ qemuBuildVirtioSerialPortDevStr(virDomainChrDefPtr dev,
dev->target.name); dev->target.name);
goto error; goto error;
} }
if ((qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE_SPICEVMC) && if ((qemuCmdFlags & QEMU_CAPS_DEVICE_SPICEVMC) &&
dev->source.type == VIR_DOMAIN_CHR_TYPE_SPICEVMC) { dev->source.type == VIR_DOMAIN_CHR_TYPE_SPICEVMC) {
virBufferVSprintf(&buf, ",id=%s", dev->info.alias); virBufferVSprintf(&buf, ",id=%s", dev->info.alias);
} else { } else {
@ -2613,7 +2613,7 @@ qemuBuildSmpArgStr(const virDomainDefPtr def,
virBufferVSprintf(&buf, "%u", def->vcpus); virBufferVSprintf(&buf, "%u", def->vcpus);
if ((qemuCmdFlags & QEMUD_CMD_FLAG_SMP_TOPOLOGY)) { if ((qemuCmdFlags & QEMU_CAPS_SMP_TOPOLOGY)) {
if (def->vcpus != def->maxvcpus) if (def->vcpus != def->maxvcpus)
virBufferVSprintf(&buf, ",maxcpus=%u", def->maxvcpus); virBufferVSprintf(&buf, ",maxcpus=%u", def->maxvcpus);
/* sockets, cores, and threads are either all zero /* sockets, cores, and threads are either all zero
@ -2696,26 +2696,26 @@ qemuBuildCommandLine(virConnectPtr conn,
* do not use boot=on for drives when not using KVM since this * do not use boot=on for drives when not using KVM since this
* is not supported at all in upstream QEmu. * is not supported at all in upstream QEmu.
*/ */
if ((qemuCmdFlags & QEMUD_CMD_FLAG_KVM) && if ((qemuCmdFlags & QEMU_CAPS_KVM) &&
(def->virtType == VIR_DOMAIN_VIRT_QEMU) && (def->virtType == VIR_DOMAIN_VIRT_QEMU) &&
(qemuCmdFlags & QEMUD_CMD_FLAG_DRIVE_BOOT)) (qemuCmdFlags & QEMU_CAPS_DRIVE_BOOT))
qemuCmdFlags -= QEMUD_CMD_FLAG_DRIVE_BOOT; qemuCmdFlags -= QEMU_CAPS_DRIVE_BOOT;
switch (def->virtType) { switch (def->virtType) {
case VIR_DOMAIN_VIRT_QEMU: case VIR_DOMAIN_VIRT_QEMU:
if (qemuCmdFlags & QEMUD_CMD_FLAG_KQEMU) if (qemuCmdFlags & QEMU_CAPS_KQEMU)
disableKQEMU = 1; disableKQEMU = 1;
if (qemuCmdFlags & QEMUD_CMD_FLAG_KVM) if (qemuCmdFlags & QEMU_CAPS_KVM)
disableKVM = 1; disableKVM = 1;
break; break;
case VIR_DOMAIN_VIRT_KQEMU: case VIR_DOMAIN_VIRT_KQEMU:
if (qemuCmdFlags & QEMUD_CMD_FLAG_KVM) if (qemuCmdFlags & QEMU_CAPS_KVM)
disableKVM = 1; disableKVM = 1;
if (qemuCmdFlags & QEMUD_CMD_FLAG_ENABLE_KQEMU) { if (qemuCmdFlags & QEMU_CAPS_ENABLE_KQEMU) {
enableKQEMU = 1; enableKQEMU = 1;
} else if (!(qemuCmdFlags & QEMUD_CMD_FLAG_KQEMU)) { } else if (!(qemuCmdFlags & QEMU_CAPS_KQEMU)) {
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("the QEMU binary %s does not support kqemu"), _("the QEMU binary %s does not support kqemu"),
emulator); emulator);
@ -2723,12 +2723,12 @@ qemuBuildCommandLine(virConnectPtr conn,
break; break;
case VIR_DOMAIN_VIRT_KVM: case VIR_DOMAIN_VIRT_KVM:
if (qemuCmdFlags & QEMUD_CMD_FLAG_KQEMU) if (qemuCmdFlags & QEMU_CAPS_KQEMU)
disableKQEMU = 1; disableKQEMU = 1;
if (qemuCmdFlags & QEMUD_CMD_FLAG_ENABLE_KVM) { if (qemuCmdFlags & QEMU_CAPS_ENABLE_KVM) {
enableKVM = 1; enableKVM = 1;
} else if (!(qemuCmdFlags & QEMUD_CMD_FLAG_KVM)) { } else if (!(qemuCmdFlags & QEMU_CAPS_KVM)) {
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("the QEMU binary %s does not support kvm"), _("the QEMU binary %s does not support kvm"),
emulator); emulator);
@ -2765,7 +2765,7 @@ qemuBuildCommandLine(virConnectPtr conn,
virCommandAddArgList(cmd, "-cpu", cpu, NULL); virCommandAddArgList(cmd, "-cpu", cpu, NULL);
VIR_FREE(cpu); VIR_FREE(cpu);
if ((qemuCmdFlags & QEMUD_CMD_FLAG_NESTING) && if ((qemuCmdFlags & QEMU_CAPS_NESTING) &&
hasHwVirt) hasHwVirt)
virCommandAddArg(cmd, "-enable-nesting"); virCommandAddArg(cmd, "-enable-nesting");
} }
@ -2796,7 +2796,7 @@ qemuBuildCommandLine(virConnectPtr conn,
"%s", _("hugepages are disabled by administrator config")); "%s", _("hugepages are disabled by administrator config"));
goto error; goto error;
} }
if (!(qemuCmdFlags & QEMUD_CMD_FLAG_MEM_PATH)) { if (!(qemuCmdFlags & QEMU_CAPS_MEM_PATH)) {
qemuReportError(VIR_ERR_INTERNAL_ERROR, qemuReportError(VIR_ERR_INTERNAL_ERROR,
_("hugepage backing not supported by '%s'"), _("hugepage backing not supported by '%s'"),
def->emulator); def->emulator);
@ -2812,25 +2812,25 @@ qemuBuildCommandLine(virConnectPtr conn,
virCommandAddArg(cmd, smp); virCommandAddArg(cmd, smp);
VIR_FREE(smp); VIR_FREE(smp);
if (qemuCmdFlags & QEMUD_CMD_FLAG_NAME) { if (qemuCmdFlags & QEMU_CAPS_NAME) {
virCommandAddArg(cmd, "-name"); virCommandAddArg(cmd, "-name");
if (driver->setProcessName && if (driver->setProcessName &&
(qemuCmdFlags & QEMUD_CMD_FLAG_NAME_PROCESS)) { (qemuCmdFlags & QEMU_CAPS_NAME_PROCESS)) {
virCommandAddArgFormat(cmd, "%s,process=qemu:%s", virCommandAddArgFormat(cmd, "%s,process=qemu:%s",
def->name, def->name); def->name, def->name);
} else { } else {
virCommandAddArg(cmd, def->name); virCommandAddArg(cmd, def->name);
} }
} }
if (qemuCmdFlags & QEMUD_CMD_FLAG_UUID) if (qemuCmdFlags & QEMU_CAPS_UUID)
virCommandAddArgList(cmd, "-uuid", uuid, NULL); virCommandAddArgList(cmd, "-uuid", uuid, NULL);
if (def->virtType == VIR_DOMAIN_VIRT_XEN || if (def->virtType == VIR_DOMAIN_VIRT_XEN ||
STREQ(def->os.type, "xen") || STREQ(def->os.type, "xen") ||
STREQ(def->os.type, "linux")) { STREQ(def->os.type, "linux")) {
if (qemuCmdFlags & QEMUD_CMD_FLAG_DOMID) { if (qemuCmdFlags & QEMU_CAPS_DOMID) {
virCommandAddArg(cmd, "-domid"); virCommandAddArg(cmd, "-domid");
virCommandAddArgFormat(cmd, "%d", def->id); virCommandAddArgFormat(cmd, "%d", def->id);
} else if (qemuCmdFlags & QEMUD_CMD_FLAG_XEN_DOMID) { } else if (qemuCmdFlags & QEMU_CAPS_XEN_DOMID) {
virCommandAddArg(cmd, "-xen-attach"); virCommandAddArg(cmd, "-xen-attach");
virCommandAddArg(cmd, "-xen-domid"); virCommandAddArg(cmd, "-xen-domid");
virCommandAddArgFormat(cmd, "%d", def->id); virCommandAddArgFormat(cmd, "%d", def->id);
@ -2847,7 +2847,7 @@ qemuBuildCommandLine(virConnectPtr conn,
virSysinfoDefPtr source = NULL; virSysinfoDefPtr source = NULL;
bool skip_uuid = false; bool skip_uuid = false;
if (!(qemuCmdFlags & QEMUD_CMD_FLAG_SMBIOS_TYPE)) { if (!(qemuCmdFlags & QEMU_CAPS_SMBIOS_TYPE)) {
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("the QEMU binary %s does not support smbios settings"), _("the QEMU binary %s does not support smbios settings"),
emulator); emulator);
@ -2900,8 +2900,8 @@ qemuBuildCommandLine(virConnectPtr conn,
if (!def->graphics) if (!def->graphics)
virCommandAddArg(cmd, "-nographic"); virCommandAddArg(cmd, "-nographic");
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) { if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
if (qemuCmdFlags & QEMUD_CMD_FLAG_NODEFCONFIG) if (qemuCmdFlags & QEMU_CAPS_NODEFCONFIG)
virCommandAddArg(cmd, virCommandAddArg(cmd,
"-nodefconfig"); /* Disable global config files */ "-nodefconfig"); /* Disable global config files */
virCommandAddArg(cmd, virCommandAddArg(cmd,
@ -2911,7 +2911,7 @@ qemuBuildCommandLine(virConnectPtr conn,
if (monitor_chr) { if (monitor_chr) {
char *chrdev; char *chrdev;
/* Use -chardev if it's available */ /* Use -chardev if it's available */
if (qemuCmdFlags & QEMUD_CMD_FLAG_CHARDEV) { if (qemuCmdFlags & QEMU_CAPS_CHARDEV) {
virCommandAddArg(cmd, "-chardev"); virCommandAddArg(cmd, "-chardev");
if (!(chrdev = qemuBuildChrChardevStr(monitor_chr, "monitor", if (!(chrdev = qemuBuildChrChardevStr(monitor_chr, "monitor",
@ -2937,7 +2937,7 @@ qemuBuildCommandLine(virConnectPtr conn,
} }
} }
if (qemuCmdFlags & QEMUD_CMD_FLAG_RTC) { if (qemuCmdFlags & QEMU_CAPS_RTC) {
const char *rtcopt; const char *rtcopt;
virCommandAddArg(cmd, "-rtc"); virCommandAddArg(cmd, "-rtc");
if (!(rtcopt = qemuBuildClockArgStr(&def->clock))) if (!(rtcopt = qemuBuildClockArgStr(&def->clock)))
@ -2979,9 +2979,9 @@ qemuBuildCommandLine(virConnectPtr conn,
case VIR_DOMAIN_TIMER_NAME_RTC: case VIR_DOMAIN_TIMER_NAME_RTC:
/* This has already been taken care of (in qemuBuildClockArgStr) /* This has already been taken care of (in qemuBuildClockArgStr)
if QEMUD_CMD_FLAG_RTC is set (mutually exclusive with if QEMU_CAPS_RTC is set (mutually exclusive with
QEMUD_FLAG_RTC_TD_HACK) */ QEMUD_FLAG_RTC_TD_HACK) */
if (qemuCmdFlags & QEMUD_CMD_FLAG_RTC_TD_HACK) { if (qemuCmdFlags & QEMU_CAPS_RTC_TD_HACK) {
switch (def->clock.timers[i]->tickpolicy) { switch (def->clock.timers[i]->tickpolicy) {
case -1: case -1:
case VIR_DOMAIN_TIMER_TICKPOLICY_DELAY: case VIR_DOMAIN_TIMER_TICKPOLICY_DELAY:
@ -2997,7 +2997,7 @@ qemuBuildCommandLine(virConnectPtr conn,
virDomainTimerTickpolicyTypeToString(def->clock.timers[i]->tickpolicy)); virDomainTimerTickpolicyTypeToString(def->clock.timers[i]->tickpolicy));
goto error; goto error;
} }
} else if (!(qemuCmdFlags & QEMUD_CMD_FLAG_RTC) } else if (!(qemuCmdFlags & QEMU_CAPS_RTC)
&& (def->clock.timers[i]->tickpolicy && (def->clock.timers[i]->tickpolicy
!= VIR_DOMAIN_TIMER_TICKPOLICY_DELAY) != VIR_DOMAIN_TIMER_TICKPOLICY_DELAY)
&& (def->clock.timers[i]->tickpolicy != -1)) { && (def->clock.timers[i]->tickpolicy != -1)) {
@ -3016,13 +3016,13 @@ qemuBuildCommandLine(virConnectPtr conn,
case VIR_DOMAIN_TIMER_TICKPOLICY_DELAY: case VIR_DOMAIN_TIMER_TICKPOLICY_DELAY:
/* delay is the default if we don't have kernel /* delay is the default if we don't have kernel
(-no-kvm-pit), otherwise, the default is catchup. */ (-no-kvm-pit), otherwise, the default is catchup. */
if (qemuCmdFlags & QEMUD_CMD_FLAG_NO_KVM_PIT) if (qemuCmdFlags & QEMU_CAPS_NO_KVM_PIT)
virCommandAddArg(cmd, "-no-kvm-pit-reinjection"); virCommandAddArg(cmd, "-no-kvm-pit-reinjection");
break; break;
case VIR_DOMAIN_TIMER_TICKPOLICY_CATCHUP: case VIR_DOMAIN_TIMER_TICKPOLICY_CATCHUP:
if (qemuCmdFlags & QEMUD_CMD_FLAG_NO_KVM_PIT) { if (qemuCmdFlags & QEMU_CAPS_NO_KVM_PIT) {
/* do nothing - this is default for kvm-pit */ /* do nothing - this is default for kvm-pit */
} else if (qemuCmdFlags & QEMUD_CMD_FLAG_TDF) { } else if (qemuCmdFlags & QEMU_CAPS_TDF) {
/* -tdf switches to 'catchup' with userspace pit. */ /* -tdf switches to 'catchup' with userspace pit. */
virCommandAddArg(cmd, "-tdf"); virCommandAddArg(cmd, "-tdf");
} else { } else {
@ -3051,7 +3051,7 @@ qemuBuildCommandLine(virConnectPtr conn,
* and when -no-hpet doesn't exist is "no". "confusing"? * and when -no-hpet doesn't exist is "no". "confusing"?
* "yes"! */ * "yes"! */
if (qemuCmdFlags & QEMUD_CMD_FLAG_NO_HPET) { if (qemuCmdFlags & QEMU_CAPS_NO_HPET) {
if (def->clock.timers[i]->present == 0) if (def->clock.timers[i]->present == 0)
virCommandAddArg(cmd, "-no-hpet"); virCommandAddArg(cmd, "-no-hpet");
} else { } else {
@ -3066,7 +3066,7 @@ qemuBuildCommandLine(virConnectPtr conn,
} }
} }
if ((qemuCmdFlags & QEMUD_CMD_FLAG_NO_REBOOT) && if ((qemuCmdFlags & QEMU_CAPS_NO_REBOOT) &&
def->onReboot != VIR_DOMAIN_LIFECYCLE_RESTART) def->onReboot != VIR_DOMAIN_LIFECYCLE_RESTART)
virCommandAddArg(cmd, "-no-reboot"); virCommandAddArg(cmd, "-no-reboot");
@ -3099,7 +3099,7 @@ qemuBuildCommandLine(virConnectPtr conn,
boot[def->os.nBootDevs] = '\0'; boot[def->os.nBootDevs] = '\0';
if (qemuCmdFlags & QEMUD_CMD_FLAG_BOOT_MENU && if (qemuCmdFlags & QEMU_CAPS_BOOT_MENU &&
def->os.bootmenu != VIR_DOMAIN_BOOT_MENU_DEFAULT) { def->os.bootmenu != VIR_DOMAIN_BOOT_MENU_DEFAULT) {
if (def->os.bootmenu == VIR_DOMAIN_BOOT_MENU_ENABLED) if (def->os.bootmenu == VIR_DOMAIN_BOOT_MENU_ENABLED)
virBufferVSprintf(&boot_buf, "order=%s,menu=on", boot); virBufferVSprintf(&boot_buf, "order=%s,menu=on", boot);
@ -3110,7 +3110,7 @@ qemuBuildCommandLine(virConnectPtr conn,
} }
virCommandAddArgBuffer(cmd, &boot_buf); virCommandAddArgBuffer(cmd, &boot_buf);
} else if (!(qemuCmdFlags & QEMUD_CMD_FLAG_BOOTINDEX)) { } else if (!(qemuCmdFlags & QEMU_CAPS_BOOTINDEX)) {
/* def->os.nBootDevs is guaranteed to be > 0 unless per-device boot /* def->os.nBootDevs is guaranteed to be > 0 unless per-device boot
* configuration is used * configuration is used
*/ */
@ -3141,7 +3141,7 @@ qemuBuildCommandLine(virConnectPtr conn,
} }
} }
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) { if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
for (i = 0 ; i < def->ncontrollers ; i++) { for (i = 0 ; i < def->ncontrollers ; i++) {
virDomainControllerDefPtr cont = def->controllers[i]; virDomainControllerDefPtr cont = def->controllers[i];
@ -3171,11 +3171,11 @@ qemuBuildCommandLine(virConnectPtr conn,
} }
/* If QEMU supports -drive param instead of old -hda, -hdb, -cdrom .. */ /* If QEMU supports -drive param instead of old -hda, -hdb, -cdrom .. */
if (qemuCmdFlags & QEMUD_CMD_FLAG_DRIVE) { if (qemuCmdFlags & QEMU_CAPS_DRIVE) {
int bootCD = 0, bootFloppy = 0, bootDisk = 0; int bootCD = 0, bootFloppy = 0, bootDisk = 0;
/* If QEMU supports boot=on for -drive param... */ /* If QEMU supports boot=on for -drive param... */
if (qemuCmdFlags & QEMUD_CMD_FLAG_DRIVE_BOOT && !def->os.kernel) { if (qemuCmdFlags & QEMU_CAPS_DRIVE_BOOT && !def->os.kernel) {
for (i = 0 ; i < def->os.nBootDevs ; i++) { for (i = 0 ; i < def->os.nBootDevs ; i++) {
switch (def->os.bootDevs[i]) { switch (def->os.bootDevs[i]) {
case VIR_DOMAIN_BOOT_CDROM: case VIR_DOMAIN_BOOT_CDROM:
@ -3201,7 +3201,7 @@ qemuBuildCommandLine(virConnectPtr conn,
/* Unless we have -device, then USB disks need special /* Unless we have -device, then USB disks need special
handling */ handling */
if ((disk->bus == VIR_DOMAIN_DISK_BUS_USB) && if ((disk->bus == VIR_DOMAIN_DISK_BUS_USB) &&
!(qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE)) { !(qemuCmdFlags & QEMU_CAPS_DEVICE)) {
if (disk->device == VIR_DOMAIN_DISK_DEVICE_DISK) { if (disk->device == VIR_DOMAIN_DISK_DEVICE_DISK) {
virCommandAddArg(cmd, "-usbdevice"); virCommandAddArg(cmd, "-usbdevice");
virCommandAddArgFormat(cmd, "disk:%s", disk->src); virCommandAddArgFormat(cmd, "disk:%s", disk->src);
@ -3236,12 +3236,12 @@ qemuBuildCommandLine(virConnectPtr conn,
devices. Fortunately, those don't need devices. Fortunately, those don't need
static PCI addresses, so we don't really static PCI addresses, so we don't really
care that we can't use -device */ care that we can't use -device */
if ((qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) && if ((qemuCmdFlags & QEMU_CAPS_DEVICE) &&
(disk->bus != VIR_DOMAIN_DISK_BUS_XEN)) (disk->bus != VIR_DOMAIN_DISK_BUS_XEN))
withDeviceArg = 1; withDeviceArg = 1;
if (!(optstr = qemuBuildDriveStr(disk, bootable, if (!(optstr = qemuBuildDriveStr(disk, bootable,
(withDeviceArg ? qemuCmdFlags : (withDeviceArg ? qemuCmdFlags :
(qemuCmdFlags & ~QEMUD_CMD_FLAG_DEVICE))))) (qemuCmdFlags & ~QEMU_CAPS_DEVICE)))))
goto error; goto error;
virCommandAddArg(cmd, optstr); virCommandAddArg(cmd, optstr);
VIR_FREE(optstr); VIR_FREE(optstr);
@ -3276,7 +3276,7 @@ qemuBuildCommandLine(virConnectPtr conn,
disk->info.alias); disk->info.alias);
if (disk->bootIndex && if (disk->bootIndex &&
(qemuCmdFlags & QEMUD_CMD_FLAG_BOOTINDEX)) { (qemuCmdFlags & QEMU_CAPS_BOOTINDEX)) {
virCommandAddArg(cmd, "-global"); virCommandAddArg(cmd, "-global");
virCommandAddArgFormat(cmd, "isa-fdc.bootindex%c=%d", virCommandAddArgFormat(cmd, "isa-fdc.bootindex%c=%d",
disk->info.addr.drive.unit disk->info.addr.drive.unit
@ -3401,7 +3401,7 @@ qemuBuildCommandLine(virConnectPtr conn,
if (has_rbd_hosts) if (has_rbd_hosts)
virCommandAddEnvBuffer(cmd, &rbd_hosts); virCommandAddEnvBuffer(cmd, &rbd_hosts);
if (qemuCmdFlags & QEMUD_CMD_FLAG_FSDEV) { if (qemuCmdFlags & QEMU_CAPS_FSDEV) {
for (i = 0 ; i < def->nfss ; i++) { for (i = 0 ; i < def->nfss ; i++) {
char *optstr; char *optstr;
virDomainFSDefPtr fs = def->fss[i]; virDomainFSDefPtr fs = def->fss[i];
@ -3428,7 +3428,7 @@ qemuBuildCommandLine(virConnectPtr conn,
if (!def->nnets) { if (!def->nnets) {
/* If we have -device, then we set -nodefault already */ /* If we have -device, then we set -nodefault already */
if (!(qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE)) if (!(qemuCmdFlags & QEMU_CAPS_DEVICE))
virCommandAddArgList(cmd, "-net", "none", NULL); virCommandAddArgList(cmd, "-net", "none", NULL);
} else { } else {
for (i = 0 ; i < def->nnets ; i++) { for (i = 0 ; i < def->nnets ; i++) {
@ -3439,8 +3439,8 @@ qemuBuildCommandLine(virConnectPtr conn,
int vlan; int vlan;
/* VLANs are not used with -netdev, so don't record them */ /* VLANs are not used with -netdev, so don't record them */
if ((qemuCmdFlags & QEMUD_CMD_FLAG_NETDEV) && if ((qemuCmdFlags & QEMU_CAPS_NETDEV) &&
(qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE)) (qemuCmdFlags & QEMU_CAPS_DEVICE))
vlan = -1; vlan = -1;
else else
vlan = i; vlan = i;
@ -3499,8 +3499,8 @@ qemuBuildCommandLine(virConnectPtr conn,
* *
* NB, no support for -netdev without use of -device * NB, no support for -netdev without use of -device
*/ */
if ((qemuCmdFlags & QEMUD_CMD_FLAG_NETDEV) && if ((qemuCmdFlags & QEMU_CAPS_NETDEV) &&
(qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE)) { (qemuCmdFlags & QEMU_CAPS_DEVICE)) {
virCommandAddArg(cmd, "-netdev"); virCommandAddArg(cmd, "-netdev");
if (!(host = qemuBuildHostNetStr(net, ',', vlan, if (!(host = qemuBuildHostNetStr(net, ',', vlan,
tapfd_name, vhostfd_name))) tapfd_name, vhostfd_name)))
@ -3508,7 +3508,7 @@ qemuBuildCommandLine(virConnectPtr conn,
virCommandAddArg(cmd, host); virCommandAddArg(cmd, host);
VIR_FREE(host); VIR_FREE(host);
} }
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) { if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
virCommandAddArg(cmd, "-device"); virCommandAddArg(cmd, "-device");
if (!(nic = qemuBuildNicDevStr(net, vlan, qemuCmdFlags))) if (!(nic = qemuBuildNicDevStr(net, vlan, qemuCmdFlags)))
goto error; goto error;
@ -3521,8 +3521,8 @@ qemuBuildCommandLine(virConnectPtr conn,
virCommandAddArg(cmd, nic); virCommandAddArg(cmd, nic);
VIR_FREE(nic); VIR_FREE(nic);
} }
if (!((qemuCmdFlags & QEMUD_CMD_FLAG_NETDEV) && if (!((qemuCmdFlags & QEMU_CAPS_NETDEV) &&
(qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE))) { (qemuCmdFlags & QEMU_CAPS_DEVICE))) {
virCommandAddArg(cmd, "-net"); virCommandAddArg(cmd, "-net");
if (!(host = qemuBuildHostNetStr(net, ',', vlan, if (!(host = qemuBuildHostNetStr(net, ',', vlan,
tapfd_name, vhostfd_name))) tapfd_name, vhostfd_name)))
@ -3555,8 +3555,8 @@ qemuBuildCommandLine(virConnectPtr conn,
switch (smartcard->type) { switch (smartcard->type) {
case VIR_DOMAIN_SMARTCARD_TYPE_HOST: case VIR_DOMAIN_SMARTCARD_TYPE_HOST:
if (!(qemuCmdFlags & QEMUD_CMD_FLAG_CHARDEV) || if (!(qemuCmdFlags & QEMU_CAPS_CHARDEV) ||
!(qemuCmdFlags & QEMUD_CMD_FLAG_CCID_EMULATED)) { !(qemuCmdFlags & QEMU_CAPS_CCID_EMULATED)) {
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("this QEMU binary lacks smartcard host " _("this QEMU binary lacks smartcard host "
"mode support")); "mode support"));
@ -3567,8 +3567,8 @@ qemuBuildCommandLine(virConnectPtr conn,
break; break;
case VIR_DOMAIN_SMARTCARD_TYPE_HOST_CERTIFICATES: case VIR_DOMAIN_SMARTCARD_TYPE_HOST_CERTIFICATES:
if (!(qemuCmdFlags & QEMUD_CMD_FLAG_CHARDEV) || if (!(qemuCmdFlags & QEMU_CAPS_CHARDEV) ||
!(qemuCmdFlags & QEMUD_CMD_FLAG_CCID_EMULATED)) { !(qemuCmdFlags & QEMU_CAPS_CCID_EMULATED)) {
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("this QEMU binary lacks smartcard host " _("this QEMU binary lacks smartcard host "
"mode support")); "mode support"));
@ -3603,8 +3603,8 @@ qemuBuildCommandLine(virConnectPtr conn,
break; break;
case VIR_DOMAIN_SMARTCARD_TYPE_PASSTHROUGH: case VIR_DOMAIN_SMARTCARD_TYPE_PASSTHROUGH:
if (!(qemuCmdFlags & QEMUD_CMD_FLAG_CHARDEV) || if (!(qemuCmdFlags & QEMU_CAPS_CHARDEV) ||
!(qemuCmdFlags & QEMUD_CMD_FLAG_CCID_PASSTHRU)) { !(qemuCmdFlags & QEMU_CAPS_CCID_PASSTHRU)) {
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("this QEMU binary lacks smartcard " _("this QEMU binary lacks smartcard "
"passthrough mode support")); "passthrough mode support"));
@ -3639,7 +3639,7 @@ qemuBuildCommandLine(virConnectPtr conn,
if (!def->nserials) { if (!def->nserials) {
/* If we have -device, then we set -nodefault already */ /* If we have -device, then we set -nodefault already */
if (!(qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE)) if (!(qemuCmdFlags & QEMU_CAPS_DEVICE))
virCommandAddArgList(cmd, "-serial", "none", NULL); virCommandAddArgList(cmd, "-serial", "none", NULL);
} else { } else {
for (i = 0 ; i < def->nserials ; i++) { for (i = 0 ; i < def->nserials ; i++) {
@ -3647,8 +3647,8 @@ qemuBuildCommandLine(virConnectPtr conn,
char *devstr; char *devstr;
/* Use -chardev with -device if they are available */ /* Use -chardev with -device if they are available */
if ((qemuCmdFlags & QEMUD_CMD_FLAG_CHARDEV) && if ((qemuCmdFlags & QEMU_CAPS_CHARDEV) &&
(qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE)) { (qemuCmdFlags & QEMU_CAPS_DEVICE)) {
virCommandAddArg(cmd, "-chardev"); virCommandAddArg(cmd, "-chardev");
if (!(devstr = qemuBuildChrChardevStr(&serial->source, if (!(devstr = qemuBuildChrChardevStr(&serial->source,
serial->info.alias, serial->info.alias,
@ -3672,7 +3672,7 @@ qemuBuildCommandLine(virConnectPtr conn,
if (!def->nparallels) { if (!def->nparallels) {
/* If we have -device, then we set -nodefault already */ /* If we have -device, then we set -nodefault already */
if (!(qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE)) if (!(qemuCmdFlags & QEMU_CAPS_DEVICE))
virCommandAddArgList(cmd, "-parallel", "none", NULL); virCommandAddArgList(cmd, "-parallel", "none", NULL);
} else { } else {
for (i = 0 ; i < def->nparallels ; i++) { for (i = 0 ; i < def->nparallels ; i++) {
@ -3680,8 +3680,8 @@ qemuBuildCommandLine(virConnectPtr conn,
char *devstr; char *devstr;
/* Use -chardev with -device if they are available */ /* Use -chardev with -device if they are available */
if ((qemuCmdFlags & QEMUD_CMD_FLAG_CHARDEV) && if ((qemuCmdFlags & QEMU_CAPS_CHARDEV) &&
(qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE)) { (qemuCmdFlags & QEMU_CAPS_DEVICE)) {
virCommandAddArg(cmd, "-chardev"); virCommandAddArg(cmd, "-chardev");
if (!(devstr = qemuBuildChrChardevStr(&parallel->source, if (!(devstr = qemuBuildChrChardevStr(&parallel->source,
parallel->info.alias, parallel->info.alias,
@ -3710,8 +3710,8 @@ qemuBuildCommandLine(virConnectPtr conn,
switch(channel->targetType) { switch(channel->targetType) {
case VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_GUESTFWD: case VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_GUESTFWD:
if (!(qemuCmdFlags & QEMUD_CMD_FLAG_CHARDEV) || if (!(qemuCmdFlags & QEMU_CAPS_CHARDEV) ||
!(qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE)) { !(qemuCmdFlags & QEMU_CAPS_DEVICE)) {
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("guestfwd requires QEMU to support -chardev & -device")); "%s", _("guestfwd requires QEMU to support -chardev & -device"));
goto error; goto error;
@ -3739,13 +3739,13 @@ qemuBuildCommandLine(virConnectPtr conn,
break; break;
case VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_VIRTIO: case VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_VIRTIO:
if (!(qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE)) { if (!(qemuCmdFlags & QEMU_CAPS_DEVICE)) {
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("virtio channel requires QEMU to support -device")); _("virtio channel requires QEMU to support -device"));
goto error; goto error;
} }
if ((qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE_SPICEVMC) && if ((qemuCmdFlags & QEMU_CAPS_DEVICE_SPICEVMC) &&
channel->source.type == VIR_DOMAIN_CHR_TYPE_SPICEVMC) { channel->source.type == VIR_DOMAIN_CHR_TYPE_SPICEVMC) {
/* spicevmc was originally introduced via a -device /* spicevmc was originally introduced via a -device
* with a backend internal to qemu; although we prefer * with a backend internal to qemu; although we prefer
@ -3778,7 +3778,7 @@ qemuBuildCommandLine(virConnectPtr conn,
switch(console->targetType) { switch(console->targetType) {
case VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_VIRTIO: case VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_VIRTIO:
if (!(qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE)) { if (!(qemuCmdFlags & QEMU_CAPS_DEVICE)) {
qemuReportError(VIR_ERR_NO_SUPPORT, "%s", qemuReportError(VIR_ERR_NO_SUPPORT, "%s",
_("virtio channel requires QEMU to support -device")); _("virtio channel requires QEMU to support -device"));
goto error; goto error;
@ -3816,7 +3816,7 @@ qemuBuildCommandLine(virConnectPtr conn,
virDomainInputDefPtr input = def->inputs[i]; virDomainInputDefPtr input = def->inputs[i];
if (input->bus == VIR_DOMAIN_INPUT_BUS_USB) { if (input->bus == VIR_DOMAIN_INPUT_BUS_USB) {
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) { if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
char *optstr; char *optstr;
virCommandAddArg(cmd, "-device"); virCommandAddArg(cmd, "-device");
if (!(optstr = qemuBuildUSBInputDevStr(input))) if (!(optstr = qemuBuildUSBInputDevStr(input)))
@ -3853,7 +3853,7 @@ qemuBuildCommandLine(virConnectPtr conn,
virBufferVSprintf(&opt, "unix:%s", virBufferVSprintf(&opt, "unix:%s",
def->graphics[0]->data.vnc.socket); def->graphics[0]->data.vnc.socket);
} else if (qemuCmdFlags & QEMUD_CMD_FLAG_VNC_COLON) { } else if (qemuCmdFlags & QEMU_CAPS_VNC_COLON) {
if (def->graphics[0]->data.vnc.listenAddr) if (def->graphics[0]->data.vnc.listenAddr)
virBufferAdd(&opt, def->graphics[0]->data.vnc.listenAddr, -1); virBufferAdd(&opt, def->graphics[0]->data.vnc.listenAddr, -1);
else if (driver->vncListen) else if (driver->vncListen)
@ -3867,7 +3867,7 @@ qemuBuildCommandLine(virConnectPtr conn,
def->graphics[0]->data.vnc.port - 5900); def->graphics[0]->data.vnc.port - 5900);
} }
if (qemuCmdFlags & QEMUD_CMD_FLAG_VNC_COLON) { if (qemuCmdFlags & QEMU_CAPS_VNC_COLON) {
if (def->graphics[0]->data.vnc.auth.passwd || if (def->graphics[0]->data.vnc.auth.passwd ||
driver->vncPassword) driver->vncPassword)
virBufferAddLit(&opt, ",password"); virBufferAddLit(&opt, ",password");
@ -3912,8 +3912,8 @@ qemuBuildCommandLine(virConnectPtr conn,
} }
} else if ((def->ngraphics == 1) && } else if ((def->ngraphics == 1) &&
def->graphics[0]->type == VIR_DOMAIN_GRAPHICS_TYPE_SDL) { def->graphics[0]->type == VIR_DOMAIN_GRAPHICS_TYPE_SDL) {
if ((qemuCmdFlags & QEMUD_CMD_FLAG_0_10) && if ((qemuCmdFlags & QEMU_CAPS_0_10) &&
!(qemuCmdFlags & QEMUD_CMD_FLAG_SDL)) { !(qemuCmdFlags & QEMU_CAPS_SDL)) {
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("sdl not supported by '%s'"), _("sdl not supported by '%s'"),
def->emulator); def->emulator);
@ -3939,14 +3939,14 @@ qemuBuildCommandLine(virConnectPtr conn,
/* New QEMU has this flag to let us explicitly ask for /* New QEMU has this flag to let us explicitly ask for
* SDL graphics. This is better than relying on the * SDL graphics. This is better than relying on the
* default, since the default changes :-( */ * default, since the default changes :-( */
if (qemuCmdFlags & QEMUD_CMD_FLAG_SDL) if (qemuCmdFlags & QEMU_CAPS_SDL)
virCommandAddArg(cmd, "-sdl"); virCommandAddArg(cmd, "-sdl");
} else if ((def->ngraphics == 1) && } else if ((def->ngraphics == 1) &&
def->graphics[0]->type == VIR_DOMAIN_GRAPHICS_TYPE_SPICE) { def->graphics[0]->type == VIR_DOMAIN_GRAPHICS_TYPE_SPICE) {
virBuffer opt = VIR_BUFFER_INITIALIZER; virBuffer opt = VIR_BUFFER_INITIALIZER;
if (!(qemuCmdFlags & QEMUD_CMD_FLAG_SPICE)) { if (!(qemuCmdFlags & QEMU_CAPS_SPICE)) {
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("spice graphics are not supported with this QEMU")); _("spice graphics are not supported with this QEMU"));
goto error; goto error;
@ -4005,12 +4005,12 @@ qemuBuildCommandLine(virConnectPtr conn,
} }
if (def->nvideos > 0) { if (def->nvideos > 0) {
if (qemuCmdFlags & QEMUD_CMD_FLAG_VGA) { if (qemuCmdFlags & QEMU_CAPS_VGA) {
if (def->videos[0]->type == VIR_DOMAIN_VIDEO_TYPE_XEN) { if (def->videos[0]->type == VIR_DOMAIN_VIDEO_TYPE_XEN) {
/* nothing - vga has no effect on Xen pvfb */ /* nothing - vga has no effect on Xen pvfb */
} else { } else {
if ((def->videos[0]->type == VIR_DOMAIN_VIDEO_TYPE_QXL) && if ((def->videos[0]->type == VIR_DOMAIN_VIDEO_TYPE_QXL) &&
!(qemuCmdFlags & QEMUD_CMD_FLAG_VGA_QXL)) { !(qemuCmdFlags & QEMU_CAPS_VGA_QXL)) {
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("This QEMU does not support QXL graphics adapters")); _("This QEMU does not support QXL graphics adapters"));
goto error; goto error;
@ -4051,7 +4051,7 @@ qemuBuildCommandLine(virConnectPtr conn,
} }
if (def->nvideos > 1) { if (def->nvideos > 1) {
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) { if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
for (i = 1 ; i < def->nvideos ; i++) { for (i = 1 ; i < def->nvideos ; i++) {
char *str; char *str;
if (def->videos[i]->type != VIR_DOMAIN_VIDEO_TYPE_QXL) { if (def->videos[i]->type != VIR_DOMAIN_VIDEO_TYPE_QXL) {
@ -4078,15 +4078,15 @@ qemuBuildCommandLine(virConnectPtr conn,
} else { } else {
/* If we have -device, then we set -nodefault already */ /* If we have -device, then we set -nodefault already */
if (!(qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) && if (!(qemuCmdFlags & QEMU_CAPS_DEVICE) &&
(qemuCmdFlags & QEMUD_CMD_FLAG_VGA) && (qemuCmdFlags & QEMU_CAPS_VGA) &&
(qemuCmdFlags & QEMUD_CMD_FLAG_VGA_NONE)) (qemuCmdFlags & QEMU_CAPS_VGA_NONE))
virCommandAddArgList(cmd, "-vga", "none", NULL); virCommandAddArgList(cmd, "-vga", "none", NULL);
} }
/* Add sound hardware */ /* Add sound hardware */
if (def->nsounds) { if (def->nsounds) {
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) { if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
for (i = 0 ; i < def->nsounds ; i++) { for (i = 0 ; i < def->nsounds ; i++) {
virDomainSoundDefPtr sound = def->sounds[i]; virDomainSoundDefPtr sound = def->sounds[i];
char *str = NULL; char *str = NULL;
@ -4105,7 +4105,7 @@ qemuBuildCommandLine(virConnectPtr conn,
if (sound->model == VIR_DOMAIN_SOUND_MODEL_ICH6) { if (sound->model == VIR_DOMAIN_SOUND_MODEL_ICH6) {
char *codecstr = NULL; char *codecstr = NULL;
if (!(qemuCmdFlags & QEMUD_CMD_FLAG_HDA_DUPLEX)) { if (!(qemuCmdFlags & QEMU_CAPS_HDA_DUPLEX)) {
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("this QEMU binary lacks hda support")); _("this QEMU binary lacks hda support"));
goto error; goto error;
@ -4161,7 +4161,7 @@ qemuBuildCommandLine(virConnectPtr conn,
virDomainWatchdogDefPtr watchdog = def->watchdog; virDomainWatchdogDefPtr watchdog = def->watchdog;
char *optstr; char *optstr;
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) { if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
virCommandAddArg(cmd, "-device"); virCommandAddArg(cmd, "-device");
optstr = qemuBuildWatchdogDevStr(watchdog, qemuCmdFlags); optstr = qemuBuildWatchdogDevStr(watchdog, qemuCmdFlags);
@ -4207,7 +4207,7 @@ qemuBuildCommandLine(virConnectPtr conn,
_("booting from assigned devices is only" _("booting from assigned devices is only"
" supported for PCI devices")); " supported for PCI devices"));
goto error; goto error;
} else if (!(qemuCmdFlags & QEMUD_CMD_FLAG_PCI_BOOTINDEX)) { } else if (!(qemuCmdFlags & QEMU_CAPS_PCI_BOOTINDEX)) {
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("booting from assigned PCI devices is not" _("booting from assigned PCI devices is not"
" supported with this version of qemu")); " supported with this version of qemu"));
@ -4219,7 +4219,7 @@ qemuBuildCommandLine(virConnectPtr conn,
if (hostdev->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS && if (hostdev->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS &&
hostdev->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB) { hostdev->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB) {
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) { if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
virCommandAddArg(cmd, "-device"); virCommandAddArg(cmd, "-device");
if (!(devstr = qemuBuildUSBHostdevDevStr(hostdev))) if (!(devstr = qemuBuildUSBHostdevDevStr(hostdev)))
goto error; goto error;
@ -4237,9 +4237,9 @@ qemuBuildCommandLine(virConnectPtr conn,
/* PCI */ /* PCI */
if (hostdev->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS && if (hostdev->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS &&
hostdev->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI) { hostdev->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI) {
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) { if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
char *configfd_name = NULL; char *configfd_name = NULL;
if (qemuCmdFlags & QEMUD_CMD_FLAG_PCI_CONFIGFD) { if (qemuCmdFlags & QEMU_CAPS_PCI_CONFIGFD) {
int configfd = qemuOpenPCIConfig(hostdev); int configfd = qemuOpenPCIConfig(hostdev);
if (configfd >= 0) { if (configfd >= 0) {
@ -4258,7 +4258,7 @@ qemuBuildCommandLine(virConnectPtr conn,
goto error; goto error;
virCommandAddArg(cmd, devstr); virCommandAddArg(cmd, devstr);
VIR_FREE(devstr); VIR_FREE(devstr);
} else if (qemuCmdFlags & QEMUD_CMD_FLAG_PCIDEVICE) { } else if (qemuCmdFlags & QEMU_CAPS_PCIDEVICE) {
virCommandAddArg(cmd, "-pcidevice"); virCommandAddArg(cmd, "-pcidevice");
if (!(devstr = qemuBuildPCIHostdevPCIDevStr(hostdev))) if (!(devstr = qemuBuildPCIHostdevPCIDevStr(hostdev)))
goto error; goto error;
@ -4278,7 +4278,7 @@ qemuBuildCommandLine(virConnectPtr conn,
if (migrateFrom) { if (migrateFrom) {
virCommandAddArg(cmd, "-incoming"); virCommandAddArg(cmd, "-incoming");
if (STRPREFIX(migrateFrom, "tcp")) { if (STRPREFIX(migrateFrom, "tcp")) {
if (!(qemuCmdFlags & QEMUD_CMD_FLAG_MIGRATE_QEMU_TCP)) { if (!(qemuCmdFlags & QEMU_CAPS_MIGRATE_QEMU_TCP)) {
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("TCP migration is not supported with " "%s", _("TCP migration is not supported with "
"this QEMU binary")); "this QEMU binary"));
@ -4286,13 +4286,13 @@ qemuBuildCommandLine(virConnectPtr conn,
} }
virCommandAddArg(cmd, migrateFrom); virCommandAddArg(cmd, migrateFrom);
} else if (STREQ(migrateFrom, "stdio")) { } else if (STREQ(migrateFrom, "stdio")) {
if (qemuCmdFlags & QEMUD_CMD_FLAG_MIGRATE_QEMU_FD) { if (qemuCmdFlags & QEMU_CAPS_MIGRATE_QEMU_FD) {
virCommandAddArgFormat(cmd, "fd:%d", migrateFd); virCommandAddArgFormat(cmd, "fd:%d", migrateFd);
virCommandPreserveFD(cmd, migrateFd); virCommandPreserveFD(cmd, migrateFd);
} else if (qemuCmdFlags & QEMUD_CMD_FLAG_MIGRATE_QEMU_EXEC) { } else if (qemuCmdFlags & QEMU_CAPS_MIGRATE_QEMU_EXEC) {
virCommandAddArg(cmd, "exec:cat"); virCommandAddArg(cmd, "exec:cat");
virCommandSetInputFD(cmd, migrateFd); virCommandSetInputFD(cmd, migrateFd);
} else if (qemuCmdFlags & QEMUD_CMD_FLAG_MIGRATE_KVM_STDIO) { } else if (qemuCmdFlags & QEMU_CAPS_MIGRATE_KVM_STDIO) {
virCommandAddArg(cmd, migrateFrom); virCommandAddArg(cmd, migrateFrom);
virCommandSetInputFD(cmd, migrateFd); virCommandSetInputFD(cmd, migrateFd);
} else { } else {
@ -4302,7 +4302,7 @@ qemuBuildCommandLine(virConnectPtr conn,
goto error; goto error;
} }
} else if (STRPREFIX(migrateFrom, "exec")) { } else if (STRPREFIX(migrateFrom, "exec")) {
if (!(qemuCmdFlags & QEMUD_CMD_FLAG_MIGRATE_QEMU_EXEC)) { if (!(qemuCmdFlags & QEMU_CAPS_MIGRATE_QEMU_EXEC)) {
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("EXEC migration is not supported " "%s", _("EXEC migration is not supported "
"with this QEMU binary")); "with this QEMU binary"));
@ -4310,7 +4310,7 @@ qemuBuildCommandLine(virConnectPtr conn,
} }
virCommandAddArg(cmd, migrateFrom); virCommandAddArg(cmd, migrateFrom);
} else if (STRPREFIX(migrateFrom, "fd")) { } else if (STRPREFIX(migrateFrom, "fd")) {
if (!(qemuCmdFlags & QEMUD_CMD_FLAG_MIGRATE_QEMU_FD)) { if (!(qemuCmdFlags & QEMU_CAPS_MIGRATE_QEMU_FD)) {
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("FD migration is not supported " "%s", _("FD migration is not supported "
"with this QEMU binary")); "with this QEMU binary"));
@ -4319,7 +4319,7 @@ qemuBuildCommandLine(virConnectPtr conn,
virCommandAddArg(cmd, migrateFrom); virCommandAddArg(cmd, migrateFrom);
virCommandPreserveFD(cmd, migrateFd); virCommandPreserveFD(cmd, migrateFd);
} else if (STRPREFIX(migrateFrom, "unix")) { } else if (STRPREFIX(migrateFrom, "unix")) {
if (!(qemuCmdFlags & QEMUD_CMD_FLAG_MIGRATE_QEMU_UNIX)) { if (!(qemuCmdFlags & QEMU_CAPS_MIGRATE_QEMU_UNIX)) {
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("UNIX migration is not supported " "%s", _("UNIX migration is not supported "
"with this QEMU binary")); "with this QEMU binary"));
@ -4347,7 +4347,7 @@ qemuBuildCommandLine(virConnectPtr conn,
virDomainMemballoonModelTypeToString(def->memballoon->model)); virDomainMemballoonModelTypeToString(def->memballoon->model));
goto error; goto error;
} }
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) { if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
char *optstr; char *optstr;
virCommandAddArg(cmd, "-device"); virCommandAddArg(cmd, "-device");
@ -4356,7 +4356,7 @@ qemuBuildCommandLine(virConnectPtr conn,
goto error; goto error;
virCommandAddArg(cmd, optstr); virCommandAddArg(cmd, optstr);
VIR_FREE(optstr); VIR_FREE(optstr);
} else if (qemuCmdFlags & QEMUD_CMD_FLAG_BALLOON) { } else if (qemuCmdFlags & QEMU_CAPS_BALLOON) {
virCommandAddArgList(cmd, "-balloon", "virtio", NULL); virCommandAddArgList(cmd, "-balloon", "virtio", NULL);
} }
} }

86
src/qemu/qemu_hotplug.c
View File

@ -160,7 +160,7 @@ int qemuDomainAttachPciDiskDevice(struct qemud_driver *driver,
vm, disk) < 0) vm, disk) < 0)
return -1; return -1;
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) { if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
if (qemuDomainPCIAddressEnsureAddr(priv->pciaddrs, &disk->info) < 0) if (qemuDomainPCIAddressEnsureAddr(priv->pciaddrs, &disk->info) < 0)
goto error; goto error;
if (qemuAssignDeviceDiskAlias(disk, qemuCmdFlags) < 0) if (qemuAssignDeviceDiskAlias(disk, qemuCmdFlags) < 0)
@ -179,7 +179,7 @@ int qemuDomainAttachPciDiskDevice(struct qemud_driver *driver,
} }
qemuDomainObjEnterMonitorWithDriver(driver, vm); qemuDomainObjEnterMonitorWithDriver(driver, vm);
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) { if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
ret = qemuMonitorAddDrive(priv->mon, drivestr); ret = qemuMonitorAddDrive(priv->mon, drivestr);
if (ret == 0) { if (ret == 0) {
ret = qemuMonitorAddDevice(priv->mon, devstr); ret = qemuMonitorAddDevice(priv->mon, devstr);
@ -219,7 +219,7 @@ error:
VIR_FREE(devstr); VIR_FREE(devstr);
VIR_FREE(drivestr); VIR_FREE(drivestr);
if ((qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) && if ((qemuCmdFlags & QEMU_CAPS_DEVICE) &&
(disk->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) && (disk->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) &&
qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &disk->info) < 0) qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &disk->info) < 0)
VIR_WARN("Unable to release PCI address on %s", disk->src); VIR_WARN("Unable to release PCI address on %s", disk->src);
@ -253,7 +253,7 @@ int qemuDomainAttachPciControllerDevice(struct qemud_driver *driver,
} }
} }
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) { if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
if (qemuDomainPCIAddressEnsureAddr(priv->pciaddrs, &controller->info) < 0) if (qemuDomainPCIAddressEnsureAddr(priv->pciaddrs, &controller->info) < 0)
goto cleanup; goto cleanup;
if (qemuAssignDeviceControllerAlias(controller) < 0) if (qemuAssignDeviceControllerAlias(controller) < 0)
@ -270,7 +270,7 @@ int qemuDomainAttachPciControllerDevice(struct qemud_driver *driver,
} }
qemuDomainObjEnterMonitorWithDriver(driver, vm); qemuDomainObjEnterMonitorWithDriver(driver, vm);
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) { if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
ret = qemuMonitorAddDevice(priv->mon, devstr); ret = qemuMonitorAddDevice(priv->mon, devstr);
} else { } else {
ret = qemuMonitorAttachPCIDiskController(priv->mon, ret = qemuMonitorAttachPCIDiskController(priv->mon,
@ -286,7 +286,7 @@ int qemuDomainAttachPciControllerDevice(struct qemud_driver *driver,
cleanup: cleanup:
if ((ret != 0) && if ((ret != 0) &&
(qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) && (qemuCmdFlags & QEMU_CAPS_DEVICE) &&
(controller->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) && (controller->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) &&
qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &controller->info) < 0) qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &controller->info) < 0)
VIR_WARN0("Unable to release PCI address on controller"); VIR_WARN0("Unable to release PCI address on controller");
@ -376,7 +376,7 @@ int qemuDomainAttachSCSIDisk(struct qemud_driver *driver,
goto error; goto error;
} }
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) { if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
if (qemuAssignDeviceDiskAlias(disk, qemuCmdFlags) < 0) if (qemuAssignDeviceDiskAlias(disk, qemuCmdFlags) < 0)
goto error; goto error;
if (!(devstr = qemuBuildDriveDevStr(disk, qemuCmdFlags))) if (!(devstr = qemuBuildDriveDevStr(disk, qemuCmdFlags)))
@ -409,7 +409,7 @@ int qemuDomainAttachSCSIDisk(struct qemud_driver *driver,
} }
qemuDomainObjEnterMonitorWithDriver(driver, vm); qemuDomainObjEnterMonitorWithDriver(driver, vm);
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) { if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
ret = qemuMonitorAddDrive(priv->mon, drivestr); ret = qemuMonitorAddDrive(priv->mon, drivestr);
if (ret == 0) { if (ret == 0) {
ret = qemuMonitorAddDevice(priv->mon, devstr); ret = qemuMonitorAddDevice(priv->mon, devstr);
@ -487,7 +487,7 @@ int qemuDomainAttachUsbMassstorageDevice(struct qemud_driver *driver,
goto error; goto error;
} }
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) { if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
if (qemuAssignDeviceDiskAlias(disk, qemuCmdFlags) < 0) if (qemuAssignDeviceDiskAlias(disk, qemuCmdFlags) < 0)
goto error; goto error;
if (!(drivestr = qemuBuildDriveStr(disk, 0, qemuCmdFlags))) if (!(drivestr = qemuBuildDriveStr(disk, 0, qemuCmdFlags)))
@ -502,7 +502,7 @@ int qemuDomainAttachUsbMassstorageDevice(struct qemud_driver *driver,
} }
qemuDomainObjEnterMonitorWithDriver(driver, vm); qemuDomainObjEnterMonitorWithDriver(driver, vm);
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) { if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
ret = qemuMonitorAddDrive(priv->mon, drivestr); ret = qemuMonitorAddDrive(priv->mon, drivestr);
if (ret == 0) { if (ret == 0) {
ret = qemuMonitorAddDevice(priv->mon, devstr); ret = qemuMonitorAddDevice(priv->mon, devstr);
@ -558,7 +558,7 @@ int qemuDomainAttachNetDevice(virConnectPtr conn,
virDomainDevicePCIAddress guestAddr; virDomainDevicePCIAddress guestAddr;
int vlan; int vlan;
if (!(qemuCmdFlags & QEMUD_CMD_FLAG_HOST_NET_ADD)) { if (!(qemuCmdFlags & QEMU_CAPS_HOST_NET_ADD)) {
qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s", qemuReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("installed qemu version does not support host_net_add")); _("installed qemu version does not support host_net_add"));
return -1; return -1;
@ -595,18 +595,18 @@ int qemuDomainAttachNetDevice(virConnectPtr conn,
if (VIR_REALLOC_N(vm->def->nets, vm->def->nnets+1) < 0) if (VIR_REALLOC_N(vm->def->nets, vm->def->nnets+1) < 0)
goto no_memory; goto no_memory;
if ((qemuCmdFlags & QEMUD_CMD_FLAG_NET_NAME) || if ((qemuCmdFlags & QEMU_CAPS_NET_NAME) ||
(qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE)) { (qemuCmdFlags & QEMU_CAPS_DEVICE)) {
if (qemuAssignDeviceNetAlias(vm->def, net, -1) < 0) if (qemuAssignDeviceNetAlias(vm->def, net, -1) < 0)
goto cleanup; goto cleanup;
} }
if ((qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) && if ((qemuCmdFlags & QEMU_CAPS_DEVICE) &&
qemuDomainPCIAddressEnsureAddr(priv->pciaddrs, &net->info) < 0) qemuDomainPCIAddressEnsureAddr(priv->pciaddrs, &net->info) < 0)
goto cleanup; goto cleanup;
if ((qemuCmdFlags & QEMUD_CMD_FLAG_NETDEV) && if ((qemuCmdFlags & QEMU_CAPS_NETDEV) &&
(qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE)) { (qemuCmdFlags & QEMU_CAPS_DEVICE)) {
vlan = -1; vlan = -1;
} else { } else {
vlan = qemuDomainNetVLAN(net); vlan = qemuDomainNetVLAN(net);
@ -637,8 +637,8 @@ int qemuDomainAttachNetDevice(virConnectPtr conn,
} }
/* FIXME - need to support vhost-net here (5th arg) */ /* FIXME - need to support vhost-net here (5th arg) */
if ((qemuCmdFlags & QEMUD_CMD_FLAG_NETDEV) && if ((qemuCmdFlags & QEMU_CAPS_NETDEV) &&
(qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE)) { (qemuCmdFlags & QEMU_CAPS_DEVICE)) {
if (!(netstr = qemuBuildHostNetStr(net, ',', if (!(netstr = qemuBuildHostNetStr(net, ',',
-1, tapfd_name, 0))) -1, tapfd_name, 0)))
goto try_tapfd_close; goto try_tapfd_close;
@ -649,8 +649,8 @@ int qemuDomainAttachNetDevice(virConnectPtr conn,
} }
qemuDomainObjEnterMonitorWithDriver(driver, vm); qemuDomainObjEnterMonitorWithDriver(driver, vm);
if ((qemuCmdFlags & QEMUD_CMD_FLAG_NETDEV) && if ((qemuCmdFlags & QEMU_CAPS_NETDEV) &&
(qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE)) { (qemuCmdFlags & QEMU_CAPS_DEVICE)) {
if (qemuMonitorAddNetdev(priv->mon, netstr) < 0) { if (qemuMonitorAddNetdev(priv->mon, netstr) < 0) {
qemuDomainObjExitMonitorWithDriver(driver, vm); qemuDomainObjExitMonitorWithDriver(driver, vm);
qemuDomainNetAudit(vm, NULL, net, "attach", false); qemuDomainNetAudit(vm, NULL, net, "attach", false);
@ -673,7 +673,7 @@ int qemuDomainAttachNetDevice(virConnectPtr conn,
goto cleanup; goto cleanup;
} }
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) { if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
if (!(nicstr = qemuBuildNicDevStr(net, vlan, qemuCmdFlags))) if (!(nicstr = qemuBuildNicDevStr(net, vlan, qemuCmdFlags)))
goto try_remove; goto try_remove;
} else { } else {
@ -682,7 +682,7 @@ int qemuDomainAttachNetDevice(virConnectPtr conn,
} }
qemuDomainObjEnterMonitorWithDriver(driver, vm); qemuDomainObjEnterMonitorWithDriver(driver, vm);
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) { if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
if (qemuMonitorAddDevice(priv->mon, nicstr) < 0) { if (qemuMonitorAddDevice(priv->mon, nicstr) < 0) {
qemuDomainObjExitMonitorWithDriver(driver, vm); qemuDomainObjExitMonitorWithDriver(driver, vm);
qemuDomainNetAudit(vm, NULL, net, "attach", false); qemuDomainNetAudit(vm, NULL, net, "attach", false);
@ -708,7 +708,7 @@ int qemuDomainAttachNetDevice(virConnectPtr conn,
cleanup: cleanup:
if ((ret != 0) && if ((ret != 0) &&
(qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) && (qemuCmdFlags & QEMU_CAPS_DEVICE) &&
(net->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) && (net->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) &&
qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &net->info) < 0) qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &net->info) < 0)
VIR_WARN0("Unable to release PCI address on NIC"); VIR_WARN0("Unable to release PCI address on NIC");
@ -728,8 +728,8 @@ try_remove:
goto cleanup; goto cleanup;
if (vlan < 0) { if (vlan < 0) {
if ((qemuCmdFlags & QEMUD_CMD_FLAG_NETDEV) && if ((qemuCmdFlags & QEMU_CAPS_NETDEV) &&
(qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE)) { (qemuCmdFlags & QEMU_CAPS_DEVICE)) {
char *netdev_name; char *netdev_name;
if (virAsprintf(&netdev_name, "host%s", net->info.alias) < 0) if (virAsprintf(&netdev_name, "host%s", net->info.alias) < 0)
goto no_memory; goto no_memory;
@ -793,12 +793,12 @@ int qemuDomainAttachHostPciDevice(struct qemud_driver *driver,
if (qemuPrepareHostdevPCIDevices(driver, &hostdev, 1) < 0) if (qemuPrepareHostdevPCIDevices(driver, &hostdev, 1) < 0)
return -1; return -1;
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) { if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
if (qemuAssignDeviceHostdevAlias(vm->def, hostdev, -1) < 0) if (qemuAssignDeviceHostdevAlias(vm->def, hostdev, -1) < 0)
goto error; goto error;
if (qemuDomainPCIAddressEnsureAddr(priv->pciaddrs, &hostdev->info) < 0) if (qemuDomainPCIAddressEnsureAddr(priv->pciaddrs, &hostdev->info) < 0)
goto error; goto error;
if (qemuCmdFlags & QEMUD_CMD_FLAG_PCI_CONFIGFD) { if (qemuCmdFlags & QEMU_CAPS_PCI_CONFIGFD) {
configfd = qemuOpenPCIConfig(hostdev); configfd = qemuOpenPCIConfig(hostdev);
if (configfd >= 0) { if (configfd >= 0) {
if (virAsprintf(&configfd_name, "fd-%s", if (virAsprintf(&configfd_name, "fd-%s",
@ -854,7 +854,7 @@ int qemuDomainAttachHostPciDevice(struct qemud_driver *driver,
return 0; return 0;
error: error:
if ((qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) && if ((qemuCmdFlags & QEMU_CAPS_DEVICE) &&
(hostdev->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) && (hostdev->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) &&
qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &hostdev->info) < 0) qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &hostdev->info) < 0)
VIR_WARN0("Unable to release PCI address on host device"); VIR_WARN0("Unable to release PCI address on host device");
@ -878,7 +878,7 @@ int qemuDomainAttachHostUsbDevice(struct qemud_driver *driver,
qemuDomainObjPrivatePtr priv = vm->privateData; qemuDomainObjPrivatePtr priv = vm->privateData;
char *devstr = NULL; char *devstr = NULL;
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) { if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
if (qemuAssignDeviceHostdevAlias(vm->def, hostdev, -1) < 0) if (qemuAssignDeviceHostdevAlias(vm->def, hostdev, -1) < 0)
goto error; goto error;
if (!(devstr = qemuBuildUSBHostdevDevStr(hostdev))) if (!(devstr = qemuBuildUSBHostdevDevStr(hostdev)))
@ -910,7 +910,7 @@ int qemuDomainAttachHostUsbDevice(struct qemud_driver *driver,
} }
qemuDomainObjEnterMonitorWithDriver(driver, vm); qemuDomainObjEnterMonitorWithDriver(driver, vm);
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) if (qemuCmdFlags & QEMU_CAPS_DEVICE)
ret = qemuMonitorAddDevice(priv->mon, devstr); ret = qemuMonitorAddDevice(priv->mon, devstr);
else else
ret = qemuMonitorAddUSBDeviceExact(priv->mon, ret = qemuMonitorAddUSBDeviceExact(priv->mon,
@ -1173,7 +1173,7 @@ int qemuDomainDetachPciDiskDevice(struct qemud_driver *driver,
} }
qemuDomainObjEnterMonitorWithDriver(driver, vm); qemuDomainObjEnterMonitorWithDriver(driver, vm);
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) { if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
if (qemuMonitorDelDevice(priv->mon, detach->info.alias) < 0) { if (qemuMonitorDelDevice(priv->mon, detach->info.alias) < 0) {
qemuDomainObjExitMonitor(vm); qemuDomainObjExitMonitor(vm);
goto cleanup; goto cleanup;
@ -1193,7 +1193,7 @@ int qemuDomainDetachPciDiskDevice(struct qemud_driver *driver,
qemuDomainDiskAudit(vm, detach, NULL, "detach", ret >= 0); qemuDomainDiskAudit(vm, detach, NULL, "detach", ret >= 0);
if ((qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) && if ((qemuCmdFlags & QEMU_CAPS_DEVICE) &&
qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &detach->info) < 0) qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &detach->info) < 0)
VIR_WARN("Unable to release PCI address on %s", dev->data.disk->src); VIR_WARN("Unable to release PCI address on %s", dev->data.disk->src);
@ -1237,7 +1237,7 @@ int qemuDomainDetachSCSIDiskDevice(struct qemud_driver *driver,
goto cleanup; goto cleanup;
} }
if (!(qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE)) { if (!(qemuCmdFlags & QEMU_CAPS_DEVICE)) {
qemuReportError(VIR_ERR_OPERATION_FAILED, "%s", qemuReportError(VIR_ERR_OPERATION_FAILED, "%s",
_("Underlying qemu does not support SCSI disk removal")); _("Underlying qemu does not support SCSI disk removal"));
goto cleanup; goto cleanup;
@ -1385,13 +1385,13 @@ int qemuDomainDetachPciControllerDevice(struct qemud_driver *driver,
goto cleanup; goto cleanup;
} }
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) { if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
if (qemuAssignDeviceControllerAlias(detach) < 0) if (qemuAssignDeviceControllerAlias(detach) < 0)
goto cleanup; goto cleanup;
} }
qemuDomainObjEnterMonitorWithDriver(driver, vm); qemuDomainObjEnterMonitorWithDriver(driver, vm);
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) { if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
if (qemuMonitorDelDevice(priv->mon, detach->info.alias)) { if (qemuMonitorDelDevice(priv->mon, detach->info.alias)) {
qemuDomainObjExitMonitor(vm); qemuDomainObjExitMonitor(vm);
goto cleanup; goto cleanup;
@ -1419,7 +1419,7 @@ int qemuDomainDetachPciControllerDevice(struct qemud_driver *driver,
vm->def->ncontrollers = 0; vm->def->ncontrollers = 0;
} }
if ((qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) && if ((qemuCmdFlags & QEMU_CAPS_DEVICE) &&
qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &detach->info) < 0) qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &detach->info) < 0)
VIR_WARN0("Unable to release PCI address on controller"); VIR_WARN0("Unable to release PCI address on controller");
@ -1479,7 +1479,7 @@ int qemuDomainDetachNetDevice(struct qemud_driver *driver,
} }
qemuDomainObjEnterMonitorWithDriver(driver, vm); qemuDomainObjEnterMonitorWithDriver(driver, vm);
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) { if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
if (qemuMonitorDelDevice(priv->mon, detach->info.alias) < 0) { if (qemuMonitorDelDevice(priv->mon, detach->info.alias) < 0) {
qemuDomainObjExitMonitor(vm); qemuDomainObjExitMonitor(vm);
qemuDomainNetAudit(vm, detach, NULL, "detach", false); qemuDomainNetAudit(vm, detach, NULL, "detach", false);
@ -1494,8 +1494,8 @@ int qemuDomainDetachNetDevice(struct qemud_driver *driver,
} }
} }
if ((qemuCmdFlags & QEMUD_CMD_FLAG_NETDEV) && if ((qemuCmdFlags & QEMU_CAPS_NETDEV) &&
(qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE)) { (qemuCmdFlags & QEMU_CAPS_DEVICE)) {
if (qemuMonitorRemoveNetdev(priv->mon, hostnet_name) < 0) { if (qemuMonitorRemoveNetdev(priv->mon, hostnet_name) < 0) {
qemuDomainObjExitMonitorWithDriver(driver, vm); qemuDomainObjExitMonitorWithDriver(driver, vm);
qemuDomainNetAudit(vm, detach, NULL, "detach", false); qemuDomainNetAudit(vm, detach, NULL, "detach", false);
@ -1512,7 +1512,7 @@ int qemuDomainDetachNetDevice(struct qemud_driver *driver,
qemuDomainNetAudit(vm, detach, NULL, "detach", true); qemuDomainNetAudit(vm, detach, NULL, "detach", true);
if ((qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) && if ((qemuCmdFlags & QEMU_CAPS_DEVICE) &&
qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &detach->info) < 0) qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &detach->info) < 0)
VIR_WARN0("Unable to release PCI address on NIC"); VIR_WARN0("Unable to release PCI address on NIC");
@ -1605,7 +1605,7 @@ int qemuDomainDetachHostPciDevice(struct qemud_driver *driver,
} }
qemuDomainObjEnterMonitorWithDriver(driver, vm); qemuDomainObjEnterMonitorWithDriver(driver, vm);
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) { if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
if (qemuMonitorDelDevice(priv->mon, detach->info.alias) < 0) { if (qemuMonitorDelDevice(priv->mon, detach->info.alias) < 0) {
qemuDomainObjExitMonitor(vm); qemuDomainObjExitMonitor(vm);
return -1; return -1;
@ -1636,7 +1636,7 @@ int qemuDomainDetachHostPciDevice(struct qemud_driver *driver,
pciFreeDevice(pci); pciFreeDevice(pci);
} }
if ((qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) && if ((qemuCmdFlags & QEMU_CAPS_DEVICE) &&
qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &detach->info) < 0) qemuDomainPCIAddressReleaseAddr(priv->pciaddrs, &detach->info) < 0)
VIR_WARN0("Unable to release PCI address on host device"); VIR_WARN0("Unable to release PCI address on host device");
@ -1707,7 +1707,7 @@ int qemuDomainDetachHostUsbDevice(struct qemud_driver *driver,
return -1; return -1;
} }
if (!(qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE)) { if (!(qemuCmdFlags & QEMU_CAPS_DEVICE)) {
qemuReportError(VIR_ERR_OPERATION_FAILED, qemuReportError(VIR_ERR_OPERATION_FAILED,
"%s", _("device cannot be detached with this QEMU version")); "%s", _("device cannot be detached with this QEMU version"));
return -1; return -1;

12
src/qemu/qemu_migration.c
View File

@ -304,9 +304,9 @@ qemuMigrationPrepareTunnel(struct qemud_driver *driver,
vm->def->emulator); vm->def->emulator);
goto endjob; goto endjob;
} }
if (qemuCmdFlags & QEMUD_CMD_FLAG_MIGRATE_QEMU_UNIX) if (qemuCmdFlags & QEMU_CAPS_MIGRATE_QEMU_UNIX)
internalret = virAsprintf(&migrateFrom, "unix:%s", unixfile); internalret = virAsprintf(&migrateFrom, "unix:%s", unixfile);
else if (qemuCmdFlags & QEMUD_CMD_FLAG_MIGRATE_QEMU_EXEC) else if (qemuCmdFlags & QEMU_CAPS_MIGRATE_QEMU_EXEC)
internalret = virAsprintf(&migrateFrom, "exec:nc -U -l %s", unixfile); internalret = virAsprintf(&migrateFrom, "exec:nc -U -l %s", unixfile);
else { else {
qemuReportError(VIR_ERR_OPERATION_FAILED, qemuReportError(VIR_ERR_OPERATION_FAILED,
@ -777,8 +777,8 @@ static int doTunnelMigrate(struct qemud_driver *driver,
goto cleanup; goto cleanup;
} }
if (!(qemuCmdFlags & QEMUD_CMD_FLAG_MIGRATE_QEMU_UNIX) && if (!(qemuCmdFlags & QEMU_CAPS_MIGRATE_QEMU_UNIX) &&
!(qemuCmdFlags & QEMUD_CMD_FLAG_MIGRATE_QEMU_EXEC)) { !(qemuCmdFlags & QEMU_CAPS_MIGRATE_QEMU_EXEC)) {
qemuReportError(VIR_ERR_OPERATION_FAILED, qemuReportError(VIR_ERR_OPERATION_FAILED,
"%s", _("Source qemu is too old to support tunnelled migration")); "%s", _("Source qemu is too old to support tunnelled migration"));
goto cleanup; goto cleanup;
@ -820,11 +820,11 @@ static int doTunnelMigrate(struct qemud_driver *driver,
background_flags |= QEMU_MONITOR_MIGRATE_NON_SHARED_DISK; background_flags |= QEMU_MONITOR_MIGRATE_NON_SHARED_DISK;
if (flags & VIR_MIGRATE_NON_SHARED_INC) if (flags & VIR_MIGRATE_NON_SHARED_INC)
background_flags |= QEMU_MONITOR_MIGRATE_NON_SHARED_INC; background_flags |= QEMU_MONITOR_MIGRATE_NON_SHARED_INC;
if (qemuCmdFlags & QEMUD_CMD_FLAG_MIGRATE_QEMU_UNIX){ if (qemuCmdFlags & QEMU_CAPS_MIGRATE_QEMU_UNIX){
internalret = qemuMonitorMigrateToUnix(priv->mon, background_flags, internalret = qemuMonitorMigrateToUnix(priv->mon, background_flags,
unixfile); unixfile);
} }
else if (qemuCmdFlags & QEMUD_CMD_FLAG_MIGRATE_QEMU_EXEC) { else if (qemuCmdFlags & QEMU_CAPS_MIGRATE_QEMU_EXEC) {
const char *args[] = { "nc", "-U", unixfile, NULL }; const char *args[] = { "nc", "-U", unixfile, NULL };
internalret = qemuMonitorMigrateToCommand(priv->mon, QEMU_MONITOR_MIGRATE_BACKGROUND, args); internalret = qemuMonitorMigrateToCommand(priv->mon, QEMU_MONITOR_MIGRATE_BACKGROUND, args);
} else { } else {

10
src/qemu/qemu_process.c
View File

@ -1159,7 +1159,7 @@ qemuProcessInitPasswords(virConnectPtr conn,
if (ret < 0) if (ret < 0)
goto cleanup; goto cleanup;
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) { if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
int i; int i;
for (i = 0 ; i < vm->def->ndisks ; i++) { for (i = 0 ; i < vm->def->ndisks ; i++) {
@ -1816,7 +1816,7 @@ qemuProcessReconnect(void *payload, const char *name ATTRIBUTE_UNUSED, void *opa
if (qemuCapsExtractVersionInfo(obj->def->emulator, obj->def->os.arch, if (qemuCapsExtractVersionInfo(obj->def->emulator, obj->def->os.arch,
NULL, NULL,
&qemuCmdFlags) >= 0 && &qemuCmdFlags) >= 0 &&
(qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE)) { (qemuCmdFlags & QEMU_CAPS_DEVICE)) {
priv->persistentAddrs = 1; priv->persistentAddrs = 1;
if (!(priv->pciaddrs = qemuDomainPCIAddressSetCreate(obj->def)) || if (!(priv->pciaddrs = qemuDomainPCIAddressSetCreate(obj->def)) ||
@ -2027,7 +2027,7 @@ int qemuProcessStart(virConnectPtr conn,
goto cleanup; goto cleanup;
#if HAVE_YAJL #if HAVE_YAJL
if (qemuCmdFlags & QEMUD_CMD_FLAG_MONITOR_JSON) if (qemuCmdFlags & QEMU_CAPS_MONITOR_JSON)
priv->monJSON = 1; priv->monJSON = 1;
else else
#endif #endif
@ -2056,7 +2056,7 @@ int qemuProcessStart(virConnectPtr conn,
* we also need to populate the PCi address set cache for later * we also need to populate the PCi address set cache for later
* use in hotplug * use in hotplug
*/ */
if (qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE) { if (qemuCmdFlags & QEMU_CAPS_DEVICE) {
VIR_DEBUG0("Assigning domain PCI addresses"); VIR_DEBUG0("Assigning domain PCI addresses");
/* Populate cache with current addresses */ /* Populate cache with current addresses */
if (priv->pciaddrs) { if (priv->pciaddrs) {
@ -2190,7 +2190,7 @@ int qemuProcessStart(virConnectPtr conn,
/* If we have -device, then addresses are assigned explicitly. /* If we have -device, then addresses are assigned explicitly.
* If not, then we have to detect dynamic ones here */ * If not, then we have to detect dynamic ones here */
if (!(qemuCmdFlags & QEMUD_CMD_FLAG_DEVICE)) { if (!(qemuCmdFlags & QEMU_CAPS_DEVICE)) {
VIR_DEBUG0("Determining domain device PCI addresses"); VIR_DEBUG0("Determining domain device PCI addresses");
if (qemuProcessInitPCIAddresses(driver, vm) < 0) if (qemuProcessInitPCIAddresses(driver, vm) < 0)
goto cleanup; goto cleanup;

2
tests/qemuargv2xmltest.c
View File

@ -145,7 +145,7 @@ mymain(int argc, char **argv)
unsetenv("LD_LIBRARY_PATH"); unsetenv("LD_LIBRARY_PATH");
/* Can't roundtrip vcpu cpuset attribute */ /* Can't roundtrip vcpu cpuset attribute */
/*DO_TEST("minimal", QEMUD_CMD_FLAG_NAME);*/ /*DO_TEST("minimal", QEMU_CAPS_NAME);*/
DO_TEST("boot-cdrom"); DO_TEST("boot-cdrom");
DO_TEST("boot-network"); DO_TEST("boot-network");
DO_TEST("boot-floppy"); DO_TEST("boot-floppy");

656
tests/qemuhelptest.c
View File

@ -57,7 +57,7 @@ static int testHelpStrParsing(const void *data)
&version, &is_kvm, &kvm_version) == -1) &version, &is_kvm, &kvm_version) == -1)
goto cleanup; goto cleanup;
if (info->flags & QEMUD_CMD_FLAG_DEVICE) { if (info->flags & QEMU_CAPS_DEVICE) {
VIR_FREE(path); VIR_FREE(path);
if (virAsprintf(&path, "%s/qemuhelpdata/%s-device", abs_srcdir, if (virAsprintf(&path, "%s/qemuhelpdata/%s-device", abs_srcdir,
info->name) < 0) info->name) < 0)
@ -133,355 +133,355 @@ mymain(int argc, char **argv)
} while (0) } while (0)
DO_TEST("qemu-0.9.1", DO_TEST("qemu-0.9.1",
QEMUD_CMD_FLAG_KQEMU | QEMU_CAPS_KQEMU |
QEMUD_CMD_FLAG_VNC_COLON | QEMU_CAPS_VNC_COLON |
QEMUD_CMD_FLAG_NO_REBOOT | QEMU_CAPS_NO_REBOOT |
QEMUD_CMD_FLAG_DRIVE | QEMU_CAPS_DRIVE |
QEMUD_CMD_FLAG_NAME, QEMU_CAPS_NAME,
9001, 0, 0); 9001, 0, 0);
DO_TEST("kvm-74", DO_TEST("kvm-74",
QEMUD_CMD_FLAG_VNC_COLON | QEMU_CAPS_VNC_COLON |
QEMUD_CMD_FLAG_NO_REBOOT | QEMU_CAPS_NO_REBOOT |
QEMUD_CMD_FLAG_DRIVE | QEMU_CAPS_DRIVE |
QEMUD_CMD_FLAG_DRIVE_BOOT | QEMU_CAPS_DRIVE_BOOT |
QEMUD_CMD_FLAG_NAME | QEMU_CAPS_NAME |
QEMUD_CMD_FLAG_VNET_HDR | QEMU_CAPS_VNET_HDR |
QEMUD_CMD_FLAG_MIGRATE_KVM_STDIO | QEMU_CAPS_MIGRATE_KVM_STDIO |
QEMUD_CMD_FLAG_KVM | QEMU_CAPS_KVM |
QEMUD_CMD_FLAG_DRIVE_FORMAT | QEMU_CAPS_DRIVE_FORMAT |
QEMUD_CMD_FLAG_MEM_PATH | QEMU_CAPS_MEM_PATH |
QEMUD_CMD_FLAG_TDF, QEMU_CAPS_TDF,
9001, 1, 74); 9001, 1, 74);
DO_TEST("kvm-83-rhel56", DO_TEST("kvm-83-rhel56",
QEMUD_CMD_FLAG_VNC_COLON | QEMU_CAPS_VNC_COLON |
QEMUD_CMD_FLAG_NO_REBOOT | QEMU_CAPS_NO_REBOOT |
QEMUD_CMD_FLAG_DRIVE | QEMU_CAPS_DRIVE |
QEMUD_CMD_FLAG_DRIVE_BOOT | QEMU_CAPS_DRIVE_BOOT |
QEMUD_CMD_FLAG_NAME | QEMU_CAPS_NAME |
QEMUD_CMD_FLAG_UUID | QEMU_CAPS_UUID |
QEMUD_CMD_FLAG_VNET_HDR | QEMU_CAPS_VNET_HDR |
QEMUD_CMD_FLAG_MIGRATE_QEMU_TCP | QEMU_CAPS_MIGRATE_QEMU_TCP |
QEMUD_CMD_FLAG_MIGRATE_QEMU_EXEC | QEMU_CAPS_MIGRATE_QEMU_EXEC |
QEMUD_CMD_FLAG_DRIVE_CACHE_V2 | QEMU_CAPS_DRIVE_CACHE_V2 |
QEMUD_CMD_FLAG_KVM | QEMU_CAPS_KVM |
QEMUD_CMD_FLAG_DRIVE_FORMAT | QEMU_CAPS_DRIVE_FORMAT |
QEMUD_CMD_FLAG_DRIVE_SERIAL | QEMU_CAPS_DRIVE_SERIAL |
QEMUD_CMD_FLAG_VGA | QEMU_CAPS_VGA |
QEMUD_CMD_FLAG_PCIDEVICE | QEMU_CAPS_PCIDEVICE |
QEMUD_CMD_FLAG_MEM_PATH | QEMU_CAPS_MEM_PATH |
QEMUD_CMD_FLAG_BALLOON | QEMU_CAPS_BALLOON |
QEMUD_CMD_FLAG_RTC_TD_HACK | QEMU_CAPS_RTC_TD_HACK |
QEMUD_CMD_FLAG_NO_HPET | QEMU_CAPS_NO_HPET |
QEMUD_CMD_FLAG_NO_KVM_PIT | QEMU_CAPS_NO_KVM_PIT |
QEMUD_CMD_FLAG_TDF | QEMU_CAPS_TDF |
QEMUD_CMD_FLAG_DRIVE_READONLY | QEMU_CAPS_DRIVE_READONLY |
QEMUD_CMD_FLAG_SMBIOS_TYPE | QEMU_CAPS_SMBIOS_TYPE |
QEMUD_CMD_FLAG_SPICE, QEMU_CAPS_SPICE,
9001, 1, 83); 9001, 1, 83);
DO_TEST("qemu-0.10.5", DO_TEST("qemu-0.10.5",
QEMUD_CMD_FLAG_KQEMU | QEMU_CAPS_KQEMU |
QEMUD_CMD_FLAG_VNC_COLON | QEMU_CAPS_VNC_COLON |
QEMUD_CMD_FLAG_NO_REBOOT | QEMU_CAPS_NO_REBOOT |
QEMUD_CMD_FLAG_DRIVE | QEMU_CAPS_DRIVE |
QEMUD_CMD_FLAG_NAME | QEMU_CAPS_NAME |
QEMUD_CMD_FLAG_UUID | QEMU_CAPS_UUID |
QEMUD_CMD_FLAG_MIGRATE_QEMU_TCP | QEMU_CAPS_MIGRATE_QEMU_TCP |
QEMUD_CMD_FLAG_MIGRATE_QEMU_EXEC | QEMU_CAPS_MIGRATE_QEMU_EXEC |
QEMUD_CMD_FLAG_DRIVE_CACHE_V2 | QEMU_CAPS_DRIVE_CACHE_V2 |
QEMUD_CMD_FLAG_DRIVE_FORMAT | QEMU_CAPS_DRIVE_FORMAT |
QEMUD_CMD_FLAG_DRIVE_SERIAL | QEMU_CAPS_DRIVE_SERIAL |
QEMUD_CMD_FLAG_VGA | QEMU_CAPS_VGA |
QEMUD_CMD_FLAG_0_10 | QEMU_CAPS_0_10 |
QEMUD_CMD_FLAG_ENABLE_KVM | QEMU_CAPS_ENABLE_KVM |
QEMUD_CMD_FLAG_SDL | QEMU_CAPS_SDL |
QEMUD_CMD_FLAG_RTC_TD_HACK | QEMU_CAPS_RTC_TD_HACK |
QEMUD_CMD_FLAG_NO_HPET | QEMU_CAPS_NO_HPET |
QEMUD_CMD_FLAG_VGA_NONE, QEMU_CAPS_VGA_NONE,
10005, 0, 0); 10005, 0, 0);
DO_TEST("qemu-kvm-0.10.5", DO_TEST("qemu-kvm-0.10.5",
QEMUD_CMD_FLAG_VNC_COLON | QEMU_CAPS_VNC_COLON |
QEMUD_CMD_FLAG_NO_REBOOT | QEMU_CAPS_NO_REBOOT |
QEMUD_CMD_FLAG_DRIVE | QEMU_CAPS_DRIVE |
QEMUD_CMD_FLAG_DRIVE_BOOT | QEMU_CAPS_DRIVE_BOOT |
QEMUD_CMD_FLAG_NAME | QEMU_CAPS_NAME |
QEMUD_CMD_FLAG_UUID | QEMU_CAPS_UUID |
QEMUD_CMD_FLAG_VNET_HDR | QEMU_CAPS_VNET_HDR |
QEMUD_CMD_FLAG_MIGRATE_QEMU_TCP | QEMU_CAPS_MIGRATE_QEMU_TCP |
QEMUD_CMD_FLAG_MIGRATE_QEMU_EXEC | QEMU_CAPS_MIGRATE_QEMU_EXEC |
QEMUD_CMD_FLAG_DRIVE_CACHE_V2 | QEMU_CAPS_DRIVE_CACHE_V2 |
QEMUD_CMD_FLAG_KVM | QEMU_CAPS_KVM |
QEMUD_CMD_FLAG_DRIVE_FORMAT | QEMU_CAPS_DRIVE_FORMAT |
QEMUD_CMD_FLAG_DRIVE_SERIAL | QEMU_CAPS_DRIVE_SERIAL |
QEMUD_CMD_FLAG_VGA | QEMU_CAPS_VGA |
QEMUD_CMD_FLAG_0_10 | QEMU_CAPS_0_10 |
QEMUD_CMD_FLAG_PCIDEVICE | QEMU_CAPS_PCIDEVICE |
QEMUD_CMD_FLAG_MEM_PATH | QEMU_CAPS_MEM_PATH |
QEMUD_CMD_FLAG_SDL | QEMU_CAPS_SDL |
QEMUD_CMD_FLAG_RTC_TD_HACK | QEMU_CAPS_RTC_TD_HACK |
QEMUD_CMD_FLAG_NO_HPET | QEMU_CAPS_NO_HPET |
QEMUD_CMD_FLAG_NO_KVM_PIT | QEMU_CAPS_NO_KVM_PIT |
QEMUD_CMD_FLAG_TDF | QEMU_CAPS_TDF |
QEMUD_CMD_FLAG_NESTING | QEMU_CAPS_NESTING |
QEMUD_CMD_FLAG_VGA_NONE, QEMU_CAPS_VGA_NONE,
10005, 1, 0); 10005, 1, 0);
DO_TEST("kvm-86", DO_TEST("kvm-86",
QEMUD_CMD_FLAG_VNC_COLON | QEMU_CAPS_VNC_COLON |
QEMUD_CMD_FLAG_NO_REBOOT | QEMU_CAPS_NO_REBOOT |
QEMUD_CMD_FLAG_DRIVE | QEMU_CAPS_DRIVE |
QEMUD_CMD_FLAG_DRIVE_BOOT | QEMU_CAPS_DRIVE_BOOT |
QEMUD_CMD_FLAG_NAME | QEMU_CAPS_NAME |
QEMUD_CMD_FLAG_UUID | QEMU_CAPS_UUID |
QEMUD_CMD_FLAG_VNET_HDR | QEMU_CAPS_VNET_HDR |
QEMUD_CMD_FLAG_MIGRATE_QEMU_TCP | QEMU_CAPS_MIGRATE_QEMU_TCP |
QEMUD_CMD_FLAG_MIGRATE_QEMU_EXEC | QEMU_CAPS_MIGRATE_QEMU_EXEC |
QEMUD_CMD_FLAG_DRIVE_CACHE_V2 | QEMU_CAPS_DRIVE_CACHE_V2 |
QEMUD_CMD_FLAG_KVM | QEMU_CAPS_KVM |
QEMUD_CMD_FLAG_DRIVE_FORMAT | QEMU_CAPS_DRIVE_FORMAT |
QEMUD_CMD_FLAG_DRIVE_SERIAL | QEMU_CAPS_DRIVE_SERIAL |
QEMUD_CMD_FLAG_VGA | QEMU_CAPS_VGA |
QEMUD_CMD_FLAG_0_10 | QEMU_CAPS_0_10 |
QEMUD_CMD_FLAG_PCIDEVICE | QEMU_CAPS_PCIDEVICE |
QEMUD_CMD_FLAG_SDL | QEMU_CAPS_SDL |
QEMUD_CMD_FLAG_RTC_TD_HACK | QEMU_CAPS_RTC_TD_HACK |
QEMUD_CMD_FLAG_NO_HPET | QEMU_CAPS_NO_HPET |
QEMUD_CMD_FLAG_NO_KVM_PIT | QEMU_CAPS_NO_KVM_PIT |
QEMUD_CMD_FLAG_TDF | QEMU_CAPS_TDF |
QEMUD_CMD_FLAG_NESTING | QEMU_CAPS_NESTING |
QEMUD_CMD_FLAG_SMBIOS_TYPE | QEMU_CAPS_SMBIOS_TYPE |
QEMUD_CMD_FLAG_VGA_NONE, QEMU_CAPS_VGA_NONE,
10050, 1, 0); 10050, 1, 0);
DO_TEST("qemu-kvm-0.11.0-rc2", DO_TEST("qemu-kvm-0.11.0-rc2",
QEMUD_CMD_FLAG_VNC_COLON | QEMU_CAPS_VNC_COLON |
QEMUD_CMD_FLAG_NO_REBOOT | QEMU_CAPS_NO_REBOOT |
QEMUD_CMD_FLAG_DRIVE | QEMU_CAPS_DRIVE |
QEMUD_CMD_FLAG_DRIVE_BOOT | QEMU_CAPS_DRIVE_BOOT |
QEMUD_CMD_FLAG_NAME | QEMU_CAPS_NAME |
QEMUD_CMD_FLAG_UUID | QEMU_CAPS_UUID |
QEMUD_CMD_FLAG_VNET_HDR | QEMU_CAPS_VNET_HDR |
QEMUD_CMD_FLAG_MIGRATE_QEMU_TCP | QEMU_CAPS_MIGRATE_QEMU_TCP |
QEMUD_CMD_FLAG_MIGRATE_QEMU_EXEC | QEMU_CAPS_MIGRATE_QEMU_EXEC |
QEMUD_CMD_FLAG_DRIVE_CACHE_V2 | QEMU_CAPS_DRIVE_CACHE_V2 |
QEMUD_CMD_FLAG_KVM | QEMU_CAPS_KVM |
QEMUD_CMD_FLAG_DRIVE_FORMAT | QEMU_CAPS_DRIVE_FORMAT |
QEMUD_CMD_FLAG_DRIVE_SERIAL | QEMU_CAPS_DRIVE_SERIAL |
QEMUD_CMD_FLAG_VGA | QEMU_CAPS_VGA |
QEMUD_CMD_FLAG_0_10 | QEMU_CAPS_0_10 |
QEMUD_CMD_FLAG_PCIDEVICE | QEMU_CAPS_PCIDEVICE |
QEMUD_CMD_FLAG_MEM_PATH | QEMU_CAPS_MEM_PATH |
QEMUD_CMD_FLAG_ENABLE_KVM | QEMU_CAPS_ENABLE_KVM |
QEMUD_CMD_FLAG_BALLOON | QEMU_CAPS_BALLOON |
QEMUD_CMD_FLAG_SDL | QEMU_CAPS_SDL |
QEMUD_CMD_FLAG_RTC_TD_HACK | QEMU_CAPS_RTC_TD_HACK |
QEMUD_CMD_FLAG_NO_HPET | QEMU_CAPS_NO_HPET |
QEMUD_CMD_FLAG_NO_KVM_PIT | QEMU_CAPS_NO_KVM_PIT |
QEMUD_CMD_FLAG_TDF | QEMU_CAPS_TDF |
QEMUD_CMD_FLAG_BOOT_MENU | QEMU_CAPS_BOOT_MENU |
QEMUD_CMD_FLAG_NESTING | QEMU_CAPS_NESTING |
QEMUD_CMD_FLAG_NAME_PROCESS | QEMU_CAPS_NAME_PROCESS |
QEMUD_CMD_FLAG_SMBIOS_TYPE | QEMU_CAPS_SMBIOS_TYPE |
QEMUD_CMD_FLAG_VGA_NONE, QEMU_CAPS_VGA_NONE,
10092, 1, 0); 10092, 1, 0);
DO_TEST("qemu-0.12.1", DO_TEST("qemu-0.12.1",
QEMUD_CMD_FLAG_VNC_COLON | QEMU_CAPS_VNC_COLON |
QEMUD_CMD_FLAG_NO_REBOOT | QEMU_CAPS_NO_REBOOT |
QEMUD_CMD_FLAG_DRIVE | QEMU_CAPS_DRIVE |
QEMUD_CMD_FLAG_NAME | QEMU_CAPS_NAME |
QEMUD_CMD_FLAG_UUID | QEMU_CAPS_UUID |
QEMUD_CMD_FLAG_MIGRATE_QEMU_TCP | QEMU_CAPS_MIGRATE_QEMU_TCP |
QEMUD_CMD_FLAG_MIGRATE_QEMU_EXEC | QEMU_CAPS_MIGRATE_QEMU_EXEC |
QEMUD_CMD_FLAG_DRIVE_CACHE_V2 | QEMU_CAPS_DRIVE_CACHE_V2 |
QEMUD_CMD_FLAG_DRIVE_FORMAT | QEMU_CAPS_DRIVE_FORMAT |
QEMUD_CMD_FLAG_DRIVE_SERIAL | QEMU_CAPS_DRIVE_SERIAL |
QEMUD_CMD_FLAG_DRIVE_READONLY | QEMU_CAPS_DRIVE_READONLY |
QEMUD_CMD_FLAG_VGA | QEMU_CAPS_VGA |
QEMUD_CMD_FLAG_0_10 | QEMU_CAPS_0_10 |
QEMUD_CMD_FLAG_ENABLE_KVM | QEMU_CAPS_ENABLE_KVM |
QEMUD_CMD_FLAG_SDL | QEMU_CAPS_SDL |
QEMUD_CMD_FLAG_XEN_DOMID | QEMU_CAPS_XEN_DOMID |
QEMUD_CMD_FLAG_MIGRATE_QEMU_UNIX | QEMU_CAPS_MIGRATE_QEMU_UNIX |
QEMUD_CMD_FLAG_CHARDEV | QEMU_CAPS_CHARDEV |
QEMUD_CMD_FLAG_BALLOON | QEMU_CAPS_BALLOON |
QEMUD_CMD_FLAG_DEVICE | QEMU_CAPS_DEVICE |
QEMUD_CMD_FLAG_SMP_TOPOLOGY | QEMU_CAPS_SMP_TOPOLOGY |
QEMUD_CMD_FLAG_RTC | QEMU_CAPS_RTC |
QEMUD_CMD_FLAG_NO_HPET | QEMU_CAPS_NO_HPET |
QEMUD_CMD_FLAG_BOOT_MENU | QEMU_CAPS_BOOT_MENU |
QEMUD_CMD_FLAG_NAME_PROCESS | QEMU_CAPS_NAME_PROCESS |
QEMUD_CMD_FLAG_SMBIOS_TYPE | QEMU_CAPS_SMBIOS_TYPE |
QEMUD_CMD_FLAG_VGA_NONE | QEMU_CAPS_VGA_NONE |
QEMUD_CMD_FLAG_MIGRATE_QEMU_FD | QEMU_CAPS_MIGRATE_QEMU_FD |
QEMUD_CMD_FLAG_DRIVE_AIO, QEMU_CAPS_DRIVE_AIO,
12001, 0, 0); 12001, 0, 0);
DO_TEST("qemu-kvm-0.12.1.2-rhel60", DO_TEST("qemu-kvm-0.12.1.2-rhel60",
QEMUD_CMD_FLAG_VNC_COLON | QEMU_CAPS_VNC_COLON |
QEMUD_CMD_FLAG_NO_REBOOT | QEMU_CAPS_NO_REBOOT |
QEMUD_CMD_FLAG_DRIVE | QEMU_CAPS_DRIVE |
QEMUD_CMD_FLAG_DRIVE_BOOT | QEMU_CAPS_DRIVE_BOOT |
QEMUD_CMD_FLAG_NAME | QEMU_CAPS_NAME |
QEMUD_CMD_FLAG_UUID | QEMU_CAPS_UUID |
QEMUD_CMD_FLAG_VNET_HDR | QEMU_CAPS_VNET_HDR |
QEMUD_CMD_FLAG_MIGRATE_QEMU_TCP | QEMU_CAPS_MIGRATE_QEMU_TCP |
QEMUD_CMD_FLAG_MIGRATE_QEMU_EXEC | QEMU_CAPS_MIGRATE_QEMU_EXEC |
QEMUD_CMD_FLAG_DRIVE_CACHE_V2 | QEMU_CAPS_DRIVE_CACHE_V2 |
QEMUD_CMD_FLAG_KVM | QEMU_CAPS_KVM |
QEMUD_CMD_FLAG_DRIVE_FORMAT | QEMU_CAPS_DRIVE_FORMAT |
QEMUD_CMD_FLAG_DRIVE_SERIAL | QEMU_CAPS_DRIVE_SERIAL |
QEMUD_CMD_FLAG_DRIVE_READONLY | QEMU_CAPS_DRIVE_READONLY |
QEMUD_CMD_FLAG_VGA | QEMU_CAPS_VGA |
QEMUD_CMD_FLAG_0_10 | QEMU_CAPS_0_10 |
QEMUD_CMD_FLAG_PCIDEVICE | QEMU_CAPS_PCIDEVICE |
QEMUD_CMD_FLAG_MEM_PATH | QEMU_CAPS_MEM_PATH |
QEMUD_CMD_FLAG_MIGRATE_QEMU_UNIX | QEMU_CAPS_MIGRATE_QEMU_UNIX |
QEMUD_CMD_FLAG_CHARDEV | QEMU_CAPS_CHARDEV |
QEMUD_CMD_FLAG_ENABLE_KVM | QEMU_CAPS_ENABLE_KVM |
QEMUD_CMD_FLAG_BALLOON | QEMU_CAPS_BALLOON |
QEMUD_CMD_FLAG_DEVICE | QEMU_CAPS_DEVICE |
QEMUD_CMD_FLAG_SMP_TOPOLOGY | QEMU_CAPS_SMP_TOPOLOGY |
QEMUD_CMD_FLAG_RTC | QEMU_CAPS_RTC |
QEMUD_CMD_FLAG_VNET_HOST | QEMU_CAPS_VNET_HOST |
QEMUD_CMD_FLAG_NO_KVM_PIT | QEMU_CAPS_NO_KVM_PIT |
QEMUD_CMD_FLAG_TDF | QEMU_CAPS_TDF |
QEMUD_CMD_FLAG_PCI_CONFIGFD | QEMU_CAPS_PCI_CONFIGFD |
QEMUD_CMD_FLAG_NODEFCONFIG | QEMU_CAPS_NODEFCONFIG |
QEMUD_CMD_FLAG_BOOT_MENU | QEMU_CAPS_BOOT_MENU |
QEMUD_CMD_FLAG_NESTING | QEMU_CAPS_NESTING |
QEMUD_CMD_FLAG_NAME_PROCESS | QEMU_CAPS_NAME_PROCESS |
QEMUD_CMD_FLAG_SMBIOS_TYPE | QEMU_CAPS_SMBIOS_TYPE |
QEMUD_CMD_FLAG_VGA_QXL | QEMU_CAPS_VGA_QXL |
QEMUD_CMD_FLAG_SPICE | QEMU_CAPS_SPICE |
QEMUD_CMD_FLAG_VGA_NONE | QEMU_CAPS_VGA_NONE |
QEMUD_CMD_FLAG_MIGRATE_QEMU_FD | QEMU_CAPS_MIGRATE_QEMU_FD |
QEMUD_CMD_FLAG_DRIVE_AIO | QEMU_CAPS_DRIVE_AIO |
QEMUD_CMD_FLAG_DEVICE_SPICEVMC, QEMU_CAPS_DEVICE_SPICEVMC,
12001, 1, 0); 12001, 1, 0);
DO_TEST("qemu-kvm-0.12.3", DO_TEST("qemu-kvm-0.12.3",
QEMUD_CMD_FLAG_VNC_COLON | QEMU_CAPS_VNC_COLON |
QEMUD_CMD_FLAG_NO_REBOOT | QEMU_CAPS_NO_REBOOT |
QEMUD_CMD_FLAG_DRIVE | QEMU_CAPS_DRIVE |
QEMUD_CMD_FLAG_DRIVE_BOOT | QEMU_CAPS_DRIVE_BOOT |
QEMUD_CMD_FLAG_NAME | QEMU_CAPS_NAME |
QEMUD_CMD_FLAG_UUID | QEMU_CAPS_UUID |
QEMUD_CMD_FLAG_VNET_HDR | QEMU_CAPS_VNET_HDR |
QEMUD_CMD_FLAG_MIGRATE_QEMU_TCP | QEMU_CAPS_MIGRATE_QEMU_TCP |
QEMUD_CMD_FLAG_MIGRATE_QEMU_EXEC | QEMU_CAPS_MIGRATE_QEMU_EXEC |
QEMUD_CMD_FLAG_DRIVE_CACHE_V2 | QEMU_CAPS_DRIVE_CACHE_V2 |
QEMUD_CMD_FLAG_KVM | QEMU_CAPS_KVM |
QEMUD_CMD_FLAG_DRIVE_FORMAT | QEMU_CAPS_DRIVE_FORMAT |
QEMUD_CMD_FLAG_DRIVE_SERIAL | QEMU_CAPS_DRIVE_SERIAL |
QEMUD_CMD_FLAG_DRIVE_READONLY | QEMU_CAPS_DRIVE_READONLY |
QEMUD_CMD_FLAG_VGA | QEMU_CAPS_VGA |
QEMUD_CMD_FLAG_0_10 | QEMU_CAPS_0_10 |
QEMUD_CMD_FLAG_PCIDEVICE | QEMU_CAPS_PCIDEVICE |
QEMUD_CMD_FLAG_MEM_PATH | QEMU_CAPS_MEM_PATH |
QEMUD_CMD_FLAG_SDL | QEMU_CAPS_SDL |
QEMUD_CMD_FLAG_MIGRATE_QEMU_UNIX | QEMU_CAPS_MIGRATE_QEMU_UNIX |
QEMUD_CMD_FLAG_CHARDEV | QEMU_CAPS_CHARDEV |
QEMUD_CMD_FLAG_BALLOON | QEMU_CAPS_BALLOON |
QEMUD_CMD_FLAG_DEVICE | QEMU_CAPS_DEVICE |
QEMUD_CMD_FLAG_SMP_TOPOLOGY | QEMU_CAPS_SMP_TOPOLOGY |
QEMUD_CMD_FLAG_RTC | QEMU_CAPS_RTC |
QEMUD_CMD_FLAG_VNET_HOST | QEMU_CAPS_VNET_HOST |
QEMUD_CMD_FLAG_NO_HPET | QEMU_CAPS_NO_HPET |
QEMUD_CMD_FLAG_NO_KVM_PIT | QEMU_CAPS_NO_KVM_PIT |
QEMUD_CMD_FLAG_TDF | QEMU_CAPS_TDF |
QEMUD_CMD_FLAG_BOOT_MENU | QEMU_CAPS_BOOT_MENU |
QEMUD_CMD_FLAG_NESTING | QEMU_CAPS_NESTING |
QEMUD_CMD_FLAG_NAME_PROCESS | QEMU_CAPS_NAME_PROCESS |
QEMUD_CMD_FLAG_SMBIOS_TYPE | QEMU_CAPS_SMBIOS_TYPE |
QEMUD_CMD_FLAG_VGA_NONE | QEMU_CAPS_VGA_NONE |
QEMUD_CMD_FLAG_MIGRATE_QEMU_FD | QEMU_CAPS_MIGRATE_QEMU_FD |
QEMUD_CMD_FLAG_DRIVE_AIO, QEMU_CAPS_DRIVE_AIO,
12003, 1, 0); 12003, 1, 0);
DO_TEST("qemu-kvm-0.13.0", DO_TEST("qemu-kvm-0.13.0",
QEMUD_CMD_FLAG_VNC_COLON | QEMU_CAPS_VNC_COLON |
QEMUD_CMD_FLAG_NO_REBOOT | QEMU_CAPS_NO_REBOOT |
QEMUD_CMD_FLAG_DRIVE | QEMU_CAPS_DRIVE |
QEMUD_CMD_FLAG_DRIVE_BOOT | QEMU_CAPS_DRIVE_BOOT |
QEMUD_CMD_FLAG_NAME | QEMU_CAPS_NAME |
QEMUD_CMD_FLAG_UUID | QEMU_CAPS_UUID |
QEMUD_CMD_FLAG_VNET_HDR | QEMU_CAPS_VNET_HDR |
QEMUD_CMD_FLAG_MIGRATE_QEMU_TCP | QEMU_CAPS_MIGRATE_QEMU_TCP |
QEMUD_CMD_FLAG_MIGRATE_QEMU_EXEC | QEMU_CAPS_MIGRATE_QEMU_EXEC |
QEMUD_CMD_FLAG_DRIVE_CACHE_V2 | QEMU_CAPS_DRIVE_CACHE_V2 |
QEMUD_CMD_FLAG_KVM | QEMU_CAPS_KVM |
QEMUD_CMD_FLAG_DRIVE_FORMAT | QEMU_CAPS_DRIVE_FORMAT |
QEMUD_CMD_FLAG_DRIVE_SERIAL | QEMU_CAPS_DRIVE_SERIAL |
QEMUD_CMD_FLAG_XEN_DOMID | QEMU_CAPS_XEN_DOMID |
QEMUD_CMD_FLAG_DRIVE_READONLY | QEMU_CAPS_DRIVE_READONLY |
QEMUD_CMD_FLAG_VGA | QEMU_CAPS_VGA |
QEMUD_CMD_FLAG_0_10 | QEMU_CAPS_0_10 |
QEMUD_CMD_FLAG_PCIDEVICE | QEMU_CAPS_PCIDEVICE |
QEMUD_CMD_FLAG_MEM_PATH | QEMU_CAPS_MEM_PATH |
QEMUD_CMD_FLAG_SDL | QEMU_CAPS_SDL |
QEMUD_CMD_FLAG_MIGRATE_QEMU_UNIX | QEMU_CAPS_MIGRATE_QEMU_UNIX |
QEMUD_CMD_FLAG_CHARDEV | QEMU_CAPS_CHARDEV |
QEMUD_CMD_FLAG_ENABLE_KVM | QEMU_CAPS_ENABLE_KVM |
QEMUD_CMD_FLAG_MONITOR_JSON | QEMU_CAPS_MONITOR_JSON |
QEMUD_CMD_FLAG_BALLOON | QEMU_CAPS_BALLOON |
QEMUD_CMD_FLAG_DEVICE | QEMU_CAPS_DEVICE |
QEMUD_CMD_FLAG_SMP_TOPOLOGY | QEMU_CAPS_SMP_TOPOLOGY |
QEMUD_CMD_FLAG_NETDEV | QEMU_CAPS_NETDEV |
QEMUD_CMD_FLAG_RTC | QEMU_CAPS_RTC |
QEMUD_CMD_FLAG_VNET_HOST | QEMU_CAPS_VNET_HOST |
QEMUD_CMD_FLAG_NO_HPET | QEMU_CAPS_NO_HPET |
QEMUD_CMD_FLAG_NO_KVM_PIT | QEMU_CAPS_NO_KVM_PIT |
QEMUD_CMD_FLAG_TDF | QEMU_CAPS_TDF |
QEMUD_CMD_FLAG_PCI_CONFIGFD | QEMU_CAPS_PCI_CONFIGFD |
QEMUD_CMD_FLAG_NODEFCONFIG | QEMU_CAPS_NODEFCONFIG |
QEMUD_CMD_FLAG_BOOT_MENU | QEMU_CAPS_BOOT_MENU |
QEMUD_CMD_FLAG_FSDEV | QEMU_CAPS_FSDEV |
QEMUD_CMD_FLAG_NESTING | QEMU_CAPS_NESTING |
QEMUD_CMD_FLAG_NAME_PROCESS | QEMU_CAPS_NAME_PROCESS |
QEMUD_CMD_FLAG_SMBIOS_TYPE | QEMU_CAPS_SMBIOS_TYPE |
QEMUD_CMD_FLAG_SPICE | QEMU_CAPS_SPICE |
QEMUD_CMD_FLAG_VGA_NONE | QEMU_CAPS_VGA_NONE |
QEMUD_CMD_FLAG_MIGRATE_QEMU_FD | QEMU_CAPS_MIGRATE_QEMU_FD |
QEMUD_CMD_FLAG_DRIVE_AIO | QEMU_CAPS_DRIVE_AIO |
QEMUD_CMD_FLAG_DEVICE_SPICEVMC, QEMU_CAPS_DEVICE_SPICEVMC,
13000, 1, 0); 13000, 1, 0);
DO_TEST("qemu-kvm-0.12.1.2-rhel61", DO_TEST("qemu-kvm-0.12.1.2-rhel61",
QEMUD_CMD_FLAG_VNC_COLON | QEMU_CAPS_VNC_COLON |
QEMUD_CMD_FLAG_NO_REBOOT | QEMU_CAPS_NO_REBOOT |
QEMUD_CMD_FLAG_DRIVE | QEMU_CAPS_DRIVE |
QEMUD_CMD_FLAG_NAME | QEMU_CAPS_NAME |
QEMUD_CMD_FLAG_UUID | QEMU_CAPS_UUID |
QEMUD_CMD_FLAG_VNET_HDR | QEMU_CAPS_VNET_HDR |
QEMUD_CMD_FLAG_MIGRATE_QEMU_TCP | QEMU_CAPS_MIGRATE_QEMU_TCP |
QEMUD_CMD_FLAG_MIGRATE_QEMU_EXEC | QEMU_CAPS_MIGRATE_QEMU_EXEC |
QEMUD_CMD_FLAG_DRIVE_CACHE_V2 | QEMU_CAPS_DRIVE_CACHE_V2 |
QEMUD_CMD_FLAG_KVM | QEMU_CAPS_KVM |
QEMUD_CMD_FLAG_DRIVE_FORMAT | QEMU_CAPS_DRIVE_FORMAT |
QEMUD_CMD_FLAG_DRIVE_SERIAL | QEMU_CAPS_DRIVE_SERIAL |
QEMUD_CMD_FLAG_DRIVE_READONLY | QEMU_CAPS_DRIVE_READONLY |
QEMUD_CMD_FLAG_VGA | QEMU_CAPS_VGA |
QEMUD_CMD_FLAG_0_10 | QEMU_CAPS_0_10 |
QEMUD_CMD_FLAG_PCIDEVICE | QEMU_CAPS_PCIDEVICE |
QEMUD_CMD_FLAG_MEM_PATH | QEMU_CAPS_MEM_PATH |
QEMUD_CMD_FLAG_MIGRATE_QEMU_UNIX | QEMU_CAPS_MIGRATE_QEMU_UNIX |
QEMUD_CMD_FLAG_CHARDEV | QEMU_CAPS_CHARDEV |
QEMUD_CMD_FLAG_ENABLE_KVM | QEMU_CAPS_ENABLE_KVM |
QEMUD_CMD_FLAG_BALLOON | QEMU_CAPS_BALLOON |
QEMUD_CMD_FLAG_DEVICE | QEMU_CAPS_DEVICE |
QEMUD_CMD_FLAG_SMP_TOPOLOGY | QEMU_CAPS_SMP_TOPOLOGY |
QEMUD_CMD_FLAG_RTC | QEMU_CAPS_RTC |
QEMUD_CMD_FLAG_VNET_HOST | QEMU_CAPS_VNET_HOST |
QEMUD_CMD_FLAG_NO_KVM_PIT | QEMU_CAPS_NO_KVM_PIT |
QEMUD_CMD_FLAG_TDF | QEMU_CAPS_TDF |
QEMUD_CMD_FLAG_PCI_CONFIGFD | QEMU_CAPS_PCI_CONFIGFD |
QEMUD_CMD_FLAG_NODEFCONFIG | QEMU_CAPS_NODEFCONFIG |
QEMUD_CMD_FLAG_BOOT_MENU | QEMU_CAPS_BOOT_MENU |
QEMUD_CMD_FLAG_NESTING | QEMU_CAPS_NESTING |
QEMUD_CMD_FLAG_NAME_PROCESS | QEMU_CAPS_NAME_PROCESS |
QEMUD_CMD_FLAG_SMBIOS_TYPE | QEMU_CAPS_SMBIOS_TYPE |
QEMUD_CMD_FLAG_VGA_QXL | QEMU_CAPS_VGA_QXL |
QEMUD_CMD_FLAG_SPICE | QEMU_CAPS_SPICE |
QEMUD_CMD_FLAG_VGA_NONE | QEMU_CAPS_VGA_NONE |
QEMUD_CMD_FLAG_MIGRATE_QEMU_FD | QEMU_CAPS_MIGRATE_QEMU_FD |
QEMUD_CMD_FLAG_HDA_DUPLEX | QEMU_CAPS_HDA_DUPLEX |
QEMUD_CMD_FLAG_DRIVE_AIO | QEMU_CAPS_DRIVE_AIO |
QEMUD_CMD_FLAG_CCID_PASSTHRU | QEMU_CAPS_CCID_PASSTHRU |
QEMUD_CMD_FLAG_CHARDEV_SPICEVMC | QEMU_CAPS_CHARDEV_SPICEVMC |
QEMUD_CMD_FLAG_VIRTIO_TX_ALG, QEMU_CAPS_VIRTIO_TX_ALG,
12001, 1, 0); 12001, 1, 0);
return ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE; return ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE;

308
tests/qemuxml2argvtest.c
View File

@ -79,7 +79,7 @@ static int testCompareXMLToArgvFiles(const char *xml,
goto fail; goto fail;
} }
if (extraFlags & QEMUD_CMD_FLAG_DOMID) if (extraFlags & QEMU_CAPS_DOMID)
vmdef->id = 6; vmdef->id = 6;
else else
vmdef->id = -1; vmdef->id = -1;
@ -89,14 +89,14 @@ static int testCompareXMLToArgvFiles(const char *xml,
monitor_chr.data.nix.path = (char *)"/tmp/test-monitor"; monitor_chr.data.nix.path = (char *)"/tmp/test-monitor";
monitor_chr.data.nix.listen = true; monitor_chr.data.nix.listen = true;
flags = QEMUD_CMD_FLAG_VNC_COLON | flags = QEMU_CAPS_VNC_COLON |
QEMUD_CMD_FLAG_NO_REBOOT | QEMU_CAPS_NO_REBOOT |
extraFlags; extraFlags;
if (qemudCanonicalizeMachine(&driver, vmdef) < 0) if (qemudCanonicalizeMachine(&driver, vmdef) < 0)
goto fail; goto fail;
if (flags & QEMUD_CMD_FLAG_DEVICE) { if (flags & QEMU_CAPS_DEVICE) {
qemuDomainPCIAddressSetPtr pciaddrs; qemuDomainPCIAddressSetPtr pciaddrs;
if (!(pciaddrs = qemuDomainPCIAddressSetCreate(vmdef))) if (!(pciaddrs = qemuDomainPCIAddressSetCreate(vmdef)))
goto fail; goto fail;
@ -112,12 +112,12 @@ static int testCompareXMLToArgvFiles(const char *xml,
virResetLastError(); virResetLastError();
/* We do not call qemuCapsExtractVersionInfo() before calling /* We do not call qemuCapsExtractVersionInfo() before calling
* qemuBuildCommandLine(), so we should set QEMUD_CMD_FLAG_PCI_MULTIBUS for * qemuBuildCommandLine(), so we should set QEMU_CAPS_PCI_MULTIBUS for
* x86_64 and i686 architectures here. * x86_64 and i686 architectures here.
*/ */
if (STREQLEN(vmdef->os.arch, "x86_64", 6) || if (STREQLEN(vmdef->os.arch, "x86_64", 6) ||
STREQLEN(vmdef->os.arch, "i686", 4)) { STREQLEN(vmdef->os.arch, "i686", 4)) {
flags |= QEMUD_CMD_FLAG_PCI_MULTIBUS; flags |= QEMU_CAPS_PCI_MULTIBUS;
} }
if (!(cmd = qemuBuildCommandLine(conn, &driver, if (!(cmd = qemuBuildCommandLine(conn, &driver,
@ -256,87 +256,87 @@ mymain(int argc, char **argv)
unsetenv("QEMU_AUDIO_DRV"); unsetenv("QEMU_AUDIO_DRV");
unsetenv("SDL_AUDIODRIVER"); unsetenv("SDL_AUDIODRIVER");
DO_TEST("minimal", QEMUD_CMD_FLAG_NAME, false); DO_TEST("minimal", QEMU_CAPS_NAME, false);
DO_TEST("machine-aliases1", 0, false); DO_TEST("machine-aliases1", 0, false);
DO_TEST("machine-aliases2", 0, true); DO_TEST("machine-aliases2", 0, true);
DO_TEST("boot-cdrom", 0, false); DO_TEST("boot-cdrom", 0, false);
DO_TEST("boot-network", 0, false); DO_TEST("boot-network", 0, false);
DO_TEST("boot-floppy", 0, false); DO_TEST("boot-floppy", 0, false);
DO_TEST("boot-multi", QEMUD_CMD_FLAG_BOOT_MENU, false); DO_TEST("boot-multi", QEMU_CAPS_BOOT_MENU, false);
DO_TEST("boot-menu-disable", QEMUD_CMD_FLAG_BOOT_MENU, false); DO_TEST("boot-menu-disable", QEMU_CAPS_BOOT_MENU, false);
DO_TEST("boot-order", QEMUD_CMD_FLAG_BOOTINDEX | DO_TEST("boot-order", QEMU_CAPS_BOOTINDEX |
QEMUD_CMD_FLAG_DRIVE | QEMUD_CMD_FLAG_DEVICE, false); QEMU_CAPS_DRIVE | QEMU_CAPS_DEVICE, false);
DO_TEST("bootloader", QEMUD_CMD_FLAG_DOMID, true); DO_TEST("bootloader", QEMU_CAPS_DOMID, true);
DO_TEST("clock-utc", 0, false); DO_TEST("clock-utc", 0, false);
DO_TEST("clock-localtime", 0, false); DO_TEST("clock-localtime", 0, false);
/* /*
* Can't be enabled since the absolute timestamp changes every time * Can't be enabled since the absolute timestamp changes every time
DO_TEST("clock-variable", QEMUD_CMD_FLAG_RTC, false); DO_TEST("clock-variable", QEMU_CAPS_RTC, false);
*/ */
DO_TEST("clock-france", QEMUD_CMD_FLAG_RTC, false); DO_TEST("clock-france", QEMU_CAPS_RTC, false);
DO_TEST("hugepages", QEMUD_CMD_FLAG_MEM_PATH, false); DO_TEST("hugepages", QEMU_CAPS_MEM_PATH, false);
DO_TEST("disk-cdrom", 0, false); DO_TEST("disk-cdrom", 0, false);
DO_TEST("disk-cdrom-empty", QEMUD_CMD_FLAG_DRIVE, false); DO_TEST("disk-cdrom-empty", QEMU_CAPS_DRIVE, false);
DO_TEST("disk-floppy", 0, false); DO_TEST("disk-floppy", 0, false);
DO_TEST("disk-many", 0, false); DO_TEST("disk-many", 0, false);
DO_TEST("disk-virtio", QEMUD_CMD_FLAG_DRIVE | DO_TEST("disk-virtio", QEMU_CAPS_DRIVE |
QEMUD_CMD_FLAG_DRIVE_BOOT, false); QEMU_CAPS_DRIVE_BOOT, false);
DO_TEST("disk-xenvbd", QEMUD_CMD_FLAG_DRIVE | DO_TEST("disk-xenvbd", QEMU_CAPS_DRIVE |
QEMUD_CMD_FLAG_DRIVE_BOOT, false); QEMU_CAPS_DRIVE_BOOT, false);
DO_TEST("disk-drive-boot-disk", QEMUD_CMD_FLAG_DRIVE | DO_TEST("disk-drive-boot-disk", QEMU_CAPS_DRIVE |
QEMUD_CMD_FLAG_DRIVE_BOOT, false); QEMU_CAPS_DRIVE_BOOT, false);
DO_TEST("disk-drive-boot-cdrom", QEMUD_CMD_FLAG_DRIVE | DO_TEST("disk-drive-boot-cdrom", QEMU_CAPS_DRIVE |
QEMUD_CMD_FLAG_DRIVE_BOOT, false); QEMU_CAPS_DRIVE_BOOT, false);
DO_TEST("floppy-drive-fat", QEMUD_CMD_FLAG_DRIVE | DO_TEST("floppy-drive-fat", QEMU_CAPS_DRIVE |
QEMUD_CMD_FLAG_DRIVE_BOOT | QEMUD_CMD_FLAG_DRIVE_FORMAT, false); QEMU_CAPS_DRIVE_BOOT | QEMU_CAPS_DRIVE_FORMAT, false);
DO_TEST("disk-drive-fat", QEMUD_CMD_FLAG_DRIVE | DO_TEST("disk-drive-fat", QEMU_CAPS_DRIVE |
QEMUD_CMD_FLAG_DRIVE_BOOT | QEMUD_CMD_FLAG_DRIVE_FORMAT, false); QEMU_CAPS_DRIVE_BOOT | QEMU_CAPS_DRIVE_FORMAT, false);
DO_TEST("disk-drive-readonly-disk", QEMUD_CMD_FLAG_DRIVE | DO_TEST("disk-drive-readonly-disk", QEMU_CAPS_DRIVE |
QEMUD_CMD_FLAG_DRIVE_READONLY | QEMUD_CMD_FLAG_DEVICE | QEMU_CAPS_DRIVE_READONLY | QEMU_CAPS_DEVICE |
QEMUD_CMD_FLAG_NODEFCONFIG, false); QEMU_CAPS_NODEFCONFIG, false);
DO_TEST("disk-drive-readonly-no-device", QEMUD_CMD_FLAG_DRIVE | DO_TEST("disk-drive-readonly-no-device", QEMU_CAPS_DRIVE |
QEMUD_CMD_FLAG_DRIVE_READONLY | QEMUD_CMD_FLAG_NODEFCONFIG, false); QEMU_CAPS_DRIVE_READONLY | QEMU_CAPS_NODEFCONFIG, false);
DO_TEST("disk-drive-fmt-qcow", QEMUD_CMD_FLAG_DRIVE | DO_TEST("disk-drive-fmt-qcow", QEMU_CAPS_DRIVE |
QEMUD_CMD_FLAG_DRIVE_BOOT | QEMUD_CMD_FLAG_DRIVE_FORMAT, false); QEMU_CAPS_DRIVE_BOOT | QEMU_CAPS_DRIVE_FORMAT, false);
DO_TEST("disk-drive-shared", QEMUD_CMD_FLAG_DRIVE | DO_TEST("disk-drive-shared", QEMU_CAPS_DRIVE |
QEMUD_CMD_FLAG_DRIVE_FORMAT | QEMUD_CMD_FLAG_DRIVE_SERIAL, false); QEMU_CAPS_DRIVE_FORMAT | QEMU_CAPS_DRIVE_SERIAL, false);
DO_TEST("disk-drive-cache-v1-wt", QEMUD_CMD_FLAG_DRIVE | DO_TEST("disk-drive-cache-v1-wt", QEMU_CAPS_DRIVE |
QEMUD_CMD_FLAG_DRIVE_FORMAT, false); QEMU_CAPS_DRIVE_FORMAT, false);
DO_TEST("disk-drive-cache-v1-wb", QEMUD_CMD_FLAG_DRIVE | DO_TEST("disk-drive-cache-v1-wb", QEMU_CAPS_DRIVE |
QEMUD_CMD_FLAG_DRIVE_FORMAT, false); QEMU_CAPS_DRIVE_FORMAT, false);
DO_TEST("disk-drive-cache-v1-none", QEMUD_CMD_FLAG_DRIVE | DO_TEST("disk-drive-cache-v1-none", QEMU_CAPS_DRIVE |
QEMUD_CMD_FLAG_DRIVE_FORMAT, false); QEMU_CAPS_DRIVE_FORMAT, false);
DO_TEST("disk-drive-error-policy-stop", QEMUD_CMD_FLAG_DRIVE | DO_TEST("disk-drive-error-policy-stop", QEMU_CAPS_DRIVE |
QEMUD_CMD_FLAG_MONITOR_JSON | QEMU_CAPS_MONITOR_JSON |
QEMUD_CMD_FLAG_DRIVE_FORMAT, false); QEMU_CAPS_DRIVE_FORMAT, false);
DO_TEST("disk-drive-cache-v2-wt", QEMUD_CMD_FLAG_DRIVE | DO_TEST("disk-drive-cache-v2-wt", QEMU_CAPS_DRIVE |
QEMUD_CMD_FLAG_DRIVE_CACHE_V2 | QEMUD_CMD_FLAG_DRIVE_FORMAT, false); QEMU_CAPS_DRIVE_CACHE_V2 | QEMU_CAPS_DRIVE_FORMAT, false);
DO_TEST("disk-drive-cache-v2-wb", QEMUD_CMD_FLAG_DRIVE | DO_TEST("disk-drive-cache-v2-wb", QEMU_CAPS_DRIVE |
QEMUD_CMD_FLAG_DRIVE_CACHE_V2 | QEMUD_CMD_FLAG_DRIVE_FORMAT, false); QEMU_CAPS_DRIVE_CACHE_V2 | QEMU_CAPS_DRIVE_FORMAT, false);
DO_TEST("disk-drive-cache-v2-none", QEMUD_CMD_FLAG_DRIVE | DO_TEST("disk-drive-cache-v2-none", QEMU_CAPS_DRIVE |
QEMUD_CMD_FLAG_DRIVE_CACHE_V2 | QEMUD_CMD_FLAG_DRIVE_FORMAT, false); QEMU_CAPS_DRIVE_CACHE_V2 | QEMU_CAPS_DRIVE_FORMAT, false);
DO_TEST("disk-drive-network-nbd", QEMUD_CMD_FLAG_DRIVE | DO_TEST("disk-drive-network-nbd", QEMU_CAPS_DRIVE |
QEMUD_CMD_FLAG_DRIVE_FORMAT, false); QEMU_CAPS_DRIVE_FORMAT, false);
DO_TEST("disk-drive-network-rbd", QEMUD_CMD_FLAG_DRIVE | DO_TEST("disk-drive-network-rbd", QEMU_CAPS_DRIVE |
QEMUD_CMD_FLAG_DRIVE_FORMAT, false); QEMU_CAPS_DRIVE_FORMAT, false);
DO_TEST("disk-drive-network-sheepdog", QEMUD_CMD_FLAG_DRIVE | DO_TEST("disk-drive-network-sheepdog", QEMU_CAPS_DRIVE |
QEMUD_CMD_FLAG_DRIVE_FORMAT, false); QEMU_CAPS_DRIVE_FORMAT, false);
DO_TEST("disk-usb", 0, false); DO_TEST("disk-usb", 0, false);
DO_TEST("disk-usb-device", QEMUD_CMD_FLAG_DRIVE | DO_TEST("disk-usb-device", QEMU_CAPS_DRIVE |
QEMUD_CMD_FLAG_DEVICE | QEMUD_CMD_FLAG_NODEFCONFIG, false); QEMU_CAPS_DEVICE | QEMU_CAPS_NODEFCONFIG, false);
DO_TEST("disk-scsi-device", QEMUD_CMD_FLAG_DRIVE | DO_TEST("disk-scsi-device", QEMU_CAPS_DRIVE |
QEMUD_CMD_FLAG_DEVICE | QEMUD_CMD_FLAG_NODEFCONFIG, false); QEMU_CAPS_DEVICE | QEMU_CAPS_NODEFCONFIG, false);
DO_TEST("disk-scsi-device-auto", QEMUD_CMD_FLAG_DRIVE | DO_TEST("disk-scsi-device-auto", QEMU_CAPS_DRIVE |
QEMUD_CMD_FLAG_DEVICE | QEMUD_CMD_FLAG_NODEFCONFIG, false); QEMU_CAPS_DEVICE | QEMU_CAPS_NODEFCONFIG, false);
DO_TEST("disk-aio", QEMUD_CMD_FLAG_DRIVE | QEMUD_CMD_FLAG_DRIVE_AIO | DO_TEST("disk-aio", QEMU_CAPS_DRIVE | QEMU_CAPS_DRIVE_AIO |
QEMUD_CMD_FLAG_DRIVE_CACHE_V2 | QEMUD_CMD_FLAG_DRIVE_FORMAT, false); QEMU_CAPS_DRIVE_CACHE_V2 | QEMU_CAPS_DRIVE_FORMAT, false);
DO_TEST("graphics-vnc", 0, false); DO_TEST("graphics-vnc", 0, false);
DO_TEST("graphics-vnc-socket", 0, false); DO_TEST("graphics-vnc-socket", 0, false);
driver.vncSASL = 1; driver.vncSASL = 1;
driver.vncSASLdir = strdup("/root/.sasl2"); driver.vncSASLdir = strdup("/root/.sasl2");
DO_TEST("graphics-vnc-sasl", QEMUD_CMD_FLAG_VGA, false); DO_TEST("graphics-vnc-sasl", QEMU_CAPS_VGA, false);
driver.vncTLS = 1; driver.vncTLS = 1;
driver.vncTLSx509verify = 1; driver.vncTLSx509verify = 1;
driver.vncTLSx509certdir = strdup("/etc/pki/tls/qemu"); driver.vncTLSx509certdir = strdup("/etc/pki/tls/qemu");
@ -348,29 +348,29 @@ mymain(int argc, char **argv)
DO_TEST("graphics-sdl", 0, false); DO_TEST("graphics-sdl", 0, false);
DO_TEST("graphics-sdl-fullscreen", 0, false); DO_TEST("graphics-sdl-fullscreen", 0, false);
DO_TEST("nographics", QEMUD_CMD_FLAG_VGA, false); DO_TEST("nographics", QEMU_CAPS_VGA, false);
DO_TEST("nographics-vga", QEMUD_CMD_FLAG_VGA | DO_TEST("nographics-vga", QEMU_CAPS_VGA |
QEMUD_CMD_FLAG_VGA_NONE, false); QEMU_CAPS_VGA_NONE, false);
DO_TEST("graphics-spice", DO_TEST("graphics-spice",
QEMUD_CMD_FLAG_VGA | QEMUD_CMD_FLAG_VGA_QXL | QEMU_CAPS_VGA | QEMU_CAPS_VGA_QXL |
QEMUD_CMD_FLAG_DEVICE | QEMUD_CMD_FLAG_SPICE, false); QEMU_CAPS_DEVICE | QEMU_CAPS_SPICE, false);
DO_TEST("input-usbmouse", 0, false); DO_TEST("input-usbmouse", 0, false);
DO_TEST("input-usbtablet", 0, false); DO_TEST("input-usbtablet", 0, false);
DO_TEST("input-xen", QEMUD_CMD_FLAG_DOMID, true); DO_TEST("input-xen", QEMU_CAPS_DOMID, true);
DO_TEST("misc-acpi", 0, false); DO_TEST("misc-acpi", 0, false);
DO_TEST("misc-no-reboot", 0, false); DO_TEST("misc-no-reboot", 0, false);
DO_TEST("misc-uuid", QEMUD_CMD_FLAG_NAME | DO_TEST("misc-uuid", QEMU_CAPS_NAME |
QEMUD_CMD_FLAG_UUID, false); QEMU_CAPS_UUID, false);
DO_TEST("net-user", 0, false); DO_TEST("net-user", 0, false);
DO_TEST("net-virtio", 0, false); DO_TEST("net-virtio", 0, false);
DO_TEST("net-virtio-device", QEMUD_CMD_FLAG_DEVICE | DO_TEST("net-virtio-device", QEMU_CAPS_DEVICE |
QEMUD_CMD_FLAG_NODEFCONFIG | QEMUD_CMD_FLAG_VIRTIO_TX_ALG, false); QEMU_CAPS_NODEFCONFIG | QEMU_CAPS_VIRTIO_TX_ALG, false);
DO_TEST("net-virtio-netdev", QEMUD_CMD_FLAG_DEVICE | DO_TEST("net-virtio-netdev", QEMU_CAPS_DEVICE |
QEMUD_CMD_FLAG_NETDEV | QEMUD_CMD_FLAG_NODEFCONFIG, false); QEMU_CAPS_NETDEV | QEMU_CAPS_NODEFCONFIG, false);
DO_TEST("net-eth", 0, false); DO_TEST("net-eth", 0, false);
DO_TEST("net-eth-ifname", 0, false); DO_TEST("net-eth-ifname", 0, false);
DO_TEST("net-eth-names", QEMUD_CMD_FLAG_NET_NAME, false); DO_TEST("net-eth-names", QEMU_CAPS_NET_NAME, false);
DO_TEST("serial-vc", 0, false); DO_TEST("serial-vc", 0, false);
DO_TEST("serial-pty", 0, false); DO_TEST("serial-pty", 0, false);
@ -385,103 +385,103 @@ mymain(int argc, char **argv)
DO_TEST("console-compat", 0, false); DO_TEST("console-compat", 0, false);
DO_TEST("console-compat-auto", 0, false); DO_TEST("console-compat-auto", 0, false);
DO_TEST("serial-vc-chardev", QEMUD_CMD_FLAG_CHARDEV|QEMUD_CMD_FLAG_DEVICE | DO_TEST("serial-vc-chardev", QEMU_CAPS_CHARDEV|QEMU_CAPS_DEVICE |
QEMUD_CMD_FLAG_NODEFCONFIG, false); QEMU_CAPS_NODEFCONFIG, false);
DO_TEST("serial-pty-chardev", QEMUD_CMD_FLAG_CHARDEV|QEMUD_CMD_FLAG_DEVICE | DO_TEST("serial-pty-chardev", QEMU_CAPS_CHARDEV|QEMU_CAPS_DEVICE |
QEMUD_CMD_FLAG_NODEFCONFIG, false); QEMU_CAPS_NODEFCONFIG, false);
DO_TEST("serial-dev-chardev", QEMUD_CMD_FLAG_CHARDEV|QEMUD_CMD_FLAG_DEVICE | DO_TEST("serial-dev-chardev", QEMU_CAPS_CHARDEV|QEMU_CAPS_DEVICE |
QEMUD_CMD_FLAG_NODEFCONFIG, false); QEMU_CAPS_NODEFCONFIG, false);
DO_TEST("serial-file-chardev", QEMUD_CMD_FLAG_CHARDEV|QEMUD_CMD_FLAG_DEVICE | DO_TEST("serial-file-chardev", QEMU_CAPS_CHARDEV|QEMU_CAPS_DEVICE |
QEMUD_CMD_FLAG_NODEFCONFIG, false); QEMU_CAPS_NODEFCONFIG, false);
DO_TEST("serial-unix-chardev", QEMUD_CMD_FLAG_CHARDEV|QEMUD_CMD_FLAG_DEVICE | DO_TEST("serial-unix-chardev", QEMU_CAPS_CHARDEV|QEMU_CAPS_DEVICE |
QEMUD_CMD_FLAG_NODEFCONFIG, false); QEMU_CAPS_NODEFCONFIG, false);
DO_TEST("serial-tcp-chardev", QEMUD_CMD_FLAG_CHARDEV|QEMUD_CMD_FLAG_DEVICE | DO_TEST("serial-tcp-chardev", QEMU_CAPS_CHARDEV|QEMU_CAPS_DEVICE |
QEMUD_CMD_FLAG_NODEFCONFIG, false); QEMU_CAPS_NODEFCONFIG, false);
DO_TEST("serial-udp-chardev", QEMUD_CMD_FLAG_CHARDEV|QEMUD_CMD_FLAG_DEVICE | DO_TEST("serial-udp-chardev", QEMU_CAPS_CHARDEV|QEMU_CAPS_DEVICE |
QEMUD_CMD_FLAG_NODEFCONFIG, false); QEMU_CAPS_NODEFCONFIG, false);
DO_TEST("serial-tcp-telnet-chardev", QEMUD_CMD_FLAG_CHARDEV|QEMUD_CMD_FLAG_DEVICE | DO_TEST("serial-tcp-telnet-chardev", QEMU_CAPS_CHARDEV|QEMU_CAPS_DEVICE |
QEMUD_CMD_FLAG_NODEFCONFIG, false); QEMU_CAPS_NODEFCONFIG, false);
DO_TEST("serial-many-chardev", QEMUD_CMD_FLAG_CHARDEV|QEMUD_CMD_FLAG_DEVICE | DO_TEST("serial-many-chardev", QEMU_CAPS_CHARDEV|QEMU_CAPS_DEVICE |
QEMUD_CMD_FLAG_NODEFCONFIG, false); QEMU_CAPS_NODEFCONFIG, false);
DO_TEST("parallel-tcp-chardev", QEMUD_CMD_FLAG_CHARDEV|QEMUD_CMD_FLAG_DEVICE | DO_TEST("parallel-tcp-chardev", QEMU_CAPS_CHARDEV|QEMU_CAPS_DEVICE |
QEMUD_CMD_FLAG_NODEFCONFIG, false); QEMU_CAPS_NODEFCONFIG, false);
DO_TEST("console-compat-chardev", QEMUD_CMD_FLAG_CHARDEV|QEMUD_CMD_FLAG_DEVICE | DO_TEST("console-compat-chardev", QEMU_CAPS_CHARDEV|QEMU_CAPS_DEVICE |
QEMUD_CMD_FLAG_NODEFCONFIG, false); QEMU_CAPS_NODEFCONFIG, false);
DO_TEST("channel-guestfwd", QEMUD_CMD_FLAG_CHARDEV|QEMUD_CMD_FLAG_DEVICE | DO_TEST("channel-guestfwd", QEMU_CAPS_CHARDEV|QEMU_CAPS_DEVICE |
QEMUD_CMD_FLAG_NODEFCONFIG, false); QEMU_CAPS_NODEFCONFIG, false);
DO_TEST("channel-virtio", QEMUD_CMD_FLAG_DEVICE | DO_TEST("channel-virtio", QEMU_CAPS_DEVICE |
QEMUD_CMD_FLAG_NODEFCONFIG, false); QEMU_CAPS_NODEFCONFIG, false);
DO_TEST("channel-virtio-auto", QEMUD_CMD_FLAG_DEVICE | DO_TEST("channel-virtio-auto", QEMU_CAPS_DEVICE |
QEMUD_CMD_FLAG_NODEFCONFIG, false); QEMU_CAPS_NODEFCONFIG, false);
DO_TEST("console-virtio", QEMUD_CMD_FLAG_DEVICE | DO_TEST("console-virtio", QEMU_CAPS_DEVICE |
QEMUD_CMD_FLAG_NODEFCONFIG, false); QEMU_CAPS_NODEFCONFIG, false);
DO_TEST("channel-spicevmc", QEMUD_CMD_FLAG_DEVICE | DO_TEST("channel-spicevmc", QEMU_CAPS_DEVICE |
QEMUD_CMD_FLAG_NODEFCONFIG | QEMUD_CMD_FLAG_SPICE | QEMU_CAPS_NODEFCONFIG | QEMU_CAPS_SPICE |
QEMUD_CMD_FLAG_CHARDEV_SPICEVMC, false); QEMU_CAPS_CHARDEV_SPICEVMC, false);
DO_TEST("channel-spicevmc-old", QEMUD_CMD_FLAG_DEVICE | DO_TEST("channel-spicevmc-old", QEMU_CAPS_DEVICE |
QEMUD_CMD_FLAG_NODEFCONFIG | QEMUD_CMD_FLAG_SPICE | QEMU_CAPS_NODEFCONFIG | QEMU_CAPS_SPICE |
QEMUD_CMD_FLAG_DEVICE_SPICEVMC, false); QEMU_CAPS_DEVICE_SPICEVMC, false);
DO_TEST("smartcard-host", DO_TEST("smartcard-host",
QEMUD_CMD_FLAG_CHARDEV | QEMUD_CMD_FLAG_DEVICE | QEMU_CAPS_CHARDEV | QEMU_CAPS_DEVICE |
QEMUD_CMD_FLAG_NODEFCONFIG | QEMUD_CMD_FLAG_CCID_EMULATED, false); QEMU_CAPS_NODEFCONFIG | QEMU_CAPS_CCID_EMULATED, false);
DO_TEST("smartcard-host-certificates", DO_TEST("smartcard-host-certificates",
QEMUD_CMD_FLAG_CHARDEV | QEMUD_CMD_FLAG_DEVICE | QEMU_CAPS_CHARDEV | QEMU_CAPS_DEVICE |
QEMUD_CMD_FLAG_NODEFCONFIG | QEMUD_CMD_FLAG_CCID_EMULATED, false); QEMU_CAPS_NODEFCONFIG | QEMU_CAPS_CCID_EMULATED, false);
DO_TEST("smartcard-passthrough-tcp", DO_TEST("smartcard-passthrough-tcp",
QEMUD_CMD_FLAG_CHARDEV | QEMUD_CMD_FLAG_DEVICE | QEMU_CAPS_CHARDEV | QEMU_CAPS_DEVICE |
QEMUD_CMD_FLAG_NODEFCONFIG | QEMUD_CMD_FLAG_CCID_PASSTHRU, false); QEMU_CAPS_NODEFCONFIG | QEMU_CAPS_CCID_PASSTHRU, false);
DO_TEST("smartcard-passthrough-spicevmc", DO_TEST("smartcard-passthrough-spicevmc",
QEMUD_CMD_FLAG_CHARDEV | QEMUD_CMD_FLAG_DEVICE | QEMU_CAPS_CHARDEV | QEMU_CAPS_DEVICE |
QEMUD_CMD_FLAG_NODEFCONFIG | QEMUD_CMD_FLAG_CCID_PASSTHRU | QEMU_CAPS_NODEFCONFIG | QEMU_CAPS_CCID_PASSTHRU |
QEMUD_CMD_FLAG_CHARDEV_SPICEVMC, false); QEMU_CAPS_CHARDEV_SPICEVMC, false);
DO_TEST("smartcard-controller", DO_TEST("smartcard-controller",
QEMUD_CMD_FLAG_CHARDEV | QEMUD_CMD_FLAG_DEVICE | QEMU_CAPS_CHARDEV | QEMU_CAPS_DEVICE |
QEMUD_CMD_FLAG_NODEFCONFIG | QEMUD_CMD_FLAG_CCID_EMULATED, false); QEMU_CAPS_NODEFCONFIG | QEMU_CAPS_CCID_EMULATED, false);
DO_TEST("smbios", QEMUD_CMD_FLAG_SMBIOS_TYPE, false); DO_TEST("smbios", QEMU_CAPS_SMBIOS_TYPE, false);
DO_TEST("watchdog", 0, false); DO_TEST("watchdog", 0, false);
DO_TEST("watchdog-device", QEMUD_CMD_FLAG_DEVICE | DO_TEST("watchdog-device", QEMU_CAPS_DEVICE |
QEMUD_CMD_FLAG_NODEFCONFIG, false); QEMU_CAPS_NODEFCONFIG, false);
DO_TEST("watchdog-dump", 0, false); DO_TEST("watchdog-dump", 0, false);
DO_TEST("balloon-device", QEMUD_CMD_FLAG_DEVICE | DO_TEST("balloon-device", QEMU_CAPS_DEVICE |
QEMUD_CMD_FLAG_NODEFCONFIG, false); QEMU_CAPS_NODEFCONFIG, false);
DO_TEST("balloon-device-auto", QEMUD_CMD_FLAG_DEVICE | DO_TEST("balloon-device-auto", QEMU_CAPS_DEVICE |
QEMUD_CMD_FLAG_NODEFCONFIG, false); QEMU_CAPS_NODEFCONFIG, false);
DO_TEST("sound", 0, false); DO_TEST("sound", 0, false);
DO_TEST("sound-device", QEMUD_CMD_FLAG_DEVICE | DO_TEST("sound-device", QEMU_CAPS_DEVICE |
QEMUD_CMD_FLAG_NODEFCONFIG | QEMUD_CMD_FLAG_HDA_DUPLEX, false); QEMU_CAPS_NODEFCONFIG | QEMU_CAPS_HDA_DUPLEX, false);
DO_TEST("fs9p", QEMUD_CMD_FLAG_DEVICE | DO_TEST("fs9p", QEMU_CAPS_DEVICE |
QEMUD_CMD_FLAG_NODEFCONFIG | QEMUD_CMD_FLAG_FSDEV, false); QEMU_CAPS_NODEFCONFIG | QEMU_CAPS_FSDEV, false);
DO_TEST("hostdev-usb-address", 0, false); DO_TEST("hostdev-usb-address", 0, false);
DO_TEST("hostdev-usb-address-device", QEMUD_CMD_FLAG_DEVICE | DO_TEST("hostdev-usb-address-device", QEMU_CAPS_DEVICE |
QEMUD_CMD_FLAG_NODEFCONFIG, false); QEMU_CAPS_NODEFCONFIG, false);
DO_TEST("hostdev-pci-address", QEMUD_CMD_FLAG_PCIDEVICE, false); DO_TEST("hostdev-pci-address", QEMU_CAPS_PCIDEVICE, false);
DO_TEST("hostdev-pci-address-device", QEMUD_CMD_FLAG_PCIDEVICE | DO_TEST("hostdev-pci-address-device", QEMU_CAPS_PCIDEVICE |
QEMUD_CMD_FLAG_DEVICE | QEMUD_CMD_FLAG_NODEFCONFIG, false); QEMU_CAPS_DEVICE | QEMU_CAPS_NODEFCONFIG, false);
DO_TEST_FULL("restore-v1", QEMUD_CMD_FLAG_MIGRATE_KVM_STDIO, "stdio", 7, DO_TEST_FULL("restore-v1", QEMU_CAPS_MIGRATE_KVM_STDIO, "stdio", 7,
false); false);
DO_TEST_FULL("restore-v2", QEMUD_CMD_FLAG_MIGRATE_QEMU_EXEC, "stdio", 7, DO_TEST_FULL("restore-v2", QEMU_CAPS_MIGRATE_QEMU_EXEC, "stdio", 7,
false); false);
DO_TEST_FULL("restore-v2", QEMUD_CMD_FLAG_MIGRATE_QEMU_EXEC, "exec:cat", 7, DO_TEST_FULL("restore-v2", QEMU_CAPS_MIGRATE_QEMU_EXEC, "exec:cat", 7,
false); false);
DO_TEST_FULL("restore-v2-fd", QEMUD_CMD_FLAG_MIGRATE_QEMU_FD, "stdio", 7, DO_TEST_FULL("restore-v2-fd", QEMU_CAPS_MIGRATE_QEMU_FD, "stdio", 7,
false); false);
DO_TEST_FULL("restore-v2-fd", QEMUD_CMD_FLAG_MIGRATE_QEMU_FD, "fd:7", 7, DO_TEST_FULL("restore-v2-fd", QEMU_CAPS_MIGRATE_QEMU_FD, "fd:7", 7,
false); false);
DO_TEST_FULL("migrate", QEMUD_CMD_FLAG_MIGRATE_QEMU_TCP, DO_TEST_FULL("migrate", QEMU_CAPS_MIGRATE_QEMU_TCP,
"tcp:10.0.0.1:5000", -1, false); "tcp:10.0.0.1:5000", -1, false);
DO_TEST("qemu-ns", 0, false); DO_TEST("qemu-ns", 0, false);
DO_TEST("smp", QEMUD_CMD_FLAG_SMP_TOPOLOGY, false); DO_TEST("smp", QEMU_CAPS_SMP_TOPOLOGY, false);
DO_TEST("cpu-topology1", QEMUD_CMD_FLAG_SMP_TOPOLOGY, false); DO_TEST("cpu-topology1", QEMU_CAPS_SMP_TOPOLOGY, false);
DO_TEST("cpu-topology2", QEMUD_CMD_FLAG_SMP_TOPOLOGY, false); DO_TEST("cpu-topology2", QEMU_CAPS_SMP_TOPOLOGY, false);
DO_TEST("cpu-topology3", 0, false); DO_TEST("cpu-topology3", 0, false);
DO_TEST("cpu-minimum1", 0, false); DO_TEST("cpu-minimum1", 0, false);
DO_TEST("cpu-minimum2", 0, false); DO_TEST("cpu-minimum2", 0, false);
@ -489,8 +489,8 @@ mymain(int argc, char **argv)
DO_TEST("cpu-exact2", 0, false); DO_TEST("cpu-exact2", 0, false);
DO_TEST("cpu-strict1", 0, false); DO_TEST("cpu-strict1", 0, false);
DO_TEST("memtune", QEMUD_CMD_FLAG_NAME, false); DO_TEST("memtune", QEMU_CAPS_NAME, false);
DO_TEST("blkiotune", QEMUD_CMD_FLAG_NAME, false); DO_TEST("blkiotune", QEMU_CAPS_NAME, false);
free(driver.stateDir); free(driver.stateDir);
virCapabilitiesFree(driver.caps); virCapabilitiesFree(driver.caps);