When read() from the qtest socket or the QMP socket fails or EOFs, we report "Broken pipe" and exit(1). This commonly happens when QEMU crashes. It also happens when QEMU refuses to run because the test passed it bad arguments. Sadly, we neglect to report either. Improve this by calling abort() instead of exit(1), so kill_qemu() runs, and reports how QEMU died. This improves error reporting to something like /x86_64/device/introspect/list: Broken pipe tests/libqtest.c:129: kill_qemu() detected QEMU death from signal 6 (Aborted) (dumped core) Three exit() remain in libqtest.c: * In qmp_response(), when we can't parse a QMP reply read from the QMP socket. Change to abort() for consistency. * In qtest_qemu_binary(), when QTEST_QEMU_BINARY isn't in the environment. This can only happen before we start QEMU. Leave alone. * In qtest_init_without_qmp_handshake(), when the fork()ed child fails to execlp(). Leave alone. exit() elsewhere are unlikely due to QEMU dying on us. If that should turn out to be wrong, we can move kill_qemu() from @abrt_hooks to atexit() or something. Signed-off-by: Markus Armbruster <armbru@redhat.com> Message-Id: <20180815141945.10457-2-armbru@redhat.com> Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org> [Commit message tweaked slightly]
1128 lines
26 KiB
C
1128 lines
26 KiB
C
/*
|
|
* QTest
|
|
*
|
|
* Copyright IBM, Corp. 2012
|
|
* Copyright Red Hat, Inc. 2012
|
|
* Copyright SUSE LINUX Products GmbH 2013
|
|
*
|
|
* Authors:
|
|
* Anthony Liguori <aliguori@us.ibm.com>
|
|
* Paolo Bonzini <pbonzini@redhat.com>
|
|
* Andreas Färber <afaerber@suse.de>
|
|
*
|
|
* This work is licensed under the terms of the GNU GPL, version 2 or later.
|
|
* See the COPYING file in the top-level directory.
|
|
*/
|
|
|
|
#include "qemu/osdep.h"
|
|
|
|
#include <sys/socket.h>
|
|
#include <sys/wait.h>
|
|
#include <sys/un.h>
|
|
|
|
#include "libqtest.h"
|
|
#include "qemu/cutils.h"
|
|
#include "qapi/error.h"
|
|
#include "qapi/qmp/json-parser.h"
|
|
#include "qapi/qmp/json-streamer.h"
|
|
#include "qapi/qmp/qdict.h"
|
|
#include "qapi/qmp/qjson.h"
|
|
#include "qapi/qmp/qlist.h"
|
|
#include "qapi/qmp/qstring.h"
|
|
|
|
#define MAX_IRQ 256
|
|
#define SOCKET_TIMEOUT 50
|
|
|
|
QTestState *global_qtest;
|
|
|
|
struct QTestState
|
|
{
|
|
int fd;
|
|
int qmp_fd;
|
|
bool irq_level[MAX_IRQ];
|
|
GString *rx;
|
|
pid_t qemu_pid; /* our child QEMU process */
|
|
bool big_endian;
|
|
};
|
|
|
|
static GHookList abrt_hooks;
|
|
static struct sigaction sigact_old;
|
|
|
|
#define g_assert_no_errno(ret) do { \
|
|
g_assert_cmpint(ret, !=, -1); \
|
|
} while (0)
|
|
|
|
static int qtest_query_target_endianness(QTestState *s);
|
|
|
|
static int init_socket(const char *socket_path)
|
|
{
|
|
struct sockaddr_un addr;
|
|
int sock;
|
|
int ret;
|
|
|
|
sock = socket(PF_UNIX, SOCK_STREAM, 0);
|
|
g_assert_no_errno(sock);
|
|
|
|
addr.sun_family = AF_UNIX;
|
|
snprintf(addr.sun_path, sizeof(addr.sun_path), "%s", socket_path);
|
|
qemu_set_cloexec(sock);
|
|
|
|
do {
|
|
ret = bind(sock, (struct sockaddr *)&addr, sizeof(addr));
|
|
} while (ret == -1 && errno == EINTR);
|
|
g_assert_no_errno(ret);
|
|
ret = listen(sock, 1);
|
|
g_assert_no_errno(ret);
|
|
|
|
return sock;
|
|
}
|
|
|
|
static int socket_accept(int sock)
|
|
{
|
|
struct sockaddr_un addr;
|
|
socklen_t addrlen;
|
|
int ret;
|
|
struct timeval timeout = { .tv_sec = SOCKET_TIMEOUT,
|
|
.tv_usec = 0 };
|
|
|
|
setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (void *)&timeout,
|
|
sizeof(timeout));
|
|
|
|
do {
|
|
addrlen = sizeof(addr);
|
|
ret = accept(sock, (struct sockaddr *)&addr, &addrlen);
|
|
} while (ret == -1 && errno == EINTR);
|
|
if (ret == -1) {
|
|
fprintf(stderr, "%s failed: %s\n", __func__, strerror(errno));
|
|
}
|
|
close(sock);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void kill_qemu(QTestState *s)
|
|
{
|
|
if (s->qemu_pid != -1) {
|
|
int wstatus = 0;
|
|
pid_t pid;
|
|
|
|
kill(s->qemu_pid, SIGTERM);
|
|
TFR(pid = waitpid(s->qemu_pid, &wstatus, 0));
|
|
|
|
assert(pid == s->qemu_pid);
|
|
/*
|
|
* We expect qemu to exit with status 0; anything else is
|
|
* fishy and should be logged with as much detail as possible.
|
|
*/
|
|
if (wstatus) {
|
|
if (WIFEXITED(wstatus)) {
|
|
fprintf(stderr, "%s:%d: kill_qemu() tried to terminate QEMU "
|
|
"process but encountered exit status %d\n",
|
|
__FILE__, __LINE__, WEXITSTATUS(wstatus));
|
|
} else if (WIFSIGNALED(wstatus)) {
|
|
int sig = WTERMSIG(wstatus);
|
|
const char *signame = strsignal(sig) ?: "unknown ???";
|
|
const char *dump = WCOREDUMP(wstatus) ? " (core dumped)" : "";
|
|
|
|
fprintf(stderr, "%s:%d: kill_qemu() detected QEMU death "
|
|
"from signal %d (%s)%s\n",
|
|
__FILE__, __LINE__, sig, signame, dump);
|
|
}
|
|
abort();
|
|
}
|
|
}
|
|
}
|
|
|
|
static void kill_qemu_hook_func(void *s)
|
|
{
|
|
kill_qemu(s);
|
|
}
|
|
|
|
static void sigabrt_handler(int signo)
|
|
{
|
|
g_hook_list_invoke(&abrt_hooks, FALSE);
|
|
}
|
|
|
|
static void setup_sigabrt_handler(void)
|
|
{
|
|
struct sigaction sigact;
|
|
|
|
/* Catch SIGABRT to clean up on g_assert() failure */
|
|
sigact = (struct sigaction){
|
|
.sa_handler = sigabrt_handler,
|
|
.sa_flags = SA_RESETHAND,
|
|
};
|
|
sigemptyset(&sigact.sa_mask);
|
|
sigaction(SIGABRT, &sigact, &sigact_old);
|
|
}
|
|
|
|
static void cleanup_sigabrt_handler(void)
|
|
{
|
|
sigaction(SIGABRT, &sigact_old, NULL);
|
|
}
|
|
|
|
void qtest_add_abrt_handler(GHookFunc fn, const void *data)
|
|
{
|
|
GHook *hook;
|
|
|
|
/* Only install SIGABRT handler once */
|
|
if (!abrt_hooks.is_setup) {
|
|
g_hook_list_init(&abrt_hooks, sizeof(GHook));
|
|
}
|
|
setup_sigabrt_handler();
|
|
|
|
hook = g_hook_alloc(&abrt_hooks);
|
|
hook->func = fn;
|
|
hook->data = (void *)data;
|
|
|
|
g_hook_prepend(&abrt_hooks, hook);
|
|
}
|
|
|
|
static const char *qtest_qemu_binary(void)
|
|
{
|
|
const char *qemu_bin;
|
|
|
|
qemu_bin = getenv("QTEST_QEMU_BINARY");
|
|
if (!qemu_bin) {
|
|
fprintf(stderr, "Environment variable QTEST_QEMU_BINARY required\n");
|
|
exit(1);
|
|
}
|
|
|
|
return qemu_bin;
|
|
}
|
|
|
|
QTestState *qtest_init_without_qmp_handshake(bool use_oob,
|
|
const char *extra_args)
|
|
{
|
|
QTestState *s;
|
|
int sock, qmpsock, i;
|
|
gchar *socket_path;
|
|
gchar *qmp_socket_path;
|
|
gchar *command;
|
|
const char *qemu_binary = qtest_qemu_binary();
|
|
|
|
s = g_new(QTestState, 1);
|
|
|
|
socket_path = g_strdup_printf("/tmp/qtest-%d.sock", getpid());
|
|
qmp_socket_path = g_strdup_printf("/tmp/qtest-%d.qmp", getpid());
|
|
|
|
/* It's possible that if an earlier test run crashed it might
|
|
* have left a stale unix socket lying around. Delete any
|
|
* stale old socket to avoid spurious test failures with
|
|
* tests/libqtest.c:70:init_socket: assertion failed (ret != -1): (-1 != -1)
|
|
*/
|
|
unlink(socket_path);
|
|
unlink(qmp_socket_path);
|
|
|
|
sock = init_socket(socket_path);
|
|
qmpsock = init_socket(qmp_socket_path);
|
|
|
|
qtest_add_abrt_handler(kill_qemu_hook_func, s);
|
|
|
|
s->qemu_pid = fork();
|
|
if (s->qemu_pid == 0) {
|
|
setenv("QEMU_AUDIO_DRV", "none", true);
|
|
command = g_strdup_printf("exec %s "
|
|
"-qtest unix:%s,nowait "
|
|
"-qtest-log %s "
|
|
"-chardev socket,path=%s,nowait,id=char0 "
|
|
"-mon chardev=char0,mode=control%s "
|
|
"-machine accel=qtest "
|
|
"-display none "
|
|
"%s", qemu_binary, socket_path,
|
|
getenv("QTEST_LOG") ? "/dev/fd/2" : "/dev/null",
|
|
qmp_socket_path, use_oob ? ",x-oob=on" : "",
|
|
extra_args ?: "");
|
|
execlp("/bin/sh", "sh", "-c", command, NULL);
|
|
exit(1);
|
|
}
|
|
|
|
s->fd = socket_accept(sock);
|
|
if (s->fd >= 0) {
|
|
s->qmp_fd = socket_accept(qmpsock);
|
|
}
|
|
unlink(socket_path);
|
|
unlink(qmp_socket_path);
|
|
g_free(socket_path);
|
|
g_free(qmp_socket_path);
|
|
|
|
g_assert(s->fd >= 0 && s->qmp_fd >= 0);
|
|
|
|
s->rx = g_string_new("");
|
|
for (i = 0; i < MAX_IRQ; i++) {
|
|
s->irq_level[i] = false;
|
|
}
|
|
|
|
if (getenv("QTEST_STOP")) {
|
|
kill(s->qemu_pid, SIGSTOP);
|
|
}
|
|
|
|
/* ask endianness of the target */
|
|
|
|
s->big_endian = qtest_query_target_endianness(s);
|
|
|
|
return s;
|
|
}
|
|
|
|
QTestState *qtest_init(const char *extra_args)
|
|
{
|
|
QTestState *s = qtest_init_without_qmp_handshake(false, extra_args);
|
|
QDict *greeting;
|
|
|
|
/* Read the QMP greeting and then do the handshake */
|
|
greeting = qtest_qmp_receive(s);
|
|
qobject_unref(greeting);
|
|
qobject_unref(qtest_qmp(s, "{ 'execute': 'qmp_capabilities' }"));
|
|
|
|
return s;
|
|
}
|
|
|
|
QTestState *qtest_vinitf(const char *fmt, va_list ap)
|
|
{
|
|
char *args = g_strdup_vprintf(fmt, ap);
|
|
QTestState *s;
|
|
|
|
s = qtest_init(args);
|
|
g_free(args);
|
|
return s;
|
|
}
|
|
|
|
QTestState *qtest_initf(const char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
QTestState *s;
|
|
|
|
va_start(ap, fmt);
|
|
s = qtest_vinitf(fmt, ap);
|
|
va_end(ap);
|
|
return s;
|
|
}
|
|
|
|
void qtest_quit(QTestState *s)
|
|
{
|
|
g_hook_destroy_link(&abrt_hooks, g_hook_find_data(&abrt_hooks, TRUE, s));
|
|
|
|
/* Uninstall SIGABRT handler on last instance */
|
|
cleanup_sigabrt_handler();
|
|
|
|
kill_qemu(s);
|
|
close(s->fd);
|
|
close(s->qmp_fd);
|
|
g_string_free(s->rx, true);
|
|
g_free(s);
|
|
}
|
|
|
|
static void socket_send(int fd, const char *buf, size_t size)
|
|
{
|
|
size_t offset;
|
|
|
|
offset = 0;
|
|
while (offset < size) {
|
|
ssize_t len;
|
|
|
|
len = write(fd, buf + offset, size - offset);
|
|
if (len == -1 && errno == EINTR) {
|
|
continue;
|
|
}
|
|
|
|
g_assert_no_errno(len);
|
|
g_assert_cmpint(len, >, 0);
|
|
|
|
offset += len;
|
|
}
|
|
}
|
|
|
|
static void socket_sendf(int fd, const char *fmt, va_list ap)
|
|
{
|
|
gchar *str = g_strdup_vprintf(fmt, ap);
|
|
size_t size = strlen(str);
|
|
|
|
socket_send(fd, str, size);
|
|
g_free(str);
|
|
}
|
|
|
|
static void GCC_FMT_ATTR(2, 3) qtest_sendf(QTestState *s, const char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
|
|
va_start(ap, fmt);
|
|
socket_sendf(s->fd, fmt, ap);
|
|
va_end(ap);
|
|
}
|
|
|
|
static GString *qtest_recv_line(QTestState *s)
|
|
{
|
|
GString *line;
|
|
size_t offset;
|
|
char *eol;
|
|
|
|
while ((eol = strchr(s->rx->str, '\n')) == NULL) {
|
|
ssize_t len;
|
|
char buffer[1024];
|
|
|
|
len = read(s->fd, buffer, sizeof(buffer));
|
|
if (len == -1 && errno == EINTR) {
|
|
continue;
|
|
}
|
|
|
|
if (len == -1 || len == 0) {
|
|
fprintf(stderr, "Broken pipe\n");
|
|
abort();
|
|
}
|
|
|
|
g_string_append_len(s->rx, buffer, len);
|
|
}
|
|
|
|
offset = eol - s->rx->str;
|
|
line = g_string_new_len(s->rx->str, offset);
|
|
g_string_erase(s->rx, 0, offset + 1);
|
|
|
|
return line;
|
|
}
|
|
|
|
static gchar **qtest_rsp(QTestState *s, int expected_args)
|
|
{
|
|
GString *line;
|
|
gchar **words;
|
|
int i;
|
|
|
|
redo:
|
|
line = qtest_recv_line(s);
|
|
words = g_strsplit(line->str, " ", 0);
|
|
g_string_free(line, TRUE);
|
|
|
|
if (strcmp(words[0], "IRQ") == 0) {
|
|
long irq;
|
|
int ret;
|
|
|
|
g_assert(words[1] != NULL);
|
|
g_assert(words[2] != NULL);
|
|
|
|
ret = qemu_strtol(words[2], NULL, 0, &irq);
|
|
g_assert(!ret);
|
|
g_assert_cmpint(irq, >=, 0);
|
|
g_assert_cmpint(irq, <, MAX_IRQ);
|
|
|
|
if (strcmp(words[1], "raise") == 0) {
|
|
s->irq_level[irq] = true;
|
|
} else {
|
|
s->irq_level[irq] = false;
|
|
}
|
|
|
|
g_strfreev(words);
|
|
goto redo;
|
|
}
|
|
|
|
g_assert(words[0] != NULL);
|
|
g_assert_cmpstr(words[0], ==, "OK");
|
|
|
|
if (expected_args) {
|
|
for (i = 0; i < expected_args; i++) {
|
|
g_assert(words[i] != NULL);
|
|
}
|
|
} else {
|
|
g_strfreev(words);
|
|
}
|
|
|
|
return words;
|
|
}
|
|
|
|
static int qtest_query_target_endianness(QTestState *s)
|
|
{
|
|
gchar **args;
|
|
int big_endian;
|
|
|
|
qtest_sendf(s, "endianness\n");
|
|
args = qtest_rsp(s, 1);
|
|
g_assert(strcmp(args[1], "big") == 0 || strcmp(args[1], "little") == 0);
|
|
big_endian = strcmp(args[1], "big") == 0;
|
|
g_strfreev(args);
|
|
|
|
return big_endian;
|
|
}
|
|
|
|
typedef struct {
|
|
JSONMessageParser parser;
|
|
QDict *response;
|
|
} QMPResponseParser;
|
|
|
|
static void qmp_response(JSONMessageParser *parser, GQueue *tokens)
|
|
{
|
|
QMPResponseParser *qmp = container_of(parser, QMPResponseParser, parser);
|
|
QObject *obj;
|
|
|
|
obj = json_parser_parse(tokens, NULL);
|
|
if (!obj) {
|
|
fprintf(stderr, "QMP JSON response parsing failed\n");
|
|
abort();
|
|
}
|
|
|
|
g_assert(!qmp->response);
|
|
qmp->response = qobject_to(QDict, obj);
|
|
g_assert(qmp->response);
|
|
}
|
|
|
|
QDict *qmp_fd_receive(int fd)
|
|
{
|
|
QMPResponseParser qmp;
|
|
bool log = getenv("QTEST_LOG") != NULL;
|
|
|
|
qmp.response = NULL;
|
|
json_message_parser_init(&qmp.parser, qmp_response);
|
|
while (!qmp.response) {
|
|
ssize_t len;
|
|
char c;
|
|
|
|
len = read(fd, &c, 1);
|
|
if (len == -1 && errno == EINTR) {
|
|
continue;
|
|
}
|
|
|
|
if (len == -1 || len == 0) {
|
|
fprintf(stderr, "Broken pipe\n");
|
|
abort();
|
|
}
|
|
|
|
if (log) {
|
|
len = write(2, &c, 1);
|
|
}
|
|
json_message_parser_feed(&qmp.parser, &c, 1);
|
|
}
|
|
json_message_parser_destroy(&qmp.parser);
|
|
|
|
return qmp.response;
|
|
}
|
|
|
|
QDict *qtest_qmp_receive(QTestState *s)
|
|
{
|
|
return qmp_fd_receive(s->qmp_fd);
|
|
}
|
|
|
|
/**
|
|
* Allow users to send a message without waiting for the reply,
|
|
* in the case that they choose to discard all replies up until
|
|
* a particular EVENT is received.
|
|
*/
|
|
void qmp_fd_vsend(int fd, const char *fmt, va_list ap)
|
|
{
|
|
QObject *qobj;
|
|
|
|
/*
|
|
* qobject_from_vjsonf_nofail() chokes on leading 0xff as invalid
|
|
* JSON, but tests/test-qga.c needs to send that to test QGA
|
|
* synchronization
|
|
*/
|
|
if (*fmt == '\377') {
|
|
socket_send(fd, fmt, 1);
|
|
fmt++;
|
|
}
|
|
|
|
/* Going through qobject ensures we escape strings properly */
|
|
qobj = qobject_from_vjsonf_nofail(fmt, ap);
|
|
|
|
/* No need to send anything for an empty QObject. */
|
|
if (qobj) {
|
|
int log = getenv("QTEST_LOG") != NULL;
|
|
QString *qstr = qobject_to_json(qobj);
|
|
const char *str;
|
|
|
|
/*
|
|
* BUG: QMP doesn't react to input until it sees a newline, an
|
|
* object, or an array. Work-around: give it a newline.
|
|
*/
|
|
qstring_append_chr(qstr, '\n');
|
|
str = qstring_get_str(qstr);
|
|
|
|
if (log) {
|
|
fprintf(stderr, "%s", str);
|
|
}
|
|
/* Send QMP request */
|
|
socket_send(fd, str, qstring_get_length(qstr));
|
|
|
|
qobject_unref(qstr);
|
|
qobject_unref(qobj);
|
|
}
|
|
}
|
|
|
|
void qtest_qmp_vsend(QTestState *s, const char *fmt, va_list ap)
|
|
{
|
|
qmp_fd_vsend(s->qmp_fd, fmt, ap);
|
|
}
|
|
|
|
QDict *qmp_fdv(int fd, const char *fmt, va_list ap)
|
|
{
|
|
qmp_fd_vsend(fd, fmt, ap);
|
|
|
|
return qmp_fd_receive(fd);
|
|
}
|
|
|
|
QDict *qtest_vqmp(QTestState *s, const char *fmt, va_list ap)
|
|
{
|
|
qtest_qmp_vsend(s, fmt, ap);
|
|
|
|
/* Receive reply */
|
|
return qtest_qmp_receive(s);
|
|
}
|
|
|
|
QDict *qmp_fd(int fd, const char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
QDict *response;
|
|
|
|
va_start(ap, fmt);
|
|
response = qmp_fdv(fd, fmt, ap);
|
|
va_end(ap);
|
|
return response;
|
|
}
|
|
|
|
void qmp_fd_send(int fd, const char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
|
|
va_start(ap, fmt);
|
|
qmp_fd_vsend(fd, fmt, ap);
|
|
va_end(ap);
|
|
}
|
|
|
|
QDict *qtest_qmp(QTestState *s, const char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
QDict *response;
|
|
|
|
va_start(ap, fmt);
|
|
response = qtest_vqmp(s, fmt, ap);
|
|
va_end(ap);
|
|
return response;
|
|
}
|
|
|
|
void qtest_qmp_send(QTestState *s, const char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
|
|
va_start(ap, fmt);
|
|
qtest_qmp_vsend(s, fmt, ap);
|
|
va_end(ap);
|
|
}
|
|
|
|
QDict *qtest_qmp_eventwait_ref(QTestState *s, const char *event)
|
|
{
|
|
QDict *response;
|
|
|
|
for (;;) {
|
|
response = qtest_qmp_receive(s);
|
|
if ((qdict_haskey(response, "event")) &&
|
|
(strcmp(qdict_get_str(response, "event"), event) == 0)) {
|
|
return response;
|
|
}
|
|
qobject_unref(response);
|
|
}
|
|
}
|
|
|
|
void qtest_qmp_eventwait(QTestState *s, const char *event)
|
|
{
|
|
QDict *response;
|
|
|
|
response = qtest_qmp_eventwait_ref(s, event);
|
|
qobject_unref(response);
|
|
}
|
|
|
|
char *qtest_vhmp(QTestState *s, const char *fmt, va_list ap)
|
|
{
|
|
char *cmd;
|
|
QDict *resp;
|
|
char *ret;
|
|
|
|
cmd = g_strdup_vprintf(fmt, ap);
|
|
resp = qtest_qmp(s, "{'execute': 'human-monitor-command',"
|
|
" 'arguments': {'command-line': %s}}",
|
|
cmd);
|
|
ret = g_strdup(qdict_get_try_str(resp, "return"));
|
|
while (ret == NULL && qdict_get_try_str(resp, "event")) {
|
|
/* Ignore asynchronous QMP events */
|
|
qobject_unref(resp);
|
|
resp = qtest_qmp_receive(s);
|
|
ret = g_strdup(qdict_get_try_str(resp, "return"));
|
|
}
|
|
g_assert(ret);
|
|
qobject_unref(resp);
|
|
g_free(cmd);
|
|
return ret;
|
|
}
|
|
|
|
char *qtest_hmp(QTestState *s, const char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
char *ret;
|
|
|
|
va_start(ap, fmt);
|
|
ret = qtest_vhmp(s, fmt, ap);
|
|
va_end(ap);
|
|
return ret;
|
|
}
|
|
|
|
const char *qtest_get_arch(void)
|
|
{
|
|
const char *qemu = qtest_qemu_binary();
|
|
const char *end = strrchr(qemu, '/');
|
|
|
|
return end + strlen("/qemu-system-");
|
|
}
|
|
|
|
bool qtest_get_irq(QTestState *s, int num)
|
|
{
|
|
/* dummy operation in order to make sure irq is up to date */
|
|
qtest_inb(s, 0);
|
|
|
|
return s->irq_level[num];
|
|
}
|
|
|
|
static int64_t qtest_clock_rsp(QTestState *s)
|
|
{
|
|
gchar **words;
|
|
int64_t clock;
|
|
words = qtest_rsp(s, 2);
|
|
clock = g_ascii_strtoll(words[1], NULL, 0);
|
|
g_strfreev(words);
|
|
return clock;
|
|
}
|
|
|
|
int64_t qtest_clock_step_next(QTestState *s)
|
|
{
|
|
qtest_sendf(s, "clock_step\n");
|
|
return qtest_clock_rsp(s);
|
|
}
|
|
|
|
int64_t qtest_clock_step(QTestState *s, int64_t step)
|
|
{
|
|
qtest_sendf(s, "clock_step %"PRIi64"\n", step);
|
|
return qtest_clock_rsp(s);
|
|
}
|
|
|
|
int64_t qtest_clock_set(QTestState *s, int64_t val)
|
|
{
|
|
qtest_sendf(s, "clock_set %"PRIi64"\n", val);
|
|
return qtest_clock_rsp(s);
|
|
}
|
|
|
|
void qtest_irq_intercept_out(QTestState *s, const char *qom_path)
|
|
{
|
|
qtest_sendf(s, "irq_intercept_out %s\n", qom_path);
|
|
qtest_rsp(s, 0);
|
|
}
|
|
|
|
void qtest_irq_intercept_in(QTestState *s, const char *qom_path)
|
|
{
|
|
qtest_sendf(s, "irq_intercept_in %s\n", qom_path);
|
|
qtest_rsp(s, 0);
|
|
}
|
|
|
|
static void qtest_out(QTestState *s, const char *cmd, uint16_t addr, uint32_t value)
|
|
{
|
|
qtest_sendf(s, "%s 0x%x 0x%x\n", cmd, addr, value);
|
|
qtest_rsp(s, 0);
|
|
}
|
|
|
|
void qtest_outb(QTestState *s, uint16_t addr, uint8_t value)
|
|
{
|
|
qtest_out(s, "outb", addr, value);
|
|
}
|
|
|
|
void qtest_outw(QTestState *s, uint16_t addr, uint16_t value)
|
|
{
|
|
qtest_out(s, "outw", addr, value);
|
|
}
|
|
|
|
void qtest_outl(QTestState *s, uint16_t addr, uint32_t value)
|
|
{
|
|
qtest_out(s, "outl", addr, value);
|
|
}
|
|
|
|
static uint32_t qtest_in(QTestState *s, const char *cmd, uint16_t addr)
|
|
{
|
|
gchar **args;
|
|
int ret;
|
|
unsigned long value;
|
|
|
|
qtest_sendf(s, "%s 0x%x\n", cmd, addr);
|
|
args = qtest_rsp(s, 2);
|
|
ret = qemu_strtoul(args[1], NULL, 0, &value);
|
|
g_assert(!ret && value <= UINT32_MAX);
|
|
g_strfreev(args);
|
|
|
|
return value;
|
|
}
|
|
|
|
uint8_t qtest_inb(QTestState *s, uint16_t addr)
|
|
{
|
|
return qtest_in(s, "inb", addr);
|
|
}
|
|
|
|
uint16_t qtest_inw(QTestState *s, uint16_t addr)
|
|
{
|
|
return qtest_in(s, "inw", addr);
|
|
}
|
|
|
|
uint32_t qtest_inl(QTestState *s, uint16_t addr)
|
|
{
|
|
return qtest_in(s, "inl", addr);
|
|
}
|
|
|
|
static void qtest_write(QTestState *s, const char *cmd, uint64_t addr,
|
|
uint64_t value)
|
|
{
|
|
qtest_sendf(s, "%s 0x%" PRIx64 " 0x%" PRIx64 "\n", cmd, addr, value);
|
|
qtest_rsp(s, 0);
|
|
}
|
|
|
|
void qtest_writeb(QTestState *s, uint64_t addr, uint8_t value)
|
|
{
|
|
qtest_write(s, "writeb", addr, value);
|
|
}
|
|
|
|
void qtest_writew(QTestState *s, uint64_t addr, uint16_t value)
|
|
{
|
|
qtest_write(s, "writew", addr, value);
|
|
}
|
|
|
|
void qtest_writel(QTestState *s, uint64_t addr, uint32_t value)
|
|
{
|
|
qtest_write(s, "writel", addr, value);
|
|
}
|
|
|
|
void qtest_writeq(QTestState *s, uint64_t addr, uint64_t value)
|
|
{
|
|
qtest_write(s, "writeq", addr, value);
|
|
}
|
|
|
|
static uint64_t qtest_read(QTestState *s, const char *cmd, uint64_t addr)
|
|
{
|
|
gchar **args;
|
|
int ret;
|
|
uint64_t value;
|
|
|
|
qtest_sendf(s, "%s 0x%" PRIx64 "\n", cmd, addr);
|
|
args = qtest_rsp(s, 2);
|
|
ret = qemu_strtou64(args[1], NULL, 0, &value);
|
|
g_assert(!ret);
|
|
g_strfreev(args);
|
|
|
|
return value;
|
|
}
|
|
|
|
uint8_t qtest_readb(QTestState *s, uint64_t addr)
|
|
{
|
|
return qtest_read(s, "readb", addr);
|
|
}
|
|
|
|
uint16_t qtest_readw(QTestState *s, uint64_t addr)
|
|
{
|
|
return qtest_read(s, "readw", addr);
|
|
}
|
|
|
|
uint32_t qtest_readl(QTestState *s, uint64_t addr)
|
|
{
|
|
return qtest_read(s, "readl", addr);
|
|
}
|
|
|
|
uint64_t qtest_readq(QTestState *s, uint64_t addr)
|
|
{
|
|
return qtest_read(s, "readq", addr);
|
|
}
|
|
|
|
static int hex2nib(char ch)
|
|
{
|
|
if (ch >= '0' && ch <= '9') {
|
|
return ch - '0';
|
|
} else if (ch >= 'a' && ch <= 'f') {
|
|
return 10 + (ch - 'a');
|
|
} else if (ch >= 'A' && ch <= 'F') {
|
|
return 10 + (ch - 'a');
|
|
} else {
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
void qtest_memread(QTestState *s, uint64_t addr, void *data, size_t size)
|
|
{
|
|
uint8_t *ptr = data;
|
|
gchar **args;
|
|
size_t i;
|
|
|
|
if (!size) {
|
|
return;
|
|
}
|
|
|
|
qtest_sendf(s, "read 0x%" PRIx64 " 0x%zx\n", addr, size);
|
|
args = qtest_rsp(s, 2);
|
|
|
|
for (i = 0; i < size; i++) {
|
|
ptr[i] = hex2nib(args[1][2 + (i * 2)]) << 4;
|
|
ptr[i] |= hex2nib(args[1][2 + (i * 2) + 1]);
|
|
}
|
|
|
|
g_strfreev(args);
|
|
}
|
|
|
|
uint64_t qtest_rtas_call(QTestState *s, const char *name,
|
|
uint32_t nargs, uint64_t args,
|
|
uint32_t nret, uint64_t ret)
|
|
{
|
|
qtest_sendf(s, "rtas %s %u 0x%"PRIx64" %u 0x%"PRIx64"\n",
|
|
name, nargs, args, nret, ret);
|
|
qtest_rsp(s, 0);
|
|
return 0;
|
|
}
|
|
|
|
void qtest_add_func(const char *str, void (*fn)(void))
|
|
{
|
|
gchar *path = g_strdup_printf("/%s/%s", qtest_get_arch(), str);
|
|
g_test_add_func(path, fn);
|
|
g_free(path);
|
|
}
|
|
|
|
void qtest_add_data_func_full(const char *str, void *data,
|
|
void (*fn)(const void *),
|
|
GDestroyNotify data_free_func)
|
|
{
|
|
gchar *path = g_strdup_printf("/%s/%s", qtest_get_arch(), str);
|
|
g_test_add_data_func_full(path, data, fn, data_free_func);
|
|
g_free(path);
|
|
}
|
|
|
|
void qtest_add_data_func(const char *str, const void *data,
|
|
void (*fn)(const void *))
|
|
{
|
|
gchar *path = g_strdup_printf("/%s/%s", qtest_get_arch(), str);
|
|
g_test_add_data_func(path, data, fn);
|
|
g_free(path);
|
|
}
|
|
|
|
void qtest_bufwrite(QTestState *s, uint64_t addr, const void *data, size_t size)
|
|
{
|
|
gchar *bdata;
|
|
|
|
bdata = g_base64_encode(data, size);
|
|
qtest_sendf(s, "b64write 0x%" PRIx64 " 0x%zx ", addr, size);
|
|
socket_send(s->fd, bdata, strlen(bdata));
|
|
socket_send(s->fd, "\n", 1);
|
|
qtest_rsp(s, 0);
|
|
g_free(bdata);
|
|
}
|
|
|
|
void qtest_bufread(QTestState *s, uint64_t addr, void *data, size_t size)
|
|
{
|
|
gchar **args;
|
|
size_t len;
|
|
|
|
qtest_sendf(s, "b64read 0x%" PRIx64 " 0x%zx\n", addr, size);
|
|
args = qtest_rsp(s, 2);
|
|
|
|
g_base64_decode_inplace(args[1], &len);
|
|
if (size != len) {
|
|
fprintf(stderr, "bufread: asked for %zu bytes but decoded %zu\n",
|
|
size, len);
|
|
len = MIN(len, size);
|
|
}
|
|
|
|
memcpy(data, args[1], len);
|
|
g_strfreev(args);
|
|
}
|
|
|
|
void qtest_memwrite(QTestState *s, uint64_t addr, const void *data, size_t size)
|
|
{
|
|
const uint8_t *ptr = data;
|
|
size_t i;
|
|
char *enc;
|
|
|
|
if (!size) {
|
|
return;
|
|
}
|
|
|
|
enc = g_malloc(2 * size + 1);
|
|
|
|
for (i = 0; i < size; i++) {
|
|
sprintf(&enc[i * 2], "%02x", ptr[i]);
|
|
}
|
|
|
|
qtest_sendf(s, "write 0x%" PRIx64 " 0x%zx 0x%s\n", addr, size, enc);
|
|
qtest_rsp(s, 0);
|
|
g_free(enc);
|
|
}
|
|
|
|
void qtest_memset(QTestState *s, uint64_t addr, uint8_t pattern, size_t size)
|
|
{
|
|
qtest_sendf(s, "memset 0x%" PRIx64 " 0x%zx 0x%02x\n", addr, size, pattern);
|
|
qtest_rsp(s, 0);
|
|
}
|
|
|
|
QDict *qmp(const char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
QDict *response;
|
|
|
|
va_start(ap, fmt);
|
|
response = qtest_vqmp(global_qtest, fmt, ap);
|
|
va_end(ap);
|
|
return response;
|
|
}
|
|
|
|
void qmp_send(const char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
|
|
va_start(ap, fmt);
|
|
qtest_qmp_vsend(global_qtest, fmt, ap);
|
|
va_end(ap);
|
|
}
|
|
|
|
char *hmp(const char *fmt, ...)
|
|
{
|
|
va_list ap;
|
|
char *ret;
|
|
|
|
va_start(ap, fmt);
|
|
ret = qtest_vhmp(global_qtest, fmt, ap);
|
|
va_end(ap);
|
|
return ret;
|
|
}
|
|
|
|
bool qtest_big_endian(QTestState *s)
|
|
{
|
|
return s->big_endian;
|
|
}
|
|
|
|
void qtest_cb_for_every_machine(void (*cb)(const char *machine))
|
|
{
|
|
QDict *response, *minfo;
|
|
QList *list;
|
|
const QListEntry *p;
|
|
QObject *qobj;
|
|
QString *qstr;
|
|
const char *mname;
|
|
|
|
qtest_start("-machine none");
|
|
response = qmp("{ 'execute': 'query-machines' }");
|
|
g_assert(response);
|
|
list = qdict_get_qlist(response, "return");
|
|
g_assert(list);
|
|
|
|
for (p = qlist_first(list); p; p = qlist_next(p)) {
|
|
minfo = qobject_to(QDict, qlist_entry_obj(p));
|
|
g_assert(minfo);
|
|
qobj = qdict_get(minfo, "name");
|
|
g_assert(qobj);
|
|
qstr = qobject_to(QString, qobj);
|
|
g_assert(qstr);
|
|
mname = qstring_get_str(qstr);
|
|
cb(mname);
|
|
}
|
|
|
|
qtest_end();
|
|
qobject_unref(response);
|
|
}
|
|
|
|
QDict *qtest_qmp_receive_success(QTestState *s,
|
|
void (*event_cb)(void *opaque,
|
|
const char *event,
|
|
QDict *data),
|
|
void *opaque)
|
|
{
|
|
QDict *response, *ret, *data;
|
|
const char *event;
|
|
|
|
for (;;) {
|
|
response = qtest_qmp_receive(s);
|
|
g_assert(!qdict_haskey(response, "error"));
|
|
ret = qdict_get_qdict(response, "return");
|
|
if (ret) {
|
|
break;
|
|
}
|
|
event = qdict_get_str(response, "event");
|
|
data = qdict_get_qdict(response, "data");
|
|
if (event_cb) {
|
|
event_cb(opaque, event, data);
|
|
}
|
|
qobject_unref(response);
|
|
}
|
|
|
|
qobject_ref(ret);
|
|
qobject_unref(response);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* Generic hot-plugging test via the device_add QMP command.
|
|
*/
|
|
void qtest_qmp_device_add(const char *driver, const char *id,
|
|
const char *fmt, ...)
|
|
{
|
|
QDict *args, *response;
|
|
va_list ap;
|
|
|
|
va_start(ap, fmt);
|
|
args = qdict_from_vjsonf_nofail(fmt, ap);
|
|
va_end(ap);
|
|
|
|
g_assert(!qdict_haskey(args, "driver") && !qdict_haskey(args, "id"));
|
|
qdict_put_str(args, "driver", driver);
|
|
qdict_put_str(args, "id", id);
|
|
|
|
response = qmp("{'execute': 'device_add', 'arguments': %p}", args);
|
|
g_assert(response);
|
|
g_assert(!qdict_haskey(response, "event")); /* We don't expect any events */
|
|
g_assert(!qdict_haskey(response, "error"));
|
|
qobject_unref(response);
|
|
}
|
|
|
|
static void device_deleted_cb(void *opaque, const char *name, QDict *data)
|
|
{
|
|
bool *got_event = opaque;
|
|
|
|
g_assert_cmpstr(name, ==, "DEVICE_DELETED");
|
|
*got_event = true;
|
|
}
|
|
|
|
/*
|
|
* Generic hot-unplugging test via the device_del QMP command.
|
|
* Device deletion will get one response and one event. For example:
|
|
*
|
|
* {'execute': 'device_del','arguments': { 'id': 'scsi-hd'}}
|
|
*
|
|
* will get this one:
|
|
*
|
|
* {"timestamp": {"seconds": 1505289667, "microseconds": 569862},
|
|
* "event": "DEVICE_DELETED", "data": {"device": "scsi-hd",
|
|
* "path": "/machine/peripheral/scsi-hd"}}
|
|
*
|
|
* and this one:
|
|
*
|
|
* {"return": {}}
|
|
*
|
|
* But the order of arrival may vary - so we've got to detect both.
|
|
*/
|
|
void qtest_qmp_device_del(const char *id)
|
|
{
|
|
bool got_event = false;
|
|
QDict *rsp;
|
|
|
|
qtest_qmp_send(global_qtest,
|
|
"{'execute': 'device_del', 'arguments': {'id': %s}}",
|
|
id);
|
|
rsp = qtest_qmp_receive_success(global_qtest, device_deleted_cb,
|
|
&got_event);
|
|
qobject_unref(rsp);
|
|
if (!got_event) {
|
|
rsp = qmp_receive();
|
|
g_assert_cmpstr(qdict_get_try_str(rsp, "event"),
|
|
==, "DEVICE_DELETED");
|
|
qobject_unref(rsp);
|
|
}
|
|
}
|
|
|
|
bool qmp_rsp_is_err(QDict *rsp)
|
|
{
|
|
QDict *error = qdict_get_qdict(rsp, "error");
|
|
qobject_unref(rsp);
|
|
return !!error;
|
|
}
|