Merge remote-tracking branch 'remotes/rth/tags/pull-tcg-20210921' into staging
[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 "trace.h"
35
36 struct QMPRequest {
37 /* Owner of the request */
38 MonitorQMP *mon;
39 /*
40 * Request object to be handled or Error to be reported
41 * (exactly one of them is non-null)
42 */
43 QObject *req;
44 Error *err;
45 };
46 typedef struct QMPRequest QMPRequest;
47
48 QmpCommandList qmp_commands, qmp_cap_negotiation_commands;
49
50 static bool qmp_oob_enabled(MonitorQMP *mon)
51 {
52 return mon->capab[QMP_CAPABILITY_OOB];
53 }
54
55 static void monitor_qmp_caps_reset(MonitorQMP *mon)
56 {
57 memset(mon->capab_offered, 0, sizeof(mon->capab_offered));
58 memset(mon->capab, 0, sizeof(mon->capab));
59 mon->capab_offered[QMP_CAPABILITY_OOB] = mon->common.use_io_thread;
60 }
61
62 static void qmp_request_free(QMPRequest *req)
63 {
64 qobject_unref(req->req);
65 error_free(req->err);
66 g_free(req);
67 }
68
69 /* Caller must hold mon->qmp.qmp_queue_lock */
70 static void monitor_qmp_cleanup_req_queue_locked(MonitorQMP *mon)
71 {
72 while (!g_queue_is_empty(mon->qmp_requests)) {
73 qmp_request_free(g_queue_pop_head(mon->qmp_requests));
74 }
75 }
76
77 static void monitor_qmp_cleanup_queue_and_resume(MonitorQMP *mon)
78 {
79 QEMU_LOCK_GUARD(&mon->qmp_queue_lock);
80
81 /*
82 * Same condition as in monitor_qmp_dispatcher_co(), but before
83 * removing an element from the queue (hence no `- 1`).
84 * Also, the queue should not be empty either, otherwise the
85 * monitor hasn't been suspended yet (or was already resumed).
86 */
87 bool need_resume = (!qmp_oob_enabled(mon) ||
88 mon->qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX)
89 && !g_queue_is_empty(mon->qmp_requests);
90
91 monitor_qmp_cleanup_req_queue_locked(mon);
92
93 if (need_resume) {
94 /*
95 * handle_qmp_command() suspended the monitor because the
96 * request queue filled up, to be resumed when the queue has
97 * space again. We just emptied it; resume the monitor.
98 *
99 * Without this, the monitor would remain suspended forever
100 * when we get here while the monitor is suspended. An
101 * unfortunately timed CHR_EVENT_CLOSED can do the trick.
102 */
103 monitor_resume(&mon->common);
104 }
105
106 }
107
108 void qmp_send_response(MonitorQMP *mon, const QDict *rsp)
109 {
110 const QObject *data = QOBJECT(rsp);
111 GString *json;
112
113 json = qobject_to_json_pretty(data, mon->pretty);
114 assert(json != NULL);
115 trace_monitor_qmp_respond(mon, json->str);
116
117 g_string_append_c(json, '\n');
118 monitor_puts(&mon->common, json->str);
119
120 g_string_free(json, true);
121 }
122
123 /*
124 * Emit QMP response @rsp to @mon.
125 * Null @rsp can only happen for commands with QCO_NO_SUCCESS_RESP.
126 * Nothing is emitted then.
127 */
128 static void monitor_qmp_respond(MonitorQMP *mon, QDict *rsp)
129 {
130 if (rsp) {
131 qmp_send_response(mon, rsp);
132 }
133 }
134
135 /*
136 * Runs outside of coroutine context for OOB commands, but in
137 * coroutine context for everything else.
138 */
139 static void monitor_qmp_dispatch(MonitorQMP *mon, QObject *req)
140 {
141 QDict *rsp;
142 QDict *error;
143
144 rsp = qmp_dispatch(mon->commands, req, qmp_oob_enabled(mon),
145 &mon->common);
146
147 if (mon->commands == &qmp_cap_negotiation_commands) {
148 error = qdict_get_qdict(rsp, "error");
149 if (error
150 && !g_strcmp0(qdict_get_try_str(error, "class"),
151 QapiErrorClass_str(ERROR_CLASS_COMMAND_NOT_FOUND))) {
152 /* Provide a more useful error message */
153 qdict_del(error, "desc");
154 qdict_put_str(error, "desc", "Expecting capabilities negotiation"
155 " with 'qmp_capabilities'");
156 }
157 }
158
159 monitor_qmp_respond(mon, rsp);
160 qobject_unref(rsp);
161 }
162
163 /*
164 * Pop a QMP request from a monitor request queue.
165 * Return the request, or NULL all request queues are empty.
166 * We are using round-robin fashion to pop the request, to avoid
167 * processing commands only on a very busy monitor. To achieve that,
168 * when we process one request on a specific monitor, we put that
169 * monitor to the end of mon_list queue.
170 *
171 * Note: if the function returned with non-NULL, then the caller will
172 * be with qmp_mon->qmp_queue_lock held, and the caller is responsible
173 * to release it.
174 */
175 static QMPRequest *monitor_qmp_requests_pop_any_with_lock(void)
176 {
177 QMPRequest *req_obj = NULL;
178 Monitor *mon;
179 MonitorQMP *qmp_mon;
180
181 QEMU_LOCK_GUARD(&monitor_lock);
182
183 QTAILQ_FOREACH(mon, &mon_list, entry) {
184 if (!monitor_is_qmp(mon)) {
185 continue;
186 }
187
188 qmp_mon = container_of(mon, MonitorQMP, common);
189 qemu_mutex_lock(&qmp_mon->qmp_queue_lock);
190 req_obj = g_queue_pop_head(qmp_mon->qmp_requests);
191 if (req_obj) {
192 /* With the lock of corresponding queue held */
193 break;
194 }
195 qemu_mutex_unlock(&qmp_mon->qmp_queue_lock);
196 }
197
198 if (req_obj) {
199 /*
200 * We found one request on the monitor. Degrade this monitor's
201 * priority to lowest by re-inserting it to end of queue.
202 */
203 QTAILQ_REMOVE(&mon_list, mon, entry);
204 QTAILQ_INSERT_TAIL(&mon_list, mon, entry);
205 }
206
207 return req_obj;
208 }
209
210 void coroutine_fn monitor_qmp_dispatcher_co(void *data)
211 {
212 QMPRequest *req_obj = NULL;
213 QDict *rsp;
214 bool oob_enabled;
215 MonitorQMP *mon;
216
217 while (true) {
218 assert(qatomic_mb_read(&qmp_dispatcher_co_busy) == true);
219
220 /*
221 * Mark the dispatcher as not busy already here so that we
222 * don't miss any new requests coming in the middle of our
223 * processing.
224 */
225 qatomic_mb_set(&qmp_dispatcher_co_busy, false);
226
227 /* On shutdown, don't take any more requests from the queue */
228 if (qmp_dispatcher_co_shutdown) {
229 return;
230 }
231
232 while (!(req_obj = monitor_qmp_requests_pop_any_with_lock())) {
233 /*
234 * No more requests to process. Wait to be reentered from
235 * handle_qmp_command() when it pushes more requests, or
236 * from monitor_cleanup() when it requests shutdown.
237 */
238 if (!qmp_dispatcher_co_shutdown) {
239 qemu_coroutine_yield();
240
241 /*
242 * busy must be set to true again by whoever
243 * rescheduled us to avoid double scheduling
244 */
245 assert(qatomic_xchg(&qmp_dispatcher_co_busy, false) == true);
246 }
247
248 /*
249 * qmp_dispatcher_co_shutdown may have changed if we
250 * yielded and were reentered from monitor_cleanup()
251 */
252 if (qmp_dispatcher_co_shutdown) {
253 return;
254 }
255 }
256
257 trace_monitor_qmp_in_band_dequeue(req_obj,
258 req_obj->mon->qmp_requests->length);
259
260 /*
261 * @req_obj has a request, we hold req_obj->mon->qmp_queue_lock
262 */
263
264 mon = req_obj->mon;
265
266 /*
267 * We need to resume the monitor if handle_qmp_command()
268 * suspended it. Two cases:
269 * 1. OOB enabled: mon->qmp_requests has no more space
270 * Resume right away, so that OOB commands can get executed while
271 * this request is being processed.
272 * 2. OOB disabled: always
273 * Resume only after we're done processing the request,
274 * We need to save qmp_oob_enabled() for later, because
275 * qmp_qmp_capabilities() can change it.
276 */
277 oob_enabled = qmp_oob_enabled(mon);
278 if (oob_enabled
279 && mon->qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX - 1) {
280 monitor_resume(&mon->common);
281 }
282
283 /*
284 * Drop the queue mutex now, before yielding, otherwise we might
285 * deadlock if the main thread tries to lock it.
286 */
287 qemu_mutex_unlock(&mon->qmp_queue_lock);
288
289 if (qatomic_xchg(&qmp_dispatcher_co_busy, true) == true) {
290 /*
291 * Someone rescheduled us (probably because a new requests
292 * came in), but we didn't actually yield. Do that now,
293 * only to be immediately reentered and removed from the
294 * list of scheduled coroutines.
295 */
296 qemu_coroutine_yield();
297 }
298
299 /*
300 * Move the coroutine from iohandler_ctx to qemu_aio_context for
301 * executing the command handler so that it can make progress if it
302 * involves an AIO_WAIT_WHILE().
303 */
304 aio_co_schedule(qemu_get_aio_context(), qmp_dispatcher_co);
305 qemu_coroutine_yield();
306
307 /* Process request */
308 if (req_obj->req) {
309 if (trace_event_get_state(TRACE_MONITOR_QMP_CMD_IN_BAND)) {
310 QDict *qdict = qobject_to(QDict, req_obj->req);
311 QObject *id = qdict ? qdict_get(qdict, "id") : NULL;
312 GString *id_json;
313
314 id_json = id ? qobject_to_json(id) : g_string_new(NULL);
315 trace_monitor_qmp_cmd_in_band(id_json->str);
316 g_string_free(id_json, true);
317 }
318 monitor_qmp_dispatch(mon, req_obj->req);
319 } else {
320 assert(req_obj->err);
321 trace_monitor_qmp_err_in_band(error_get_pretty(req_obj->err));
322 rsp = qmp_error_response(req_obj->err);
323 req_obj->err = NULL;
324 monitor_qmp_respond(mon, rsp);
325 qobject_unref(rsp);
326 }
327
328 if (!oob_enabled) {
329 monitor_resume(&mon->common);
330 }
331
332 qmp_request_free(req_obj);
333
334 /*
335 * Yield and reschedule so the main loop stays responsive.
336 *
337 * Move back to iohandler_ctx so that nested event loops for
338 * qemu_aio_context don't start new monitor commands.
339 */
340 aio_co_schedule(iohandler_get_aio_context(), qmp_dispatcher_co);
341 qemu_coroutine_yield();
342 }
343 }
344
345 static void handle_qmp_command(void *opaque, QObject *req, Error *err)
346 {
347 MonitorQMP *mon = opaque;
348 QDict *qdict = qobject_to(QDict, req);
349 QMPRequest *req_obj;
350
351 assert(!req != !err);
352
353 if (req && trace_event_get_state_backends(TRACE_HANDLE_QMP_COMMAND)) {
354 GString *req_json = qobject_to_json(req);
355 trace_handle_qmp_command(mon, req_json->str);
356 g_string_free(req_json, true);
357 }
358
359 if (qdict && qmp_is_oob(qdict)) {
360 /* OOB commands are executed immediately */
361 if (trace_event_get_state(TRACE_MONITOR_QMP_CMD_OUT_OF_BAND)) {
362 QObject *id = qdict_get(qdict, "id");
363 GString *id_json;
364
365 id_json = id ? qobject_to_json(id) : g_string_new(NULL);
366 trace_monitor_qmp_cmd_out_of_band(id_json->str);
367 g_string_free(id_json, true);
368 }
369 monitor_qmp_dispatch(mon, req);
370 qobject_unref(req);
371 return;
372 }
373
374 req_obj = g_new0(QMPRequest, 1);
375 req_obj->mon = mon;
376 req_obj->req = req;
377 req_obj->err = err;
378
379 /* Protect qmp_requests and fetching its length. */
380 WITH_QEMU_LOCK_GUARD(&mon->qmp_queue_lock) {
381
382 /*
383 * Suspend the monitor when we can't queue more requests after
384 * this one. Dequeuing in monitor_qmp_dispatcher_co() or
385 * monitor_qmp_cleanup_queue_and_resume() will resume it.
386 * Note that when OOB is disabled, we queue at most one command,
387 * for backward compatibility.
388 */
389 if (!qmp_oob_enabled(mon) ||
390 mon->qmp_requests->length == QMP_REQ_QUEUE_LEN_MAX - 1) {
391 monitor_suspend(&mon->common);
392 }
393
394 /*
395 * Put the request to the end of queue so that requests will be
396 * handled in time order. Ownership for req_obj, req,
397 * etc. will be delivered to the handler side.
398 */
399 trace_monitor_qmp_in_band_enqueue(req_obj, mon,
400 mon->qmp_requests->length);
401 assert(mon->qmp_requests->length < QMP_REQ_QUEUE_LEN_MAX);
402 g_queue_push_tail(mon->qmp_requests, req_obj);
403 }
404
405 /* Kick the dispatcher routine */
406 if (!qatomic_xchg(&qmp_dispatcher_co_busy, true)) {
407 aio_co_wake(qmp_dispatcher_co);
408 }
409 }
410
411 static void monitor_qmp_read(void *opaque, const uint8_t *buf, int size)
412 {
413 MonitorQMP *mon = opaque;
414
415 json_message_parser_feed(&mon->parser, (const char *) buf, size);
416 }
417
418 static QDict *qmp_greeting(MonitorQMP *mon)
419 {
420 QList *cap_list = qlist_new();
421 QObject *ver = NULL;
422 QDict *args;
423 QMPCapability cap;
424
425 args = qdict_new();
426 qmp_marshal_query_version(args, &ver, NULL);
427 qobject_unref(args);
428
429 for (cap = 0; cap < QMP_CAPABILITY__MAX; cap++) {
430 if (mon->capab_offered[cap]) {
431 qlist_append_str(cap_list, QMPCapability_str(cap));
432 }
433 }
434
435 return qdict_from_jsonf_nofail(
436 "{'QMP': {'version': %p, 'capabilities': %p}}",
437 ver, cap_list);
438 }
439
440 static void monitor_qmp_event(void *opaque, QEMUChrEvent event)
441 {
442 QDict *data;
443 MonitorQMP *mon = opaque;
444
445 switch (event) {
446 case CHR_EVENT_OPENED:
447 mon->commands = &qmp_cap_negotiation_commands;
448 monitor_qmp_caps_reset(mon);
449 data = qmp_greeting(mon);
450 qmp_send_response(mon, data);
451 qobject_unref(data);
452 mon_refcount++;
453 break;
454 case CHR_EVENT_CLOSED:
455 /*
456 * Note: this is only useful when the output of the chardev
457 * backend is still open. For example, when the backend is
458 * stdio, it's possible that stdout is still open when stdin
459 * is closed.
460 */
461 monitor_qmp_cleanup_queue_and_resume(mon);
462 json_message_parser_destroy(&mon->parser);
463 json_message_parser_init(&mon->parser, handle_qmp_command,
464 mon, NULL);
465 mon_refcount--;
466 monitor_fdsets_cleanup();
467 break;
468 case CHR_EVENT_BREAK:
469 case CHR_EVENT_MUX_IN:
470 case CHR_EVENT_MUX_OUT:
471 /* Ignore */
472 break;
473 }
474 }
475
476 void monitor_data_destroy_qmp(MonitorQMP *mon)
477 {
478 json_message_parser_destroy(&mon->parser);
479 qemu_mutex_destroy(&mon->qmp_queue_lock);
480 monitor_qmp_cleanup_req_queue_locked(mon);
481 g_queue_free(mon->qmp_requests);
482 }
483
484 static void monitor_qmp_setup_handlers_bh(void *opaque)
485 {
486 MonitorQMP *mon = opaque;
487 GMainContext *context;
488
489 assert(mon->common.use_io_thread);
490 context = iothread_get_g_main_context(mon_iothread);
491 assert(context);
492 qemu_chr_fe_set_handlers(&mon->common.chr, monitor_can_read,
493 monitor_qmp_read, monitor_qmp_event,
494 NULL, &mon->common, context, true);
495 monitor_list_append(&mon->common);
496 }
497
498 void monitor_init_qmp(Chardev *chr, bool pretty, Error **errp)
499 {
500 MonitorQMP *mon = g_new0(MonitorQMP, 1);
501
502 if (!qemu_chr_fe_init(&mon->common.chr, chr, errp)) {
503 g_free(mon);
504 return;
505 }
506 qemu_chr_fe_set_echo(&mon->common.chr, true);
507
508 /* Note: we run QMP monitor in I/O thread when @chr supports that */
509 monitor_data_init(&mon->common, true, false,
510 qemu_chr_has_feature(chr, QEMU_CHAR_FEATURE_GCONTEXT));
511
512 mon->pretty = pretty;
513
514 qemu_mutex_init(&mon->qmp_queue_lock);
515 mon->qmp_requests = g_queue_new();
516
517 json_message_parser_init(&mon->parser, handle_qmp_command, mon, NULL);
518 if (mon->common.use_io_thread) {
519 /*
520 * Make sure the old iowatch is gone. It's possible when
521 * e.g. the chardev is in client mode, with wait=on.
522 */
523 remove_fd_in_watch(chr);
524 /*
525 * We can't call qemu_chr_fe_set_handlers() directly here
526 * since chardev might be running in the monitor I/O
527 * thread. Schedule a bottom half.
528 */
529 aio_bh_schedule_oneshot(iothread_get_aio_context(mon_iothread),
530 monitor_qmp_setup_handlers_bh, mon);
531 /* The bottom half will add @mon to @mon_list */
532 } else {
533 qemu_chr_fe_set_handlers(&mon->common.chr, monitor_can_read,
534 monitor_qmp_read, monitor_qmp_event,
535 NULL, &mon->common, NULL, true);
536 monitor_list_append(&mon->common);
537 }
538 }