External/libvirt
1
0
Fork 0
mirror of https://gitlab.com/libvirt/libvirt.git synced 2024-11-09 15:00:07 +00:00
Code Issues Packages Projects Releases Wiki Activity
6d3955acf1
libvirt/tests/testutilsqemu.c
Rayhan Faizel d666426718 tests: Move domainEventState initialization to qemuTestDriverInit 
Under the test environment, driver->domainEventState is uninitialized. If a
disk gets dropped, it will attempt to queue an event which will cause a
segmentation fault. This crash does not occur during normal use.

This patch moves driver->domainEventState initialization from qemuhotplugtest
to qemuTestDriverInit in testutilsqemu (Credit goes to Michal Privoznik as he
had already provided the diff).

An additional test case is added to test dropping of disks with startupPolicy
set as optional.

Signed-off-by: Rayhan Faizel <rayhan.faizel@gmail.com>
Reviewed-by: Michal Privoznik <mprivozn@redhat.com>
2024-07-04 09:27:34 +02:00

1079 lines
31 KiB
C
Raw Blame History

#include <config.h>
#ifdef WITH_QEMU
# include "testutilsqemu.h"
# include "testutilsqemuschema.h"
# include "testutilshostcpus.h"
# include "testutils.h"
# include "viralloc.h"
# include "cpu_conf.h"
# include "qemu/qemu_domain.h"
# define LIBVIRT_QEMU_CAPSPRIV_H_ALLOW
# include "qemu/qemu_capspriv.h"
# include "virstring.h"
# include "virfilecache.h"
# include "virtpm.h"
# include <sys/types.h>
# include <fcntl.h>
# define VIR_FROM_THIS VIR_FROM_QEMU
static virCPUDef *cpuDefault;
static virCPUDef *cpuHaswell;
static virCPUDef *cpuPower8;
static virCPUDef *cpuPower9;
static virCPUDef *cpuPower10;
char *
virFindFileInPath(const char *file)
{
if (g_str_has_prefix(file, "qemu-system") ||
g_str_equal(file, "qemu-kvm")) {
return g_strdup_printf("/usr/bin/%s", file);
}
if (g_str_equal(file, "nbdkit")) {
return g_strdup(TEST_NBDKIT_PATH);
}
/* Nothing in tests should be relying on real files
* in host OS, so we return NULL to try to force
* an error in such a case
*/
return NULL;
}
/* Enough to tell capabilities code that swtpm is usable */
bool virTPMHasSwtpm(void)
{
return true;
}
bool
virTPMSwtpmSetupCapsGet(virTPMSwtpmSetupFeature cap)
{
const char *tpmver = getenv(TEST_TPM_ENV_VAR);
switch (cap) {
case VIR_TPM_SWTPM_SETUP_FEATURE_TPM_1_2:
if (!tpmver || (tpmver && strstr(tpmver, TPM_VER_1_2)))
return true;
break;
case VIR_TPM_SWTPM_SETUP_FEATURE_TPM_2_0:
if (!tpmver || (tpmver && strstr(tpmver, TPM_VER_2_0)))
return true;
break;
case VIR_TPM_SWTPM_SETUP_FEATURE_CMDARG_PWDFILE_FD:
case VIR_TPM_SWTPM_SETUP_FEATURE_CMDARG_CREATE_CONFIG_FILES:
case VIR_TPM_SWTPM_SETUP_FEATURE_TPM12_NOT_NEED_ROOT:
case VIR_TPM_SWTPM_SETUP_FEATURE_CMDARG_RECONFIGURE_PCR_BANKS:
case VIR_TPM_SWTPM_SETUP_FEATURE_LAST:
break;
}
return false;
}
virCapsHostNUMA *
virCapabilitiesHostNUMANewHost(void)
{
/*
* Build a NUMA topology with cell_id (NUMA node id
* being 3(0 + 3),4(1 + 3), 5 and 6
*/
return virTestCapsBuildNUMATopology(3);
}
void
virHostCPUX86GetCPUID(uint32_t leaf,
uint32_t extended,
uint32_t *eax,
uint32_t *ebx,
uint32_t *ecx,
uint32_t *edx)
{
if (eax)
*eax = 0;
if (ebx)
*ebx = 0;
if (ecx)
*ecx = 0;
if (edx)
*edx = 0;
if (leaf == 0x8000001F && extended == 0) {
if (ecx)
*ecx = 509;
if (edx)
*edx = 451;
}
}
static virCaps *
testQemuCapsInit(void)
{
virCaps *caps;
if (!(caps = virCapabilitiesNew(VIR_ARCH_X86_64, false, false)))
return NULL;
/* Add dummy 'none' security_driver. This is equal to setting
* security_driver = "none" in qemu.conf. */
caps->host.secModels = g_new0(virCapsHostSecModel, 1);
caps->host.nsecModels = 1;
caps->host.secModels[0].model = g_strdup("none");
caps->host.secModels[0].doi = g_strdup("0");
if (!(caps->host.numa = virCapabilitiesHostNUMANewHost()))
goto cleanup;
if (virTestGetDebug()) {
g_autofree char *caps_str = NULL;
caps_str = virCapabilitiesFormatXML(caps);
if (!caps_str)
goto cleanup;
VIR_TEST_DEBUG("QEMU driver capabilities:\n%s", caps_str);
}
return caps;
cleanup:
caps->host.cpu = NULL;
virObjectUnref(caps);
return NULL;
}
virCPUDef *
qemuTestGetCPUDef(qemuTestCPUDef d)
{
switch (d) {
case QEMU_CPU_DEF_DEFAULT: return cpuDefault;
case QEMU_CPU_DEF_HASWELL: return cpuHaswell;
case QEMU_CPU_DEF_POWER8: return cpuPower8;
case QEMU_CPU_DEF_POWER9: return cpuPower9;
case QEMU_CPU_DEF_POWER10: return cpuPower10;
}
return NULL;
}
void
qemuTestSetHostArch(virQEMUDriver *driver,
virArch arch)
{
if (arch == VIR_ARCH_NONE)
arch = VIR_ARCH_X86_64;
virTestSetHostArch(arch);
driver->hostarch = virArchFromHost();
driver->caps->host.arch = virArchFromHost();
qemuTestSetHostCPU(driver, arch, NULL);
}
void
qemuTestSetHostCPU(virQEMUDriver *driver,
virArch arch,
virCPUDef *cpu)
{
if (!cpu) {
if (ARCH_IS_X86(arch))
cpu = cpuDefault;
else if (ARCH_IS_PPC64(arch))
cpu = cpuPower8;
}
g_unsetenv("VIR_TEST_MOCK_FAKE_HOST_CPU");
if (cpu) {
if (cpu->model)
g_setenv("VIR_TEST_MOCK_FAKE_HOST_CPU", cpu->model, TRUE);
}
if (driver) {
if (cpu)
driver->caps->host.arch = cpu->arch;
driver->caps->host.cpu = cpu;
virCPUDefFree(driver->hostcpu);
if (cpu)
virCPUDefRef(cpu);
driver->hostcpu = cpu;
}
}
virQEMUCaps *
qemuTestParseCapabilitiesArch(virArch arch,
const char *capsFile)
{
g_autofree char *binary = g_strdup_printf("/usr/bin/qemu-system-%s",
virArchToString(arch));
g_autoptr(virQEMUCaps) qemuCaps = virQEMUCapsNewBinary(binary);
if (virQEMUCapsLoadCache(arch, qemuCaps, capsFile, true) < 0)
return NULL;
return g_steal_pointer(&qemuCaps);
}
void qemuTestDriverFree(virQEMUDriver *driver)
{
virMutexDestroy(&driver->lock);
if (driver->config) {
virFileDeleteTree(driver->config->stateDir);
virFileDeleteTree(driver->config->configDir);
}
virObjectUnref(driver->qemuCapsCache);
virObjectUnref(driver->xmlopt);
virObjectUnref(driver->caps);
virObjectUnref(driver->config);
virObjectUnref(driver->securityManager);
virObjectUnref(driver->domainEventState);
g_clear_object(&driver->nbdkitCapsCache);
virCPUDefFree(cpuDefault);
virCPUDefFree(cpuHaswell);
virCPUDefFree(cpuPower8);
virCPUDefFree(cpuPower9);
virCPUDefFree(cpuPower10);
}
static int
qemuTestCapsCacheInsertData(virFileCache *cache,
const char *binary,
virQEMUCaps *caps)
{
if (virFileCacheInsertData(cache, binary, virObjectRef(caps)) < 0) {
virObjectUnref(caps);
return -1;
}
return 0;
}
int
qemuTestCapsCacheInsert(virFileCache *cache,
virQEMUCaps *caps)
{
/* At this point we support only real capabilities. */
if (virQEMUCapsGetArch(caps) == VIR_ARCH_NONE ||
!virQEMUCapsGetBinary(caps)) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
"missing 'arch' or 'binary' in qemuCaps to be inserted into testing cache");
return -1;
}
if (qemuTestCapsCacheInsertData(cache, virQEMUCapsGetBinary(caps), caps) < 0)
return -1;
return 0;
}
# define STATEDIRTEMPLATE abs_builddir "/qemustatedir-XXXXXX"
# define CONFIGDIRTEMPLATE abs_builddir "/qemuconfigdir-XXXXXX"
int qemuTestDriverInit(virQEMUDriver *driver)
{
virQEMUDriverConfig *cfg = NULL;
virSecurityManager *mgr = NULL;
char statedir[] = STATEDIRTEMPLATE;
char configdir[] = CONFIGDIRTEMPLATE;
memset(driver, 0, sizeof(*driver));
cpuDefault = virCPUDefCopy(&cpuDefaultData);
cpuHaswell = virCPUDefCopy(&cpuHaswellData);
cpuPower8 = virCPUDefCopy(&cpuPower8Data);
cpuPower9 = virCPUDefCopy(&cpuPower9Data);
cpuPower10 = virCPUDefCopy(&cpuPower10Data);
if (virMutexInit(&driver->lock) < 0)
return -1;
driver->hostarch = virArchFromHost();
cfg = virQEMUDriverConfigNew(false, NULL);
if (!cfg)
goto error;
driver->config = cfg;
/* Do this early so that qemuTestDriverFree() doesn't see (unlink) the real
* dirs. */
VIR_FREE(cfg->stateDir);
VIR_FREE(cfg->configDir);
/* Override paths to ensure predictable output
*
* FIXME Find a way to achieve the same result while avoiding
* code duplication
*/
VIR_FREE(cfg->libDir);
cfg->libDir = g_strdup("/var/lib/libvirt/qemu");
VIR_FREE(cfg->channelTargetDir);
cfg->channelTargetDir = g_strdup("/var/run/libvirt/qemu/channel");
VIR_FREE(cfg->memoryBackingDir);
cfg->memoryBackingDir = g_strdup("/var/lib/libvirt/qemu/ram");
VIR_FREE(cfg->nvramDir);
cfg->nvramDir = g_strdup("/var/lib/libvirt/qemu/nvram");
VIR_FREE(cfg->passtStateDir);
cfg->passtStateDir = g_strdup("/var/run/libvirt/qemu/passt");
VIR_FREE(cfg->dbusStateDir);
cfg->dbusStateDir = g_strdup("/var/run/libvirt/qemu/dbus");
if (!g_mkdtemp(statedir)) {
fprintf(stderr, "Cannot create fake stateDir");
goto error;
}
cfg->stateDir = g_strdup(statedir);
if (!g_mkdtemp(configdir)) {
fprintf(stderr, "Cannot create fake configDir");
goto error;
}
cfg->configDir = g_strdup(configdir);
driver->caps = testQemuCapsInit();
if (!driver->caps)
goto error;
/* Using /dev/null for libDir and cacheDir automatically produces errors
* upon attempt to use any of them */
driver->qemuCapsCache = virQEMUCapsCacheNew("/dev/null", "/dev/null", 0, 0);
if (!driver->qemuCapsCache)
goto error;
driver->nbdkitCapsCache = qemuNbdkitCapsCacheNew("/dev/null");
/* the nbdkitCapsCache just interprets the presence of a non-null private
* data pointer as a signal to skip cache validation. This prevents the
* cache from trying to validate the plugindir mtime, etc during test */
virFileCacheSetPriv(driver->nbdkitCapsCache, GUINT_TO_POINTER(1));
driver->xmlopt = virQEMUDriverCreateXMLConf(driver, "none");
if (!driver->xmlopt)
goto error;
if (!(mgr = virSecurityManagerNew("none", "qemu",
VIR_SECURITY_MANAGER_PRIVILEGED)))
goto error;
if (!(driver->securityManager = virSecurityManagerNewStack(mgr)))
goto error;
if (!(driver->domainEventState = virObjectEventStateNew()))
goto error;
qemuTestSetHostCPU(driver, driver->hostarch, NULL);
VIR_FREE(cfg->vncTLSx509certdir);
cfg->vncTLSx509certdir = g_strdup("/etc/pki/libvirt-vnc");
VIR_FREE(cfg->spiceTLSx509certdir);
cfg->spiceTLSx509certdir = g_strdup("/etc/pki/libvirt-spice");
VIR_FREE(cfg->chardevTLSx509certdir);
cfg->chardevTLSx509certdir = g_strdup("/etc/pki/libvirt-chardev");
VIR_FREE(cfg->vxhsTLSx509certdir);
cfg->vxhsTLSx509certdir = g_strdup("/etc/pki/libvirt-vxhs");
VIR_FREE(cfg->nbdTLSx509certdir);
cfg->nbdTLSx509certdir = g_strdup("/etc/pki/libvirt-nbd");
VIR_FREE(cfg->migrateTLSx509certdir);
cfg->migrateTLSx509certdir = g_strdup("/etc/pki/libvirt-migrate");
VIR_FREE(cfg->backupTLSx509certdir);
cfg->backupTLSx509certdir = g_strdup("/etc/pki/libvirt-backup");
VIR_FREE(cfg->vncSASLdir);
cfg->vncSASLdir = g_strdup("/etc/sasl2");
VIR_FREE(cfg->spiceSASLdir);
cfg->spiceSASLdir = g_strdup("/etc/sasl2");
VIR_FREE(cfg->spicePassword);
cfg->spicePassword = g_strdup("123456");
VIR_FREE(cfg->hugetlbfs);
cfg->hugetlbfs = g_new0(virHugeTLBFS, 2);
cfg->nhugetlbfs = 2;
cfg->hugetlbfs[0].mnt_dir = g_strdup("/dev/hugepages2M");
cfg->hugetlbfs[1].mnt_dir = g_strdup("/dev/hugepages1G");
cfg->hugetlbfs[0].size = 2048;
cfg->hugetlbfs[0].deflt = true;
cfg->hugetlbfs[1].size = 1048576;
driver->privileged = true;
return 0;
error:
virObjectUnref(mgr);
qemuTestDriverFree(driver);
return -1;
}
int
testQemuCapsSetGIC(virQEMUCaps *qemuCaps,
int gic)
{
virGICCapability *gicCapabilities = NULL;
size_t ngicCapabilities = 0;
gicCapabilities = g_new0(virGICCapability, 2);
# define IMPL_BOTH \
VIR_GIC_IMPLEMENTATION_KERNEL|VIR_GIC_IMPLEMENTATION_EMULATED
if (gic & GIC_V2) {
gicCapabilities[ngicCapabilities].version = VIR_GIC_VERSION_2;
gicCapabilities[ngicCapabilities].implementation = IMPL_BOTH;
ngicCapabilities++;
}
if (gic & GIC_V3) {
gicCapabilities[ngicCapabilities].version = VIR_GIC_VERSION_3;
gicCapabilities[ngicCapabilities].implementation = IMPL_BOTH;
ngicCapabilities++;
}
# undef IMPL_BOTH
virQEMUCapsSetGICCapabilities(qemuCaps,
gicCapabilities, ngicCapabilities);
return 0;
}
#endif
struct testQemuCapsFile {
unsigned long long ver;
char *path;
};
static void
testQemuCapsFileFree(struct testQemuCapsFile *f)
{
if (!f)
return;
g_free(f->path);
g_free(f);
}
char *
testQemuGetLatestCapsForArch(const char *arch,
const char *suffix)
{
g_autoptr(GHashTable) caps = testQemuGetLatestCaps();
struct testQemuCapsFile *f;
if (!(f = g_hash_table_lookup(caps, arch))) {
VIR_TEST_VERBOSE("failed to find capabilities for '%s' in '%s'",
arch, TEST_QEMU_CAPS_PATH);
return NULL;
}
if (STRNEQ(suffix, "xml")) {
ignore_value(virStringStripSuffix(f->path, "xml"));
return g_strdup_printf("%s%s", f->path, suffix);
}
return g_steal_pointer(&f->path);
}
GHashTable *
testQemuGetLatestCaps(void)
{
g_autoptr(GHashTable) caps = virHashNew((GDestroyNotify)testQemuCapsFileFree);
struct dirent *ent;
g_autoptr(DIR) dir = NULL;
int rc;
if (virDirOpen(&dir, TEST_QEMU_CAPS_PATH) < 0)
return NULL;
while ((rc = virDirRead(dir, &ent, TEST_QEMU_CAPS_PATH)) > 0) {
g_autofree char *version = NULL;
char *arch = NULL;
unsigned long long ver;
struct testQemuCapsFile *f;
if (!(version = g_strdup(STRSKIP(ent->d_name, "caps_"))))
continue;
if (!virStringStripSuffix(version, ".xml"))
continue;
if (!(arch = strchr(version, '_'))) {
VIR_TEST_VERBOSE("malformed caps file name '%s'", ent->d_name);
return NULL;
}
*arch = '\0';
arch++;
if (virStringParseVersion(&ver, version, false) < 0) {
VIR_TEST_VERBOSE("malformed caps file name '%s'", ent->d_name);
return NULL;
}
if (!(f = g_hash_table_lookup(caps, arch))) {
VIR_TEST_DEBUG("CAPS: '%s': 'X' -> '%llu'", arch, ver);
f = g_new0(struct testQemuCapsFile, 1);
f->ver = ver;
f->path = g_strdup_printf("%s/%s", TEST_QEMU_CAPS_PATH, ent->d_name);
g_hash_table_insert(caps, g_strdup(arch), f);
continue;
}
if (f->ver < ver) {
VIR_TEST_DEBUG("CAPS: '%s': '%llu' -> '%llu'", arch, f->ver, ver);
f->ver = ver;
g_free(f->path);
f->path = g_strdup_printf("%s/%s", TEST_QEMU_CAPS_PATH, ent->d_name);
}
}
if (rc < 0)
return NULL;
return g_steal_pointer(&caps);
}
int
testQemuCapsIterate(const char *suffix,
testQemuCapsIterateCallback callback,
void *opaque)
{
struct dirent *ent;
g_autoptr(DIR) dir = NULL;
int rc;
bool fail = false;
if (!callback)
return 0;
/* Validate suffix */
if (!STRPREFIX(suffix, ".")) {
VIR_TEST_VERBOSE("malformed suffix '%s'", suffix);
return -1;
}
if (virDirOpen(&dir, TEST_QEMU_CAPS_PATH) < 0)
return -1;
while ((rc = virDirRead(dir, &ent, TEST_QEMU_CAPS_PATH)) > 0) {
g_autofree char *tmp = g_strdup(ent->d_name);
char *version = NULL;
char *archName = NULL;
g_autofree char *variant = NULL;
char *var;
/* Strip the trailing suffix, moving on if it's not present */
if (!virStringStripSuffix(tmp, suffix))
continue;
/* Strip the leading prefix */
if (!(version = STRSKIP(tmp, "caps_"))) {
VIR_TEST_VERBOSE("malformed file name '%s'", ent->d_name);
return -1;
}
/* Find the underscore separating version from arch */
if (!(archName = strchr(version, '_'))) {
VIR_TEST_VERBOSE("malformed file name '%s'", ent->d_name);
return -1;
}
/* The version number and the architecture name are separated by
* a underscore: overwriting that underscore with \0 results in both
* being usable as independent, null-terminated strings */
archName[0] = '\0';
archName++;
/* Find the 'variant' of the test and split it including the leading '+' */
if ((var = strchr(archName, '+'))) {
variant = g_strdup(var);
var[0] = '\0';
} else {
variant = g_strdup("");
}
/* Run the user-provided callback.
*
* We skip the dot that, as verified earlier, starts the suffix
* to make it nicer to rebuild the original file name from inside
* the callback.
*/
if (callback(TEST_QEMU_CAPS_PATH, "caps", version,
archName, variant, suffix + 1, opaque) < 0)
fail = true;
}
if (rc < 0 || fail)
return -1;
return 0;
}
void
testQemuInfoSetArgs(testQemuInfo *info,
va_list argptr)
{
testQemuInfoArgName argname;
int flag;
info->args.newargs = true;
while ((argname = va_arg(argptr, testQemuInfoArgName)) != ARG_END) {
switch (argname) {
case ARG_QEMU_CAPS:
if (!(info->args.fakeCapsAdd))
info->args.fakeCapsAdd = virBitmapNew(QEMU_CAPS_LAST);
while ((flag = va_arg(argptr, int)) < QEMU_CAPS_LAST)
ignore_value(virBitmapSetBit(info->args.fakeCapsAdd, flag));
break;
case ARG_QEMU_CAPS_DEL:
if (!(info->args.fakeCapsDel))
info->args.fakeCapsDel = virBitmapNew(QEMU_CAPS_LAST);
while ((flag = va_arg(argptr, int)) < QEMU_CAPS_LAST)
ignore_value(virBitmapSetBit(info->args.fakeCapsDel, flag));
break;
case ARG_NBDKIT_CAPS:
if (!(info->args.fakeNbdkitCaps))
info->args.fakeNbdkitCaps = virBitmapNew(QEMU_NBDKIT_CAPS_LAST);
while ((flag = va_arg(argptr, int)) < QEMU_NBDKIT_CAPS_LAST)
ignore_value(virBitmapSetBit(info->args.fakeNbdkitCaps, flag));
break;
case ARG_GIC:
info->args.gic = va_arg(argptr, int);
break;
case ARG_MIGRATE_FROM:
info->migrateFrom = va_arg(argptr, char *);
break;
case ARG_MIGRATE_FD:
info->migrateFd = va_arg(argptr, int);
break;
case ARG_FLAGS:
info->flags = va_arg(argptr, int);
break;
case ARG_PARSEFLAGS:
info->parseFlags = va_arg(argptr, int);
break;
case ARG_CAPS_ARCH:
info->args.capsarch = va_arg(argptr, char *);
break;
case ARG_CAPS_VER:
info->args.capsver = va_arg(argptr, char *);
break;
case ARG_CAPS_VARIANT:
info->args.capsvariant = va_arg(argptr, char *);
break;
case ARG_CAPS_HOST_CPU_MODEL:
info->args.capsHostCPUModel = va_arg(argptr, int);
break;
case ARG_FD_GROUP: {
virStorageSourceFDTuple *new = virStorageSourceFDTupleNew();
const char *fdname = va_arg(argptr, char *);
VIR_AUTOCLOSE fakefd = open("/dev/zero", O_RDWR);
size_t i;
new->nfds = va_arg(argptr, unsigned int);
new->fds = g_new0(int, new->nfds);
new->testfds = g_new0(int, new->nfds);
for (i = 0; i < new->nfds; i++) {
new->testfds[i] = va_arg(argptr, unsigned int);
if (fcntl(new->testfds[i], F_GETFD) != -1) {
fprintf(stderr, "fd '%d' is already in use\n", new->fds[i]);
abort();
}
if ((new->fds[i] = dup(fakefd)) < 0) {
fprintf(stderr, "failed to duplicate fake fd: %s",
g_strerror(errno));
abort();
}
}
if (!info->args.fds)
info->args.fds = virHashNew(g_object_unref);
g_hash_table_insert(info->args.fds, g_strdup(fdname), new);
break;
}
case ARG_VDPA_FD: {
const char *vdpadev = va_arg(argptr, char *);
int vdpafd = va_arg(argptr, unsigned int);
if (!info->args.vdpafds)
info->args.vdpafds = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
g_hash_table_insert(info->args.vdpafds, g_strdup(vdpadev), GINT_TO_POINTER(vdpafd));
break;
}
case ARG_END:
default:
info->args.invalidarg = true;
break;
}
if (info->args.invalidarg)
break;
}
}
/**
* See testQemuGetRealCaps, this helper returns the pointer to the virQEMUCaps
* object as stored in the cache hash table.
*/
static virQEMUCaps *
testQemuGetRealCapsInternal(const char *arch,
const char *version,
const char *variant,
GHashTable *capsLatestFiles,
GHashTable *capsCache,
GHashTable *schemaCache,
GHashTable **schema)
{
g_autofree char *capsfile = NULL;
bool stripmachinealiases = false;
virQEMUCaps *cachedcaps = NULL;
if (STREQ(version, "latest")) {
g_autofree char *archvariant = g_strdup_printf("%s%s", arch, variant);
struct testQemuCapsFile *f = g_hash_table_lookup(capsLatestFiles, archvariant);
if (!f) {
VIR_TEST_VERBOSE("'latest' caps for '%s' were not found\n", arch);
return NULL;
}
capsfile = g_strdup(f->path);
stripmachinealiases = true;
} else {
capsfile = g_strdup_printf("%s/caps_%s_%s%s.xml",
TEST_QEMU_CAPS_PATH,
version, arch, variant);
}
if (!g_hash_table_lookup_extended(capsCache, capsfile, NULL, (void **) &cachedcaps)) {
if (!(cachedcaps = qemuTestParseCapabilitiesArch(virArchFromString(arch), capsfile))) {
VIR_TEST_VERBOSE("Failed to parse qemu capabilities file '%s'", capsfile);
return NULL;
}
if (stripmachinealiases)
virQEMUCapsStripMachineAliases(cachedcaps);
g_hash_table_insert(capsCache, g_strdup(capsfile), cachedcaps);
}
/* strip 'xml' suffix so that we can format the file to '.replies' */
capsfile[strlen(capsfile) - 3] = '\0';
if (schemaCache && schema) {
g_autofree char *schemafile = g_strdup_printf("%sreplies", capsfile);
if (!g_hash_table_lookup_extended(schemaCache, schemafile, NULL, (void **) schema)) {
*schema = testQEMUSchemaLoad(schemafile);
g_hash_table_insert(schemaCache, g_strdup(schemafile), *schema);
}
}
return cachedcaps;
}
/**
* testQemuGetRealCaps:
*
* @arch: architecture to fetch caps for
* @version: qemu version to fetch caps for ("latest" for fetching the latest version from @capsLatestFiles)
* @variant: capabilities variant to fetch caps for
* @capsLatestFiles: hash table containing latest version of capabilities for the @arch+@variant tuple
* @capsCache: hash table filled with the cache of capabilities
* @schemaCache: hash table for caching QMP schemas (may be NULL, see below)
* @schema: Filled with the QMP schema (hash table) (may be NULL, see below)
*
* Fetches and returns the appropriate virQEMUCaps for the @arch+@version+@variant
* tuple. The returned pointer is a copy of the cached object and thus can
* be freely modified. Caller is responsible for freeing it.
*
* If @schemaCache and @schema are non-NULL, @schema is filled with with a
* pointer (borrowed from the cache) to the hash table representing the QEMU QMP
* schema used for validation of the monitor traffic.
*/
virQEMUCaps *
testQemuGetRealCaps(const char *arch,
const char *version,
const char *variant,
GHashTable *capsLatestFiles,
GHashTable *capsCache,
GHashTable *schemaCache,
GHashTable **schema)
{
virQEMUCaps *cachedcaps;
if (!(cachedcaps = testQemuGetRealCapsInternal(arch, version, variant,
capsLatestFiles, capsCache,
schemaCache, schema)))
return NULL;
return virQEMUCapsNewCopy(cachedcaps);
}
/**
* testQemuInsertRealCaps:
*
* @arch: architecture to fetch caps for
* @version: qemu version to fetch caps for ("latest" for fetching the latest version from @capsLatestFiles)
* @variant: capabilities variant to fetch caps for
* @capsLatestFiles: hash table containing latest version of capabilities for the @arch+@variant tuple
* @capsCache: hash table filled with the cache of capabilities
* @schemaCache: hash table for caching QMP schemas (may be NULL, see below)
* @schema: Filled with the QMP schema (hash table) (may be NULL, see below)
*
* Fetches and inserts into the test capability cache the appropriate virQEMUCaps
* for the @arch+@version+@variant tuple. Note that the data inserted into
* the cache is borrowed from the cache thus must not be further modified.
*
* If @schemaCache and @schema are non-NULL, @schema is filled with with a
* pointer (borrowed from the cache) to the hash table representing the QEMU QMP
* schema used for validation of the monitor traffic.
*/
int
testQemuInsertRealCaps(virFileCache *cache,
const char *arch,
const char *version,
const char *variant,
GHashTable *capsLatestFiles,
GHashTable *capsCache,
GHashTable *schemaCache,
GHashTable **schema)
{
virQEMUCaps *cachedcaps;
virFileCacheClear(cache);
if (!(cachedcaps = testQemuGetRealCapsInternal(arch, version, variant,
capsLatestFiles, capsCache,
schemaCache, schema)))
return -1;
if (qemuTestCapsCacheInsertData(cache, virQEMUCapsGetBinary(cachedcaps), cachedcaps) < 0)
return -1;
return 0;
}
int
testQemuInfoInitArgs(testQemuInfo *info)
{
ssize_t cap;
if (!info->args.newargs)
return 0;
info->args.newargs = false;
if (!info->args.capsvariant)
info->args.capsvariant = "";
if (info->args.invalidarg) {
fprintf(stderr, "Invalid argument encountered by 'testQemuInfoSetArgs'\n");
return -1;
}
if (!!info->args.capsarch ^ !!info->args.capsver) {
fprintf(stderr, "ARG_CAPS_ARCH and ARG_CAPS_VER must be specified together.\n");
return -1;
}
if (info->args.capsarch && info->args.capsver) {
info->arch = virArchFromString(info->args.capsarch);
info->flags |= FLAG_REAL_CAPS;
info->qemuCaps = testQemuGetRealCaps(info->args.capsarch,
info->args.capsver,
info->args.capsvariant,
info->conf->capslatest,
info->conf->capscache,
info->conf->qapiSchemaCache,
&info->qmpSchema);
if (!info->qemuCaps)
return -1;
} else {
info->qemuCaps = virQEMUCapsNew();
}
for (cap = -1; (cap = virBitmapNextSetBit(info->args.fakeCapsAdd, cap)) >= 0;)
virQEMUCapsSet(info->qemuCaps, cap);
for (cap = -1; (cap = virBitmapNextSetBit(info->args.fakeCapsDel, cap)) >= 0;)
virQEMUCapsClear(info->qemuCaps, cap);
info->nbdkitCaps = qemuNbdkitCapsNew(TEST_NBDKIT_PATH);
for (cap = -1; (cap = virBitmapNextSetBit(info->args.fakeNbdkitCaps, cap)) >= 0;)
qemuNbdkitCapsSet(info->nbdkitCaps, cap);
if (info->args.gic != GIC_NONE &&
testQemuCapsSetGIC(info->qemuCaps, info->args.gic) < 0)
return -1;
return 0;
}
void
testQemuInfoFree(testQemuInfo *info)
{
VIR_FREE(info->infile);
VIR_FREE(info->outfile);
VIR_FREE(info->out_xml_active);
VIR_FREE(info->out_xml_inactive);
VIR_FREE(info->errfile);
virDomainDefFree(info->def);
virObjectUnref(info->qemuCaps);
g_clear_pointer(&info->args.fakeCapsAdd, virBitmapFree);
g_clear_pointer(&info->args.fakeCapsDel, virBitmapFree);
g_clear_pointer(&info->args.fds, g_hash_table_unref);
g_clear_pointer(&info->args.vdpafds, g_hash_table_unref);
g_clear_object(&info->nbdkitCaps);
g_clear_pointer(&info->args.fakeNbdkitCaps, virBitmapFree);
g_free(info);
}
/**
* testQemuPrepareHostBackendChardevOne:
* @dev: device definition object
* @chardev: chardev source object
* @opaque: Caller is expected to pass pointer to virDomainObj or NULL
*
* This helper sets up a chardev source backend for FD passing with fake
* file descriptros. It's expected to be used as callback for
* 'qemuDomainDeviceBackendChardevForeach', thus the VM object is passed via
* @opaque. Callers may pass NULL if the test scope is limited.
*/
int
testQemuPrepareHostBackendChardevOne(virDomainDeviceDef *dev,
virDomainChrSourceDef *chardev,
void *opaque)
{
virDomainObj *vm = opaque;
qemuDomainObjPrivate *priv = NULL;
qemuDomainChrSourcePrivate *charpriv = QEMU_DOMAIN_CHR_SOURCE_PRIVATE(chardev);
int fakesourcefd = -1;
const char *devalias = NULL;
if (vm)
priv = vm->privateData;
if (dev) {
virDomainDeviceInfo *info = virDomainDeviceGetInfo(dev);
devalias = info->alias;
/* vhost-user disk doesn't use FD passing */
if (dev->type == VIR_DOMAIN_DEVICE_DISK)
return 0;
if (dev->type == VIR_DOMAIN_DEVICE_NET) {
/* due to a historical bug in qemu we don't use FD passtrhough for
* vhost-sockets for network devices */
return 0;
}
/* TPMs FD passing setup is special and handled separately */
if (dev->type == VIR_DOMAIN_DEVICE_TPM)
return 0;
} else {
devalias = "monitor";
}
switch ((virDomainChrType) chardev->type) {
case VIR_DOMAIN_CHR_TYPE_NULL:
case VIR_DOMAIN_CHR_TYPE_VC:
case VIR_DOMAIN_CHR_TYPE_PTY:
case VIR_DOMAIN_CHR_TYPE_DEV:
case VIR_DOMAIN_CHR_TYPE_PIPE:
case VIR_DOMAIN_CHR_TYPE_STDIO:
case VIR_DOMAIN_CHR_TYPE_UDP:
case VIR_DOMAIN_CHR_TYPE_TCP:
case VIR_DOMAIN_CHR_TYPE_SPICEVMC:
case VIR_DOMAIN_CHR_TYPE_SPICEPORT:
case VIR_DOMAIN_CHR_TYPE_QEMU_VDAGENT:
case VIR_DOMAIN_CHR_TYPE_DBUS:
break;
case VIR_DOMAIN_CHR_TYPE_FILE:
fakesourcefd = 1750;
if (fcntl(fakesourcefd, F_GETFD) != -1)
abort();
charpriv->sourcefd = qemuFDPassNew(devalias, priv);
qemuFDPassAddFD(charpriv->sourcefd, &fakesourcefd, "-source");
break;
case VIR_DOMAIN_CHR_TYPE_UNIX:
if (chardev->data.nix.listen) {
g_autofree char *name = g_strdup_printf("%s-source", devalias);
fakesourcefd = 1729;
charpriv->directfd = qemuFDPassDirectNew(name, &fakesourcefd);
}
break;
case VIR_DOMAIN_CHR_TYPE_NMDM:
case VIR_DOMAIN_CHR_TYPE_LAST:
break;
}
if (chardev->logfile) {
int fd = 1751;
if (fcntl(fd, F_GETFD) != -1)
abort();
charpriv->logfd = qemuFDPassNew(devalias, priv);
qemuFDPassAddFD(charpriv->logfd, &fd, "-log");
}
return 0;
}
Reference in New Issue View Git Blame Copy Permalink