xref: /openbmc/qemu/monitor/monitor.c (revision 05caa062)
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 #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"
35 #include "trace.h"
36 
37 /*
38  * To prevent flooding clients, events can be throttled. The
39  * throttling is calculated globally, rather than per-Monitor
40  * instance.
41  */
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;
48 
49 typedef struct {
50     int64_t rate;       /* Minimum time (in ns) between two events */
51 } MonitorQAPIEventConf;
52 
53 /* Shared monitor I/O thread */
54 IOThread *mon_iothread;
55 
56 /* Coroutine to dispatch the requests received from I/O thread */
57 Coroutine *qmp_dispatcher_co;
58 
59 /*
60  * Set to true when the dispatcher coroutine should terminate.  Protected
61  * by monitor_lock.
62  */
63 bool qmp_dispatcher_co_shutdown;
64 
65 /*
66  * Protects mon_list, monitor_qapi_event_state, coroutine_mon,
67  * monitor_destroyed.
68  */
69 QemuMutex monitor_lock;
70 static GHashTable *monitor_qapi_event_state;
71 static GHashTable *coroutine_mon; /* Maps Coroutine* to Monitor* */
72 
73 MonitorList mon_list;
74 static bool monitor_destroyed;
75 
76 Monitor *monitor_cur(void)
77 {
78     Monitor *mon;
79 
80     qemu_mutex_lock(&monitor_lock);
81     mon = g_hash_table_lookup(coroutine_mon, qemu_coroutine_self());
82     qemu_mutex_unlock(&monitor_lock);
83 
84     return mon;
85 }
86 
87 /**
88  * Sets a new current monitor and returns the old one.
89  *
90  * If a non-NULL monitor is set for a coroutine, another call
91  * resetting it to NULL is required before the coroutine terminates,
92  * otherwise a stale entry would remain in the hash table.
93  */
94 Monitor *monitor_set_cur(Coroutine *co, Monitor *mon)
95 {
96     Monitor *old_monitor = monitor_cur();
97 
98     qemu_mutex_lock(&monitor_lock);
99     if (mon) {
100         g_hash_table_replace(coroutine_mon, co, mon);
101     } else {
102         g_hash_table_remove(coroutine_mon, co);
103     }
104     qemu_mutex_unlock(&monitor_lock);
105 
106     return old_monitor;
107 }
108 
109 /**
110  * Is the current monitor, if any, a QMP monitor?
111  */
112 bool monitor_cur_is_qmp(void)
113 {
114     Monitor *cur_mon = monitor_cur();
115 
116     return cur_mon && monitor_is_qmp(cur_mon);
117 }
118 
119 /**
120  * Is @mon is using readline?
121  * Note: not all HMP monitors use readline, e.g., gdbserver has a
122  * non-interactive HMP monitor, so readline is not used there.
123  */
124 static inline bool monitor_uses_readline(const MonitorHMP *mon)
125 {
126     return mon->use_readline;
127 }
128 
129 static inline bool monitor_is_hmp_non_interactive(const Monitor *mon)
130 {
131     if (monitor_is_qmp(mon)) {
132         return false;
133     }
134 
135     return !monitor_uses_readline(container_of(mon, MonitorHMP, common));
136 }
137 
138 static gboolean monitor_unblocked(void *do_not_use, GIOCondition cond,
139                                   void *opaque)
140 {
141     Monitor *mon = opaque;
142 
143     QEMU_LOCK_GUARD(&mon->mon_lock);
144     mon->out_watch = 0;
145     monitor_flush_locked(mon);
146     return G_SOURCE_REMOVE;
147 }
148 
149 /* Caller must hold mon->mon_lock */
150 void monitor_flush_locked(Monitor *mon)
151 {
152     int rc;
153     size_t len;
154     const char *buf;
155 
156     if (mon->skip_flush) {
157         return;
158     }
159 
160     buf = mon->outbuf->str;
161     len = mon->outbuf->len;
162 
163     if (len && !mon->mux_out) {
164         rc = qemu_chr_fe_write(&mon->chr, (const uint8_t *) buf, len);
165         if ((rc < 0 && errno != EAGAIN) || (rc == len)) {
166             /* all flushed or error */
167             g_string_truncate(mon->outbuf, 0);
168             return;
169         }
170         if (rc > 0) {
171             /* partial write */
172             g_string_erase(mon->outbuf, 0, rc);
173         }
174         if (mon->out_watch == 0) {
175             mon->out_watch =
176                 qemu_chr_fe_add_watch(&mon->chr, G_IO_OUT | G_IO_HUP,
177                                       monitor_unblocked, mon);
178         }
179     }
180 }
181 
182 void monitor_flush(Monitor *mon)
183 {
184     QEMU_LOCK_GUARD(&mon->mon_lock);
185     monitor_flush_locked(mon);
186 }
187 
188 /* flush at every end of line */
189 int monitor_puts_locked(Monitor *mon, const char *str)
190 {
191     int i;
192     char c;
193 
194     for (i = 0; str[i]; i++) {
195         c = str[i];
196         if (c == '\n') {
197             g_string_append_c(mon->outbuf, '\r');
198         }
199         g_string_append_c(mon->outbuf, c);
200         if (c == '\n') {
201             monitor_flush_locked(mon);
202         }
203     }
204 
205     return i;
206 }
207 
208 int monitor_puts(Monitor *mon, const char *str)
209 {
210     QEMU_LOCK_GUARD(&mon->mon_lock);
211     return monitor_puts_locked(mon, str);
212 }
213 
214 int monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
215 {
216     char *buf;
217     int n;
218 
219     if (!mon) {
220         return -1;
221     }
222 
223     if (monitor_is_qmp(mon)) {
224         return -1;
225     }
226 
227     buf = g_strdup_vprintf(fmt, ap);
228     n = monitor_puts(mon, buf);
229     g_free(buf);
230     return n;
231 }
232 
233 int monitor_printf(Monitor *mon, const char *fmt, ...)
234 {
235     int ret;
236 
237     va_list ap;
238     va_start(ap, fmt);
239     ret = monitor_vprintf(mon, fmt, ap);
240     va_end(ap);
241     return ret;
242 }
243 
244 void monitor_printc(Monitor *mon, int c)
245 {
246     monitor_printf(mon, "'");
247     switch(c) {
248     case '\'':
249         monitor_printf(mon, "\\'");
250         break;
251     case '\\':
252         monitor_printf(mon, "\\\\");
253         break;
254     case '\n':
255         monitor_printf(mon, "\\n");
256         break;
257     case '\r':
258         monitor_printf(mon, "\\r");
259         break;
260     default:
261         if (c >= 32 && c <= 126) {
262             monitor_printf(mon, "%c", c);
263         } else {
264             monitor_printf(mon, "\\x%02x", c);
265         }
266         break;
267     }
268     monitor_printf(mon, "'");
269 }
270 
271 /*
272  * Print to current monitor if we have one, else to stderr.
273  */
274 int error_vprintf(const char *fmt, va_list ap)
275 {
276     Monitor *cur_mon = monitor_cur();
277 
278     if (cur_mon && !monitor_cur_is_qmp()) {
279         return monitor_vprintf(cur_mon, fmt, ap);
280     }
281     return vfprintf(stderr, fmt, ap);
282 }
283 
284 int error_vprintf_unless_qmp(const char *fmt, va_list ap)
285 {
286     Monitor *cur_mon = monitor_cur();
287 
288     if (!cur_mon) {
289         return vfprintf(stderr, fmt, ap);
290     }
291     if (!monitor_cur_is_qmp()) {
292         return monitor_vprintf(cur_mon, fmt, ap);
293     }
294     return -1;
295 }
296 
297 int error_printf_unless_qmp(const char *fmt, ...)
298 {
299     va_list ap;
300     int ret;
301 
302     va_start(ap, fmt);
303     ret = error_vprintf_unless_qmp(fmt, ap);
304     va_end(ap);
305     return ret;
306 }
307 
308 static MonitorQAPIEventConf monitor_qapi_event_conf[QAPI_EVENT__MAX] = {
309     /* Limit guest-triggerable events to 1 per second */
310     [QAPI_EVENT_RTC_CHANGE]        = { 1000 * SCALE_MS },
311     [QAPI_EVENT_WATCHDOG]          = { 1000 * SCALE_MS },
312     [QAPI_EVENT_BALLOON_CHANGE]    = { 1000 * SCALE_MS },
313     [QAPI_EVENT_QUORUM_REPORT_BAD] = { 1000 * SCALE_MS },
314     [QAPI_EVENT_QUORUM_FAILURE]    = { 1000 * SCALE_MS },
315     [QAPI_EVENT_VSERPORT_CHANGE]   = { 1000 * SCALE_MS },
316     [QAPI_EVENT_MEMORY_DEVICE_SIZE_CHANGE] = { 1000 * SCALE_MS },
317     [QAPI_EVENT_HV_BALLOON_STATUS_REPORT] = { 1000 * SCALE_MS },
318 };
319 
320 /*
321  * Return the clock to use for recording an event's time.
322  * It's QEMU_CLOCK_REALTIME, except for qtests it's
323  * QEMU_CLOCK_VIRTUAL, to support testing rate limits.
324  * Beware: result is invalid before configure_accelerator().
325  */
326 static inline QEMUClockType monitor_get_event_clock(void)
327 {
328     return qtest_enabled() ? QEMU_CLOCK_VIRTUAL : QEMU_CLOCK_REALTIME;
329 }
330 
331 /*
332  * Broadcast an event to all monitors.
333  * @qdict is the event object.  Its member "event" must match @event.
334  * Caller must hold monitor_lock.
335  */
336 static void monitor_qapi_event_emit(QAPIEvent event, QDict *qdict)
337 {
338     Monitor *mon;
339     MonitorQMP *qmp_mon;
340 
341     trace_monitor_protocol_event_emit(event, qdict);
342     QTAILQ_FOREACH(mon, &mon_list, entry) {
343         if (!monitor_is_qmp(mon)) {
344             continue;
345         }
346 
347         qmp_mon = container_of(mon, MonitorQMP, common);
348         if (qmp_mon->commands != &qmp_cap_negotiation_commands) {
349             qmp_send_response(qmp_mon, qdict);
350         }
351     }
352 }
353 
354 static void monitor_qapi_event_handler(void *opaque);
355 
356 /*
357  * Queue a new event for emission to Monitor instances,
358  * applying any rate limiting if required.
359  */
360 static void
361 monitor_qapi_event_queue_no_reenter(QAPIEvent event, QDict *qdict)
362 {
363     MonitorQAPIEventConf *evconf;
364     MonitorQAPIEventState *evstate;
365 
366     assert(event < QAPI_EVENT__MAX);
367     evconf = &monitor_qapi_event_conf[event];
368     trace_monitor_protocol_event_queue(event, qdict, evconf->rate);
369 
370     QEMU_LOCK_GUARD(&monitor_lock);
371 
372     if (!evconf->rate) {
373         /* Unthrottled event */
374         monitor_qapi_event_emit(event, qdict);
375     } else {
376         QDict *data = qobject_to(QDict, qdict_get(qdict, "data"));
377         MonitorQAPIEventState key = { .event = event, .data = data };
378 
379         evstate = g_hash_table_lookup(monitor_qapi_event_state, &key);
380         assert(!evstate || timer_pending(evstate->timer));
381 
382         if (evstate) {
383             /*
384              * Timer is pending for (at least) evconf->rate ns after
385              * last send.  Store event for sending when timer fires,
386              * replacing a prior stored event if any.
387              */
388             qobject_unref(evstate->qdict);
389             evstate->qdict = qobject_ref(qdict);
390         } else {
391             /*
392              * Last send was (at least) evconf->rate ns ago.
393              * Send immediately, and arm the timer to call
394              * monitor_qapi_event_handler() in evconf->rate ns.  Any
395              * events arriving before then will be delayed until then.
396              */
397             int64_t now = qemu_clock_get_ns(monitor_get_event_clock());
398 
399             monitor_qapi_event_emit(event, qdict);
400 
401             evstate = g_new(MonitorQAPIEventState, 1);
402             evstate->event = event;
403             evstate->data = qobject_ref(data);
404             evstate->qdict = NULL;
405             evstate->timer = timer_new_ns(monitor_get_event_clock(),
406                                           monitor_qapi_event_handler,
407                                           evstate);
408             g_hash_table_add(monitor_qapi_event_state, evstate);
409             timer_mod_ns(evstate->timer, now + evconf->rate);
410         }
411     }
412 }
413 
414 void qapi_event_emit(QAPIEvent event, QDict *qdict)
415 {
416     /*
417      * monitor_qapi_event_queue_no_reenter() is not reentrant: it
418      * would deadlock on monitor_lock.  Work around by queueing
419      * events in thread-local storage.
420      * TODO: remove this, make it re-enter safe.
421      */
422     typedef struct MonitorQapiEvent {
423         QAPIEvent event;
424         QDict *qdict;
425         QSIMPLEQ_ENTRY(MonitorQapiEvent) entry;
426     } MonitorQapiEvent;
427     static __thread QSIMPLEQ_HEAD(, MonitorQapiEvent) event_queue;
428     static __thread bool reentered;
429     MonitorQapiEvent *ev;
430 
431     if (!reentered) {
432         QSIMPLEQ_INIT(&event_queue);
433     }
434 
435     ev = g_new(MonitorQapiEvent, 1);
436     ev->qdict = qobject_ref(qdict);
437     ev->event = event;
438     QSIMPLEQ_INSERT_TAIL(&event_queue, ev, entry);
439     if (reentered) {
440         return;
441     }
442 
443     reentered = true;
444 
445     while ((ev = QSIMPLEQ_FIRST(&event_queue)) != NULL) {
446         QSIMPLEQ_REMOVE_HEAD(&event_queue, entry);
447         monitor_qapi_event_queue_no_reenter(ev->event, ev->qdict);
448         qobject_unref(ev->qdict);
449         g_free(ev);
450     }
451 
452     reentered = false;
453 }
454 
455 /*
456  * This function runs evconf->rate ns after sending a throttled
457  * event.
458  * If another event has since been stored, send it.
459  */
460 static void monitor_qapi_event_handler(void *opaque)
461 {
462     MonitorQAPIEventState *evstate = opaque;
463     MonitorQAPIEventConf *evconf = &monitor_qapi_event_conf[evstate->event];
464 
465     trace_monitor_protocol_event_handler(evstate->event, evstate->qdict);
466     QEMU_LOCK_GUARD(&monitor_lock);
467 
468     if (evstate->qdict) {
469         int64_t now = qemu_clock_get_ns(monitor_get_event_clock());
470 
471         monitor_qapi_event_emit(evstate->event, evstate->qdict);
472         qobject_unref(evstate->qdict);
473         evstate->qdict = NULL;
474         timer_mod_ns(evstate->timer, now + evconf->rate);
475     } else {
476         g_hash_table_remove(monitor_qapi_event_state, evstate);
477         qobject_unref(evstate->data);
478         timer_free(evstate->timer);
479         g_free(evstate);
480     }
481 }
482 
483 static unsigned int qapi_event_throttle_hash(const void *key)
484 {
485     const MonitorQAPIEventState *evstate = key;
486     unsigned int hash = evstate->event * 255;
487 
488     if (evstate->event == QAPI_EVENT_VSERPORT_CHANGE) {
489         hash += g_str_hash(qdict_get_str(evstate->data, "id"));
490     }
491 
492     if (evstate->event == QAPI_EVENT_QUORUM_REPORT_BAD) {
493         hash += g_str_hash(qdict_get_str(evstate->data, "node-name"));
494     }
495 
496     if (evstate->event == QAPI_EVENT_MEMORY_DEVICE_SIZE_CHANGE) {
497         hash += g_str_hash(qdict_get_str(evstate->data, "qom-path"));
498     }
499 
500     return hash;
501 }
502 
503 static gboolean qapi_event_throttle_equal(const void *a, const void *b)
504 {
505     const MonitorQAPIEventState *eva = a;
506     const MonitorQAPIEventState *evb = b;
507 
508     if (eva->event != evb->event) {
509         return FALSE;
510     }
511 
512     if (eva->event == QAPI_EVENT_VSERPORT_CHANGE) {
513         return !strcmp(qdict_get_str(eva->data, "id"),
514                        qdict_get_str(evb->data, "id"));
515     }
516 
517     if (eva->event == QAPI_EVENT_QUORUM_REPORT_BAD) {
518         return !strcmp(qdict_get_str(eva->data, "node-name"),
519                        qdict_get_str(evb->data, "node-name"));
520     }
521 
522     if (eva->event == QAPI_EVENT_MEMORY_DEVICE_SIZE_CHANGE) {
523         return !strcmp(qdict_get_str(eva->data, "qom-path"),
524                        qdict_get_str(evb->data, "qom-path"));
525     }
526 
527     return TRUE;
528 }
529 
530 int monitor_suspend(Monitor *mon)
531 {
532     if (monitor_is_hmp_non_interactive(mon)) {
533         return -ENOTTY;
534     }
535 
536     qatomic_inc(&mon->suspend_cnt);
537 
538     if (mon->use_io_thread) {
539         /*
540          * Kick I/O thread to make sure this takes effect.  It'll be
541          * evaluated again in prepare() of the watch object.
542          */
543         aio_notify(iothread_get_aio_context(mon_iothread));
544     }
545 
546     trace_monitor_suspend(mon, 1);
547     return 0;
548 }
549 
550 static void monitor_accept_input(void *opaque)
551 {
552     Monitor *mon = opaque;
553 
554     qemu_mutex_lock(&mon->mon_lock);
555     if (!monitor_is_qmp(mon) && mon->reset_seen) {
556         MonitorHMP *hmp_mon = container_of(mon, MonitorHMP, common);
557         assert(hmp_mon->rs);
558         readline_restart(hmp_mon->rs);
559         qemu_mutex_unlock(&mon->mon_lock);
560         readline_show_prompt(hmp_mon->rs);
561     } else {
562         qemu_mutex_unlock(&mon->mon_lock);
563     }
564 
565     qemu_chr_fe_accept_input(&mon->chr);
566 }
567 
568 void monitor_resume(Monitor *mon)
569 {
570     if (monitor_is_hmp_non_interactive(mon)) {
571         return;
572     }
573 
574     if (qatomic_dec_fetch(&mon->suspend_cnt) == 0) {
575         AioContext *ctx;
576 
577         if (mon->use_io_thread) {
578             ctx = iothread_get_aio_context(mon_iothread);
579         } else {
580             ctx = qemu_get_aio_context();
581         }
582 
583         aio_bh_schedule_oneshot(ctx, monitor_accept_input, mon);
584     }
585 
586     trace_monitor_suspend(mon, -1);
587 }
588 
589 int monitor_can_read(void *opaque)
590 {
591     Monitor *mon = opaque;
592 
593     return !qatomic_read(&mon->suspend_cnt);
594 }
595 
596 void monitor_list_append(Monitor *mon)
597 {
598     qemu_mutex_lock(&monitor_lock);
599     /*
600      * This prevents inserting new monitors during monitor_cleanup().
601      * A cleaner solution would involve the main thread telling other
602      * threads to terminate, waiting for their termination.
603      */
604     if (!monitor_destroyed) {
605         QTAILQ_INSERT_HEAD(&mon_list, mon, entry);
606         mon = NULL;
607     }
608     qemu_mutex_unlock(&monitor_lock);
609 
610     if (mon) {
611         monitor_data_destroy(mon);
612         g_free(mon);
613     }
614 }
615 
616 static void monitor_iothread_init(void)
617 {
618     mon_iothread = iothread_create("mon_iothread", &error_abort);
619 }
620 
621 void monitor_data_init(Monitor *mon, bool is_qmp, bool skip_flush,
622                        bool use_io_thread)
623 {
624     if (use_io_thread && !mon_iothread) {
625         monitor_iothread_init();
626     }
627     qemu_mutex_init(&mon->mon_lock);
628     mon->is_qmp = is_qmp;
629     mon->outbuf = g_string_new(NULL);
630     mon->skip_flush = skip_flush;
631     mon->use_io_thread = use_io_thread;
632 }
633 
634 void monitor_data_destroy(Monitor *mon)
635 {
636     g_free(mon->mon_cpu_path);
637     qemu_chr_fe_deinit(&mon->chr, false);
638     if (monitor_is_qmp(mon)) {
639         monitor_data_destroy_qmp(container_of(mon, MonitorQMP, common));
640     } else {
641         readline_free(container_of(mon, MonitorHMP, common)->rs);
642     }
643     g_string_free(mon->outbuf, true);
644     qemu_mutex_destroy(&mon->mon_lock);
645 }
646 
647 void monitor_cleanup(void)
648 {
649     /*
650      * The dispatcher needs to stop before destroying the monitor and
651      * the I/O thread.
652      *
653      * We need to poll both qemu_aio_context and iohandler_ctx to make
654      * sure that the dispatcher coroutine keeps making progress and
655      * eventually terminates.  qemu_aio_context is automatically
656      * polled by calling AIO_WAIT_WHILE_UNLOCKED on it, but we must poll
657      * iohandler_ctx manually.
658      *
659      * Letting the iothread continue while shutting down the dispatcher
660      * means that new requests may still be coming in. This is okay,
661      * we'll just leave them in the queue without sending a response
662      * and monitor_data_destroy() will free them.
663      */
664     WITH_QEMU_LOCK_GUARD(&monitor_lock) {
665         qmp_dispatcher_co_shutdown = true;
666     }
667     qmp_dispatcher_co_wake();
668 
669     AIO_WAIT_WHILE_UNLOCKED(NULL,
670                    (aio_poll(iohandler_get_aio_context(), false),
671                     qatomic_read(&qmp_dispatcher_co)));
672 
673     /*
674      * We need to explicitly stop the I/O thread (but not destroy it),
675      * clean up the monitor resources, then destroy the I/O thread since
676      * we need to unregister from chardev below in
677      * monitor_data_destroy(), and chardev is not thread-safe yet
678      */
679     if (mon_iothread) {
680         iothread_stop(mon_iothread);
681     }
682 
683     /* Flush output buffers and destroy monitors */
684     qemu_mutex_lock(&monitor_lock);
685     monitor_destroyed = true;
686     while (!QTAILQ_EMPTY(&mon_list)) {
687         Monitor *mon = QTAILQ_FIRST(&mon_list);
688         QTAILQ_REMOVE(&mon_list, mon, entry);
689         /* Permit QAPI event emission from character frontend release */
690         qemu_mutex_unlock(&monitor_lock);
691         monitor_flush(mon);
692         monitor_data_destroy(mon);
693         qemu_mutex_lock(&monitor_lock);
694         g_free(mon);
695     }
696     qemu_mutex_unlock(&monitor_lock);
697 
698     if (mon_iothread) {
699         iothread_destroy(mon_iothread);
700         mon_iothread = NULL;
701     }
702 }
703 
704 static void monitor_qapi_event_init(void)
705 {
706     monitor_qapi_event_state = g_hash_table_new(qapi_event_throttle_hash,
707                                                 qapi_event_throttle_equal);
708 }
709 
710 void monitor_init_globals(void)
711 {
712     monitor_qapi_event_init();
713     qemu_mutex_init(&monitor_lock);
714     coroutine_mon = g_hash_table_new(NULL, NULL);
715 
716     /*
717      * The dispatcher BH must run in the main loop thread, since we
718      * have commands assuming that context.  It would be nice to get
719      * rid of those assumptions.
720      */
721     qmp_dispatcher_co = qemu_coroutine_create(monitor_qmp_dispatcher_co, NULL);
722     aio_co_schedule(iohandler_get_aio_context(), qmp_dispatcher_co);
723 }
724 
725 int monitor_init(MonitorOptions *opts, bool allow_hmp, Error **errp)
726 {
727     ERRP_GUARD();
728     Chardev *chr;
729 
730     chr = qemu_chr_find(opts->chardev);
731     if (chr == NULL) {
732         error_setg(errp, "chardev \"%s\" not found", opts->chardev);
733         return -1;
734     }
735 
736     if (!opts->has_mode) {
737         opts->mode = allow_hmp ? MONITOR_MODE_READLINE : MONITOR_MODE_CONTROL;
738     }
739 
740     switch (opts->mode) {
741     case MONITOR_MODE_CONTROL:
742         monitor_init_qmp(chr, opts->pretty, errp);
743         break;
744     case MONITOR_MODE_READLINE:
745         if (!allow_hmp) {
746             error_setg(errp, "Only QMP is supported");
747             return -1;
748         }
749         if (opts->pretty) {
750             error_setg(errp, "'pretty' is not compatible with HMP monitors");
751             return -1;
752         }
753         monitor_init_hmp(chr, true, errp);
754         break;
755     default:
756         g_assert_not_reached();
757     }
758 
759     return *errp ? -1 : 0;
760 }
761 
762 int monitor_init_opts(QemuOpts *opts, Error **errp)
763 {
764     Visitor *v;
765     MonitorOptions *options;
766     int ret;
767 
768     v = opts_visitor_new(opts);
769     visit_type_MonitorOptions(v, NULL, &options, errp);
770     visit_free(v);
771     if (!options) {
772         return -1;
773     }
774 
775     ret = monitor_init(options, true, errp);
776     qapi_free_MonitorOptions(options);
777     return ret;
778 }
779 
780 QemuOptsList qemu_mon_opts = {
781     .name = "mon",
782     .implied_opt_name = "chardev",
783     .head = QTAILQ_HEAD_INITIALIZER(qemu_mon_opts.head),
784     .desc = {
785         {
786             .name = "mode",
787             .type = QEMU_OPT_STRING,
788         },{
789             .name = "chardev",
790             .type = QEMU_OPT_STRING,
791         },{
792             .name = "pretty",
793             .type = QEMU_OPT_BOOL,
794         },
795         { /* end of list */ }
796     },
797 };
798