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"
|
2021-05-07 15:53:40 +00:00
|
|
|
# include "viridentity.h"
|
2023-09-25 14:19:34 +00:00
|
|
|
# include "qemu/qemu_block.h"
|
2010-12-17 16:41:51 +00:00
|
|
|
# include "qemu/qemu_capabilities.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"
|
2010-03-09 18:22:22 +00:00
|
|
|
# include "datatypes.h"
|
2013-11-20 15:04:10 +00:00
|
|
|
# include "conf/storage_conf.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"
|
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,
|
2020-09-16 14:47:13 +00:00
|
|
|
unsigned int fakeflags 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;
|
|
|
|
}
|
2021-01-06 16:19:03 +00:00
|
|
|
} else if (STRNEQ(usageID, "mycluster_myname") &&
|
|
|
|
STRNEQ(usageID, "client.admin secret")) {
|
2016-06-02 20:28:28 +00:00
|
|
|
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
|
|
|
|
|
|
|
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);
|
2021-09-04 20:38:39 +00:00
|
|
|
return NULL;
|
2013-11-20 15:04:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-09-04 20:38:39 +00:00
|
|
|
return virGetStoragePool(conn, name, fakeUUID, NULL, NULL);
|
2013-11-20 15:04:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static virStorageVolPtr
|
|
|
|
fakeStorageVolLookupByName(virStoragePoolPtr pool,
|
|
|
|
const char *name)
|
|
|
|
{
|
2020-12-01 08:21:32 +00:00
|
|
|
g_auto(GStrv) volinfo = NULL;
|
2013-11-20 15:04:10 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2021-02-05 17:35:07 +00:00
|
|
|
if (!(volinfo = g_strsplit(name, "+", 2)))
|
2013-11-20 15:04:10 +00:00
|
|
|
return NULL;
|
|
|
|
|
2021-11-04 14:26:07 +00:00
|
|
|
if (!volinfo[1]) {
|
|
|
|
return virGetStorageVol(pool->conn, pool->name, name, "block", NULL, NULL);
|
|
|
|
}
|
2013-11-20 15:04:10 +00:00
|
|
|
|
2021-09-04 20:38:39 +00:00
|
|
|
return virGetStorageVol(pool->conn, pool->name, volinfo[1], volinfo[0],
|
2013-11-20 15:04:10 +00:00
|
|
|
NULL, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
2021-09-04 20:38:39 +00:00
|
|
|
return NULL;
|
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
|
|
|
|
2023-12-01 14:49:21 +00:00
|
|
|
/* name of the fake network shall be constructed as:
|
|
|
|
* NETWORKXMLNAME;NETWORKPORTXMLNAME
|
|
|
|
* where:
|
|
|
|
* NETWORKXMLNAME resolves to abs_srcdir/networkxml2xmlin/NETWORKXMLNAME.xml
|
|
|
|
* NETWORKPORTXMLNAME resolves to abs_srcdir/virnetworkportxml2xmldata/NETWORKPORTXMLNAME.xml
|
|
|
|
*/
|
|
|
|
static virNetworkPtr
|
|
|
|
fakeNetworkLookupByName(virConnectPtr conn,
|
|
|
|
const char *name)
|
|
|
|
{
|
|
|
|
unsigned char uuid[VIR_UUID_BUFLEN];
|
|
|
|
g_autofree char *netname = g_strdup(name);
|
|
|
|
g_autofree char *path = NULL;
|
|
|
|
char *tmp;
|
|
|
|
|
|
|
|
memset(uuid, 0, VIR_UUID_BUFLEN);
|
|
|
|
|
|
|
|
if ((tmp = strchr(netname, ';'))) {
|
|
|
|
*tmp = '\0';
|
|
|
|
} else {
|
|
|
|
virReportError(VIR_ERR_NO_NETWORK,
|
|
|
|
"Malformed fake network name '%s'. See fakeNetworkLookupByName.",
|
|
|
|
name);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
path = g_strdup_printf(abs_srcdir "/networkxml2xmlin/%s.xml", netname);
|
|
|
|
|
|
|
|
if (!virFileExists(path)) {
|
|
|
|
virReportError(VIR_ERR_NO_NETWORK, "fake network '%s' not found", path);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return virGetNetwork(conn, name, uuid);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static char *
|
|
|
|
fakeNetworkGetXMLDesc(virNetworkPtr network,
|
|
|
|
unsigned int noflags G_GNUC_UNUSED)
|
|
|
|
{
|
|
|
|
g_autofree char *netname = g_strdup(network->name);
|
|
|
|
g_autofree char *path = NULL;
|
|
|
|
char *xml = NULL;
|
|
|
|
|
|
|
|
*(strchr(netname, ';')) = '\0';
|
|
|
|
|
|
|
|
path = g_strdup_printf(abs_srcdir "/networkxml2xmlin/%s.xml", netname);
|
|
|
|
|
|
|
|
if (virFileReadAll(path, 4 * 1024, &xml) < 0)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return xml;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static virNetworkPortPtr
|
|
|
|
fakeNetworkPortCreateXML(virNetworkPtr net,
|
|
|
|
const char *xmldesc G_GNUC_UNUSED,
|
|
|
|
unsigned int noflags G_GNUC_UNUSED)
|
|
|
|
{
|
|
|
|
unsigned char uuid[VIR_UUID_BUFLEN];
|
|
|
|
g_autofree char *portname = g_strdup(strchr(net->name, ';') + 1);
|
|
|
|
g_autofree char *path = g_strdup_printf(abs_srcdir "/virnetworkportxml2xmldata/%s.xml", portname);
|
|
|
|
|
|
|
|
memset(uuid, 0, VIR_UUID_BUFLEN);
|
|
|
|
|
|
|
|
if (!virFileExists(path)) {
|
|
|
|
virReportError(VIR_ERR_NO_NETWORK_PORT, "fake network port '%s' not found", path);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return virGetNetworkPort(net, uuid);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static char *
|
|
|
|
fakeNetworkPortGetXMLDesc(virNetworkPortPtr port,
|
|
|
|
unsigned int noflags G_GNUC_UNUSED)
|
|
|
|
{
|
|
|
|
g_autofree char *portname = g_strdup(strchr(port->net->name, ';') + 1);
|
|
|
|
g_autofree char *path = g_strdup_printf(abs_srcdir "/virnetworkportxml2xmldata/%s.xml", portname);
|
|
|
|
char *xml = NULL;
|
|
|
|
|
|
|
|
if (virFileReadAll(path, 4 * 1024, &xml) < 0)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return xml;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static virNetworkDriver fakeNetworkDriver = {
|
|
|
|
.networkLookupByName = fakeNetworkLookupByName,
|
|
|
|
.networkGetXMLDesc = fakeNetworkGetXMLDesc,
|
|
|
|
.networkPortCreateXML = fakeNetworkPortCreateXML,
|
|
|
|
.networkPortGetXMLDesc = fakeNetworkPortGetXMLDesc,
|
|
|
|
};
|
|
|
|
|
|
|
|
|
testutilsqemu: introduce ARG_CAPS_HOST_CPU_MODEL
When loading a latest caps for an arch for the first time the following
occurs in testQemuInfoInitArgs():
- the caps file is located. It's not in the cache since it's the first time
it's being read;
- the cachecaps are retrieved using qemuTestParseCapabilitiesArch() and
stored in the capscache;
- FLAG_REAL_CAPS is set and regular flow continues.
Loading the same latest caps for the second time the caps are loaded from the
cache, skipping qemuTestParseCapabilitiesArch(). By skipping this function it
means that it also skips virQEMUCapsLoadCache() and, more relevant to
our case, virQEMUCapsInitHostCPUModel(). This function will use the
current arch and cpuModel settings to write the qemuCaps that are being
stored in the cache. And we're also setting FLAG_REAL_CAPS, meaning that
we won't be updating the qemucaps host model via testUpdateQEMUCaps() as
well.
This has side-effects such as:
- the first time the latest caps for an arch is loaded determines the
cpuModel it'll use during the current qemuxml2argvtest run. For
example, when running all tests, the first time the latest ppc64 caps
are read is on "disk-floppy-pseries" test. Since the current host arch
at this point is x86_64, the cpuModel that will be set for this
capability is "core2duo";
- every other latest arch test will use the same hostCPU as the first
one set since we read it from the cache after the first run.
qemuTestSetHostCPU() makes no difference because we won't update the
host model due to FLAG_REAL_CAPS being set. Using the previous example,
every other latest ppc64 test that will be run will be using the
"core2duo" cpuModel.
Using fake capabilities (e.g. using DO_TEST()) prevents FLAG_REAL_CAPS to
be set, meaning that the cpuModel will be updated using the current
settings the test is being ran due to testUpdateQEMUCaps().
Note that not all latest caps arch tests care about the cpuModel being
set to an unexpected default cpuModel. But some tests will care, e.g.
"pseries-cpu-compat-power9", and changing it from DO_TEST() to
DO_TEST_CAPS_ARCH_LATEST() will make it fail every time the
"disk-floppy-pseries" is being ran first.
One way of fixing it is to rethink all the existing logic, for example
not setting FLAG_REAL_CAPS for latest arch tests. Another way is
presented here. ARGS_CAPS_HOST_CPU_MODEL is a new testQemuInfo arg that
allow us to set any specific host CPU model we want when running latest
arch caps tests. This new arg can then be used when converting existing
DO_TEST() testcases to DO_TEST_CAPS_ARCH_LATEST() that requires a
specific host CPU setting to be successful, which we're going to do in
the next patch with "pseries-cpu-compat-power9".
Reviewed-by: Martin Kletzander <mkletzan@redhat.com>
Signed-off-by: Daniel Henrique Barboza <danielhb413@gmail.com>
2022-05-20 13:58:23 +00:00
|
|
|
static void
|
|
|
|
testUpdateQEMUCapsHostCPUModel(virQEMUCaps *qemuCaps, virArch hostArch)
|
|
|
|
{
|
|
|
|
virQEMUCapsUpdateHostCPUModel(qemuCaps, hostArch, VIR_DOMAIN_VIRT_KVM);
|
|
|
|
virQEMUCapsUpdateHostCPUModel(qemuCaps, hostArch, VIR_DOMAIN_VIRT_QEMU);
|
|
|
|
}
|
2016-08-03 08:47:00 +00:00
|
|
|
|
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 |
|
2019-08-08 14:55:14 +00:00
|
|
|
FLAG_SLIRP_HELPER |
|
2023-12-01 15:27:26 +00:00
|
|
|
FLAG_ALLOW_DUPLICATE_OUTPUT |
|
2018-09-09 01:33:57 +00:00
|
|
|
0, -1);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2021-03-11 07:16:13 +00:00
|
|
|
static virCommand *
|
|
|
|
testCompareXMLToArgvCreateArgs(virQEMUDriver *drv,
|
|
|
|
virDomainObj *vm,
|
2020-05-15 06:50:31 +00:00
|
|
|
const char *migrateURI,
|
2023-12-04 21:28:10 +00:00
|
|
|
testQemuInfo *info,
|
2021-09-24 17:15:22 +00:00
|
|
|
unsigned int flags)
|
2020-05-15 06:50:31 +00:00
|
|
|
{
|
2021-03-11 07:16:13 +00:00
|
|
|
qemuDomainObjPrivate *priv = vm->privateData;
|
2020-05-15 06:50:31 +00:00
|
|
|
size_t i;
|
|
|
|
|
2022-05-16 10:47:19 +00:00
|
|
|
drv->hostFips = flags & FLAG_FIPS_HOST;
|
|
|
|
|
2022-01-04 14:13:45 +00:00
|
|
|
if (qemuProcessCreatePretendCmdPrepare(drv, vm, migrateURI,
|
2020-10-15 12:39:16 +00:00
|
|
|
VIR_QEMU_PROCESS_START_COLD) < 0)
|
|
|
|
return NULL;
|
|
|
|
|
2021-10-25 10:42:16 +00:00
|
|
|
if (qemuDomainDeviceBackendChardevForeach(vm->def,
|
2022-02-09 11:30:25 +00:00
|
|
|
testQemuPrepareHostBackendChardevOne,
|
2022-02-02 16:31:29 +00:00
|
|
|
vm) < 0)
|
2021-10-25 10:42:16 +00:00
|
|
|
return NULL;
|
|
|
|
|
2022-02-09 11:30:25 +00:00
|
|
|
if (testQemuPrepareHostBackendChardevOne(NULL, priv->monConfig, vm) < 0)
|
2022-02-02 16:31:29 +00:00
|
|
|
return NULL;
|
2021-10-25 10:42:16 +00:00
|
|
|
|
2020-10-15 11:47:46 +00:00
|
|
|
for (i = 0; i < vm->def->ndisks; i++) {
|
2021-03-11 07:16:13 +00:00
|
|
|
virDomainDiskDef *disk = vm->def->disks[i];
|
2023-03-17 14:58:36 +00:00
|
|
|
virStorageSource *src;
|
2020-10-15 11:47:46 +00:00
|
|
|
|
|
|
|
/* 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;
|
2023-03-17 14:58:36 +00:00
|
|
|
|
|
|
|
if (info->args.vdpafds) {
|
|
|
|
for (src = disk->src; virStorageSourceIsBacking(src); src = src->backingStore) {
|
|
|
|
gpointer value;
|
|
|
|
|
|
|
|
if (src->type != VIR_STORAGE_TYPE_VHOST_VDPA)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if ((value = g_hash_table_lookup(info->args.vdpafds, src->vdpadev))) {
|
|
|
|
int fd = GPOINTER_TO_INT(value);
|
|
|
|
qemuDomainStorageSourcePrivate *srcpriv;
|
|
|
|
VIR_AUTOCLOSE fakefd = open("/dev/zero", O_RDWR);
|
|
|
|
|
|
|
|
if (fcntl(fd, F_GETFD) != -1) {
|
|
|
|
fprintf(stderr, "fd '%d' is already in use\n", fd);
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dup2(fakefd, fd) < 0) {
|
|
|
|
fprintf(stderr, "failed to duplicate fake fd: %s",
|
|
|
|
g_strerror(errno));
|
|
|
|
abort();
|
|
|
|
}
|
|
|
|
|
|
|
|
srcpriv = qemuDomainStorageSourcePrivateFetch(src);
|
|
|
|
|
2023-09-25 14:19:34 +00:00
|
|
|
srcpriv->fdpass = qemuFDPassNew(qemuBlockStorageSourceGetStorageNodename(src), priv);
|
2023-03-17 14:58:36 +00:00
|
|
|
qemuFDPassAddFD(srcpriv->fdpass, &fd, "-vdpa");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2020-10-15 11:47:46 +00:00
|
|
|
}
|
|
|
|
|
2020-05-15 06:50:31 +00:00
|
|
|
if (vm->def->vsock) {
|
2021-03-11 07:16:13 +00:00
|
|
|
virDomainVsockDef *vsock = vm->def->vsock;
|
|
|
|
qemuDomainVsockPrivate *vsockPriv =
|
|
|
|
(qemuDomainVsockPrivate *)vsock->privateData;
|
2020-05-15 06:50:31 +00:00
|
|
|
|
|
|
|
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;
|
|
|
|
|
2021-11-15 15:52:52 +00:00
|
|
|
VIR_FREE(vm->def->tpms[i]->data.emulator.source->data.nix.path);
|
|
|
|
vm->def->tpms[i]->data.emulator.source->type = VIR_DOMAIN_CHR_TYPE_UNIX;
|
|
|
|
vm->def->tpms[i]->data.emulator.source->data.nix.path = g_strdup("/dev/test");
|
2020-05-15 06:50:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < vm->def->nvideos; i++) {
|
2021-03-11 07:16:13 +00:00
|
|
|
virDomainVideoDef *video = vm->def->videos[i];
|
2020-05-15 06:50:31 +00:00
|
|
|
|
|
|
|
if (video->backend == VIR_DOMAIN_VIDEO_BACKEND_TYPE_VHOSTUSER) {
|
2021-03-11 07:16:13 +00:00
|
|
|
qemuDomainVideoPrivate *vpriv = QEMU_DOMAIN_VIDEO_PRIVATE(video);
|
2020-05-15 06:50:31 +00:00
|
|
|
|
|
|
|
vpriv->vhost_user_fd = 1729;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (flags & FLAG_SLIRP_HELPER) {
|
|
|
|
for (i = 0; i < vm->def->nnets; i++) {
|
2021-03-11 07:16:13 +00:00
|
|
|
virDomainNetDef *net = vm->def->nets[i];
|
2020-05-15 06:50:31 +00:00
|
|
|
|
|
|
|
if (net->type == VIR_DOMAIN_NET_TYPE_USER &&
|
2022-12-15 19:19:16 +00:00
|
|
|
net->backend.type == VIR_DOMAIN_NET_BACKEND_DEFAULT &&
|
2020-05-15 06:50:31 +00:00
|
|
|
virQEMUCapsGet(info->qemuCaps, QEMU_CAPS_DBUS_VMSTATE)) {
|
2021-03-11 07:16:13 +00:00
|
|
|
qemuSlirp *slirp = qemuSlirpNew();
|
2020-05-15 06:50:31 +00:00
|
|
|
slirp->fd[0] = 42;
|
|
|
|
QEMU_DOMAIN_NETWORK_PRIVATE(net)->slirp = slirp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-05-16 11:55:25 +00:00
|
|
|
return qemuProcessCreatePretendCmdBuild(vm, migrateURI);
|
2020-05-15 06:50:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2021-09-24 11:28:57 +00:00
|
|
|
struct testValidateSchemaCommandData {
|
|
|
|
const char *name;
|
|
|
|
const char *schema;
|
2021-10-15 10:21:06 +00:00
|
|
|
bool allowIncomplete; /* relax validator for commands with incomplete schema */
|
2021-09-24 11:28:57 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
static const struct testValidateSchemaCommandData commands[] = {
|
2021-10-15 10:21:06 +00:00
|
|
|
{ "-blockdev", "blockdev-add", false },
|
|
|
|
{ "-netdev", "netdev_add", false },
|
|
|
|
{ "-object", "object-add", false },
|
|
|
|
{ "-device", "device_add", true },
|
2021-09-24 11:28:57 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static int
|
|
|
|
testCompareXMLToArgvValidateSchemaCommand(GStrv args,
|
|
|
|
GHashTable *schema)
|
|
|
|
{
|
|
|
|
GStrv arg;
|
|
|
|
|
|
|
|
for (arg = args; *arg; arg++) {
|
|
|
|
const char *curcommand = *arg;
|
|
|
|
const char *curargs = *(arg + 1);
|
|
|
|
size_t i;
|
|
|
|
|
|
|
|
for (i = 0; i < G_N_ELEMENTS(commands); i++) {
|
|
|
|
const struct testValidateSchemaCommandData *command = commands + i;
|
|
|
|
g_auto(virBuffer) debug = VIR_BUFFER_INITIALIZER;
|
|
|
|
g_autoptr(virJSONValue) jsonargs = NULL;
|
|
|
|
|
|
|
|
if (STRNEQ(curcommand, command->name))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!curargs) {
|
|
|
|
VIR_TEST_VERBOSE("expected arguments for command '%s'",
|
|
|
|
command->name);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (*curargs != '{') {
|
|
|
|
arg++;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(jsonargs = virJSONValueFromString(curargs)))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (testQEMUSchemaValidateCommand(command->schema, jsonargs,
|
2021-10-15 10:21:06 +00:00
|
|
|
schema, false, false,
|
|
|
|
command->allowIncomplete,
|
|
|
|
&debug) < 0) {
|
2021-09-24 11:28:57 +00:00
|
|
|
VIR_TEST_VERBOSE("failed to validate '%s %s' against QAPI schema: %s",
|
|
|
|
command->name, curargs, virBufferCurrentContent(&debug));
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
arg++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-05-15 12:33:10 +00:00
|
|
|
static int
|
2022-10-19 15:10:45 +00:00
|
|
|
testCompareXMLToArgvValidateSchema(virCommand *cmd,
|
2023-12-04 21:28:10 +00:00
|
|
|
testQemuInfo *info)
|
2020-05-15 12:33:10 +00:00
|
|
|
{
|
2020-12-01 08:21:32 +00:00
|
|
|
g_auto(GStrv) args = NULL;
|
2020-05-15 12:33:10 +00:00
|
|
|
|
2023-03-09 14:15:40 +00:00
|
|
|
if (!info->qmpSchema)
|
2020-05-15 12:33:10 +00:00
|
|
|
return 0;
|
|
|
|
|
2021-09-24 11:32:16 +00:00
|
|
|
if (virCommandGetArgList(cmd, &args) < 0)
|
2020-05-15 12:33:10 +00:00
|
|
|
return -1;
|
|
|
|
|
2023-03-09 14:15:40 +00:00
|
|
|
if (testCompareXMLToArgvValidateSchemaCommand(args, info->qmpSchema) < 0)
|
2021-09-24 11:28:57 +00:00
|
|
|
return -1;
|
2020-05-15 12:33:10 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2023-12-01 15:27:26 +00:00
|
|
|
static int
|
2023-12-04 21:28:10 +00:00
|
|
|
testInfoCheckDuplicate(testQemuInfo *info)
|
2023-12-01 15:27:26 +00:00
|
|
|
{
|
|
|
|
const char *path = info->outfile;
|
|
|
|
|
|
|
|
if (info->flags & FLAG_ALLOW_DUPLICATE_OUTPUT)
|
|
|
|
return 0;
|
|
|
|
|
2024-01-23 12:35:39 +00:00
|
|
|
if (!path)
|
2023-12-01 15:27:26 +00:00
|
|
|
path = info->errfile;
|
|
|
|
|
|
|
|
if (g_hash_table_contains(info->conf->duplicateTests, path)) {
|
|
|
|
fprintf(stderr, "\nduplicate invocation of test case: %s\n'", path);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
g_hash_table_insert(info->conf->duplicateTests, g_strdup(path), NULL);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2023-12-16 15:30:57 +00:00
|
|
|
/**
|
|
|
|
* testQemuConfXMLCommon: Prepare common test data (e.g. parse input XML)
|
|
|
|
* for a test case.
|
|
|
|
*
|
|
|
|
* @info: test info struct to prepare
|
|
|
|
* @rv: return value that the caller is supposed to return (see below)
|
|
|
|
*
|
|
|
|
* Since some of the prepared data is reused by multiple tests, which can be
|
|
|
|
* potentially skipped via 'VIR_TEST_RANGE', this function is designed to be
|
|
|
|
* callable multiple times but processes data just once.
|
|
|
|
*
|
|
|
|
* Returns 'true' if subsequent tests are expected to run (input XML was parsed
|
|
|
|
* properly and test is not expected to fail on parse error). Otherwise 'false'
|
|
|
|
* is returned and rv is populated according to the following logic:
|
|
|
|
* 1) expected failure of parsing (FLAG_EXPECT_PARSE_ERROR)
|
|
|
|
* - first invocation sets @rv to 0
|
|
|
|
* - other invocations set rv to EXIT_AM_SKIP
|
|
|
|
* 2) unexpected error
|
|
|
|
* - all invocations return -1
|
|
|
|
* - first invocation reports actual error
|
|
|
|
* - other invocations report replacement error
|
|
|
|
*/
|
|
|
|
static bool
|
|
|
|
testQemuConfXMLCommon(testQemuInfo *info,
|
|
|
|
int *rv)
|
2018-03-27 09:11:01 +00:00
|
|
|
{
|
2023-12-16 15:30:57 +00:00
|
|
|
g_autoptr(virDomainDef) def = NULL;
|
|
|
|
|
|
|
|
/* initialize a test just once */
|
|
|
|
if (info->prepared)
|
|
|
|
goto cleanup;
|
2010-02-10 13:19:17 +00:00
|
|
|
|
2023-12-01 15:47:23 +00:00
|
|
|
/* mark test case as used */
|
|
|
|
ignore_value(g_hash_table_remove(info->conf->existingTestCases, info->infile));
|
2024-01-23 12:44:50 +00:00
|
|
|
if (info->outfile)
|
|
|
|
ignore_value(g_hash_table_remove(info->conf->existingTestCases, info->outfile));
|
|
|
|
if (info->errfile)
|
|
|
|
ignore_value(g_hash_table_remove(info->conf->existingTestCases, info->errfile));
|
|
|
|
if (info->out_xml_inactive)
|
|
|
|
ignore_value(g_hash_table_remove(info->conf->existingTestCases, info->out_xml_inactive));
|
2023-12-01 15:47:23 +00:00
|
|
|
|
2023-12-04 21:28:10 +00:00
|
|
|
if (testQemuInfoInitArgs((testQemuInfo *) info) < 0)
|
2021-08-17 13:30:44 +00:00
|
|
|
goto cleanup;
|
|
|
|
|
2023-12-01 15:27:26 +00:00
|
|
|
if (testInfoCheckDuplicate(info) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
2024-01-03 12:03:24 +00:00
|
|
|
# if !WITH_NBDKIT
|
|
|
|
/* when compiled without nbdkit support we want to skip the test after
|
|
|
|
* marking it as used */
|
|
|
|
if (info->args.fakeNbdkitCaps) {
|
2023-12-16 15:30:57 +00:00
|
|
|
info->prep_skip = true;
|
|
|
|
info->prepared = true;
|
2024-01-03 12:03:24 +00:00
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
# endif /* !WITH_NBDKIT */
|
|
|
|
|
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
|
|
|
|
testutilsqemu: introduce ARG_CAPS_HOST_CPU_MODEL
When loading a latest caps for an arch for the first time the following
occurs in testQemuInfoInitArgs():
- the caps file is located. It's not in the cache since it's the first time
it's being read;
- the cachecaps are retrieved using qemuTestParseCapabilitiesArch() and
stored in the capscache;
- FLAG_REAL_CAPS is set and regular flow continues.
Loading the same latest caps for the second time the caps are loaded from the
cache, skipping qemuTestParseCapabilitiesArch(). By skipping this function it
means that it also skips virQEMUCapsLoadCache() and, more relevant to
our case, virQEMUCapsInitHostCPUModel(). This function will use the
current arch and cpuModel settings to write the qemuCaps that are being
stored in the cache. And we're also setting FLAG_REAL_CAPS, meaning that
we won't be updating the qemucaps host model via testUpdateQEMUCaps() as
well.
This has side-effects such as:
- the first time the latest caps for an arch is loaded determines the
cpuModel it'll use during the current qemuxml2argvtest run. For
example, when running all tests, the first time the latest ppc64 caps
are read is on "disk-floppy-pseries" test. Since the current host arch
at this point is x86_64, the cpuModel that will be set for this
capability is "core2duo";
- every other latest arch test will use the same hostCPU as the first
one set since we read it from the cache after the first run.
qemuTestSetHostCPU() makes no difference because we won't update the
host model due to FLAG_REAL_CAPS being set. Using the previous example,
every other latest ppc64 test that will be run will be using the
"core2duo" cpuModel.
Using fake capabilities (e.g. using DO_TEST()) prevents FLAG_REAL_CAPS to
be set, meaning that the cpuModel will be updated using the current
settings the test is being ran due to testUpdateQEMUCaps().
Note that not all latest caps arch tests care about the cpuModel being
set to an unexpected default cpuModel. But some tests will care, e.g.
"pseries-cpu-compat-power9", and changing it from DO_TEST() to
DO_TEST_CAPS_ARCH_LATEST() will make it fail every time the
"disk-floppy-pseries" is being ran first.
One way of fixing it is to rethink all the existing logic, for example
not setting FLAG_REAL_CAPS for latest arch tests. Another way is
presented here. ARGS_CAPS_HOST_CPU_MODEL is a new testQemuInfo arg that
allow us to set any specific host CPU model we want when running latest
arch caps tests. This new arg can then be used when converting existing
DO_TEST() testcases to DO_TEST_CAPS_ARCH_LATEST() that requires a
specific host CPU setting to be successful, which we're going to do in
the next patch with "pseries-cpu-compat-power9".
Reviewed-by: Martin Kletzander <mkletzan@redhat.com>
Signed-off-by: Daniel Henrique Barboza <danielhb413@gmail.com>
2022-05-20 13:58:23 +00:00
|
|
|
if (info->args.capsHostCPUModel) {
|
|
|
|
virCPUDef *hostCPUModel = qemuTestGetCPUDef(info->args.capsHostCPUModel);
|
|
|
|
|
|
|
|
qemuTestSetHostCPU(&driver, driver.hostarch, hostCPUModel);
|
|
|
|
testUpdateQEMUCapsHostCPUModel(info->qemuCaps, driver.hostarch);
|
|
|
|
}
|
|
|
|
|
2018-09-09 01:33:57 +00:00
|
|
|
if (testCheckExclusiveFlags(info->flags) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
2023-03-02 16:44:21 +00:00
|
|
|
virFileCacheClear(driver.qemuCapsCache);
|
|
|
|
|
2023-03-08 16:34:25 +00:00
|
|
|
if (qemuTestCapsCacheInsert(driver.qemuCapsCache, info->qemuCaps) < 0)
|
2016-08-03 08:42:08 +00:00
|
|
|
goto cleanup;
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2023-12-16 15:30:57 +00:00
|
|
|
if (!(def = virDomainDefParseFile(info->infile, driver.xmlopt, NULL,
|
|
|
|
info->parseFlags | VIR_DOMAIN_DEF_PARSE_INACTIVE))) {
|
|
|
|
virError *err = virGetLastError();
|
2021-03-31 14:11:42 +00:00
|
|
|
|
2020-09-22 11:57:39 +00:00
|
|
|
if (!err) {
|
|
|
|
VIR_TEST_DEBUG("no error was reported for expected parse error");
|
|
|
|
goto cleanup;
|
|
|
|
}
|
2023-12-16 15:30:57 +00:00
|
|
|
|
|
|
|
if (info->flags & FLAG_EXPECT_PARSE_ERROR) {
|
2020-09-24 11:09:47 +00:00
|
|
|
g_autofree char *tmperr = g_strdup_printf("%s\n", NULLSTR(err->message));
|
2023-12-16 15:30:57 +00:00
|
|
|
if (virTestCompareToFile(tmperr, info->errfile) >= 0) {
|
|
|
|
info->prep_skip = true;
|
|
|
|
}
|
2020-09-24 11:09:47 +00:00
|
|
|
}
|
2023-12-16 15:30:57 +00:00
|
|
|
|
2016-08-03 08:19:10 +00:00
|
|
|
goto cleanup;
|
2012-07-09 16:29:55 +00:00
|
|
|
}
|
2023-12-16 15:30:57 +00:00
|
|
|
|
|
|
|
if (info->flags & FLAG_EXPECT_PARSE_ERROR) {
|
2017-09-07 12:19:37 +00:00
|
|
|
VIR_TEST_DEBUG("passed instead of expected parse error");
|
|
|
|
goto cleanup;
|
|
|
|
}
|
2023-12-16 15:30:57 +00:00
|
|
|
|
|
|
|
info->def = g_steal_pointer(&def);
|
|
|
|
|
|
|
|
cleanup:
|
|
|
|
/* definition is present and correct, return true to signal that caller can continue */
|
|
|
|
if (info->def) {
|
|
|
|
info->prepared = true;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* definition is not present, but failure was expected */
|
|
|
|
if (info->prep_skip) {
|
|
|
|
/* first time we report success, any subsequent time EXIT_AM_SKIP */
|
|
|
|
if (!info->prepared)
|
|
|
|
*rv = 0;
|
|
|
|
else
|
|
|
|
*rv = EXIT_AM_SKIP;
|
|
|
|
} else {
|
|
|
|
/* any other failure always results in error in all invocations
|
|
|
|
* so that the user will see all the failures in the final error
|
|
|
|
* message which is suggesting a VIR_TEST_RANGE-limited run for
|
|
|
|
* debugging. */
|
|
|
|
*rv = -1;
|
|
|
|
|
|
|
|
/* report replacement error on subsequent runs */
|
|
|
|
if (!info->prepared)
|
|
|
|
VIR_TEST_VERBOSE("error from testQemuConfXMLCommon() was reported in the first invocation");
|
|
|
|
}
|
|
|
|
|
|
|
|
info->prepared = true;
|
|
|
|
/* caller is not expected to run tests */
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2023-12-16 16:13:35 +00:00
|
|
|
static int
|
|
|
|
testCompareDef2XML(const void *data)
|
|
|
|
{
|
|
|
|
testQemuInfo *info = (void *) data;
|
|
|
|
g_autofree char *actual = NULL;
|
|
|
|
unsigned int format_flags = VIR_DOMAIN_DEF_FORMAT_SECURE;
|
|
|
|
int rc = 0;
|
|
|
|
|
|
|
|
if (!testQemuConfXMLCommon(info, &rc))
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
/* we deliberately format the XML as live to catch potential test regressions
|
|
|
|
* as virDomainDefFormatInternalSetRootName implies _INACTIVE if 'def->id'
|
|
|
|
* is -1, thus VM is inactive. */
|
|
|
|
if (!(actual = virDomainDefFormat(info->def, driver.xmlopt, format_flags)))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (virTestCompareToFile(actual, info->out_xml_inactive) < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2023-12-18 15:38:46 +00:00
|
|
|
static int
|
|
|
|
testCompareOutXML2XML(const void *data)
|
|
|
|
{
|
|
|
|
testQemuInfo *info = (void *) data;
|
|
|
|
g_autofree char *actual = NULL;
|
|
|
|
g_autoptr(virDomainDef) outdef = NULL;
|
|
|
|
unsigned int format_flags = VIR_DOMAIN_DEF_FORMAT_SECURE;
|
|
|
|
int rc = 0;
|
|
|
|
|
|
|
|
if (!testQemuConfXMLCommon(info, &rc))
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
/* parsing of the file produced by libvirt MUST succeed */
|
|
|
|
if (!(outdef = virDomainDefParseFile(info->out_xml_inactive, driver.xmlopt, NULL,
|
|
|
|
info->parseFlags | VIR_DOMAIN_DEF_PARSE_INACTIVE))) {
|
|
|
|
VIR_TEST_VERBOSE("failed to parse '%s'", info->out_xml_inactive);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* we deliberately format the XML as live to catch potential test regressions
|
|
|
|
* as virDomainDefFormatInternalSetRootName implies _INACTIVE if 'def->id'
|
|
|
|
* is -1, thus VM is inactive. */
|
|
|
|
if (!(actual = virDomainDefFormat(outdef, driver.xmlopt, format_flags)))
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (virTestCompareToFile(actual, info->out_xml_inactive) < 0)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2023-12-16 15:30:57 +00:00
|
|
|
static int
|
|
|
|
testCompareXMLToArgv(const void *data)
|
|
|
|
{
|
|
|
|
testQemuInfo *info = (void *) data;
|
|
|
|
g_autofree char *migrateURI = NULL;
|
|
|
|
g_auto(virBuffer) actualBuf = VIR_BUFFER_INITIALIZER;
|
|
|
|
g_autofree char *actualargv = NULL;
|
|
|
|
unsigned int flags = info->flags;
|
|
|
|
int ret = -1;
|
|
|
|
virDomainObj *vm = NULL;
|
|
|
|
virDomainChrSourceDef monitor_chr = { 0 };
|
|
|
|
virError *err = NULL;
|
|
|
|
g_autofree char *log = NULL;
|
|
|
|
g_autoptr(virCommand) cmd = NULL;
|
|
|
|
qemuDomainObjPrivate *priv = NULL;
|
|
|
|
g_autoptr(virIdentity) sysident = virIdentityGetSystem();
|
|
|
|
int rc = 0;
|
|
|
|
|
|
|
|
if (!testQemuConfXMLCommon(info, &rc))
|
|
|
|
return rc;
|
|
|
|
|
|
|
|
if (virIdentitySetCurrent(sysident) < 0)
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
if (info->nbdkitCaps) {
|
|
|
|
if (virFileCacheInsertData(driver.nbdkitCapsCache, TEST_NBDKIT_PATH,
|
|
|
|
g_object_ref(info->nbdkitCaps)) < 0) {
|
|
|
|
g_object_unref(info->nbdkitCaps);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (info->migrateFrom &&
|
|
|
|
!(migrateURI = qemuMigrationDstGetURI(info->migrateFrom,
|
|
|
|
info->migrateFd)))
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
if (!(vm = virDomainObjNew(driver.xmlopt)))
|
|
|
|
goto cleanup;
|
|
|
|
|
|
|
|
vm->def = info->def;
|
2016-03-15 12:54:24 +00:00
|
|
|
priv = vm->privateData;
|
2007-07-18 21:34:22 +00:00
|
|
|
|
2022-10-11 13:52:54 +00:00
|
|
|
if (info->args.fds) {
|
|
|
|
g_clear_pointer(&priv->fds, g_hash_table_unref);
|
|
|
|
priv->fds = g_steal_pointer(&info->args.fds);
|
|
|
|
}
|
|
|
|
|
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
|
|
|
|
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,
|
2021-09-24 17:15:22 +00:00
|
|
|
flags))) {
|
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
|
|
|
|
2022-10-19 15:10:45 +00:00
|
|
|
if (testCompareXMLToArgvValidateSchema(cmd, info) < 0)
|
2020-05-15 12:33:10 +00:00
|
|
|
goto cleanup;
|
|
|
|
|
2021-06-11 07:45:12 +00:00
|
|
|
if (virCommandToStringBuf(cmd, &actualBuf, true, false) < 0)
|
2016-08-03 08:19:10 +00:00
|
|
|
goto cleanup;
|
2010-11-22 23:09:13 +00:00
|
|
|
|
2021-06-11 07:45:12 +00:00
|
|
|
virBufferAddLit(&actualBuf, "\n");
|
|
|
|
actualargv = virBufferContentAndReset(&actualBuf);
|
|
|
|
|
2021-03-31 08:46:36 +00:00
|
|
|
if (virTestCompareToFileFull(actualargv, info->outfile, false) < 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:
|
2023-09-01 13:41:10 +00:00
|
|
|
/* clear overriden host cpu */
|
|
|
|
if (info->args.capsHostCPUModel)
|
|
|
|
qemuTestSetHostCPU(&driver, driver.hostarch, NULL);
|
2016-07-08 21:45:22 +00:00
|
|
|
virDomainChrSourceDefClear(&monitor_chr);
|
2023-12-16 15:30:57 +00:00
|
|
|
if (vm) {
|
|
|
|
vm->def = NULL;
|
|
|
|
virObjectUnref(vm);
|
|
|
|
}
|
2021-05-07 15:53:40 +00:00
|
|
|
virIdentitySetCurrent(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
|
|
|
}
|
|
|
|
|
2023-12-01 15:47:23 +00:00
|
|
|
|
|
|
|
static int
|
|
|
|
testConfXMLCheck(GHashTable *existingTestCases)
|
|
|
|
{
|
|
|
|
g_autofree virHashKeyValuePair *items = virHashGetItems(existingTestCases, NULL, true);
|
|
|
|
size_t i;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
for (i = 0; items[i].key; i++) {
|
|
|
|
if (ret == 0)
|
|
|
|
fprintf(stderr, "\n");
|
|
|
|
|
2024-01-23 12:44:50 +00:00
|
|
|
fprintf(stderr, "unused file: %s\n", (const char *) items[i].key);
|
2023-12-01 15:47:23 +00:00
|
|
|
ret = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
testConfXMLEnumerate(GHashTable *existingTestCases)
|
|
|
|
{
|
|
|
|
struct dirent *ent;
|
|
|
|
g_autoptr(DIR) dir = NULL;
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
/* If VIR_TEST_RANGE is in use don't bother filling in the data, which
|
|
|
|
* also makes testConfXMLCheck succeed. */
|
|
|
|
if (virTestHasRangeBitmap())
|
|
|
|
return 0;
|
|
|
|
|
2024-01-22 12:18:56 +00:00
|
|
|
if (virDirOpen(&dir, abs_srcdir "/qemuxmlconfdata") < 0)
|
2023-12-01 15:47:23 +00:00
|
|
|
return -1;
|
|
|
|
|
2024-01-22 12:18:56 +00:00
|
|
|
while ((rc = virDirRead(dir, &ent, abs_srcdir "/qemuxmlconfdata")) > 0) {
|
2024-01-23 12:44:50 +00:00
|
|
|
if (virStringHasSuffix(ent->d_name, ".xml") ||
|
|
|
|
virStringHasSuffix(ent->d_name, ".args") ||
|
|
|
|
virStringHasSuffix(ent->d_name, ".err")) {
|
2023-12-01 15:47:23 +00:00
|
|
|
g_hash_table_insert(existingTestCases,
|
2024-01-22 12:18:56 +00:00
|
|
|
g_strdup_printf(abs_srcdir "/qemuxmlconfdata/%s", ent->d_name),
|
2023-12-01 15:47:23 +00:00
|
|
|
NULL);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2023-12-18 15:02:33 +00:00
|
|
|
static int
|
|
|
|
testXMLParse(const void *data)
|
|
|
|
{
|
|
|
|
testQemuInfo *info = (void *) data;
|
|
|
|
int rc = 0;
|
|
|
|
|
|
|
|
testQemuConfXMLCommon(info, &rc);
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2023-12-04 16:00:54 +00:00
|
|
|
static void
|
|
|
|
testRun(const char *name,
|
|
|
|
const char *suffix,
|
|
|
|
int *ret,
|
|
|
|
struct testQemuConf *testConf,
|
|
|
|
...)
|
|
|
|
{
|
2023-12-18 15:02:33 +00:00
|
|
|
g_autofree char *name_parse = g_strdup_printf("QEMU XML def parse %s%s", name, suffix);
|
2023-12-16 16:13:35 +00:00
|
|
|
g_autofree char *name_xml = g_strdup_printf("QEMU XML def -> XML %s%s", name, suffix);
|
2023-12-18 15:38:46 +00:00
|
|
|
g_autofree char *name_outxml = g_strdup_printf("QEMU XML OUT -> XML %s%s", name, suffix);
|
2023-12-18 15:02:33 +00:00
|
|
|
g_autofree char *name_argv = g_strdup_printf("QEMU XML def -> ARGV %s%s", name, suffix);
|
2023-12-04 16:00:54 +00:00
|
|
|
g_autoptr(testQemuInfo) info = g_new0(testQemuInfo, 1);
|
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
info->name = name;
|
|
|
|
info->conf = testConf;
|
|
|
|
|
|
|
|
va_start(ap, testConf);
|
|
|
|
testQemuInfoSetArgs(info, ap);
|
|
|
|
va_end(ap);
|
|
|
|
|
2024-01-22 12:18:56 +00:00
|
|
|
info->infile = g_strdup_printf("%s/qemuxmlconfdata/%s.xml", abs_srcdir, info->name);
|
2024-01-23 12:35:39 +00:00
|
|
|
if (info->flags & (FLAG_EXPECT_FAILURE | FLAG_EXPECT_PARSE_ERROR)) {
|
2024-01-22 12:18:56 +00:00
|
|
|
info->errfile = g_strdup_printf("%s/qemuxmlconfdata/%s%s.err", abs_srcdir, info->name, suffix);
|
2024-01-23 12:35:39 +00:00
|
|
|
} else {
|
2024-01-22 12:18:56 +00:00
|
|
|
info->outfile = g_strdup_printf("%s/qemuxmlconfdata/%s%s.args", abs_srcdir, info->name, suffix);
|
2024-01-23 12:35:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!(info->flags & FLAG_EXPECT_PARSE_ERROR))
|
2024-01-22 15:49:18 +00:00
|
|
|
info->out_xml_inactive = g_strdup_printf("%s/qemuxmlconfdata/%s%s.xml", abs_srcdir, info->name, suffix);
|
2023-12-04 16:00:54 +00:00
|
|
|
|
2023-12-18 15:02:33 +00:00
|
|
|
virTestRunLog(ret, name_parse, testXMLParse, info);
|
2023-12-16 16:13:35 +00:00
|
|
|
virTestRunLog(ret, name_xml, testCompareDef2XML, info);
|
2023-12-18 15:38:46 +00:00
|
|
|
virTestRunLog(ret, name_outxml, testCompareOutXML2XML, info);
|
2023-12-18 15:02:33 +00:00
|
|
|
virTestRunLog(ret, name_argv, testCompareXMLToArgv, info);
|
2023-12-16 15:30:57 +00:00
|
|
|
|
|
|
|
/* clear overriden host cpu */
|
|
|
|
if (info->args.capsHostCPUModel)
|
|
|
|
qemuTestSetHostCPU(&driver, driver.hostarch, NULL);
|
|
|
|
if (info->arch != VIR_ARCH_NONE && info->arch != VIR_ARCH_X86_64)
|
|
|
|
qemuTestSetHostArch(&driver, VIR_ARCH_NONE);
|
2023-12-04 16:00:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
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;
|
2023-12-16 07:48:21 +00:00
|
|
|
g_autoptr(virConnect) conn = NULL;
|
2023-12-01 15:27:26 +00:00
|
|
|
g_autoptr(GHashTable) duplicateTests = virHashNew(NULL);
|
2023-12-01 15:47:23 +00:00
|
|
|
g_autoptr(GHashTable) existingTestCases = virHashNew(NULL);
|
2021-08-17 14:26:58 +00:00
|
|
|
g_autoptr(GHashTable) capslatest = testQemuGetLatestCaps();
|
2021-11-30 13:07:36 +00:00
|
|
|
g_autoptr(GHashTable) qapiSchemaCache = virHashNew((GDestroyNotify) g_hash_table_unref);
|
2022-07-13 20:26:51 +00:00
|
|
|
g_autoptr(GHashTable) capscache = virHashNew(virObjectUnref);
|
2021-08-17 14:26:58 +00:00
|
|
|
struct testQemuConf testConf = { .capslatest = capslatest,
|
|
|
|
.capscache = capscache,
|
2023-12-01 15:27:26 +00:00
|
|
|
.qapiSchemaCache = qapiSchemaCache,
|
2023-12-01 15:47:23 +00:00
|
|
|
.duplicateTests = duplicateTests,
|
|
|
|
.existingTestCases = existingTestCases };
|
2021-08-17 14:26:58 +00:00
|
|
|
|
|
|
|
if (!capslatest)
|
|
|
|
return EXIT_FAILURE;
|
2007-07-18 21:34:22 +00:00
|
|
|
|
2023-12-01 15:47:23 +00:00
|
|
|
/* enumerate and store all available test cases to verify at the end that
|
|
|
|
* all of them were invoked */
|
|
|
|
if (testConfXMLEnumerate(existingTestCases) < 0)
|
|
|
|
return EXIT_FAILURE;
|
|
|
|
|
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
|
|
|
|
2023-03-07 14:36:35 +00:00
|
|
|
virFileWrapperAddPrefix("/sys/devices/system",
|
|
|
|
abs_srcdir "/vircaps2xmldata/linux-basic/system");
|
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");
|
|
|
|
|
2023-12-16 07:48:21 +00:00
|
|
|
if (!(conn = virGetConnect()))
|
|
|
|
return EXIT_FAILURE;
|
|
|
|
|
|
|
|
conn->secretDriver = &fakeSecretDriver;
|
|
|
|
conn->storageDriver = &fakeStorageDriver;
|
|
|
|
conn->nwfilterDriver = &fakeNWFilterDriver;
|
|
|
|
conn->networkDriver = &fakeNetworkDriver;
|
|
|
|
|
|
|
|
virSetConnectInterface(conn);
|
|
|
|
virSetConnectNetwork(conn);
|
|
|
|
virSetConnectNWFilter(conn);
|
|
|
|
virSetConnectNodeDev(conn);
|
|
|
|
virSetConnectSecret(conn);
|
|
|
|
virSetConnectStorage(conn);
|
|
|
|
|
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.
|
|
|
|
*/
|
2021-08-16 15:02:16 +00:00
|
|
|
# define DO_TEST_FULL(_name, _suffix, ...) \
|
2023-12-04 16:00:54 +00:00
|
|
|
testRun(_name, _suffix, &ret, &testConf, __VA_ARGS__);
|
2018-04-04 07:42:36 +00:00
|
|
|
|
2019-03-14 13:38:02 +00:00
|
|
|
# define DO_TEST_CAPS_INTERNAL(name, arch, ver, ...) \
|
2021-08-16 15:02:16 +00:00
|
|
|
DO_TEST_FULL(name, "." arch "-" ver, \
|
|
|
|
ARG_CAPS_ARCH, arch, \
|
|
|
|
ARG_CAPS_VER, ver, \
|
|
|
|
__VA_ARGS__, \
|
|
|
|
ARG_END)
|
2019-03-14 13:38:02 +00:00
|
|
|
|
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
|
|
|
|
2023-03-27 17:47:27 +00:00
|
|
|
# define DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE(name, arch) \
|
2024-01-26 10:57:21 +00:00
|
|
|
DO_TEST_FULL(name, "." arch "-latest.abi-update", \
|
|
|
|
ARG_CAPS_ARCH, arch, \
|
|
|
|
ARG_CAPS_VER, "latest", \
|
|
|
|
ARG_PARSEFLAGS, VIR_DOMAIN_DEF_PARSE_ABI_UPDATE, \
|
|
|
|
ARG_END)
|
2023-03-27 17:47:27 +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
|
|
|
|
2024-01-03 12:03:24 +00:00
|
|
|
# define DO_TEST_CAPS_LATEST_NBDKIT(name, ...) \
|
2022-07-08 19:30:30 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL(name, "x86_64", ARG_NBDKIT_CAPS, __VA_ARGS__, QEMU_NBDKIT_CAPS_LAST, ARG_END)
|
|
|
|
|
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
|
|
|
|
2023-05-16 14:50:37 +00:00
|
|
|
# define DO_TEST_CAPS_LATEST_ABI_UPDATE(name) \
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE(name, "x86_64")
|
|
|
|
|
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")
|
|
|
|
|
2022-05-20 18:15:18 +00:00
|
|
|
# define DO_TEST_CAPS_LATEST_PPC64_HOSTCPU(name, hostcpu) \
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL(name, "ppc64", \
|
|
|
|
ARG_CAPS_HOST_CPU_MODEL, hostcpu)
|
|
|
|
|
|
|
|
# define DO_TEST_CAPS_LATEST_PPC64_HOSTCPU_FAILURE(name, hostcpu) \
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL(name, "ppc64", \
|
|
|
|
ARG_CAPS_HOST_CPU_MODEL, hostcpu, \
|
|
|
|
ARG_FLAGS, FLAG_EXPECT_FAILURE)
|
|
|
|
|
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
|
|
|
|
2023-05-16 14:50:37 +00:00
|
|
|
# define DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE_FAILURE(name, arch) \
|
2024-01-26 10:57:21 +00:00
|
|
|
DO_TEST_FULL(name, "." arch "-latest.abi-update", \
|
|
|
|
ARG_CAPS_ARCH, arch, \
|
|
|
|
ARG_CAPS_VER, "latest", \
|
|
|
|
ARG_PARSEFLAGS, VIR_DOMAIN_DEF_PARSE_ABI_UPDATE, \
|
|
|
|
ARG_FLAGS, FLAG_EXPECT_FAILURE, \
|
|
|
|
ARG_END)
|
2023-05-16 14:50:37 +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")
|
|
|
|
|
2023-05-16 14:50:37 +00:00
|
|
|
# define DO_TEST_CAPS_LATEST_ABI_UPDATE_FAILURE(name) \
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE_FAILURE(name, "x86_64")
|
|
|
|
|
2019-07-02 15:37:20 +00:00
|
|
|
# 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
|
|
|
|
2023-05-16 14:50:37 +00:00
|
|
|
# define DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE_PARSE_ERROR(name, arch) \
|
2024-01-26 10:57:21 +00:00
|
|
|
DO_TEST_FULL(name, "." arch "-latest.abi-update", \
|
|
|
|
ARG_CAPS_ARCH, arch, \
|
|
|
|
ARG_CAPS_VER, "latest", \
|
|
|
|
ARG_PARSEFLAGS, VIR_DOMAIN_DEF_PARSE_ABI_UPDATE, \
|
|
|
|
ARG_FLAGS, FLAG_EXPECT_PARSE_ERROR, \
|
|
|
|
ARG_END)
|
2023-05-16 14:50:37 +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")
|
|
|
|
|
2023-05-16 14:50:37 +00:00
|
|
|
# define DO_TEST_CAPS_LATEST_ABI_UPDATE_PARSE_ERROR(name) \
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE_PARSE_ERROR(name, "x86_64")
|
|
|
|
|
2019-07-02 15:37:20 +00:00
|
|
|
# define DO_TEST_CAPS_VER_PARSE_ERROR(name, ver) \
|
|
|
|
DO_TEST_CAPS_ARCH_VER_PARSE_ERROR(name, "x86_64", ver)
|
|
|
|
|
2023-09-01 08:04:18 +00:00
|
|
|
# define DO_TEST_GIC(name, ver, gic) \
|
2023-12-01 15:27:26 +00:00
|
|
|
DO_TEST_CAPS_ARCH_VER_FULL(name, "aarch64", ver, ARG_GIC, gic, ARG_FLAGS, FLAG_ALLOW_DUPLICATE_OUTPUT, ARG_END)
|
2016-05-10 10:36:10 +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");
|
2022-08-17 13:41:57 +00:00
|
|
|
g_unsetenv("DYLD_INSERT_LIBRARIES");
|
|
|
|
g_unsetenv("DYLD_FORCE_FLAT_NAMESPACE");
|
2019-12-18 17:16:19 +00:00
|
|
|
g_unsetenv("QEMU_AUDIO_DRV");
|
|
|
|
g_unsetenv("SDL_AUDIODRIVER");
|
2023-05-10 10:58:44 +00:00
|
|
|
g_unsetenv("PIPEWIRE_CORE");
|
|
|
|
g_unsetenv("PIPEWIRE_REMOTE");
|
|
|
|
g_unsetenv("PIPEWIRE_RUNTIME_DIR");
|
2008-10-10 16:52:20 +00:00
|
|
|
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("minimal");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("minimal-no-memory");
|
2018-03-20 22:29:46 +00:00
|
|
|
|
|
|
|
DO_TEST_CAPS_LATEST("genid");
|
|
|
|
DO_TEST_CAPS_LATEST("genid-auto");
|
|
|
|
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("machine-aliases1");
|
|
|
|
DO_TEST_CAPS_LATEST("machine-aliases2");
|
|
|
|
DO_TEST_CAPS_LATEST("machine-core-on");
|
2016-08-03 15:20:19 +00:00
|
|
|
driver.config->dumpGuestCore = true;
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("machine-core-off");
|
2016-08-03 15:20:19 +00:00
|
|
|
driver.config->dumpGuestCore = false;
|
2022-05-13 14:00:09 +00:00
|
|
|
DO_TEST_CAPS_LATEST("machine-smm-on");
|
2022-05-13 14:05:26 +00:00
|
|
|
DO_TEST_CAPS_LATEST("machine-smm-off");
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("machine-vmport-opt");
|
|
|
|
DO_TEST_CAPS_LATEST("default-kvm-host-arch");
|
|
|
|
DO_TEST_CAPS_LATEST("default-qemu-host-arch");
|
2022-01-05 21:19:40 +00:00
|
|
|
DO_TEST_CAPS_LATEST("x86-kvm-32-on-64");
|
2022-08-23 13:13:53 +00:00
|
|
|
DO_TEST_CAPS_LATEST("boot-cdrom");
|
|
|
|
DO_TEST_CAPS_LATEST("boot-network");
|
|
|
|
DO_TEST_CAPS_LATEST("boot-floppy");
|
|
|
|
DO_TEST_CAPS_LATEST("boot-floppy-q35");
|
|
|
|
DO_TEST_CAPS_LATEST("boot-multi");
|
|
|
|
DO_TEST_CAPS_LATEST("boot-menu-enable");
|
|
|
|
DO_TEST_CAPS_LATEST("boot-menu-enable-with-timeout");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("boot-menu-enable-with-timeout-invalid");
|
|
|
|
DO_TEST_CAPS_LATEST("boot-menu-disable");
|
|
|
|
DO_TEST_CAPS_LATEST("boot-menu-disable-drive");
|
|
|
|
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("boot-dev+order");
|
|
|
|
DO_TEST_CAPS_LATEST("boot-order");
|
|
|
|
DO_TEST_CAPS_LATEST("boot-complex");
|
2012-09-18 10:32:07 +00:00
|
|
|
|
2021-02-24 14:40:19 +00:00
|
|
|
DO_TEST_CAPS_LATEST("audio-none-minimal");
|
|
|
|
DO_TEST_CAPS_LATEST("audio-alsa-minimal");
|
|
|
|
DO_TEST_CAPS_LATEST("audio-coreaudio-minimal");
|
|
|
|
DO_TEST_CAPS_LATEST("audio-jack-minimal");
|
|
|
|
DO_TEST_CAPS_LATEST("audio-oss-minimal");
|
|
|
|
DO_TEST_CAPS_LATEST("audio-pulseaudio-minimal");
|
2023-05-10 10:58:44 +00:00
|
|
|
g_setenv("PIPEWIRE_RUNTIME_DIR", "/run/user/1000", TRUE);
|
|
|
|
DO_TEST_CAPS_LATEST("audio-pipewire-minimal");
|
|
|
|
g_unsetenv("PIPEWIRE_RUNTIME_DIR");
|
2021-02-24 14:40:19 +00:00
|
|
|
DO_TEST_CAPS_LATEST("audio-sdl-minimal");
|
|
|
|
DO_TEST_CAPS_LATEST("audio-spice-minimal");
|
|
|
|
DO_TEST_CAPS_LATEST("audio-file-minimal");
|
|
|
|
|
2021-03-02 17:22:47 +00:00
|
|
|
DO_TEST_CAPS_LATEST("audio-none-best");
|
|
|
|
DO_TEST_CAPS_LATEST("audio-alsa-best");
|
|
|
|
DO_TEST_CAPS_LATEST("audio-coreaudio-best");
|
2021-02-24 14:40:19 +00:00
|
|
|
DO_TEST_CAPS_LATEST("audio-oss-best");
|
2021-03-02 17:22:47 +00:00
|
|
|
DO_TEST_CAPS_LATEST("audio-pulseaudio-best");
|
2023-05-10 10:58:44 +00:00
|
|
|
DO_TEST_CAPS_LATEST("audio-pipewire-best");
|
2021-02-24 14:40:19 +00:00
|
|
|
DO_TEST_CAPS_LATEST("audio-sdl-best");
|
2021-03-02 17:22:47 +00:00
|
|
|
DO_TEST_CAPS_LATEST("audio-spice-best");
|
|
|
|
DO_TEST_CAPS_LATEST("audio-file-best");
|
|
|
|
|
|
|
|
DO_TEST_CAPS_LATEST("audio-none-full");
|
|
|
|
DO_TEST_CAPS_LATEST("audio-alsa-full");
|
|
|
|
DO_TEST_CAPS_LATEST("audio-coreaudio-full");
|
|
|
|
DO_TEST_CAPS_LATEST("audio-jack-full");
|
|
|
|
DO_TEST_CAPS_LATEST("audio-oss-full");
|
|
|
|
DO_TEST_CAPS_LATEST("audio-pulseaudio-full");
|
2023-05-10 10:58:44 +00:00
|
|
|
DO_TEST_CAPS_LATEST("audio-pipewire-full");
|
2021-03-02 17:22:47 +00:00
|
|
|
DO_TEST_CAPS_LATEST("audio-sdl-full");
|
|
|
|
DO_TEST_CAPS_LATEST("audio-spice-full");
|
|
|
|
DO_TEST_CAPS_LATEST("audio-file-full");
|
2021-02-24 14:40:19 +00:00
|
|
|
|
2023-05-10 10:58:44 +00:00
|
|
|
g_setenv("PIPEWIRE_RUNTIME_DIR", "/run/user/1000", TRUE);
|
2021-02-24 14:40:19 +00:00
|
|
|
DO_TEST_CAPS_LATEST("audio-many-backends");
|
2023-05-10 10:58:44 +00:00
|
|
|
g_unsetenv("PIPEWIRE_RUNTIME_DIR");
|
2021-02-23 18:32:25 +00:00
|
|
|
|
2021-02-24 14:24:10 +00:00
|
|
|
/* Validate auto-creation of <audio> for legacy compat */
|
|
|
|
g_setenv("QEMU_AUDIO_DRV", "sdl", TRUE);
|
|
|
|
g_setenv("SDL_AUDIODRIVER", "esd", TRUE);
|
2023-05-09 15:24:51 +00:00
|
|
|
DO_TEST_CAPS_VER("audio-default-sdl", "4.2.0");
|
2021-02-24 14:40:19 +00:00
|
|
|
DO_TEST_CAPS_LATEST("audio-default-sdl");
|
2021-02-24 14:24:10 +00:00
|
|
|
g_unsetenv("QEMU_AUDIO_DRV");
|
|
|
|
g_unsetenv("SDL_AUDIODRIVER");
|
|
|
|
|
|
|
|
g_setenv("QEMU_AUDIO_DRV", "alsa", TRUE);
|
|
|
|
driver.config->vncAllowHostAudio = true;
|
2023-05-09 15:24:51 +00:00
|
|
|
DO_TEST_CAPS_VER("audio-default-vnc", "4.2.0");
|
2021-02-24 14:40:19 +00:00
|
|
|
DO_TEST_CAPS_LATEST("audio-default-vnc");
|
2021-02-24 14:24:10 +00:00
|
|
|
driver.config->vncAllowHostAudio = false;
|
|
|
|
g_unsetenv("QEMU_AUDIO_DRV");
|
|
|
|
|
2023-05-09 15:24:51 +00:00
|
|
|
DO_TEST_CAPS_VER("audio-default-spice", "4.2.0");
|
2021-02-24 14:40:19 +00:00
|
|
|
DO_TEST_CAPS_LATEST("audio-default-spice");
|
2021-02-24 14:24:10 +00:00
|
|
|
|
|
|
|
g_setenv("QEMU_AUDIO_DRV", "alsa", TRUE);
|
|
|
|
driver.config->nogfxAllowHostAudio = true;
|
2021-02-24 14:40:19 +00:00
|
|
|
DO_TEST_CAPS_LATEST("audio-default-nographics");
|
2021-02-24 14:24:10 +00:00
|
|
|
driver.config->nogfxAllowHostAudio = false;
|
|
|
|
g_unsetenv("QEMU_AUDIO_DRV");
|
|
|
|
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("reboot-timeout-disabled");
|
|
|
|
DO_TEST_CAPS_LATEST("reboot-timeout-enabled");
|
2012-09-18 10:32:07 +00:00
|
|
|
|
2023-02-08 18:10:48 +00:00
|
|
|
DO_TEST_CAPS_LATEST("firmware-manual-bios");
|
|
|
|
DO_TEST_CAPS_LATEST("firmware-manual-bios-stateless");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("firmware-manual-bios-not-stateless");
|
|
|
|
DO_TEST_CAPS_LATEST("firmware-manual-efi");
|
2023-04-11 15:56:45 +00:00
|
|
|
DO_TEST_CAPS_LATEST("firmware-manual-efi-features");
|
2024-01-26 10:56:54 +00:00
|
|
|
DO_TEST_CAPS_LATEST_ABI_UPDATE_PARSE_ERROR("firmware-manual-efi-features");
|
2023-01-26 14:23:38 +00:00
|
|
|
DO_TEST_CAPS_LATEST("firmware-manual-efi-rw");
|
2023-05-26 16:19:24 +00:00
|
|
|
DO_TEST_CAPS_LATEST("firmware-manual-efi-rw-legacy-paths");
|
|
|
|
DO_TEST_CAPS_LATEST("firmware-manual-efi-rw-modern-paths");
|
2023-01-26 14:23:38 +00:00
|
|
|
DO_TEST_CAPS_LATEST("firmware-manual-efi-rw-implicit");
|
2023-03-16 16:36:45 +00:00
|
|
|
DO_TEST_CAPS_LATEST("firmware-manual-efi-loader-secure");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("firmware-manual-efi-loader-no-path");
|
2023-05-26 12:40:02 +00:00
|
|
|
DO_TEST_CAPS_LATEST("firmware-manual-efi-loader-path-nonstandard");
|
2023-03-15 18:39:06 +00:00
|
|
|
DO_TEST_CAPS_LATEST("firmware-manual-efi-secboot");
|
|
|
|
DO_TEST_CAPS_LATEST("firmware-manual-efi-no-enrolled-keys");
|
|
|
|
DO_TEST_CAPS_LATEST("firmware-manual-efi-no-secboot");
|
2022-07-22 15:59:43 +00:00
|
|
|
DO_TEST_CAPS_LATEST("firmware-manual-efi-stateless");
|
2022-06-09 13:54:36 +00:00
|
|
|
DO_TEST_CAPS_LATEST("firmware-manual-efi-nvram-template");
|
2023-05-26 12:40:02 +00:00
|
|
|
DO_TEST_CAPS_LATEST("firmware-manual-efi-nvram-template-nonstandard");
|
conf: support stateless UEFI firmware
Normally when an UEFI firmware is marked as read-only, an associated
NVRAM file will be created. Some builds of UEFI firmware, however, wish
to remain stateless and so will be read-only, but never have any NVRAM
file. To represent this concept a 'stateless' tristate bool attribute
is introduced on the <loader/> element.
There are rather a large number of permutations to consider.
With default firmware selection
* <os/>
=> Historic default, no change
* <os>
<loader stateless='yes'/>
</os>
=> Explicit version of historic default, no change
* <os>
<loader stateless='no'/>
</os>
=> Invalid, bios is always stateless
With manual legacy BIOS selection
* <os>
<loader>/path/to/seabios</loader>
...
</os>
=> Historic default, no change
* <os>
<loader stateless='yes'>/path/to/seabios</loader>
...
</os>
=> Explicit version of historic default, no change
* <os>
<loader stateless='no'>/path/to/seabios</loader>
...
</os>
=> Invalid, bios is always stateless
With manual UEFI selection
* <os>
<loader type='pflash'>/path/to/edk2</loader>
...
</os>
=> Historic default, no change
* <os>
<loader type='pflash' stateless='yes'>/path/to/edk2</loader>
...
</os>
=> Skip auto-filling NVRAM / template
* <os>
<loader type='pflash' stateless='no'>/path/to/edk2</loader>
...
</os>
=> Explicit version of historic default, no change
With automatic firmware selection
* <os firmware='bios'/>
=> Historic default, no change
* <os firmware='bios'>
<loader stateless='yes'/>
</os>
=> Explicit version of historic default, no change
* <os firmware='bios'>
<loader stateless='no'/>
</os>
=> Invalid, bios is always stateless
* <os firmware='uefi'/>
=> Historic default, no change
* <os firmware='uefi'>
<loader stateless='yes'/>
</os>
=> Skip auto-filling NVRAM / template
* <os firmware='uefi'>
<loader stateless='no'/>
</os>
=> Explicit version of historic default, no change
Reviewed-by: Michal Privoznik <mprivozn@redhat.com>
Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
2022-07-22 14:27:55 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("firmware-manual-efi-nvram-template-stateless");
|
2022-06-09 13:54:36 +00:00
|
|
|
DO_TEST_CAPS_LATEST("firmware-manual-efi-nvram-network-iscsi");
|
|
|
|
DO_TEST_CAPS_LATEST("firmware-manual-efi-nvram-network-nbd");
|
|
|
|
DO_TEST_CAPS_LATEST("firmware-manual-efi-nvram-file");
|
conf: support stateless UEFI firmware
Normally when an UEFI firmware is marked as read-only, an associated
NVRAM file will be created. Some builds of UEFI firmware, however, wish
to remain stateless and so will be read-only, but never have any NVRAM
file. To represent this concept a 'stateless' tristate bool attribute
is introduced on the <loader/> element.
There are rather a large number of permutations to consider.
With default firmware selection
* <os/>
=> Historic default, no change
* <os>
<loader stateless='yes'/>
</os>
=> Explicit version of historic default, no change
* <os>
<loader stateless='no'/>
</os>
=> Invalid, bios is always stateless
With manual legacy BIOS selection
* <os>
<loader>/path/to/seabios</loader>
...
</os>
=> Historic default, no change
* <os>
<loader stateless='yes'>/path/to/seabios</loader>
...
</os>
=> Explicit version of historic default, no change
* <os>
<loader stateless='no'>/path/to/seabios</loader>
...
</os>
=> Invalid, bios is always stateless
With manual UEFI selection
* <os>
<loader type='pflash'>/path/to/edk2</loader>
...
</os>
=> Historic default, no change
* <os>
<loader type='pflash' stateless='yes'>/path/to/edk2</loader>
...
</os>
=> Skip auto-filling NVRAM / template
* <os>
<loader type='pflash' stateless='no'>/path/to/edk2</loader>
...
</os>
=> Explicit version of historic default, no change
With automatic firmware selection
* <os firmware='bios'/>
=> Historic default, no change
* <os firmware='bios'>
<loader stateless='yes'/>
</os>
=> Explicit version of historic default, no change
* <os firmware='bios'>
<loader stateless='no'/>
</os>
=> Invalid, bios is always stateless
* <os firmware='uefi'/>
=> Historic default, no change
* <os firmware='uefi'>
<loader stateless='yes'/>
</os>
=> Skip auto-filling NVRAM / template
* <os firmware='uefi'>
<loader stateless='no'/>
</os>
=> Explicit version of historic default, no change
Reviewed-by: Michal Privoznik <mprivozn@redhat.com>
Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
2022-07-22 14:27:55 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("firmware-manual-efi-nvram-stateless");
|
2017-03-09 15:38:56 +00:00
|
|
|
|
|
|
|
/* Make sure all combinations of ACPI and UEFI behave as expected */
|
2023-02-08 18:10:48 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("firmware-manual-efi-acpi-aarch64", "aarch64");
|
|
|
|
DO_TEST_CAPS_LATEST("firmware-manual-efi-acpi-q35");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("firmware-manual-efi-noacpi-aarch64", "aarch64");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("firmware-manual-efi-noacpi-q35");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("firmware-manual-noefi-acpi-aarch64", "aarch64");
|
|
|
|
DO_TEST_CAPS_LATEST("firmware-manual-noefi-acpi-q35");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("firmware-manual-noefi-noacpi-aarch64", "aarch64");
|
|
|
|
DO_TEST_CAPS_LATEST("firmware-manual-noefi-noacpi-q35");
|
2022-06-09 13:54:36 +00:00
|
|
|
|
2023-05-26 16:19:24 +00:00
|
|
|
/* Ensure that legacy firmware paths keep working */
|
|
|
|
DO_TEST_CAPS_LATEST("firmware-manual-efi-secboot-legacy-paths");
|
|
|
|
DO_TEST_CAPS_LATEST("firmware-manual-efi-no-enrolled-keys-legacy-paths");
|
|
|
|
DO_TEST_CAPS_LATEST("firmware-manual-efi-no-secboot-legacy-paths");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("firmware-manual-efi-aarch64-legacy-paths", "aarch64");
|
|
|
|
|
2022-06-09 13:54:36 +00:00
|
|
|
DO_TEST_CAPS_LATEST("firmware-auto-bios");
|
conf: support stateless UEFI firmware
Normally when an UEFI firmware is marked as read-only, an associated
NVRAM file will be created. Some builds of UEFI firmware, however, wish
to remain stateless and so will be read-only, but never have any NVRAM
file. To represent this concept a 'stateless' tristate bool attribute
is introduced on the <loader/> element.
There are rather a large number of permutations to consider.
With default firmware selection
* <os/>
=> Historic default, no change
* <os>
<loader stateless='yes'/>
</os>
=> Explicit version of historic default, no change
* <os>
<loader stateless='no'/>
</os>
=> Invalid, bios is always stateless
With manual legacy BIOS selection
* <os>
<loader>/path/to/seabios</loader>
...
</os>
=> Historic default, no change
* <os>
<loader stateless='yes'>/path/to/seabios</loader>
...
</os>
=> Explicit version of historic default, no change
* <os>
<loader stateless='no'>/path/to/seabios</loader>
...
</os>
=> Invalid, bios is always stateless
With manual UEFI selection
* <os>
<loader type='pflash'>/path/to/edk2</loader>
...
</os>
=> Historic default, no change
* <os>
<loader type='pflash' stateless='yes'>/path/to/edk2</loader>
...
</os>
=> Skip auto-filling NVRAM / template
* <os>
<loader type='pflash' stateless='no'>/path/to/edk2</loader>
...
</os>
=> Explicit version of historic default, no change
With automatic firmware selection
* <os firmware='bios'/>
=> Historic default, no change
* <os firmware='bios'>
<loader stateless='yes'/>
</os>
=> Explicit version of historic default, no change
* <os firmware='bios'>
<loader stateless='no'/>
</os>
=> Invalid, bios is always stateless
* <os firmware='uefi'/>
=> Historic default, no change
* <os firmware='uefi'>
<loader stateless='yes'/>
</os>
=> Skip auto-filling NVRAM / template
* <os firmware='uefi'>
<loader stateless='no'/>
</os>
=> Explicit version of historic default, no change
Reviewed-by: Michal Privoznik <mprivozn@redhat.com>
Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
2022-07-22 14:27:55 +00:00
|
|
|
DO_TEST_CAPS_LATEST("firmware-auto-bios-stateless");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("firmware-auto-bios-not-stateless");
|
2022-06-15 10:00:58 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("firmware-auto-bios-nvram");
|
2022-06-09 13:54:36 +00:00
|
|
|
DO_TEST_CAPS_LATEST("firmware-auto-efi");
|
2024-01-26 10:57:21 +00:00
|
|
|
DO_TEST_CAPS_LATEST_ABI_UPDATE("firmware-auto-efi");
|
2022-07-22 15:59:43 +00:00
|
|
|
DO_TEST_CAPS_LATEST("firmware-auto-efi-stateless");
|
2023-05-30 16:01:58 +00:00
|
|
|
DO_TEST_CAPS_LATEST_FAILURE("firmware-auto-efi-rw");
|
2024-01-26 10:57:21 +00:00
|
|
|
DO_TEST_CAPS_LATEST_ABI_UPDATE_PARSE_ERROR("firmware-auto-efi-rw");
|
2022-06-09 13:54:36 +00:00
|
|
|
DO_TEST_CAPS_LATEST("firmware-auto-efi-loader-secure");
|
2024-01-26 10:57:21 +00:00
|
|
|
DO_TEST_CAPS_LATEST_ABI_UPDATE("firmware-auto-efi-loader-secure");
|
conf: Remove some firmware validation checks
libvirt 8.6.0 introduced these checks and very clearly delineated
two possible firmware selection scenarios: manual firmware
selection, where the user is responsible for providing all
information, and firmware autoselection, where a list of desired
features is provided and everything else is handled by libvirt.
In the interest of maintaining the clear separation between these
two scenarios, setting most attributes when firmware autoselection
is active will result in the configuration being rejected.
This works fine, but is unnecessarily restrictive: in most cases,
the additional information that the user has provided matches
the information that libvirt would have discovered on its own by
looking at firmware descriptors, and asking the user to scrub it
from the XML only result in pointless friction.
Remove these checks entirely.
Unsurprisingly, this results in a few test cases that were
rejected until now to suddenly start working and producing
sensible results.
The firmware-auto-efi-loader-path-nonstandard test case is
notable: while we can now enable the xml2xml part of the test,
the xml2argv part is still failing, although in a slightly
different way. This is expected: since the firmware binary is a
non-standard one, libvirt is unable to figure out the missing
information from a firmware descriptor, and the configuration
is still ultimately an invalid one. However, if we were to find
such a configuration on disk at daemon startup, we would not
ignore it completely and instead would offer the user a chance
to fix it.
Signed-off-by: Andrea Bolognani <abologna@redhat.com>
Reviewed-by: Michal Privoznik <mprivozn@redhat.com>
2023-03-14 22:02:46 +00:00
|
|
|
DO_TEST_CAPS_LATEST("firmware-auto-efi-loader-insecure");
|
|
|
|
DO_TEST_CAPS_LATEST("firmware-auto-efi-loader-path");
|
|
|
|
DO_TEST_CAPS_LATEST_FAILURE("firmware-auto-efi-loader-path-nonstandard");
|
2022-06-09 13:56:32 +00:00
|
|
|
DO_TEST_CAPS_LATEST("firmware-auto-efi-secboot");
|
|
|
|
DO_TEST_CAPS_LATEST("firmware-auto-efi-no-secboot");
|
|
|
|
DO_TEST_CAPS_LATEST("firmware-auto-efi-enrolled-keys");
|
2022-06-09 13:54:36 +00:00
|
|
|
DO_TEST_CAPS_LATEST("firmware-auto-efi-no-enrolled-keys");
|
2022-06-15 09:30:48 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("firmware-auto-efi-enrolled-keys-no-secboot");
|
2023-01-27 16:22:24 +00:00
|
|
|
DO_TEST_CAPS_LATEST("firmware-auto-efi-smm-off");
|
2022-06-09 13:54:36 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("firmware-auto-efi-aarch64", "aarch64");
|
2024-01-26 10:57:21 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE("firmware-auto-efi-aarch64", "aarch64");
|
2023-05-26 16:16:24 +00:00
|
|
|
DO_TEST_CAPS_LATEST("firmware-auto-efi-nvram-path");
|
2023-05-26 16:19:24 +00:00
|
|
|
DO_TEST_CAPS_LATEST("firmware-auto-efi-nvram-template");
|
|
|
|
DO_TEST_CAPS_LATEST_FAILURE("firmware-auto-efi-nvram-template-nonstandard");
|
2023-02-10 16:40:29 +00:00
|
|
|
DO_TEST_CAPS_LATEST("firmware-auto-efi-nvram-file");
|
|
|
|
DO_TEST_CAPS_LATEST("firmware-auto-efi-nvram-network-nbd");
|
|
|
|
DO_TEST_CAPS_LATEST("firmware-auto-efi-nvram-network-iscsi");
|
2021-08-17 08:35:53 +00:00
|
|
|
|
2023-02-08 17:47:39 +00:00
|
|
|
DO_TEST_CAPS_LATEST("firmware-auto-efi-format-loader-qcow2");
|
2023-08-03 13:19:59 +00:00
|
|
|
DO_TEST_CAPS_LATEST("firmware-auto-efi-format-loader-qcow2-nvram-path");
|
2023-02-08 17:47:39 +00:00
|
|
|
DO_TEST_CAPS_LATEST("firmware-auto-efi-format-nvram-qcow2");
|
|
|
|
DO_TEST_CAPS_LATEST("firmware-auto-efi-format-nvram-qcow2-path");
|
|
|
|
DO_TEST_CAPS_LATEST("firmware-auto-efi-format-nvram-qcow2-network-nbd");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("firmware-auto-efi-format-loader-raw", "aarch64");
|
2024-01-26 10:57:21 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE("firmware-auto-efi-format-loader-raw", "aarch64");
|
2023-08-03 13:22:10 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("firmware-auto-efi-format-mismatch");
|
2023-02-08 17:47:39 +00:00
|
|
|
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("clock-utc");
|
|
|
|
DO_TEST_CAPS_LATEST("clock-localtime");
|
|
|
|
DO_TEST_CAPS_LATEST("clock-localtime-basis-localtime");
|
|
|
|
DO_TEST_CAPS_LATEST("clock-variable");
|
|
|
|
DO_TEST_CAPS_LATEST("clock-france");
|
2023-09-04 13:49:50 +00:00
|
|
|
DO_TEST_CAPS_VER("clock-hpet-off", "7.2.0");
|
|
|
|
DO_TEST_CAPS_LATEST("clock-hpet-off");
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("clock-catchup");
|
2023-09-14 13:15:55 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-kvmclock", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("cpu-host-kvmclock");
|
|
|
|
DO_TEST_CAPS_LATEST("kvmclock");
|
|
|
|
DO_TEST_CAPS_LATEST("clock-timer-hyperv-rtc");
|
2023-08-14 12:28:48 +00:00
|
|
|
DO_TEST_CAPS_LATEST("clock-realtime");
|
2022-04-26 15:21:51 +00:00
|
|
|
DO_TEST_CAPS_LATEST("clock-absolute");
|
2012-07-09 16:29:55 +00:00
|
|
|
|
2022-01-05 12:01:10 +00:00
|
|
|
DO_TEST_CAPS_LATEST("controller-usb-order");
|
|
|
|
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("controller-order");
|
2022-06-21 15:07:51 +00:00
|
|
|
/* 'eoi' cpu feature with an explicit CPU defined */
|
|
|
|
DO_TEST_CAPS_LATEST("cpu-eoi-disabled");
|
|
|
|
DO_TEST_CAPS_LATEST("cpu-eoi-enabled");
|
|
|
|
/* 'eoi' cpu feature without an explicit CPU defined */
|
2019-06-12 10:08:06 +00:00
|
|
|
DO_TEST_CAPS_LATEST("eoi-disabled");
|
|
|
|
DO_TEST_CAPS_LATEST("eoi-enabled");
|
|
|
|
DO_TEST_CAPS_LATEST("pv-spinlock-disabled");
|
|
|
|
DO_TEST_CAPS_LATEST("pv-spinlock-enabled");
|
|
|
|
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_LATEST("hyperv");
|
|
|
|
DO_TEST_CAPS_LATEST("hyperv-off");
|
|
|
|
DO_TEST_CAPS_LATEST("hyperv-panic");
|
2021-11-25 18:57:49 +00:00
|
|
|
DO_TEST_CAPS_VER("hyperv-passthrough", "6.1.0");
|
|
|
|
DO_TEST_CAPS_LATEST("hyperv-passthrough");
|
2019-08-09 14:31:40 +00:00
|
|
|
DO_TEST_CAPS_LATEST("hyperv-stimer-direct");
|
2012-10-17 12:55:18 +00:00
|
|
|
|
2023-08-14 12:28:48 +00:00
|
|
|
DO_TEST_CAPS_LATEST("kvm-features");
|
|
|
|
DO_TEST_CAPS_LATEST("kvm-features-off");
|
2014-08-21 17:04:45 +00:00
|
|
|
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("pmu-feature");
|
|
|
|
DO_TEST_CAPS_LATEST("pmu-feature-off");
|
2015-01-05 15:52:18 +00:00
|
|
|
|
2022-11-02 13:10:41 +00:00
|
|
|
DO_TEST_CAPS_LATEST("pages-discard");
|
|
|
|
DO_TEST_CAPS_LATEST("pages-discard-hugepages");
|
|
|
|
DO_TEST_CAPS_LATEST("pages-dimm-discard");
|
|
|
|
DO_TEST_CAPS_LATEST("hugepages-default");
|
|
|
|
DO_TEST_CAPS_LATEST("hugepages-default-2M");
|
|
|
|
DO_TEST_CAPS_LATEST("hugepages-default-system-size");
|
2022-02-22 08:02:17 +00:00
|
|
|
DO_TEST_CAPS_LATEST_FAILURE("hugepages-default-5M");
|
2023-08-31 12:58:30 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("hugepages-default-1G-nodeset-2M");
|
2022-11-02 13:10:41 +00:00
|
|
|
DO_TEST_CAPS_LATEST("hugepages-nodeset");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("hugepages-nodeset-nonexist");
|
|
|
|
DO_TEST_CAPS_LATEST("hugepages-numa-default");
|
|
|
|
DO_TEST_CAPS_LATEST("hugepages-numa-default-2M");
|
|
|
|
DO_TEST_CAPS_LATEST("hugepages-numa-default-dimm");
|
|
|
|
DO_TEST_CAPS_LATEST("hugepages-numa-nodeset");
|
|
|
|
DO_TEST_CAPS_LATEST("hugepages-numa-nodeset-part");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("hugepages-numa-nodeset-nonexist");
|
|
|
|
DO_TEST_CAPS_LATEST("hugepages-shared");
|
2023-08-31 12:58:30 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("hugepages-memaccess-invalid");
|
2022-11-02 13:10:41 +00:00
|
|
|
DO_TEST_CAPS_LATEST("hugepages-memaccess");
|
|
|
|
DO_TEST_CAPS_LATEST("hugepages-memaccess2");
|
2023-08-31 12:58:30 +00:00
|
|
|
DO_TEST_CAPS_VER_PARSE_ERROR("hugepages-memaccess3", "5.1.0");
|
2020-12-14 11:20:07 +00:00
|
|
|
DO_TEST_CAPS_LATEST("hugepages-memaccess3");
|
2018-08-09 14:29:17 +00:00
|
|
|
DO_TEST_CAPS_LATEST("hugepages-nvdimm");
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("nosharepages");
|
2021-09-21 14:35:51 +00:00
|
|
|
|
2022-09-30 13:45:08 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("non-x86_64-timer-error", "s390x");
|
2021-09-21 14:35:51 +00:00
|
|
|
|
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");
|
2018-07-19 12:07:17 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-cdrom-network");
|
|
|
|
DO_TEST_CAPS_LATEST("disk-cdrom-tray");
|
2018-07-19 15:30:07 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-floppy");
|
2022-01-05 09:07:41 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-floppy-q35");
|
2021-09-22 08:46:06 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FAILURE("disk-floppy-pseries", "ppc64");
|
2021-09-22 08:21:43 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-floppy-tray");
|
|
|
|
DO_TEST_CAPS_LATEST("disk-virtio");
|
2021-09-22 08:58:22 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("disk-virtio-ccw", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("disk-virtio-ccw-many", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("disk-virtio-s390-zpci", "s390x");
|
2021-09-22 08:21:43 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-order");
|
2021-09-09 03:34:44 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-virtio-queues");
|
2021-09-22 08:21:43 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-boot-disk");
|
|
|
|
DO_TEST_CAPS_LATEST("disk-boot-cdrom");
|
2018-07-19 15:30:07 +00:00
|
|
|
DO_TEST_CAPS_LATEST("floppy-drive-fat");
|
2018-07-19 15:30:07 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-readonly-disk");
|
2021-09-22 08:41:52 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-fmt-qcow");
|
2021-09-21 17:14:19 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-fmt-cow");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-fmt-dir");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-fmt-iso");
|
2018-07-19 15:30:07 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-shared");
|
2021-09-21 17:14:19 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-shared-qcow");
|
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_LATEST("disk-error-policy-s390x", "s390x");
|
2018-07-19 12:51:21 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-cache");
|
2021-01-06 17:20:29 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-metadata-cache");
|
2020-09-24 10:23:24 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-transient");
|
2018-07-19 14:29:19 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-network-nbd");
|
2018-07-19 14:19:32 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-network-iscsi");
|
2021-09-21 17:14:19 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-network-iscsi-auth-secrettype-invalid");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-network-iscsi-auth-wrong-secrettype");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-network-source-auth-both");
|
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_LATEST("disk-network-rbd");
|
2021-10-24 09:51:29 +00:00
|
|
|
DO_TEST_CAPS_VER_PARSE_ERROR("disk-network-rbd-encryption", "6.0.0");
|
|
|
|
DO_TEST_CAPS_LATEST("disk-network-rbd-encryption");
|
2023-03-13 09:50:21 +00:00
|
|
|
DO_TEST_CAPS_VER_PARSE_ERROR("disk-network-rbd-encryption-layering", "7.2.0");
|
|
|
|
DO_TEST_CAPS_LATEST("disk-network-rbd-encryption-layering");
|
2023-03-13 09:50:23 +00:00
|
|
|
DO_TEST_CAPS_VER_PARSE_ERROR("disk-network-rbd-encryption-luks-any", "7.2.0");
|
|
|
|
DO_TEST_CAPS_LATEST("disk-network-rbd-encryption-luks-any");
|
2022-04-22 14:33:28 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-encryption-wrong");
|
2021-09-22 08:30:56 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-network-rbd-no-colon");
|
2022-02-10 08:47:19 +00:00
|
|
|
/* qemu-6.0 is the last qemu version supporting sheepdog */
|
2021-05-17 08:38:25 +00:00
|
|
|
DO_TEST_CAPS_VER("disk-network-sheepdog", "6.0.0");
|
2018-07-19 15:30:07 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-network-source-auth");
|
2022-07-08 22:13:34 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-network-source-curl");
|
2021-01-06 21:32:32 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-network-nfs");
|
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");
|
2021-03-12 16:56:49 +00:00
|
|
|
DO_TEST_CAPS_VER("disk-network-tlsx509-nbd", "5.2.0");
|
2020-07-30 15:29:44 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-network-tlsx509-nbd");
|
2022-03-10 09:05:53 +00:00
|
|
|
DO_TEST_CAPS_VER_PARSE_ERROR("disk-network-tlsx509-nbd-hostname", "6.2.0");
|
|
|
|
DO_TEST_CAPS_LATEST("disk-network-tlsx509-nbd-hostname");
|
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");
|
2023-03-06 12:43:01 +00:00
|
|
|
VIR_FREE(driver.config->nbdTLSx509secretUUID);
|
|
|
|
VIR_FREE(driver.config->vxhsTLSx509secretUUID);
|
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;
|
2022-07-05 20:53:57 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-network-ssh");
|
2021-09-22 08:21:43 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-no-boot");
|
2019-06-21 13:07:22 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-nvme");
|
2022-01-13 11:47:17 +00:00
|
|
|
DO_TEST_CAPS_VER("disk-vhostuser-numa", "4.2.0");
|
|
|
|
DO_TEST_CAPS_LATEST("disk-vhostuser-numa");
|
2021-02-01 11:00:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-vhostuser");
|
2023-03-17 14:58:36 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL("disk-vhostvdpa", "x86_64",
|
2023-10-25 14:48:18 +00:00
|
|
|
ARG_VDPA_FD, "/dev/vhost-vdpa-0", 201);
|
2021-09-21 17:14:19 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-device-lun-type-invalid");
|
2019-09-30 13:41:00 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-attaching-partition-nosupport");
|
2021-09-22 08:21:43 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-usb-device");
|
2023-06-05 05:07:29 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-device-removable");
|
2021-09-21 17:14:19 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-usb-pci");
|
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_LATEST("disk-scsi-device-auto");
|
2021-09-22 08:21:43 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-scsi-disk-split");
|
|
|
|
DO_TEST_CAPS_LATEST("disk-scsi-disk-wwn");
|
|
|
|
DO_TEST_CAPS_LATEST("disk-scsi-disk-vpd");
|
2021-09-21 17:14:19 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-scsi-disk-vpd-build-error");
|
2019-01-28 09:47:21 +00:00
|
|
|
DO_TEST_CAPS_LATEST("controller-virtio-scsi");
|
2021-09-22 08:21:43 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-sata-device");
|
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");
|
2021-09-22 08:41:52 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-source-pool");
|
|
|
|
DO_TEST_CAPS_LATEST("disk-source-pool-mode");
|
2021-09-22 08:21:43 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-ioeventfd");
|
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_LATEST("disk-discard");
|
2018-07-19 12:12:19 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-detect-zeroes");
|
2023-06-09 10:47:36 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-discard_no_unref");
|
2021-09-22 08:21:43 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-snapshot");
|
2021-09-21 17:14:19 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-same-targets");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-missing-target-invalid");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-address-conflict");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-hostdev-scsi-address-conflict");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("hostdevs-drive-address-conflict");
|
2021-09-22 08:21:43 +00:00
|
|
|
DO_TEST_CAPS_LATEST("event_idx");
|
|
|
|
DO_TEST_CAPS_LATEST("virtio-lun");
|
|
|
|
DO_TEST_CAPS_LATEST("disk-scsi-lun-passthrough");
|
|
|
|
DO_TEST_CAPS_LATEST("disk-serial");
|
2021-09-21 17:14:19 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-fdc-incompatible-address");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-ide-incompatible-address");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-sata-incompatible-address");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("disk-scsi-incompatible-address");
|
2018-06-19 11:16:54 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-backing-chains-index");
|
|
|
|
DO_TEST_CAPS_LATEST("disk-backing-chains-noindex");
|
2022-12-19 14:54:59 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL("disk-source-fd", "x86_64",
|
2023-10-25 14:48:18 +00:00
|
|
|
ARG_FD_GROUP, "testgroup2", 2, 200, 205,
|
|
|
|
ARG_FD_GROUP, "testgroup5", 1, 204,
|
|
|
|
ARG_FD_GROUP, "testgroup6", 2, 247, 248);
|
2011-06-20 08:26:47 +00:00
|
|
|
|
2020-02-05 17:18:39 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-slices");
|
2021-03-31 09:17:07 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-rotation");
|
2020-02-05 17:18:39 +00:00
|
|
|
|
2020-05-06 09:40:18 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("disk-arm-virtio-sd", "aarch64");
|
|
|
|
|
2021-09-21 14:43:58 +00:00
|
|
|
DO_TEST_CAPS_LATEST("encrypted-disk");
|
|
|
|
DO_TEST_CAPS_LATEST("encrypted-disk-usage");
|
|
|
|
DO_TEST_CAPS_LATEST("luks-disks");
|
|
|
|
DO_TEST_CAPS_LATEST("luks-disks-source");
|
2021-09-21 14:35:51 +00:00
|
|
|
DO_TEST_CAPS_VER("luks-disks-source-qcow2", "5.2.0");
|
|
|
|
DO_TEST_CAPS_LATEST("luks-disks-source-qcow2");
|
2021-09-21 14:43:58 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("luks-disk-invalid");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("luks-disks-source-both");
|
2021-09-21 14:35:51 +00:00
|
|
|
|
2021-09-22 08:21:43 +00:00
|
|
|
DO_TEST_CAPS_LATEST("disk-ide-split");
|
|
|
|
DO_TEST_CAPS_LATEST("disk-ide-wwn");
|
|
|
|
DO_TEST_CAPS_LATEST("disk-geometry");
|
|
|
|
DO_TEST_CAPS_LATEST("disk-blockio");
|
2021-09-21 14:35:51 +00:00
|
|
|
|
2023-11-08 19:14:50 +00:00
|
|
|
driver.config->storageUseNbdkit = 1;
|
|
|
|
DO_TEST_CAPS_LATEST_NBDKIT("disk-cdrom-network-nbdkit", QEMU_NBDKIT_CAPS_PLUGIN_CURL);
|
|
|
|
DO_TEST_CAPS_LATEST_NBDKIT("disk-network-source-curl-nbdkit", QEMU_NBDKIT_CAPS_PLUGIN_CURL);
|
|
|
|
DO_TEST_CAPS_LATEST_NBDKIT("disk-network-source-curl-nbdkit-backing", QEMU_NBDKIT_CAPS_PLUGIN_CURL);
|
|
|
|
DO_TEST_CAPS_LATEST_NBDKIT("disk-network-http-nbdkit", QEMU_NBDKIT_CAPS_PLUGIN_CURL);
|
|
|
|
DO_TEST_CAPS_LATEST_NBDKIT("disk-network-ssh-nbdkit", QEMU_NBDKIT_CAPS_PLUGIN_SSH);
|
|
|
|
DO_TEST_CAPS_LATEST_NBDKIT("disk-network-ssh-password", QEMU_NBDKIT_CAPS_PLUGIN_SSH);
|
2023-12-01 14:19:15 +00:00
|
|
|
DO_TEST_CAPS_LATEST_NBDKIT("disk-network-ssh-key", QEMU_NBDKIT_CAPS_PLUGIN_SSH);
|
2023-11-08 19:14:50 +00:00
|
|
|
driver.config->storageUseNbdkit = 0;
|
|
|
|
|
2021-09-21 14:35:51 +00:00
|
|
|
DO_TEST_CAPS_VER("disk-virtio-scsi-reservations", "5.2.0");
|
|
|
|
DO_TEST_CAPS_LATEST("disk-virtio-scsi-reservations");
|
|
|
|
|
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
|
|
|
|
2021-09-23 15:15:16 +00:00
|
|
|
DO_TEST_CAPS_LATEST("graphics-vnc");
|
2021-09-23 15:12:53 +00:00
|
|
|
DO_TEST_CAPS_LATEST("graphics-vnc-socket");
|
2021-09-23 15:15:16 +00:00
|
|
|
DO_TEST_CAPS_LATEST("graphics-vnc-websocket");
|
|
|
|
DO_TEST_CAPS_LATEST("graphics-vnc-policy");
|
2021-02-16 13:38:06 +00:00
|
|
|
DO_TEST_CAPS_LATEST("graphics-vnc-power");
|
2021-09-23 15:15:16 +00:00
|
|
|
DO_TEST_CAPS_LATEST("graphics-vnc-no-listen-attr");
|
|
|
|
DO_TEST_CAPS_LATEST("graphics-vnc-remove-generated-socket");
|
2016-05-19 08:53:55 +00:00
|
|
|
driver.config->vncAutoUnixSocket = true;
|
2021-09-23 15:12:53 +00:00
|
|
|
DO_TEST_CAPS_LATEST("graphics-vnc-auto-socket-cfg");
|
2016-05-19 08:53:55 +00:00
|
|
|
driver.config->vncAutoUnixSocket = false;
|
2021-09-23 15:12:53 +00:00
|
|
|
DO_TEST_CAPS_LATEST("graphics-vnc-auto-socket");
|
2021-09-23 15:15:16 +00:00
|
|
|
DO_TEST_CAPS_LATEST("graphics-vnc-none");
|
|
|
|
DO_TEST_CAPS_LATEST("graphics-vnc-socket-new-cmdline");
|
2009-03-16 13:54:26 +00:00
|
|
|
|
2013-01-10 21:03:14 +00:00
|
|
|
driver.config->vncSASL = 1;
|
2021-09-23 15:15:16 +00:00
|
|
|
DO_TEST_CAPS_LATEST("graphics-vnc-sasl");
|
2013-01-10 21:03:14 +00:00
|
|
|
driver.config->vncTLS = 1;
|
|
|
|
driver.config->vncTLSx509verify = 1;
|
2018-07-16 13:15:21 +00:00
|
|
|
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");
|
2021-03-12 16:56:49 +00:00
|
|
|
DO_TEST_CAPS_VER("graphics-vnc-tls-secret", "5.2.0");
|
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;
|
2021-09-23 15:15:16 +00:00
|
|
|
DO_TEST_CAPS_LATEST("graphics-vnc-egl-headless");
|
2009-03-16 13:54:26 +00:00
|
|
|
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("graphics-sdl");
|
2018-12-07 13:53:46 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("graphics-sdl-egl-headless");
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("graphics-sdl-fullscreen");
|
2023-03-02 19:23:37 +00:00
|
|
|
|
|
|
|
driver.config->spiceTLS = 1;
|
2021-11-02 14:29:30 +00:00
|
|
|
DO_TEST_CAPS_LATEST("graphics-spice");
|
|
|
|
DO_TEST_CAPS_LATEST("graphics-spice-no-args");
|
2012-02-24 14:13:06 +00:00
|
|
|
driver.config->spiceSASL = 1;
|
2021-11-02 14:29:30 +00:00
|
|
|
DO_TEST_CAPS_LATEST("graphics-spice-sasl");
|
2012-02-24 14:13:06 +00:00
|
|
|
driver.config->spiceSASL = 0;
|
2021-11-02 14:29:30 +00:00
|
|
|
DO_TEST_CAPS_LATEST("graphics-spice-agentmouse");
|
|
|
|
DO_TEST_CAPS_LATEST("graphics-spice-compression");
|
|
|
|
DO_TEST_CAPS_LATEST("graphics-spice-timeout");
|
|
|
|
DO_TEST_CAPS_LATEST("graphics-spice-qxl-vga");
|
|
|
|
DO_TEST_CAPS_LATEST("graphics-spice-usb-redir");
|
|
|
|
DO_TEST_CAPS_LATEST("graphics-spice-agent-file-xfer");
|
|
|
|
DO_TEST_CAPS_LATEST("graphics-spice-socket");
|
|
|
|
DO_TEST_CAPS_LATEST("graphics-spice-auto-socket");
|
2016-05-18 12:11:20 +00:00
|
|
|
driver.config->spiceAutoUnixSocket = true;
|
2021-11-02 14:29:30 +00:00
|
|
|
DO_TEST_CAPS_LATEST("graphics-spice-auto-socket-cfg");
|
2016-05-18 12:11:20 +00:00
|
|
|
driver.config->spiceAutoUnixSocket = false;
|
2021-11-02 14:29:30 +00:00
|
|
|
DO_TEST_CAPS_LATEST("graphics-spice-egl-headless");
|
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");
|
2023-03-02 19:23:37 +00:00
|
|
|
driver.config->spiceTLS = 0;
|
2011-02-08 14:22:39 +00:00
|
|
|
|
2023-08-15 14:30:21 +00:00
|
|
|
DO_TEST_CAPS_LATEST("graphics-dbus");
|
|
|
|
DO_TEST_CAPS_LATEST("graphics-dbus-address");
|
|
|
|
DO_TEST_CAPS_LATEST("graphics-dbus-p2p");
|
|
|
|
DO_TEST_CAPS_LATEST("graphics-dbus-audio");
|
|
|
|
DO_TEST_CAPS_LATEST("graphics-dbus-chardev");
|
|
|
|
DO_TEST_CAPS_LATEST("graphics-dbus-usbredir");
|
2022-05-13 18:38:13 +00:00
|
|
|
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("input-usbmouse");
|
|
|
|
DO_TEST_CAPS_LATEST("input-usbtablet");
|
|
|
|
DO_TEST_CAPS_LATEST("misc-acpi");
|
|
|
|
DO_TEST_CAPS_LATEST("misc-disable-s3");
|
|
|
|
DO_TEST_CAPS_LATEST("misc-disable-suspends");
|
|
|
|
DO_TEST_CAPS_LATEST("misc-enable-s4");
|
2021-09-22 10:50:51 +00:00
|
|
|
DO_TEST_CAPS_VER("misc-no-reboot", "5.2.0");
|
2021-08-23 15:09:30 +00:00
|
|
|
DO_TEST_CAPS_LATEST("misc-no-reboot");
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("misc-uuid");
|
2023-08-16 13:20:37 +00:00
|
|
|
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("vhost_queues-invalid");
|
2023-08-16 13:20:37 +00:00
|
|
|
|
|
|
|
DO_TEST_CAPS_LATEST("net-vhostuser");
|
|
|
|
DO_TEST_CAPS_LATEST("net-vhostuser-multiq");
|
|
|
|
DO_TEST_CAPS_LATEST_FAILURE("net-vhostuser-fail");
|
|
|
|
DO_TEST_CAPS_LATEST("net-user");
|
2023-12-01 15:27:26 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL("net-user", "x86_64", ARG_FLAGS, FLAG_SLIRP_HELPER | FLAG_ALLOW_DUPLICATE_OUTPUT);
|
2023-08-14 12:28:48 +00:00
|
|
|
DO_TEST_CAPS_LATEST("net-user-addr");
|
2022-12-15 19:19:16 +00:00
|
|
|
DO_TEST_CAPS_LATEST("net-user-passt");
|
2023-02-20 23:26:51 +00:00
|
|
|
DO_TEST_CAPS_VER("net-user-passt", "7.2.0");
|
2023-04-18 09:08:03 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("net-user-slirp-portforward");
|
2023-08-16 13:20:37 +00:00
|
|
|
DO_TEST_CAPS_LATEST("net-virtio");
|
|
|
|
DO_TEST_CAPS_LATEST("net-virtio-device");
|
|
|
|
DO_TEST_CAPS_LATEST("net-virtio-disable-offloads");
|
|
|
|
DO_TEST_CAPS_LATEST("net-virtio-netdev");
|
2023-12-04 14:58:39 +00:00
|
|
|
DO_TEST_CAPS_LATEST("net-virtio-vhost");
|
2022-09-30 13:45:08 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("net-virtio-ccw", "s390x");
|
2023-08-16 13:20:37 +00:00
|
|
|
DO_TEST_CAPS_LATEST("net-virtio-rxtxqueuesize");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("net-virtio-rxqueuesize-invalid-size");
|
|
|
|
DO_TEST_CAPS_LATEST("net-virtio-teaming");
|
|
|
|
DO_TEST_CAPS_LATEST("net-virtio-teaming-hostdev");
|
2023-12-04 14:26:13 +00:00
|
|
|
DO_TEST_CAPS_LATEST("net-linkstate");
|
2023-08-16 13:20:37 +00:00
|
|
|
DO_TEST_CAPS_LATEST("net-eth");
|
|
|
|
DO_TEST_CAPS_LATEST("net-eth-ifname");
|
|
|
|
DO_TEST_CAPS_LATEST("net-eth-names");
|
|
|
|
DO_TEST_CAPS_LATEST("net-eth-hostip");
|
|
|
|
DO_TEST_CAPS_LATEST("net-eth-unmanaged-tap");
|
|
|
|
DO_TEST_CAPS_LATEST("net-client");
|
|
|
|
DO_TEST_CAPS_LATEST("net-server");
|
2023-08-15 10:21:07 +00:00
|
|
|
DO_TEST_CAPS_LATEST("net-many-models");
|
2023-08-16 13:20:37 +00:00
|
|
|
DO_TEST_CAPS_LATEST("net-mcast");
|
|
|
|
DO_TEST_CAPS_LATEST("net-udp");
|
|
|
|
DO_TEST_CAPS_LATEST("net-hostdev");
|
|
|
|
DO_TEST_CAPS_LATEST("net-hostdev-bootorder");
|
|
|
|
DO_TEST_CAPS_LATEST("net-hostdev-multidomain");
|
|
|
|
DO_TEST_CAPS_LATEST("net-hostdev-vfio");
|
|
|
|
DO_TEST_CAPS_LATEST("net-hostdev-vfio-multidomain");
|
|
|
|
DO_TEST_CAPS_LATEST_FAILURE("net-hostdev-fail");
|
2020-10-14 17:08:27 +00:00
|
|
|
DO_TEST_CAPS_LATEST("net-vdpa");
|
2022-03-01 22:55:21 +00:00
|
|
|
DO_TEST_CAPS_LATEST("net-vdpa-multiqueue");
|
2022-01-09 21:07:37 +00:00
|
|
|
DO_TEST_CAPS_LATEST("net-virtio-rss");
|
2016-09-26 07:54:26 +00:00
|
|
|
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("hostdev-pci-multifunction");
|
2011-02-08 14:22:39 +00:00
|
|
|
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("hostdev-pci-address-unassigned");
|
2019-12-17 20:35:03 +00:00
|
|
|
|
2021-10-26 12:38:41 +00:00
|
|
|
DO_TEST_CAPS_LATEST("serial-file-log");
|
2023-03-02 19:23:37 +00:00
|
|
|
driver.config->spiceTLS = 1;
|
2021-10-26 12:38:41 +00:00
|
|
|
DO_TEST_CAPS_LATEST("serial-spiceport");
|
2023-03-02 19:23:37 +00:00
|
|
|
driver.config->spiceTLS = 0;
|
2022-02-02 11:54:59 +00:00
|
|
|
DO_TEST_CAPS_LATEST("serial-debugcon");
|
2021-10-26 12:38:41 +00:00
|
|
|
|
|
|
|
DO_TEST_CAPS_LATEST("console-compat");
|
|
|
|
DO_TEST_CAPS_LATEST("console-compat-auto");
|
|
|
|
|
|
|
|
DO_TEST_CAPS_LATEST("serial-vc-chardev");
|
|
|
|
DO_TEST_CAPS_LATEST("serial-pty-chardev");
|
|
|
|
DO_TEST_CAPS_LATEST("serial-dev-chardev");
|
|
|
|
DO_TEST_CAPS_LATEST("serial-dev-chardev-iobase");
|
|
|
|
DO_TEST_CAPS_LATEST("serial-file-chardev");
|
2018-07-06 10:00:11 +00:00
|
|
|
DO_TEST_CAPS_LATEST("serial-unix-chardev");
|
2021-10-26 12:38:41 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("serial-unix-missing-source");
|
|
|
|
DO_TEST_CAPS_LATEST("serial-tcp-chardev");
|
|
|
|
DO_TEST_CAPS_LATEST("serial-udp-chardev");
|
|
|
|
DO_TEST_CAPS_LATEST("serial-tcp-telnet-chardev");
|
2016-06-09 22:30:55 +00:00
|
|
|
driver.config->chardevTLS = 1;
|
2021-10-26 12:38:41 +00:00
|
|
|
DO_TEST_CAPS_LATEST("serial-tcp-tlsx509-chardev");
|
2016-10-17 15:31:43 +00:00
|
|
|
driver.config->chardevTLSx509verify = 1;
|
2021-10-26 12:38:41 +00:00
|
|
|
DO_TEST_CAPS_LATEST("serial-tcp-tlsx509-chardev-verify");
|
2016-10-17 15:31:43 +00:00
|
|
|
driver.config->chardevTLSx509verify = 0;
|
2021-10-26 12:38:41 +00:00
|
|
|
DO_TEST_CAPS_LATEST("serial-tcp-tlsx509-chardev-notls");
|
2019-10-20 11:49:46 +00:00
|
|
|
driver.config->chardevTLSx509secretUUID = g_strdup("6fd3f62d-9fe7-4a4e-a869-7acd6376d8ea");
|
2021-10-26 12:38:41 +00:00
|
|
|
DO_TEST_CAPS_LATEST("serial-tcp-tlsx509-secret-chardev");
|
2023-03-06 12:43:01 +00:00
|
|
|
VIR_FREE(driver.config->chardevTLSx509secretUUID);
|
2016-06-09 22:30:55 +00:00
|
|
|
driver.config->chardevTLS = 0;
|
2021-10-26 12:38:41 +00:00
|
|
|
DO_TEST_CAPS_LATEST("serial-many-chardev");
|
|
|
|
DO_TEST_CAPS_LATEST("parallel-tcp-chardev");
|
|
|
|
DO_TEST_CAPS_LATEST("parallel-parport-chardev");
|
2018-10-04 17:03:12 +00:00
|
|
|
DO_TEST_CAPS_LATEST("parallel-unix-chardev");
|
2023-12-01 14:14:00 +00:00
|
|
|
DO_TEST_CAPS_LATEST("console-compat-chardev");
|
|
|
|
DO_TEST_CAPS_LATEST("pci-serial-dev-chardev");
|
2011-02-08 14:22:39 +00:00
|
|
|
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("channel-guestfwd");
|
2018-10-04 17:11:43 +00:00
|
|
|
DO_TEST_CAPS_LATEST("channel-unix-guestfwd");
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("channel-virtio");
|
|
|
|
DO_TEST_CAPS_LATEST("channel-virtio-state");
|
|
|
|
DO_TEST_CAPS_LATEST("channel-virtio-auto");
|
|
|
|
DO_TEST_CAPS_LATEST("channel-virtio-autoassign");
|
|
|
|
DO_TEST_CAPS_LATEST("channel-virtio-autoadd");
|
|
|
|
DO_TEST_CAPS_LATEST("console-virtio");
|
|
|
|
DO_TEST_CAPS_LATEST("console-virtio-many");
|
2022-09-30 13:45:08 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("console-virtio-ccw", "s390x");
|
2018-10-04 17:15:15 +00:00
|
|
|
DO_TEST_CAPS_LATEST("console-virtio-unix");
|
2021-06-10 15:08:05 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("console-sclp", "s390x");
|
2023-03-02 19:23:37 +00:00
|
|
|
driver.config->spiceTLS = 1;
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("channel-spicevmc");
|
2023-03-02 19:23:37 +00:00
|
|
|
driver.config->spiceTLS = 0;
|
2022-03-18 22:04:05 +00:00
|
|
|
DO_TEST_CAPS_LATEST("channel-qemu-vdagent");
|
|
|
|
DO_TEST_CAPS_LATEST("channel-qemu-vdagent-features");
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("channel-virtio-default");
|
|
|
|
DO_TEST_CAPS_LATEST("channel-virtio-unix");
|
|
|
|
|
|
|
|
DO_TEST_CAPS_LATEST("smartcard-host");
|
|
|
|
DO_TEST_CAPS_LATEST("smartcard-host-certificates");
|
|
|
|
DO_TEST_CAPS_LATEST("smartcard-host-certificates-database");
|
|
|
|
DO_TEST_CAPS_LATEST("smartcard-passthrough-tcp");
|
|
|
|
DO_TEST_CAPS_LATEST("smartcard-passthrough-spicevmc");
|
|
|
|
DO_TEST_CAPS_LATEST("smartcard-controller");
|
2018-10-04 16:24:53 +00:00
|
|
|
DO_TEST_CAPS_LATEST("smartcard-passthrough-unix");
|
2011-02-08 14:22:39 +00:00
|
|
|
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("chardev-reconnect");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("chardev-reconnect-invalid-timeout");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("chardev-reconnect-generated-path");
|
2017-08-25 17:11:24 +00:00
|
|
|
|
2023-08-31 13:47:00 +00:00
|
|
|
DO_TEST_CAPS_LATEST("usb-controller-implicit-isapc");
|
|
|
|
DO_TEST_CAPS_LATEST("usb-controller-implicit-i440fx");
|
|
|
|
DO_TEST_CAPS_LATEST("usb-controller-implicit-q35");
|
2023-08-31 14:00:48 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("usb-controller-default-isapc");
|
|
|
|
DO_TEST_CAPS_LATEST("usb-controller-default-i440fx");
|
|
|
|
DO_TEST_CAPS_LATEST("usb-controller-default-q35");
|
|
|
|
/* i440fx downgrades to use '-usb' if the explicit controller is not present */
|
|
|
|
DO_TEST_FULL("usb-controller-default-unavailable-i440fx", ".x86_64-latest",
|
|
|
|
ARG_CAPS_ARCH, "x86_64",
|
|
|
|
ARG_CAPS_VER, "latest",
|
|
|
|
ARG_QEMU_CAPS_DEL, QEMU_CAPS_PIIX3_USB_UHCI, QEMU_CAPS_LAST,
|
|
|
|
ARG_END);
|
|
|
|
DO_TEST_FULL("usb-controller-default-unavailable-q35", ".x86_64-latest",
|
|
|
|
ARG_CAPS_ARCH, "x86_64",
|
|
|
|
ARG_CAPS_VER, "latest",
|
|
|
|
ARG_FLAGS, FLAG_EXPECT_FAILURE,
|
|
|
|
ARG_QEMU_CAPS_DEL, QEMU_CAPS_PIIX3_USB_UHCI, QEMU_CAPS_LAST,
|
|
|
|
ARG_END);
|
|
|
|
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("usb-none");
|
|
|
|
|
|
|
|
DO_TEST_CAPS_LATEST("usb-controller-piix3");
|
|
|
|
DO_TEST_CAPS_LATEST("usb-controller-ich9-ehci-addr");
|
|
|
|
DO_TEST_CAPS_LATEST("usb-controller-ich9-companion");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("usb-controller-ich9-no-companion");
|
|
|
|
DO_TEST_CAPS_LATEST("usb-controller-ich9-autoassign");
|
|
|
|
DO_TEST_CAPS_LATEST("usb1-usb2");
|
2023-08-31 12:45:13 +00:00
|
|
|
|
2023-08-31 15:07:38 +00:00
|
|
|
DO_TEST_CAPS_LATEST("usb-controller-nec-xhci");
|
|
|
|
DO_TEST_FULL("usb-controller-nec-xhci-unavailable", ".x86_64-latest",
|
|
|
|
ARG_CAPS_ARCH, "x86_64",
|
|
|
|
ARG_CAPS_VER, "latest",
|
|
|
|
ARG_FLAGS, FLAG_EXPECT_FAILURE,
|
|
|
|
ARG_QEMU_CAPS_DEL, QEMU_CAPS_NEC_USB_XHCI, QEMU_CAPS_LAST,
|
|
|
|
ARG_END);
|
|
|
|
DO_TEST_CAPS_LATEST("usb-controller-nex-xhci-autoassign");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("usb-controller-nec-xhci-limit");
|
|
|
|
DO_TEST_CAPS_LATEST("usb-controller-qemu-xhci");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("usb-controller-qemu-xhci-limit");
|
2023-08-31 12:45:13 +00:00
|
|
|
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("input-usbmouse-addr");
|
|
|
|
DO_TEST_CAPS_LATEST("usb-hub");
|
|
|
|
DO_TEST_CAPS_LATEST("usb-hub-autoadd");
|
|
|
|
DO_TEST_CAPS_LATEST("usb-hub-autoadd-deluxe");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("usb-hub-conflict");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("usb-hub-nonexistent");
|
|
|
|
DO_TEST_CAPS_LATEST("usb-port-missing");
|
|
|
|
DO_TEST_CAPS_LATEST_FAILURE("usb-bus-missing");
|
|
|
|
DO_TEST_CAPS_LATEST("usb-ports");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("usb-ports-out-of-range");
|
|
|
|
DO_TEST_CAPS_LATEST("usb-port-autoassign");
|
|
|
|
DO_TEST_CAPS_LATEST("usb-redir");
|
|
|
|
DO_TEST_CAPS_LATEST("usb-redir-boot");
|
|
|
|
DO_TEST_CAPS_LATEST("usb-redir-filter");
|
|
|
|
DO_TEST_CAPS_LATEST("usb-redir-filter-version");
|
2018-10-04 17:24:01 +00:00
|
|
|
DO_TEST_CAPS_LATEST("usb-redir-unix");
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("usb-none-other");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("usb-none-hub");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("usb-none-usbtablet");
|
|
|
|
DO_TEST_CAPS_LATEST("usb-long-port-path");
|
|
|
|
|
|
|
|
DO_TEST_CAPS_LATEST("smbios");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("smbios-date");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("smbios-uuid-match");
|
2023-08-14 12:28:48 +00:00
|
|
|
DO_TEST_CAPS_LATEST("smbios-type-fwcfg");
|
2011-02-08 14:22:39 +00:00
|
|
|
|
2021-03-25 17:23:19 +00:00
|
|
|
DO_TEST_CAPS_LATEST("watchdog");
|
|
|
|
DO_TEST_CAPS_LATEST("watchdog-device");
|
|
|
|
DO_TEST_CAPS_LATEST("watchdog-dump");
|
|
|
|
DO_TEST_CAPS_LATEST("watchdog-injectnmi");
|
2022-11-08 08:10:57 +00:00
|
|
|
DO_TEST_CAPS_LATEST("watchdog-q35-multiple");
|
2021-06-10 15:01:37 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("watchdog-diag288", "s390x");
|
2023-09-04 12:15:35 +00:00
|
|
|
|
|
|
|
DO_TEST_CAPS_LATEST("balloon-device");
|
|
|
|
DO_TEST_CAPS_LATEST("balloon-device-deflate");
|
2022-09-30 13:45:08 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("balloon-ccw-deflate", "s390x");
|
2024-01-16 14:44:44 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("balloon-mmio-deflate", "aarch64");
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("balloon-device-deflate-off");
|
|
|
|
DO_TEST_CAPS_LATEST("balloon-device-auto");
|
|
|
|
DO_TEST_CAPS_LATEST("balloon-device-period");
|
|
|
|
|
2023-05-09 11:13:19 +00:00
|
|
|
DO_TEST_CAPS_VER("sound-device", "4.2.0");
|
|
|
|
DO_TEST_CAPS_LATEST("sound-device");
|
2019-07-16 10:49:32 +00:00
|
|
|
DO_TEST_CAPS_LATEST("fs9p");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("fs9p-ccw", "s390x");
|
2011-02-08 14:22:39 +00:00
|
|
|
|
2022-07-12 11:00:33 +00:00
|
|
|
DO_TEST_CAPS_LATEST("hostdev-usb-address");
|
|
|
|
DO_TEST_CAPS_LATEST("hostdev-usb-address-device");
|
|
|
|
DO_TEST_CAPS_LATEST("hostdev-usb-address-device-boot");
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("hostdev-usb-duplicate");
|
2022-07-12 11:00:33 +00:00
|
|
|
DO_TEST_CAPS_LATEST("hostdev-pci-address");
|
|
|
|
DO_TEST_CAPS_LATEST("hostdev-pci-address-device");
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("hostdev-pci-duplicate");
|
|
|
|
DO_TEST_CAPS_LATEST("hostdev-vfio");
|
|
|
|
DO_TEST_CAPS_LATEST("hostdev-vfio-multidomain");
|
|
|
|
DO_TEST_CAPS_LATEST("hostdev-mdev-precreated");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("hostdev-mdev-src-address-invalid");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("hostdev-mdev-invalid-target-address");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("hostdev-mdev-duplicate");
|
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");
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("hostdev-mdev-display-missing-graphics");
|
2019-10-18 15:30:17 +00:00
|
|
|
DO_TEST_CAPS_LATEST("hostdev-mdev-display-ramfb");
|
2022-04-29 20:07:26 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("hostdev-mdev-display-ramfb-multiple");
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("hostdev-vfio-zpci-wrong-arch");
|
2023-03-24 14:28:56 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("hostdev-vfio-zpci", "s390x");
|
2022-09-30 14:02:23 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("hostdev-vfio-zpci-invalid-uid-valid-fid", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("hostdev-vfio-zpci-multidomain-many", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("hostdev-vfio-zpci-autogenerate", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("hostdev-vfio-zpci-autogenerate-uids", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("hostdev-vfio-zpci-autogenerate-fids", "s390x");
|
2023-03-24 14:28:56 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("hostdev-vfio-zpci-uid-set-zero", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("hostdev-vfio-zpci-boundaries", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("hostdev-vfio-zpci-duplicate", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("hostdev-vfio-zpci-set-zero", "s390x");
|
2022-09-30 13:45:08 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("hostdev-vfio-zpci-ccw-memballoon", "s390x");
|
2020-06-18 08:25:17 +00:00
|
|
|
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("pci-rom");
|
|
|
|
DO_TEST_CAPS_LATEST("pci-rom-disabled");
|
|
|
|
DO_TEST_CAPS_LATEST("pci-rom-disabled-invalid");
|
2011-02-08 14:22:39 +00:00
|
|
|
|
2022-09-30 13:45:08 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("hostdev-subsys-mdev-vfio-ccw", "s390x");
|
2023-03-24 14:28:56 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("hostdev-subsys-mdev-vfio-ccw-boot", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("hostdev-subsys-mdev-vfio-ccw-duplicate-address", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("hostdev-subsys-mdev-vfio-ccw-invalid-address", "s390x");
|
|
|
|
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("hostdev-subsys-mdev-vfio-ap", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("hostdev-subsys-mdev-vfio-ap-boot-fail", "s390x");
|
2019-08-27 14:19:18 +00:00
|
|
|
|
2023-09-01 12:17:45 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL("restore-v2", "x86_64",
|
|
|
|
ARG_MIGRATE_FROM, "exec:cat",
|
|
|
|
ARG_MIGRATE_FD, 7);
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL("restore-v2-fd", "x86_64",
|
|
|
|
ARG_MIGRATE_FROM, "stdio",
|
|
|
|
ARG_MIGRATE_FD, 7);
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL("restore-v2-fd", "x86_64",
|
|
|
|
ARG_MIGRATE_FROM, "fd:7",
|
2023-12-01 15:27:26 +00:00
|
|
|
ARG_MIGRATE_FD, 7,
|
|
|
|
ARG_FLAGS, FLAG_ALLOW_DUPLICATE_OUTPUT);
|
2023-09-01 12:17:45 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL("migrate", "x86_64",
|
|
|
|
ARG_MIGRATE_FROM, "tcp:10.0.0.1:5000");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL("migrate-numa-unaligned", "x86_64",
|
|
|
|
ARG_MIGRATE_FROM, "stdio",
|
|
|
|
ARG_MIGRATE_FD, 7);
|
2015-09-21 17:10:12 +00:00
|
|
|
|
2019-06-18 06:27:07 +00:00
|
|
|
DO_TEST_CAPS_LATEST("qemu-ns");
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("qemu-ns-no-env");
|
|
|
|
DO_TEST_CAPS_LATEST("qemu-ns-alt");
|
2011-02-08 14:22:39 +00:00
|
|
|
|
2023-02-22 14:23:04 +00:00
|
|
|
DO_TEST_CAPS_LATEST("iothreads-ids");
|
|
|
|
DO_TEST_CAPS_LATEST("iothreads-ids-partial");
|
2022-03-09 10:46:15 +00:00
|
|
|
DO_TEST_CAPS_LATEST("iothreads-ids-pool-sizes");
|
2023-02-22 14:23:04 +00:00
|
|
|
DO_TEST_CAPS_LATEST("iothreads-disk");
|
2022-09-30 13:45:08 +00:00
|
|
|
DO_TEST_CAPS_ARCH_VER("iothreads-disk-virtio-ccw", "s390x", "4.2.0");
|
2021-03-12 16:56:49 +00:00
|
|
|
DO_TEST_CAPS_VER("iothreads-virtio-scsi-pci", "5.2.0");
|
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
|
|
|
|
2023-09-01 12:41:42 +00:00
|
|
|
DO_TEST_CAPS_LATEST("cpu-topology1");
|
|
|
|
DO_TEST_CAPS_LATEST("cpu-topology2");
|
|
|
|
DO_TEST_CAPS_LATEST("cpu-topology3");
|
|
|
|
DO_TEST_CAPS_LATEST("cpu-topology4");
|
2024-01-08 15:21:25 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("cpu-topology5", "aarch64");
|
2023-09-01 12:41:42 +00:00
|
|
|
|
2023-09-01 13:28:18 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-minimum1", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-minimum2", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
|
2023-09-01 13:28:18 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-exact1", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-exact2", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-exact2-nofallback", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
|
2023-09-01 14:18:12 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-strict1", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
|
2023-09-01 13:28:18 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-no-removed-features", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
|
2023-09-05 11:04:31 +00:00
|
|
|
|
|
|
|
/* EPYC-Milan became available in qemu-6.0, use it for the fallback tests */
|
|
|
|
DO_TEST_CAPS_VER_FAILURE("cpu-nofallback", "5.2.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-nofallback", "8.0.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-fallback", "5.2.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-fallback", "8.0.0");
|
|
|
|
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("cpu-numa1");
|
|
|
|
DO_TEST_CAPS_LATEST("cpu-numa2");
|
|
|
|
DO_TEST_CAPS_LATEST("cpu-numa-no-memory-element");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("cpu-numa3");
|
|
|
|
DO_TEST_CAPS_LATEST("cpu-numa-disjoint");
|
|
|
|
DO_TEST_CAPS_LATEST("cpu-numa-memshared");
|
2021-08-18 12:28:23 +00:00
|
|
|
|
|
|
|
/* host-model cpu expansion depends on the cpu reported by qemu and thus
|
|
|
|
* we invoke it for all real capability dumps we have */
|
2023-11-09 14:15:39 +00:00
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-kvm", "4.2.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-kvm", "5.0.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-kvm", "5.1.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-kvm", "5.2.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-kvm", "6.0.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-kvm", "6.1.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-kvm", "6.2.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-kvm", "7.0.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-kvm", "7.1.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-kvm", "7.2.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-kvm", "8.0.0");
|
2023-11-09 14:28:22 +00:00
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-kvm", "8.1.0");
|
2023-11-09 14:15:39 +00:00
|
|
|
|
2023-11-09 14:20:38 +00:00
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-tcg", "4.2.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-tcg", "5.0.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-tcg", "5.1.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-tcg", "5.2.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-tcg", "6.0.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-tcg", "6.1.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-tcg", "6.2.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-tcg", "7.0.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-tcg", "7.1.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-tcg", "7.2.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-tcg", "8.0.0");
|
2023-11-09 14:28:22 +00:00
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-tcg", "8.1.0");
|
2023-11-09 14:20:38 +00:00
|
|
|
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-fallback-kvm", "4.2.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-fallback-kvm", "5.0.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-fallback-kvm", "5.1.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-fallback-kvm", "5.2.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-fallback-kvm", "6.0.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-fallback-kvm", "6.1.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-fallback-kvm", "6.2.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-fallback-kvm", "7.0.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-fallback-kvm", "7.1.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-fallback-kvm", "7.2.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-fallback-kvm", "8.0.0");
|
2023-11-09 14:28:22 +00:00
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-fallback-kvm", "8.1.0");
|
2023-11-09 14:20:38 +00:00
|
|
|
|
2023-11-09 14:15:39 +00:00
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-fallback-tcg", "4.2.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-fallback-tcg", "5.0.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-fallback-tcg", "5.1.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-fallback-tcg", "5.2.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-fallback-tcg", "6.0.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-fallback-tcg", "6.1.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-fallback-tcg", "6.2.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-fallback-tcg", "7.0.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-fallback-tcg", "7.1.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-fallback-tcg", "7.2.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-fallback-tcg", "8.0.0");
|
2023-11-09 14:28:22 +00:00
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-fallback-tcg", "8.1.0");
|
2023-11-09 14:15:39 +00:00
|
|
|
|
2023-11-09 14:20:38 +00:00
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-nofallback-kvm", "4.2.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-nofallback-kvm", "5.0.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-nofallback-kvm", "5.1.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-nofallback-kvm", "5.2.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-nofallback-kvm", "6.0.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-nofallback-kvm", "6.1.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-nofallback-kvm", "6.2.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-nofallback-kvm", "7.0.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-nofallback-kvm", "7.1.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-nofallback-kvm", "7.2.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-nofallback-kvm", "8.0.0");
|
2023-11-09 14:28:22 +00:00
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-nofallback-kvm", "8.1.0");
|
2023-11-09 14:20:38 +00:00
|
|
|
|
2023-11-09 14:15:39 +00:00
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-nofallback-tcg", "4.2.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-nofallback-tcg", "5.0.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-nofallback-tcg", "5.1.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-nofallback-tcg", "5.2.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-nofallback-tcg", "6.0.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-nofallback-tcg", "6.1.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-nofallback-tcg", "6.2.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-nofallback-tcg", "7.0.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-nofallback-tcg", "7.1.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-nofallback-tcg", "7.2.0");
|
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-nofallback-tcg", "8.0.0");
|
2023-11-09 14:28:22 +00:00
|
|
|
DO_TEST_CAPS_VER("cpu-host-model-nofallback-tcg", "8.1.0");
|
2023-08-31 11:33:55 +00:00
|
|
|
|
2021-08-25 12:50:25 +00:00
|
|
|
/* For this specific test we accept the increased likelihood of changes
|
2021-08-18 12:30:10 +00:00
|
|
|
* if qemu updates the CPU model */
|
2023-11-09 14:15:39 +00:00
|
|
|
DO_TEST_CAPS_LATEST("cpu-host-model-kvm");
|
2023-11-09 14:20:38 +00:00
|
|
|
DO_TEST_CAPS_LATEST("cpu-host-model-fallback-kvm");
|
|
|
|
DO_TEST_CAPS_LATEST("cpu-host-model-nofallback-kvm");
|
|
|
|
|
|
|
|
DO_TEST_CAPS_LATEST("cpu-host-model-tcg");
|
2023-11-09 14:15:39 +00:00
|
|
|
DO_TEST_CAPS_LATEST("cpu-host-model-fallback-tcg");
|
|
|
|
DO_TEST_CAPS_LATEST("cpu-host-model-nofallback-tcg");
|
2021-08-18 12:30:10 +00:00
|
|
|
|
2023-09-04 11:47:42 +00:00
|
|
|
/* this test case uses 'cpu="host-model"', run it with Haswell host cpu to prevent test case churn */
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-host-model-vendor", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("cpu-host-passthrough");
|
|
|
|
DO_TEST_CAPS_LATEST_FAILURE("cpu-qemu-host-passthrough");
|
2011-02-08 14:22:39 +00:00
|
|
|
|
2023-03-24 13:53:01 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("cpu-s390-zEC12", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("cpu-s390-features", "s390x");
|
2016-12-18 19:22:28 +00:00
|
|
|
|
2023-09-01 11:57:23 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-Haswell", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-Haswell2", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-Haswell3", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-Haswell-noTSX", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-host-model-cmt", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-tsc-frequency", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
|
2022-06-22 11:30:18 +00:00
|
|
|
|
2019-06-11 15:14:27 +00:00
|
|
|
DO_TEST_CAPS_LATEST("cpu-translation");
|
2015-03-23 16:19:28 +00:00
|
|
|
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("memtune");
|
|
|
|
DO_TEST_CAPS_LATEST("memtune-unlimited");
|
|
|
|
DO_TEST_CAPS_LATEST("blkiotune");
|
|
|
|
DO_TEST_CAPS_LATEST("blkiotune-device");
|
2023-02-22 14:57:47 +00:00
|
|
|
DO_TEST_CAPS_LATEST("cputune");
|
|
|
|
DO_TEST_CAPS_LATEST("cputune-zero-shares");
|
2023-02-23 08:21:41 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("cputune-iothreadsched-toomuch");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("cputune-vcpusched-overlap");
|
2023-02-22 14:57:47 +00:00
|
|
|
DO_TEST_CAPS_LATEST("cputune-numatune");
|
|
|
|
DO_TEST_CAPS_LATEST("vcpu-placement-static");
|
2020-06-11 11:57:07 +00:00
|
|
|
DO_TEST_CAPS_LATEST("cputune-cpuset-big-id");
|
2014-07-02 09:15:45 +00:00
|
|
|
|
2023-08-31 13:18:11 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("numatune-memory-invalid-nodeset");
|
2021-03-12 16:42:14 +00:00
|
|
|
DO_TEST_CAPS_VER("numatune-memnode", "5.2.0");
|
|
|
|
DO_TEST_CAPS_LATEST("numatune-memnode");
|
2023-08-31 13:18:11 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("numatune-memnode-invalid-mode");
|
2021-04-15 13:55:04 +00:00
|
|
|
DO_TEST_CAPS_LATEST("numatune-memnode-restrictive-mode");
|
2023-05-18 08:31:12 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("numatune-memnode-restrictive-mode-err-mixed");
|
2021-11-09 14:00:53 +00:00
|
|
|
DO_TEST_CAPS_LATEST("numatune-system-memory");
|
2014-07-02 09:15:45 +00:00
|
|
|
|
2023-08-31 13:18:11 +00:00
|
|
|
DO_TEST_CAPS_LATEST("numatune-memnode-no-memory");
|
2014-07-02 09:15:45 +00:00
|
|
|
|
2023-08-31 13:18:11 +00:00
|
|
|
DO_TEST_CAPS_LATEST("numatune-distances");
|
2023-08-14 12:28:48 +00:00
|
|
|
DO_TEST_CAPS_LATEST("numatune-no-vcpu");
|
2020-07-08 09:28:37 +00:00
|
|
|
DO_TEST_CAPS_LATEST("numatune-hmat");
|
2023-05-16 08:22:39 +00:00
|
|
|
DO_TEST_CAPS_LATEST("numatune-hmat-none");
|
2017-11-14 13:31:17 +00:00
|
|
|
|
2023-08-31 13:18:11 +00:00
|
|
|
DO_TEST_CAPS_LATEST("numatune-auto-nodeset-invalid");
|
|
|
|
DO_TEST_CAPS_LATEST("numatune-auto-prefer");
|
|
|
|
DO_TEST_CAPS_LATEST_FAILURE("numatune-static-nodeset-exceed-hostnode");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("numatune-memnode-nocpu");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("numatune-memnodes-problematic");
|
2023-01-03 18:27:19 +00:00
|
|
|
DO_TEST_CAPS_LATEST_FAILURE("numatune-memnode-unavailable-strict");
|
2023-01-03 17:46:05 +00:00
|
|
|
DO_TEST_CAPS_LATEST_FAILURE("numatune-memnode-unavailable-restrictive");
|
2023-08-31 13:18:11 +00:00
|
|
|
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("numad");
|
|
|
|
DO_TEST_CAPS_LATEST("numad-auto-vcpu-static-numatune");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("numad-auto-vcpu-static-numatune-no-nodeset");
|
|
|
|
DO_TEST_CAPS_LATEST("numad-auto-memory-vcpu-cpuset");
|
|
|
|
DO_TEST_CAPS_LATEST("numad-auto-memory-vcpu-no-cpuset-and-placement");
|
|
|
|
DO_TEST_CAPS_LATEST("numad-static-memory-auto-vcpu");
|
2022-01-05 21:38:24 +00:00
|
|
|
DO_TEST_CAPS_LATEST("blkdeviotune");
|
2020-05-04 16:16:26 +00:00
|
|
|
DO_TEST_CAPS_LATEST("blkdeviotune-max");
|
|
|
|
DO_TEST_CAPS_LATEST("blkdeviotune-group-num");
|
|
|
|
DO_TEST_CAPS_LATEST("blkdeviotune-max-length");
|
2011-02-08 06:59:38 +00:00
|
|
|
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("multifunction-pci-device");
|
|
|
|
|
|
|
|
DO_TEST_CAPS_LATEST("seclabel-dynamic");
|
|
|
|
DO_TEST_CAPS_LATEST("seclabel-dynamic-baselabel");
|
|
|
|
DO_TEST_CAPS_LATEST("seclabel-dynamic-override");
|
|
|
|
DO_TEST_CAPS_LATEST("seclabel-dynamic-labelskip");
|
|
|
|
DO_TEST_CAPS_LATEST("seclabel-dynamic-relabel");
|
|
|
|
DO_TEST_CAPS_LATEST("seclabel-static");
|
|
|
|
DO_TEST_CAPS_LATEST("seclabel-static-relabel");
|
|
|
|
DO_TEST_CAPS_LATEST("seclabel-static-labelskip");
|
|
|
|
DO_TEST_CAPS_LATEST("seclabel-none");
|
|
|
|
DO_TEST_CAPS_LATEST("seclabel-dac-none");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("seclabel-multiple");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("seclabel-device-duplicates");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("seclabel-device-relabel-invalid");
|
2011-12-23 00:47:46 +00:00
|
|
|
|
2022-09-13 14:30:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PPC64("pseries-basic");
|
|
|
|
DO_TEST_CAPS_LATEST_PPC64("pseries-vio");
|
2023-12-01 14:24:34 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("pseries-vio-address-clash", "ppc64");
|
2022-09-13 14:30:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PPC64("pseries-usb-default");
|
|
|
|
DO_TEST_CAPS_LATEST_PPC64("pseries-usb-multi");
|
|
|
|
DO_TEST_CAPS_LATEST_PPC64("pseries-vio-user-assigned");
|
|
|
|
DO_TEST_CAPS_LATEST_PPC64("pseries-nvram");
|
|
|
|
DO_TEST_CAPS_LATEST_PPC64("pseries-usb-kbd");
|
|
|
|
DO_TEST_CAPS_LATEST_PPC64("pseries-cpu-exact");
|
2023-03-17 14:52:06 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("pseries-no-parallel", "ppc64");
|
2022-09-13 14:30:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PPC64("pseries-cpu-le");
|
2016-08-04 11:19:39 +00:00
|
|
|
|
2019-11-26 17:51:22 +00:00
|
|
|
qemuTestSetHostArch(&driver, VIR_ARCH_PPC64);
|
2022-09-13 14:30:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PPC64_HOSTCPU("pseries-cpu-compat",
|
|
|
|
QEMU_CPU_DEF_POWER9);
|
2022-05-20 18:15:18 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PPC64_HOSTCPU_FAILURE("pseries-cpu-compat-power9",
|
|
|
|
QEMU_CPU_DEF_POWER8);
|
|
|
|
DO_TEST_CAPS_LATEST_PPC64_HOSTCPU("pseries-cpu-compat-power9",
|
|
|
|
QEMU_CPU_DEF_POWER9);
|
2022-05-03 20:15:05 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PPC64_HOSTCPU_FAILURE("pseries-cpu-compat-power10",
|
|
|
|
QEMU_CPU_DEF_POWER9);
|
|
|
|
DO_TEST_CAPS_LATEST_PPC64_HOSTCPU("pseries-cpu-compat-power10",
|
|
|
|
QEMU_CPU_DEF_POWER10);
|
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
|
|
|
|
2022-09-13 14:30:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PPC64("pseries-panic-missing");
|
|
|
|
DO_TEST_CAPS_LATEST_PPC64("pseries-panic-no-address");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("pseries-panic-address", "ppc64");
|
|
|
|
|
|
|
|
DO_TEST_CAPS_LATEST_PPC64("pseries-phb-simple");
|
|
|
|
DO_TEST_CAPS_LATEST_PPC64("pseries-phb-default-missing");
|
|
|
|
DO_TEST_CAPS_LATEST_PPC64("pseries-phb-numa-node");
|
2024-01-16 16:05:07 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PPC64("pseries-phb-user-alias");
|
2022-09-13 14:30:35 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("pseries-default-phb-numa-node",
|
|
|
|
"ppc64");
|
2023-03-17 14:52:06 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("pseries-phb-invalid-target-index-1", "ppc64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("pseries-phb-invalid-target-index-2", "ppc64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("pseries-phb-invalid-target-index-3", "ppc64");
|
2017-02-20 17:20:26 +00:00
|
|
|
|
2022-09-13 14:30:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PPC64("pseries-many-devices");
|
|
|
|
DO_TEST_CAPS_LATEST_PPC64("pseries-many-buses-1");
|
|
|
|
DO_TEST_CAPS_LATEST_PPC64("pseries-many-buses-2");
|
|
|
|
DO_TEST_CAPS_LATEST_PPC64("pseries-hostdevs-1");
|
|
|
|
DO_TEST_CAPS_LATEST_PPC64("pseries-hostdevs-2");
|
|
|
|
DO_TEST_CAPS_LATEST_PPC64("pseries-hostdevs-3");
|
2017-05-26 16:33:36 +00:00
|
|
|
|
2023-03-21 14:49:22 +00:00
|
|
|
DO_TEST_CAPS_ARCH_VER("pseries-features", "ppc64", "4.2.0");
|
2022-09-13 14:30:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PPC64("pseries-features");
|
2019-12-09 23:15:06 +00:00
|
|
|
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("pseries-features-invalid-machine");
|
2017-11-06 15:39:58 +00:00
|
|
|
|
2022-09-13 14:30:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PPC64("pseries-serial-native");
|
|
|
|
DO_TEST_CAPS_LATEST_PPC64("pseries-serial+console-native");
|
|
|
|
DO_TEST_CAPS_LATEST_PPC64("pseries-serial-compat");
|
|
|
|
DO_TEST_CAPS_LATEST_PPC64("pseries-serial-pci");
|
|
|
|
DO_TEST_CAPS_LATEST_PPC64("pseries-serial-usb");
|
|
|
|
DO_TEST_CAPS_LATEST_PPC64("pseries-console-native");
|
|
|
|
DO_TEST_CAPS_LATEST_PPC64("pseries-console-virtio");
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("pseries-serial-invalid-machine");
|
2023-03-17 14:52:06 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("pseries-spaprvio-invalid", "ppc64");
|
2017-11-08 14:31:21 +00:00
|
|
|
|
2023-03-24 14:41:25 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("mach-virt-serial-native", "aarch64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("mach-virt-serial+console-native", "aarch64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("mach-virt-serial-compat", "aarch64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("mach-virt-serial-pci", "aarch64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("mach-virt-serial-usb", "aarch64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("mach-virt-console-native", "aarch64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("mach-virt-console-virtio", "aarch64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("mach-virt-serial-invalid-machine", "x86_64");
|
2017-11-09 16:14:57 +00:00
|
|
|
|
2023-08-16 12:44:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("video-device-pciaddr-default");
|
|
|
|
DO_TEST_CAPS_LATEST("video-vga-device");
|
|
|
|
DO_TEST_CAPS_LATEST("video-vga-device-vgamem");
|
|
|
|
DO_TEST_CAPS_LATEST("video-qxl-device");
|
|
|
|
DO_TEST_CAPS_LATEST("video-qxl-device-vgamem");
|
2018-08-27 15:59:26 +00:00
|
|
|
DO_TEST_CAPS_LATEST("video-qxl-device-vram64");
|
2023-08-16 12:44:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("video-qxl-sec-device");
|
|
|
|
DO_TEST_CAPS_LATEST("video-qxl-sec-device-vgamem");
|
2018-08-27 15:59:26 +00:00
|
|
|
DO_TEST_CAPS_LATEST("video-qxl-sec-device-vram64");
|
2023-08-16 12:44:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("video-qxl-heads");
|
|
|
|
DO_TEST_CAPS_LATEST("video-vga-qxl-heads");
|
|
|
|
DO_TEST_CAPS_LATEST("video-qxl-noheads");
|
|
|
|
DO_TEST_CAPS_LATEST("video-qxl-resolution");
|
|
|
|
DO_TEST_CAPS_LATEST("video-virtio-gpu-device");
|
|
|
|
DO_TEST_CAPS_LATEST("video-virtio-gpu-virgl");
|
|
|
|
DO_TEST_CAPS_LATEST("video-virtio-gpu-spice-gl");
|
|
|
|
DO_TEST_CAPS_LATEST("video-virtio-gpu-sdl-gl");
|
|
|
|
DO_TEST_CAPS_LATEST("video-virtio-gpu-secondary");
|
|
|
|
DO_TEST_CAPS_LATEST("video-virtio-vga");
|
2022-02-23 21:06:55 +00:00
|
|
|
DO_TEST_CAPS_LATEST("video-virtio-blob-on");
|
|
|
|
DO_TEST_CAPS_LATEST("video-virtio-blob-off");
|
2021-06-09 08:32:27 +00:00
|
|
|
DO_TEST_CAPS_LATEST("video-virtio-vga-gpu-gl");
|
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");
|
2023-08-16 12:44:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("video-none-device");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("video-invalid-multiple-devices");
|
2023-08-15 14:46:05 +00:00
|
|
|
DO_TEST_CAPS_LATEST("default-video-type-x86_64");
|
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");
|
|
|
|
|
2023-08-16 12:44:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("video-multiple-primaries");
|
2020-12-02 20:23:02 +00:00
|
|
|
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("virtio-rng-default");
|
|
|
|
DO_TEST_CAPS_LATEST("virtio-rng-random");
|
|
|
|
DO_TEST_CAPS_LATEST("virtio-rng-egd");
|
2021-03-12 16:56:49 +00:00
|
|
|
DO_TEST_CAPS_VER("virtio-rng-builtin", "5.2.0");
|
2020-01-09 08:00:08 +00:00
|
|
|
DO_TEST_CAPS_LATEST("virtio-rng-builtin");
|
2021-03-12 16:56:49 +00:00
|
|
|
DO_TEST_CAPS_VER("virtio-rng-egd-unix", "5.2.0");
|
2018-10-04 17:27:17 +00:00
|
|
|
DO_TEST_CAPS_LATEST("virtio-rng-egd-unix");
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("virtio-rng-multiple");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("virtio-rng-egd-crash");
|
2022-09-30 13:45:08 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("virtio-rng-ccw", "s390x");
|
2013-02-12 16:56:00 +00:00
|
|
|
|
2021-06-11 08:16:01 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("s390-allow-bogus-usb-none", "s390x");
|
2021-06-11 08:16:01 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("s390-allow-bogus-usb-controller", "s390x");
|
2013-04-26 15:50:36 +00:00
|
|
|
|
2023-03-24 14:28:56 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("s390-panic-no-address", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("s390-panic-address", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("s390-panic-missing", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("s390-no-parallel", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("s390-serial", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("s390-serial-2", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("s390-serial-console", "s390x");
|
2016-04-29 13:23:43 +00:00
|
|
|
|
2023-03-03 13:17:06 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("ppc-dtb", "ppc");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("ppce500-serial", "ppc");
|
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");
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("tpm-no-backend-invalid");
|
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");
|
2021-01-04 02:31:59 +00:00
|
|
|
DO_TEST_CAPS_LATEST("tpm-emulator-tpm2-pstate");
|
2020-02-05 18:35:50 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PPC64("tpm-emulator-spapr");
|
2021-02-09 21:57:22 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("aarch64-tpm", "aarch64");
|
2023-03-24 14:42:43 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("aarch64-tpm-wrong-model", "aarch64");
|
2022-10-17 14:05:08 +00:00
|
|
|
DO_TEST_CAPS_LATEST("tpm-external");
|
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
|
|
|
|
2022-08-02 08:23:42 +00:00
|
|
|
g_setenv(TEST_TPM_ENV_VAR, TPM_VER_2_0, true);
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("tpm-emulator");
|
|
|
|
g_setenv(TEST_TPM_ENV_VAR, TPM_VER_1_2, true);
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("tpm-emulator-tpm2");
|
|
|
|
unsetenv(TEST_TPM_ENV_VAR);
|
|
|
|
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("pci-domain-invalid");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("pci-bus-invalid");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("pci-slot-invalid");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("pci-function-invalid");
|
|
|
|
|
|
|
|
DO_TEST_CAPS_LATEST("pci-bridge");
|
|
|
|
DO_TEST_CAPS_LATEST("pci-autoadd-addr");
|
|
|
|
DO_TEST_CAPS_LATEST("pci-autoadd-idx");
|
|
|
|
DO_TEST_CAPS_LATEST("pci-autofill-addr");
|
|
|
|
DO_TEST_CAPS_LATEST("pci-many");
|
|
|
|
DO_TEST_CAPS_LATEST("pci-bridge-many-disks");
|
|
|
|
DO_TEST_CAPS_LATEST("pcie-root");
|
|
|
|
DO_TEST_CAPS_LATEST("q35");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("q35-dmi-bad-address1");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("q35-dmi-bad-address2");
|
2021-10-11 12:30:58 +00:00
|
|
|
DO_TEST_CAPS_LATEST("pc-i440fx-acpi-root-hotplug-disable");
|
2021-10-11 12:55:42 +00:00
|
|
|
DO_TEST_CAPS_LATEST("pc-i440fx-acpi-root-hotplug-enable");
|
2021-10-11 12:30:58 +00:00
|
|
|
DO_TEST_CAPS_VER_PARSE_ERROR("pc-i440fx-acpi-root-hotplug-disable", "5.1.0");
|
2021-10-11 12:55:42 +00:00
|
|
|
DO_TEST_CAPS_VER_PARSE_ERROR("pc-i440fx-acpi-root-hotplug-enable", "5.1.0");
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("q35-usb2");
|
|
|
|
DO_TEST_CAPS_LATEST("q35-usb2-multi");
|
|
|
|
DO_TEST_CAPS_LATEST("q35-usb2-reorder");
|
2022-06-23 15:11:57 +00:00
|
|
|
|
2022-08-25 13:46:09 +00:00
|
|
|
/* Note: The real caps versions of the following tests based on qemu-4.2.0
|
|
|
|
* were added as a comparison point between fake caps testing and real caps
|
|
|
|
* testing and don't have any other specific purpose */
|
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 */
|
2022-08-25 13:46:09 +00:00
|
|
|
DO_TEST_CAPS_VER("q35-pcie", "4.2.0");
|
2022-06-23 15:11:57 +00:00
|
|
|
DO_TEST_CAPS_LATEST("q35-pcie");
|
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
|
|
|
/* same as q35-pcie, but all PCI controllers are added automatically */
|
2022-08-25 13:46:09 +00:00
|
|
|
DO_TEST_CAPS_VER("q35-pcie-autoadd", "4.2.0");
|
2022-06-23 15:11:57 +00:00
|
|
|
DO_TEST_CAPS_LATEST("q35-pcie-autoadd");
|
2022-08-25 13:46:09 +00:00
|
|
|
DO_TEST_CAPS_VER("q35-default-devices-only", "4.2.0");
|
2022-06-23 15:11:57 +00:00
|
|
|
DO_TEST_CAPS_LATEST("q35-default-devices-only");
|
2022-08-25 13:46:09 +00:00
|
|
|
DO_TEST_CAPS_VER("q35-multifunction", "4.2.0");
|
2022-06-23 15:11:57 +00:00
|
|
|
DO_TEST_CAPS_LATEST("q35-multifunction");
|
2022-08-25 13:46:09 +00:00
|
|
|
DO_TEST_CAPS_VER("q35-virt-manager-basic", "4.2.0");
|
2022-06-23 15:11:57 +00:00
|
|
|
DO_TEST_CAPS_LATEST("q35-virt-manager-basic");
|
2017-03-16 16:41:21 +00:00
|
|
|
|
|
|
|
/* Test automatic and manual setting of pcie-root-port attributes */
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("pcie-root-port");
|
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 */
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("pcie-root-port-model-generic");
|
|
|
|
DO_TEST_CAPS_LATEST("pcie-root-port-model-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
|
|
|
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("autoindex");
|
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 */
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("q35-pci-force-address");
|
|
|
|
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("q35-wrong-root");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("440fx-wrong-root");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("440fx-ide-address-conflict");
|
|
|
|
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("pcie-root-port-too-many");
|
|
|
|
|
|
|
|
DO_TEST_CAPS_LATEST("pcie-switch-upstream-port");
|
|
|
|
DO_TEST_CAPS_LATEST("pcie-switch-downstream-port");
|
|
|
|
|
|
|
|
DO_TEST_CAPS_LATEST("pci-expander-bus");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("pci-expander-bus-bad-node");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("pci-expander-bus-bad-machine");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("pci-expander-bus-bad-bus");
|
|
|
|
|
|
|
|
DO_TEST_CAPS_LATEST("pcie-expander-bus");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("pcie-expander-bus-bad-machine");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("pcie-expander-bus-bad-bus");
|
2021-07-22 13:06:03 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("pcie-expander-bus-aarch64", "aarch64");
|
2016-03-23 19:49:29 +00:00
|
|
|
|
2020-06-17 12:58:49 +00:00
|
|
|
DO_TEST_CAPS_LATEST("hostdev-scsi-lsi");
|
2020-06-17 13:51:57 +00:00
|
|
|
DO_TEST_CAPS_LATEST("hostdev-scsi-virtio-scsi");
|
2020-06-17 12:55:04 +00:00
|
|
|
|
2023-03-24 14:28:56 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("hostdev-scsi-vhost-scsi-ccw", "s390x");
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("hostdev-scsi-vhost-scsi-pci");
|
2019-08-27 14:19:20 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("hostdev-scsi-vhost-scsi-pci-boot-fail");
|
2022-08-25 13:46:09 +00:00
|
|
|
DO_TEST_CAPS_VER("hostdev-scsi-vhost-scsi-pcie", "4.2.0");
|
2022-06-23 15:11:57 +00:00
|
|
|
DO_TEST_CAPS_LATEST("hostdev-scsi-vhost-scsi-pcie");
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("hostdev-scsi-duplicate");
|
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:01:53 +00:00
|
|
|
DO_TEST_CAPS_LATEST("mlock-on");
|
|
|
|
DO_TEST_CAPS_LATEST("mlock-off");
|
2019-04-12 08:00:41 +00:00
|
|
|
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("pci-bridge-negative-index-invalid");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("pci-bridge-duplicate-index");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("pci-root-nonzero-index");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("pci-root-address");
|
2013-07-12 12:17:23 +00:00
|
|
|
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("hotplug-base");
|
2013-07-18 09:19:23 +00:00
|
|
|
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("pcihole64");
|
|
|
|
DO_TEST_CAPS_LATEST("pcihole64-q35");
|
2013-08-12 11:48:34 +00:00
|
|
|
|
2023-03-03 13:38:25 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("arm-vexpressa9-nodevs", "aarch64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("arm-vexpressa9-basic", "aarch64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("arm-vexpressa9-virtio", "aarch64");
|
2016-01-27 22:47:14 +00:00
|
|
|
|
2023-03-24 12:03:27 +00:00
|
|
|
DO_TEST_CAPS_ARCH_VER("aarch64-virt-virtio", "aarch64", "4.2.0");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("aarch64-virt-virtio", "aarch64");
|
|
|
|
|
2016-01-27 22:47:14 +00:00
|
|
|
/* Example of using virtio-pci with no explicit PCI controller
|
|
|
|
but with manual PCI addresses */
|
2023-03-28 12:41:57 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("aarch64-virtio-pci-manual-addresses", "aarch64");
|
2023-03-24 14:42:43 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("aarch64-video-virtio-gpu-pci", "aarch64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("aarch64-video-default", "aarch64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("aarch64-virt-default-nic", "aarch64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("aarch64-cpu-passthrough", "aarch64");
|
2023-09-01 08:04:18 +00:00
|
|
|
DO_TEST_GIC("aarch64-gic-none", "4.2.0", GIC_NONE);
|
|
|
|
DO_TEST_GIC("aarch64-gic-none", "latest", GIC_NONE);
|
|
|
|
DO_TEST_GIC("aarch64-gic-none-v2", "latest", GIC_V2);
|
|
|
|
DO_TEST_GIC("aarch64-gic-none-v3", "latest", GIC_V3);
|
|
|
|
DO_TEST_GIC("aarch64-gic-none-both", "latest", GIC_BOTH);
|
|
|
|
DO_TEST_CAPS_ARCH_VER_FULL("aarch64-gic-none-tcg", "aarch64", "latest",
|
|
|
|
ARG_GIC, GIC_BOTH,
|
|
|
|
ARG_QEMU_CAPS_DEL, QEMU_CAPS_KVM, QEMU_CAPS_LAST,
|
|
|
|
ARG_END);
|
|
|
|
DO_TEST_GIC("aarch64-gic-default", "4.2.0", GIC_NONE);
|
|
|
|
DO_TEST_GIC("aarch64-gic-default", "latest", GIC_NONE);
|
|
|
|
DO_TEST_GIC("aarch64-gic-default-v2", "latest", GIC_V2);
|
|
|
|
DO_TEST_GIC("aarch64-gic-default-v3", "latest", GIC_V3);
|
|
|
|
DO_TEST_GIC("aarch64-gic-default-both", "latest", GIC_BOTH);
|
|
|
|
DO_TEST_GIC("aarch64-gic-v2", "latest", GIC_NONE);
|
|
|
|
DO_TEST_GIC("aarch64-gic-v2", "latest", GIC_V2);
|
|
|
|
DO_TEST_GIC("aarch64-gic-v2", "latest", GIC_V3);
|
|
|
|
DO_TEST_GIC("aarch64-gic-v2", "latest", GIC_BOTH);
|
|
|
|
DO_TEST_GIC("aarch64-gic-v3", "latest", GIC_NONE);
|
|
|
|
DO_TEST_GIC("aarch64-gic-v3", "latest", GIC_V2);
|
|
|
|
DO_TEST_GIC("aarch64-gic-v3", "latest", GIC_V3);
|
|
|
|
DO_TEST_GIC("aarch64-gic-v3", "latest", GIC_BOTH);
|
|
|
|
DO_TEST_GIC("aarch64-gic-host", "latest", GIC_NONE);
|
|
|
|
DO_TEST_GIC("aarch64-gic-host", "latest", GIC_V2);
|
|
|
|
DO_TEST_GIC("aarch64-gic-host", "latest", GIC_V3);
|
|
|
|
DO_TEST_GIC("aarch64-gic-host", "latest", GIC_BOTH);
|
2023-03-24 10:15:40 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("aarch64-gic-invalid", "aarch64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("aarch64-gic-not-virt", "aarch64");
|
2023-03-17 14:52:06 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("aarch64-gic-not-arm", "ppc64");
|
2023-03-03 13:38:25 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("aarch64-kvm-32-on-64", "aarch64");
|
2023-03-24 14:42:43 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("aarch64-pci-serial", "aarch64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("aarch64-traditional-pci", "aarch64");
|
2017-03-09 15:38:56 +00:00
|
|
|
|
2019-06-24 13:22:24 +00:00
|
|
|
/* 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
|
|
|
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("kvm-pit-delay");
|
|
|
|
DO_TEST_CAPS_LATEST("kvm-pit-discard");
|
2013-07-01 16:28:50 +00:00
|
|
|
|
2021-03-26 15:21:19 +00:00
|
|
|
DO_TEST_CAPS_LATEST("panic");
|
|
|
|
DO_TEST_CAPS_LATEST("panic-double");
|
|
|
|
DO_TEST_CAPS_LATEST("panic-no-address");
|
2015-02-26 14:28:07 +00:00
|
|
|
|
2023-02-20 16:12:56 +00:00
|
|
|
DO_TEST_CAPS_LATEST("pvpanic-pci-x86_64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("pvpanic-pci-aarch64", "aarch64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("pvpanic-pci-invalid-address-aarch64", "aarch64");
|
2023-02-20 16:12:58 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("pvpanic-pci-no-address-aarch64", "aarch64");
|
2023-02-20 16:12:56 +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
|
|
|
|
2023-08-16 11:22:59 +00:00
|
|
|
DO_TEST_CAPS_LATEST("shmem-plain-doorbell");
|
2023-12-18 23:16:29 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("shmem-invalid-size");
|
2023-08-16 11:22:59 +00:00
|
|
|
DO_TEST_CAPS_LATEST_FAILURE("shmem-invalid-address");
|
2023-12-18 23:16:29 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("shmem-small-size");
|
2023-08-16 11:22:59 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("shmem-msi-only");
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("cpu-host-passthrough-features");
|
2014-09-22 08:49:39 +00:00
|
|
|
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST_FAILURE("memory-align-fail");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("memory-hotplug-nonuma");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("memory-hotplug-invalid-targetnode");
|
|
|
|
DO_TEST_CAPS_LATEST("memory-hotplug");
|
|
|
|
DO_TEST_CAPS_LATEST("memory-hotplug-dimm");
|
2022-07-26 17:42:33 +00:00
|
|
|
DO_TEST_CAPS_LATEST("memory-hotplug-dimm-addr");
|
2023-03-08 22:31:47 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("memory-hotplug-ppc64-nonuma", "ppc64");
|
2024-01-26 10:57:21 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE("memory-hotplug-ppc64-nonuma", "ppc64");
|
2018-12-20 09:14:46 +00:00
|
|
|
DO_TEST_CAPS_LATEST("memory-hotplug-nvdimm");
|
|
|
|
DO_TEST_CAPS_LATEST("memory-hotplug-nvdimm-access");
|
2021-03-12 16:56:49 +00:00
|
|
|
DO_TEST_CAPS_VER("memory-hotplug-nvdimm-label", "5.2.0");
|
2018-12-20 09:14:46 +00:00
|
|
|
DO_TEST_CAPS_LATEST("memory-hotplug-nvdimm-label");
|
2021-03-12 16:56:49 +00:00
|
|
|
DO_TEST_CAPS_VER("memory-hotplug-nvdimm-align", "5.2.0");
|
2018-12-20 09:14:47 +00:00
|
|
|
DO_TEST_CAPS_LATEST("memory-hotplug-nvdimm-align");
|
2021-03-12 16:56:49 +00:00
|
|
|
DO_TEST_CAPS_VER("memory-hotplug-nvdimm-pmem", "5.2.0");
|
2018-12-20 09:14:48 +00:00
|
|
|
DO_TEST_CAPS_LATEST("memory-hotplug-nvdimm-pmem");
|
2021-03-12 16:56:49 +00:00
|
|
|
DO_TEST_CAPS_VER("memory-hotplug-nvdimm-readonly", "5.2.0");
|
2018-12-20 09:14:49 +00:00
|
|
|
DO_TEST_CAPS_LATEST("memory-hotplug-nvdimm-readonly");
|
2023-03-08 22:31:47 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("memory-hotplug-nvdimm-ppc64", "ppc64");
|
2024-01-26 10:57:21 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE("memory-hotplug-nvdimm-ppc64", "ppc64");
|
2021-03-12 16:56:49 +00:00
|
|
|
DO_TEST_CAPS_VER("memory-hotplug-virtio-pmem", "5.2.0");
|
2020-10-31 19:50:22 +00:00
|
|
|
DO_TEST_CAPS_LATEST("memory-hotplug-virtio-pmem");
|
2021-01-19 09:16:55 +00:00
|
|
|
DO_TEST_CAPS_LATEST("memory-hotplug-virtio-mem");
|
2023-06-22 11:56:06 +00:00
|
|
|
DO_TEST_CAPS_LATEST("memory-hotplug-multiple");
|
2023-09-22 09:01:40 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("memory-hotplug-virtio-mem-overlap-address");
|
2014-10-06 12:18:37 +00:00
|
|
|
|
2023-03-24 13:42:04 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("machine-aeskeywrap-on-caps", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("machine-aeskeywrap-on-cap", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("machine-aeskeywrap-off-caps", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("machine-aeskeywrap-off-cap", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("machine-deakeywrap-on-caps", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("machine-deakeywrap-on-cap", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("machine-deakeywrap-off-caps", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("machine-deakeywrap-off-cap", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("machine-keywrap-none-caps", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("machine-keywrap-none", "s390x");
|
2015-04-27 21:57:30 +00:00
|
|
|
|
2023-03-24 14:26:22 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("machine-loadparm-s390", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("machine-loadparm-net-s390", "s390x");
|
2023-03-10 02:38:09 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("machine-loadparm-hostdev", "s390x");
|
2023-03-24 14:26:22 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("machine-loadparm-multiple-disks-nets-s390", "s390x");
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("machine-loadparm-s390-char-invalid");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("machine-loadparm-s390-len-invalid");
|
2017-06-01 16:36:25 +00:00
|
|
|
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("qemu-ns-domain-ns0");
|
|
|
|
DO_TEST_CAPS_LATEST("qemu-ns-domain-commandline");
|
|
|
|
DO_TEST_CAPS_LATEST("qemu-ns-domain-commandline-ns0");
|
|
|
|
DO_TEST_CAPS_LATEST("qemu-ns-commandline");
|
|
|
|
DO_TEST_CAPS_LATEST("qemu-ns-commandline-ns0");
|
|
|
|
DO_TEST_CAPS_LATEST("qemu-ns-commandline-ns1");
|
2015-10-20 14:01:01 +00:00
|
|
|
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("virtio-input");
|
|
|
|
DO_TEST_CAPS_LATEST("virtio-input-passthrough");
|
2015-11-13 10:38:07 +00:00
|
|
|
|
2021-05-21 11:01:08 +00:00
|
|
|
DO_TEST_CAPS_LATEST("input-linux");
|
|
|
|
|
2023-03-08 22:31:47 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("ppc64-usb-controller", "ppc64");
|
2024-01-26 10:57:21 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_ABI_UPDATE("ppc64-usb-controller", "ppc64");
|
2017-04-27 15:56:41 +00:00
|
|
|
|
2023-03-17 14:52:06 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("ppc64-tpmproxy-double", "ppc64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("ppc64-tpm-double", "ppc64");
|
2020-06-10 18:11:49 +00:00
|
|
|
|
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");
|
|
|
|
|
2023-03-24 15:33:06 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("aarch64-usb-controller", "aarch64");
|
2017-04-27 15:53:51 +00:00
|
|
|
|
2023-03-02 15:53:47 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("sparc-minimal", "sparc");
|
2020-11-18 16:20:36 +00:00
|
|
|
|
2022-01-05 21:46:50 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("missing-machine");
|
2016-02-25 15:21:41 +00:00
|
|
|
|
2021-11-15 16:00:56 +00:00
|
|
|
DO_TEST_CAPS_LATEST("name-escape");
|
2016-03-10 19:46:39 +00:00
|
|
|
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("usb-too-long-port-path-invalid");
|
2016-03-29 22:23:02 +00:00
|
|
|
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("acpi-table");
|
2019-05-17 12:45:36 +00:00
|
|
|
|
|
|
|
DO_TEST_CAPS_LATEST("intel-iommu");
|
|
|
|
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");
|
2021-09-23 12:46:23 +00:00
|
|
|
DO_TEST_CAPS_LATEST("virtio-iommu-x86_64");
|
2021-10-07 17:35:45 +00:00
|
|
|
DO_TEST_CAPS_VER_PARSE_ERROR("virtio-iommu-x86_64", "6.1.0");
|
2021-09-23 12:46:23 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("virtio-iommu-aarch64", "aarch64");
|
2021-09-22 17:02:17 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("virtio-iommu-wrong-machine");
|
2021-10-07 16:47:20 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("virtio-iommu-no-acpi");
|
2021-10-07 17:53:45 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("virtio-iommu-invalid-address-type");
|
2021-10-07 17:44:26 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("virtio-iommu-invalid-address");
|
2016-05-12 11:21:01 +00:00
|
|
|
|
2023-08-28 12:11:52 +00:00
|
|
|
DO_TEST_CAPS_LATEST("cpu-hotplug-startup");
|
2023-03-17 14:52:06 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_PARSE_ERROR("cpu-hotplug-granularity", "ppc64");
|
2017-12-14 14:54:59 +00:00
|
|
|
|
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");
|
2023-09-01 11:47:30 +00:00
|
|
|
DO_TEST_CAPS_VER_PARSE_ERROR("virtio-options-memballoon-freepage-reporting", "5.0.0");
|
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");
|
2016-08-04 12:36:24 +00:00
|
|
|
|
2023-08-15 14:55:10 +00:00
|
|
|
DO_TEST_CAPS_LATEST("fd-memory-numa-topology");
|
|
|
|
DO_TEST_CAPS_LATEST("fd-memory-numa-topology2");
|
|
|
|
DO_TEST_CAPS_LATEST("fd-memory-numa-topology3");
|
2021-09-15 14:05:49 +00:00
|
|
|
DO_TEST_CAPS_LATEST("fd-memory-numa-topology4");
|
2017-02-02 13:27:33 +00:00
|
|
|
|
2023-08-15 14:55:10 +00:00
|
|
|
DO_TEST_CAPS_LATEST("fd-memory-no-numa-topology");
|
2017-02-02 13:27:33 +00:00
|
|
|
|
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
|
|
|
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("cpu-check-none");
|
2023-09-14 13:15:55 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-check-partial", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("cpu-check-full");
|
|
|
|
DO_TEST_CAPS_LATEST("cpu-check-default-none");
|
|
|
|
DO_TEST_CAPS_LATEST("cpu-check-default-none2");
|
2023-09-04 11:47:42 +00:00
|
|
|
/* this test case uses 'cpu="host-model"', run it with Haswell host cpu to prevent test case churn */
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-check-default-partial", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
|
2023-09-14 13:15:55 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-check-default-partial2", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
|
2017-03-01 15:12:07 +00:00
|
|
|
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("cpu-cache-disable");
|
2023-09-04 11:47:42 +00:00
|
|
|
/* this test case uses 'cpu="host-model"', run it with Haswell host cpu to prevent test case churn */
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-cache-disable3", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("cpu-cache-passthrough");
|
|
|
|
DO_TEST_CAPS_LATEST("cpu-cache-emulate-l3");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("cpu-cache-emulate-l2");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("cpu-cache-passthrough3");
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("cpu-cache-passthrough-l3");
|
|
|
|
DO_TEST_CAPS_LATEST("vmcoreinfo");
|
2017-04-25 17:07:19 +00:00
|
|
|
|
2022-07-15 14:48:22 +00:00
|
|
|
DO_TEST_CAPS_LATEST("user-aliases");
|
|
|
|
DO_TEST_CAPS_LATEST("user-aliases2");
|
|
|
|
DO_TEST_CAPS_LATEST("user-aliases-usb");
|
2017-10-20 14:48: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_LATEST_PARSE_ERROR("tseg-invalid-size");
|
2018-05-10 21:37:18 +00:00
|
|
|
|
2023-03-24 14:28:56 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("video-virtio-gpu-ccw", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("input-virtio-ccw", "s390x");
|
2018-03-23 17:22:42 +00:00
|
|
|
|
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");
|
2021-01-27 18:46:59 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("vhost-vsock-ccw-iommu", "s390x");
|
2018-05-22 13:57:47 +00:00
|
|
|
|
2021-06-10 13:58:15 +00:00
|
|
|
DO_TEST_CAPS_VER("launch-security-sev", "6.0.0");
|
2022-02-10 09:01:36 +00:00
|
|
|
DO_TEST_CAPS_VER("launch-security-sev-missing-platform-info", "6.0.0");
|
2021-12-09 14:57:05 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL("launch-security-sev-direct",
|
|
|
|
"x86_64",
|
|
|
|
ARG_QEMU_CAPS,
|
|
|
|
QEMU_CAPS_SEV_GUEST,
|
|
|
|
QEMU_CAPS_LAST);
|
2018-06-08 14:40:58 +00:00
|
|
|
|
2021-07-21 11:17:40 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("launch-security-s390-pv", "s390x");
|
|
|
|
|
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
|
|
|
|
2019-01-11 20:06:05 +00:00
|
|
|
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");
|
2024-01-16 14:51:31 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("aarch64-virt-headless-mmio", "aarch64");
|
2018-09-05 11:38:34 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("ppc64-pseries-headless", "ppc64");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("riscv64-virt-headless", "riscv64");
|
2024-01-16 14:51:31 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("riscv64-virt-headless-mmio", "riscv64");
|
2018-09-05 11:38:34 +00:00
|
|
|
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-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_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");
|
2021-11-04 10:43:52 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST("x86_64-default-cpu-tcg-features", "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-10-08 14:32:25 +00:00
|
|
|
DO_TEST_CAPS_LATEST("virtio-9p-createmode");
|
2020-03-30 18:26:19 +00:00
|
|
|
|
2021-04-06 14:01:20 +00:00
|
|
|
DO_TEST_CAPS_LATEST("devices-acpi-index");
|
|
|
|
|
2023-03-08 16:12:07 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL("hvf-x86_64-q35-headless", "x86_64", ARG_CAPS_VARIANT, "+hvf", ARG_END);
|
2023-03-08 16:12:07 +00:00
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL("hvf-aarch64-virt-headless", "aarch64", ARG_CAPS_VARIANT, "+hvf", ARG_END);
|
2022-01-04 16:27:01 +00:00
|
|
|
/* HVF guests should not work on Linux with KVM */
|
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("hvf-x86_64-q35-headless");
|
|
|
|
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST("cpu-phys-bits-passthrough");
|
|
|
|
DO_TEST_CAPS_LATEST("cpu-phys-bits-emulate");
|
2023-09-04 11:47:42 +00:00
|
|
|
/* this test case uses 'cpu="host"', run it with Haswell host cpu to prevent test case churn */
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST_FULL("cpu-phys-bits-emulate2", "x86_64", ARG_CAPS_HOST_CPU_MODEL, QEMU_CPU_DEF_HASWELL);
|
2023-09-04 12:15:35 +00:00
|
|
|
DO_TEST_CAPS_LATEST_PARSE_ERROR("cpu-phys-bits-passthrough2");
|
2023-03-01 11:31:41 +00:00
|
|
|
DO_TEST_CAPS_LATEST("cpu-phys-bits-limit");
|
2023-04-25 09:11:59 +00:00
|
|
|
DO_TEST_CAPS_LATEST("cpu-phys-bits-emulate-bare");
|
2022-07-29 19:34:35 +00:00
|
|
|
|
qemu: Add command-line to generate SGX EPC memory backend
According to the result parsing from xml, add the argument of
SGX EPC memory backend into QEMU command line.
$ qemu-system-x86_64 \
...... \
-object '{"qom-type":"memory-backend-epc","id":"memepc0","prealloc":true,"size":67108864,"host-nodes":[0,1],"policy":"bind"}' \
-object '{"qom-type":"memory-backend-epc","id":"memepc1","prealloc":true,"size":16777216,"host-nodes":[2,3],"policy":"bind"}' \
-machine sgx-epc.0.memdev=memepc0,sgx-epc.0.node=0,sgx-epc.1.memdev=memepc1,sgx-epc.1.node=1
Signed-off-by: Lin Yang <lin.a.yang@intel.com>
Signed-off-by: Haibin Huang <haibin.huang@intel.com>
Signed-off-by: Michal Privoznik <mprivozn@redhat.com>
Reviewed-by: Michal Privoznik <mprivozn@redhat.com>
2022-11-11 01:21:27 +00:00
|
|
|
DO_TEST_CAPS_VER("sgx-epc", "7.0.0");
|
|
|
|
|
2023-01-17 01:46:53 +00:00
|
|
|
DO_TEST_CAPS_LATEST("crypto-builtin");
|
|
|
|
|
2023-07-05 06:20:26 +00:00
|
|
|
DO_TEST_CAPS_LATEST("async-teardown");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("s390-async-teardown", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("s390-async-teardown-no-attrib", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_VER_PARSE_ERROR("s390-async-teardown", "s390x", "6.0.0");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("s390-async-teardown-disabled", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_VER("s390-async-teardown-disabled", "s390x", "6.0.0");
|
|
|
|
|
2023-12-01 15:53:32 +00:00
|
|
|
DO_TEST_CAPS_LATEST("boot-menu-disable-with-timeout");
|
|
|
|
DO_TEST_CAPS_LATEST("channel-unix-source-path");
|
|
|
|
DO_TEST_CAPS_LATEST("chardev-label");
|
|
|
|
DO_TEST_CAPS_LATEST("console-compat2");
|
|
|
|
DO_TEST_CAPS_LATEST("cpu-empty");
|
|
|
|
DO_TEST_CAPS_LATEST("cpu-host-model-features");
|
|
|
|
DO_TEST_CAPS_LATEST("cpu-numa-disordered");
|
|
|
|
DO_TEST_CAPS_LATEST("disk-active-commit");
|
|
|
|
DO_TEST_CAPS_LATEST("disk-mirror-old");
|
|
|
|
DO_TEST_CAPS_LATEST("disk-mirror");
|
|
|
|
DO_TEST_CAPS_VER("disk-network-vxhs", "5.0.0");
|
|
|
|
DO_TEST_CAPS_LATEST("downscript");
|
|
|
|
DO_TEST_CAPS_LATEST("hostdev-mdev-display");
|
|
|
|
DO_TEST_CAPS_LATEST("hostdev-scsi-autogen-address");
|
|
|
|
DO_TEST_CAPS_LATEST("hostdev-scsi-large-unit");
|
|
|
|
DO_TEST_CAPS_LATEST("hostdev-scsi-shareable");
|
|
|
|
DO_TEST_CAPS_LATEST("lease");
|
|
|
|
DO_TEST_CAPS_LATEST("memorybacking-set");
|
|
|
|
DO_TEST_CAPS_LATEST("memorybacking-unset");
|
|
|
|
DO_TEST_CAPS_LATEST("metadata-duplicate");
|
|
|
|
DO_TEST_CAPS_LATEST("metadata");
|
|
|
|
DO_TEST_CAPS_LATEST("net-midonet");
|
|
|
|
DO_TEST_CAPS_LATEST("numad-auto-vcpu-no-numatune");
|
|
|
|
DO_TEST_CAPS_LATEST("numad-static-vcpu-no-numatune");
|
|
|
|
DO_TEST_CAPS_LATEST("numavcpus-topology-mismatch");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("panic-pseries", "ppc64");
|
|
|
|
DO_TEST_CAPS_LATEST("pcihole64-gib");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("s390-defaultconsole", "s390x");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("s390-panic", "s390x");
|
|
|
|
DO_TEST_CAPS_LATEST("seclabel-device-multiple");
|
2023-12-05 09:12:41 +00:00
|
|
|
DO_TEST_CAPS_LATEST("seclabel-dynamic-none-relabel");
|
2023-12-01 15:53:32 +00:00
|
|
|
DO_TEST_CAPS_LATEST("seclabel-dynamic-none");
|
|
|
|
DO_TEST_CAPS_LATEST("serial-target-port-auto");
|
|
|
|
DO_TEST_CAPS_LATEST("vhost-user-fs-sock");
|
|
|
|
DO_TEST_CAPS_ARCH_LATEST("video-virtio-gpu-ccw-auto", "s390x");
|
|
|
|
|
2023-12-04 13:51:14 +00:00
|
|
|
DO_TEST_CAPS_LATEST("graphics-listen-network");
|
2023-12-04 13:52:34 +00:00
|
|
|
DO_TEST_CAPS_LATEST("net-bandwidth");
|
|
|
|
DO_TEST_CAPS_LATEST("net-bandwidth2");
|
|
|
|
DO_TEST_CAPS_LATEST("net-coalesce");
|
|
|
|
DO_TEST_CAPS_LATEST("net-isolated-port");
|
|
|
|
DO_TEST_CAPS_LATEST("net-mtu");
|
|
|
|
DO_TEST_CAPS_LATEST("net-openvswitch");
|
|
|
|
DO_TEST_CAPS_LATEST("net-virtio-network-portgroup");
|
|
|
|
DO_TEST_CAPS_LATEST("net-virtio-teaming-network");
|
|
|
|
DO_TEST_CAPS_LATEST("tap-vhost-incorrect");
|
|
|
|
DO_TEST_CAPS_LATEST("tap-vhost");
|
2023-12-04 13:51:14 +00:00
|
|
|
|
2023-12-01 15:47:23 +00:00
|
|
|
/* check that all input files were actually used here */
|
|
|
|
if (testConfXMLCheck(existingTestCases) < 0)
|
|
|
|
ret = -1;
|
|
|
|
|
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"),
|
2023-03-07 14:36:35 +00:00
|
|
|
VIR_TEST_MOCK("virpci"),
|
|
|
|
VIR_TEST_MOCK("virnuma"))
|
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 */
|