2016-02-08 19:08:51 +01:00
|
|
|
#include "qemu/osdep.h"
|
2015-01-19 21:15:51 +01:00
|
|
|
#include <sys/wait.h>
|
|
|
|
|
|
|
|
#include "libqtest.h"
|
|
|
|
#include "libqos/libqos.h"
|
|
|
|
#include "libqos/pci.h"
|
2018-02-01 12:18:39 +01:00
|
|
|
#include "qapi/qmp/qdict.h"
|
2015-01-19 21:15:51 +01:00
|
|
|
|
|
|
|
/*** Test Setup & Teardown ***/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Launch QEMU with the given command line,
|
|
|
|
* and then set up interrupts and our guest malloc interface.
|
2016-10-17 12:30:20 +02:00
|
|
|
* Never returns NULL:
|
|
|
|
* Terminates the application in case an error is encountered.
|
2015-01-19 21:15:51 +01:00
|
|
|
*/
|
2015-01-19 21:15:55 +01:00
|
|
|
QOSState *qtest_vboot(QOSOps *ops, const char *cmdline_fmt, va_list ap)
|
2015-01-19 21:15:51 +01:00
|
|
|
{
|
|
|
|
char *cmdline;
|
|
|
|
|
2017-09-11 19:19:52 +02:00
|
|
|
QOSState *qs = g_new0(QOSState, 1);
|
2015-01-19 21:15:51 +01:00
|
|
|
|
2015-01-19 21:15:52 +01:00
|
|
|
cmdline = g_strdup_vprintf(cmdline_fmt, ap);
|
2017-09-11 19:20:01 +02:00
|
|
|
qs->qts = qtest_init(cmdline);
|
2015-01-19 21:15:55 +01:00
|
|
|
qs->ops = ops;
|
2016-09-29 12:32:45 +02:00
|
|
|
if (ops) {
|
2018-11-29 12:37:04 +01:00
|
|
|
ops->alloc_init(&qs->alloc, qs->qts, ALLOC_NO_FLAGS);
|
|
|
|
qs->pcibus = ops->qpci_new(qs->qts, &qs->alloc);
|
2015-01-19 21:15:55 +01:00
|
|
|
}
|
2015-01-19 21:15:51 +01:00
|
|
|
|
|
|
|
g_free(cmdline);
|
|
|
|
return qs;
|
|
|
|
}
|
|
|
|
|
2015-01-19 21:15:52 +01:00
|
|
|
/**
|
|
|
|
* Launch QEMU with the given command line,
|
|
|
|
* and then set up interrupts and our guest malloc interface.
|
|
|
|
*/
|
2015-01-19 21:15:55 +01:00
|
|
|
QOSState *qtest_boot(QOSOps *ops, const char *cmdline_fmt, ...)
|
2015-01-19 21:15:52 +01:00
|
|
|
{
|
|
|
|
QOSState *qs;
|
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
va_start(ap, cmdline_fmt);
|
2015-01-19 21:15:55 +01:00
|
|
|
qs = qtest_vboot(ops, cmdline_fmt, ap);
|
2015-01-19 21:15:52 +01:00
|
|
|
va_end(ap);
|
|
|
|
|
|
|
|
return qs;
|
|
|
|
}
|
|
|
|
|
2015-01-19 21:15:51 +01:00
|
|
|
/**
|
|
|
|
* Tear down the QEMU instance.
|
|
|
|
*/
|
2016-09-29 12:32:46 +02:00
|
|
|
void qtest_common_shutdown(QOSState *qs)
|
2015-01-19 21:15:51 +01:00
|
|
|
{
|
2016-09-29 12:32:45 +02:00
|
|
|
if (qs->ops) {
|
|
|
|
if (qs->pcibus && qs->ops->qpci_free) {
|
|
|
|
qs->ops->qpci_free(qs->pcibus);
|
|
|
|
qs->pcibus = NULL;
|
|
|
|
}
|
2015-01-19 21:15:51 +01:00
|
|
|
}
|
2018-11-29 12:37:04 +01:00
|
|
|
alloc_destroy(&qs->alloc);
|
2015-01-19 21:15:51 +01:00
|
|
|
qtest_quit(qs->qts);
|
|
|
|
g_free(qs);
|
|
|
|
}
|
2015-04-28 21:27:51 +02:00
|
|
|
|
2016-09-29 12:32:46 +02:00
|
|
|
void qtest_shutdown(QOSState *qs)
|
|
|
|
{
|
|
|
|
if (qs->ops && qs->ops->shutdown) {
|
|
|
|
qs->ops->shutdown(qs);
|
|
|
|
} else {
|
|
|
|
qtest_common_shutdown(qs);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-05-22 20:13:43 +02:00
|
|
|
void set_context(QOSState *s)
|
|
|
|
{
|
|
|
|
global_qtest = s->qts;
|
|
|
|
}
|
|
|
|
|
2017-09-11 19:20:01 +02:00
|
|
|
static QDict *qmp_execute(QTestState *qts, const char *command)
|
2015-05-22 20:13:43 +02:00
|
|
|
{
|
2017-09-11 19:20:01 +02:00
|
|
|
return qtest_qmp(qts, "{ 'execute': %s }", command);
|
2015-05-22 20:13:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void migrate(QOSState *from, QOSState *to, const char *uri)
|
|
|
|
{
|
|
|
|
const char *st;
|
|
|
|
QDict *rsp, *sub;
|
|
|
|
bool running;
|
|
|
|
|
|
|
|
set_context(from);
|
|
|
|
|
|
|
|
/* Is the machine currently running? */
|
2017-09-11 19:20:01 +02:00
|
|
|
rsp = qmp_execute(from->qts, "query-status");
|
2015-05-22 20:13:43 +02:00
|
|
|
g_assert(qdict_haskey(rsp, "return"));
|
|
|
|
sub = qdict_get_qdict(rsp, "return");
|
|
|
|
g_assert(qdict_haskey(sub, "running"));
|
|
|
|
running = qdict_get_bool(sub, "running");
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(rsp);
|
2015-05-22 20:13:43 +02:00
|
|
|
|
|
|
|
/* Issue the migrate command. */
|
2017-09-11 19:20:01 +02:00
|
|
|
rsp = qtest_qmp(from->qts,
|
|
|
|
"{ 'execute': 'migrate', 'arguments': { 'uri': %s }}",
|
|
|
|
uri);
|
2015-05-22 20:13:43 +02:00
|
|
|
g_assert(qdict_haskey(rsp, "return"));
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(rsp);
|
2015-05-22 20:13:43 +02:00
|
|
|
|
|
|
|
/* Wait for STOP event, but only if we were running: */
|
|
|
|
if (running) {
|
2017-09-11 19:20:01 +02:00
|
|
|
qtest_qmp_eventwait(from->qts, "STOP");
|
2015-05-22 20:13:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* If we were running, we can wait for an event. */
|
|
|
|
if (running) {
|
2018-11-29 12:37:04 +01:00
|
|
|
migrate_allocator(&from->alloc, &to->alloc);
|
2015-05-22 20:13:43 +02:00
|
|
|
set_context(to);
|
2017-09-11 19:20:01 +02:00
|
|
|
qtest_qmp_eventwait(to->qts, "RESUME");
|
2015-05-22 20:13:43 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Otherwise, we need to wait: poll until migration is completed. */
|
|
|
|
while (1) {
|
2017-09-11 19:20:01 +02:00
|
|
|
rsp = qmp_execute(from->qts, "query-migrate");
|
2015-05-22 20:13:43 +02:00
|
|
|
g_assert(qdict_haskey(rsp, "return"));
|
|
|
|
sub = qdict_get_qdict(rsp, "return");
|
|
|
|
g_assert(qdict_haskey(sub, "status"));
|
|
|
|
st = qdict_get_str(sub, "status");
|
|
|
|
|
|
|
|
/* "setup", "active", "completed", "failed", "cancelled" */
|
|
|
|
if (strcmp(st, "completed") == 0) {
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(rsp);
|
2015-05-22 20:13:43 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((strcmp(st, "setup") == 0) || (strcmp(st, "active") == 0)) {
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(rsp);
|
2015-05-22 20:13:43 +02:00
|
|
|
g_usleep(5000);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
fprintf(stderr, "Migration did not complete, status: %s\n", st);
|
|
|
|
g_assert_not_reached();
|
|
|
|
}
|
|
|
|
|
2018-11-29 12:37:04 +01:00
|
|
|
migrate_allocator(&from->alloc, &to->alloc);
|
2015-05-22 20:13:43 +02:00
|
|
|
set_context(to);
|
|
|
|
}
|
|
|
|
|
2015-11-13 20:31:42 +01:00
|
|
|
bool have_qemu_img(void)
|
|
|
|
{
|
|
|
|
char *rpath;
|
|
|
|
const char *path = getenv("QTEST_QEMU_IMG");
|
|
|
|
if (!path) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
rpath = realpath(path, NULL);
|
|
|
|
if (!rpath) {
|
|
|
|
return false;
|
|
|
|
} else {
|
|
|
|
free(rpath);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-28 21:27:51 +02:00
|
|
|
void mkimg(const char *file, const char *fmt, unsigned size_mb)
|
|
|
|
{
|
|
|
|
gchar *cli;
|
|
|
|
bool ret;
|
|
|
|
int rc;
|
|
|
|
GError *err = NULL;
|
|
|
|
char *qemu_img_path;
|
|
|
|
gchar *out, *out2;
|
2015-11-13 20:31:42 +01:00
|
|
|
char *qemu_img_abs_path;
|
2015-04-28 21:27:51 +02:00
|
|
|
|
|
|
|
qemu_img_path = getenv("QTEST_QEMU_IMG");
|
2015-11-13 20:31:42 +01:00
|
|
|
g_assert(qemu_img_path);
|
|
|
|
qemu_img_abs_path = realpath(qemu_img_path, NULL);
|
|
|
|
g_assert(qemu_img_abs_path);
|
2015-04-28 21:27:51 +02:00
|
|
|
|
2015-11-13 20:31:42 +01:00
|
|
|
cli = g_strdup_printf("%s create -f %s %s %uM", qemu_img_abs_path,
|
2015-04-28 21:27:51 +02:00
|
|
|
fmt, file, size_mb);
|
|
|
|
ret = g_spawn_command_line_sync(cli, &out, &out2, &rc, &err);
|
2018-08-21 21:05:16 +02:00
|
|
|
if (err || !g_spawn_check_exit_status(rc, &err)) {
|
2015-04-28 21:27:51 +02:00
|
|
|
fprintf(stderr, "%s\n", err->message);
|
|
|
|
g_error_free(err);
|
|
|
|
}
|
|
|
|
g_assert(ret && !err);
|
|
|
|
|
|
|
|
g_free(out);
|
|
|
|
g_free(out2);
|
|
|
|
g_free(cli);
|
2015-11-13 20:31:42 +01:00
|
|
|
free(qemu_img_abs_path);
|
2015-04-28 21:27:51 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void mkqcow2(const char *file, unsigned size_mb)
|
|
|
|
{
|
|
|
|
return mkimg(file, "qcow2", size_mb);
|
|
|
|
}
|
2015-04-28 21:27:51 +02:00
|
|
|
|
|
|
|
void prepare_blkdebug_script(const char *debug_fn, const char *event)
|
|
|
|
{
|
|
|
|
FILE *debug_file = fopen(debug_fn, "w");
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
fprintf(debug_file, "[inject-error]\n");
|
|
|
|
fprintf(debug_file, "event = \"%s\"\n", event);
|
|
|
|
fprintf(debug_file, "errno = \"5\"\n");
|
|
|
|
fprintf(debug_file, "state = \"1\"\n");
|
|
|
|
fprintf(debug_file, "immediately = \"off\"\n");
|
|
|
|
fprintf(debug_file, "once = \"on\"\n");
|
|
|
|
|
|
|
|
fprintf(debug_file, "[set-state]\n");
|
|
|
|
fprintf(debug_file, "event = \"%s\"\n", event);
|
|
|
|
fprintf(debug_file, "new_state = \"2\"\n");
|
|
|
|
fflush(debug_file);
|
|
|
|
g_assert(!ferror(debug_file));
|
|
|
|
|
|
|
|
ret = fclose(debug_file);
|
|
|
|
g_assert(ret == 0);
|
|
|
|
}
|
2015-09-17 20:17:04 +02:00
|
|
|
|
|
|
|
void generate_pattern(void *buffer, size_t len, size_t cycle_len)
|
|
|
|
{
|
|
|
|
int i, j;
|
|
|
|
unsigned char *tx = (unsigned char *)buffer;
|
|
|
|
unsigned char p;
|
|
|
|
size_t *sx;
|
|
|
|
|
|
|
|
/* Write an indicative pattern that varies and is unique per-cycle */
|
|
|
|
p = rand() % 256;
|
|
|
|
for (i = 0; i < len; i++) {
|
|
|
|
tx[i] = p++ % 256;
|
|
|
|
if (i % cycle_len == 0) {
|
|
|
|
p = rand() % 256;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* force uniqueness by writing an id per-cycle */
|
|
|
|
for (i = 0; i < len / cycle_len; i++) {
|
|
|
|
j = i * cycle_len;
|
|
|
|
if (j + sizeof(*sx) <= len) {
|
|
|
|
sx = (size_t *)&tx[j];
|
|
|
|
*sx = i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|