xref: /openbmc/qemu/tests/qtest/qos-test.c (revision 7f6c3d1a)
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/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     /* compares the current command line with the
93      * one previously executed: if they are the same,
94      * don't restart QEMU, if they differ, stop previous
95      * QEMU subprocess (if active) and start over with
96      * the new command line
97      */
98     if (g_strcmp0(old_path, path)) {
99         qtest_end();
100         qos_invalidate_command_line();
101         old_path = g_strdup(path);
102         qtest_start(path);
103     } else { /* if cmd line is the same, reset the guest */
104         qobject_unref(qmp("{ 'execute': 'system_reset' }"));
105         qmp_eventwait("RESET");
106     }
107 }
108 
109 void qos_invalidate_command_line(void)
110 {
111     g_free(old_path);
112     old_path = NULL;
113 }
114 
115 
116 /* The argument to run_one_test, which is the test function that is registered
117  * with GTest, is a vector of strings.  The first item is the initial command
118  * line (before it is modified by the test's "before" function), the remaining
119  * items are node names forming the path to the test node.
120  */
121 static char **current_path;
122 
123 const char *qos_get_current_command_line(void)
124 {
125     return current_path[0];
126 }
127 
128 void *qos_allocate_objects(QTestState *qts, QGuestAllocator **p_alloc)
129 {
130     return allocate_objects(qts, current_path + 1, p_alloc);
131 }
132 
133 /**
134  * run_one_test(): given an array of nodes @arg,
135  * walks the path invoking all constructors and
136  * passing the corresponding parameter in order to
137  * continue the objects allocation.
138  * Once the test is reached, its function is executed.
139  *
140  * Since the machine and QEDGE_CONSUMED_BY nodes allocate
141  * memory in the constructor, g_test_queue_destroy is used so
142  * that after execution they can be safely free'd.  The test's
143  * ->before callback is also welcome to use g_test_queue_destroy.
144  *
145  * Note: as specified in walk_path() too, @arg is an array of
146  * char *, where arg[0] is a pointer to the command line
147  * string that will be used to properly start QEMU when executing
148  * the test, and the remaining elements represent the actual objects
149  * that will be allocated.
150  *
151  * The order of execution is the following:
152  * 1) @before test function as defined in the given QOSGraphTestOptions
153  * 2) start QEMU
154  * 3) call all nodes constructor and get_driver/get_device depending on edge,
155  *    start the hardware (*_device_enable functions)
156  * 4) start test
157  */
158 static void run_one_test(const void *arg)
159 {
160     QOSGraphNode *test_node;
161     QGuestAllocator *alloc = NULL;
162     void *obj;
163     char **path = (char **) arg;
164     GString *cmd_line = g_string_new(path[0]);
165     void *test_arg;
166 
167     /* Before test */
168     current_path = path;
169     test_node = qos_graph_get_node(path[(g_strv_length(path) - 1)]);
170     test_arg = test_node->u.test.arg;
171     if (test_node->u.test.before) {
172         test_arg = test_node->u.test.before(cmd_line, test_arg);
173     }
174 
175     restart_qemu_or_continue(cmd_line->str);
176     g_string_free(cmd_line, true);
177 
178     obj = qos_allocate_objects(global_qtest, &alloc);
179     test_node->u.test.function(obj, test_arg, alloc);
180 }
181 
182 static void subprocess_run_one_test(const void *arg)
183 {
184     const gchar *path = arg;
185     g_test_trap_subprocess(path, 0, 0);
186     g_test_trap_assert_passed();
187 }
188 
189 /*
190  * in this function, 2 path will be built:
191  * path_str, a one-string path (ex "pc/i440FX-pcihost/...")
192  * path_vec, a string-array path (ex [0] = "pc", [1] = "i440FX-pcihost").
193  *
194  * path_str will be only used to build the test name, and won't need the
195  * architecture name at beginning, since it will be added by qtest_add_func().
196  *
197  * path_vec is used to allocate all constructors of the path nodes.
198  * Each name in this array except position 0 must correspond to a valid
199  * QOSGraphNode name.
200  * Position 0 is special, initially contains just the <machine> name of
201  * the node, (ex for "x86_64/pc" it will be "pc"), used to build the test
202  * path (see below). After it will contain the command line used to start
203  * qemu with all required devices.
204  *
205  * Note that the machine node name must be with format <arch>/<machine>
206  * (ex "x86_64/pc"), because it will identify the node "x86_64/pc"
207  * and start QEMU with "-M pc". For this reason,
208  * when building path_str, path_vec
209  * initially contains the <machine> at position 0 ("pc"),
210  * and the node name at position 1 (<arch>/<machine>)
211  * ("x86_64/pc"), followed by the rest of the nodes.
212  */
213 static void walk_path(QOSGraphNode *orig_path, int len)
214 {
215     QOSGraphNode *path;
216     QOSGraphEdge *edge;
217 
218     /* etype set to QEDGE_CONSUMED_BY so that machine can add to the command line */
219     QOSEdgeType etype = QEDGE_CONSUMED_BY;
220 
221     /* twice QOS_PATH_MAX_ELEMENT_SIZE since each edge can have its arg */
222     char **path_vec = g_new0(char *, (QOS_PATH_MAX_ELEMENT_SIZE * 2));
223     int path_vec_size = 0;
224 
225     char *after_cmd, *before_cmd, *after_device;
226     GString *after_device_str = g_string_new("");
227     char *node_name = orig_path->name, *path_str;
228 
229     GString *cmd_line = g_string_new("");
230     GString *cmd_line2 = g_string_new("");
231 
232     path = qos_graph_get_node(node_name); /* root */
233     node_name = qos_graph_edge_get_dest(path->path_edge); /* machine name */
234 
235     path_vec[path_vec_size++] = node_name;
236     path_vec[path_vec_size++] = qos_get_machine_type(node_name);
237 
238     for (;;) {
239         path = qos_graph_get_node(node_name);
240         if (!path->path_edge) {
241             break;
242         }
243 
244         node_name = qos_graph_edge_get_dest(path->path_edge);
245 
246         /* append node command line + previous edge command line */
247         if (path->command_line && etype == QEDGE_CONSUMED_BY) {
248             g_string_append(cmd_line, path->command_line);
249             g_string_append(cmd_line, after_device_str->str);
250             g_string_truncate(after_device_str, 0);
251         }
252 
253         path_vec[path_vec_size++] = qos_graph_edge_get_name(path->path_edge);
254         /* detect if edge has command line args */
255         after_cmd = qos_graph_edge_get_after_cmd_line(path->path_edge);
256         after_device = qos_graph_edge_get_extra_device_opts(path->path_edge);
257         before_cmd = qos_graph_edge_get_before_cmd_line(path->path_edge);
258         edge = qos_graph_get_edge(path->name, node_name);
259         etype = qos_graph_edge_get_type(edge);
260 
261         if (before_cmd) {
262             g_string_append(cmd_line, before_cmd);
263         }
264         if (after_cmd) {
265             g_string_append(cmd_line2, after_cmd);
266         }
267         if (after_device) {
268             g_string_append(after_device_str, after_device);
269         }
270     }
271 
272     path_vec[path_vec_size++] = NULL;
273     g_string_append(cmd_line, after_device_str->str);
274     g_string_free(after_device_str, true);
275 
276     g_string_append(cmd_line, cmd_line2->str);
277     g_string_free(cmd_line2, true);
278 
279     /* here position 0 has <arch>/<machine>, position 1 has <machine>.
280      * The path must not have the <arch>, qtest_add_data_func adds it.
281      */
282     path_str = g_strjoinv("/", path_vec + 1);
283 
284     /* put arch/machine in position 1 so run_one_test can do its work
285      * and add the command line at position 0.
286      */
287     path_vec[1] = path_vec[0];
288     path_vec[0] = g_string_free(cmd_line, false);
289 
290     if (path->u.test.subprocess) {
291         gchar *subprocess_path = g_strdup_printf("/%s/%s/subprocess",
292                                                  qtest_get_arch(), path_str);
293         qtest_add_data_func(path_str, subprocess_path, subprocess_run_one_test);
294         g_test_add_data_func(subprocess_path, path_vec, run_one_test);
295     } else {
296         qtest_add_data_func(path_str, path_vec, run_one_test);
297     }
298 
299     g_free(path_str);
300 }
301 
302 
303 
304 /**
305  * main(): heart of the qgraph framework.
306  *
307  * - Initializes the glib test framework
308  * - Creates the graph by invoking the various _init constructors
309  * - Starts QEMU to mark the available devices
310  * - Walks the graph, and each path is added to
311  *   the glib test framework (walk_path)
312  * - Runs the tests, calling allocate_object() and allocating the
313  *   machine/drivers/test objects
314  * - Cleans up everything
315  */
316 int main(int argc, char **argv)
317 {
318     g_test_init(&argc, &argv, NULL);
319     qos_graph_init();
320     module_call_init(MODULE_INIT_QOM);
321     module_call_init(MODULE_INIT_LIBQOS);
322     qos_set_machines_devices_available();
323 
324     qos_graph_foreach_test_path(walk_path);
325     g_test_run();
326     qtest_end();
327     qos_graph_destroy();
328     g_free(old_path);
329     return 0;
330 }
331