* are used in domain status files which are read on
* daemon restarts
*/
-VIR_ENUM_IMPL(qemuCaps, QEMU_CAPS_LAST,
+VIR_ENUM_IMPL(virQEMUCaps, QEMU_CAPS_LAST,
"kqemu", /* 0 */
"vnc-colon",
"no-reboot",
);
-struct _qemuCaps {
+struct _virQEMUCaps {
virObject object;
bool usedQMP;
char **machineAliases;
};
-struct _qemuCapsCache {
+struct _virQEMUCapsCache {
virMutex lock;
virHashTablePtr binaries;
char *libDir;
};
-static virClassPtr qemuCapsClass;
-static void qemuCapsDispose(void *obj);
+static virClassPtr virQEMUCapsClass;
+static void virQEMUCapsDispose(void *obj);
-static int qemuCapsOnceInit(void)
+static int virQEMUCapsOnceInit(void)
{
- if (!(qemuCapsClass = virClassNew(virClassForObject(),
- "qemuCaps",
- sizeof(qemuCaps),
- qemuCapsDispose)))
+ if (!(virQEMUCapsClass = virClassNew(virClassForObject(),
+ "virQEMUCaps",
+ sizeof(virQEMUCaps),
+ virQEMUCapsDispose)))
return -1;
return 0;
}
-VIR_ONCE_GLOBAL_INIT(qemuCaps)
+VIR_ONCE_GLOBAL_INIT(virQEMUCaps)
-static virArch qemuCapsArchFromString(const char *arch)
+static virArch virQEMUCapsArchFromString(const char *arch)
{
if (STREQ(arch, "i386"))
return VIR_ARCH_I686;
}
-static const char *qemuCapsArchToString(virArch arch)
+static const char *virQEMUCapsArchToString(virArch arch)
{
if (arch == VIR_ARCH_I686)
return "i386";
}
-struct _qemuCapsHookData {
+struct _virQEMUCapsHookData {
uid_t runUid;
gid_t runGid;
};
-typedef struct _qemuCapsHookData qemuCapsHookData;
-typedef qemuCapsHookData *qemuCapsHookDataPtr;
+typedef struct _virQEMUCapsHookData virQEMUCapsHookData;
+typedef virQEMUCapsHookData *virQEMUCapsHookDataPtr;
-static int qemuCapsHook(void * data)
+static int virQEMUCapsHook(void * data)
{
int ret;
- qemuCapsHookDataPtr hookData = data;
+ virQEMUCapsHookDataPtr hookData = data;
if (!hookData) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
}
static virCommandPtr
-qemuCapsProbeCommand(const char *qemu,
- qemuCapsPtr caps,
- qemuCapsHookDataPtr hookData)
+virQEMUCapsProbeCommand(const char *qemu,
+ virQEMUCapsPtr qemuCaps,
+ virQEMUCapsHookDataPtr hookData)
{
virCommandPtr cmd = virCommandNew(qemu);
- if (caps) {
- if (qemuCapsGet(caps, QEMU_CAPS_NO_USER_CONFIG))
+ if (qemuCaps) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_NO_USER_CONFIG))
virCommandAddArg(cmd, "-no-user-config");
- else if (qemuCapsGet(caps, QEMU_CAPS_NODEFCONFIG))
+ else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_NODEFCONFIG))
virCommandAddArg(cmd, "-nodefconfig");
}
virCommandAddEnvPassCommon(cmd);
virCommandClearCaps(cmd);
- virCommandSetPreExecHook(cmd, qemuCapsHook, hookData);
+ virCommandSetPreExecHook(cmd, virQEMUCapsHook, hookData);
return cmd;
}
static void
-qemuSetDefaultMachine(qemuCapsPtr caps,
- size_t defIdx)
+virQEMUCapsSetDefaultMachine(virQEMUCapsPtr qemuCaps,
+ size_t defIdx)
{
- char *name = caps->machineTypes[defIdx];
- char *alias = caps->machineAliases[defIdx];
-
- memmove(caps->machineTypes + 1,
- caps->machineTypes,
- sizeof(caps->machineTypes[0]) * defIdx);
- memmove(caps->machineAliases + 1,
- caps->machineAliases,
- sizeof(caps->machineAliases[0]) * defIdx);
- caps->machineTypes[0] = name;
- caps->machineAliases[0] = alias;
+ char *name = qemuCaps->machineTypes[defIdx];
+ char *alias = qemuCaps->machineAliases[defIdx];
+
+ memmove(qemuCaps->machineTypes + 1,
+ qemuCaps->machineTypes,
+ sizeof(qemuCaps->machineTypes[0]) * defIdx);
+ memmove(qemuCaps->machineAliases + 1,
+ qemuCaps->machineAliases,
+ sizeof(qemuCaps->machineAliases[0]) * defIdx);
+ qemuCaps->machineTypes[0] = name;
+ qemuCaps->machineAliases[0] = alias;
}
/* Format is:
* <machine> <desc> [(default)|(alias of <canonical>)]
*/
static int
-qemuCapsParseMachineTypesStr(const char *output,
- qemuCapsPtr caps)
+virQEMUCapsParseMachineTypesStr(const char *output,
+ virQEMUCapsPtr qemuCaps)
{
const char *p = output;
const char *next;
p = t;
if ((t = strstr(p, "(default)")) && (!next || t < next))
- defIdx = caps->nmachineTypes;
+ defIdx = qemuCaps->nmachineTypes;
if ((t = strstr(p, "(alias of ")) && (!next || t < next)) {
p = t + strlen("(alias of ");
}
}
- if (VIR_REALLOC_N(caps->machineTypes, caps->nmachineTypes + 1) < 0 ||
- VIR_REALLOC_N(caps->machineAliases, caps->nmachineTypes + 1) < 0) {
+ if (VIR_REALLOC_N(qemuCaps->machineTypes, qemuCaps->nmachineTypes + 1) < 0 ||
+ VIR_REALLOC_N(qemuCaps->machineAliases, qemuCaps->nmachineTypes + 1) < 0) {
VIR_FREE(name);
VIR_FREE(canonical);
goto no_memory;
}
- caps->nmachineTypes++;
+ qemuCaps->nmachineTypes++;
if (canonical) {
- caps->machineTypes[caps->nmachineTypes-1] = canonical;
- caps->machineAliases[caps->nmachineTypes-1] = name;
+ qemuCaps->machineTypes[qemuCaps->nmachineTypes-1] = canonical;
+ qemuCaps->machineAliases[qemuCaps->nmachineTypes-1] = name;
} else {
- caps->machineTypes[caps->nmachineTypes-1] = name;
- caps->machineAliases[caps->nmachineTypes-1] = NULL;
+ qemuCaps->machineTypes[qemuCaps->nmachineTypes-1] = name;
+ qemuCaps->machineAliases[qemuCaps->nmachineTypes-1] = NULL;
}
} while ((p = next));
if (defIdx)
- qemuSetDefaultMachine(caps, defIdx);
+ virQEMUCapsSetDefaultMachine(qemuCaps, defIdx);
return 0;
}
static int
-qemuCapsProbeMachineTypes(qemuCapsPtr caps, qemuCapsHookDataPtr hookData)
+virQEMUCapsProbeMachineTypes(virQEMUCapsPtr qemuCaps, virQEMUCapsHookDataPtr hookData)
{
char *output;
int ret = -1;
* Technically we could catch the exec() failure, but that's
* in a sub-process so it's hard to feed back a useful error.
*/
- if (!virFileIsExecutable(caps->binary)) {
+ if (!virFileIsExecutable(qemuCaps->binary)) {
virReportSystemError(errno, _("Cannot find QEMU binary %s"),
- caps->binary);
+ qemuCaps->binary);
return -1;
}
- cmd = qemuCapsProbeCommand(caps->binary, caps, hookData);
+ cmd = virQEMUCapsProbeCommand(qemuCaps->binary, qemuCaps, hookData);
virCommandAddArgList(cmd, "-M", "?", NULL);
virCommandSetOutputBuffer(cmd, &output);
if (virCommandRun(cmd, &status) < 0)
goto cleanup;
- if (qemuCapsParseMachineTypesStr(output, caps) < 0)
+ if (virQEMUCapsParseMachineTypesStr(output, qemuCaps) < 0)
goto cleanup;
ret = 0;
typedef int
-(*qemuCapsParseCPUModels)(const char *output,
- qemuCapsPtr caps);
+(*virQEMUCapsParseCPUModels)(const char *output,
+ virQEMUCapsPtr qemuCaps);
/* Format:
* <arch> <model>
* <arch> [<model>]
*/
static int
-qemuCapsParseX86Models(const char *output,
- qemuCapsPtr caps)
+virQEMUCapsParseX86Models(const char *output,
+ virQEMUCapsPtr qemuCaps)
{
const char *p = output;
const char *next;
if (*p == '\0' || *p == '\n')
continue;
- if (VIR_EXPAND_N(caps->cpuDefinitions, caps->ncpuDefinitions, 1) < 0) {
+ if (VIR_EXPAND_N(qemuCaps->cpuDefinitions, qemuCaps->ncpuDefinitions, 1) < 0) {
virReportOOMError();
goto cleanup;
}
len -= 2;
}
- if (!(caps->cpuDefinitions[caps->ncpuDefinitions - 1] = strndup(p, len))) {
+ if (!(qemuCaps->cpuDefinitions[qemuCaps->ncpuDefinitions - 1] = strndup(p, len))) {
virReportOOMError();
goto cleanup;
}
* Format : PowerPC <machine> <description>
*/
static int
-qemuCapsParsePPCModels(const char *output,
- qemuCapsPtr caps)
+virQEMUCapsParsePPCModels(const char *output,
+ virQEMUCapsPtr qemuCaps)
{
const char *p = output;
const char *next;
if (*p == '\n')
continue;
- if (VIR_EXPAND_N(caps->cpuDefinitions, caps->ncpuDefinitions, 1) < 0) {
+ if (VIR_EXPAND_N(qemuCaps->cpuDefinitions, qemuCaps->ncpuDefinitions, 1) < 0) {
virReportOOMError();
goto cleanup;
}
len = t - p - 1;
- if (!(caps->cpuDefinitions[caps->ncpuDefinitions - 1] = strndup(p, len))) {
+ if (!(qemuCaps->cpuDefinitions[qemuCaps->ncpuDefinitions - 1] = strndup(p, len))) {
virReportOOMError();
goto cleanup;
}
}
static int
-qemuCapsProbeCPUModels(qemuCapsPtr caps, qemuCapsHookDataPtr hookData)
+virQEMUCapsProbeCPUModels(virQEMUCapsPtr qemuCaps, virQEMUCapsHookDataPtr hookData)
{
char *output = NULL;
int ret = -1;
- qemuCapsParseCPUModels parse;
+ virQEMUCapsParseCPUModels parse;
virCommandPtr cmd;
- if (caps->arch == VIR_ARCH_I686 ||
- caps->arch == VIR_ARCH_X86_64)
- parse = qemuCapsParseX86Models;
- else if (caps->arch == VIR_ARCH_PPC64)
- parse = qemuCapsParsePPCModels;
+ if (qemuCaps->arch == VIR_ARCH_I686 ||
+ qemuCaps->arch == VIR_ARCH_X86_64)
+ parse = virQEMUCapsParseX86Models;
+ else if (qemuCaps->arch == VIR_ARCH_PPC64)
+ parse = virQEMUCapsParsePPCModels;
else {
VIR_DEBUG("don't know how to parse %s CPU models",
- virArchToString(caps->arch));
+ virArchToString(qemuCaps->arch));
return 0;
}
- cmd = qemuCapsProbeCommand(caps->binary, caps, hookData);
+ cmd = virQEMUCapsProbeCommand(qemuCaps->binary, qemuCaps, hookData);
virCommandAddArgList(cmd, "-cpu", "?", NULL);
virCommandSetOutputBuffer(cmd, &output);
if (virCommandRun(cmd, NULL) < 0)
goto cleanup;
- if (parse(output, caps) < 0)
+ if (parse(output, qemuCaps) < 0)
goto cleanup;
ret = 0;
static char *
-qemuCapsFindBinaryForArch(virArch hostarch,
- virArch guestarch)
+virQEMUCapsFindBinaryForArch(virArch hostarch,
+ virArch guestarch)
{
char *ret;
- const char *archstr = qemuCapsArchToString(guestarch);
+ const char *archstr = virQEMUCapsArchToString(guestarch);
char *binary;
if (virAsprintf(&binary, "qemu-system-%s", archstr) < 0) {
static bool
-qemuCapsIsValidForKVM(virArch hostarch,
- virArch guestarch)
+virQEMUCapsIsValidForKVM(virArch hostarch,
+ virArch guestarch)
{
if (hostarch == guestarch)
return true;
}
static int
-qemuCapsInitGuest(virCapsPtr caps,
- qemuCapsCachePtr cache,
- virArch hostarch,
- virArch guestarch)
+virQEMUCapsInitGuest(virCapsPtr caps,
+ virQEMUCapsCachePtr cache,
+ virArch hostarch,
+ virArch guestarch)
{
virCapsGuestPtr guest;
int i;
char *binary = NULL;
virCapsGuestMachinePtr *machines = NULL;
size_t nmachines = 0;
- qemuCapsPtr qemubinCaps = NULL;
- qemuCapsPtr kvmbinCaps = NULL;
+ virQEMUCapsPtr qemubinCaps = NULL;
+ virQEMUCapsPtr kvmbinCaps = NULL;
int ret = -1;
/* Check for existence of base emulator, or alternate base
* which can be used with magic cpu choice
*/
- binary = qemuCapsFindBinaryForArch(hostarch, guestarch);
+ binary = virQEMUCapsFindBinaryForArch(hostarch, guestarch);
/* Ignore binary if extracting version info fails */
if (binary) {
- if (!(qemubinCaps = qemuCapsCacheLookup(cache, binary))) {
+ if (!(qemubinCaps = virQEMUCapsCacheLookup(cache, binary))) {
virResetLastError();
VIR_FREE(binary);
}
* - hostarch is x86_64 and guest arch is i686
* The latter simply needs "-cpu qemu32"
*/
- if (qemuCapsIsValidForKVM(hostarch, guestarch)) {
+ if (virQEMUCapsIsValidForKVM(hostarch, guestarch)) {
const char *const kvmbins[] = { "/usr/libexec/qemu-kvm", /* RHEL */
"qemu-kvm", /* Fedora */
"kvm" }; /* Upstream .spec */
if (!kvmbin)
continue;
- if (!(kvmbinCaps = qemuCapsCacheLookup(cache, kvmbin))) {
+ if (!(kvmbinCaps = virQEMUCapsCacheLookup(cache, kvmbin))) {
virResetLastError();
VIR_FREE(kvmbin);
continue;
return 0;
if (access("/dev/kvm", F_OK) == 0 &&
- (qemuCapsGet(qemubinCaps, QEMU_CAPS_KVM) ||
- qemuCapsGet(qemubinCaps, QEMU_CAPS_ENABLE_KVM) ||
+ (virQEMUCapsGet(qemubinCaps, QEMU_CAPS_KVM) ||
+ virQEMUCapsGet(qemubinCaps, QEMU_CAPS_ENABLE_KVM) ||
kvmbin))
haskvm = 1;
if (access("/dev/kqemu", F_OK) == 0 &&
- qemuCapsGet(qemubinCaps, QEMU_CAPS_KQEMU))
+ virQEMUCapsGet(qemubinCaps, QEMU_CAPS_KQEMU))
haskqemu = 1;
- if (qemuCapsGetMachineTypesCaps(qemubinCaps, &nmachines, &machines) < 0)
+ if (virQEMUCapsGetMachineTypesCaps(qemubinCaps, &nmachines, &machines) < 0)
goto error;
/* We register kvm as the base emulator too, since we can
if (caps->host.cpu &&
caps->host.cpu->model &&
- qemuCapsGetCPUDefinitions(qemubinCaps, NULL) > 0 &&
+ virQEMUCapsGetCPUDefinitions(qemubinCaps, NULL) > 0 &&
!virCapabilitiesAddGuestFeature(guest, "cpuselection", 1, 0))
goto error;
- if (qemuCapsGet(qemubinCaps, QEMU_CAPS_BOOTINDEX) &&
+ if (virQEMUCapsGet(qemubinCaps, QEMU_CAPS_BOOTINDEX) &&
!virCapabilitiesAddGuestFeature(guest, "deviceboot", 1, 0))
goto error;
virCapsGuestDomainPtr dom;
if (kvmbin &&
- qemuCapsGetMachineTypesCaps(kvmbinCaps, &nmachines, &machines) < 0)
+ virQEMUCapsGetMachineTypesCaps(kvmbinCaps, &nmachines, &machines) < 0)
goto error;
if ((dom = virCapabilitiesAddGuestDomain(guest,
static int
-qemuCapsInitCPU(virCapsPtr caps,
- virArch arch)
+virQEMUCapsInitCPU(virCapsPtr caps,
+ virArch arch)
{
virCPUDefPtr cpu = NULL;
union cpuData *data = NULL;
}
-static int qemuDefaultConsoleType(const char *ostype ATTRIBUTE_UNUSED,
- virArch arch)
+static int virQEMUCapsDefaultConsoleType(const char *ostype ATTRIBUTE_UNUSED,
+ virArch arch)
{
if (arch == VIR_ARCH_S390 ||
arch == VIR_ARCH_S390X)
}
-virCapsPtr qemuCapsInit(qemuCapsCachePtr cache)
+virCapsPtr virQEMUCapsInit(virQEMUCapsCachePtr cache)
{
virCapsPtr caps;
int i;
VIR_WARN("Failed to query host NUMA topology, disabling NUMA capabilities");
}
- if (qemuCapsInitCPU(caps, virArchFromHost()) < 0)
+ if (virQEMUCapsInitCPU(caps, virArchFromHost()) < 0)
VIR_WARN("Failed to get host CPU");
/* Add the power management features of the host */
* if a qemu-system-$ARCH binary can't be found
*/
for (i = 0 ; i < VIR_ARCH_LAST ; i++)
- if (qemuCapsInitGuest(caps, cache,
- virArchFromHost(),
- i) < 0)
+ if (virQEMUCapsInitGuest(caps, cache,
+ virArchFromHost(),
+ i) < 0)
goto error;
/* QEMU Requires an emulator in the XML */
virCapabilitiesSetEmulatorRequired(caps);
- caps->defaultConsoleTargetType = qemuDefaultConsoleType;
+ caps->defaultConsoleTargetType = virQEMUCapsDefaultConsoleType;
return caps;
static int
-qemuCapsComputeCmdFlags(const char *help,
- unsigned int version,
- unsigned int is_kvm,
- unsigned int kvm_version,
- qemuCapsPtr caps,
- bool check_yajl ATTRIBUTE_UNUSED)
+virQEMUCapsComputeCmdFlags(const char *help,
+ unsigned int version,
+ unsigned int is_kvm,
+ unsigned int kvm_version,
+ virQEMUCapsPtr qemuCaps,
+ bool check_yajl ATTRIBUTE_UNUSED)
{
const char *p;
const char *fsdev, *netdev;
if (strstr(help, "-no-kqemu"))
- qemuCapsSet(caps, QEMU_CAPS_KQEMU);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_KQEMU);
if (strstr(help, "-enable-kqemu"))
- qemuCapsSet(caps, QEMU_CAPS_ENABLE_KQEMU);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_ENABLE_KQEMU);
if (strstr(help, "-no-kvm"))
- qemuCapsSet(caps, QEMU_CAPS_KVM);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_KVM);
if (strstr(help, "-enable-kvm"))
- qemuCapsSet(caps, QEMU_CAPS_ENABLE_KVM);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_ENABLE_KVM);
if (strstr(help, "-no-reboot"))
- qemuCapsSet(caps, QEMU_CAPS_NO_REBOOT);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_REBOOT);
if (strstr(help, "-name")) {
- qemuCapsSet(caps, QEMU_CAPS_NAME);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_NAME);
if (strstr(help, ",process="))
- qemuCapsSet(caps, QEMU_CAPS_NAME_PROCESS);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_NAME_PROCESS);
}
if (strstr(help, "-uuid"))
- qemuCapsSet(caps, QEMU_CAPS_UUID);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_UUID);
if (strstr(help, "-xen-domid"))
- qemuCapsSet(caps, QEMU_CAPS_XEN_DOMID);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_XEN_DOMID);
else if (strstr(help, "-domid"))
- qemuCapsSet(caps, QEMU_CAPS_DOMID);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_DOMID);
if (strstr(help, "-drive")) {
const char *cache = strstr(help, "cache=");
- qemuCapsSet(caps, QEMU_CAPS_DRIVE);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE);
if (cache && (p = strchr(cache, ']'))) {
if (memmem(cache, p - cache, "on|off", sizeof("on|off") - 1) == NULL)
- qemuCapsSet(caps, QEMU_CAPS_DRIVE_CACHE_V2);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_V2);
if (memmem(cache, p - cache, "directsync", sizeof("directsync") - 1))
- qemuCapsSet(caps, QEMU_CAPS_DRIVE_CACHE_DIRECTSYNC);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_DIRECTSYNC);
if (memmem(cache, p - cache, "unsafe", sizeof("unsafe") - 1))
- qemuCapsSet(caps, QEMU_CAPS_DRIVE_CACHE_UNSAFE);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_UNSAFE);
}
if (strstr(help, "format="))
- qemuCapsSet(caps, QEMU_CAPS_DRIVE_FORMAT);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_FORMAT);
if (strstr(help, "readonly="))
- qemuCapsSet(caps, QEMU_CAPS_DRIVE_READONLY);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_READONLY);
if (strstr(help, "aio=threads|native"))
- qemuCapsSet(caps, QEMU_CAPS_DRIVE_AIO);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_AIO);
if (strstr(help, "copy-on-read=on|off"))
- qemuCapsSet(caps, QEMU_CAPS_DRIVE_COPY_ON_READ);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_COPY_ON_READ);
if (strstr(help, "bps="))
- qemuCapsSet(caps, QEMU_CAPS_DRIVE_IOTUNE);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_IOTUNE);
}
if ((p = strstr(help, "-vga")) && !strstr(help, "-std-vga")) {
const char *nl = strstr(p, "\n");
- qemuCapsSet(caps, QEMU_CAPS_VGA);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_VGA);
if (strstr(p, "|qxl"))
- qemuCapsSet(caps, QEMU_CAPS_VGA_QXL);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_VGA_QXL);
if ((p = strstr(p, "|none")) && p < nl)
- qemuCapsSet(caps, QEMU_CAPS_VGA_NONE);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_VGA_NONE);
}
if (strstr(help, "-spice"))
- qemuCapsSet(caps, QEMU_CAPS_SPICE);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_SPICE);
if (strstr(help, "-vnc"))
- qemuCapsSet(caps, QEMU_CAPS_VNC);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_VNC);
if (strstr(help, "seamless-migration="))
- qemuCapsSet(caps, QEMU_CAPS_SEAMLESS_MIGRATION);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_SEAMLESS_MIGRATION);
if (strstr(help, "boot=on"))
- qemuCapsSet(caps, QEMU_CAPS_DRIVE_BOOT);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_BOOT);
if (strstr(help, "serial=s"))
- qemuCapsSet(caps, QEMU_CAPS_DRIVE_SERIAL);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_SERIAL);
if (strstr(help, "-pcidevice"))
- qemuCapsSet(caps, QEMU_CAPS_PCIDEVICE);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_PCIDEVICE);
if (strstr(help, "-mem-path"))
- qemuCapsSet(caps, QEMU_CAPS_MEM_PATH);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_MEM_PATH);
if (strstr(help, "-chardev")) {
- qemuCapsSet(caps, QEMU_CAPS_CHARDEV);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_CHARDEV);
if (strstr(help, "-chardev spicevmc"))
- qemuCapsSet(caps, QEMU_CAPS_CHARDEV_SPICEVMC);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_CHARDEV_SPICEVMC);
}
if (strstr(help, "-balloon"))
- qemuCapsSet(caps, QEMU_CAPS_BALLOON);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_BALLOON);
if (strstr(help, "-device")) {
- qemuCapsSet(caps, QEMU_CAPS_DEVICE);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_DEVICE);
/*
* When -device was introduced, qemu already supported drive's
* readonly option but didn't advertise that.
*/
- qemuCapsSet(caps, QEMU_CAPS_DRIVE_READONLY);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_READONLY);
}
if (strstr(help, "-nodefconfig"))
- qemuCapsSet(caps, QEMU_CAPS_NODEFCONFIG);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_NODEFCONFIG);
if (strstr(help, "-no-user-config"))
- qemuCapsSet(caps, QEMU_CAPS_NO_USER_CONFIG);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_USER_CONFIG);
/* The trailing ' ' is important to avoid a bogus match */
if (strstr(help, "-rtc "))
- qemuCapsSet(caps, QEMU_CAPS_RTC);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_RTC);
/* to wit */
if (strstr(help, "-rtc-td-hack"))
- qemuCapsSet(caps, QEMU_CAPS_RTC_TD_HACK);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_RTC_TD_HACK);
if (strstr(help, "-no-hpet"))
- qemuCapsSet(caps, QEMU_CAPS_NO_HPET);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_HPET);
if (strstr(help, "-no-acpi"))
- qemuCapsSet(caps, QEMU_CAPS_NO_ACPI);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_ACPI);
if (strstr(help, "-no-kvm-pit-reinjection"))
- qemuCapsSet(caps, QEMU_CAPS_NO_KVM_PIT);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_KVM_PIT);
if (strstr(help, "-tdf"))
- qemuCapsSet(caps, QEMU_CAPS_TDF);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_TDF);
if (strstr(help, "-enable-nesting"))
- qemuCapsSet(caps, QEMU_CAPS_NESTING);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_NESTING);
if (strstr(help, ",menu=on"))
- qemuCapsSet(caps, QEMU_CAPS_BOOT_MENU);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_BOOT_MENU);
if (strstr(help, ",reboot-timeout=rb_time"))
- qemuCapsSet(caps, QEMU_CAPS_REBOOT_TIMEOUT);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_REBOOT_TIMEOUT);
if ((fsdev = strstr(help, "-fsdev"))) {
- qemuCapsSet(caps, QEMU_CAPS_FSDEV);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_FSDEV);
if (strstr(fsdev, "readonly"))
- qemuCapsSet(caps, QEMU_CAPS_FSDEV_READONLY);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_FSDEV_READONLY);
if (strstr(fsdev, "writeout"))
- qemuCapsSet(caps, QEMU_CAPS_FSDEV_WRITEOUT);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_FSDEV_WRITEOUT);
}
if (strstr(help, "-smbios type"))
- qemuCapsSet(caps, QEMU_CAPS_SMBIOS_TYPE);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_SMBIOS_TYPE);
if (strstr(help, "-sandbox"))
- qemuCapsSet(caps, QEMU_CAPS_SECCOMP_SANDBOX);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_SECCOMP_SANDBOX);
if ((netdev = strstr(help, "-netdev"))) {
/* Disable -netdev on 0.12 since although it exists,
* But see below about RHEL build. */
if (version >= 13000) {
if (strstr(netdev, "bridge"))
- qemuCapsSet(caps, QEMU_CAPS_NETDEV_BRIDGE);
- qemuCapsSet(caps, QEMU_CAPS_NETDEV);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_NETDEV_BRIDGE);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_NETDEV);
}
}
if (strstr(help, "-sdl"))
- qemuCapsSet(caps, QEMU_CAPS_SDL);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_SDL);
if (strstr(help, "cores=") &&
strstr(help, "threads=") &&
strstr(help, "sockets="))
- qemuCapsSet(caps, QEMU_CAPS_SMP_TOPOLOGY);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_SMP_TOPOLOGY);
if (version >= 9000)
- qemuCapsSet(caps, QEMU_CAPS_VNC_COLON);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_VNC_COLON);
if (is_kvm && (version >= 10000 || kvm_version >= 74))
- qemuCapsSet(caps, QEMU_CAPS_VNET_HDR);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_VNET_HDR);
if (strstr(help, ",vhost=")) {
- qemuCapsSet(caps, QEMU_CAPS_VHOST_NET);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_VHOST_NET);
}
/* Do not use -no-shutdown if qemu doesn't support it or SIGTERM handling
* 0.14.* and 0.15.0)
*/
if (strstr(help, "-no-shutdown") && (version < 14000 || version > 15000))
- qemuCapsSet(caps, QEMU_CAPS_NO_SHUTDOWN);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_SHUTDOWN);
if (strstr(help, "dump-guest-core=on|off"))
- qemuCapsSet(caps, QEMU_CAPS_DUMP_GUEST_CORE);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_DUMP_GUEST_CORE);
/*
* Handling of -incoming arg with varying features
* while waiting for data, so pretend it doesn't exist
*/
if (version >= 10000) {
- qemuCapsSet(caps, QEMU_CAPS_MIGRATE_QEMU_TCP);
- qemuCapsSet(caps, QEMU_CAPS_MIGRATE_QEMU_EXEC);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_TCP);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_EXEC);
if (version >= 12000) {
- qemuCapsSet(caps, QEMU_CAPS_MIGRATE_QEMU_UNIX);
- qemuCapsSet(caps, QEMU_CAPS_MIGRATE_QEMU_FD);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_UNIX);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_FD);
}
} else if (kvm_version >= 79) {
- qemuCapsSet(caps, QEMU_CAPS_MIGRATE_QEMU_TCP);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_TCP);
if (kvm_version >= 80)
- qemuCapsSet(caps, QEMU_CAPS_MIGRATE_QEMU_EXEC);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_EXEC);
} else if (kvm_version > 0) {
- qemuCapsSet(caps, QEMU_CAPS_MIGRATE_KVM_STDIO);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_MIGRATE_KVM_STDIO);
}
if (version >= 10000)
- qemuCapsSet(caps, QEMU_CAPS_0_10);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_0_10);
if (version >= 11000)
- qemuCapsSet(caps, QEMU_CAPS_VIRTIO_BLK_SG_IO);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_VIRTIO_BLK_SG_IO);
/* While JSON mode was available in 0.12.0, it was too
* incomplete to contemplate using. The 0.13.0 release
*/
#if WITH_YAJL
if (version >= 13000) {
- qemuCapsSet(caps, QEMU_CAPS_MONITOR_JSON);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_MONITOR_JSON);
} else if (version >= 12000 &&
strstr(help, "libvirt")) {
- qemuCapsSet(caps, QEMU_CAPS_MONITOR_JSON);
- qemuCapsSet(caps, QEMU_CAPS_NETDEV);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_MONITOR_JSON);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_NETDEV);
}
#else
/* Starting with qemu 0.15 and newer, upstream qemu no longer
"compiled with yajl"));
return -1;
}
- qemuCapsSet(caps, QEMU_CAPS_NETDEV);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_NETDEV);
}
#endif
if (version >= 13000)
- qemuCapsSet(caps, QEMU_CAPS_PCI_MULTIFUNCTION);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_PCI_MULTIFUNCTION);
/* Although very new versions of qemu advertise the presence of
* the rombar option in the output of "qemu -device pci-assign,?",
* log and refuse to start, so it would be immediately obvious).
*/
if (version >= 12000)
- qemuCapsSet(caps, QEMU_CAPS_PCI_ROMBAR);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_PCI_ROMBAR);
if (version >= 11000)
- qemuCapsSet(caps, QEMU_CAPS_CPU_HOST);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_CPU_HOST);
if (version >= 1002000)
- qemuCapsSet(caps, QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
return 0;
}
#define SKIP_BLANKS(p) do { while ((*(p) == ' ') || (*(p) == '\t')) (p)++; } while (0)
-int qemuCapsParseHelpStr(const char *qemu,
- const char *help,
- qemuCapsPtr caps,
- unsigned int *version,
- unsigned int *is_kvm,
- unsigned int *kvm_version,
- bool check_yajl)
+int virQEMUCapsParseHelpStr(const char *qemu,
+ const char *help,
+ virQEMUCapsPtr qemuCaps,
+ unsigned int *version,
+ unsigned int *is_kvm,
+ unsigned int *kvm_version,
+ bool check_yajl)
{
unsigned major, minor, micro;
const char *p = help;
*version = (major * 1000 * 1000) + (minor * 1000) + micro;
- if (qemuCapsComputeCmdFlags(help, *version, *is_kvm, *kvm_version,
- caps, check_yajl) < 0)
+ if (virQEMUCapsComputeCmdFlags(help, *version, *is_kvm, *kvm_version,
+ qemuCaps, check_yajl) < 0)
goto cleanup;
- strflags = virBitmapString(caps->flags);
+ strflags = virBitmapString(qemuCaps->flags);
VIR_DEBUG("Version %u.%u.%u, cooked version %u, flags %s",
major, minor, micro, *version, NULLSTR(strflags));
VIR_FREE(strflags);
}
-struct qemuCapsStringFlags {
+struct virQEMUCapsStringFlags {
const char *value;
int flag;
};
-struct qemuCapsStringFlags qemuCapsObjectTypes[] = {
+struct virQEMUCapsStringFlags virQEMUCapsObjectTypes[] = {
{ "hda-duplex", QEMU_CAPS_HDA_DUPLEX },
{ "hda-micro", QEMU_CAPS_HDA_MICRO },
{ "ccid-card-emulated", QEMU_CAPS_CCID_EMULATED },
};
-static struct qemuCapsStringFlags qemuCapsObjectPropsVirtioBlk[] = {
+static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsVirtioBlk[] = {
{ "multifunction", QEMU_CAPS_PCI_MULTIFUNCTION },
{ "bootindex", QEMU_CAPS_BOOTINDEX },
{ "ioeventfd", QEMU_CAPS_VIRTIO_IOEVENTFD },
{ "logical_block_size", QEMU_CAPS_BLOCKIO },
};
-static struct qemuCapsStringFlags qemuCapsObjectPropsVirtioNet[] = {
+static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsVirtioNet[] = {
{ "tx", QEMU_CAPS_VIRTIO_TX_ALG },
{ "event_idx", QEMU_CAPS_VIRTIO_NET_EVENT_IDX },
};
-static struct qemuCapsStringFlags qemuCapsObjectPropsPciAssign[] = {
+static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsPciAssign[] = {
{ "rombar", QEMU_CAPS_PCI_ROMBAR },
{ "configfd", QEMU_CAPS_PCI_CONFIGFD },
{ "bootindex", QEMU_CAPS_PCI_BOOTINDEX },
};
-static struct qemuCapsStringFlags qemuCapsObjectPropsScsiDisk[] = {
+static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsScsiDisk[] = {
{ "channel", QEMU_CAPS_SCSI_DISK_CHANNEL },
{ "wwn", QEMU_CAPS_SCSI_DISK_WWN },
};
-static struct qemuCapsStringFlags qemuCapsObjectPropsIDEDrive[] = {
+static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsIDEDrive[] = {
{ "wwn", QEMU_CAPS_IDE_DRIVE_WWN },
};
-static struct qemuCapsStringFlags qemuCapsObjectPropsPixx4PM[] = {
+static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsPixx4PM[] = {
{ "disable_s3", QEMU_CAPS_DISABLE_S3 },
{ "disable_s4", QEMU_CAPS_DISABLE_S4 },
};
-static struct qemuCapsStringFlags qemuCapsObjectPropsUsbRedir[] = {
+static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsUsbRedir[] = {
{ "filter", QEMU_CAPS_USB_REDIR_FILTER },
{ "bootindex", QEMU_CAPS_USB_REDIR_BOOTINDEX },
};
-static struct qemuCapsStringFlags qemuCapsObjectPropsUsbHost[] = {
+static struct virQEMUCapsStringFlags virQEMUCapsObjectPropsUsbHost[] = {
{ "bootindex", QEMU_CAPS_USB_HOST_BOOTINDEX },
};
-struct qemuCapsObjectTypeProps {
+struct virQEMUCapsObjectTypeProps {
const char *type;
- struct qemuCapsStringFlags *props;
+ struct virQEMUCapsStringFlags *props;
size_t nprops;
};
-static struct qemuCapsObjectTypeProps qemuCapsObjectProps[] = {
- { "virtio-blk-pci", qemuCapsObjectPropsVirtioBlk,
- ARRAY_CARDINALITY(qemuCapsObjectPropsVirtioBlk) },
- { "virtio-net-pci", qemuCapsObjectPropsVirtioNet,
- ARRAY_CARDINALITY(qemuCapsObjectPropsVirtioNet) },
- { "virtio-blk-s390", qemuCapsObjectPropsVirtioBlk,
- ARRAY_CARDINALITY(qemuCapsObjectPropsVirtioBlk) },
- { "virtio-net-s390", qemuCapsObjectPropsVirtioNet,
- ARRAY_CARDINALITY(qemuCapsObjectPropsVirtioNet) },
- { "pci-assign", qemuCapsObjectPropsPciAssign,
- ARRAY_CARDINALITY(qemuCapsObjectPropsPciAssign) },
- { "kvm-pci-assign", qemuCapsObjectPropsPciAssign,
- ARRAY_CARDINALITY(qemuCapsObjectPropsPciAssign) },
- { "scsi-disk", qemuCapsObjectPropsScsiDisk,
- ARRAY_CARDINALITY(qemuCapsObjectPropsScsiDisk) },
- { "ide-drive", qemuCapsObjectPropsIDEDrive,
- ARRAY_CARDINALITY(qemuCapsObjectPropsIDEDrive) },
- { "PIIX4_PM", qemuCapsObjectPropsPixx4PM,
- ARRAY_CARDINALITY(qemuCapsObjectPropsPixx4PM) },
- { "usb-redir", qemuCapsObjectPropsUsbRedir,
- ARRAY_CARDINALITY(qemuCapsObjectPropsUsbRedir) },
- { "usb-host", qemuCapsObjectPropsUsbHost,
- ARRAY_CARDINALITY(qemuCapsObjectPropsUsbHost) },
+static struct virQEMUCapsObjectTypeProps virQEMUCapsObjectProps[] = {
+ { "virtio-blk-pci", virQEMUCapsObjectPropsVirtioBlk,
+ ARRAY_CARDINALITY(virQEMUCapsObjectPropsVirtioBlk) },
+ { "virtio-net-pci", virQEMUCapsObjectPropsVirtioNet,
+ ARRAY_CARDINALITY(virQEMUCapsObjectPropsVirtioNet) },
+ { "virtio-blk-s390", virQEMUCapsObjectPropsVirtioBlk,
+ ARRAY_CARDINALITY(virQEMUCapsObjectPropsVirtioBlk) },
+ { "virtio-net-s390", virQEMUCapsObjectPropsVirtioNet,
+ ARRAY_CARDINALITY(virQEMUCapsObjectPropsVirtioNet) },
+ { "pci-assign", virQEMUCapsObjectPropsPciAssign,
+ ARRAY_CARDINALITY(virQEMUCapsObjectPropsPciAssign) },
+ { "kvm-pci-assign", virQEMUCapsObjectPropsPciAssign,
+ ARRAY_CARDINALITY(virQEMUCapsObjectPropsPciAssign) },
+ { "scsi-disk", virQEMUCapsObjectPropsScsiDisk,
+ ARRAY_CARDINALITY(virQEMUCapsObjectPropsScsiDisk) },
+ { "ide-drive", virQEMUCapsObjectPropsIDEDrive,
+ ARRAY_CARDINALITY(virQEMUCapsObjectPropsIDEDrive) },
+ { "PIIX4_PM", virQEMUCapsObjectPropsPixx4PM,
+ ARRAY_CARDINALITY(virQEMUCapsObjectPropsPixx4PM) },
+ { "usb-redir", virQEMUCapsObjectPropsUsbRedir,
+ ARRAY_CARDINALITY(virQEMUCapsObjectPropsUsbRedir) },
+ { "usb-host", virQEMUCapsObjectPropsUsbHost,
+ ARRAY_CARDINALITY(virQEMUCapsObjectPropsUsbHost) },
};
static void
-qemuCapsProcessStringFlags(qemuCapsPtr caps,
- size_t nflags,
- struct qemuCapsStringFlags *flags,
- size_t nvalues,
- char *const*values)
+virQEMUCapsProcessStringFlags(virQEMUCapsPtr qemuCaps,
+ size_t nflags,
+ struct virQEMUCapsStringFlags *flags,
+ size_t nvalues,
+ char *const*values)
{
size_t i, j;
for (i = 0 ; i < nflags ; i++) {
for (j = 0 ; j < nvalues ; j++) {
if (STREQ(values[j], flags[i].value)) {
- qemuCapsSet(caps, flags[i].flag);
+ virQEMUCapsSet(qemuCaps, flags[i].flag);
break;
}
}
static void
-qemuCapsFreeStringList(size_t len,
- char **values)
+virQEMUCapsFreeStringList(size_t len,
+ char **values)
{
size_t i;
for (i = 0 ; i < len ; i++)
#define OBJECT_TYPE_PREFIX "name \""
static int
-qemuCapsParseDeviceStrObjectTypes(const char *str,
- char ***types)
+virQEMUCapsParseDeviceStrObjectTypes(const char *str,
+ char ***types)
{
const char *tmp = str;
int ret = -1;
cleanup:
if (ret < 0)
- qemuCapsFreeStringList(ntypelist, typelist);
+ virQEMUCapsFreeStringList(ntypelist, typelist);
return ret;
}
static int
-qemuCapsParseDeviceStrObjectProps(const char *str,
- const char *type,
- char ***props)
+virQEMUCapsParseDeviceStrObjectProps(const char *str,
+ const char *type,
+ char ***props)
{
const char *tmp = str;
int ret = -1;
cleanup:
if (ret < 0)
- qemuCapsFreeStringList(nproplist, proplist);
+ virQEMUCapsFreeStringList(nproplist, proplist);
return ret;
}
int
-qemuCapsParseDeviceStr(qemuCapsPtr caps, const char *str)
+virQEMUCapsParseDeviceStr(virQEMUCapsPtr qemuCaps, const char *str)
{
int nvalues;
char **values;
size_t i;
- if ((nvalues = qemuCapsParseDeviceStrObjectTypes(str, &values)) < 0)
+ if ((nvalues = virQEMUCapsParseDeviceStrObjectTypes(str, &values)) < 0)
return -1;
- qemuCapsProcessStringFlags(caps,
- ARRAY_CARDINALITY(qemuCapsObjectTypes),
- qemuCapsObjectTypes,
- nvalues, values);
- qemuCapsFreeStringList(nvalues, values);
-
- for (i = 0 ; i < ARRAY_CARDINALITY(qemuCapsObjectProps); i++) {
- const char *type = qemuCapsObjectProps[i].type;
- if ((nvalues = qemuCapsParseDeviceStrObjectProps(str,
- type,
- &values)) < 0)
+ virQEMUCapsProcessStringFlags(qemuCaps,
+ ARRAY_CARDINALITY(virQEMUCapsObjectTypes),
+ virQEMUCapsObjectTypes,
+ nvalues, values);
+ virQEMUCapsFreeStringList(nvalues, values);
+
+ for (i = 0 ; i < ARRAY_CARDINALITY(virQEMUCapsObjectProps); i++) {
+ const char *type = virQEMUCapsObjectProps[i].type;
+ if ((nvalues = virQEMUCapsParseDeviceStrObjectProps(str,
+ type,
+ &values)) < 0)
return -1;
- qemuCapsProcessStringFlags(caps,
- qemuCapsObjectProps[i].nprops,
- qemuCapsObjectProps[i].props,
- nvalues, values);
- qemuCapsFreeStringList(nvalues, values);
+ virQEMUCapsProcessStringFlags(qemuCaps,
+ virQEMUCapsObjectProps[i].nprops,
+ virQEMUCapsObjectProps[i].props,
+ nvalues, values);
+ virQEMUCapsFreeStringList(nvalues, values);
}
/* Prefer -chardev spicevmc (detected earlier) over -device spicevmc */
- if (qemuCapsGet(caps, QEMU_CAPS_CHARDEV_SPICEVMC))
- qemuCapsClear(caps, QEMU_CAPS_DEVICE_SPICEVMC);
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_CHARDEV_SPICEVMC))
+ virQEMUCapsClear(qemuCaps, QEMU_CAPS_DEVICE_SPICEVMC);
return 0;
}
static int
-qemuCapsExtractDeviceStr(const char *qemu,
- qemuCapsPtr caps,
- qemuCapsHookDataPtr hookData)
+virQEMUCapsExtractDeviceStr(const char *qemu,
+ virQEMUCapsPtr qemuCaps,
+ virQEMUCapsHookDataPtr hookData)
{
char *output = NULL;
virCommandPtr cmd;
* understand '-device name,?', and always exits with status 1 for
* the simpler '-device ?', so this function is really only useful
* if -help includes "device driver,?". */
- cmd = qemuCapsProbeCommand(qemu, caps, hookData);
+ cmd = virQEMUCapsProbeCommand(qemu, qemuCaps, hookData);
virCommandAddArgList(cmd,
"-device", "?",
"-device", "pci-assign,?",
if (virCommandRun(cmd, NULL) < 0)
goto cleanup;
- ret = qemuCapsParseDeviceStr(caps, output);
+ ret = virQEMUCapsParseDeviceStr(qemuCaps, output);
cleanup:
VIR_FREE(output);
}
-int qemuCapsGetDefaultVersion(virCapsPtr caps,
- qemuCapsCachePtr capsCache,
- unsigned int *version)
+int virQEMUCapsGetDefaultVersion(virCapsPtr caps,
+ virQEMUCapsCachePtr capsCache,
+ unsigned int *version)
{
const char *binary;
- qemuCapsPtr qemucaps;
+ virQEMUCapsPtr qemucaps;
if (*version > 0)
return 0;
return -1;
}
- if (!(qemucaps = qemuCapsCacheLookup(capsCache, binary)))
+ if (!(qemucaps = virQEMUCapsCacheLookup(capsCache, binary)))
return -1;
- *version = qemuCapsGetVersion(qemucaps);
+ *version = virQEMUCapsGetVersion(qemucaps);
virObjectUnref(qemucaps);
return 0;
}
-qemuCapsPtr
-qemuCapsNew(void)
+virQEMUCapsPtr
+virQEMUCapsNew(void)
{
- qemuCapsPtr caps;
+ virQEMUCapsPtr qemuCaps;
- if (qemuCapsInitialize() < 0)
+ if (virQEMUCapsInitialize() < 0)
return NULL;
- if (!(caps = virObjectNew(qemuCapsClass)))
+ if (!(qemuCaps = virObjectNew(virQEMUCapsClass)))
return NULL;
- if (!(caps->flags = virBitmapNew(QEMU_CAPS_LAST)))
+ if (!(qemuCaps->flags = virBitmapNew(QEMU_CAPS_LAST)))
goto no_memory;
- return caps;
+ return qemuCaps;
no_memory:
virReportOOMError();
- virObjectUnref(caps);
+ virObjectUnref(qemuCaps);
return NULL;
}
-qemuCapsPtr qemuCapsNewCopy(qemuCapsPtr caps)
+virQEMUCapsPtr virQEMUCapsNewCopy(virQEMUCapsPtr qemuCaps)
{
- qemuCapsPtr ret = qemuCapsNew();
+ virQEMUCapsPtr ret = virQEMUCapsNew();
size_t i;
if (!ret)
return NULL;
- virBitmapCopy(ret->flags, caps->flags);
+ virBitmapCopy(ret->flags, qemuCaps->flags);
- ret->usedQMP = caps->usedQMP;
- ret->version = caps->version;
- ret->kvmVersion = caps->kvmVersion;
- ret->arch = caps->arch;
+ ret->usedQMP = qemuCaps->usedQMP;
+ ret->version = qemuCaps->version;
+ ret->kvmVersion = qemuCaps->kvmVersion;
+ ret->arch = qemuCaps->arch;
- if (VIR_ALLOC_N(ret->cpuDefinitions, caps->ncpuDefinitions) < 0)
+ if (VIR_ALLOC_N(ret->cpuDefinitions, qemuCaps->ncpuDefinitions) < 0)
goto no_memory;
- ret->ncpuDefinitions = caps->ncpuDefinitions;
- for (i = 0 ; i < caps->ncpuDefinitions ; i++) {
- if (!(ret->cpuDefinitions[i] = strdup(caps->cpuDefinitions[i])))
+ ret->ncpuDefinitions = qemuCaps->ncpuDefinitions;
+ for (i = 0 ; i < qemuCaps->ncpuDefinitions ; i++) {
+ if (!(ret->cpuDefinitions[i] = strdup(qemuCaps->cpuDefinitions[i])))
goto no_memory;
}
- if (VIR_ALLOC_N(ret->machineTypes, caps->nmachineTypes) < 0)
+ if (VIR_ALLOC_N(ret->machineTypes, qemuCaps->nmachineTypes) < 0)
goto no_memory;
- if (VIR_ALLOC_N(ret->machineAliases, caps->nmachineTypes) < 0)
+ if (VIR_ALLOC_N(ret->machineAliases, qemuCaps->nmachineTypes) < 0)
goto no_memory;
- ret->nmachineTypes = caps->nmachineTypes;
- for (i = 0 ; i < caps->nmachineTypes ; i++) {
- if (!(ret->machineTypes[i] = strdup(caps->machineTypes[i])))
+ ret->nmachineTypes = qemuCaps->nmachineTypes;
+ for (i = 0 ; i < qemuCaps->nmachineTypes ; i++) {
+ if (!(ret->machineTypes[i] = strdup(qemuCaps->machineTypes[i])))
goto no_memory;
- if (caps->machineAliases[i] &&
- !(ret->machineAliases[i] = strdup(caps->machineAliases[i])))
+ if (qemuCaps->machineAliases[i] &&
+ !(ret->machineAliases[i] = strdup(qemuCaps->machineAliases[i])))
goto no_memory;
}
}
-void qemuCapsDispose(void *obj)
+void virQEMUCapsDispose(void *obj)
{
- qemuCapsPtr caps = obj;
+ virQEMUCapsPtr qemuCaps = obj;
size_t i;
- for (i = 0 ; i < caps->nmachineTypes ; i++) {
- VIR_FREE(caps->machineTypes[i]);
- VIR_FREE(caps->machineAliases[i]);
+ for (i = 0 ; i < qemuCaps->nmachineTypes ; i++) {
+ VIR_FREE(qemuCaps->machineTypes[i]);
+ VIR_FREE(qemuCaps->machineAliases[i]);
}
- VIR_FREE(caps->machineTypes);
- VIR_FREE(caps->machineAliases);
+ VIR_FREE(qemuCaps->machineTypes);
+ VIR_FREE(qemuCaps->machineAliases);
- for (i = 0 ; i < caps->ncpuDefinitions ; i++) {
- VIR_FREE(caps->cpuDefinitions[i]);
+ for (i = 0 ; i < qemuCaps->ncpuDefinitions ; i++) {
+ VIR_FREE(qemuCaps->cpuDefinitions[i]);
}
- VIR_FREE(caps->cpuDefinitions);
+ VIR_FREE(qemuCaps->cpuDefinitions);
- virBitmapFree(caps->flags);
+ virBitmapFree(qemuCaps->flags);
- VIR_FREE(caps->binary);
+ VIR_FREE(qemuCaps->binary);
}
void
-qemuCapsSet(qemuCapsPtr caps,
- enum qemuCapsFlags flag)
+virQEMUCapsSet(virQEMUCapsPtr qemuCaps,
+ enum virQEMUCapsFlags flag)
{
- ignore_value(virBitmapSetBit(caps->flags, flag));
+ ignore_value(virBitmapSetBit(qemuCaps->flags, flag));
}
void
-qemuCapsSetList(qemuCapsPtr caps, ...)
+virQEMUCapsSetList(virQEMUCapsPtr qemuCaps, ...)
{
va_list list;
int flag;
- va_start(list, caps);
+ va_start(list, qemuCaps);
while ((flag = va_arg(list, int)) < QEMU_CAPS_LAST)
- ignore_value(virBitmapSetBit(caps->flags, flag));
+ ignore_value(virBitmapSetBit(qemuCaps->flags, flag));
va_end(list);
}
void
-qemuCapsClear(qemuCapsPtr caps,
- enum qemuCapsFlags flag)
+virQEMUCapsClear(virQEMUCapsPtr qemuCaps,
+ enum virQEMUCapsFlags flag)
{
- ignore_value(virBitmapClearBit(caps->flags, flag));
+ ignore_value(virBitmapClearBit(qemuCaps->flags, flag));
}
-char *qemuCapsFlagsString(qemuCapsPtr caps)
+char *virQEMUCapsFlagsString(virQEMUCapsPtr qemuCaps)
{
- return virBitmapString(caps->flags);
+ return virBitmapString(qemuCaps->flags);
}
bool
-qemuCapsGet(qemuCapsPtr caps,
- enum qemuCapsFlags flag)
+virQEMUCapsGet(virQEMUCapsPtr qemuCaps,
+ enum virQEMUCapsFlags flag)
{
bool b;
- if (!caps || virBitmapGetBit(caps->flags, flag, &b) < 0)
+ if (!qemuCaps || virBitmapGetBit(qemuCaps->flags, flag, &b) < 0)
return false;
else
return b;
}
-const char *qemuCapsGetBinary(qemuCapsPtr caps)
+const char *virQEMUCapsGetBinary(virQEMUCapsPtr qemuCaps)
{
- return caps->binary;
+ return qemuCaps->binary;
}
-virArch qemuCapsGetArch(qemuCapsPtr caps)
+virArch virQEMUCapsGetArch(virQEMUCapsPtr qemuCaps)
{
- return caps->arch;
+ return qemuCaps->arch;
}
-unsigned int qemuCapsGetVersion(qemuCapsPtr caps)
+unsigned int virQEMUCapsGetVersion(virQEMUCapsPtr qemuCaps)
{
- return caps->version;
+ return qemuCaps->version;
}
-unsigned int qemuCapsGetKVMVersion(qemuCapsPtr caps)
+unsigned int virQEMUCapsGetKVMVersion(virQEMUCapsPtr qemuCaps)
{
- return caps->kvmVersion;
+ return qemuCaps->kvmVersion;
}
-int qemuCapsAddCPUDefinition(qemuCapsPtr caps,
- const char *name)
+int virQEMUCapsAddCPUDefinition(virQEMUCapsPtr qemuCaps,
+ const char *name)
{
char *tmp = strdup(name);
if (!tmp) {
virReportOOMError();
return -1;
}
- if (VIR_EXPAND_N(caps->cpuDefinitions, caps->ncpuDefinitions, 1) < 0) {
+ if (VIR_EXPAND_N(qemuCaps->cpuDefinitions, qemuCaps->ncpuDefinitions, 1) < 0) {
VIR_FREE(tmp);
virReportOOMError();
return -1;
}
- caps->cpuDefinitions[caps->ncpuDefinitions-1] = tmp;
+ qemuCaps->cpuDefinitions[qemuCaps->ncpuDefinitions-1] = tmp;
return 0;
}
-size_t qemuCapsGetCPUDefinitions(qemuCapsPtr caps,
- char ***names)
+size_t virQEMUCapsGetCPUDefinitions(virQEMUCapsPtr qemuCaps,
+ char ***names)
{
if (names)
- *names = caps->cpuDefinitions;
- return caps->ncpuDefinitions;
+ *names = qemuCaps->cpuDefinitions;
+ return qemuCaps->ncpuDefinitions;
}
-size_t qemuCapsGetMachineTypes(qemuCapsPtr caps,
- char ***names)
+size_t virQEMUCapsGetMachineTypes(virQEMUCapsPtr qemuCaps,
+ char ***names)
{
if (names)
- *names = caps->machineTypes;
- return caps->nmachineTypes;
+ *names = qemuCaps->machineTypes;
+ return qemuCaps->nmachineTypes;
}
-int qemuCapsGetMachineTypesCaps(qemuCapsPtr caps,
- size_t *nmachines,
- virCapsGuestMachinePtr **machines)
+int virQEMUCapsGetMachineTypesCaps(virQEMUCapsPtr qemuCaps,
+ size_t *nmachines,
+ virCapsGuestMachinePtr **machines)
{
size_t i;
*nmachines = 0;
*machines = NULL;
- if (VIR_ALLOC_N(*machines, caps->nmachineTypes) < 0)
+ if (VIR_ALLOC_N(*machines, qemuCaps->nmachineTypes) < 0)
goto no_memory;
- *nmachines = caps->nmachineTypes;
+ *nmachines = qemuCaps->nmachineTypes;
- for (i = 0 ; i < caps->nmachineTypes ; i++) {
+ for (i = 0 ; i < qemuCaps->nmachineTypes ; i++) {
virCapsGuestMachinePtr mach;
if (VIR_ALLOC(mach) < 0)
goto no_memory;
- if (caps->machineAliases[i]) {
- if (!(mach->name = strdup(caps->machineAliases[i])))
+ if (qemuCaps->machineAliases[i]) {
+ if (!(mach->name = strdup(qemuCaps->machineAliases[i])))
goto no_memory;
- if (!(mach->canonical = strdup(caps->machineTypes[i])))
+ if (!(mach->canonical = strdup(qemuCaps->machineTypes[i])))
goto no_memory;
} else {
- if (!(mach->name = strdup(caps->machineTypes[i])))
+ if (!(mach->name = strdup(qemuCaps->machineTypes[i])))
goto no_memory;
}
(*machines)[i] = mach;
-const char *qemuCapsGetCanonicalMachine(qemuCapsPtr caps,
- const char *name)
+const char *virQEMUCapsGetCanonicalMachine(virQEMUCapsPtr qemuCaps,
+ const char *name)
{
size_t i;
if (!name)
return NULL;
- for (i = 0 ; i < caps->nmachineTypes ; i++) {
- if (!caps->machineAliases[i])
+ for (i = 0 ; i < qemuCaps->nmachineTypes ; i++) {
+ if (!qemuCaps->machineAliases[i])
continue;
- if (STREQ(caps->machineAliases[i], name))
- return caps->machineTypes[i];
+ if (STREQ(qemuCaps->machineAliases[i], name))
+ return qemuCaps->machineTypes[i];
}
return name;
static int
-qemuCapsProbeQMPCommands(qemuCapsPtr caps,
- qemuMonitorPtr mon)
+virQEMUCapsProbeQMPCommands(virQEMUCapsPtr qemuCaps,
+ qemuMonitorPtr mon)
{
char **commands = NULL;
int ncommands;
for (i = 0 ; i < ncommands ; i++) {
char *name = commands[i];
if (STREQ(name, "system_wakeup"))
- qemuCapsSet(caps, QEMU_CAPS_WAKEUP);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_WAKEUP);
else if (STREQ(name, "transaction"))
- qemuCapsSet(caps, QEMU_CAPS_TRANSACTION);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_TRANSACTION);
else if (STREQ(name, "block_job_cancel"))
- qemuCapsSet(caps, QEMU_CAPS_BLOCKJOB_SYNC);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_BLOCKJOB_SYNC);
else if (STREQ(name, "block-job-cancel"))
- qemuCapsSet(caps, QEMU_CAPS_BLOCKJOB_ASYNC);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_BLOCKJOB_ASYNC);
else if (STREQ(name, "dump-guest-memory"))
- qemuCapsSet(caps, QEMU_CAPS_DUMP_GUEST_MEMORY);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_DUMP_GUEST_MEMORY);
else if (STREQ(name, "query-spice"))
- qemuCapsSet(caps, QEMU_CAPS_SPICE);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_SPICE);
else if (STREQ(name, "query-kvm"))
- qemuCapsSet(caps, QEMU_CAPS_KVM);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_KVM);
else if (STREQ(name, "block-commit"))
- qemuCapsSet(caps, QEMU_CAPS_BLOCK_COMMIT);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_BLOCK_COMMIT);
else if (STREQ(name, "query-vnc"))
- qemuCapsSet(caps, QEMU_CAPS_VNC);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_VNC);
else if (STREQ(name, "drive-mirror"))
- qemuCapsSet(caps, QEMU_CAPS_DRIVE_MIRROR);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_MIRROR);
else if (STREQ(name, "blockdev-snapshot-sync"))
- qemuCapsSet(caps, QEMU_CAPS_DISK_SNAPSHOT);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_DISK_SNAPSHOT);
else if (STREQ(name, "add-fd"))
- qemuCapsSet(caps, QEMU_CAPS_ADD_FD);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_ADD_FD);
VIR_FREE(name);
}
VIR_FREE(commands);
* management control of set numbering, and did not have a
* counterpart -add-fd command line option. We require the
* add-fd features from 1.3 or later. */
- if (qemuCapsGet(caps, QEMU_CAPS_ADD_FD)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_ADD_FD)) {
int fd = open("/dev/null", O_RDONLY);
if (fd < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
return -1;
}
if (qemuMonitorAddFd(mon, 0, fd, "/dev/null") < 0)
- qemuCapsClear(caps, QEMU_CAPS_ADD_FD);
+ virQEMUCapsClear(qemuCaps, QEMU_CAPS_ADD_FD);
VIR_FORCE_CLOSE(fd);
}
static int
-qemuCapsProbeQMPEvents(qemuCapsPtr caps,
- qemuMonitorPtr mon)
+virQEMUCapsProbeQMPEvents(virQEMUCapsPtr qemuCaps,
+ qemuMonitorPtr mon)
{
char **events = NULL;
int nevents;
char *name = events[i];
if (STREQ(name, "BALLOON_CHANGE"))
- qemuCapsSet(caps, QEMU_CAPS_BALLOON_EVENT);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_BALLOON_EVENT);
if (STREQ(name, "SPICE_MIGRATE_COMPLETED"))
- qemuCapsSet(caps, QEMU_CAPS_SEAMLESS_MIGRATION);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_SEAMLESS_MIGRATION);
VIR_FREE(name);
}
VIR_FREE(events);
static int
-qemuCapsProbeQMPObjects(qemuCapsPtr caps,
- qemuMonitorPtr mon)
+virQEMUCapsProbeQMPObjects(virQEMUCapsPtr qemuCaps,
+ qemuMonitorPtr mon)
{
int nvalues;
char **values;
if ((nvalues = qemuMonitorGetObjectTypes(mon, &values)) < 0)
return -1;
- qemuCapsProcessStringFlags(caps,
- ARRAY_CARDINALITY(qemuCapsObjectTypes),
- qemuCapsObjectTypes,
- nvalues, values);
- qemuCapsFreeStringList(nvalues, values);
-
- for (i = 0 ; i < ARRAY_CARDINALITY(qemuCapsObjectProps); i++) {
- const char *type = qemuCapsObjectProps[i].type;
+ virQEMUCapsProcessStringFlags(qemuCaps,
+ ARRAY_CARDINALITY(virQEMUCapsObjectTypes),
+ virQEMUCapsObjectTypes,
+ nvalues, values);
+ virQEMUCapsFreeStringList(nvalues, values);
+
+ for (i = 0 ; i < ARRAY_CARDINALITY(virQEMUCapsObjectProps); i++) {
+ const char *type = virQEMUCapsObjectProps[i].type;
if ((nvalues = qemuMonitorGetObjectProps(mon,
type,
&values)) < 0)
return -1;
- qemuCapsProcessStringFlags(caps,
- qemuCapsObjectProps[i].nprops,
- qemuCapsObjectProps[i].props,
- nvalues, values);
- qemuCapsFreeStringList(nvalues, values);
+ virQEMUCapsProcessStringFlags(qemuCaps,
+ virQEMUCapsObjectProps[i].nprops,
+ virQEMUCapsObjectProps[i].props,
+ nvalues, values);
+ virQEMUCapsFreeStringList(nvalues, values);
}
/* Prefer -chardev spicevmc (detected earlier) over -device spicevmc */
- if (qemuCapsGet(caps, QEMU_CAPS_CHARDEV_SPICEVMC))
- qemuCapsClear(caps, QEMU_CAPS_DEVICE_SPICEVMC);
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_CHARDEV_SPICEVMC))
+ virQEMUCapsClear(qemuCaps, QEMU_CAPS_DEVICE_SPICEVMC);
/* If qemu supports newer -device qxl it supports -vga qxl as well */
- if (qemuCapsGet(caps, QEMU_CAPS_DEVICE_QXL))
- qemuCapsSet(caps, QEMU_CAPS_VGA_QXL);
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_QXL))
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_VGA_QXL);
return 0;
}
static int
-qemuCapsProbeQMPMachineTypes(qemuCapsPtr caps,
- qemuMonitorPtr mon)
+virQEMUCapsProbeQMPMachineTypes(virQEMUCapsPtr qemuCaps,
+ qemuMonitorPtr mon)
{
qemuMonitorMachineInfoPtr *machines = NULL;
int nmachines = 0;
if ((nmachines = qemuMonitorGetMachines(mon, &machines)) < 0)
goto cleanup;
- if (VIR_ALLOC_N(caps->machineTypes, nmachines) < 0) {
+ if (VIR_ALLOC_N(qemuCaps->machineTypes, nmachines) < 0) {
virReportOOMError();
goto cleanup;
}
- if (VIR_ALLOC_N(caps->machineAliases, nmachines) < 0) {
+ if (VIR_ALLOC_N(qemuCaps->machineAliases, nmachines) < 0) {
virReportOOMError();
goto cleanup;
}
for (i = 0 ; i < nmachines ; i++) {
if (machines[i]->alias) {
- if (!(caps->machineAliases[i] = strdup(machines[i]->alias))) {
+ if (!(qemuCaps->machineAliases[i] = strdup(machines[i]->alias))) {
virReportOOMError();
goto cleanup;
}
}
- if (!(caps->machineTypes[i] = strdup(machines[i]->name))) {
+ if (!(qemuCaps->machineTypes[i] = strdup(machines[i]->name))) {
virReportOOMError();
goto cleanup;
}
if (machines[i]->isDefault)
defIdx = i;
}
- caps->nmachineTypes = nmachines;
+ qemuCaps->nmachineTypes = nmachines;
if (defIdx)
- qemuSetDefaultMachine(caps, defIdx);
+ virQEMUCapsSetDefaultMachine(qemuCaps, defIdx);
ret = 0;
static int
-qemuCapsProbeQMPCPUDefinitions(qemuCapsPtr caps,
- qemuMonitorPtr mon)
+virQEMUCapsProbeQMPCPUDefinitions(virQEMUCapsPtr qemuCaps,
+ qemuMonitorPtr mon)
{
int ncpuDefinitions;
char **cpuDefinitions;
if ((ncpuDefinitions = qemuMonitorGetCPUDefinitions(mon, &cpuDefinitions)) < 0)
return -1;
- caps->ncpuDefinitions = ncpuDefinitions;
- caps->cpuDefinitions = cpuDefinitions;
+ qemuCaps->ncpuDefinitions = ncpuDefinitions;
+ qemuCaps->cpuDefinitions = cpuDefinitions;
return 0;
}
static int
-qemuCapsProbeQMPKVMState(qemuCapsPtr caps,
- qemuMonitorPtr mon)
+virQEMUCapsProbeQMPKVMState(virQEMUCapsPtr qemuCaps,
+ qemuMonitorPtr mon)
{
bool enabled = false;
bool present = false;
- if (!qemuCapsGet(caps, QEMU_CAPS_KVM))
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM))
return 0;
if (qemuMonitorGetKVMState(mon, &enabled, &present) < 0)
* not enabled by default we need to change the flag.
*/
if (!present) {
- qemuCapsClear(caps, QEMU_CAPS_KVM);
+ virQEMUCapsClear(qemuCaps, QEMU_CAPS_KVM);
} else if (!enabled) {
- qemuCapsClear(caps, QEMU_CAPS_KVM);
- qemuCapsSet(caps, QEMU_CAPS_ENABLE_KVM);
+ virQEMUCapsClear(qemuCaps, QEMU_CAPS_KVM);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_ENABLE_KVM);
}
return 0;
}
-int qemuCapsProbeQMP(qemuCapsPtr caps,
- qemuMonitorPtr mon)
+int virQEMUCapsProbeQMP(virQEMUCapsPtr qemuCaps,
+ qemuMonitorPtr mon)
{
- VIR_DEBUG("caps=%p mon=%p", caps, mon);
+ VIR_DEBUG("qemuCaps=%p mon=%p", qemuCaps, mon);
- if (caps->usedQMP)
+ if (qemuCaps->usedQMP)
return 0;
- if (qemuCapsProbeQMPCommands(caps, mon) < 0)
+ if (virQEMUCapsProbeQMPCommands(qemuCaps, mon) < 0)
return -1;
- if (qemuCapsProbeQMPEvents(caps, mon) < 0)
+ if (virQEMUCapsProbeQMPEvents(qemuCaps, mon) < 0)
return -1;
return 0;
#define QEMU_SYSTEM_PREFIX "qemu-system-"
static int
-qemuCapsInitHelp(qemuCapsPtr caps, uid_t runUid, gid_t runGid)
+virQEMUCapsInitHelp(virQEMUCapsPtr qemuCaps, uid_t runUid, gid_t runGid)
{
virCommandPtr cmd = NULL;
unsigned int is_kvm;
char *help = NULL;
int ret = -1;
const char *tmp;
- qemuCapsHookData hookData;
+ virQEMUCapsHookData hookData;
- VIR_DEBUG("caps=%p", caps);
+ VIR_DEBUG("qemuCaps=%p", qemuCaps);
- tmp = strstr(caps->binary, QEMU_SYSTEM_PREFIX);
+ tmp = strstr(qemuCaps->binary, QEMU_SYSTEM_PREFIX);
if (tmp) {
tmp += strlen(QEMU_SYSTEM_PREFIX);
- caps->arch = qemuCapsArchFromString(tmp);
+ qemuCaps->arch = virQEMUCapsArchFromString(tmp);
} else {
- caps->arch = virArchFromHost();
+ qemuCaps->arch = virArchFromHost();
}
hookData.runUid = runUid;
hookData.runGid = runGid;
- cmd = qemuCapsProbeCommand(caps->binary, NULL, &hookData);
+ cmd = virQEMUCapsProbeCommand(qemuCaps->binary, NULL, &hookData);
virCommandAddArgList(cmd, "-help", NULL);
virCommandSetOutputBuffer(cmd, &help);
if (virCommandRun(cmd, NULL) < 0)
goto cleanup;
- if (qemuCapsParseHelpStr(caps->binary,
- help, caps,
- &caps->version,
- &is_kvm,
- &caps->kvmVersion,
- false) < 0)
+ if (virQEMUCapsParseHelpStr(qemuCaps->binary,
+ help, qemuCaps,
+ &qemuCaps->version,
+ &is_kvm,
+ &qemuCaps->kvmVersion,
+ false) < 0)
goto cleanup;
/* Currently only x86_64 and i686 support PCI-multibus. */
- if (caps->arch == VIR_ARCH_X86_64 ||
- caps->arch == VIR_ARCH_I686) {
- qemuCapsSet(caps, QEMU_CAPS_PCI_MULTIBUS);
+ if (qemuCaps->arch == VIR_ARCH_X86_64 ||
+ qemuCaps->arch == VIR_ARCH_I686) {
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_PCI_MULTIBUS);
} else {
/* -no-acpi is not supported on other archs
* even if qemu reports it in -help */
- qemuCapsClear(caps, QEMU_CAPS_NO_ACPI);
+ virQEMUCapsClear(qemuCaps, QEMU_CAPS_NO_ACPI);
}
- /* qemuCapsExtractDeviceStr will only set additional caps if qemu
+ /* virQEMUCapsExtractDeviceStr will only set additional caps if qemu
* understands the 0.13.0+ notion of "-device driver,". */
- if (qemuCapsGet(caps, QEMU_CAPS_DEVICE) &&
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE) &&
strstr(help, "-device driver,?") &&
- qemuCapsExtractDeviceStr(caps->binary, caps, &hookData) < 0)
+ virQEMUCapsExtractDeviceStr(qemuCaps->binary, qemuCaps, &hookData) < 0)
goto cleanup;
- if (qemuCapsProbeCPUModels(caps, &hookData) < 0)
+ if (virQEMUCapsProbeCPUModels(qemuCaps, &hookData) < 0)
goto cleanup;
- if (qemuCapsProbeMachineTypes(caps, &hookData) < 0)
+ if (virQEMUCapsProbeMachineTypes(qemuCaps, &hookData) < 0)
goto cleanup;
ret = 0;
}
-static void qemuCapsMonitorNotify(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
- virDomainObjPtr vm ATTRIBUTE_UNUSED)
+static void virQEMUCapsMonitorNotify(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
+ virDomainObjPtr vm ATTRIBUTE_UNUSED)
{
}
static qemuMonitorCallbacks callbacks = {
- .eofNotify = qemuCapsMonitorNotify,
- .errorNotify = qemuCapsMonitorNotify,
+ .eofNotify = virQEMUCapsMonitorNotify,
+ .errorNotify = virQEMUCapsMonitorNotify,
};
* for QEMU >= 1.2.0
*/
static void
-qemuCapsInitQMPBasic(qemuCapsPtr caps)
+virQEMUCapsInitQMPBasic(virQEMUCapsPtr qemuCaps)
{
- qemuCapsSet(caps, QEMU_CAPS_VNC_COLON);
- qemuCapsSet(caps, QEMU_CAPS_NO_REBOOT);
- qemuCapsSet(caps, QEMU_CAPS_DRIVE);
- qemuCapsSet(caps, QEMU_CAPS_NAME);
- qemuCapsSet(caps, QEMU_CAPS_UUID);
- qemuCapsSet(caps, QEMU_CAPS_VNET_HDR);
- qemuCapsSet(caps, QEMU_CAPS_MIGRATE_QEMU_TCP);
- qemuCapsSet(caps, QEMU_CAPS_MIGRATE_QEMU_EXEC);
- qemuCapsSet(caps, QEMU_CAPS_DRIVE_CACHE_V2);
- qemuCapsSet(caps, QEMU_CAPS_DRIVE_FORMAT);
- qemuCapsSet(caps, QEMU_CAPS_VGA);
- qemuCapsSet(caps, QEMU_CAPS_0_10);
- qemuCapsSet(caps, QEMU_CAPS_MEM_PATH);
- qemuCapsSet(caps, QEMU_CAPS_DRIVE_SERIAL);
- qemuCapsSet(caps, QEMU_CAPS_MIGRATE_QEMU_UNIX);
- qemuCapsSet(caps, QEMU_CAPS_CHARDEV);
- qemuCapsSet(caps, QEMU_CAPS_MONITOR_JSON);
- qemuCapsSet(caps, QEMU_CAPS_BALLOON);
- qemuCapsSet(caps, QEMU_CAPS_DEVICE);
- qemuCapsSet(caps, QEMU_CAPS_SDL);
- qemuCapsSet(caps, QEMU_CAPS_SMP_TOPOLOGY);
- qemuCapsSet(caps, QEMU_CAPS_NETDEV);
- qemuCapsSet(caps, QEMU_CAPS_RTC);
- qemuCapsSet(caps, QEMU_CAPS_VHOST_NET);
- qemuCapsSet(caps, QEMU_CAPS_NO_HPET);
- qemuCapsSet(caps, QEMU_CAPS_NODEFCONFIG);
- qemuCapsSet(caps, QEMU_CAPS_BOOT_MENU);
- qemuCapsSet(caps, QEMU_CAPS_FSDEV);
- qemuCapsSet(caps, QEMU_CAPS_NAME_PROCESS);
- qemuCapsSet(caps, QEMU_CAPS_DRIVE_READONLY);
- qemuCapsSet(caps, QEMU_CAPS_SMBIOS_TYPE);
- qemuCapsSet(caps, QEMU_CAPS_VGA_NONE);
- qemuCapsSet(caps, QEMU_CAPS_MIGRATE_QEMU_FD);
- qemuCapsSet(caps, QEMU_CAPS_DRIVE_AIO);
- qemuCapsSet(caps, QEMU_CAPS_CHARDEV_SPICEVMC);
- qemuCapsSet(caps, QEMU_CAPS_DEVICE_QXL_VGA);
- qemuCapsSet(caps, QEMU_CAPS_DRIVE_CACHE_DIRECTSYNC);
- qemuCapsSet(caps, QEMU_CAPS_NO_SHUTDOWN);
- qemuCapsSet(caps, QEMU_CAPS_DRIVE_CACHE_UNSAFE);
- qemuCapsSet(caps, QEMU_CAPS_FSDEV_READONLY);
- qemuCapsSet(caps, QEMU_CAPS_VIRTIO_BLK_SG_IO);
- qemuCapsSet(caps, QEMU_CAPS_DRIVE_COPY_ON_READ);
- qemuCapsSet(caps, QEMU_CAPS_CPU_HOST);
- qemuCapsSet(caps, QEMU_CAPS_FSDEV_WRITEOUT);
- qemuCapsSet(caps, QEMU_CAPS_DRIVE_IOTUNE);
- qemuCapsSet(caps, QEMU_CAPS_WAKEUP);
- qemuCapsSet(caps, QEMU_CAPS_NO_USER_CONFIG);
- qemuCapsSet(caps, QEMU_CAPS_NETDEV_BRIDGE);
- qemuCapsSet(caps, QEMU_CAPS_SECCOMP_SANDBOX);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_VNC_COLON);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_REBOOT);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_NAME);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_UUID);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_VNET_HDR);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_TCP);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_EXEC);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_V2);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_FORMAT);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_VGA);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_0_10);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_MEM_PATH);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_SERIAL);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_UNIX);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_CHARDEV);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_MONITOR_JSON);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_BALLOON);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_DEVICE);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_SDL);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_SMP_TOPOLOGY);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_NETDEV);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_RTC);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_VHOST_NET);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_HPET);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_NODEFCONFIG);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_BOOT_MENU);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_FSDEV);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_NAME_PROCESS);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_READONLY);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_SMBIOS_TYPE);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_VGA_NONE);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_FD);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_AIO);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_CHARDEV_SPICEVMC);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_DEVICE_QXL_VGA);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_DIRECTSYNC);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_SHUTDOWN);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_UNSAFE);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_FSDEV_READONLY);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_VIRTIO_BLK_SG_IO);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_COPY_ON_READ);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_CPU_HOST);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_FSDEV_WRITEOUT);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_DRIVE_IOTUNE);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_WAKEUP);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_USER_CONFIG);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_NETDEV_BRIDGE);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_SECCOMP_SANDBOX);
}
static int
-qemuCapsInitQMP(qemuCapsPtr caps,
- const char *libDir,
- uid_t runUid,
- gid_t runGid)
+virQEMUCapsInitQMP(virQEMUCapsPtr qemuCaps,
+ const char *libDir,
+ uid_t runUid,
+ gid_t runGid)
{
int ret = -1;
virCommandPtr cmd = NULL;
char *monarg = NULL;
char *monpath = NULL;
char *pidfile = NULL;
- qemuCapsHookData hookData;
+ virQEMUCapsHookData hookData;
char *archstr;
pid_t pid = 0;
virDomainObj vm;
config.data.nix.path = monpath;
config.data.nix.listen = false;
- VIR_DEBUG("Try to get caps via QMP caps=%p", caps);
+ VIR_DEBUG("Try to get caps via QMP qemuCaps=%p", qemuCaps);
/*
* We explicitly need to use -daemonize here, rather than
* daemonize guarantees control won't return to libvirt
* until the socket is present.
*/
- cmd = virCommandNewArgList(caps->binary,
+ cmd = virCommandNewArgList(qemuCaps->binary,
"-S",
"-no-user-config",
"-nodefaults",
virCommandClearCaps(cmd);
hookData.runUid = runUid;
hookData.runGid = runGid;
- virCommandSetPreExecHook(cmd, qemuCapsHook, &hookData);
+ virCommandSetPreExecHook(cmd, virQEMUCapsHook, &hookData);
if (virCommandRun(cmd, &status) < 0)
goto cleanup;
if (status != 0) {
ret = 0;
- VIR_DEBUG("QEMU %s exited with status %d", caps->binary, status);
+ VIR_DEBUG("QEMU %s exited with status %d", qemuCaps->binary, status);
goto cleanup;
}
goto cleanup;
}
- caps->version = major * 1000000 + minor * 1000 + micro;
- caps->usedQMP = true;
+ qemuCaps->version = major * 1000000 + minor * 1000 + micro;
+ qemuCaps->usedQMP = true;
- qemuCapsInitQMPBasic(caps);
+ virQEMUCapsInitQMPBasic(qemuCaps);
if (!(archstr = qemuMonitorGetTargetArch(mon)))
goto cleanup;
- if ((caps->arch = qemuCapsArchFromString(archstr)) == VIR_ARCH_NONE) {
+ if ((qemuCaps->arch = virQEMUCapsArchFromString(archstr)) == VIR_ARCH_NONE) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Unknown QEMU arch %s"), archstr);
VIR_FREE(archstr);
VIR_FREE(archstr);
/* Currently only x86_64 and i686 support PCI-multibus and -no-acpi. */
- if (caps->arch == VIR_ARCH_X86_64 ||
- caps->arch == VIR_ARCH_I686) {
- qemuCapsSet(caps, QEMU_CAPS_PCI_MULTIBUS);
- qemuCapsSet(caps, QEMU_CAPS_NO_ACPI);
+ if (qemuCaps->arch == VIR_ARCH_X86_64 ||
+ qemuCaps->arch == VIR_ARCH_I686) {
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_PCI_MULTIBUS);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_NO_ACPI);
}
- if (qemuCapsProbeQMPCommands(caps, mon) < 0)
+ if (virQEMUCapsProbeQMPCommands(qemuCaps, mon) < 0)
goto cleanup;
- if (qemuCapsProbeQMPEvents(caps, mon) < 0)
+ if (virQEMUCapsProbeQMPEvents(qemuCaps, mon) < 0)
goto cleanup;
- if (qemuCapsProbeQMPObjects(caps, mon) < 0)
+ if (virQEMUCapsProbeQMPObjects(qemuCaps, mon) < 0)
goto cleanup;
- if (qemuCapsProbeQMPMachineTypes(caps, mon) < 0)
+ if (virQEMUCapsProbeQMPMachineTypes(qemuCaps, mon) < 0)
goto cleanup;
- if (qemuCapsProbeQMPCPUDefinitions(caps, mon) < 0)
+ if (virQEMUCapsProbeQMPCPUDefinitions(qemuCaps, mon) < 0)
goto cleanup;
- if (qemuCapsProbeQMPKVMState(caps, mon) < 0)
+ if (virQEMUCapsProbeQMPKVMState(qemuCaps, mon) < 0)
goto cleanup;
ret = 0;
}
-qemuCapsPtr qemuCapsNewForBinary(const char *binary,
- const char *libDir,
- uid_t runUid,
- gid_t runGid)
+virQEMUCapsPtr virQEMUCapsNewForBinary(const char *binary,
+ const char *libDir,
+ uid_t runUid,
+ gid_t runGid)
{
- qemuCapsPtr caps = qemuCapsNew();
+ virQEMUCapsPtr qemuCaps = virQEMUCapsNew();
struct stat sb;
int rv;
- if (!(caps->binary = strdup(binary)))
+ if (!(qemuCaps->binary = strdup(binary)))
goto no_memory;
/* We would also want to check faccessat if we cared about ACLs,
binary);
goto error;
}
- caps->mtime = sb.st_mtime;
+ qemuCaps->mtime = sb.st_mtime;
/* Make sure the binary we are about to try exec'ing exists.
* Technically we could catch the exec() failure, but that's
goto error;
}
- if ((rv = qemuCapsInitQMP(caps, libDir, runUid, runGid)) < 0)
+ if ((rv = virQEMUCapsInitQMP(qemuCaps, libDir, runUid, runGid)) < 0)
goto error;
- if (!caps->usedQMP &&
- qemuCapsInitHelp(caps, runUid, runGid) < 0)
+ if (!qemuCaps->usedQMP &&
+ virQEMUCapsInitHelp(qemuCaps, runUid, runGid) < 0)
goto error;
- return caps;
+ return qemuCaps;
no_memory:
virReportOOMError();
error:
- virObjectUnref(caps);
- caps = NULL;
+ virObjectUnref(qemuCaps);
+ qemuCaps = NULL;
return NULL;
}
-bool qemuCapsIsValid(qemuCapsPtr caps)
+bool virQEMUCapsIsValid(virQEMUCapsPtr qemuCaps)
{
struct stat sb;
- if (!caps->binary)
+ if (!qemuCaps->binary)
return true;
- if (stat(caps->binary, &sb) < 0)
+ if (stat(qemuCaps->binary, &sb) < 0)
return false;
- return sb.st_mtime == caps->mtime;
+ return sb.st_mtime == qemuCaps->mtime;
}
static void
-qemuCapsHashDataFree(void *payload, const void *key ATTRIBUTE_UNUSED)
+virQEMUCapsHashDataFree(void *payload, const void *key ATTRIBUTE_UNUSED)
{
virObjectUnref(payload);
}
-qemuCapsCachePtr
-qemuCapsCacheNew(const char *libDir,
- uid_t runUid,
- gid_t runGid)
+virQEMUCapsCachePtr
+virQEMUCapsCacheNew(const char *libDir,
+ uid_t runUid,
+ gid_t runGid)
{
- qemuCapsCachePtr cache;
+ virQEMUCapsCachePtr cache;
if (VIR_ALLOC(cache) < 0) {
virReportOOMError();
return NULL;
}
- if (!(cache->binaries = virHashCreate(10, qemuCapsHashDataFree)))
+ if (!(cache->binaries = virHashCreate(10, virQEMUCapsHashDataFree)))
goto error;
if (!(cache->libDir = strdup(libDir))) {
virReportOOMError();
return cache;
error:
- qemuCapsCacheFree(cache);
+ virQEMUCapsCacheFree(cache);
return NULL;
}
-qemuCapsPtr
-qemuCapsCacheLookup(qemuCapsCachePtr cache, const char *binary)
+virQEMUCapsPtr
+virQEMUCapsCacheLookup(virQEMUCapsCachePtr cache, const char *binary)
{
- qemuCapsPtr ret = NULL;
+ virQEMUCapsPtr ret = NULL;
virMutexLock(&cache->lock);
ret = virHashLookup(cache->binaries, binary);
if (ret &&
- !qemuCapsIsValid(ret)) {
+ !virQEMUCapsIsValid(ret)) {
VIR_DEBUG("Cached capabilities %p no longer valid for %s",
ret, binary);
virHashRemoveEntry(cache->binaries, binary);
if (!ret) {
VIR_DEBUG("Creating capabilities for %s",
binary);
- ret = qemuCapsNewForBinary(binary, cache->libDir,
- cache->runUid, cache->runGid);
+ ret = virQEMUCapsNewForBinary(binary, cache->libDir,
+ cache->runUid, cache->runGid);
if (ret) {
VIR_DEBUG("Caching capabilities %p for %s",
ret, binary);
}
-qemuCapsPtr
-qemuCapsCacheLookupCopy(qemuCapsCachePtr cache, const char *binary)
+virQEMUCapsPtr
+virQEMUCapsCacheLookupCopy(virQEMUCapsCachePtr cache, const char *binary)
{
- qemuCapsPtr caps = qemuCapsCacheLookup(cache, binary);
- qemuCapsPtr ret;
+ virQEMUCapsPtr qemuCaps = virQEMUCapsCacheLookup(cache, binary);
+ virQEMUCapsPtr ret;
- if (!caps)
+ if (!qemuCaps)
return NULL;
- ret = qemuCapsNewCopy(caps);
- virObjectUnref(caps);
+ ret = virQEMUCapsNewCopy(qemuCaps);
+ virObjectUnref(qemuCaps);
return ret;
}
void
-qemuCapsCacheFree(qemuCapsCachePtr cache)
+virQEMUCapsCacheFree(virQEMUCapsCachePtr cache)
{
if (!cache)
return;
}
bool
-qemuCapsUsedQMP(qemuCapsPtr caps)
+virQEMUCapsUsedQMP(virQEMUCapsPtr qemuCaps)
{
- return caps->usedQMP;
+ return qemuCaps->usedQMP;
}
# include "qemu_monitor.h"
/* Internal flags to keep track of qemu command line capabilities */
-enum qemuCapsFlags {
+enum virQEMUCapsFlags {
QEMU_CAPS_KQEMU = 0, /* Whether KQEMU is compiled in */
QEMU_CAPS_VNC_COLON = 1, /* VNC takes or address + display */
QEMU_CAPS_NO_REBOOT = 2, /* Is the -no-reboot flag available */
QEMU_CAPS_LAST, /* this must always be the last item */
};
-typedef struct _qemuCaps qemuCaps;
-typedef qemuCaps *qemuCapsPtr;
+typedef struct _virQEMUCaps virQEMUCaps;
+typedef virQEMUCaps *virQEMUCapsPtr;
-typedef struct _qemuCapsCache qemuCapsCache;
-typedef qemuCapsCache *qemuCapsCachePtr;
+typedef struct _virQEMUCapsCache virQEMUCapsCache;
+typedef virQEMUCapsCache *virQEMUCapsCachePtr;
-qemuCapsPtr qemuCapsNew(void);
-qemuCapsPtr qemuCapsNewCopy(qemuCapsPtr caps);
-qemuCapsPtr qemuCapsNewForBinary(const char *binary,
- const char *libDir,
- uid_t runUid,
- gid_t runGid);
+virQEMUCapsPtr virQEMUCapsNew(void);
+virQEMUCapsPtr virQEMUCapsNewCopy(virQEMUCapsPtr qemuCaps);
+virQEMUCapsPtr virQEMUCapsNewForBinary(const char *binary,
+ const char *libDir,
+ uid_t runUid,
+ gid_t runGid);
-int qemuCapsProbeQMP(qemuCapsPtr caps,
- qemuMonitorPtr mon);
+int virQEMUCapsProbeQMP(virQEMUCapsPtr qemuCaps,
+ qemuMonitorPtr mon);
-void qemuCapsSet(qemuCapsPtr caps,
- enum qemuCapsFlags flag) ATTRIBUTE_NONNULL(1);
+void virQEMUCapsSet(virQEMUCapsPtr qemuCaps,
+ enum virQEMUCapsFlags flag) ATTRIBUTE_NONNULL(1);
-void qemuCapsSetList(qemuCapsPtr caps, ...) ATTRIBUTE_NONNULL(1);
+void virQEMUCapsSetList(virQEMUCapsPtr qemuCaps, ...) ATTRIBUTE_NONNULL(1);
-void qemuCapsClear(qemuCapsPtr caps,
- enum qemuCapsFlags flag) ATTRIBUTE_NONNULL(1);
+void virQEMUCapsClear(virQEMUCapsPtr qemuCaps,
+ enum virQEMUCapsFlags flag) ATTRIBUTE_NONNULL(1);
-bool qemuCapsGet(qemuCapsPtr caps,
- enum qemuCapsFlags flag);
+bool virQEMUCapsGet(virQEMUCapsPtr qemuCaps,
+ enum virQEMUCapsFlags flag);
-char *qemuCapsFlagsString(qemuCapsPtr caps);
+char *virQEMUCapsFlagsString(virQEMUCapsPtr qemuCaps);
-const char *qemuCapsGetBinary(qemuCapsPtr caps);
-virArch qemuCapsGetArch(qemuCapsPtr caps);
-unsigned int qemuCapsGetVersion(qemuCapsPtr caps);
-unsigned int qemuCapsGetKVMVersion(qemuCapsPtr caps);
-int qemuCapsAddCPUDefinition(qemuCapsPtr caps,
- const char *name);
-size_t qemuCapsGetCPUDefinitions(qemuCapsPtr caps,
- char ***names);
-size_t qemuCapsGetMachineTypes(qemuCapsPtr caps,
- char ***names);
-const char *qemuCapsGetCanonicalMachine(qemuCapsPtr caps,
- const char *name);
+const char *virQEMUCapsGetBinary(virQEMUCapsPtr qemuCaps);
+virArch virQEMUCapsGetArch(virQEMUCapsPtr qemuCaps);
+unsigned int virQEMUCapsGetVersion(virQEMUCapsPtr qemuCaps);
+unsigned int virQEMUCapsGetKVMVersion(virQEMUCapsPtr qemuCaps);
+int virQEMUCapsAddCPUDefinition(virQEMUCapsPtr qemuCaps,
+ const char *name);
+size_t virQEMUCapsGetCPUDefinitions(virQEMUCapsPtr qemuCaps,
+ char ***names);
+size_t virQEMUCapsGetMachineTypes(virQEMUCapsPtr qemuCaps,
+ char ***names);
+const char *virQEMUCapsGetCanonicalMachine(virQEMUCapsPtr qemuCaps,
+ const char *name);
-int qemuCapsGetMachineTypesCaps(qemuCapsPtr caps,
- size_t *nmachines,
- virCapsGuestMachinePtr **machines);
+int virQEMUCapsGetMachineTypesCaps(virQEMUCapsPtr qemuCaps,
+ size_t *nmachines,
+ virCapsGuestMachinePtr **machines);
-bool qemuCapsIsValid(qemuCapsPtr caps);
+bool virQEMUCapsIsValid(virQEMUCapsPtr qemuCaps);
-qemuCapsCachePtr qemuCapsCacheNew(const char *libDir,
- uid_t uid, gid_t gid);
-qemuCapsPtr qemuCapsCacheLookup(qemuCapsCachePtr cache, const char *binary);
-qemuCapsPtr qemuCapsCacheLookupCopy(qemuCapsCachePtr cache, const char *binary);
-void qemuCapsCacheFree(qemuCapsCachePtr cache);
+virQEMUCapsCachePtr virQEMUCapsCacheNew(const char *libDir,
+ uid_t uid, gid_t gid);
+virQEMUCapsPtr virQEMUCapsCacheLookup(virQEMUCapsCachePtr cache,
+ const char *binary);
+virQEMUCapsPtr virQEMUCapsCacheLookupCopy(virQEMUCapsCachePtr cache,
+ const char *binary);
+void virQEMUCapsCacheFree(virQEMUCapsCachePtr cache);
-virCapsPtr qemuCapsInit(qemuCapsCachePtr cache);
+virCapsPtr virQEMUCapsInit(virQEMUCapsCachePtr cache);
-int qemuCapsGetDefaultVersion(virCapsPtr caps,
- qemuCapsCachePtr capsCache,
- unsigned int *version);
+int virQEMUCapsGetDefaultVersion(virCapsPtr caps,
+ virQEMUCapsCachePtr capsCache,
+ unsigned int *version);
/* Only for use by test suite */
-int qemuCapsParseHelpStr(const char *qemu,
- const char *str,
- qemuCapsPtr caps,
- unsigned int *version,
- unsigned int *is_kvm,
- unsigned int *kvm_version,
- bool check_yajl);
+int virQEMUCapsParseHelpStr(const char *qemu,
+ const char *str,
+ virQEMUCapsPtr qemuCaps,
+ unsigned int *version,
+ unsigned int *is_kvm,
+ unsigned int *kvm_version,
+ bool check_yajl);
/* Only for use by test suite */
-int qemuCapsParseDeviceStr(qemuCapsPtr caps, const char *str);
+int virQEMUCapsParseDeviceStr(virQEMUCapsPtr qemuCaps, const char *str);
-VIR_ENUM_DECL(qemuCaps);
+VIR_ENUM_DECL(virQEMUCaps);
-bool qemuCapsUsedQMP(qemuCapsPtr caps);
+bool virQEMUCapsUsedQMP(virQEMUCapsPtr qemuCaps);
#endif /* __QEMU_CAPABILITIES_H__*/
qemuPhysIfaceConnect(virDomainDefPtr def,
virQEMUDriverPtr driver,
virDomainNetDefPtr net,
- qemuCapsPtr caps,
+ virQEMUCapsPtr qemuCaps,
enum virNetDevVPortProfileOp vmop)
{
int rc;
int vnet_hdr = 0;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
- if (qemuCapsGet(caps, QEMU_CAPS_VNET_HDR) &&
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_VNET_HDR) &&
net->model && STREQ(net->model, "virtio"))
vnet_hdr = 1;
virConnectPtr conn,
virQEMUDriverPtr driver,
virDomainNetDefPtr net,
- qemuCapsPtr caps)
+ virQEMUCapsPtr qemuCaps)
{
char *brname = NULL;
int err;
template_ifname = true;
}
- if (qemuCapsGet(caps, QEMU_CAPS_VNET_HDR) &&
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_VNET_HDR) &&
net->model && STREQ(net->model, "virtio")) {
tap_create_flags |= VIR_NETDEV_TAP_CREATE_VNET_HDR;
}
int
qemuOpenVhostNet(virDomainDefPtr def,
virDomainNetDefPtr net,
- qemuCapsPtr caps,
+ virQEMUCapsPtr qemuCaps,
int *vhostfd)
{
*vhostfd = -1; /* assume we won't use vhost */
/* If qemu doesn't support vhost-net mode (including the -netdev command
* option), don't try to open the device.
*/
- if (!(qemuCapsGet(caps, QEMU_CAPS_VHOST_NET) &&
- qemuCapsGet(caps, QEMU_CAPS_NETDEV) &&
- qemuCapsGet(caps, QEMU_CAPS_DEVICE))) {
+ if (!(virQEMUCapsGet(qemuCaps, QEMU_CAPS_VHOST_NET) &&
+ virQEMUCapsGet(qemuCaps, QEMU_CAPS_NETDEV) &&
+ virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE))) {
if (net->driver.virtio.name == VIR_DOMAIN_NET_BACKEND_TYPE_VHOST) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("vhost-net is not supported with "
char *qemuDeviceDriveHostAlias(virDomainDiskDefPtr disk,
- qemuCapsPtr caps)
+ virQEMUCapsPtr qemuCaps)
{
char *ret;
- if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
if (virAsprintf(&ret, "%s%s", QEMU_DRIVE_HOST_PREFIX, disk->info.alias) < 0) {
virReportOOMError();
return NULL;
static int
qemuSetScsiControllerModel(virDomainDefPtr def,
- qemuCapsPtr caps,
+ virQEMUCapsPtr qemuCaps,
int *model)
{
if (*model > 0) {
switch (*model) {
case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_LSILOGIC:
- if (!qemuCapsGet(caps, QEMU_CAPS_SCSI_LSI)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_SCSI_LSI)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("This QEMU doesn't support "
"lsi scsi controller"));
}
break;
case VIR_DOMAIN_CONTROLLER_MODEL_SCSI_VIRTIO_SCSI:
- if (!qemuCapsGet(caps, QEMU_CAPS_VIRTIO_SCSI_PCI)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_SCSI_PCI)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("This QEMU doesn't support "
"virtio scsi controller"));
if ((def->os.arch == VIR_ARCH_PPC64) &&
STREQ(def->os.machine, "pseries")) {
*model = VIR_DOMAIN_CONTROLLER_MODEL_SCSI_IBMVSCSI;
- } else if (qemuCapsGet(caps, QEMU_CAPS_SCSI_LSI)) {
+ } else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_SCSI_LSI)) {
*model = VIR_DOMAIN_CONTROLLER_MODEL_SCSI_LSILOGIC;
} else {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
static int
qemuAssignDeviceDiskAliasCustom(virDomainDefPtr def,
virDomainDiskDefPtr disk,
- qemuCapsPtr caps)
+ virQEMUCapsPtr qemuCaps)
{
const char *prefix = virDomainDiskBusTypeToString(disk->bus);
int controllerModel = -1;
virDomainDiskFindControllerModel(def, disk,
VIR_DOMAIN_CONTROLLER_TYPE_SCSI);
- if ((qemuSetScsiControllerModel(def, caps, &controllerModel)) < 0)
+ if ((qemuSetScsiControllerModel(def, qemuCaps, &controllerModel)) < 0)
return -1;
}
int
qemuAssignDeviceDiskAlias(virDomainDefPtr vmdef,
virDomainDiskDefPtr def,
- qemuCapsPtr caps)
+ virQEMUCapsPtr qemuCaps)
{
- if (qemuCapsGet(caps, QEMU_CAPS_DRIVE)) {
- if (qemuCapsGet(caps, QEMU_CAPS_DEVICE))
- return qemuAssignDeviceDiskAliasCustom(vmdef, def, caps);
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DRIVE)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
+ return qemuAssignDeviceDiskAliasCustom(vmdef, def, qemuCaps);
else
return qemuAssignDeviceDiskAliasFixed(def);
} else {
int
-qemuAssignDeviceAliases(virDomainDefPtr def, qemuCapsPtr caps)
+qemuAssignDeviceAliases(virDomainDefPtr def, virQEMUCapsPtr qemuCaps)
{
int i;
for (i = 0; i < def->ndisks ; i++) {
- if (qemuAssignDeviceDiskAlias(def, def->disks[i], caps) < 0)
+ if (qemuAssignDeviceDiskAlias(def, def->disks[i], qemuCaps) < 0)
return -1;
}
- if (qemuCapsGet(caps, QEMU_CAPS_NET_NAME) ||
- qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_NET_NAME) ||
+ virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
for (i = 0; i < def->nnets ; i++) {
/* type='hostdev' interfaces are also on the hostdevs list,
* and will have their alias assigned with other hostdevs.
}
}
- if (!qemuCapsGet(caps, QEMU_CAPS_DEVICE))
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
return 0;
for (i = 0; i < def->nfss ; i++) {
}
static void
-qemuDomainAssignS390Addresses(virDomainDefPtr def, qemuCapsPtr caps)
+qemuDomainAssignS390Addresses(virDomainDefPtr def, virQEMUCapsPtr qemuCaps)
{
/* deal with legacy virtio-s390 */
- if (qemuCapsGet(caps, QEMU_CAPS_VIRTIO_S390))
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_S390))
qemuDomainPrimeS390VirtioDevices(
def, VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_S390);
}
}
int qemuDomainAssignSpaprVIOAddresses(virDomainDefPtr def,
- qemuCapsPtr caps)
+ virQEMUCapsPtr qemuCaps)
{
int i, ret = -1;
int model;
for (i = 0 ; i < def->ncontrollers; i++) {
model = def->controllers[i]->model;
if (def->controllers[i]->type == VIR_DOMAIN_CONTROLLER_TYPE_SCSI) {
- if (qemuSetScsiControllerModel(def, caps, &model) < 0)
+ if (qemuSetScsiControllerModel(def, qemuCaps, &model) < 0)
goto cleanup;
}
int
qemuDomainAssignPCIAddresses(virDomainDefPtr def,
- qemuCapsPtr caps,
+ virQEMUCapsPtr qemuCaps,
virDomainObjPtr obj)
{
int ret = -1;
qemuDomainPCIAddressSetPtr addrs = NULL;
qemuDomainObjPrivatePtr priv = NULL;
- if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
if (!(addrs = qemuDomainPCIAddressSetCreate(def)))
goto cleanup;
- if (qemuAssignDevicePCISlots(def, caps, addrs) < 0)
+ if (qemuAssignDevicePCISlots(def, qemuCaps, addrs) < 0)
goto cleanup;
}
}
int qemuDomainAssignAddresses(virDomainDefPtr def,
- qemuCapsPtr caps,
+ virQEMUCapsPtr qemuCaps,
virDomainObjPtr obj)
{
int rc;
- rc = qemuDomainAssignSpaprVIOAddresses(def, caps);
+ rc = qemuDomainAssignSpaprVIOAddresses(def, qemuCaps);
if (rc)
return rc;
- qemuDomainAssignS390Addresses(def, caps);
+ qemuDomainAssignS390Addresses(def, qemuCaps);
- return qemuDomainAssignPCIAddresses(def, caps, obj);
+ return qemuDomainAssignPCIAddresses(def, qemuCaps, obj);
}
static void
*/
int
qemuAssignDevicePCISlots(virDomainDefPtr def,
- qemuCapsPtr caps,
+ virQEMUCapsPtr qemuCaps,
qemuDomainPCIAddressSetPtr addrs)
{
size_t i, j;
bool reservedIDE = false;
bool reservedUSB = false;
int function;
- bool qemuDeviceVideoUsable = qemuCapsGet(caps, QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
+ bool qemuDeviceVideoUsable = virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
/* Host bridge */
if (qemuDomainPCIAddressReserveSlot(addrs, 0) < 0)
static int
qemuBuildDeviceAddressStr(virBufferPtr buf,
virDomainDeviceInfoPtr info,
- qemuCapsPtr caps)
+ virQEMUCapsPtr qemuCaps)
{
if (info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
if (info->addr.pci.domain != 0) {
_("Only PCI device addresses with bus=0 are supported"));
return -1;
}
- if (qemuCapsGet(caps, QEMU_CAPS_PCI_MULTIFUNCTION)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_PCI_MULTIFUNCTION)) {
if (info->addr.pci.function > 7) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("The function of PCI device addresses must "
* When QEMU grows support for > 1 PCI domain, then pci.0 change
* to pciNN.0 where NN is the domain number
*/
- if (qemuCapsGet(caps, QEMU_CAPS_PCI_MULTIBUS))
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_PCI_MULTIBUS))
virBufferAsprintf(buf, ",bus=pci.0");
else
virBufferAsprintf(buf, ",bus=pci");
static int
qemuBuildRomStr(virBufferPtr buf,
virDomainDeviceInfoPtr info,
- qemuCapsPtr caps)
+ virQEMUCapsPtr qemuCaps)
{
if (info->rombar || info->romfile) {
if (info->type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) {
"%s", _("rombar and romfile are supported only for PCI devices"));
return -1;
}
- if (!qemuCapsGet(caps, QEMU_CAPS_PCI_ROMBAR)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_PCI_ROMBAR)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("rombar and romfile not supported in this QEMU binary"));
return -1;
static int
qemuBuildIoEventFdStr(virBufferPtr buf,
enum virDomainIoEventFd use,
- qemuCapsPtr caps)
+ virQEMUCapsPtr qemuCaps)
{
- if (use && qemuCapsGet(caps, QEMU_CAPS_VIRTIO_IOEVENTFD))
+ if (use && virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_IOEVENTFD))
virBufferAsprintf(buf, ",ioeventfd=%s",
virDomainIoEventFdTypeToString(use));
return 0;
qemuBuildDriveStr(virConnectPtr conn ATTRIBUTE_UNUSED,
virDomainDiskDefPtr disk,
bool bootable,
- qemuCapsPtr caps)
+ virQEMUCapsPtr qemuCaps)
{
virBuffer opt = VIR_BUFFER_INITIALIZER;
const char *bus = virDomainDiskQEMUBusTypeToString(disk->bus);
break;
case VIR_DOMAIN_DISK_BUS_VIRTIO:
- if (qemuCapsGet(caps, QEMU_CAPS_VIRTIO_S390) &&
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_S390) &&
(disk->info.type != VIR_DOMAIN_DEVICE_ADDRESS_TYPE_VIRTIO_S390)) {
/* Paranoia - leave in here for now */
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
virBufferEscape(&opt, ',', ",", "file=%s,", disk->src);
}
}
- if (qemuCapsGet(caps, QEMU_CAPS_DEVICE))
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
virBufferAddLit(&opt, "if=none");
else
virBufferAsprintf(&opt, "if=%s", bus);
if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM) {
if ((disk->bus == VIR_DOMAIN_DISK_BUS_SCSI)) {
- if (!qemuCapsGet(caps, QEMU_CAPS_SCSI_CD))
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_SCSI_CD))
virBufferAddLit(&opt, ",media=cdrom");
} else if (disk->bus == VIR_DOMAIN_DISK_BUS_IDE) {
- if (!qemuCapsGet(caps, QEMU_CAPS_IDE_CD))
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_IDE_CD))
virBufferAddLit(&opt, ",media=cdrom");
} else {
virBufferAddLit(&opt, ",media=cdrom");
}
}
- if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
virBufferAsprintf(&opt, ",id=%s%s", QEMU_DRIVE_HOST_PREFIX, disk->info.alias);
} else {
if (busid == -1 && unitid == -1) {
}
}
if (bootable &&
- qemuCapsGet(caps, QEMU_CAPS_DRIVE_BOOT) &&
+ virQEMUCapsGet(qemuCaps, QEMU_CAPS_DRIVE_BOOT) &&
(disk->device == VIR_DOMAIN_DISK_DEVICE_DISK ||
disk->device == VIR_DOMAIN_DISK_DEVICE_LUN) &&
disk->bus != VIR_DOMAIN_DISK_BUS_IDE)
virBufferAddLit(&opt, ",boot=on");
if (disk->readonly &&
- qemuCapsGet(caps, QEMU_CAPS_DRIVE_READONLY))
+ virQEMUCapsGet(qemuCaps, QEMU_CAPS_DRIVE_READONLY))
virBufferAddLit(&opt, ",readonly=on");
if (disk->transient) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
}
if (disk->format > 0 &&
disk->type != VIR_DOMAIN_DISK_TYPE_DIR &&
- qemuCapsGet(caps, QEMU_CAPS_DRIVE_FORMAT))
+ virQEMUCapsGet(qemuCaps, QEMU_CAPS_DRIVE_FORMAT))
virBufferAsprintf(&opt, ",format=%s",
virStorageFileFormatTypeToString(disk->format));
}
if (disk->serial &&
- qemuCapsGet(caps, QEMU_CAPS_DRIVE_SERIAL)) {
+ virQEMUCapsGet(qemuCaps, QEMU_CAPS_DRIVE_SERIAL)) {
if (qemuSafeSerialParamValue(disk->serial) < 0)
goto error;
virBufferAsprintf(&opt, ",serial=%s", disk->serial);
if (disk->cachemode) {
const char *mode = NULL;
- if (qemuCapsGet(caps, QEMU_CAPS_DRIVE_CACHE_V2)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_V2)) {
mode = qemuDiskCacheV2TypeToString(disk->cachemode);
if (disk->cachemode == VIR_DOMAIN_DISK_CACHE_DIRECTSYNC &&
- !qemuCapsGet(caps, QEMU_CAPS_DRIVE_CACHE_DIRECTSYNC)) {
+ !virQEMUCapsGet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_DIRECTSYNC)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("disk cache mode 'directsync' is not "
"supported by this QEMU"));
goto error;
} else if (disk->cachemode == VIR_DOMAIN_DISK_CACHE_UNSAFE &&
- !qemuCapsGet(caps, QEMU_CAPS_DRIVE_CACHE_UNSAFE)) {
+ !virQEMUCapsGet(qemuCaps, QEMU_CAPS_DRIVE_CACHE_UNSAFE)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("disk cache mode 'unsafe' is not "
"supported by this QEMU"));
}
if (disk->copy_on_read) {
- if (qemuCapsGet(caps, QEMU_CAPS_DRIVE_COPY_ON_READ)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DRIVE_COPY_ON_READ)) {
virBufferAsprintf(&opt, ",copy-on-read=%s",
virDomainDiskCopyOnReadTypeToString(disk->copy_on_read));
} else {
}
}
- if (qemuCapsGet(caps, QEMU_CAPS_MONITOR_JSON)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_MONITOR_JSON)) {
const char *wpolicy = NULL, *rpolicy = NULL;
if (disk->error_policy)
}
if (disk->iomode) {
- if (qemuCapsGet(caps, QEMU_CAPS_DRIVE_AIO)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DRIVE_AIO)) {
virBufferAsprintf(&opt, ",aio=%s",
virDomainDiskIoTypeToString(disk->iomode));
} else {
disk->blkdeviotune.total_iops_sec ||
disk->blkdeviotune.read_iops_sec ||
disk->blkdeviotune.write_iops_sec) &&
- !qemuCapsGet(caps, QEMU_CAPS_DRIVE_IOTUNE)) {
+ !virQEMUCapsGet(qemuCaps, QEMU_CAPS_DRIVE_IOTUNE)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("block I/O throttling not supported with this "
"QEMU binary"));
qemuBuildDriveDevStr(virDomainDefPtr def,
virDomainDiskDefPtr disk,
int bootindex,
- qemuCapsPtr caps)
+ virQEMUCapsPtr qemuCaps)
{
virBuffer opt = VIR_BUFFER_INITIALIZER;
const char *bus = virDomainDiskQEMUBusTypeToString(disk->bus);
virDomainDiskTypeToString(disk->type));
goto error;
}
- if (!qemuCapsGet(caps, QEMU_CAPS_VIRTIO_BLK_SG_IO)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_BLK_SG_IO)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("disk device='lun' is not supported by this QEMU"));
goto error;
}
if (disk->wwn &&
- !qemuCapsGet(caps, QEMU_CAPS_IDE_DRIVE_WWN)) {
+ !virQEMUCapsGet(qemuCaps, QEMU_CAPS_IDE_DRIVE_WWN)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("Setting wwn for ide disk is not supported "
"by this QEMU"));
goto error;
}
- if (qemuCapsGet(caps, QEMU_CAPS_IDE_CD)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_IDE_CD)) {
if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM)
virBufferAddLit(&opt, "ide-cd");
else
break;
case VIR_DOMAIN_DISK_BUS_SCSI:
if (disk->device == VIR_DOMAIN_DISK_DEVICE_LUN) {
- if (!qemuCapsGet(caps, QEMU_CAPS_SCSI_BLOCK)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_SCSI_BLOCK)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("This QEMU doesn't support scsi-block for "
"lun passthrough"));
}
if (disk->wwn &&
- !qemuCapsGet(caps, QEMU_CAPS_SCSI_DISK_WWN)) {
+ !virQEMUCapsGet(qemuCaps, QEMU_CAPS_SCSI_DISK_WWN)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("Setting wwn for scsi disk is not supported "
"by this QEMU"));
* same QEMU release (1.2.0).
*/
if ((disk->vendor || disk->product) &&
- !qemuCapsGet(caps, QEMU_CAPS_SCSI_DISK_WWN)) {
+ !virQEMUCapsGet(qemuCaps, QEMU_CAPS_SCSI_DISK_WWN)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("Setting vendor or product for scsi disk is not "
"supported by this QEMU"));
controllerModel =
virDomainDiskFindControllerModel(def, disk,
VIR_DOMAIN_CONTROLLER_TYPE_SCSI);
- if ((qemuSetScsiControllerModel(def, caps, &controllerModel)) < 0)
+ if ((qemuSetScsiControllerModel(def, qemuCaps, &controllerModel)) < 0)
goto error;
if (controllerModel == VIR_DOMAIN_CONTROLLER_MODEL_SCSI_LSILOGIC) {
if (disk->device == VIR_DOMAIN_DISK_DEVICE_LUN) {
virBufferAddLit(&opt, "scsi-block");
} else {
- if (qemuCapsGet(caps, QEMU_CAPS_SCSI_CD)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_SCSI_CD)) {
if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM)
virBufferAddLit(&opt, "scsi-cd");
else
disk->info.addr.drive.bus,
disk->info.addr.drive.unit);
} else {
- if (!qemuCapsGet(caps, QEMU_CAPS_SCSI_DISK_CHANNEL)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_SCSI_DISK_CHANNEL)) {
if (disk->info.addr.drive.target > 7) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("This QEMU doesn't support target "
}
if (disk->device != VIR_DOMAIN_DISK_DEVICE_LUN) {
- if (qemuCapsGet(caps, QEMU_CAPS_SCSI_CD)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_SCSI_CD)) {
if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM)
virBufferAddLit(&opt, "scsi-cd");
else
goto error;
}
- if (qemuCapsGet(caps, QEMU_CAPS_IDE_CD)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_IDE_CD)) {
if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM)
virBufferAddLit(&opt, "ide-cd");
else
} else {
virBufferAddLit(&opt, "virtio-blk-pci");
}
- qemuBuildIoEventFdStr(&opt, disk->ioeventfd, caps);
+ qemuBuildIoEventFdStr(&opt, disk->ioeventfd, qemuCaps);
if (disk->event_idx &&
- qemuCapsGet(caps, QEMU_CAPS_VIRTIO_BLK_EVENT_IDX)) {
+ virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_BLK_EVENT_IDX)) {
virBufferAsprintf(&opt, ",event_idx=%s",
virDomainVirtioEventIdxTypeToString(disk->event_idx));
}
- if (qemuCapsGet(caps, QEMU_CAPS_VIRTIO_BLK_SCSI)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_BLK_SCSI)) {
/* if sg_io is true but the scsi option isn't supported,
* that means it's just always on in this version of qemu.
*/
(disk->device == VIR_DOMAIN_DISK_DEVICE_LUN)
? "on" : "off");
}
- if (qemuBuildDeviceAddressStr(&opt, &disk->info, caps) < 0)
+ if (qemuBuildDeviceAddressStr(&opt, &disk->info, qemuCaps) < 0)
goto error;
break;
case VIR_DOMAIN_DISK_BUS_USB:
virBufferAddLit(&opt, "usb-storage");
- if (qemuBuildDeviceAddressStr(&opt, &disk->info, caps) < 0)
+ if (qemuBuildDeviceAddressStr(&opt, &disk->info, qemuCaps) < 0)
goto error;
break;
default:
}
virBufferAsprintf(&opt, ",drive=%s%s", QEMU_DRIVE_HOST_PREFIX, disk->info.alias);
virBufferAsprintf(&opt, ",id=%s", disk->info.alias);
- if (bootindex && qemuCapsGet(caps, QEMU_CAPS_BOOTINDEX))
+ if (bootindex && virQEMUCapsGet(qemuCaps, QEMU_CAPS_BOOTINDEX))
virBufferAsprintf(&opt, ",bootindex=%d", bootindex);
- if (qemuCapsGet(caps, QEMU_CAPS_BLOCKIO)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_BLOCKIO)) {
if (disk->blockio.logical_block_size > 0)
virBufferAsprintf(&opt, ",logical_block_size=%u",
disk->blockio.logical_block_size);
char *qemuBuildFSStr(virDomainFSDefPtr fs,
- qemuCapsPtr caps ATTRIBUTE_UNUSED)
+ virQEMUCapsPtr qemuCaps ATTRIBUTE_UNUSED)
{
virBuffer opt = VIR_BUFFER_INITIALIZER;
const char *driver = qemuDomainFSDriverTypeToString(fs->fsdriver);
}
if (fs->wrpolicy) {
- if (qemuCapsGet(caps, QEMU_CAPS_FSDEV_WRITEOUT)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_FSDEV_WRITEOUT)) {
virBufferAsprintf(&opt, ",writeout=%s", wrpolicy);
} else {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
virBufferAsprintf(&opt, ",path=%s", fs->src);
if (fs->readonly) {
- if (qemuCapsGet(caps, QEMU_CAPS_FSDEV_READONLY)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_FSDEV_READONLY)) {
virBufferAddLit(&opt, ",readonly");
} else {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
char *
qemuBuildFSDevStr(virDomainFSDefPtr fs,
- qemuCapsPtr caps)
+ virQEMUCapsPtr qemuCaps)
{
virBuffer opt = VIR_BUFFER_INITIALIZER;
virBufferAsprintf(&opt, ",fsdev=%s%s", QEMU_FSDEV_HOST_PREFIX, fs->info.alias);
virBufferAsprintf(&opt, ",mount_tag=%s", fs->dst);
- if (qemuBuildDeviceAddressStr(&opt, &fs->info, caps) < 0)
+ if (qemuBuildDeviceAddressStr(&opt, &fs->info, qemuCaps) < 0)
goto error;
if (virBufferError(&opt)) {
static int
qemuBuildUSBControllerDevStr(virDomainDefPtr domainDef,
virDomainControllerDefPtr def,
- qemuCapsPtr caps,
+ virQEMUCapsPtr qemuCaps,
virBuffer *buf)
{
const char *smodel;
smodel = qemuControllerModelUSBTypeToString(model);
flags = qemuControllerModelUSBToCaps(model);
- if (flags == -1 || !qemuCapsGet(caps, flags)) {
+ if (flags == -1 || !virQEMUCapsGet(qemuCaps, flags)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("%s not supported in this QEMU binary"), smodel);
return -1;
char *
qemuBuildControllerDevStr(virDomainDefPtr domainDef,
virDomainControllerDefPtr def,
- qemuCapsPtr caps,
+ virQEMUCapsPtr qemuCaps,
int *nusbcontroller)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
switch (def->type) {
case VIR_DOMAIN_CONTROLLER_TYPE_SCSI:
model = def->model;
- if ((qemuSetScsiControllerModel(domainDef, caps, &model)) < 0)
+ if ((qemuSetScsiControllerModel(domainDef, qemuCaps, &model)) < 0)
return NULL;
switch (model) {
break;
case VIR_DOMAIN_CONTROLLER_TYPE_USB:
- if (qemuBuildUSBControllerDevStr(domainDef, def, caps, &buf) == -1)
+ if (qemuBuildUSBControllerDevStr(domainDef, def, qemuCaps, &buf) == -1)
goto error;
if (nusbcontroller)
goto error;
}
- if (qemuBuildDeviceAddressStr(&buf, &def->info, caps) < 0)
+ if (qemuBuildDeviceAddressStr(&buf, &def->info, qemuCaps) < 0)
goto error;
if (virBufferError(&buf)) {
qemuBuildNicDevStr(virDomainNetDefPtr net,
int vlan,
int bootindex,
- qemuCapsPtr caps)
+ virQEMUCapsPtr qemuCaps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
const char *nic;
virBufferAdd(&buf, nic, strlen(nic));
if (usingVirtio && net->driver.virtio.txmode) {
- if (qemuCapsGet(caps, QEMU_CAPS_VIRTIO_TX_ALG)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_TX_ALG)) {
virBufferAddLit(&buf, ",tx=");
switch (net->driver.virtio.txmode) {
case VIR_DOMAIN_NET_VIRTIO_TX_MODE_IOTHREAD:
}
}
if (usingVirtio) {
- qemuBuildIoEventFdStr(&buf, net->driver.virtio.ioeventfd, caps);
+ qemuBuildIoEventFdStr(&buf, net->driver.virtio.ioeventfd, qemuCaps);
if (net->driver.virtio.event_idx &&
- qemuCapsGet(caps, QEMU_CAPS_VIRTIO_NET_EVENT_IDX)) {
+ virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_NET_EVENT_IDX)) {
virBufferAsprintf(&buf, ",event_idx=%s",
virDomainVirtioEventIdxTypeToString(net->driver.virtio.event_idx));
}
net->mac.addr[0], net->mac.addr[1],
net->mac.addr[2], net->mac.addr[3],
net->mac.addr[4], net->mac.addr[5]);
- if (qemuBuildDeviceAddressStr(&buf, &net->info, caps) < 0)
+ if (qemuBuildDeviceAddressStr(&buf, &net->info, qemuCaps) < 0)
goto error;
- if (qemuBuildRomStr(&buf, &net->info, caps) < 0)
+ if (qemuBuildRomStr(&buf, &net->info, qemuCaps) < 0)
goto error;
- if (bootindex && qemuCapsGet(caps, QEMU_CAPS_BOOTINDEX))
+ if (bootindex && virQEMUCapsGet(qemuCaps, QEMU_CAPS_BOOTINDEX))
virBufferAsprintf(&buf, ",bootindex=%d", bootindex);
if (virBufferError(&buf)) {
char *
qemuBuildHostNetStr(virDomainNetDefPtr net,
virQEMUDriverPtr driver,
- qemuCapsPtr caps,
+ virQEMUCapsPtr qemuCaps,
char type_sep,
int vlan,
const char *tapfd,
*/
case VIR_DOMAIN_NET_TYPE_BRIDGE:
if (!cfg->privileged &&
- qemuCapsGet(caps, QEMU_CAPS_NETDEV_BRIDGE)) {
+ virQEMUCapsGet(qemuCaps, QEMU_CAPS_NETDEV_BRIDGE)) {
brname = virDomainNetGetActualBridgeName(net);
virBufferAsprintf(&buf, "bridge%cbr=%s", type_sep, brname);
type_sep = ',';
char *
qemuBuildWatchdogDevStr(virDomainWatchdogDefPtr dev,
- qemuCapsPtr caps)
+ virQEMUCapsPtr qemuCaps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
}
virBufferAsprintf(&buf, "%s,id=%s", model, dev->info.alias);
- if (qemuBuildDeviceAddressStr(&buf, &dev->info, caps) < 0)
+ if (qemuBuildDeviceAddressStr(&buf, &dev->info, qemuCaps) < 0)
goto error;
if (virBufferError(&buf)) {
char *
qemuBuildMemballoonDevStr(virDomainMemballoonDefPtr dev,
- qemuCapsPtr caps)
+ virQEMUCapsPtr qemuCaps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
virBufferAddLit(&buf, "virtio-balloon-pci");
virBufferAsprintf(&buf, ",id=%s", dev->info.alias);
- if (qemuBuildDeviceAddressStr(&buf, &dev->info, caps) < 0)
+ if (qemuBuildDeviceAddressStr(&buf, &dev->info, qemuCaps) < 0)
goto error;
if (virBufferError(&buf)) {
char *
qemuBuildUSBInputDevStr(virDomainInputDefPtr dev,
- qemuCapsPtr caps)
+ virQEMUCapsPtr qemuCaps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
dev->type == VIR_DOMAIN_INPUT_TYPE_MOUSE ?
"usb-mouse" : "usb-tablet", dev->info.alias);
- if (qemuBuildDeviceAddressStr(&buf, &dev->info, caps) < 0)
+ if (qemuBuildDeviceAddressStr(&buf, &dev->info, qemuCaps) < 0)
goto error;
if (virBufferError(&buf)) {
char *
qemuBuildSoundDevStr(virDomainSoundDefPtr sound,
- qemuCapsPtr caps)
+ virQEMUCapsPtr qemuCaps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
const char *model = virDomainSoundModelTypeToString(sound->model);
model = "intel-hda";
virBufferAsprintf(&buf, "%s,id=%s", model, sound->info.alias);
- if (qemuBuildDeviceAddressStr(&buf, &sound->info, caps) < 0)
+ if (qemuBuildDeviceAddressStr(&buf, &sound->info, qemuCaps) < 0)
goto error;
if (virBufferError(&buf)) {
static char *
qemuBuildSoundCodecStr(virDomainSoundDefPtr sound,
virDomainSoundCodecDefPtr codec,
- qemuCapsPtr caps)
+ virQEMUCapsPtr qemuCaps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
const char *stype;
stype = qemuSoundCodecTypeToString(type);
flags = qemuSoundCodecTypeToCaps(type);
- if (flags == -1 || !qemuCapsGet(caps, flags)) {
+ if (flags == -1 || !virQEMUCapsGet(qemuCaps, flags)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("%s not supported in this QEMU binary"), stype);
goto error;
static char *
qemuBuildDeviceVideoStr(virDomainVideoDefPtr video,
- qemuCapsPtr caps,
+ virQEMUCapsPtr qemuCaps,
bool primary)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
goto error;
}
- if (!qemuCapsGet(caps, QEMU_CAPS_DEVICE_QXL)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_QXL)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("only one video card is currently supported"));
goto error;
virBufferAsprintf(&buf, ",vram_size=%u", video->vram * 1024);
}
- if (qemuBuildDeviceAddressStr(&buf, &video->info, caps) < 0)
+ if (qemuBuildDeviceAddressStr(&buf, &video->info, qemuCaps) < 0)
goto error;
if (virBufferError(&buf)) {
char *
qemuBuildPCIHostdevDevStr(virDomainHostdevDefPtr dev, const char *configfd,
- qemuCapsPtr caps)
+ virQEMUCapsPtr qemuCaps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
virBufferAsprintf(&buf, ",configfd=%s", configfd);
if (dev->info->bootIndex)
virBufferAsprintf(&buf, ",bootindex=%d", dev->info->bootIndex);
- if (qemuBuildDeviceAddressStr(&buf, dev->info, caps) < 0)
+ if (qemuBuildDeviceAddressStr(&buf, dev->info, qemuCaps) < 0)
goto error;
- if (qemuBuildRomStr(&buf, dev->info, caps) < 0)
+ if (qemuBuildRomStr(&buf, dev->info, qemuCaps) < 0)
goto error;
if (virBufferError(&buf)) {
char *
qemuBuildRedirdevDevStr(virDomainDefPtr def,
virDomainRedirdevDefPtr dev,
- qemuCapsPtr caps)
+ virQEMUCapsPtr qemuCaps)
{
size_t i;
virBuffer buf = VIR_BUFFER_INITIALIZER;
goto error;
}
- if (!qemuCapsGet(caps, QEMU_CAPS_USB_REDIR)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_USB_REDIR)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("USB redirection is not supported "
"by this version of QEMU"));
dev->info.alias);
if (redirfilter && redirfilter->nusbdevs) {
- if (!qemuCapsGet(caps, QEMU_CAPS_USB_REDIR_FILTER)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_USB_REDIR_FILTER)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("USB redirection filter is not "
"supported by this version of QEMU"));
}
if (dev->info.bootIndex) {
- if (!qemuCapsGet(caps, QEMU_CAPS_USB_REDIR_BOOTINDEX)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_USB_REDIR_BOOTINDEX)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("USB redirection booting is not "
"supported by this version of QEMU"));
virBufferAsprintf(&buf, ",bootindex=%d", dev->info.bootIndex);
}
- if (qemuBuildDeviceAddressStr(&buf, &dev->info, caps) < 0)
+ if (qemuBuildDeviceAddressStr(&buf, &dev->info, qemuCaps) < 0)
goto error;
if (virBufferError(&buf)) {
char *
qemuBuildUSBHostdevDevStr(virDomainHostdevDefPtr dev,
- qemuCapsPtr caps)
+ virQEMUCapsPtr qemuCaps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
if (dev->info->bootIndex)
virBufferAsprintf(&buf, ",bootindex=%d", dev->info->bootIndex);
- if (qemuBuildDeviceAddressStr(&buf, dev->info, caps) < 0)
+ if (qemuBuildDeviceAddressStr(&buf, dev->info, qemuCaps) < 0)
goto error;
if (virBufferError(&buf)) {
char *
qemuBuildHubDevStr(virDomainHubDefPtr dev,
- qemuCapsPtr caps)
+ virQEMUCapsPtr qemuCaps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
goto error;
}
- if (!qemuCapsGet(caps, QEMU_CAPS_USB_HUB)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_USB_HUB)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("usb-hub not supported by QEMU binary"));
goto error;
virBufferAddLit(&buf, "usb-hub");
virBufferAsprintf(&buf, ",id=%s", dev->info.alias);
- if (qemuBuildDeviceAddressStr(&buf, &dev->info, caps) < 0)
+ if (qemuBuildDeviceAddressStr(&buf, &dev->info, qemuCaps) < 0)
goto error;
if (virBufferError(&buf)) {
* host side of the character device */
static char *
qemuBuildChrChardevStr(virDomainChrSourceDefPtr dev, const char *alias,
- qemuCapsPtr caps)
+ virQEMUCapsPtr qemuCaps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
bool telnet;
break;
case VIR_DOMAIN_CHR_TYPE_SPICEVMC:
- if (!qemuCapsGet(caps, QEMU_CAPS_CHARDEV_SPICEVMC)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_CHARDEV_SPICEVMC)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("spicevmc not supported in this QEMU binary"));
goto error;
static char *
qemuBuildVirtioSerialPortDevStr(virDomainChrDefPtr dev,
- qemuCapsPtr caps)
+ virQEMUCapsPtr qemuCaps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
switch (dev->deviceType) {
case VIR_DOMAIN_CHR_DEVICE_TYPE_CHANNEL:
/* Legacy syntax '-device spicevmc' */
if (dev->source.type == VIR_DOMAIN_CHR_TYPE_SPICEVMC &&
- qemuCapsGet(caps, QEMU_CAPS_DEVICE_SPICEVMC)) {
+ virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_SPICEVMC)) {
virBufferAddLit(&buf, "spicevmc");
} else {
virBufferAddLit(&buf, "virtserialport");
if (!(dev->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CHANNEL &&
dev->source.type == VIR_DOMAIN_CHR_TYPE_SPICEVMC &&
- qemuCapsGet(caps, QEMU_CAPS_DEVICE_SPICEVMC))) {
+ virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_SPICEVMC))) {
virBufferAsprintf(&buf, ",chardev=char%s,id=%s",
dev->info.alias, dev->info.alias);
if (dev->deviceType == VIR_DOMAIN_CHR_DEVICE_TYPE_CHANNEL) {
qemuBuildCpuArgStr(const virQEMUDriverPtr driver,
const virDomainDefPtr def,
const char *emulator,
- qemuCapsPtr caps,
+ virQEMUCapsPtr qemuCaps,
virArch hostarch,
char **opt,
bool *hasHwVirt,
if (!host ||
!host->model ||
- (ncpus = qemuCapsGetCPUDefinitions(caps, &cpus)) == 0) {
+ (ncpus = virQEMUCapsGetCPUDefinitions(qemuCaps, &cpus)) == 0) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("CPU specification not supported by hypervisor"));
goto cleanup;
if (cpu->mode == VIR_CPU_MODE_HOST_PASSTHROUGH) {
const char *mode = virCPUModeTypeToString(cpu->mode);
- if (!qemuCapsGet(caps, QEMU_CAPS_CPU_HOST)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_CPU_HOST)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("CPU mode '%s' is not supported by QEMU"
" binary"), mode);
static int
qemuBuildMachineArgStr(virCommandPtr cmd,
const virDomainDefPtr def,
- qemuCapsPtr caps)
+ virQEMUCapsPtr qemuCaps)
{
/* This should *never* be NULL, since we always provide
* a machine in the capabilities data for QEMU. So this
*/
virCommandAddArgList(cmd, "-M", def->os.machine, NULL);
} else {
- if (!qemuCapsGet(caps, QEMU_CAPS_DUMP_GUEST_CORE)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DUMP_GUEST_CORE)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("dump-guest-core is not available "
" with this QEMU binary"));
static char *
qemuBuildSmpArgStr(const virDomainDefPtr def,
- qemuCapsPtr caps)
+ virQEMUCapsPtr qemuCaps)
{
virBuffer buf = VIR_BUFFER_INITIALIZER;
virBufferAsprintf(&buf, "%u", def->vcpus);
- if (qemuCapsGet(caps, QEMU_CAPS_SMP_TOPOLOGY)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_SMP_TOPOLOGY)) {
if (def->vcpus != def->maxvcpus)
virBufferAsprintf(&buf, ",maxcpus=%u", def->maxvcpus);
/* sockets, cores, and threads are either all zero
qemuBuildGraphicsCommandLine(virQEMUDriverConfigPtr cfg,
virCommandPtr cmd,
virDomainDefPtr def,
- qemuCapsPtr caps,
+ virQEMUCapsPtr qemuCaps,
virDomainGraphicsDefPtr graphics)
{
int i;
if (graphics->type == VIR_DOMAIN_GRAPHICS_TYPE_VNC) {
virBuffer opt = VIR_BUFFER_INITIALIZER;
- if (!qemuCapsGet(caps, QEMU_CAPS_VNC)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_VNC)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("vnc graphics are not supported with this QEMU"));
goto error;
virBufferAsprintf(&opt, "unix:%s",
graphics->data.vnc.socket);
- } else if (qemuCapsGet(caps, QEMU_CAPS_VNC_COLON)) {
+ } else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_VNC_COLON)) {
const char *listenNetwork;
const char *listenAddr = NULL;
char *netAddr = NULL;
graphics->data.vnc.port - 5900);
}
- if (qemuCapsGet(caps, QEMU_CAPS_VNC_COLON)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_VNC_COLON)) {
if (graphics->data.vnc.auth.passwd ||
cfg->vncPassword)
virBufferAddLit(&opt, ",password");
virCommandAddEnvString(cmd, "QEMU_AUDIO_DRV=none");
}
} else if (graphics->type == VIR_DOMAIN_GRAPHICS_TYPE_SDL) {
- if (qemuCapsGet(caps, QEMU_CAPS_0_10) &&
- !qemuCapsGet(caps, QEMU_CAPS_SDL)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_0_10) &&
+ !virQEMUCapsGet(qemuCaps, QEMU_CAPS_SDL)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("sdl not supported by '%s'"),
def->emulator);
/* New QEMU has this flag to let us explicitly ask for
* SDL graphics. This is better than relying on the
* default, since the default changes :-( */
- if (qemuCapsGet(caps, QEMU_CAPS_SDL))
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_SDL))
virCommandAddArg(cmd, "-sdl");
} else if (graphics->type == VIR_DOMAIN_GRAPHICS_TYPE_SPICE) {
int port = graphics->data.spice.port;
int tlsPort = graphics->data.spice.tlsPort;
- if (!qemuCapsGet(caps, QEMU_CAPS_SPICE)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_SPICE)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("spice graphics are not supported with this QEMU"));
goto error;
if (graphics->data.spice.copypaste == VIR_DOMAIN_GRAPHICS_SPICE_CLIPBOARD_COPYPASTE_NO)
virBufferAddLit(&opt, ",disable-copy-paste");
- if (qemuCapsGet(caps, QEMU_CAPS_SEAMLESS_MIGRATION)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_SEAMLESS_MIGRATION)) {
/* If qemu supports seamless migration turn it
* unconditionally on. If migration destination
* doesn't support it, it fallbacks to previous
virDomainDefPtr def,
virDomainChrSourceDefPtr monitor_chr,
bool monitor_json,
- qemuCapsPtr caps,
+ virQEMUCapsPtr qemuCaps,
const char *migrateFrom,
int migrateFd,
virDomainSnapshotObjPtr snapshot,
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
VIR_DEBUG("conn=%p driver=%p def=%p mon=%p json=%d "
- "caps=%p migrateFrom=%s migrateFD=%d "
+ "qemuCaps=%p migrateFrom=%s migrateFD=%d "
"snapshot=%p vmop=%d",
conn, driver, def, monitor_chr, monitor_json,
- caps, migrateFrom, migrateFd, snapshot, vmop);
+ qemuCaps, migrateFrom, migrateFd, snapshot, vmop);
virUUIDFormat(def->uuid, uuid);
* do not use boot=on for drives when not using KVM since this
* is not supported at all in upstream QEmu.
*/
- if (qemuCapsGet(caps, QEMU_CAPS_KVM) &&
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM) &&
(def->virtType == VIR_DOMAIN_VIRT_QEMU))
- qemuCapsClear(caps, QEMU_CAPS_DRIVE_BOOT);
+ virQEMUCapsClear(qemuCaps, QEMU_CAPS_DRIVE_BOOT);
switch (def->virtType) {
case VIR_DOMAIN_VIRT_QEMU:
- if (qemuCapsGet(caps, QEMU_CAPS_KQEMU))
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KQEMU))
disableKQEMU = 1;
- if (qemuCapsGet(caps, QEMU_CAPS_KVM))
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM))
disableKVM = 1;
break;
case VIR_DOMAIN_VIRT_KQEMU:
- if (qemuCapsGet(caps, QEMU_CAPS_KVM))
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM))
disableKVM = 1;
- if (qemuCapsGet(caps, QEMU_CAPS_ENABLE_KQEMU)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_ENABLE_KQEMU)) {
enableKQEMU = 1;
- } else if (!qemuCapsGet(caps, QEMU_CAPS_KQEMU)) {
+ } else if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_KQEMU)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("the QEMU binary %s does not support kqemu"),
emulator);
break;
case VIR_DOMAIN_VIRT_KVM:
- if (qemuCapsGet(caps, QEMU_CAPS_KQEMU))
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_KQEMU))
disableKQEMU = 1;
- if (qemuCapsGet(caps, QEMU_CAPS_ENABLE_KVM)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_ENABLE_KVM)) {
enableKVM = 1;
- } else if (!qemuCapsGet(caps, QEMU_CAPS_KVM)) {
+ } else if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_KVM)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("the QEMU binary %s does not support kvm"),
emulator);
virCommandAddEnvPassCommon(cmd);
- if (qemuCapsGet(caps, QEMU_CAPS_NAME)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_NAME)) {
virCommandAddArg(cmd, "-name");
if (cfg->setProcessName &&
- qemuCapsGet(caps, QEMU_CAPS_NAME_PROCESS)) {
+ virQEMUCapsGet(qemuCaps, QEMU_CAPS_NAME_PROCESS)) {
virCommandAddArgFormat(cmd, "%s,process=qemu:%s",
def->name, def->name);
} else {
}
virCommandAddArg(cmd, "-S"); /* freeze CPU */
- if (qemuBuildMachineArgStr(cmd, def, caps) < 0)
+ if (qemuBuildMachineArgStr(cmd, def, qemuCaps) < 0)
goto error;
- if (qemuBuildCpuArgStr(driver, def, emulator, caps,
+ if (qemuBuildCpuArgStr(driver, def, emulator, qemuCaps,
hostarch, &cpu, &hasHwVirt, !!migrateFrom) < 0)
goto error;
virCommandAddArgList(cmd, "-cpu", cpu, NULL);
VIR_FREE(cpu);
- if (qemuCapsGet(caps, QEMU_CAPS_NESTING) &&
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_NESTING) &&
hasHwVirt)
virCommandAddArg(cmd, "-enable-nesting");
}
"%s", _("hugepages are disabled by administrator config"));
goto error;
}
- if (!qemuCapsGet(caps, QEMU_CAPS_MEM_PATH)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_MEM_PATH)) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("hugepage backing not supported by '%s'"),
def->emulator);
}
virCommandAddArg(cmd, "-smp");
- if (!(smp = qemuBuildSmpArgStr(def, caps)))
+ if (!(smp = qemuBuildSmpArgStr(def, qemuCaps)))
goto error;
virCommandAddArg(cmd, smp);
VIR_FREE(smp);
if (qemuBuildNumaArgStr(def, cmd) < 0)
goto error;
- if (qemuCapsGet(caps, QEMU_CAPS_UUID))
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_UUID))
virCommandAddArgList(cmd, "-uuid", uuid, NULL);
if (def->virtType == VIR_DOMAIN_VIRT_XEN ||
STREQ(def->os.type, "xen") ||
STREQ(def->os.type, "linux")) {
- if (qemuCapsGet(caps, QEMU_CAPS_DOMID)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DOMID)) {
virCommandAddArg(cmd, "-domid");
virCommandAddArgFormat(cmd, "%d", def->id);
- } else if (qemuCapsGet(caps, QEMU_CAPS_XEN_DOMID)) {
+ } else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_XEN_DOMID)) {
virCommandAddArg(cmd, "-xen-attach");
virCommandAddArg(cmd, "-xen-domid");
virCommandAddArgFormat(cmd, "%d", def->id);
virSysinfoDefPtr source = NULL;
bool skip_uuid = false;
- if (!qemuCapsGet(caps, QEMU_CAPS_SMBIOS_TYPE)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_SMBIOS_TYPE)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
_("the QEMU binary %s does not support smbios settings"),
emulator);
if (!def->graphics)
virCommandAddArg(cmd, "-nographic");
- if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
/* Disable global config files and default devices */
- if (qemuCapsGet(caps, QEMU_CAPS_NO_USER_CONFIG))
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_NO_USER_CONFIG))
virCommandAddArg(cmd, "-no-user-config");
- else if (qemuCapsGet(caps, QEMU_CAPS_NODEFCONFIG))
+ else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_NODEFCONFIG))
virCommandAddArg(cmd, "-nodefconfig");
virCommandAddArg(cmd, "-nodefaults");
}
/* Serial graphics adapter */
if (def->os.bios.useserial == VIR_DOMAIN_BIOS_USESERIAL_YES) {
- if (!qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("qemu does not support -device"));
goto error;
}
- if (!qemuCapsGet(caps, QEMU_CAPS_SGA)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_SGA)) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("qemu does not support SGA"));
goto error;
if (monitor_chr) {
char *chrdev;
/* Use -chardev if it's available */
- if (qemuCapsGet(caps, QEMU_CAPS_CHARDEV)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_CHARDEV)) {
virCommandAddArg(cmd, "-chardev");
if (!(chrdev = qemuBuildChrChardevStr(monitor_chr, "monitor",
- caps)))
+ qemuCaps)))
goto error;
virCommandAddArg(cmd, chrdev);
VIR_FREE(chrdev);
}
}
- if (qemuCapsGet(caps, QEMU_CAPS_RTC)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_RTC)) {
const char *rtcopt;
virCommandAddArg(cmd, "-rtc");
if (!(rtcopt = qemuBuildClockArgStr(&def->clock)))
/* This has already been taken care of (in qemuBuildClockArgStr)
if QEMU_CAPS_RTC is set (mutually exclusive with
QEMUD_FLAG_RTC_TD_HACK) */
- if (qemuCapsGet(caps, QEMU_CAPS_RTC_TD_HACK)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_RTC_TD_HACK)) {
switch (def->clock.timers[i]->tickpolicy) {
case -1:
case VIR_DOMAIN_TIMER_TICKPOLICY_DELAY:
virDomainTimerTickpolicyTypeToString(def->clock.timers[i]->tickpolicy));
goto error;
}
- } else if (!qemuCapsGet(caps, QEMU_CAPS_RTC)
+ } else if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_RTC)
&& (def->clock.timers[i]->tickpolicy
!= VIR_DOMAIN_TIMER_TICKPOLICY_DELAY)
&& (def->clock.timers[i]->tickpolicy != -1)) {
case VIR_DOMAIN_TIMER_TICKPOLICY_DELAY:
/* delay is the default if we don't have kernel
(-no-kvm-pit), otherwise, the default is catchup. */
- if (qemuCapsGet(caps, QEMU_CAPS_NO_KVM_PIT))
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_NO_KVM_PIT))
virCommandAddArg(cmd, "-no-kvm-pit-reinjection");
break;
case VIR_DOMAIN_TIMER_TICKPOLICY_CATCHUP:
- if (qemuCapsGet(caps, QEMU_CAPS_NO_KVM_PIT)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_NO_KVM_PIT)) {
/* do nothing - this is default for kvm-pit */
- } else if (qemuCapsGet(caps, QEMU_CAPS_TDF)) {
+ } else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_TDF)) {
/* -tdf switches to 'catchup' with userspace pit. */
virCommandAddArg(cmd, "-tdf");
} else {
* and when -no-hpet doesn't exist is "no". "confusing"?
* "yes"! */
- if (qemuCapsGet(caps, QEMU_CAPS_NO_HPET)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_NO_HPET)) {
if (def->clock.timers[i]->present == 0)
virCommandAddArg(cmd, "-no-hpet");
} else {
}
}
- if (qemuCapsGet(caps, QEMU_CAPS_NO_REBOOT) &&
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_NO_REBOOT) &&
def->onReboot != VIR_DOMAIN_LIFECYCLE_RESTART)
virCommandAddArg(cmd, "-no-reboot");
* when QEMU stops. If we use no-shutdown, then we can
* watch for this event and do a soft/warm reboot.
*/
- if (monitor_json && qemuCapsGet(caps, QEMU_CAPS_NO_SHUTDOWN))
+ if (monitor_json && virQEMUCapsGet(qemuCaps, QEMU_CAPS_NO_SHUTDOWN))
virCommandAddArg(cmd, "-no-shutdown");
- if (qemuCapsGet(caps, QEMU_CAPS_NO_ACPI)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_NO_ACPI)) {
if (!(def->features & (1 << VIR_DOMAIN_FEATURE_ACPI)))
virCommandAddArg(cmd, "-no-acpi");
}
if (def->pm.s3) {
- if (!qemuCapsGet(caps, QEMU_CAPS_DISABLE_S3)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DISABLE_S3)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("setting ACPI S3 not supported"));
goto error;
}
if (def->pm.s4) {
- if (!qemuCapsGet(caps, QEMU_CAPS_DISABLE_S4)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DISABLE_S4)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("setting ACPI S4 not supported"));
goto error;
/* def->os.nBootDevs is guaranteed to be > 0 unless per-device boot
* configuration is used
*/
- if (!qemuCapsGet(caps, QEMU_CAPS_BOOTINDEX)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_BOOTINDEX)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("hypervisor lacks deviceboot feature"));
goto error;
}
emitBootindex = true;
- } else if (qemuCapsGet(caps, QEMU_CAPS_BOOTINDEX) &&
+ } else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_BOOTINDEX) &&
(def->os.bootmenu != VIR_DOMAIN_BOOT_MENU_ENABLED ||
- !qemuCapsGet(caps, QEMU_CAPS_BOOT_MENU))) {
+ !virQEMUCapsGet(qemuCaps, QEMU_CAPS_BOOT_MENU))) {
emitBootindex = true;
}
}
if (def->os.bootmenu) {
- if (qemuCapsGet(caps, QEMU_CAPS_BOOT_MENU)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_BOOT_MENU)) {
if (boot_nparams++)
virBufferAddChar(&boot_buf, ',');
}
if (def->os.bios.rt_set) {
- if (!qemuCapsGet(caps, QEMU_CAPS_REBOOT_TIMEOUT)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_REBOOT_TIMEOUT)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("reboot timeout is not supported "
"by this QEMU binary"));
}
}
- if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
for (j = 0; j < ARRAY_CARDINALITY(contOrder); j++) {
for (i = 0; i < def->ncontrollers; i++) {
virDomainControllerDefPtr cont = def->controllers[i];
/* Only recent QEMU implements a SATA (AHCI) controller */
if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_SATA) {
- if (!qemuCapsGet(caps, QEMU_CAPS_ICH9_AHCI)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_ICH9_AHCI)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("SATA is not supported with this "
"QEMU binary"));
virCommandAddArg(cmd, "-device");
if (!(devstr = qemuBuildControllerDevStr(def, cont,
- caps, NULL)))
+ qemuCaps, NULL)))
goto error;
virCommandAddArg(cmd, devstr);
}
} else if (cont->type == VIR_DOMAIN_CONTROLLER_TYPE_USB &&
cont->model == -1 &&
- !qemuCapsGet(caps, QEMU_CAPS_PIIX3_USB_UHCI)) {
+ !virQEMUCapsGet(qemuCaps, QEMU_CAPS_PIIX3_USB_UHCI)) {
if (usblegacy) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("Multiple legacy USB controllers are "
virCommandAddArg(cmd, "-device");
char *devstr;
- if (!(devstr = qemuBuildControllerDevStr(def, cont, caps,
+ if (!(devstr = qemuBuildControllerDevStr(def, cont, qemuCaps,
&usbcontroller)))
goto error;
char *optstr;
virCommandAddArg(cmd, "-device");
- if (!(optstr = qemuBuildHubDevStr(hub, caps)))
+ if (!(optstr = qemuBuildHubDevStr(hub, qemuCaps)))
goto error;
virCommandAddArg(cmd, optstr);
VIR_FREE(optstr);
}
/* If QEMU supports -drive param instead of old -hda, -hdb, -cdrom .. */
- if (qemuCapsGet(caps, QEMU_CAPS_DRIVE)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DRIVE)) {
int bootCD = 0, bootFloppy = 0, bootDisk = 0;
- if ((qemuCapsGet(caps, QEMU_CAPS_DRIVE_BOOT) || emitBootindex)) {
+ if ((virQEMUCapsGet(qemuCaps, QEMU_CAPS_DRIVE_BOOT) || emitBootindex)) {
/* bootDevs will get translated into either bootindex=N or boot=on
* depending on what qemu supports */
for (i = 0 ; i < def->os.nBootDevs ; i++) {
/* Unless we have -device, then USB disks need special
handling */
if ((disk->bus == VIR_DOMAIN_DISK_BUS_USB) &&
- !qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
+ !virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
if (disk->device == VIR_DOMAIN_DISK_DEVICE_DISK) {
virCommandAddArg(cmd, "-usbdevice");
virCommandAddArgFormat(cmd, "disk:%s", disk->src);
devices. Fortunately, those don't need
static PCI addresses, so we don't really
care that we can't use -device */
- if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
if (disk->bus != VIR_DOMAIN_DISK_BUS_XEN) {
withDeviceArg = 1;
} else {
- qemuCapsClear(caps, QEMU_CAPS_DEVICE);
+ virQEMUCapsClear(qemuCaps, QEMU_CAPS_DEVICE);
deviceFlagMasked = true;
}
}
optstr = qemuBuildDriveStr(conn, disk,
emitBootindex ? false : !!bootindex,
- caps);
+ qemuCaps);
if (deviceFlagMasked)
- qemuCapsSet(caps, QEMU_CAPS_DEVICE);
+ virQEMUCapsSet(qemuCaps, QEMU_CAPS_DEVICE);
if (!optstr)
goto error;
virCommandAddArg(cmd, optstr);
virCommandAddArg(cmd, "-device");
if (!(optstr = qemuBuildDriveDevStr(def, disk, bootindex,
- caps)))
+ qemuCaps)))
goto error;
virCommandAddArg(cmd, optstr);
VIR_FREE(optstr);
}
}
- if (qemuCapsGet(caps, QEMU_CAPS_FSDEV)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_FSDEV)) {
for (i = 0 ; i < def->nfss ; i++) {
char *optstr;
virDomainFSDefPtr fs = def->fss[i];
virCommandAddArg(cmd, "-fsdev");
- if (!(optstr = qemuBuildFSStr(fs, caps)))
+ if (!(optstr = qemuBuildFSStr(fs, qemuCaps)))
goto error;
virCommandAddArg(cmd, optstr);
VIR_FREE(optstr);
virCommandAddArg(cmd, "-device");
- if (!(optstr = qemuBuildFSDevStr(fs, caps)))
+ if (!(optstr = qemuBuildFSDevStr(fs, qemuCaps)))
goto error;
virCommandAddArg(cmd, optstr);
VIR_FREE(optstr);
if (!def->nnets) {
/* If we have -device, then we set -nodefault already */
- if (!qemuCapsGet(caps, QEMU_CAPS_DEVICE))
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
virCommandAddArgList(cmd, "-net", "none", NULL);
} else {
int bootNet = 0;
bootindex = net->info.bootIndex;
/* VLANs are not used with -netdev, so don't record them */
- if (qemuCapsGet(caps, QEMU_CAPS_NETDEV) &&
- qemuCapsGet(caps, QEMU_CAPS_DEVICE))
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_NETDEV) &&
+ virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
vlan = -1;
else
vlan = i;
*/
if (actualType == VIR_DOMAIN_NET_TYPE_NETWORK ||
cfg->privileged ||
- (!qemuCapsGet(caps, QEMU_CAPS_NETDEV_BRIDGE))) {
+ (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_NETDEV_BRIDGE))) {
int tapfd = qemuNetworkIfaceConnect(def, conn, driver, net,
- caps);
+ qemuCaps);
if (tapfd < 0)
goto error;
}
} else if (actualType == VIR_DOMAIN_NET_TYPE_DIRECT) {
int tapfd = qemuPhysIfaceConnect(def, driver, net,
- caps, vmop);
+ qemuCaps, vmop);
if (tapfd < 0)
goto error;
network device */
int vhostfd;
- if (qemuOpenVhostNet(def, net, caps, &vhostfd) < 0)
+ if (qemuOpenVhostNet(def, net, qemuCaps, &vhostfd) < 0)
goto error;
if (vhostfd >= 0) {
virCommandTransferFD(cmd, vhostfd);
*
* NB, no support for -netdev without use of -device
*/
- if (qemuCapsGet(caps, QEMU_CAPS_NETDEV) &&
- qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_NETDEV) &&
+ virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
virCommandAddArg(cmd, "-netdev");
- if (!(host = qemuBuildHostNetStr(net, driver, caps,
+ if (!(host = qemuBuildHostNetStr(net, driver, qemuCaps,
',', vlan, tapfd_name,
vhostfd_name)))
goto error;
virCommandAddArg(cmd, host);
VIR_FREE(host);
}
- if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
virCommandAddArg(cmd, "-device");
- nic = qemuBuildNicDevStr(net, vlan, bootindex, caps);
+ nic = qemuBuildNicDevStr(net, vlan, bootindex, qemuCaps);
if (!nic)
goto error;
virCommandAddArg(cmd, nic);
virCommandAddArg(cmd, nic);
VIR_FREE(nic);
}
- if (!(qemuCapsGet(caps, QEMU_CAPS_NETDEV) &&
- qemuCapsGet(caps, QEMU_CAPS_DEVICE))) {
+ if (!(virQEMUCapsGet(qemuCaps, QEMU_CAPS_NETDEV) &&
+ virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE))) {
virCommandAddArg(cmd, "-net");
- if (!(host = qemuBuildHostNetStr(net, driver, caps,
+ if (!(host = qemuBuildHostNetStr(net, driver, qemuCaps,
',', vlan, tapfd_name,
vhostfd_name)))
goto error;
switch (smartcard->type) {
case VIR_DOMAIN_SMARTCARD_TYPE_HOST:
- if (!qemuCapsGet(caps, QEMU_CAPS_CHARDEV) ||
- !qemuCapsGet(caps, QEMU_CAPS_CCID_EMULATED)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_CHARDEV) ||
+ !virQEMUCapsGet(qemuCaps, QEMU_CAPS_CCID_EMULATED)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("this QEMU binary lacks smartcard host "
"mode support"));
break;
case VIR_DOMAIN_SMARTCARD_TYPE_HOST_CERTIFICATES:
- if (!qemuCapsGet(caps, QEMU_CAPS_CHARDEV) ||
- !qemuCapsGet(caps, QEMU_CAPS_CCID_EMULATED)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_CHARDEV) ||
+ !virQEMUCapsGet(qemuCaps, QEMU_CAPS_CCID_EMULATED)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("this QEMU binary lacks smartcard host "
"mode support"));
break;
case VIR_DOMAIN_SMARTCARD_TYPE_PASSTHROUGH:
- if (!qemuCapsGet(caps, QEMU_CAPS_CHARDEV) ||
- !qemuCapsGet(caps, QEMU_CAPS_CCID_PASSTHRU)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_CHARDEV) ||
+ !virQEMUCapsGet(qemuCaps, QEMU_CAPS_CCID_PASSTHRU)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("this QEMU binary lacks smartcard "
"passthrough mode support"));
virCommandAddArg(cmd, "-chardev");
if (!(devstr = qemuBuildChrChardevStr(&smartcard->data.passthru,
smartcard->info.alias,
- caps))) {
+ qemuCaps))) {
virBufferFreeAndReset(&opt);
goto error;
}
if (!def->nserials) {
/* If we have -device, then we set -nodefault already */
- if (!qemuCapsGet(caps, QEMU_CAPS_DEVICE))
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
virCommandAddArgList(cmd, "-serial", "none", NULL);
} else {
for (i = 0 ; i < def->nserials ; i++) {
char *devstr;
/* Use -chardev with -device if they are available */
- if (qemuCapsGet(caps, QEMU_CAPS_CHARDEV) &&
- qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_CHARDEV) &&
+ virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
virCommandAddArg(cmd, "-chardev");
if (!(devstr = qemuBuildChrChardevStr(&serial->source,
serial->info.alias,
- caps)))
+ qemuCaps)))
goto error;
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
virCommandAddArg(cmd, "-device");
- if (!(devstr = qemuBuildChrDeviceStr(serial, caps,
+ if (!(devstr = qemuBuildChrDeviceStr(serial, qemuCaps,
def->os.arch,
def->os.machine)))
goto error;
if (!def->nparallels) {
/* If we have -device, then we set -nodefault already */
- if (!qemuCapsGet(caps, QEMU_CAPS_DEVICE))
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
virCommandAddArgList(cmd, "-parallel", "none", NULL);
} else {
for (i = 0 ; i < def->nparallels ; i++) {
char *devstr;
/* Use -chardev with -device if they are available */
- if (qemuCapsGet(caps, QEMU_CAPS_CHARDEV) &&
- qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_CHARDEV) &&
+ virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
virCommandAddArg(cmd, "-chardev");
if (!(devstr = qemuBuildChrChardevStr(¶llel->source,
parallel->info.alias,
- caps)))
+ qemuCaps)))
goto error;
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
switch (channel->targetType) {
case VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_GUESTFWD:
- if (!qemuCapsGet(caps, QEMU_CAPS_CHARDEV) ||
- !qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_CHARDEV) ||
+ !virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("guestfwd requires QEMU to support -chardev & -device"));
goto error;
virCommandAddArg(cmd, "-chardev");
if (!(devstr = qemuBuildChrChardevStr(&channel->source,
channel->info.alias,
- caps)))
+ qemuCaps)))
goto error;
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
break;
case VIR_DOMAIN_CHR_CHANNEL_TARGET_TYPE_VIRTIO:
- if (!qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("virtio channel requires QEMU to support -device"));
goto error;
}
- if (qemuCapsGet(caps, QEMU_CAPS_DEVICE_SPICEVMC) &&
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_SPICEVMC) &&
channel->source.type == VIR_DOMAIN_CHR_TYPE_SPICEVMC) {
/* spicevmc was originally introduced via a -device
* with a backend internal to qemu; although we prefer
virCommandAddArg(cmd, "-chardev");
if (!(devstr = qemuBuildChrChardevStr(&channel->source,
channel->info.alias,
- caps)))
+ qemuCaps)))
goto error;
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
virCommandAddArg(cmd, "-device");
if (!(devstr = qemuBuildVirtioSerialPortDevStr(channel,
- caps)))
+ qemuCaps)))
goto error;
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
switch (console->targetType) {
case VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_SCLP:
case VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_SCLPLM:
- if (!qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("sclp console requires QEMU to support -device"));
goto error;
}
- if (!qemuCapsGet(caps, QEMU_CAPS_SCLP_S390)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_SCLP_S390)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("sclp console requires QEMU to support s390-sclp"));
goto error;
virCommandAddArg(cmd, "-chardev");
if (!(devstr = qemuBuildChrChardevStr(&console->source,
console->info.alias,
- caps)))
+ qemuCaps)))
goto error;
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
break;
case VIR_DOMAIN_CHR_CONSOLE_TARGET_TYPE_VIRTIO:
- if (!qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("virtio channel requires QEMU to support -device"));
goto error;
virCommandAddArg(cmd, "-chardev");
if (!(devstr = qemuBuildChrChardevStr(&console->source,
console->info.alias,
- caps)))
+ qemuCaps)))
goto error;
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
virCommandAddArg(cmd, "-device");
if (!(devstr = qemuBuildVirtioSerialPortDevStr(console,
- caps)))
+ qemuCaps)))
goto error;
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
virDomainInputDefPtr input = def->inputs[i];
if (input->bus == VIR_DOMAIN_INPUT_BUS_USB) {
- if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
char *optstr;
virCommandAddArg(cmd, "-device");
- if (!(optstr = qemuBuildUSBInputDevStr(input, caps)))
+ if (!(optstr = qemuBuildUSBInputDevStr(input, qemuCaps)))
goto error;
virCommandAddArg(cmd, optstr);
VIR_FREE(optstr);
break;
}
}
- if (!qemuCapsGet(caps, QEMU_CAPS_0_10) && sdl + vnc + spice > 1) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_0_10) && sdl + vnc + spice > 1) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("only 1 graphics device is supported"));
goto error;
}
for (i = 0 ; i < def->ngraphics ; ++i) {
- if (qemuBuildGraphicsCommandLine(cfg, cmd, def, caps,
+ if (qemuBuildGraphicsCommandLine(cfg, cmd, def, qemuCaps,
def->graphics[i]) < 0)
goto error;
}
if (def->nvideos > 0) {
int primaryVideoType = def->videos[0]->type;
- if (qemuCapsGet(caps, QEMU_CAPS_DEVICE_VIDEO_PRIMARY) &&
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VIDEO_PRIMARY) &&
((primaryVideoType == VIR_DOMAIN_VIDEO_TYPE_VGA &&
- qemuCapsGet(caps, QEMU_CAPS_DEVICE_VGA)) ||
+ virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VGA)) ||
(primaryVideoType == VIR_DOMAIN_VIDEO_TYPE_CIRRUS &&
- qemuCapsGet(caps, QEMU_CAPS_DEVICE_CIRRUS_VGA)) ||
+ virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_CIRRUS_VGA)) ||
(primaryVideoType == VIR_DOMAIN_VIDEO_TYPE_VMVGA &&
- qemuCapsGet(caps, QEMU_CAPS_DEVICE_VMWARE_SVGA)) ||
+ virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_VMWARE_SVGA)) ||
(primaryVideoType == VIR_DOMAIN_VIDEO_TYPE_QXL &&
- qemuCapsGet(caps, QEMU_CAPS_DEVICE_QXL_VGA)))
+ virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_QXL_VGA)))
) {
for (i = 0 ; i < def->nvideos ; i++) {
char *str;
virCommandAddArg(cmd, "-device");
- if (!(str = qemuBuildDeviceVideoStr(def->videos[i], caps, !i)))
+ if (!(str = qemuBuildDeviceVideoStr(def->videos[i], qemuCaps, !i)))
goto error;
virCommandAddArg(cmd, str);
VIR_FREE(str);
}
- } else if (qemuCapsGet(caps, QEMU_CAPS_VGA)) {
+ } else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_VGA)) {
if (primaryVideoType == VIR_DOMAIN_VIDEO_TYPE_XEN) {
/* nothing - vga has no effect on Xen pvfb */
} else {
if ((primaryVideoType == VIR_DOMAIN_VIDEO_TYPE_QXL) &&
- !qemuCapsGet(caps, QEMU_CAPS_VGA_QXL)) {
+ !virQEMUCapsGet(qemuCaps, QEMU_CAPS_VGA_QXL)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("This QEMU does not support QXL graphics adapters"));
goto error;
if (def->videos[0]->type == VIR_DOMAIN_VIDEO_TYPE_QXL &&
(def->videos[0]->vram || def->videos[0]->ram) &&
- qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
- const char *dev = (qemuCapsGet(caps, QEMU_CAPS_DEVICE_QXL_VGA)
+ virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
+ const char *dev = (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_QXL_VGA)
? "qxl-vga" : "qxl");
int ram = def->videos[0]->ram;
int vram = def->videos[0]->vram;
}
if (def->nvideos > 1) {
- if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
for (i = 1 ; i < def->nvideos ; i++) {
char *str;
if (def->videos[i]->type != VIR_DOMAIN_VIDEO_TYPE_QXL) {
virCommandAddArg(cmd, "-device");
- if (!(str = qemuBuildDeviceVideoStr(def->videos[i], caps, false)))
+ if (!(str = qemuBuildDeviceVideoStr(def->videos[i], qemuCaps, false)))
goto error;
virCommandAddArg(cmd, str);
} else {
/* If we have -device, then we set -nodefault already */
- if (!qemuCapsGet(caps, QEMU_CAPS_DEVICE) &&
- qemuCapsGet(caps, QEMU_CAPS_VGA) &&
- qemuCapsGet(caps, QEMU_CAPS_VGA_NONE))
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE) &&
+ virQEMUCapsGet(qemuCaps, QEMU_CAPS_VGA) &&
+ virQEMUCapsGet(qemuCaps, QEMU_CAPS_VGA_NONE))
virCommandAddArgList(cmd, "-vga", "none", NULL);
}
/* Add sound hardware */
if (def->nsounds) {
- if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
for (i = 0 ; i < def->nsounds ; i++) {
virDomainSoundDefPtr sound = def->sounds[i];
char *str = NULL;
virCommandAddArgList(cmd, "-soundhw", "pcspk", NULL);
} else {
virCommandAddArg(cmd, "-device");
- if (!(str = qemuBuildSoundDevStr(sound, caps)))
+ if (!(str = qemuBuildSoundDevStr(sound, qemuCaps)))
goto error;
virCommandAddArg(cmd, str);
for (ii = 0 ; ii < sound->ncodecs ; ii++) {
virCommandAddArg(cmd, "-device");
- if (!(codecstr = qemuBuildSoundCodecStr(sound, sound->codecs[ii], caps))) {
+ if (!(codecstr = qemuBuildSoundCodecStr(sound, sound->codecs[ii], qemuCaps))) {
goto error;
}
0
};
virCommandAddArg(cmd, "-device");
- if (!(codecstr = qemuBuildSoundCodecStr(sound, &codec, caps))) {
+ if (!(codecstr = qemuBuildSoundCodecStr(sound, &codec, qemuCaps))) {
goto error;
}
virDomainWatchdogDefPtr watchdog = def->watchdog;
char *optstr;
- if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
virCommandAddArg(cmd, "-device");
- optstr = qemuBuildWatchdogDevStr(watchdog, caps);
+ optstr = qemuBuildWatchdogDevStr(watchdog, qemuCaps);
if (!optstr)
goto error;
} else {
virCommandAddArg(cmd, "-chardev");
if (!(devstr = qemuBuildChrChardevStr(&redirdev->source.chr,
redirdev->info.alias,
- caps))) {
+ qemuCaps))) {
goto error;
}
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
- if (!qemuCapsGet(caps, QEMU_CAPS_DEVICE))
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE))
goto error;
virCommandAddArg(cmd, "-device");
- if (!(devstr = qemuBuildRedirdevDevStr(def, redirdev, caps)))
+ if (!(devstr = qemuBuildRedirdevDevStr(def, redirdev, qemuCaps)))
goto error;
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
goto error;
} else {
if (hostdev->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI &&
- !qemuCapsGet(caps, QEMU_CAPS_PCI_BOOTINDEX)) {
+ !virQEMUCapsGet(qemuCaps, QEMU_CAPS_PCI_BOOTINDEX)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("booting from assigned PCI devices is not"
" supported with this version of qemu"));
goto error;
}
if (hostdev->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB &&
- !qemuCapsGet(caps, QEMU_CAPS_USB_HOST_BOOTINDEX)) {
+ !virQEMUCapsGet(qemuCaps, QEMU_CAPS_USB_HOST_BOOTINDEX)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("booting from assigned USB devices is not"
" supported with this version of qemu"));
if (hostdev->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS &&
hostdev->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_USB) {
- if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
virCommandAddArg(cmd, "-device");
- if (!(devstr = qemuBuildUSBHostdevDevStr(hostdev, caps)))
+ if (!(devstr = qemuBuildUSBHostdevDevStr(hostdev, qemuCaps)))
goto error;
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
/* PCI */
if (hostdev->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS &&
hostdev->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI) {
- if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
char *configfd_name = NULL;
- if (qemuCapsGet(caps, QEMU_CAPS_PCI_CONFIGFD)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_PCI_CONFIGFD)) {
int configfd = qemuOpenPCIConfig(hostdev);
if (configfd >= 0) {
}
}
virCommandAddArg(cmd, "-device");
- devstr = qemuBuildPCIHostdevDevStr(hostdev, configfd_name, caps);
+ devstr = qemuBuildPCIHostdevDevStr(hostdev, configfd_name, qemuCaps);
VIR_FREE(configfd_name);
if (!devstr)
goto error;
virCommandAddArg(cmd, devstr);
VIR_FREE(devstr);
- } else if (qemuCapsGet(caps, QEMU_CAPS_PCIDEVICE)) {
+ } else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_PCIDEVICE)) {
virCommandAddArg(cmd, "-pcidevice");
if (!(devstr = qemuBuildPCIHostdevPCIDevStr(hostdev)))
goto error;
if (migrateFrom) {
virCommandAddArg(cmd, "-incoming");
if (STRPREFIX(migrateFrom, "tcp")) {
- if (!qemuCapsGet(caps, QEMU_CAPS_MIGRATE_QEMU_TCP)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_TCP)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("TCP migration is not supported with "
"this QEMU binary"));
}
virCommandAddArg(cmd, migrateFrom);
} else if (STREQ(migrateFrom, "stdio")) {
- if (qemuCapsGet(caps, QEMU_CAPS_MIGRATE_QEMU_FD)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_FD)) {
virCommandAddArgFormat(cmd, "fd:%d", migrateFd);
virCommandPreserveFD(cmd, migrateFd);
- } else if (qemuCapsGet(caps, QEMU_CAPS_MIGRATE_QEMU_EXEC)) {
+ } else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_EXEC)) {
virCommandAddArg(cmd, "exec:cat");
virCommandSetInputFD(cmd, migrateFd);
- } else if (qemuCapsGet(caps, QEMU_CAPS_MIGRATE_KVM_STDIO)) {
+ } else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_KVM_STDIO)) {
virCommandAddArg(cmd, migrateFrom);
virCommandSetInputFD(cmd, migrateFd);
} else {
goto error;
}
} else if (STRPREFIX(migrateFrom, "exec")) {
- if (!qemuCapsGet(caps, QEMU_CAPS_MIGRATE_QEMU_EXEC)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_EXEC)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("EXEC migration is not supported "
"with this QEMU binary"));
}
virCommandAddArg(cmd, migrateFrom);
} else if (STRPREFIX(migrateFrom, "fd")) {
- if (!qemuCapsGet(caps, QEMU_CAPS_MIGRATE_QEMU_FD)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_FD)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("FD migration is not supported "
"with this QEMU binary"));
virCommandAddArg(cmd, migrateFrom);
virCommandPreserveFD(cmd, migrateFd);
} else if (STRPREFIX(migrateFrom, "unix")) {
- if (!qemuCapsGet(caps, QEMU_CAPS_MIGRATE_QEMU_UNIX)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_MIGRATE_QEMU_UNIX)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED,
"%s", _("UNIX migration is not supported "
"with this QEMU binary"));
* NB: Earlier we declared that VirtIO balloon will always be in
* slot 0x3 on bus 0x0
*/
- if (qemuCapsGet(caps, QEMU_CAPS_VIRTIO_S390) && def->memballoon)
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_VIRTIO_S390) && def->memballoon)
def->memballoon->model = VIR_DOMAIN_MEMBALLOON_MODEL_NONE;
if (def->memballoon &&
virDomainMemballoonModelTypeToString(def->memballoon->model));
goto error;
}
- if (qemuCapsGet(caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE)) {
char *optstr;
virCommandAddArg(cmd, "-device");
- optstr = qemuBuildMemballoonDevStr(def->memballoon, caps);
+ optstr = qemuBuildMemballoonDevStr(def->memballoon, qemuCaps);
if (!optstr)
goto error;
virCommandAddArg(cmd, optstr);
VIR_FREE(optstr);
- } else if (qemuCapsGet(caps, QEMU_CAPS_BALLOON)) {
+ } else if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_BALLOON)) {
virCommandAddArgList(cmd, "-balloon", "virtio", NULL);
}
}
? qemucmd->env_value[i] : "");
}
- if (qemuCapsGet(caps, QEMU_CAPS_SECCOMP_SANDBOX)) {
+ if (virQEMUCapsGet(qemuCaps, QEMU_CAPS_SECCOMP_SANDBOX)) {
if (cfg->seccompSandbox == 0)
virCommandAddArgList(cmd, "-sandbox", "off", NULL);
else if (cfg->seccompSandbox > 0)
*/
char *
qemuBuildChrDeviceStr(virDomainChrDefPtr serial,
- qemuCapsPtr caps,
+ virQEMUCapsPtr qemuCaps,
virArch arch,
char *machine)
{
serial->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_SPAPRVIO) {
virBufferAsprintf(&cmd, "spapr-vty,chardev=char%s",
serial->info.alias);
- if (qemuBuildDeviceAddressStr(&cmd, &serial->info, caps) < 0)
+ if (qemuBuildDeviceAddressStr(&cmd, &serial->info, qemuCaps) < 0)
goto error;
}
} else {
serial->info.alias, serial->info.alias);
if (serial->targetType == VIR_DOMAIN_CHR_SERIAL_TARGET_TYPE_USB) {
- if (!qemuCapsGet(caps, QEMU_CAPS_DEVICE_USB_SERIAL)) {
+ if (!virQEMUCapsGet(qemuCaps, QEMU_CAPS_DEVICE_USB_SERIAL)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("usb-serial is not supported in this QEMU binary"));
goto error;
goto error;
}
- if (qemuBuildDeviceAddressStr(&cmd, &serial->info, caps) < 0)
+ if (qemuBuildDeviceAddressStr(&cmd, &serial->info, qemuCaps) < 0)
goto error;
}
}
* Will fail if not using the 'index' keyword
*/
static virDomainDiskDefPtr
-qemuParseCommandLineDisk(virCapsPtr caps,
+qemuParseCommandLineDisk(virCapsPtr qemuCaps,
const char *val,
int nvirtiodisk,
bool old_style_ceph_args)
else
def->dst[2] = 'a' + idx;
- if (virDomainDiskDefAssignAddress(caps, def) < 0) {
+ if (virDomainDiskDefAssignAddress(qemuCaps, def) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("invalid device name '%s'"), def->dst);
virDomainDiskDefFree(def);
* match up against. Horribly complicated stuff
*/
static virDomainNetDefPtr
-qemuParseCommandLineNet(virCapsPtr caps,
+qemuParseCommandLineNet(virCapsPtr qemuCaps,
const char *val,
int nnics,
const char **nics)
}
if (genmac)
- virCapabilitiesGenerateMac(caps, &def->mac);
+ virCapabilitiesGenerateMac(qemuCaps, &def->mac);
cleanup:
for (i = 0 ; i < nkeywords ; i++) {
* virDomainDefPtr representing these settings as closely
* as is practical. This is not an exact science....
*/
-virDomainDefPtr qemuParseCommandLine(virCapsPtr caps,
+virDomainDefPtr qemuParseCommandLine(virCapsPtr qemuCaps,
const char **progenv,
const char **progargv,
char **pidfile,
else
path = strstr(def->emulator, "qemu");
if (def->virtType == VIR_DOMAIN_VIRT_KVM)
- def->os.arch = caps->host.arch;
+ def->os.arch = qemuCaps->host.arch;
else if (path &&
STRPREFIX(path, "qemu-system-"))
def->os.arch = virArchFromString(path + strlen("qemu-system-"));
!disk->dst)
goto no_memory;
- if (virDomainDiskDefAssignAddress(caps, disk) < 0) {
+ if (virDomainDiskDefAssignAddress(qemuCaps, disk) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Cannot assign address for device name '%s'"),
disk->dst);
WANT_VALUE();
if (!STRPREFIX(val, "nic") && STRNEQ(val, "none")) {
virDomainNetDefPtr net;
- if (!(net = qemuParseCommandLineNet(caps, val, nnics, nics)))
+ if (!(net = qemuParseCommandLineNet(qemuCaps, val, nnics, nics)))
goto error;
if (VIR_REALLOC_N(def->nets, def->nnets+1) < 0) {
virDomainNetDefFree(net);
}
} else if (STREQ(arg, "-drive")) {
WANT_VALUE();
- if (!(disk = qemuParseCommandLineDisk(caps, val, nvirtiodisk,
+ if (!(disk = qemuParseCommandLineDisk(qemuCaps, val, nvirtiodisk,
ceph_args != NULL)))
goto error;
if (VIR_REALLOC_N(def->disks, def->ndisks+1) < 0)
if (!def->os.machine) {
const char *defaultMachine =
- virCapabilitiesDefaultGuestMachine(caps,
+ virCapabilitiesDefaultGuestMachine(qemuCaps,
def->os.type,
def->os.arch,
virDomainVirtTypeToString(def->virtType));
goto error;
if (cmd->num_args || cmd->num_env) {
- def->ns = caps->ns;
+ def->ns = qemuCaps->ns;
def->namespaceData = cmd;
}
else
}
-virDomainDefPtr qemuParseCommandLineString(virCapsPtr caps,
+virDomainDefPtr qemuParseCommandLineString(virCapsPtr qemuCaps,
const char *args,
char **pidfile,
virDomainChrSourceDefPtr *monConfig,
if (qemuStringToArgvEnv(args, &progenv, &progargv) < 0)
goto cleanup;
- def = qemuParseCommandLine(caps, progenv, progargv,
+ def = qemuParseCommandLine(qemuCaps, progenv, progargv,
pidfile, monConfig, monJSON);
cleanup:
return ret;
}
-virDomainDefPtr qemuParseCommandLinePid(virCapsPtr caps,
+virDomainDefPtr qemuParseCommandLinePid(virCapsPtr qemuCaps,
pid_t pid,
char **pidfile,
virDomainChrSourceDefPtr *monConfig,
qemuParseProcFileStrings(pid, "environ", &progenv) < 0)
goto cleanup;
- if (!(def = qemuParseCommandLine(caps, progenv, progargv,
+ if (!(def = qemuParseCommandLine(qemuCaps, progenv, progargv,
pidfile, monConfig, monJSON)))
goto cleanup;
virDomainDefPtr def,
virDomainChrSourceDefPtr monitor_chr,
bool monitor_json,
- qemuCapsPtr caps,
+ virQEMUCapsPtr qemuCaps,
const char *migrateFrom,
int migrateFd,
virDomainSnapshotObjPtr current_snapshot,
/* Generate string for arch-specific '-device' parameter */
char *
qemuBuildChrDeviceStr (virDomainChrDefPtr serial,
- qemuCapsPtr caps,
+ virQEMUCapsPtr qemuCaps,
virArch arch,
char *machine);
/* With vlan == -1, use netdev syntax, else old hostnet */
char * qemuBuildHostNetStr(virDomainNetDefPtr net,
virQEMUDriverPtr driver,
- qemuCapsPtr caps,
+ virQEMUCapsPtr qemuCaps,
char type_sep,
int vlan,
const char *tapfd,
char * qemuBuildNicDevStr(virDomainNetDefPtr net,
int vlan,
int bootindex,
- qemuCapsPtr caps);
+ virQEMUCapsPtr qemuCaps);
char *qemuDeviceDriveHostAlias(virDomainDiskDefPtr disk,
- qemuCapsPtr caps);
+ virQEMUCapsPtr qemuCaps);
/* Both legacy & current support */
char *qemuBuildDriveStr(virConnectPtr conn,
virDomainDiskDefPtr disk,
bool bootable,
- qemuCapsPtr caps);
+ virQEMUCapsPtr qemuCaps);
char *qemuBuildFSStr(virDomainFSDefPtr fs,
- qemuCapsPtr caps);
+ virQEMUCapsPtr qemuCaps);
/* Current, best practice */
char * qemuBuildDriveDevStr(virDomainDefPtr def,
virDomainDiskDefPtr disk,
int bootindex,
- qemuCapsPtr caps);
+ virQEMUCapsPtr qemuCaps);
char * qemuBuildFSDevStr(virDomainFSDefPtr fs,
- qemuCapsPtr caps);
+ virQEMUCapsPtr qemuCaps);
/* Current, best practice */
char * qemuBuildControllerDevStr(virDomainDefPtr domainDef,
virDomainControllerDefPtr def,
- qemuCapsPtr caps,
+ virQEMUCapsPtr qemuCaps,
int *nusbcontroller);
char * qemuBuildWatchdogDevStr(virDomainWatchdogDefPtr dev,
- qemuCapsPtr caps);
+ virQEMUCapsPtr qemuCaps);
char * qemuBuildMemballoonDevStr(virDomainMemballoonDefPtr dev,
- qemuCapsPtr caps);
+ virQEMUCapsPtr qemuCaps);
char * qemuBuildUSBInputDevStr(virDomainInputDefPtr dev,
- qemuCapsPtr caps);
+ virQEMUCapsPtr qemuCaps);
char * qemuBuildSoundDevStr(virDomainSoundDefPtr sound,
- qemuCapsPtr caps);
+ virQEMUCapsPtr qemuCaps);
/* Legacy, pre device support */
char * qemuBuildPCIHostdevPCIDevStr(virDomainHostdevDefPtr dev);
/* Current, best practice */
char * qemuBuildPCIHostdevDevStr(virDomainHostdevDefPtr dev,
const char *configfd,
- qemuCapsPtr caps);
+ virQEMUCapsPtr qemuCaps);
int qemuOpenPCIConfig(virDomainHostdevDefPtr dev);
char * qemuBuildUSBHostdevUsbDevStr(virDomainHostdevDefPtr dev);
/* Current, best practice */
char * qemuBuildUSBHostdevDevStr(virDomainHostdevDefPtr dev,
- qemuCapsPtr caps);
+ virQEMUCapsPtr qemuCaps);
-char * qemuBuildHubDevStr(virDomainHubDefPtr dev, qemuCapsPtr caps);
+char * qemuBuildHubDevStr(virDomainHubDefPtr dev, virQEMUCapsPtr qemuCaps);
char * qemuBuildRedirdevDevStr(virDomainDefPtr def,
virDomainRedirdevDefPtr dev,
- qemuCapsPtr caps);
+ virQEMUCapsPtr qemuCaps);
int qemuNetworkIfaceConnect(virDomainDefPtr def,
virConnectPtr conn,
virQEMUDriverPtr driver,
virDomainNetDefPtr net,
- qemuCapsPtr caps)
+ virQEMUCapsPtr qemuCaps)
ATTRIBUTE_NONNULL(2);
int qemuPhysIfaceConnect(virDomainDefPtr def,
virQEMUDriverPtr driver,
virDomainNetDefPtr net,
- qemuCapsPtr caps,
+ virQEMUCapsPtr qemuCaps,
enum virNetDevVPortProfileOp vmop);
int qemuOpenVhostNet(virDomainDefPtr def,
virDomainNetDefPtr net,
- qemuCapsPtr caps,
+ virQEMUCapsPtr qemuCaps,
int *vhostfd);
/*
* NB: def->name can be NULL upon return and the caller
* *must* decide how to fill in a name in this case
*/
-virDomainDefPtr qemuParseCommandLine(virCapsPtr caps,
+virDomainDefPtr qemuParseCommandLine(virCapsPtr qemuCaps,
const char **progenv,
const char **progargv,
char **pidfile,
virDomainChrSourceDefPtr *monConfig,
bool *monJSON);
-virDomainDefPtr qemuParseCommandLineString(virCapsPtr caps,
+virDomainDefPtr qemuParseCommandLineString(virCapsPtr qemuCaps,
const char *args,
char **pidfile,
virDomainChrSourceDefPtr *monConfig,
bool *monJSON);
-virDomainDefPtr qemuParseCommandLinePid(virCapsPtr caps,
+virDomainDefPtr qemuParseCommandLinePid(virCapsPtr qemuCaps,
pid_t pid,
char **pidfile,
virDomainChrSourceDefPtr *monConfig,
bool *monJSON);
int qemuDomainAssignAddresses(virDomainDefPtr def,
- qemuCapsPtr caps,
+ virQEMUCapsPtr qemuCaps,
virDomainObjPtr obj)
ATTRIBUTE_NONNULL(1) ATTRIBUTE_NONNULL(2);
int qemuDomainAssignSpaprVIOAddresses(virDomainDefPtr def,
- qemuCapsPtr caps);
+ virQEMUCapsPtr qemuCaps);
int qemuDomainAssignPCIAddresses(virDomainDefPtr def,
- qemuCapsPtr caps,
+ virQEMUCapsPtr qemuCaps,
virDomainObjPtr obj);
qemuDomainPCIAddressSetPtr qemuDomainPCIAddressSetCreate(virDomainDefPtr def);
int qemuDomainPCIAddressReserveFunction(qemuDomainPCIAddressSetPtr addrs,
void qemuDomainPCIAddressSetFree(qemuDomainPCIAddressSetPtr addrs);
int qemuAssignDevicePCISlots(virDomainDefPtr def,
- qemuCapsPtr caps,
+ virQEMUCapsPtr qemuCaps,
qemuDomainPCIAddressSetPtr addrs);
-int qemuAssignDeviceAliases(virDomainDefPtr def, qemuCapsPtr caps);
+int qemuAssignDeviceAliases(virDomainDefPtr def, virQEMUCapsPtr qemuCaps);
int qemuDomainNetVLAN(virDomainNetDefPtr def);
int qemuAssignDeviceNetAlias(virDomainDefPtr def, virDomainNetDefPtr net, int idx);
int qemuAssignDeviceDiskAlias(virDomainDefPtr vmdef,
virDomainDiskDefPtr def,
- qemuCapsPtr caps);
+ virQEMUCapsPtr qemuCaps);
int qemuAssignDeviceHostdevAlias(virDomainDefPtr def, virDomainHostdevDefPtr hostdev, int idx);
int qemuAssignDeviceControllerAlias(virDomainControllerDefPtr controller);
int qemuAssignDeviceRedirdevAlias(virDomainDefPtr def, virDomainRedirdevDefPtr redirdev, int idx);
virCapsPtr caps;
/* Immutable pointer, self-locking APIs */
- qemuCapsCachePtr capsCache;
+ virQEMUCapsCachePtr qemuCapsCache;
/* Immutable pointer, self-locking APIs */
virDomainEventStatePtr domainEventState;
{
qemuDomainObjPrivatePtr priv = data;
- virObjectUnref(priv->caps);
+ virObjectUnref(priv->qemuCaps);
qemuDomainPCIAddressSetFree(priv->pciaddrs);
virDomainChrSourceDefFree(priv->monConfig);
virBufferAddLit(buf, " </vcpus>\n");
}
- if (priv->caps) {
+ if (priv->qemuCaps) {
int i;
virBufferAddLit(buf, " <qemuCaps>\n");
for (i = 0 ; i < QEMU_CAPS_LAST ; i++) {
- if (qemuCapsGet(priv->caps, i)) {
+ if (virQEMUCapsGet(priv->qemuCaps, i)) {
virBufferAsprintf(buf, " <flag name='%s'/>\n",
- qemuCapsTypeToString(i));
+ virQEMUCapsTypeToString(i));
}
}
virBufferAddLit(buf, " </qemuCaps>\n");
char *tmp;
int n, i;
xmlNodePtr *nodes = NULL;
- qemuCapsPtr caps = NULL;
+ virQEMUCapsPtr qemuCaps = NULL;
if (VIR_ALLOC(priv->monConfig) < 0) {
virReportOOMError();
goto error;
}
if (n > 0) {
- if (!(caps = qemuCapsNew()))
+ if (!(qemuCaps = virQEMUCapsNew()))
goto error;
for (i = 0 ; i < n ; i++) {
char *str = virXMLPropString(nodes[i], "name");
if (str) {
- int flag = qemuCapsTypeFromString(str);
+ int flag = virQEMUCapsTypeFromString(str);
if (flag < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("Unknown qemu capabilities flag %s"), str);
goto error;
}
VIR_FREE(str);
- qemuCapsSet(caps, flag);
+ virQEMUCapsSet(qemuCaps, flag);
}
}
- priv->caps = caps;
+ priv->qemuCaps = qemuCaps;
}
VIR_FREE(nodes);
virDomainChrSourceDefFree(priv->monConfig);
priv->monConfig = NULL;
VIR_FREE(nodes);
- virObjectUnref(caps);
+ virObjectUnref(qemuCaps);
return -1;
}
qemuDomainPCIAddressSetPtr pciaddrs;
int persistentAddrs;
- qemuCapsPtr caps;
+ virQEMUCapsPtr qemuCaps;
char *lockState;
bool fakeReboot;
virQEMUDriverConfigPtr cfg = virQEMUDriverGetConfig(driver);
/* Basic host arch / guest machine capabilities */
- if (!(caps = qemuCapsInit(driver->capsCache))) {
+ if (!(caps = virQEMUCapsInit(driver->qemuCapsCache))) {
virReportOOMError();
virObjectUnref(cfg);
return NULL;
}
}
- qemu_driver->capsCache = qemuCapsCacheNew(cfg->libDir,
- cfg->user,
- cfg->group);
- if (!qemu_driver->capsCache)
+ qemu_driver->qemuCapsCache = virQEMUCapsCacheNew(cfg->libDir,
+ cfg->user,
+ cfg->group);
+ if (!qemu_driver->qemuCapsCache)
goto error;
if ((qemu_driver->caps = qemuCreateCapabilities(qemu_driver)) == NULL)
virObjectUnref(qemu_driver->activeUsbHostdevs);
virHashFree(qemu_driver->sharedDisks);
virObjectUnref(qemu_driver->caps);
- qemuCapsCacheFree(qemu_driver->capsCache);
+ virQEMUCapsCacheFree(qemu_driver->qemuCapsCache);
virObjectUnref(qemu_driver->domains);
virObjectUnref(qemu_driver->remotePorts);
unsigned int qemuVersion;
qemuDriverLock(driver);
- if (qemuCapsGetDefaultVersion(driver->caps,
- driver->capsCache,
- &qemuVersion) < 0)
+ if (virQEMUCapsGetDefaultVersion(driver->caps,
+ driver->qemuCapsCache,
+ &qemuVersion) < 0)
goto cleanup;
*version = qemuVersion;
static int
-qemuCanonicalizeMachine(virDomainDefPtr def, qemuCapsPtr caps)
+qemuCanonicalizeMachine(virDomainDefPtr def, virQEMUCapsPtr qemuCaps)
{
const char *canon;
- if (!(canon = qemuCapsGetCanonicalMachine(caps, def->os.machine)))
+ if (!(canon = virQEMUCapsGetCanonicalMachine(qemuCaps, def->os.machine)))
return 0;
if (STRNEQ(canon, def->os.machine)) {
virDomainEventPtr event = NULL;
virDomainEventPtr event2 = NULL;
unsigned int start_flags = VIR_QEMU_PROCESS_START_COLD;
- qemuCapsPtr caps = NULL;
+ virQEMUCapsPtr qemuCaps = NULL;
virCheckFlags(VIR_DOMAIN_START_PAUSED |
VIR_DOMAIN_START_AUTODESTROY, NULL);
if (virSecurityManagerVerify(driver->securityManager, def) < 0)
goto cleanup;
- if (!(caps = qemuCapsCacheLookup(driver->capsCache, def->emulator)))
+ if (!(qemuCaps = virQEMUCapsCacheLookup(driver->qemuCapsCache, def->emulator)))
goto cleanup;
- if (qemuCanonicalizeMachine(def, caps) < 0)
+ if (qemuCanonicalizeMachine(def, qemuCaps) < 0)
goto cleanup;
- if (qemuDomainAssignAddresses(def, caps, NULL) < 0)
+ if (qemuDomainAssignAddresses(def, qemuCaps, NULL) < 0)
goto cleanup;
if (!(vm = virDomainObjListAdd(driver->domains,
if (event2)
qemuDomainEventQueue(driver, event2);
}
- virObjectUnref(caps);
+ virObjectUnref(qemuCaps);
qemuDriverUnlock(driver);
return dom;
}
}
} else {
#if WITH_YAJL
- if (qemuCapsGet(priv->caps, QEMU_CAPS_MONITOR_JSON)) {
- if (!qemuCapsGet(priv->caps, QEMU_CAPS_NO_SHUTDOWN)) {
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_MONITOR_JSON)) {
+ if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_NO_SHUTDOWN)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("Reboot is not supported with this QEMU binary"));
goto cleanup;
if ((vm->def->memballoon != NULL) &&
(vm->def->memballoon->model == VIR_DOMAIN_MEMBALLOON_MODEL_NONE)) {
info->memory = vm->def->mem.max_balloon;
- } else if (qemuCapsGet(priv->caps, QEMU_CAPS_BALLOON_EVENT)) {
+ } else if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BALLOON_EVENT)) {
info->memory = vm->def->mem.cur_balloon;
} else if (qemuDomainJobAllowed(priv, QEMU_JOB_QUERY)) {
if (qemuDomainObjBeginJob(driver, vm, QEMU_JOB_QUERY) < 0)
qemuDomainObjPrivatePtr priv = vm->privateData;
int ret = -1;
- if (!qemuCapsGet(priv->caps, QEMU_CAPS_DUMP_GUEST_MEMORY)) {
+ if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DUMP_GUEST_MEMORY)) {
virReportError(VIR_ERR_NO_SUPPORT, "%s",
_("dump-guest-memory is not supported"));
return -1;
/* Refresh current memory based on balloon info if supported */
if ((vm->def->memballoon != NULL) &&
(vm->def->memballoon->model != VIR_DOMAIN_MEMBALLOON_MODEL_NONE) &&
- !qemuCapsGet(priv->caps, QEMU_CAPS_BALLOON_EVENT) &&
+ !virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BALLOON_EVENT) &&
(virDomainObjIsActive(vm))) {
/* Don't delay if someone's using the monitor, just use
* existing most recent data instead */
virQEMUDriverPtr driver = conn->privateData;
virDomainDefPtr def = NULL;
virDomainChrSourceDef monConfig;
- qemuCapsPtr caps = NULL;
+ virQEMUCapsPtr qemuCaps = NULL;
bool monitor_json = false;
virCommandPtr cmd = NULL;
char *ret = NULL;
if (!def)
goto cleanup;
- if (!(caps = qemuCapsCacheLookup(driver->capsCache, def->emulator)))
+ if (!(qemuCaps = virQEMUCapsCacheLookup(driver->qemuCapsCache, def->emulator)))
goto cleanup;
/* Since we're just exporting args, we can't do bridge/network/direct
net->model = model;
}
- monitor_json = qemuCapsGet(caps, QEMU_CAPS_MONITOR_JSON);
+ monitor_json = virQEMUCapsGet(qemuCaps, QEMU_CAPS_MONITOR_JSON);
if (qemuProcessPrepareMonitorChr(cfg, &monConfig, def->name) < 0)
goto cleanup;
- if (qemuAssignDeviceAliases(def, caps) < 0)
+ if (qemuAssignDeviceAliases(def, qemuCaps) < 0)
goto cleanup;
if (!(cmd = qemuBuildCommandLine(conn, driver, def,
- &monConfig, monitor_json, caps,
+ &monConfig, monitor_json, qemuCaps,
NULL, -1, NULL, VIR_NETDEV_VPORT_PROFILE_OP_NO_OP)))
goto cleanup;
cleanup:
qemuDriverUnlock(driver);
- virObjectUnref(caps);
+ virObjectUnref(qemuCaps);
virCommandFree(cmd);
virDomainDefFree(def);
virObjectUnref(cfg);
virDomainObjPtr vm = NULL;
virDomainPtr dom = NULL;
virDomainEventPtr event = NULL;
- qemuCapsPtr caps = NULL;
+ virQEMUCapsPtr qemuCaps = NULL;
virQEMUDriverConfigPtr cfg;
qemuDriverLock(driver);
if (virSecurityManagerVerify(driver->securityManager, def) < 0)
goto cleanup;
- if (!(caps = qemuCapsCacheLookup(driver->capsCache, def->emulator)))
+ if (!(qemuCaps = virQEMUCapsCacheLookup(driver->qemuCapsCache, def->emulator)))
goto cleanup;
- if (qemuCanonicalizeMachine(def, caps) < 0)
+ if (qemuCanonicalizeMachine(def, qemuCaps) < 0)
goto cleanup;
- if (qemuDomainAssignAddresses(def, caps, NULL) < 0)
+ if (qemuDomainAssignAddresses(def, qemuCaps, NULL) < 0)
goto cleanup;
if (!(vm = virDomainObjListAdd(driver->domains,
virObjectUnlock(vm);
if (event)
qemuDomainEventQueue(driver, event);
- virObjectUnref(caps);
+ virObjectUnref(qemuCaps);
qemuDriverUnlock(driver);
virObjectUnref(cfg);
return dom;
}
static int
-qemuDomainAttachDeviceConfig(qemuCapsPtr caps,
+qemuDomainAttachDeviceConfig(virQEMUCapsPtr qemuCaps,
virDomainDefPtr vmdef,
virDomainDeviceDefPtr dev)
{
if (disk->bus != VIR_DOMAIN_DISK_BUS_VIRTIO)
if (virDomainDefAddImplicitControllers(vmdef) < 0)
return -1;
- if (qemuDomainAssignAddresses(vmdef, caps, NULL) < 0)
+ if (qemuDomainAssignAddresses(vmdef, qemuCaps, NULL) < 0)
return -1;
break;
return -1;
}
dev->data.net = NULL;
- if (qemuDomainAssignAddresses(vmdef, caps, NULL) < 0)
+ if (qemuDomainAssignAddresses(vmdef, qemuCaps, NULL) < 0)
return -1;
break;
return -1;
}
dev->data.hostdev = NULL;
- if (qemuDomainAssignAddresses(vmdef, caps, NULL) < 0)
+ if (qemuDomainAssignAddresses(vmdef, qemuCaps, NULL) < 0)
return -1;
break;
return -1;
dev->data.controller = NULL;
- if (qemuDomainAssignAddresses(vmdef, caps, NULL) < 0)
+ if (qemuDomainAssignAddresses(vmdef, qemuCaps, NULL) < 0)
return -1;
break;
}
static int
-qemuDomainUpdateDeviceConfig(qemuCapsPtr caps,
+qemuDomainUpdateDeviceConfig(virQEMUCapsPtr qemuCaps,
virDomainDefPtr vmdef,
virDomainDeviceDefPtr dev)
{
vmdef->nets[pos] = net;
dev->data.net = NULL;
- if (qemuDomainAssignAddresses(vmdef, caps, NULL) < 0)
+ if (qemuDomainAssignAddresses(vmdef, qemuCaps, NULL) < 0)
return -1;
break;
bool force = (flags & VIR_DOMAIN_DEVICE_MODIFY_FORCE) != 0;
int ret = -1;
unsigned int affect;
- qemuCapsPtr caps = NULL;
+ virQEMUCapsPtr qemuCaps = NULL;
qemuDomainObjPrivatePtr priv;
virQEMUDriverConfigPtr cfg = NULL;
goto endjob;
}
- if (priv->caps)
- caps = virObjectRef(priv->caps);
- else if (!(caps = qemuCapsCacheLookup(driver->capsCache, vm->def->emulator)))
+ if (priv->qemuCaps)
+ qemuCaps = virObjectRef(priv->qemuCaps);
+ else if (!(qemuCaps = virQEMUCapsCacheLookup(driver->qemuCapsCache, vm->def->emulator)))
goto cleanup;
if (flags & VIR_DOMAIN_AFFECT_CONFIG) {
goto endjob;
switch (action) {
case QEMU_DEVICE_ATTACH:
- ret = qemuDomainAttachDeviceConfig(caps, vmdef, dev);
+ ret = qemuDomainAttachDeviceConfig(qemuCaps, vmdef, dev);
break;
case QEMU_DEVICE_DETACH:
ret = qemuDomainDetachDeviceConfig(vmdef, dev);
break;
case QEMU_DEVICE_UPDATE:
- ret = qemuDomainUpdateDeviceConfig(caps, vmdef, dev);
+ ret = qemuDomainUpdateDeviceConfig(qemuCaps, vmdef, dev);
break;
default:
virReportError(VIR_ERR_INTERNAL_ERROR,
vm = NULL;
cleanup:
- virObjectUnref(caps);
+ virObjectUnref(qemuCaps);
virDomainDefFree(vmdef);
if (dev != dev_copy)
virDomainDeviceDefFree(dev_copy);
qemuDomainObjPrivatePtr priv = vm->privateData;
if (def->state == VIR_DOMAIN_DISK_SNAPSHOT &&
- reuse && !qemuCapsGet(priv->caps, QEMU_CAPS_TRANSACTION)) {
+ reuse && !virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_TRANSACTION)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("reuse is not supported with this QEMU binary"));
goto cleanup;
if (def->state != VIR_DOMAIN_DISK_SNAPSHOT && active) {
if (external == 1 ||
- qemuCapsGet(priv->caps, QEMU_CAPS_TRANSACTION)) {
+ virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_TRANSACTION)) {
*flags |= VIR_DOMAIN_SNAPSHOT_CREATE_ATOMIC;
} else if (atomic && external > 1) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
}
/* 'cgroup' is still NULL if cgroups are disabled. */
- if (qemuCapsGet(priv->caps, QEMU_CAPS_TRANSACTION)) {
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_TRANSACTION)) {
if (!(actions = virJSONValueNewArray())) {
virReportOOMError();
goto cleanup;
}
- } else if (!qemuCapsGet(priv->caps, QEMU_CAPS_DISK_SNAPSHOT)) {
+ } else if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DISK_SNAPSHOT)) {
virReportError(VIR_ERR_OPERATION_UNSUPPORTED, "%s",
_("live disk snapshot not supported with this "
"QEMU binary"));
cleanup:
virCgroupFree(&cgroup);
- if (ret == 0 || !qemuCapsGet(priv->caps, QEMU_CAPS_TRANSACTION)) {
+ if (ret == 0 || !virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_TRANSACTION)) {
if (virDomainSaveStatus(driver->caps, cfg->stateDir, vm) < 0 ||
(persist && virDomainSaveConfig(cfg->configDir, vm->newDef) < 0))
ret = -1;
bool memory = snap->def->memory == VIR_DOMAIN_SNAPSHOT_LOCATION_EXTERNAL;
bool memory_unlink = false;
bool atomic = !!(flags & VIR_DOMAIN_SNAPSHOT_CREATE_ATOMIC);
- bool transaction = qemuCapsGet(priv->caps, QEMU_CAPS_TRANSACTION);
+ bool transaction = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_TRANSACTION);
int thaw = 0; /* 1 if freeze succeeded, -1 if freeze failed */
bool pmsuspended = false;
bool monJSON = false;
pid_t pid = pid_value;
char *pidfile = NULL;
- qemuCapsPtr caps = NULL;
+ virQEMUCapsPtr qemuCaps = NULL;
virCheckFlags(0, NULL);
goto cleanup;
}
- if (!(caps = qemuCapsCacheLookup(driver->capsCache, def->emulator)))
+ if (!(qemuCaps = virQEMUCapsCacheLookup(driver->qemuCapsCache, def->emulator)))
goto cleanup;
- if (qemuCanonicalizeMachine(def, caps) < 0)
+ if (qemuCanonicalizeMachine(def, qemuCaps) < 0)
goto cleanup;
- if (qemuDomainAssignAddresses(def, caps, NULL) < 0)
+ if (qemuDomainAssignAddresses(def, qemuCaps, NULL) < 0)
goto cleanup;
if (!(vm = virDomainObjListAdd(driver->domains,
cleanup:
virDomainDefFree(def);
- virObjectUnref(caps);
+ virObjectUnref(qemuCaps);
virDomainChrSourceDefFree(monConfig);
if (vm)
virObjectUnlock(vm);
}
priv = vm->privateData;
- if (qemuCapsGet(priv->caps, QEMU_CAPS_BLOCKJOB_ASYNC)) {
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKJOB_ASYNC)) {
async = true;
- } else if (!qemuCapsGet(priv->caps, QEMU_CAPS_BLOCKJOB_SYNC)) {
+ } else if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKJOB_SYNC)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("block jobs not supported with this QEMU binary"));
goto cleanup;
goto cleanup;
}
- if (!(qemuCapsGet(priv->caps, QEMU_CAPS_DRIVE_MIRROR) &&
- qemuCapsGet(priv->caps, QEMU_CAPS_BLOCKJOB_ASYNC))) {
+ if (!(virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DRIVE_MIRROR) &&
+ virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCKJOB_ASYNC))) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("block copy is not supported with this QEMU binary"));
goto cleanup;
"%s", _("domain is not running"));
goto endjob;
}
- if (!qemuCapsGet(priv->caps, QEMU_CAPS_BLOCK_COMMIT)) {
+ if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_BLOCK_COMMIT)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("online commit not supported with this QEMU binary"));
goto endjob;
priv = vm->privateData;
cfg = virQEMUDriverGetConfig(driver);
- if (!qemuCapsGet(priv->caps, QEMU_CAPS_DRIVE_IOTUNE)) {
+ if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DRIVE_IOTUNE)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("block I/O throttling not supported with this "
"QEMU binary"));
goto cleanup;
}
- if (!qemuCapsGet(priv->caps, QEMU_CAPS_WAKEUP) &&
+ if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_WAKEUP) &&
(target == VIR_NODE_SUSPEND_TARGET_MEM ||
target == VIR_NODE_SUSPEND_TARGET_HYBRID)) {
virReportError(VIR_ERR_ARGUMENT_UNSUPPORTED, "%s",
priv = vm->privateData;
- if (!qemuCapsGet(priv->caps, QEMU_CAPS_WAKEUP)) {
+ if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_WAKEUP)) {
virReportError(VIR_ERR_OPERATION_INVALID, "%s",
_("Unable to wake up domain due to "
"missing system_wakeup monitor command"));
goto cleanup;
}
- if (!(driveAlias = qemuDeviceDriveHostAlias(origdisk, priv->caps)))
+ if (!(driveAlias = qemuDeviceDriveHostAlias(origdisk, priv->qemuCaps)))
goto error;
qemuDomainObjEnterMonitorWithDriver(driver, vm);
goto cleanup;
}
- if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
if (qemuDomainPCIAddressEnsureAddr(priv->pciaddrs, &disk->info) < 0)
goto error;
releaseaddr = true;
- if (qemuAssignDeviceDiskAlias(vm->def, disk, priv->caps) < 0)
+ if (qemuAssignDeviceDiskAlias(vm->def, disk, priv->qemuCaps) < 0)
goto error;
- if (!(drivestr = qemuBuildDriveStr(conn, disk, false, priv->caps)))
+ if (!(drivestr = qemuBuildDriveStr(conn, disk, false, priv->qemuCaps)))
goto error;
- if (!(devstr = qemuBuildDriveDevStr(NULL, disk, 0, priv->caps)))
+ if (!(devstr = qemuBuildDriveDevStr(NULL, disk, 0, priv->qemuCaps)))
goto error;
}
}
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
ret = qemuMonitorAddDrive(priv->mon, drivestr);
if (ret == 0) {
ret = qemuMonitorAddDevice(priv->mon, devstr);
return ret;
error:
- if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE) &&
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
(disk->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) &&
releaseaddr &&
qemuDomainPCIAddressReleaseSlot(priv->pciaddrs,
return -1;
}
- if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
if (qemuDomainPCIAddressEnsureAddr(priv->pciaddrs, &controller->info) < 0)
goto cleanup;
releaseaddr = true;
if (controller->type == VIR_DOMAIN_CONTROLLER_TYPE_USB &&
controller->model == -1 &&
- !qemuCapsGet(priv->caps, QEMU_CAPS_PIIX3_USB_UHCI)) {
+ !virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_PIIX3_USB_UHCI)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("USB controller hotplug unsupported in this QEMU binary"));
goto cleanup;
}
- if (!(devstr = qemuBuildControllerDevStr(vm->def, controller, priv->caps, NULL))) {
+ if (!(devstr = qemuBuildControllerDevStr(vm->def, controller, priv->qemuCaps, NULL))) {
goto cleanup;
}
}
}
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
ret = qemuMonitorAddDevice(priv->mon, devstr);
} else {
ret = qemuMonitorAttachPCIDiskController(priv->mon,
cleanup:
if ((ret != 0) &&
- qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE) &&
+ virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
(controller->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) &&
releaseaddr &&
qemuDomainPCIAddressReleaseSlot(priv->pciaddrs,
goto error;
}
- if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
- if (qemuAssignDeviceDiskAlias(vm->def, disk, priv->caps) < 0)
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuAssignDeviceDiskAlias(vm->def, disk, priv->qemuCaps) < 0)
goto error;
- if (!(devstr = qemuBuildDriveDevStr(vm->def, disk, 0, priv->caps)))
+ if (!(devstr = qemuBuildDriveDevStr(vm->def, disk, 0, priv->qemuCaps)))
goto error;
}
- if (!(drivestr = qemuBuildDriveStr(conn, disk, false, priv->caps)))
+ if (!(drivestr = qemuBuildDriveStr(conn, disk, false, priv->qemuCaps)))
goto error;
for (i = 0 ; i <= disk->info.addr.drive.controller ; i++) {
}
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
ret = qemuMonitorAddDrive(priv->mon, drivestr);
if (ret == 0) {
ret = qemuMonitorAddDevice(priv->mon, devstr);
goto error;
}
- if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
- if (qemuAssignDeviceDiskAlias(vm->def, disk, priv->caps) < 0)
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (qemuAssignDeviceDiskAlias(vm->def, disk, priv->qemuCaps) < 0)
goto error;
- if (!(drivestr = qemuBuildDriveStr(conn, disk, false, priv->caps)))
+ if (!(drivestr = qemuBuildDriveStr(conn, disk, false, priv->qemuCaps)))
goto error;
- if (!(devstr = qemuBuildDriveDevStr(NULL, disk, 0, priv->caps)))
+ if (!(devstr = qemuBuildDriveDevStr(NULL, disk, 0, priv->qemuCaps)))
goto error;
}
}
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
ret = qemuMonitorAddDrive(priv->mon, drivestr);
if (ret == 0) {
ret = qemuMonitorAddDevice(priv->mon, devstr);
goto cleanup;
}
- if (!qemuCapsGet(priv->caps, QEMU_CAPS_HOST_NET_ADD)) {
+ if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_HOST_NET_ADD)) {
virReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
_("installed qemu version does not support host_net_add"));
goto cleanup;
*/
if (actualType == VIR_DOMAIN_NET_TYPE_NETWORK ||
cfg->privileged ||
- (!qemuCapsGet(priv->caps, QEMU_CAPS_NETDEV_BRIDGE))) {
+ (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV_BRIDGE))) {
if ((tapfd = qemuNetworkIfaceConnect(vm->def, conn, driver, net,
- priv->caps)) < 0)
+ priv->qemuCaps)) < 0)
goto cleanup;
iface_connected = true;
- if (qemuOpenVhostNet(vm->def, net, priv->caps, &vhostfd) < 0)
+ if (qemuOpenVhostNet(vm->def, net, priv->qemuCaps, &vhostfd) < 0)
goto cleanup;
}
} else if (actualType == VIR_DOMAIN_NET_TYPE_DIRECT) {
if ((tapfd = qemuPhysIfaceConnect(vm->def, driver, net,
- priv->caps,
+ priv->qemuCaps,
VIR_NETDEV_VPORT_PROFILE_OP_CREATE)) < 0)
goto cleanup;
iface_connected = true;
- if (qemuOpenVhostNet(vm->def, net, priv->caps, &vhostfd) < 0)
+ if (qemuOpenVhostNet(vm->def, net, priv->qemuCaps, &vhostfd) < 0)
goto cleanup;
}
- if (qemuCapsGet(priv->caps, QEMU_CAPS_NET_NAME) ||
- qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_NET_NAME) ||
+ virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
if (qemuAssignDeviceNetAlias(vm->def, net, -1) < 0)
goto cleanup;
}
- if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE) &&
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
qemuDomainPCIAddressEnsureAddr(priv->pciaddrs, &net->info) < 0)
goto cleanup;
releaseaddr = true;
- if (qemuCapsGet(priv->caps, QEMU_CAPS_NETDEV) &&
- qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV) &&
+ virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
vlan = -1;
} else {
vlan = qemuDomainNetVLAN(net);
goto no_memory;
}
- if (qemuCapsGet(priv->caps, QEMU_CAPS_NETDEV) &&
- qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
- if (!(netstr = qemuBuildHostNetStr(net, driver, priv->caps,
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV) &&
+ virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (!(netstr = qemuBuildHostNetStr(net, driver, priv->qemuCaps,
',', -1, tapfd_name,
vhostfd_name)))
goto cleanup;
} else {
- if (!(netstr = qemuBuildHostNetStr(net, driver, priv->caps,
+ if (!(netstr = qemuBuildHostNetStr(net, driver, priv->qemuCaps,
' ', vlan, tapfd_name,
vhostfd_name)))
goto cleanup;
}
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->caps, QEMU_CAPS_NETDEV) &&
- qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV) &&
+ virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
if (qemuMonitorAddNetdev(priv->mon, netstr, tapfd, tapfd_name,
vhostfd, vhostfd_name) < 0) {
qemuDomainObjExitMonitorWithDriver(driver, vm);
goto cleanup;
}
- if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
- if (!(nicstr = qemuBuildNicDevStr(net, vlan, 0, priv->caps)))
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
+ if (!(nicstr = qemuBuildNicDevStr(net, vlan, 0, priv->qemuCaps)))
goto try_remove;
} else {
if (!(nicstr = qemuBuildNicStr(net, NULL, vlan)))
}
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
if (qemuMonitorAddDevice(priv->mon, nicstr) < 0) {
qemuDomainObjExitMonitorWithDriver(driver, vm);
virDomainAuditNet(vm, NULL, net, "attach", false);
} else {
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->caps, QEMU_CAPS_NETDEV)) {
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV)) {
if (qemuMonitorSetLink(priv->mon, net->info.alias, VIR_DOMAIN_NET_INTERFACE_LINK_STATE_DOWN) < 0) {
qemuDomainObjExitMonitorWithDriver(driver, vm);
virDomainAuditNet(vm, NULL, net, "attach", false);
if (!ret) {
vm->def->nets[vm->def->nnets++] = net;
} else {
- if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE) &&
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
(net->info.type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) &&
releaseaddr &&
qemuDomainPCIAddressReleaseSlot(priv->pciaddrs,
goto cleanup;
if (vlan < 0) {
- if (qemuCapsGet(priv->caps, QEMU_CAPS_NETDEV) &&
- qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV) &&
+ virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
char *netdev_name;
if (virAsprintf(&netdev_name, "host%s", net->info.alias) < 0)
goto no_memory;
&hostdev, 1) < 0)
return -1;
- if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
if (qemuAssignDeviceHostdevAlias(vm->def, hostdev, -1) < 0)
goto error;
if (qemuDomainPCIAddressEnsureAddr(priv->pciaddrs, hostdev->info) < 0)
goto error;
releaseaddr = true;
- if (qemuCapsGet(priv->caps, QEMU_CAPS_PCI_CONFIGFD)) {
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_PCI_CONFIGFD)) {
configfd = qemuOpenPCIConfig(hostdev);
if (configfd >= 0) {
if (virAsprintf(&configfd_name, "fd-%s",
}
if (!(devstr = qemuBuildPCIHostdevDevStr(hostdev, configfd_name,
- priv->caps)))
+ priv->qemuCaps)))
goto error;
qemuDomainObjEnterMonitorWithDriver(driver, vm);
return 0;
error:
- if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE) &&
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
(hostdev->info->type == VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI) &&
releaseaddr &&
qemuDomainPCIAddressReleaseSlot(priv->pciaddrs,
virDomainDefPtr def = vm->def;
char *devstr = NULL;
- if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
if (qemuAssignDeviceRedirdevAlias(vm->def, redirdev, -1) < 0)
goto error;
- if (!(devstr = qemuBuildRedirdevDevStr(def, redirdev, priv->caps)))
+ if (!(devstr = qemuBuildRedirdevDevStr(def, redirdev, priv->qemuCaps)))
goto error;
}
}
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE))
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE))
ret = qemuMonitorAddDevice(priv->mon, devstr);
else
goto error;
qemuDomainObjPrivatePtr priv = vm->privateData;
char *devstr = NULL;
- if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
if (qemuAssignDeviceHostdevAlias(vm->def, hostdev, -1) < 0)
goto error;
- if (!(devstr = qemuBuildUSBHostdevDevStr(hostdev, priv->caps)))
+ if (!(devstr = qemuBuildUSBHostdevDevStr(hostdev, priv->qemuCaps)))
goto error;
}
}
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE))
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE))
ret = qemuMonitorAddDevice(priv->mon, devstr);
else
ret = qemuMonitorAddUSBDeviceExact(priv->mon,
}
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
if (qemuMonitorDelDevice(priv->mon, detach->info.alias) < 0) {
qemuDomainObjExitMonitorWithDriver(driver, vm);
virDomainAuditDisk(vm, detach->src, NULL, "detach", false);
virDomainAuditDisk(vm, detach->src, NULL, "detach", true);
- if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE) &&
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
qemuDomainPCIAddressReleaseSlot(priv->pciaddrs,
detach->info.addr.pci.slot) < 0)
VIR_WARN("Unable to release PCI address on %s", dev->data.disk->src);
goto cleanup;
}
- if (!qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
+ if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
virReportError(VIR_ERR_OPERATION_FAILED,
_("Underlying qemu does not support %s disk removal"),
virDomainDiskBusTypeToString(dev->data.disk->bus));
goto cleanup;
}
- if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
if (qemuAssignDeviceControllerAlias(detach) < 0)
goto cleanup;
}
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
if (qemuMonitorDelDevice(priv->mon, detach->info.alias)) {
qemuDomainObjExitMonitorWithDriver(driver, vm);
goto cleanup;
virDomainControllerRemove(vm->def, idx);
virDomainControllerDefFree(detach);
- if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE) &&
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
qemuDomainPCIAddressReleaseSlot(priv->pciaddrs,
detach->info.addr.pci.slot) < 0)
VIR_WARN("Unable to release PCI address on controller");
}
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
rv = qemuMonitorDelDevice(priv->mon, detach->info->alias);
} else {
rv = qemuMonitorRemovePCIDevice(priv->mon, &detach->info->addr.pci);
virObjectUnlock(driver->activePciHostdevs);
virObjectUnlock(driver->inactivePciHostdevs);
- if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE) &&
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
qemuDomainPCIAddressReleaseSlot(priv->pciaddrs,
detach->info->addr.pci.slot) < 0)
VIR_WARN("Unable to release PCI address on host device");
return -1;
}
- if (!qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
+ if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
virReportError(VIR_ERR_OPERATION_FAILED,
"%s", _("device cannot be detached with this QEMU version"));
return -1;
}
qemuDomainObjEnterMonitorWithDriver(driver, vm);
- if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
if (qemuMonitorDelDevice(priv->mon, detach->info.alias) < 0) {
qemuDomainObjExitMonitorWithDriver(driver, vm);
virDomainAuditNet(vm, detach, NULL, "detach", false);
}
}
- if (qemuCapsGet(priv->caps, QEMU_CAPS_NETDEV) &&
- qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV) &&
+ virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
if (qemuMonitorRemoveNetdev(priv->mon, hostnet_name) < 0) {
qemuDomainObjExitMonitorWithDriver(driver, vm);
virDomainAuditNet(vm, detach, NULL, "detach", false);
virDomainAuditNet(vm, detach, NULL, "detach", true);
- if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE) &&
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE) &&
qemuDomainPCIAddressReleaseSlot(priv->pciaddrs,
detach->info.addr.pci.slot) < 0)
VIR_WARN("Unable to release PCI address on NIC");
* migration finish until SPICE server transfers its data */
if (vm->def->ngraphics == 1 &&
vm->def->graphics[0]->type == VIR_DOMAIN_GRAPHICS_TYPE_SPICE &&
- qemuCapsGet(priv->caps, QEMU_CAPS_SEAMLESS_MIGRATION))
+ virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_SEAMLESS_MIGRATION))
wait_for_spice = true;
ret = qemuDomainObjEnterMonitorAsync(driver, vm, asyncJob);
break;
case MIGRATION_DEST_UNIX:
- if (qemuCapsGet(priv->caps, QEMU_CAPS_MIGRATE_QEMU_UNIX)) {
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATE_QEMU_UNIX)) {
ret = qemuMonitorMigrateToUnix(priv->mon, migrate_flags,
spec->dest.unix_socket.file);
} else {
if (!uribits)
return -1;
- if (qemuCapsGet(priv->caps, QEMU_CAPS_MIGRATE_QEMU_FD))
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATE_QEMU_FD))
spec.destType = MIGRATION_DEST_CONNECT_HOST;
else
spec.destType = MIGRATION_DEST_HOST;
driver, vm, st, NULLSTR(cookiein), cookieinlen,
cookieout, cookieoutlen, flags, resource);
- if (!qemuCapsGet(priv->caps, QEMU_CAPS_MIGRATE_QEMU_FD) &&
- !qemuCapsGet(priv->caps, QEMU_CAPS_MIGRATE_QEMU_UNIX) &&
- !qemuCapsGet(priv->caps, QEMU_CAPS_MIGRATE_QEMU_EXEC)) {
+ if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATE_QEMU_FD) &&
+ !virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATE_QEMU_UNIX) &&
+ !virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATE_QEMU_EXEC)) {
virReportError(VIR_ERR_OPERATION_FAILED, "%s",
_("Source qemu is too old to support tunnelled migration"));
virObjectUnref(cfg);
spec.fwdType = MIGRATION_FWD_STREAM;
spec.fwd.stream = st;
- if (qemuCapsGet(priv->caps, QEMU_CAPS_MIGRATE_QEMU_FD)) {
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATE_QEMU_FD)) {
int fds[2];
spec.destType = MIGRATION_DEST_FD;
qemuDomainObjExitMonitorWithDriver(driver, vm);
}
- if (qemuCapsGet(priv->caps, QEMU_CAPS_MIGRATE_QEMU_FD) &&
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATE_QEMU_FD) &&
(!compressor || pipe(pipeFD) == 0)) {
/* All right! We can use fd migration, which means that qemu
* doesn't have to open() the file, so while we still have to
if (!compressor) {
const char *args[] = { "cat", NULL };
- if (qemuCapsGet(priv->caps, QEMU_CAPS_MIGRATE_QEMU_FD) &&
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_MIGRATE_QEMU_FD) &&
priv->monConfig->type == VIR_DOMAIN_CHR_TYPE_UNIX) {
rc = qemuMonitorMigrateToFd(priv->mon,
QEMU_MONITOR_MIGRATE_BACKGROUND,
qemuDomainObjEnterMonitorWithDriver(driver, vm);
ret = qemuMonitorSetCapabilities(priv->mon);
if (ret == 0 &&
- qemuCapsGet(priv->caps, QEMU_CAPS_MONITOR_JSON))
- ret = qemuCapsProbeQMP(priv->caps, priv->mon);
+ virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_MONITOR_JSON))
+ ret = virQEMUCapsProbeQMP(priv->qemuCaps, priv->mon);
qemuDomainObjExitMonitorWithDriver(driver, vm);
error:
static int
qemuProcessFindCharDevicePTYsMonitor(virDomainObjPtr vm,
- qemuCapsPtr caps,
+ virQEMUCapsPtr qemuCaps,
virHashTablePtr paths)
{
- bool chardevfmt = qemuCapsGet(caps, QEMU_CAPS_CHARDEV);
+ bool chardevfmt = virQEMUCapsGet(qemuCaps, QEMU_CAPS_CHARDEV);
int i = 0;
if (qemuProcessLookupPTYs(vm->def->serials, vm->def->nserials,
static int
qemuProcessWaitForMonitor(virQEMUDriverPtr driver,
virDomainObjPtr vm,
- qemuCapsPtr caps,
+ virQEMUCapsPtr qemuCaps,
off_t pos)
{
char *buf = NULL;
virHashTablePtr paths = NULL;
qemuDomainObjPrivatePtr priv;
- if (!qemuCapsUsedQMP(caps) && pos != -1) {
+ if (!virQEMUCapsUsedQMP(qemuCaps) && pos != -1) {
if ((logfd = qemuDomainOpenLog(driver, vm, pos)) < 0)
return -1;
VIR_DEBUG("qemuMonitorGetPtyPaths returned %i", ret);
if (ret == 0)
- ret = qemuProcessFindCharDevicePTYsMonitor(vm, caps, paths);
+ ret = qemuProcessFindCharDevicePTYsMonitor(vm, qemuCaps, paths);
cleanup:
virHashFree(paths);
if (pos != -1 && kill(vm->pid, 0) == -1 && errno == ESRCH) {
/* VM is dead, any other error raised in the interim is probably
* not as important as the qemu cmdline output */
- if (qemuCapsUsedQMP(caps)) {
+ if (virQEMUCapsUsedQMP(qemuCaps)) {
if ((logfd = qemuDomainOpenLog(driver, vm, pos)) < 0)
return -1;
if (def->nets[i]->linkstate == VIR_DOMAIN_NET_INTERFACE_LINK_STATE_DOWN) {
VIR_DEBUG("Setting link state: %s", def->nets[i]->info.alias);
- if (!qemuCapsGet(priv->caps, QEMU_CAPS_NETDEV)) {
+ if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_NETDEV)) {
virReportError(VIR_ERR_NO_SUPPORT, "%s",
_("Setting of link state is not supported by this qemu"));
return -1;
if (ret < 0)
goto cleanup;
- if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
for (i = 0 ; i < vm->def->ndisks ; i++) {
char *secret;
size_t secretLen;
/* If upgrading from old libvirtd we won't have found any
* caps in the domain status, so re-query them
*/
- if (!priv->caps &&
- !(priv->caps = qemuCapsCacheLookupCopy(driver->capsCache,
- obj->def->emulator)))
+ if (!priv->qemuCaps &&
+ !(priv->qemuCaps = virQEMUCapsCacheLookupCopy(driver->qemuCapsCache,
+ obj->def->emulator)))
goto error;
/* In case the domain shutdown while we were not running,
* we need to finish the shutdown process. And we need to do it after
- * we have qemuCaps filled in.
+ * we have virQEMUCaps filled in.
*/
if (state == VIR_DOMAIN_SHUTDOWN ||
(state == VIR_DOMAIN_PAUSED &&
goto endjob;
}
- if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE))
- if ((qemuDomainAssignAddresses(obj->def, priv->caps, obj)) < 0)
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE))
+ if ((qemuDomainAssignAddresses(obj->def, priv->qemuCaps, obj)) < 0)
goto error;
if (virSecurityManagerReserveLabel(driver->securityManager, obj->def, obj->pid) < 0)
* to remove danger of it ending up running twice if
* user tries to start it again later
*/
- if (qemuCapsGet(priv->caps, QEMU_CAPS_NO_SHUTDOWN)) {
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_NO_SHUTDOWN)) {
/* If we couldn't get the monitor and qemu supports
* no-shutdown, we can safely say that the domain
* crashed ... */
}
VIR_DEBUG("Determining emulator version");
- virObjectUnref(priv->caps);
- if (!(priv->caps = qemuCapsCacheLookupCopy(driver->capsCache,
- vm->def->emulator)))
+ virObjectUnref(priv->qemuCaps);
+ if (!(priv->qemuCaps = virQEMUCapsCacheLookupCopy(driver->qemuCapsCache,
+ vm->def->emulator)))
goto cleanup;
- if (qemuAssignDeviceAliases(vm->def, priv->caps) < 0)
+ if (qemuAssignDeviceAliases(vm->def, priv->qemuCaps) < 0)
goto cleanup;
VIR_DEBUG("Checking for CDROM and floppy presence");
if (qemuProcessPrepareMonitorChr(cfg, priv->monConfig, vm->def->name) < 0)
goto cleanup;
- if (qemuCapsGet(priv->caps, QEMU_CAPS_MONITOR_JSON))
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_MONITOR_JSON))
priv->monJSON = 1;
else
priv->monJSON = 0;
* we also need to populate the PCi address set cache for later
* use in hotplug
*/
- if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
VIR_DEBUG("Assigning domain PCI addresses");
- if ((qemuDomainAssignAddresses(vm->def, priv->caps, vm)) < 0)
+ if ((qemuDomainAssignAddresses(vm->def, priv->qemuCaps, vm)) < 0)
goto cleanup;
}
VIR_DEBUG("Building emulator command line");
if (!(cmd = qemuBuildCommandLine(conn, driver, vm->def, priv->monConfig,
- priv->monJSON != 0, priv->caps,
+ priv->monJSON != 0, priv->qemuCaps,
migrateFrom, stdin_fd, snapshot, vmop)))
goto cleanup;
goto cleanup;
VIR_DEBUG("Waiting for monitor to show up");
- if (qemuProcessWaitForMonitor(driver, vm, priv->caps, pos) < 0)
+ if (qemuProcessWaitForMonitor(driver, vm, priv->qemuCaps, pos) < 0)
goto cleanup;
/* Failure to connect to agent shouldn't be fatal */
/* If we have -device, then addresses are assigned explicitly.
* If not, then we have to detect dynamic ones here */
- if (!qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
+ if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
VIR_DEBUG("Determining domain device PCI addresses");
if (qemuProcessInitPCIAddresses(driver, vm) < 0)
goto cleanup;
virDomainObjSetState(vm, VIR_DOMAIN_SHUTOFF, reason);
VIR_FREE(priv->vcpupids);
priv->nvcpupids = 0;
- virObjectUnref(priv->caps);
- priv->caps = NULL;
+ virObjectUnref(priv->qemuCaps);
+ priv->qemuCaps = NULL;
VIR_FREE(priv->pidfile);
/* The "release" hook cleans up additional resources */
goto cleanup;
VIR_DEBUG("Determining emulator version");
- virObjectUnref(priv->caps);
- if (!(priv->caps = qemuCapsCacheLookupCopy(driver->capsCache,
- vm->def->emulator)))
+ virObjectUnref(priv->qemuCaps);
+ if (!(priv->qemuCaps = virQEMUCapsCacheLookupCopy(driver->qemuCapsCache,
+ vm->def->emulator)))
goto cleanup;
VIR_DEBUG("Preparing monitor state");
* we also need to populate the PCi address set cache for later
* use in hotplug
*/
- if (qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
VIR_DEBUG("Assigning domain PCI addresses");
- if ((qemuDomainAssignAddresses(vm->def, priv->caps, vm)) < 0)
+ if ((qemuDomainAssignAddresses(vm->def, priv->qemuCaps, vm)) < 0)
goto cleanup;
}
vm->pid = pid;
VIR_DEBUG("Waiting for monitor to show up");
- if (qemuProcessWaitForMonitor(driver, vm, priv->caps, -1) < 0)
+ if (qemuProcessWaitForMonitor(driver, vm, priv->qemuCaps, -1) < 0)
goto cleanup;
/* Failure to connect to agent shouldn't be fatal */
/* If we have -device, then addresses are assigned explicitly.
* If not, then we have to detect dynamic ones here */
- if (!qemuCapsGet(priv->caps, QEMU_CAPS_DEVICE)) {
+ if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_DEVICE)) {
VIR_DEBUG("Determining domain device PCI addresses");
if (qemuProcessInitPCIAddresses(driver, vm) < 0)
goto cleanup;
struct testInfo {
const char *name;
- qemuCapsPtr flags;
+ virQEMUCapsPtr flags;
unsigned int version;
unsigned int is_kvm;
unsigned int kvm_version;
};
-static void printMismatchedFlags(qemuCapsPtr got,
- qemuCapsPtr expect)
+static void printMismatchedFlags(virQEMUCapsPtr got,
+ virQEMUCapsPtr expect)
{
int i;
for (i = 0 ; i < QEMU_CAPS_LAST ; i++) {
- bool gotFlag = qemuCapsGet(got, i);
- bool expectFlag = qemuCapsGet(expect, i);
+ bool gotFlag = virQEMUCapsGet(got, i);
+ bool expectFlag = virQEMUCapsGet(expect, i);
if (gotFlag && !expectFlag)
fprintf(stderr, "Extra flag %i\n", i);
if (!gotFlag && expectFlag)
char *path = NULL;
char *help = NULL;
unsigned int version, is_kvm, kvm_version;
- qemuCapsPtr flags = NULL;
+ virQEMUCapsPtr flags = NULL;
int ret = -1;
char *got = NULL;
char *expected = NULL;
if (virtTestLoadFile(path, &help) < 0)
goto cleanup;
- if (!(flags = qemuCapsNew()))
+ if (!(flags = virQEMUCapsNew()))
goto cleanup;
- if (qemuCapsParseHelpStr("QEMU", help, flags,
- &version, &is_kvm, &kvm_version, false) == -1)
+ if (virQEMUCapsParseHelpStr("QEMU", help, flags,
+ &version, &is_kvm, &kvm_version, false) == -1)
goto cleanup;
# ifndef WITH_YAJL
- if (qemuCapsGet(info->flags, QEMU_CAPS_MONITOR_JSON))
- qemuCapsSet(flags, QEMU_CAPS_MONITOR_JSON);
+ if (virQEMUCapsGet(info->flags, QEMU_CAPS_MONITOR_JSON))
+ virQEMUCapsSet(flags, QEMU_CAPS_MONITOR_JSON);
# endif
- if (qemuCapsGet(info->flags, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(info->flags, QEMU_CAPS_DEVICE)) {
VIR_FREE(path);
VIR_FREE(help);
if (virAsprintf(&path, "%s/qemuhelpdata/%s-device", abs_srcdir,
if (virtTestLoadFile(path, &help) < 0)
goto cleanup;
- if (qemuCapsParseDeviceStr(flags, help) < 0)
+ if (virQEMUCapsParseDeviceStr(flags, help) < 0)
goto cleanup;
}
- got = qemuCapsFlagsString(flags);
- expected = qemuCapsFlagsString(info->flags);
+ got = virQEMUCapsFlagsString(flags);
+ expected = virQEMUCapsFlagsString(info->flags);
if (!got || !expected)
goto cleanup;
struct testInfo info = { \
name, NULL, version, is_kvm, kvm_version \
}; \
- if (!(info.flags = qemuCapsNew())) \
+ if (!(info.flags = virQEMUCapsNew())) \
return EXIT_FAILURE; \
- qemuCapsSetList(info.flags, __VA_ARGS__, QEMU_CAPS_LAST); \
+ virQEMUCapsSetList(info.flags, __VA_ARGS__, QEMU_CAPS_LAST); \
if (virtTestRun("QEMU Help String Parsing " name, \
1, testHelpStrParsing, &info) < 0) \
ret = -1; \
static int testCompareXMLToArgvFiles(const char *xml,
const char *cmdline,
- qemuCapsPtr extraFlags,
+ virQEMUCapsPtr extraFlags,
const char *migrateFrom,
int migrateFd,
virQemuXML2ArgvTestFlags flags)
goto out;
}
- if (qemuCapsGet(extraFlags, QEMU_CAPS_DOMID))
+ if (virQEMUCapsGet(extraFlags, QEMU_CAPS_DOMID))
vmdef->id = 6;
else
vmdef->id = -1;
monitor_chr.data.nix.path = (char *)"/tmp/test-monitor";
monitor_chr.data.nix.listen = true;
- qemuCapsSetList(extraFlags,
- QEMU_CAPS_VNC_COLON,
- QEMU_CAPS_NO_REBOOT,
- QEMU_CAPS_NO_ACPI,
- QEMU_CAPS_LAST);
+ virQEMUCapsSetList(extraFlags,
+ QEMU_CAPS_VNC_COLON,
+ QEMU_CAPS_NO_REBOOT,
+ QEMU_CAPS_NO_ACPI,
+ QEMU_CAPS_LAST);
if (STREQ(vmdef->os.machine, "pc") &&
STREQ(vmdef->emulator, "/usr/bin/qemu-system-x86_64")) {
goto out;
}
- if (qemuCapsGet(extraFlags, QEMU_CAPS_DEVICE)) {
+ if (virQEMUCapsGet(extraFlags, QEMU_CAPS_DEVICE)) {
if (qemuDomainAssignAddresses(vmdef, extraFlags, NULL)) {
if (flags & FLAG_EXPECT_ERROR)
goto ok;
if (vmdef->os.arch == VIR_ARCH_X86_64 ||
vmdef->os.arch == VIR_ARCH_I686) {
- qemuCapsSet(extraFlags, QEMU_CAPS_PCI_MULTIBUS);
+ virQEMUCapsSet(extraFlags, QEMU_CAPS_PCI_MULTIBUS);
}
if (qemuAssignDeviceAliases(vmdef, extraFlags) < 0)
struct testInfo {
const char *name;
- qemuCapsPtr extraFlags;
+ virQEMUCapsPtr extraFlags;
const char *migrateFrom;
int migrateFd;
unsigned int flags;
abs_srcdir, info->name) < 0)
goto cleanup;
- if (qemuCapsGet(info->extraFlags, QEMU_CAPS_MONITOR_JSON))
+ if (virQEMUCapsGet(info->extraFlags, QEMU_CAPS_MONITOR_JSON))
flags |= FLAG_JSON;
result = testCompareXMLToArgvFiles(xml, args, info->extraFlags,
static int
-testAddCPUModels(qemuCapsPtr caps, bool skipLegacy)
+testAddCPUModels(virQEMUCapsPtr caps, bool skipLegacy)
{
const char *newModels[] = {
"Opteron_G3", "Opteron_G2", "Opteron_G1",
size_t i;
for (i = 0 ; i < ARRAY_CARDINALITY(newModels) ; i++) {
- if (qemuCapsAddCPUDefinition(caps, newModels[i]) < 0)
+ if (virQEMUCapsAddCPUDefinition(caps, newModels[i]) < 0)
return -1;
}
if (skipLegacy)
return 0;
for (i = 0 ; i < ARRAY_CARDINALITY(legacyModels) ; i++) {
- if (qemuCapsAddCPUDefinition(caps, legacyModels[i]) < 0)
+ if (virQEMUCapsAddCPUDefinition(caps, legacyModels[i]) < 0)
return -1;
}
return 0;
static struct testInfo info = { \
name, NULL, migrateFrom, migrateFd, (flags) \
}; \
- if (!(info.extraFlags = qemuCapsNew())) \
+ if (!(info.extraFlags = virQEMUCapsNew())) \
return EXIT_FAILURE; \
if (testAddCPUModels(info.extraFlags, skipLegacyCPUs) < 0) \
return EXIT_FAILURE; \
- qemuCapsSetList(info.extraFlags, __VA_ARGS__, QEMU_CAPS_LAST); \
+ virQEMUCapsSetList(info.extraFlags, __VA_ARGS__, QEMU_CAPS_LAST);\
if (virtTestRun("QEMU XML-2-ARGV " name, \
1, testCompareXMLToArgvHelper, &info) < 0) \
ret = -1; \
static int testCompareXMLToArgvFiles(const char *xml,
const char *cmdline,
- qemuCapsPtr extraFlags,
+ virQEMUCapsPtr extraFlags,
const char *migrateFrom,
int migrateFd,
bool json,
goto fail;
}
- if (qemuCapsGet(extraFlags, QEMU_CAPS_DOMID))
+ if (virQEMUCapsGet(extraFlags, QEMU_CAPS_DOMID))
vmdef->id = 6;
else
vmdef->id = -1;
monitor_chr.data.nix.path = (char *)"/tmp/test-monitor";
monitor_chr.data.nix.listen = true;
- qemuCapsSetList(extraFlags,
- QEMU_CAPS_VNC_COLON,
- QEMU_CAPS_NO_REBOOT,
- QEMU_CAPS_NO_ACPI,
- QEMU_CAPS_LAST);
+ virQEMUCapsSetList(extraFlags,
+ QEMU_CAPS_VNC_COLON,
+ QEMU_CAPS_NO_REBOOT,
+ QEMU_CAPS_NO_ACPI,
+ QEMU_CAPS_LAST);
- if (qemuCapsGet(extraFlags, QEMU_CAPS_DEVICE))
+ if (virQEMUCapsGet(extraFlags, QEMU_CAPS_DEVICE))
qemuDomainAssignAddresses(vmdef, extraFlags, NULL);
log = virtTestLogContentAndReset();
if (vmdef->os.arch == VIR_ARCH_X86_64 ||
vmdef->os.arch == VIR_ARCH_I686) {
- qemuCapsSet(extraFlags, QEMU_CAPS_PCI_MULTIBUS);
+ virQEMUCapsSet(extraFlags, QEMU_CAPS_PCI_MULTIBUS);
}
if (qemuAssignDeviceAliases(vmdef, extraFlags) < 0)
struct testInfo {
const char *name;
- qemuCapsPtr extraFlags;
+ virQEMUCapsPtr extraFlags;
const char *migrateFrom;
int migrateFd;
bool json;
struct testInfo info = { \
name, NULL, migrateFrom, migrateFd, json, expectError \
}; \
- if (!(info.extraFlags = qemuCapsNew())) \
+ if (!(info.extraFlags = virQEMUCapsNew())) \
return EXIT_FAILURE; \
- qemuCapsSetList(info.extraFlags, __VA_ARGS__, QEMU_CAPS_LAST); \
+ virQEMUCapsSetList(info.extraFlags, __VA_ARGS__, QEMU_CAPS_LAST);\
if (virtTestRun("QEMU XML-2-ARGV " name, \
1, testCompareXMLToArgvHelper, &info) < 0) \
ret = -1; \
projects / libvirt.git / commitdiff