2 * QMP protocol test cases
4 * Copyright (c) 2017 Red Hat Inc.
7 * Markus Armbruster <armbru@redhat.com>,
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.
13 #include "qemu/osdep.h"
15 #include "qapi/error.h"
16 #include "qapi/qapi-visit-introspect.h"
17 #include "qapi/qapi-visit-misc.h"
18 #include "qapi/qmp/qdict.h"
19 #include "qapi/qmp/qlist.h"
20 #include "qapi/qobject-input-visitor.h"
21 #include "qapi/util.h"
22 #include "qapi/visitor.h"
23 #include "qapi/qmp/qstring.h"
25 const char common_args
[] = "-nodefaults -machine none";
27 static const char *get_error_class(QDict
*resp
)
29 QDict
*error
= qdict_get_qdict(resp
, "error");
30 const char *desc
= qdict_get_try_str(error
, "desc");
33 return error
? qdict_get_try_str(error
, "class") : NULL
;
36 static void test_version(QObject
*version
)
42 v
= qobject_input_visitor_new(version
);
43 visit_type_VersionInfo(v
, "version", &vinfo
, &error_abort
);
44 qapi_free_VersionInfo(vinfo
);
48 static void test_malformed(QTestState
*qts
)
52 /* Not even a dictionary */
53 resp
= qtest_qmp(qts
, "null");
54 g_assert_cmpstr(get_error_class(resp
), ==, "GenericError");
57 /* No "execute" key */
58 resp
= qtest_qmp(qts
, "{}");
59 g_assert_cmpstr(get_error_class(resp
), ==, "GenericError");
62 /* "execute" isn't a string */
63 resp
= qtest_qmp(qts
, "{ 'execute': true }");
64 g_assert_cmpstr(get_error_class(resp
), ==, "GenericError");
67 /* "arguments" isn't a dictionary */
68 resp
= qtest_qmp(qts
, "{ 'execute': 'no-such-cmd', 'arguments': [] }");
69 g_assert_cmpstr(get_error_class(resp
), ==, "GenericError");
73 resp
= qtest_qmp(qts
, "{ 'execute': 'no-such-cmd', 'extra': true }");
74 g_assert_cmpstr(get_error_class(resp
), ==, "GenericError");
78 static void test_qmp_protocol(void)
80 QDict
*resp
, *q
, *ret
;
83 const QListEntry
*entry
;
87 qts
= qtest_init_without_qmp_handshake(common_args
);
90 resp
= qtest_qmp_receive(qts
);
91 q
= qdict_get_qdict(resp
, "QMP");
93 test_version(qdict_get(q
, "version"));
94 capabilities
= qdict_get_qlist(q
, "capabilities");
95 g_assert(capabilities
);
96 entry
= qlist_first(capabilities
);
98 qstr
= qobject_to(QString
, entry
->value
);
100 g_assert_cmpstr(qstring_get_str(qstr
), ==, "oob");
103 /* Test valid command before handshake */
104 resp
= qtest_qmp(qts
, "{ 'execute': 'query-version' }");
105 g_assert_cmpstr(get_error_class(resp
), ==, "CommandNotFound");
108 /* Test malformed commands before handshake */
112 resp
= qtest_qmp(qts
, "{ 'execute': 'qmp_capabilities' }");
113 ret
= qdict_get_qdict(resp
, "return");
114 g_assert(ret
&& !qdict_size(ret
));
117 /* Test repeated handshake */
118 resp
= qtest_qmp(qts
, "{ 'execute': 'qmp_capabilities' }");
119 g_assert_cmpstr(get_error_class(resp
), ==, "CommandNotFound");
122 /* Test valid command */
123 resp
= qtest_qmp(qts
, "{ 'execute': 'query-version' }");
124 test_version(qdict_get(resp
, "return"));
127 /* Test malformed commands */
131 resp
= qtest_qmp(qts
, "{ 'execute': 'query-name', 'id': 'cookie#1' }");
132 ret
= qdict_get_qdict(resp
, "return");
134 g_assert_cmpstr(qdict_get_try_str(resp
, "id"), ==, "cookie#1");
137 /* Test command failure with 'id' */
138 resp
= qtest_qmp(qts
, "{ 'execute': 'human-monitor-command', 'id': 2 }");
139 g_assert_cmpstr(get_error_class(resp
), ==, "GenericError");
140 g_assert_cmpint(qdict_get_int(resp
, "id"), ==, 2);
144 * Test command batching. In current test OOB is not enabled, we
145 * should be able to run as many commands in batch as we like.
146 * Using 16 (>8, which is OOB queue length) to make sure OOB won't
147 * break existing clients. Note: this test does not control the
148 * scheduling of QEMU's QMP command processing threads so it may
149 * not really trigger batching inside QEMU. This is just a
152 for (i
= 0; i
< 16; i
++) {
153 qtest_async_qmp(qts
, "{ 'execute': 'query-version' }");
155 /* Verify the replies to make sure no command is dropped. */
156 for (i
= 0; i
< 16; i
++) {
157 resp
= qtest_qmp_receive(qts
);
158 /* It should never be dropped. Each of them should be a reply. */
159 g_assert(qdict_haskey(resp
, "return"));
160 g_assert(!qdict_haskey(resp
, "event"));
167 /* Tests for Out-Of-Band support. */
168 static void test_qmp_oob(void)
174 global_qtest
= qtest_init_without_qmp_handshake(common_args
);
176 /* Ignore the greeting message. */
177 resp
= qmp_receive();
178 g_assert(qdict_get_qdict(resp
, "QMP"));
181 /* Try a fake capability, it should fail. */
182 resp
= qmp("{ 'execute': 'qmp_capabilities', "
183 " 'arguments': { 'enable': [ 'cap-does-not-exist' ] } }");
184 g_assert(qdict_haskey(resp
, "error"));
187 /* Now, enable OOB in current QMP session, it should succeed. */
188 resp
= qmp("{ 'execute': 'qmp_capabilities', "
189 " 'arguments': { 'enable': [ 'oob' ] } }");
190 g_assert(qdict_haskey(resp
, "return"));
194 * Try any command that does not support OOB but with OOB flag. We
195 * should get failure.
197 resp
= qmp("{ 'execute': 'query-cpus',"
198 " 'control': { 'run-oob': true } }");
199 g_assert(qdict_haskey(resp
, "error"));
203 * First send the "x-oob-test" command with lock=true and
204 * oob=false, it should hang the dispatcher and main thread;
205 * later, we send another lock=false with oob=true to continue
206 * that thread processing. Finally we should receive replies from
209 qmp_async("{ 'execute': 'x-oob-test',"
210 " 'arguments': { 'lock': true }, "
211 " 'id': 'lock-cmd'}");
212 qmp_async("{ 'execute': 'x-oob-test', "
213 " 'arguments': { 'lock': false }, "
214 " 'control': { 'run-oob': true }, "
215 " 'id': 'unlock-cmd' }");
217 /* Ignore all events. Wait for 2 acks */
219 resp
= qmp_receive();
220 cmd_id
= qdict_get_str(resp
, "id");
221 if (!g_strcmp0(cmd_id
, "lock-cmd") ||
222 !g_strcmp0(cmd_id
, "unlock-cmd")) {
231 static int query_error_class(const char *cmd
)
237 /* Success depends on build configuration: */
239 { "query-spice", ERROR_CLASS_COMMAND_NOT_FOUND
},
242 { "query-vnc", ERROR_CLASS_GENERIC_ERROR
},
243 { "query-vnc-servers", ERROR_CLASS_GENERIC_ERROR
},
245 #ifndef CONFIG_REPLICATION
246 { "query-xen-replication-status", ERROR_CLASS_COMMAND_NOT_FOUND
},
248 /* Likewise, and require special QEMU command-line arguments: */
249 { "query-acpi-ospm-status", ERROR_CLASS_GENERIC_ERROR
},
250 { "query-balloon", ERROR_CLASS_DEVICE_NOT_ACTIVE
},
251 { "query-hotpluggable-cpus", ERROR_CLASS_GENERIC_ERROR
},
252 { "query-vm-generation-id", ERROR_CLASS_GENERIC_ERROR
},
257 for (i
= 0; fails
[i
].cmd
; i
++) {
258 if (!strcmp(cmd
, fails
[i
].cmd
)) {
259 return fails
[i
].err_class
;
265 static void test_query(const void *data
)
267 const char *cmd
= data
;
268 int expected_error_class
= query_error_class(cmd
);
270 const char *error_class
;
272 qtest_start(common_args
);
274 resp
= qmp("{ 'execute': %s }", cmd
);
275 error
= qdict_get_qdict(resp
, "error");
276 error_class
= error
? qdict_get_str(error
, "class") : NULL
;
278 if (expected_error_class
< 0) {
279 g_assert(qdict_haskey(resp
, "return"));
282 g_assert_cmpint(qapi_enum_parse(&QapiErrorClass_lookup
, error_class
,
284 ==, expected_error_class
);
291 static bool query_is_blacklisted(const char *cmd
)
293 const char *blacklist
[] = {
294 /* Not actually queries: */
296 /* Success depends on target arch: */
297 "query-cpu-definitions", /* arm, i386, ppc, s390x */
298 "query-gic-capabilities", /* arm */
299 /* Success depends on target-specific build configuration: */
300 "query-pci", /* CONFIG_PCI */
301 /* Success depends on launching SEV guest */
302 "query-sev-launch-measure",
303 /* Success depends on Host or Hypervisor SEV support */
305 "query-sev-capabilities",
310 for (i
= 0; blacklist
[i
]; i
++) {
311 if (!strcmp(cmd
, blacklist
[i
])) {
319 SchemaInfoList
*list
;
323 static void qmp_schema_init(QmpSchema
*schema
)
327 SchemaInfoList
*tail
;
329 qtest_start(common_args
);
330 resp
= qmp("{ 'execute': 'query-qmp-schema' }");
332 qiv
= qobject_input_visitor_new(qdict_get(resp
, "return"));
333 visit_type_SchemaInfoList(qiv
, NULL
, &schema
->list
, &error_abort
);
339 schema
->hash
= g_hash_table_new(g_str_hash
, g_str_equal
);
341 /* Build @schema: hash table mapping entity name to SchemaInfo */
342 for (tail
= schema
->list
; tail
; tail
= tail
->next
) {
343 g_hash_table_insert(schema
->hash
, tail
->value
->name
, tail
->value
);
347 static SchemaInfo
*qmp_schema_lookup(QmpSchema
*schema
, const char *name
)
349 return g_hash_table_lookup(schema
->hash
, name
);
352 static void qmp_schema_cleanup(QmpSchema
*schema
)
354 qapi_free_SchemaInfoList(schema
->list
);
355 g_hash_table_destroy(schema
->hash
);
358 static bool object_type_has_mandatory_members(SchemaInfo
*type
)
360 SchemaInfoObjectMemberList
*tail
;
362 g_assert(type
->meta_type
== SCHEMA_META_TYPE_OBJECT
);
364 for (tail
= type
->u
.object
.members
; tail
; tail
= tail
->next
) {
365 if (!tail
->value
->has_q_default
) {
373 static void add_query_tests(QmpSchema
*schema
)
375 SchemaInfoList
*tail
;
376 SchemaInfo
*si
, *arg_type
, *ret_type
;
379 /* Test the query-like commands */
380 for (tail
= schema
->list
; tail
; tail
= tail
->next
) {
382 if (si
->meta_type
!= SCHEMA_META_TYPE_COMMAND
) {
386 if (query_is_blacklisted(si
->name
)) {
390 arg_type
= qmp_schema_lookup(schema
, si
->u
.command
.arg_type
);
391 if (object_type_has_mandatory_members(arg_type
)) {
395 ret_type
= qmp_schema_lookup(schema
, si
->u
.command
.ret_type
);
396 if (ret_type
->meta_type
== SCHEMA_META_TYPE_OBJECT
397 && !ret_type
->u
.object
.members
) {
401 test_name
= g_strdup_printf("qmp/%s", si
->name
);
402 qtest_add_data_func(test_name
, si
->name
, test_query
);
407 int main(int argc
, char *argv
[])
412 g_test_init(&argc
, &argv
, NULL
);
414 qtest_add_func("qmp/protocol", test_qmp_protocol
);
415 qtest_add_func("qmp/oob", test_qmp_oob
);
416 qmp_schema_init(&schema
);
417 add_query_tests(&schema
);
421 qmp_schema_cleanup(&schema
);