int qemuTestCapsCacheInsert(virQEMUCapsCachePtr cache, const char *binary,
virQEMUCapsPtr caps)
{
int ret;
if (caps) {
/* Our caps were created artificially, so we don't want
* virQEMUCapsCacheFree() to attempt to deallocate them */
virObjectRef(caps);
} else {
caps = virQEMUCapsNew();
if (!caps)
return -ENOMEM;
}
/* We can have repeating names for our test data sets,
* so make sure there's no old copy */
virHashRemoveEntry(cache->binaries, binary);
ret = virHashAddEntry(cache->binaries, binary, caps);
if (ret < 0)
virObjectUnref(caps);
else
qemuTestCapsName = binary;
return ret;
}
static int
qemuHotplugCreateObjects(virDomainXMLOptionPtr xmlopt,
virDomainObjPtr *vm,
const char *filename)
{
int ret = -1;
qemuDomainObjPrivatePtr priv = NULL;
if (!(*vm = virDomainObjNew(xmlopt)))
goto cleanup;
if (!((*vm)->def = virDomainDefParseFile(filename,
driver.caps,
driver.xmlopt,
QEMU_EXPECTED_VIRT_TYPES,
0)))
goto cleanup;
priv = (*vm)->privateData;
if (!(priv->qemuCaps = virQEMUCapsNew()))
goto cleanup;
/* for attach & detach qemu must support -device */
virQEMUCapsSet(priv->qemuCaps, QEMU_CAPS_DEVICE);
ret = 0;
cleanup:
return ret;
}
int qemuTestCapsCacheInsert(virQEMUCapsCachePtr cache,
virQEMUCapsPtr caps)
{
size_t i;
virQEMUCapsPtr tmpCaps;
if (caps) {
tmpCaps = caps;
} else {
if (!(tmpCaps = virQEMUCapsNew()))
return -ENOMEM;
}
for (i = 0; i < ARRAY_CARDINALITY(QEMUBinList); i++) {
virObjectRef(tmpCaps);
if (virHashUpdateEntry(cache->binaries,
QEMUBinList[i],
tmpCaps) < 0) {
virObjectUnref(tmpCaps);
return -1;
}
}
if (!caps)
virObjectUnref(tmpCaps);
return 0;
}
static int
testInfoSet(struct testInfo *info,
const char *name,
int when)
{
if (!(info->qemuCaps = virQEMUCapsNew()))
goto error;
virQEMUCapsSetList(info->qemuCaps,
QEMU_CAPS_DEVICE,
QEMU_CAPS_LAST);
if (qemuTestCapsCacheInsert(driver.qemuCapsCache, name,
info->qemuCaps) < 0)
goto error;
if (virAsprintf(&info->inName, "%s/qemuxml2argvdata/qemuxml2argv-%s.xml",
abs_srcdir, name) < 0)
goto error;
if (when & WHEN_INACTIVE) {
if (virAsprintf(&info->outInactiveName,
"%s/qemuxml2xmloutdata/qemuxml2xmlout-%s-inactive.xml",
abs_srcdir, name) < 0)
goto error;
if (!virFileExists(info->outInactiveName)) {
VIR_FREE(info->outInactiveName);
if (virAsprintf(&info->outInactiveName,
"%s/qemuxml2xmloutdata/qemuxml2xmlout-%s.xml",
abs_srcdir, name) < 0)
goto error;
}
}
if (when & WHEN_ACTIVE) {
if (virAsprintf(&info->outActiveName,
"%s/qemuxml2xmloutdata/qemuxml2xmlout-%s-active.xml",
abs_srcdir, name) < 0)
goto error;
if (!virFileExists(info->outActiveName)) {
VIR_FREE(info->outActiveName);
if (virAsprintf(&info->outActiveName,
"%s/qemuxml2xmloutdata/qemuxml2xmlout-%s.xml",
abs_srcdir, name) < 0)
goto error;
}
}
return 0;
error:
testInfoFree(info);
return -1;
}
static int
testQemuCaps(const void *opaque)
{
int ret = -1;
const testQemuData *data = opaque;
char *repliesFile = NULL, *capsFile = NULL;
char *replies = NULL;
qemuMonitorTestPtr mon = NULL;
virQEMUCapsPtr capsProvided = NULL, capsComputed = NULL;
if (virAsprintf(&repliesFile, "%s/qemucapabilitiesdata/%s.replies",
abs_srcdir, data->base) < 0 ||
virAsprintf(&capsFile, "%s/qemucapabilitiesdata/%s.caps",
abs_srcdir, data->base) < 0)
goto cleanup;
if (virtTestLoadFile(repliesFile, &replies) < 0)
goto cleanup;
if (!(mon = testQemuFeedMonitor(replies, data->xmlopt)))
goto cleanup;
if (!(capsProvided = qemuTestParseCapabilities(capsFile)))
goto cleanup;
if (!(capsComputed = virQEMUCapsNew()))
goto cleanup;
if (virQEMUCapsInitQMPMonitor(capsComputed,
qemuMonitorTestGetMonitor(mon)) < 0)
goto cleanup;
/* So that our test does not depend on the contents of /proc, we
* hoisted the setting of ENABLE_FIPS to virQEMUCapsInitQMP. But
* we do want to test the effect of that flag. */
if (data->fips)
virQEMUCapsSet(capsComputed, QEMU_CAPS_ENABLE_FIPS);
if (testQemuCapsCompare(capsProvided, capsComputed) < 0)
goto cleanup;
ret = 0;
cleanup:
VIR_FREE(repliesFile);
VIR_FREE(capsFile);
VIR_FREE(replies);
qemuMonitorTestFree(mon);
virObjectUnref(capsProvided);
virObjectUnref(capsComputed);
return ret;
}
static int
qemuHotplugCreateObjects(virDomainXMLOptionPtr xmlopt,
virDomainObjPtr *vm,
const char *domxml,
bool event, const char *testname)
{
int ret = -1;
qemuDomainObjPrivatePtr priv = NULL;
if (!(*vm = virDomainObjNew(xmlopt)))
goto cleanup;
priv = (*vm)->privateData;
if (!(priv->qemuCaps = virQEMUCapsNew()))
goto cleanup;
virQEMUCapsSet(priv->qemuCaps, QEMU_CAPS_VIRTIO_SCSI);
virQEMUCapsSet(priv->qemuCaps, QEMU_CAPS_DEVICE_USB_STORAGE);
virQEMUCapsSet(priv->qemuCaps, QEMU_CAPS_VIRTIO_CCW);
virQEMUCapsSet(priv->qemuCaps, QEMU_CAPS_DEVICE_IVSHMEM_PLAIN);
virQEMUCapsSet(priv->qemuCaps, QEMU_CAPS_DEVICE_IVSHMEM_DOORBELL);
if (event)
virQEMUCapsSet(priv->qemuCaps, QEMU_CAPS_DEVICE_DEL_EVENT);
if (qemuTestCapsCacheInsert(driver.qemuCapsCache, testname,
priv->qemuCaps) < 0)
goto cleanup;
if (!((*vm)->def = virDomainDefParseString(domxml,
driver.caps,
driver.xmlopt,
NULL,
VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto cleanup;
if (qemuDomainAssignAddresses((*vm)->def, priv->qemuCaps, *vm, true) < 0)
goto cleanup;
if (qemuAssignDeviceAliases((*vm)->def, priv->qemuCaps) < 0)
goto cleanup;
(*vm)->def->id = QEMU_HOTPLUG_TEST_DOMAIN_ID;
if (qemuDomainSetPrivatePaths(&driver, *vm) < 0)
goto cleanup;
ret = 0;
cleanup:
return ret;
}
static int
testQemuCaps(const void *opaque)
{
int ret = -1;
const testQemuData *data = opaque;
char *repliesFile = NULL;
char *capsFile = NULL;
qemuMonitorTestPtr mon = NULL;
virQEMUCapsPtr capsActual = NULL;
char *actual = NULL;
if (virAsprintf(&repliesFile, "%s/qemucapabilitiesdata/%s.%s.replies",
abs_srcdir, data->base, data->archName) < 0 ||
virAsprintf(&capsFile, "%s/qemucapabilitiesdata/%s.%s.xml",
abs_srcdir, data->base, data->archName) < 0)
goto cleanup;
if (!(mon = qemuMonitorTestNewFromFile(repliesFile, data->xmlopt, false)))
goto cleanup;
if (!(capsActual = virQEMUCapsNew()) ||
virQEMUCapsInitQMPMonitor(capsActual,
qemuMonitorTestGetMonitor(mon)) < 0)
goto cleanup;
if (virQEMUCapsGet(capsActual, QEMU_CAPS_KVM)) {
if (virQEMUCapsInitQMPMonitorTCG(capsActual,
qemuMonitorTestGetMonitor(mon)) < 0)
goto cleanup;
/* Fill microcodeVersion with a "random" value which is the file
* length to provide a reproducible number for testing.
*/
virQEMUCapsSetMicrocodeVersion(capsActual, virFileLength(repliesFile, -1));
}
if (!(actual = virQEMUCapsFormatCache(capsActual)))
goto cleanup;
if (virTestCompareToFile(actual, capsFile) < 0)
goto cleanup;
ret = 0;
cleanup:
VIR_FREE(repliesFile);
VIR_FREE(capsFile);
VIR_FREE(actual);
qemuMonitorTestFree(mon);
virObjectUnref(capsActual);
return ret;
}
static int
qemuHotplugCreateObjects(virDomainXMLOptionPtr xmlopt,
virDomainObjPtr *vm,
const char *domxml,
bool event, const char *testname)
{
int ret = -1;
qemuDomainObjPrivatePtr priv = NULL;
if (!(*vm = virDomainObjNew(xmlopt)))
goto cleanup;
priv = (*vm)->privateData;
if (!(priv->qemuCaps = virQEMUCapsNew()))
goto cleanup;
/* for attach & detach qemu must support -device */
virQEMUCapsSet(priv->qemuCaps, QEMU_CAPS_DRIVE);
virQEMUCapsSet(priv->qemuCaps, QEMU_CAPS_DEVICE);
virQEMUCapsSet(priv->qemuCaps, QEMU_CAPS_NET_NAME);
virQEMUCapsSet(priv->qemuCaps, QEMU_CAPS_VIRTIO_SCSI);
virQEMUCapsSet(priv->qemuCaps, QEMU_CAPS_DEVICE_USB_STORAGE);
if (event)
virQEMUCapsSet(priv->qemuCaps, QEMU_CAPS_DEVICE_DEL_EVENT);
ret = qemuTestCapsCacheInsert(driver.qemuCapsCache, testname,
priv->qemuCaps);
if (ret < 0)
goto cleanup;
if (!((*vm)->def = virDomainDefParseString(domxml,
driver.caps,
driver.xmlopt,
VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto cleanup;
if (qemuDomainAssignAddresses((*vm)->def, priv->qemuCaps, *vm) < 0)
goto cleanup;
if (qemuAssignDeviceAliases((*vm)->def, priv->qemuCaps) < 0)
goto cleanup;
(*vm)->def->id = QEMU_HOTPLUG_TEST_DOMAIN_ID;
ret = 0;
cleanup:
return ret;
}
static virQEMUCapsPtr
testQemuGetCaps(char *caps)
{
virQEMUCapsPtr qemuCaps = NULL;
xmlDocPtr xml;
xmlXPathContextPtr ctxt = NULL;
ssize_t i, n;
xmlNodePtr *nodes = NULL;
if (!(xml = virXMLParseStringCtxt(caps, "(test caps)", &ctxt)))
goto error;
if ((n = virXPathNodeSet("/qemuCaps/flag", ctxt, &nodes)) < 0) {
fprintf(stderr, "failed to parse qemu capabilities flags");
goto error;
}
if (n > 0) {
if (!(qemuCaps = virQEMUCapsNew()))
goto error;
for (i = 0; i < n; i++) {
char *str = virXMLPropString(nodes[i], "name");
if (str) {
int flag = virQEMUCapsTypeFromString(str);
if (flag < 0) {
fprintf(stderr, "Unknown qemu capabilities flag %s", str);
VIR_FREE(str);
goto error;
}
VIR_FREE(str);
virQEMUCapsSet(qemuCaps, flag);
}
}
}
VIR_FREE(nodes);
xmlFreeDoc(xml);
xmlXPathFreeContext(ctxt);
return qemuCaps;
error:
VIR_FREE(nodes);
virObjectUnref(qemuCaps);
xmlFreeDoc(xml);
xmlXPathFreeContext(ctxt);
return NULL;
}
static int
testQemuCaps(const void *opaque)
{
int ret = -1;
const testQemuDataPtr data = (const testQemuDataPtr) opaque;
char *repliesFile = NULL, *capsFile = NULL;
char *replies = NULL, *caps = NULL;
qemuMonitorTestPtr mon = NULL;
virQEMUCapsPtr capsProvided = NULL, capsComputed = NULL;
if (virAsprintf(&repliesFile, "%s/qemucapabilitiesdata/%s.replies",
abs_srcdir, data->base) < 0 ||
virAsprintf(&capsFile, "%s/qemucapabilitiesdata/%s.caps",
abs_srcdir, data->base) < 0)
goto cleanup;
if (virtTestLoadFile(repliesFile, &replies) < 0 ||
virtTestLoadFile(capsFile, &caps) < 0)
goto cleanup;
if (!(mon = testQemuFeedMonitor(replies, data->xmlopt)))
goto cleanup;
if (!(capsProvided = testQemuGetCaps(caps)))
goto cleanup;
if (!(capsComputed = virQEMUCapsNew()))
goto cleanup;
if (virQEMUCapsInitQMPMonitor(capsComputed,
qemuMonitorTestGetMonitor(mon)) < 0)
goto cleanup;
if (testQemuCapsCompare(capsProvided, capsComputed) < 0)
goto cleanup;
ret = 0;
cleanup:
VIR_FREE(repliesFile);
VIR_FREE(capsFile);
VIR_FREE(replies);
VIR_FREE(caps);
qemuMonitorTestFree(mon);
virObjectUnref(capsProvided);
virObjectUnref(capsComputed);
return ret;
}
static int
qemuHotplugCreateObjects(virDomainXMLOptionPtr xmlopt,
virDomainObjPtr *vm,
const char *domxml,
bool event)
{
int ret = -1;
qemuDomainObjPrivatePtr priv = NULL;
if (!(*vm = virDomainObjNew(xmlopt)))
goto cleanup;
if (!((*vm)->def = virDomainDefParseString(domxml,
driver.caps,
driver.xmlopt,
QEMU_EXPECTED_VIRT_TYPES,
0)))
goto cleanup;
priv = (*vm)->privateData;
if (!(priv->qemuCaps = virQEMUCapsNew()))
goto cleanup;
/* for attach & detach qemu must support -device */
virQEMUCapsSet(priv->qemuCaps, QEMU_CAPS_DRIVE);
virQEMUCapsSet(priv->qemuCaps, QEMU_CAPS_DEVICE);
virQEMUCapsSet(priv->qemuCaps, QEMU_CAPS_NET_NAME);
virQEMUCapsSet(priv->qemuCaps, QEMU_CAPS_VIRTIO_SCSI);
virQEMUCapsSet(priv->qemuCaps, QEMU_CAPS_DEVICE_USB_STORAGE);
if (event)
virQEMUCapsSet(priv->qemuCaps, QEMU_CAPS_DEVICE_DEL_EVENT);
if (qemuDomainAssignPCIAddresses((*vm)->def, priv->qemuCaps, *vm) < 0)
goto cleanup;
if (qemuAssignDeviceAliases((*vm)->def, priv->qemuCaps) < 0)
goto cleanup;
ret = 0;
cleanup:
return ret;
}
virQEMUCapsPtr
qemuTestParseCapabilities(virCapsPtr caps,
const char *capsFile)
{
virQEMUCapsPtr qemuCaps = NULL;
time_t selfctime;
unsigned long version;
if (!(qemuCaps = virQEMUCapsNew()) ||
virQEMUCapsLoadCache(caps, qemuCaps, capsFile,
&selfctime, &version) < 0)
goto error;
return qemuCaps;
error:
virObjectUnref(qemuCaps);
return NULL;
}
static int
testQemuCaps(const void *opaque)
{
int ret = -1;
const testQemuData *data = opaque;
char *repliesFile = NULL;
char *capsFile = NULL;
qemuMonitorTestPtr mon = NULL;
virQEMUCapsPtr capsActual = NULL;
char *actual = NULL;
if (virAsprintf(&repliesFile, "%s/qemucapabilitiesdata/%s.%s.replies",
abs_srcdir, data->base, data->archName) < 0 ||
virAsprintf(&capsFile, "%s/qemucapabilitiesdata/%s.%s.xml",
abs_srcdir, data->base, data->archName) < 0)
goto cleanup;
if (!(mon = qemuMonitorTestNewFromFile(repliesFile, data->xmlopt, false)))
goto cleanup;
if (!(capsActual = virQEMUCapsNew()) ||
virQEMUCapsInitQMPMonitor(capsActual,
qemuMonitorTestGetMonitor(mon)) < 0)
goto cleanup;
if (!(actual = virQEMUCapsFormatCache(capsActual, 0, 0)))
goto cleanup;
if (virTestCompareToFile(actual, capsFile) < 0)
goto cleanup;
ret = 0;
cleanup:
VIR_FREE(repliesFile);
VIR_FREE(capsFile);
VIR_FREE(actual);
qemuMonitorTestFree(mon);
virObjectUnref(capsActual);
return ret;
}
static int testHelpStrParsing(const void *data)
{
const struct testInfo *info = data;
char *path = NULL;
char *help = NULL;
unsigned int version, kvm_version;
bool is_kvm;
virQEMUCapsPtr flags = NULL;
int ret = -1;
char *got = NULL;
char *expected = NULL;
if (virAsprintf(&path, "%s/qemuhelpdata/%s", abs_srcdir, info->name) < 0)
return -1;
if (virTestLoadFile(path, &help) < 0)
goto cleanup;
if (!(flags = virQEMUCapsNew()))
goto cleanup;
if (virQEMUCapsParseHelpStr("QEMU", help, flags,
&version, &is_kvm, &kvm_version, false, NULL) == -1) {
if (info->error && virGetLastError()->code == info->error)
ret = 0;
goto cleanup;
}
# ifndef WITH_YAJL
if (virQEMUCapsGet(info->flags, QEMU_CAPS_MONITOR_JSON))
virQEMUCapsSet(flags, QEMU_CAPS_MONITOR_JSON);
# endif
VIR_FREE(path);
VIR_FREE(help);
if (virAsprintf(&path, "%s/qemuhelpdata/%s-device", abs_srcdir,
info->name) < 0)
goto cleanup;
if (virTestLoadFile(path, &help) < 0)
goto cleanup;
if (virQEMUCapsParseDeviceStr(flags, help) < 0)
goto cleanup;
got = virQEMUCapsFlagsString(flags);
expected = virQEMUCapsFlagsString(info->flags);
if (!got || !expected)
goto cleanup;
if (STRNEQ(got, expected)) {
VIR_TEST_DEBUG("%s: computed flags do not match: got %s, expected %s\n",
info->name, got, expected);
if (virTestGetDebug())
printMismatchedFlags(flags, info->flags);
goto cleanup;
}
if (version != info->version) {
fprintf(stderr, "%s: parsed versions do not match: got %u, expected %u\n",
info->name, version, info->version);
goto cleanup;
}
if (is_kvm != info->is_kvm) {
fprintf(stderr,
"%s: parsed is_kvm flag does not match: got %u, expected %u\n",
info->name, is_kvm, info->is_kvm);
goto cleanup;
}
if (kvm_version != info->kvm_version) {
fprintf(stderr,
"%s: parsed KVM versions do not match: got %u, expected %u\n",
info->name, kvm_version, info->kvm_version);
goto cleanup;
}
ret = 0;
cleanup:
VIR_FREE(path);
VIR_FREE(help);
virObjectUnref(flags);
VIR_FREE(got);
VIR_FREE(expected);
return ret;
}
