4 * Copyright (c) 2003-2004 Fabrice Bellard
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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
25 #include "qemu/osdep.h"
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"
37 * qmp_dispatcher_co_busy is used for synchronisation between the
38 * monitor thread and the main thread to ensure that the dispatcher
39 * coroutine never gets scheduled a second time when it's already
40 * scheduled (scheduling the same coroutine twice is forbidden).
42 * It is true if the coroutine is active and processing requests.
43 * Additional requests may then be pushed onto mon->qmp_requests,
44 * and @qmp_dispatcher_co_shutdown may be set without further ado.
45 * @qmp_dispatcher_co_busy must not be woken up in this case.
47 * If false, you also have to set @qmp_dispatcher_co_busy to true and
48 * wake up @qmp_dispatcher_co after pushing the new requests.
50 * The coroutine will automatically change this variable back to false
51 * before it yields. Nobody else may set the variable to false.
53 * Access must be atomic for thread safety.
55 static bool qmp_dispatcher_co_busy
= true;
58 /* Owner of the request */
61 * Request object to be handled or Error to be reported
62 * (exactly one of them is non-null)
67 typedef struct QMPRequest QMPRequest
;
69 QmpCommandList qmp_commands
, qmp_cap_negotiation_commands
;
71 static bool qmp_oob_enabled(MonitorQMP
*mon
)
73 return mon
->capab
[QMP_CAPABILITY_OOB
];
76 static void monitor_qmp_caps_reset(MonitorQMP
*mon
)
78 memset(mon
->capab_offered
, 0, sizeof(mon
->capab_offered
));
79 memset(mon
->capab
, 0, sizeof(mon
->capab
));
80 mon
->capab_offered
[QMP_CAPABILITY_OOB
] = mon
->common
.use_io_thread
;
83 static void qmp_request_free(QMPRequest
*req
)
85 qobject_unref(req
->req
);
90 /* Caller must hold mon->qmp.qmp_queue_lock */
91 static void monitor_qmp_cleanup_req_queue_locked(MonitorQMP
*mon
)
93 while (!g_queue_is_empty(mon
->qmp_requests
)) {
94 qmp_request_free(g_queue_pop_head(mon
->qmp_requests
));
98 static void monitor_qmp_cleanup_queue_and_resume(MonitorQMP
*mon
)
100 QEMU_LOCK_GUARD(&mon
->qmp_queue_lock
);
103 * Same condition as in monitor_qmp_dispatcher_co(), but before
104 * removing an element from the queue (hence no `- 1`).
105 * Also, the queue should not be empty either, otherwise the
106 * monitor hasn't been suspended yet (or was already resumed).
108 bool need_resume
= (!qmp_oob_enabled(mon
) ||
109 mon
->qmp_requests
->length
== QMP_REQ_QUEUE_LEN_MAX
)
110 && !g_queue_is_empty(mon
->qmp_requests
);
112 monitor_qmp_cleanup_req_queue_locked(mon
);
116 * handle_qmp_command() suspended the monitor because the
117 * request queue filled up, to be resumed when the queue has
118 * space again. We just emptied it; resume the monitor.
120 * Without this, the monitor would remain suspended forever
121 * when we get here while the monitor is suspended. An
122 * unfortunately timed CHR_EVENT_CLOSED can do the trick.
124 monitor_resume(&mon
->common
);
129 void qmp_send_response(MonitorQMP
*mon
, const QDict
*rsp
)
131 const QObject
*data
= QOBJECT(rsp
);
134 json
= qobject_to_json_pretty(data
, mon
->pretty
);
135 assert(json
!= NULL
);
136 trace_monitor_qmp_respond(mon
, json
->str
);
138 g_string_append_c(json
, '\n');
139 monitor_puts(&mon
->common
, json
->str
);
141 g_string_free(json
, true);
145 * Emit QMP response @rsp to @mon.
146 * Null @rsp can only happen for commands with QCO_NO_SUCCESS_RESP.
147 * Nothing is emitted then.
149 static void monitor_qmp_respond(MonitorQMP
*mon
, QDict
*rsp
)
152 qmp_send_response(mon
, rsp
);
157 * Runs outside of coroutine context for OOB commands, but in
158 * coroutine context for everything else.
160 static void monitor_qmp_dispatch(MonitorQMP
*mon
, QObject
*req
)
165 rsp
= qmp_dispatch(mon
->commands
, req
, qmp_oob_enabled(mon
),
168 if (mon
->commands
== &qmp_cap_negotiation_commands
) {
169 error
= qdict_get_qdict(rsp
, "error");
171 && !g_strcmp0(qdict_get_try_str(error
, "class"),
172 QapiErrorClass_str(ERROR_CLASS_COMMAND_NOT_FOUND
))) {
173 /* Provide a more useful error message */
174 qdict_del(error
, "desc");
175 qdict_put_str(error
, "desc", "Expecting capabilities negotiation"
176 " with 'qmp_capabilities'");
180 monitor_qmp_respond(mon
, rsp
);
185 * Pop a QMP request from a monitor request queue.
186 * Return the request, or NULL all request queues are empty.
187 * We are using round-robin fashion to pop the request, to avoid
188 * processing commands only on a very busy monitor. To achieve that,
189 * when we process one request on a specific monitor, we put that
190 * monitor to the end of mon_list queue.
192 * Note: if the function returned with non-NULL, then the caller will
193 * be with qmp_mon->qmp_queue_lock held, and the caller is responsible
196 static QMPRequest
*monitor_qmp_requests_pop_any_with_lock(void)
198 QMPRequest
*req_obj
= NULL
;
202 QTAILQ_FOREACH(mon
, &mon_list
, entry
) {
203 if (!monitor_is_qmp(mon
)) {
207 qmp_mon
= container_of(mon
, MonitorQMP
, common
);
208 qemu_mutex_lock(&qmp_mon
->qmp_queue_lock
);
209 req_obj
= g_queue_pop_head(qmp_mon
->qmp_requests
);
211 /* With the lock of corresponding queue held */
214 qemu_mutex_unlock(&qmp_mon
->qmp_queue_lock
);
219 * We found one request on the monitor. Degrade this monitor's
220 * priority to lowest by re-inserting it to end of queue.
222 QTAILQ_REMOVE(&mon_list
, mon
, entry
);
223 QTAILQ_INSERT_TAIL(&mon_list
, mon
, entry
);
229 void coroutine_fn
monitor_qmp_dispatcher_co(void *data
)
231 QMPRequest
*req_obj
= NULL
;
238 * busy must be set to true again by whoever
239 * rescheduled us to avoid double scheduling
241 assert(qatomic_mb_read(&qmp_dispatcher_co_busy
) == true);
244 * Mark the dispatcher as not busy already here so that we
245 * don't miss any new requests coming in the middle of our
248 qatomic_mb_set(&qmp_dispatcher_co_busy
, false);
250 WITH_QEMU_LOCK_GUARD(&monitor_lock
) {
251 /* On shutdown, don't take any more requests from the queue */
252 if (qmp_dispatcher_co_shutdown
) {
256 req_obj
= monitor_qmp_requests_pop_any_with_lock();
261 * No more requests to process. Wait to be reentered from
262 * handle_qmp_command() when it pushes more requests, or
263 * from monitor_cleanup() when it requests shutdown.
265 qemu_coroutine_yield();
269 trace_monitor_qmp_in_band_dequeue(req_obj
,
270 req_obj
->mon
->qmp_requests
->length
);
273 * @req_obj has a request, we hold req_obj->mon->qmp_queue_lock
279 * We need to resume the monitor if handle_qmp_command()
280 * suspended it. Two cases:
281 * 1. OOB enabled: mon->qmp_requests has no more space
282 * Resume right away, so that OOB commands can get executed while
283 * this request is being processed.
284 * 2. OOB disabled: always
285 * Resume only after we're done processing the request,
286 * We need to save qmp_oob_enabled() for later, because
287 * qmp_qmp_capabilities() can change it.
289 oob_enabled
= qmp_oob_enabled(mon
);
291 && mon
->qmp_requests
->length
== QMP_REQ_QUEUE_LEN_MAX
- 1) {
292 monitor_resume(&mon
->common
);
296 * Drop the queue mutex now, before yielding, otherwise we might
297 * deadlock if the main thread tries to lock it.
299 qemu_mutex_unlock(&mon
->qmp_queue_lock
);
301 if (qatomic_xchg(&qmp_dispatcher_co_busy
, true) == true) {
303 * Someone rescheduled us (probably because a new requests
304 * came in), but we didn't actually yield. Do that now,
305 * only to be immediately reentered and removed from the
306 * list of scheduled coroutines.
308 qemu_coroutine_yield();
312 * Move the coroutine from iohandler_ctx to qemu_aio_context for
313 * executing the command handler so that it can make progress if it
314 * involves an AIO_WAIT_WHILE().
316 aio_co_schedule(qemu_get_aio_context(), qmp_dispatcher_co
);
317 qemu_coroutine_yield();
319 /* Process request */
321 if (trace_event_get_state(TRACE_MONITOR_QMP_CMD_IN_BAND
)) {
322 QDict
*qdict
= qobject_to(QDict
, req_obj
->req
);
323 QObject
*id
= qdict
? qdict_get(qdict
, "id") : NULL
;
326 id_json
= id
? qobject_to_json(id
) : g_string_new(NULL
);
327 trace_monitor_qmp_cmd_in_band(id_json
->str
);
328 g_string_free(id_json
, true);
330 monitor_qmp_dispatch(mon
, req_obj
->req
);
332 assert(req_obj
->err
);
333 trace_monitor_qmp_err_in_band(error_get_pretty(req_obj
->err
));
334 rsp
= qmp_error_response(req_obj
->err
);
336 monitor_qmp_respond(mon
, rsp
);
341 monitor_resume(&mon
->common
);
344 qmp_request_free(req_obj
);
347 * Yield and reschedule so the main loop stays responsive.
349 * Move back to iohandler_ctx so that nested event loops for
350 * qemu_aio_context don't start new monitor commands.
352 aio_co_schedule(iohandler_get_aio_context(), qmp_dispatcher_co
);
353 qemu_coroutine_yield();
355 qatomic_set(&qmp_dispatcher_co
, NULL
);
358 void qmp_dispatcher_co_wake(void)
360 if (!qatomic_xchg(&qmp_dispatcher_co_busy
, true)) {
361 aio_co_wake(qmp_dispatcher_co
);
365 static void handle_qmp_command(void *opaque
, QObject
*req
, Error
*err
)
367 MonitorQMP
*mon
= opaque
;
368 QDict
*qdict
= qobject_to(QDict
, req
);
371 assert(!req
!= !err
);
373 if (req
&& trace_event_get_state_backends(TRACE_HANDLE_QMP_COMMAND
)) {
374 GString
*req_json
= qobject_to_json(req
);
375 trace_handle_qmp_command(mon
, req_json
->str
);
376 g_string_free(req_json
, true);
379 if (qdict
&& qmp_is_oob(qdict
)) {
380 /* OOB commands are executed immediately */
381 if (trace_event_get_state(TRACE_MONITOR_QMP_CMD_OUT_OF_BAND
)) {
382 QObject
*id
= qdict_get(qdict
, "id");
385 id_json
= id
? qobject_to_json(id
) : g_string_new(NULL
);
386 trace_monitor_qmp_cmd_out_of_band(id_json
->str
);
387 g_string_free(id_json
, true);
389 monitor_qmp_dispatch(mon
, req
);
394 req_obj
= g_new0(QMPRequest
, 1);
399 /* Protect qmp_requests and fetching its length. */
400 WITH_QEMU_LOCK_GUARD(&mon
->qmp_queue_lock
) {
403 * Suspend the monitor when we can't queue more requests after
404 * this one. Dequeuing in monitor_qmp_dispatcher_co() or
405 * monitor_qmp_cleanup_queue_and_resume() will resume it.
406 * Note that when OOB is disabled, we queue at most one command,
407 * for backward compatibility.
409 if (!qmp_oob_enabled(mon
) ||
410 mon
->qmp_requests
->length
== QMP_REQ_QUEUE_LEN_MAX
- 1) {
411 monitor_suspend(&mon
->common
);
415 * Put the request to the end of queue so that requests will be
416 * handled in time order. Ownership for req_obj, req,
417 * etc. will be delivered to the handler side.
419 trace_monitor_qmp_in_band_enqueue(req_obj
, mon
,
420 mon
->qmp_requests
->length
);
421 assert(mon
->qmp_requests
->length
< QMP_REQ_QUEUE_LEN_MAX
);
422 g_queue_push_tail(mon
->qmp_requests
, req_obj
);
425 /* Kick the dispatcher routine */
426 qmp_dispatcher_co_wake();
429 static void monitor_qmp_read(void *opaque
, const uint8_t *buf
, int size
)
431 MonitorQMP
*mon
= opaque
;
433 json_message_parser_feed(&mon
->parser
, (const char *) buf
, size
);
436 static QDict
*qmp_greeting(MonitorQMP
*mon
)
438 QList
*cap_list
= qlist_new();
444 qmp_marshal_query_version(args
, &ver
, NULL
);
447 for (cap
= 0; cap
< QMP_CAPABILITY__MAX
; cap
++) {
448 if (mon
->capab_offered
[cap
]) {
449 qlist_append_str(cap_list
, QMPCapability_str(cap
));
453 return qdict_from_jsonf_nofail(
454 "{'QMP': {'version': %p, 'capabilities': %p}}",
458 static void monitor_qmp_event(void *opaque
, QEMUChrEvent event
)
461 MonitorQMP
*mon
= opaque
;
464 case CHR_EVENT_OPENED
:
465 mon
->commands
= &qmp_cap_negotiation_commands
;
466 monitor_qmp_caps_reset(mon
);
467 data
= qmp_greeting(mon
);
468 qmp_send_response(mon
, data
);
472 case CHR_EVENT_CLOSED
:
474 * Note: this is only useful when the output of the chardev
475 * backend is still open. For example, when the backend is
476 * stdio, it's possible that stdout is still open when stdin
479 monitor_qmp_cleanup_queue_and_resume(mon
);
480 json_message_parser_destroy(&mon
->parser
);
481 json_message_parser_init(&mon
->parser
, handle_qmp_command
,
484 monitor_fdsets_cleanup();
486 case CHR_EVENT_BREAK
:
487 case CHR_EVENT_MUX_IN
:
488 case CHR_EVENT_MUX_OUT
:
494 void monitor_data_destroy_qmp(MonitorQMP
*mon
)
496 json_message_parser_destroy(&mon
->parser
);
497 qemu_mutex_destroy(&mon
->qmp_queue_lock
);
498 monitor_qmp_cleanup_req_queue_locked(mon
);
499 g_queue_free(mon
->qmp_requests
);
502 static void monitor_qmp_setup_handlers_bh(void *opaque
)
504 MonitorQMP
*mon
= opaque
;
505 GMainContext
*context
;
507 assert(mon
->common
.use_io_thread
);
508 context
= iothread_get_g_main_context(mon_iothread
);
510 qemu_chr_fe_set_handlers(&mon
->common
.chr
, monitor_can_read
,
511 monitor_qmp_read
, monitor_qmp_event
,
512 NULL
, &mon
->common
, context
, true);
513 monitor_list_append(&mon
->common
);
516 void monitor_init_qmp(Chardev
*chr
, bool pretty
, Error
**errp
)
518 MonitorQMP
*mon
= g_new0(MonitorQMP
, 1);
520 if (!qemu_chr_fe_init(&mon
->common
.chr
, chr
, errp
)) {
524 qemu_chr_fe_set_echo(&mon
->common
.chr
, true);
526 /* Note: we run QMP monitor in I/O thread when @chr supports that */
527 monitor_data_init(&mon
->common
, true, false,
528 qemu_chr_has_feature(chr
, QEMU_CHAR_FEATURE_GCONTEXT
));
530 mon
->pretty
= pretty
;
532 qemu_mutex_init(&mon
->qmp_queue_lock
);
533 mon
->qmp_requests
= g_queue_new();
535 json_message_parser_init(&mon
->parser
, handle_qmp_command
, mon
, NULL
);
536 if (mon
->common
.use_io_thread
) {
538 * Make sure the old iowatch is gone. It's possible when
539 * e.g. the chardev is in client mode, with wait=on.
541 remove_fd_in_watch(chr
);
543 * We can't call qemu_chr_fe_set_handlers() directly here
544 * since chardev might be running in the monitor I/O
545 * thread. Schedule a bottom half.
547 aio_bh_schedule_oneshot(iothread_get_aio_context(mon_iothread
),
548 monitor_qmp_setup_handlers_bh
, mon
);
549 /* The bottom half will add @mon to @mon_list */
551 qemu_chr_fe_set_handlers(&mon
->common
.chr
, monitor_can_read
,
552 monitor_qmp_read
, monitor_qmp_event
,
553 NULL
, &mon
->common
, NULL
, true);
554 monitor_list_append(&mon
->common
);