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"
26 #include "monitor-internal.h"
27 #include "qapi/error.h"
28 #include "qapi/opts-visitor.h"
29 #include "qapi/qapi-emit-events.h"
30 #include "qapi/qapi-visit-control.h"
31 #include "qapi/qmp/qdict.h"
32 #include "qemu/error-report.h"
33 #include "qemu/option.h"
34 #include "sysemu/qtest.h"
38 * To prevent flooding clients, events can be throttled. The
39 * throttling is calculated globally, rather than per-Monitor
42 typedef struct MonitorQAPIEventState
{
43 QAPIEvent event
; /* Throttling state for this event type and... */
44 QDict
*data
; /* ... data, see qapi_event_throttle_equal() */
45 QEMUTimer
*timer
; /* Timer for handling delayed events */
46 QDict
*qdict
; /* Delayed event (if any) */
47 } MonitorQAPIEventState
;
50 int64_t rate
; /* Minimum time (in ns) between two events */
51 } MonitorQAPIEventConf
;
53 /* Shared monitor I/O thread */
54 IOThread
*mon_iothread
;
56 /* Coroutine to dispatch the requests received from I/O thread */
57 Coroutine
*qmp_dispatcher_co
;
60 * Set to true when the dispatcher coroutine should terminate. Protected
63 bool qmp_dispatcher_co_shutdown
;
66 * qmp_dispatcher_co_busy is used for synchronisation between the
67 * monitor thread and the main thread to ensure that the dispatcher
68 * coroutine never gets scheduled a second time when it's already
69 * scheduled (scheduling the same coroutine twice is forbidden).
71 * It is true if the coroutine is active and processing requests.
72 * Additional requests may then be pushed onto mon->qmp_requests,
73 * and @qmp_dispatcher_co_shutdown may be set without further ado.
74 * @qmp_dispatcher_co_busy must not be woken up in this case.
76 * If false, you also have to set @qmp_dispatcher_co_busy to true and
77 * wake up @qmp_dispatcher_co after pushing the new requests.
79 * The coroutine will automatically change this variable back to false
80 * before it yields. Nobody else may set the variable to false.
82 * Access must be atomic for thread safety.
84 bool qmp_dispatcher_co_busy
;
87 * Protects mon_list, monitor_qapi_event_state, coroutine_mon,
90 QemuMutex monitor_lock
;
91 static GHashTable
*monitor_qapi_event_state
;
92 static GHashTable
*coroutine_mon
; /* Maps Coroutine* to Monitor* */
96 static bool monitor_destroyed
;
98 Monitor
*monitor_cur(void)
102 qemu_mutex_lock(&monitor_lock
);
103 mon
= g_hash_table_lookup(coroutine_mon
, qemu_coroutine_self());
104 qemu_mutex_unlock(&monitor_lock
);
110 * Sets a new current monitor and returns the old one.
112 * If a non-NULL monitor is set for a coroutine, another call
113 * resetting it to NULL is required before the coroutine terminates,
114 * otherwise a stale entry would remain in the hash table.
116 Monitor
*monitor_set_cur(Coroutine
*co
, Monitor
*mon
)
118 Monitor
*old_monitor
= monitor_cur();
120 qemu_mutex_lock(&monitor_lock
);
122 g_hash_table_replace(coroutine_mon
, co
, mon
);
124 g_hash_table_remove(coroutine_mon
, co
);
126 qemu_mutex_unlock(&monitor_lock
);
132 * Is the current monitor, if any, a QMP monitor?
134 bool monitor_cur_is_qmp(void)
136 Monitor
*cur_mon
= monitor_cur();
138 return cur_mon
&& monitor_is_qmp(cur_mon
);
142 * Is @mon is using readline?
143 * Note: not all HMP monitors use readline, e.g., gdbserver has a
144 * non-interactive HMP monitor, so readline is not used there.
146 static inline bool monitor_uses_readline(const MonitorHMP
*mon
)
148 return mon
->use_readline
;
151 static inline bool monitor_is_hmp_non_interactive(const Monitor
*mon
)
153 if (monitor_is_qmp(mon
)) {
157 return !monitor_uses_readline(container_of(mon
, MonitorHMP
, common
));
160 static gboolean
monitor_unblocked(void *do_not_use
, GIOCondition cond
,
163 Monitor
*mon
= opaque
;
165 QEMU_LOCK_GUARD(&mon
->mon_lock
);
167 monitor_flush_locked(mon
);
171 /* Caller must hold mon->mon_lock */
172 void monitor_flush_locked(Monitor
*mon
)
178 if (mon
->skip_flush
) {
182 buf
= mon
->outbuf
->str
;
183 len
= mon
->outbuf
->len
;
185 if (len
&& !mon
->mux_out
) {
186 rc
= qemu_chr_fe_write(&mon
->chr
, (const uint8_t *) buf
, len
);
187 if ((rc
< 0 && errno
!= EAGAIN
) || (rc
== len
)) {
188 /* all flushed or error */
189 g_string_truncate(mon
->outbuf
, 0);
194 g_string_erase(mon
->outbuf
, 0, rc
);
196 if (mon
->out_watch
== 0) {
198 qemu_chr_fe_add_watch(&mon
->chr
, G_IO_OUT
| G_IO_HUP
,
199 monitor_unblocked
, mon
);
204 void monitor_flush(Monitor
*mon
)
206 QEMU_LOCK_GUARD(&mon
->mon_lock
);
207 monitor_flush_locked(mon
);
210 /* flush at every end of line */
211 int monitor_puts_locked(Monitor
*mon
, const char *str
)
216 for (i
= 0; str
[i
]; i
++) {
219 g_string_append_c(mon
->outbuf
, '\r');
221 g_string_append_c(mon
->outbuf
, c
);
223 monitor_flush_locked(mon
);
230 int monitor_puts(Monitor
*mon
, const char *str
)
232 QEMU_LOCK_GUARD(&mon
->mon_lock
);
233 return monitor_puts_locked(mon
, str
);
236 int monitor_vprintf(Monitor
*mon
, const char *fmt
, va_list ap
)
245 if (monitor_is_qmp(mon
)) {
249 buf
= g_strdup_vprintf(fmt
, ap
);
250 n
= monitor_puts(mon
, buf
);
255 int monitor_printf(Monitor
*mon
, const char *fmt
, ...)
261 ret
= monitor_vprintf(mon
, fmt
, ap
);
266 void monitor_printc(Monitor
*mon
, int c
)
268 monitor_printf(mon
, "'");
271 monitor_printf(mon
, "\\'");
274 monitor_printf(mon
, "\\\\");
277 monitor_printf(mon
, "\\n");
280 monitor_printf(mon
, "\\r");
283 if (c
>= 32 && c
<= 126) {
284 monitor_printf(mon
, "%c", c
);
286 monitor_printf(mon
, "\\x%02x", c
);
290 monitor_printf(mon
, "'");
294 * Print to current monitor if we have one, else to stderr.
296 int error_vprintf(const char *fmt
, va_list ap
)
298 Monitor
*cur_mon
= monitor_cur();
300 if (cur_mon
&& !monitor_cur_is_qmp()) {
301 return monitor_vprintf(cur_mon
, fmt
, ap
);
303 return vfprintf(stderr
, fmt
, ap
);
306 int error_vprintf_unless_qmp(const char *fmt
, va_list ap
)
308 Monitor
*cur_mon
= monitor_cur();
311 return vfprintf(stderr
, fmt
, ap
);
313 if (!monitor_cur_is_qmp()) {
314 return monitor_vprintf(cur_mon
, fmt
, ap
);
319 int error_printf_unless_qmp(const char *fmt
, ...)
325 ret
= error_vprintf_unless_qmp(fmt
, ap
);
330 static MonitorQAPIEventConf monitor_qapi_event_conf
[QAPI_EVENT__MAX
] = {
331 /* Limit guest-triggerable events to 1 per second */
332 [QAPI_EVENT_RTC_CHANGE
] = { 1000 * SCALE_MS
},
333 [QAPI_EVENT_WATCHDOG
] = { 1000 * SCALE_MS
},
334 [QAPI_EVENT_BALLOON_CHANGE
] = { 1000 * SCALE_MS
},
335 [QAPI_EVENT_QUORUM_REPORT_BAD
] = { 1000 * SCALE_MS
},
336 [QAPI_EVENT_QUORUM_FAILURE
] = { 1000 * SCALE_MS
},
337 [QAPI_EVENT_VSERPORT_CHANGE
] = { 1000 * SCALE_MS
},
338 [QAPI_EVENT_MEMORY_DEVICE_SIZE_CHANGE
] = { 1000 * SCALE_MS
},
342 * Return the clock to use for recording an event's time.
343 * It's QEMU_CLOCK_REALTIME, except for qtests it's
344 * QEMU_CLOCK_VIRTUAL, to support testing rate limits.
345 * Beware: result is invalid before configure_accelerator().
347 static inline QEMUClockType
monitor_get_event_clock(void)
349 return qtest_enabled() ? QEMU_CLOCK_VIRTUAL
: QEMU_CLOCK_REALTIME
;
353 * Broadcast an event to all monitors.
354 * @qdict is the event object. Its member "event" must match @event.
355 * Caller must hold monitor_lock.
357 static void monitor_qapi_event_emit(QAPIEvent event
, QDict
*qdict
)
362 trace_monitor_protocol_event_emit(event
, qdict
);
363 QTAILQ_FOREACH(mon
, &mon_list
, entry
) {
364 if (!monitor_is_qmp(mon
)) {
368 qmp_mon
= container_of(mon
, MonitorQMP
, common
);
369 if (qmp_mon
->commands
!= &qmp_cap_negotiation_commands
) {
370 qmp_send_response(qmp_mon
, qdict
);
375 static void monitor_qapi_event_handler(void *opaque
);
378 * Queue a new event for emission to Monitor instances,
379 * applying any rate limiting if required.
382 monitor_qapi_event_queue_no_reenter(QAPIEvent event
, QDict
*qdict
)
384 MonitorQAPIEventConf
*evconf
;
385 MonitorQAPIEventState
*evstate
;
387 assert(event
< QAPI_EVENT__MAX
);
388 evconf
= &monitor_qapi_event_conf
[event
];
389 trace_monitor_protocol_event_queue(event
, qdict
, evconf
->rate
);
391 QEMU_LOCK_GUARD(&monitor_lock
);
394 /* Unthrottled event */
395 monitor_qapi_event_emit(event
, qdict
);
397 QDict
*data
= qobject_to(QDict
, qdict_get(qdict
, "data"));
398 MonitorQAPIEventState key
= { .event
= event
, .data
= data
};
400 evstate
= g_hash_table_lookup(monitor_qapi_event_state
, &key
);
401 assert(!evstate
|| timer_pending(evstate
->timer
));
405 * Timer is pending for (at least) evconf->rate ns after
406 * last send. Store event for sending when timer fires,
407 * replacing a prior stored event if any.
409 qobject_unref(evstate
->qdict
);
410 evstate
->qdict
= qobject_ref(qdict
);
413 * Last send was (at least) evconf->rate ns ago.
414 * Send immediately, and arm the timer to call
415 * monitor_qapi_event_handler() in evconf->rate ns. Any
416 * events arriving before then will be delayed until then.
418 int64_t now
= qemu_clock_get_ns(monitor_get_event_clock());
420 monitor_qapi_event_emit(event
, qdict
);
422 evstate
= g_new(MonitorQAPIEventState
, 1);
423 evstate
->event
= event
;
424 evstate
->data
= qobject_ref(data
);
425 evstate
->qdict
= NULL
;
426 evstate
->timer
= timer_new_ns(monitor_get_event_clock(),
427 monitor_qapi_event_handler
,
429 g_hash_table_add(monitor_qapi_event_state
, evstate
);
430 timer_mod_ns(evstate
->timer
, now
+ evconf
->rate
);
435 void qapi_event_emit(QAPIEvent event
, QDict
*qdict
)
438 * monitor_qapi_event_queue_no_reenter() is not reentrant: it
439 * would deadlock on monitor_lock. Work around by queueing
440 * events in thread-local storage.
441 * TODO: remove this, make it re-enter safe.
443 typedef struct MonitorQapiEvent
{
446 QSIMPLEQ_ENTRY(MonitorQapiEvent
) entry
;
448 static __thread
QSIMPLEQ_HEAD(, MonitorQapiEvent
) event_queue
;
449 static __thread
bool reentered
;
450 MonitorQapiEvent
*ev
;
453 QSIMPLEQ_INIT(&event_queue
);
456 ev
= g_new(MonitorQapiEvent
, 1);
457 ev
->qdict
= qobject_ref(qdict
);
459 QSIMPLEQ_INSERT_TAIL(&event_queue
, ev
, entry
);
466 while ((ev
= QSIMPLEQ_FIRST(&event_queue
)) != NULL
) {
467 QSIMPLEQ_REMOVE_HEAD(&event_queue
, entry
);
468 monitor_qapi_event_queue_no_reenter(ev
->event
, ev
->qdict
);
469 qobject_unref(ev
->qdict
);
477 * This function runs evconf->rate ns after sending a throttled
479 * If another event has since been stored, send it.
481 static void monitor_qapi_event_handler(void *opaque
)
483 MonitorQAPIEventState
*evstate
= opaque
;
484 MonitorQAPIEventConf
*evconf
= &monitor_qapi_event_conf
[evstate
->event
];
486 trace_monitor_protocol_event_handler(evstate
->event
, evstate
->qdict
);
487 QEMU_LOCK_GUARD(&monitor_lock
);
489 if (evstate
->qdict
) {
490 int64_t now
= qemu_clock_get_ns(monitor_get_event_clock());
492 monitor_qapi_event_emit(evstate
->event
, evstate
->qdict
);
493 qobject_unref(evstate
->qdict
);
494 evstate
->qdict
= NULL
;
495 timer_mod_ns(evstate
->timer
, now
+ evconf
->rate
);
497 g_hash_table_remove(monitor_qapi_event_state
, evstate
);
498 qobject_unref(evstate
->data
);
499 timer_free(evstate
->timer
);
504 static unsigned int qapi_event_throttle_hash(const void *key
)
506 const MonitorQAPIEventState
*evstate
= key
;
507 unsigned int hash
= evstate
->event
* 255;
509 if (evstate
->event
== QAPI_EVENT_VSERPORT_CHANGE
) {
510 hash
+= g_str_hash(qdict_get_str(evstate
->data
, "id"));
513 if (evstate
->event
== QAPI_EVENT_QUORUM_REPORT_BAD
) {
514 hash
+= g_str_hash(qdict_get_str(evstate
->data
, "node-name"));
517 if (evstate
->event
== QAPI_EVENT_MEMORY_DEVICE_SIZE_CHANGE
) {
518 hash
+= g_str_hash(qdict_get_str(evstate
->data
, "qom-path"));
524 static gboolean
qapi_event_throttle_equal(const void *a
, const void *b
)
526 const MonitorQAPIEventState
*eva
= a
;
527 const MonitorQAPIEventState
*evb
= b
;
529 if (eva
->event
!= evb
->event
) {
533 if (eva
->event
== QAPI_EVENT_VSERPORT_CHANGE
) {
534 return !strcmp(qdict_get_str(eva
->data
, "id"),
535 qdict_get_str(evb
->data
, "id"));
538 if (eva
->event
== QAPI_EVENT_QUORUM_REPORT_BAD
) {
539 return !strcmp(qdict_get_str(eva
->data
, "node-name"),
540 qdict_get_str(evb
->data
, "node-name"));
543 if (eva
->event
== QAPI_EVENT_MEMORY_DEVICE_SIZE_CHANGE
) {
544 return !strcmp(qdict_get_str(eva
->data
, "qom-path"),
545 qdict_get_str(evb
->data
, "qom-path"));
551 int monitor_suspend(Monitor
*mon
)
553 if (monitor_is_hmp_non_interactive(mon
)) {
557 qatomic_inc(&mon
->suspend_cnt
);
559 if (mon
->use_io_thread
) {
561 * Kick I/O thread to make sure this takes effect. It'll be
562 * evaluated again in prepare() of the watch object.
564 aio_notify(iothread_get_aio_context(mon_iothread
));
567 trace_monitor_suspend(mon
, 1);
571 static void monitor_accept_input(void *opaque
)
573 Monitor
*mon
= opaque
;
575 qemu_mutex_lock(&mon
->mon_lock
);
576 if (!monitor_is_qmp(mon
) && mon
->reset_seen
) {
577 MonitorHMP
*hmp_mon
= container_of(mon
, MonitorHMP
, common
);
579 readline_restart(hmp_mon
->rs
);
580 qemu_mutex_unlock(&mon
->mon_lock
);
581 readline_show_prompt(hmp_mon
->rs
);
583 qemu_mutex_unlock(&mon
->mon_lock
);
586 qemu_chr_fe_accept_input(&mon
->chr
);
589 void monitor_resume(Monitor
*mon
)
591 if (monitor_is_hmp_non_interactive(mon
)) {
595 if (qatomic_dec_fetch(&mon
->suspend_cnt
) == 0) {
598 if (mon
->use_io_thread
) {
599 ctx
= iothread_get_aio_context(mon_iothread
);
601 ctx
= qemu_get_aio_context();
604 aio_bh_schedule_oneshot(ctx
, monitor_accept_input
, mon
);
607 trace_monitor_suspend(mon
, -1);
610 int monitor_can_read(void *opaque
)
612 Monitor
*mon
= opaque
;
614 return !qatomic_read(&mon
->suspend_cnt
);
617 void monitor_list_append(Monitor
*mon
)
619 qemu_mutex_lock(&monitor_lock
);
621 * This prevents inserting new monitors during monitor_cleanup().
622 * A cleaner solution would involve the main thread telling other
623 * threads to terminate, waiting for their termination.
625 if (!monitor_destroyed
) {
626 QTAILQ_INSERT_HEAD(&mon_list
, mon
, entry
);
629 qemu_mutex_unlock(&monitor_lock
);
632 monitor_data_destroy(mon
);
637 static void monitor_iothread_init(void)
639 mon_iothread
= iothread_create("mon_iothread", &error_abort
);
642 void monitor_data_init(Monitor
*mon
, bool is_qmp
, bool skip_flush
,
645 if (use_io_thread
&& !mon_iothread
) {
646 monitor_iothread_init();
648 qemu_mutex_init(&mon
->mon_lock
);
649 mon
->is_qmp
= is_qmp
;
650 mon
->outbuf
= g_string_new(NULL
);
651 mon
->skip_flush
= skip_flush
;
652 mon
->use_io_thread
= use_io_thread
;
655 void monitor_data_destroy(Monitor
*mon
)
657 g_free(mon
->mon_cpu_path
);
658 qemu_chr_fe_deinit(&mon
->chr
, false);
659 if (monitor_is_qmp(mon
)) {
660 monitor_data_destroy_qmp(container_of(mon
, MonitorQMP
, common
));
662 readline_free(container_of(mon
, MonitorHMP
, common
)->rs
);
664 g_string_free(mon
->outbuf
, true);
665 qemu_mutex_destroy(&mon
->mon_lock
);
668 void monitor_cleanup(void)
671 * The dispatcher needs to stop before destroying the monitor and
674 * We need to poll both qemu_aio_context and iohandler_ctx to make
675 * sure that the dispatcher coroutine keeps making progress and
676 * eventually terminates. qemu_aio_context is automatically
677 * polled by calling AIO_WAIT_WHILE_UNLOCKED on it, but we must poll
678 * iohandler_ctx manually.
680 * Letting the iothread continue while shutting down the dispatcher
681 * means that new requests may still be coming in. This is okay,
682 * we'll just leave them in the queue without sending a response
683 * and monitor_data_destroy() will free them.
685 WITH_QEMU_LOCK_GUARD(&monitor_lock
) {
686 qmp_dispatcher_co_shutdown
= true;
688 if (!qatomic_xchg(&qmp_dispatcher_co_busy
, true)) {
689 aio_co_wake(qmp_dispatcher_co
);
692 AIO_WAIT_WHILE_UNLOCKED(NULL
,
693 (aio_poll(iohandler_get_aio_context(), false),
694 qatomic_read(&qmp_dispatcher_co
)));
697 * We need to explicitly stop the I/O thread (but not destroy it),
698 * clean up the monitor resources, then destroy the I/O thread since
699 * we need to unregister from chardev below in
700 * monitor_data_destroy(), and chardev is not thread-safe yet
703 iothread_stop(mon_iothread
);
706 /* Flush output buffers and destroy monitors */
707 qemu_mutex_lock(&monitor_lock
);
708 monitor_destroyed
= true;
709 while (!QTAILQ_EMPTY(&mon_list
)) {
710 Monitor
*mon
= QTAILQ_FIRST(&mon_list
);
711 QTAILQ_REMOVE(&mon_list
, mon
, entry
);
712 /* Permit QAPI event emission from character frontend release */
713 qemu_mutex_unlock(&monitor_lock
);
715 monitor_data_destroy(mon
);
716 qemu_mutex_lock(&monitor_lock
);
719 qemu_mutex_unlock(&monitor_lock
);
722 iothread_destroy(mon_iothread
);
727 static void monitor_qapi_event_init(void)
729 monitor_qapi_event_state
= g_hash_table_new(qapi_event_throttle_hash
,
730 qapi_event_throttle_equal
);
733 void monitor_init_globals(void)
735 monitor_qapi_event_init();
736 qemu_mutex_init(&monitor_lock
);
737 coroutine_mon
= g_hash_table_new(NULL
, NULL
);
740 * The dispatcher BH must run in the main loop thread, since we
741 * have commands assuming that context. It would be nice to get
742 * rid of those assumptions.
744 qmp_dispatcher_co
= qemu_coroutine_create(monitor_qmp_dispatcher_co
, NULL
);
745 qatomic_mb_set(&qmp_dispatcher_co_busy
, true);
746 aio_co_schedule(iohandler_get_aio_context(), qmp_dispatcher_co
);
749 int monitor_init(MonitorOptions
*opts
, bool allow_hmp
, Error
**errp
)
754 chr
= qemu_chr_find(opts
->chardev
);
756 error_setg(errp
, "chardev \"%s\" not found", opts
->chardev
);
760 if (!opts
->has_mode
) {
761 opts
->mode
= allow_hmp
? MONITOR_MODE_READLINE
: MONITOR_MODE_CONTROL
;
764 switch (opts
->mode
) {
765 case MONITOR_MODE_CONTROL
:
766 monitor_init_qmp(chr
, opts
->pretty
, errp
);
768 case MONITOR_MODE_READLINE
:
770 error_setg(errp
, "Only QMP is supported");
774 error_setg(errp
, "'pretty' is not compatible with HMP monitors");
777 monitor_init_hmp(chr
, true, errp
);
780 g_assert_not_reached();
783 return *errp
? -1 : 0;
786 int monitor_init_opts(QemuOpts
*opts
, Error
**errp
)
789 MonitorOptions
*options
;
792 v
= opts_visitor_new(opts
);
793 visit_type_MonitorOptions(v
, NULL
, &options
, errp
);
799 ret
= monitor_init(options
, true, errp
);
800 qapi_free_MonitorOptions(options
);
804 QemuOptsList qemu_mon_opts
= {
806 .implied_opt_name
= "chardev",
807 .head
= QTAILQ_HEAD_INITIALIZER(qemu_mon_opts
.head
),
811 .type
= QEMU_OPT_STRING
,
814 .type
= QEMU_OPT_STRING
,
817 .type
= QEMU_OPT_BOOL
,
819 { /* end of list */ }