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