LXR qemu/tests/qtest/libqos/libqos.c

   1#include "qemu/osdep.h"
   2#include "../libqtest.h"
   3#include "libqos.h"
   4#include "pci.h"
   5#include "qapi/qmp/qdict.h"
   6
   7/*** Test Setup & Teardown ***/
   8
   9/**
  10 * Launch QEMU with the given command line,
  11 * and then set up interrupts and our guest malloc interface.
  12 * Never returns NULL:
  13 * Terminates the application in case an error is encountered.
  14 */
  15QOSState *qtest_vboot(QOSOps *ops, const char *cmdline_fmt, va_list ap)
  16{
  17    char *cmdline;
  18
  19    QOSState *qs = g_new0(QOSState, 1);
  20
  21    cmdline = g_strdup_vprintf(cmdline_fmt, ap);
  22    qs->qts = qtest_init(cmdline);
  23    qs->ops = ops;
  24    if (ops) {
  25        ops->alloc_init(&qs->alloc, qs->qts, ALLOC_NO_FLAGS);
  26        qs->pcibus = ops->qpci_new(qs->qts, &qs->alloc);
  27    }
  28
  29    g_free(cmdline);
  30    return qs;
  31}
  32
  33/**
  34 * Launch QEMU with the given command line,
  35 * and then set up interrupts and our guest malloc interface.
  36 */
  37QOSState *qtest_boot(QOSOps *ops, const char *cmdline_fmt, ...)
  38{
  39    QOSState *qs;
  40    va_list ap;
  41
  42    va_start(ap, cmdline_fmt);
  43    qs = qtest_vboot(ops, cmdline_fmt, ap);
  44    va_end(ap);
  45
  46    return qs;
  47}
  48
  49/**
  50 * Tear down the QEMU instance.
  51 */
  52void qtest_common_shutdown(QOSState *qs)
  53{
  54    if (qs->ops) {
  55        if (qs->pcibus && qs->ops->qpci_free) {
  56            qs->ops->qpci_free(qs->pcibus);
  57            qs->pcibus = NULL;
  58        }
  59    }
  60    alloc_destroy(&qs->alloc);
  61    qtest_quit(qs->qts);
  62    g_free(qs);
  63}
  64
  65void qtest_shutdown(QOSState *qs)
  66{
  67    if (qs->ops && qs->ops->shutdown) {
  68        qs->ops->shutdown(qs);
  69    } else {
  70        qtest_common_shutdown(qs);
  71    }
  72}
  73
  74static QDict *qmp_execute(QTestState *qts, const char *command)
  75{
  76    return qtest_qmp(qts, "{ 'execute': %s }", command);
  77}
  78
  79void migrate(QOSState *from, QOSState *to, const char *uri)
  80{
  81    const char *st;
  82    QDict *rsp, *sub;
  83    bool running;
  84
  85    /* Is the machine currently running? */
  86    rsp = qmp_execute(from->qts, "query-status");
  87    g_assert(qdict_haskey(rsp, "return"));
  88    sub = qdict_get_qdict(rsp, "return");
  89    g_assert(qdict_haskey(sub, "running"));
  90    running = qdict_get_bool(sub, "running");
  91    qobject_unref(rsp);
  92
  93    /* Issue the migrate command. */
  94    rsp = qtest_qmp(from->qts,
  95                    "{ 'execute': 'migrate', 'arguments': { 'uri': %s }}",
  96                    uri);
  97    g_assert(qdict_haskey(rsp, "return"));
  98    qobject_unref(rsp);
  99
 100    /* Wait for STOP event, but only if we were running: */
 101    if (running) {
 102        qtest_qmp_eventwait(from->qts, "STOP");
 103    }
 104
 105    /* If we were running, we can wait for an event. */
 106    if (running) {
 107        migrate_allocator(&from->alloc, &to->alloc);
 108        qtest_qmp_eventwait(to->qts, "RESUME");
 109        return;
 110    }
 111
 112    /* Otherwise, we need to wait: poll until migration is completed. */
 113    while (1) {
 114        rsp = qmp_execute(from->qts, "query-migrate");
 115        g_assert(qdict_haskey(rsp, "return"));
 116        sub = qdict_get_qdict(rsp, "return");
 117        g_assert(qdict_haskey(sub, "status"));
 118        st = qdict_get_str(sub, "status");
 119
 120        /* "setup", "active", "completed", "failed", "cancelled" */
 121        if (strcmp(st, "completed") == 0) {
 122            qobject_unref(rsp);
 123            break;
 124        }
 125
 126        if ((strcmp(st, "setup") == 0) || (strcmp(st, "active") == 0)
 127            || (strcmp(st, "wait-unplug") == 0)) {
 128            qobject_unref(rsp);
 129            g_usleep(5000);
 130            continue;
 131        }
 132
 133        fprintf(stderr, "Migration did not complete, status: %s\n", st);
 134        g_assert_not_reached();
 135    }
 136
 137    migrate_allocator(&from->alloc, &to->alloc);
 138}
 139
 140void mkqcow2(const char *file, unsigned size_mb)
 141{
 142    g_assert_true(mkimg(file, "qcow2", size_mb));
 143}
 144
 145void prepare_blkdebug_script(const char *debug_fn, const char *event)
 146{
 147    FILE *debug_file = fopen(debug_fn, "w");
 148    int ret;
 149
 150    fprintf(debug_file, "[inject-error]\n");
 151    fprintf(debug_file, "event = \"%s\"\n", event);
 152    fprintf(debug_file, "errno = \"5\"\n");
 153    fprintf(debug_file, "state = \"1\"\n");
 154    fprintf(debug_file, "immediately = \"off\"\n");
 155    fprintf(debug_file, "once = \"on\"\n");
 156
 157    fprintf(debug_file, "[set-state]\n");
 158    fprintf(debug_file, "event = \"%s\"\n", event);
 159    fprintf(debug_file, "new_state = \"2\"\n");
 160    fflush(debug_file);
 161    g_assert(!ferror(debug_file));
 162
 163    ret = fclose(debug_file);
 164    g_assert(ret == 0);
 165}
 166
 167void generate_pattern(void *buffer, size_t len, size_t cycle_len)
 168{
 169    int i, j;
 170    unsigned char *tx = (unsigned char *)buffer;
 171    unsigned char p;
 172    size_t *sx;
 173
 174    /* Write an indicative pattern that varies and is unique per-cycle */
 175    p = rand() % 256;
 176    for (i = 0; i < len; i++) {
 177        tx[i] = p++ % 256;
 178        if (i % cycle_len == 0) {
 179            p = rand() % 256;
 180        }
 181    }
 182
 183    /* force uniqueness by writing an id per-cycle */
 184    for (i = 0; i < len / cycle_len; i++) {
 185        j = i * cycle_len;
 186        if (j + sizeof(*sx) <= len) {
 187            sx = (size_t *)&tx[j];
 188            *sx = i;
 189        }
 190    }
 191}
 192