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