xref: /openbmc/qemu/tests/qtest/qmp-test.c (revision 7c08eefc) 
1 /*
2  * QMP protocol test cases
3  *
4  * Copyright (c) 2017-2018 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-control.h"
17 #include "qapi/qmp/qdict.h"
18 #include "qapi/qmp/qlist.h"
19 #include "qapi/qobject-input-visitor.h"
20 #include "qapi/qmp/qstring.h"
21 
22 const char common_args[] = "-nodefaults -machine none";
23 
24 static void test_version(QObject *version)
25 {
26     Visitor *v;
27     VersionInfo *vinfo;
28 
29     g_assert(version);
30     v = qobject_input_visitor_new(version);
31     visit_type_VersionInfo(v, "version", &vinfo, &error_abort);
32     qapi_free_VersionInfo(vinfo);
33     visit_free(v);
34 }
35 
36 static void assert_recovered(QTestState *qts)
37 {
38     QDict *resp;
39 
40     resp = qtest_qmp(qts, "{ 'execute': 'no-such-cmd' }");
41     qmp_expect_error_and_unref(resp, "CommandNotFound");
42 }
43 
44 static void test_malformed(QTestState *qts)
45 {
46     QDict *resp;
47 
48     /* syntax error */
49     qtest_qmp_send_raw(qts, "{]\n");
50     resp = qtest_qmp_receive_dict(qts);
51     qmp_expect_error_and_unref(resp, "GenericError");
52     assert_recovered(qts);
53 
54     /* lexical error: impossible byte outside string */
55     qtest_qmp_send_raw(qts, "{\xFF");
56     resp = qtest_qmp_receive_dict(qts);
57     qmp_expect_error_and_unref(resp, "GenericError");
58     assert_recovered(qts);
59 
60     /* lexical error: funny control character outside string */
61     qtest_qmp_send_raw(qts, "{\x01");
62     resp = qtest_qmp_receive_dict(qts);
63     qmp_expect_error_and_unref(resp, "GenericError");
64     assert_recovered(qts);
65 
66     /* lexical error: impossible byte in string */
67     qtest_qmp_send_raw(qts, "{'bad \xFF");
68     resp = qtest_qmp_receive_dict(qts);
69     qmp_expect_error_and_unref(resp, "GenericError");
70     assert_recovered(qts);
71 
72     /* lexical error: control character in string */
73     qtest_qmp_send_raw(qts, "{'execute': 'nonexistent', 'id':'\n");
74     resp = qtest_qmp_receive_dict(qts);
75     qmp_expect_error_and_unref(resp, "GenericError");
76     assert_recovered(qts);
77 
78     /* lexical error: interpolation */
79     qtest_qmp_send_raw(qts, "%%p");
80     resp = qtest_qmp_receive_dict(qts);
81     qmp_expect_error_and_unref(resp, "GenericError");
82     assert_recovered(qts);
83 
84     /* Not even a dictionary */
85     resp = qtest_qmp(qts, "null");
86     qmp_expect_error_and_unref(resp, "GenericError");
87 
88     /* No "execute" key */
89     resp = qtest_qmp(qts, "{}");
90     qmp_expect_error_and_unref(resp, "GenericError");
91 
92     /* "execute" isn't a string */
93     resp = qtest_qmp(qts, "{ 'execute': true }");
94     qmp_expect_error_and_unref(resp, "GenericError");
95 
96     /* "arguments" isn't a dictionary */
97     resp = qtest_qmp(qts, "{ 'execute': 'no-such-cmd', 'arguments': [] }");
98     qmp_expect_error_and_unref(resp, "GenericError");
99 
100     /* extra key */
101     resp = qtest_qmp(qts, "{ 'execute': 'no-such-cmd', 'extra': true }");
102     qmp_expect_error_and_unref(resp, "GenericError");
103 }
104 
105 static void test_qmp_protocol(void)
106 {
107     QDict *resp, *q, *ret;
108     QList *capabilities;
109     QTestState *qts;
110 
111     qts = qtest_init_without_qmp_handshake(common_args);
112 
113     /* Test greeting */
114     resp = qtest_qmp_receive_dict(qts);
115     q = qdict_get_qdict(resp, "QMP");
116     g_assert(q);
117     test_version(qdict_get(q, "version"));
118     capabilities = qdict_get_qlist(q, "capabilities");
119     g_assert(capabilities);
120     qobject_unref(resp);
121 
122     /* Test valid command before handshake */
123     resp = qtest_qmp(qts, "{ 'execute': 'query-version' }");
124     qmp_expect_error_and_unref(resp, "CommandNotFound");
125 
126     /* Test malformed commands before handshake */
127     test_malformed(qts);
128 
129     /* Test handshake */
130     resp = qtest_qmp(qts, "{ 'execute': 'qmp_capabilities' }");
131     ret = qdict_get_qdict(resp, "return");
132     g_assert(ret && !qdict_size(ret));
133     qobject_unref(resp);
134 
135     /* Test repeated handshake */
136     resp = qtest_qmp(qts, "{ 'execute': 'qmp_capabilities' }");
137     qmp_expect_error_and_unref(resp, "CommandNotFound");
138 
139     /* Test valid command */
140     resp = qtest_qmp(qts, "{ 'execute': 'query-version' }");
141     test_version(qdict_get(resp, "return"));
142     qobject_unref(resp);
143 
144     /* Test malformed commands */
145     test_malformed(qts);
146 
147     /* Test 'id' */
148     resp = qtest_qmp(qts, "{ 'execute': 'query-name', 'id': 'cookie#1' }");
149     ret = qdict_get_qdict(resp, "return");
150     g_assert(ret);
151     g_assert_cmpstr(qdict_get_try_str(resp, "id"), ==, "cookie#1");
152     qobject_unref(resp);
153 
154     /* Test command failure with 'id' */
155     resp = qtest_qmp(qts, "{ 'execute': 'human-monitor-command', 'id': 2 }");
156     g_assert_cmpint(qdict_get_int(resp, "id"), ==, 2);
157     qmp_expect_error_and_unref(resp, "GenericError");
158 
159     qtest_quit(qts);
160 }
161 
162 #ifndef _WIN32
163 
164 /* Out-of-band tests */
165 
166 char *tmpdir;
167 char *fifo_name;
168 
169 static void setup_blocking_cmd(void)
170 {
171     GError *err = NULL;
172     tmpdir = g_dir_make_tmp("qmp-test-XXXXXX", &err);
173     g_assert_no_error(err);
174 
175     fifo_name = g_strdup_printf("%s/fifo", tmpdir);
176     if (mkfifo(fifo_name, 0666)) {
177         g_error("mkfifo: %s", strerror(errno));
178     }
179 }
180 
181 static void cleanup_blocking_cmd(void)
182 {
183     unlink(fifo_name);
184     rmdir(tmpdir);
185     g_free(tmpdir);
186 }
187 
188 static void send_cmd_that_blocks(QTestState *s, const char *id)
189 {
190     qtest_qmp_send(s, "{ 'execute': 'blockdev-add',  'id': %s,"
191                    " 'arguments': {"
192                    " 'driver': 'blkdebug', 'node-name': %s,"
193                    " 'config': %s,"
194                    " 'image': { 'driver': 'null-co', 'read-zeroes': true } } }",
195                    id, id, fifo_name);
196 }
197 
198 static void unblock_blocked_cmd(void)
199 {
200     int fd = open(fifo_name, O_WRONLY);
201     g_assert(fd >= 0);
202     close(fd);
203 }
204 
205 static void send_oob_cmd_that_fails(QTestState *s, const char *id)
206 {
207     qtest_qmp_send(s, "{ 'exec-oob': 'migrate-pause', 'id': %s }", id);
208 }
209 
210 static void recv_cmd_id(QTestState *s, const char *id)
211 {
212     QDict *resp = qtest_qmp_receive_dict(s);
213 
214     g_assert_cmpstr(qdict_get_try_str(resp, "id"), ==, id);
215     qobject_unref(resp);
216 }
217 
218 static void test_qmp_oob(void)
219 {
220     QTestState *qts;
221     QDict *resp, *q;
222     const QListEntry *entry;
223     QList *capabilities;
224     QString *qstr;
225 
226     qts = qtest_init_without_qmp_handshake(common_args);
227 
228     /* Check the greeting message. */
229     resp = qtest_qmp_receive_dict(qts);
230     q = qdict_get_qdict(resp, "QMP");
231     g_assert(q);
232     capabilities = qdict_get_qlist(q, "capabilities");
233     g_assert(capabilities && !qlist_empty(capabilities));
234     entry = qlist_first(capabilities);
235     g_assert(entry);
236     qstr = qobject_to(QString, entry->value);
237     g_assert(qstr);
238     g_assert_cmpstr(qstring_get_str(qstr), ==, "oob");
239     qobject_unref(resp);
240 
241     /* Try a fake capability, it should fail. */
242     resp = qtest_qmp(qts,
243                      "{ 'execute': 'qmp_capabilities', "
244                      "  'arguments': { 'enable': [ 'cap-does-not-exist' ] } }");
245     g_assert(qdict_haskey(resp, "error"));
246     qobject_unref(resp);
247 
248     /* Now, enable OOB in current QMP session, it should succeed. */
249     resp = qtest_qmp(qts,
250                      "{ 'execute': 'qmp_capabilities', "
251                      "  'arguments': { 'enable': [ 'oob' ] } }");
252     g_assert(qdict_haskey(resp, "return"));
253     qobject_unref(resp);
254 
255     /*
256      * Try any command that does not support OOB but with OOB flag. We
257      * should get failure.
258      */
259     resp = qtest_qmp(qts, "{ 'exec-oob': 'query-cpus-fast' }");
260     g_assert(qdict_haskey(resp, "error"));
261     qobject_unref(resp);
262 
263     /* OOB command overtakes slow in-band command */
264     setup_blocking_cmd();
265     send_cmd_that_blocks(qts, "ib-blocks-1");
266     qtest_qmp_send(qts, "{ 'execute': 'query-name', 'id': 'ib-quick-1' }");
267     send_oob_cmd_that_fails(qts, "oob-1");
268     recv_cmd_id(qts, "oob-1");
269     unblock_blocked_cmd();
270     recv_cmd_id(qts, "ib-blocks-1");
271     recv_cmd_id(qts, "ib-quick-1");
272 
273     /* Even malformed in-band command fails in-band */
274     send_cmd_that_blocks(qts, "blocks-2");
275     qtest_qmp_send(qts, "{ 'id': 'err-2' }");
276     unblock_blocked_cmd();
277     recv_cmd_id(qts, "blocks-2");
278     recv_cmd_id(qts, "err-2");
279     cleanup_blocking_cmd();
280 
281     qtest_quit(qts);
282 }
283 
284 #endif /* _WIN32 */
285 
286 /* Preconfig tests */
287 
288 static void test_qmp_preconfig(void)
289 {
290     QDict *rsp, *ret;
291     QTestState *qs = qtest_initf("%s --preconfig", common_args);
292 
293     /* preconfig state */
294     /* enabled commands, no error expected  */
295     g_assert(!qmp_rsp_is_err(qtest_qmp(qs, "{ 'execute': 'query-commands' }")));
296 
297     /* forbidden commands, expected error */
298     g_assert(qmp_rsp_is_err(qtest_qmp(qs, "{ 'execute': 'query-cpus-fast' }")));
299 
300     /* check that query-status returns preconfig state */
301     rsp = qtest_qmp(qs, "{ 'execute': 'query-status' }");
302     ret = qdict_get_qdict(rsp, "return");
303     g_assert(ret);
304     g_assert_cmpstr(qdict_get_try_str(ret, "status"), ==, "prelaunch");
305     qobject_unref(rsp);
306 
307     /* exit preconfig state */
308     g_assert(!qmp_rsp_is_err(qtest_qmp(qs, "{ 'execute': 'x-exit-preconfig' }")));
309     qtest_qmp_eventwait(qs, "RESUME");
310 
311     /* check that query-status returns running state */
312     rsp = qtest_qmp(qs, "{ 'execute': 'query-status' }");
313     ret = qdict_get_qdict(rsp, "return");
314     g_assert(ret);
315     g_assert_cmpstr(qdict_get_try_str(ret, "status"), ==, "running");
316     qobject_unref(rsp);
317 
318     /* check that x-exit-preconfig returns error after exiting preconfig */
319     g_assert(qmp_rsp_is_err(qtest_qmp(qs, "{ 'execute': 'x-exit-preconfig' }")));
320 
321     /* enabled commands, no error expected  */
322     g_assert(!qmp_rsp_is_err(qtest_qmp(qs, "{ 'execute': 'query-cpus-fast' }")));
323 
324     qtest_quit(qs);
325 }
326 
327 static void test_qmp_missing_any_arg(void)
328 {
329     QTestState *qts;
330     QDict *resp;
331 
332     qts = qtest_init(common_args);
333     resp = qtest_qmp(qts, "{'execute': 'qom-set', 'arguments':"
334                      " { 'path': '/machine', 'property': 'rtc-time' } }");
335     g_assert_nonnull(resp);
336     qmp_expect_error_and_unref(resp, "GenericError");
337     qtest_quit(qts);
338 }
339 
340 int main(int argc, char *argv[])
341 {
342     g_test_init(&argc, &argv, NULL);
343 
344     qtest_add_func("qmp/protocol", test_qmp_protocol);
345 #ifndef _WIN32
346     /* This case calls mkfifo() which does not exist on win32 */
347     qtest_add_func("qmp/oob", test_qmp_oob);
348 #endif
349     qtest_add_func("qmp/preconfig", test_qmp_preconfig);
350     qtest_add_func("qmp/missing-any-arg", test_qmp_missing_any_arg);
351 
352     return g_test_run();
353 }
354