tests/libqos/libqos.c

   1 #include "qemu/osdep.h"
   2 #include <sys/wait.h>
   3
   4 #include "libqtest.h"
   5 #include "libqos/libqos.h"
   6 #include "libqos/pci.h"
   7
   8 /*** Test Setup & Teardown ***/
   9
  10 /**
  11  * Launch QEMU with the given command line,
  12  * and then set up interrupts and our guest malloc interface.
  13  * Never returns NULL:
  14  * Terminates the application in case an error is encountered.
  15  */
  16 QOSState *qtest_vboot(QOSOps *ops, const char *cmdline_fmt, va_list ap)
  17 {
  18     char *cmdline;
  19
  20     struct QOSState *qs = g_malloc(sizeof(QOSState));
  21
  22     cmdline = g_strdup_vprintf(cmdline_fmt, ap);
  23     qs->qts = qtest_start(cmdline);
  24     qs->ops = ops;
  25     if (ops) {
  26         if (ops->init_allocator) {
  27             qs->alloc = ops->init_allocator(ALLOC_NO_FLAGS);
  28         }
  29         if (ops->qpci_init && qs->alloc) {
  30             qs->pcibus = ops->qpci_init(qs->alloc);
  31         }
  32     }
  33
  34     g_free(cmdline);
  35     return qs;
  36 }
  37
  38 /**
  39  * Launch QEMU with the given command line,
  40  * and then set up interrupts and our guest malloc interface.
  41  */
  42 QOSState *qtest_boot(QOSOps *ops, const char *cmdline_fmt, ...)
  43 {
  44     QOSState *qs;
  45     va_list ap;
  46
  47     va_start(ap, cmdline_fmt);
  48     qs = qtest_vboot(ops, cmdline_fmt, ap);
  49     va_end(ap);
  50
  51     return qs;
  52 }
  53
  54 /**
  55  * Tear down the QEMU instance.
  56  */
  57 void qtest_common_shutdown(QOSState *qs)
  58 {
  59     if (qs->ops) {
  60         if (qs->pcibus && qs->ops->qpci_free) {
  61             qs->ops->qpci_free(qs->pcibus);
  62             qs->pcibus = NULL;
  63         }
  64         if (qs->alloc && qs->ops->uninit_allocator) {
  65             qs->ops->uninit_allocator(qs->alloc);
  66             qs->alloc = NULL;
  67         }
  68     }
  69     qtest_quit(qs->qts);
  70     g_free(qs);
  71 }
  72
  73 void qtest_shutdown(QOSState *qs)
  74 {
  75     if (qs->ops && qs->ops->shutdown) {
  76         qs->ops->shutdown(qs);
  77     } else {
  78         qtest_common_shutdown(qs);
  79     }
  80 }
  81
  82 void set_context(QOSState *s)
  83 {
  84     global_qtest = s->qts;
  85 }
  86
  87 static QDict *qmp_execute(const char *command)
  88 {
  89     char *fmt;
  90     QDict *rsp;
  91
  92     fmt = g_strdup_printf("{ 'execute': '%s' }", command);
  93     rsp = qmp(fmt);
  94     g_free(fmt);
  95
  96     return rsp;
  97 }
  98
  99 void migrate(QOSState *from, QOSState *to, const char *uri)
 100 {
 101     const char *st;
 102     char *s;
 103     QDict *rsp, *sub;
 104     bool running;
 105
 106     set_context(from);
 107
 108     /* Is the machine currently running? */
 109     rsp = qmp_execute("query-status");
 110     g_assert(qdict_haskey(rsp, "return"));
 111     sub = qdict_get_qdict(rsp, "return");
 112     g_assert(qdict_haskey(sub, "running"));
 113     running = qdict_get_bool(sub, "running");
 114     QDECREF(rsp);
 115
 116     /* Issue the migrate command. */
 117     s = g_strdup_printf("{ 'execute': 'migrate',"
 118                         "'arguments': { 'uri': '%s' } }",
 119                         uri);
 120     rsp = qmp(s);
 121     g_free(s);
 122     g_assert(qdict_haskey(rsp, "return"));
 123     QDECREF(rsp);
 124
 125     /* Wait for STOP event, but only if we were running: */
 126     if (running) {
 127         qmp_eventwait("STOP");
 128     }
 129
 130     /* If we were running, we can wait for an event. */
 131     if (running) {
 132         migrate_allocator(from->alloc, to->alloc);
 133         set_context(to);
 134         qmp_eventwait("RESUME");
 135         return;
 136     }
 137
 138     /* Otherwise, we need to wait: poll until migration is completed. */
 139     while (1) {
 140         rsp = qmp_execute("query-migrate");
 141         g_assert(qdict_haskey(rsp, "return"));
 142         sub = qdict_get_qdict(rsp, "return");
 143         g_assert(qdict_haskey(sub, "status"));
 144         st = qdict_get_str(sub, "status");
 145
 146         /* "setup", "active", "completed", "failed", "cancelled" */
 147         if (strcmp(st, "completed") == 0) {
 148             QDECREF(rsp);
 149             break;
 150         }
 151
 152         if ((strcmp(st, "setup") == 0) || (strcmp(st, "active") == 0)) {
 153             QDECREF(rsp);
 154             g_usleep(5000);
 155             continue;
 156         }
 157
 158         fprintf(stderr, "Migration did not complete, status: %s\n", st);
 159         g_assert_not_reached();
 160     }
 161
 162     migrate_allocator(from->alloc, to->alloc);
 163     set_context(to);
 164 }
 165
 166 bool have_qemu_img(void)
 167 {
 168     char *rpath;
 169     const char *path = getenv("QTEST_QEMU_IMG");
 170     if (!path) {
 171         return false;
 172     }
 173
 174     rpath = realpath(path, NULL);
 175     if (!rpath) {
 176         return false;
 177     } else {
 178         free(rpath);
 179         return true;
 180     }
 181 }
 182
 183 void mkimg(const char *file, const char *fmt, unsigned size_mb)
 184 {
 185     gchar *cli;
 186     bool ret;
 187     int rc;
 188     GError *err = NULL;
 189     char *qemu_img_path;
 190     gchar *out, *out2;
 191     char *qemu_img_abs_path;
 192
 193     qemu_img_path = getenv("QTEST_QEMU_IMG");
 194     g_assert(qemu_img_path);
 195     qemu_img_abs_path = realpath(qemu_img_path, NULL);
 196     g_assert(qemu_img_abs_path);
 197
 198     cli = g_strdup_printf("%s create -f %s %s %uM", qemu_img_abs_path,
 199                           fmt, file, size_mb);
 200     ret = g_spawn_command_line_sync(cli, &out, &out2, &rc, &err);
 201     if (err) {
 202         fprintf(stderr, "%s\n", err->message);
 203         g_error_free(err);
 204     }
 205     g_assert(ret && !err);
 206
 207     /* In glib 2.34, we have g_spawn_check_exit_status. in 2.12, we don't.
 208      * glib 2.43.91 implementation assumes that any non-zero is an error for
 209      * windows, but uses extra precautions for Linux. However,
 210      * 0 is only possible if the program exited normally, so that should be
 211      * sufficient for our purposes on all platforms, here. */
 212     if (rc) {
 213         fprintf(stderr, "qemu-img returned status code %d\n", rc);
 214     }
 215     g_assert(!rc);
 216
 217     g_free(out);
 218     g_free(out2);
 219     g_free(cli);
 220     free(qemu_img_abs_path);
 221 }
 222
 223 void mkqcow2(const char *file, unsigned size_mb)
 224 {
 225     return mkimg(file, "qcow2", size_mb);
 226 }
 227
 228 void prepare_blkdebug_script(const char *debug_fn, const char *event)
 229 {
 230     FILE *debug_file = fopen(debug_fn, "w");
 231     int ret;
 232
 233     fprintf(debug_file, "[inject-error]\n");
 234     fprintf(debug_file, "event = \"%s\"\n", event);
 235     fprintf(debug_file, "errno = \"5\"\n");
 236     fprintf(debug_file, "state = \"1\"\n");
 237     fprintf(debug_file, "immediately = \"off\"\n");
 238     fprintf(debug_file, "once = \"on\"\n");
 239
 240     fprintf(debug_file, "[set-state]\n");
 241     fprintf(debug_file, "event = \"%s\"\n", event);
 242     fprintf(debug_file, "new_state = \"2\"\n");
 243     fflush(debug_file);
 244     g_assert(!ferror(debug_file));
 245
 246     ret = fclose(debug_file);
 247     g_assert(ret == 0);
 248 }
 249
 250 void generate_pattern(void *buffer, size_t len, size_t cycle_len)
 251 {
 252     int i, j;
 253     unsigned char *tx = (unsigned char *)buffer;
 254     unsigned char p;
 255     size_t *sx;
 256
 257     /* Write an indicative pattern that varies and is unique per-cycle */
 258     p = rand() % 256;
 259     for (i = 0; i < len; i++) {
 260         tx[i] = p++ % 256;
 261         if (i % cycle_len == 0) {
 262             p = rand() % 256;
 263         }
 264     }
 265
 266     /* force uniqueness by writing an id per-cycle */
 267     for (i = 0; i < len / cycle_len; i++) {
 268         j = i * cycle_len;
 269         if (j + sizeof(*sx) <= len) {
 270             sx = (size_t *)&tx[j];
 271             *sx = i;
 272         }
 273     }
 274 }