static int
testQemuAgentFSTrim(const void *data)
{
virDomainXMLOptionPtr xmlopt = (virDomainXMLOptionPtr)data;
qemuMonitorTestPtr test = qemuMonitorTestNewAgent(xmlopt);
int ret = -1;
if (!test)
return -1;
if (qemuMonitorTestAddAgentSyncResponse(test) < 0)
goto cleanup;
if (qemuMonitorTestAddItemParams(test, "guest-fstrim",
"{ \"return\" : {} }",
"minimum", "1337",
NULL) < 0)
goto cleanup;
if (qemuAgentFSTrim(qemuMonitorTestGetAgent(test), 1337) < 0)
goto cleanup;
ret = 0;
cleanup:
qemuMonitorTestFree(test);
return ret;
}
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
testQemuMonitorJSONGetTPMModels(const void *data)
{
const virDomainXMLOptionPtr xmlopt = (virDomainXMLOptionPtr)data;
qemuMonitorTestPtr test = qemuMonitorTestNew(true, xmlopt);
int ret = -1;
char **tpmmodels = NULL;
int ntpmmodels = 0;
if (!test)
return -1;
if (qemuMonitorTestAddItem(test, "query-tpm-models",
"{ "
" \"return\": [ "
" \"passthrough\""
" ]"
"}") < 0)
goto cleanup;
if ((ntpmmodels = qemuMonitorGetTPMModels(qemuMonitorTestGetMonitor(test),
&tpmmodels)) < 0)
goto cleanup;
if (ntpmmodels != 1) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"ntpmmodels %d is not 1", ntpmmodels);
goto cleanup;
}
#define CHECK(i, wantname) \
do { \
if (STRNEQ(tpmmodels[i], (wantname))) { \
virReportError(VIR_ERR_INTERNAL_ERROR, \
"name %s is not %s", \
tpmmodels[i], (wantname)); \
goto cleanup; \
} \
} while (0)
CHECK(0, "passthrough");
#undef CHECK
ret = 0;
cleanup:
qemuMonitorTestFree(test);
virStringFreeList(tpmmodels);
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 qemuMonitorTestPtr
testQemuFeedMonitor(char *replies,
virDomainXMLOptionPtr xmlopt)
{
qemuMonitorTestPtr test = NULL;
char *tmp = replies;
char *singleReply = tmp;
/* Our JSON parser expects replies to be separated by a newline character.
* Hence we must preprocess the file a bit. */
while ((tmp = strchr(tmp, '\n'))) {
/* It is safe to touch tmp[1] since all strings ends with '\0'. */
bool eof = !tmp[1];
if (*(tmp + 1) != '\n') {
*tmp = ' ';
tmp++;
} else {
/* Cut off a single reply. */
*(tmp + 1) = '\0';
if (test) {
if (qemuMonitorTestAddItem(test, NULL, singleReply) < 0)
goto error;
} else {
/* Create new mocked monitor with our greeting */
if (!(test = qemuMonitorTestNew(true, xmlopt, NULL, NULL, singleReply)))
goto error;
}
if (!eof) {
/* Move the @tmp and @singleReply. */
tmp += 2;
singleReply = tmp;
}
}
if (eof)
break;
}
if (test && qemuMonitorTestAddItem(test, NULL, singleReply) < 0)
goto error;
return test;
error:
qemuMonitorTestFree(test);
return NULL;
}
static int
testQemuAgentFSFreeze(const void *data)
{
virDomainXMLOptionPtr xmlopt = (virDomainXMLOptionPtr)data;
qemuMonitorTestPtr test = qemuMonitorTestNewAgent(xmlopt);
const char *mountpoints[] = {"/fs1", "/fs2", "/fs3", "/fs4", "/fs5"};
int ret = -1;
if (!test)
return -1;
if (qemuMonitorTestAddAgentSyncResponse(test) < 0)
goto cleanup;
if (qemuMonitorTestAddItem(test, "guest-fsfreeze-freeze-list",
"{ \"return\" : 5 }") < 0)
goto cleanup;
if (qemuMonitorTestAddAgentSyncResponse(test) < 0)
goto cleanup;
if (qemuMonitorTestAddItem(test, "guest-fsfreeze-freeze",
"{ \"return\" : 7 }") < 0)
goto cleanup;
if ((ret = qemuAgentFSFreeze(qemuMonitorTestGetAgent(test),
mountpoints, 5)) < 0)
goto cleanup;
if (ret != 5) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"expected 5 frozen filesystems, got %d", ret);
goto cleanup;
}
if ((ret = qemuAgentFSFreeze(qemuMonitorTestGetAgent(test), NULL, 0)) < 0)
goto cleanup;
if (ret != 7) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"expected 7 frozen filesystems, got %d", ret);
goto cleanup;
}
ret = 0;
cleanup:
qemuMonitorTestFree(test);
return ret;
}
static int
testQemuAgentFSThaw(const void *data)
{
virDomainXMLOptionPtr xmlopt = (virDomainXMLOptionPtr)data;
qemuMonitorTestPtr test = qemuMonitorTestNewAgent(xmlopt);
int ret = -1;
if (!test)
return -1;
if (qemuMonitorTestAddAgentSyncResponse(test) < 0)
goto cleanup;
if (qemuMonitorTestAddItem(test, "guest-fsfreeze-thaw",
"{ \"return\" : 5 }") < 0)
goto cleanup;
if (qemuMonitorTestAddAgentSyncResponse(test) < 0)
goto cleanup;
if (qemuMonitorTestAddItem(test, "guest-fsfreeze-thaw",
"{ \"return\" : 7 }") < 0)
goto cleanup;
if ((ret = qemuAgentFSThaw(qemuMonitorTestGetAgent(test))) < 0)
goto cleanup;
if (ret != 5) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"expected 5 thawed filesystems, got %d", ret);
goto cleanup;
}
if ((ret = qemuAgentFSThaw(qemuMonitorTestGetAgent(test))) < 0)
goto cleanup;
if (ret != 7) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"expected 7 thawed filesystems, got %d", ret);
goto cleanup;
}
ret = 0;
cleanup:
qemuMonitorTestFree(test);
return ret;
}
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
testQemuAgentSuspend(const void *data)
{
virDomainXMLOptionPtr xmlopt = (virDomainXMLOptionPtr)data;
qemuMonitorTestPtr test = qemuMonitorTestNewAgent(xmlopt);
int ret = -1;
size_t i;
if (!test)
return -1;
if (qemuMonitorTestAddAgentSyncResponse(test) < 0)
goto cleanup;
if (qemuMonitorTestAddItem(test, "guest-suspend-ram",
"{ \"return\" : {} }") < 0)
goto cleanup;
if (qemuMonitorTestAddAgentSyncResponse(test) < 0)
goto cleanup;
if (qemuMonitorTestAddItem(test, "guest-suspend-disk",
"{ \"return\" : {} }") < 0)
goto cleanup;
if (qemuMonitorTestAddAgentSyncResponse(test) < 0)
goto cleanup;
if (qemuMonitorTestAddItem(test, "guest-suspend-hybrid",
"{ \"return\" : {} }") < 0)
goto cleanup;
/* try the commands - fail if ordering changes */
for (i = 0; i < VIR_NODE_SUSPEND_TARGET_LAST; i++) {
if (qemuAgentSuspend(qemuMonitorTestGetAgent(test), i) < 0)
goto cleanup;
}
ret = 0;
cleanup:
qemuMonitorTestFree(test);
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 (!(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
testQemuAgentArbitraryCommand(const void *data)
{
virDomainXMLOptionPtr xmlopt = (virDomainXMLOptionPtr)data;
qemuMonitorTestPtr test = qemuMonitorTestNewAgent(xmlopt);
int ret = -1;
char *reply = NULL;
if (!test)
return -1;
if (qemuMonitorTestAddAgentSyncResponse(test) < 0)
goto cleanup;
if (qemuMonitorTestAddItem(test, "ble",
testQemuAgentArbitraryCommandResponse) < 0)
goto cleanup;
if (qemuAgentArbitraryCommand(qemuMonitorTestGetAgent(test),
"{\"execute\":\"ble\"}",
&reply,
VIR_DOMAIN_QEMU_AGENT_COMMAND_BLOCK) < 0)
goto cleanup;
if (STRNEQ(reply, testQemuAgentArbitraryCommandResponse)) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"invalid processing of guest agent reply: "
"got '%s' expected '%s'",
reply, testQemuAgentArbitraryCommandResponse);
goto cleanup;
}
ret = 0;
cleanup:
VIR_FREE(reply);
qemuMonitorTestFree(test);
return ret;
}
static int
testQemuMonitorJSONGetCPUDefinitions(const void *data)
{
virCapsPtr caps = (virCapsPtr)data;
qemuMonitorTestPtr test = qemuMonitorTestNew(true, caps);
int ret = -1;
char **cpus = NULL;
int ncpus = 0;
int i;
if (!test)
return -1;
if (qemuMonitorTestAddItem(test, "query-cpu-definitions",
"{ "
" \"return\": [ "
" { "
" \"name\": \"qemu64\" "
" }, "
" { "
" \"name\": \"Opteron_G4\" "
" }, "
" { "
" \"name\": \"Westmere\" "
" } "
" ]"
"}") < 0)
goto cleanup;
if ((ncpus = qemuMonitorGetCPUDefinitions(qemuMonitorTestGetMonitor(test),
&cpus)) < 0)
goto cleanup;
if (ncpus != 3) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"ncpus %d is not 3", ncpus);
goto cleanup;
}
#define CHECK(i, wantname) \
do { \
if (STRNEQ(cpus[i], (wantname))) { \
virReportError(VIR_ERR_INTERNAL_ERROR, \
"name %s is not %s", \
cpus[i], (wantname)); \
goto cleanup; \
} \
} while (0)
CHECK(0, "qemu64");
CHECK(1, "Opteron_G4");
CHECK(2, "Westmere");
#undef CHECK
ret = 0;
cleanup:
qemuMonitorTestFree(test);
for (i = 0; i < ncpus; i++)
VIR_FREE(cpus[i]);
VIR_FREE(cpus);
return ret;
}
static int
testQemuMonitorJSONGetStatus(const void *data)
{
virCapsPtr caps = (virCapsPtr)data;
qemuMonitorTestPtr test = qemuMonitorTestNew(true, caps);
int ret = -1;
bool running = false;
virDomainPausedReason reason = 0;
if (!test)
return -1;
if (qemuMonitorTestAddItem(test, "query-status",
"{ "
" \"return\": { "
" \"status\": \"running\", "
" \"singlestep\": false, "
" \"running\": true "
" } "
"}") < 0)
goto cleanup;
if (qemuMonitorTestAddItem(test, "query-status",
"{ "
" \"return\": { "
" \"singlestep\": false, "
" \"running\": false "
" } "
"}") < 0)
goto cleanup;
if (qemuMonitorTestAddItem(test, "query-status",
"{ "
" \"return\": { "
" \"status\": \"inmigrate\", "
" \"singlestep\": false, "
" \"running\": false "
" } "
"}") < 0)
goto cleanup;
if (qemuMonitorGetStatus(qemuMonitorTestGetMonitor(test),
&running, &reason) < 0)
goto cleanup;
if (!running) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
"Running was not true");
goto cleanup;
}
if (reason != VIR_DOMAIN_PAUSED_UNKNOWN) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"Reason was unexpectedly set to %d", reason);
goto cleanup;
}
if (qemuMonitorGetStatus(qemuMonitorTestGetMonitor(test),
&running, &reason) < 0)
goto cleanup;
if (running) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
"Running was not false");
goto cleanup;
}
if (reason != VIR_DOMAIN_PAUSED_UNKNOWN) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"Reason was unexpectedly set to %d", reason);
goto cleanup;
}
if (qemuMonitorGetStatus(qemuMonitorTestGetMonitor(test),
&running, &reason) < 0)
goto cleanup;
if (running) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
"Running was not false");
goto cleanup;
}
if (reason != VIR_DOMAIN_PAUSED_MIGRATION) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"Reason was unexpectedly set to %d", reason);
goto cleanup;
}
ret = 0;
cleanup:
qemuMonitorTestFree(test);
return ret;
}
static int
testQemuMonitorJSONGetMachines(const void *data)
{
virCapsPtr caps = (virCapsPtr)data;
qemuMonitorTestPtr test = qemuMonitorTestNew(true, caps);
int ret = -1;
qemuMonitorMachineInfoPtr *info;
int ninfo = 0;
const char *null = NULL;
int i;
if (!test)
return -1;
if (qemuMonitorTestAddItem(test, "query-machines",
"{ "
" \"return\": [ "
" { "
" \"name\": \"pc-1.0\" "
" }, "
" { "
" \"name\": \"pc-1.1\" "
" }, "
" { "
" \"name\": \"pc-1.2\", "
" \"is-default\": true, "
" \"alias\": \"pc\" "
" } "
" ]"
"}") < 0)
goto cleanup;
if ((ninfo = qemuMonitorGetMachines(qemuMonitorTestGetMonitor(test),
&info)) < 0)
goto cleanup;
if (ninfo != 3) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"ninfo %d is not 3", ninfo);
goto cleanup;
}
#define CHECK(i, wantname, wantisDefault, wantalias) \
do { \
if (STRNEQ(info[i]->name, (wantname))) { \
virReportError(VIR_ERR_INTERNAL_ERROR, \
"name %s is not %s", \
info[i]->name, (wantname)); \
goto cleanup; \
} \
if (info[i]->isDefault != (wantisDefault)) { \
virReportError(VIR_ERR_INTERNAL_ERROR, \
"isDefault %d is not %d", \
info[i]->isDefault, (wantisDefault)); \
goto cleanup; \
} \
if (STRNEQ_NULLABLE(info[i]->alias, (wantalias))) { \
virReportError(VIR_ERR_INTERNAL_ERROR, \
"alias %s is not %s", \
info[i]->alias, NULLSTR(wantalias)); \
goto cleanup; \
} \
} while (0)
CHECK(0, "pc-1.0", false, null);
CHECK(1, "pc-1.1", false, null);
CHECK(2, "pc-1.2", true, "pc");
#undef CHECK
ret = 0;
cleanup:
qemuMonitorTestFree(test);
for (i = 0; i < ninfo; i++)
qemuMonitorMachineInfoFree(info[i]);
VIR_FREE(info);
return ret;
}
static int
testQemuMonitorJSONGetVersion(const void *data)
{
virCapsPtr caps = (virCapsPtr)data;
qemuMonitorTestPtr test = qemuMonitorTestNew(true, caps);
int ret = -1;
int major;
int minor;
int micro;
char *package = NULL;
if (!test)
return -1;
if (qemuMonitorTestAddItem(test, "query-version",
"{ "
" \"return\":{ "
" \"qemu\":{ "
" \"major\":1, "
" \"minor\":2, "
" \"micro\":3 "
" },"
" \"package\":\"\""
" }"
"}") < 0)
goto cleanup;
if (qemuMonitorTestAddItem(test, "query-version",
"{ "
" \"return\":{ "
" \"qemu\":{ "
" \"major\":0, "
" \"minor\":11, "
" \"micro\":6 "
" },"
" \"package\":\"2.283.el6\""
" }"
"}") < 0)
goto cleanup;
if (qemuMonitorGetVersion(qemuMonitorTestGetMonitor(test),
&major, &minor, µ,
&package) < 0)
goto cleanup;
if (major != 1) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"Major %d was not 1", major);
goto cleanup;
}
if (minor != 2) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"Minor %d was not 2", major);
goto cleanup;
}
if (micro != 3) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"Micro %d was not 3", major);
goto cleanup;
}
if (STRNEQ(package, "")) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"Package %s was not ''", package);
goto cleanup;
}
VIR_FREE(package);
if (qemuMonitorGetVersion(qemuMonitorTestGetMonitor(test),
&major, &minor, µ,
&package) < 0)
goto cleanup;
if (major != 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"Major %d was not 0", major);
goto cleanup;
}
if (minor != 11) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"Minor %d was not 11", major);
goto cleanup;
}
if (micro != 6) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"Micro %d was not 6", major);
goto cleanup;
}
if (STRNEQ(package, "2.283.el6")) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"Package %s was not '2.283.el6'", package);
goto cleanup;
}
ret = 0;
cleanup:
qemuMonitorTestFree(test);
VIR_FREE(package);
return ret;
}
static int
testQemuMonitorJSONGetCommandLineOptionParameters(const void *data)
{
const virDomainXMLOptionPtr xmlopt = (virDomainXMLOptionPtr)data;
qemuMonitorTestPtr test = qemuMonitorTestNew(true, xmlopt);
int ret = -1;
char **params = NULL;
int nparams = 0;
if (!test)
return -1;
if (qemuMonitorTestAddItem(test, "query-command-line-options",
"{ "
" \"return\": [ "
" {\"parameters\": [], \"option\": \"acpi\" },"
" {\"parameters\": ["
" {\"name\": \"romfile\", "
" \"type\": \"string\"}, "
" {\"name\": \"bootindex\", "
" \"type\": \"number\"}], "
" \"option\": \"option-rom\"}"
" ]"
"}") < 0)
goto cleanup;
/* present with params */
if ((nparams = qemuMonitorGetCommandLineOptionParameters(qemuMonitorTestGetMonitor(test),
"option-rom",
¶ms)) < 0)
goto cleanup;
if (nparams != 2) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"nparams was %d, expected 2", nparams);
goto cleanup;
}
#define CHECK(i, wantname) \
do { \
if (STRNEQ(params[i], (wantname))) { \
virReportError(VIR_ERR_INTERNAL_ERROR, \
"name was %s, expected %s", \
params[i], (wantname)); \
goto cleanup; \
} \
} while (0)
CHECK(0, "romfile");
CHECK(1, "bootindex");
#undef CHECK
virStringFreeList(params);
params = NULL;
/* present but empty */
if ((nparams = qemuMonitorGetCommandLineOptionParameters(qemuMonitorTestGetMonitor(test),
"acpi",
¶ms)) < 0)
goto cleanup;
if (nparams != 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"nparams was %d, expected 0", nparams);
goto cleanup;
}
if (params && params[0]) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
"unexpected array contents");
goto cleanup;
}
virStringFreeList(params);
params = NULL;
/* no such option */
if ((nparams = qemuMonitorGetCommandLineOptionParameters(qemuMonitorTestGetMonitor(test),
"foobar",
¶ms)) < 0)
goto cleanup;
if (nparams != 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"nparams was %d, expected 0", nparams);
goto cleanup;
}
if (params && params[0]) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
"unexpected array contents");
goto cleanup;
}
ret = 0;
cleanup:
qemuMonitorTestFree(test);
virStringFreeList(params);
return ret;
}
qemuMonitorTestPtr qemuMonitorTestNew(bool json, virCapsPtr caps)
{
qemuMonitorTestPtr test = NULL;
virDomainChrSourceDef src;
char *path = NULL;
char *tmpdir_template = NULL;
if (VIR_ALLOC(test) < 0)
goto no_memory;
if (virMutexInit(&test->lock) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
"Cannot initialize mutex");
VIR_FREE(test);
return NULL;
}
if (!(tmpdir_template = strdup("/tmp/libvirt_XXXXXX")))
goto no_memory;
if (!(test->tmpdir = mkdtemp(tmpdir_template))) {
virReportSystemError(errno, "%s",
"Failed to create temporary directory");
goto error;
}
tmpdir_template = NULL;
if (virAsprintf(&path, "%s/qemumonitorjsontest.sock", test->tmpdir) < 0)
goto no_memory;
test->json = json;
if (!(test->vm = virDomainObjNew(caps)))
goto error;
if (virNetSocketNewListenUNIX(path,
0700,
getuid(),
getgid(),
&test->server) < 0)
goto error;
memset(&src, 0, sizeof(src));
src.type = VIR_DOMAIN_CHR_TYPE_UNIX;
src.data.nix.path = (char *)path;
src.data.nix.listen = false;
if (virNetSocketListen(test->server, 1) < 0)
goto error;
if (!(test->mon = qemuMonitorOpen(test->vm,
&src,
json ? 1 : 0,
&qemuCallbacks)))
goto error;
qemuMonitorLock(test->mon);
if (virNetSocketAccept(test->server, &test->client) < 0)
goto error;
if (!test->client)
goto error;
if (qemuMonitorTestAddReponse(test, json ?
QEMU_JSON_GREETING :
QEMU_TEXT_GREETING) < 0)
goto error;
if (virNetSocketAddIOCallback(test->client,
VIR_EVENT_HANDLE_WRITABLE,
qemuMonitorTestIO,
test,
NULL) < 0)
goto error;
virMutexLock(&test->lock);
if (virThreadCreate(&test->thread,
true,
qemuMonitorTestWorker,
test) < 0) {
virMutexUnlock(&test->lock);
goto error;
}
test->running = true;
virMutexUnlock(&test->lock);
cleanup:
VIR_FREE(path);
return test;
no_memory:
virReportOOMError();
error:
VIR_FREE(tmpdir_template);
qemuMonitorTestFree(test);
goto cleanup;
}
static int
testQemuMonitorJSONGetCommands(const void *data)
{
virCapsPtr caps = (virCapsPtr)data;
qemuMonitorTestPtr test = qemuMonitorTestNew(true, caps);
int ret = -1;
char **commands = NULL;
int ncommands = 0;
int i;
if (!test)
return -1;
if (qemuMonitorTestAddItem(test, "query-commands",
"{ "
" \"return\": [ "
" { "
" \"name\": \"system_wakeup\" "
" }, "
" { "
" \"name\": \"cont\" "
" }, "
" { "
" \"name\": \"quit\" "
" } "
" ]"
"}") < 0)
goto cleanup;
if ((ncommands = qemuMonitorGetCommands(qemuMonitorTestGetMonitor(test),
&commands)) < 0)
goto cleanup;
if (ncommands != 3) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"ncommands %d is not 3", ncommands);
goto cleanup;
}
#define CHECK(i, wantname) \
do { \
if (STRNEQ(commands[i], (wantname))) { \
virReportError(VIR_ERR_INTERNAL_ERROR, \
"name %s is not %s", \
commands[i], (wantname)); \
goto cleanup; \
} \
} while (0)
CHECK(0, "system_wakeup");
CHECK(1, "cont");
CHECK(2, "quit");
#undef CHECK
ret = 0;
cleanup:
qemuMonitorTestFree(test);
for (i = 0; i < ncommands; i++)
VIR_FREE(commands[i]);
VIR_FREE(commands);
return ret;
}
static int
testQemuAgentShutdown(const void *data)
{
virDomainXMLOptionPtr xmlopt = (virDomainXMLOptionPtr)data;
qemuMonitorTestPtr test = qemuMonitorTestNewAgent(xmlopt);
struct qemuAgentShutdownTestData priv;
int ret = -1;
if (!test)
return -1;
if (qemuMonitorTestAddAgentSyncResponse(test) < 0)
goto cleanup;
priv.event = QEMU_AGENT_EVENT_SHUTDOWN;
priv.mode = "halt";
if (qemuMonitorTestAddHandler(test, qemuAgentShutdownTestMonitorHandler,
&priv, NULL) < 0)
goto cleanup;
if (qemuAgentShutdown(qemuMonitorTestGetAgent(test),
QEMU_AGENT_SHUTDOWN_HALT) < 0)
goto cleanup;
if (qemuMonitorTestAddAgentSyncResponse(test) < 0)
goto cleanup;
priv.event = QEMU_AGENT_EVENT_SHUTDOWN;
priv.mode = "powerdown";
if (qemuMonitorTestAddHandler(test, qemuAgentShutdownTestMonitorHandler,
&priv, NULL) < 0)
goto cleanup;
if (qemuAgentShutdown(qemuMonitorTestGetAgent(test),
QEMU_AGENT_SHUTDOWN_POWERDOWN) < 0)
goto cleanup;
if (qemuMonitorTestAddAgentSyncResponse(test) < 0)
goto cleanup;
priv.event = QEMU_AGENT_EVENT_RESET;
priv.mode = "reboot";
if (qemuMonitorTestAddHandler(test, qemuAgentShutdownTestMonitorHandler,
&priv, NULL) < 0)
goto cleanup;
if (qemuAgentShutdown(qemuMonitorTestGetAgent(test),
QEMU_AGENT_SHUTDOWN_REBOOT) < 0)
goto cleanup;
/* check negative response, so that we can verify that the agent breaks
* out from sleep */
if (qemuMonitorTestAddAgentSyncResponse(test) < 0)
goto cleanup;
if (qemuMonitorTestAddItem(test, "guest-shutdown",
"{\"error\":"
" {\"class\":\"CommandDisabled\","
" \"desc\":\"The command guest-shutdown has "
"been disabled for this instance\","
" \"data\":{\"name\":\"guest-shutdown\"}"
" }"
"}") < 0)
goto cleanup;
if (qemuAgentShutdown(qemuMonitorTestGetAgent(test),
QEMU_AGENT_SHUTDOWN_REBOOT) != -1) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
"agent shutdown command should have failed");
goto cleanup;
}
ret = 0;
cleanup:
qemuMonitorTestFree(test);
return ret;
}
static int
testQemuAgentCPU(const void *data)
{
virDomainXMLOptionPtr xmlopt = (virDomainXMLOptionPtr)data;
qemuMonitorTestPtr test = qemuMonitorTestNewAgent(xmlopt);
qemuAgentCPUInfoPtr cpuinfo = NULL;
int nvcpus;
int ret = -1;
if (!test)
return -1;
if (qemuMonitorTestAddAgentSyncResponse(test) < 0)
goto cleanup;
if (qemuMonitorTestAddItem(test, "guest-get-vcpus",
testQemuAgentCPUResponse) < 0)
goto cleanup;
/* get cpus */
if ((nvcpus = qemuAgentGetVCPUs(qemuMonitorTestGetAgent(test),
&cpuinfo)) < 0)
goto cleanup;
if (nvcpus != 4) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"Expected '4' cpus, got '%d'", nvcpus);
goto cleanup;
}
/* try to unplug one */
if (qemuAgentUpdateCPUInfo(2, cpuinfo, nvcpus) < 0)
goto cleanup;
if (qemuMonitorTestAddAgentSyncResponse(test) < 0)
goto cleanup;
if (qemuMonitorTestAddItemParams(test, "guest-set-vcpus",
"{ \"return\" : 4 }",
"vcpus", testQemuAgentCPUArguments1,
NULL) < 0)
goto cleanup;
if ((nvcpus = qemuAgentSetVCPUs(qemuMonitorTestGetAgent(test),
cpuinfo, nvcpus)) < 0)
goto cleanup;
if (nvcpus != 4) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"Expected '4' cpus updated , got '%d'", nvcpus);
goto cleanup;
}
/* try to hotplug two */
if (qemuMonitorTestAddAgentSyncResponse(test) < 0)
goto cleanup;
if (qemuMonitorTestAddItemParams(test, "guest-set-vcpus",
"{ \"return\" : 4 }",
"vcpus", testQemuAgentCPUArguments2,
NULL) < 0)
goto cleanup;
if (qemuAgentUpdateCPUInfo(4, cpuinfo, nvcpus) < 0)
goto cleanup;
if ((nvcpus = qemuAgentSetVCPUs(qemuMonitorTestGetAgent(test),
cpuinfo, nvcpus)) < 0)
goto cleanup;
if (nvcpus != 4) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"Expected '4' cpus updated , got '%d'", nvcpus);
goto cleanup;
}
ret = 0;
cleanup:
VIR_FREE(cpuinfo);
qemuMonitorTestFree(test);
return ret;
}
static int
testQemuHotplug(const void *data)
{
int ret = -1;
struct qemuHotplugTestData *test = (struct qemuHotplugTestData *) data;
char *domain_filename = NULL;
char *device_filename = NULL;
char *result_filename = NULL;
char *domain_xml = NULL;
char *device_xml = NULL;
char *result_xml = NULL;
const char *const *tmp;
bool fail = test->fail;
bool keep = test->keep;
unsigned int device_parse_flags = 0;
virDomainObjPtr vm = NULL;
virDomainDeviceDefPtr dev = NULL;
virCapsPtr caps = NULL;
qemuMonitorTestPtr test_mon = NULL;
qemuDomainObjPrivatePtr priv = NULL;
if (virAsprintf(&domain_filename, "%s/qemuxml2argvdata/qemuxml2argv-%s.xml",
abs_srcdir, test->domain_filename) < 0 ||
virAsprintf(&device_filename, "%s/qemuhotplugtestdata/qemuhotplug-%s.xml",
abs_srcdir, test->device_filename) < 0 ||
virAsprintf(&result_filename,
"%s/qemuhotplugtestdata/qemuhotplug-%s+%s.xml",
abs_srcdir, test->domain_filename,
test->device_filename) < 0)
goto cleanup;
if (virtTestLoadFile(domain_filename, &domain_xml) < 0 ||
virtTestLoadFile(device_filename, &device_xml) < 0)
goto cleanup;
if (test->action != UPDATE &&
virtTestLoadFile(result_filename, &result_xml) < 0)
goto cleanup;
if (!(caps = virQEMUDriverGetCapabilities(&driver, false)))
goto cleanup;
if (test->vm) {
vm = test->vm;
} else {
if (qemuHotplugCreateObjects(driver.xmlopt, &vm, domain_xml,
test->deviceDeletedEvent,
test->domain_filename) < 0)
goto cleanup;
}
if (test->action == ATTACH)
device_parse_flags = VIR_DOMAIN_DEF_PARSE_INACTIVE;
if (!(dev = virDomainDeviceDefParse(device_xml, vm->def,
caps, driver.xmlopt,
device_parse_flags)))
goto cleanup;
/* Now is the best time to feed the spoofed monitor with predefined
* replies. */
if (!(test_mon = qemuMonitorTestNew(true, driver.xmlopt, vm, &driver, NULL)))
goto cleanup;
tmp = test->mon;
while (tmp && *tmp) {
const char *command_name;
const char *response;
if (!(command_name = *tmp++) ||
!(response = *tmp++))
break;
if (qemuMonitorTestAddItem(test_mon, command_name, response) < 0)
goto cleanup;
}
priv = vm->privateData;
priv->mon = qemuMonitorTestGetMonitor(test_mon);
priv->monJSON = true;
/* XXX We need to unlock the monitor here, as
* qemuDomainObjEnterMonitorInternal (called from qemuDomainChangeGraphics)
* tries to lock it again */
virObjectUnlock(priv->mon);
switch (test->action) {
case ATTACH:
ret = testQemuHotplugAttach(vm, dev);
if (ret == 0) {
/* vm->def stolen dev->data.* so we just need to free the dev
* envelope */
VIR_FREE(dev);
}
if (ret == 0 || fail)
ret = testQemuHotplugCheckResult(vm, result_xml,
result_filename, fail);
break;
case DETACH:
ret = testQemuHotplugDetach(vm, dev);
if (ret == 0 || fail)
ret = testQemuHotplugCheckResult(vm, domain_xml,
domain_filename, fail);
break;
case UPDATE:
ret = testQemuHotplugUpdate(vm, dev);
}
cleanup:
VIR_FREE(domain_filename);
VIR_FREE(device_filename);
VIR_FREE(result_filename);
VIR_FREE(domain_xml);
VIR_FREE(device_xml);
VIR_FREE(result_xml);
/* don't dispose test monitor with VM */
if (priv)
priv->mon = NULL;
if (keep) {
test->vm = vm;
} else {
virObjectUnref(vm);
test->vm = NULL;
}
virDomainDeviceDefFree(dev);
virObjectUnref(caps);
qemuMonitorTestFree(test_mon);
return ((ret < 0 && fail) || (!ret && !fail)) ? 0 : -1;
}
static int
testQemuAgentGetFSInfo(const void *data)
{
virDomainXMLOptionPtr xmlopt = (virDomainXMLOptionPtr)data;
qemuMonitorTestPtr test = qemuMonitorTestNewAgent(xmlopt);
char *domain_filename = NULL;
virDomainDefPtr def = NULL;
virDomainFSInfoPtr *info = NULL;
int ret = -1, ninfo = 0, i;
if (!test)
return -1;
if (virAsprintf(&domain_filename, "%s/qemuagentdata/fsinfo.xml",
abs_srcdir) < 0)
goto cleanup;
if (!(def = virDomainDefParseFile(domain_filename, driver.caps, xmlopt,
NULL, VIR_DOMAIN_DEF_PARSE_INACTIVE)))
goto cleanup;
if (qemuMonitorTestAddAgentSyncResponse(test) < 0)
goto cleanup;
if (qemuMonitorTestAddItem(test, "guest-get-fsinfo",
"{\"return\": ["
" {\"name\": \"sda1\", \"mountpoint\": \"/\","
" \"disk\": ["
" {\"bus-type\": \"ide\","
" \"bus\": 1, \"unit\": 0,"
" \"pci-controller\": {"
" \"bus\": 0, \"slot\": 1,"
" \"domain\": 0, \"function\": 1},"
" \"target\": 0}],"
" \"type\": \"ext4\"},"
" {\"name\": \"dm-1\","
" \"mountpoint\": \"/opt\","
" \"disk\": ["
" {\"bus-type\": \"virtio\","
" \"bus\": 0, \"unit\": 0,"
" \"pci-controller\": {"
" \"bus\": 0, \"slot\": 6,"
" \"domain\": 0, \"function\": 0},"
" \"target\": 0},"
" {\"bus-type\": \"virtio\","
" \"bus\": 0, \"unit\": 0,"
" \"pci-controller\": {"
" \"bus\": 0, \"slot\": 7,"
" \"domain\": 0, \"function\": 0},"
" \"target\": 0}],"
" \"type\": \"vfat\"},"
" {\"name\": \"sdb1\","
" \"mountpoint\": \"/mnt/disk\","
" \"disk\": [], \"type\": \"xfs\"}]}") < 0)
goto cleanup;
if ((ninfo = qemuAgentGetFSInfo(qemuMonitorTestGetAgent(test),
&info, def)) < 0)
goto cleanup;
if (ninfo != 3) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"expected 3 filesystems information, got %d", ninfo);
ret = -1;
goto cleanup;
}
if (STRNEQ(info[2]->name, "sda1") ||
STRNEQ(info[2]->mountpoint, "/") ||
STRNEQ(info[2]->fstype, "ext4") ||
info[2]->ndevAlias != 1 ||
!info[2]->devAlias || !info[2]->devAlias[0] ||
STRNEQ(info[2]->devAlias[0], "hdc")) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"unexpected filesystems information returned for sda1 (%s,%s)",
info[2]->name, info[2]->devAlias ? info[2]->devAlias[0] : "null");
ret = -1;
goto cleanup;
}
if (STRNEQ(info[1]->name, "dm-1") ||
STRNEQ(info[1]->mountpoint, "/opt") ||
STRNEQ(info[1]->fstype, "vfat") ||
info[1]->ndevAlias != 2 ||
!info[1]->devAlias || !info[1]->devAlias[0] || !info[1]->devAlias[1] ||
STRNEQ(info[1]->devAlias[0], "vda") ||
STRNEQ(info[1]->devAlias[1], "vdb")) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"unexpected filesystems information returned for dm-1 (%s,%s)",
info[0]->name, info[0]->devAlias ? info[0]->devAlias[0] : "null");
ret = -1;
goto cleanup;
}
if (STRNEQ(info[0]->name, "sdb1") ||
STRNEQ(info[0]->mountpoint, "/mnt/disk") ||
STRNEQ(info[0]->fstype, "xfs") ||
info[0]->ndevAlias != 0 || info[0]->devAlias) {
virReportError(VIR_ERR_INTERNAL_ERROR,
"unexpected filesystems information returned for sdb1 (%s,%s)",
info[0]->name, info[0]->devAlias ? info[0]->devAlias[0] : "null");
ret = -1;
goto cleanup;
}
if (qemuMonitorTestAddAgentSyncResponse(test) < 0)
goto cleanup;
if (qemuMonitorTestAddItem(test, "guest-get-fsinfo",
"{\"error\":"
" {\"class\":\"CommandDisabled\","
" \"desc\":\"The command guest-get-fsinfo "
"has been disabled for "
"this instance\","
" \"data\":{\"name\":\"guest-get-fsinfo\"}"
" }"
"}") < 0)
goto cleanup;
if (qemuAgentGetFSInfo(qemuMonitorTestGetAgent(test), &info, def) != -1) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
"agent get-fsinfo command should have failed");
goto cleanup;
}
ret = 0;
cleanup:
for (i = 0; i < ninfo; i++)
virDomainFSInfoFree(info[i]);
VIR_FREE(info);
VIR_FREE(domain_filename);
virDomainDefFree(def);
qemuMonitorTestFree(test);
return ret;
}
