qemu-devel.nongnu.org archive mirror
 help / color / mirror / Atom feed
* [Qemu-devel] [PATCH 1/6] qtest: add test framework
@ 2012-01-13 18:32 Anthony Liguori
  2012-01-13 18:32 ` [Qemu-devel] [PATCH 2/6] qtest: add support for -M pc Anthony Liguori
                   ` (5 more replies)
  0 siblings, 6 replies; 25+ messages in thread
From: Anthony Liguori @ 2012-01-13 18:32 UTC (permalink / raw)
  To: qemu-devel; +Cc: Kevin Wolf, Paolo Bonzini, Anthony Liguori, Stefan Hajnoczi

The idea behind qtest is pretty simple.  Instead of executing a CPU via TCG or
KVM, rely on an external process to send events to the device model that the CPU
would normally generate.

qtest presents itself as an accelerator.  In addition, a new option is added to
establish a qtest server (-qtest) that takes a character device.  This is what
allows the external process to send CPU events to the device model.

This is currently modelled after Xen since the Xen device model does something
very similar.  Instead of hooking cpu_exec, Xen sticks the CPU in the halted
state making sure it never gets to execute.  In addition, Xen replaces the LAPIC
with a dummy interrupt controller that forwards interrupt requests.

qtest does the exact same thing and uses a simple line based protocol to send
the events.  Documentation of that protocol is in qtest.c.

I considered reusing the monitor for this job.  Adding interrupts would be a bit
difficult.  In addition, logging would also be difficult.

qtest has extensive logging support.  All protocol commands are logged with
time stamps using a new command line option (-qtest-log).  Logging is important
since ultimately, this is a feature for debugging.

Signed-off-by: Anthony Liguori <aliguori@us.ibm.com>
---
 Makefile.objs   |    2 +
 cpu-exec.c      |    5 +
 qemu-options.hx |    8 ++
 qtest.c         |  357 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 qtest.h         |   37 ++++++
 vl.c            |    8 ++
 6 files changed, 417 insertions(+), 0 deletions(-)
 create mode 100644 qtest.c
 create mode 100644 qtest.h

diff --git a/Makefile.objs b/Makefile.objs
index 4f6d26c..52b2faf 100644
--- a/Makefile.objs
+++ b/Makefile.objs
@@ -292,6 +292,8 @@ hw-obj-$(CONFIG_DP8393X) += dp8393x.o
 hw-obj-$(CONFIG_DS1225Y) += ds1225y.o
 hw-obj-$(CONFIG_MIPSNET) += mipsnet.o
 
+hw-obj-y += qtest.o
+
 # Sound
 sound-obj-y =
 sound-obj-$(CONFIG_SB16) += sb16.o
diff --git a/cpu-exec.c b/cpu-exec.c
index a9fa608..bf5a2aa 100644
--- a/cpu-exec.c
+++ b/cpu-exec.c
@@ -21,6 +21,7 @@
 #include "disas.h"
 #include "tcg.h"
 #include "qemu-barrier.h"
+#include "qtest.h"
 
 int tb_invalidated_flag;
 
@@ -188,6 +189,10 @@ int cpu_exec(CPUState *env)
     uint8_t *tc_ptr;
     unsigned long next_tb;
 
+    if (qtest_enabled()) {
+        env->halted = 1;
+    }
+
     if (env->halted) {
         if (!cpu_has_work(env)) {
             return EXCP_HALTED;
diff --git a/qemu-options.hx b/qemu-options.hx
index 6295cde..da0c648 100644
--- a/qemu-options.hx
+++ b/qemu-options.hx
@@ -2622,6 +2622,14 @@ the @var{simple} tracing backend.
 @end table
 ETEXI
 
+DEF("qtest", HAS_ARG, QEMU_OPTION_qtest,
+    "-qtest CHR      specify tracing options\n",
+    QEMU_ARCH_ALL)
+
+DEF("qtest-log", HAS_ARG, QEMU_OPTION_qtest_log,
+    "-qtest-log LOG  specify tracing options\n",
+    QEMU_ARCH_ALL)
+
 HXCOMM This is the last statement. Insert new options before this line!
 STEXI
 @end table
diff --git a/qtest.c b/qtest.c
new file mode 100644
index 0000000..f41a9c3
--- /dev/null
+++ b/qtest.c
@@ -0,0 +1,357 @@
+/*
+ * 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.
+ *
+ */
+
+#include "qtest.h"
+#include "qemu-char.h"
+#include "ioport.h"
+#include "memory.h"
+#include "hw/irq.h"
+#include "sysemu.h"
+
+#define MAX_IRQ 256
+
+const char *qtest_chrdev;
+const char *qtest_log;
+int qtest_allowed = 0;
+
+static FILE *qtest_log_fp;
+static CharDriverState *qtest_chr;
+static GString *inbuf;
+static int irq_levels[MAX_IRQ];
+static struct timeval start_time;
+static bool qtest_opened;
+
+#define FMT_timeval "%" PRId64 ".%06" PRId64
+
+/**
+ * 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
+ *
+ *  > outb ADDR VALUE
+ *  < OK
+ *
+ *  > outw ADDR VALUE
+ *  < OK
+ *
+ *  > outl ADDR VALUE
+ *  < OK
+ *
+ *  > inb ADDR
+ *  < OK VALUE
+ *
+ *  > inw ADDR
+ *  < OK VALUE
+ *
+ *  > inl ADDR
+ *  < OK VALUE
+ *
+ *  > read ADDR SIZE
+ *  < OK DATA
+ *
+ *  > write ADDR SIZE DATA
+ *  < OK
+ *
+ * Valid async messages:
+ *
+ *  IRQ raise NUM
+ *  IRQ lower NUM
+ *
+ * ADDR, SIZE, VALUE are all integers parsed with strtoul() with a base of 0.
+ *
+ * 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.
+ *
+ * NUM is an IRQ number.
+ */
+
+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;
+    }
+}
+
+static void qtest_get_time(struct timeval *tv)
+{
+    gettimeofday(tv, NULL);
+    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;
+    }
+}
+
+static void qtest_send_prefix(CharDriverState *chr)
+{
+    struct timeval tv;
+
+    if (!qtest_log_fp || !qtest_opened) {
+        return;
+    }
+
+    qtest_get_time(&tv);
+    fprintf(qtest_log_fp, "[S +" FMT_timeval "] ",
+            tv.tv_sec, tv.tv_usec);
+}
+
+static void qtest_send(CharDriverState *chr, const char *fmt, ...)
+{
+    va_list ap;
+    char buffer[1024];
+    size_t len;
+
+    va_start(ap, fmt);
+    len = vsnprintf(buffer, sizeof(buffer), fmt, ap);
+    va_end(ap);
+
+    qemu_chr_fe_write(chr, (uint8_t *)buffer, len);
+    if (qtest_log_fp && qtest_opened) {
+        fprintf(qtest_log_fp, "%s", buffer);
+    }
+}
+
+static void qtest_process_command(CharDriverState *chr, gchar **words)
+{
+    const gchar *command;
+
+    g_assert(words);
+
+    command = words[0];
+
+    if (qtest_log_fp) {
+        struct timeval tv;
+        int i;
+
+        qtest_get_time(&tv);
+        fprintf(qtest_log_fp, "[R +" FMT_timeval "]",
+                tv.tv_sec, tv.tv_usec);
+        for (i = 0; words[i]; i++) {
+            fprintf(qtest_log_fp, " %s", words[i]);
+        }
+        fprintf(qtest_log_fp, "\n");
+    }
+
+    g_assert(command);
+    if (strcmp(words[0], "outb") == 0 ||
+        strcmp(words[0], "outw") == 0 ||
+        strcmp(words[0], "outl") == 0) {
+        uint16_t addr;
+        uint32_t value;
+
+        g_assert(words[1] && words[2]);
+        addr = strtol(words[1], NULL, 0);
+        value = strtol(words[2], NULL, 0);
+
+        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) {
+        uint16_t addr;
+        uint32_t value = -1U;
+
+        g_assert(words[1]);
+        addr = strtol(words[1], NULL, 0);
+
+        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);
+        qtest_send(chr, "OK 0x%04x\n", value);
+    } else if (strcmp(words[0], "read") == 0) {
+        uint64_t addr, len, i;
+        uint8_t *data;
+
+        g_assert(words[1] && words[2]);
+        addr = strtoul(words[1], NULL, 0);
+        len = strtoul(words[2], NULL, 0);
+
+        data = g_malloc(len);
+        cpu_physical_memory_read(addr, data, len);
+
+        qtest_send_prefix(chr);
+        qtest_send(chr, "OK 0x");
+        for (i = 0; i < len; i++) {
+            qtest_send(chr, "%02x", data[i]);
+        }
+        qtest_send(chr, "\n");
+
+        g_free(data);
+    } else if (strcmp(words[0], "write") == 0) {
+        uint64_t addr, len, i;
+        uint8_t *data;
+        size_t data_len;
+
+        g_assert(words[1] && words[2] && words[3]);
+        addr = strtoul(words[1], NULL, 0);
+        len = strtoul(words[2], NULL, 0);
+
+        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);
+
+        qtest_send_prefix(chr);
+        qtest_send(chr, "OK\n");
+    } else {
+        fprintf(stderr, "Unknown command `%s'\n", words[0]);
+    }
+}
+
+static void qtest_process_inbuf(CharDriverState *chr, GString *inbuf)
+{
+    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)
+{
+    CharDriverState *chr = opaque;
+
+    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:
+        qemu_system_reset(false);
+        for (i = 0; i < ARRAY_SIZE(irq_levels); i++) {
+            irq_levels[i] = 0;
+        }
+        gettimeofday(&start_time, NULL);
+        qtest_opened = true;
+        if (qtest_log_fp) {
+            fprintf(qtest_log_fp, "[I " FMT_timeval "] OPENED\n",
+                    start_time.tv_sec, start_time.tv_usec);
+        }
+        break;
+    case CHR_EVENT_CLOSED:
+        qtest_opened = false;
+        if (qtest_log_fp) {
+            struct timeval tv;
+            qtest_get_time(&tv);
+            fprintf(qtest_log_fp, "[I +" FMT_timeval "] CLOSED\n",
+                    tv.tv_sec, tv.tv_usec);
+        }
+        break;
+    default:
+        break;
+    }
+}
+
+static void qtest_set_irq(void *opaque, int irq, int level)
+{
+    CharDriverState *chr = qtest_chr;
+    bool changed;
+
+    changed = (irq_levels[irq] != level);
+    irq_levels[irq] = level;
+
+    if (changed) {
+        qtest_send_prefix(chr);
+        qtest_send(chr, "IRQ %s %d\n",
+                   level ? "raise" : "lower", irq);
+    }
+}
+
+qemu_irq *qtest_interrupt_controller_init(void)
+{
+    return qemu_allocate_irqs(qtest_set_irq, NULL, MAX_IRQ);
+}
+
+int qtest_init(void)
+{
+    CharDriverState *chr;
+
+    g_assert(qtest_chrdev != NULL);
+
+    chr = qemu_chr_new("qtest", qtest_chrdev, NULL);
+
+    qemu_chr_add_handlers(chr, qtest_can_read, qtest_read, qtest_event, chr);
+
+    inbuf = g_string_new("");
+
+    if (qtest_log) {
+        if (strcmp(qtest_log, "none") != 0) {
+            qtest_log_fp = fopen(qtest_log, "w+");
+        }
+    } else {
+        qtest_log_fp = stderr;
+    }
+
+    qtest_chr = chr;
+
+    return 0;
+}
diff --git a/qtest.h b/qtest.h
new file mode 100644
index 0000000..f0e1377
--- /dev/null
+++ b/qtest.h
@@ -0,0 +1,37 @@
+/*
+ * 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.
+ *
+ */
+
+#ifndef QTEST_H
+#define QTEST_H
+
+#include "qemu-common.h"
+
+extern int qtest_allowed;
+extern const char *qtest_chrdev;
+extern const char *qtest_log;
+
+static inline bool qtest_enabled(void)
+{
+    return qtest_allowed;
+}
+
+static inline int qtest_available(void)
+{
+    return 1;
+}
+
+int qtest_init(void);
+
+qemu_irq *qtest_interrupt_controller_init(void);
+
+#endif
diff --git a/vl.c b/vl.c
index ba55b35..58fb5d9 100644
--- a/vl.c
+++ b/vl.c
@@ -152,6 +152,7 @@ int main(int argc, char **argv)
 #ifdef CONFIG_VIRTFS
 #include "fsdev/qemu-fsdev.h"
 #endif
+#include "qtest.h"
 
 #include "disas.h"
 
@@ -1988,6 +1989,7 @@ static struct {
     { "tcg", "tcg", tcg_available, tcg_init, &tcg_allowed },
     { "xen", "Xen", xen_available, xen_init, &xen_allowed },
     { "kvm", "KVM", kvm_available, kvm_init, &kvm_allowed },
+    { "qtest", "QTest", qtest_available, qtest_init, &qtest_allowed },
 };
 
 static int configure_accelerator(void)
@@ -3053,6 +3055,12 @@ int main(int argc, char **argv, char **envp)
                     fclose(fp);
                     break;
                 }
+            case QEMU_OPTION_qtest:
+                qtest_chrdev = optarg;
+                break;
+            case QEMU_OPTION_qtest_log:
+                qtest_log = optarg;
+                break;
             default:
                 os_parse_cmd_args(popt->index, optarg);
             }
-- 
1.7.4.1

^ permalink raw reply related	[flat|nested] 25+ messages in thread
* Re: [Qemu-devel] [PATCH 1/6] qtest: add test framework
@ 2012-01-17 17:22 Michael Walle
  0 siblings, 0 replies; 25+ messages in thread
From: Michael Walle @ 2012-01-17 17:22 UTC (permalink / raw)
  To: Anthony Liguori; +Cc: Kevin Wolf, Paolo Bonzini, qemu-devel, Stefan Hajnoczi

On Fri, January 13, 2012 19:32, Anthony Liguori wrote:
> diff --git a/qtest.c b/qtest.c
> new file mode 100644
> index 0000000..f41a9c3
> --- /dev/null
> +++ b/qtest.c
> @@ -0,0 +1,357 @@
> +/*
> + * 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.
> + *
> + */
> +
> +#include "qtest.h"
> +#include "qemu-char.h"
> +#include "ioport.h"
> +#include "memory.h"
> +#include "hw/irq.h"
> +#include "sysemu.h"
> +
> +#define MAX_IRQ 256
> +
> +const char *qtest_chrdev;
> +const char *qtest_log;
> +int qtest_allowed = 0;
> +
> +static FILE *qtest_log_fp;
> +static CharDriverState *qtest_chr;
> +static GString *inbuf;
> +static int irq_levels[MAX_IRQ];
> +static struct timeval start_time;
> +static bool qtest_opened;
> +
> +#define FMT_timeval "%" PRId64 ".%06" PRId64

This doesnt work for me. tv_sec and tv_usec are "long int" on my platform
(32bit, x86, debian stable).

> +
> +/**
> + * 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
> + *
> + *  > outb ADDR VALUE
> + *  < OK
> + *
> + *  > outw ADDR VALUE
> + *  < OK
> + *
> + *  > outl ADDR VALUE
> + *  < OK
> + *
> + *  > inb ADDR
> + *  < OK VALUE
> + *
> + *  > inw ADDR
> + *  < OK VALUE
> + *
> + *  > inl ADDR
> + *  < OK VALUE
> + *
> + *  > read ADDR SIZE
> + *  < OK DATA
> + *
> + *  > write ADDR SIZE DATA
> + *  < OK
> + *
> + * Valid async messages:
> + *
> + *  IRQ raise NUM
> + *  IRQ lower NUM
> + *
> + * ADDR, SIZE, VALUE are all integers parsed with strtoul() with a base
of 0.
> + *
> + * 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.
> + *
> + * NUM is an IRQ number.
> + */
> +
> +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;
> +    }
> +}
> +
> +static void qtest_get_time(struct timeval *tv)
> +{
> +    gettimeofday(tv, NULL);
> +    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;
> +    }
> +}
> +
> +static void qtest_send_prefix(CharDriverState *chr)
> +{
> +    struct timeval tv;
> +
> +    if (!qtest_log_fp || !qtest_opened) {
> +        return;
> +    }
> +
> +    qtest_get_time(&tv);
> +    fprintf(qtest_log_fp, "[S +" FMT_timeval "] ",
> +            tv.tv_sec, tv.tv_usec);
> +}
> +
> +static void qtest_send(CharDriverState *chr, const char *fmt, ...) +{
> +    va_list ap;
> +    char buffer[1024];
> +    size_t len;
> +
> +    va_start(ap, fmt);
> +    len = vsnprintf(buffer, sizeof(buffer), fmt, ap);
> +    va_end(ap);
> +
> +    qemu_chr_fe_write(chr, (uint8_t *)buffer, len);
> +    if (qtest_log_fp && qtest_opened) {
> +        fprintf(qtest_log_fp, "%s", buffer);
> +    }
> +}
> +
> +static void qtest_process_command(CharDriverState *chr, gchar **words) +{
> +    const gchar *command;
> +
> +    g_assert(words);
> +
> +    command = words[0];
> +
> +    if (qtest_log_fp) {
> +        struct timeval tv;
> +        int i;
> +
> +        qtest_get_time(&tv);
> +        fprintf(qtest_log_fp, "[R +" FMT_timeval "]",
> +                tv.tv_sec, tv.tv_usec);
> +        for (i = 0; words[i]; i++) {
> +            fprintf(qtest_log_fp, " %s", words[i]);
> +        }
> +        fprintf(qtest_log_fp, "\n");
> +    }
> +
> +    g_assert(command);
i don't know if these asserts will be in the final version of your patch
or wether one say that any protocol violations will terminate qemu. maybe
we should just ignore unknown/invalid commands for now? Eg. i found it
very useful to use the protocol directly with telnet but it was annoying
that any invalid command aborted qemu.

OTOH you may dictate to use a proper client library. i'm fine with this
too ;)

> +    if (strcmp(words[0], "outb") == 0 ||
> +        strcmp(words[0], "outw") == 0 ||
> +        strcmp(words[0], "outl") == 0) {
> +        uint16_t addr;
> +        uint32_t value;
> +
> +        g_assert(words[1] && words[2]);
> +        addr = strtol(words[1], NULL, 0);
> +        value = strtol(words[2], NULL, 0);
> +
> +        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) {
> +        uint16_t addr;
> +        uint32_t value = -1U;
> +
> +        g_assert(words[1]);
> +        addr = strtol(words[1], NULL, 0);
> +
> +        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);
> +        qtest_send(chr, "OK 0x%04x\n", value);
> +    } else if (strcmp(words[0], "read") == 0) {
> +        uint64_t addr, len, i;
> +        uint8_t *data;
> +
> +        g_assert(words[1] && words[2]);
> +        addr = strtoul(words[1], NULL, 0);
> +        len = strtoul(words[2], NULL, 0);
> +
> +        data = g_malloc(len);
> +        cpu_physical_memory_read(addr, data, len);
> +
> +        qtest_send_prefix(chr);
> +        qtest_send(chr, "OK 0x");
> +        for (i = 0; i < len; i++) {
> +            qtest_send(chr, "%02x", data[i]);
> +        }
> +        qtest_send(chr, "\n");
> +
> +        g_free(data);
> +    } else if (strcmp(words[0], "write") == 0) {
> +        uint64_t addr, len, i;
> +        uint8_t *data;
> +        size_t data_len;
> +
> +        g_assert(words[1] && words[2] && words[3]);
> +        addr = strtoul(words[1], NULL, 0);
> +        len = strtoul(words[2], NULL, 0);
> +
> +        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);
> +
> +        qtest_send_prefix(chr);
> +        qtest_send(chr, "OK\n");
> +    } else {
> +        fprintf(stderr, "Unknown command `%s'\n", words[0]);
> +    }
> +}
> +
> +static void qtest_process_inbuf(CharDriverState *chr, GString *inbuf) +{
> +    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) +{
> +    CharDriverState *chr = opaque;
> +
> +    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:
> +        qemu_system_reset(false);
> +        for (i = 0; i < ARRAY_SIZE(irq_levels); i++) {
> +            irq_levels[i] = 0;
> +        }
> +        gettimeofday(&start_time, NULL);
> +        qtest_opened = true;
> +        if (qtest_log_fp) {
> +            fprintf(qtest_log_fp, "[I " FMT_timeval "] OPENED\n", +    
               start_time.tv_sec, start_time.tv_usec);
> +        }
> +        break;
> +    case CHR_EVENT_CLOSED:
> +        qtest_opened = false;
> +        if (qtest_log_fp) {
> +            struct timeval tv;
> +            qtest_get_time(&tv);
> +            fprintf(qtest_log_fp, "[I +" FMT_timeval "] CLOSED\n", +   
                tv.tv_sec, tv.tv_usec);
> +        }
> +        break;
> +    default:
> +        break;
> +    }
> +}
> +
> +static void qtest_set_irq(void *opaque, int irq, int level)
> +{
> +    CharDriverState *chr = qtest_chr;
> +    bool changed;
> +
> +    changed = (irq_levels[irq] != level);
> +    irq_levels[irq] = level;
> +
> +    if (changed) {
> +        qtest_send_prefix(chr);
> +        qtest_send(chr, "IRQ %s %d\n",
> +                   level ? "raise" : "lower", irq);
> +    }
> +}
> +
> +qemu_irq *qtest_interrupt_controller_init(void)
> +{
> +    return qemu_allocate_irqs(qtest_set_irq, NULL, MAX_IRQ);
> +}
> +
> +int qtest_init(void)
> +{
> +    CharDriverState *chr;
> +
> +    g_assert(qtest_chrdev != NULL);
> +
> +    chr = qemu_chr_new("qtest", qtest_chrdev, NULL);
chr may be NULL


> +
> +    qemu_chr_add_handlers(chr, qtest_can_read, qtest_read, qtest_event,
chr);
> +
> +    inbuf = g_string_new("");
> +
> +    if (qtest_log) {
> +        if (strcmp(qtest_log, "none") != 0) {
> +            qtest_log_fp = fopen(qtest_log, "w+");
> +        }
> +    } else {
> +        qtest_log_fp = stderr;
> +    }
> +
> +    qtest_chr = chr;
> +
> +    return 0;
> +}
> diff --git a/qtest.h b/qtest.h
> new file mode 100644
> index 0000000..f0e1377
> --- /dev/null
> +++ b/qtest.h
> @@ -0,0 +1,37 @@
> +/*
> + * 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.
> + *
> + */
> +
> +#ifndef QTEST_H
> +#define QTEST_H
> +
> +#include "qemu-common.h"
> +
> +extern int qtest_allowed;
> +extern const char *qtest_chrdev;
> +extern const char *qtest_log;
> +
> +static inline bool qtest_enabled(void)
> +{
> +    return qtest_allowed;
> +}
> +
> +static inline int qtest_available(void)
> +{
> +    return 1;
> +}
> +
> +int qtest_init(void);
> +
> +qemu_irq *qtest_interrupt_controller_init(void);
> +
> +#endif
> diff --git a/vl.c b/vl.c
> index ba55b35..58fb5d9 100644
> --- a/vl.c
> +++ b/vl.c
> @@ -152,6 +152,7 @@ int main(int argc, char **argv)
>  #ifdef CONFIG_VIRTFS
>  #include "fsdev/qemu-fsdev.h"
>  #endif
> +#include "qtest.h"
>  #include "disas.h"
> @@ -1988,6 +1989,7 @@ static struct {
>      { "tcg", "tcg", tcg_available, tcg_init, &tcg_allowed },
>      { "xen", "Xen", xen_available, xen_init, &xen_allowed },
>      { "kvm", "KVM", kvm_available, kvm_init, &kvm_allowed },
> +    { "qtest", "QTest", qtest_available, qtest_init, &qtest_allowed },
>  };
>  static int configure_accelerator(void)
> @@ -3053,6 +3055,12 @@ int main(int argc, char **argv, char **envp)
>                      fclose(fp);
>                      break;
>                  }
> +            case QEMU_OPTION_qtest:
> +                qtest_chrdev = optarg;
> +                break;
> +            case QEMU_OPTION_qtest_log:
> +                qtest_log = optarg;
> +                break;
>              default:
>                  os_parse_cmd_args(popt->index, optarg);
>              }
> --
> 1.7.4.1

-- 
michael

^ permalink raw reply	[flat|nested] 25+ messages in thread
end of thread, other threads:[~2012-01-18 16:10 UTC | newest]

Thread overview: 25+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2012-01-13 18:32 [Qemu-devel] [PATCH 1/6] qtest: add test framework Anthony Liguori
2012-01-13 18:32 ` [Qemu-devel] [PATCH 2/6] qtest: add support for -M pc Anthony Liguori
2012-01-13 18:32 ` [Qemu-devel] [PATCH 3/6] qtest: add C version of test infrastructure Anthony Liguori
2012-01-17 11:33   ` Stefan Hajnoczi
2012-01-17 13:33     ` Paolo Bonzini
2012-01-17 13:39       ` Stefan Hajnoczi
2012-01-17 16:09   ` Paolo Bonzini
2012-01-18 16:00   ` Kevin Wolf
2012-01-18 16:02     ` Paolo Bonzini
2012-01-18 16:08     ` Anthony Liguori
2012-01-13 18:32 ` [Qemu-devel] [PATCH 4/6] make: add check targets based on gtester Anthony Liguori
2012-01-16 17:16   ` Paolo Bonzini
2012-01-16 18:14     ` Anthony Liguori
2012-01-17 10:42       ` Paolo Bonzini
2012-01-17 14:04   ` Paolo Bonzini
2012-01-17 14:22     ` Anthony Liguori
2012-01-13 18:32 ` [Qemu-devel] [PATCH 5/6] rtc: split out macros into a header file and use in test case Anthony Liguori
2012-01-13 18:32 ` [Qemu-devel] [PATCH 6/6] qtest: add rtc-test test-case Anthony Liguori
2012-01-16 16:59 ` [Qemu-devel] [PATCH 1/6] qtest: add test framework Stefan Hajnoczi
2012-01-16 17:08   ` Avi Kivity
2012-01-16 17:20     ` Anthony Liguori
2012-01-16 17:08   ` Anthony Liguori
2012-01-17 11:13     ` Stefan Hajnoczi
2012-01-18  9:05       ` Stefan Hajnoczi
  -- strict thread matches above, loose matches on Subject: below --
2012-01-17 17:22 Michael Walle

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).