2012-03-28 15:42:02 +02:00
|
|
|
/*
|
|
|
|
* Test Server
|
|
|
|
*
|
|
|
|
* Copyright IBM, Corp. 2011
|
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Anthony Liguori <aliguori@us.ibm.com>
|
|
|
|
*
|
|
|
|
* This work is licensed under the terms of the GNU GPL, version 2 or later.
|
|
|
|
* See the COPYING file in the top-level directory.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2016-01-29 18:50:05 +01:00
|
|
|
#include "qemu/osdep.h"
|
include/qemu/osdep.h: Don't include qapi/error.h
Commit 57cb38b included qapi/error.h into qemu/osdep.h to get the
Error typedef. Since then, we've moved to include qemu/osdep.h
everywhere. Its file comment explains: "To avoid getting into
possible circular include dependencies, this file should not include
any other QEMU headers, with the exceptions of config-host.h,
compiler.h, os-posix.h and os-win32.h, all of which are doing a
similar job to this file and are under similar constraints."
qapi/error.h doesn't do a similar job, and it doesn't adhere to
similar constraints: it includes qapi-types.h. That's in excess of
100KiB of crap most .c files don't actually need.
Add the typedef to qemu/typedefs.h, and include that instead of
qapi/error.h. Include qapi/error.h in .c files that need it and don't
get it now. Include qapi-types.h in qom/object.h for uint16List.
Update scripts/clean-includes accordingly. Update it further to match
reality: replace config.h by config-target.h, add sysemu/os-posix.h,
sysemu/os-win32.h. Update the list of includes in the qemu/osdep.h
comment quoted above similarly.
This reduces the number of objects depending on qapi/error.h from "all
of them" to less than a third. Unfortunately, the number depending on
qapi-types.h shrinks only a little. More work is needed for that one.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
[Fix compilation without the spice devel packages. - Paolo]
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2016-03-14 09:01:28 +01:00
|
|
|
#include "qapi/error.h"
|
2016-03-15 16:58:45 +01:00
|
|
|
#include "qemu-common.h"
|
|
|
|
#include "cpu.h"
|
2012-12-17 18:20:04 +01:00
|
|
|
#include "sysemu/qtest.h"
|
2012-03-28 15:42:03 +02:00
|
|
|
#include "hw/qdev.h"
|
2017-01-26 15:26:44 +01:00
|
|
|
#include "chardev/char-fe.h"
|
2012-12-17 18:19:49 +01:00
|
|
|
#include "exec/ioport.h"
|
|
|
|
#include "exec/memory.h"
|
2012-03-28 15:42:02 +02:00
|
|
|
#include "hw/irq.h"
|
2014-09-26 22:45:26 +02:00
|
|
|
#include "sysemu/accel.h"
|
2012-12-17 18:20:04 +01:00
|
|
|
#include "sysemu/sysemu.h"
|
|
|
|
#include "sysemu/cpus.h"
|
2014-07-25 11:56:28 +02:00
|
|
|
#include "qemu/config-file.h"
|
|
|
|
#include "qemu/option.h"
|
|
|
|
#include "qemu/error-report.h"
|
2016-09-13 14:52:43 +02:00
|
|
|
#include "qemu/cutils.h"
|
2016-09-13 14:52:45 +02:00
|
|
|
#ifdef TARGET_PPC64
|
|
|
|
#include "hw/ppc/spapr_rtas.h"
|
|
|
|
#endif
|
2012-03-28 15:42:02 +02:00
|
|
|
|
|
|
|
#define MAX_IRQ 256
|
|
|
|
|
2013-01-24 06:03:27 +01:00
|
|
|
bool qtest_allowed;
|
2012-03-28 15:42:02 +02:00
|
|
|
|
2012-03-28 15:42:03 +02:00
|
|
|
static DeviceState *irq_intercept_dev;
|
2012-03-28 15:42:02 +02:00
|
|
|
static FILE *qtest_log_fp;
|
2016-10-22 11:52:52 +02:00
|
|
|
static CharBackend qtest_chr;
|
2012-03-28 15:42:02 +02:00
|
|
|
static GString *inbuf;
|
|
|
|
static int irq_levels[MAX_IRQ];
|
2012-03-30 21:04:04 +02:00
|
|
|
static qemu_timeval start_time;
|
2012-03-28 15:42:02 +02:00
|
|
|
static bool qtest_opened;
|
|
|
|
|
2012-03-30 19:53:54 +02:00
|
|
|
#define FMT_timeval "%ld.%06ld"
|
2012-03-28 15:42:02 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* QTest Protocol
|
|
|
|
*
|
|
|
|
* Line based protocol, request/response based. Server can send async messages
|
|
|
|
* so clients should always handle many async messages before the response
|
|
|
|
* comes in.
|
|
|
|
*
|
|
|
|
* Valid requests
|
|
|
|
*
|
2012-03-28 15:42:04 +02:00
|
|
|
* Clock management:
|
|
|
|
*
|
2013-08-21 17:03:08 +02:00
|
|
|
* The qtest client is completely in charge of the QEMU_CLOCK_VIRTUAL. qtest commands
|
2012-03-28 15:42:04 +02:00
|
|
|
* let you adjust the value of the clock (monotonically). All the commands
|
|
|
|
* return the current value of the clock in nanoseconds.
|
|
|
|
*
|
|
|
|
* > clock_step
|
|
|
|
* < OK VALUE
|
|
|
|
*
|
|
|
|
* Advance the clock to the next deadline. Useful when waiting for
|
|
|
|
* asynchronous events.
|
|
|
|
*
|
|
|
|
* > clock_step NS
|
|
|
|
* < OK VALUE
|
|
|
|
*
|
|
|
|
* Advance the clock by NS nanoseconds.
|
|
|
|
*
|
|
|
|
* > clock_set NS
|
|
|
|
* < OK VALUE
|
|
|
|
*
|
|
|
|
* Advance the clock to NS nanoseconds (do nothing if it's already past).
|
|
|
|
*
|
|
|
|
* PIO and memory access:
|
|
|
|
*
|
2012-03-28 15:42:02 +02:00
|
|
|
* > outb ADDR VALUE
|
|
|
|
* < OK
|
|
|
|
*
|
|
|
|
* > outw ADDR VALUE
|
|
|
|
* < OK
|
|
|
|
*
|
|
|
|
* > outl ADDR VALUE
|
|
|
|
* < OK
|
|
|
|
*
|
|
|
|
* > inb ADDR
|
|
|
|
* < OK VALUE
|
|
|
|
*
|
|
|
|
* > inw ADDR
|
|
|
|
* < OK VALUE
|
|
|
|
*
|
|
|
|
* > inl ADDR
|
|
|
|
* < OK VALUE
|
|
|
|
*
|
2013-02-16 22:44:03 +01:00
|
|
|
* > writeb ADDR VALUE
|
|
|
|
* < OK
|
|
|
|
*
|
|
|
|
* > writew ADDR VALUE
|
|
|
|
* < OK
|
|
|
|
*
|
|
|
|
* > writel ADDR VALUE
|
|
|
|
* < OK
|
|
|
|
*
|
|
|
|
* > writeq ADDR VALUE
|
|
|
|
* < OK
|
|
|
|
*
|
|
|
|
* > readb ADDR
|
|
|
|
* < OK VALUE
|
|
|
|
*
|
|
|
|
* > readw ADDR
|
|
|
|
* < OK VALUE
|
|
|
|
*
|
|
|
|
* > readl ADDR
|
|
|
|
* < OK VALUE
|
|
|
|
*
|
|
|
|
* > readq ADDR
|
|
|
|
* < OK VALUE
|
|
|
|
*
|
2012-03-28 15:42:02 +02:00
|
|
|
* > read ADDR SIZE
|
|
|
|
* < OK DATA
|
|
|
|
*
|
|
|
|
* > write ADDR SIZE DATA
|
|
|
|
* < OK
|
|
|
|
*
|
2015-05-22 20:13:44 +02:00
|
|
|
* > b64read ADDR SIZE
|
|
|
|
* < OK B64_DATA
|
|
|
|
*
|
|
|
|
* > b64write ADDR SIZE B64_DATA
|
|
|
|
* < OK
|
|
|
|
*
|
2015-05-22 20:13:44 +02:00
|
|
|
* > memset ADDR SIZE VALUE
|
|
|
|
* < OK
|
|
|
|
*
|
2012-03-28 15:42:02 +02:00
|
|
|
* ADDR, SIZE, VALUE are all integers parsed with strtoul() with a base of 0.
|
2016-08-05 12:43:20 +02:00
|
|
|
* For 'memset' a zero size is permitted and does nothing.
|
2012-03-28 15:42:02 +02:00
|
|
|
*
|
|
|
|
* DATA is an arbitrarily long hex number prefixed with '0x'. If it's smaller
|
|
|
|
* than the expected size, the value will be zero filled at the end of the data
|
|
|
|
* sequence.
|
|
|
|
*
|
2015-05-22 20:13:44 +02:00
|
|
|
* B64_DATA is an arbitrarily long base64 encoded string.
|
|
|
|
* If the sizes do not match, the data will be truncated.
|
|
|
|
*
|
2012-03-28 15:42:03 +02:00
|
|
|
* IRQ management:
|
|
|
|
*
|
|
|
|
* > irq_intercept_in QOM-PATH
|
|
|
|
* < OK
|
|
|
|
*
|
|
|
|
* > irq_intercept_out QOM-PATH
|
|
|
|
* < OK
|
|
|
|
*
|
|
|
|
* Attach to the gpio-in (resp. gpio-out) pins exported by the device at
|
|
|
|
* QOM-PATH. When the pin is triggered, one of the following async messages
|
|
|
|
* will be printed to the qtest stream:
|
|
|
|
*
|
|
|
|
* IRQ raise NUM
|
|
|
|
* IRQ lower NUM
|
|
|
|
*
|
|
|
|
* where NUM is an IRQ number. For the PC, interrupts can be intercepted
|
|
|
|
* simply with "irq_intercept_in ioapic" (note that IRQ0 comes out with
|
|
|
|
* NUM=0 even though it is remapped to GSI 2).
|
2012-03-28 15:42:02 +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') {
|
2014-05-27 14:15:20 +02:00
|
|
|
return 10 + (ch - 'A');
|
2012-03-28 15:42:02 +02:00
|
|
|
} else {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-03-30 21:04:04 +02:00
|
|
|
static void qtest_get_time(qemu_timeval *tv)
|
2012-03-28 15:42:02 +02:00
|
|
|
{
|
2012-03-30 21:04:04 +02:00
|
|
|
qemu_gettimeofday(tv);
|
2012-03-28 15:42:02 +02:00
|
|
|
tv->tv_sec -= start_time.tv_sec;
|
|
|
|
tv->tv_usec -= start_time.tv_usec;
|
|
|
|
if (tv->tv_usec < 0) {
|
|
|
|
tv->tv_usec += 1000000;
|
|
|
|
tv->tv_sec -= 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-22 11:52:55 +02:00
|
|
|
static void qtest_send_prefix(CharBackend *chr)
|
2012-03-28 15:42:02 +02:00
|
|
|
{
|
2012-03-30 21:04:04 +02:00
|
|
|
qemu_timeval tv;
|
2012-03-28 15:42:02 +02:00
|
|
|
|
|
|
|
if (!qtest_log_fp || !qtest_opened) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
qtest_get_time(&tv);
|
|
|
|
fprintf(qtest_log_fp, "[S +" FMT_timeval "] ",
|
2013-08-20 22:53:25 +02:00
|
|
|
(long) tv.tv_sec, (long) tv.tv_usec);
|
2012-03-28 15:42:02 +02:00
|
|
|
}
|
|
|
|
|
2015-05-22 20:13:44 +02:00
|
|
|
static void GCC_FMT_ATTR(1, 2) qtest_log_send(const char *fmt, ...)
|
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
|
|
|
|
if (!qtest_log_fp || !qtest_opened) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
qtest_send_prefix(NULL);
|
|
|
|
|
|
|
|
va_start(ap, fmt);
|
|
|
|
vfprintf(qtest_log_fp, fmt, ap);
|
|
|
|
va_end(ap);
|
|
|
|
}
|
|
|
|
|
2016-10-22 11:52:55 +02:00
|
|
|
static void do_qtest_send(CharBackend *chr, const char *str, size_t len)
|
2015-05-22 20:13:43 +02:00
|
|
|
{
|
|
|
|
qemu_chr_fe_write_all(chr, (uint8_t *)str, len);
|
|
|
|
if (qtest_log_fp && qtest_opened) {
|
|
|
|
fprintf(qtest_log_fp, "%s", str);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-22 11:52:55 +02:00
|
|
|
static void qtest_send(CharBackend *chr, const char *str)
|
2015-05-22 20:13:43 +02:00
|
|
|
{
|
|
|
|
do_qtest_send(chr, str, strlen(str));
|
|
|
|
}
|
|
|
|
|
2016-10-22 11:52:55 +02:00
|
|
|
static void GCC_FMT_ATTR(2, 3) qtest_sendf(CharBackend *chr,
|
2015-05-22 20:13:43 +02:00
|
|
|
const char *fmt, ...)
|
2012-03-28 15:42:02 +02:00
|
|
|
{
|
|
|
|
va_list ap;
|
2015-05-22 20:13:43 +02:00
|
|
|
gchar *buffer;
|
2012-03-28 15:42:02 +02:00
|
|
|
|
|
|
|
va_start(ap, fmt);
|
2015-05-22 20:13:43 +02:00
|
|
|
buffer = g_strdup_vprintf(fmt, ap);
|
|
|
|
qtest_send(chr, buffer);
|
2016-11-10 09:25:00 +01:00
|
|
|
g_free(buffer);
|
2012-03-28 15:42:02 +02:00
|
|
|
va_end(ap);
|
|
|
|
}
|
|
|
|
|
2012-03-28 15:42:03 +02:00
|
|
|
static void qtest_irq_handler(void *opaque, int n, int level)
|
|
|
|
{
|
2014-09-26 07:21:31 +02:00
|
|
|
qemu_irq old_irq = *(qemu_irq *)opaque;
|
|
|
|
qemu_set_irq(old_irq, level);
|
2012-03-28 15:42:03 +02:00
|
|
|
|
|
|
|
if (irq_levels[n] != level) {
|
2016-10-22 11:52:55 +02:00
|
|
|
CharBackend *chr = &qtest_chr;
|
2012-03-28 15:42:03 +02:00
|
|
|
irq_levels[n] = level;
|
|
|
|
qtest_send_prefix(chr);
|
2015-05-22 20:13:43 +02:00
|
|
|
qtest_sendf(chr, "IRQ %s %d\n",
|
|
|
|
level ? "raise" : "lower", n);
|
2012-03-28 15:42:03 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-22 11:52:55 +02:00
|
|
|
static void qtest_process_command(CharBackend *chr, gchar **words)
|
2012-03-28 15:42:02 +02:00
|
|
|
{
|
|
|
|
const gchar *command;
|
|
|
|
|
|
|
|
g_assert(words);
|
|
|
|
|
|
|
|
command = words[0];
|
|
|
|
|
|
|
|
if (qtest_log_fp) {
|
2012-03-30 21:04:04 +02:00
|
|
|
qemu_timeval tv;
|
2012-03-28 15:42:02 +02:00
|
|
|
int i;
|
|
|
|
|
|
|
|
qtest_get_time(&tv);
|
|
|
|
fprintf(qtest_log_fp, "[R +" FMT_timeval "]",
|
2013-08-20 22:53:25 +02:00
|
|
|
(long) tv.tv_sec, (long) tv.tv_usec);
|
2012-03-28 15:42:02 +02:00
|
|
|
for (i = 0; words[i]; i++) {
|
|
|
|
fprintf(qtest_log_fp, " %s", words[i]);
|
|
|
|
}
|
|
|
|
fprintf(qtest_log_fp, "\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
g_assert(command);
|
2012-03-28 15:42:03 +02:00
|
|
|
if (strcmp(words[0], "irq_intercept_out") == 0
|
|
|
|
|| strcmp(words[0], "irq_intercept_in") == 0) {
|
2014-05-20 08:30:58 +02:00
|
|
|
DeviceState *dev;
|
|
|
|
NamedGPIOList *ngl;
|
2012-03-28 15:42:03 +02:00
|
|
|
|
|
|
|
g_assert(words[1]);
|
|
|
|
dev = DEVICE(object_resolve_path(words[1], NULL));
|
|
|
|
if (!dev) {
|
|
|
|
qtest_send_prefix(chr);
|
|
|
|
qtest_send(chr, "FAIL Unknown device\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (irq_intercept_dev) {
|
|
|
|
qtest_send_prefix(chr);
|
|
|
|
if (irq_intercept_dev != dev) {
|
|
|
|
qtest_send(chr, "FAIL IRQ intercept already enabled\n");
|
|
|
|
} else {
|
|
|
|
qtest_send(chr, "OK\n");
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-05-20 08:30:58 +02:00
|
|
|
QLIST_FOREACH(ngl, &dev->gpios, node) {
|
|
|
|
/* We don't support intercept of named GPIOs yet */
|
|
|
|
if (ngl->name) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (words[0][14] == 'o') {
|
2014-09-26 07:21:31 +02:00
|
|
|
int i;
|
|
|
|
for (i = 0; i < ngl->num_out; ++i) {
|
|
|
|
qemu_irq *disconnected = g_new0(qemu_irq, 1);
|
|
|
|
qemu_irq icpt = qemu_allocate_irq(qtest_irq_handler,
|
|
|
|
disconnected, i);
|
|
|
|
|
|
|
|
*disconnected = qdev_intercept_gpio_out(dev, icpt,
|
|
|
|
ngl->name, i);
|
|
|
|
}
|
2014-05-20 08:30:58 +02:00
|
|
|
} else {
|
|
|
|
qemu_irq_intercept_in(ngl->in, qtest_irq_handler,
|
|
|
|
ngl->num_in);
|
|
|
|
}
|
2012-03-28 15:42:03 +02:00
|
|
|
}
|
|
|
|
irq_intercept_dev = dev;
|
|
|
|
qtest_send_prefix(chr);
|
|
|
|
qtest_send(chr, "OK\n");
|
|
|
|
|
|
|
|
} else if (strcmp(words[0], "outb") == 0 ||
|
|
|
|
strcmp(words[0], "outw") == 0 ||
|
|
|
|
strcmp(words[0], "outl") == 0) {
|
2016-09-13 14:52:43 +02:00
|
|
|
unsigned long addr;
|
|
|
|
unsigned long value;
|
2017-09-11 19:19:46 +02:00
|
|
|
int ret;
|
2012-03-28 15:42:02 +02:00
|
|
|
|
|
|
|
g_assert(words[1] && words[2]);
|
2017-09-11 19:19:46 +02:00
|
|
|
ret = qemu_strtoul(words[1], NULL, 0, &addr);
|
|
|
|
g_assert(ret == 0);
|
|
|
|
ret = qemu_strtoul(words[2], NULL, 0, &value);
|
|
|
|
g_assert(ret == 0);
|
2016-09-13 14:52:43 +02:00
|
|
|
g_assert(addr <= 0xffff);
|
2012-03-28 15:42:02 +02:00
|
|
|
|
|
|
|
if (words[0][3] == 'b') {
|
|
|
|
cpu_outb(addr, value);
|
|
|
|
} else if (words[0][3] == 'w') {
|
|
|
|
cpu_outw(addr, value);
|
|
|
|
} else if (words[0][3] == 'l') {
|
|
|
|
cpu_outl(addr, value);
|
|
|
|
}
|
|
|
|
qtest_send_prefix(chr);
|
|
|
|
qtest_send(chr, "OK\n");
|
|
|
|
} else if (strcmp(words[0], "inb") == 0 ||
|
|
|
|
strcmp(words[0], "inw") == 0 ||
|
|
|
|
strcmp(words[0], "inl") == 0) {
|
2016-09-13 14:52:43 +02:00
|
|
|
unsigned long addr;
|
2012-03-28 15:42:02 +02:00
|
|
|
uint32_t value = -1U;
|
2017-09-11 19:19:46 +02:00
|
|
|
int ret;
|
2012-03-28 15:42:02 +02:00
|
|
|
|
|
|
|
g_assert(words[1]);
|
2017-09-11 19:19:46 +02:00
|
|
|
ret = qemu_strtoul(words[1], NULL, 0, &addr);
|
|
|
|
g_assert(ret == 0);
|
2016-09-13 14:52:43 +02:00
|
|
|
g_assert(addr <= 0xffff);
|
2012-03-28 15:42:02 +02:00
|
|
|
|
|
|
|
if (words[0][2] == 'b') {
|
|
|
|
value = cpu_inb(addr);
|
|
|
|
} else if (words[0][2] == 'w') {
|
|
|
|
value = cpu_inw(addr);
|
|
|
|
} else if (words[0][2] == 'l') {
|
|
|
|
value = cpu_inl(addr);
|
|
|
|
}
|
|
|
|
qtest_send_prefix(chr);
|
2015-05-22 20:13:43 +02:00
|
|
|
qtest_sendf(chr, "OK 0x%04x\n", value);
|
2013-02-16 22:44:03 +01:00
|
|
|
} else if (strcmp(words[0], "writeb") == 0 ||
|
|
|
|
strcmp(words[0], "writew") == 0 ||
|
|
|
|
strcmp(words[0], "writel") == 0 ||
|
|
|
|
strcmp(words[0], "writeq") == 0) {
|
|
|
|
uint64_t addr;
|
|
|
|
uint64_t value;
|
2017-09-11 19:19:46 +02:00
|
|
|
int ret;
|
2013-02-16 22:44:03 +01:00
|
|
|
|
|
|
|
g_assert(words[1] && words[2]);
|
2017-09-11 19:19:46 +02:00
|
|
|
ret = qemu_strtou64(words[1], NULL, 0, &addr);
|
|
|
|
g_assert(ret == 0);
|
|
|
|
ret = qemu_strtou64(words[2], NULL, 0, &value);
|
|
|
|
g_assert(ret == 0);
|
2013-02-16 22:44:03 +01:00
|
|
|
|
|
|
|
if (words[0][5] == 'b') {
|
|
|
|
uint8_t data = value;
|
|
|
|
cpu_physical_memory_write(addr, &data, 1);
|
|
|
|
} else if (words[0][5] == 'w') {
|
|
|
|
uint16_t data = value;
|
|
|
|
tswap16s(&data);
|
|
|
|
cpu_physical_memory_write(addr, &data, 2);
|
|
|
|
} else if (words[0][5] == 'l') {
|
|
|
|
uint32_t data = value;
|
|
|
|
tswap32s(&data);
|
|
|
|
cpu_physical_memory_write(addr, &data, 4);
|
|
|
|
} else if (words[0][5] == 'q') {
|
|
|
|
uint64_t data = value;
|
|
|
|
tswap64s(&data);
|
|
|
|
cpu_physical_memory_write(addr, &data, 8);
|
|
|
|
}
|
|
|
|
qtest_send_prefix(chr);
|
|
|
|
qtest_send(chr, "OK\n");
|
|
|
|
} else if (strcmp(words[0], "readb") == 0 ||
|
|
|
|
strcmp(words[0], "readw") == 0 ||
|
|
|
|
strcmp(words[0], "readl") == 0 ||
|
|
|
|
strcmp(words[0], "readq") == 0) {
|
|
|
|
uint64_t addr;
|
|
|
|
uint64_t value = UINT64_C(-1);
|
2017-09-11 19:19:46 +02:00
|
|
|
int ret;
|
2013-02-16 22:44:03 +01:00
|
|
|
|
|
|
|
g_assert(words[1]);
|
2017-09-11 19:19:46 +02:00
|
|
|
ret = qemu_strtou64(words[1], NULL, 0, &addr);
|
|
|
|
g_assert(ret == 0);
|
2013-02-16 22:44:03 +01:00
|
|
|
|
|
|
|
if (words[0][4] == 'b') {
|
|
|
|
uint8_t data;
|
|
|
|
cpu_physical_memory_read(addr, &data, 1);
|
|
|
|
value = data;
|
|
|
|
} else if (words[0][4] == 'w') {
|
|
|
|
uint16_t data;
|
|
|
|
cpu_physical_memory_read(addr, &data, 2);
|
|
|
|
value = tswap16(data);
|
|
|
|
} else if (words[0][4] == 'l') {
|
|
|
|
uint32_t data;
|
|
|
|
cpu_physical_memory_read(addr, &data, 4);
|
|
|
|
value = tswap32(data);
|
|
|
|
} else if (words[0][4] == 'q') {
|
|
|
|
cpu_physical_memory_read(addr, &value, 8);
|
|
|
|
tswap64s(&value);
|
|
|
|
}
|
|
|
|
qtest_send_prefix(chr);
|
2015-05-22 20:13:43 +02:00
|
|
|
qtest_sendf(chr, "OK 0x%016" PRIx64 "\n", value);
|
2012-03-28 15:42:02 +02:00
|
|
|
} else if (strcmp(words[0], "read") == 0) {
|
|
|
|
uint64_t addr, len, i;
|
|
|
|
uint8_t *data;
|
2015-05-22 20:13:44 +02:00
|
|
|
char *enc;
|
2017-09-11 19:19:46 +02:00
|
|
|
int ret;
|
2012-03-28 15:42:02 +02:00
|
|
|
|
|
|
|
g_assert(words[1] && words[2]);
|
2017-09-11 19:19:46 +02:00
|
|
|
ret = qemu_strtou64(words[1], NULL, 0, &addr);
|
|
|
|
g_assert(ret == 0);
|
|
|
|
ret = qemu_strtou64(words[2], NULL, 0, &len);
|
|
|
|
g_assert(ret == 0);
|
2017-01-11 09:49:32 +01:00
|
|
|
/* We'd send garbage to libqtest if len is 0 */
|
|
|
|
g_assert(len);
|
2012-03-28 15:42:02 +02:00
|
|
|
|
|
|
|
data = g_malloc(len);
|
|
|
|
cpu_physical_memory_read(addr, data, len);
|
|
|
|
|
2015-05-22 20:13:44 +02:00
|
|
|
enc = g_malloc(2 * len + 1);
|
2012-03-28 15:42:02 +02:00
|
|
|
for (i = 0; i < len; i++) {
|
2015-05-22 20:13:44 +02:00
|
|
|
sprintf(&enc[i * 2], "%02x", data[i]);
|
2012-03-28 15:42:02 +02:00
|
|
|
}
|
2015-05-22 20:13:44 +02:00
|
|
|
|
|
|
|
qtest_send_prefix(chr);
|
|
|
|
qtest_sendf(chr, "OK 0x%s\n", enc);
|
2012-03-28 15:42:02 +02:00
|
|
|
|
|
|
|
g_free(data);
|
2015-05-22 20:13:44 +02:00
|
|
|
g_free(enc);
|
2015-05-22 20:13:44 +02:00
|
|
|
} else if (strcmp(words[0], "b64read") == 0) {
|
|
|
|
uint64_t addr, len;
|
|
|
|
uint8_t *data;
|
|
|
|
gchar *b64_data;
|
2017-09-11 19:19:46 +02:00
|
|
|
int ret;
|
2015-05-22 20:13:44 +02:00
|
|
|
|
|
|
|
g_assert(words[1] && words[2]);
|
2017-09-11 19:19:46 +02:00
|
|
|
ret = qemu_strtou64(words[1], NULL, 0, &addr);
|
|
|
|
g_assert(ret == 0);
|
|
|
|
ret = qemu_strtou64(words[2], NULL, 0, &len);
|
|
|
|
g_assert(ret == 0);
|
2015-05-22 20:13:44 +02:00
|
|
|
|
|
|
|
data = g_malloc(len);
|
|
|
|
cpu_physical_memory_read(addr, data, len);
|
|
|
|
b64_data = g_base64_encode(data, len);
|
|
|
|
qtest_send_prefix(chr);
|
|
|
|
qtest_sendf(chr, "OK %s\n", b64_data);
|
|
|
|
|
|
|
|
g_free(data);
|
|
|
|
g_free(b64_data);
|
2012-03-28 15:42:02 +02:00
|
|
|
} else if (strcmp(words[0], "write") == 0) {
|
|
|
|
uint64_t addr, len, i;
|
|
|
|
uint8_t *data;
|
|
|
|
size_t data_len;
|
2017-09-11 19:19:46 +02:00
|
|
|
int ret;
|
2012-03-28 15:42:02 +02:00
|
|
|
|
|
|
|
g_assert(words[1] && words[2] && words[3]);
|
2017-09-11 19:19:46 +02:00
|
|
|
ret = qemu_strtou64(words[1], NULL, 0, &addr);
|
|
|
|
g_assert(ret == 0);
|
|
|
|
ret = qemu_strtou64(words[2], NULL, 0, &len);
|
|
|
|
g_assert(ret == 0);
|
2012-03-28 15:42:02 +02:00
|
|
|
|
|
|
|
data_len = strlen(words[3]);
|
|
|
|
if (data_len < 3) {
|
|
|
|
qtest_send(chr, "ERR invalid argument size\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
data = g_malloc(len);
|
|
|
|
for (i = 0; i < len; i++) {
|
|
|
|
if ((i * 2 + 4) <= data_len) {
|
|
|
|
data[i] = hex2nib(words[3][i * 2 + 2]) << 4;
|
|
|
|
data[i] |= hex2nib(words[3][i * 2 + 3]);
|
|
|
|
} else {
|
|
|
|
data[i] = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
cpu_physical_memory_write(addr, data, len);
|
|
|
|
g_free(data);
|
|
|
|
|
2015-05-22 20:13:44 +02:00
|
|
|
qtest_send_prefix(chr);
|
|
|
|
qtest_send(chr, "OK\n");
|
|
|
|
} else if (strcmp(words[0], "memset") == 0) {
|
|
|
|
uint64_t addr, len;
|
|
|
|
uint8_t *data;
|
2016-09-13 14:52:43 +02:00
|
|
|
unsigned long pattern;
|
2017-09-11 19:19:46 +02:00
|
|
|
int ret;
|
2015-05-22 20:13:44 +02:00
|
|
|
|
|
|
|
g_assert(words[1] && words[2] && words[3]);
|
2017-09-11 19:19:46 +02:00
|
|
|
ret = qemu_strtou64(words[1], NULL, 0, &addr);
|
|
|
|
g_assert(ret == 0);
|
|
|
|
ret = qemu_strtou64(words[2], NULL, 0, &len);
|
|
|
|
g_assert(ret == 0);
|
|
|
|
ret = qemu_strtoul(words[3], NULL, 0, &pattern);
|
|
|
|
g_assert(ret == 0);
|
2015-05-22 20:13:44 +02:00
|
|
|
|
2016-08-05 12:43:20 +02:00
|
|
|
if (len) {
|
|
|
|
data = g_malloc(len);
|
|
|
|
memset(data, pattern, len);
|
|
|
|
cpu_physical_memory_write(addr, data, len);
|
|
|
|
g_free(data);
|
|
|
|
}
|
2015-05-22 20:13:44 +02:00
|
|
|
|
2015-05-22 20:13:44 +02:00
|
|
|
qtest_send_prefix(chr);
|
|
|
|
qtest_send(chr, "OK\n");
|
|
|
|
} else if (strcmp(words[0], "b64write") == 0) {
|
|
|
|
uint64_t addr, len;
|
|
|
|
uint8_t *data;
|
|
|
|
size_t data_len;
|
|
|
|
gsize out_len;
|
2017-09-11 19:19:46 +02:00
|
|
|
int ret;
|
2015-05-22 20:13:44 +02:00
|
|
|
|
|
|
|
g_assert(words[1] && words[2] && words[3]);
|
2017-09-11 19:19:46 +02:00
|
|
|
ret = qemu_strtou64(words[1], NULL, 0, &addr);
|
|
|
|
g_assert(ret == 0);
|
|
|
|
ret = qemu_strtou64(words[2], NULL, 0, &len);
|
|
|
|
g_assert(ret == 0);
|
2015-05-22 20:13:44 +02:00
|
|
|
|
|
|
|
data_len = strlen(words[3]);
|
|
|
|
if (data_len < 3) {
|
|
|
|
qtest_send(chr, "ERR invalid argument size\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
data = g_base64_decode_inplace(words[3], &out_len);
|
|
|
|
if (out_len != len) {
|
|
|
|
qtest_log_send("b64write: data length mismatch (told %"PRIu64", "
|
|
|
|
"found %zu)\n",
|
|
|
|
len, out_len);
|
|
|
|
out_len = MIN(out_len, len);
|
|
|
|
}
|
|
|
|
|
|
|
|
cpu_physical_memory_write(addr, data, out_len);
|
|
|
|
|
2012-03-28 15:42:02 +02:00
|
|
|
qtest_send_prefix(chr);
|
|
|
|
qtest_send(chr, "OK\n");
|
2016-10-07 12:14:27 +02:00
|
|
|
} else if (strcmp(words[0], "endianness") == 0) {
|
|
|
|
qtest_send_prefix(chr);
|
|
|
|
#if defined(TARGET_WORDS_BIGENDIAN)
|
|
|
|
qtest_sendf(chr, "OK big\n");
|
|
|
|
#else
|
|
|
|
qtest_sendf(chr, "OK little\n");
|
|
|
|
#endif
|
2016-09-13 14:52:45 +02:00
|
|
|
#ifdef TARGET_PPC64
|
|
|
|
} else if (strcmp(words[0], "rtas") == 0) {
|
|
|
|
uint64_t res, args, ret;
|
|
|
|
unsigned long nargs, nret;
|
2017-09-11 19:19:46 +02:00
|
|
|
int rc;
|
|
|
|
|
|
|
|
rc = qemu_strtoul(words[2], NULL, 0, &nargs);
|
|
|
|
g_assert(rc == 0);
|
|
|
|
rc = qemu_strtou64(words[3], NULL, 0, &args);
|
|
|
|
g_assert(rc == 0);
|
|
|
|
rc = qemu_strtoul(words[4], NULL, 0, &nret);
|
|
|
|
g_assert(rc == 0);
|
|
|
|
rc = qemu_strtou64(words[5], NULL, 0, &ret);
|
|
|
|
g_assert(rc == 0);
|
2016-09-13 14:52:45 +02:00
|
|
|
res = qtest_rtas_call(words[1], nargs, args, nret, ret);
|
|
|
|
|
|
|
|
qtest_send_prefix(chr);
|
|
|
|
qtest_sendf(chr, "OK %"PRIu64"\n", res);
|
|
|
|
#endif
|
2013-10-18 13:51:11 +02:00
|
|
|
} else if (qtest_enabled() && strcmp(words[0], "clock_step") == 0) {
|
2012-03-28 15:42:04 +02:00
|
|
|
int64_t ns;
|
|
|
|
|
|
|
|
if (words[1]) {
|
2017-09-11 19:19:46 +02:00
|
|
|
int ret = qemu_strtoi64(words[1], NULL, 0, &ns);
|
|
|
|
g_assert(ret == 0);
|
2012-03-28 15:42:04 +02:00
|
|
|
} else {
|
2013-08-21 17:03:02 +02:00
|
|
|
ns = qemu_clock_deadline_ns_all(QEMU_CLOCK_VIRTUAL);
|
2012-03-28 15:42:04 +02:00
|
|
|
}
|
2013-08-21 17:03:08 +02:00
|
|
|
qtest_clock_warp(qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + ns);
|
2012-03-28 15:42:04 +02:00
|
|
|
qtest_send_prefix(chr);
|
2015-05-22 20:13:43 +02:00
|
|
|
qtest_sendf(chr, "OK %"PRIi64"\n",
|
|
|
|
(int64_t)qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL));
|
2013-10-18 13:51:11 +02:00
|
|
|
} else if (qtest_enabled() && strcmp(words[0], "clock_set") == 0) {
|
2012-03-28 15:42:04 +02:00
|
|
|
int64_t ns;
|
2017-09-11 19:19:46 +02:00
|
|
|
int ret;
|
2012-03-28 15:42:04 +02:00
|
|
|
|
|
|
|
g_assert(words[1]);
|
2017-09-11 19:19:46 +02:00
|
|
|
ret = qemu_strtoi64(words[1], NULL, 0, &ns);
|
|
|
|
g_assert(ret == 0);
|
2012-03-28 15:42:04 +02:00
|
|
|
qtest_clock_warp(ns);
|
|
|
|
qtest_send_prefix(chr);
|
2015-05-22 20:13:43 +02:00
|
|
|
qtest_sendf(chr, "OK %"PRIi64"\n",
|
|
|
|
(int64_t)qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL));
|
2012-03-28 15:42:02 +02:00
|
|
|
} else {
|
|
|
|
qtest_send_prefix(chr);
|
2015-05-22 20:13:43 +02:00
|
|
|
qtest_sendf(chr, "FAIL Unknown command '%s'\n", words[0]);
|
2012-03-28 15:42:02 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-22 11:52:55 +02:00
|
|
|
static void qtest_process_inbuf(CharBackend *chr, GString *inbuf)
|
2012-03-28 15:42:02 +02:00
|
|
|
{
|
|
|
|
char *end;
|
|
|
|
|
|
|
|
while ((end = strchr(inbuf->str, '\n')) != NULL) {
|
|
|
|
size_t offset;
|
|
|
|
GString *cmd;
|
|
|
|
gchar **words;
|
|
|
|
|
|
|
|
offset = end - inbuf->str;
|
|
|
|
|
|
|
|
cmd = g_string_new_len(inbuf->str, offset);
|
|
|
|
g_string_erase(inbuf, 0, offset + 1);
|
|
|
|
|
|
|
|
words = g_strsplit(cmd->str, " ", 0);
|
|
|
|
qtest_process_command(chr, words);
|
|
|
|
g_strfreev(words);
|
|
|
|
|
|
|
|
g_string_free(cmd, TRUE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void qtest_read(void *opaque, const uint8_t *buf, int size)
|
|
|
|
{
|
2016-10-22 11:52:55 +02:00
|
|
|
CharBackend *chr = opaque;
|
2012-03-28 15:42:02 +02:00
|
|
|
|
|
|
|
g_string_append_len(inbuf, (const gchar *)buf, size);
|
|
|
|
qtest_process_inbuf(chr, inbuf);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int qtest_can_read(void *opaque)
|
|
|
|
{
|
|
|
|
return 1024;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void qtest_event(void *opaque, int event)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
switch (event) {
|
|
|
|
case CHR_EVENT_OPENED:
|
2013-06-26 15:52:12 +02:00
|
|
|
/*
|
|
|
|
* We used to call qemu_system_reset() here, hoping we could
|
|
|
|
* use the same process for multiple tests that way. Never
|
|
|
|
* used. Injects an extra reset even when it's not used, and
|
|
|
|
* that can mess up tests, e.g. -boot once.
|
|
|
|
*/
|
2012-03-28 15:42:02 +02:00
|
|
|
for (i = 0; i < ARRAY_SIZE(irq_levels); i++) {
|
|
|
|
irq_levels[i] = 0;
|
|
|
|
}
|
2012-03-30 21:04:04 +02:00
|
|
|
qemu_gettimeofday(&start_time);
|
2012-03-28 15:42:02 +02:00
|
|
|
qtest_opened = true;
|
|
|
|
if (qtest_log_fp) {
|
|
|
|
fprintf(qtest_log_fp, "[I " FMT_timeval "] OPENED\n",
|
2013-08-20 22:53:25 +02:00
|
|
|
(long) start_time.tv_sec, (long) start_time.tv_usec);
|
2012-03-28 15:42:02 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case CHR_EVENT_CLOSED:
|
|
|
|
qtest_opened = false;
|
|
|
|
if (qtest_log_fp) {
|
2012-03-30 21:04:04 +02:00
|
|
|
qemu_timeval tv;
|
2012-03-28 15:42:02 +02:00
|
|
|
qtest_get_time(&tv);
|
|
|
|
fprintf(qtest_log_fp, "[I +" FMT_timeval "] CLOSED\n",
|
2013-08-20 22:53:25 +02:00
|
|
|
(long) tv.tv_sec, (long) tv.tv_usec);
|
2012-03-28 15:42:02 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-02-13 15:48:19 +01:00
|
|
|
static int qtest_init_accel(MachineState *ms)
|
2012-03-28 15:42:02 +02:00
|
|
|
{
|
2015-02-13 15:48:19 +01:00
|
|
|
QemuOpts *opts = qemu_opts_create(qemu_find_opts("icount"), NULL, 0,
|
|
|
|
&error_abort);
|
|
|
|
qemu_opt_set(opts, "shift", "0", &error_abort);
|
2014-07-25 11:56:28 +02:00
|
|
|
configure_icount(opts, &error_abort);
|
|
|
|
qemu_opts_del(opts);
|
2013-10-18 13:51:11 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-02-10 02:28:02 +01:00
|
|
|
void qtest_init(const char *qtest_chrdev, const char *qtest_log, Error **errp)
|
2013-10-18 13:51:11 +02:00
|
|
|
{
|
2016-12-07 14:20:22 +01:00
|
|
|
Chardev *chr;
|
2012-03-28 15:42:02 +02:00
|
|
|
|
2016-10-22 11:52:46 +02:00
|
|
|
chr = qemu_chr_new("qtest", qtest_chrdev);
|
2012-03-28 15:42:02 +02:00
|
|
|
|
2014-02-10 02:28:02 +01:00
|
|
|
if (chr == NULL) {
|
|
|
|
error_setg(errp, "Failed to initialize device for qtest: \"%s\"",
|
|
|
|
qtest_chrdev);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-03-28 15:42:02 +02:00
|
|
|
if (qtest_log) {
|
|
|
|
if (strcmp(qtest_log, "none") != 0) {
|
|
|
|
qtest_log_fp = fopen(qtest_log, "w+");
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
qtest_log_fp = stderr;
|
|
|
|
}
|
|
|
|
|
2016-10-22 11:52:55 +02:00
|
|
|
qemu_chr_fe_init(&qtest_chr, chr, errp);
|
|
|
|
qemu_chr_fe_set_handlers(&qtest_chr, qtest_can_read, qtest_read,
|
2017-07-06 14:08:49 +02:00
|
|
|
qtest_event, NULL, &qtest_chr, NULL, true);
|
2016-10-22 11:52:55 +02:00
|
|
|
qemu_chr_fe_set_echo(&qtest_chr, true);
|
2014-10-22 04:26:47 +02:00
|
|
|
|
|
|
|
inbuf = g_string_new("");
|
2012-03-28 15:42:02 +02:00
|
|
|
}
|
2014-02-04 19:06:47 +01:00
|
|
|
|
|
|
|
bool qtest_driver(void)
|
|
|
|
{
|
2016-10-22 11:52:52 +02:00
|
|
|
return qtest_chr.chr != NULL;
|
2014-02-04 19:06:47 +01:00
|
|
|
}
|
2014-09-26 22:45:26 +02:00
|
|
|
|
|
|
|
static void qtest_accel_class_init(ObjectClass *oc, void *data)
|
|
|
|
{
|
|
|
|
AccelClass *ac = ACCEL_CLASS(oc);
|
|
|
|
ac->name = "QTest";
|
|
|
|
ac->available = qtest_available;
|
accel: Rename 'init' method to 'init_machine'
Today, all accelerator init functions affect some global state:
* tcg_init() calls tcg_exec_init() and affects globals such as tcg_tcx,
page size globals, and possibly others;
* kvm_init() changes the kvm_state global, cpu_interrupt_handler, and possibly
others;
* xen_init() changes the xen_xc global, and registers a change state handler.
With the new accelerator QOM classes, initialization may now be split in two
steps:
* instance_init() will do basic initialization that doesn't affect any global
state and don't need MachineState or MachineClass data. This will allow
probing code to safely create multiple accelerator objects on the fly just
for reporting host/accelerator capabilities, for example.
* accel_init_machine()/init_machine() will save the accelerator object in
MachineState, and do initialization steps which still affect global state,
machine state, or that need data from MachineClass or MachineState.
To clarify the difference between those two steps, rename init() to
init_machine().
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
2014-09-26 22:45:29 +02:00
|
|
|
ac->init_machine = qtest_init_accel;
|
2014-09-26 22:45:26 +02:00
|
|
|
ac->allowed = &qtest_allowed;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define TYPE_QTEST_ACCEL ACCEL_CLASS_NAME("qtest")
|
|
|
|
|
|
|
|
static const TypeInfo qtest_accel_type = {
|
|
|
|
.name = TYPE_QTEST_ACCEL,
|
|
|
|
.parent = TYPE_ACCEL,
|
|
|
|
.class_init = qtest_accel_class_init,
|
|
|
|
};
|
|
|
|
|
|
|
|
static void qtest_type_init(void)
|
|
|
|
{
|
|
|
|
type_register_static(&qtest_accel_type);
|
|
|
|
}
|
|
|
|
|
|
|
|
type_init(qtest_type_init);
|