2008-01-29 18:15:54 +00:00
|
|
|
#include <config.h>
|
2007-11-26 12:03:34 +00:00
|
|
|
|
|
|
|
#include <unistd.h>
|
2007-07-18 21:34:22 +00:00
|
|
|
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <fcntl.h>
|
|
|
|
|
2013-04-16 13:41:44 +00:00
|
|
|
#include "testutils.h"
|
|
|
|
|
2007-11-26 12:03:34 +00:00
|
|
|
#ifdef WITH_QEMU
|
|
|
|
|
2010-03-09 18:22:22 +00:00
|
|
|
# include "internal.h"
|
2012-12-12 18:06:53 +00:00
|
|
|
# include "viralloc.h"
|
2016-02-16 15:24:35 +00:00
|
|
|
# include "qemu/qemu_alias.h"
|
2010-12-17 16:41:51 +00:00
|
|
|
# include "qemu/qemu_capabilities.h"
|
|
|
|
# include "qemu/qemu_command.h"
|
2011-07-11 17:29:09 +00:00
|
|
|
# include "qemu/qemu_domain.h"
|
2015-10-20 13:48:33 +00:00
|
|
|
# include "qemu/qemu_migration.h"
|
2016-02-04 14:29:49 +00:00
|
|
|
# include "qemu/qemu_process.h"
|
2019-08-08 14:55:14 +00:00
|
|
|
# include "qemu/qemu_slirp.h"
|
2020-05-15 12:33:10 +00:00
|
|
|
# include "qemu/qemu_qapi.h"
|
2010-03-09 18:22:22 +00:00
|
|
|
# include "datatypes.h"
|
2013-11-20 15:04:10 +00:00
|
|
|
# include "conf/storage_conf.h"
|
2010-04-16 06:21:23 +00:00
|
|
|
# include "cpu/cpu_map.h"
|
2013-04-03 10:36:23 +00:00
|
|
|
# include "virstring.h"
|
2014-08-14 16:05:48 +00:00
|
|
|
# include "storage/storage_driver.h"
|
2015-02-02 10:26:49 +00:00
|
|
|
# include "virmock.h"
|
2019-02-25 13:15:28 +00:00
|
|
|
# include "virfilewrapper.h"
|
|
|
|
# include "configmake.h"
|
2020-05-15 12:33:10 +00:00
|
|
|
# include "testutilsqemuschema.h"
|
|
|
|
# include "qemu/qemu_monitor_json.h"
|
2007-07-18 21:34:22 +00:00
|
|
|
|
2018-12-13 14:53:50 +00:00
|
|
|
# define LIBVIRT_QEMU_CAPSPRIV_H_ALLOW
|
2016-08-03 10:26:41 +00:00
|
|
|
# include "qemu/qemu_capspriv.h"
|
|
|
|
|
2010-03-09 18:22:22 +00:00
|
|
|
# include "testutilsqemu.h"
|
2008-05-16 16:51:30 +00:00
|
|
|
|
2013-05-03 12:52:21 +00:00
|
|
|
# define VIR_FROM_THIS VIR_FROM_QEMU
|
|
|
|
|
2012-11-28 16:43:10 +00:00
|
|
|
static virQEMUDriver driver;
|
2007-07-18 21:34:22 +00:00
|
|
|
|
2011-11-01 01:29:07 +00:00
|
|
|
static unsigned char *
|
2019-10-14 12:45:03 +00:00
|
|
|
fakeSecretGetValue(virSecretPtr obj G_GNUC_UNUSED,
|
2011-11-01 01:29:07 +00:00
|
|
|
size_t *value_size,
|
2019-10-14 12:45:03 +00:00
|
|
|
unsigned int fakeflags G_GNUC_UNUSED,
|
|
|
|
unsigned int internalFlags G_GNUC_UNUSED)
|
2011-11-01 01:29:07 +00:00
|
|
|
{
|
2013-05-03 12:52:21 +00:00
|
|
|
char *secret;
|
2019-10-20 11:49:46 +00:00
|
|
|
secret = g_strdup("AQCVn5hO6HzFAhAAq0NCv8jtJcIcE+HOBlMQ1A");
|
2011-11-01 01:29:07 +00:00
|
|
|
*value_size = strlen(secret);
|
|
|
|
return (unsigned char *) secret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static virSecretPtr
|
|
|
|
fakeSecretLookupByUsage(virConnectPtr conn,
|
2016-06-02 20:28:28 +00:00
|
|
|
int usageType,
|
2011-11-01 01:29:07 +00:00
|
|
|
const char *usageID)
|
|
|
|
{
|
Convert public datatypes to inherit from virObject
This converts the following public API datatypes to use the
virObject infrastructure:
virConnectPtr
virDomainPtr
virDomainSnapshotPtr
virInterfacePtr
virNetworkPtr
virNodeDevicePtr
virNWFilterPtr
virSecretPtr
virStreamPtr
virStorageVolPtr
virStoragePoolPtr
The code is significantly simplified, since the mutex in the
virConnectPtr object now only needs to be held when accessing
the per-connection virError object instance. All other operations
are completely lock free.
* src/datatypes.c, src/datatypes.h, src/libvirt.c: Convert
public datatypes to use virObject
* src/conf/domain_event.c, src/phyp/phyp_driver.c,
src/qemu/qemu_command.c, src/qemu/qemu_migration.c,
src/qemu/qemu_process.c, src/storage/storage_driver.c,
src/vbox/vbox_tmpl.c, src/xen/xend_internal.c,
tests/qemuxml2argvtest.c, tests/qemuxmlnstest.c,
tests/sexpr2xmltest.c, tests/xmconfigtest.c: Convert
to use virObjectUnref/virObjectRef
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
2012-07-31 16:55:36 +00:00
|
|
|
unsigned char uuid[VIR_UUID_BUFLEN];
|
2016-06-02 20:28:28 +00:00
|
|
|
if (usageType == VIR_SECRET_USAGE_TYPE_VOLUME) {
|
|
|
|
if (!STRPREFIX(usageID, "/storage/guest_disks/")) {
|
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"test provided invalid volume storage prefix '%s'",
|
|
|
|
usageID);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
} else if (STRNEQ(usageID, "mycluster_myname")) {
|
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"test provided incorrect usage '%s'", usageID);
|
2011-11-01 01:29:07 +00:00
|
|
|
return NULL;
|
2016-06-02 20:28:28 +00:00
|
|
|
}
|
Convert public datatypes to inherit from virObject
This converts the following public API datatypes to use the
virObject infrastructure:
virConnectPtr
virDomainPtr
virDomainSnapshotPtr
virInterfacePtr
virNetworkPtr
virNodeDevicePtr
virNWFilterPtr
virSecretPtr
virStreamPtr
virStorageVolPtr
virStoragePoolPtr
The code is significantly simplified, since the mutex in the
virConnectPtr object now only needs to be held when accessing
the per-connection virError object instance. All other operations
are completely lock free.
* src/datatypes.c, src/datatypes.h, src/libvirt.c: Convert
public datatypes to use virObject
* src/conf/domain_event.c, src/phyp/phyp_driver.c,
src/qemu/qemu_command.c, src/qemu/qemu_migration.c,
src/qemu/qemu_process.c, src/storage/storage_driver.c,
src/vbox/vbox_tmpl.c, src/xen/xend_internal.c,
tests/qemuxml2argvtest.c, tests/qemuxmlnstest.c,
tests/sexpr2xmltest.c, tests/xmconfigtest.c: Convert
to use virObjectUnref/virObjectRef
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
2012-07-31 16:55:36 +00:00
|
|
|
|
2014-06-11 09:40:44 +00:00
|
|
|
if (virUUIDGenerate(uuid) < 0)
|
|
|
|
return NULL;
|
|
|
|
|
Convert public datatypes to inherit from virObject
This converts the following public API datatypes to use the
virObject infrastructure:
virConnectPtr
virDomainPtr
virDomainSnapshotPtr
virInterfacePtr
virNetworkPtr
virNodeDevicePtr
virNWFilterPtr
virSecretPtr
virStreamPtr
virStorageVolPtr
virStoragePoolPtr
The code is significantly simplified, since the mutex in the
virConnectPtr object now only needs to be held when accessing
the per-connection virError object instance. All other operations
are completely lock free.
* src/datatypes.c, src/datatypes.h, src/libvirt.c: Convert
public datatypes to use virObject
* src/conf/domain_event.c, src/phyp/phyp_driver.c,
src/qemu/qemu_command.c, src/qemu/qemu_migration.c,
src/qemu/qemu_process.c, src/storage/storage_driver.c,
src/vbox/vbox_tmpl.c, src/xen/xend_internal.c,
tests/qemuxml2argvtest.c, tests/qemuxmlnstest.c,
tests/sexpr2xmltest.c, tests/xmconfigtest.c: Convert
to use virObjectUnref/virObjectRef
Signed-off-by: Daniel P. Berrange <berrange@redhat.com>
2012-07-31 16:55:36 +00:00
|
|
|
return virGetSecret(conn, uuid, usageType, usageID);
|
2011-11-01 01:29:07 +00:00
|
|
|
}
|
|
|
|
|
2016-06-02 20:28:28 +00:00
|
|
|
static virSecretPtr
|
|
|
|
fakeSecretLookupByUUID(virConnectPtr conn,
|
|
|
|
const unsigned char *uuid)
|
|
|
|
{
|
2018-12-04 20:15:22 +00:00
|
|
|
/* NB: This mocked value could be "tls" or "volume" depending on
|
|
|
|
* which test is being run, we'll leave at NONE (or 0) */
|
|
|
|
return virGetSecret(conn, uuid, VIR_SECRET_USAGE_TYPE_NONE, "");
|
2016-06-02 20:28:28 +00:00
|
|
|
}
|
|
|
|
|
2011-11-01 01:29:07 +00:00
|
|
|
static virSecretDriver fakeSecretDriver = {
|
2013-04-22 17:26:01 +00:00
|
|
|
.connectNumOfSecrets = NULL,
|
|
|
|
.connectListSecrets = NULL,
|
2016-06-02 20:28:28 +00:00
|
|
|
.secretLookupByUUID = fakeSecretLookupByUUID,
|
2013-04-22 17:26:01 +00:00
|
|
|
.secretLookupByUsage = fakeSecretLookupByUsage,
|
|
|
|
.secretDefineXML = NULL,
|
|
|
|
.secretGetXMLDesc = NULL,
|
|
|
|
.secretSetValue = NULL,
|
|
|
|
.secretGetValue = fakeSecretGetValue,
|
|
|
|
.secretUndefine = NULL,
|
2011-11-01 01:29:07 +00:00
|
|
|
};
|
|
|
|
|
2013-11-20 15:04:10 +00:00
|
|
|
|
|
|
|
# define STORAGE_POOL_XML_PATH "storagepoolxml2xmlout/"
|
|
|
|
static const unsigned char fakeUUID[VIR_UUID_BUFLEN] = "fakeuuid";
|
|
|
|
|
|
|
|
static virStoragePoolPtr
|
|
|
|
fakeStoragePoolLookupByName(virConnectPtr conn,
|
|
|
|
const char *name)
|
|
|
|
{
|
2020-07-28 19:57:28 +00:00
|
|
|
g_autofree char *xmlpath = NULL;
|
2013-11-20 15:04:10 +00:00
|
|
|
virStoragePoolPtr ret = NULL;
|
|
|
|
|
|
|
|
if (STRNEQ(name, "inactive")) {
|
2019-10-22 13:26:14 +00:00
|
|
|
xmlpath = g_strdup_printf("%s/%s%s.xml", abs_srcdir,
|
|
|
|
STORAGE_POOL_XML_PATH, name);
|
2013-11-20 15:04:10 +00:00
|
|
|
|
|
|
|
if (!virFileExists(xmlpath)) {
|
|
|
|
virReportError(VIR_ERR_NO_STORAGE_POOL,
|
|
|
|
"File '%s' not found", xmlpath);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = virGetStoragePool(conn, name, fakeUUID, NULL, NULL);
|
|
|
|
|
2014-03-25 06:53:44 +00:00
|
|
|
cleanup:
|
2013-11-20 15:04:10 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static virStorageVolPtr
|
|
|
|
fakeStorageVolLookupByName(virStoragePoolPtr pool,
|
|
|
|
const char *name)
|
|
|
|
{
|
2020-07-28 20:12:34 +00:00
|
|
|
VIR_AUTOSTRINGLIST volinfo = NULL;
|
2013-11-20 15:04:10 +00:00
|
|
|
virStorageVolPtr ret = NULL;
|
|
|
|
|
|
|
|
if (STREQ(pool->name, "inactive")) {
|
|
|
|
virReportError(VIR_ERR_OPERATION_INVALID,
|
|
|
|
"storage pool '%s' is not active", pool->name);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (STREQ(name, "nonexistent")) {
|
|
|
|
virReportError(VIR_ERR_NO_STORAGE_VOL,
|
|
|
|
"no storage vol with matching name '%s'", name);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!strchr(name, '+'))
|
|
|
|
goto fallback;
|
|
|
|
|
|
|
|
if (!(volinfo = virStringSplit(name, "+", 2)))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (!volinfo[1])
|
|
|
|
goto fallback;
|
|
|
|
|
|
|
|
ret = virGetStorageVol(pool->conn, pool->name, volinfo[1], volinfo[0],
|
|
|
|
NULL, NULL);
|
|
|
|
|
2014-03-25 06:53:44 +00:00
|
|
|
cleanup:
|
2013-11-20 15:04:10 +00:00
|
|
|
return ret;
|
|
|
|
|
2014-03-25 06:53:44 +00:00
|
|
|
fallback:
|
2013-11-20 15:04:10 +00:00
|
|
|
ret = virGetStorageVol(pool->conn, pool->name, name, "block", NULL, NULL);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
fakeStorageVolGetInfo(virStorageVolPtr vol,
|
|
|
|
virStorageVolInfoPtr info)
|
|
|
|
{
|
|
|
|
memset(info, 0, sizeof(*info));
|
|
|
|
|
|
|
|
info->type = virStorageVolTypeFromString(vol->key);
|
|
|
|
|
|
|
|
if (info->type < 0) {
|
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"Invalid volume type '%s'", vol->key);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static char *
|
|
|
|
fakeStorageVolGetPath(virStorageVolPtr vol)
|
|
|
|
{
|
2020-05-04 15:03:42 +00:00
|
|
|
return g_strdup_printf("/some/%s/device/%s", vol->key, vol->name);
|
2013-11-20 15:04:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static char *
|
|
|
|
fakeStoragePoolGetXMLDesc(virStoragePoolPtr pool,
|
2019-10-14 12:45:03 +00:00
|
|
|
unsigned int flags_unused G_GNUC_UNUSED)
|
2013-11-20 15:04:10 +00:00
|
|
|
{
|
2020-07-28 19:57:28 +00:00
|
|
|
g_autofree char *xmlpath = NULL;
|
2013-11-20 15:04:10 +00:00
|
|
|
char *xmlbuf = NULL;
|
|
|
|
|
|
|
|
if (STREQ(pool->name, "inactive")) {
|
|
|
|
virReportError(VIR_ERR_NO_STORAGE_POOL, NULL);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2019-10-22 13:26:14 +00:00
|
|
|
xmlpath = g_strdup_printf("%s/%s%s.xml", abs_srcdir, STORAGE_POOL_XML_PATH,
|
|
|
|
pool->name);
|
2013-11-20 15:04:10 +00:00
|
|
|
|
2016-05-26 15:01:52 +00:00
|
|
|
if (virTestLoadFile(xmlpath, &xmlbuf) < 0) {
|
2013-11-20 15:04:10 +00:00
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"failed to load XML file '%s'",
|
|
|
|
xmlpath);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2014-03-25 06:53:44 +00:00
|
|
|
cleanup:
|
2013-11-20 15:04:10 +00:00
|
|
|
|
|
|
|
return xmlbuf;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
fakeStoragePoolIsActive(virStoragePoolPtr pool)
|
|
|
|
{
|
|
|
|
if (STREQ(pool->name, "inactive"))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Test storage pool implementation
|
|
|
|
*
|
|
|
|
* These functions aid testing of storage pool related stuff when creating a
|
2013-12-02 12:25:01 +00:00
|
|
|
* qemu command line.
|
2013-11-20 15:04:10 +00:00
|
|
|
*
|
|
|
|
* There are a few "magic" values to pass to these functions:
|
|
|
|
*
|
2013-12-02 12:25:01 +00:00
|
|
|
* 1) "inactive" as a pool name to create an inactive pool. All other names are
|
|
|
|
* interpreted as file names in storagepoolxml2xmlout/ and are used as the
|
2013-11-20 15:04:10 +00:00
|
|
|
* definition for the pool. If the file doesn't exist the pool doesn't exist.
|
|
|
|
*
|
|
|
|
* 2) "nonexistent" returns an error while looking up a volume. Otherwise
|
2013-12-02 12:25:01 +00:00
|
|
|
* pattern VOLUME_TYPE+VOLUME_PATH can be used to simulate a volume in a pool.
|
2013-11-20 15:04:10 +00:00
|
|
|
* This creates a fake path for this volume. If the '+' sign is omitted, block
|
|
|
|
* type is assumed.
|
|
|
|
*/
|
|
|
|
static virStorageDriver fakeStorageDriver = {
|
|
|
|
.storagePoolLookupByName = fakeStoragePoolLookupByName,
|
|
|
|
.storageVolLookupByName = fakeStorageVolLookupByName,
|
|
|
|
.storagePoolGetXMLDesc = fakeStoragePoolGetXMLDesc,
|
|
|
|
.storageVolGetPath = fakeStorageVolGetPath,
|
|
|
|
.storageVolGetInfo = fakeStorageVolGetInfo,
|
|
|
|
.storagePoolIsActive = fakeStoragePoolIsActive,
|
|
|
|
};
|
|
|
|
|
2018-07-12 07:08:04 +00:00
|
|
|
|
|
|
|
/* virNetDevOpenvswitchGetVhostuserIfname mocks a portdev name - handle that */
|
|
|
|
static virNWFilterBindingPtr
|
|
|
|
fakeNWFilterBindingLookupByPortDev(virConnectPtr conn,
|
|
|
|
const char *portdev)
|
|
|
|
{
|
|
|
|
if (STREQ(portdev, "vhost-user0"))
|
|
|
|
return virGetNWFilterBinding(conn, "fake_vnet0", "fakeFilterName");
|
|
|
|
|
|
|
|
virReportError(VIR_ERR_NO_NWFILTER_BINDING,
|
|
|
|
"no nwfilter binding for port dev '%s'", portdev);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int
|
2019-10-14 12:45:03 +00:00
|
|
|
fakeNWFilterBindingDelete(virNWFilterBindingPtr binding G_GNUC_UNUSED)
|
2018-07-12 07:08:04 +00:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static virNWFilterDriver fakeNWFilterDriver = {
|
|
|
|
.nwfilterBindingLookupByPortDev = fakeNWFilterBindingLookupByPortDev,
|
|
|
|
.nwfilterBindingDelete = fakeNWFilterBindingDelete,
|
|
|
|
};
|
|
|
|
|
2016-08-03 08:47:00 +00:00
|
|
|
|
|
|
|
static int
|
|
|
|
testAddCPUModels(virQEMUCapsPtr caps, bool skipLegacy)
|
|
|
|
{
|
2016-08-04 11:25:02 +00:00
|
|
|
virArch arch = virQEMUCapsGetArch(caps);
|
|
|
|
const char *x86Models[] = {
|
2016-08-03 08:47:00 +00:00
|
|
|
"Opteron_G3", "Opteron_G2", "Opteron_G1",
|
|
|
|
"Nehalem", "Penryn", "Conroe",
|
|
|
|
"Haswell-noTSX", "Haswell",
|
|
|
|
};
|
2016-08-04 11:25:02 +00:00
|
|
|
const char *x86LegacyModels[] = {
|
2016-08-03 08:47:00 +00:00
|
|
|
"n270", "athlon", "pentium3", "pentium2", "pentium",
|
|
|
|
"486", "coreduo", "kvm32", "qemu32", "kvm64",
|
|
|
|
"core2duo", "phenom", "qemu64",
|
|
|
|
};
|
2016-08-04 11:25:02 +00:00
|
|
|
const char *armModels[] = {
|
|
|
|
"cortex-a9", "cortex-a8", "cortex-a57", "cortex-a53",
|
|
|
|
};
|
|
|
|
const char *ppc64Models[] = {
|
|
|
|
"POWER8", "POWER7",
|
|
|
|
};
|
2016-12-18 19:22:28 +00:00
|
|
|
const char *s390xModels[] = {
|
|
|
|
"z990", "zEC12", "z13",
|
|
|
|
};
|
2016-08-03 08:47:00 +00:00
|
|
|
|
2016-08-04 11:25:02 +00:00
|
|
|
if (ARCH_IS_X86(arch)) {
|
2016-11-14 16:21:30 +00:00
|
|
|
if (virQEMUCapsAddCPUDefinitions(caps, VIR_DOMAIN_VIRT_KVM, x86Models,
|
2019-10-15 11:55:26 +00:00
|
|
|
G_N_ELEMENTS(x86Models),
|
2016-04-21 11:08:12 +00:00
|
|
|
VIR_DOMCAPS_CPU_USABLE_UNKNOWN) < 0 ||
|
2016-11-14 16:21:30 +00:00
|
|
|
virQEMUCapsAddCPUDefinitions(caps, VIR_DOMAIN_VIRT_QEMU, x86Models,
|
2019-10-15 11:55:26 +00:00
|
|
|
G_N_ELEMENTS(x86Models),
|
2016-04-21 11:08:12 +00:00
|
|
|
VIR_DOMCAPS_CPU_USABLE_UNKNOWN) < 0)
|
2016-08-04 11:25:02 +00:00
|
|
|
return -1;
|
|
|
|
|
2016-11-14 16:21:30 +00:00
|
|
|
if (!skipLegacy) {
|
|
|
|
if (virQEMUCapsAddCPUDefinitions(caps, VIR_DOMAIN_VIRT_KVM,
|
|
|
|
x86LegacyModels,
|
2019-10-15 11:55:26 +00:00
|
|
|
G_N_ELEMENTS(x86LegacyModels),
|
2016-04-21 11:08:12 +00:00
|
|
|
VIR_DOMCAPS_CPU_USABLE_UNKNOWN) < 0 ||
|
2016-11-14 16:21:30 +00:00
|
|
|
virQEMUCapsAddCPUDefinitions(caps, VIR_DOMAIN_VIRT_QEMU,
|
|
|
|
x86LegacyModels,
|
2019-10-15 11:55:26 +00:00
|
|
|
G_N_ELEMENTS(x86LegacyModels),
|
2016-04-21 11:08:12 +00:00
|
|
|
VIR_DOMCAPS_CPU_USABLE_UNKNOWN) < 0)
|
2016-11-14 16:21:30 +00:00
|
|
|
return -1;
|
|
|
|
}
|
2016-08-04 11:25:02 +00:00
|
|
|
} else if (ARCH_IS_ARM(arch)) {
|
2016-11-14 16:21:30 +00:00
|
|
|
if (virQEMUCapsAddCPUDefinitions(caps, VIR_DOMAIN_VIRT_KVM, armModels,
|
2019-10-15 11:55:26 +00:00
|
|
|
G_N_ELEMENTS(armModels),
|
2016-04-21 11:08:12 +00:00
|
|
|
VIR_DOMCAPS_CPU_USABLE_UNKNOWN) < 0 ||
|
2016-11-14 16:21:30 +00:00
|
|
|
virQEMUCapsAddCPUDefinitions(caps, VIR_DOMAIN_VIRT_QEMU, armModels,
|
2019-10-15 11:55:26 +00:00
|
|
|
G_N_ELEMENTS(armModels),
|
2016-04-21 11:08:12 +00:00
|
|
|
VIR_DOMCAPS_CPU_USABLE_UNKNOWN) < 0)
|
2016-08-04 11:25:02 +00:00
|
|
|
return -1;
|
|
|
|
} else if (ARCH_IS_PPC64(arch)) {
|
2016-11-14 16:21:30 +00:00
|
|
|
if (virQEMUCapsAddCPUDefinitions(caps, VIR_DOMAIN_VIRT_KVM, ppc64Models,
|
2019-10-15 11:55:26 +00:00
|
|
|
G_N_ELEMENTS(ppc64Models),
|
2016-04-21 11:08:12 +00:00
|
|
|
VIR_DOMCAPS_CPU_USABLE_UNKNOWN) < 0 ||
|
2016-11-14 16:21:30 +00:00
|
|
|
virQEMUCapsAddCPUDefinitions(caps, VIR_DOMAIN_VIRT_QEMU, ppc64Models,
|
2019-10-15 11:55:26 +00:00
|
|
|
G_N_ELEMENTS(ppc64Models),
|
2016-04-21 11:08:12 +00:00
|
|
|
VIR_DOMCAPS_CPU_USABLE_UNKNOWN) < 0)
|
2016-08-04 11:25:02 +00:00
|
|
|
return -1;
|
2016-12-18 19:22:28 +00:00
|
|
|
} else if (ARCH_IS_S390(arch)) {
|
|
|
|
if (virQEMUCapsAddCPUDefinitions(caps, VIR_DOMAIN_VIRT_KVM, s390xModels,
|
2019-10-15 11:55:26 +00:00
|
|
|
G_N_ELEMENTS(s390xModels),
|
2016-12-18 19:22:28 +00:00
|
|
|
VIR_DOMCAPS_CPU_USABLE_UNKNOWN) < 0)
|
|
|
|
return -1;
|
2016-08-04 11:25:02 +00:00
|
|
|
}
|
2016-08-03 08:47:00 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-08-03 10:21:19 +00:00
|
|
|
static int
|
2019-03-31 15:32:18 +00:00
|
|
|
testUpdateQEMUCaps(const struct testQemuInfo *info,
|
2016-06-15 12:35:18 +00:00
|
|
|
virDomainObjPtr vm,
|
|
|
|
virCapsPtr caps)
|
2016-08-03 10:21:19 +00:00
|
|
|
{
|
2017-07-21 13:09:54 +00:00
|
|
|
if (!caps)
|
2019-11-12 20:46:29 +00:00
|
|
|
return -1;
|
2017-07-21 13:09:54 +00:00
|
|
|
|
2016-08-03 10:26:41 +00:00
|
|
|
virQEMUCapsSetArch(info->qemuCaps, vm->def->os.arch);
|
|
|
|
|
2017-03-02 18:24:22 +00:00
|
|
|
virQEMUCapsInitQMPBasicArch(info->qemuCaps);
|
|
|
|
|
2018-09-09 01:19:35 +00:00
|
|
|
if (testAddCPUModels(info->qemuCaps,
|
|
|
|
!!(info->flags & FLAG_SKIP_LEGACY_CPUS)) < 0)
|
2019-11-12 20:46:29 +00:00
|
|
|
return -1;
|
2016-08-03 10:21:19 +00:00
|
|
|
|
2017-07-21 13:09:54 +00:00
|
|
|
virQEMUCapsInitHostCPUModel(info->qemuCaps, caps->host.arch,
|
|
|
|
VIR_DOMAIN_VIRT_KVM);
|
|
|
|
virQEMUCapsInitHostCPUModel(info->qemuCaps, caps->host.arch,
|
|
|
|
VIR_DOMAIN_VIRT_QEMU);
|
2016-06-15 12:35:18 +00:00
|
|
|
|
2019-11-12 20:46:29 +00:00
|
|
|
return 0;
|
2016-08-03 10:21:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-09-09 01:33:57 +00:00
|
|
|
static int
|
|
|
|
testCheckExclusiveFlags(int flags)
|
|
|
|
{
|
|
|
|
virCheckFlags(FLAG_EXPECT_FAILURE |
|
|
|
|
FLAG_EXPECT_PARSE_ERROR |
|
2020-10-21 08:08:11 +00:00
|
|
|
FLAG_FIPS_HOST |
|
2018-09-08 22:13:23 +00:00
|
|
|
FLAG_REAL_CAPS |
|
2018-09-09 01:19:35 +00:00
|
|
|
FLAG_SKIP_LEGACY_CPUS |
|
2019-08-08 14:55:14 +00:00
|
|
|
FLAG_SLIRP_HELPER |
|
2018-09-09 01:33:57 +00:00
|
|
|
0, -1);
|
|
|
|
|
2018-09-09 01:19:35 +00:00
|
|
|
VIR_EXCLUSIVE_FLAGS_RET(FLAG_REAL_CAPS, FLAG_SKIP_LEGACY_CPUS, -1);
|
2018-09-09 01:33:57 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-05-15 06:50:31 +00:00
|
|
|
static virCommandPtr
|
|
|
|
testCompareXMLToArgvCreateArgs(virQEMUDriverPtr drv,
|
|
|
|
virDomainObjPtr vm,
|
|
|
|
const char *migrateURI,
|
|
|
|
struct testQemuInfo *info,
|
2020-05-15 12:24:21 +00:00
|
|
|
unsigned int flags,
|
|
|
|
bool jsonPropsValidation)
|
2020-05-15 06:50:31 +00:00
|
|
|
{
|
2020-10-20 16:48:59 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = vm->privateData;
|
2020-10-21 08:08:11 +00:00
|
|
|
bool enableFips = !!(flags & FLAG_FIPS_HOST);
|
2020-05-15 06:50:31 +00:00
|
|
|
size_t i;
|
|
|
|
|
2020-10-15 12:39:16 +00:00
|
|
|
if (qemuProcessCreatePretendCmdPrepare(drv, vm, migrateURI, false,
|
|
|
|
VIR_QEMU_PROCESS_START_COLD) < 0)
|
|
|
|
return NULL;
|
|
|
|
|
2020-10-15 11:47:46 +00:00
|
|
|
for (i = 0; i < vm->def->ndisks; i++) {
|
|
|
|
virDomainDiskDefPtr disk = vm->def->disks[i];
|
|
|
|
|
|
|
|
/* host cdrom requires special treatment in qemu, mock it */
|
|
|
|
if (disk->device == VIR_DOMAIN_DISK_DEVICE_CDROM &&
|
|
|
|
disk->src->format == VIR_STORAGE_FILE_RAW &&
|
|
|
|
virStorageSourceIsBlockLocal(disk->src) &&
|
|
|
|
STREQ(disk->src->path, "/dev/cdrom"))
|
|
|
|
disk->src->hostcdrom = true;
|
|
|
|
}
|
|
|
|
|
2020-05-15 06:50:31 +00:00
|
|
|
for (i = 0; i < vm->def->nhostdevs; i++) {
|
|
|
|
virDomainHostdevDefPtr hostdev = vm->def->hostdevs[i];
|
|
|
|
|
|
|
|
if (hostdev->mode == VIR_DOMAIN_HOSTDEV_MODE_SUBSYS &&
|
|
|
|
hostdev->source.subsys.type == VIR_DOMAIN_HOSTDEV_SUBSYS_TYPE_PCI &&
|
|
|
|
hostdev->source.subsys.u.pci.backend == VIR_DOMAIN_HOSTDEV_PCI_BACKEND_DEFAULT) {
|
|
|
|
hostdev->source.subsys.u.pci.backend = VIR_DOMAIN_HOSTDEV_PCI_BACKEND_VFIO;
|
|
|
|
}
|
2020-10-15 13:06:01 +00:00
|
|
|
|
|
|
|
if (virHostdevIsSCSIDevice(hostdev)) {
|
|
|
|
virDomainHostdevSubsysSCSIPtr scsisrc = &hostdev->source.subsys.u.scsi;
|
|
|
|
|
|
|
|
switch ((virDomainHostdevSCSIProtocolType) scsisrc->protocol) {
|
|
|
|
case VIR_DOMAIN_HOSTDEV_SCSI_PROTOCOL_TYPE_NONE:
|
|
|
|
scsisrc->u.host.src->path = g_strdup("/dev/sg0");
|
|
|
|
break;
|
|
|
|
|
|
|
|
case VIR_DOMAIN_HOSTDEV_SCSI_PROTOCOL_TYPE_ISCSI:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case VIR_DOMAIN_HOSTDEV_SCSI_PROTOCOL_TYPE_LAST:
|
|
|
|
default:
|
|
|
|
virReportEnumRangeError(virDomainHostdevSCSIProtocolType, scsisrc->protocol);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
2020-05-15 06:50:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < vm->def->nfss; i++) {
|
|
|
|
virDomainFSDefPtr fs = vm->def->fss[i];
|
|
|
|
char *s;
|
|
|
|
|
|
|
|
if (fs->fsdriver != VIR_DOMAIN_FS_DRIVER_TYPE_VIRTIOFS ||
|
|
|
|
QEMU_DOMAIN_FS_PRIVATE(fs)->vhostuser_fs_sock)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
s = g_strdup_printf("/tmp/lib/domain--1-guest/fs%zu.vhost-fs.sock", i);
|
|
|
|
QEMU_DOMAIN_FS_PRIVATE(fs)->vhostuser_fs_sock = s;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (vm->def->vsock) {
|
|
|
|
virDomainVsockDefPtr vsock = vm->def->vsock;
|
|
|
|
qemuDomainVsockPrivatePtr vsockPriv =
|
|
|
|
(qemuDomainVsockPrivatePtr)vsock->privateData;
|
|
|
|
|
|
|
|
if (vsock->auto_cid == VIR_TRISTATE_BOOL_YES)
|
|
|
|
vsock->guest_cid = 42;
|
|
|
|
|
|
|
|
vsockPriv->vhostfd = 6789;
|
|
|
|
}
|
|
|
|
|
2020-06-10 18:11:47 +00:00
|
|
|
for (i = 0; i < vm->def->ntpms; i++) {
|
|
|
|
if (vm->def->tpms[i]->type != VIR_DOMAIN_TPM_TYPE_EMULATOR)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
VIR_FREE(vm->def->tpms[i]->data.emulator.source.data.file.path);
|
|
|
|
vm->def->tpms[i]->data.emulator.source.data.file.path = g_strdup("/dev/test");
|
|
|
|
vm->def->tpms[i]->data.emulator.source.type = VIR_DOMAIN_CHR_TYPE_FILE;
|
2020-05-15 06:50:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < vm->def->nvideos; i++) {
|
|
|
|
virDomainVideoDefPtr video = vm->def->videos[i];
|
|
|
|
|
|
|
|
if (video->backend == VIR_DOMAIN_VIDEO_BACKEND_TYPE_VHOSTUSER) {
|
|
|
|
qemuDomainVideoPrivatePtr vpriv = QEMU_DOMAIN_VIDEO_PRIVATE(video);
|
|
|
|
|
|
|
|
vpriv->vhost_user_fd = 1729;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (flags & FLAG_SLIRP_HELPER) {
|
|
|
|
for (i = 0; i < vm->def->nnets; i++) {
|
|
|
|
virDomainNetDefPtr net = vm->def->nets[i];
|
|
|
|
|
|
|
|
if (net->type == VIR_DOMAIN_NET_TYPE_USER &&
|
|
|
|
virQEMUCapsGet(info->qemuCaps, QEMU_CAPS_DBUS_VMSTATE)) {
|
|
|
|
qemuSlirpPtr slirp = qemuSlirpNew();
|
|
|
|
slirp->fd[0] = 42;
|
|
|
|
QEMU_DOMAIN_NETWORK_PRIVATE(net)->slirp = slirp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-10-20 16:48:59 +00:00
|
|
|
/* we can't use qemuCheckFips() directly as it queries host state */
|
|
|
|
if (!virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_ENABLE_FIPS))
|
|
|
|
enableFips = false;
|
|
|
|
|
2020-10-15 12:39:16 +00:00
|
|
|
return qemuProcessCreatePretendCmdBuild(drv, vm, migrateURI,
|
2020-10-21 08:08:11 +00:00
|
|
|
enableFips, false,
|
2020-10-15 12:39:16 +00:00
|
|
|
jsonPropsValidation);
|
2020-05-15 06:50:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-05-15 12:33:10 +00:00
|
|
|
static int
|
|
|
|
testCompareXMLToArgvValidateSchema(virQEMUDriverPtr drv,
|
|
|
|
const char *migrateURI,
|
|
|
|
struct testQemuInfo *info,
|
|
|
|
unsigned int flags)
|
|
|
|
{
|
|
|
|
VIR_AUTOSTRINGLIST args = NULL;
|
2020-05-21 18:55:01 +00:00
|
|
|
g_autoptr(virDomainObj) vm = NULL;
|
2020-05-15 12:33:10 +00:00
|
|
|
size_t nargs = 0;
|
|
|
|
size_t i;
|
|
|
|
g_autoptr(virHashTable) schema = NULL;
|
|
|
|
g_autoptr(virCommand) cmd = NULL;
|
2020-05-21 18:55:01 +00:00
|
|
|
unsigned int parseFlags = info->parseFlags;
|
2020-05-15 12:33:10 +00:00
|
|
|
|
|
|
|
if (info->schemafile)
|
|
|
|
schema = testQEMUSchemaLoad(info->schemafile);
|
|
|
|
|
|
|
|
/* comment out with line comment to enable schema checking for non _CAPS tests
|
|
|
|
if (!schema)
|
|
|
|
schema = testQEMUSchemaLoadLatest(virArchToString(info->arch));
|
|
|
|
// */
|
|
|
|
|
|
|
|
if (!schema)
|
|
|
|
return 0;
|
|
|
|
|
2020-05-21 18:55:01 +00:00
|
|
|
if (!(vm = virDomainObjNew(driver.xmlopt)))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
parseFlags |= VIR_DOMAIN_DEF_PARSE_INACTIVE;
|
|
|
|
if (!(vm->def = virDomainDefParseFile(info->infile,
|
|
|
|
driver.xmlopt,
|
|
|
|
NULL, parseFlags)))
|
|
|
|
return -1;
|
|
|
|
|
2020-05-15 12:33:10 +00:00
|
|
|
if (!(cmd = testCompareXMLToArgvCreateArgs(drv, vm, migrateURI, info, flags,
|
|
|
|
true)))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (virCommandGetArgList(cmd, &args, &nargs) < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
for (i = 0; i < nargs; i++) {
|
|
|
|
g_auto(virBuffer) debug = VIR_BUFFER_INITIALIZER;
|
|
|
|
g_autoptr(virJSONValue) jsonargs = NULL;
|
|
|
|
|
|
|
|
if (STREQ(args[i], "-blockdev")) {
|
|
|
|
if (!(jsonargs = virJSONValueFromString(args[i + 1])))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (testQEMUSchemaValidateCommand("blockdev-add", jsonargs,
|
|
|
|
schema, false, false, &debug) < 0) {
|
|
|
|
VIR_TEST_VERBOSE("failed to validate -blockdev '%s' against QAPI schema: %s",
|
|
|
|
args[i + 1], virBufferCurrentContent(&debug));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
i++;
|
|
|
|
} else if (STREQ(args[i], "-netdev")) {
|
|
|
|
if (!(jsonargs = virJSONValueFromString(args[i + 1])))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
/* skip the validation for pre-QAPIfication cases */
|
|
|
|
if (virQEMUQAPISchemaPathExists("netdev_add/arg-type/type/!string", schema))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (testQEMUSchemaValidateCommand("netdev_add", jsonargs,
|
|
|
|
schema, false, false, &debug) < 0) {
|
|
|
|
VIR_TEST_VERBOSE("failed to validate -netdev '%s' against QAPI schema: %s",
|
|
|
|
args[i + 1], virBufferCurrentContent(&debug));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2018-03-27 09:11:01 +00:00
|
|
|
static int
|
|
|
|
testCompareXMLToArgv(const void *data)
|
|
|
|
{
|
2019-03-31 15:32:18 +00:00
|
|
|
struct testQemuInfo *info = (void *) data;
|
2020-07-28 19:57:28 +00:00
|
|
|
g_autofree char *migrateURI = NULL;
|
|
|
|
g_autofree char *actualargv = NULL;
|
2016-08-03 08:42:08 +00:00
|
|
|
unsigned int flags = info->flags;
|
|
|
|
unsigned int parseFlags = info->parseFlags;
|
2010-11-22 23:09:13 +00:00
|
|
|
int ret = -1;
|
2016-03-17 12:19:35 +00:00
|
|
|
virDomainObjPtr vm = NULL;
|
2011-01-07 23:36:25 +00:00
|
|
|
virDomainChrSourceDef monitor_chr;
|
2020-07-28 19:58:18 +00:00
|
|
|
g_autoptr(virConnect) conn = NULL;
|
2020-09-22 11:57:39 +00:00
|
|
|
virError *err = NULL;
|
2010-10-22 16:50:34 +00:00
|
|
|
char *log = NULL;
|
2020-07-28 19:58:18 +00:00
|
|
|
g_autoptr(virCommand) cmd = NULL;
|
2016-03-15 12:54:24 +00:00
|
|
|
qemuDomainObjPrivatePtr priv = NULL;
|
2010-02-10 13:19:17 +00:00
|
|
|
|
2019-11-27 16:20:02 +00:00
|
|
|
if (info->arch != VIR_ARCH_NONE && info->arch != VIR_ARCH_X86_64)
|
2019-11-26 17:51:22 +00:00
|
|
|
qemuTestSetHostArch(&driver, info->arch);
|
2019-11-27 16:20:02 +00:00
|
|
|
|
2016-07-08 21:45:22 +00:00
|
|
|
memset(&monitor_chr, 0, sizeof(monitor_chr));
|
|
|
|
|
2010-02-10 13:19:17 +00:00
|
|
|
if (!(conn = virGetConnect()))
|
2016-08-03 08:19:10 +00:00
|
|
|
goto cleanup;
|
2016-08-03 08:42:08 +00:00
|
|
|
|
2011-11-01 01:29:07 +00:00
|
|
|
conn->secretDriver = &fakeSecretDriver;
|
2013-11-20 15:04:10 +00:00
|
|
|
conn->storageDriver = &fakeStorageDriver;
|
2018-07-12 07:08:04 +00:00
|
|
|
conn->nwfilterDriver = &fakeNWFilterDriver;
|
2007-07-18 21:34:22 +00:00
|
|
|
|
2018-07-12 07:08:04 +00:00
|
|
|
virSetConnectInterface(conn);
|
|
|
|
virSetConnectNetwork(conn);
|
|
|
|
virSetConnectNWFilter(conn);
|
|
|
|
virSetConnectNodeDev(conn);
|
2018-02-09 16:06:43 +00:00
|
|
|
virSetConnectSecret(conn);
|
|
|
|
virSetConnectStorage(conn);
|
|
|
|
|
2018-09-09 01:33:57 +00:00
|
|
|
if (testCheckExclusiveFlags(info->flags) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
2017-04-11 12:02:06 +00:00
|
|
|
if (qemuTestCapsCacheInsert(driver.qemuCapsCache, info->qemuCaps) < 0)
|
2016-08-03 08:42:08 +00:00
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
if (info->migrateFrom &&
|
2018-02-12 17:11:41 +00:00
|
|
|
!(migrateURI = qemuMigrationDstGetURI(info->migrateFrom,
|
|
|
|
info->migrateFd)))
|
2016-08-03 08:42:08 +00:00
|
|
|
goto cleanup;
|
|
|
|
|
2016-03-17 12:19:35 +00:00
|
|
|
if (!(vm = virDomainObjNew(driver.xmlopt)))
|
2016-08-03 08:19:10 +00:00
|
|
|
goto cleanup;
|
2016-03-17 12:19:35 +00:00
|
|
|
|
2020-06-25 20:18:23 +00:00
|
|
|
if (!virFileExists(info->infile)) {
|
|
|
|
virReportError(VIR_ERR_INTERNAL_ERROR,
|
|
|
|
"Input file '%s' not found", info->infile);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
|
2016-08-03 08:42:08 +00:00
|
|
|
parseFlags |= VIR_DOMAIN_DEF_PARSE_INACTIVE;
|
2019-03-31 14:59:30 +00:00
|
|
|
if (!(vm->def = virDomainDefParseFile(info->infile,
|
2019-11-27 12:29:21 +00:00
|
|
|
driver.xmlopt,
|
2016-09-22 15:14:17 +00:00
|
|
|
NULL, parseFlags))) {
|
2020-09-22 11:57:39 +00:00
|
|
|
err = virGetLastError();
|
|
|
|
if (!err) {
|
|
|
|
VIR_TEST_DEBUG("no error was reported for expected parse error");
|
|
|
|
goto cleanup;
|
|
|
|
}
|
2020-09-24 11:09:47 +00:00
|
|
|
if (flags & FLAG_EXPECT_PARSE_ERROR) {
|
|
|
|
g_autofree char *tmperr = g_strdup_printf("%s\n", NULLSTR(err->message));
|
|
|
|
if (virTestCompareToFile(tmperr, info->errfile) >= 0)
|
|
|
|
goto ok;
|
|
|
|
}
|
2016-08-03 08:19:10 +00:00
|
|
|
goto cleanup;
|
2012-07-09 16:29:55 +00:00
|
|
|
}
|
2017-09-07 12:19:37 +00:00
|
|
|
if (flags & FLAG_EXPECT_PARSE_ERROR) {
|
|
|
|
VIR_TEST_DEBUG("passed instead of expected parse error");
|
|
|
|
goto cleanup;
|
|
|
|
}
|
2016-03-15 12:54:24 +00:00
|
|
|
priv = vm->privateData;
|
2007-07-18 21:34:22 +00:00
|
|
|
|
2016-06-17 12:56:45 +00:00
|
|
|
if (virBitmapParse("0-3", &priv->autoNodeset, 4) < 0)
|
2016-08-03 08:19:10 +00:00
|
|
|
goto cleanup;
|
2016-03-15 12:57:47 +00:00
|
|
|
|
2017-05-19 13:07:15 +00:00
|
|
|
if (!virDomainDefCheckABIStability(vm->def, vm->def, driver.xmlopt)) {
|
2019-03-31 14:59:30 +00:00
|
|
|
VIR_TEST_DEBUG("ABI stability check failed on %s", info->infile);
|
2016-08-03 08:19:10 +00:00
|
|
|
goto cleanup;
|
2014-01-10 17:18:03 +00:00
|
|
|
}
|
|
|
|
|
2016-03-17 12:19:35 +00:00
|
|
|
vm->def->id = -1;
|
2007-09-21 21:20:32 +00:00
|
|
|
|
2016-03-15 12:54:24 +00:00
|
|
|
if (qemuProcessPrepareMonitorChr(&monitor_chr, priv->libDir) < 0)
|
2016-08-03 08:19:10 +00:00
|
|
|
goto cleanup;
|
2009-07-09 17:06:38 +00:00
|
|
|
|
2019-12-02 12:19:44 +00:00
|
|
|
if (!(info->flags & FLAG_REAL_CAPS)) {
|
|
|
|
if (testUpdateQEMUCaps(info, vm, driver.caps) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
if (qemuTestCapsCacheInsert(driver.qemuCapsCache, info->qemuCaps) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
}
|
2015-02-12 13:50:31 +00:00
|
|
|
|
2016-05-26 15:01:58 +00:00
|
|
|
log = virTestLogContentAndReset();
|
2012-02-02 23:16:43 +00:00
|
|
|
VIR_FREE(log);
|
2010-11-29 13:11:53 +00:00
|
|
|
virResetLastError();
|
2010-10-22 16:50:34 +00:00
|
|
|
|
2020-05-15 06:50:31 +00:00
|
|
|
if (!(cmd = testCompareXMLToArgvCreateArgs(&driver, vm, migrateURI, info,
|
2020-05-15 12:24:21 +00:00
|
|
|
flags, false))) {
|
2020-09-22 11:57:39 +00:00
|
|
|
err = virGetLastError();
|
|
|
|
if (!err) {
|
|
|
|
VIR_TEST_DEBUG("no error was reported for expected failure");
|
|
|
|
goto cleanup;
|
|
|
|
}
|
2020-09-24 11:09:47 +00:00
|
|
|
if (flags & FLAG_EXPECT_FAILURE) {
|
|
|
|
g_autofree char *tmperr = g_strdup_printf("%s\n", NULLSTR(err->message));
|
|
|
|
if (virTestCompareToFile(tmperr, info->errfile) >= 0)
|
|
|
|
goto ok;
|
|
|
|
}
|
2016-08-03 08:19:10 +00:00
|
|
|
goto cleanup;
|
2010-10-22 16:50:34 +00:00
|
|
|
}
|
2017-09-07 12:19:37 +00:00
|
|
|
if (flags & FLAG_EXPECT_FAILURE) {
|
|
|
|
VIR_TEST_DEBUG("passed instead of expected failure");
|
|
|
|
goto cleanup;
|
|
|
|
}
|
2010-10-22 16:50:34 +00:00
|
|
|
|
2020-05-21 18:55:01 +00:00
|
|
|
if (testCompareXMLToArgvValidateSchema(&driver, migrateURI, info, flags) < 0)
|
2020-05-15 12:33:10 +00:00
|
|
|
goto cleanup;
|
|
|
|
|
qemu: use line breaks in command line args written to log
The QEMU command line arguments are very long and currently all written
on a single line to /var/log/libvirt/qemu/$GUEST.log. This introduces
logic to add line breaks after every env variable and "-" optional
argument, and every positional argument. This will create a clearer log
file, which will in turn present better in bug reports when people cut +
paste from the log into a bug comment.
An example log file entry now looks like this:
2018-12-14 12:57:03.677+0000: starting up libvirt version: 5.0.0, qemu version: 3.0.0qemu-3.0.0-1.fc29, kernel: 4.19.5-300.fc29.x86_64, hostname: localhost.localdomain
LC_ALL=C \
PATH=/usr/local/bin:/usr/local/sbin:/usr/bin:/usr/sbin \
HOME=/home/berrange \
USER=berrange \
LOGNAME=berrange \
QEMU_AUDIO_DRV=none \
/usr/bin/qemu-system-ppc64 \
-name guest=guest,debug-threads=on \
-S \
-object secret,id=masterKey0,format=raw,file=/home/berrange/.config/libvirt/qemu/lib/domain-33-guest/master-key.aes \
-machine pseries-2.10,accel=tcg,usb=off,dump-guest-core=off \
-m 1024 \
-realtime mlock=off \
-smp 1,sockets=1,cores=1,threads=1 \
-uuid c8a74977-ab18-41d0-ae3b-4041c7fffbcd \
-display none \
-no-user-config \
-nodefaults \
-chardev socket,id=charmonitor,fd=23,server,nowait \
-mon chardev=charmonitor,id=monitor,mode=control \
-rtc base=utc \
-no-shutdown \
-boot strict=on \
-device qemu-xhci,id=usb,bus=pci.0,addr=0x1 \
-device virtio-balloon-pci,id=balloon0,bus=pci.0,addr=0x2 \
-sandbox on,obsolete=deny,elevateprivileges=deny,spawn=deny,resourcecontrol=deny \
-msg timestamp=on
2018-12-14 12:57:03.730+0000: shutting down, reason=failed
Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
2018-12-14 12:07:08 +00:00
|
|
|
if (!(actualargv = virCommandToString(cmd, false)))
|
2016-08-03 08:19:10 +00:00
|
|
|
goto cleanup;
|
2010-11-22 23:09:13 +00:00
|
|
|
|
2019-03-31 14:59:30 +00:00
|
|
|
if (virTestCompareToFile(actualargv, info->outfile) < 0)
|
2016-08-03 08:19:10 +00:00
|
|
|
goto cleanup;
|
2007-07-18 21:34:22 +00:00
|
|
|
|
2016-03-14 09:37:40 +00:00
|
|
|
ret = 0;
|
|
|
|
|
2012-01-13 03:39:24 +00:00
|
|
|
ok:
|
2016-04-13 06:21:42 +00:00
|
|
|
if (ret == 0 && flags & FLAG_EXPECT_FAILURE) {
|
2016-03-14 09:37:40 +00:00
|
|
|
ret = -1;
|
2019-05-03 08:31:02 +00:00
|
|
|
VIR_TEST_DEBUG("Error expected but there wasn't any.");
|
2016-08-03 08:19:10 +00:00
|
|
|
goto cleanup;
|
2016-03-14 09:37:40 +00:00
|
|
|
}
|
2019-08-29 12:04:07 +00:00
|
|
|
if (flags & FLAG_EXPECT_FAILURE) {
|
|
|
|
if ((log = virTestLogContentAndReset()))
|
|
|
|
VIR_TEST_DEBUG("Got expected error: \n%s", log);
|
2012-01-13 03:39:24 +00:00
|
|
|
}
|
2019-08-29 12:04:07 +00:00
|
|
|
virResetLastError();
|
|
|
|
ret = 0;
|
2012-01-13 03:39:24 +00:00
|
|
|
|
2016-08-03 08:19:10 +00:00
|
|
|
cleanup:
|
2012-02-02 23:16:43 +00:00
|
|
|
VIR_FREE(log);
|
2016-07-08 21:45:22 +00:00
|
|
|
virDomainChrSourceDefClear(&monitor_chr);
|
2016-03-17 12:19:35 +00:00
|
|
|
virObjectUnref(vm);
|
2018-02-09 16:06:43 +00:00
|
|
|
virSetConnectSecret(NULL);
|
|
|
|
virSetConnectStorage(NULL);
|
2019-11-27 16:20:02 +00:00
|
|
|
if (info->arch != VIR_ARCH_NONE && info->arch != VIR_ARCH_X86_64)
|
2019-11-26 17:51:22 +00:00
|
|
|
qemuTestSetHostArch(&driver, VIR_ARCH_NONE);
|
2019-11-27 16:20:02 +00:00
|
|
|
|
2016-08-03 08:42:08 +00:00
|
|
|
return ret;
|
2007-07-18 21:34:22 +00:00
|
|
|
}
|
|
|
|
|
2019-10-22 13:26:14 +00:00
|
|
|
static void
|
2019-03-31 15:32:18 +00:00
|
|
|
testInfoSetPaths(struct testQemuInfo *info,
|
2019-03-31 15:08:19 +00:00
|
|
|
const char *suffix)
|
|
|
|
{
|
2019-10-22 13:26:14 +00:00
|
|
|
info->infile = g_strdup_printf("%s/qemuxml2argvdata/%s.xml",
|
|
|
|
abs_srcdir, info->name);
|
|
|
|
info->outfile = g_strdup_printf("%s/qemuxml2argvdata/%s%s.args",
|
|
|
|
abs_srcdir, info->name, suffix ? suffix : "");
|
2020-09-22 11:57:39 +00:00
|
|
|
info->errfile = g_strdup_printf("%s/qemuxml2argvdata/%s%s.err",
|
|
|
|
abs_srcdir, info->name, suffix ? suffix : "");
|
2019-03-31 15:08:19 +00:00
|
|
|
}
|
|
|
|
|
2020-05-07 20:31:04 +00:00
|
|
|
# define FAKEROOTDIRTEMPLATE abs_builddir "/fakerootdir-XXXXXX"
|
|
|
|
|
2008-05-29 15:31:49 +00:00
|
|
|
static int
|
2011-04-29 16:21:20 +00:00
|
|
|
mymain(void)
|
2007-07-18 21:34:22 +00:00
|
|
|
{
|
2019-03-31 16:43:44 +00:00
|
|
|
int ret = 0;
|
2020-07-28 19:57:28 +00:00
|
|
|
g_autofree char *fakerootdir = NULL;
|
2020-07-28 19:58:18 +00:00
|
|
|
g_autoptr(virHashTable) capslatest = NULL;
|
2007-07-18 21:34:22 +00:00
|
|
|
|
2020-05-07 20:31:04 +00:00
|
|
|
fakerootdir = g_strdup(FAKEROOTDIRTEMPLATE);
|
|
|
|
|
|
|
|
if (!g_mkdtemp(fakerootdir)) {
|
|
|
|
fprintf(stderr, "Cannot create fakerootdir");
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
|
|
|
|
g_setenv("LIBVIRT_FAKE_ROOT_DIR", fakerootdir, TRUE);
|
|
|
|
|
2014-02-06 13:24:02 +00:00
|
|
|
/* Set the timezone because we are mocking the time() function.
|
|
|
|
* If we don't do that, then localtime() may return unpredictable
|
|
|
|
* results. In order to detect things that just work by a blind
|
|
|
|
* chance, we need to set an virtual timezone that no libvirt
|
|
|
|
* developer resides in. */
|
2019-12-18 17:16:19 +00:00
|
|
|
if (g_setenv("TZ", "VIR00:30", TRUE) == FALSE) {
|
|
|
|
perror("g_setenv");
|
2014-02-06 13:24:02 +00:00
|
|
|
return EXIT_FAILURE;
|
|
|
|
}
|
|
|
|
|
2015-09-15 06:16:02 +00:00
|
|
|
if (qemuTestDriverInit(&driver) < 0)
|
2014-04-07 06:53:26 +00:00
|
|
|
return EXIT_FAILURE;
|
2015-06-15 18:59:58 +00:00
|
|
|
|
|
|
|
driver.privileged = true;
|
2014-04-07 06:53:26 +00:00
|
|
|
|
2016-09-14 09:44:44 +00:00
|
|
|
VIR_FREE(driver.config->defaultTLSx509certdir);
|
2019-10-20 11:49:46 +00:00
|
|
|
driver.config->defaultTLSx509certdir = g_strdup("/etc/pki/qemu");
|
2013-02-07 16:39:16 +00:00
|
|
|
VIR_FREE(driver.config->vncTLSx509certdir);
|
2019-10-20 11:49:46 +00:00
|
|
|
driver.config->vncTLSx509certdir = g_strdup("/etc/pki/libvirt-vnc");
|
2013-02-07 16:39:16 +00:00
|
|
|
VIR_FREE(driver.config->spiceTLSx509certdir);
|
2019-10-20 11:49:46 +00:00
|
|
|
driver.config->spiceTLSx509certdir = g_strdup("/etc/pki/libvirt-spice");
|
2016-09-14 09:44:44 +00:00
|
|
|
VIR_FREE(driver.config->chardevTLSx509certdir);
|
2019-10-20 11:49:46 +00:00
|
|
|
driver.config->chardevTLSx509certdir = g_strdup("/etc/pki/libvirt-chardev");
|
2017-09-28 17:41:21 +00:00
|
|
|
VIR_FREE(driver.config->vxhsTLSx509certdir);
|
2019-10-20 11:49:46 +00:00
|
|
|
driver.config->vxhsTLSx509certdir = g_strdup("/etc/pki/libvirt-vxhs/dummy,path");
|
2018-06-05 17:27:32 +00:00
|
|
|
VIR_FREE(driver.config->nbdTLSx509certdir);
|
2019-10-20 11:49:46 +00:00
|
|
|
driver.config->nbdTLSx509certdir = g_strdup("/etc/pki/libvirt-nbd/dummy,path");
|
2013-02-07 16:39:16 +00:00
|
|
|
|
2014-07-23 15:37:18 +00:00
|
|
|
VIR_FREE(driver.config->hugetlbfs);
|
2020-09-22 23:04:17 +00:00
|
|
|
driver.config->hugetlbfs = g_new0(virHugeTLBFS, 2);
|
2014-07-23 15:37:21 +00:00
|
|
|
driver.config->nhugetlbfs = 2;
|
2019-10-20 11:49:46 +00:00
|
|
|
driver.config->hugetlbfs[0].mnt_dir = g_strdup("/dev/hugepages2M");
|
|
|
|
driver.config->hugetlbfs[1].mnt_dir = g_strdup("/dev/hugepages1G");
|
2014-07-23 15:37:18 +00:00
|
|
|
driver.config->hugetlbfs[0].size = 2048;
|
|
|
|
driver.config->hugetlbfs[0].deflt = true;
|
2014-07-23 15:37:21 +00:00
|
|
|
driver.config->hugetlbfs[1].size = 1048576;
|
2013-01-10 21:03:14 +00:00
|
|
|
driver.config->spiceTLS = 1;
|
2019-10-20 11:49:46 +00:00
|
|
|
driver.config->spicePassword = g_strdup("123456");
|
2017-02-02 13:27:33 +00:00
|
|
|
VIR_FREE(driver.config->memoryBackingDir);
|
2019-10-20 11:49:46 +00:00
|
|
|
driver.config->memoryBackingDir = g_strdup("/var/lib/libvirt/qemu/ram");
|
2019-02-25 13:15:28 +00:00
|
|
|
VIR_FREE(driver.config->nvramDir);
|
2019-10-20 11:49:46 +00:00
|
|
|
driver.config->nvramDir = g_strdup("/var/lib/libvirt/qemu/nvram");
|
2010-04-16 06:21:23 +00:00
|
|
|
|
2019-03-31 16:43:44 +00:00
|
|
|
capslatest = testQemuGetLatestCaps();
|
2018-08-06 15:41:06 +00:00
|
|
|
if (!capslatest)
|
2018-04-04 07:42:36 +00:00
|
|
|
return EXIT_FAILURE;
|
|
|
|
|
2019-02-25 13:15:28 +00:00
|
|
|
virFileWrapperAddPrefix(SYSCONFDIR "/qemu/firmware",
|
|
|
|
abs_srcdir "/qemufirmwaredata/etc/qemu/firmware");
|
|
|
|
virFileWrapperAddPrefix(PREFIX "/share/qemu/firmware",
|
|
|
|
abs_srcdir "/qemufirmwaredata/usr/share/qemu/firmware");
|
|
|
|
virFileWrapperAddPrefix("/home/user/.config/qemu/firmware",
|
|
|
|
abs_srcdir "/qemufirmwaredata/home/user/.config/qemu/firmware");
|
|
|
|
|
2019-09-23 10:44:39 +00:00
|
|
|
virFileWrapperAddPrefix(SYSCONFDIR "/qemu/vhost-user",
|
|
|
|
abs_srcdir "/qemuvhostuserdata/etc/qemu/vhost-user");
|
|
|
|
virFileWrapperAddPrefix(PREFIX "/share/qemu/vhost-user",
|
|
|
|
abs_srcdir "/qemuvhostuserdata/usr/share/qemu/vhost-user");
|
|
|
|
virFileWrapperAddPrefix("/home/user/.config/qemu/vhost-user",
|
|
|
|
abs_srcdir "/qemuvhostuserdata/home/user/.config/qemu/vhost-user");
|
|
|
|
|
|
|
|
virFileWrapperAddPrefix("/usr/libexec/qemu/vhost-user",
|
|
|
|
abs_srcdir "/qemuvhostuserdata/usr/libexec/qemu/vhost-user");
|
|
|
|
|
2018-04-04 07:42:36 +00:00
|
|
|
/**
|
|
|
|
* The following set of macros allows testing of XML -> argv conversion with a
|
|
|
|
* real set of capabilities gathered from a real qemu copy. It is desired to use
|
|
|
|
* these for positive test cases as it provides combinations of flags which
|
|
|
|
* can be met in real life.
|
|
|
|
*
|
|
|
|
* The capabilities are taken from the real capabilities stored in
|
|
|
|
* tests/qemucapabilitiesdata.
|
|
|
|
*
|
|
|
|
* It is suggested to use the DO_TEST_CAPS_LATEST macro which always takes the
|
|
|
|
* most recent capability set. In cases when the new code would change behaviour
|
|
|
|
* the test cases should be forked using DO_TEST_CAPS_VER with the appropriate
|
|
|
|
* version.
|
|
|
|
*/
|
2019-03-14 13:38:02 +00:00
|
|
|
# define DO_TEST_INTERNAL(_name, _suffix, ...) \
|
2018-04-04 07:42:36 +00:00
|
|
|
do { \
|
2019-03-31 15:32:18 +00:00
|
|
|
static struct testQemuInfo info = { \
|
2019-03-13 23:26:08 +00:00
|
|
|
.name = _name, \
|
2018-04-04 07:42:36 +00:00
|
|
|
}; \
|
2019-03-31 15:32:18 +00:00
|
|
|
if (testQemuInfoSetArgs(&info, capslatest, \
|
|
|
|
__VA_ARGS__, ARG_END) < 0) \
|
2019-03-13 23:15:05 +00:00
|
|
|
return EXIT_FAILURE; \
|
2019-10-22 13:26:14 +00:00
|
|
|
testInfoSetPaths(&info, _suffix); \
|
2019-03-14 13:38:02 +00:00
|
|
|
if (virTestRun("QEMU XML-2-ARGV " _name _suffix, \
|
2018-04-04 07:42:36 +00:00
|
|
|
testCompareXMLToArgv, &info) < 0) \
|
|
|
|
ret = -1; \
|
2019-03-31 15:32:18 +00:00
|
|
|
testQemuInfoClear(&info); \
|
2018-04-04 07:42:36 +00:00
|
|
|
} while (0)
|
|
|
|
|
2019-03-14 13:38:02 +00:00
|
|
|
# define DO_TEST_CAPS_INTERNAL(name, arch, ver, ...) \
|
|
|
|
DO_TEST_INTERNAL(name, "." arch "-" ver, \
|
|
|
|
ARG_CAPS_ARCH, arch, \
|
|
|
|
ARG_CAPS_VER, ver, \
|
|
|
|
__VA_ARGS__)
|
|
|
|
|
2019-03-13 23:15:05 +00:00
|
|
|
# define DO_TEST_CAPS_ARCH_LATEST_FULL(name, arch, ...) \
|
2019-03-13 23:48:06 +00:00
|
|
|
DO_TEST_CAPS_INTERNAL(name, arch, "latest", __VA_ARGS__)
|
2018-08-06 15:41:06 +00:00
|
|
|
|
2019-07-02 15:35:33 +00:00
|
|
|
# define DO_TEST_CAPS_ARCH_VER_FULL(name, arch, ver, ...) \
|
|
|
|
DO_TEST_CAPS_INTERNAL(name, arch, ver, __VA_ARGS__)
|
|
|
|
|
2018-12-07 12:13:58 +00:00
|
|
|
# define DO_TEST_CAPS_ARCH_LATEST(name, arch) \
|
2019-03-13 23:15:05 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL(name, arch, ARG_END)
|
2018-12-07 12:13:58 +00:00
|
|
|
|
2019-07-02 15:33:31 +00:00
|
|
|
# define DO_TEST_CAPS_ARCH_VER(name, arch, ver) \
|
2019-07-02 15:35:33 +00:00
|
|
|
DO_TEST_CAPS_ARCH_VER_FULL(name, arch, ver, ARG_END)
|
2019-07-02 15:33:31 +00:00
|
|
|
|
2018-04-04 07:42:36 +00:00
|
|
|
# define DO_TEST_CAPS_LATEST(name) \
|
2018-08-06 15:41:06 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST(name, "x86_64")
|
2018-04-04 07:42:36 +00:00
|
|
|
|
2019-07-02 15:33:31 +00:00
|
|
|
# define DO_TEST_CAPS_VER(name, ver) \
|
|
|
|
DO_TEST_CAPS_ARCH_VER(name, "x86_64", ver)
|
|
|
|
|
2020-02-05 18:35:50 +00:00
|
|
|
# define DO_TEST_CAPS_LATEST_PPC64(name) \
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST(name, "ppc64")
|
|
|
|
|
2019-07-02 15:37:20 +00:00
|
|
|
# define DO_TEST_CAPS_ARCH_LATEST_FAILURE(name, arch) \
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL(name, arch, \
|
2019-03-13 23:15:05 +00:00
|
|
|
ARG_FLAGS, FLAG_EXPECT_FAILURE)
|
2018-12-07 12:13:58 +00:00
|
|
|
|
2019-07-02 15:37:20 +00:00
|
|
|
# define DO_TEST_CAPS_ARCH_VER_FAILURE(name, arch, ver) \
|
|
|
|
DO_TEST_CAPS_ARCH_VER_FULL(name, arch, ver, \
|
|
|
|
ARG_FLAGS, FLAG_EXPECT_FAILURE)
|
|
|
|
|
|
|
|
# define DO_TEST_CAPS_LATEST_FAILURE(name) \
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FAILURE(name, "x86_64")
|
|
|
|
|
|
|
|
# define DO_TEST_CAPS_VER_FAILURE(name, ver) \
|
|
|
|
DO_TEST_CAPS_ARCH_VER_FAILURE(name, "x86_64", ver)
|
|
|
|
|
|
|
|
# define DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR(name, arch) \
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL(name, arch, \
|
2019-03-13 23:15:05 +00:00
|
|
|
ARG_FLAGS, FLAG_EXPECT_PARSE_ERROR)
|
2018-12-07 12:13:58 +00:00
|
|
|
|
2019-07-02 15:37:20 +00:00
|
|
|
# define DO_TEST_CAPS_ARCH_VER_PARSE_ERROR(name, arch, ver) \
|
|
|
|
DO_TEST_CAPS_ARCH_VER_FULL(name, arch, ver, \
|
|
|
|
ARG_FLAGS, FLAG_EXPECT_PARSE_ERROR)
|
|
|
|
|
|
|
|
# define DO_TEST_CAPS_LATEST_PARSE_ERROR(name) \
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR(name, "x86_64")
|
|
|
|
|
|
|
|
# define DO_TEST_CAPS_VER_PARSE_ERROR(name, ver) \
|
|
|
|
DO_TEST_CAPS_ARCH_VER_PARSE_ERROR(name, "x86_64", ver)
|
|
|
|
|
2019-03-14 13:38:02 +00:00
|
|
|
# define DO_TEST_FULL(name, ...) \
|
|
|
|
DO_TEST_INTERNAL(name, "", \
|
|
|
|
__VA_ARGS__, QEMU_CAPS_LAST)
|
2008-05-09 16:41:19 +00:00
|
|
|
|
2019-03-14 13:43:23 +00:00
|
|
|
/* All the following macros require an explicit QEMU_CAPS_* list
|
|
|
|
* at the end of the argument list, or the NONE placeholder.
|
|
|
|
* */
|
2017-11-03 12:09:47 +00:00
|
|
|
# define DO_TEST(name, ...) \
|
2019-03-13 20:17:10 +00:00
|
|
|
DO_TEST_FULL(name, \
|
2019-03-13 19:18:11 +00:00
|
|
|
ARG_QEMU_CAPS, __VA_ARGS__)
|
2012-07-09 16:29:55 +00:00
|
|
|
|
2017-11-03 12:09:47 +00:00
|
|
|
# define DO_TEST_GIC(name, gic, ...) \
|
2019-03-13 20:17:10 +00:00
|
|
|
DO_TEST_FULL(name, \
|
2019-03-13 19:49:18 +00:00
|
|
|
ARG_GIC, gic, \
|
2019-03-13 19:18:11 +00:00
|
|
|
ARG_QEMU_CAPS, __VA_ARGS__)
|
2016-05-10 10:36:10 +00:00
|
|
|
|
2017-11-03 12:09:47 +00:00
|
|
|
# define DO_TEST_FAILURE(name, ...) \
|
2019-03-13 20:04:44 +00:00
|
|
|
DO_TEST_FULL(name, \
|
|
|
|
ARG_FLAGS, FLAG_EXPECT_FAILURE, \
|
2019-03-13 19:18:11 +00:00
|
|
|
ARG_QEMU_CAPS, __VA_ARGS__)
|
2012-07-09 16:29:55 +00:00
|
|
|
|
2017-11-03 12:09:47 +00:00
|
|
|
# define DO_TEST_PARSE_ERROR(name, ...) \
|
2019-03-13 19:59:42 +00:00
|
|
|
DO_TEST_FULL(name, \
|
2019-03-13 20:04:44 +00:00
|
|
|
ARG_FLAGS, FLAG_EXPECT_PARSE_ERROR | FLAG_EXPECT_FAILURE, \
|
2019-03-13 19:18:11 +00:00
|
|
|
ARG_QEMU_CAPS, __VA_ARGS__)
|
2016-02-25 15:21:13 +00:00
|
|
|
|
2011-02-08 14:22:39 +00:00
|
|
|
# define NONE QEMU_CAPS_LAST
|
2009-01-29 17:27:54 +00:00
|
|
|
|
2009-12-28 15:21:15 +00:00
|
|
|
/* Unset or set all envvars here that are copied in qemudBuildCommandLine
|
|
|
|
* using ADD_ENV_COPY, otherwise these tests may fail due to unexpected
|
|
|
|
* values for these envvars */
|
2019-12-18 17:16:19 +00:00
|
|
|
g_setenv("PATH", "/bin", TRUE);
|
|
|
|
g_setenv("USER", "test", TRUE);
|
|
|
|
g_setenv("LOGNAME", "test", TRUE);
|
|
|
|
g_setenv("HOME", "/home/test", TRUE);
|
2020-09-22 11:57:39 +00:00
|
|
|
g_setenv("LC_ALL", "C", TRUE);
|
2019-12-18 17:16:19 +00:00
|
|
|
g_unsetenv("TMPDIR");
|
|
|
|
g_unsetenv("LD_PRELOAD");
|
|
|
|
g_unsetenv("LD_LIBRARY_PATH");
|
|
|
|
g_unsetenv("QEMU_AUDIO_DRV");
|
|
|
|
g_unsetenv("SDL_AUDIODRIVER");
|
2008-10-10 16:52:20 +00:00
|
|
|
|
2015-11-06 14:29:41 +00:00
|
|
|
DO_TEST("minimal", NONE);
|
2018-03-31 20:15:03 +00:00
|
|
|
DO_TEST("minimal-sandbox",
|
|
|
|
QEMU_CAPS_SECCOMP_BLACKLIST);
|
2015-03-04 10:04:27 +00:00
|
|
|
DO_TEST_PARSE_ERROR("minimal-no-memory", NONE);
|
2015-11-06 14:29:41 +00:00
|
|
|
DO_TEST("minimal-msg-timestamp", QEMU_CAPS_MSG_TIMESTAMP);
|
2018-03-20 22:29:46 +00:00
|
|
|
|
|
|
|
DO_TEST_CAPS_LATEST("genid");
|
|
|
|
DO_TEST_CAPS_LATEST("genid-auto");
|
|
|
|
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("machine-aliases1", NONE);
|
2012-09-14 14:34:33 +00:00
|
|
|
DO_TEST("machine-aliases2", QEMU_CAPS_KVM);
|
2018-03-30 05:49:56 +00:00
|
|
|
DO_TEST("machine-core-on", NONE);
|
2016-08-03 15:20:19 +00:00
|
|
|
driver.config->dumpGuestCore = true;
|
2018-03-30 05:49:56 +00:00
|
|
|
DO_TEST("machine-core-off", NONE);
|
2016-08-03 15:20:19 +00:00
|
|
|
driver.config->dumpGuestCore = false;
|
2016-07-13 12:09:20 +00:00
|
|
|
DO_TEST("machine-smm-opt",
|
|
|
|
QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
|
|
|
|
QEMU_CAPS_DEVICE_PCI_BRIDGE,
|
qemu: initially reserve one open pcie-root-port for hotplug
For machinetypes with a pci-root bus (all legacy PCI), libvirt will
make a "fake" reservation for one extra slot prior to assigning
addresses to unaddressed PCI endpoint devices in the domain. This will
trigger auto-adding of a pci-bridge for the final device to be
assigned an address *if that device would have otherwise instead been
the last device on the last available pci-bridge*; thus it assures
that there will always be at least one slot left open in the domain's
bus topology for expansion (which is important both for hotplug (since
a new pci-bridge can't be added while the guest is running) as well as
for offline additions to the config (since adding a new device might
otherwise in some cases require re-addressing existing devices, which
we want to avoid)).
It's important to note that for the above case (legacy PCI), we must
check for the special case of all slots on all buses being occupied
*prior to assigning any addresses*, and avoid attempting to reserve
the extra address in that case, because there is no free address in
the existing topology, so no place to auto-add a pci-bridge for
expansion (i.e. it would always fail anyway). Since that condition can
only be reached by manual intervention, this is acceptable.
For machinetypes with pcie-root (Q35, aarch64 virt), libvirt's
methodology for automatically expanding the bus topology is different
- pcie-root-ports are plugged into slots (soon to be functions) of
pcie-root as needed, and the new endpoint devices are assigned to the
single slot in each pcie-root-port. This is done so that the devices
are, by default, hotpluggable (the slots of pcie-root don't support
hotplug, but the single slot of the pcie-root-port does). Since
pcie-root-ports can only be plugged into pcie-root, and we don't
auto-assign endpoint devices to the pcie-root slots, this means
topology expansion doesn't compete with endpoint devices for slots, so
we don't need to worry about checking for all "useful" slots being
free *prior* to assigning addresses to new endpoint devices - as a
matter of fact, if we attempt to reserve the open slots before the
used slots, it can lead to errors.
Instead this patch just reserves one slot for a "future potential"
PCIe device after doing the assignment for actual devices, but only
if the only PCI controller defined prior to starting address
assignment was pcie-root, and only if we auto-added at least one PCI
controller during address assignment. This assures two things:
1) that reserving the open slots will only be done when the domain is
initially defined, never at any time after, and
2) that if the user understands enough about PCI controllers that they
are adding them manually, that we don't mess up their plan by
adding extras - if they know enough to add one pcie-root-port, or
to manually assign addresses such that no pcie-root-ports are
needed, they know enough to add extra pcie-root-ports if they want
them (this could be called the "libguestfs clause", since
libguestfs needs to be able to create domains with as few
devices/controllers as possible).
This is set to reserve a single free port for now, but could be
increased in the future if public sentiment goes in that direction
(it's easy to increase later, but essentially impossible to decrease)
2016-09-28 00:37:30 +00:00
|
|
|
QEMU_CAPS_DEVICE_IOH3420,
|
2016-07-13 12:09:20 +00:00
|
|
|
QEMU_CAPS_ICH9_AHCI,
|
|
|
|
QEMU_CAPS_MACHINE_SMM_OPT,
|
|
|
|
QEMU_CAPS_VIRTIO_SCSI);
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST("machine-vmport-opt",
|
2015-04-02 16:44:44 +00:00
|
|
|
QEMU_CAPS_MACHINE_VMPORT_OPT);
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST("default-kvm-host-arch", NONE);
|
|
|
|
DO_TEST("default-qemu-host-arch", NONE);
|
|
|
|
DO_TEST("x86-kvm-32-on-64", NONE);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("boot-cdrom", NONE);
|
|
|
|
DO_TEST("boot-network", NONE);
|
|
|
|
DO_TEST("boot-floppy", NONE);
|
2015-06-22 13:20:55 +00:00
|
|
|
DO_TEST("boot-floppy-q35",
|
qemu: initially reserve one open pcie-root-port for hotplug
For machinetypes with a pci-root bus (all legacy PCI), libvirt will
make a "fake" reservation for one extra slot prior to assigning
addresses to unaddressed PCI endpoint devices in the domain. This will
trigger auto-adding of a pci-bridge for the final device to be
assigned an address *if that device would have otherwise instead been
the last device on the last available pci-bridge*; thus it assures
that there will always be at least one slot left open in the domain's
bus topology for expansion (which is important both for hotplug (since
a new pci-bridge can't be added while the guest is running) as well as
for offline additions to the config (since adding a new device might
otherwise in some cases require re-addressing existing devices, which
we want to avoid)).
It's important to note that for the above case (legacy PCI), we must
check for the special case of all slots on all buses being occupied
*prior to assigning any addresses*, and avoid attempting to reserve
the extra address in that case, because there is no free address in
the existing topology, so no place to auto-add a pci-bridge for
expansion (i.e. it would always fail anyway). Since that condition can
only be reached by manual intervention, this is acceptable.
For machinetypes with pcie-root (Q35, aarch64 virt), libvirt's
methodology for automatically expanding the bus topology is different
- pcie-root-ports are plugged into slots (soon to be functions) of
pcie-root as needed, and the new endpoint devices are assigned to the
single slot in each pcie-root-port. This is done so that the devices
are, by default, hotpluggable (the slots of pcie-root don't support
hotplug, but the single slot of the pcie-root-port does). Since
pcie-root-ports can only be plugged into pcie-root, and we don't
auto-assign endpoint devices to the pcie-root slots, this means
topology expansion doesn't compete with endpoint devices for slots, so
we don't need to worry about checking for all "useful" slots being
free *prior* to assigning addresses to new endpoint devices - as a
matter of fact, if we attempt to reserve the open slots before the
used slots, it can lead to errors.
Instead this patch just reserves one slot for a "future potential"
PCIe device after doing the assignment for actual devices, but only
if the only PCI controller defined prior to starting address
assignment was pcie-root, and only if we auto-added at least one PCI
controller during address assignment. This assures two things:
1) that reserving the open slots will only be done when the domain is
initially defined, never at any time after, and
2) that if the user understands enough about PCI controllers that they
are adding them manually, that we don't mess up their plan by
adding extras - if they know enough to add one pcie-root-port, or
to manually assign addresses such that no pcie-root-ports are
needed, they know enough to add extra pcie-root-ports if they want
them (this could be called the "libguestfs clause", since
libguestfs needs to be able to create domains with as few
devices/controllers as possible).
This is set to reserve a single free port for now, but could be
increased in the future if public sentiment goes in that direction
(it's easy to increase later, but essentially impossible to decrease)
2016-09-28 00:37:30 +00:00
|
|
|
QEMU_CAPS_DEVICE_IOH3420,
|
2015-11-06 14:28:57 +00:00
|
|
|
QEMU_CAPS_ICH9_AHCI);
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST("boot-multi", NONE);
|
|
|
|
DO_TEST("boot-menu-enable", NONE);
|
2014-08-22 12:13:37 +00:00
|
|
|
DO_TEST("boot-menu-enable-with-timeout",
|
2015-11-06 14:28:57 +00:00
|
|
|
QEMU_CAPS_SPLASH_TIMEOUT);
|
2019-12-09 23:15:23 +00:00
|
|
|
DO_TEST_PARSE_ERROR("boot-menu-enable-with-timeout", NONE);
|
2014-08-22 11:39:26 +00:00
|
|
|
DO_TEST_PARSE_ERROR("boot-menu-enable-with-timeout-invalid", NONE);
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST("boot-menu-disable", NONE);
|
|
|
|
DO_TEST("boot-menu-disable-drive", NONE);
|
2012-10-16 10:25:32 +00:00
|
|
|
DO_TEST_PARSE_ERROR("boot-dev+order",
|
2016-05-16 08:29:57 +00:00
|
|
|
QEMU_CAPS_VIRTIO_BLK_SCSI);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("boot-order",
|
2016-05-16 08:29:57 +00:00
|
|
|
QEMU_CAPS_VIRTIO_BLK_SCSI);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("boot-complex",
|
2016-05-16 08:29:57 +00:00
|
|
|
QEMU_CAPS_VIRTIO_BLK_SCSI);
|
qemu: add "-boot strict" to commandline whenever possible
This resolves:
https://bugzilla.redhat.com/show_bug.cgi?id=888635
(which was already closed as CANTFIX because the qemu "-boot strict"
commandline option wasn't available at the time).
Problem: you couldn't have a domain that used PXE to boot, but also
had an un-bootable disk device *even if that disk wasn't listed in the
boot order*, because if PXE timed out (e.g. due to the bridge
forwarding delay), the BIOS would move on to the next target, which
would be the unbootable disk device (again - even though it wasn't
given a boot order), and get stuck at a "BOOT DISK FAILURE, PRESS ANY
KEY" message until a user intervened.
The solution available since sometime around QEMU 1.5, is to add
"-boot strict=on" to *every* qemu command. When this is done, if any
devices have a boot order specified, then QEMU will *only* attempt to
boot from those devices that have an explicit boot order, ignoring the
rest.
2013-12-02 12:07:12 +00:00
|
|
|
DO_TEST("boot-strict",
|
2018-08-09 11:26:17 +00:00
|
|
|
QEMU_CAPS_BOOT_STRICT,
|
2016-05-16 08:29:57 +00:00
|
|
|
QEMU_CAPS_VIRTIO_BLK_SCSI);
|
2012-09-18 10:32:07 +00:00
|
|
|
|
|
|
|
DO_TEST("reboot-timeout-disabled", QEMU_CAPS_REBOOT_TIMEOUT);
|
|
|
|
DO_TEST("reboot-timeout-enabled", QEMU_CAPS_REBOOT_TIMEOUT);
|
2019-12-09 23:15:23 +00:00
|
|
|
DO_TEST_PARSE_ERROR("reboot-timeout-enabled", NONE);
|
2012-09-18 10:32:07 +00:00
|
|
|
|
2017-06-26 17:02:57 +00:00
|
|
|
DO_TEST("bios",
|
2017-11-26 16:35:28 +00:00
|
|
|
QEMU_CAPS_DEVICE_ISA_SERIAL,
|
2017-06-26 17:13:00 +00:00
|
|
|
QEMU_CAPS_SGA);
|
2016-05-20 12:25:22 +00:00
|
|
|
DO_TEST("bios-nvram", NONE);
|
qemu: Enable secure boot
In qemu, enabling this feature boils down to adding the following
onto the command line:
-global driver=cfi.pflash01,property=secure,value=on
However, there are some constraints resulting from the
implementation. For instance, System Management Mode (SMM) is
required to be enabled, the machine type must be q35-2.4 or
later, and the guest should be x86_64. While technically it is
possible to have 32 bit guests with secure boot, some non-trivial
CPU flags tuning is required (for instance lm and nx flags must
be prohibited). Given complexity of our CPU driver, this is not
trivial. Therefore I've chosen to forbid 32 bit guests for now.
If there's ever need, we can refine the check later.
Signed-off-by: Michal Privoznik <mprivozn@redhat.com>
2016-07-13 09:33:52 +00:00
|
|
|
DO_TEST("bios-nvram-secure",
|
|
|
|
QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
|
|
|
|
QEMU_CAPS_DEVICE_PCI_BRIDGE,
|
qemu: initially reserve one open pcie-root-port for hotplug
For machinetypes with a pci-root bus (all legacy PCI), libvirt will
make a "fake" reservation for one extra slot prior to assigning
addresses to unaddressed PCI endpoint devices in the domain. This will
trigger auto-adding of a pci-bridge for the final device to be
assigned an address *if that device would have otherwise instead been
the last device on the last available pci-bridge*; thus it assures
that there will always be at least one slot left open in the domain's
bus topology for expansion (which is important both for hotplug (since
a new pci-bridge can't be added while the guest is running) as well as
for offline additions to the config (since adding a new device might
otherwise in some cases require re-addressing existing devices, which
we want to avoid)).
It's important to note that for the above case (legacy PCI), we must
check for the special case of all slots on all buses being occupied
*prior to assigning any addresses*, and avoid attempting to reserve
the extra address in that case, because there is no free address in
the existing topology, so no place to auto-add a pci-bridge for
expansion (i.e. it would always fail anyway). Since that condition can
only be reached by manual intervention, this is acceptable.
For machinetypes with pcie-root (Q35, aarch64 virt), libvirt's
methodology for automatically expanding the bus topology is different
- pcie-root-ports are plugged into slots (soon to be functions) of
pcie-root as needed, and the new endpoint devices are assigned to the
single slot in each pcie-root-port. This is done so that the devices
are, by default, hotpluggable (the slots of pcie-root don't support
hotplug, but the single slot of the pcie-root-port does). Since
pcie-root-ports can only be plugged into pcie-root, and we don't
auto-assign endpoint devices to the pcie-root slots, this means
topology expansion doesn't compete with endpoint devices for slots, so
we don't need to worry about checking for all "useful" slots being
free *prior* to assigning addresses to new endpoint devices - as a
matter of fact, if we attempt to reserve the open slots before the
used slots, it can lead to errors.
Instead this patch just reserves one slot for a "future potential"
PCIe device after doing the assignment for actual devices, but only
if the only PCI controller defined prior to starting address
assignment was pcie-root, and only if we auto-added at least one PCI
controller during address assignment. This assures two things:
1) that reserving the open slots will only be done when the domain is
initially defined, never at any time after, and
2) that if the user understands enough about PCI controllers that they
are adding them manually, that we don't mess up their plan by
adding extras - if they know enough to add one pcie-root-port, or
to manually assign addresses such that no pcie-root-ports are
needed, they know enough to add extra pcie-root-ports if they want
them (this could be called the "libguestfs clause", since
libguestfs needs to be able to create domains with as few
devices/controllers as possible).
This is set to reserve a single free port for now, but could be
increased in the future if public sentiment goes in that direction
(it's easy to increase later, but essentially impossible to decrease)
2016-09-28 00:37:30 +00:00
|
|
|
QEMU_CAPS_DEVICE_IOH3420,
|
qemu: Enable secure boot
In qemu, enabling this feature boils down to adding the following
onto the command line:
-global driver=cfi.pflash01,property=secure,value=on
However, there are some constraints resulting from the
implementation. For instance, System Management Mode (SMM) is
required to be enabled, the machine type must be q35-2.4 or
later, and the guest should be x86_64. While technically it is
possible to have 32 bit guests with secure boot, some non-trivial
CPU flags tuning is required (for instance lm and nx flags must
be prohibited). Given complexity of our CPU driver, this is not
trivial. Therefore I've chosen to forbid 32 bit guests for now.
If there's ever need, we can refine the check later.
Signed-off-by: Michal Privoznik <mprivozn@redhat.com>
2016-07-13 09:33:52 +00:00
|
|
|
QEMU_CAPS_ICH9_AHCI,
|
|
|
|
QEMU_CAPS_MACHINE_SMM_OPT,
|
|
|
|
QEMU_CAPS_VIRTIO_SCSI);
|
2017-03-09 15:38:56 +00:00
|
|
|
|
|
|
|
/* Make sure all combinations of ACPI and UEFI behave as expected */
|
|
|
|
DO_TEST("q35-acpi-uefi", NONE);
|
|
|
|
DO_TEST_PARSE_ERROR("q35-noacpi-uefi", NONE);
|
|
|
|
DO_TEST("q35-noacpi-nouefi", NONE);
|
|
|
|
DO_TEST("q35-acpi-nouefi", NONE);
|
|
|
|
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST("clock-utc", NONE);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("clock-localtime", NONE);
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST("clock-localtime-basis-localtime", NONE);
|
|
|
|
DO_TEST("clock-variable", NONE);
|
|
|
|
DO_TEST("clock-france", NONE);
|
|
|
|
DO_TEST("clock-hpet-off", NONE);
|
2018-05-03 08:38:42 +00:00
|
|
|
DO_TEST("clock-catchup", QEMU_CAPS_KVM_PIT_TICK_POLICY);
|
2018-09-13 15:40:51 +00:00
|
|
|
DO_TEST("cpu-kvmclock", NONE);
|
|
|
|
DO_TEST("cpu-host-kvmclock", NONE);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("kvmclock", QEMU_CAPS_KVM);
|
2014-01-21 17:50:12 +00:00
|
|
|
DO_TEST("clock-timer-hyperv-rtc", QEMU_CAPS_KVM);
|
2012-07-09 16:29:55 +00:00
|
|
|
|
2018-09-13 15:40:51 +00:00
|
|
|
DO_TEST("cpu-eoi-disabled", NONE);
|
|
|
|
DO_TEST("cpu-eoi-enabled", NONE);
|
2016-05-20 12:41:49 +00:00
|
|
|
DO_TEST("controller-order",
|
2017-06-26 17:13:00 +00:00
|
|
|
QEMU_CAPS_KVM,
|
|
|
|
QEMU_CAPS_PIIX3_USB_UHCI,
|
|
|
|
QEMU_CAPS_CCID_PASSTHRU,
|
|
|
|
QEMU_CAPS_SPICE,
|
|
|
|
QEMU_CAPS_HDA_DUPLEX,
|
|
|
|
QEMU_CAPS_USB_HUB,
|
2017-11-26 16:35:28 +00:00
|
|
|
QEMU_CAPS_DEVICE_ISA_SERIAL,
|
2016-10-10 15:51:38 +00:00
|
|
|
QEMU_CAPS_DEVICE_CIRRUS_VGA);
|
2019-06-12 10:08:06 +00:00
|
|
|
DO_TEST_CAPS_VER("eoi-disabled", "2.7.0");
|
2019-06-11 14:44:36 +00:00
|
|
|
DO_TEST_CAPS_VER("eoi-disabled", "4.0.0");
|
2019-06-12 10:08:06 +00:00
|
|
|
DO_TEST_CAPS_LATEST("eoi-disabled");
|
|
|
|
DO_TEST_CAPS_VER("eoi-enabled", "2.7.0");
|
2019-06-11 14:44:36 +00:00
|
|
|
DO_TEST_CAPS_VER("eoi-enabled", "4.0.0");
|
2019-06-12 10:08:06 +00:00
|
|
|
DO_TEST_CAPS_LATEST("eoi-enabled");
|
|
|
|
DO_TEST_CAPS_VER("pv-spinlock-disabled", "2.7.0");
|
2019-06-11 14:44:36 +00:00
|
|
|
DO_TEST_CAPS_VER("pv-spinlock-disabled", "4.0.0");
|
2019-06-12 10:08:06 +00:00
|
|
|
DO_TEST_CAPS_LATEST("pv-spinlock-disabled");
|
|
|
|
DO_TEST_CAPS_VER("pv-spinlock-enabled", "2.7.0");
|
2019-06-11 14:44:36 +00:00
|
|
|
DO_TEST_CAPS_VER("pv-spinlock-enabled", "4.0.0");
|
2019-06-12 10:08:06 +00:00
|
|
|
DO_TEST_CAPS_LATEST("pv-spinlock-enabled");
|
|
|
|
DO_TEST_CAPS_VER("kvmclock+eoi-disabled", "2.7.0");
|
2019-06-11 14:44:36 +00:00
|
|
|
DO_TEST_CAPS_VER("kvmclock+eoi-disabled", "4.0.0");
|
2019-06-12 10:08:06 +00:00
|
|
|
DO_TEST_CAPS_LATEST("kvmclock+eoi-disabled");
|
2012-09-13 13:27:07 +00:00
|
|
|
|
2019-08-09 14:31:38 +00:00
|
|
|
DO_TEST_CAPS_VER("hyperv", "4.0.0");
|
|
|
|
DO_TEST_CAPS_LATEST("hyperv");
|
|
|
|
DO_TEST_CAPS_VER("hyperv-off", "4.0.0");
|
|
|
|
DO_TEST_CAPS_LATEST("hyperv-off");
|
|
|
|
DO_TEST_CAPS_VER("hyperv-panic", "4.0.0");
|
|
|
|
DO_TEST_CAPS_LATEST("hyperv-panic");
|
2019-08-09 14:31:40 +00:00
|
|
|
DO_TEST_CAPS_LATEST("hyperv-stimer-direct");
|
2012-10-17 12:55:18 +00:00
|
|
|
|
2014-08-21 17:04:45 +00:00
|
|
|
DO_TEST("kvm-features", NONE);
|
|
|
|
DO_TEST("kvm-features-off", NONE);
|
|
|
|
|
2015-01-05 15:52:18 +00:00
|
|
|
DO_TEST("pmu-feature", NONE);
|
|
|
|
DO_TEST("pmu-feature-off", NONE);
|
|
|
|
|
2018-08-08 10:27:18 +00:00
|
|
|
DO_TEST("pages-discard",
|
|
|
|
QEMU_CAPS_OBJECT_MEMORY_FILE,
|
|
|
|
QEMU_CAPS_OBJECT_MEMORY_FILE_DISCARD);
|
2018-08-09 11:26:53 +00:00
|
|
|
DO_TEST("pages-discard-hugepages",
|
|
|
|
QEMU_CAPS_OBJECT_MEMORY_RAM,
|
|
|
|
QEMU_CAPS_OBJECT_MEMORY_FILE,
|
|
|
|
QEMU_CAPS_OBJECT_MEMORY_FILE_DISCARD);
|
2018-08-10 11:14:58 +00:00
|
|
|
DO_TEST("pages-dimm-discard",
|
|
|
|
QEMU_CAPS_DEVICE_PC_DIMM,
|
|
|
|
QEMU_CAPS_OBJECT_MEMORY_FILE,
|
|
|
|
QEMU_CAPS_OBJECT_MEMORY_FILE_DISCARD);
|
2019-12-09 23:15:12 +00:00
|
|
|
DO_TEST("hugepages-default", QEMU_CAPS_OBJECT_MEMORY_FILE);
|
|
|
|
DO_TEST("hugepages-default-2M", QEMU_CAPS_OBJECT_MEMORY_FILE);
|
2020-01-13 08:39:22 +00:00
|
|
|
DO_TEST("hugepages-default-system-size", QEMU_CAPS_OBJECT_MEMORY_FILE);
|
2018-08-09 12:02:16 +00:00
|
|
|
DO_TEST_PARSE_ERROR("hugepages-default-1G-nodeset-2M", NONE);
|
2019-12-09 23:15:12 +00:00
|
|
|
DO_TEST("hugepages-nodeset", QEMU_CAPS_OBJECT_MEMORY_FILE);
|
2018-08-09 12:02:16 +00:00
|
|
|
DO_TEST_PARSE_ERROR("hugepages-nodeset-nonexist",
|
|
|
|
QEMU_CAPS_DEVICE_PC_DIMM,
|
|
|
|
QEMU_CAPS_OBJECT_MEMORY_FILE,
|
|
|
|
QEMU_CAPS_OBJECT_MEMORY_FILE_DISCARD);
|
2018-08-09 09:56:39 +00:00
|
|
|
DO_TEST("hugepages-numa-default",
|
2018-08-07 15:00:02 +00:00
|
|
|
QEMU_CAPS_OBJECT_MEMORY_FILE);
|
2018-08-10 11:08:53 +00:00
|
|
|
DO_TEST("hugepages-numa-default-2M",
|
|
|
|
QEMU_CAPS_OBJECT_MEMORY_RAM,
|
|
|
|
QEMU_CAPS_OBJECT_MEMORY_FILE);
|
2018-08-07 15:00:02 +00:00
|
|
|
DO_TEST("hugepages-numa-default-dimm",
|
qemuBuildMemoryBackendStr: Honour passed @pagesize
So far the argument has not much meaning and was practically ignored.
This is not good since when doing memory hotplug, the size of desired
hugepage backing is passed in that argument. Taking closer look at the
tests I'm fixing reveals the bug. For instance, while the following is
in the test:
<memory model='dimm'>
<source>
<nodemask>1-3</nodemask>
<pagesize unit='KiB'>4096</pagesize>
</source>
<target>
<size unit='KiB'>524287</size>
<node>0</node>
</target>
<address type='dimm' slot='0' base='0x100000000'/>
</memory>
the generated commandline corresponding to this XML was:
-object memory-backend-ram,id=memdimm0,size=536870912,\
host-nodes=1-3,policy=bind
Have you noticed? Yes, memory-backend-ram! Nothing can be further away
from the right answer. The hugepage backing is requested in the XML
and we happily ignore it. This is just not right. It's
memory-backend-file which should have been used:
-object memory-backend-file,id=memdimm0,prealloc=yes,\
mem-path=/dev/hugepages4M/libvirt/qemu,size=536870912,\
host-nodes=1-3,policy=bind
The problem is, that @pagesize passed to qemuBuildMemoryBackendStr
(where this part of commandline is built) was ignored. The hugepage to
back memory was searched only and only by NUMA nodes pinning. This
works only for regular guest NUMA nodes.
Then, I'm changing the hugepages size in the test XMLs too. This is
simply because in the test suite we create dummy mount points just for
2M and 1G hugepages. And in the test 4M was requested. I'm sticking to
2M, but 1G should just work too.
Signed-off-by: Michal Privoznik <mprivozn@redhat.com>
2015-06-25 15:27:29 +00:00
|
|
|
QEMU_CAPS_DEVICE_PC_DIMM,
|
2018-03-29 10:46:23 +00:00
|
|
|
QEMU_CAPS_OBJECT_MEMORY_FILE);
|
2018-08-10 11:05:50 +00:00
|
|
|
DO_TEST("hugepages-numa-nodeset",
|
2018-05-02 15:37:59 +00:00
|
|
|
QEMU_CAPS_OBJECT_MEMORY_RAM,
|
2018-08-08 10:27:18 +00:00
|
|
|
QEMU_CAPS_OBJECT_MEMORY_FILE);
|
2018-08-10 11:10:29 +00:00
|
|
|
DO_TEST("hugepages-numa-nodeset-part",
|
|
|
|
QEMU_CAPS_OBJECT_MEMORY_RAM,
|
2018-08-09 11:26:53 +00:00
|
|
|
QEMU_CAPS_OBJECT_MEMORY_FILE);
|
2018-08-09 12:02:16 +00:00
|
|
|
DO_TEST_PARSE_ERROR("hugepages-numa-nodeset-nonexist",
|
|
|
|
QEMU_CAPS_OBJECT_MEMORY_RAM,
|
|
|
|
QEMU_CAPS_OBJECT_MEMORY_FILE);
|
2018-05-02 15:37:59 +00:00
|
|
|
DO_TEST("hugepages-shared",
|
|
|
|
QEMU_CAPS_OBJECT_MEMORY_RAM,
|
|
|
|
QEMU_CAPS_OBJECT_MEMORY_FILE);
|
2014-09-25 11:28:33 +00:00
|
|
|
DO_TEST_PARSE_ERROR("hugepages-memaccess-invalid", NONE);
|
2017-06-06 08:58:37 +00:00
|
|
|
DO_TEST("hugepages-memaccess", QEMU_CAPS_OBJECT_MEMORY_FILE,
|
|
|
|
QEMU_CAPS_OBJECT_MEMORY_RAM, QEMU_CAPS_DEVICE_PC_DIMM,
|
|
|
|
QEMU_CAPS_NUMA);
|
qemu: Prefer hugepages over mem source='file'
https://bugzilla.redhat.com/show_bug.cgi?id=1214369
Consider the following XML:
<memoryBacking>
<hugepages>
<page size='2048' unit='KiB' nodeset='1'/>
</hugepages>
<source type='file'/>
<access mode='shared'/>
</memoryBacking>
<numa>
<cell id='0' cpus='0-3' memory='512000' unit='KiB'/>
<cell id='1' cpus='4-7' memory='512000' unit='KiB'/>
</numa>
The following cmd line is generated:
-object
memory-backend-file,id=ram-node0,mem-path=/var/lib/libvirt/qemu/ram,
share=yes,size=524288000 -numa node,nodeid=0,cpus=0-3,memdev=ram-node0
-object
memory-backend-file,id=ram-node1,mem-path=/var/lib/libvirt/qemu/ram,
share=yes,size=524288000 -numa node,nodeid=1,cpus=4-7,memdev=ram-node1
This is obviously wrong as for node 1 hugepages should have been
used. The hugepages configuration is more specific than <source
type='file'/>.
Signed-off-by: Michal Privoznik <mprivozn@redhat.com>
2017-06-08 14:45:02 +00:00
|
|
|
DO_TEST("hugepages-memaccess2", QEMU_CAPS_OBJECT_MEMORY_FILE,
|
|
|
|
QEMU_CAPS_OBJECT_MEMORY_RAM, QEMU_CAPS_DEVICE_PC_DIMM,
|
|
|
|
QEMU_CAPS_NUMA);
|
qemu: Validate memory access during validate domain config
Commit 6534b3c4 tried to raise an error when there is no numa
nodes by setting access='shared' in the domain config, but added
a helper called from qemuDomainDeviceDefValidate instead of a
helper called from qemuDomainDefValidate for XML:
<memoryBacking>
<hugepages/>
<access mode='shared'/>
</memoryBacking>
Since there are no memory devices in the test XML, there would
be no validation failure, but the test added was still failing.
Investigating that it turns out that unnecessary XML elements
were causing the failure (no need for <video>, <graphics>,
<pm>, usb controller model "piix3-uhci", disk attribute for
"discard='unmap'", <serial>, <console>, <channel> and a
memballoon model). Removing all those before moving the method
caused the test to succeed.
So this patch moves the validation to the right place and
removes all the unnecessary XML pieces that were causing
a false validation failure.
https://bugzilla.redhat.com/show_bug.cgi?id=1448149#c14
Signed-off-by: Luyao Huang <lhuang@redhat.com>
Reviewed-by: John Ferlan <jferlan@redhat.com>
2018-08-20 09:48:33 +00:00
|
|
|
DO_TEST_PARSE_ERROR("hugepages-memaccess3",
|
|
|
|
QEMU_CAPS_OBJECT_MEMORY_RAM,
|
|
|
|
QEMU_CAPS_OBJECT_MEMORY_FILE);
|
2018-08-09 14:29:17 +00:00
|
|
|
DO_TEST_CAPS_LATEST("hugepages-nvdimm");
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST("nosharepages", QEMU_CAPS_MEM_MERGE);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("disk-cdrom", NONE);
|
2018-05-10 12:16:20 +00:00
|
|
|
DO_TEST_CAPS_VER("disk-cdrom", "2.12.0");
|
2018-07-19 12:07:17 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-cdrom");
|
2019-10-15 13:19:58 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-cdrom-empty-network-invalid");
|
2019-01-28 14:59:36 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-cdrom-bus-other");
|
2015-03-26 22:48:07 +00:00
|
|
|
DO_TEST("disk-iscsi", NONE);
|
2018-07-19 11:46:05 +00:00
|
|
|
DO_TEST("disk-cdrom-network", QEMU_CAPS_KVM);
|
2018-05-10 12:16:20 +00:00
|
|
|
DO_TEST_CAPS_VER("disk-cdrom-network", "2.12.0");
|
2018-07-19 12:07:17 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-cdrom-network");
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("disk-cdrom-tray",
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_VIRTIO_TX_ALG);
|
2018-05-10 12:16:20 +00:00
|
|
|
DO_TEST_CAPS_VER("disk-cdrom-tray", "2.12.0");
|
2018-07-19 12:07:17 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-cdrom-tray");
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("disk-floppy", NONE);
|
2018-05-10 12:16:20 +00:00
|
|
|
DO_TEST_CAPS_VER("disk-floppy", "2.12.0");
|
2018-07-19 15:30:07 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-floppy");
|
2018-05-10 12:16:20 +00:00
|
|
|
DO_TEST_CAPS_VER("disk-floppy-q35-2_9", "2.12.0");
|
2018-08-09 10:28:56 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-floppy-q35-2_9");
|
2018-05-10 12:16:20 +00:00
|
|
|
DO_TEST_CAPS_VER("disk-floppy-q35-2_11", "2.12.0");
|
2018-08-09 10:28:56 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-floppy-q35-2_11");
|
2018-02-21 09:18:19 +00:00
|
|
|
DO_TEST_FAILURE("disk-floppy-pseries",
|
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE);
|
2016-01-13 00:26:40 +00:00
|
|
|
DO_TEST("disk-floppy-tray", NONE);
|
2015-11-06 14:28:57 +00:00
|
|
|
DO_TEST("disk-virtio-s390",
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_VIRTIO_S390);
|
2018-08-09 11:28:16 +00:00
|
|
|
DO_TEST("disk-virtio", NONE);
|
2015-11-06 14:28:57 +00:00
|
|
|
DO_TEST("disk-virtio-ccw",
|
2018-05-07 14:41:11 +00:00
|
|
|
QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
|
2015-11-06 14:28:57 +00:00
|
|
|
DO_TEST("disk-virtio-ccw-many",
|
2018-05-07 14:41:11 +00:00
|
|
|
QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
|
2018-11-08 11:00:26 +00:00
|
|
|
DO_TEST("disk-virtio-s390-zpci",
|
|
|
|
QEMU_CAPS_DEVICE_ZPCI,
|
|
|
|
QEMU_CAPS_CCW,
|
|
|
|
QEMU_CAPS_VIRTIO_S390);
|
2020-09-22 11:57:40 +00:00
|
|
|
DO_TEST_PARSE_ERROR("non-x86_64-timer-error",
|
|
|
|
QEMU_CAPS_VIRTIO_S390);
|
2018-08-09 11:28:16 +00:00
|
|
|
DO_TEST("disk-order", QEMU_CAPS_VIRTIO_BLK_SCSI);
|
2018-07-19 08:29:29 +00:00
|
|
|
DO_TEST("disk-virtio-queues",
|
2017-09-30 17:15:36 +00:00
|
|
|
QEMU_CAPS_VIRTIO_BLK_NUM_QUEUES);
|
2018-08-09 11:28:16 +00:00
|
|
|
DO_TEST("disk-boot-disk", NONE);
|
|
|
|
DO_TEST("disk-boot-cdrom", NONE);
|
|
|
|
DO_TEST("floppy-drive-fat", NONE);
|
2018-05-10 12:16:20 +00:00
|
|
|
DO_TEST_CAPS_VER("floppy-drive-fat", "2.12.0");
|
2018-07-19 15:30:07 +00:00
|
|
|
DO_TEST_CAPS_LATEST("floppy-drive-fat");
|
2018-07-19 08:29:29 +00:00
|
|
|
DO_TEST("disk-readonly-disk", NONE);
|
2018-05-10 12:16:20 +00:00
|
|
|
DO_TEST_CAPS_VER("disk-readonly-disk", "2.12.0");
|
2018-07-19 15:30:07 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-readonly-disk");
|
2018-08-09 11:28:16 +00:00
|
|
|
DO_TEST("disk-fmt-qcow", NONE);
|
|
|
|
DO_TEST_PARSE_ERROR("disk-fmt-cow", NONE);
|
|
|
|
DO_TEST_PARSE_ERROR("disk-fmt-dir", NONE);
|
|
|
|
DO_TEST_PARSE_ERROR("disk-fmt-iso", NONE);
|
2018-05-10 12:16:20 +00:00
|
|
|
DO_TEST_CAPS_VER("disk-shared", "2.12.0");
|
2018-07-19 15:30:07 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-shared");
|
2018-07-19 08:29:29 +00:00
|
|
|
DO_TEST_PARSE_ERROR("disk-shared-qcow", NONE);
|
|
|
|
DO_TEST("disk-error-policy", NONE);
|
2018-05-10 12:16:20 +00:00
|
|
|
DO_TEST_CAPS_VER("disk-error-policy", "2.12.0");
|
2018-07-19 08:29:29 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-error-policy");
|
2020-03-31 18:15:13 +00:00
|
|
|
DO_TEST_CAPS_ARCH_VER("disk-error-policy-s390x", "s390x", "2.12.0");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("disk-error-policy-s390x", "s390x");
|
2019-01-28 13:11:36 +00:00
|
|
|
DO_TEST_CAPS_VER("disk-cache", "1.5.3");
|
2018-07-19 12:51:21 +00:00
|
|
|
DO_TEST_CAPS_VER("disk-cache", "2.6.0");
|
|
|
|
DO_TEST_CAPS_VER("disk-cache", "2.7.0");
|
2018-05-10 12:16:20 +00:00
|
|
|
DO_TEST_CAPS_VER("disk-cache", "2.12.0");
|
2018-07-19 12:51:21 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-cache");
|
2020-09-24 10:23:24 +00:00
|
|
|
DO_TEST_CAPS_ARCH_VER_PARSE_ERROR("disk-transient", "x86_64", "4.1.0");
|
|
|
|
DO_TEST_CAPS_LATEST("disk-transient");
|
2018-07-19 08:29:29 +00:00
|
|
|
DO_TEST("disk-network-nbd", NONE);
|
2018-05-10 12:16:20 +00:00
|
|
|
DO_TEST_CAPS_VER("disk-network-nbd", "2.12.0");
|
2018-07-19 14:29:19 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-network-nbd");
|
2018-07-19 13:39:23 +00:00
|
|
|
DO_TEST("disk-network-iscsi", QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_BLOCK);
|
2018-08-07 13:32:20 +00:00
|
|
|
DO_TEST("disk-network-iscsi-modern",
|
|
|
|
QEMU_CAPS_VIRTIO_SCSI,
|
|
|
|
QEMU_CAPS_SCSI_BLOCK,
|
|
|
|
QEMU_CAPS_ISCSI_PASSWORD_SECRET);
|
2018-05-10 12:16:20 +00:00
|
|
|
DO_TEST_CAPS_VER("disk-network-iscsi", "2.12.0");
|
2018-07-19 14:19:32 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-network-iscsi");
|
2018-07-19 08:29:29 +00:00
|
|
|
DO_TEST_PARSE_ERROR("disk-network-iscsi-auth-secrettype-invalid", NONE);
|
|
|
|
DO_TEST_PARSE_ERROR("disk-network-iscsi-auth-wrong-secrettype", NONE);
|
|
|
|
DO_TEST_PARSE_ERROR("disk-network-source-auth-both", NONE);
|
|
|
|
DO_TEST("disk-network-gluster",
|
2016-10-14 03:37:45 +00:00
|
|
|
QEMU_CAPS_GLUSTER_DEBUG_LEVEL);
|
2018-05-10 12:16:20 +00:00
|
|
|
DO_TEST_CAPS_VER("disk-network-gluster", "2.12.0");
|
2018-07-19 15:30:07 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-network-gluster");
|
2018-07-19 15:07:45 +00:00
|
|
|
DO_TEST_CAPS_VER("disk-network-rbd", "2.5.0");
|
2018-05-10 12:16:20 +00:00
|
|
|
DO_TEST_CAPS_VER("disk-network-rbd", "2.12.0");
|
2018-07-19 15:07:45 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-network-rbd");
|
|
|
|
DO_TEST_FAILURE("disk-network-rbd-no-colon", NONE);
|
2018-07-19 08:29:29 +00:00
|
|
|
DO_TEST("disk-network-sheepdog", NONE);
|
2018-05-10 12:16:20 +00:00
|
|
|
DO_TEST_CAPS_VER("disk-network-sheepdog", "2.12.0");
|
2018-07-19 15:30:07 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-network-sheepdog");
|
2018-07-19 08:29:29 +00:00
|
|
|
DO_TEST("disk-network-source-auth", NONE);
|
2018-05-10 12:16:20 +00:00
|
|
|
DO_TEST_CAPS_VER("disk-network-source-auth", "2.12.0");
|
2018-07-19 15:30:07 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-network-source-auth");
|
2018-07-19 08:29:29 +00:00
|
|
|
DO_TEST("disk-network-vxhs", QEMU_CAPS_VXHS);
|
qemu: Add TLS support for Veritas HyperScale (VxHS)
Alter qemu command line generation in order to possibly add TLS for
a suitably configured domain.
Sample TLS args generated by libvirt -
-object tls-creds-x509,id=objvirtio-disk0_tls0,dir=/etc/pki/qemu,\
endpoint=client,verify-peer=yes \
-drive file.driver=vxhs,file.tls-creds=objvirtio-disk0_tls0,\
file.vdisk-id=eb90327c-8302-4725-9e1b-4e85ed4dc251,\
file.server.type=tcp,file.server.host=192.168.0.1,\
file.server.port=9999,format=raw,if=none,\
id=drive-virtio-disk0,cache=none \
-device virtio-blk-pci,bus=pci.0,addr=0x4,drive=drive-virtio-disk0,\
id=virtio-disk0
Update the qemuxml2argvtest with a couple of examples. One for a
simple case and the other a bit more complex where multiple VxHS disks
are added where at least one uses a VxHS that doesn't require TLS
credentials and thus sets the domain disk source attribute "tls = 'no'".
Update the hotplug to be able to handle processing the tlsAlias whether
it's to add the TLS object when hotplugging a disk or to remove the TLS
object when hot unplugging a disk. The hot plug/unplug code is largely
generic, but the addition code does make the VXHS specific checks only
because it needs to grab the correct config directory and generate the
object as the command line would do.
Signed-off-by: Ashish Mittal <Ashish.Mittal@veritas.com>
Signed-off-by: John Ferlan <jferlan@redhat.com>
2017-08-30 15:06:00 +00:00
|
|
|
driver.config->vxhsTLS = 1;
|
2020-06-30 15:08:44 +00:00
|
|
|
driver.config->nbdTLSx509secretUUID = g_strdup("6fd3f62d-9fe7-4a4e-a869-7acd6376d8ea");
|
|
|
|
driver.config->vxhsTLSx509secretUUID = g_strdup("6fd3f62d-9fe7-4a4e-a869-7acd6376d8ea");
|
2020-07-30 15:29:44 +00:00
|
|
|
DO_TEST_CAPS_VER("disk-network-tlsx509-nbd", "2.12.0");
|
|
|
|
DO_TEST_CAPS_VER("disk-network-tlsx509-vxhs", "2.12.0");
|
|
|
|
DO_TEST_CAPS_LATEST("disk-network-tlsx509-nbd");
|
2020-07-30 15:46:03 +00:00
|
|
|
DO_TEST_CAPS_VER("disk-network-tlsx509-vxhs", "5.0.0");
|
2020-03-09 11:38:21 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-network-http");
|
qemu: Add TLS support for Veritas HyperScale (VxHS)
Alter qemu command line generation in order to possibly add TLS for
a suitably configured domain.
Sample TLS args generated by libvirt -
-object tls-creds-x509,id=objvirtio-disk0_tls0,dir=/etc/pki/qemu,\
endpoint=client,verify-peer=yes \
-drive file.driver=vxhs,file.tls-creds=objvirtio-disk0_tls0,\
file.vdisk-id=eb90327c-8302-4725-9e1b-4e85ed4dc251,\
file.server.type=tcp,file.server.host=192.168.0.1,\
file.server.port=9999,format=raw,if=none,\
id=drive-virtio-disk0,cache=none \
-device virtio-blk-pci,bus=pci.0,addr=0x4,drive=drive-virtio-disk0,\
id=virtio-disk0
Update the qemuxml2argvtest with a couple of examples. One for a
simple case and the other a bit more complex where multiple VxHS disks
are added where at least one uses a VxHS that doesn't require TLS
credentials and thus sets the domain disk source attribute "tls = 'no'".
Update the hotplug to be able to handle processing the tlsAlias whether
it's to add the TLS object when hotplugging a disk or to remove the TLS
object when hot unplugging a disk. The hot plug/unplug code is largely
generic, but the addition code does make the VXHS specific checks only
because it needs to grab the correct config directory and generate the
object as the command line would do.
Signed-off-by: Ashish Mittal <Ashish.Mittal@veritas.com>
Signed-off-by: John Ferlan <jferlan@redhat.com>
2017-08-30 15:06:00 +00:00
|
|
|
driver.config->vxhsTLS = 0;
|
|
|
|
VIR_FREE(driver.config->vxhsTLSx509certdir);
|
2018-08-09 11:26:17 +00:00
|
|
|
DO_TEST("disk-no-boot", NONE);
|
2019-06-21 13:07:22 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-nvme");
|
2015-06-26 17:48:06 +00:00
|
|
|
DO_TEST_PARSE_ERROR("disk-device-lun-type-invalid",
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_VIRTIO_SCSI);
|
2019-09-30 13:41:00 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-attaching-partition-nosupport");
|
2020-10-08 19:35:58 +00:00
|
|
|
DO_TEST_PARSE_ERROR("disk-usb-nosupport", NONE);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("disk-usb-device",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_USB_STORAGE);
|
2013-08-23 10:38:11 +00:00
|
|
|
DO_TEST("disk-usb-device-removable",
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_DEVICE_USB_STORAGE,
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_USB_STORAGE_REMOVABLE);
|
2020-10-08 19:35:58 +00:00
|
|
|
DO_TEST_PARSE_ERROR("disk-usb-pci",
|
|
|
|
QEMU_CAPS_DEVICE_USB_STORAGE);
|
2019-01-28 11:59:49 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-scsi");
|
2019-01-28 10:25:12 +00:00
|
|
|
DO_TEST_CAPS_VER("disk-scsi-device-auto", "1.5.3");
|
|
|
|
DO_TEST_CAPS_LATEST("disk-scsi-device-auto");
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("disk-scsi-disk-split",
|
2019-01-28 13:29:10 +00:00
|
|
|
QEMU_CAPS_SCSI_LSI, QEMU_CAPS_VIRTIO_SCSI);
|
2012-09-11 08:57:04 +00:00
|
|
|
DO_TEST("disk-scsi-disk-wwn",
|
2019-01-28 13:29:10 +00:00
|
|
|
QEMU_CAPS_SCSI_LSI, QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_DISK_WWN);
|
2012-12-06 10:23:02 +00:00
|
|
|
DO_TEST("disk-scsi-disk-vpd",
|
2019-01-28 13:29:10 +00:00
|
|
|
QEMU_CAPS_SCSI_LSI, QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_DISK_WWN);
|
2020-05-04 16:53:01 +00:00
|
|
|
DO_TEST_PARSE_ERROR("disk-scsi-disk-vpd-build-error",
|
2019-01-28 13:29:10 +00:00
|
|
|
QEMU_CAPS_SCSI_LSI, QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_SCSI_DISK_WWN);
|
2019-01-28 09:47:21 +00:00
|
|
|
DO_TEST_CAPS_LATEST("controller-virtio-scsi");
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("disk-sata-device",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_ICH9_AHCI);
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST("disk-aio", NONE);
|
2018-05-10 12:16:20 +00:00
|
|
|
DO_TEST_CAPS_VER("disk-aio", "2.12.0");
|
2018-07-19 12:14:11 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-aio");
|
2020-04-21 12:19:37 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-aio-io_uring");
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST("disk-source-pool", NONE);
|
|
|
|
DO_TEST("disk-source-pool-mode", NONE);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("disk-ioeventfd",
|
2015-11-06 14:28:57 +00:00
|
|
|
QEMU_CAPS_VIRTIO_IOEVENTFD,
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_VIRTIO_TX_ALG,
|
2016-05-16 08:29:57 +00:00
|
|
|
QEMU_CAPS_VIRTIO_BLK_SCSI);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("disk-copy_on_read",
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_VIRTIO_TX_ALG,
|
2016-05-16 08:29:57 +00:00
|
|
|
QEMU_CAPS_VIRTIO_BLK_SCSI);
|
2018-05-10 12:16:20 +00:00
|
|
|
DO_TEST_CAPS_VER("disk-copy_on_read", "2.12.0");
|
2018-07-19 11:49:39 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-copy_on_read");
|
2020-05-04 16:53:31 +00:00
|
|
|
DO_TEST_CAPS_VER("disk-discard", "4.1.0");
|
|
|
|
DO_TEST_CAPS_LATEST("disk-discard");
|
2018-05-10 12:16:20 +00:00
|
|
|
DO_TEST_CAPS_VER("disk-detect-zeroes", "2.12.0");
|
2018-07-19 12:12:19 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-detect-zeroes");
|
2015-11-06 18:20:20 +00:00
|
|
|
DO_TEST("disk-snapshot", NONE);
|
2016-05-27 10:34:14 +00:00
|
|
|
DO_TEST_PARSE_ERROR("disk-same-targets",
|
|
|
|
QEMU_CAPS_SCSI_LSI,
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_USB_STORAGE);
|
2018-07-19 08:29:29 +00:00
|
|
|
DO_TEST_PARSE_ERROR("disk-address-conflict",
|
2016-11-30 11:47:05 +00:00
|
|
|
QEMU_CAPS_ICH9_AHCI);
|
|
|
|
DO_TEST_PARSE_ERROR("disk-hostdev-scsi-address-conflict",
|
2018-09-18 10:29:10 +00:00
|
|
|
QEMU_CAPS_VIRTIO_SCSI);
|
2016-11-30 11:47:05 +00:00
|
|
|
DO_TEST_PARSE_ERROR("hostdevs-drive-address-conflict",
|
2018-09-18 10:29:10 +00:00
|
|
|
QEMU_CAPS_VIRTIO_SCSI);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("event_idx",
|
2011-08-13 06:32:45 +00:00
|
|
|
QEMU_CAPS_VIRTIO_BLK_EVENT_IDX,
|
|
|
|
QEMU_CAPS_VIRTIO_NET_EVENT_IDX,
|
2016-05-16 08:29:57 +00:00
|
|
|
QEMU_CAPS_VIRTIO_BLK_SCSI);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("virtio-lun",
|
2016-05-16 08:29:57 +00:00
|
|
|
QEMU_CAPS_VIRTIO_BLK_SCSI);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("disk-scsi-lun-passthrough",
|
2016-05-16 08:29:57 +00:00
|
|
|
QEMU_CAPS_SCSI_BLOCK,
|
2013-03-14 18:32:24 +00:00
|
|
|
QEMU_CAPS_SCSI_LSI, QEMU_CAPS_VIRTIO_SCSI);
|
2015-02-23 11:34:23 +00:00
|
|
|
DO_TEST("disk-serial",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_KVM);
|
2016-11-29 12:11:32 +00:00
|
|
|
DO_TEST_PARSE_ERROR("disk-fdc-incompatible-address",
|
|
|
|
NONE);
|
|
|
|
DO_TEST_PARSE_ERROR("disk-ide-incompatible-address",
|
|
|
|
NONE);
|
|
|
|
DO_TEST_PARSE_ERROR("disk-sata-incompatible-address",
|
|
|
|
QEMU_CAPS_ICH9_AHCI);
|
|
|
|
DO_TEST_PARSE_ERROR("disk-scsi-incompatible-address",
|
|
|
|
QEMU_CAPS_VIRTIO_SCSI);
|
2018-06-19 11:16:54 +00:00
|
|
|
DO_TEST_CAPS_VER("disk-backing-chains-index", "2.12.0");
|
|
|
|
DO_TEST_CAPS_LATEST("disk-backing-chains-index");
|
|
|
|
DO_TEST_CAPS_VER("disk-backing-chains-noindex", "2.12.0");
|
|
|
|
DO_TEST_CAPS_LATEST("disk-backing-chains-noindex");
|
2011-06-20 08:26:47 +00:00
|
|
|
|
2020-02-05 17:18:39 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-slices");
|
|
|
|
|
2020-05-06 09:40:18 +00:00
|
|
|
DO_TEST_CAPS_ARCH_VER("disk-arm-virtio-sd", "aarch64", "4.0.0");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("disk-arm-virtio-sd", "aarch64");
|
|
|
|
|
2018-06-30 14:23:01 +00:00
|
|
|
DO_TEST("graphics-egl-headless",
|
|
|
|
QEMU_CAPS_EGL_HEADLESS,
|
|
|
|
QEMU_CAPS_DEVICE_CIRRUS_VGA);
|
2018-11-15 10:38:00 +00:00
|
|
|
DO_TEST_CAPS_LATEST("graphics-egl-headless");
|
|
|
|
DO_TEST_CAPS_LATEST("graphics-egl-headless-rendernode");
|
2018-06-30 14:23:01 +00:00
|
|
|
|
2016-10-10 15:51:38 +00:00
|
|
|
DO_TEST("graphics-vnc", QEMU_CAPS_VNC, QEMU_CAPS_DEVICE_CIRRUS_VGA);
|
|
|
|
DO_TEST("graphics-vnc-socket", QEMU_CAPS_VNC, QEMU_CAPS_DEVICE_CIRRUS_VGA);
|
2018-09-12 12:29:13 +00:00
|
|
|
DO_TEST("graphics-vnc-websocket",
|
|
|
|
QEMU_CAPS_VNC,
|
2016-10-10 15:51:38 +00:00
|
|
|
QEMU_CAPS_DEVICE_CIRRUS_VGA);
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST("graphics-vnc-policy", QEMU_CAPS_VNC,
|
2016-10-10 15:51:38 +00:00
|
|
|
QEMU_CAPS_DEVICE_CIRRUS_VGA);
|
|
|
|
DO_TEST("graphics-vnc-no-listen-attr", QEMU_CAPS_VNC,
|
|
|
|
QEMU_CAPS_DEVICE_CIRRUS_VGA);
|
|
|
|
DO_TEST("graphics-vnc-remove-generated-socket", QEMU_CAPS_VNC,
|
|
|
|
QEMU_CAPS_DEVICE_CIRRUS_VGA);
|
2016-05-19 08:53:55 +00:00
|
|
|
driver.config->vncAutoUnixSocket = true;
|
2016-10-10 15:51:38 +00:00
|
|
|
DO_TEST("graphics-vnc-auto-socket-cfg", QEMU_CAPS_VNC,
|
|
|
|
QEMU_CAPS_DEVICE_CIRRUS_VGA);
|
2016-05-19 08:53:55 +00:00
|
|
|
driver.config->vncAutoUnixSocket = false;
|
2016-10-10 15:51:38 +00:00
|
|
|
DO_TEST("graphics-vnc-socket", QEMU_CAPS_VNC, QEMU_CAPS_DEVICE_CIRRUS_VGA);
|
|
|
|
DO_TEST("graphics-vnc-auto-socket", QEMU_CAPS_VNC,
|
|
|
|
QEMU_CAPS_DEVICE_CIRRUS_VGA);
|
|
|
|
DO_TEST("graphics-vnc-none", QEMU_CAPS_VNC, QEMU_CAPS_DEVICE_CIRRUS_VGA);
|
2017-07-21 17:55:35 +00:00
|
|
|
DO_TEST("graphics-vnc-socket-new-cmdline", QEMU_CAPS_VNC,
|
|
|
|
QEMU_CAPS_DEVICE_CIRRUS_VGA, QEMU_CAPS_VNC_MULTI_SERVERS);
|
2009-03-16 13:54:26 +00:00
|
|
|
|
2013-01-10 21:03:14 +00:00
|
|
|
driver.config->vncSASL = 1;
|
|
|
|
VIR_FREE(driver.config->vncSASLdir);
|
2019-10-18 11:27:03 +00:00
|
|
|
driver.config->vncSASLdir = g_strdup("/root/.sasl2");
|
2016-10-10 15:51:38 +00:00
|
|
|
DO_TEST("graphics-vnc-sasl", QEMU_CAPS_VNC, QEMU_CAPS_DEVICE_CIRRUS_VGA);
|
2013-01-10 21:03:14 +00:00
|
|
|
driver.config->vncTLS = 1;
|
|
|
|
driver.config->vncTLSx509verify = 1;
|
2016-10-10 15:51:38 +00:00
|
|
|
DO_TEST("graphics-vnc-tls", QEMU_CAPS_VNC, QEMU_CAPS_DEVICE_CIRRUS_VGA);
|
2018-07-16 13:15:21 +00:00
|
|
|
DO_TEST_CAPS_VER("graphics-vnc-tls", "2.4.0");
|
|
|
|
DO_TEST_CAPS_LATEST("graphics-vnc-tls");
|
2019-10-20 11:49:46 +00:00
|
|
|
driver.config->vncTLSx509secretUUID = g_strdup("6fd3f62d-9fe7-4a4e-a869-7acd6376d8ea");
|
2019-01-14 13:20:01 +00:00
|
|
|
DO_TEST_CAPS_LATEST("graphics-vnc-tls-secret");
|
|
|
|
VIR_FREE(driver.config->vncTLSx509secretUUID);
|
2013-01-10 21:03:14 +00:00
|
|
|
driver.config->vncSASL = driver.config->vncTLSx509verify = driver.config->vncTLS = 0;
|
2013-02-04 14:54:33 +00:00
|
|
|
VIR_FREE(driver.config->vncSASLdir);
|
|
|
|
VIR_FREE(driver.config->vncTLSx509certdir);
|
2018-06-30 14:23:01 +00:00
|
|
|
DO_TEST("graphics-vnc-egl-headless",
|
|
|
|
QEMU_CAPS_VNC,
|
|
|
|
QEMU_CAPS_EGL_HEADLESS,
|
|
|
|
QEMU_CAPS_DEVICE_CIRRUS_VGA);
|
2009-03-16 13:54:26 +00:00
|
|
|
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST("graphics-sdl",
|
|
|
|
QEMU_CAPS_DEVICE_VGA);
|
2018-12-07 13:53:46 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("graphics-sdl-egl-headless");
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST("graphics-sdl-fullscreen",
|
2016-10-10 15:51:38 +00:00
|
|
|
QEMU_CAPS_DEVICE_CIRRUS_VGA);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("graphics-spice",
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_SPICE,
|
2014-01-16 16:11:15 +00:00
|
|
|
QEMU_CAPS_DEVICE_QXL,
|
|
|
|
QEMU_CAPS_SPICE_FILE_XFER_DISABLE);
|
2016-03-16 11:11:58 +00:00
|
|
|
DO_TEST("graphics-spice-no-args",
|
2016-10-10 15:51:38 +00:00
|
|
|
QEMU_CAPS_SPICE, QEMU_CAPS_DEVICE_CIRRUS_VGA);
|
2012-02-24 14:13:06 +00:00
|
|
|
driver.config->spiceSASL = 1;
|
2019-10-18 11:27:03 +00:00
|
|
|
driver.config->spiceSASLdir = g_strdup("/root/.sasl2");
|
2012-02-24 14:13:06 +00:00
|
|
|
DO_TEST("graphics-spice-sasl",
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_SPICE,
|
2012-02-24 14:13:06 +00:00
|
|
|
QEMU_CAPS_DEVICE_QXL);
|
|
|
|
VIR_FREE(driver.config->spiceSASLdir);
|
|
|
|
driver.config->spiceSASL = 0;
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("graphics-spice-agentmouse",
|
2016-10-11 15:46:39 +00:00
|
|
|
QEMU_CAPS_DEVICE_QXL,
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_SPICE,
|
2016-10-10 15:51:38 +00:00
|
|
|
QEMU_CAPS_DEVICE_CIRRUS_VGA);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("graphics-spice-compression",
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_SPICE,
|
2012-12-14 07:08:01 +00:00
|
|
|
QEMU_CAPS_DEVICE_QXL);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("graphics-spice-timeout",
|
2015-11-06 14:28:57 +00:00
|
|
|
QEMU_CAPS_KVM,
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_SPICE,
|
2016-10-10 15:51:38 +00:00
|
|
|
QEMU_CAPS_DEVICE_QXL,
|
|
|
|
QEMU_CAPS_DEVICE_VGA);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("graphics-spice-qxl-vga",
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_SPICE,
|
2012-12-14 07:08:01 +00:00
|
|
|
QEMU_CAPS_DEVICE_QXL);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("graphics-spice-usb-redir",
|
2015-11-09 15:39:54 +00:00
|
|
|
QEMU_CAPS_SPICE,
|
2017-06-26 17:13:00 +00:00
|
|
|
QEMU_CAPS_USB_HUB,
|
|
|
|
QEMU_CAPS_ICH9_USB_EHCI1,
|
|
|
|
QEMU_CAPS_USB_REDIR,
|
|
|
|
QEMU_CAPS_DEVICE_CIRRUS_VGA);
|
2014-01-16 16:11:15 +00:00
|
|
|
DO_TEST("graphics-spice-agent-file-xfer",
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_SPICE,
|
2014-01-16 16:11:15 +00:00
|
|
|
QEMU_CAPS_DEVICE_QXL,
|
|
|
|
QEMU_CAPS_SPICE_FILE_XFER_DISABLE);
|
2016-06-08 13:18:59 +00:00
|
|
|
DO_TEST("graphics-spice-socket",
|
|
|
|
QEMU_CAPS_SPICE,
|
2016-10-10 15:51:38 +00:00
|
|
|
QEMU_CAPS_SPICE_UNIX,
|
|
|
|
QEMU_CAPS_DEVICE_CIRRUS_VGA);
|
2016-06-08 13:18:59 +00:00
|
|
|
DO_TEST("graphics-spice-auto-socket",
|
|
|
|
QEMU_CAPS_SPICE,
|
2016-10-10 15:51:38 +00:00
|
|
|
QEMU_CAPS_SPICE_UNIX,
|
|
|
|
QEMU_CAPS_DEVICE_CIRRUS_VGA);
|
2016-05-18 12:11:20 +00:00
|
|
|
driver.config->spiceAutoUnixSocket = true;
|
|
|
|
DO_TEST("graphics-spice-auto-socket-cfg",
|
|
|
|
QEMU_CAPS_SPICE,
|
2016-10-10 15:51:38 +00:00
|
|
|
QEMU_CAPS_SPICE_UNIX,
|
|
|
|
QEMU_CAPS_DEVICE_CIRRUS_VGA);
|
2016-05-18 12:11:20 +00:00
|
|
|
driver.config->spiceAutoUnixSocket = false;
|
2018-06-30 14:23:01 +00:00
|
|
|
DO_TEST("graphics-spice-egl-headless",
|
|
|
|
QEMU_CAPS_SPICE,
|
|
|
|
QEMU_CAPS_EGL_HEADLESS,
|
|
|
|
QEMU_CAPS_DEVICE_QXL);
|
2018-12-07 13:53:46 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("graphics-spice-invalid-egl-headless");
|
2018-11-14 15:48:27 +00:00
|
|
|
DO_TEST_CAPS_LATEST("graphics-spice-gl-auto-rendernode");
|
2011-02-08 14:22:39 +00:00
|
|
|
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("input-usbmouse", NONE);
|
|
|
|
DO_TEST("input-usbtablet", NONE);
|
|
|
|
DO_TEST("misc-acpi", NONE);
|
2016-01-04 22:57:06 +00:00
|
|
|
DO_TEST("misc-disable-s3", QEMU_CAPS_PIIX_DISABLE_S3);
|
|
|
|
DO_TEST("misc-disable-suspends", QEMU_CAPS_PIIX_DISABLE_S3, QEMU_CAPS_PIIX_DISABLE_S4);
|
|
|
|
DO_TEST("misc-enable-s4", QEMU_CAPS_PIIX_DISABLE_S4);
|
2019-12-09 23:15:22 +00:00
|
|
|
DO_TEST_PARSE_ERROR("misc-enable-s4", NONE);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("misc-no-reboot", NONE);
|
2015-11-06 14:29:52 +00:00
|
|
|
DO_TEST("misc-uuid", NONE);
|
2014-09-16 08:06:50 +00:00
|
|
|
DO_TEST_PARSE_ERROR("vhost_queues-invalid", NONE);
|
2018-07-04 13:28:14 +00:00
|
|
|
DO_TEST("net-vhostuser", QEMU_CAPS_CHARDEV_FD_PASS);
|
2018-10-04 17:44:55 +00:00
|
|
|
DO_TEST_CAPS_VER("net-vhostuser", "2.5.0");
|
|
|
|
DO_TEST_CAPS_LATEST("net-vhostuser");
|
2015-02-26 11:45:57 +00:00
|
|
|
DO_TEST("net-vhostuser-multiq",
|
2018-03-28 21:36:13 +00:00
|
|
|
QEMU_CAPS_VHOSTUSER_MULTIQUEUE);
|
|
|
|
DO_TEST_FAILURE("net-vhostuser-multiq", NONE);
|
2016-09-26 08:32:44 +00:00
|
|
|
DO_TEST_FAILURE("net-vhostuser-fail",
|
|
|
|
QEMU_CAPS_VHOSTUSER_MULTIQUEUE);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("net-user", NONE);
|
2019-08-08 14:55:14 +00:00
|
|
|
DO_TEST_CAPS_ARCH_VER_FULL("net-user", "x86_64", "4.0.0", ARG_FLAGS, FLAG_SLIRP_HELPER);
|
2018-03-28 21:36:13 +00:00
|
|
|
DO_TEST("net-user-addr", NONE);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("net-virtio", NONE);
|
|
|
|
DO_TEST("net-virtio-device",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_VIRTIO_TX_ALG);
|
|
|
|
DO_TEST("net-virtio-disable-offloads", NONE);
|
|
|
|
DO_TEST("net-virtio-netdev", NONE);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("net-virtio-s390",
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_VIRTIO_S390);
|
2013-03-05 15:44:23 +00:00
|
|
|
DO_TEST("net-virtio-ccw",
|
2018-05-07 14:41:11 +00:00
|
|
|
QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
|
2017-07-12 12:19:26 +00:00
|
|
|
DO_TEST("net-virtio-rxtxqueuesize",
|
|
|
|
QEMU_CAPS_VIRTIO_NET_RX_QUEUE_SIZE,
|
|
|
|
QEMU_CAPS_VIRTIO_NET_TX_QUEUE_SIZE);
|
2020-10-09 14:08:49 +00:00
|
|
|
DO_TEST_PARSE_ERROR("net-virtio-rxqueuesize-invalid-size",
|
|
|
|
QEMU_CAPS_VIRTIO_NET_RX_QUEUE_SIZE);
|
qemu: support interface <teaming> functionality
The QEMU driver uses the <teaming type='persistent|transient'
persistent='blah'/> element to setup a "failover" pair of devices -
the persistent device must be a virtio emulated NIC, with the only
extra configuration being the addition of ",failover=on" to the device
commandline, and the transient device must be a hostdev NIC
(<interface type='hostdev'> or <interface type='network'> with a
network that is a pool of SRIOV VFs) where the extra configuration is
the addition of ",failover_pair_id=$aliasOfVirtio" to the device
commandline. These new options are supported in QEMU 4.2.0 and later.
Extra qemu-specific validation is added to ensure that the device
type/model is appropriate and that the qemu binary supports these
commandline options.
The result of this will be:
1) The virtio device presented to the guest will have an extra bit set
in its PCI capabilities indicating that it can be used as a failover
backup device. The virtio guest driver will need to be equipped to do
something with this information - this is included in the Linux
virtio-net driver in kernel 4.18 and above (and also backported to
some older distro kernels). Unfortunately there is no way for libvirt
to learn whether or not the guest driver supports failover - if it
doesn't then the extra PCI capability will be ignored and the guest OS
will just see two independent devices. (NB: the current virtio guest
driver also requires that the MAC addresses of the two NICs match in
order to pair them into a bond).
2) When a migration is requested, QEMu will automatically unplug the
transient/hostdev NIC from the guest on the source host before
starting migration, and automatically re-plug a similar device after
restarting the guest CPUs on the destination host. While the transient
NIC is unplugged, all network traffic will go through the
persistent/virtio device, but when the hostdev NIC is plugged in, it
will get all the traffic. This means that in normal circumstances the
guest gets the performance advantage of vfio-assigned "real hardware"
networking, but it can still be migrated with the only downside being
a performance penalty (due to using an emulated NIC) during the
migration.
Signed-off-by: Laine Stump <laine@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
2020-01-23 20:34:53 +00:00
|
|
|
DO_TEST("net-virtio-teaming",
|
|
|
|
QEMU_CAPS_VIRTIO_NET_FAILOVER,
|
|
|
|
QEMU_CAPS_DEVICE_VFIO_PCI);
|
|
|
|
DO_TEST_PARSE_ERROR("net-virtio-teaming", NONE);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("net-eth", NONE);
|
|
|
|
DO_TEST("net-eth-ifname", NONE);
|
2015-11-09 16:20:08 +00:00
|
|
|
DO_TEST("net-eth-names", NONE);
|
2016-06-21 16:00:45 +00:00
|
|
|
DO_TEST("net-eth-hostip", NONE);
|
2019-08-26 04:24:34 +00:00
|
|
|
DO_TEST("net-eth-unmanaged-tap", NONE);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("net-client", NONE);
|
|
|
|
DO_TEST("net-server", NONE);
|
2019-01-18 20:46:56 +00:00
|
|
|
DO_TEST("net-many-models", NONE);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("net-mcast", NONE);
|
2015-08-29 20:19:10 +00:00
|
|
|
DO_TEST("net-udp", NONE);
|
2019-08-12 14:47:14 +00:00
|
|
|
DO_TEST("net-hostdev", QEMU_CAPS_DEVICE_VFIO_PCI);
|
|
|
|
DO_TEST("net-hostdev-bootorder", QEMU_CAPS_DEVICE_VFIO_PCI);
|
|
|
|
DO_TEST("net-hostdev-multidomain", QEMU_CAPS_DEVICE_VFIO_PCI);
|
2013-04-25 11:58:37 +00:00
|
|
|
DO_TEST("net-hostdev-vfio",
|
|
|
|
QEMU_CAPS_DEVICE_VFIO_PCI);
|
2014-04-30 11:32:19 +00:00
|
|
|
DO_TEST("net-hostdev-vfio-multidomain",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_VFIO_PCI);
|
2016-09-26 07:54:26 +00:00
|
|
|
DO_TEST_FAILURE("net-hostdev-fail",
|
|
|
|
QEMU_CAPS_DEVICE_VFIO_PCI);
|
2020-10-14 17:08:27 +00:00
|
|
|
DO_TEST_CAPS_LATEST("net-vdpa");
|
2016-09-26 07:54:26 +00:00
|
|
|
|
2019-08-29 19:19:02 +00:00
|
|
|
DO_TEST("hostdev-pci-multifunction",
|
|
|
|
QEMU_CAPS_KVM,
|
|
|
|
QEMU_CAPS_DEVICE_VFIO_PCI);
|
2011-02-08 14:22:39 +00:00
|
|
|
|
2019-12-17 20:35:03 +00:00
|
|
|
DO_TEST("hostdev-pci-address-unassigned",
|
|
|
|
QEMU_CAPS_KVM,
|
|
|
|
QEMU_CAPS_DEVICE_VFIO_PCI);
|
|
|
|
|
2017-06-26 17:13:00 +00:00
|
|
|
DO_TEST("serial-file-log",
|
|
|
|
QEMU_CAPS_CHARDEV_FILE_APPEND,
|
2017-11-26 16:35:28 +00:00
|
|
|
QEMU_CAPS_DEVICE_ISA_SERIAL,
|
2016-02-23 11:56:34 +00:00
|
|
|
QEMU_CAPS_CHARDEV_LOGFILE);
|
2014-01-30 11:19:12 +00:00
|
|
|
DO_TEST("serial-spiceport",
|
2017-06-26 17:13:00 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
|
2016-10-11 15:42:37 +00:00
|
|
|
QEMU_CAPS_DEVICE_QXL,
|
2017-06-26 17:13:00 +00:00
|
|
|
QEMU_CAPS_SPICE,
|
2018-09-12 12:38:45 +00:00
|
|
|
QEMU_CAPS_DEVICE_ISA_SERIAL);
|
2015-11-06 14:29:41 +00:00
|
|
|
DO_TEST("serial-spiceport-nospice", NONE);
|
2014-01-30 11:19:12 +00:00
|
|
|
|
2017-11-26 16:35:28 +00:00
|
|
|
DO_TEST("console-compat",
|
|
|
|
QEMU_CAPS_DEVICE_ISA_SERIAL);
|
|
|
|
DO_TEST("console-compat-auto",
|
|
|
|
QEMU_CAPS_DEVICE_ISA_SERIAL);
|
2012-07-09 16:29:55 +00:00
|
|
|
|
|
|
|
DO_TEST("serial-vc-chardev",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_ISA_SERIAL);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("serial-pty-chardev",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_ISA_SERIAL);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("serial-dev-chardev",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_ISA_SERIAL);
|
2015-06-16 13:07:59 +00:00
|
|
|
DO_TEST("serial-dev-chardev-iobase",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_ISA_SERIAL);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("serial-file-chardev",
|
2017-11-26 16:35:28 +00:00
|
|
|
QEMU_CAPS_DEVICE_ISA_SERIAL,
|
2015-12-24 14:27:55 +00:00
|
|
|
QEMU_CAPS_CHARDEV_FILE_APPEND);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("serial-unix-chardev",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_ISA_SERIAL);
|
2018-07-06 10:00:11 +00:00
|
|
|
DO_TEST_CAPS_LATEST("serial-unix-chardev");
|
2018-09-06 15:51:10 +00:00
|
|
|
DO_TEST_PARSE_ERROR("serial-unix-missing-source", NONE);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("serial-tcp-chardev",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_ISA_SERIAL);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("serial-udp-chardev",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_ISA_SERIAL);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("serial-tcp-telnet-chardev",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_ISA_SERIAL);
|
2016-06-09 22:30:55 +00:00
|
|
|
driver.config->chardevTLS = 1;
|
|
|
|
DO_TEST("serial-tcp-tlsx509-chardev",
|
2017-11-26 16:35:28 +00:00
|
|
|
QEMU_CAPS_DEVICE_ISA_SERIAL,
|
2016-06-09 22:30:55 +00:00
|
|
|
QEMU_CAPS_OBJECT_TLS_CREDS_X509);
|
2016-10-17 15:31:43 +00:00
|
|
|
driver.config->chardevTLSx509verify = 1;
|
|
|
|
DO_TEST("serial-tcp-tlsx509-chardev-verify",
|
2017-11-26 16:35:28 +00:00
|
|
|
QEMU_CAPS_DEVICE_ISA_SERIAL,
|
2016-10-17 15:31:43 +00:00
|
|
|
QEMU_CAPS_OBJECT_TLS_CREDS_X509);
|
|
|
|
driver.config->chardevTLSx509verify = 0;
|
2016-10-24 12:05:54 +00:00
|
|
|
DO_TEST("serial-tcp-tlsx509-chardev-notls",
|
2017-11-26 16:35:28 +00:00
|
|
|
QEMU_CAPS_DEVICE_ISA_SERIAL,
|
2016-10-24 12:05:54 +00:00
|
|
|
QEMU_CAPS_OBJECT_TLS_CREDS_X509);
|
2016-10-21 23:02:35 +00:00
|
|
|
VIR_FREE(driver.config->chardevTLSx509certdir);
|
2019-10-20 11:49:46 +00:00
|
|
|
driver.config->chardevTLSx509certdir = g_strdup("/etc/pki/libvirt-chardev");
|
|
|
|
driver.config->chardevTLSx509secretUUID = g_strdup("6fd3f62d-9fe7-4a4e-a869-7acd6376d8ea");
|
2016-10-21 23:02:35 +00:00
|
|
|
DO_TEST("serial-tcp-tlsx509-secret-chardev",
|
|
|
|
QEMU_CAPS_OBJECT_SECRET,
|
2017-11-26 16:35:28 +00:00
|
|
|
QEMU_CAPS_DEVICE_ISA_SERIAL,
|
2016-10-21 23:02:35 +00:00
|
|
|
QEMU_CAPS_OBJECT_TLS_CREDS_X509);
|
2016-06-09 22:30:55 +00:00
|
|
|
driver.config->chardevTLS = 0;
|
|
|
|
VIR_FREE(driver.config->chardevTLSx509certdir);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("serial-many-chardev",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_ISA_SERIAL);
|
|
|
|
DO_TEST("parallel-tcp-chardev", NONE);
|
|
|
|
DO_TEST("parallel-parport-chardev", NONE);
|
2018-10-04 17:03:12 +00:00
|
|
|
DO_TEST_CAPS_VER("parallel-unix-chardev", "2.5.0");
|
|
|
|
DO_TEST_CAPS_LATEST("parallel-unix-chardev");
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("console-compat-chardev",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_ISA_SERIAL);
|
2015-05-06 15:50:03 +00:00
|
|
|
DO_TEST("pci-serial-dev-chardev",
|
|
|
|
QEMU_CAPS_DEVICE_PCI_SERIAL);
|
2011-02-08 14:22:39 +00:00
|
|
|
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST("channel-guestfwd", NONE);
|
2018-10-04 17:11:43 +00:00
|
|
|
DO_TEST_CAPS_VER("channel-unix-guestfwd", "2.5.0");
|
|
|
|
DO_TEST_CAPS_LATEST("channel-unix-guestfwd");
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST("channel-virtio", NONE);
|
|
|
|
DO_TEST("channel-virtio-state", NONE);
|
|
|
|
DO_TEST("channel-virtio-auto", NONE);
|
|
|
|
DO_TEST("channel-virtio-autoassign", NONE);
|
|
|
|
DO_TEST("channel-virtio-autoadd", NONE);
|
|
|
|
DO_TEST("console-virtio", NONE);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("console-virtio-many",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_ISA_SERIAL);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("console-virtio-s390",
|
2017-06-26 17:13:00 +00:00
|
|
|
QEMU_CAPS_VIRTIO_S390);
|
2013-03-05 15:44:23 +00:00
|
|
|
DO_TEST("console-virtio-ccw",
|
2018-05-07 14:41:11 +00:00
|
|
|
QEMU_CAPS_CCW,
|
2013-03-05 15:44:23 +00:00
|
|
|
QEMU_CAPS_VIRTIO_S390);
|
2018-10-04 17:15:15 +00:00
|
|
|
DO_TEST_CAPS_VER("console-virtio-unix", "2.5.0");
|
|
|
|
DO_TEST_CAPS_LATEST("console-virtio-unix");
|
2013-01-07 17:17:15 +00:00
|
|
|
DO_TEST("console-sclp",
|
2017-06-26 17:13:00 +00:00
|
|
|
QEMU_CAPS_VIRTIO_S390,
|
2017-11-15 17:05:44 +00:00
|
|
|
QEMU_CAPS_DEVICE_SCLPCONSOLE);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("channel-spicevmc",
|
2017-06-26 17:13:00 +00:00
|
|
|
QEMU_CAPS_SPICE,
|
2016-10-10 15:51:38 +00:00
|
|
|
QEMU_CAPS_DEVICE_CIRRUS_VGA);
|
2015-06-30 08:21:21 +00:00
|
|
|
DO_TEST("channel-virtio-default",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_SPICE);
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST("channel-virtio-unix", NONE);
|
2011-02-08 14:22:39 +00:00
|
|
|
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("smartcard-host",
|
2017-06-26 17:13:00 +00:00
|
|
|
QEMU_CAPS_CCID_EMULATED);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("smartcard-host-certificates",
|
2017-06-26 17:13:00 +00:00
|
|
|
QEMU_CAPS_CCID_EMULATED);
|
2018-06-15 14:45:05 +00:00
|
|
|
DO_TEST("smartcard-host-certificates-database",
|
|
|
|
QEMU_CAPS_CCID_EMULATED);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("smartcard-passthrough-tcp",
|
2017-06-26 17:13:00 +00:00
|
|
|
QEMU_CAPS_CCID_PASSTHRU);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("smartcard-passthrough-spicevmc",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_CCID_PASSTHRU);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("smartcard-controller",
|
2017-06-26 17:13:00 +00:00
|
|
|
QEMU_CAPS_CCID_EMULATED);
|
2018-10-04 16:24:53 +00:00
|
|
|
DO_TEST_CAPS_VER("smartcard-passthrough-unix", "2.5.0");
|
|
|
|
DO_TEST_CAPS_LATEST("smartcard-passthrough-unix");
|
2011-02-08 14:22:39 +00:00
|
|
|
|
2017-08-25 17:11:24 +00:00
|
|
|
DO_TEST("chardev-reconnect",
|
|
|
|
QEMU_CAPS_CHARDEV_RECONNECT,
|
|
|
|
QEMU_CAPS_USB_REDIR,
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_RNG,
|
|
|
|
QEMU_CAPS_OBJECT_RNG_EGD,
|
|
|
|
QEMU_CAPS_CCID_PASSTHRU);
|
|
|
|
DO_TEST_PARSE_ERROR("chardev-reconnect-invalid-timeout",
|
|
|
|
QEMU_CAPS_CHARDEV_RECONNECT);
|
2017-08-30 13:56:52 +00:00
|
|
|
DO_TEST_PARSE_ERROR("chardev-reconnect-generated-path",
|
|
|
|
QEMU_CAPS_CHARDEV_RECONNECT);
|
2017-08-25 17:11:24 +00:00
|
|
|
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST("usb-controller", NONE);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("usb-piix3-controller",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_PIIX3_USB_UHCI);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("usb-ich9-ehci-addr",
|
2017-06-26 17:13:00 +00:00
|
|
|
QEMU_CAPS_ICH9_USB_EHCI1);
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST("input-usbmouse-addr", NONE);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("usb-ich9-companion",
|
2017-06-26 17:13:00 +00:00
|
|
|
QEMU_CAPS_ICH9_USB_EHCI1);
|
2013-04-23 14:23:51 +00:00
|
|
|
DO_TEST_PARSE_ERROR("usb-ich9-no-companion",
|
2017-06-26 17:13:00 +00:00
|
|
|
QEMU_CAPS_ICH9_USB_EHCI1);
|
2016-07-18 15:16:33 +00:00
|
|
|
DO_TEST("usb-ich9-autoassign",
|
2017-06-26 17:13:00 +00:00
|
|
|
QEMU_CAPS_ICH9_USB_EHCI1,
|
2016-07-18 15:16:33 +00:00
|
|
|
QEMU_CAPS_USB_HUB);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("usb-hub",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_USB_HUB);
|
2016-06-17 07:49:54 +00:00
|
|
|
DO_TEST("usb-hub-autoadd",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_USB_HUB);
|
2017-01-27 13:06:29 +00:00
|
|
|
DO_TEST("usb-hub-autoadd-deluxe",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_USB_HUB);
|
2015-08-12 14:52:17 +00:00
|
|
|
DO_TEST_PARSE_ERROR("usb-hub-conflict",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_USB_HUB);
|
2016-08-15 15:39:35 +00:00
|
|
|
DO_TEST_PARSE_ERROR("usb-hub-nonexistent",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_USB_HUB);
|
2016-07-01 12:20:44 +00:00
|
|
|
DO_TEST("usb-port-missing",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_USB_HUB);
|
2017-09-07 12:19:36 +00:00
|
|
|
DO_TEST_FAILURE("usb-bus-missing",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_USB_HUB);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("usb-ports",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_USB_HUB);
|
2016-11-28 10:05:22 +00:00
|
|
|
DO_TEST_PARSE_ERROR("usb-ports-out-of-range",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_USB_HUB);
|
2016-07-18 15:16:33 +00:00
|
|
|
DO_TEST("usb-port-autoassign",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_USB_HUB);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("usb-redir",
|
2017-06-26 17:13:00 +00:00
|
|
|
QEMU_CAPS_USB_HUB,
|
|
|
|
QEMU_CAPS_ICH9_USB_EHCI1,
|
|
|
|
QEMU_CAPS_USB_REDIR,
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_SPICE);
|
2012-11-20 18:47:09 +00:00
|
|
|
DO_TEST("usb-redir-boot",
|
2017-06-26 17:13:00 +00:00
|
|
|
QEMU_CAPS_USB_HUB,
|
|
|
|
QEMU_CAPS_ICH9_USB_EHCI1,
|
|
|
|
QEMU_CAPS_USB_REDIR,
|
2018-09-07 12:37:34 +00:00
|
|
|
QEMU_CAPS_SPICE);
|
2012-09-13 07:25:47 +00:00
|
|
|
DO_TEST("usb-redir-filter",
|
2017-06-26 17:13:00 +00:00
|
|
|
QEMU_CAPS_USB_HUB,
|
|
|
|
QEMU_CAPS_ICH9_USB_EHCI1,
|
|
|
|
QEMU_CAPS_USB_REDIR,
|
|
|
|
QEMU_CAPS_SPICE,
|
2012-09-13 07:25:47 +00:00
|
|
|
QEMU_CAPS_USB_REDIR_FILTER);
|
2015-04-10 13:49:42 +00:00
|
|
|
DO_TEST("usb-redir-filter-version",
|
|
|
|
QEMU_CAPS_USB_REDIR,
|
2017-06-26 17:13:00 +00:00
|
|
|
QEMU_CAPS_SPICE,
|
2015-04-10 13:49:42 +00:00
|
|
|
QEMU_CAPS_USB_REDIR_FILTER);
|
2018-10-04 17:24:01 +00:00
|
|
|
DO_TEST_CAPS_VER("usb-redir-unix", "2.5.0");
|
|
|
|
DO_TEST_CAPS_LATEST("usb-redir-unix");
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("usb1-usb2",
|
2017-06-26 17:13:00 +00:00
|
|
|
QEMU_CAPS_PIIX3_USB_UHCI,
|
|
|
|
QEMU_CAPS_USB_HUB,
|
|
|
|
QEMU_CAPS_ICH9_USB_EHCI1);
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST("usb-none", NONE);
|
|
|
|
DO_TEST_PARSE_ERROR("usb-none-other", NONE);
|
2012-07-03 13:43:13 +00:00
|
|
|
DO_TEST_PARSE_ERROR("usb-none-hub",
|
|
|
|
QEMU_CAPS_USB_HUB);
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST_PARSE_ERROR("usb-none-usbtablet", NONE);
|
2016-01-08 15:20:47 +00:00
|
|
|
DO_TEST("usb-controller-default-q35",
|
qemu: initially reserve one open pcie-root-port for hotplug
For machinetypes with a pci-root bus (all legacy PCI), libvirt will
make a "fake" reservation for one extra slot prior to assigning
addresses to unaddressed PCI endpoint devices in the domain. This will
trigger auto-adding of a pci-bridge for the final device to be
assigned an address *if that device would have otherwise instead been
the last device on the last available pci-bridge*; thus it assures
that there will always be at least one slot left open in the domain's
bus topology for expansion (which is important both for hotplug (since
a new pci-bridge can't be added while the guest is running) as well as
for offline additions to the config (since adding a new device might
otherwise in some cases require re-addressing existing devices, which
we want to avoid)).
It's important to note that for the above case (legacy PCI), we must
check for the special case of all slots on all buses being occupied
*prior to assigning any addresses*, and avoid attempting to reserve
the extra address in that case, because there is no free address in
the existing topology, so no place to auto-add a pci-bridge for
expansion (i.e. it would always fail anyway). Since that condition can
only be reached by manual intervention, this is acceptable.
For machinetypes with pcie-root (Q35, aarch64 virt), libvirt's
methodology for automatically expanding the bus topology is different
- pcie-root-ports are plugged into slots (soon to be functions) of
pcie-root as needed, and the new endpoint devices are assigned to the
single slot in each pcie-root-port. This is done so that the devices
are, by default, hotpluggable (the slots of pcie-root don't support
hotplug, but the single slot of the pcie-root-port does). Since
pcie-root-ports can only be plugged into pcie-root, and we don't
auto-assign endpoint devices to the pcie-root slots, this means
topology expansion doesn't compete with endpoint devices for slots, so
we don't need to worry about checking for all "useful" slots being
free *prior* to assigning addresses to new endpoint devices - as a
matter of fact, if we attempt to reserve the open slots before the
used slots, it can lead to errors.
Instead this patch just reserves one slot for a "future potential"
PCIe device after doing the assignment for actual devices, but only
if the only PCI controller defined prior to starting address
assignment was pcie-root, and only if we auto-added at least one PCI
controller during address assignment. This assures two things:
1) that reserving the open slots will only be done when the domain is
initially defined, never at any time after, and
2) that if the user understands enough about PCI controllers that they
are adding them manually, that we don't mess up their plan by
adding extras - if they know enough to add one pcie-root-port, or
to manually assign addresses such that no pcie-root-ports are
needed, they know enough to add extra pcie-root-ports if they want
them (this could be called the "libguestfs clause", since
libguestfs needs to be able to create domains with as few
devices/controllers as possible).
This is set to reserve a single free port for now, but could be
increased in the future if public sentiment goes in that direction
(it's easy to increase later, but essentially impossible to decrease)
2016-09-28 00:37:30 +00:00
|
|
|
QEMU_CAPS_DEVICE_IOH3420,
|
2017-02-23 17:47:36 +00:00
|
|
|
QEMU_CAPS_PCI_OHCI,
|
|
|
|
QEMU_CAPS_PIIX3_USB_UHCI,
|
|
|
|
QEMU_CAPS_NEC_USB_XHCI);
|
2016-01-08 15:20:47 +00:00
|
|
|
DO_TEST_FAILURE("usb-controller-default-unavailable-q35",
|
qemu: initially reserve one open pcie-root-port for hotplug
For machinetypes with a pci-root bus (all legacy PCI), libvirt will
make a "fake" reservation for one extra slot prior to assigning
addresses to unaddressed PCI endpoint devices in the domain. This will
trigger auto-adding of a pci-bridge for the final device to be
assigned an address *if that device would have otherwise instead been
the last device on the last available pci-bridge*; thus it assures
that there will always be at least one slot left open in the domain's
bus topology for expansion (which is important both for hotplug (since
a new pci-bridge can't be added while the guest is running) as well as
for offline additions to the config (since adding a new device might
otherwise in some cases require re-addressing existing devices, which
we want to avoid)).
It's important to note that for the above case (legacy PCI), we must
check for the special case of all slots on all buses being occupied
*prior to assigning any addresses*, and avoid attempting to reserve
the extra address in that case, because there is no free address in
the existing topology, so no place to auto-add a pci-bridge for
expansion (i.e. it would always fail anyway). Since that condition can
only be reached by manual intervention, this is acceptable.
For machinetypes with pcie-root (Q35, aarch64 virt), libvirt's
methodology for automatically expanding the bus topology is different
- pcie-root-ports are plugged into slots (soon to be functions) of
pcie-root as needed, and the new endpoint devices are assigned to the
single slot in each pcie-root-port. This is done so that the devices
are, by default, hotpluggable (the slots of pcie-root don't support
hotplug, but the single slot of the pcie-root-port does). Since
pcie-root-ports can only be plugged into pcie-root, and we don't
auto-assign endpoint devices to the pcie-root slots, this means
topology expansion doesn't compete with endpoint devices for slots, so
we don't need to worry about checking for all "useful" slots being
free *prior* to assigning addresses to new endpoint devices - as a
matter of fact, if we attempt to reserve the open slots before the
used slots, it can lead to errors.
Instead this patch just reserves one slot for a "future potential"
PCIe device after doing the assignment for actual devices, but only
if the only PCI controller defined prior to starting address
assignment was pcie-root, and only if we auto-added at least one PCI
controller during address assignment. This assures two things:
1) that reserving the open slots will only be done when the domain is
initially defined, never at any time after, and
2) that if the user understands enough about PCI controllers that they
are adding them manually, that we don't mess up their plan by
adding extras - if they know enough to add one pcie-root-port, or
to manually assign addresses such that no pcie-root-ports are
needed, they know enough to add extra pcie-root-ports if they want
them (this could be called the "libguestfs clause", since
libguestfs needs to be able to create domains with as few
devices/controllers as possible).
This is set to reserve a single free port for now, but could be
increased in the future if public sentiment goes in that direction
(it's easy to increase later, but essentially impossible to decrease)
2016-09-28 00:37:30 +00:00
|
|
|
QEMU_CAPS_DEVICE_IOH3420,
|
2017-02-23 17:47:36 +00:00
|
|
|
QEMU_CAPS_PCI_OHCI,
|
2016-01-08 15:20:47 +00:00
|
|
|
QEMU_CAPS_NEC_USB_XHCI);
|
|
|
|
DO_TEST("usb-controller-explicit-q35",
|
qemu: initially reserve one open pcie-root-port for hotplug
For machinetypes with a pci-root bus (all legacy PCI), libvirt will
make a "fake" reservation for one extra slot prior to assigning
addresses to unaddressed PCI endpoint devices in the domain. This will
trigger auto-adding of a pci-bridge for the final device to be
assigned an address *if that device would have otherwise instead been
the last device on the last available pci-bridge*; thus it assures
that there will always be at least one slot left open in the domain's
bus topology for expansion (which is important both for hotplug (since
a new pci-bridge can't be added while the guest is running) as well as
for offline additions to the config (since adding a new device might
otherwise in some cases require re-addressing existing devices, which
we want to avoid)).
It's important to note that for the above case (legacy PCI), we must
check for the special case of all slots on all buses being occupied
*prior to assigning any addresses*, and avoid attempting to reserve
the extra address in that case, because there is no free address in
the existing topology, so no place to auto-add a pci-bridge for
expansion (i.e. it would always fail anyway). Since that condition can
only be reached by manual intervention, this is acceptable.
For machinetypes with pcie-root (Q35, aarch64 virt), libvirt's
methodology for automatically expanding the bus topology is different
- pcie-root-ports are plugged into slots (soon to be functions) of
pcie-root as needed, and the new endpoint devices are assigned to the
single slot in each pcie-root-port. This is done so that the devices
are, by default, hotpluggable (the slots of pcie-root don't support
hotplug, but the single slot of the pcie-root-port does). Since
pcie-root-ports can only be plugged into pcie-root, and we don't
auto-assign endpoint devices to the pcie-root slots, this means
topology expansion doesn't compete with endpoint devices for slots, so
we don't need to worry about checking for all "useful" slots being
free *prior* to assigning addresses to new endpoint devices - as a
matter of fact, if we attempt to reserve the open slots before the
used slots, it can lead to errors.
Instead this patch just reserves one slot for a "future potential"
PCIe device after doing the assignment for actual devices, but only
if the only PCI controller defined prior to starting address
assignment was pcie-root, and only if we auto-added at least one PCI
controller during address assignment. This assures two things:
1) that reserving the open slots will only be done when the domain is
initially defined, never at any time after, and
2) that if the user understands enough about PCI controllers that they
are adding them manually, that we don't mess up their plan by
adding extras - if they know enough to add one pcie-root-port, or
to manually assign addresses such that no pcie-root-ports are
needed, they know enough to add extra pcie-root-ports if they want
them (this could be called the "libguestfs clause", since
libguestfs needs to be able to create domains with as few
devices/controllers as possible).
This is set to reserve a single free port for now, but could be
increased in the future if public sentiment goes in that direction
(it's easy to increase later, but essentially impossible to decrease)
2016-09-28 00:37:30 +00:00
|
|
|
QEMU_CAPS_DEVICE_IOH3420,
|
2017-02-23 17:47:36 +00:00
|
|
|
QEMU_CAPS_PCI_OHCI,
|
|
|
|
QEMU_CAPS_PIIX3_USB_UHCI,
|
|
|
|
QEMU_CAPS_NEC_USB_XHCI);
|
2016-01-08 15:20:47 +00:00
|
|
|
DO_TEST_FAILURE("usb-controller-explicit-unavailable-q35",
|
qemu: initially reserve one open pcie-root-port for hotplug
For machinetypes with a pci-root bus (all legacy PCI), libvirt will
make a "fake" reservation for one extra slot prior to assigning
addresses to unaddressed PCI endpoint devices in the domain. This will
trigger auto-adding of a pci-bridge for the final device to be
assigned an address *if that device would have otherwise instead been
the last device on the last available pci-bridge*; thus it assures
that there will always be at least one slot left open in the domain's
bus topology for expansion (which is important both for hotplug (since
a new pci-bridge can't be added while the guest is running) as well as
for offline additions to the config (since adding a new device might
otherwise in some cases require re-addressing existing devices, which
we want to avoid)).
It's important to note that for the above case (legacy PCI), we must
check for the special case of all slots on all buses being occupied
*prior to assigning any addresses*, and avoid attempting to reserve
the extra address in that case, because there is no free address in
the existing topology, so no place to auto-add a pci-bridge for
expansion (i.e. it would always fail anyway). Since that condition can
only be reached by manual intervention, this is acceptable.
For machinetypes with pcie-root (Q35, aarch64 virt), libvirt's
methodology for automatically expanding the bus topology is different
- pcie-root-ports are plugged into slots (soon to be functions) of
pcie-root as needed, and the new endpoint devices are assigned to the
single slot in each pcie-root-port. This is done so that the devices
are, by default, hotpluggable (the slots of pcie-root don't support
hotplug, but the single slot of the pcie-root-port does). Since
pcie-root-ports can only be plugged into pcie-root, and we don't
auto-assign endpoint devices to the pcie-root slots, this means
topology expansion doesn't compete with endpoint devices for slots, so
we don't need to worry about checking for all "useful" slots being
free *prior* to assigning addresses to new endpoint devices - as a
matter of fact, if we attempt to reserve the open slots before the
used slots, it can lead to errors.
Instead this patch just reserves one slot for a "future potential"
PCIe device after doing the assignment for actual devices, but only
if the only PCI controller defined prior to starting address
assignment was pcie-root, and only if we auto-added at least one PCI
controller during address assignment. This assures two things:
1) that reserving the open slots will only be done when the domain is
initially defined, never at any time after, and
2) that if the user understands enough about PCI controllers that they
are adding them manually, that we don't mess up their plan by
adding extras - if they know enough to add one pcie-root-port, or
to manually assign addresses such that no pcie-root-ports are
needed, they know enough to add extra pcie-root-ports if they want
them (this could be called the "libguestfs clause", since
libguestfs needs to be able to create domains with as few
devices/controllers as possible).
This is set to reserve a single free port for now, but could be
increased in the future if public sentiment goes in that direction
(it's easy to increase later, but essentially impossible to decrease)
2016-09-28 00:37:30 +00:00
|
|
|
QEMU_CAPS_DEVICE_IOH3420,
|
2017-02-23 17:47:36 +00:00
|
|
|
QEMU_CAPS_PCI_OHCI,
|
2016-01-08 15:20:47 +00:00
|
|
|
QEMU_CAPS_PIIX3_USB_UHCI);
|
2016-04-23 23:52:56 +00:00
|
|
|
DO_TEST("usb-controller-xhci",
|
2017-06-26 17:13:00 +00:00
|
|
|
QEMU_CAPS_PIIX3_USB_UHCI,
|
|
|
|
QEMU_CAPS_NEC_USB_XHCI,
|
|
|
|
QEMU_CAPS_NEC_USB_XHCI_PORTS);
|
2016-07-18 15:16:33 +00:00
|
|
|
DO_TEST("usb-xhci-autoassign",
|
2017-06-26 17:13:00 +00:00
|
|
|
QEMU_CAPS_PIIX3_USB_UHCI,
|
|
|
|
QEMU_CAPS_NEC_USB_XHCI,
|
|
|
|
QEMU_CAPS_NEC_USB_XHCI_PORTS,
|
2016-07-18 15:16:33 +00:00
|
|
|
QEMU_CAPS_USB_HUB);
|
2016-11-28 16:37:39 +00:00
|
|
|
DO_TEST_PARSE_ERROR("usb-controller-xhci-limit",
|
2017-06-26 17:13:00 +00:00
|
|
|
QEMU_CAPS_PIIX3_USB_UHCI,
|
|
|
|
QEMU_CAPS_NEC_USB_XHCI,
|
|
|
|
QEMU_CAPS_NEC_USB_XHCI_PORTS);
|
2017-04-13 10:25:25 +00:00
|
|
|
DO_TEST("usb-controller-qemu-xhci", QEMU_CAPS_DEVICE_QEMU_XHCI);
|
|
|
|
DO_TEST_FAILURE("usb-controller-qemu-xhci-unavailable", NONE);
|
|
|
|
DO_TEST_PARSE_ERROR("usb-controller-qemu-xhci-limit",
|
|
|
|
QEMU_CAPS_DEVICE_QEMU_XHCI);
|
2011-09-02 13:21:23 +00:00
|
|
|
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST("smbios", NONE);
|
|
|
|
DO_TEST_PARSE_ERROR("smbios-date", NONE);
|
|
|
|
DO_TEST_PARSE_ERROR("smbios-uuid-match", NONE);
|
2020-06-02 15:07:59 +00:00
|
|
|
DO_TEST("smbios-type-fwcfg", QEMU_CAPS_FW_CFG);
|
2011-02-08 14:22:39 +00:00
|
|
|
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("watchdog", NONE);
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST("watchdog-device", NONE);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("watchdog-dump", NONE);
|
2015-06-24 09:28:42 +00:00
|
|
|
DO_TEST("watchdog-injectnmi", NONE);
|
2018-08-09 11:26:17 +00:00
|
|
|
DO_TEST("watchdog-diag288", QEMU_CAPS_VIRTIO_S390);
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST("balloon-device", NONE);
|
|
|
|
DO_TEST("balloon-device-deflate",
|
2016-01-08 10:45:07 +00:00
|
|
|
QEMU_CAPS_VIRTIO_BALLOON_AUTODEFLATE);
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST("balloon-ccw-deflate",
|
2016-01-08 10:45:07 +00:00
|
|
|
QEMU_CAPS_VIRTIO_BALLOON_AUTODEFLATE);
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST("balloon-mmio-deflate",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_MMIO,
|
2016-01-08 10:45:07 +00:00
|
|
|
QEMU_CAPS_VIRTIO_BALLOON_AUTODEFLATE);
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST("balloon-device-deflate-off",
|
2016-01-08 10:45:07 +00:00
|
|
|
QEMU_CAPS_VIRTIO_BALLOON_AUTODEFLATE);
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST("balloon-device-auto", NONE);
|
|
|
|
DO_TEST("balloon-device-period", NONE);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("sound", NONE);
|
|
|
|
DO_TEST("sound-device",
|
2013-09-24 14:17:38 +00:00
|
|
|
QEMU_CAPS_HDA_DUPLEX, QEMU_CAPS_HDA_MICRO,
|
2018-05-22 11:12:34 +00:00
|
|
|
QEMU_CAPS_HDA_OUTPUT,
|
2014-07-24 15:32:31 +00:00
|
|
|
QEMU_CAPS_DEVICE_ICH9_INTEL_HDA,
|
|
|
|
QEMU_CAPS_OBJECT_USB_AUDIO);
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST("fs9p", NONE);
|
2019-07-16 10:49:32 +00:00
|
|
|
DO_TEST_CAPS_LATEST("fs9p");
|
2015-07-07 15:30:43 +00:00
|
|
|
DO_TEST("fs9p-ccw",
|
2018-05-07 14:41:11 +00:00
|
|
|
QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
|
2019-07-16 10:49:32 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("fs9p-ccw", "s390x");
|
2011-02-08 14:22:39 +00:00
|
|
|
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("hostdev-usb-address", NONE);
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST("hostdev-usb-address-device", NONE);
|
2018-09-07 12:37:34 +00:00
|
|
|
DO_TEST("hostdev-usb-address-device-boot", NONE);
|
2019-08-12 14:47:14 +00:00
|
|
|
DO_TEST("hostdev-pci-address", QEMU_CAPS_DEVICE_VFIO_PCI);
|
|
|
|
DO_TEST("hostdev-pci-address-device", QEMU_CAPS_DEVICE_VFIO_PCI);
|
2013-04-25 11:58:37 +00:00
|
|
|
DO_TEST("hostdev-vfio",
|
|
|
|
QEMU_CAPS_DEVICE_VFIO_PCI);
|
2014-04-30 11:32:19 +00:00
|
|
|
DO_TEST("hostdev-vfio-multidomain",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_VFIO_PCI);
|
2017-01-07 12:27:34 +00:00
|
|
|
DO_TEST("hostdev-mdev-precreated",
|
|
|
|
QEMU_CAPS_DEVICE_VFIO_PCI);
|
|
|
|
DO_TEST_PARSE_ERROR("hostdev-mdev-src-address-invalid",
|
|
|
|
QEMU_CAPS_DEVICE_VFIO_PCI);
|
|
|
|
DO_TEST_PARSE_ERROR("hostdev-mdev-invalid-target-address",
|
|
|
|
QEMU_CAPS_DEVICE_VFIO_PCI);
|
2018-05-25 13:55:42 +00:00
|
|
|
DO_TEST_CAPS_LATEST("hostdev-mdev-display-spice-opengl");
|
|
|
|
DO_TEST_CAPS_LATEST("hostdev-mdev-display-spice-egl-headless");
|
|
|
|
DO_TEST_CAPS_LATEST("hostdev-mdev-display-vnc");
|
|
|
|
DO_TEST_CAPS_LATEST("hostdev-mdev-display-vnc-egl-headless");
|
|
|
|
DO_TEST_PARSE_ERROR("hostdev-mdev-display-missing-graphics",
|
|
|
|
QEMU_CAPS_DEVICE_VFIO_PCI,
|
|
|
|
QEMU_CAPS_VFIO_PCI_DISPLAY);
|
2019-10-18 15:30:17 +00:00
|
|
|
DO_TEST_CAPS_LATEST("hostdev-mdev-display-ramfb");
|
2018-11-08 11:00:27 +00:00
|
|
|
DO_TEST_PARSE_ERROR("hostdev-vfio-zpci-wrong-arch",
|
|
|
|
QEMU_CAPS_DEVICE_VFIO_PCI);
|
2018-11-08 11:00:26 +00:00
|
|
|
DO_TEST("hostdev-vfio-zpci",
|
|
|
|
QEMU_CAPS_DEVICE_VFIO_PCI,
|
|
|
|
QEMU_CAPS_DEVICE_ZPCI);
|
2020-06-18 08:25:17 +00:00
|
|
|
DO_TEST_PARSE_ERROR("hostdev-vfio-zpci-autogenerate-fids",
|
|
|
|
QEMU_CAPS_DEVICE_VFIO_PCI);
|
|
|
|
DO_TEST_PARSE_ERROR("hostdev-vfio-zpci-invalid-uid-valid-fid",
|
|
|
|
QEMU_CAPS_DEVICE_VFIO_PCI,
|
|
|
|
QEMU_CAPS_DEVICE_ZPCI);
|
2018-11-08 11:00:29 +00:00
|
|
|
DO_TEST("hostdev-vfio-zpci-multidomain-many",
|
|
|
|
QEMU_CAPS_DEVICE_VFIO_PCI,
|
|
|
|
QEMU_CAPS_DEVICE_PCI_BRIDGE,
|
|
|
|
QEMU_CAPS_DEVICE_ZPCI);
|
|
|
|
DO_TEST("hostdev-vfio-zpci-autogenerate",
|
|
|
|
QEMU_CAPS_DEVICE_VFIO_PCI,
|
|
|
|
QEMU_CAPS_DEVICE_ZPCI);
|
2020-06-18 08:25:17 +00:00
|
|
|
DO_TEST("hostdev-vfio-zpci-autogenerate-uids",
|
|
|
|
QEMU_CAPS_DEVICE_VFIO_PCI,
|
|
|
|
QEMU_CAPS_DEVICE_ZPCI);
|
|
|
|
DO_TEST("hostdev-vfio-zpci-autogenerate-fids",
|
|
|
|
QEMU_CAPS_DEVICE_VFIO_PCI,
|
|
|
|
QEMU_CAPS_DEVICE_ZPCI);
|
conf: fix zPCI address auto-generation on s390
Let us fix the issues with zPCI address validation and auto-generation
on s390.
Currently, there are two issues with handling the ZPCI address
extension. Firstly, when the uid is to be auto-generated with a
specified fid, .i.e.:
...
<address type='pci'>
<zpci fid='0x0000001f'/>
</address>
...
we expect uid='0x0001' (or the next available uid for the domain).
However, we get a parsing error:
$ virsh define zpci.xml
error: XML error: Invalid PCI address uid='0x0000', must be > 0x0000
and <= 0xffff
Secondly, when the uid is specified explicitly with the invalid
numerical value '0x0000', we actually expect the parsing error above.
However, the domain is being defined and the uid value is silently
changed to a valid value.
The first issue is a bug and the second one is undesired behaviour, and
both issues are related to how we (in-band) signal invalid values for
uid and fid. So let's fix the XML parsing to do validation based on what
is actually specified in the XML.
The first issue is also related to the current code behaviour, which
is, if either uid or fid is specified by the user, it is incorrectly
assumed that both uid and fid are specified. This bug is fixed by
identifying when the user specified ZPCI address is incomplete and
auto-generating the missing ZPCI address.
Signed-off-by: Bjoern Walk <bwalk@linux.ibm.com>
Signed-off-by: Boris Fiuczynski <fiuczy@linux.ibm.com>
Signed-off-by: Shalini Chellathurai Saroja <shalini@linux.ibm.com>
Reviewed-by: Andrea Bolognani <abologna@redhat.com>
2020-06-18 08:25:15 +00:00
|
|
|
DO_TEST_PARSE_ERROR("hostdev-vfio-zpci-uid-set-zero",
|
|
|
|
QEMU_CAPS_DEVICE_VFIO_PCI,
|
|
|
|
QEMU_CAPS_DEVICE_ZPCI);
|
2018-11-08 11:00:29 +00:00
|
|
|
DO_TEST("hostdev-vfio-zpci-boundaries",
|
|
|
|
QEMU_CAPS_DEVICE_VFIO_PCI,
|
|
|
|
QEMU_CAPS_DEVICE_PCI_BRIDGE,
|
|
|
|
QEMU_CAPS_DEVICE_ZPCI);
|
|
|
|
DO_TEST_PARSE_ERROR("hostdev-vfio-zpci",
|
|
|
|
QEMU_CAPS_DEVICE_VFIO_PCI);
|
2020-06-18 08:25:17 +00:00
|
|
|
DO_TEST_PARSE_ERROR("hostdev-vfio-zpci-duplicate",
|
|
|
|
QEMU_CAPS_DEVICE_VFIO_PCI,
|
|
|
|
QEMU_CAPS_DEVICE_ZPCI);
|
|
|
|
DO_TEST_PARSE_ERROR("hostdev-vfio-zpci-set-zero",
|
|
|
|
QEMU_CAPS_DEVICE_VFIO_PCI,
|
|
|
|
QEMU_CAPS_DEVICE_ZPCI);
|
2020-06-18 08:25:18 +00:00
|
|
|
DO_TEST("hostdev-vfio-zpci-ccw-memballoon",
|
|
|
|
QEMU_CAPS_CCW,
|
|
|
|
QEMU_CAPS_DEVICE_VFIO_PCI,
|
|
|
|
QEMU_CAPS_DEVICE_ZPCI);
|
2020-06-18 08:25:17 +00:00
|
|
|
|
2019-08-12 14:47:14 +00:00
|
|
|
DO_TEST("pci-rom", QEMU_CAPS_DEVICE_VFIO_PCI);
|
2018-04-20 15:17:11 +00:00
|
|
|
DO_TEST("pci-rom-disabled", NONE);
|
2018-04-23 11:45:59 +00:00
|
|
|
DO_TEST("pci-rom-disabled-invalid", NONE);
|
2011-02-08 14:22:39 +00:00
|
|
|
|
2018-05-07 14:41:15 +00:00
|
|
|
DO_TEST("hostdev-subsys-mdev-vfio-ccw",
|
|
|
|
QEMU_CAPS_CCW,
|
|
|
|
QEMU_CAPS_CCW_CSSID_UNRESTRICTED,
|
|
|
|
QEMU_CAPS_DEVICE_VFIO_CCW);
|
2019-08-27 14:19:23 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("hostdev-subsys-mdev-vfio-ccw-boot",
|
|
|
|
"s390x");
|
2019-12-09 23:15:18 +00:00
|
|
|
DO_TEST_PARSE_ERROR("hostdev-subsys-mdev-vfio-ccw",
|
|
|
|
QEMU_CAPS_CCW,
|
|
|
|
QEMU_CAPS_CCW_CSSID_UNRESTRICTED);
|
2018-05-07 14:41:15 +00:00
|
|
|
DO_TEST_PARSE_ERROR("hostdev-subsys-mdev-vfio-ccw-duplicate-address",
|
|
|
|
QEMU_CAPS_CCW,
|
|
|
|
QEMU_CAPS_CCW_CSSID_UNRESTRICTED,
|
|
|
|
QEMU_CAPS_DEVICE_VFIO_CCW);
|
|
|
|
DO_TEST_PARSE_ERROR("hostdev-subsys-mdev-vfio-ccw-invalid-address",
|
|
|
|
QEMU_CAPS_CCW,
|
|
|
|
QEMU_CAPS_CCW_CSSID_UNRESTRICTED,
|
|
|
|
QEMU_CAPS_DEVICE_VFIO_CCW);
|
|
|
|
|
2019-08-27 14:19:18 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("hostdev-subsys-mdev-vfio-ap",
|
|
|
|
"s390x");
|
2019-08-27 14:19:20 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("hostdev-subsys-mdev-vfio-ap-boot-fail",
|
|
|
|
"s390x");
|
2019-08-27 14:19:18 +00:00
|
|
|
|
2019-03-13 20:17:10 +00:00
|
|
|
DO_TEST_FULL("restore-v2",
|
2019-03-13 19:59:42 +00:00
|
|
|
ARG_MIGRATE_FROM, "exec:cat",
|
|
|
|
ARG_MIGRATE_FD, 7,
|
2019-03-13 19:18:11 +00:00
|
|
|
ARG_QEMU_CAPS, NONE);
|
2019-03-13 20:17:10 +00:00
|
|
|
DO_TEST_FULL("restore-v2-fd",
|
2019-03-13 19:59:42 +00:00
|
|
|
ARG_MIGRATE_FROM, "stdio",
|
|
|
|
ARG_MIGRATE_FD, 7,
|
2019-03-13 19:18:11 +00:00
|
|
|
ARG_QEMU_CAPS, NONE);
|
2019-03-13 20:17:10 +00:00
|
|
|
DO_TEST_FULL("restore-v2-fd",
|
2019-03-13 19:59:42 +00:00
|
|
|
ARG_MIGRATE_FROM, "fd:7",
|
|
|
|
ARG_MIGRATE_FD, 7,
|
2019-03-13 19:18:11 +00:00
|
|
|
ARG_QEMU_CAPS, NONE);
|
2019-03-13 20:17:10 +00:00
|
|
|
DO_TEST_FULL("migrate",
|
2019-03-13 19:59:42 +00:00
|
|
|
ARG_MIGRATE_FROM, "tcp:10.0.0.1:5000",
|
2019-03-13 19:18:11 +00:00
|
|
|
ARG_QEMU_CAPS, NONE);
|
2011-02-08 14:22:39 +00:00
|
|
|
|
2019-03-13 20:17:10 +00:00
|
|
|
DO_TEST_FULL("migrate-numa-unaligned",
|
2019-03-13 19:59:42 +00:00
|
|
|
ARG_MIGRATE_FROM, "stdio",
|
|
|
|
ARG_MIGRATE_FD, 7,
|
2019-03-13 19:18:11 +00:00
|
|
|
ARG_QEMU_CAPS,
|
2018-05-02 15:37:59 +00:00
|
|
|
QEMU_CAPS_NUMA,
|
|
|
|
QEMU_CAPS_OBJECT_MEMORY_RAM);
|
2015-09-21 17:10:12 +00:00
|
|
|
|
2019-06-18 06:27:07 +00:00
|
|
|
DO_TEST_CAPS_VER("qemu-ns", "4.0.0");
|
|
|
|
DO_TEST_CAPS_LATEST("qemu-ns");
|
2016-01-08 14:48:06 +00:00
|
|
|
DO_TEST("qemu-ns-no-env", NONE);
|
2017-07-10 10:13:05 +00:00
|
|
|
DO_TEST("qemu-ns-alt", NONE);
|
2011-02-08 14:22:39 +00:00
|
|
|
|
2016-06-23 11:29:16 +00:00
|
|
|
DO_TEST("smp", NONE);
|
2019-12-16 15:28:09 +00:00
|
|
|
DO_TEST("smp-dies", QEMU_CAPS_SMP_DIES);
|
2011-02-08 14:22:39 +00:00
|
|
|
|
2014-08-22 22:15:30 +00:00
|
|
|
DO_TEST("iothreads", QEMU_CAPS_OBJECT_IOTHREAD);
|
2015-04-10 13:21:23 +00:00
|
|
|
DO_TEST("iothreads-ids", QEMU_CAPS_OBJECT_IOTHREAD);
|
|
|
|
DO_TEST("iothreads-ids-partial", QEMU_CAPS_OBJECT_IOTHREAD);
|
qemu: Fix qemu startup check for QEMU_CAPS_OBJECT_IOTHREAD
https://bugzilla.redhat.com/show_bug.cgi?id=1249981
When qemuDomainPinIOThread was added in commit id 'fb562614', a check
for the IOThread capability was not needed since a check for iothreadpids
covered the condition where the support for IOThreads was not present.
The iothreadpids array was only created if qemuProcessDetectIOThreadPIDs
was able to query the monitor for IOThreads. It would only do that if
the QEMU_CAPS_OBJECT_IOTHREAD capability was set.
However, when iothreadids were added in commit id '8d4614a5' and the
check for iothreadpids was replaced by a search through the iothreadids[]
array for the matching iothread_id that left open the possibility that
an iothreadids[] array was defined, but the entries essentially pointed
to elements with only the 'iothread_id' defined leaving the 'thread_id'
value of 0 and eventually the cpumap entry of NULL.
This was because, the original IOThreads commit id '72edaae7' only
checked if IOThreads were defined and if the emulator had the IOThreads
capability, then IOThread objects were added at startup. The "capability
failure" check was only done when a disk was assigned to an IOThread in
qemuCheckIOThreads. This was because the initial implementation had no way
to dynamically add IOThreads, but it was possible to dynamically add a
disk to the domain. So the decision was if the domain supported it, then
add the IOThread objects. Then if a disk with an IOThread defined was
added, it could check the capability and fail to add if not there. This
just meant the 'iothreads' value was essentially ignored.
Eventually commit id 'a27ed6e7' allowed for the dynamic addition and
deletion of IOThread objects. So it was no longer necessary to generate
IOThread objects to dynamically attach a disk to. However, the startup
and disk check code was not modified to reflect this.
This patch will move the capability failure check to when IOThread
objects are being added to the command line. Thus a domain that has
IOThreads defined will not be started if the emulator doesn't support
the capability. This means when qemuCheckIOThreads is called to add
a disk, it's no longer necessary to check the capability. Instead the
code can use the IOThreadFind call to indicate that the IOThread
doesn't exist.
Finally because it could be possible to have a domain running with the
iothreadids[] defined prior to this change if libvirtd is restarted each
having mostly empty elements, qemuProcessDetectIOThreadPIDs will check
if there are niothreadids when the QEMU_CAPS_OBJECT_IOTHREAD capability
check fails and remove the elements and array if it exists.
With these changes in place, it turns out the cputune-numatune test
was failing because the right bit wasn't set in the test. So used the
opportunity to fix that and create a test that would expect to fail
with some sort of iothreads defined and used, but not having the
correct capability.
2015-10-15 16:30:40 +00:00
|
|
|
DO_TEST_FAILURE("iothreads-nocap", NONE);
|
2016-01-13 00:26:40 +00:00
|
|
|
DO_TEST("iothreads-disk", QEMU_CAPS_OBJECT_IOTHREAD);
|
|
|
|
DO_TEST("iothreads-disk-virtio-ccw", QEMU_CAPS_OBJECT_IOTHREAD,
|
2018-05-07 14:41:11 +00:00
|
|
|
QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
|
2019-01-28 13:17:15 +00:00
|
|
|
DO_TEST_CAPS_LATEST("iothreads-virtio-scsi-pci");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("iothreads-virtio-scsi-ccw", "s390x");
|
2014-08-22 22:15:30 +00:00
|
|
|
|
2016-06-23 11:29:16 +00:00
|
|
|
DO_TEST("cpu-topology1", NONE);
|
|
|
|
DO_TEST("cpu-topology2", NONE);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("cpu-topology3", NONE);
|
2014-09-23 17:07:09 +00:00
|
|
|
DO_TEST("cpu-minimum1", QEMU_CAPS_KVM);
|
|
|
|
DO_TEST("cpu-minimum2", QEMU_CAPS_KVM);
|
|
|
|
DO_TEST("cpu-exact1", QEMU_CAPS_KVM);
|
|
|
|
DO_TEST("cpu-exact2", QEMU_CAPS_KVM);
|
|
|
|
DO_TEST("cpu-exact2-nofallback", QEMU_CAPS_KVM);
|
|
|
|
DO_TEST("cpu-fallback", QEMU_CAPS_KVM);
|
|
|
|
DO_TEST_FAILURE("cpu-nofallback", QEMU_CAPS_KVM);
|
|
|
|
DO_TEST("cpu-strict1", QEMU_CAPS_KVM);
|
2019-04-25 09:51:55 +00:00
|
|
|
DO_TEST("cpu-no-removed-features", QEMU_CAPS_KVM);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("cpu-numa1", NONE);
|
2016-06-23 11:29:16 +00:00
|
|
|
DO_TEST("cpu-numa2", NONE);
|
|
|
|
DO_TEST("cpu-numa-no-memory-element", NONE);
|
2014-05-22 07:13:05 +00:00
|
|
|
DO_TEST_PARSE_ERROR("cpu-numa3", NONE);
|
2019-12-09 23:15:12 +00:00
|
|
|
DO_TEST_PARSE_ERROR("cpu-numa-disjoint", NONE);
|
2014-06-17 12:16:59 +00:00
|
|
|
DO_TEST("cpu-numa-disjoint", QEMU_CAPS_NUMA);
|
2016-06-23 11:29:16 +00:00
|
|
|
DO_TEST_FAILURE("cpu-numa-memshared", QEMU_CAPS_OBJECT_MEMORY_RAM);
|
2020-09-22 11:57:39 +00:00
|
|
|
DO_TEST_PARSE_ERROR("cpu-numa-memshared-1", NONE);
|
2017-06-14 08:40:20 +00:00
|
|
|
DO_TEST("cpu-numa-memshared", QEMU_CAPS_OBJECT_MEMORY_FILE);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("cpu-host-model", NONE);
|
2015-04-30 09:10:16 +00:00
|
|
|
DO_TEST("cpu-host-model-vendor", NONE);
|
2019-03-13 19:59:42 +00:00
|
|
|
DO_TEST_FULL("cpu-host-model-fallback",
|
2019-03-13 20:04:44 +00:00
|
|
|
ARG_FLAGS, FLAG_SKIP_LEGACY_CPUS,
|
2019-03-13 19:18:11 +00:00
|
|
|
ARG_QEMU_CAPS, NONE);
|
2019-03-13 19:59:42 +00:00
|
|
|
DO_TEST_FULL("cpu-host-model-nofallback",
|
2019-03-13 20:04:44 +00:00
|
|
|
ARG_FLAGS, FLAG_SKIP_LEGACY_CPUS | FLAG_EXPECT_FAILURE,
|
2019-03-13 19:18:11 +00:00
|
|
|
ARG_QEMU_CAPS, NONE);
|
2016-05-16 08:08:29 +00:00
|
|
|
DO_TEST("cpu-host-passthrough", QEMU_CAPS_KVM);
|
|
|
|
DO_TEST_FAILURE("cpu-qemu-host-passthrough", QEMU_CAPS_KVM);
|
2011-02-08 14:22:39 +00:00
|
|
|
|
2019-11-26 17:51:22 +00:00
|
|
|
qemuTestSetHostArch(&driver, VIR_ARCH_S390X);
|
2018-05-07 14:41:11 +00:00
|
|
|
DO_TEST("cpu-s390-zEC12", QEMU_CAPS_KVM, QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
|
2016-12-18 19:22:29 +00:00
|
|
|
DO_TEST("cpu-s390-features", QEMU_CAPS_KVM, QEMU_CAPS_QUERY_CPU_MODEL_EXPANSION);
|
|
|
|
DO_TEST_FAILURE("cpu-s390-features", QEMU_CAPS_KVM);
|
2019-11-26 17:51:22 +00:00
|
|
|
qemuTestSetHostArch(&driver, VIR_ARCH_NONE);
|
2016-12-18 19:22:28 +00:00
|
|
|
|
2019-11-29 10:40:39 +00:00
|
|
|
qemuTestSetHostCPU(&driver, driver.hostarch, cpuHaswell);
|
2015-03-23 16:19:28 +00:00
|
|
|
DO_TEST("cpu-Haswell", QEMU_CAPS_KVM);
|
|
|
|
DO_TEST("cpu-Haswell2", QEMU_CAPS_KVM);
|
|
|
|
DO_TEST("cpu-Haswell3", QEMU_CAPS_KVM);
|
|
|
|
DO_TEST("cpu-Haswell-noTSX", QEMU_CAPS_KVM);
|
2016-08-09 13:03:20 +00:00
|
|
|
DO_TEST("cpu-host-model-cmt", NONE);
|
2019-10-07 06:55:31 +00:00
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-cmt", "4.0.0");
|
2017-03-23 14:54:38 +00:00
|
|
|
DO_TEST("cpu-tsc-frequency", QEMU_CAPS_KVM);
|
2019-10-07 06:55:31 +00:00
|
|
|
DO_TEST_CAPS_VER("cpu-tsc-frequency", "4.0.0");
|
2019-06-11 15:14:27 +00:00
|
|
|
DO_TEST_CAPS_VER("cpu-translation", "4.0.0");
|
|
|
|
DO_TEST_CAPS_LATEST("cpu-translation");
|
2019-11-29 10:40:39 +00:00
|
|
|
qemuTestSetHostCPU(&driver, driver.hostarch, NULL);
|
2015-03-23 16:19:28 +00:00
|
|
|
|
2018-05-22 12:53:06 +00:00
|
|
|
DO_TEST("encrypted-disk", QEMU_CAPS_QCOW2_LUKS, QEMU_CAPS_OBJECT_SECRET);
|
|
|
|
DO_TEST("encrypted-disk-usage", QEMU_CAPS_QCOW2_LUKS, QEMU_CAPS_OBJECT_SECRET);
|
2016-06-02 20:28:28 +00:00
|
|
|
DO_TEST("luks-disks", QEMU_CAPS_OBJECT_SECRET);
|
2017-09-14 13:32:57 +00:00
|
|
|
DO_TEST("luks-disks-source", QEMU_CAPS_OBJECT_SECRET);
|
2018-03-28 13:39:35 +00:00
|
|
|
DO_TEST_PARSE_ERROR("luks-disks-source-qcow2", QEMU_CAPS_OBJECT_SECRET);
|
|
|
|
DO_TEST("luks-disks-source-qcow2", QEMU_CAPS_OBJECT_SECRET, QEMU_CAPS_QCOW2_LUKS);
|
2020-01-10 16:49:42 +00:00
|
|
|
DO_TEST_CAPS_LATEST("luks-disks-source-qcow2");
|
2017-09-14 15:14:57 +00:00
|
|
|
DO_TEST_PARSE_ERROR("luks-disk-invalid", NONE);
|
2017-09-14 13:32:57 +00:00
|
|
|
DO_TEST_PARSE_ERROR("luks-disks-source-both", QEMU_CAPS_OBJECT_SECRET);
|
2016-06-06 12:57:38 +00:00
|
|
|
|
2015-11-06 14:29:41 +00:00
|
|
|
DO_TEST("memtune", NONE);
|
|
|
|
DO_TEST("memtune-unlimited", NONE);
|
|
|
|
DO_TEST("blkiotune", NONE);
|
|
|
|
DO_TEST("blkiotune-device", NONE);
|
|
|
|
DO_TEST("cputune", NONE);
|
|
|
|
DO_TEST("cputune-zero-shares", NONE);
|
|
|
|
DO_TEST_PARSE_ERROR("cputune-iothreadsched-toomuch", NONE);
|
|
|
|
DO_TEST_PARSE_ERROR("cputune-vcpusched-overlap", NONE);
|
2016-06-23 11:29:16 +00:00
|
|
|
DO_TEST("cputune-numatune",
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_KVM,
|
qemu: Fix qemu startup check for QEMU_CAPS_OBJECT_IOTHREAD
https://bugzilla.redhat.com/show_bug.cgi?id=1249981
When qemuDomainPinIOThread was added in commit id 'fb562614', a check
for the IOThread capability was not needed since a check for iothreadpids
covered the condition where the support for IOThreads was not present.
The iothreadpids array was only created if qemuProcessDetectIOThreadPIDs
was able to query the monitor for IOThreads. It would only do that if
the QEMU_CAPS_OBJECT_IOTHREAD capability was set.
However, when iothreadids were added in commit id '8d4614a5' and the
check for iothreadpids was replaced by a search through the iothreadids[]
array for the matching iothread_id that left open the possibility that
an iothreadids[] array was defined, but the entries essentially pointed
to elements with only the 'iothread_id' defined leaving the 'thread_id'
value of 0 and eventually the cpumap entry of NULL.
This was because, the original IOThreads commit id '72edaae7' only
checked if IOThreads were defined and if the emulator had the IOThreads
capability, then IOThread objects were added at startup. The "capability
failure" check was only done when a disk was assigned to an IOThread in
qemuCheckIOThreads. This was because the initial implementation had no way
to dynamically add IOThreads, but it was possible to dynamically add a
disk to the domain. So the decision was if the domain supported it, then
add the IOThread objects. Then if a disk with an IOThread defined was
added, it could check the capability and fail to add if not there. This
just meant the 'iothreads' value was essentially ignored.
Eventually commit id 'a27ed6e7' allowed for the dynamic addition and
deletion of IOThread objects. So it was no longer necessary to generate
IOThread objects to dynamically attach a disk to. However, the startup
and disk check code was not modified to reflect this.
This patch will move the capability failure check to when IOThread
objects are being added to the command line. Thus a domain that has
IOThreads defined will not be started if the emulator doesn't support
the capability. This means when qemuCheckIOThreads is called to add
a disk, it's no longer necessary to check the capability. Instead the
code can use the IOThreadFind call to indicate that the IOThread
doesn't exist.
Finally because it could be possible to have a domain running with the
iothreadids[] defined prior to this change if libvirtd is restarted each
having mostly empty elements, qemuProcessDetectIOThreadPIDs will check
if there are niothreadids when the QEMU_CAPS_OBJECT_IOTHREAD capability
check fails and remove the elements and array if it exists.
With these changes in place, it turns out the cputune-numatune test
was failing because the right bit wasn't set in the test. So used the
opportunity to fix that and create a test that would expect to fail
with some sort of iothreads defined and used, but not having the
correct capability.
2015-10-15 16:30:40 +00:00
|
|
|
QEMU_CAPS_OBJECT_IOTHREAD,
|
qemuBuildMemoryBackendStr: Report backend requirement more appropriately
So, when building the '-numa' command line, the
qemuBuildMemoryBackendStr() function does quite a lot of checks to
chose the best backend, or to check if one is in fact needed. However,
it returned that backend is needed even for this little fella:
<numatune>
<memory mode="strict" nodeset="0,2"/>
</numatune>
This can be guaranteed via CGroups entirely, there's no need to use
memory-backend-ram to let qemu know where to get memory from. Well, as
long as there's no <memnode/> element, which explicitly requires the
backend. Long story short, we wouldn't have to care, as qemu works
either way. However, the problem is migration (as always). Previously,
libvirt would have started qemu with:
-numa node,memory=X
in this case and restricted memory placement in CGroups. Today, libvirt
creates more complicated command line:
-object memory-backend-ram,id=ram-node0,size=X
-numa node,memdev=ram-node0
Again, one wouldn't find anything wrong with these two approaches.
Both work just fine. Unless you try to migrated from the older libvirt
into the newer one. These two approaches are, unfortunately, not
compatible. My suggestion is, in order to allow users to migrate, lets
use the older approach for as long as the newer one is not needed.
Signed-off-by: Michal Privoznik <mprivozn@redhat.com>
2015-02-12 16:43:27 +00:00
|
|
|
QEMU_CAPS_OBJECT_MEMORY_RAM,
|
|
|
|
QEMU_CAPS_OBJECT_MEMORY_FILE);
|
2017-02-23 17:47:36 +00:00
|
|
|
DO_TEST("vcpu-placement-static",
|
|
|
|
QEMU_CAPS_KVM,
|
|
|
|
QEMU_CAPS_OBJECT_IOTHREAD);
|
2020-06-11 11:57:07 +00:00
|
|
|
DO_TEST_CAPS_LATEST("cputune-cpuset-big-id");
|
2014-07-02 09:15:45 +00:00
|
|
|
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("numatune-memory", NONE);
|
2014-08-11 14:06:23 +00:00
|
|
|
DO_TEST_PARSE_ERROR("numatune-memory-invalid-nodeset", NONE);
|
2018-05-02 15:37:59 +00:00
|
|
|
DO_TEST("numatune-memnode",
|
|
|
|
QEMU_CAPS_NUMA,
|
|
|
|
QEMU_CAPS_OBJECT_MEMORY_RAM);
|
2019-12-09 23:15:12 +00:00
|
|
|
DO_TEST_PARSE_ERROR("numatune-memnode", NONE);
|
2014-07-02 09:15:45 +00:00
|
|
|
|
2018-05-02 15:37:59 +00:00
|
|
|
DO_TEST("numatune-memnode-no-memory",
|
|
|
|
QEMU_CAPS_NUMA,
|
|
|
|
QEMU_CAPS_OBJECT_MEMORY_RAM);
|
2019-12-09 23:15:12 +00:00
|
|
|
DO_TEST_PARSE_ERROR("numatune-memnode-no-memory", NONE);
|
2014-07-02 09:15:45 +00:00
|
|
|
|
2017-11-14 13:31:17 +00:00
|
|
|
DO_TEST("numatune-distances", QEMU_CAPS_NUMA, QEMU_CAPS_NUMA_DIST);
|
2020-05-27 11:42:22 +00:00
|
|
|
DO_TEST("numatune-no-vcpu", NONE);
|
2020-07-08 09:28:37 +00:00
|
|
|
DO_TEST_CAPS_LATEST("numatune-hmat");
|
2017-11-14 13:31:17 +00:00
|
|
|
|
2013-09-11 08:49:39 +00:00
|
|
|
DO_TEST("numatune-auto-nodeset-invalid", NONE);
|
qemuBuildMemoryBackendStr: Report backend requirement more appropriately
So, when building the '-numa' command line, the
qemuBuildMemoryBackendStr() function does quite a lot of checks to
chose the best backend, or to check if one is in fact needed. However,
it returned that backend is needed even for this little fella:
<numatune>
<memory mode="strict" nodeset="0,2"/>
</numatune>
This can be guaranteed via CGroups entirely, there's no need to use
memory-backend-ram to let qemu know where to get memory from. Well, as
long as there's no <memnode/> element, which explicitly requires the
backend. Long story short, we wouldn't have to care, as qemu works
either way. However, the problem is migration (as always). Previously,
libvirt would have started qemu with:
-numa node,memory=X
in this case and restricted memory placement in CGroups. Today, libvirt
creates more complicated command line:
-object memory-backend-ram,id=ram-node0,size=X
-numa node,memdev=ram-node0
Again, one wouldn't find anything wrong with these two approaches.
Both work just fine. Unless you try to migrated from the older libvirt
into the newer one. These two approaches are, unfortunately, not
compatible. My suggestion is, in order to allow users to migrate, lets
use the older approach for as long as the newer one is not needed.
Signed-off-by: Michal Privoznik <mprivozn@redhat.com>
2015-02-12 16:43:27 +00:00
|
|
|
DO_TEST("numatune-auto-prefer", QEMU_CAPS_OBJECT_MEMORY_RAM,
|
|
|
|
QEMU_CAPS_OBJECT_MEMORY_FILE);
|
2014-11-04 02:44:40 +00:00
|
|
|
DO_TEST_FAILURE("numatune-static-nodeset-exceed-hostnode",
|
|
|
|
QEMU_CAPS_OBJECT_MEMORY_RAM);
|
2014-07-15 09:39:44 +00:00
|
|
|
DO_TEST_PARSE_ERROR("numatune-memnode-nocpu", NONE);
|
|
|
|
DO_TEST_PARSE_ERROR("numatune-memnodes-problematic", NONE);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("numad", NONE);
|
|
|
|
DO_TEST("numad-auto-vcpu-static-numatune", NONE);
|
2014-08-22 14:05:37 +00:00
|
|
|
DO_TEST_PARSE_ERROR("numad-auto-vcpu-static-numatune-no-nodeset", NONE);
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("numad-auto-memory-vcpu-cpuset", NONE);
|
|
|
|
DO_TEST("numad-auto-memory-vcpu-no-cpuset-and-placement", NONE);
|
|
|
|
DO_TEST("numad-static-memory-auto-vcpu", NONE);
|
2020-05-04 16:16:26 +00:00
|
|
|
DO_TEST_CAPS_VER("blkdeviotune-max", "4.1.0");
|
|
|
|
DO_TEST_CAPS_LATEST("blkdeviotune-max");
|
|
|
|
DO_TEST_CAPS_VER("blkdeviotune-group-num", "4.1.0");
|
|
|
|
DO_TEST_CAPS_LATEST("blkdeviotune-group-num");
|
|
|
|
DO_TEST_CAPS_VER("blkdeviotune-max-length", "4.1.0");
|
|
|
|
DO_TEST_CAPS_LATEST("blkdeviotune-max-length");
|
2011-02-08 06:59:38 +00:00
|
|
|
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("multifunction-pci-device",
|
2018-03-28 21:20:45 +00:00
|
|
|
QEMU_CAPS_SCSI_LSI);
|
2011-06-08 04:34:04 +00:00
|
|
|
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST("monitor-json", NONE);
|
2011-06-15 16:49:58 +00:00
|
|
|
|
2015-11-06 14:29:41 +00:00
|
|
|
DO_TEST("seclabel-dynamic", NONE);
|
|
|
|
DO_TEST("seclabel-dynamic-baselabel", NONE);
|
|
|
|
DO_TEST("seclabel-dynamic-override", NONE);
|
|
|
|
DO_TEST("seclabel-dynamic-labelskip", NONE);
|
|
|
|
DO_TEST("seclabel-dynamic-relabel", NONE);
|
|
|
|
DO_TEST("seclabel-static", NONE);
|
|
|
|
DO_TEST("seclabel-static-relabel", NONE);
|
|
|
|
DO_TEST("seclabel-static-labelskip", NONE);
|
|
|
|
DO_TEST("seclabel-none", NONE);
|
|
|
|
DO_TEST("seclabel-dac-none", NONE);
|
|
|
|
DO_TEST_PARSE_ERROR("seclabel-multiple", NONE);
|
|
|
|
DO_TEST_PARSE_ERROR("seclabel-device-duplicates", NONE);
|
2011-12-23 00:47:46 +00:00
|
|
|
|
2012-07-09 16:29:55 +00:00
|
|
|
DO_TEST("pseries-basic",
|
2018-02-21 09:18:19 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_VTY);
|
2015-11-06 14:28:57 +00:00
|
|
|
DO_TEST("pseries-vio",
|
2018-02-21 09:18:19 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_VTY);
|
2015-11-06 14:28:57 +00:00
|
|
|
DO_TEST("pseries-usb-default",
|
2018-02-21 09:18:19 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
2017-11-08 18:13:28 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_VTY,
|
2017-06-26 17:13:00 +00:00
|
|
|
QEMU_CAPS_PIIX3_USB_UHCI,
|
2018-03-28 21:20:45 +00:00
|
|
|
QEMU_CAPS_PCI_OHCI);
|
2015-11-06 14:28:57 +00:00
|
|
|
DO_TEST("pseries-usb-multi",
|
2018-02-21 09:18:19 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
2017-11-08 18:13:28 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_VTY,
|
2017-06-26 17:13:00 +00:00
|
|
|
QEMU_CAPS_PIIX3_USB_UHCI,
|
2018-03-28 21:20:45 +00:00
|
|
|
QEMU_CAPS_PCI_OHCI);
|
2015-11-06 14:28:57 +00:00
|
|
|
DO_TEST("pseries-vio-user-assigned",
|
2018-02-21 09:18:19 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_VTY);
|
|
|
|
DO_TEST_PARSE_ERROR("pseries-vio-address-clash", NONE);
|
2018-02-21 09:18:19 +00:00
|
|
|
DO_TEST("pseries-nvram",
|
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
|
|
|
QEMU_CAPS_DEVICE_NVRAM);
|
2014-02-17 10:17:56 +00:00
|
|
|
DO_TEST("pseries-usb-kbd", QEMU_CAPS_PCI_OHCI,
|
2018-02-21 09:18:19 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
2017-06-26 17:13:00 +00:00
|
|
|
QEMU_CAPS_DEVICE_USB_KBD,
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_VTY);
|
2017-06-26 17:13:00 +00:00
|
|
|
DO_TEST("pseries-cpu-exact",
|
2018-02-21 09:18:19 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_VTY);
|
|
|
|
DO_TEST_PARSE_ERROR("pseries-no-parallel", NONE);
|
2016-08-04 11:19:39 +00:00
|
|
|
|
2019-11-26 17:51:22 +00:00
|
|
|
qemuTestSetHostArch(&driver, VIR_ARCH_PPC64);
|
2016-05-16 08:08:29 +00:00
|
|
|
DO_TEST("pseries-cpu-compat", QEMU_CAPS_KVM,
|
2018-02-21 09:18:19 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_VTY);
|
2018-01-05 13:48:00 +00:00
|
|
|
DO_TEST("pseries-machine-max-cpu-compat",
|
|
|
|
QEMU_CAPS_KVM,
|
|
|
|
QEMU_CAPS_MACHINE_PSERIES_MAX_CPU_COMPAT,
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE);
|
2016-05-16 08:08:29 +00:00
|
|
|
DO_TEST("pseries-cpu-le", QEMU_CAPS_KVM,
|
2018-02-21 09:18:19 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_VTY);
|
2018-02-21 09:18:19 +00:00
|
|
|
DO_TEST_FAILURE("pseries-cpu-compat-power9",
|
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
|
|
|
QEMU_CAPS_KVM);
|
2017-05-17 14:39:16 +00:00
|
|
|
|
2019-11-29 10:40:39 +00:00
|
|
|
qemuTestSetHostCPU(&driver, driver.hostarch, cpuPower9);
|
2017-05-17 14:39:16 +00:00
|
|
|
DO_TEST("pseries-cpu-compat-power9",
|
2017-06-26 17:13:00 +00:00
|
|
|
QEMU_CAPS_KVM,
|
2018-02-21 09:18:19 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_VTY);
|
2019-11-29 10:40:39 +00:00
|
|
|
qemuTestSetHostCPU(&driver, driver.hostarch, NULL);
|
2017-05-17 14:39:16 +00:00
|
|
|
|
2019-11-26 17:51:22 +00:00
|
|
|
qemuTestSetHostArch(&driver, VIR_ARCH_NONE);
|
2016-08-04 11:19:39 +00:00
|
|
|
|
2015-05-28 14:39:13 +00:00
|
|
|
DO_TEST("pseries-panic-missing",
|
2018-02-21 09:18:19 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_VTY);
|
2015-05-28 14:39:12 +00:00
|
|
|
DO_TEST("pseries-panic-no-address",
|
2018-02-21 09:18:19 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_VTY);
|
2020-10-13 21:38:07 +00:00
|
|
|
DO_TEST_PARSE_ERROR("pseries-panic-address",
|
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE);
|
2017-02-20 17:20:26 +00:00
|
|
|
|
|
|
|
DO_TEST("pseries-phb-simple",
|
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE);
|
|
|
|
DO_TEST("pseries-phb-default-missing",
|
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE);
|
2017-07-21 08:03:15 +00:00
|
|
|
DO_TEST("pseries-phb-numa-node",
|
|
|
|
QEMU_CAPS_NUMA,
|
|
|
|
QEMU_CAPS_OBJECT_MEMORY_RAM,
|
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
|
|
|
QEMU_CAPS_SPAPR_PCI_HOST_BRIDGE_NUMA_NODE);
|
|
|
|
DO_TEST_PARSE_ERROR("pseries-default-phb-numa-node", NONE);
|
2017-08-17 14:45:28 +00:00
|
|
|
DO_TEST_PARSE_ERROR("pseries-phb-invalid-target-index-1", NONE);
|
|
|
|
DO_TEST_PARSE_ERROR("pseries-phb-invalid-target-index-2", NONE);
|
|
|
|
DO_TEST_PARSE_ERROR("pseries-phb-invalid-target-index-3", NONE);
|
2017-02-20 17:20:26 +00:00
|
|
|
|
2017-05-26 16:33:36 +00:00
|
|
|
DO_TEST("pseries-many-devices",
|
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
|
|
|
QEMU_CAPS_VIRTIO_SCSI);
|
|
|
|
DO_TEST("pseries-many-buses-1",
|
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
|
|
|
QEMU_CAPS_VIRTIO_SCSI);
|
|
|
|
DO_TEST("pseries-many-buses-2",
|
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
|
|
|
QEMU_CAPS_VIRTIO_SCSI);
|
|
|
|
DO_TEST("pseries-hostdevs-1",
|
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
|
|
|
QEMU_CAPS_VIRTIO_SCSI,
|
|
|
|
QEMU_CAPS_DEVICE_VFIO_PCI);
|
|
|
|
DO_TEST("pseries-hostdevs-2",
|
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
|
|
|
QEMU_CAPS_VIRTIO_SCSI,
|
|
|
|
QEMU_CAPS_DEVICE_VFIO_PCI);
|
|
|
|
DO_TEST("pseries-hostdevs-3",
|
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
|
|
|
QEMU_CAPS_VIRTIO_SCSI,
|
|
|
|
QEMU_CAPS_DEVICE_VFIO_PCI);
|
|
|
|
|
2018-03-01 17:13:23 +00:00
|
|
|
DO_TEST("pseries-features",
|
2018-02-21 09:18:19 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
2018-05-23 16:18:01 +00:00
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_HPT_MAX_PAGE_SIZE,
|
2018-07-02 08:35:54 +00:00
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_HTM,
|
2018-11-20 12:56:38 +00:00
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_NESTED_HV,
|
2019-10-08 20:06:24 +00:00
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_CCF_ASSIST,
|
2020-04-27 12:14:27 +00:00
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_CFPC,
|
2020-04-27 12:14:29 +00:00
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_SBBC,
|
2020-04-27 12:14:31 +00:00
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_IBS,
|
2017-11-06 15:39:58 +00:00
|
|
|
QEMU_CAPS_MACHINE_PSERIES_RESIZE_HPT);
|
2019-12-09 23:15:06 +00:00
|
|
|
|
|
|
|
/* parse error: no QEMU_CAPS_MACHINE_PSERIES_RESIZE_HPT */
|
2020-09-22 11:57:39 +00:00
|
|
|
DO_TEST_PARSE_ERROR("pseries-features-htp-resize",
|
2019-12-09 23:15:06 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_HPT_MAX_PAGE_SIZE,
|
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_HTM,
|
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_NESTED_HV,
|
2020-04-27 12:14:27 +00:00
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_CCF_ASSIST,
|
2020-04-27 12:14:29 +00:00
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_CFPC,
|
2020-04-27 12:14:31 +00:00
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_SBBC,
|
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_IBS);
|
2019-12-09 23:15:06 +00:00
|
|
|
|
|
|
|
/* parse error: no QEMU_CAPS_MACHINE_PSERIES_CAP_HPT_MAX_PAGE_SIZE */
|
2020-09-22 11:57:39 +00:00
|
|
|
DO_TEST_PARSE_ERROR("pseries-features-hpt-pagesize",
|
2019-12-09 23:15:06 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_HTM,
|
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_NESTED_HV,
|
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_CCF_ASSIST,
|
2020-04-27 12:14:27 +00:00
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_CFPC,
|
2020-04-27 12:14:29 +00:00
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_SBBC,
|
2020-04-27 12:14:31 +00:00
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_IBS,
|
2019-12-09 23:15:06 +00:00
|
|
|
QEMU_CAPS_MACHINE_PSERIES_RESIZE_HPT);
|
|
|
|
|
|
|
|
/* parse error: no QEMU_CAPS_MACHINE_PSERIES_CAP_HTM */
|
2020-09-22 11:57:39 +00:00
|
|
|
DO_TEST_PARSE_ERROR("pseries-features-htm",
|
2019-12-09 23:15:06 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_HPT_MAX_PAGE_SIZE,
|
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_NESTED_HV,
|
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_CCF_ASSIST,
|
2020-04-27 12:14:27 +00:00
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_CFPC,
|
2020-04-27 12:14:29 +00:00
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_SBBC,
|
2020-04-27 12:14:31 +00:00
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_IBS,
|
2019-12-09 23:15:06 +00:00
|
|
|
QEMU_CAPS_MACHINE_PSERIES_RESIZE_HPT);
|
|
|
|
|
|
|
|
/* parse error: no QEMU_CAPS_MACHINE_PSERIES_CAP_NESTED_HV */
|
2020-09-22 11:57:39 +00:00
|
|
|
DO_TEST_PARSE_ERROR("pseries-features-nested-hv",
|
2019-12-09 23:15:06 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_HPT_MAX_PAGE_SIZE,
|
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_HTM,
|
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_CCF_ASSIST,
|
2020-04-27 12:14:27 +00:00
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_CFPC,
|
2020-04-27 12:14:29 +00:00
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_SBBC,
|
2020-04-27 12:14:31 +00:00
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_IBS,
|
2019-12-09 23:15:06 +00:00
|
|
|
QEMU_CAPS_MACHINE_PSERIES_RESIZE_HPT);
|
|
|
|
|
|
|
|
/* parse error: no QEMU_CAPS_MACHINE_PSERIES_CAP_CCF_ASSIST */
|
2020-09-22 11:57:39 +00:00
|
|
|
DO_TEST_PARSE_ERROR("pseries-features-ccf",
|
2019-12-09 23:15:06 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_HPT_MAX_PAGE_SIZE,
|
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_HTM,
|
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_NESTED_HV,
|
2020-04-27 12:14:27 +00:00
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_CFPC,
|
2020-04-27 12:14:29 +00:00
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_SBBC,
|
2020-04-27 12:14:31 +00:00
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_IBS,
|
2019-12-09 23:15:06 +00:00
|
|
|
QEMU_CAPS_MACHINE_PSERIES_RESIZE_HPT);
|
|
|
|
|
2020-04-27 12:14:27 +00:00
|
|
|
/* parse error: no QEMU_CAPS_MACHINE_PSERIES_CFPC */
|
2020-09-22 11:57:39 +00:00
|
|
|
DO_TEST_PARSE_ERROR("pseries-features-cfpc",
|
2020-04-27 12:14:27 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
|
|
|
QEMU_CAPS_MACHINE_PSERIES_RESIZE_HPT,
|
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_HPT_MAX_PAGE_SIZE,
|
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_HTM,
|
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_NESTED_HV,
|
2020-04-27 12:14:29 +00:00
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_CCF_ASSIST,
|
2020-04-27 12:14:31 +00:00
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_SBBC,
|
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_IBS);
|
2020-04-27 12:14:29 +00:00
|
|
|
|
|
|
|
/* parse error: no QEMU_CAPS_MACHINE_PSERIES_SBBC */
|
2020-09-22 11:57:39 +00:00
|
|
|
DO_TEST_PARSE_ERROR("pseries-features-sbbc",
|
2020-04-27 12:14:29 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
|
|
|
QEMU_CAPS_MACHINE_PSERIES_RESIZE_HPT,
|
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_HPT_MAX_PAGE_SIZE,
|
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_HTM,
|
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_NESTED_HV,
|
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_CCF_ASSIST,
|
2020-04-27 12:14:31 +00:00
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_CFPC,
|
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_IBS);
|
|
|
|
|
|
|
|
/* parse error: no QEMU_CAPS_MACHINE_PSERIES_IBS */
|
2020-09-22 11:57:39 +00:00
|
|
|
DO_TEST_PARSE_ERROR("pseries-features-ibs",
|
2020-04-27 12:14:31 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
|
|
|
QEMU_CAPS_MACHINE_PSERIES_RESIZE_HPT,
|
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_HPT_MAX_PAGE_SIZE,
|
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_HTM,
|
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_NESTED_HV,
|
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_CCF_ASSIST,
|
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_CFPC,
|
|
|
|
QEMU_CAPS_MACHINE_PSERIES_CAP_SBBC);
|
2020-04-27 12:14:27 +00:00
|
|
|
|
2018-01-23 09:50:04 +00:00
|
|
|
DO_TEST_PARSE_ERROR("pseries-features-invalid-machine", NONE);
|
2017-11-06 15:39:58 +00:00
|
|
|
|
2017-11-08 14:31:21 +00:00
|
|
|
DO_TEST("pseries-serial-native",
|
2018-02-21 09:18:19 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
2017-11-08 14:31:21 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_VTY);
|
|
|
|
DO_TEST("pseries-serial+console-native",
|
2018-02-21 09:18:19 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
2017-11-08 14:31:21 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_VTY);
|
|
|
|
DO_TEST("pseries-serial-compat",
|
2018-02-21 09:18:19 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
2017-11-08 14:31:21 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_VTY);
|
2017-11-10 16:57:53 +00:00
|
|
|
DO_TEST("pseries-serial-pci",
|
2018-02-21 09:18:19 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
2017-11-10 16:57:53 +00:00
|
|
|
QEMU_CAPS_DEVICE_PCI_SERIAL);
|
|
|
|
DO_TEST("pseries-serial-usb",
|
2018-02-21 09:18:19 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
2017-11-10 16:57:53 +00:00
|
|
|
QEMU_CAPS_DEVICE_QEMU_XHCI,
|
|
|
|
QEMU_CAPS_DEVICE_USB_SERIAL);
|
2017-11-08 14:31:21 +00:00
|
|
|
DO_TEST("pseries-console-native",
|
2018-02-21 09:18:19 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
2017-11-08 14:31:21 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_VTY);
|
|
|
|
DO_TEST("pseries-console-virtio",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE);
|
2017-11-08 14:31:21 +00:00
|
|
|
DO_TEST_PARSE_ERROR("pseries-serial-invalid-machine", NONE);
|
2019-06-14 10:50:43 +00:00
|
|
|
DO_TEST_PARSE_ERROR("pseries-spaprvio-invalid", "ppc64");
|
2017-11-08 14:31:21 +00:00
|
|
|
|
2017-11-09 16:14:57 +00:00
|
|
|
DO_TEST("mach-virt-serial-native",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_PL011);
|
2017-11-09 16:14:57 +00:00
|
|
|
DO_TEST("mach-virt-serial+console-native",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_PL011);
|
2017-11-09 16:14:57 +00:00
|
|
|
DO_TEST("mach-virt-serial-compat",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_PL011);
|
2017-11-09 16:14:57 +00:00
|
|
|
DO_TEST("mach-virt-serial-pci",
|
|
|
|
QEMU_CAPS_OBJECT_GPEX,
|
|
|
|
QEMU_CAPS_DEVICE_PCIE_ROOT_PORT,
|
|
|
|
QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
|
|
|
|
QEMU_CAPS_DEVICE_PCI_BRIDGE,
|
|
|
|
QEMU_CAPS_DEVICE_PCI_SERIAL);
|
|
|
|
DO_TEST("mach-virt-serial-usb",
|
|
|
|
QEMU_CAPS_OBJECT_GPEX,
|
|
|
|
QEMU_CAPS_DEVICE_PCIE_ROOT_PORT,
|
|
|
|
QEMU_CAPS_DEVICE_QEMU_XHCI,
|
|
|
|
QEMU_CAPS_DEVICE_USB_SERIAL);
|
|
|
|
DO_TEST("mach-virt-console-native",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_PL011);
|
2018-08-30 16:03:58 +00:00
|
|
|
DO_TEST("mach-virt-console-virtio",
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_MMIO);
|
2017-11-09 16:14:57 +00:00
|
|
|
DO_TEST_PARSE_ERROR("mach-virt-serial-invalid-machine", NONE);
|
|
|
|
|
2019-01-28 13:44:57 +00:00
|
|
|
DO_TEST("disk-ide-split", NONE);
|
2020-10-08 14:02:20 +00:00
|
|
|
DO_TEST("disk-ide-wwn",
|
|
|
|
QEMU_CAPS_IDE_DRIVE_WWN,
|
|
|
|
QEMU_CAPS_SCSI_DISK_WWN);
|
2012-01-13 03:39:25 +00:00
|
|
|
|
2015-11-06 14:28:57 +00:00
|
|
|
DO_TEST("disk-geometry", NONE);
|
2019-01-28 13:44:57 +00:00
|
|
|
DO_TEST("disk-blockio", QEMU_CAPS_BLOCKIO);
|
2012-08-20 13:58:51 +00:00
|
|
|
|
2012-12-14 07:09:17 +00:00
|
|
|
DO_TEST("video-device-pciaddr-default",
|
2017-02-23 17:47:36 +00:00
|
|
|
QEMU_CAPS_KVM,
|
|
|
|
QEMU_CAPS_VNC,
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
|
2017-02-23 17:47:36 +00:00
|
|
|
QEMU_CAPS_DEVICE_QXL);
|
2016-10-10 15:51:38 +00:00
|
|
|
DO_TEST("video-vga-nodevice", QEMU_CAPS_DEVICE_VGA);
|
2016-01-13 00:26:40 +00:00
|
|
|
DO_TEST("video-vga-device", QEMU_CAPS_DEVICE_VGA,
|
2014-11-20 18:51:12 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
|
2016-01-13 00:26:40 +00:00
|
|
|
DO_TEST("video-vga-device-vgamem", QEMU_CAPS_DEVICE_VGA,
|
2014-11-20 18:51:12 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY, QEMU_CAPS_VGA_VGAMEM);
|
2016-10-11 15:46:39 +00:00
|
|
|
DO_TEST("video-qxl-nodevice", QEMU_CAPS_DEVICE_QXL);
|
2016-10-11 15:42:37 +00:00
|
|
|
DO_TEST("video-qxl-device",
|
2016-09-21 16:26:21 +00:00
|
|
|
QEMU_CAPS_DEVICE_QXL,
|
2014-11-20 18:51:12 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
|
2016-01-13 00:26:40 +00:00
|
|
|
DO_TEST("video-qxl-device-vgamem",
|
2016-10-11 15:42:37 +00:00
|
|
|
QEMU_CAPS_DEVICE_QXL,
|
2016-09-21 16:26:21 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
|
2016-10-11 15:42:37 +00:00
|
|
|
QEMU_CAPS_QXL_VGAMEM);
|
2018-08-27 15:59:26 +00:00
|
|
|
DO_TEST_CAPS_LATEST("video-qxl-device-vram64");
|
2016-10-11 15:42:37 +00:00
|
|
|
DO_TEST("video-qxl-sec-device",
|
2014-11-20 18:51:12 +00:00
|
|
|
QEMU_CAPS_DEVICE_QXL, QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
|
2016-01-13 00:26:40 +00:00
|
|
|
DO_TEST("video-qxl-sec-device-vgamem",
|
2016-10-11 15:42:37 +00:00
|
|
|
QEMU_CAPS_DEVICE_QXL,
|
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
|
2014-11-20 18:52:00 +00:00
|
|
|
QEMU_CAPS_QXL_VGAMEM);
|
2018-08-27 15:59:26 +00:00
|
|
|
DO_TEST_CAPS_LATEST("video-qxl-sec-device-vram64");
|
2015-12-11 13:43:10 +00:00
|
|
|
DO_TEST("video-qxl-heads",
|
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
|
|
|
|
QEMU_CAPS_DEVICE_QXL,
|
2016-10-11 15:42:37 +00:00
|
|
|
QEMU_CAPS_QXL_MAX_OUTPUTS);
|
2017-06-14 09:20:52 +00:00
|
|
|
DO_TEST("video-vga-qxl-heads",
|
|
|
|
QEMU_CAPS_DEVICE_QXL,
|
|
|
|
QEMU_CAPS_QXL_MAX_OUTPUTS);
|
2015-12-11 13:43:10 +00:00
|
|
|
DO_TEST("video-qxl-noheads",
|
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
|
|
|
|
QEMU_CAPS_DEVICE_QXL,
|
2016-10-11 15:42:37 +00:00
|
|
|
QEMU_CAPS_QXL_MAX_OUTPUTS);
|
2019-10-17 04:30:31 +00:00
|
|
|
DO_TEST("video-qxl-resolution",
|
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
|
|
|
|
QEMU_CAPS_DEVICE_QXL,
|
|
|
|
QEMU_CAPS_QXL_VGAMEM);
|
2015-11-25 08:42:32 +00:00
|
|
|
DO_TEST("video-virtio-gpu-device",
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_GPU,
|
2015-11-25 08:42:32 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
|
2015-11-25 08:42:33 +00:00
|
|
|
DO_TEST("video-virtio-gpu-virgl",
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_GPU,
|
2016-10-11 12:06:53 +00:00
|
|
|
QEMU_CAPS_VIRTIO_GPU_VIRGL,
|
2015-11-25 08:42:33 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
|
2016-02-19 14:30:15 +00:00
|
|
|
DO_TEST("video-virtio-gpu-spice-gl",
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_GPU,
|
2016-10-11 12:06:53 +00:00
|
|
|
QEMU_CAPS_VIRTIO_GPU_VIRGL,
|
2016-02-19 14:30:15 +00:00
|
|
|
QEMU_CAPS_SPICE,
|
|
|
|
QEMU_CAPS_SPICE_GL,
|
2017-02-14 21:04:13 +00:00
|
|
|
QEMU_CAPS_SPICE_RENDERNODE,
|
2016-02-19 14:30:15 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
|
2018-05-10 10:53:59 +00:00
|
|
|
DO_TEST("video-virtio-gpu-sdl-gl",
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_GPU,
|
|
|
|
QEMU_CAPS_VIRTIO_GPU_VIRGL,
|
|
|
|
QEMU_CAPS_SDL_GL,
|
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
|
2016-10-10 18:19:06 +00:00
|
|
|
DO_TEST("video-virtio-gpu-secondary",
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_GPU,
|
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
|
2016-09-30 12:41:37 +00:00
|
|
|
DO_TEST("video-virtio-vga",
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_GPU,
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_VGA,
|
2017-08-23 12:06:41 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
|
|
|
|
QEMU_CAPS_VIRTIO_GPU_MAX_OUTPUTS);
|
2019-07-12 20:12:16 +00:00
|
|
|
DO_TEST_CAPS_LATEST("video-bochs-display-device");
|
2019-09-13 21:20:29 +00:00
|
|
|
DO_TEST_CAPS_LATEST("video-ramfb-display-device");
|
2020-06-25 20:18:22 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("video-ramfb-display-device-pci-address");
|
2018-05-21 12:29:26 +00:00
|
|
|
DO_TEST("video-none-device",
|
|
|
|
QEMU_CAPS_VNC);
|
|
|
|
DO_TEST_PARSE_ERROR("video-invalid-multiple-devices", NONE);
|
2019-11-25 10:54:26 +00:00
|
|
|
DO_TEST_PARSE_ERROR("default-video-type-x86_64-caps-test-0", NONE);
|
2012-12-14 07:09:17 +00:00
|
|
|
|
2020-01-22 10:56:09 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("default-video-type-aarch64", "aarch64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("default-video-type-ppc64", "ppc64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("default-video-type-riscv64", "riscv64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("default-video-type-s390x", "s390x");
|
|
|
|
|
2017-06-26 17:13:00 +00:00
|
|
|
DO_TEST("virtio-rng-default",
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_RNG,
|
2013-03-07 11:50:14 +00:00
|
|
|
QEMU_CAPS_OBJECT_RNG_RANDOM);
|
2017-06-26 17:13:00 +00:00
|
|
|
DO_TEST("virtio-rng-random",
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_RNG,
|
2013-02-12 16:56:00 +00:00
|
|
|
QEMU_CAPS_OBJECT_RNG_RANDOM);
|
2017-06-26 17:13:00 +00:00
|
|
|
DO_TEST("virtio-rng-egd",
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_RNG,
|
2013-02-12 16:56:00 +00:00
|
|
|
QEMU_CAPS_OBJECT_RNG_EGD);
|
2020-01-09 08:00:08 +00:00
|
|
|
DO_TEST_CAPS_LATEST("virtio-rng-builtin");
|
2018-10-04 17:27:17 +00:00
|
|
|
DO_TEST_CAPS_VER("virtio-rng-egd-unix", "2.5.0");
|
|
|
|
DO_TEST_CAPS_LATEST("virtio-rng-egd-unix");
|
2017-06-26 17:13:00 +00:00
|
|
|
DO_TEST("virtio-rng-multiple",
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_RNG,
|
|
|
|
QEMU_CAPS_OBJECT_RNG_EGD,
|
|
|
|
QEMU_CAPS_OBJECT_RNG_RANDOM);
|
2016-01-13 00:26:40 +00:00
|
|
|
DO_TEST_PARSE_ERROR("virtio-rng-egd-crash",
|
2017-06-26 17:13:00 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_RNG,
|
|
|
|
QEMU_CAPS_OBJECT_RNG_EGD);
|
2013-03-14 18:32:26 +00:00
|
|
|
DO_TEST("virtio-rng-ccw",
|
2018-05-07 14:41:11 +00:00
|
|
|
QEMU_CAPS_CCW,
|
2017-06-26 17:13:00 +00:00
|
|
|
QEMU_CAPS_VIRTIO_S390,
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_RNG,
|
2013-03-14 18:32:26 +00:00
|
|
|
QEMU_CAPS_OBJECT_RNG_RANDOM);
|
2013-02-12 16:56:00 +00:00
|
|
|
|
qemu: remove test for allowing ide controller in s390, rename usb tests
Back in 2013, commit 877bc089 added in some tests that made sure no
error was generated on a domain definition that had an automatically
added usb controller if that domain didn't have a PCI bus to attach
the usb controller to. This was done because, at that time, libvirt
was automatically adding a usb controller to *any* domain definition
that didn't have one. Along with permitting the controller, two
s390-specific tests were added to ensure this behavior was maintained
- one with <controller type='usb' model='none'/> and another (called
"s390-piix-controllers") that had both usb and ide controllers, but
nothing attached to them.
Then in February of this year, commit 09ab9dcc eliminated the annoying
auto-adding of a usb device for s390 and s390x machines, stating:
"Since s390 does not support usb the default creation of a usb
controller for a domain should not occur."
Although, as verified here, the s390 doesn't support usb, and usb
controllers aren't currently added to s390 domain definitions
automatically, there are likely still some domain definitions in the
wild that have a usb controller (which was added *by libvirt*, not by
the user), so we will keep the tests verifying that behavior for
now. But this patch changes the names of the tests to reflect that
they don't actually contain a valid s390 config; this way future
developers won't propagate the incorrect idea that an s390 virtual
machine can have a USB (or IDE) bus.
In the case of the IDE controller, though, libvirt has never
automatically added an IDE controller unless a user added an IDE disk
(which itself would have caused an error), and we specifically *do*
want to begin generating an error when someone tries to add an IDE
controller to a domain that can't support one. For that reason, while
renaming the sz390-piix-controllers patch, this patch removes the
<controller type='ide'...> from it (otherwise the upcoming patch would
break make check)
2015-05-05 17:09:42 +00:00
|
|
|
DO_TEST("s390-allow-bogus-usb-none",
|
2017-06-26 17:13:00 +00:00
|
|
|
QEMU_CAPS_VIRTIO_S390,
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_RNG,
|
|
|
|
QEMU_CAPS_OBJECT_RNG_RANDOM);
|
qemu: remove test for allowing ide controller in s390, rename usb tests
Back in 2013, commit 877bc089 added in some tests that made sure no
error was generated on a domain definition that had an automatically
added usb controller if that domain didn't have a PCI bus to attach
the usb controller to. This was done because, at that time, libvirt
was automatically adding a usb controller to *any* domain definition
that didn't have one. Along with permitting the controller, two
s390-specific tests were added to ensure this behavior was maintained
- one with <controller type='usb' model='none'/> and another (called
"s390-piix-controllers") that had both usb and ide controllers, but
nothing attached to them.
Then in February of this year, commit 09ab9dcc eliminated the annoying
auto-adding of a usb device for s390 and s390x machines, stating:
"Since s390 does not support usb the default creation of a usb
controller for a domain should not occur."
Although, as verified here, the s390 doesn't support usb, and usb
controllers aren't currently added to s390 domain definitions
automatically, there are likely still some domain definitions in the
wild that have a usb controller (which was added *by libvirt*, not by
the user), so we will keep the tests verifying that behavior for
now. But this patch changes the names of the tests to reflect that
they don't actually contain a valid s390 config; this way future
developers won't propagate the incorrect idea that an s390 virtual
machine can have a USB (or IDE) bus.
In the case of the IDE controller, though, libvirt has never
automatically added an IDE controller unless a user added an IDE disk
(which itself would have caused an error), and we specifically *do*
want to begin generating an error when someone tries to add an IDE
controller to a domain that can't support one. For that reason, while
renaming the sz390-piix-controllers patch, this patch removes the
<controller type='ide'...> from it (otherwise the upcoming patch would
break make check)
2015-05-05 17:09:42 +00:00
|
|
|
DO_TEST("s390-allow-bogus-usb-controller",
|
2017-06-26 17:13:00 +00:00
|
|
|
QEMU_CAPS_VIRTIO_S390,
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_RNG,
|
|
|
|
QEMU_CAPS_OBJECT_RNG_RANDOM);
|
2013-04-26 15:50:36 +00:00
|
|
|
|
2016-04-29 13:23:43 +00:00
|
|
|
DO_TEST("s390-panic-no-address",
|
2018-05-07 14:41:11 +00:00
|
|
|
QEMU_CAPS_CCW,
|
2017-06-26 17:13:00 +00:00
|
|
|
QEMU_CAPS_VIRTIO_S390);
|
2020-10-13 21:38:07 +00:00
|
|
|
DO_TEST_PARSE_ERROR("s390-panic-address",
|
|
|
|
QEMU_CAPS_CCW,
|
|
|
|
QEMU_CAPS_VIRTIO_S390);
|
2016-04-29 13:23:43 +00:00
|
|
|
DO_TEST("s390-panic-missing",
|
2018-05-07 14:41:11 +00:00
|
|
|
QEMU_CAPS_CCW,
|
2017-06-26 17:13:00 +00:00
|
|
|
QEMU_CAPS_VIRTIO_S390);
|
2017-09-07 12:19:39 +00:00
|
|
|
DO_TEST_PARSE_ERROR("s390-no-parallel",
|
2018-05-07 14:41:11 +00:00
|
|
|
QEMU_CAPS_CCW,
|
2017-09-07 12:19:39 +00:00
|
|
|
QEMU_CAPS_VIRTIO_S390);
|
2017-11-14 15:27:04 +00:00
|
|
|
DO_TEST("s390-serial",
|
2018-05-07 14:41:11 +00:00
|
|
|
QEMU_CAPS_CCW,
|
2017-11-14 15:27:04 +00:00
|
|
|
QEMU_CAPS_VIRTIO_S390,
|
|
|
|
QEMU_CAPS_DEVICE_SCLPCONSOLE);
|
|
|
|
DO_TEST("s390-serial-2",
|
2018-05-07 14:41:11 +00:00
|
|
|
QEMU_CAPS_CCW,
|
2017-11-14 15:27:04 +00:00
|
|
|
QEMU_CAPS_VIRTIO_S390,
|
|
|
|
QEMU_CAPS_DEVICE_SCLPCONSOLE,
|
|
|
|
QEMU_CAPS_DEVICE_SCLPLMCONSOLE);
|
|
|
|
DO_TEST("s390-serial-console",
|
2018-05-07 14:41:11 +00:00
|
|
|
QEMU_CAPS_CCW,
|
2017-11-14 15:27:04 +00:00
|
|
|
QEMU_CAPS_VIRTIO_S390,
|
|
|
|
QEMU_CAPS_DEVICE_SCLPCONSOLE);
|
2016-04-29 13:23:43 +00:00
|
|
|
|
2017-06-26 17:13:00 +00:00
|
|
|
DO_TEST("ppc-dtb",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_KVM);
|
2017-06-26 17:13:00 +00:00
|
|
|
DO_TEST("ppce500-serial",
|
|
|
|
QEMU_CAPS_KVM);
|
2013-03-14 04:49:43 +00:00
|
|
|
|
2020-01-23 09:26:12 +00:00
|
|
|
DO_TEST_CAPS_LATEST("tpm-passthrough");
|
|
|
|
DO_TEST_CAPS_LATEST("tpm-passthrough-crb");
|
2016-01-13 00:26:40 +00:00
|
|
|
DO_TEST_PARSE_ERROR("tpm-no-backend-invalid",
|
2013-05-09 10:33:11 +00:00
|
|
|
QEMU_CAPS_DEVICE_TPM_PASSTHROUGH, QEMU_CAPS_DEVICE_TPM_TIS);
|
2017-04-04 16:22:31 +00:00
|
|
|
DO_TEST_CAPS_LATEST("tpm-emulator");
|
2018-04-04 18:40:17 +00:00
|
|
|
DO_TEST_CAPS_LATEST("tpm-emulator-tpm2");
|
2019-07-25 18:22:01 +00:00
|
|
|
DO_TEST_CAPS_LATEST("tpm-emulator-tpm2-enc");
|
2020-02-05 18:35:50 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PPC64("tpm-emulator-spapr");
|
conf: more useful error message when pci function is out of range
If a pci address had a function number out of range, the error message
would be:
Insufficient specification for PCI address
which is logged by virDevicePCIAddressParseXML() after
virDevicePCIAddressIsValid returns a failure.
This patch enhances virDevicePCIAddressIsValid() to optionally report
the error itself (since it is the place that decides which part of the
address is "invalid"), and uses that feature when calling from
virDevicePCIAddressParseXML(), so that the error will be more useful,
e.g.:
Invalid PCI address function=0x8, must be <= 7
Previously, virDevicePCIAddressIsValid didn't check for the
theoretical limits of domain or bus, only for slot or function. While
adding log messages, we also correct that ommission. (The RNG for PCI
addresses already enforces this limit, which by the way means that we
can't add any negative tests for this - as far as I know our
domainschematest has no provisions for passing XML that is supposed to
fail).
Note that virDevicePCIAddressIsValid() can only check against the
absolute maximum attribute values for *any* possible PCI controller,
not for the actual maximums of the specific controller that this
device is attaching to; fortunately there is later more specific
validation for guest-side PCI addresses when building the set of
assigned PCI addresses. For host-side PCI addresses (e.g. for
<hostdev> and for network device pools), we rely on the error that
will be logged when it is found that the device doesn't actually
exist.
This resolves:
https://bugzilla.redhat.com/show_bug.cgi?id=1004596
2015-07-22 15:59:00 +00:00
|
|
|
|
2016-01-13 00:26:40 +00:00
|
|
|
DO_TEST_PARSE_ERROR("pci-domain-invalid", NONE);
|
|
|
|
DO_TEST_PARSE_ERROR("pci-bus-invalid", NONE);
|
|
|
|
DO_TEST_PARSE_ERROR("pci-slot-invalid", NONE);
|
|
|
|
DO_TEST_PARSE_ERROR("pci-function-invalid", NONE);
|
conf: more useful error message when pci function is out of range
If a pci address had a function number out of range, the error message
would be:
Insufficient specification for PCI address
which is logged by virDevicePCIAddressParseXML() after
virDevicePCIAddressIsValid returns a failure.
This patch enhances virDevicePCIAddressIsValid() to optionally report
the error itself (since it is the place that decides which part of the
address is "invalid"), and uses that feature when calling from
virDevicePCIAddressParseXML(), so that the error will be more useful,
e.g.:
Invalid PCI address function=0x8, must be <= 7
Previously, virDevicePCIAddressIsValid didn't check for the
theoretical limits of domain or bus, only for slot or function. While
adding log messages, we also correct that ommission. (The RNG for PCI
addresses already enforces this limit, which by the way means that we
can't add any negative tests for this - as far as I know our
domainschematest has no provisions for passing XML that is supposed to
fail).
Note that virDevicePCIAddressIsValid() can only check against the
absolute maximum attribute values for *any* possible PCI controller,
not for the actual maximums of the specific controller that this
device is attaching to; fortunately there is later more specific
validation for guest-side PCI addresses when building the set of
assigned PCI addresses. For host-side PCI addresses (e.g. for
<hostdev> and for network device pools), we rely on the error that
will be logged when it is found that the device doesn't actually
exist.
This resolves:
https://bugzilla.redhat.com/show_bug.cgi?id=1004596
2015-07-22 15:59:00 +00:00
|
|
|
|
2017-02-23 17:47:36 +00:00
|
|
|
DO_TEST("pci-bridge",
|
|
|
|
QEMU_CAPS_DEVICE_PCI_BRIDGE,
|
|
|
|
QEMU_CAPS_VNC,
|
|
|
|
QEMU_CAPS_DEVICE_CIRRUS_VGA);
|
|
|
|
DO_TEST("pci-autoadd-addr",
|
|
|
|
QEMU_CAPS_DEVICE_PCI_BRIDGE,
|
2016-10-10 15:51:38 +00:00
|
|
|
QEMU_CAPS_DEVICE_CIRRUS_VGA);
|
2017-02-23 17:47:36 +00:00
|
|
|
DO_TEST("pci-autoadd-idx",
|
|
|
|
QEMU_CAPS_DEVICE_PCI_BRIDGE,
|
2016-10-10 15:51:38 +00:00
|
|
|
QEMU_CAPS_DEVICE_CIRRUS_VGA);
|
|
|
|
DO_TEST("pci-autofill-addr", QEMU_CAPS_DEVICE_CIRRUS_VGA);
|
2015-01-15 13:14:19 +00:00
|
|
|
DO_TEST("pci-many",
|
2016-10-10 15:51:38 +00:00
|
|
|
QEMU_CAPS_DEVICE_CIRRUS_VGA);
|
qemu: set/validate slot/connection type when assigning slots for PCI devices
Since PCI bridges, PCIe bridges, PCIe switches, and PCIe root ports
all share the same namespace, they are all defined as controllers of
type='pci' in libvirt (but with a differing model attribute). Each of
these controllers has a certain connection type upstream, allows
certain connection types downstream, and each can either allow a
single downstream connection at slot 0, or connections from slot 1 -
31.
Right now, we only support the pci-root and pci-bridge devices, both
of which only allow PCI devices to connect, and both which have usable
slots 1 - 31. In preparation for adding other types of controllers
that have different capabilities, this patch 1) adds info to the
qemuDomainPCIAddressBus object to indicate the capabilities, 2) sets
those capabilities appropriately for pci-root and pci-bridge devices,
and 3) validates that the controller being connected to is the proper
type when allocating slots or validating that a user-selected slot is
appropriate for a device..
Having this infrastructure in place will make it much easier to add
support for the other PCI controller types.
While it would be possible to do all the necessary checking by just
storing the controller model in the qemyuDomainPCIAddressBus, it
greatly simplifies all the validation code to also keep a "flags",
"minSlot" and "maxSlot" for each - that way we can just check those
attributes rather than requiring a nearly identical switch statement
everywhere we need to validate compatibility.
You may notice many places where the flags are seemingly hard-coded to
QEMU_PCI_CONNECT_HOTPLUGGABLE | QEMU_PCI_CONNECT_TYPE_PCI
This is currently the correct value for all PCI devices, and in the
future will be the default, with small bits of code added to change to
the flags for the few devices which are the exceptions to this rule.
Finally, there are a few places with "FIXME" comments. Note that these
aren't indicating places that are broken according to the currently
supported devices, they are places that will need fixing when support
for new PCI controller models is added.
To assure that there was no regression in the auto-allocation of PCI
addresses or auto-creation of integrated pci-root, ide, and usb
controllers, a new test case (pci-bridge-many-disks) has been added to
both the qemuxml2argv and qemuxml2xml tests. This new test defines a
domain with several dozen virtio disks but no pci-root or
pci-bridges. The .args file of the new test case was created using
libvirt sources from before this patch, and the test still passes
after this patch has been applied.
2013-07-15 00:09:44 +00:00
|
|
|
DO_TEST("pci-bridge-many-disks",
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_DEVICE_PCI_BRIDGE);
|
2013-07-10 19:19:32 +00:00
|
|
|
DO_TEST("pcie-root",
|
2017-02-23 17:47:36 +00:00
|
|
|
QEMU_CAPS_DEVICE_IOH3420,
|
|
|
|
QEMU_CAPS_ICH9_AHCI,
|
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
|
|
|
|
QEMU_CAPS_DEVICE_QXL);
|
qemu: add dmi-to-pci-bridge controller
This PCI controller, named "dmi-to-pci-bridge" in the libvirt config,
and implemented with qemu's "i82801b11-bridge" device, connects to a
PCI Express slot (e.g. one of the slots provided by the pcie-root
controller, aka "pcie.0" on the qemu commandline), and provides 31
*non-hot-pluggable* PCI (*not* PCIe) slots, numbered 1-31.
Any time a machine is defined which has a pcie-root controller
(i.e. any q35-based machinetype), libvirt will automatically add a
dmi-to-pci-bridge controller if one doesn't exist, and also add a
pci-bridge controller. The reasoning here is that any useful domain
will have either an immediate (startup time) or eventual (subsequent
hot-plug) need for a standard PCI slot; since the pcie-root controller
only provides PCIe slots, we need to connect a dmi-to-pci-bridge
controller to it in order to get a non-hot-plug PCI slot that we can
then use to connect a pci-bridge - the slots provided by the
pci-bridge will be both standard PCI and hot-pluggable.
Since pci-bridge devices themselves can not be hot-plugged into a
running system (although you can hot-plug other devices into a
pci-bridge's slots), any new pci-bridge controller that is added can
(and will) be plugged into the dmi-to-pci-bridge as long as it has
empty slots available.
This patch is also changing the qemuxml2xml-pcie test from a "DO_TEST"
to a "DO_DIFFERENT_TEST". This is so that the "before" xml can omit
the automatically added dmi-to-pci-bridge and pci-bridge devices, and
the "after" xml can include it - this way we are testing if libvirt is
properly adding these devices.
2013-07-31 01:37:32 +00:00
|
|
|
DO_TEST("q35",
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_DEVICE_PCI_BRIDGE,
|
qemu: add dmi-to-pci-bridge controller
This PCI controller, named "dmi-to-pci-bridge" in the libvirt config,
and implemented with qemu's "i82801b11-bridge" device, connects to a
PCI Express slot (e.g. one of the slots provided by the pcie-root
controller, aka "pcie.0" on the qemu commandline), and provides 31
*non-hot-pluggable* PCI (*not* PCIe) slots, numbered 1-31.
Any time a machine is defined which has a pcie-root controller
(i.e. any q35-based machinetype), libvirt will automatically add a
dmi-to-pci-bridge controller if one doesn't exist, and also add a
pci-bridge controller. The reasoning here is that any useful domain
will have either an immediate (startup time) or eventual (subsequent
hot-plug) need for a standard PCI slot; since the pcie-root controller
only provides PCIe slots, we need to connect a dmi-to-pci-bridge
controller to it in order to get a non-hot-plug PCI slot that we can
then use to connect a pci-bridge - the slots provided by the
pci-bridge will be both standard PCI and hot-pluggable.
Since pci-bridge devices themselves can not be hot-plugged into a
running system (although you can hot-plug other devices into a
pci-bridge's slots), any new pci-bridge controller that is added can
(and will) be plugged into the dmi-to-pci-bridge as long as it has
empty slots available.
This patch is also changing the qemuxml2xml-pcie test from a "DO_TEST"
to a "DO_DIFFERENT_TEST". This is so that the "before" xml can omit
the automatically added dmi-to-pci-bridge and pci-bridge devices, and
the "after" xml can include it - this way we are testing if libvirt is
properly adding these devices.
2013-07-31 01:37:32 +00:00
|
|
|
QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
|
qemu: initially reserve one open pcie-root-port for hotplug
For machinetypes with a pci-root bus (all legacy PCI), libvirt will
make a "fake" reservation for one extra slot prior to assigning
addresses to unaddressed PCI endpoint devices in the domain. This will
trigger auto-adding of a pci-bridge for the final device to be
assigned an address *if that device would have otherwise instead been
the last device on the last available pci-bridge*; thus it assures
that there will always be at least one slot left open in the domain's
bus topology for expansion (which is important both for hotplug (since
a new pci-bridge can't be added while the guest is running) as well as
for offline additions to the config (since adding a new device might
otherwise in some cases require re-addressing existing devices, which
we want to avoid)).
It's important to note that for the above case (legacy PCI), we must
check for the special case of all slots on all buses being occupied
*prior to assigning any addresses*, and avoid attempting to reserve
the extra address in that case, because there is no free address in
the existing topology, so no place to auto-add a pci-bridge for
expansion (i.e. it would always fail anyway). Since that condition can
only be reached by manual intervention, this is acceptable.
For machinetypes with pcie-root (Q35, aarch64 virt), libvirt's
methodology for automatically expanding the bus topology is different
- pcie-root-ports are plugged into slots (soon to be functions) of
pcie-root as needed, and the new endpoint devices are assigned to the
single slot in each pcie-root-port. This is done so that the devices
are, by default, hotpluggable (the slots of pcie-root don't support
hotplug, but the single slot of the pcie-root-port does). Since
pcie-root-ports can only be plugged into pcie-root, and we don't
auto-assign endpoint devices to the pcie-root slots, this means
topology expansion doesn't compete with endpoint devices for slots, so
we don't need to worry about checking for all "useful" slots being
free *prior* to assigning addresses to new endpoint devices - as a
matter of fact, if we attempt to reserve the open slots before the
used slots, it can lead to errors.
Instead this patch just reserves one slot for a "future potential"
PCIe device after doing the assignment for actual devices, but only
if the only PCI controller defined prior to starting address
assignment was pcie-root, and only if we auto-added at least one PCI
controller during address assignment. This assures two things:
1) that reserving the open slots will only be done when the domain is
initially defined, never at any time after, and
2) that if the user understands enough about PCI controllers that they
are adding them manually, that we don't mess up their plan by
adding extras - if they know enough to add one pcie-root-port, or
to manually assign addresses such that no pcie-root-ports are
needed, they know enough to add extra pcie-root-ports if they want
them (this could be called the "libguestfs clause", since
libguestfs needs to be able to create domains with as few
devices/controllers as possible).
This is set to reserve a single free port for now, but could be
increased in the future if public sentiment goes in that direction
(it's easy to increase later, but essentially impossible to decrease)
2016-09-28 00:37:30 +00:00
|
|
|
QEMU_CAPS_DEVICE_IOH3420,
|
2015-11-06 14:28:57 +00:00
|
|
|
QEMU_CAPS_ICH9_AHCI,
|
2017-02-23 17:47:36 +00:00
|
|
|
QEMU_CAPS_ICH9_USB_EHCI1,
|
2015-11-09 15:39:54 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
|
2016-10-11 15:42:37 +00:00
|
|
|
QEMU_CAPS_DEVICE_QXL);
|
2016-08-05 19:01:08 +00:00
|
|
|
DO_TEST_PARSE_ERROR("q35-dmi-bad-address1",
|
|
|
|
QEMU_CAPS_DEVICE_PCI_BRIDGE,
|
|
|
|
QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
|
|
|
|
QEMU_CAPS_DEVICE_IOH3420);
|
|
|
|
DO_TEST_PARSE_ERROR("q35-dmi-bad-address2",
|
|
|
|
QEMU_CAPS_DEVICE_PCI_BRIDGE,
|
|
|
|
QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
|
|
|
|
QEMU_CAPS_DEVICE_IOH3420);
|
2016-01-09 21:00:01 +00:00
|
|
|
DO_TEST("q35-pm-disable",
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_DEVICE_PCI_BRIDGE,
|
qemu: initially reserve one open pcie-root-port for hotplug
For machinetypes with a pci-root bus (all legacy PCI), libvirt will
make a "fake" reservation for one extra slot prior to assigning
addresses to unaddressed PCI endpoint devices in the domain. This will
trigger auto-adding of a pci-bridge for the final device to be
assigned an address *if that device would have otherwise instead been
the last device on the last available pci-bridge*; thus it assures
that there will always be at least one slot left open in the domain's
bus topology for expansion (which is important both for hotplug (since
a new pci-bridge can't be added while the guest is running) as well as
for offline additions to the config (since adding a new device might
otherwise in some cases require re-addressing existing devices, which
we want to avoid)).
It's important to note that for the above case (legacy PCI), we must
check for the special case of all slots on all buses being occupied
*prior to assigning any addresses*, and avoid attempting to reserve
the extra address in that case, because there is no free address in
the existing topology, so no place to auto-add a pci-bridge for
expansion (i.e. it would always fail anyway). Since that condition can
only be reached by manual intervention, this is acceptable.
For machinetypes with pcie-root (Q35, aarch64 virt), libvirt's
methodology for automatically expanding the bus topology is different
- pcie-root-ports are plugged into slots (soon to be functions) of
pcie-root as needed, and the new endpoint devices are assigned to the
single slot in each pcie-root-port. This is done so that the devices
are, by default, hotpluggable (the slots of pcie-root don't support
hotplug, but the single slot of the pcie-root-port does). Since
pcie-root-ports can only be plugged into pcie-root, and we don't
auto-assign endpoint devices to the pcie-root slots, this means
topology expansion doesn't compete with endpoint devices for slots, so
we don't need to worry about checking for all "useful" slots being
free *prior* to assigning addresses to new endpoint devices - as a
matter of fact, if we attempt to reserve the open slots before the
used slots, it can lead to errors.
Instead this patch just reserves one slot for a "future potential"
PCIe device after doing the assignment for actual devices, but only
if the only PCI controller defined prior to starting address
assignment was pcie-root, and only if we auto-added at least one PCI
controller during address assignment. This assures two things:
1) that reserving the open slots will only be done when the domain is
initially defined, never at any time after, and
2) that if the user understands enough about PCI controllers that they
are adding them manually, that we don't mess up their plan by
adding extras - if they know enough to add one pcie-root-port, or
to manually assign addresses such that no pcie-root-ports are
needed, they know enough to add extra pcie-root-ports if they want
them (this could be called the "libguestfs clause", since
libguestfs needs to be able to create domains with as few
devices/controllers as possible).
This is set to reserve a single free port for now, but could be
increased in the future if public sentiment goes in that direction
(it's easy to increase later, but essentially impossible to decrease)
2016-09-28 00:37:30 +00:00
|
|
|
QEMU_CAPS_DEVICE_IOH3420,
|
2016-01-09 21:00:01 +00:00
|
|
|
QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE, QEMU_CAPS_ICH9_AHCI,
|
|
|
|
QEMU_CAPS_PIIX_DISABLE_S3, QEMU_CAPS_PIIX_DISABLE_S4,
|
|
|
|
QEMU_CAPS_ICH9_DISABLE_S3, QEMU_CAPS_ICH9_DISABLE_S4);
|
|
|
|
DO_TEST("q35-pm-disable-fallback",
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_DEVICE_PCI_BRIDGE,
|
qemu: initially reserve one open pcie-root-port for hotplug
For machinetypes with a pci-root bus (all legacy PCI), libvirt will
make a "fake" reservation for one extra slot prior to assigning
addresses to unaddressed PCI endpoint devices in the domain. This will
trigger auto-adding of a pci-bridge for the final device to be
assigned an address *if that device would have otherwise instead been
the last device on the last available pci-bridge*; thus it assures
that there will always be at least one slot left open in the domain's
bus topology for expansion (which is important both for hotplug (since
a new pci-bridge can't be added while the guest is running) as well as
for offline additions to the config (since adding a new device might
otherwise in some cases require re-addressing existing devices, which
we want to avoid)).
It's important to note that for the above case (legacy PCI), we must
check for the special case of all slots on all buses being occupied
*prior to assigning any addresses*, and avoid attempting to reserve
the extra address in that case, because there is no free address in
the existing topology, so no place to auto-add a pci-bridge for
expansion (i.e. it would always fail anyway). Since that condition can
only be reached by manual intervention, this is acceptable.
For machinetypes with pcie-root (Q35, aarch64 virt), libvirt's
methodology for automatically expanding the bus topology is different
- pcie-root-ports are plugged into slots (soon to be functions) of
pcie-root as needed, and the new endpoint devices are assigned to the
single slot in each pcie-root-port. This is done so that the devices
are, by default, hotpluggable (the slots of pcie-root don't support
hotplug, but the single slot of the pcie-root-port does). Since
pcie-root-ports can only be plugged into pcie-root, and we don't
auto-assign endpoint devices to the pcie-root slots, this means
topology expansion doesn't compete with endpoint devices for slots, so
we don't need to worry about checking for all "useful" slots being
free *prior* to assigning addresses to new endpoint devices - as a
matter of fact, if we attempt to reserve the open slots before the
used slots, it can lead to errors.
Instead this patch just reserves one slot for a "future potential"
PCIe device after doing the assignment for actual devices, but only
if the only PCI controller defined prior to starting address
assignment was pcie-root, and only if we auto-added at least one PCI
controller during address assignment. This assures two things:
1) that reserving the open slots will only be done when the domain is
initially defined, never at any time after, and
2) that if the user understands enough about PCI controllers that they
are adding them manually, that we don't mess up their plan by
adding extras - if they know enough to add one pcie-root-port, or
to manually assign addresses such that no pcie-root-ports are
needed, they know enough to add extra pcie-root-ports if they want
them (this could be called the "libguestfs clause", since
libguestfs needs to be able to create domains with as few
devices/controllers as possible).
This is set to reserve a single free port for now, but could be
increased in the future if public sentiment goes in that direction
(it's easy to increase later, but essentially impossible to decrease)
2016-09-28 00:37:30 +00:00
|
|
|
QEMU_CAPS_DEVICE_IOH3420,
|
2016-01-09 21:00:01 +00:00
|
|
|
QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE, QEMU_CAPS_ICH9_AHCI,
|
|
|
|
QEMU_CAPS_PIIX_DISABLE_S3, QEMU_CAPS_PIIX_DISABLE_S4);
|
2015-10-21 19:08:49 +00:00
|
|
|
DO_TEST("q35-usb2",
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_DEVICE_PCI_BRIDGE,
|
2015-10-21 19:08:49 +00:00
|
|
|
QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
|
qemu: initially reserve one open pcie-root-port for hotplug
For machinetypes with a pci-root bus (all legacy PCI), libvirt will
make a "fake" reservation for one extra slot prior to assigning
addresses to unaddressed PCI endpoint devices in the domain. This will
trigger auto-adding of a pci-bridge for the final device to be
assigned an address *if that device would have otherwise instead been
the last device on the last available pci-bridge*; thus it assures
that there will always be at least one slot left open in the domain's
bus topology for expansion (which is important both for hotplug (since
a new pci-bridge can't be added while the guest is running) as well as
for offline additions to the config (since adding a new device might
otherwise in some cases require re-addressing existing devices, which
we want to avoid)).
It's important to note that for the above case (legacy PCI), we must
check for the special case of all slots on all buses being occupied
*prior to assigning any addresses*, and avoid attempting to reserve
the extra address in that case, because there is no free address in
the existing topology, so no place to auto-add a pci-bridge for
expansion (i.e. it would always fail anyway). Since that condition can
only be reached by manual intervention, this is acceptable.
For machinetypes with pcie-root (Q35, aarch64 virt), libvirt's
methodology for automatically expanding the bus topology is different
- pcie-root-ports are plugged into slots (soon to be functions) of
pcie-root as needed, and the new endpoint devices are assigned to the
single slot in each pcie-root-port. This is done so that the devices
are, by default, hotpluggable (the slots of pcie-root don't support
hotplug, but the single slot of the pcie-root-port does). Since
pcie-root-ports can only be plugged into pcie-root, and we don't
auto-assign endpoint devices to the pcie-root slots, this means
topology expansion doesn't compete with endpoint devices for slots, so
we don't need to worry about checking for all "useful" slots being
free *prior* to assigning addresses to new endpoint devices - as a
matter of fact, if we attempt to reserve the open slots before the
used slots, it can lead to errors.
Instead this patch just reserves one slot for a "future potential"
PCIe device after doing the assignment for actual devices, but only
if the only PCI controller defined prior to starting address
assignment was pcie-root, and only if we auto-added at least one PCI
controller during address assignment. This assures two things:
1) that reserving the open slots will only be done when the domain is
initially defined, never at any time after, and
2) that if the user understands enough about PCI controllers that they
are adding them manually, that we don't mess up their plan by
adding extras - if they know enough to add one pcie-root-port, or
to manually assign addresses such that no pcie-root-ports are
needed, they know enough to add extra pcie-root-ports if they want
them (this could be called the "libguestfs clause", since
libguestfs needs to be able to create domains with as few
devices/controllers as possible).
This is set to reserve a single free port for now, but could be
increased in the future if public sentiment goes in that direction
(it's easy to increase later, but essentially impossible to decrease)
2016-09-28 00:37:30 +00:00
|
|
|
QEMU_CAPS_DEVICE_IOH3420,
|
2015-10-21 19:08:49 +00:00
|
|
|
QEMU_CAPS_ICH9_AHCI,
|
2017-02-23 17:47:36 +00:00
|
|
|
QEMU_CAPS_ICH9_USB_EHCI1,
|
2015-10-21 19:08:49 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
|
2016-10-11 15:42:37 +00:00
|
|
|
QEMU_CAPS_DEVICE_QXL);
|
2015-10-21 19:08:49 +00:00
|
|
|
DO_TEST("q35-usb2-multi",
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_DEVICE_PCI_BRIDGE,
|
2015-10-21 19:08:49 +00:00
|
|
|
QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
|
qemu: initially reserve one open pcie-root-port for hotplug
For machinetypes with a pci-root bus (all legacy PCI), libvirt will
make a "fake" reservation for one extra slot prior to assigning
addresses to unaddressed PCI endpoint devices in the domain. This will
trigger auto-adding of a pci-bridge for the final device to be
assigned an address *if that device would have otherwise instead been
the last device on the last available pci-bridge*; thus it assures
that there will always be at least one slot left open in the domain's
bus topology for expansion (which is important both for hotplug (since
a new pci-bridge can't be added while the guest is running) as well as
for offline additions to the config (since adding a new device might
otherwise in some cases require re-addressing existing devices, which
we want to avoid)).
It's important to note that for the above case (legacy PCI), we must
check for the special case of all slots on all buses being occupied
*prior to assigning any addresses*, and avoid attempting to reserve
the extra address in that case, because there is no free address in
the existing topology, so no place to auto-add a pci-bridge for
expansion (i.e. it would always fail anyway). Since that condition can
only be reached by manual intervention, this is acceptable.
For machinetypes with pcie-root (Q35, aarch64 virt), libvirt's
methodology for automatically expanding the bus topology is different
- pcie-root-ports are plugged into slots (soon to be functions) of
pcie-root as needed, and the new endpoint devices are assigned to the
single slot in each pcie-root-port. This is done so that the devices
are, by default, hotpluggable (the slots of pcie-root don't support
hotplug, but the single slot of the pcie-root-port does). Since
pcie-root-ports can only be plugged into pcie-root, and we don't
auto-assign endpoint devices to the pcie-root slots, this means
topology expansion doesn't compete with endpoint devices for slots, so
we don't need to worry about checking for all "useful" slots being
free *prior* to assigning addresses to new endpoint devices - as a
matter of fact, if we attempt to reserve the open slots before the
used slots, it can lead to errors.
Instead this patch just reserves one slot for a "future potential"
PCIe device after doing the assignment for actual devices, but only
if the only PCI controller defined prior to starting address
assignment was pcie-root, and only if we auto-added at least one PCI
controller during address assignment. This assures two things:
1) that reserving the open slots will only be done when the domain is
initially defined, never at any time after, and
2) that if the user understands enough about PCI controllers that they
are adding them manually, that we don't mess up their plan by
adding extras - if they know enough to add one pcie-root-port, or
to manually assign addresses such that no pcie-root-ports are
needed, they know enough to add extra pcie-root-ports if they want
them (this could be called the "libguestfs clause", since
libguestfs needs to be able to create domains with as few
devices/controllers as possible).
This is set to reserve a single free port for now, but could be
increased in the future if public sentiment goes in that direction
(it's easy to increase later, but essentially impossible to decrease)
2016-09-28 00:37:30 +00:00
|
|
|
QEMU_CAPS_DEVICE_IOH3420,
|
2015-10-21 19:08:49 +00:00
|
|
|
QEMU_CAPS_ICH9_AHCI,
|
2017-02-23 17:47:36 +00:00
|
|
|
QEMU_CAPS_ICH9_USB_EHCI1,
|
2015-10-21 19:08:49 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
|
2016-10-11 15:42:37 +00:00
|
|
|
QEMU_CAPS_DEVICE_QXL);
|
2015-10-21 19:08:49 +00:00
|
|
|
DO_TEST("q35-usb2-reorder",
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_DEVICE_PCI_BRIDGE,
|
2015-10-21 19:08:49 +00:00
|
|
|
QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
|
qemu: initially reserve one open pcie-root-port for hotplug
For machinetypes with a pci-root bus (all legacy PCI), libvirt will
make a "fake" reservation for one extra slot prior to assigning
addresses to unaddressed PCI endpoint devices in the domain. This will
trigger auto-adding of a pci-bridge for the final device to be
assigned an address *if that device would have otherwise instead been
the last device on the last available pci-bridge*; thus it assures
that there will always be at least one slot left open in the domain's
bus topology for expansion (which is important both for hotplug (since
a new pci-bridge can't be added while the guest is running) as well as
for offline additions to the config (since adding a new device might
otherwise in some cases require re-addressing existing devices, which
we want to avoid)).
It's important to note that for the above case (legacy PCI), we must
check for the special case of all slots on all buses being occupied
*prior to assigning any addresses*, and avoid attempting to reserve
the extra address in that case, because there is no free address in
the existing topology, so no place to auto-add a pci-bridge for
expansion (i.e. it would always fail anyway). Since that condition can
only be reached by manual intervention, this is acceptable.
For machinetypes with pcie-root (Q35, aarch64 virt), libvirt's
methodology for automatically expanding the bus topology is different
- pcie-root-ports are plugged into slots (soon to be functions) of
pcie-root as needed, and the new endpoint devices are assigned to the
single slot in each pcie-root-port. This is done so that the devices
are, by default, hotpluggable (the slots of pcie-root don't support
hotplug, but the single slot of the pcie-root-port does). Since
pcie-root-ports can only be plugged into pcie-root, and we don't
auto-assign endpoint devices to the pcie-root slots, this means
topology expansion doesn't compete with endpoint devices for slots, so
we don't need to worry about checking for all "useful" slots being
free *prior* to assigning addresses to new endpoint devices - as a
matter of fact, if we attempt to reserve the open slots before the
used slots, it can lead to errors.
Instead this patch just reserves one slot for a "future potential"
PCIe device after doing the assignment for actual devices, but only
if the only PCI controller defined prior to starting address
assignment was pcie-root, and only if we auto-added at least one PCI
controller during address assignment. This assures two things:
1) that reserving the open slots will only be done when the domain is
initially defined, never at any time after, and
2) that if the user understands enough about PCI controllers that they
are adding them manually, that we don't mess up their plan by
adding extras - if they know enough to add one pcie-root-port, or
to manually assign addresses such that no pcie-root-ports are
needed, they know enough to add extra pcie-root-ports if they want
them (this could be called the "libguestfs clause", since
libguestfs needs to be able to create domains with as few
devices/controllers as possible).
This is set to reserve a single free port for now, but could be
increased in the future if public sentiment goes in that direction
(it's easy to increase later, but essentially impossible to decrease)
2016-09-28 00:37:30 +00:00
|
|
|
QEMU_CAPS_DEVICE_IOH3420,
|
2015-10-21 19:08:49 +00:00
|
|
|
QEMU_CAPS_ICH9_AHCI,
|
2017-02-23 17:47:36 +00:00
|
|
|
QEMU_CAPS_ICH9_USB_EHCI1,
|
2015-10-21 19:08:49 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
|
2016-10-11 15:42:37 +00:00
|
|
|
QEMU_CAPS_DEVICE_QXL);
|
qemu: assign virtio devices to PCIe slot when appropriate
libvirt previously assigned nearly all devices to a "hotpluggable"
legacy PCI slot even on machines with a PCIe root bus (and even though
most such machines don't even support hotplug on legacy PCI slots!)
Forcing all devices onto legacy PCI slots means that the domain will
need a dmi-to-pci-bridge (to convert from PCIe to legacy PCI) and a
pci-bridge (to provide hotpluggable legacy PCI slots which, again,
usually aren't hotpluggable anyway).
To help reduce the need for these legacy controllers, this patch tries
to assign virtio-1.0-capable devices to PCIe slots whenever possible,
by setting appropriate connectFlags in
virDomainCalculateDevicePCIConnectFlags(). Happily, when that function
was written (just a few commits ago) it was created with a
"virtioFlags" argument, set by both of its callers, which is the
proper connectFlags to set for any virtio-*-pci device - depending on
the arch/machinetype of the domain, and whether or not the qemu binary
supports virtio-1.0, that flag will have either been set to PCI or
PCIe. This patch merely enables the functionality by setting the flags
for the device to whatever is in virtioFlags if the device is a
virtio-*-pci device.
NB: the first virtio video device will be placed directly on bus 0
slot 1 rather than on a pcie-root-port due to the override for primary
video devices in qemuDomainValidateDevicePCISlotsQ35(). Whether or not
to change that is a topic of discussion, but this patch doesn't change
that particular behavior.
NB2: since the slot must be hotpluggable, and pcie-root (the PCIe root
complex) does *not* support hotplug, this means that suitable
controllers must also be in the config (i.e. either pcie-root-port, or
pcie-downstream-port). For now, libvirt doesn't add those
automatically, so if you put virtio devices in a config for a qemu
that has PCIe-capable virtio devices, you'll need to add extra
pcie-root-ports yourself. That requirement will be eliminated in a
future patch, but for now, it's simple to do this:
<controller type='pci' model='pcie-root-port'/>
<controller type='pci' model='pcie-root-port'/>
<controller type='pci' model='pcie-root-port'/>
...
Partially Resolves: https://bugzilla.redhat.com/show_bug.cgi?id=1330024
2016-08-13 22:10:41 +00:00
|
|
|
/* verify that devices with pcie capability are assigned to a pcie slot */
|
|
|
|
DO_TEST("q35-pcie",
|
|
|
|
QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY,
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_RNG,
|
|
|
|
QEMU_CAPS_OBJECT_RNG_RANDOM,
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_NET,
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_GPU,
|
|
|
|
QEMU_CAPS_VIRTIO_GPU_VIRGL,
|
|
|
|
QEMU_CAPS_VIRTIO_KEYBOARD,
|
|
|
|
QEMU_CAPS_VIRTIO_MOUSE,
|
|
|
|
QEMU_CAPS_VIRTIO_TABLET,
|
|
|
|
QEMU_CAPS_VIRTIO_INPUT_HOST,
|
|
|
|
QEMU_CAPS_VIRTIO_SCSI,
|
|
|
|
QEMU_CAPS_DEVICE_PCI_BRIDGE,
|
|
|
|
QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
|
|
|
|
QEMU_CAPS_DEVICE_IOH3420,
|
|
|
|
QEMU_CAPS_ICH9_AHCI,
|
|
|
|
QEMU_CAPS_ICH9_USB_EHCI1,
|
2016-08-14 05:58:11 +00:00
|
|
|
QEMU_CAPS_NEC_USB_XHCI,
|
qemu: assign virtio devices to PCIe slot when appropriate
libvirt previously assigned nearly all devices to a "hotpluggable"
legacy PCI slot even on machines with a PCIe root bus (and even though
most such machines don't even support hotplug on legacy PCI slots!)
Forcing all devices onto legacy PCI slots means that the domain will
need a dmi-to-pci-bridge (to convert from PCIe to legacy PCI) and a
pci-bridge (to provide hotpluggable legacy PCI slots which, again,
usually aren't hotpluggable anyway).
To help reduce the need for these legacy controllers, this patch tries
to assign virtio-1.0-capable devices to PCIe slots whenever possible,
by setting appropriate connectFlags in
virDomainCalculateDevicePCIConnectFlags(). Happily, when that function
was written (just a few commits ago) it was created with a
"virtioFlags" argument, set by both of its callers, which is the
proper connectFlags to set for any virtio-*-pci device - depending on
the arch/machinetype of the domain, and whether or not the qemu binary
supports virtio-1.0, that flag will have either been set to PCI or
PCIe. This patch merely enables the functionality by setting the flags
for the device to whatever is in virtioFlags if the device is a
virtio-*-pci device.
NB: the first virtio video device will be placed directly on bus 0
slot 1 rather than on a pcie-root-port due to the override for primary
video devices in qemuDomainValidateDevicePCISlotsQ35(). Whether or not
to change that is a topic of discussion, but this patch doesn't change
that particular behavior.
NB2: since the slot must be hotpluggable, and pcie-root (the PCIe root
complex) does *not* support hotplug, this means that suitable
controllers must also be in the config (i.e. either pcie-root-port, or
pcie-downstream-port). For now, libvirt doesn't add those
automatically, so if you put virtio devices in a config for a qemu
that has PCIe-capable virtio devices, you'll need to add extra
pcie-root-ports yourself. That requirement will be eliminated in a
future patch, but for now, it's simple to do this:
<controller type='pci' model='pcie-root-port'/>
<controller type='pci' model='pcie-root-port'/>
<controller type='pci' model='pcie-root-port'/>
...
Partially Resolves: https://bugzilla.redhat.com/show_bug.cgi?id=1330024
2016-08-13 22:10:41 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
|
|
|
|
/* same XML as q35-pcie, but don't set
|
|
|
|
* QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY, so virtio devices should
|
|
|
|
* be assigned to legacy pci slots
|
|
|
|
*/
|
|
|
|
DO_TEST("q35-virtio-pci",
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_RNG,
|
|
|
|
QEMU_CAPS_OBJECT_RNG_RANDOM,
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_NET,
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_GPU,
|
|
|
|
QEMU_CAPS_VIRTIO_GPU_VIRGL,
|
|
|
|
QEMU_CAPS_VIRTIO_KEYBOARD,
|
|
|
|
QEMU_CAPS_VIRTIO_MOUSE,
|
qemu: auto-add pcie-root-port/dmi-to-pci-bridge controllers as needed
Previously libvirt would only add pci-bridge devices automatically
when an address was requested for a device that required a legacy PCI
slot and none was available. This patch expands that support to
dmi-to-pci-bridge (which is needed in order to add a pci-bridge on a
machine with a pcie-root), and pcie-root-port (which is needed to add
a hotpluggable PCIe device). It does *not* automatically add
pcie-switch-upstream-ports or pcie-switch-downstream-ports (and
currently there are no plans for that).
Given the existing code to auto-add pci-bridge devices, automatically
adding pcie-root-ports is fairly straightforward. The
dmi-to-pci-bridge support is a bit tricky though, for a few reasons:
1) Although the only reason to add a dmi-to-pci-bridge is so that
there is a reasonable place to plug in a pci-bridge controller,
most of the time it's not the presence of a pci-bridge *in the
config* that triggers the requirement to add a dmi-to-pci-bridge.
Rather, it is the presence of a legacy-PCI device in the config,
which triggers auto-add of a pci-bridge, which triggers auto-add of
a dmi-to-pci-bridge (this is handled in
virDomainPCIAddressSetGrow() - if there's a request to add a
pci-bridge we'll check if there is a suitable bus to plug it into;
if not, we first add a dmi-to-pci-bridge).
2) Once there is already a single dmi-to-pci-bridge on the system,
there won't be a need for any more, even if it's full, as long as
there is a pci-bridge with an open slot - you can also plug
pci-bridges into existing pci-bridges. So we have to make sure we
don't add a dmi-to-pci-bridge unless there aren't any
dmi-to-pci-bridges *or* any pci-bridges.
3) Although it is strongly discouraged, it is legal for a pci-bridge
to be directly plugged into pcie-root, and we don't want to
auto-add a dmi-to-pci-bridge if there is already a pci-bridge
that's been forced directly into pcie-root.
Although libvirt will now automatically create a dmi-to-pci-bridge
when it's needed, the code still remains for now that forces a
dmi-to-pci-bridge on all domains with pcie-root (in
qemuDomainDefAddDefaultDevices()). That will be removed in a future
patch.
For now, the pcie-root-ports are added one to a slot, which is a bit
wasteful and means it will fail after 31 total PCIe devices (30 if
there are also some PCI devices), but helps keep the changeset down
for this patch. A future patch will have 8 pcie-root-ports sharing the
functions on a single slot.
2016-09-19 18:38:47 +00:00
|
|
|
QEMU_CAPS_VIRTIO_TABLET,
|
|
|
|
QEMU_CAPS_VIRTIO_INPUT_HOST,
|
|
|
|
QEMU_CAPS_VIRTIO_SCSI,
|
|
|
|
QEMU_CAPS_DEVICE_PCI_BRIDGE,
|
|
|
|
QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
|
|
|
|
QEMU_CAPS_DEVICE_IOH3420,
|
|
|
|
QEMU_CAPS_ICH9_AHCI,
|
|
|
|
QEMU_CAPS_ICH9_USB_EHCI1,
|
|
|
|
QEMU_CAPS_NEC_USB_XHCI,
|
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
|
|
|
|
/* same as q35-pcie, but all PCI controllers are added automatically */
|
|
|
|
DO_TEST("q35-pcie-autoadd",
|
|
|
|
QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY,
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_RNG,
|
|
|
|
QEMU_CAPS_OBJECT_RNG_RANDOM,
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_NET,
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_GPU,
|
|
|
|
QEMU_CAPS_VIRTIO_GPU_VIRGL,
|
|
|
|
QEMU_CAPS_VIRTIO_KEYBOARD,
|
|
|
|
QEMU_CAPS_VIRTIO_MOUSE,
|
2016-09-19 22:46:41 +00:00
|
|
|
QEMU_CAPS_VIRTIO_TABLET,
|
|
|
|
QEMU_CAPS_VIRTIO_INPUT_HOST,
|
|
|
|
QEMU_CAPS_VIRTIO_SCSI,
|
|
|
|
QEMU_CAPS_DEVICE_PCI_BRIDGE,
|
|
|
|
QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
|
|
|
|
QEMU_CAPS_DEVICE_IOH3420,
|
|
|
|
QEMU_CAPS_ICH9_AHCI,
|
|
|
|
QEMU_CAPS_ICH9_USB_EHCI1,
|
|
|
|
QEMU_CAPS_NEC_USB_XHCI,
|
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
|
|
|
|
DO_TEST("q35-default-devices-only",
|
|
|
|
QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY,
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_RNG,
|
|
|
|
QEMU_CAPS_OBJECT_RNG_RANDOM,
|
2017-01-10 05:20:11 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_NET,
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_GPU,
|
|
|
|
QEMU_CAPS_VIRTIO_GPU_VIRGL,
|
|
|
|
QEMU_CAPS_VIRTIO_KEYBOARD,
|
|
|
|
QEMU_CAPS_VIRTIO_MOUSE,
|
|
|
|
QEMU_CAPS_VIRTIO_TABLET,
|
|
|
|
QEMU_CAPS_VIRTIO_INPUT_HOST,
|
|
|
|
QEMU_CAPS_VIRTIO_SCSI,
|
|
|
|
QEMU_CAPS_DEVICE_PCI_BRIDGE,
|
|
|
|
QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
|
|
|
|
QEMU_CAPS_DEVICE_IOH3420,
|
|
|
|
QEMU_CAPS_ICH9_AHCI,
|
|
|
|
QEMU_CAPS_ICH9_USB_EHCI1,
|
|
|
|
QEMU_CAPS_NEC_USB_XHCI,
|
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
|
|
|
|
DO_TEST("q35-multifunction",
|
|
|
|
QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY,
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_RNG,
|
|
|
|
QEMU_CAPS_OBJECT_RNG_RANDOM,
|
2016-09-19 22:46:41 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_NET,
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_GPU,
|
|
|
|
QEMU_CAPS_VIRTIO_GPU_VIRGL,
|
|
|
|
QEMU_CAPS_VIRTIO_KEYBOARD,
|
|
|
|
QEMU_CAPS_VIRTIO_MOUSE,
|
qemu: assign virtio devices to PCIe slot when appropriate
libvirt previously assigned nearly all devices to a "hotpluggable"
legacy PCI slot even on machines with a PCIe root bus (and even though
most such machines don't even support hotplug on legacy PCI slots!)
Forcing all devices onto legacy PCI slots means that the domain will
need a dmi-to-pci-bridge (to convert from PCIe to legacy PCI) and a
pci-bridge (to provide hotpluggable legacy PCI slots which, again,
usually aren't hotpluggable anyway).
To help reduce the need for these legacy controllers, this patch tries
to assign virtio-1.0-capable devices to PCIe slots whenever possible,
by setting appropriate connectFlags in
virDomainCalculateDevicePCIConnectFlags(). Happily, when that function
was written (just a few commits ago) it was created with a
"virtioFlags" argument, set by both of its callers, which is the
proper connectFlags to set for any virtio-*-pci device - depending on
the arch/machinetype of the domain, and whether or not the qemu binary
supports virtio-1.0, that flag will have either been set to PCI or
PCIe. This patch merely enables the functionality by setting the flags
for the device to whatever is in virtioFlags if the device is a
virtio-*-pci device.
NB: the first virtio video device will be placed directly on bus 0
slot 1 rather than on a pcie-root-port due to the override for primary
video devices in qemuDomainValidateDevicePCISlotsQ35(). Whether or not
to change that is a topic of discussion, but this patch doesn't change
that particular behavior.
NB2: since the slot must be hotpluggable, and pcie-root (the PCIe root
complex) does *not* support hotplug, this means that suitable
controllers must also be in the config (i.e. either pcie-root-port, or
pcie-downstream-port). For now, libvirt doesn't add those
automatically, so if you put virtio devices in a config for a qemu
that has PCIe-capable virtio devices, you'll need to add extra
pcie-root-ports yourself. That requirement will be eliminated in a
future patch, but for now, it's simple to do this:
<controller type='pci' model='pcie-root-port'/>
<controller type='pci' model='pcie-root-port'/>
<controller type='pci' model='pcie-root-port'/>
...
Partially Resolves: https://bugzilla.redhat.com/show_bug.cgi?id=1330024
2016-08-13 22:10:41 +00:00
|
|
|
QEMU_CAPS_VIRTIO_TABLET,
|
|
|
|
QEMU_CAPS_VIRTIO_INPUT_HOST,
|
|
|
|
QEMU_CAPS_VIRTIO_SCSI,
|
|
|
|
QEMU_CAPS_DEVICE_PCI_BRIDGE,
|
|
|
|
QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
|
|
|
|
QEMU_CAPS_DEVICE_IOH3420,
|
|
|
|
QEMU_CAPS_ICH9_AHCI,
|
|
|
|
QEMU_CAPS_ICH9_USB_EHCI1,
|
2016-08-14 05:58:11 +00:00
|
|
|
QEMU_CAPS_NEC_USB_XHCI,
|
qemu: assign virtio devices to PCIe slot when appropriate
libvirt previously assigned nearly all devices to a "hotpluggable"
legacy PCI slot even on machines with a PCIe root bus (and even though
most such machines don't even support hotplug on legacy PCI slots!)
Forcing all devices onto legacy PCI slots means that the domain will
need a dmi-to-pci-bridge (to convert from PCIe to legacy PCI) and a
pci-bridge (to provide hotpluggable legacy PCI slots which, again,
usually aren't hotpluggable anyway).
To help reduce the need for these legacy controllers, this patch tries
to assign virtio-1.0-capable devices to PCIe slots whenever possible,
by setting appropriate connectFlags in
virDomainCalculateDevicePCIConnectFlags(). Happily, when that function
was written (just a few commits ago) it was created with a
"virtioFlags" argument, set by both of its callers, which is the
proper connectFlags to set for any virtio-*-pci device - depending on
the arch/machinetype of the domain, and whether or not the qemu binary
supports virtio-1.0, that flag will have either been set to PCI or
PCIe. This patch merely enables the functionality by setting the flags
for the device to whatever is in virtioFlags if the device is a
virtio-*-pci device.
NB: the first virtio video device will be placed directly on bus 0
slot 1 rather than on a pcie-root-port due to the override for primary
video devices in qemuDomainValidateDevicePCISlotsQ35(). Whether or not
to change that is a topic of discussion, but this patch doesn't change
that particular behavior.
NB2: since the slot must be hotpluggable, and pcie-root (the PCIe root
complex) does *not* support hotplug, this means that suitable
controllers must also be in the config (i.e. either pcie-root-port, or
pcie-downstream-port). For now, libvirt doesn't add those
automatically, so if you put virtio devices in a config for a qemu
that has PCIe-capable virtio devices, you'll need to add extra
pcie-root-ports yourself. That requirement will be eliminated in a
future patch, but for now, it's simple to do this:
<controller type='pci' model='pcie-root-port'/>
<controller type='pci' model='pcie-root-port'/>
<controller type='pci' model='pcie-root-port'/>
...
Partially Resolves: https://bugzilla.redhat.com/show_bug.cgi?id=1330024
2016-08-13 22:10:41 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY);
|
2016-09-20 17:12:55 +00:00
|
|
|
DO_TEST("q35-virt-manager-basic",
|
|
|
|
QEMU_CAPS_KVM,
|
2018-03-30 05:58:15 +00:00
|
|
|
QEMU_CAPS_MACHINE_VMPORT_OPT,
|
2016-09-20 17:12:55 +00:00
|
|
|
QEMU_CAPS_ICH9_DISABLE_S3,
|
|
|
|
QEMU_CAPS_ICH9_DISABLE_S4,
|
|
|
|
QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY,
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_RNG,
|
|
|
|
QEMU_CAPS_OBJECT_RNG_RANDOM,
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_NET,
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_GPU,
|
|
|
|
QEMU_CAPS_VIRTIO_GPU_VIRGL,
|
|
|
|
QEMU_CAPS_VIRTIO_KEYBOARD,
|
|
|
|
QEMU_CAPS_VIRTIO_MOUSE,
|
|
|
|
QEMU_CAPS_VIRTIO_TABLET,
|
|
|
|
QEMU_CAPS_VIRTIO_INPUT_HOST,
|
|
|
|
QEMU_CAPS_VIRTIO_SCSI,
|
|
|
|
QEMU_CAPS_DEVICE_PCI_BRIDGE,
|
|
|
|
QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
|
|
|
|
QEMU_CAPS_DEVICE_IOH3420,
|
|
|
|
QEMU_CAPS_ICH9_AHCI,
|
|
|
|
QEMU_CAPS_ICH9_USB_EHCI1,
|
|
|
|
QEMU_CAPS_NEC_USB_XHCI,
|
|
|
|
QEMU_CAPS_DEVICE_ICH9_INTEL_HDA,
|
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
|
|
|
|
QEMU_CAPS_SPICE,
|
|
|
|
QEMU_CAPS_DEVICE_QXL,
|
|
|
|
QEMU_CAPS_HDA_DUPLEX,
|
2017-11-26 16:35:28 +00:00
|
|
|
QEMU_CAPS_DEVICE_ISA_SERIAL,
|
2016-09-20 17:12:55 +00:00
|
|
|
QEMU_CAPS_USB_REDIR);
|
2017-03-16 16:41:21 +00:00
|
|
|
|
|
|
|
/* Test automatic and manual setting of pcie-root-port attributes */
|
2015-06-17 17:27:57 +00:00
|
|
|
DO_TEST("pcie-root-port",
|
|
|
|
QEMU_CAPS_DEVICE_IOH3420,
|
2015-11-06 14:28:57 +00:00
|
|
|
QEMU_CAPS_ICH9_AHCI,
|
2015-11-09 15:39:54 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
|
2016-10-11 15:42:37 +00:00
|
|
|
QEMU_CAPS_DEVICE_QXL);
|
2017-03-16 16:41:21 +00:00
|
|
|
|
|
|
|
/* Make sure the default model for PCIe Root Ports is picked correctly
|
|
|
|
* based on QEMU binary capabilities. We use x86/q35 for the test, but
|
|
|
|
* any PCIe machine type (such as aarch64/virt) will behave the same */
|
|
|
|
DO_TEST("pcie-root-port-model-generic",
|
|
|
|
QEMU_CAPS_DEVICE_PCIE_ROOT_PORT,
|
2018-03-28 21:20:45 +00:00
|
|
|
QEMU_CAPS_DEVICE_IOH3420);
|
2017-03-16 16:41:21 +00:00
|
|
|
DO_TEST("pcie-root-port-model-ioh3420",
|
2018-03-28 21:20:45 +00:00
|
|
|
QEMU_CAPS_DEVICE_IOH3420);
|
2020-03-04 03:22:14 +00:00
|
|
|
DO_TEST_CAPS_LATEST("pcie-root-port-nohotplug");
|
2017-03-16 16:41:21 +00:00
|
|
|
|
2016-05-10 17:14:32 +00:00
|
|
|
DO_TEST("autoindex",
|
|
|
|
QEMU_CAPS_DEVICE_PCI_BRIDGE,
|
|
|
|
QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
|
|
|
|
QEMU_CAPS_DEVICE_IOH3420,
|
|
|
|
QEMU_CAPS_DEVICE_X3130_UPSTREAM,
|
|
|
|
QEMU_CAPS_DEVICE_XIO3130_DOWNSTREAM,
|
|
|
|
QEMU_CAPS_ICH9_AHCI,
|
2017-02-23 17:47:36 +00:00
|
|
|
QEMU_CAPS_ICH9_USB_EHCI1,
|
2016-05-10 17:14:32 +00:00
|
|
|
QEMU_CAPS_NEC_USB_XHCI);
|
2016-10-12 15:02:37 +00:00
|
|
|
/* Make sure the user can always override libvirt's default device
|
|
|
|
* placement policy by providing an explicit PCI address */
|
|
|
|
DO_TEST("q35-pci-force-address",
|
|
|
|
QEMU_CAPS_DEVICE_PCI_BRIDGE,
|
|
|
|
QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
|
|
|
|
QEMU_CAPS_DEVICE_IOH3420,
|
|
|
|
QEMU_CAPS_HDA_DUPLEX);
|
2015-06-17 17:27:57 +00:00
|
|
|
|
2016-04-19 21:05:54 +00:00
|
|
|
DO_TEST_PARSE_ERROR("q35-wrong-root",
|
qemu: initially reserve one open pcie-root-port for hotplug
For machinetypes with a pci-root bus (all legacy PCI), libvirt will
make a "fake" reservation for one extra slot prior to assigning
addresses to unaddressed PCI endpoint devices in the domain. This will
trigger auto-adding of a pci-bridge for the final device to be
assigned an address *if that device would have otherwise instead been
the last device on the last available pci-bridge*; thus it assures
that there will always be at least one slot left open in the domain's
bus topology for expansion (which is important both for hotplug (since
a new pci-bridge can't be added while the guest is running) as well as
for offline additions to the config (since adding a new device might
otherwise in some cases require re-addressing existing devices, which
we want to avoid)).
It's important to note that for the above case (legacy PCI), we must
check for the special case of all slots on all buses being occupied
*prior to assigning any addresses*, and avoid attempting to reserve
the extra address in that case, because there is no free address in
the existing topology, so no place to auto-add a pci-bridge for
expansion (i.e. it would always fail anyway). Since that condition can
only be reached by manual intervention, this is acceptable.
For machinetypes with pcie-root (Q35, aarch64 virt), libvirt's
methodology for automatically expanding the bus topology is different
- pcie-root-ports are plugged into slots (soon to be functions) of
pcie-root as needed, and the new endpoint devices are assigned to the
single slot in each pcie-root-port. This is done so that the devices
are, by default, hotpluggable (the slots of pcie-root don't support
hotplug, but the single slot of the pcie-root-port does). Since
pcie-root-ports can only be plugged into pcie-root, and we don't
auto-assign endpoint devices to the pcie-root slots, this means
topology expansion doesn't compete with endpoint devices for slots, so
we don't need to worry about checking for all "useful" slots being
free *prior* to assigning addresses to new endpoint devices - as a
matter of fact, if we attempt to reserve the open slots before the
used slots, it can lead to errors.
Instead this patch just reserves one slot for a "future potential"
PCIe device after doing the assignment for actual devices, but only
if the only PCI controller defined prior to starting address
assignment was pcie-root, and only if we auto-added at least one PCI
controller during address assignment. This assures two things:
1) that reserving the open slots will only be done when the domain is
initially defined, never at any time after, and
2) that if the user understands enough about PCI controllers that they
are adding them manually, that we don't mess up their plan by
adding extras - if they know enough to add one pcie-root-port, or
to manually assign addresses such that no pcie-root-ports are
needed, they know enough to add extra pcie-root-ports if they want
them (this could be called the "libguestfs clause", since
libguestfs needs to be able to create domains with as few
devices/controllers as possible).
This is set to reserve a single free port for now, but could be
increased in the future if public sentiment goes in that direction
(it's easy to increase later, but essentially impossible to decrease)
2016-09-28 00:37:30 +00:00
|
|
|
QEMU_CAPS_DEVICE_IOH3420,
|
2016-04-19 21:05:54 +00:00
|
|
|
QEMU_CAPS_ICH9_AHCI,
|
2018-03-28 21:20:45 +00:00
|
|
|
QEMU_CAPS_ICH9_USB_EHCI1,
|
2016-04-19 21:05:54 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
|
2016-10-11 15:42:37 +00:00
|
|
|
QEMU_CAPS_DEVICE_QXL);
|
2016-04-19 21:05:54 +00:00
|
|
|
DO_TEST_PARSE_ERROR("440fx-wrong-root", NONE);
|
2017-09-26 10:35:29 +00:00
|
|
|
DO_TEST_PARSE_ERROR("440fx-ide-address-conflict", NONE);
|
2016-04-19 21:05:54 +00:00
|
|
|
|
2016-05-14 20:36:16 +00:00
|
|
|
DO_TEST_PARSE_ERROR("pcie-root-port-too-many",
|
2015-06-17 17:27:57 +00:00
|
|
|
QEMU_CAPS_DEVICE_IOH3420,
|
2015-11-06 14:28:57 +00:00
|
|
|
QEMU_CAPS_ICH9_AHCI,
|
2015-11-09 15:39:54 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
|
2016-10-11 15:42:37 +00:00
|
|
|
QEMU_CAPS_DEVICE_QXL);
|
2013-04-19 10:38:53 +00:00
|
|
|
|
2015-06-16 19:09:07 +00:00
|
|
|
DO_TEST("pcie-switch-upstream-port",
|
|
|
|
QEMU_CAPS_DEVICE_IOH3420,
|
|
|
|
QEMU_CAPS_DEVICE_X3130_UPSTREAM,
|
2015-11-06 14:28:57 +00:00
|
|
|
QEMU_CAPS_ICH9_AHCI,
|
2015-11-09 15:39:54 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
|
2016-10-11 15:42:37 +00:00
|
|
|
QEMU_CAPS_DEVICE_QXL);
|
2015-06-17 21:48:28 +00:00
|
|
|
DO_TEST("pcie-switch-downstream-port",
|
|
|
|
QEMU_CAPS_DEVICE_IOH3420,
|
|
|
|
QEMU_CAPS_DEVICE_X3130_UPSTREAM,
|
|
|
|
QEMU_CAPS_DEVICE_XIO3130_DOWNSTREAM,
|
2015-11-06 14:28:57 +00:00
|
|
|
QEMU_CAPS_ICH9_AHCI,
|
2015-11-09 15:39:54 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
|
2016-10-11 15:42:37 +00:00
|
|
|
QEMU_CAPS_DEVICE_QXL);
|
2015-06-16 19:09:07 +00:00
|
|
|
|
2016-03-04 19:35:20 +00:00
|
|
|
DO_TEST("pci-expander-bus",
|
|
|
|
QEMU_CAPS_DEVICE_PXB);
|
|
|
|
DO_TEST_PARSE_ERROR("pci-expander-bus-bad-node",
|
|
|
|
QEMU_CAPS_DEVICE_PXB);
|
|
|
|
DO_TEST_PARSE_ERROR("pci-expander-bus-bad-machine",
|
|
|
|
QEMU_CAPS_DEVICE_PXB);
|
2016-08-06 23:03:31 +00:00
|
|
|
DO_TEST_PARSE_ERROR("pci-expander-bus-bad-bus",
|
|
|
|
QEMU_CAPS_DEVICE_PXB);
|
2016-03-04 19:35:20 +00:00
|
|
|
|
2016-03-23 19:49:29 +00:00
|
|
|
DO_TEST("pcie-expander-bus",
|
|
|
|
QEMU_CAPS_DEVICE_IOH3420,
|
|
|
|
QEMU_CAPS_DEVICE_X3130_UPSTREAM,
|
|
|
|
QEMU_CAPS_DEVICE_XIO3130_DOWNSTREAM,
|
|
|
|
QEMU_CAPS_DEVICE_PXB_PCIE);
|
|
|
|
DO_TEST_PARSE_ERROR("pcie-expander-bus-bad-machine",
|
|
|
|
QEMU_CAPS_DEVICE_IOH3420,
|
|
|
|
QEMU_CAPS_DEVICE_X3130_UPSTREAM,
|
|
|
|
QEMU_CAPS_DEVICE_XIO3130_DOWNSTREAM,
|
|
|
|
QEMU_CAPS_DEVICE_PXB_PCIE);
|
2016-08-06 23:03:31 +00:00
|
|
|
DO_TEST_PARSE_ERROR("pcie-expander-bus-bad-bus",
|
|
|
|
QEMU_CAPS_DEVICE_IOH3420,
|
|
|
|
QEMU_CAPS_DEVICE_PXB_PCIE);
|
2016-03-23 19:49:29 +00:00
|
|
|
|
2020-06-17 13:10:51 +00:00
|
|
|
DO_TEST_CAPS_VER("hostdev-scsi-lsi", "2.8.0");
|
2020-06-17 12:55:04 +00:00
|
|
|
DO_TEST_CAPS_VER("hostdev-scsi-lsi", "4.1.0");
|
2020-06-17 12:58:49 +00:00
|
|
|
DO_TEST_CAPS_LATEST("hostdev-scsi-lsi");
|
2020-06-17 13:10:51 +00:00
|
|
|
DO_TEST_CAPS_VER("hostdev-scsi-virtio-scsi", "2.8.0");
|
2020-06-17 13:42:54 +00:00
|
|
|
DO_TEST_CAPS_VER("hostdev-scsi-virtio-scsi", "4.1.0");
|
2020-06-17 13:51:57 +00:00
|
|
|
DO_TEST_CAPS_LATEST("hostdev-scsi-virtio-scsi");
|
2020-06-17 12:55:04 +00:00
|
|
|
|
2016-11-22 03:58:20 +00:00
|
|
|
DO_TEST("hostdev-scsi-vhost-scsi-ccw",
|
|
|
|
QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_DEVICE_VHOST_SCSI,
|
2018-09-18 10:29:10 +00:00
|
|
|
QEMU_CAPS_CCW);
|
2016-11-22 03:58:20 +00:00
|
|
|
DO_TEST("hostdev-scsi-vhost-scsi-pci",
|
2018-09-18 10:29:10 +00:00
|
|
|
QEMU_CAPS_VIRTIO_SCSI,
|
|
|
|
QEMU_CAPS_DEVICE_VHOST_SCSI);
|
2019-08-27 14:19:20 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("hostdev-scsi-vhost-scsi-pci-boot-fail");
|
qemu: assign correct type of PCI address for vhost-scsi when using pcie-root
Commit 10c73bf1 fixed a bug that I had introduced back in commit
70249927 - if a vhost-scsi device had no manually assigned PCI
address, one wouldn't be assigned automatically. There was a slight
problem with the logic of the fix though - in the case of domains with
pcie-root (e.g. those with a q35 machinetype),
qemuDomainDeviceCalculatePCIConnectFlags() will attempt to determine
if the host-side PCI device is Express or legacy by examining sysfs
based on the host-side PCI address stored in
hostdev->source.subsys.u.pci.addr, but that part of the union is only
valid for PCI hostdevs, *not* for SCSI hostdevs. So we end up trying
to read sysfs for some probably-non-existent device, which fails, and
the function virPCIDeviceIsPCIExpress() returns failure (-1).
By coincidence, the return value is being examined as a boolean, and
since -1 is true, we still end up assigning the vhost-scsi device to
an Express slot, but that is just by chance (and could fail in the
case that the gibberish in the "hostside PCI address" was the address
of a real device that happened to be legacy PCI).
Since (according to Paolo Bonzini) vhost-scsi devices appear just like
virtio-scsi devices in the guest, they should follow the same rules as
virtio devices when deciding whether they should be placed in an
Express or a legacy slot. That's accomplished in this patch by
returning early with virtioFlags, rather than erroneously using
hostdev->source.subsys.u.pci.addr. It also adds a test case for PCIe
to assure it doesn't get broken in the future.
2017-12-15 16:42:35 +00:00
|
|
|
DO_TEST("hostdev-scsi-vhost-scsi-pcie",
|
|
|
|
QEMU_CAPS_KVM,
|
|
|
|
QEMU_CAPS_VIRTIO_SCSI, QEMU_CAPS_DEVICE_VHOST_SCSI,
|
|
|
|
QEMU_CAPS_DEVICE_PCIE_ROOT_PORT,
|
|
|
|
QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY);
|
qemu: Build qemu command line for scsi host device
Except the scsi host device's controller is "lsilogic", mapping
between the libvirt attributes and scsi-generic properties is:
libvirt qemu
-----------------------------------------
controller bus ($libvirt_controller.0)
bus channel
target scsi-id
unit lun
For scsi host device with "lsilogic" controller, the mapping is:
('target (libvirt)' must be 0, as it's not used; 'unit (libvirt)
must <= 7).
libvirt qemu
----------------------------------------------------------
controller && bus bus ($libvirt_controller.$libvirt_bus)
unit scsi-id
It's not good to hardcode/hard-check limits of these attributes,
and even worse, these limits are not documented, one has to find
out by either testing or reading the qemu code, I'm looking forward
to qemu expose limits like these one day). For example, exposing
"max_target", "max_lun" for megasas:
static const struct SCSIBusInfo megasas_scsi_info = {
.tcq = true,
.max_target = MFI_MAX_LD,
.max_lun = 255,
.transfer_data = megasas_xfer_complete,
.get_sg_list = megasas_get_sg_list,
.complete = megasas_command_complete,
.cancel = megasas_command_cancel,
};
Example of the qemu command line (lsilogic controller):
-drive file=/dev/sg2,if=none,id=drive-hostdev-scsi_host7-0-0-0 \
-device scsi-generic,bus=scsi0.0,scsi-id=8,\
drive=drive-hostdev-scsi_host7-0-0-0,id=hostdev-scsi_host7-0-0-0
Example of the qemu command line (virtio-scsi controller):
-drive file=/dev/sg2,if=none,id=drive-hostdev-scsi_host7-0-0-0 \
-device scsi-generic,bus=scsi0.0,channel=0,scsi-id=128,lun=128,\
drive=drive-hostdev-scsi_host7-0-0-0,id=hostdev-scsi_host7-0-0-0
Signed-off-by: Han Cheng <hanc.fnst@cn.fujitsu.com>
Signed-off-by: Osier Yang <jyang@redhat.com>
2013-05-03 18:07:23 +00:00
|
|
|
|
2019-04-12 08:00:41 +00:00
|
|
|
DO_TEST_CAPS_VER("mlock-on", "3.0.0");
|
|
|
|
DO_TEST_CAPS_VER("mlock-off", "3.0.0");
|
2019-04-12 08:01:53 +00:00
|
|
|
DO_TEST_CAPS_LATEST("mlock-on");
|
|
|
|
DO_TEST_CAPS_LATEST("mlock-off");
|
2019-04-12 08:00:41 +00:00
|
|
|
|
2017-02-23 18:14:15 +00:00
|
|
|
DO_TEST_PARSE_ERROR("pci-bridge-negative-index-invalid", NONE);
|
|
|
|
DO_TEST_PARSE_ERROR("pci-bridge-duplicate-index", NONE);
|
|
|
|
DO_TEST_PARSE_ERROR("pci-root-nonzero-index", NONE);
|
|
|
|
DO_TEST_PARSE_ERROR("pci-root-address", NONE);
|
2013-07-12 12:17:23 +00:00
|
|
|
|
2013-07-18 09:19:23 +00:00
|
|
|
DO_TEST("hotplug-base",
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_KVM, QEMU_CAPS_VIRTIO_SCSI);
|
2013-07-18 09:19:23 +00:00
|
|
|
|
2016-01-13 00:26:40 +00:00
|
|
|
DO_TEST("pcihole64", QEMU_CAPS_I440FX_PCI_HOLE64_SIZE);
|
2019-12-09 23:15:24 +00:00
|
|
|
DO_TEST_PARSE_ERROR("pcihole64-none", NONE);
|
2013-08-12 11:48:34 +00:00
|
|
|
DO_TEST("pcihole64-q35",
|
qemu: initially reserve one open pcie-root-port for hotplug
For machinetypes with a pci-root bus (all legacy PCI), libvirt will
make a "fake" reservation for one extra slot prior to assigning
addresses to unaddressed PCI endpoint devices in the domain. This will
trigger auto-adding of a pci-bridge for the final device to be
assigned an address *if that device would have otherwise instead been
the last device on the last available pci-bridge*; thus it assures
that there will always be at least one slot left open in the domain's
bus topology for expansion (which is important both for hotplug (since
a new pci-bridge can't be added while the guest is running) as well as
for offline additions to the config (since adding a new device might
otherwise in some cases require re-addressing existing devices, which
we want to avoid)).
It's important to note that for the above case (legacy PCI), we must
check for the special case of all slots on all buses being occupied
*prior to assigning any addresses*, and avoid attempting to reserve
the extra address in that case, because there is no free address in
the existing topology, so no place to auto-add a pci-bridge for
expansion (i.e. it would always fail anyway). Since that condition can
only be reached by manual intervention, this is acceptable.
For machinetypes with pcie-root (Q35, aarch64 virt), libvirt's
methodology for automatically expanding the bus topology is different
- pcie-root-ports are plugged into slots (soon to be functions) of
pcie-root as needed, and the new endpoint devices are assigned to the
single slot in each pcie-root-port. This is done so that the devices
are, by default, hotpluggable (the slots of pcie-root don't support
hotplug, but the single slot of the pcie-root-port does). Since
pcie-root-ports can only be plugged into pcie-root, and we don't
auto-assign endpoint devices to the pcie-root slots, this means
topology expansion doesn't compete with endpoint devices for slots, so
we don't need to worry about checking for all "useful" slots being
free *prior* to assigning addresses to new endpoint devices - as a
matter of fact, if we attempt to reserve the open slots before the
used slots, it can lead to errors.
Instead this patch just reserves one slot for a "future potential"
PCIe device after doing the assignment for actual devices, but only
if the only PCI controller defined prior to starting address
assignment was pcie-root, and only if we auto-added at least one PCI
controller during address assignment. This assures two things:
1) that reserving the open slots will only be done when the domain is
initially defined, never at any time after, and
2) that if the user understands enough about PCI controllers that they
are adding them manually, that we don't mess up their plan by
adding extras - if they know enough to add one pcie-root-port, or
to manually assign addresses such that no pcie-root-ports are
needed, they know enough to add extra pcie-root-ports if they want
them (this could be called the "libguestfs clause", since
libguestfs needs to be able to create domains with as few
devices/controllers as possible).
This is set to reserve a single free port for now, but could be
increased in the future if public sentiment goes in that direction
(it's easy to increase later, but essentially impossible to decrease)
2016-09-28 00:37:30 +00:00
|
|
|
QEMU_CAPS_DEVICE_IOH3420,
|
2015-11-06 14:28:57 +00:00
|
|
|
QEMU_CAPS_ICH9_AHCI,
|
2015-11-09 15:39:54 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
|
2016-10-11 15:42:37 +00:00
|
|
|
QEMU_CAPS_DEVICE_QXL,
|
2013-08-12 11:48:34 +00:00
|
|
|
QEMU_CAPS_Q35_PCI_HOLE64_SIZE);
|
|
|
|
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST("arm-vexpressa9-nodevs", NONE);
|
|
|
|
DO_TEST("arm-vexpressa9-basic", NONE);
|
2013-08-01 01:40:35 +00:00
|
|
|
DO_TEST("arm-vexpressa9-virtio",
|
2015-11-06 14:28:57 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_MMIO,
|
2013-08-01 01:40:35 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_RNG, QEMU_CAPS_OBJECT_RNG_RANDOM);
|
2013-11-19 21:49:40 +00:00
|
|
|
DO_TEST("arm-virt-virtio",
|
2015-11-06 14:28:57 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_MMIO,
|
2017-11-28 10:34:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_PL011,
|
2013-11-19 21:49:40 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_RNG, QEMU_CAPS_OBJECT_RNG_RANDOM);
|
2013-07-30 19:41:14 +00:00
|
|
|
|
2014-01-02 10:42:56 +00:00
|
|
|
DO_TEST("aarch64-virt-virtio",
|
2015-11-06 14:28:57 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_MMIO,
|
2017-11-28 10:34:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_PL011,
|
2014-01-02 10:42:56 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_RNG, QEMU_CAPS_OBJECT_RNG_RANDOM);
|
2016-01-27 22:47:14 +00:00
|
|
|
|
|
|
|
/* Demonstrates the virtio-pci default... namely that there isn't any!
|
|
|
|
q35 style PCI controllers will be added if the binary supports it,
|
|
|
|
but virtio-mmio is always used unless PCI addresses are manually
|
|
|
|
specified. */
|
|
|
|
DO_TEST("aarch64-virtio-pci-default",
|
2016-10-21 09:50:15 +00:00
|
|
|
QEMU_CAPS_VIRTIO_PCI_DISABLE_LEGACY,
|
2016-04-08 08:46:41 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_MMIO,
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_RNG, QEMU_CAPS_OBJECT_RNG_RANDOM,
|
|
|
|
QEMU_CAPS_OBJECT_GPEX, QEMU_CAPS_DEVICE_PCI_BRIDGE,
|
qemu: initially reserve one open pcie-root-port for hotplug
For machinetypes with a pci-root bus (all legacy PCI), libvirt will
make a "fake" reservation for one extra slot prior to assigning
addresses to unaddressed PCI endpoint devices in the domain. This will
trigger auto-adding of a pci-bridge for the final device to be
assigned an address *if that device would have otherwise instead been
the last device on the last available pci-bridge*; thus it assures
that there will always be at least one slot left open in the domain's
bus topology for expansion (which is important both for hotplug (since
a new pci-bridge can't be added while the guest is running) as well as
for offline additions to the config (since adding a new device might
otherwise in some cases require re-addressing existing devices, which
we want to avoid)).
It's important to note that for the above case (legacy PCI), we must
check for the special case of all slots on all buses being occupied
*prior to assigning any addresses*, and avoid attempting to reserve
the extra address in that case, because there is no free address in
the existing topology, so no place to auto-add a pci-bridge for
expansion (i.e. it would always fail anyway). Since that condition can
only be reached by manual intervention, this is acceptable.
For machinetypes with pcie-root (Q35, aarch64 virt), libvirt's
methodology for automatically expanding the bus topology is different
- pcie-root-ports are plugged into slots (soon to be functions) of
pcie-root as needed, and the new endpoint devices are assigned to the
single slot in each pcie-root-port. This is done so that the devices
are, by default, hotpluggable (the slots of pcie-root don't support
hotplug, but the single slot of the pcie-root-port does). Since
pcie-root-ports can only be plugged into pcie-root, and we don't
auto-assign endpoint devices to the pcie-root slots, this means
topology expansion doesn't compete with endpoint devices for slots, so
we don't need to worry about checking for all "useful" slots being
free *prior* to assigning addresses to new endpoint devices - as a
matter of fact, if we attempt to reserve the open slots before the
used slots, it can lead to errors.
Instead this patch just reserves one slot for a "future potential"
PCIe device after doing the assignment for actual devices, but only
if the only PCI controller defined prior to starting address
assignment was pcie-root, and only if we auto-added at least one PCI
controller during address assignment. This assures two things:
1) that reserving the open slots will only be done when the domain is
initially defined, never at any time after, and
2) that if the user understands enough about PCI controllers that they
are adding them manually, that we don't mess up their plan by
adding extras - if they know enough to add one pcie-root-port, or
to manually assign addresses such that no pcie-root-ports are
needed, they know enough to add extra pcie-root-ports if they want
them (this could be called the "libguestfs clause", since
libguestfs needs to be able to create domains with as few
devices/controllers as possible).
This is set to reserve a single free port for now, but could be
increased in the future if public sentiment goes in that direction
(it's easy to increase later, but essentially impossible to decrease)
2016-09-28 00:37:30 +00:00
|
|
|
QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
|
2017-02-23 17:47:36 +00:00
|
|
|
QEMU_CAPS_DEVICE_IOH3420,
|
2017-11-28 10:34:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_PL011,
|
2017-02-23 17:47:36 +00:00
|
|
|
QEMU_CAPS_VIRTIO_SCSI);
|
2016-04-08 08:46:41 +00:00
|
|
|
DO_TEST("aarch64-virt-2.6-virtio-pci-default",
|
2015-11-06 14:28:57 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_MMIO,
|
2015-09-30 00:10:07 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_RNG, QEMU_CAPS_OBJECT_RNG_RANDOM,
|
|
|
|
QEMU_CAPS_OBJECT_GPEX, QEMU_CAPS_DEVICE_PCI_BRIDGE,
|
qemu: initially reserve one open pcie-root-port for hotplug
For machinetypes with a pci-root bus (all legacy PCI), libvirt will
make a "fake" reservation for one extra slot prior to assigning
addresses to unaddressed PCI endpoint devices in the domain. This will
trigger auto-adding of a pci-bridge for the final device to be
assigned an address *if that device would have otherwise instead been
the last device on the last available pci-bridge*; thus it assures
that there will always be at least one slot left open in the domain's
bus topology for expansion (which is important both for hotplug (since
a new pci-bridge can't be added while the guest is running) as well as
for offline additions to the config (since adding a new device might
otherwise in some cases require re-addressing existing devices, which
we want to avoid)).
It's important to note that for the above case (legacy PCI), we must
check for the special case of all slots on all buses being occupied
*prior to assigning any addresses*, and avoid attempting to reserve
the extra address in that case, because there is no free address in
the existing topology, so no place to auto-add a pci-bridge for
expansion (i.e. it would always fail anyway). Since that condition can
only be reached by manual intervention, this is acceptable.
For machinetypes with pcie-root (Q35, aarch64 virt), libvirt's
methodology for automatically expanding the bus topology is different
- pcie-root-ports are plugged into slots (soon to be functions) of
pcie-root as needed, and the new endpoint devices are assigned to the
single slot in each pcie-root-port. This is done so that the devices
are, by default, hotpluggable (the slots of pcie-root don't support
hotplug, but the single slot of the pcie-root-port does). Since
pcie-root-ports can only be plugged into pcie-root, and we don't
auto-assign endpoint devices to the pcie-root slots, this means
topology expansion doesn't compete with endpoint devices for slots, so
we don't need to worry about checking for all "useful" slots being
free *prior* to assigning addresses to new endpoint devices - as a
matter of fact, if we attempt to reserve the open slots before the
used slots, it can lead to errors.
Instead this patch just reserves one slot for a "future potential"
PCIe device after doing the assignment for actual devices, but only
if the only PCI controller defined prior to starting address
assignment was pcie-root, and only if we auto-added at least one PCI
controller during address assignment. This assures two things:
1) that reserving the open slots will only be done when the domain is
initially defined, never at any time after, and
2) that if the user understands enough about PCI controllers that they
are adding them manually, that we don't mess up their plan by
adding extras - if they know enough to add one pcie-root-port, or
to manually assign addresses such that no pcie-root-ports are
needed, they know enough to add extra pcie-root-ports if they want
them (this could be called the "libguestfs clause", since
libguestfs needs to be able to create domains with as few
devices/controllers as possible).
This is set to reserve a single free port for now, but could be
increased in the future if public sentiment goes in that direction
(it's easy to increase later, but essentially impossible to decrease)
2016-09-28 00:37:30 +00:00
|
|
|
QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
|
2017-11-28 10:34:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_PL011,
|
qemu: initially reserve one open pcie-root-port for hotplug
For machinetypes with a pci-root bus (all legacy PCI), libvirt will
make a "fake" reservation for one extra slot prior to assigning
addresses to unaddressed PCI endpoint devices in the domain. This will
trigger auto-adding of a pci-bridge for the final device to be
assigned an address *if that device would have otherwise instead been
the last device on the last available pci-bridge*; thus it assures
that there will always be at least one slot left open in the domain's
bus topology for expansion (which is important both for hotplug (since
a new pci-bridge can't be added while the guest is running) as well as
for offline additions to the config (since adding a new device might
otherwise in some cases require re-addressing existing devices, which
we want to avoid)).
It's important to note that for the above case (legacy PCI), we must
check for the special case of all slots on all buses being occupied
*prior to assigning any addresses*, and avoid attempting to reserve
the extra address in that case, because there is no free address in
the existing topology, so no place to auto-add a pci-bridge for
expansion (i.e. it would always fail anyway). Since that condition can
only be reached by manual intervention, this is acceptable.
For machinetypes with pcie-root (Q35, aarch64 virt), libvirt's
methodology for automatically expanding the bus topology is different
- pcie-root-ports are plugged into slots (soon to be functions) of
pcie-root as needed, and the new endpoint devices are assigned to the
single slot in each pcie-root-port. This is done so that the devices
are, by default, hotpluggable (the slots of pcie-root don't support
hotplug, but the single slot of the pcie-root-port does). Since
pcie-root-ports can only be plugged into pcie-root, and we don't
auto-assign endpoint devices to the pcie-root slots, this means
topology expansion doesn't compete with endpoint devices for slots, so
we don't need to worry about checking for all "useful" slots being
free *prior* to assigning addresses to new endpoint devices - as a
matter of fact, if we attempt to reserve the open slots before the
used slots, it can lead to errors.
Instead this patch just reserves one slot for a "future potential"
PCIe device after doing the assignment for actual devices, but only
if the only PCI controller defined prior to starting address
assignment was pcie-root, and only if we auto-added at least one PCI
controller during address assignment. This assures two things:
1) that reserving the open slots will only be done when the domain is
initially defined, never at any time after, and
2) that if the user understands enough about PCI controllers that they
are adding them manually, that we don't mess up their plan by
adding extras - if they know enough to add one pcie-root-port, or
to manually assign addresses such that no pcie-root-ports are
needed, they know enough to add extra pcie-root-ports if they want
them (this could be called the "libguestfs clause", since
libguestfs needs to be able to create domains with as few
devices/controllers as possible).
This is set to reserve a single free port for now, but could be
increased in the future if public sentiment goes in that direction
(it's easy to increase later, but essentially impossible to decrease)
2016-09-28 00:37:30 +00:00
|
|
|
QEMU_CAPS_DEVICE_IOH3420);
|
2016-01-27 22:47:14 +00:00
|
|
|
/* Example of using virtio-pci with no explicit PCI controller
|
|
|
|
but with manual PCI addresses */
|
|
|
|
DO_TEST("aarch64-virtio-pci-manual-addresses",
|
2015-11-06 14:28:57 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_MMIO,
|
2015-09-30 00:10:07 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_RNG, QEMU_CAPS_OBJECT_RNG_RANDOM,
|
|
|
|
QEMU_CAPS_OBJECT_GPEX, QEMU_CAPS_DEVICE_PCI_BRIDGE,
|
qemu: initially reserve one open pcie-root-port for hotplug
For machinetypes with a pci-root bus (all legacy PCI), libvirt will
make a "fake" reservation for one extra slot prior to assigning
addresses to unaddressed PCI endpoint devices in the domain. This will
trigger auto-adding of a pci-bridge for the final device to be
assigned an address *if that device would have otherwise instead been
the last device on the last available pci-bridge*; thus it assures
that there will always be at least one slot left open in the domain's
bus topology for expansion (which is important both for hotplug (since
a new pci-bridge can't be added while the guest is running) as well as
for offline additions to the config (since adding a new device might
otherwise in some cases require re-addressing existing devices, which
we want to avoid)).
It's important to note that for the above case (legacy PCI), we must
check for the special case of all slots on all buses being occupied
*prior to assigning any addresses*, and avoid attempting to reserve
the extra address in that case, because there is no free address in
the existing topology, so no place to auto-add a pci-bridge for
expansion (i.e. it would always fail anyway). Since that condition can
only be reached by manual intervention, this is acceptable.
For machinetypes with pcie-root (Q35, aarch64 virt), libvirt's
methodology for automatically expanding the bus topology is different
- pcie-root-ports are plugged into slots (soon to be functions) of
pcie-root as needed, and the new endpoint devices are assigned to the
single slot in each pcie-root-port. This is done so that the devices
are, by default, hotpluggable (the slots of pcie-root don't support
hotplug, but the single slot of the pcie-root-port does). Since
pcie-root-ports can only be plugged into pcie-root, and we don't
auto-assign endpoint devices to the pcie-root slots, this means
topology expansion doesn't compete with endpoint devices for slots, so
we don't need to worry about checking for all "useful" slots being
free *prior* to assigning addresses to new endpoint devices - as a
matter of fact, if we attempt to reserve the open slots before the
used slots, it can lead to errors.
Instead this patch just reserves one slot for a "future potential"
PCIe device after doing the assignment for actual devices, but only
if the only PCI controller defined prior to starting address
assignment was pcie-root, and only if we auto-added at least one PCI
controller during address assignment. This assures two things:
1) that reserving the open slots will only be done when the domain is
initially defined, never at any time after, and
2) that if the user understands enough about PCI controllers that they
are adding them manually, that we don't mess up their plan by
adding extras - if they know enough to add one pcie-root-port, or
to manually assign addresses such that no pcie-root-ports are
needed, they know enough to add extra pcie-root-ports if they want
them (this could be called the "libguestfs clause", since
libguestfs needs to be able to create domains with as few
devices/controllers as possible).
This is set to reserve a single free port for now, but could be
increased in the future if public sentiment goes in that direction
(it's easy to increase later, but essentially impossible to decrease)
2016-09-28 00:37:30 +00:00
|
|
|
QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
|
|
|
|
QEMU_CAPS_DEVICE_IOH3420,
|
|
|
|
QEMU_CAPS_VIRTIO_SCSI);
|
qemu: map "virtio" video model to "virt" machtype correctly (arm/aarch64)
Most of QEMU's PCI display device models, such as:
libvirt video/model/@type QEMU -device
------------------------- ------------
cirrus cirrus-vga
vga VGA
qxl qxl-vga
virtio virtio-vga
come with a linear framebuffer (sometimes called "VGA compatibility
framebuffer"). This linear framebuffer lives in one of the PCI device's
MMIO BARs, and allows guest code (primarily: firmware drivers, and
non-accelerated OS drivers) to display graphics with direct memory access.
Due to architectural reasons on aarch64/KVM hosts, this kind of
framebuffer doesn't / can't work in
qemu-system-(arm|aarch64) -M virt
machines. Cache coherency issues guarantee a corrupted / unusable display.
The problem has been researched by several people, including kvm-arm
maintainers, and it's been decided that the best way (practically the only
way) to have boot time graphics for such guests is to consolidate on
QEMU's "virtio-gpu-pci" device.
>From <https://bugzilla.redhat.com/show_bug.cgi?id=1195176>, libvirt
supports
<devices>
<video>
<model type='virtio'/>
</video>
</devices>
but libvirt unconditionally maps @type='virtio' to QEMU's "virtio-vga"
device model. (See the qemuBuildDeviceVideoStr() function and the
"qemuDeviceVideo" enum impl.)
According to the above, this is not right for the "virt" machine type; the
qemu-system-(arm|aarch64) binaries don't even recognize the "virtio-vga"
device model (justifiedly). Whereas "virtio-gpu-pci", which is a pure
virtio device without a compatibility framebuffer, is available, and works
fine.
(The ArmVirtQemu ("AAVMF") platform of edk2 -- that is, the UEFI firmware
for "virt" -- supports "virtio-gpu-pci", as of upstream commit
3ef3209d3028. See
<https://tianocore.acgmultimedia.com/show_bug.cgi?id=66>.)
Override the default mapping of "virtio", from "virtio-vga" to
"virtio-gpu-pci", if qemuDomainMachineIsVirt() evaluates to true.
Cc: Andrea Bolognani <abologna@redhat.com>
Cc: Drew Jones <drjones@redhat.com>
Cc: Marc-André Lureau <marcandre.lureau@redhat.com>
Cc: Martin Kletzander <mkletzan@redhat.com>
Suggested-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Resolves: https://bugzilla.redhat.com/show_bug.cgi?id=1372901
Signed-off-by: Laszlo Ersek <lersek@redhat.com>
Acked-by: Martin Kletzander <mkletzan@redhat.com>
2016-09-16 07:30:23 +00:00
|
|
|
DO_TEST("aarch64-video-virtio-gpu-pci",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_OBJECT_GPEX,
|
qemu: map "virtio" video model to "virt" machtype correctly (arm/aarch64)
Most of QEMU's PCI display device models, such as:
libvirt video/model/@type QEMU -device
------------------------- ------------
cirrus cirrus-vga
vga VGA
qxl qxl-vga
virtio virtio-vga
come with a linear framebuffer (sometimes called "VGA compatibility
framebuffer"). This linear framebuffer lives in one of the PCI device's
MMIO BARs, and allows guest code (primarily: firmware drivers, and
non-accelerated OS drivers) to display graphics with direct memory access.
Due to architectural reasons on aarch64/KVM hosts, this kind of
framebuffer doesn't / can't work in
qemu-system-(arm|aarch64) -M virt
machines. Cache coherency issues guarantee a corrupted / unusable display.
The problem has been researched by several people, including kvm-arm
maintainers, and it's been decided that the best way (practically the only
way) to have boot time graphics for such guests is to consolidate on
QEMU's "virtio-gpu-pci" device.
>From <https://bugzilla.redhat.com/show_bug.cgi?id=1195176>, libvirt
supports
<devices>
<video>
<model type='virtio'/>
</video>
</devices>
but libvirt unconditionally maps @type='virtio' to QEMU's "virtio-vga"
device model. (See the qemuBuildDeviceVideoStr() function and the
"qemuDeviceVideo" enum impl.)
According to the above, this is not right for the "virt" machine type; the
qemu-system-(arm|aarch64) binaries don't even recognize the "virtio-vga"
device model (justifiedly). Whereas "virtio-gpu-pci", which is a pure
virtio device without a compatibility framebuffer, is available, and works
fine.
(The ArmVirtQemu ("AAVMF") platform of edk2 -- that is, the UEFI firmware
for "virt" -- supports "virtio-gpu-pci", as of upstream commit
3ef3209d3028. See
<https://tianocore.acgmultimedia.com/show_bug.cgi?id=66>.)
Override the default mapping of "virtio", from "virtio-vga" to
"virtio-gpu-pci", if qemuDomainMachineIsVirt() evaluates to true.
Cc: Andrea Bolognani <abologna@redhat.com>
Cc: Drew Jones <drjones@redhat.com>
Cc: Marc-André Lureau <marcandre.lureau@redhat.com>
Cc: Martin Kletzander <mkletzan@redhat.com>
Suggested-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Resolves: https://bugzilla.redhat.com/show_bug.cgi?id=1372901
Signed-off-by: Laszlo Ersek <lersek@redhat.com>
Acked-by: Martin Kletzander <mkletzan@redhat.com>
2016-09-16 07:30:23 +00:00
|
|
|
QEMU_CAPS_DEVICE_PCI_BRIDGE, QEMU_CAPS_DEVICE_IOH3420,
|
2018-03-28 21:20:45 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
|
2018-08-09 11:26:17 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_GPU);
|
2017-08-27 15:04:42 +00:00
|
|
|
DO_TEST("aarch64-video-default",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_OBJECT_GPEX,
|
2017-08-27 15:04:42 +00:00
|
|
|
QEMU_CAPS_DEVICE_PCI_BRIDGE, QEMU_CAPS_DEVICE_IOH3420,
|
2018-03-28 21:20:45 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
|
2017-08-27 15:04:42 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_GPU, QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
|
|
|
|
QEMU_CAPS_VNC);
|
2015-02-25 14:12:31 +00:00
|
|
|
DO_TEST("aarch64-aavmf-virtio-mmio",
|
2015-11-06 14:28:57 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_MMIO,
|
2015-02-25 14:12:31 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_RNG, QEMU_CAPS_OBJECT_RNG_RANDOM);
|
2014-02-14 14:09:00 +00:00
|
|
|
DO_TEST("aarch64-virt-default-nic",
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_MMIO);
|
2019-11-26 17:51:22 +00:00
|
|
|
qemuTestSetHostArch(&driver, VIR_ARCH_AARCH64);
|
2016-01-13 00:26:40 +00:00
|
|
|
DO_TEST("aarch64-cpu-passthrough",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_MMIO,
|
2016-05-16 08:08:29 +00:00
|
|
|
QEMU_CAPS_KVM);
|
2016-05-10 10:36:10 +00:00
|
|
|
DO_TEST_GIC("aarch64-gic-none", GIC_NONE,
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_KVM,
|
2016-02-03 13:35:41 +00:00
|
|
|
QEMU_CAPS_MACH_VIRT_GIC_VERSION);
|
2016-05-10 10:36:10 +00:00
|
|
|
DO_TEST_GIC("aarch64-gic-none-v2", GIC_V2,
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_KVM,
|
2016-05-10 10:36:10 +00:00
|
|
|
QEMU_CAPS_MACH_VIRT_GIC_VERSION);
|
|
|
|
DO_TEST_GIC("aarch64-gic-none-v3", GIC_V3,
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_KVM,
|
2016-02-03 13:35:41 +00:00
|
|
|
QEMU_CAPS_MACH_VIRT_GIC_VERSION);
|
2016-05-10 10:36:10 +00:00
|
|
|
DO_TEST_GIC("aarch64-gic-none-both", GIC_BOTH,
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_KVM,
|
2016-05-10 10:36:10 +00:00
|
|
|
QEMU_CAPS_MACH_VIRT_GIC_VERSION);
|
2017-05-12 12:05:55 +00:00
|
|
|
DO_TEST_GIC("aarch64-gic-none-tcg", GIC_BOTH,
|
|
|
|
QEMU_CAPS_MACH_VIRT_GIC_VERSION);
|
2016-05-10 10:36:10 +00:00
|
|
|
DO_TEST_GIC("aarch64-gic-default", GIC_NONE,
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_KVM,
|
2016-05-10 10:36:10 +00:00
|
|
|
QEMU_CAPS_MACH_VIRT_GIC_VERSION);
|
2018-02-01 17:17:13 +00:00
|
|
|
DO_TEST_GIC("aarch64-gic-default-v2", GIC_V2,
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_KVM,
|
2015-09-30 11:04:11 +00:00
|
|
|
QEMU_CAPS_MACH_VIRT_GIC_VERSION);
|
2018-02-01 17:17:13 +00:00
|
|
|
DO_TEST_GIC("aarch64-gic-default-v3", GIC_V3,
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_KVM,
|
2016-05-10 10:36:10 +00:00
|
|
|
QEMU_CAPS_MACH_VIRT_GIC_VERSION);
|
2018-02-01 17:17:13 +00:00
|
|
|
DO_TEST_GIC("aarch64-gic-default-both", GIC_BOTH,
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_KVM,
|
2016-05-10 10:36:10 +00:00
|
|
|
QEMU_CAPS_MACH_VIRT_GIC_VERSION);
|
|
|
|
DO_TEST_GIC("aarch64-gic-v2", GIC_NONE,
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_KVM,
|
2016-05-10 10:36:10 +00:00
|
|
|
QEMU_CAPS_MACH_VIRT_GIC_VERSION);
|
|
|
|
DO_TEST_GIC("aarch64-gic-v2", GIC_V2,
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_KVM,
|
2016-05-10 10:36:10 +00:00
|
|
|
QEMU_CAPS_MACH_VIRT_GIC_VERSION);
|
|
|
|
DO_TEST_GIC("aarch64-gic-v2", GIC_V3,
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_KVM,
|
2016-02-03 15:58:20 +00:00
|
|
|
QEMU_CAPS_MACH_VIRT_GIC_VERSION);
|
2016-05-10 10:36:10 +00:00
|
|
|
DO_TEST_GIC("aarch64-gic-v2", GIC_BOTH,
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_KVM,
|
2016-05-10 10:36:10 +00:00
|
|
|
QEMU_CAPS_MACH_VIRT_GIC_VERSION);
|
2016-07-29 16:11:26 +00:00
|
|
|
DO_TEST_FAILURE("aarch64-gic-v3",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_KVM, NONE);
|
2016-05-10 10:36:10 +00:00
|
|
|
DO_TEST_GIC("aarch64-gic-v3", GIC_NONE,
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_KVM,
|
2016-05-10 10:36:10 +00:00
|
|
|
QEMU_CAPS_MACH_VIRT_GIC_VERSION);
|
|
|
|
DO_TEST_GIC("aarch64-gic-v3", GIC_V2,
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_KVM,
|
2016-05-10 10:36:10 +00:00
|
|
|
QEMU_CAPS_MACH_VIRT_GIC_VERSION);
|
|
|
|
DO_TEST_GIC("aarch64-gic-v3", GIC_V3,
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_KVM,
|
2016-05-10 10:36:10 +00:00
|
|
|
QEMU_CAPS_MACH_VIRT_GIC_VERSION);
|
|
|
|
DO_TEST_GIC("aarch64-gic-v3", GIC_BOTH,
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_KVM,
|
2016-02-03 13:35:41 +00:00
|
|
|
QEMU_CAPS_MACH_VIRT_GIC_VERSION);
|
2016-07-29 16:11:26 +00:00
|
|
|
DO_TEST_FAILURE("aarch64-gic-host",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_KVM, NONE);
|
2016-05-10 10:36:10 +00:00
|
|
|
DO_TEST_GIC("aarch64-gic-host", GIC_NONE,
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_KVM,
|
2016-05-10 10:36:10 +00:00
|
|
|
QEMU_CAPS_MACH_VIRT_GIC_VERSION);
|
|
|
|
DO_TEST_GIC("aarch64-gic-host", GIC_V2,
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_KVM,
|
2016-05-10 10:36:10 +00:00
|
|
|
QEMU_CAPS_MACH_VIRT_GIC_VERSION);
|
|
|
|
DO_TEST_GIC("aarch64-gic-host", GIC_V3,
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_KVM,
|
2016-05-10 10:36:10 +00:00
|
|
|
QEMU_CAPS_MACH_VIRT_GIC_VERSION);
|
|
|
|
DO_TEST_GIC("aarch64-gic-host", GIC_BOTH,
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_KVM,
|
2016-05-10 10:36:10 +00:00
|
|
|
QEMU_CAPS_MACH_VIRT_GIC_VERSION);
|
2016-07-29 16:11:26 +00:00
|
|
|
DO_TEST_PARSE_ERROR("aarch64-gic-invalid",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_KVM,
|
2016-02-03 13:35:41 +00:00
|
|
|
QEMU_CAPS_MACH_VIRT_GIC_VERSION);
|
2018-02-02 15:05:51 +00:00
|
|
|
DO_TEST_PARSE_ERROR("aarch64-gic-not-virt",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_KVM,
|
2018-02-02 15:05:51 +00:00
|
|
|
QEMU_CAPS_MACH_VIRT_GIC_VERSION);
|
|
|
|
DO_TEST_PARSE_ERROR("aarch64-gic-not-arm",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_KVM,
|
2018-02-02 15:05:51 +00:00
|
|
|
QEMU_CAPS_MACH_VIRT_GIC_VERSION);
|
2016-01-13 00:26:40 +00:00
|
|
|
DO_TEST("aarch64-kvm-32-on-64",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_MMIO,
|
2017-11-28 10:34:55 +00:00
|
|
|
QEMU_CAPS_DEVICE_PL011,
|
2016-05-16 08:08:29 +00:00
|
|
|
QEMU_CAPS_KVM, QEMU_CAPS_CPU_AARCH64_OFF);
|
2020-10-10 14:39:20 +00:00
|
|
|
DO_TEST_PARSE_ERROR("aarch64-kvm-32-on-64",
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_MMIO,
|
|
|
|
QEMU_CAPS_KVM);
|
2017-06-26 16:10:49 +00:00
|
|
|
DO_TEST("aarch64-pci-serial",
|
|
|
|
QEMU_CAPS_DEVICE_PCI_SERIAL,
|
|
|
|
QEMU_CAPS_CHARDEV_LOGFILE,
|
|
|
|
QEMU_CAPS_OBJECT_GPEX,
|
|
|
|
QEMU_CAPS_DEVICE_PCI_BRIDGE,
|
|
|
|
QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
|
|
|
|
QEMU_CAPS_DEVICE_PCIE_ROOT_PORT);
|
2018-01-09 17:42:51 +00:00
|
|
|
DO_TEST("aarch64-traditional-pci",
|
|
|
|
QEMU_CAPS_OBJECT_GPEX,
|
|
|
|
QEMU_CAPS_DEVICE_PCIE_ROOT_PORT,
|
|
|
|
QEMU_CAPS_DEVICE_DMI_TO_PCI_BRIDGE,
|
2018-03-28 10:48:38 +00:00
|
|
|
QEMU_CAPS_DEVICE_PCIE_PCI_BRIDGE,
|
2018-01-09 17:42:51 +00:00
|
|
|
QEMU_CAPS_DEVICE_PCI_BRIDGE,
|
|
|
|
QEMU_CAPS_DEVICE_PCI_SERIAL);
|
2017-03-09 15:38:56 +00:00
|
|
|
|
|
|
|
/* Make sure all combinations of ACPI and UEFI behave as expected */
|
|
|
|
DO_TEST("aarch64-acpi-uefi", NONE);
|
|
|
|
DO_TEST("aarch64-noacpi-uefi", NONE);
|
|
|
|
DO_TEST("aarch64-noacpi-nouefi", NONE);
|
|
|
|
DO_TEST_PARSE_ERROR("aarch64-acpi-nouefi", NONE);
|
|
|
|
|
2019-06-24 13:22:24 +00:00
|
|
|
/* QEMU 4.0.0 didn't have support for aarch64 CPU features */
|
|
|
|
DO_TEST_CAPS_ARCH_VER_FAILURE("aarch64-features-sve", "aarch64", "4.0.0");
|
|
|
|
/* aarch64 doesn't support the same CPU features as x86 */
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FAILURE("aarch64-features-wrong", "aarch64");
|
|
|
|
/* Can't enable vector lengths when SVE is overall disabled */
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("aarch64-features-sve-disabled", "aarch64");
|
|
|
|
/* SVE aarch64 CPU features work on modern QEMU */
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("aarch64-features-sve", "aarch64");
|
|
|
|
|
2020-02-07 12:11:42 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("clock-timer-armvtimer", "aarch64");
|
|
|
|
|
2019-11-26 17:51:22 +00:00
|
|
|
qemuTestSetHostArch(&driver, VIR_ARCH_NONE);
|
2015-05-21 22:18:20 +00:00
|
|
|
|
2016-12-09 14:28:04 +00:00
|
|
|
DO_TEST("kvm-pit-delay", QEMU_CAPS_KVM_PIT_TICK_POLICY);
|
2016-12-09 14:28:05 +00:00
|
|
|
DO_TEST("kvm-pit-discard", QEMU_CAPS_KVM_PIT_TICK_POLICY);
|
2013-07-01 16:28:50 +00:00
|
|
|
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST("panic",
|
|
|
|
QEMU_CAPS_DEVICE_PANIC);
|
|
|
|
DO_TEST("panic-double",
|
|
|
|
QEMU_CAPS_DEVICE_PANIC);
|
2013-12-09 09:11:15 +00:00
|
|
|
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST("panic-no-address",
|
|
|
|
QEMU_CAPS_DEVICE_PANIC);
|
2015-02-26 14:28:07 +00:00
|
|
|
|
2020-10-21 08:08:11 +00:00
|
|
|
DO_TEST_CAPS_ARCH_VER_FULL("fips-enabled", "x86_64", "5.1.0", ARG_FLAGS, FLAG_FIPS_HOST);
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL("fips-enabled", "x86_64", ARG_FLAGS, FLAG_FIPS_HOST);
|
2014-09-18 15:38:32 +00:00
|
|
|
|
2016-05-20 12:41:49 +00:00
|
|
|
DO_TEST("shmem", QEMU_CAPS_DEVICE_IVSHMEM);
|
2016-08-10 09:15:22 +00:00
|
|
|
DO_TEST("shmem-plain-doorbell", QEMU_CAPS_DEVICE_IVSHMEM,
|
|
|
|
QEMU_CAPS_DEVICE_IVSHMEM_PLAIN,
|
|
|
|
QEMU_CAPS_DEVICE_IVSHMEM_DOORBELL);
|
2020-10-13 18:12:59 +00:00
|
|
|
DO_TEST_PARSE_ERROR("shmem", NONE);
|
2016-05-20 12:41:49 +00:00
|
|
|
DO_TEST_FAILURE("shmem-invalid-size",
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_DEVICE_IVSHMEM);
|
2016-05-20 12:41:49 +00:00
|
|
|
DO_TEST_FAILURE("shmem-invalid-address",
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_DEVICE_IVSHMEM);
|
2016-05-20 12:41:49 +00:00
|
|
|
DO_TEST_FAILURE("shmem-small-size",
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_DEVICE_IVSHMEM);
|
2014-09-22 08:49:39 +00:00
|
|
|
DO_TEST_PARSE_ERROR("shmem-msi-only", NONE);
|
2016-05-16 08:08:29 +00:00
|
|
|
DO_TEST("cpu-host-passthrough-features", QEMU_CAPS_KVM);
|
2014-09-22 08:49:39 +00:00
|
|
|
|
2015-12-01 13:08:37 +00:00
|
|
|
DO_TEST_FAILURE("memory-align-fail", NONE);
|
2020-07-28 08:51:32 +00:00
|
|
|
DO_TEST_PARSE_ERROR("memory-hotplug-nonuma", QEMU_CAPS_DEVICE_PC_DIMM);
|
2016-07-29 09:02:25 +00:00
|
|
|
DO_TEST("memory-hotplug", NONE);
|
2014-10-06 12:18:37 +00:00
|
|
|
DO_TEST("memory-hotplug", QEMU_CAPS_DEVICE_PC_DIMM, QEMU_CAPS_NUMA);
|
2015-01-09 09:40:37 +00:00
|
|
|
DO_TEST("memory-hotplug-dimm", QEMU_CAPS_DEVICE_PC_DIMM, QEMU_CAPS_NUMA,
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_OBJECT_MEMORY_RAM, QEMU_CAPS_OBJECT_MEMORY_FILE);
|
2015-03-26 06:30:56 +00:00
|
|
|
DO_TEST("memory-hotplug-dimm-addr", QEMU_CAPS_DEVICE_PC_DIMM, QEMU_CAPS_NUMA,
|
2016-10-13 12:55:47 +00:00
|
|
|
QEMU_CAPS_OBJECT_MEMORY_RAM, QEMU_CAPS_OBJECT_MEMORY_FILE);
|
2015-10-13 17:12:23 +00:00
|
|
|
DO_TEST("memory-hotplug-ppc64-nonuma", QEMU_CAPS_KVM, QEMU_CAPS_DEVICE_PC_DIMM, QEMU_CAPS_NUMA,
|
2018-02-21 09:18:19 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_OBJECT_MEMORY_RAM, QEMU_CAPS_OBJECT_MEMORY_FILE);
|
2018-12-20 09:14:46 +00:00
|
|
|
DO_TEST_CAPS_LATEST("memory-hotplug-nvdimm");
|
|
|
|
DO_TEST_CAPS_LATEST("memory-hotplug-nvdimm-access");
|
|
|
|
DO_TEST_CAPS_LATEST("memory-hotplug-nvdimm-label");
|
2018-12-20 09:14:47 +00:00
|
|
|
DO_TEST_CAPS_LATEST("memory-hotplug-nvdimm-align");
|
2018-12-20 09:14:48 +00:00
|
|
|
DO_TEST_CAPS_LATEST("memory-hotplug-nvdimm-pmem");
|
2018-12-20 09:14:49 +00:00
|
|
|
DO_TEST_CAPS_LATEST("memory-hotplug-nvdimm-readonly");
|
2020-03-23 19:40:49 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("memory-hotplug-nvdimm-ppc64", "ppc64");
|
2014-10-06 12:18:37 +00:00
|
|
|
|
2015-04-27 21:57:30 +00:00
|
|
|
DO_TEST("machine-aeskeywrap-on-caps",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_AES_KEY_WRAP,
|
2015-11-06 14:28:57 +00:00
|
|
|
QEMU_CAPS_DEA_KEY_WRAP,
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_VIRTIO_SCSI,
|
2018-05-07 14:41:11 +00:00
|
|
|
QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST_FAILURE("machine-aeskeywrap-on-caps",
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_VIRTIO_SCSI,
|
2018-05-07 14:41:11 +00:00
|
|
|
QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
|
2015-04-27 21:57:30 +00:00
|
|
|
DO_TEST_FAILURE("machine-aeskeywrap-on-caps", NONE);
|
|
|
|
|
|
|
|
DO_TEST("machine-aeskeywrap-on-cap",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_AES_KEY_WRAP,
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_VIRTIO_SCSI,
|
2018-05-07 14:41:11 +00:00
|
|
|
QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST_FAILURE("machine-aeskeywrap-on-cap",
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_VIRTIO_SCSI,
|
2018-05-07 14:41:11 +00:00
|
|
|
QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
|
2015-04-27 21:57:30 +00:00
|
|
|
DO_TEST_FAILURE("machine-aeskeywrap-on-cap", NONE);
|
|
|
|
|
|
|
|
DO_TEST("machine-aeskeywrap-off-caps",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_AES_KEY_WRAP, QEMU_CAPS_DEA_KEY_WRAP,
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_VIRTIO_SCSI,
|
2018-05-07 14:41:11 +00:00
|
|
|
QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST_FAILURE("machine-aeskeywrap-off-caps",
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_VIRTIO_SCSI,
|
2018-05-07 14:41:11 +00:00
|
|
|
QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
|
2015-04-27 21:57:30 +00:00
|
|
|
DO_TEST_FAILURE("machine-aeskeywrap-off-caps", NONE);
|
|
|
|
|
|
|
|
DO_TEST("machine-aeskeywrap-off-cap",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_AES_KEY_WRAP,
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_VIRTIO_SCSI,
|
2018-05-07 14:41:11 +00:00
|
|
|
QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST_FAILURE("machine-aeskeywrap-off-cap",
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_VIRTIO_SCSI,
|
2018-05-07 14:41:11 +00:00
|
|
|
QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
|
2015-04-27 21:57:30 +00:00
|
|
|
DO_TEST_FAILURE("machine-aeskeywrap-off-cap", NONE);
|
|
|
|
|
|
|
|
DO_TEST("machine-deakeywrap-on-caps",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_AES_KEY_WRAP, QEMU_CAPS_DEA_KEY_WRAP,
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_VIRTIO_SCSI,
|
2018-05-07 14:41:11 +00:00
|
|
|
QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST_FAILURE("machine-deakeywrap-on-caps",
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_VIRTIO_SCSI,
|
2018-05-07 14:41:11 +00:00
|
|
|
QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
|
2015-04-27 21:57:30 +00:00
|
|
|
DO_TEST_FAILURE("machine-deakeywrap-on-caps", NONE);
|
|
|
|
|
|
|
|
DO_TEST("machine-deakeywrap-on-cap",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_DEA_KEY_WRAP,
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_VIRTIO_SCSI,
|
2018-05-07 14:41:11 +00:00
|
|
|
QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST_FAILURE("machine-deakeywrap-on-cap",
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_VIRTIO_SCSI,
|
2018-05-07 14:41:11 +00:00
|
|
|
QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
|
2015-04-27 21:57:30 +00:00
|
|
|
DO_TEST_FAILURE("machine-deakeywrap-on-cap", NONE);
|
|
|
|
|
|
|
|
DO_TEST("machine-deakeywrap-off-caps",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_AES_KEY_WRAP, QEMU_CAPS_DEA_KEY_WRAP,
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_VIRTIO_SCSI,
|
2018-05-07 14:41:11 +00:00
|
|
|
QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST_FAILURE("machine-deakeywrap-off-caps",
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_VIRTIO_SCSI,
|
2018-05-07 14:41:11 +00:00
|
|
|
QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
|
2015-04-27 21:57:30 +00:00
|
|
|
DO_TEST_FAILURE("machine-deakeywrap-off-caps", NONE);
|
|
|
|
|
|
|
|
DO_TEST("machine-deakeywrap-off-cap",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_DEA_KEY_WRAP,
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_VIRTIO_SCSI,
|
2018-05-07 14:41:11 +00:00
|
|
|
QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST_FAILURE("machine-deakeywrap-off-cap",
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_VIRTIO_SCSI,
|
2018-05-07 14:41:11 +00:00
|
|
|
QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
|
2015-04-27 21:57:30 +00:00
|
|
|
DO_TEST_FAILURE("machine-deakeywrap-off-cap", NONE);
|
|
|
|
|
|
|
|
DO_TEST("machine-keywrap-none-caps",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_AES_KEY_WRAP, QEMU_CAPS_DEA_KEY_WRAP,
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_VIRTIO_SCSI,
|
2018-05-07 14:41:11 +00:00
|
|
|
QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
|
2015-04-27 21:57:30 +00:00
|
|
|
DO_TEST("machine-keywrap-none",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_VIRTIO_SCSI,
|
2018-05-07 14:41:11 +00:00
|
|
|
QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390);
|
2015-04-27 21:57:30 +00:00
|
|
|
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST("machine-loadparm-s390",
|
2018-05-07 14:41:11 +00:00
|
|
|
QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390,
|
2018-08-09 11:26:17 +00:00
|
|
|
QEMU_CAPS_LOADPARM);
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST("machine-loadparm-net-s390",
|
2018-05-07 14:41:11 +00:00
|
|
|
QEMU_CAPS_CCW, QEMU_CAPS_VIRTIO_S390,
|
2018-08-09 11:26:17 +00:00
|
|
|
QEMU_CAPS_LOADPARM);
|
2017-06-01 16:36:25 +00:00
|
|
|
DO_TEST("machine-loadparm-multiple-disks-nets-s390",
|
2018-05-07 14:41:11 +00:00
|
|
|
QEMU_CAPS_CCW,
|
2018-08-09 11:26:17 +00:00
|
|
|
QEMU_CAPS_VIRTIO_S390,
|
2017-06-01 16:36:25 +00:00
|
|
|
QEMU_CAPS_LOADPARM);
|
|
|
|
DO_TEST_PARSE_ERROR("machine-loadparm-s390-char-invalid",
|
2018-05-07 14:41:11 +00:00
|
|
|
QEMU_CAPS_CCW,
|
2018-08-09 11:26:17 +00:00
|
|
|
QEMU_CAPS_VIRTIO_S390,
|
2017-06-01 16:36:25 +00:00
|
|
|
QEMU_CAPS_LOADPARM);
|
|
|
|
DO_TEST_PARSE_ERROR("machine-loadparm-s390-len-invalid",
|
2018-05-07 14:41:11 +00:00
|
|
|
QEMU_CAPS_CCW,
|
2018-08-09 11:26:17 +00:00
|
|
|
QEMU_CAPS_VIRTIO_S390,
|
2017-06-01 16:36:25 +00:00
|
|
|
QEMU_CAPS_LOADPARM);
|
|
|
|
|
2015-10-20 14:01:01 +00:00
|
|
|
DO_TEST("qemu-ns-domain-ns0", NONE);
|
|
|
|
DO_TEST("qemu-ns-domain-commandline", NONE);
|
|
|
|
DO_TEST("qemu-ns-domain-commandline-ns0", NONE);
|
|
|
|
DO_TEST("qemu-ns-commandline", NONE);
|
|
|
|
DO_TEST("qemu-ns-commandline-ns0", NONE);
|
|
|
|
DO_TEST("qemu-ns-commandline-ns1", NONE);
|
|
|
|
|
2016-01-13 00:26:40 +00:00
|
|
|
DO_TEST("virtio-input", QEMU_CAPS_VIRTIO_KEYBOARD,
|
2015-11-13 10:38:07 +00:00
|
|
|
QEMU_CAPS_VIRTIO_MOUSE, QEMU_CAPS_VIRTIO_TABLET);
|
2016-01-13 00:26:40 +00:00
|
|
|
DO_TEST("virtio-input-passthrough", QEMU_CAPS_VIRTIO_INPUT_HOST);
|
2015-11-13 10:38:07 +00:00
|
|
|
|
2016-01-07 15:14:58 +00:00
|
|
|
DO_TEST("ppc64-usb-controller",
|
2018-02-21 09:18:19 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_PCI_OHCI);
|
2016-01-07 15:14:58 +00:00
|
|
|
DO_TEST("ppc64-usb-controller-legacy",
|
2018-02-21 09:18:19 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
2016-01-13 00:26:40 +00:00
|
|
|
QEMU_CAPS_PIIX3_USB_UHCI);
|
2019-03-13 20:04:44 +00:00
|
|
|
DO_TEST_FULL("ppc64-usb-controller-qemu-xhci",
|
2019-03-13 20:17:10 +00:00
|
|
|
ARG_PARSEFLAGS, VIR_DOMAIN_DEF_PARSE_ABI_UPDATE,
|
2019-03-13 19:18:11 +00:00
|
|
|
ARG_QEMU_CAPS,
|
2018-02-21 09:18:19 +00:00
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
2017-04-27 15:56:41 +00:00
|
|
|
QEMU_CAPS_NEC_USB_XHCI,
|
|
|
|
QEMU_CAPS_DEVICE_QEMU_XHCI);
|
|
|
|
|
2020-06-10 18:11:49 +00:00
|
|
|
DO_TEST_PARSE_ERROR("ppc64-tpmproxy-double",
|
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
|
|
|
QEMU_CAPS_PCI_OHCI,
|
|
|
|
QEMU_CAPS_DEVICE_TPM_PASSTHROUGH,
|
|
|
|
QEMU_CAPS_DEVICE_SPAPR_TPM_PROXY);
|
|
|
|
|
|
|
|
DO_TEST_PARSE_ERROR("ppc64-tpm-double",
|
|
|
|
QEMU_CAPS_DEVICE_SPAPR_PCI_HOST_BRIDGE,
|
|
|
|
QEMU_CAPS_PCI_OHCI,
|
|
|
|
QEMU_CAPS_DEVICE_TPM_PASSTHROUGH,
|
|
|
|
QEMU_CAPS_DEVICE_SPAPR_TPM_PROXY);
|
|
|
|
|
2020-06-10 18:11:51 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PPC64("ppc64-tpmproxy-single");
|
|
|
|
DO_TEST_CAPS_LATEST_PPC64("ppc64-tpmproxy-with-tpm");
|
|
|
|
|
2017-04-27 15:56:41 +00:00
|
|
|
DO_TEST("aarch64-usb-controller-qemu-xhci",
|
|
|
|
QEMU_CAPS_OBJECT_GPEX,
|
|
|
|
QEMU_CAPS_NEC_USB_XHCI,
|
|
|
|
QEMU_CAPS_DEVICE_QEMU_XHCI);
|
2016-01-07 15:14:58 +00:00
|
|
|
|
2017-04-27 15:53:51 +00:00
|
|
|
DO_TEST("aarch64-usb-controller-nec-xhci",
|
|
|
|
QEMU_CAPS_OBJECT_GPEX,
|
|
|
|
QEMU_CAPS_NEC_USB_XHCI);
|
|
|
|
|
2018-07-24 20:54:51 +00:00
|
|
|
/* VM XML has invalid arch/ostype/virttype combo, but the SKIP flag
|
2019-12-11 11:55:23 +00:00
|
|
|
* will avoid the error during parse. This will cause us to fill in
|
|
|
|
* the missing machine type using the i386 binary, despite it being
|
|
|
|
* the wrong binary for the arch. We expect to get a failure about
|
|
|
|
* bad arch later when creating the pretend command.
|
|
|
|
*/
|
2019-03-13 21:25:23 +00:00
|
|
|
DO_TEST_FULL("missing-machine",
|
2019-12-11 11:55:23 +00:00
|
|
|
ARG_FLAGS, FLAG_EXPECT_FAILURE,
|
2019-03-13 21:25:23 +00:00
|
|
|
ARG_PARSEFLAGS, VIR_DOMAIN_DEF_PARSE_SKIP_VALIDATE,
|
|
|
|
ARG_QEMU_CAPS, NONE);
|
2016-02-25 15:21:41 +00:00
|
|
|
|
2017-06-26 17:13:00 +00:00
|
|
|
DO_TEST("name-escape",
|
|
|
|
QEMU_CAPS_NAME_DEBUG_THREADS,
|
|
|
|
QEMU_CAPS_OBJECT_SECRET,
|
2018-06-19 16:20:18 +00:00
|
|
|
QEMU_CAPS_DRIVE_IOTUNE_MAX,
|
|
|
|
QEMU_CAPS_DRIVE_IOTUNE_GROUP,
|
2017-06-26 17:13:00 +00:00
|
|
|
QEMU_CAPS_VNC,
|
|
|
|
QEMU_CAPS_NAME_GUEST,
|
|
|
|
QEMU_CAPS_DEVICE_CIRRUS_VGA,
|
|
|
|
QEMU_CAPS_SPICE,
|
2018-06-18 17:57:23 +00:00
|
|
|
QEMU_CAPS_SPICE_UNIX,
|
2018-06-18 17:57:26 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_GPU,
|
|
|
|
QEMU_CAPS_VIRTIO_GPU_VIRGL,
|
|
|
|
QEMU_CAPS_SPICE_GL,
|
|
|
|
QEMU_CAPS_SPICE_RENDERNODE,
|
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
|
2018-06-18 17:57:24 +00:00
|
|
|
QEMU_CAPS_DEVICE_ISA_SERIAL,
|
2018-06-18 17:57:25 +00:00
|
|
|
QEMU_CAPS_CHARDEV_FILE_APPEND,
|
2018-06-20 13:17:00 +00:00
|
|
|
QEMU_CAPS_CCID_EMULATED,
|
2018-09-18 10:29:10 +00:00
|
|
|
QEMU_CAPS_VIRTIO_SCSI);
|
2016-03-10 19:46:39 +00:00
|
|
|
DO_TEST("debug-threads", QEMU_CAPS_NAME_DEBUG_THREADS);
|
|
|
|
|
2016-03-29 22:23:02 +00:00
|
|
|
DO_TEST("master-key", QEMU_CAPS_OBJECT_SECRET);
|
2018-03-29 10:51:55 +00:00
|
|
|
DO_TEST("usb-long-port-path",
|
2016-04-20 13:03:57 +00:00
|
|
|
QEMU_CAPS_USB_HUB);
|
2016-07-29 11:54:13 +00:00
|
|
|
DO_TEST_PARSE_ERROR("usb-too-long-port-path-invalid",
|
2018-03-29 10:51:55 +00:00
|
|
|
QEMU_CAPS_USB_HUB);
|
2016-03-29 22:23:02 +00:00
|
|
|
|
2016-05-12 11:21:01 +00:00
|
|
|
DO_TEST("acpi-table", NONE);
|
2019-05-17 12:45:36 +00:00
|
|
|
|
|
|
|
DO_TEST_CAPS_LATEST("intel-iommu");
|
|
|
|
DO_TEST_CAPS_VER("intel-iommu", "2.6.0");
|
|
|
|
DO_TEST_CAPS_LATEST("intel-iommu-caching-mode");
|
|
|
|
DO_TEST_CAPS_LATEST("intel-iommu-eim");
|
|
|
|
DO_TEST_CAPS_LATEST("intel-iommu-device-iotlb");
|
2020-06-04 07:42:43 +00:00
|
|
|
DO_TEST_CAPS_LATEST("intel-iommu-aw-bits");
|
2019-07-02 14:36:55 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("intel-iommu-wrong-machine");
|
2019-05-17 11:23:16 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("iommu-smmuv3", "aarch64");
|
2016-05-12 11:21:01 +00:00
|
|
|
|
2016-08-04 12:36:24 +00:00
|
|
|
DO_TEST("cpu-hotplug-startup", QEMU_CAPS_QUERY_HOTPLUGGABLE_CPUS);
|
2017-12-14 14:54:59 +00:00
|
|
|
DO_TEST_PARSE_ERROR("cpu-hotplug-granularity",
|
|
|
|
QEMU_CAPS_QUERY_HOTPLUGGABLE_CPUS);
|
|
|
|
|
2020-04-23 13:15:06 +00:00
|
|
|
DO_TEST_CAPS_LATEST("virtio-options");
|
2020-04-23 13:15:07 +00:00
|
|
|
DO_TEST_CAPS_LATEST("virtio-options-controller-iommu");
|
|
|
|
DO_TEST_CAPS_LATEST("virtio-options-disk-iommu");
|
|
|
|
DO_TEST_CAPS_LATEST("virtio-options-fs-iommu");
|
|
|
|
DO_TEST_CAPS_LATEST("virtio-options-input-iommu");
|
|
|
|
DO_TEST_CAPS_LATEST("virtio-options-memballoon-iommu");
|
|
|
|
DO_TEST_CAPS_LATEST("virtio-options-net-iommu");
|
|
|
|
DO_TEST_CAPS_LATEST("virtio-options-rng-iommu");
|
|
|
|
DO_TEST_CAPS_LATEST("virtio-options-video-iommu");
|
|
|
|
DO_TEST_CAPS_LATEST("virtio-options-controller-ats");
|
|
|
|
DO_TEST_CAPS_LATEST("virtio-options-disk-ats");
|
|
|
|
DO_TEST_CAPS_LATEST("virtio-options-fs-ats");
|
|
|
|
DO_TEST_CAPS_LATEST("virtio-options-input-ats");
|
|
|
|
DO_TEST_CAPS_LATEST("virtio-options-memballoon-ats");
|
|
|
|
DO_TEST_CAPS_LATEST("virtio-options-net-ats");
|
|
|
|
DO_TEST_CAPS_LATEST("virtio-options-rng-ats");
|
|
|
|
DO_TEST_CAPS_LATEST("virtio-options-video-ats");
|
|
|
|
DO_TEST_CAPS_LATEST("virtio-options-controller-packed");
|
|
|
|
DO_TEST_CAPS_LATEST("virtio-options-disk-packed");
|
|
|
|
DO_TEST_CAPS_LATEST("virtio-options-fs-packed");
|
|
|
|
DO_TEST_CAPS_LATEST("virtio-options-input-packed");
|
|
|
|
DO_TEST_CAPS_LATEST("virtio-options-memballoon-packed");
|
2020-10-12 23:35:39 +00:00
|
|
|
DO_TEST_CAPS_LATEST("virtio-options-memballoon-freepage-reporting");
|
2020-04-23 13:15:07 +00:00
|
|
|
DO_TEST_CAPS_LATEST("virtio-options-net-packed");
|
|
|
|
DO_TEST_CAPS_LATEST("virtio-options-rng-packed");
|
|
|
|
DO_TEST_CAPS_LATEST("virtio-options-video-packed");
|
2020-04-23 13:15:08 +00:00
|
|
|
DO_TEST_PARSE_ERROR("virtio-options-controller-iommu", QEMU_CAPS_VIRTIO_SCSI);
|
|
|
|
DO_TEST_PARSE_ERROR("virtio-options-disk-iommu", NONE);
|
|
|
|
DO_TEST_PARSE_ERROR("virtio-options-fs-iommu", NONE);
|
|
|
|
DO_TEST_PARSE_ERROR("virtio-options-input-iommu", QEMU_CAPS_VIRTIO_MOUSE,
|
|
|
|
QEMU_CAPS_VIRTIO_KEYBOARD);
|
|
|
|
DO_TEST_PARSE_ERROR("virtio-options-net-iommu", NONE);
|
|
|
|
DO_TEST_PARSE_ERROR("virtio-options-memballoon-iommu", NONE);
|
|
|
|
DO_TEST_PARSE_ERROR("virtio-options-rng-iommu", QEMU_CAPS_DEVICE_VIRTIO_RNG,
|
|
|
|
QEMU_CAPS_OBJECT_RNG_RANDOM);
|
|
|
|
DO_TEST_PARSE_ERROR("virtio-options-video-iommu", QEMU_CAPS_DEVICE_VIRTIO_GPU,
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_GPU,
|
|
|
|
QEMU_CAPS_VIRTIO_GPU_VIRGL,
|
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
|
|
|
|
QEMU_CAPS_DEVICE_VHOST_USER_GPU);
|
|
|
|
DO_TEST_PARSE_ERROR("virtio-options-controller-ats", QEMU_CAPS_VIRTIO_SCSI);
|
|
|
|
DO_TEST_PARSE_ERROR("virtio-options-disk-ats", NONE);
|
|
|
|
DO_TEST_PARSE_ERROR("virtio-options-fs-ats", NONE);
|
|
|
|
DO_TEST_PARSE_ERROR("virtio-options-input-ats", QEMU_CAPS_VIRTIO_MOUSE,
|
|
|
|
QEMU_CAPS_VIRTIO_KEYBOARD);
|
|
|
|
DO_TEST_PARSE_ERROR("virtio-options-memballoon-ats", NONE);
|
|
|
|
DO_TEST_PARSE_ERROR("virtio-options-net-ats", NONE);
|
|
|
|
DO_TEST_PARSE_ERROR("virtio-options-rng-ats", QEMU_CAPS_DEVICE_VIRTIO_RNG,
|
|
|
|
QEMU_CAPS_OBJECT_RNG_RANDOM);
|
|
|
|
DO_TEST_PARSE_ERROR("virtio-options-video-ats", QEMU_CAPS_DEVICE_VIRTIO_GPU,
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_GPU,
|
|
|
|
QEMU_CAPS_VIRTIO_GPU_VIRGL,
|
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
|
|
|
|
QEMU_CAPS_DEVICE_VHOST_USER_GPU);
|
|
|
|
DO_TEST_PARSE_ERROR("virtio-options-controller-packed", QEMU_CAPS_VIRTIO_SCSI);
|
|
|
|
DO_TEST_PARSE_ERROR("virtio-options-disk-packed", NONE);
|
|
|
|
DO_TEST_PARSE_ERROR("virtio-options-fs-packed", NONE);
|
|
|
|
DO_TEST_PARSE_ERROR("virtio-options-input-packed", QEMU_CAPS_VIRTIO_MOUSE,
|
|
|
|
QEMU_CAPS_VIRTIO_KEYBOARD);
|
|
|
|
DO_TEST_PARSE_ERROR("virtio-options-memballoon-packed", NONE);
|
2020-10-12 23:35:39 +00:00
|
|
|
DO_TEST_PARSE_ERROR("virtio-options-memballoon-freepage-reporting", NONE);
|
2020-04-23 13:15:08 +00:00
|
|
|
DO_TEST_PARSE_ERROR("virtio-options-net-packed", NONE);
|
|
|
|
DO_TEST_PARSE_ERROR("virtio-options-rng-packed", QEMU_CAPS_DEVICE_VIRTIO_RNG,
|
|
|
|
QEMU_CAPS_OBJECT_RNG_RANDOM);
|
|
|
|
DO_TEST_PARSE_ERROR("virtio-options-video-packed", QEMU_CAPS_DEVICE_VIRTIO_GPU,
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_GPU,
|
|
|
|
QEMU_CAPS_VIRTIO_GPU_VIRGL,
|
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
|
|
|
|
QEMU_CAPS_DEVICE_VHOST_USER_GPU);
|
2016-08-04 12:36:24 +00:00
|
|
|
|
2018-03-29 10:46:23 +00:00
|
|
|
DO_TEST("fd-memory-numa-topology", QEMU_CAPS_OBJECT_MEMORY_FILE,
|
2017-02-02 13:27:33 +00:00
|
|
|
QEMU_CAPS_KVM);
|
2018-03-29 10:46:23 +00:00
|
|
|
DO_TEST("fd-memory-numa-topology2", QEMU_CAPS_OBJECT_MEMORY_FILE,
|
2017-02-02 13:27:33 +00:00
|
|
|
QEMU_CAPS_KVM);
|
2018-03-29 10:46:23 +00:00
|
|
|
DO_TEST("fd-memory-numa-topology3", QEMU_CAPS_OBJECT_MEMORY_FILE,
|
2017-02-02 13:27:33 +00:00
|
|
|
QEMU_CAPS_KVM);
|
|
|
|
|
2018-03-29 10:46:23 +00:00
|
|
|
DO_TEST("fd-memory-no-numa-topology", QEMU_CAPS_OBJECT_MEMORY_FILE,
|
2017-02-02 13:27:33 +00:00
|
|
|
QEMU_CAPS_KVM);
|
|
|
|
|
2018-11-15 11:55:53 +00:00
|
|
|
DO_TEST_CAPS_LATEST("memfd-memory-numa");
|
2019-03-29 15:21:28 +00:00
|
|
|
DO_TEST_CAPS_LATEST("memfd-memory-default-hugepage");
|
2018-11-15 11:55:53 +00:00
|
|
|
|
2017-03-01 15:12:07 +00:00
|
|
|
DO_TEST("cpu-check-none", QEMU_CAPS_KVM);
|
|
|
|
DO_TEST("cpu-check-partial", QEMU_CAPS_KVM);
|
|
|
|
DO_TEST("cpu-check-full", QEMU_CAPS_KVM);
|
|
|
|
DO_TEST("cpu-check-default-none", QEMU_CAPS_KVM);
|
|
|
|
DO_TEST("cpu-check-default-none2", NONE);
|
|
|
|
DO_TEST("cpu-check-default-partial", QEMU_CAPS_KVM);
|
|
|
|
DO_TEST("cpu-check-default-partial2", QEMU_CAPS_KVM);
|
|
|
|
|
2017-04-25 17:07:19 +00:00
|
|
|
DO_TEST("cpu-cache-disable", QEMU_CAPS_KVM, QEMU_CAPS_CPU_CACHE);
|
|
|
|
DO_TEST("cpu-cache-disable2", QEMU_CAPS_KVM);
|
|
|
|
DO_TEST("cpu-cache-disable3", QEMU_CAPS_KVM, QEMU_CAPS_CPU_CACHE);
|
|
|
|
DO_TEST("cpu-cache-passthrough", QEMU_CAPS_KVM, QEMU_CAPS_CPU_CACHE);
|
|
|
|
DO_TEST("cpu-cache-passthrough2", QEMU_CAPS_KVM);
|
|
|
|
DO_TEST("cpu-cache-emulate-l3", QEMU_CAPS_KVM, QEMU_CAPS_CPU_CACHE);
|
|
|
|
DO_TEST_PARSE_ERROR("cpu-cache-emulate-l2", QEMU_CAPS_KVM);
|
|
|
|
DO_TEST_PARSE_ERROR("cpu-cache-passthrough3", QEMU_CAPS_KVM);
|
|
|
|
DO_TEST_PARSE_ERROR("cpu-cache-passthrough-l3", QEMU_CAPS_KVM);
|
2017-11-16 16:49:38 +00:00
|
|
|
DO_TEST("vmcoreinfo", QEMU_CAPS_DEVICE_VMCOREINFO);
|
2017-04-25 17:07:19 +00:00
|
|
|
|
2017-10-20 14:48:14 +00:00
|
|
|
DO_TEST("user-aliases", QEMU_CAPS_KVM, QEMU_CAPS_DEVICE_CIRRUS_VGA,
|
|
|
|
QEMU_CAPS_OBJECT_MEMORY_FILE, QEMU_CAPS_PIIX_DISABLE_S3,
|
|
|
|
QEMU_CAPS_PIIX_DISABLE_S4, QEMU_CAPS_VNC,
|
2017-11-26 16:35:28 +00:00
|
|
|
QEMU_CAPS_DEVICE_ISA_SERIAL,
|
2018-03-23 13:24:14 +00:00
|
|
|
QEMU_CAPS_HDA_DUPLEX,
|
2018-05-23 14:00:33 +00:00
|
|
|
QEMU_CAPS_CCID_EMULATED,
|
|
|
|
QEMU_CAPS_QCOW2_LUKS, QEMU_CAPS_OBJECT_SECRET);
|
2017-11-15 14:18:43 +00:00
|
|
|
DO_TEST("user-aliases2", QEMU_CAPS_DEVICE_IOH3420, QEMU_CAPS_ICH9_AHCI);
|
2018-03-16 14:53:32 +00:00
|
|
|
DO_TEST("user-aliases-usb", QEMU_CAPS_KVM,
|
|
|
|
QEMU_CAPS_PIIX_DISABLE_S3, QEMU_CAPS_PIIX_DISABLE_S4,
|
2018-03-28 21:20:45 +00:00
|
|
|
QEMU_CAPS_ICH9_USB_EHCI1);
|
2017-10-20 14:48:14 +00:00
|
|
|
|
2018-05-10 12:16:20 +00:00
|
|
|
DO_TEST_CAPS_VER("disk-virtio-scsi-reservations", "2.12.0");
|
2018-03-26 10:27:16 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-virtio-scsi-reservations");
|
2018-04-18 14:55:14 +00:00
|
|
|
|
2018-05-10 21:37:18 +00:00
|
|
|
DO_TEST_CAPS_LATEST("tseg-explicit-size");
|
2019-07-02 14:36:55 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("tseg-i440fx");
|
|
|
|
DO_TEST_CAPS_VER_PARSE_ERROR("tseg-explicit-size", "2.10.0");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("tseg-invalid-size");
|
2018-05-10 21:37:18 +00:00
|
|
|
|
2018-05-07 14:41:11 +00:00
|
|
|
DO_TEST("video-virtio-gpu-ccw", QEMU_CAPS_CCW,
|
2018-03-23 17:22:39 +00:00
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_GPU,
|
|
|
|
QEMU_CAPS_DEVICE_VIDEO_PRIMARY,
|
|
|
|
QEMU_CAPS_VIRTIO_GPU_MAX_OUTPUTS,
|
|
|
|
QEMU_CAPS_VNC,
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_GPU_CCW);
|
|
|
|
|
2018-05-07 14:41:11 +00:00
|
|
|
DO_TEST("input-virtio-ccw", QEMU_CAPS_CCW,
|
2018-03-23 17:22:42 +00:00
|
|
|
QEMU_CAPS_VIRTIO_KEYBOARD,
|
|
|
|
QEMU_CAPS_VIRTIO_MOUSE,
|
|
|
|
QEMU_CAPS_VIRTIO_TABLET,
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_KEYBOARD_CCW,
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_MOUSE_CCW,
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_TABLET_CCW);
|
|
|
|
|
2018-05-22 13:57:47 +00:00
|
|
|
DO_TEST_CAPS_LATEST("vhost-vsock");
|
|
|
|
DO_TEST_CAPS_LATEST("vhost-vsock-auto");
|
2018-08-06 15:41:07 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("vhost-vsock-ccw", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("vhost-vsock-ccw-auto", "s390x");
|
2018-05-22 13:57:47 +00:00
|
|
|
|
2018-08-15 12:00:23 +00:00
|
|
|
DO_TEST_CAPS_VER("launch-security-sev", "2.12.0");
|
2020-10-09 13:15:21 +00:00
|
|
|
DO_TEST_CAPS_VER("launch-security-sev-missing-platform-info", "2.12.0");
|
2018-06-08 14:40:58 +00:00
|
|
|
|
2019-08-06 16:21:32 +00:00
|
|
|
DO_TEST_CAPS_LATEST("vhost-user-fs-fd-memory");
|
|
|
|
DO_TEST_CAPS_LATEST("vhost-user-fs-hugepages");
|
2020-05-13 08:52:36 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("vhost-user-fs-readonly");
|
2019-08-06 16:21:32 +00:00
|
|
|
|
2018-08-22 09:15:27 +00:00
|
|
|
DO_TEST("riscv64-virt",
|
|
|
|
QEMU_CAPS_DEVICE_VIRTIO_MMIO);
|
2019-01-31 13:54:11 +00:00
|
|
|
DO_TEST("riscv64-virt-pci",
|
|
|
|
QEMU_CAPS_OBJECT_GPEX);
|
2018-08-22 09:15:27 +00:00
|
|
|
|
2019-01-11 20:06:05 +00:00
|
|
|
/* Older version checks disable-legacy usage */
|
|
|
|
DO_TEST_CAPS_VER("virtio-transitional", "3.1.0");
|
|
|
|
DO_TEST_CAPS_VER("virtio-non-transitional", "3.1.0");
|
|
|
|
DO_TEST_CAPS_LATEST("virtio-transitional");
|
|
|
|
DO_TEST_CAPS_LATEST("virtio-non-transitional");
|
2019-07-02 14:36:55 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("virtio-transitional-not-supported");
|
2019-01-11 20:06:05 +00:00
|
|
|
|
2018-09-05 11:38:34 +00:00
|
|
|
/* Simple headless guests for various architectures */
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("aarch64-virt-headless", "aarch64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("ppc64-pseries-headless", "ppc64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("riscv64-virt-headless", "riscv64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("s390x-ccw-headless", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("x86_64-pc-headless", "x86_64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("x86_64-q35-headless", "x86_64");
|
|
|
|
|
2019-02-27 17:08:29 +00:00
|
|
|
/* Simple guests with graphics for various architectures */
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("aarch64-virt-graphics", "aarch64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("ppc64-pseries-graphics", "ppc64");
|
2019-06-13 11:51:33 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("riscv64-virt-graphics", "riscv64");
|
2019-03-21 09:28:29 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("s390x-ccw-graphics", "s390x");
|
2019-02-27 17:08:29 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("x86_64-pc-graphics", "x86_64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("x86_64-q35-graphics", "x86_64");
|
|
|
|
|
2019-02-25 13:15:28 +00:00
|
|
|
DO_TEST_CAPS_LATEST("os-firmware-bios");
|
|
|
|
DO_TEST_CAPS_LATEST("os-firmware-efi");
|
|
|
|
DO_TEST_CAPS_LATEST("os-firmware-efi-secboot");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("aarch64-os-firmware-efi", "aarch64");
|
|
|
|
|
2019-09-23 10:44:43 +00:00
|
|
|
DO_TEST_CAPS_LATEST("vhost-user-vga");
|
|
|
|
DO_TEST_CAPS_LATEST("vhost-user-gpu-secondary");
|
|
|
|
|
2019-10-18 14:14:23 +00:00
|
|
|
DO_TEST_CAPS_VER("cpu-Icelake-Server-pconfig", "3.1.0");
|
|
|
|
DO_TEST_CAPS_LATEST("cpu-Icelake-Server-pconfig");
|
|
|
|
|
2019-10-11 18:15:03 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("aarch64-default-cpu-kvm-virt-4.2", "aarch64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("aarch64-default-cpu-tcg-virt-4.2", "aarch64");
|
2019-10-11 18:15:03 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("ppc64-default-cpu-kvm-pseries-2.7", "ppc64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("ppc64-default-cpu-tcg-pseries-2.7", "ppc64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("ppc64-default-cpu-kvm-pseries-3.1", "ppc64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("ppc64-default-cpu-tcg-pseries-3.1", "ppc64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("ppc64-default-cpu-kvm-pseries-4.2", "ppc64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("ppc64-default-cpu-tcg-pseries-4.2", "ppc64");
|
2020-02-06 09:18:49 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("s390-default-cpu-kvm-ccw-virtio-2.7", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("s390-default-cpu-tcg-ccw-virtio-2.7", "s390x");
|
2019-10-11 18:15:03 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("s390-default-cpu-kvm-ccw-virtio-4.2", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("s390-default-cpu-tcg-ccw-virtio-4.2", "s390x");
|
2019-10-11 18:15:03 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("x86_64-default-cpu-kvm-pc-4.2", "x86_64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("x86_64-default-cpu-tcg-pc-4.2", "x86_64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("x86_64-default-cpu-kvm-q35-4.2", "x86_64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("x86_64-default-cpu-tcg-q35-4.2", "x86_64");
|
2019-10-11 18:15:03 +00:00
|
|
|
|
2020-03-30 18:26:19 +00:00
|
|
|
DO_TEST_CAPS_LATEST("virtio-9p-multidevs");
|
|
|
|
|
2020-05-07 20:31:04 +00:00
|
|
|
if (getenv("LIBVIRT_SKIP_CLEANUP") == NULL)
|
|
|
|
virFileDeleteTree(fakerootdir);
|
|
|
|
|
2018-06-05 17:27:32 +00:00
|
|
|
VIR_FREE(driver.config->nbdTLSx509certdir);
|
2015-09-15 06:16:02 +00:00
|
|
|
qemuTestDriverFree(&driver);
|
2019-03-13 08:56:47 +00:00
|
|
|
virFileWrapperClearPrefixes();
|
2008-02-27 04:35:08 +00:00
|
|
|
|
2014-03-17 09:38:38 +00:00
|
|
|
return ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE;
|
2007-07-18 21:34:22 +00:00
|
|
|
}
|
|
|
|
|
2017-03-29 14:45:42 +00:00
|
|
|
VIR_TEST_MAIN_PRELOAD(mymain,
|
2019-08-21 16:13:16 +00:00
|
|
|
VIR_TEST_MOCK("qemuxml2argv"),
|
2019-11-15 10:56:46 +00:00
|
|
|
VIR_TEST_MOCK("domaincaps"),
|
2019-08-21 16:13:16 +00:00
|
|
|
VIR_TEST_MOCK("virrandom"),
|
|
|
|
VIR_TEST_MOCK("qemucpu"),
|
|
|
|
VIR_TEST_MOCK("virpci"))
|
2008-05-29 15:31:49 +00:00
|
|
|
|
2007-11-26 12:03:34 +00:00
|
|
|
#else
|
|
|
|
|
2011-07-08 23:24:44 +00:00
|
|
|
int main(void)
|
|
|
|
{
|
|
|
|
return EXIT_AM_SKIP;
|
|
|
|
}
|
2007-11-26 12:03:34 +00:00
|
|
|
|
|
|
|
#endif /* WITH_QEMU */
|