2012-03-28 15:42:05 +02:00
|
|
|
/*
|
|
|
|
* QTest
|
|
|
|
*
|
|
|
|
* Copyright IBM, Corp. 2012
|
|
|
|
* Copyright Red Hat, Inc. 2012
|
2013-02-16 22:44:03 +01:00
|
|
|
* Copyright SUSE LINUX Products GmbH 2013
|
2012-03-28 15:42:05 +02:00
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Anthony Liguori <aliguori@us.ibm.com>
|
|
|
|
* Paolo Bonzini <pbonzini@redhat.com>
|
2013-02-16 22:44:03 +01:00
|
|
|
* Andreas Färber <afaerber@suse.de>
|
2012-03-28 15:42:05 +02:00
|
|
|
*
|
|
|
|
* This work is licensed under the terms of the GNU GPL, version 2 or later.
|
|
|
|
* See the COPYING file in the top-level directory.
|
|
|
|
*/
|
2018-02-01 12:18:38 +01:00
|
|
|
|
2016-02-08 19:08:51 +01:00
|
|
|
#include "qemu/osdep.h"
|
2012-03-28 15:42:05 +02:00
|
|
|
#include "libqtest.h"
|
|
|
|
|
|
|
|
#include <sys/socket.h>
|
|
|
|
#include <sys/wait.h>
|
|
|
|
#include <sys/un.h>
|
|
|
|
|
2017-02-28 22:26:55 +01:00
|
|
|
#include "qapi/error.h"
|
2013-10-30 14:54:33 +01:00
|
|
|
#include "qapi/qmp/json-parser.h"
|
2014-06-13 09:35:18 +02:00
|
|
|
#include "qapi/qmp/json-streamer.h"
|
2018-02-01 12:18:39 +01:00
|
|
|
#include "qapi/qmp/qdict.h"
|
2014-06-13 09:35:18 +02:00
|
|
|
#include "qapi/qmp/qjson.h"
|
2018-02-01 12:18:38 +01:00
|
|
|
#include "qapi/qmp/qlist.h"
|
2012-03-28 15:42:05 +02:00
|
|
|
|
|
|
|
#define MAX_IRQ 256
|
2016-06-13 13:16:44 +02:00
|
|
|
#define SOCKET_TIMEOUT 50
|
2012-03-28 15:42:05 +02:00
|
|
|
|
|
|
|
QTestState *global_qtest;
|
|
|
|
|
|
|
|
struct QTestState
|
|
|
|
{
|
|
|
|
int fd;
|
2012-04-26 19:07:55 +02:00
|
|
|
int qmp_fd;
|
2012-03-28 15:42:05 +02:00
|
|
|
bool irq_level[MAX_IRQ];
|
|
|
|
GString *rx;
|
2014-02-17 14:54:17 +01:00
|
|
|
pid_t qemu_pid; /* our child QEMU process */
|
2016-10-07 12:14:27 +02:00
|
|
|
bool big_endian;
|
2012-03-28 15:42:05 +02:00
|
|
|
};
|
|
|
|
|
2015-06-19 18:45:14 +02:00
|
|
|
static GHookList abrt_hooks;
|
2014-03-27 15:09:50 +01:00
|
|
|
static struct sigaction sigact_old;
|
|
|
|
|
2012-03-28 15:42:05 +02:00
|
|
|
#define g_assert_no_errno(ret) do { \
|
|
|
|
g_assert_cmpint(ret, !=, -1); \
|
|
|
|
} while (0)
|
|
|
|
|
2016-10-07 12:14:27 +02:00
|
|
|
static int qtest_query_target_endianness(QTestState *s);
|
|
|
|
|
2012-04-26 19:07:55 +02:00
|
|
|
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);
|
2014-04-17 18:19:14 +02:00
|
|
|
ret = listen(sock, 1);
|
|
|
|
g_assert_no_errno(ret);
|
2012-04-26 19:07:55 +02:00
|
|
|
|
|
|
|
return sock;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int socket_accept(int sock)
|
|
|
|
{
|
|
|
|
struct sockaddr_un addr;
|
|
|
|
socklen_t addrlen;
|
|
|
|
int ret;
|
2014-03-11 14:00:34 +01:00
|
|
|
struct timeval timeout = { .tv_sec = SOCKET_TIMEOUT,
|
|
|
|
.tv_usec = 0 };
|
|
|
|
|
|
|
|
setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (void *)&timeout,
|
|
|
|
sizeof(timeout));
|
2012-04-26 19:07:55 +02:00
|
|
|
|
|
|
|
do {
|
2014-04-17 19:21:12 +02:00
|
|
|
addrlen = sizeof(addr);
|
2012-04-26 19:07:55 +02:00
|
|
|
ret = accept(sock, (struct sockaddr *)&addr, &addrlen);
|
|
|
|
} while (ret == -1 && errno == EINTR);
|
2014-04-17 18:38:25 +02:00
|
|
|
if (ret == -1) {
|
|
|
|
fprintf(stderr, "%s failed: %s\n", __func__, strerror(errno));
|
|
|
|
}
|
2012-04-26 19:07:55 +02:00
|
|
|
close(sock);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-02-17 16:33:35 +01:00
|
|
|
static void kill_qemu(QTestState *s)
|
|
|
|
{
|
|
|
|
if (s->qemu_pid != -1) {
|
|
|
|
kill(s->qemu_pid, SIGTERM);
|
|
|
|
waitpid(s->qemu_pid, NULL, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-12-02 21:20:33 +01:00
|
|
|
static void kill_qemu_hook_func(void *s)
|
|
|
|
{
|
|
|
|
kill_qemu(s);
|
|
|
|
}
|
|
|
|
|
2014-02-17 16:33:35 +01:00
|
|
|
static void sigabrt_handler(int signo)
|
|
|
|
{
|
2015-06-19 18:45:14 +02:00
|
|
|
g_hook_list_invoke(&abrt_hooks, FALSE);
|
2014-03-27 15:09:50 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
2014-02-17 16:33:35 +01:00
|
|
|
}
|
|
|
|
|
2015-12-02 21:20:33 +01:00
|
|
|
void qtest_add_abrt_handler(GHookFunc fn, const void *data)
|
2015-06-19 18:45:14 +02:00
|
|
|
{
|
|
|
|
GHook *hook;
|
|
|
|
|
|
|
|
/* Only install SIGABRT handler once */
|
|
|
|
if (!abrt_hooks.is_setup) {
|
|
|
|
g_hook_list_init(&abrt_hooks, sizeof(GHook));
|
|
|
|
}
|
2017-08-08 22:38:59 +02:00
|
|
|
setup_sigabrt_handler();
|
2015-06-19 18:45:14 +02:00
|
|
|
|
|
|
|
hook = g_hook_alloc(&abrt_hooks);
|
|
|
|
hook->func = fn;
|
|
|
|
hook->data = (void *)data;
|
|
|
|
|
|
|
|
g_hook_prepend(&abrt_hooks, hook);
|
|
|
|
}
|
|
|
|
|
2017-08-28 12:25:45 +02:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2017-03-03 13:32:23 +01:00
|
|
|
QTestState *qtest_init_without_qmp_handshake(const char *extra_args)
|
2012-03-28 15:42:05 +02:00
|
|
|
{
|
|
|
|
QTestState *s;
|
2013-04-16 16:45:15 +02:00
|
|
|
int sock, qmpsock, i;
|
2013-11-21 11:37:25 +01:00
|
|
|
gchar *socket_path;
|
|
|
|
gchar *qmp_socket_path;
|
2012-03-28 15:42:05 +02:00
|
|
|
gchar *command;
|
2017-08-28 12:25:45 +02:00
|
|
|
const char *qemu_binary = qtest_qemu_binary();
|
2012-03-28 15:42:05 +02:00
|
|
|
|
2017-10-07 01:49:56 +02:00
|
|
|
s = g_new(QTestState, 1);
|
2012-03-28 15:42:05 +02:00
|
|
|
|
2013-11-21 11:37:25 +01:00
|
|
|
socket_path = g_strdup_printf("/tmp/qtest-%d.sock", getpid());
|
|
|
|
qmp_socket_path = g_strdup_printf("/tmp/qtest-%d.qmp", getpid());
|
2012-06-29 17:34:27 +02:00
|
|
|
|
2017-03-31 14:36:41 +02:00
|
|
|
/* 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);
|
|
|
|
|
2013-11-21 11:37:25 +01:00
|
|
|
sock = init_socket(socket_path);
|
|
|
|
qmpsock = init_socket(qmp_socket_path);
|
2012-03-28 15:42:05 +02:00
|
|
|
|
2015-12-02 21:20:33 +01:00
|
|
|
qtest_add_abrt_handler(kill_qemu_hook_func, s);
|
2014-02-17 16:33:35 +01:00
|
|
|
|
2014-02-17 14:54:17 +01:00
|
|
|
s->qemu_pid = fork();
|
|
|
|
if (s->qemu_pid == 0) {
|
2014-08-27 13:08:52 +02:00
|
|
|
setenv("QEMU_AUDIO_DRV", "none", true);
|
2014-02-17 14:54:17 +01:00
|
|
|
command = g_strdup_printf("exec %s "
|
2012-03-28 15:42:05 +02:00
|
|
|
"-qtest unix:%s,nowait "
|
2014-08-04 23:11:03 +02:00
|
|
|
"-qtest-log %s "
|
2012-04-26 19:07:55 +02:00
|
|
|
"-qmp unix:%s,nowait "
|
2012-03-28 15:42:05 +02:00
|
|
|
"-machine accel=qtest "
|
2013-11-18 17:36:34 +01:00
|
|
|
"-display none "
|
2013-11-21 11:37:25 +01:00
|
|
|
"%s", qemu_binary, socket_path,
|
2014-08-04 23:11:03 +02:00
|
|
|
getenv("QTEST_LOG") ? "/dev/fd/2" : "/dev/null",
|
2014-02-17 14:54:17 +01:00
|
|
|
qmp_socket_path,
|
2012-03-28 15:42:05 +02:00
|
|
|
extra_args ?: "");
|
2013-04-16 16:45:15 +02:00
|
|
|
execlp("/bin/sh", "sh", "-c", command, NULL);
|
|
|
|
exit(1);
|
2012-03-28 15:42:05 +02:00
|
|
|
}
|
|
|
|
|
2012-04-26 19:07:55 +02:00
|
|
|
s->fd = socket_accept(sock);
|
2014-03-11 14:00:34 +01:00
|
|
|
if (s->fd >= 0) {
|
|
|
|
s->qmp_fd = socket_accept(qmpsock);
|
|
|
|
}
|
2013-11-21 11:37:25 +01:00
|
|
|
unlink(socket_path);
|
|
|
|
unlink(qmp_socket_path);
|
|
|
|
g_free(socket_path);
|
|
|
|
g_free(qmp_socket_path);
|
2012-03-28 15:42:05 +02:00
|
|
|
|
2014-03-11 14:00:34 +01:00
|
|
|
g_assert(s->fd >= 0 && s->qmp_fd >= 0);
|
|
|
|
|
2012-03-28 15:42:05 +02:00
|
|
|
s->rx = g_string_new("");
|
|
|
|
for (i = 0; i < MAX_IRQ; i++) {
|
|
|
|
s->irq_level[i] = false;
|
|
|
|
}
|
|
|
|
|
2012-10-01 14:18:07 +02:00
|
|
|
if (getenv("QTEST_STOP")) {
|
2013-11-21 11:33:17 +01:00
|
|
|
kill(s->qemu_pid, SIGSTOP);
|
2012-10-01 14:18:07 +02:00
|
|
|
}
|
|
|
|
|
2016-10-07 12:14:27 +02:00
|
|
|
/* ask endianness of the target */
|
|
|
|
|
|
|
|
s->big_endian = qtest_query_target_endianness(s);
|
|
|
|
|
2012-03-28 15:42:05 +02:00
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
2017-03-03 13:32:23 +01:00
|
|
|
QTestState *qtest_init(const char *extra_args)
|
|
|
|
{
|
|
|
|
QTestState *s = qtest_init_without_qmp_handshake(extra_args);
|
|
|
|
|
|
|
|
/* Read the QMP greeting and then do the handshake */
|
|
|
|
qtest_qmp_discard_response(s, "");
|
|
|
|
qtest_qmp_discard_response(s, "{ 'execute': 'qmp_capabilities' }");
|
|
|
|
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
2017-10-18 16:20:27 +02:00
|
|
|
QTestState *qtest_vstartf(const char *fmt, va_list ap)
|
|
|
|
{
|
|
|
|
char *args = g_strdup_vprintf(fmt, ap);
|
|
|
|
QTestState *s;
|
|
|
|
|
|
|
|
s = qtest_start(args);
|
|
|
|
g_free(args);
|
|
|
|
global_qtest = NULL;
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
QTestState *qtest_startf(const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
QTestState *s;
|
|
|
|
|
|
|
|
va_start(ap, fmt);
|
|
|
|
s = qtest_vstartf(fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
2012-03-28 15:42:05 +02:00
|
|
|
void qtest_quit(QTestState *s)
|
|
|
|
{
|
2015-06-19 18:45:14 +02:00
|
|
|
g_hook_destroy_link(&abrt_hooks, g_hook_find_data(&abrt_hooks, TRUE, s));
|
|
|
|
|
2014-03-27 15:09:50 +01:00
|
|
|
/* Uninstall SIGABRT handler on last instance */
|
2017-09-11 19:19:49 +02:00
|
|
|
cleanup_sigabrt_handler();
|
2014-03-27 15:09:50 +01:00
|
|
|
|
2014-02-17 16:33:35 +01:00
|
|
|
kill_qemu(s);
|
2013-06-20 08:55:28 +02:00
|
|
|
close(s->fd);
|
|
|
|
close(s->qmp_fd);
|
|
|
|
g_string_free(s->rx, true);
|
|
|
|
g_free(s);
|
2012-03-28 15:42:05 +02:00
|
|
|
}
|
|
|
|
|
2014-06-13 09:35:18 +02:00
|
|
|
static void socket_send(int fd, const char *buf, size_t size)
|
2012-03-28 15:42:05 +02:00
|
|
|
{
|
2014-06-13 09:35:18 +02:00
|
|
|
size_t offset;
|
2012-03-28 15:42:05 +02:00
|
|
|
|
|
|
|
offset = 0;
|
|
|
|
while (offset < size) {
|
|
|
|
ssize_t len;
|
|
|
|
|
2014-06-13 09:35:18 +02:00
|
|
|
len = write(fd, buf + offset, size - offset);
|
2012-03-28 15:42:05 +02:00
|
|
|
if (len == -1 && errno == EINTR) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
g_assert_no_errno(len);
|
|
|
|
g_assert_cmpint(len, >, 0);
|
|
|
|
|
|
|
|
offset += len;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-13 09:35:18 +02:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2012-04-26 19:07:55 +02:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2012-03-28 15:42:05 +02:00
|
|
|
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");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
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) {
|
|
|
|
int irq;
|
|
|
|
|
|
|
|
g_assert(words[1] != NULL);
|
|
|
|
g_assert(words[2] != NULL);
|
|
|
|
|
|
|
|
irq = strtoul(words[2], NULL, 0);
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2016-10-07 12:14:27 +02:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2013-10-30 14:54:33 +01:00
|
|
|
typedef struct {
|
|
|
|
JSONMessageParser parser;
|
|
|
|
QDict *response;
|
|
|
|
} QMPResponseParser;
|
|
|
|
|
2015-11-25 22:23:31 +01:00
|
|
|
static void qmp_response(JSONMessageParser *parser, GQueue *tokens)
|
2012-04-26 19:07:55 +02:00
|
|
|
{
|
2013-10-30 14:54:33 +01:00
|
|
|
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");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
g_assert(!qmp->response);
|
2017-02-17 21:38:16 +01:00
|
|
|
qmp->response = qobject_to_qdict(obj);
|
|
|
|
g_assert(qmp->response);
|
2013-10-30 14:54:33 +01:00
|
|
|
}
|
|
|
|
|
2015-10-02 14:58:16 +02:00
|
|
|
QDict *qmp_fd_receive(int fd)
|
2013-10-30 14:54:33 +01:00
|
|
|
{
|
|
|
|
QMPResponseParser qmp;
|
2014-08-04 23:11:03 +02:00
|
|
|
bool log = getenv("QTEST_LOG") != NULL;
|
2012-04-26 19:07:55 +02:00
|
|
|
|
2013-10-30 14:54:33 +01:00
|
|
|
qmp.response = NULL;
|
|
|
|
json_message_parser_init(&qmp.parser, qmp_response);
|
|
|
|
while (!qmp.response) {
|
2012-04-26 19:07:55 +02:00
|
|
|
ssize_t len;
|
|
|
|
char c;
|
|
|
|
|
2015-10-02 14:58:16 +02:00
|
|
|
len = read(fd, &c, 1);
|
2012-04-26 19:07:55 +02:00
|
|
|
if (len == -1 && errno == EINTR) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2012-06-27 15:20:43 +02:00
|
|
|
if (len == -1 || len == 0) {
|
|
|
|
fprintf(stderr, "Broken pipe\n");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
2014-08-04 23:11:03 +02:00
|
|
|
if (log) {
|
|
|
|
len = write(2, &c, 1);
|
|
|
|
}
|
2013-10-30 14:54:33 +01:00
|
|
|
json_message_parser_feed(&qmp.parser, &c, 1);
|
2012-04-26 19:07:55 +02:00
|
|
|
}
|
2013-10-30 14:54:33 +01:00
|
|
|
json_message_parser_destroy(&qmp.parser);
|
|
|
|
|
|
|
|
return qmp.response;
|
|
|
|
}
|
|
|
|
|
2015-10-02 14:58:16 +02:00
|
|
|
QDict *qtest_qmp_receive(QTestState *s)
|
|
|
|
{
|
|
|
|
return qmp_fd_receive(s->qmp_fd);
|
|
|
|
}
|
|
|
|
|
2015-04-28 21:27:51 +02:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
2015-10-02 14:58:16 +02:00
|
|
|
void qmp_fd_sendv(int fd, const char *fmt, va_list ap)
|
2014-02-21 20:55:30 +01:00
|
|
|
{
|
2014-06-13 09:35:18 +02:00
|
|
|
va_list ap_copy;
|
|
|
|
QObject *qobj;
|
|
|
|
|
test-qga: Actually test 0xff sync bytes
Commit 62c39b3 introduced test-qga, and at face value, appears
to be testing the 'guest-sync' behavior that is recommended for
guests in sending 0xff to QGA to force the parser to reset. But
this aspect of the test has never actually done anything: the
qmp_fd() call chain converts its string argument into QObject,
then converts that QObject back to the actual string that is
sent over the wire - and the conversion process silently drops
the 0xff byte from the string sent to QGA, thus never resetting
the QGA parser.
An upcoming patch will get rid of the wasteful round trip
through QObject, at which point the string in test-qga will be
directly sent over the wire.
But fixing qmp_fd() to actually send 0xff over the wire is not
all we have to do - the actual QMP parser loudly complains that
0xff is not valid JSON, and sends an error message _prior_ to
actually parsing the 'guest-sync' or 'guest-sync-delimited'
command. With 'guest-sync', we cannot easily tell if this error
message is a result of our command - which is WHY we invented
the 'guest-sync-delimited' command. So for the testsuite, fix
things to only check 0xff behavior on 'guest-sync-delimited',
and to loop until we've consumed all garbage prior to the
requested delimiter, which is compatible with the documented actions
that a real QGA client is supposed to do.
Ideally, we'd fix the QGA JSON parser to silently ignore 0xff
rather than sending an error message back, at which point we
could enhance this test for 'guest-sync' as well as for
'guest-sync-delimited'. But for the sake of this patch, our
testing of 'guest-sync' is no worse than it was pre-patch,
because we have never been sending 0xff over the wire in the
first place.
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Message-Id: <20170427215821.19397-11-eblake@redhat.com>
Reviewed-by: Michael Roth <mdroth@linux.vnet.ibm.com>
[Additional comment squashed in, along with matching commit message
update]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2017-04-27 23:58:21 +02:00
|
|
|
/* qobject_from_jsonv() silently eats leading 0xff as invalid
|
|
|
|
* JSON, but we want to test sending them over the wire to force
|
|
|
|
* resyncs */
|
|
|
|
if (*fmt == '\377') {
|
|
|
|
socket_send(fd, fmt, 1);
|
|
|
|
fmt++;
|
|
|
|
}
|
|
|
|
|
2014-06-13 09:35:18 +02:00
|
|
|
/* Going through qobject ensures we escape strings properly.
|
|
|
|
* This seemingly unnecessary copy is required in case va_list
|
|
|
|
* is an array type.
|
|
|
|
*/
|
|
|
|
va_copy(ap_copy, ap);
|
2017-02-28 22:26:55 +01:00
|
|
|
qobj = qobject_from_jsonv(fmt, &ap_copy, &error_abort);
|
2014-06-13 09:35:18 +02:00
|
|
|
va_end(ap_copy);
|
|
|
|
|
|
|
|
/* No need to send anything for an empty QObject. */
|
|
|
|
if (qobj) {
|
2014-08-12 13:41:48 +02:00
|
|
|
int log = getenv("QTEST_LOG") != NULL;
|
2014-06-13 09:35:18 +02:00
|
|
|
QString *qstr = qobject_to_json(qobj);
|
libqtest: Work around a "QMP wants a newline" bug
The next commit is going to add a test that calls qmp("null").
Curiously, this hangs. Here's why.
qmp_fd_sendv() doesn't send newlines. Not even when @fmt contains
some. At first glance, the QMP parser seems to be fine with that.
However, it turns out that it fails to react to input until it sees
either a newline, an object or an array. To reproduce, feed to a QMP
monitor like this:
$ echo -n 'null' | socat UNIX:/work/armbru/images/test-qmp STDIO
{"QMP": {"version": {"qemu": {"micro": 50, "minor": 8, "major": 2}, "package": " (v2.8.0-1195-gf84141e-dirty)"}, "capabilities": []}}
No output after the greeting.
Add a newline:
$ echo 'null' | socat UNIX:/work/armbru/images/test-qmp STDIO
{"QMP": {"version": {"qemu": {"micro": 50, "minor": 8, "major": 2}, "package": " (v2.8.0-1195-gf84141e-dirty)"}, "capabilities": []}}
{"error": {"class": "GenericError", "desc": "Expected 'object' in QMP input"}}
Correct output for input 'null'.
Add an object instead:
$ echo -n 'null { "execute": "qmp_capabilities" }' | socat UNIX:qmp-socket STDIO
{"QMP": {"version": {"qemu": {"micro": 50, "minor": 8, "major": 2}, "package": " (v2.8.0-1195-gf84141e-dirty)"}, "capabilities": []}}
{"error": {"class": "GenericError", "desc": "Expected 'object' in QMP input"}}
{"return": {}}
Also correct output.
Work around this QMP bug by having qmp_fd_sendv() append a newline.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Message-Id: <1488544368-30622-3-git-send-email-armbru@redhat.com>
2017-03-03 13:32:22 +01:00
|
|
|
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);
|
2014-06-13 09:35:18 +02:00
|
|
|
|
2014-08-12 13:41:48 +02:00
|
|
|
if (log) {
|
|
|
|
fprintf(stderr, "%s", str);
|
|
|
|
}
|
2014-06-13 09:35:18 +02:00
|
|
|
/* Send QMP request */
|
libqtest: Work around a "QMP wants a newline" bug
The next commit is going to add a test that calls qmp("null").
Curiously, this hangs. Here's why.
qmp_fd_sendv() doesn't send newlines. Not even when @fmt contains
some. At first glance, the QMP parser seems to be fine with that.
However, it turns out that it fails to react to input until it sees
either a newline, an object or an array. To reproduce, feed to a QMP
monitor like this:
$ echo -n 'null' | socat UNIX:/work/armbru/images/test-qmp STDIO
{"QMP": {"version": {"qemu": {"micro": 50, "minor": 8, "major": 2}, "package": " (v2.8.0-1195-gf84141e-dirty)"}, "capabilities": []}}
No output after the greeting.
Add a newline:
$ echo 'null' | socat UNIX:/work/armbru/images/test-qmp STDIO
{"QMP": {"version": {"qemu": {"micro": 50, "minor": 8, "major": 2}, "package": " (v2.8.0-1195-gf84141e-dirty)"}, "capabilities": []}}
{"error": {"class": "GenericError", "desc": "Expected 'object' in QMP input"}}
Correct output for input 'null'.
Add an object instead:
$ echo -n 'null { "execute": "qmp_capabilities" }' | socat UNIX:qmp-socket STDIO
{"QMP": {"version": {"qemu": {"micro": 50, "minor": 8, "major": 2}, "package": " (v2.8.0-1195-gf84141e-dirty)"}, "capabilities": []}}
{"error": {"class": "GenericError", "desc": "Expected 'object' in QMP input"}}
{"return": {}}
Also correct output.
Work around this QMP bug by having qmp_fd_sendv() append a newline.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Message-Id: <1488544368-30622-3-git-send-email-armbru@redhat.com>
2017-03-03 13:32:22 +01:00
|
|
|
socket_send(fd, str, qstring_get_length(qstr));
|
2014-06-13 09:35:18 +02:00
|
|
|
|
|
|
|
QDECREF(qstr);
|
|
|
|
qobject_decref(qobj);
|
|
|
|
}
|
2015-04-28 21:27:51 +02:00
|
|
|
}
|
|
|
|
|
2015-10-02 14:58:16 +02:00
|
|
|
void qtest_async_qmpv(QTestState *s, const char *fmt, va_list ap)
|
|
|
|
{
|
|
|
|
qmp_fd_sendv(s->qmp_fd, fmt, ap);
|
|
|
|
}
|
|
|
|
|
|
|
|
QDict *qmp_fdv(int fd, const char *fmt, va_list ap)
|
|
|
|
{
|
|
|
|
qmp_fd_sendv(fd, fmt, ap);
|
|
|
|
|
|
|
|
return qmp_fd_receive(fd);
|
|
|
|
}
|
|
|
|
|
2015-04-28 21:27:51 +02:00
|
|
|
QDict *qtest_qmpv(QTestState *s, const char *fmt, va_list ap)
|
|
|
|
{
|
|
|
|
qtest_async_qmpv(s, fmt, ap);
|
2014-02-21 20:55:30 +01:00
|
|
|
|
|
|
|
/* Receive reply */
|
|
|
|
return qtest_qmp_receive(s);
|
|
|
|
}
|
|
|
|
|
2015-10-02 14:58:16 +02:00
|
|
|
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_sendv(fd, fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
}
|
|
|
|
|
2013-10-30 14:54:33 +01:00
|
|
|
QDict *qtest_qmp(QTestState *s, const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
QDict *response;
|
|
|
|
|
|
|
|
va_start(ap, fmt);
|
|
|
|
response = qtest_qmpv(s, fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
return response;
|
|
|
|
}
|
|
|
|
|
2015-04-28 21:27:51 +02:00
|
|
|
void qtest_async_qmp(QTestState *s, const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
va_start(ap, fmt);
|
|
|
|
qtest_async_qmpv(s, fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
}
|
|
|
|
|
2013-10-30 14:54:33 +01:00
|
|
|
void qtest_qmpv_discard_response(QTestState *s, const char *fmt, va_list ap)
|
|
|
|
{
|
|
|
|
QDict *response = qtest_qmpv(s, fmt, ap);
|
|
|
|
QDECREF(response);
|
2012-04-26 19:07:55 +02:00
|
|
|
}
|
|
|
|
|
2013-10-30 14:54:32 +01:00
|
|
|
void qtest_qmp_discard_response(QTestState *s, const char *fmt, ...)
|
2013-02-16 22:44:02 +01:00
|
|
|
{
|
|
|
|
va_list ap;
|
2013-10-30 14:54:33 +01:00
|
|
|
QDict *response;
|
2013-02-16 22:44:02 +01:00
|
|
|
|
|
|
|
va_start(ap, fmt);
|
2013-10-30 14:54:33 +01:00
|
|
|
response = qtest_qmpv(s, fmt, ap);
|
2013-02-16 22:44:02 +01:00
|
|
|
va_end(ap);
|
2013-10-30 14:54:33 +01:00
|
|
|
QDECREF(response);
|
2013-02-16 22:44:02 +01:00
|
|
|
}
|
|
|
|
|
2016-11-14 17:15:54 +01:00
|
|
|
QDict *qtest_qmp_eventwait_ref(QTestState *s, const char *event)
|
2015-04-28 21:27:51 +02:00
|
|
|
{
|
|
|
|
QDict *response;
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
response = qtest_qmp_receive(s);
|
|
|
|
if ((qdict_haskey(response, "event")) &&
|
|
|
|
(strcmp(qdict_get_str(response, "event"), event) == 0)) {
|
2016-11-14 17:15:54 +01:00
|
|
|
return response;
|
2015-04-28 21:27:51 +02:00
|
|
|
}
|
|
|
|
QDECREF(response);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-14 17:15:54 +01:00
|
|
|
void qtest_qmp_eventwait(QTestState *s, const char *event)
|
|
|
|
{
|
|
|
|
QDict *response;
|
|
|
|
|
|
|
|
response = qtest_qmp_eventwait_ref(s, event);
|
|
|
|
QDECREF(response);
|
|
|
|
}
|
|
|
|
|
2015-10-01 10:59:55 +02:00
|
|
|
char *qtest_hmpv(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"));
|
2017-03-30 09:50:05 +02:00
|
|
|
while (ret == NULL && qdict_get_try_str(resp, "event")) {
|
|
|
|
/* Ignore asynchronous QMP events */
|
|
|
|
QDECREF(resp);
|
|
|
|
resp = qtest_qmp_receive(s);
|
|
|
|
ret = g_strdup(qdict_get_try_str(resp, "return"));
|
|
|
|
}
|
2015-10-01 10:59:55 +02:00
|
|
|
g_assert(ret);
|
|
|
|
QDECREF(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_hmpv(s, fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
return ret;
|
|
|
|
}
|
2015-04-28 21:27:51 +02:00
|
|
|
|
2012-03-28 15:42:05 +02:00
|
|
|
const char *qtest_get_arch(void)
|
|
|
|
{
|
2017-08-28 12:25:45 +02:00
|
|
|
const char *qemu = qtest_qemu_binary();
|
2012-03-28 15:42:05 +02:00
|
|
|
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;
|
|
|
|
uint32_t value;
|
|
|
|
|
|
|
|
qtest_sendf(s, "%s 0x%x\n", cmd, addr);
|
|
|
|
args = qtest_rsp(s, 2);
|
|
|
|
value = strtoul(args[1], NULL, 0);
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2013-02-16 22:44:03 +01:00
|
|
|
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;
|
|
|
|
uint64_t value;
|
|
|
|
|
|
|
|
qtest_sendf(s, "%s 0x%" PRIx64 "\n", cmd, addr);
|
|
|
|
args = qtest_rsp(s, 2);
|
|
|
|
value = strtoull(args[1], NULL, 0);
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2012-03-28 15:42:05 +02:00
|
|
|
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;
|
|
|
|
|
2017-01-11 09:49:32 +01:00
|
|
|
if (!size) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-04-23 21:40:08 +02:00
|
|
|
qtest_sendf(s, "read 0x%" PRIx64 " 0x%zx\n", addr, size);
|
2012-03-28 15:42:05 +02:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2016-09-13 14:52:45 +02:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2015-12-02 21:20:33 +01:00
|
|
|
void qtest_add_func(const char *str, void (*fn)(void))
|
2012-03-28 15:42:05 +02:00
|
|
|
{
|
|
|
|
gchar *path = g_strdup_printf("/%s/%s", qtest_get_arch(), str);
|
|
|
|
g_test_add_func(path, fn);
|
2014-08-04 23:11:22 +02:00
|
|
|
g_free(path);
|
2012-03-28 15:42:05 +02:00
|
|
|
}
|
|
|
|
|
2016-07-19 13:42:01 +02:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2015-12-02 21:20:33 +01:00
|
|
|
void qtest_add_data_func(const char *str, const void *data,
|
|
|
|
void (*fn)(const void *))
|
2015-03-24 19:33:34 +01:00
|
|
|
{
|
|
|
|
gchar *path = g_strdup_printf("/%s/%s", qtest_get_arch(), str);
|
|
|
|
g_test_add_data_func(path, data, fn);
|
|
|
|
g_free(path);
|
|
|
|
}
|
|
|
|
|
2015-05-22 20:13:44 +02:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2012-03-28 15:42:05 +02:00
|
|
|
void qtest_memwrite(QTestState *s, uint64_t addr, const void *data, size_t size)
|
|
|
|
{
|
|
|
|
const uint8_t *ptr = data;
|
|
|
|
size_t i;
|
2017-01-11 09:49:32 +01:00
|
|
|
char *enc;
|
|
|
|
|
|
|
|
if (!size) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
enc = g_malloc(2 * size + 1);
|
2012-03-28 15:42:05 +02:00
|
|
|
|
|
|
|
for (i = 0; i < size; i++) {
|
2015-05-22 20:13:44 +02:00
|
|
|
sprintf(&enc[i * 2], "%02x", ptr[i]);
|
2012-03-28 15:42:05 +02:00
|
|
|
}
|
2015-05-22 20:13:44 +02:00
|
|
|
|
|
|
|
qtest_sendf(s, "write 0x%" PRIx64 " 0x%zx 0x%s\n", addr, size, enc);
|
2012-03-28 15:42:05 +02:00
|
|
|
qtest_rsp(s, 0);
|
2015-05-22 20:13:44 +02:00
|
|
|
g_free(enc);
|
2012-03-28 15:42:05 +02:00
|
|
|
}
|
2014-03-13 12:24:15 +01:00
|
|
|
|
2014-08-04 23:11:20 +02:00
|
|
|
void qtest_memset(QTestState *s, uint64_t addr, uint8_t pattern, size_t size)
|
|
|
|
{
|
2015-05-22 20:13:44 +02:00
|
|
|
qtest_sendf(s, "memset 0x%" PRIx64 " 0x%zx 0x%02x\n", addr, size, pattern);
|
2014-08-04 23:11:20 +02:00
|
|
|
qtest_rsp(s, 0);
|
|
|
|
}
|
|
|
|
|
2014-03-13 12:24:15 +01:00
|
|
|
QDict *qmp(const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
QDict *response;
|
|
|
|
|
|
|
|
va_start(ap, fmt);
|
|
|
|
response = qtest_qmpv(global_qtest, fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
return response;
|
|
|
|
}
|
|
|
|
|
2015-04-28 21:27:51 +02:00
|
|
|
void qmp_async(const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
va_start(ap, fmt);
|
|
|
|
qtest_async_qmpv(global_qtest, fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
}
|
|
|
|
|
2014-03-13 12:24:15 +01:00
|
|
|
void qmp_discard_response(const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
va_start(ap, fmt);
|
|
|
|
qtest_qmpv_discard_response(global_qtest, fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
}
|
2015-10-01 10:59:55 +02:00
|
|
|
char *hmp(const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
char *ret;
|
|
|
|
|
|
|
|
va_start(ap, fmt);
|
|
|
|
ret = qtest_hmpv(global_qtest, fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
return ret;
|
|
|
|
}
|
2014-09-01 12:07:55 +02:00
|
|
|
|
2016-10-07 12:14:27 +02:00
|
|
|
bool qtest_big_endian(QTestState *s)
|
2014-09-01 12:07:55 +02:00
|
|
|
{
|
2016-10-07 12:14:27 +02:00
|
|
|
return s->big_endian;
|
2014-09-01 12:07:55 +02:00
|
|
|
}
|
2017-03-30 09:50:06 +02:00
|
|
|
|
|
|
|
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();
|
|
|
|
QDECREF(response);
|
|
|
|
}
|
2017-08-15 08:58:54 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
* 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 *response;
|
|
|
|
char *cmd, *opts = NULL;
|
|
|
|
va_list va;
|
|
|
|
|
|
|
|
if (fmt) {
|
|
|
|
va_start(va, fmt);
|
|
|
|
opts = g_strdup_vprintf(fmt, va);
|
|
|
|
va_end(va);
|
|
|
|
}
|
|
|
|
|
|
|
|
cmd = g_strdup_printf("{'execute': 'device_add',"
|
|
|
|
" 'arguments': { 'driver': '%s', 'id': '%s'%s%s }}",
|
|
|
|
driver, id, opts ? ", " : "", opts ? opts : "");
|
|
|
|
g_free(opts);
|
|
|
|
|
|
|
|
response = qmp(cmd);
|
|
|
|
g_free(cmd);
|
|
|
|
g_assert(response);
|
|
|
|
g_assert(!qdict_haskey(response, "event")); /* We don't expect any events */
|
|
|
|
g_assert(!qdict_haskey(response, "error"));
|
|
|
|
QDECREF(response);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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)
|
|
|
|
{
|
|
|
|
QDict *response1, *response2, *event = NULL;
|
|
|
|
char *cmd;
|
|
|
|
|
|
|
|
cmd = g_strdup_printf("{'execute': 'device_del',"
|
|
|
|
" 'arguments': { 'id': '%s' }}", id);
|
|
|
|
response1 = qmp(cmd);
|
|
|
|
g_free(cmd);
|
|
|
|
g_assert(response1);
|
|
|
|
g_assert(!qdict_haskey(response1, "error"));
|
|
|
|
|
|
|
|
response2 = qmp("");
|
|
|
|
g_assert(response2);
|
|
|
|
g_assert(!qdict_haskey(response2, "error"));
|
|
|
|
|
|
|
|
if (qdict_haskey(response1, "event")) {
|
|
|
|
event = response1;
|
|
|
|
} else if (qdict_haskey(response2, "event")) {
|
|
|
|
event = response2;
|
|
|
|
}
|
|
|
|
g_assert(event);
|
|
|
|
g_assert_cmpstr(qdict_get_str(event, "event"), ==, "DEVICE_DELETED");
|
|
|
|
|
|
|
|
QDECREF(response1);
|
|
|
|
QDECREF(response2);
|
|
|
|
}
|