1 /* 2 * Device introspection test cases 3 * 4 * Copyright (c) 2015 Red Hat Inc. 5 * 6 * Authors: 7 * Markus Armbruster <armbru@redhat.com>, 8 * 9 * This work is licensed under the terms of the GNU GPL, version 2 or later. 10 * See the COPYING file in the top-level directory. 11 */ 12 13 /* 14 * Covers QMP device-list-properties and HMP device_add help. We 15 * currently don't check that their output makes sense, only that QEMU 16 * survives. Useful since we've had an astounding number of crash 17 * bugs around here. 18 */ 19 20 #include "qemu/osdep.h" 21 #include "qemu-common.h" 22 #include "qapi/qmp/qstring.h" 23 #include "qapi/qmp/qdict.h" 24 #include "qapi/qmp/qlist.h" 25 #include "libqos/libqtest.h" 26 27 const char common_args[] = "-nodefaults -machine none"; 28 29 static QList *qom_list_types(QTestState * qts, const char *implements, 30 bool abstract) 31 { 32 QDict *resp; 33 QList *ret; 34 QDict *args = qdict_new(); 35 36 qdict_put_bool(args, "abstract", abstract); 37 if (implements) { 38 qdict_put_str(args, "implements", implements); 39 } 40 resp = qtest_qmp(qts, "{'execute': 'qom-list-types', 'arguments': %p }", 41 args); 42 g_assert(qdict_haskey(resp, "return")); 43 ret = qdict_get_qlist(resp, "return"); 44 qobject_ref(ret); 45 qobject_unref(resp); 46 return ret; 47 } 48 49 /* Build a name -> ObjectTypeInfo index from a ObjectTypeInfo list */ 50 static QDict *qom_type_index(QList *types) 51 { 52 QDict *index = qdict_new(); 53 QListEntry *e; 54 55 QLIST_FOREACH_ENTRY(types, e) { 56 QDict *d = qobject_to(QDict, qlist_entry_obj(e)); 57 const char *name = qdict_get_str(d, "name"); 58 qobject_ref(d); 59 qdict_put(index, name, d); 60 } 61 return index; 62 } 63 64 /* Check if @parent is present in the parent chain of @type */ 65 static bool qom_has_parent(QDict *index, const char *type, const char *parent) 66 { 67 while (type) { 68 QDict *d = qdict_get_qdict(index, type); 69 const char *p = d && qdict_haskey(d, "parent") ? 70 qdict_get_str(d, "parent") : 71 NULL; 72 73 if (!strcmp(type, parent)) { 74 return true; 75 } 76 77 type = p; 78 } 79 80 return false; 81 } 82 83 /* Find an entry on a list returned by qom-list-types */ 84 static QDict *type_list_find(QList *types, const char *name) 85 { 86 QListEntry *e; 87 88 QLIST_FOREACH_ENTRY(types, e) { 89 QDict *d = qobject_to(QDict, qlist_entry_obj(e)); 90 const char *ename = qdict_get_str(d, "name"); 91 if (!strcmp(ename, name)) { 92 return d; 93 } 94 } 95 96 return NULL; 97 } 98 99 static QList *device_type_list(QTestState *qts, bool abstract) 100 { 101 return qom_list_types(qts, "device", abstract); 102 } 103 104 static void test_one_device(QTestState *qts, const char *type) 105 { 106 QDict *resp; 107 char *help; 108 109 g_test_message("Testing device '%s'", type); 110 111 resp = qtest_qmp(qts, "{'execute': 'device-list-properties'," 112 " 'arguments': {'typename': %s}}", 113 type); 114 qobject_unref(resp); 115 116 help = qtest_hmp(qts, "device_add \"%s,help\"", type); 117 g_free(help); 118 } 119 120 static void test_device_intro_list(void) 121 { 122 QList *types; 123 char *help; 124 QTestState *qts; 125 126 qts = qtest_init(common_args); 127 128 types = device_type_list(qts, true); 129 qobject_unref(types); 130 131 help = qtest_hmp(qts, "device_add help"); 132 g_free(help); 133 134 qtest_quit(qts); 135 } 136 137 /* 138 * Ensure all entries returned by qom-list-types implements=<parent> 139 * have <parent> as a parent. 140 */ 141 static void test_qom_list_parents(QTestState *qts, const char *parent) 142 { 143 QList *types; 144 QListEntry *e; 145 QDict *index; 146 147 types = qom_list_types(qts, parent, true); 148 index = qom_type_index(types); 149 150 QLIST_FOREACH_ENTRY(types, e) { 151 QDict *d = qobject_to(QDict, qlist_entry_obj(e)); 152 const char *name = qdict_get_str(d, "name"); 153 154 g_assert(qom_has_parent(index, name, parent)); 155 } 156 157 qobject_unref(types); 158 qobject_unref(index); 159 } 160 161 static void test_qom_list_fields(void) 162 { 163 QList *all_types; 164 QList *non_abstract; 165 QListEntry *e; 166 QTestState *qts; 167 168 qts = qtest_init(common_args); 169 170 all_types = qom_list_types(qts, NULL, true); 171 non_abstract = qom_list_types(qts, NULL, false); 172 173 QLIST_FOREACH_ENTRY(all_types, e) { 174 QDict *d = qobject_to(QDict, qlist_entry_obj(e)); 175 const char *name = qdict_get_str(d, "name"); 176 bool abstract = qdict_haskey(d, "abstract") ? 177 qdict_get_bool(d, "abstract") : 178 false; 179 bool expected_abstract = !type_list_find(non_abstract, name); 180 181 g_assert(abstract == expected_abstract); 182 } 183 184 test_qom_list_parents(qts, "object"); 185 test_qom_list_parents(qts, "device"); 186 test_qom_list_parents(qts, "sys-bus-device"); 187 188 qobject_unref(all_types); 189 qobject_unref(non_abstract); 190 qtest_quit(qts); 191 } 192 193 static void test_device_intro_none(void) 194 { 195 QTestState *qts = qtest_init(common_args); 196 g_autofree char *qom_tree_start = qtest_hmp(qts, "info qom-tree"); 197 g_autofree char *qom_tree_end = NULL; 198 g_autofree char *qtree_start = qtest_hmp(qts, "info qtree"); 199 g_autofree char *qtree_end = NULL; 200 201 test_one_device(qts, "nonexistent"); 202 203 /* Make sure that really nothing changed in the trees */ 204 qom_tree_end = qtest_hmp(qts, "info qom-tree"); 205 g_assert_cmpstr(qom_tree_start, ==, qom_tree_end); 206 qtree_end = qtest_hmp(qts, "info qtree"); 207 g_assert_cmpstr(qtree_start, ==, qtree_end); 208 209 qtest_quit(qts); 210 } 211 212 static void test_device_intro_abstract(void) 213 { 214 QTestState *qts = qtest_init(common_args); 215 g_autofree char *qom_tree_start = qtest_hmp(qts, "info qom-tree"); 216 g_autofree char *qom_tree_end = NULL; 217 g_autofree char *qtree_start = qtest_hmp(qts, "info qtree"); 218 g_autofree char *qtree_end = NULL; 219 220 test_one_device(qts, "device"); 221 222 /* Make sure that really nothing changed in the trees */ 223 qom_tree_end = qtest_hmp(qts, "info qom-tree"); 224 g_assert_cmpstr(qom_tree_start, ==, qom_tree_end); 225 qtree_end = qtest_hmp(qts, "info qtree"); 226 g_assert_cmpstr(qtree_start, ==, qtree_end); 227 228 qtest_quit(qts); 229 } 230 231 static void test_device_intro_concrete(const void *args) 232 { 233 QList *types; 234 QListEntry *entry; 235 const char *type; 236 QTestState *qts = qtest_init(args); 237 g_autofree char *qom_tree_start = qtest_hmp(qts, "info qom-tree"); 238 g_autofree char *qom_tree_end = NULL; 239 g_autofree char *qtree_start = qtest_hmp(qts, "info qtree"); 240 g_autofree char *qtree_end = NULL; 241 242 types = device_type_list(qts, false); 243 244 QLIST_FOREACH_ENTRY(types, entry) { 245 type = qdict_get_try_str(qobject_to(QDict, qlist_entry_obj(entry)), 246 "name"); 247 g_assert(type); 248 test_one_device(qts, type); 249 } 250 251 /* 252 * Some devices leave dangling pointers in QOM behind. 253 * "info qom-tree" or "info qtree" have a good chance at crashing then. 254 * Also make sure that the tree did not change. 255 */ 256 qom_tree_end = qtest_hmp(qts, "info qom-tree"); 257 g_assert_cmpstr(qom_tree_start, ==, qom_tree_end); 258 259 qtree_end = qtest_hmp(qts, "info qtree"); 260 g_assert_cmpstr(qtree_start, ==, qtree_end); 261 262 qobject_unref(types); 263 qtest_quit(qts); 264 g_free((void *)args); 265 } 266 267 static void test_abstract_interfaces(void) 268 { 269 QList *all_types; 270 QListEntry *e; 271 QDict *index; 272 QTestState *qts; 273 274 qts = qtest_init(common_args); 275 276 all_types = qom_list_types(qts, "interface", true); 277 index = qom_type_index(all_types); 278 279 QLIST_FOREACH_ENTRY(all_types, e) { 280 QDict *d = qobject_to(QDict, qlist_entry_obj(e)); 281 const char *name = qdict_get_str(d, "name"); 282 283 /* 284 * qom-list-types implements=interface returns all types 285 * that implement _any_ interface (not just interface 286 * types), so skip the ones that don't have "interface" 287 * on the parent type chain. 288 */ 289 if (!qom_has_parent(index, name, "interface")) { 290 /* Not an interface type */ 291 continue; 292 } 293 294 g_assert(qdict_haskey(d, "abstract") && qdict_get_bool(d, "abstract")); 295 } 296 297 qobject_unref(all_types); 298 qobject_unref(index); 299 qtest_quit(qts); 300 } 301 302 static void add_machine_test_case(const char *mname) 303 { 304 char *path, *args; 305 306 path = g_strdup_printf("device/introspect/concrete/defaults/%s", mname); 307 args = g_strdup_printf("-M %s", mname); 308 qtest_add_data_func(path, args, test_device_intro_concrete); 309 g_free(path); 310 311 path = g_strdup_printf("device/introspect/concrete/nodefaults/%s", mname); 312 args = g_strdup_printf("-nodefaults -M %s", mname); 313 qtest_add_data_func(path, args, test_device_intro_concrete); 314 g_free(path); 315 } 316 317 int main(int argc, char **argv) 318 { 319 g_test_init(&argc, &argv, NULL); 320 321 qtest_add_func("device/introspect/list", test_device_intro_list); 322 qtest_add_func("device/introspect/list-fields", test_qom_list_fields); 323 qtest_add_func("device/introspect/none", test_device_intro_none); 324 qtest_add_func("device/introspect/abstract", test_device_intro_abstract); 325 qtest_add_func("device/introspect/abstract-interfaces", test_abstract_interfaces); 326 if (g_test_quick()) { 327 qtest_add_data_func("device/introspect/concrete/defaults/none", 328 g_strdup(common_args), test_device_intro_concrete); 329 } else { 330 qtest_cb_for_every_machine(add_machine_test_case, true); 331 } 332 333 return g_test_run(); 334 } 335