xref: /openbmc/qemu/tests/qtest/qmp-cmd-test.c (revision 7acafcfa) 
1 /*
2  * QMP command test cases
3  *
4  * Copyright (c) 2017 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 #include "qemu/osdep.h"
14 #include "libqtest.h"
15 #include "qapi/error.h"
16 #include "qapi/qapi-visit-introspect.h"
17 #include "qapi/qmp/qdict.h"
18 #include "qapi/qobject-input-visitor.h"
19 
20 const char common_args[] = "-nodefaults -machine none";
21 
22 /* Query smoke tests */
23 
24 static int query_error_class(const char *cmd)
25 {
26     static struct {
27         const char *cmd;
28         int err_class;
29     } fails[] = {
30         /* Success depends on build configuration: */
31 #ifndef CONFIG_SPICE
32         { "query-spice", ERROR_CLASS_COMMAND_NOT_FOUND },
33 #endif
34 #ifndef CONFIG_VNC
35         { "query-vnc", ERROR_CLASS_GENERIC_ERROR },
36         { "query-vnc-servers", ERROR_CLASS_GENERIC_ERROR },
37 #endif
38 #ifndef CONFIG_REPLICATION
39         { "query-xen-replication-status", ERROR_CLASS_COMMAND_NOT_FOUND },
40 #endif
41         /* Likewise, and require special QEMU command-line arguments: */
42         { "query-acpi-ospm-status", ERROR_CLASS_GENERIC_ERROR },
43         { "query-balloon", ERROR_CLASS_DEVICE_NOT_ACTIVE },
44         { "query-hotpluggable-cpus", ERROR_CLASS_GENERIC_ERROR },
45         { "query-vm-generation-id", ERROR_CLASS_GENERIC_ERROR },
46         { NULL, -1 }
47     };
48     int i;
49 
50     for (i = 0; fails[i].cmd; i++) {
51         if (!strcmp(cmd, fails[i].cmd)) {
52             return fails[i].err_class;
53         }
54     }
55     return -1;
56 }
57 
58 static void test_query(const void *data)
59 {
60     const char *cmd = data;
61     int expected_error_class = query_error_class(cmd);
62     QDict *resp, *error;
63     const char *error_class;
64     QTestState *qts;
65 
66     qts = qtest_init(common_args);
67 
68     resp = qtest_qmp(qts, "{ 'execute': %s }", cmd);
69     error = qdict_get_qdict(resp, "error");
70     error_class = error ? qdict_get_str(error, "class") : NULL;
71 
72     if (expected_error_class < 0) {
73         g_assert(qdict_haskey(resp, "return"));
74     } else {
75         g_assert(error);
76         g_assert_cmpint(qapi_enum_parse(&QapiErrorClass_lookup, error_class,
77                                         -1, &error_abort),
78                         ==, expected_error_class);
79     }
80     qobject_unref(resp);
81 
82     qtest_quit(qts);
83 }
84 
85 static bool query_is_blacklisted(const char *cmd)
86 {
87     const char *blacklist[] = {
88         /* Not actually queries: */
89         "add-fd",
90         /* Success depends on target arch: */
91         "query-cpu-definitions",  /* arm, i386, ppc, s390x */
92         "query-gic-capabilities", /* arm */
93         /* Success depends on target-specific build configuration: */
94         "query-pci",              /* CONFIG_PCI */
95         /* Success depends on launching SEV guest */
96         "query-sev-launch-measure",
97         /* Success depends on Host or Hypervisor SEV support */
98         "query-sev",
99         "query-sev-capabilities",
100         NULL
101     };
102     int i;
103 
104     for (i = 0; blacklist[i]; i++) {
105         if (!strcmp(cmd, blacklist[i])) {
106             return true;
107         }
108     }
109     return false;
110 }
111 
112 typedef struct {
113     SchemaInfoList *list;
114     GHashTable *hash;
115 } QmpSchema;
116 
117 static void qmp_schema_init(QmpSchema *schema)
118 {
119     QDict *resp;
120     Visitor *qiv;
121     SchemaInfoList *tail;
122     QTestState *qts;
123 
124     qts = qtest_init(common_args);
125 
126     resp = qtest_qmp(qts, "{ 'execute': 'query-qmp-schema' }");
127 
128     qiv = qobject_input_visitor_new(qdict_get(resp, "return"));
129     visit_type_SchemaInfoList(qiv, NULL, &schema->list, &error_abort);
130     visit_free(qiv);
131 
132     qobject_unref(resp);
133     qtest_quit(qts);
134 
135     schema->hash = g_hash_table_new(g_str_hash, g_str_equal);
136 
137     /* Build @schema: hash table mapping entity name to SchemaInfo */
138     for (tail = schema->list; tail; tail = tail->next) {
139         g_hash_table_insert(schema->hash, tail->value->name, tail->value);
140     }
141 }
142 
143 static SchemaInfo *qmp_schema_lookup(QmpSchema *schema, const char *name)
144 {
145     return g_hash_table_lookup(schema->hash, name);
146 }
147 
148 static void qmp_schema_cleanup(QmpSchema *schema)
149 {
150     qapi_free_SchemaInfoList(schema->list);
151     g_hash_table_destroy(schema->hash);
152 }
153 
154 static bool object_type_has_mandatory_members(SchemaInfo *type)
155 {
156     SchemaInfoObjectMemberList *tail;
157 
158     g_assert(type->meta_type == SCHEMA_META_TYPE_OBJECT);
159 
160     for (tail = type->u.object.members; tail; tail = tail->next) {
161         if (!tail->value->has_q_default) {
162             return true;
163         }
164     }
165 
166     return false;
167 }
168 
169 static void add_query_tests(QmpSchema *schema)
170 {
171     SchemaInfoList *tail;
172     SchemaInfo *si, *arg_type, *ret_type;
173     char *test_name;
174 
175     /* Test the query-like commands */
176     for (tail = schema->list; tail; tail = tail->next) {
177         si = tail->value;
178         if (si->meta_type != SCHEMA_META_TYPE_COMMAND) {
179             continue;
180         }
181 
182         if (query_is_blacklisted(si->name)) {
183             continue;
184         }
185 
186         arg_type = qmp_schema_lookup(schema, si->u.command.arg_type);
187         if (object_type_has_mandatory_members(arg_type)) {
188             continue;
189         }
190 
191         ret_type = qmp_schema_lookup(schema, si->u.command.ret_type);
192         if (ret_type->meta_type == SCHEMA_META_TYPE_OBJECT
193             && !ret_type->u.object.members) {
194             continue;
195         }
196 
197         test_name = g_strdup_printf("qmp/%s", si->name);
198         qtest_add_data_func(test_name, si->name, test_query);
199         g_free(test_name);
200     }
201 }
202 
203 static void test_object_add_failure_modes(void)
204 {
205     QTestState *qts;
206     QDict *resp;
207 
208     /* attempt to create an object without props */
209     qts = qtest_init(common_args);
210     resp = qtest_qmp(qts, "{'execute': 'object-add', 'arguments':"
211                      " {'qom-type': 'memory-backend-ram', 'id': 'ram1' } }");
212     g_assert_nonnull(resp);
213     qmp_assert_error_class(resp, "GenericError");
214 
215     /* attempt to create an object without qom-type */
216     resp = qtest_qmp(qts, "{'execute': 'object-add', 'arguments':"
217                      " {'id': 'ram1' } }");
218     g_assert_nonnull(resp);
219     qmp_assert_error_class(resp, "GenericError");
220 
221     /* attempt to delete an object that does not exist */
222     resp = qtest_qmp(qts, "{'execute': 'object-del', 'arguments':"
223                      " {'id': 'ram1' } }");
224     g_assert_nonnull(resp);
225     qmp_assert_error_class(resp, "GenericError");
226 
227     /* attempt to create 2 objects with duplicate id */
228     resp = qtest_qmp(qts, "{'execute': 'object-add', 'arguments':"
229                      " {'qom-type': 'memory-backend-ram', 'id': 'ram1',"
230                      " 'props': {'size': 1048576 } } }");
231     g_assert_nonnull(resp);
232     g_assert(qdict_haskey(resp, "return"));
233     resp = qtest_qmp(qts, "{'execute': 'object-add', 'arguments':"
234                      " {'qom-type': 'memory-backend-ram', 'id': 'ram1',"
235                      " 'props': {'size': 1048576 } } }");
236     g_assert_nonnull(resp);
237     qmp_assert_error_class(resp, "GenericError");
238 
239     /* delete ram1 object */
240     resp = qtest_qmp(qts, "{'execute': 'object-del', 'arguments':"
241                      " {'id': 'ram1' } }");
242     g_assert_nonnull(resp);
243     g_assert(qdict_haskey(resp, "return"));
244 
245     /* attempt to create an object with a property of a wrong type */
246     resp = qtest_qmp(qts, "{'execute': 'object-add', 'arguments':"
247                      " {'qom-type': 'memory-backend-ram', 'id': 'ram1',"
248                      " 'props': {'size': '1048576' } } }");
249     g_assert_nonnull(resp);
250     /* now do it right */
251     qmp_assert_error_class(resp, "GenericError");
252     resp = qtest_qmp(qts, "{'execute': 'object-add', 'arguments':"
253                      " {'qom-type': 'memory-backend-ram', 'id': 'ram1',"
254                      " 'props': {'size': 1048576 } } }");
255     g_assert_nonnull(resp);
256     g_assert(qdict_haskey(resp, "return"));
257 
258     /* delete ram1 object */
259     resp = qtest_qmp(qts, "{'execute': 'object-del', 'arguments':"
260                      " {'id': 'ram1' } }");
261     g_assert_nonnull(resp);
262     g_assert(qdict_haskey(resp, "return"));
263 
264     /* attempt to create an object without the id */
265     resp = qtest_qmp(qts, "{'execute': 'object-add', 'arguments':"
266                      " {'qom-type': 'memory-backend-ram',"
267                      " 'props': {'size': 1048576 } } }");
268     g_assert_nonnull(resp);
269     qmp_assert_error_class(resp, "GenericError");
270     /* now do it right */
271     resp = qtest_qmp(qts, "{'execute': 'object-add', 'arguments':"
272                      " {'qom-type': 'memory-backend-ram', 'id': 'ram1',"
273                      " 'props': {'size': 1048576 } } }");
274     g_assert_nonnull(resp);
275     g_assert(qdict_haskey(resp, "return"));
276 
277     /* delete ram1 object */
278     resp = qtest_qmp(qts, "{'execute': 'object-del', 'arguments':"
279                      " {'id': 'ram1' } }");
280     g_assert_nonnull(resp);
281     g_assert(qdict_haskey(resp, "return"));
282 
283     /* attempt to set a non existing property */
284     resp = qtest_qmp(qts, "{'execute': 'object-add', 'arguments':"
285                      " {'qom-type': 'memory-backend-ram', 'id': 'ram1',"
286                      " 'props': {'sized': 1048576 } } }");
287     g_assert_nonnull(resp);
288     qmp_assert_error_class(resp, "GenericError");
289     /* now do it right */
290     resp = qtest_qmp(qts, "{'execute': 'object-add', 'arguments':"
291                      " {'qom-type': 'memory-backend-ram', 'id': 'ram1',"
292                      " 'props': {'size': 1048576 } } }");
293     g_assert_nonnull(resp);
294     g_assert(qdict_haskey(resp, "return"));
295 
296     /* delete ram1 object without id */
297     resp = qtest_qmp(qts, "{'execute': 'object-del', 'arguments':"
298                      " {'ida': 'ram1' } }");
299     g_assert_nonnull(resp);
300 
301     /* delete ram1 object */
302     resp = qtest_qmp(qts, "{'execute': 'object-del', 'arguments':"
303                      " {'id': 'ram1' } }");
304     g_assert_nonnull(resp);
305     g_assert(qdict_haskey(resp, "return"));
306 
307     /* delete ram1 object that does not exist anymore*/
308     resp = qtest_qmp(qts, "{'execute': 'object-del', 'arguments':"
309                      " {'id': 'ram1' } }");
310     g_assert_nonnull(resp);
311     qmp_assert_error_class(resp, "GenericError");
312 
313     qtest_quit(qts);
314 }
315 
316 int main(int argc, char *argv[])
317 {
318     QmpSchema schema;
319     int ret;
320 
321     g_test_init(&argc, &argv, NULL);
322 
323     qmp_schema_init(&schema);
324     add_query_tests(&schema);
325 
326     qtest_add_func("qmp/object-add-failure-modes",
327                    test_object_add_failure_modes);
328 
329     ret = g_test_run();
330 
331     qmp_schema_cleanup(&schema);
332     return ret;
333 }
334