qos-test.c (11727B)
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 }