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