tests/qtest/qos-test.c

   1 /*
   2  * libqos driver framework
   3  *
   4  * Copyright (c) 2018 Emanuele Giuseppe Esposito <e.emanuelegiuseppe@gmail.com>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License version 2.1 as published by the Free Software Foundation.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, see <http://www.gnu.org/licenses/>
  17  */
  18
  19 #include "qemu/osdep.h"
  20 #include <getopt.h>
  21 #include "libqtest-single.h"
  22 #include "qapi/error.h"
  23 #include "qapi/qmp/qdict.h"
  24 #include "qemu/module.h"
  25 #include "qapi/qobject-input-visitor.h"
  26 #include "qapi/qapi-visit-machine.h"
  27 #include "qapi/qapi-visit-qom.h"
  28 #include "libqos/libqos-malloc.h"
  29 #include "libqos/qgraph.h"
  30 #include "libqos/qgraph_internal.h"
  31 #include "libqos/qos_external.h"
  32
  33 static char *old_path;
  34
  35
  36
  37 /**
  38  * qos_set_machines_devices_available(): sets availability of qgraph
  39  * machines and devices.
  40  *
  41  * This function firstly starts QEMU with "-machine none" option,
  42  * and then executes the QMP protocol asking for the list of devices
  43  * and machines available.
  44  *
  45  * for each of these items, it looks up the corresponding qgraph node,
  46  * setting it as available. The list currently returns all devices that
  47  * are either machines or QEDGE_CONSUMED_BY other nodes.
  48  * Therefore, in order to mark all other nodes, it recursively sets
  49  * all its QEDGE_CONTAINS and QEDGE_PRODUCES child as available too.
  50  */
  51 static void qos_set_machines_devices_available(void)
  52 {
  53     QDict *response;
  54     QDict *args = qdict_new();
  55     QObject *ret;
  56     Visitor *v;
  57     MachineInfoList *mach_info;
  58     ObjectTypeInfoList *type_info;
  59
  60     qtest_start("-machine none");
  61     response = qmp("{ 'execute': 'query-machines' }");
  62     ret = qdict_get(response, "return");
  63
  64     v = qobject_input_visitor_new(ret);
  65     visit_type_MachineInfoList(v, NULL, &mach_info, &error_abort);
  66     visit_free(v);
  67     machines_apply_to_node(mach_info);
  68     qapi_free_MachineInfoList(mach_info);
  69
  70     qobject_unref(response);
  71
  72     qdict_put_bool(args, "abstract", true);
  73     qdict_put_str(args, "implements", "device");
  74
  75     response = qmp("{'execute': 'qom-list-types',"
  76                    " 'arguments': %p }", args);
  77     ret = qdict_get(response, "return");
  78
  79     v = qobject_input_visitor_new(ret);
  80     visit_type_ObjectTypeInfoList(v, NULL, &type_info, &error_abort);
  81     visit_free(v);
  82     types_apply_to_node(type_info);
  83     qapi_free_ObjectTypeInfoList(type_info);
  84
  85     qtest_end();
  86     qobject_unref(response);
  87 }
  88
  89
  90 static void restart_qemu_or_continue(char *path)
  91 {
  92     if (g_test_verbose()) {
  93         qos_printf("Run QEMU with: '%s'\n", path);
  94     }
  95     /* compares the current command line with the
  96      * one previously executed: if they are the same,
  97      * don't restart QEMU, if they differ, stop previous
  98      * QEMU subprocess (if active) and start over with
  99      * the new command line
 100      */
 101     if (g_strcmp0(old_path, path)) {
 102         qtest_end();
 103         qos_invalidate_command_line();
 104         old_path = g_strdup(path);
 105         qtest_start(path);
 106     } else { /* if cmd line is the same, reset the guest */
 107         qobject_unref(qmp("{ 'execute': 'system_reset' }"));
 108         qmp_eventwait("RESET");
 109     }
 110 }
 111
 112 void qos_invalidate_command_line(void)
 113 {
 114     g_free(old_path);
 115     old_path = NULL;
 116 }
 117
 118
 119 /* The argument to run_one_test, which is the test function that is registered
 120  * with GTest, is a vector of strings.  The first item is the initial command
 121  * line (before it is modified by the test's "before" function), the remaining
 122  * items are node names forming the path to the test node.
 123  */
 124 static char **current_path;
 125
 126 const char *qos_get_current_command_line(void)
 127 {
 128     return current_path[0];
 129 }
 130
 131 void *qos_allocate_objects(QTestState *qts, QGuestAllocator **p_alloc)
 132 {
 133     return allocate_objects(qts, current_path + 1, p_alloc);
 134 }
 135
 136 /**
 137  * run_one_test(): given an array of nodes @arg,
 138  * walks the path invoking all constructors and
 139  * passing the corresponding parameter in order to
 140  * continue the objects allocation.
 141  * Once the test is reached, its function is executed.
 142  *
 143  * Since the machine and QEDGE_CONSUMED_BY nodes allocate
 144  * memory in the constructor, g_test_queue_destroy is used so
 145  * that after execution they can be safely free'd.  The test's
 146  * ->before callback is also welcome to use g_test_queue_destroy.
 147  *
 148  * Note: as specified in walk_path() too, @arg is an array of
 149  * char *, where arg[0] is a pointer to the command line
 150  * string that will be used to properly start QEMU when executing
 151  * the test, and the remaining elements represent the actual objects
 152  * that will be allocated.
 153  *
 154  * The order of execution is the following:
 155  * 1) @before test function as defined in the given QOSGraphTestOptions
 156  * 2) start QEMU
 157  * 3) call all nodes constructor and get_driver/get_device depending on edge,
 158  *    start the hardware (*_device_enable functions)
 159  * 4) start test
 160  */
 161 static void run_one_test(const void *arg)
 162 {
 163     QOSGraphNode *test_node;
 164     QGuestAllocator *alloc = NULL;
 165     void *obj;
 166     char **path = (char **) arg;
 167     GString *cmd_line = g_string_new(path[0]);
 168     void *test_arg;
 169
 170     /* Before test */
 171     current_path = path;
 172     test_node = qos_graph_get_node(path[(g_strv_length(path) - 1)]);
 173     test_arg = test_node->u.test.arg;
 174     if (test_node->u.test.before) {
 175         test_arg = test_node->u.test.before(cmd_line, test_arg);
 176     }
 177
 178     restart_qemu_or_continue(cmd_line->str);
 179     g_string_free(cmd_line, true);
 180
 181     obj = qos_allocate_objects(global_qtest, &alloc);
 182     test_node->u.test.function(obj, test_arg, alloc);
 183 }
 184
 185 static void subprocess_run_one_test(const void *arg)
 186 {
 187     const gchar *path = arg;
 188     g_test_trap_subprocess(path, 180 * G_USEC_PER_SEC,
 189                            G_TEST_SUBPROCESS_INHERIT_STDOUT |
 190                            G_TEST_SUBPROCESS_INHERIT_STDERR);
 191     g_test_trap_assert_passed();
 192 }
 193
 194 /*
 195  * in this function, 2 path will be built:
 196  * path_str, a one-string path (ex "pc/i440FX-pcihost/...")
 197  * path_vec, a string-array path (ex [0] = "pc", [1] = "i440FX-pcihost").
 198  *
 199  * path_str will be only used to build the test name, and won't need the
 200  * architecture name at beginning, since it will be added by qtest_add_func().
 201  *
 202  * path_vec is used to allocate all constructors of the path nodes.
 203  * Each name in this array except position 0 must correspond to a valid
 204  * QOSGraphNode name.
 205  * Position 0 is special, initially contains just the <machine> name of
 206  * the node, (ex for "x86_64/pc" it will be "pc"), used to build the test
 207  * path (see below). After it will contain the command line used to start
 208  * qemu with all required devices.
 209  *
 210  * Note that the machine node name must be with format <arch>/<machine>
 211  * (ex "x86_64/pc"), because it will identify the node "x86_64/pc"
 212  * and start QEMU with "-M pc". For this reason,
 213  * when building path_str, path_vec
 214  * initially contains the <machine> at position 0 ("pc"),
 215  * and the node name at position 1 (<arch>/<machine>)
 216  * ("x86_64/pc"), followed by the rest of the nodes.
 217  */
 218 static void walk_path(QOSGraphNode *orig_path, int len)
 219 {
 220     QOSGraphNode *path;
 221     QOSGraphEdge *edge;
 222
 223     /* etype set to QEDGE_CONSUMED_BY so that machine can add to the command line */
 224     QOSEdgeType etype = QEDGE_CONSUMED_BY;
 225
 226     /* twice QOS_PATH_MAX_ELEMENT_SIZE since each edge can have its arg */
 227     char **path_vec = g_new0(char *, (QOS_PATH_MAX_ELEMENT_SIZE * 2));
 228     int path_vec_size = 0;
 229
 230     char *after_cmd, *before_cmd, *after_device;
 231     GString *after_device_str = g_string_new("");
 232     char *node_name = orig_path->name, *path_str;
 233
 234     GString *cmd_line = g_string_new("");
 235     GString *cmd_line2 = g_string_new("");
 236
 237     path = qos_graph_get_node(node_name); /* root */
 238     node_name = qos_graph_edge_get_dest(path->path_edge); /* machine name */
 239
 240     path_vec[path_vec_size++] = node_name;
 241     path_vec[path_vec_size++] = qos_get_machine_type(node_name);
 242
 243     for (;;) {
 244         path = qos_graph_get_node(node_name);
 245         if (!path->path_edge) {
 246             break;
 247         }
 248
 249         node_name = qos_graph_edge_get_dest(path->path_edge);
 250
 251         /* append node command line + previous edge command line */
 252         if (path->command_line && etype == QEDGE_CONSUMED_BY) {
 253             g_string_append(cmd_line, path->command_line);
 254             g_string_append(cmd_line, after_device_str->str);
 255             g_string_truncate(after_device_str, 0);
 256         }
 257
 258         path_vec[path_vec_size++] = qos_graph_edge_get_name(path->path_edge);
 259         /* detect if edge has command line args */
 260         after_cmd = qos_graph_edge_get_after_cmd_line(path->path_edge);
 261         after_device = qos_graph_edge_get_extra_device_opts(path->path_edge);
 262         before_cmd = qos_graph_edge_get_before_cmd_line(path->path_edge);
 263         edge = qos_graph_get_edge(path->name, node_name);
 264         etype = qos_graph_edge_get_type(edge);
 265
 266         if (before_cmd) {
 267             g_string_append(cmd_line, before_cmd);
 268         }
 269         if (after_cmd) {
 270             g_string_append(cmd_line2, after_cmd);
 271         }
 272         if (after_device) {
 273             g_string_append(after_device_str, after_device);
 274         }
 275     }
 276
 277     path_vec[path_vec_size++] = NULL;
 278     g_string_append(cmd_line, after_device_str->str);
 279     g_string_free(after_device_str, true);
 280
 281     g_string_append(cmd_line, cmd_line2->str);
 282     g_string_free(cmd_line2, true);
 283
 284     /* here position 0 has <arch>/<machine>, position 1 has <machine>.
 285      * The path must not have the <arch>, qtest_add_data_func adds it.
 286      */
 287     path_str = g_strjoinv("/", path_vec + 1);
 288
 289     /* put arch/machine in position 1 so run_one_test can do its work
 290      * and add the command line at position 0.
 291      */
 292     path_vec[1] = path_vec[0];
 293     path_vec[0] = g_string_free(cmd_line, false);
 294
 295     if (path->u.test.subprocess) {
 296         gchar *subprocess_path = g_strdup_printf("/%s/%s/subprocess",
 297                                                  qtest_get_arch(), path_str);
 298         qtest_add_data_func(path_str, subprocess_path, subprocess_run_one_test);
 299         g_test_add_data_func(subprocess_path, path_vec, run_one_test);
 300     } else {
 301         qtest_add_data_func(path_str, path_vec, run_one_test);
 302     }
 303
 304     g_free(path_str);
 305 }
 306
 307
 308
 309 /**
 310  * main(): heart of the qgraph framework.
 311  *
 312  * - Initializes the glib test framework
 313  * - Creates the graph by invoking the various _init constructors
 314  * - Starts QEMU to mark the available devices
 315  * - Walks the graph, and each path is added to
 316  *   the glib test framework (walk_path)
 317  * - Runs the tests, calling allocate_object() and allocating the
 318  *   machine/drivers/test objects
 319  * - Cleans up everything
 320  */
 321 int main(int argc, char **argv, char** envp)
 322 {
 323     g_test_init(&argc, &argv, NULL);
 324
 325     if (g_test_subprocess()) {
 326         qos_printf("qos_test running single test in subprocess\n");
 327     }
 328
 329     if (g_test_verbose()) {
 330         qos_printf("ENVIRONMENT VARIABLES: {\n");
 331         for (char **env = envp; *env != 0; env++) {
 332             qos_printf("\t%s\n", *env);
 333         }
 334         qos_printf("}\n");
 335     }
 336     qos_graph_init();
 337     module_call_init(MODULE_INIT_QOM);
 338     module_call_init(MODULE_INIT_LIBQOS);
 339     qos_set_machines_devices_available();
 340
 341     qos_graph_foreach_test_path(walk_path);
 342     if (g_test_verbose()) {
 343         qos_dump_graph();
 344     }
 345     g_test_run();
 346     qtest_end();
 347     qos_graph_destroy();
 348     g_free(old_path);
 349     return 0;
 350 }