qapi: Restrict 'query-kvm' command to machine code
[qemu.git] / monitor / qmp.c
1 /*
2 * QEMU monitor
3 *
4 * Copyright (c) 2003-2004 Fabrice Bellard
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24
25 #include "qemu/osdep.h"
26
27 #include "chardev/char-io.h"
28 #include "monitor-internal.h"
29 #include "qapi/error.h"
30 #include "qapi/qapi-commands-control.h"
31 #include "qapi/qmp/qdict.h"
32 #include "qapi/qmp/qjson.h"
33 #include "qapi/qmp/qlist.h"
34 #include "qapi/qmp/qstring.h"
35 #include "trace.h"
36
37 struct QMPRequest {
38 /* Owner of the request */
39 MonitorQMP *mon;
40 /*
41 * Request object to be handled or Error to be reported
42 * (exactly one of them is non-null)
43 */
44 QObject *req;
45 Error *err;
46 };
47 typedef struct QMPRequest QMPRequest;
48
49 QmpCommandList qmp_commands, qmp_cap_negotiation_commands;
50
51 static bool qmp_oob_enabled(MonitorQMP *mon)
52 {
53 return mon->capab[QMP_CAPABILITY_OOB];
54 }
55
56 static void monitor_qmp_caps_reset(MonitorQMP *mon)
57 {
58 memset(mon->capab_offered, 0, sizeof(mon->capab_offered));
59 memset(mon->capab, 0, sizeof(mon->capab));
60 mon->capab_offered[QMP_CAPABILITY_OOB] = mon->common.use_io_thread;
61 }
62
63 static void qmp_request_free(QMPRequest *req)
64 {
65 qobject_unref(req->req);
66 error_free(req->err);
67 g_free(req);
68 }
69
70 /* Caller must hold mon->qmp.qmp_queue_lock */
71 static void monitor_qmp_cleanup_req_queue_locked(MonitorQMP *mon)
72 {
73 while (!g_queue_is_empty(mon->qmp_requests)) {
74 qmp_request_free(g_queue_pop_head(mon->qmp_requests));
75 }
76 }
77
78 static void monitor_qmp_cleanup_queue_and_resume(MonitorQMP *mon)
79 {
80 qemu_mutex_lock(&mon->qmp_queue_lock);
81
82 /*
83 * Same condition as in monitor_qmp_bh_dispatcher(), but before
84 * removing an element from the queue (hence no `- 1`).
85 * Also, the queue should not be empty either, otherwise the
86 * monitor hasn't been suspended yet (or was already resumed).
87 */
88 bool need_resume = (!qmp_oob_enabled(mon) ||
89 mon->qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX)
90 && !g_queue_is_empty(mon->qmp_requests);
91
92 monitor_qmp_cleanup_req_queue_locked(mon);
93
94 if (need_resume) {
95 /*
96 * handle_qmp_command() suspended the monitor because the
97 * request queue filled up, to be resumed when the queue has
98 * space again. We just emptied it; resume the monitor.
99 *
100 * Without this, the monitor would remain suspended forever
101 * when we get here while the monitor is suspended. An
102 * unfortunately timed CHR_EVENT_CLOSED can do the trick.
103 */
104 monitor_resume(&mon->common);
105 }
106
107 qemu_mutex_unlock(&mon->qmp_queue_lock);
108 }
109
110 void qmp_send_response(MonitorQMP *mon, const QDict *rsp)
111 {
112 const QObject *data = QOBJECT(rsp);
113 QString *json;
114
115 json = mon->pretty ? qobject_to_json_pretty(data) : qobject_to_json(data);
116 assert(json != NULL);
117
118 qstring_append_chr(json, '\n');
119 monitor_puts(&mon->common, qstring_get_str(json));
120
121 qobject_unref(json);
122 }
123
124 /*
125 * Emit QMP response @rsp to @mon.
126 * Null @rsp can only happen for commands with QCO_NO_SUCCESS_RESP.
127 * Nothing is emitted then.
128 */
129 static void monitor_qmp_respond(MonitorQMP *mon, QDict *rsp)
130 {
131 if (rsp) {
132 qmp_send_response(mon, rsp);
133 }
134 }
135
136 /*
137 * Runs outside of coroutine context for OOB commands, but in
138 * coroutine context for everything else.
139 */
140 static void monitor_qmp_dispatch(MonitorQMP *mon, QObject *req)
141 {
142 QDict *rsp;
143 QDict *error;
144
145 rsp = qmp_dispatch(mon->commands, req, qmp_oob_enabled(mon),
146 &mon->common);
147
148 if (mon->commands == &qmp_cap_negotiation_commands) {
149 error = qdict_get_qdict(rsp, "error");
150 if (error
151 && !g_strcmp0(qdict_get_try_str(error, "class"),
152 QapiErrorClass_str(ERROR_CLASS_COMMAND_NOT_FOUND))) {
153 /* Provide a more useful error message */
154 qdict_del(error, "desc");
155 qdict_put_str(error, "desc", "Expecting capabilities negotiation"
156 " with 'qmp_capabilities'");
157 }
158 }
159
160 monitor_qmp_respond(mon, rsp);
161 qobject_unref(rsp);
162 }
163
164 /*
165 * Pop a QMP request from a monitor request queue.
166 * Return the request, or NULL all request queues are empty.
167 * We are using round-robin fashion to pop the request, to avoid
168 * processing commands only on a very busy monitor. To achieve that,
169 * when we process one request on a specific monitor, we put that
170 * monitor to the end of mon_list queue.
171 *
172 * Note: if the function returned with non-NULL, then the caller will
173 * be with qmp_mon->qmp_queue_lock held, and the caller is responsible
174 * to release it.
175 */
176 static QMPRequest *monitor_qmp_requests_pop_any_with_lock(void)
177 {
178 QMPRequest *req_obj = NULL;
179 Monitor *mon;
180 MonitorQMP *qmp_mon;
181
182 qemu_mutex_lock(&monitor_lock);
183
184 QTAILQ_FOREACH(mon, &mon_list, entry) {
185 if (!monitor_is_qmp(mon)) {
186 continue;
187 }
188
189 qmp_mon = container_of(mon, MonitorQMP, common);
190 qemu_mutex_lock(&qmp_mon->qmp_queue_lock);
191 req_obj = g_queue_pop_head(qmp_mon->qmp_requests);
192 if (req_obj) {
193 /* With the lock of corresponding queue held */
194 break;
195 }
196 qemu_mutex_unlock(&qmp_mon->qmp_queue_lock);
197 }
198
199 if (req_obj) {
200 /*
201 * We found one request on the monitor. Degrade this monitor's
202 * priority to lowest by re-inserting it to end of queue.
203 */
204 QTAILQ_REMOVE(&mon_list, mon, entry);
205 QTAILQ_INSERT_TAIL(&mon_list, mon, entry);
206 }
207
208 qemu_mutex_unlock(&monitor_lock);
209
210 return req_obj;
211 }
212
213 void coroutine_fn monitor_qmp_dispatcher_co(void *data)
214 {
215 QMPRequest *req_obj = NULL;
216 QDict *rsp;
217 bool need_resume;
218 MonitorQMP *mon;
219
220 while (true) {
221 assert(qatomic_mb_read(&qmp_dispatcher_co_busy) == true);
222
223 /*
224 * Mark the dispatcher as not busy already here so that we
225 * don't miss any new requests coming in the middle of our
226 * processing.
227 */
228 qatomic_mb_set(&qmp_dispatcher_co_busy, false);
229
230 while (!(req_obj = monitor_qmp_requests_pop_any_with_lock())) {
231 /*
232 * No more requests to process. Wait to be reentered from
233 * handle_qmp_command() when it pushes more requests, or
234 * from monitor_cleanup() when it requests shutdown.
235 */
236 if (!qmp_dispatcher_co_shutdown) {
237 qemu_coroutine_yield();
238
239 /*
240 * busy must be set to true again by whoever
241 * rescheduled us to avoid double scheduling
242 */
243 assert(qatomic_xchg(&qmp_dispatcher_co_busy, false) == true);
244 }
245
246 /*
247 * qmp_dispatcher_co_shutdown may have changed if we
248 * yielded and were reentered from monitor_cleanup()
249 */
250 if (qmp_dispatcher_co_shutdown) {
251 return;
252 }
253 }
254
255 if (qatomic_xchg(&qmp_dispatcher_co_busy, true) == true) {
256 /*
257 * Someone rescheduled us (probably because a new requests
258 * came in), but we didn't actually yield. Do that now,
259 * only to be immediately reentered and removed from the
260 * list of scheduled coroutines.
261 */
262 qemu_coroutine_yield();
263 }
264
265 /*
266 * Move the coroutine from iohandler_ctx to qemu_aio_context for
267 * executing the command handler so that it can make progress if it
268 * involves an AIO_WAIT_WHILE().
269 */
270 aio_co_schedule(qemu_get_aio_context(), qmp_dispatcher_co);
271 qemu_coroutine_yield();
272
273 mon = req_obj->mon;
274 /* qmp_oob_enabled() might change after "qmp_capabilities" */
275 need_resume = !qmp_oob_enabled(mon) ||
276 mon->qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX - 1;
277 qemu_mutex_unlock(&mon->qmp_queue_lock);
278 if (req_obj->req) {
279 QDict *qdict = qobject_to(QDict, req_obj->req);
280 QObject *id = qdict ? qdict_get(qdict, "id") : NULL;
281 trace_monitor_qmp_cmd_in_band(qobject_get_try_str(id) ?: "");
282 monitor_qmp_dispatch(mon, req_obj->req);
283 } else {
284 assert(req_obj->err);
285 rsp = qmp_error_response(req_obj->err);
286 req_obj->err = NULL;
287 monitor_qmp_respond(mon, rsp);
288 qobject_unref(rsp);
289 }
290
291 if (need_resume) {
292 /* Pairs with the monitor_suspend() in handle_qmp_command() */
293 monitor_resume(&mon->common);
294 }
295 qmp_request_free(req_obj);
296
297 /*
298 * Yield and reschedule so the main loop stays responsive.
299 *
300 * Move back to iohandler_ctx so that nested event loops for
301 * qemu_aio_context don't start new monitor commands.
302 */
303 aio_co_schedule(iohandler_get_aio_context(), qmp_dispatcher_co);
304 qemu_coroutine_yield();
305 }
306 }
307
308 static void handle_qmp_command(void *opaque, QObject *req, Error *err)
309 {
310 MonitorQMP *mon = opaque;
311 QObject *id = NULL;
312 QDict *qdict;
313 QMPRequest *req_obj;
314
315 assert(!req != !err);
316
317 qdict = qobject_to(QDict, req);
318 if (qdict) {
319 id = qdict_get(qdict, "id");
320 } /* else will fail qmp_dispatch() */
321
322 if (req && trace_event_get_state_backends(TRACE_HANDLE_QMP_COMMAND)) {
323 QString *req_json = qobject_to_json(req);
324 trace_handle_qmp_command(mon, qstring_get_str(req_json));
325 qobject_unref(req_json);
326 }
327
328 if (qdict && qmp_is_oob(qdict)) {
329 /* OOB commands are executed immediately */
330 trace_monitor_qmp_cmd_out_of_band(qobject_get_try_str(id) ?: "");
331 monitor_qmp_dispatch(mon, req);
332 qobject_unref(req);
333 return;
334 }
335
336 req_obj = g_new0(QMPRequest, 1);
337 req_obj->mon = mon;
338 req_obj->req = req;
339 req_obj->err = err;
340
341 /* Protect qmp_requests and fetching its length. */
342 qemu_mutex_lock(&mon->qmp_queue_lock);
343
344 /*
345 * Suspend the monitor when we can't queue more requests after
346 * this one. Dequeuing in monitor_qmp_bh_dispatcher() or
347 * monitor_qmp_cleanup_queue_and_resume() will resume it.
348 * Note that when OOB is disabled, we queue at most one command,
349 * for backward compatibility.
350 */
351 if (!qmp_oob_enabled(mon) ||
352 mon->qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX - 1) {
353 monitor_suspend(&mon->common);
354 }
355
356 /*
357 * Put the request to the end of queue so that requests will be
358 * handled in time order. Ownership for req_obj, req,
359 * etc. will be delivered to the handler side.
360 */
361 assert(mon->qmp_requests->length < QMP_REQ_QUEUE_LEN_MAX);
362 g_queue_push_tail(mon->qmp_requests, req_obj);
363 qemu_mutex_unlock(&mon->qmp_queue_lock);
364
365 /* Kick the dispatcher routine */
366 if (!qatomic_xchg(&qmp_dispatcher_co_busy, true)) {
367 aio_co_wake(qmp_dispatcher_co);
368 }
369 }
370
371 static void monitor_qmp_read(void *opaque, const uint8_t *buf, int size)
372 {
373 MonitorQMP *mon = opaque;
374
375 json_message_parser_feed(&mon->parser, (const char *) buf, size);
376 }
377
378 static QDict *qmp_greeting(MonitorQMP *mon)
379 {
380 QList *cap_list = qlist_new();
381 QObject *ver = NULL;
382 QDict *args;
383 QMPCapability cap;
384
385 args = qdict_new();
386 qmp_marshal_query_version(args, &ver, NULL);
387 qobject_unref(args);
388
389 for (cap = 0; cap < QMP_CAPABILITY__MAX; cap++) {
390 if (mon->capab_offered[cap]) {
391 qlist_append_str(cap_list, QMPCapability_str(cap));
392 }
393 }
394
395 return qdict_from_jsonf_nofail(
396 "{'QMP': {'version': %p, 'capabilities': %p}}",
397 ver, cap_list);
398 }
399
400 static void monitor_qmp_event(void *opaque, QEMUChrEvent event)
401 {
402 QDict *data;
403 MonitorQMP *mon = opaque;
404
405 switch (event) {
406 case CHR_EVENT_OPENED:
407 mon->commands = &qmp_cap_negotiation_commands;
408 monitor_qmp_caps_reset(mon);
409 data = qmp_greeting(mon);
410 qmp_send_response(mon, data);
411 qobject_unref(data);
412 mon_refcount++;
413 break;
414 case CHR_EVENT_CLOSED:
415 /*
416 * Note: this is only useful when the output of the chardev
417 * backend is still open. For example, when the backend is
418 * stdio, it's possible that stdout is still open when stdin
419 * is closed.
420 */
421 monitor_qmp_cleanup_queue_and_resume(mon);
422 json_message_parser_destroy(&mon->parser);
423 json_message_parser_init(&mon->parser, handle_qmp_command,
424 mon, NULL);
425 mon_refcount--;
426 monitor_fdsets_cleanup();
427 break;
428 case CHR_EVENT_BREAK:
429 case CHR_EVENT_MUX_IN:
430 case CHR_EVENT_MUX_OUT:
431 /* Ignore */
432 break;
433 }
434 }
435
436 void monitor_data_destroy_qmp(MonitorQMP *mon)
437 {
438 json_message_parser_destroy(&mon->parser);
439 qemu_mutex_destroy(&mon->qmp_queue_lock);
440 monitor_qmp_cleanup_req_queue_locked(mon);
441 g_queue_free(mon->qmp_requests);
442 }
443
444 static void monitor_qmp_setup_handlers_bh(void *opaque)
445 {
446 MonitorQMP *mon = opaque;
447 GMainContext *context;
448
449 assert(mon->common.use_io_thread);
450 context = iothread_get_g_main_context(mon_iothread);
451 assert(context);
452 qemu_chr_fe_set_handlers(&mon->common.chr, monitor_can_read,
453 monitor_qmp_read, monitor_qmp_event,
454 NULL, &mon->common, context, true);
455 monitor_list_append(&mon->common);
456 }
457
458 void monitor_init_qmp(Chardev *chr, bool pretty, Error **errp)
459 {
460 MonitorQMP *mon = g_new0(MonitorQMP, 1);
461
462 if (!qemu_chr_fe_init(&mon->common.chr, chr, errp)) {
463 g_free(mon);
464 return;
465 }
466 qemu_chr_fe_set_echo(&mon->common.chr, true);
467
468 /* Note: we run QMP monitor in I/O thread when @chr supports that */
469 monitor_data_init(&mon->common, true, false,
470 qemu_chr_has_feature(chr, QEMU_CHAR_FEATURE_GCONTEXT));
471
472 mon->pretty = pretty;
473
474 qemu_mutex_init(&mon->qmp_queue_lock);
475 mon->qmp_requests = g_queue_new();
476
477 json_message_parser_init(&mon->parser, handle_qmp_command, mon, NULL);
478 if (mon->common.use_io_thread) {
479 /*
480 * Make sure the old iowatch is gone. It's possible when
481 * e.g. the chardev is in client mode, with wait=on.
482 */
483 remove_fd_in_watch(chr);
484 /*
485 * We can't call qemu_chr_fe_set_handlers() directly here
486 * since chardev might be running in the monitor I/O
487 * thread. Schedule a bottom half.
488 */
489 aio_bh_schedule_oneshot(iothread_get_aio_context(mon_iothread),
490 monitor_qmp_setup_handlers_bh, mon);
491 /* The bottom half will add @mon to @mon_list */
492 } else {
493 qemu_chr_fe_set_handlers(&mon->common.chr, monitor_can_read,
494 monitor_qmp_read, monitor_qmp_event,
495 NULL, &mon->common, NULL, true);
496 monitor_list_append(&mon->common);
497 }
498 }