1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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
39
40
41
42typedef struct MonitorQAPIEventState {
43 QAPIEvent event;
44 QDict *data;
45 QEMUTimer *timer;
46 QDict *qdict;
47} MonitorQAPIEventState;
48
49typedef struct {
50 int64_t rate;
51} MonitorQAPIEventConf;
52
53
54IOThread *mon_iothread;
55
56
57Coroutine *qmp_dispatcher_co;
58
59
60bool qmp_dispatcher_co_shutdown;
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81bool qmp_dispatcher_co_busy;
82
83
84
85
86
87QemuMutex monitor_lock;
88static GHashTable *monitor_qapi_event_state;
89static GHashTable *coroutine_mon;
90
91MonitorList mon_list;
92int mon_refcount;
93static bool monitor_destroyed;
94
95Monitor *monitor_cur(void)
96{
97 Monitor *mon;
98
99 qemu_mutex_lock(&monitor_lock);
100 mon = g_hash_table_lookup(coroutine_mon, qemu_coroutine_self());
101 qemu_mutex_unlock(&monitor_lock);
102
103 return mon;
104}
105
106
107
108
109
110
111
112
113Monitor *monitor_set_cur(Coroutine *co, Monitor *mon)
114{
115 Monitor *old_monitor = monitor_cur();
116
117 qemu_mutex_lock(&monitor_lock);
118 if (mon) {
119 g_hash_table_replace(coroutine_mon, co, mon);
120 } else {
121 g_hash_table_remove(coroutine_mon, co);
122 }
123 qemu_mutex_unlock(&monitor_lock);
124
125 return old_monitor;
126}
127
128
129
130
131bool monitor_cur_is_qmp(void)
132{
133 Monitor *cur_mon = monitor_cur();
134
135 return cur_mon && monitor_is_qmp(cur_mon);
136}
137
138
139
140
141
142
143static inline bool monitor_uses_readline(const MonitorHMP *mon)
144{
145 return mon->use_readline;
146}
147
148static inline bool monitor_is_hmp_non_interactive(const Monitor *mon)
149{
150 if (monitor_is_qmp(mon)) {
151 return false;
152 }
153
154 return !monitor_uses_readline(container_of(mon, MonitorHMP, common));
155}
156
157static void monitor_flush_locked(Monitor *mon);
158
159static gboolean monitor_unblocked(void *do_not_use, GIOCondition cond,
160 void *opaque)
161{
162 Monitor *mon = opaque;
163
164 qemu_mutex_lock(&mon->mon_lock);
165 mon->out_watch = 0;
166 monitor_flush_locked(mon);
167 qemu_mutex_unlock(&mon->mon_lock);
168 return FALSE;
169}
170
171
172static void monitor_flush_locked(Monitor *mon)
173{
174 int rc;
175 size_t len;
176 const char *buf;
177
178 if (mon->skip_flush) {
179 return;
180 }
181
182 buf = mon->outbuf->str;
183 len = mon->outbuf->len;
184
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
189 g_string_truncate(mon->outbuf, 0);
190 return;
191 }
192 if (rc > 0) {
193
194 g_string_erase(mon->outbuf, 0, rc);
195 }
196 if (mon->out_watch == 0) {
197 mon->out_watch =
198 qemu_chr_fe_add_watch(&mon->chr, G_IO_OUT | G_IO_HUP,
199 monitor_unblocked, mon);
200 }
201 }
202}
203
204void monitor_flush(Monitor *mon)
205{
206 qemu_mutex_lock(&mon->mon_lock);
207 monitor_flush_locked(mon);
208 qemu_mutex_unlock(&mon->mon_lock);
209}
210
211
212int monitor_puts(Monitor *mon, const char *str)
213{
214 int i;
215 char c;
216
217 qemu_mutex_lock(&mon->mon_lock);
218 for (i = 0; str[i]; i++) {
219 c = str[i];
220 if (c == '\n') {
221 g_string_append_c(mon->outbuf, '\r');
222 }
223 g_string_append_c(mon->outbuf, c);
224 if (c == '\n') {
225 monitor_flush_locked(mon);
226 }
227 }
228 qemu_mutex_unlock(&mon->mon_lock);
229
230 return i;
231}
232
233int monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
234{
235 char *buf;
236 int n;
237
238 if (!mon) {
239 return -1;
240 }
241
242 if (monitor_is_qmp(mon)) {
243 return -1;
244 }
245
246 buf = g_strdup_vprintf(fmt, ap);
247 n = monitor_puts(mon, buf);
248 g_free(buf);
249 return n;
250}
251
252int monitor_printf(Monitor *mon, const char *fmt, ...)
253{
254 int ret;
255
256 va_list ap;
257 va_start(ap, fmt);
258 ret = monitor_vprintf(mon, fmt, ap);
259 va_end(ap);
260 return ret;
261}
262
263
264
265
266int error_vprintf(const char *fmt, va_list ap)
267{
268 Monitor *cur_mon = monitor_cur();
269
270 if (cur_mon && !monitor_cur_is_qmp()) {
271 return monitor_vprintf(cur_mon, fmt, ap);
272 }
273 return vfprintf(stderr, fmt, ap);
274}
275
276int error_vprintf_unless_qmp(const char *fmt, va_list ap)
277{
278 Monitor *cur_mon = monitor_cur();
279
280 if (!cur_mon) {
281 return vfprintf(stderr, fmt, ap);
282 }
283 if (!monitor_cur_is_qmp()) {
284 return monitor_vprintf(cur_mon, fmt, ap);
285 }
286 return -1;
287}
288
289
290static MonitorQAPIEventConf monitor_qapi_event_conf[QAPI_EVENT__MAX] = {
291
292 [QAPI_EVENT_RTC_CHANGE] = { 1000 * SCALE_MS },
293 [QAPI_EVENT_WATCHDOG] = { 1000 * SCALE_MS },
294 [QAPI_EVENT_BALLOON_CHANGE] = { 1000 * SCALE_MS },
295 [QAPI_EVENT_QUORUM_REPORT_BAD] = { 1000 * SCALE_MS },
296 [QAPI_EVENT_QUORUM_FAILURE] = { 1000 * SCALE_MS },
297 [QAPI_EVENT_VSERPORT_CHANGE] = { 1000 * SCALE_MS },
298 [QAPI_EVENT_MEMORY_DEVICE_SIZE_CHANGE] = { 1000 * SCALE_MS },
299};
300
301
302
303
304
305
306
307static inline QEMUClockType monitor_get_event_clock(void)
308{
309 return qtest_enabled() ? QEMU_CLOCK_VIRTUAL : QEMU_CLOCK_REALTIME;
310}
311
312
313
314
315
316
317static void monitor_qapi_event_emit(QAPIEvent event, QDict *qdict)
318{
319 Monitor *mon;
320 MonitorQMP *qmp_mon;
321
322 trace_monitor_protocol_event_emit(event, qdict);
323 QTAILQ_FOREACH(mon, &mon_list, entry) {
324 if (!monitor_is_qmp(mon)) {
325 continue;
326 }
327
328 qmp_mon = container_of(mon, MonitorQMP, common);
329 if (qmp_mon->commands != &qmp_cap_negotiation_commands) {
330 qmp_send_response(qmp_mon, qdict);
331 }
332 }
333}
334
335static void monitor_qapi_event_handler(void *opaque);
336
337
338
339
340
341static void
342monitor_qapi_event_queue_no_reenter(QAPIEvent event, QDict *qdict)
343{
344 MonitorQAPIEventConf *evconf;
345 MonitorQAPIEventState *evstate;
346
347 assert(event < QAPI_EVENT__MAX);
348 evconf = &monitor_qapi_event_conf[event];
349 trace_monitor_protocol_event_queue(event, qdict, evconf->rate);
350
351 QEMU_LOCK_GUARD(&monitor_lock);
352
353 if (!evconf->rate) {
354
355 monitor_qapi_event_emit(event, qdict);
356 } else {
357 QDict *data = qobject_to(QDict, qdict_get(qdict, "data"));
358 MonitorQAPIEventState key = { .event = event, .data = data };
359
360 evstate = g_hash_table_lookup(monitor_qapi_event_state, &key);
361 assert(!evstate || timer_pending(evstate->timer));
362
363 if (evstate) {
364
365
366
367
368
369 qobject_unref(evstate->qdict);
370 evstate->qdict = qobject_ref(qdict);
371 } else {
372
373
374
375
376
377
378 int64_t now = qemu_clock_get_ns(monitor_get_event_clock());
379
380 monitor_qapi_event_emit(event, qdict);
381
382 evstate = g_new(MonitorQAPIEventState, 1);
383 evstate->event = event;
384 evstate->data = qobject_ref(data);
385 evstate->qdict = NULL;
386 evstate->timer = timer_new_ns(monitor_get_event_clock(),
387 monitor_qapi_event_handler,
388 evstate);
389 g_hash_table_add(monitor_qapi_event_state, evstate);
390 timer_mod_ns(evstate->timer, now + evconf->rate);
391 }
392 }
393}
394
395void qapi_event_emit(QAPIEvent event, QDict *qdict)
396{
397
398
399
400
401
402
403 typedef struct MonitorQapiEvent {
404 QAPIEvent event;
405 QDict *qdict;
406 QSIMPLEQ_ENTRY(MonitorQapiEvent) entry;
407 } MonitorQapiEvent;
408 static __thread QSIMPLEQ_HEAD(, MonitorQapiEvent) event_queue;
409 static __thread bool reentered;
410 MonitorQapiEvent *ev;
411
412 if (!reentered) {
413 QSIMPLEQ_INIT(&event_queue);
414 }
415
416 ev = g_new(MonitorQapiEvent, 1);
417 ev->qdict = qobject_ref(qdict);
418 ev->event = event;
419 QSIMPLEQ_INSERT_TAIL(&event_queue, ev, entry);
420 if (reentered) {
421 return;
422 }
423
424 reentered = true;
425
426 while ((ev = QSIMPLEQ_FIRST(&event_queue)) != NULL) {
427 QSIMPLEQ_REMOVE_HEAD(&event_queue, entry);
428 monitor_qapi_event_queue_no_reenter(ev->event, ev->qdict);
429 qobject_unref(ev->qdict);
430 g_free(ev);
431 }
432
433 reentered = false;
434}
435
436
437
438
439
440
441static void monitor_qapi_event_handler(void *opaque)
442{
443 MonitorQAPIEventState *evstate = opaque;
444 MonitorQAPIEventConf *evconf = &monitor_qapi_event_conf[evstate->event];
445
446 trace_monitor_protocol_event_handler(evstate->event, evstate->qdict);
447 QEMU_LOCK_GUARD(&monitor_lock);
448
449 if (evstate->qdict) {
450 int64_t now = qemu_clock_get_ns(monitor_get_event_clock());
451
452 monitor_qapi_event_emit(evstate->event, evstate->qdict);
453 qobject_unref(evstate->qdict);
454 evstate->qdict = NULL;
455 timer_mod_ns(evstate->timer, now + evconf->rate);
456 } else {
457 g_hash_table_remove(monitor_qapi_event_state, evstate);
458 qobject_unref(evstate->data);
459 timer_free(evstate->timer);
460 g_free(evstate);
461 }
462}
463
464static unsigned int qapi_event_throttle_hash(const void *key)
465{
466 const MonitorQAPIEventState *evstate = key;
467 unsigned int hash = evstate->event * 255;
468
469 if (evstate->event == QAPI_EVENT_VSERPORT_CHANGE) {
470 hash += g_str_hash(qdict_get_str(evstate->data, "id"));
471 }
472
473 if (evstate->event == QAPI_EVENT_QUORUM_REPORT_BAD) {
474 hash += g_str_hash(qdict_get_str(evstate->data, "node-name"));
475 }
476
477 if (evstate->event == QAPI_EVENT_MEMORY_DEVICE_SIZE_CHANGE) {
478 hash += g_str_hash(qdict_get_str(evstate->data, "qom-path"));
479 }
480
481 return hash;
482}
483
484static gboolean qapi_event_throttle_equal(const void *a, const void *b)
485{
486 const MonitorQAPIEventState *eva = a;
487 const MonitorQAPIEventState *evb = b;
488
489 if (eva->event != evb->event) {
490 return FALSE;
491 }
492
493 if (eva->event == QAPI_EVENT_VSERPORT_CHANGE) {
494 return !strcmp(qdict_get_str(eva->data, "id"),
495 qdict_get_str(evb->data, "id"));
496 }
497
498 if (eva->event == QAPI_EVENT_QUORUM_REPORT_BAD) {
499 return !strcmp(qdict_get_str(eva->data, "node-name"),
500 qdict_get_str(evb->data, "node-name"));
501 }
502
503 if (eva->event == QAPI_EVENT_MEMORY_DEVICE_SIZE_CHANGE) {
504 return !strcmp(qdict_get_str(eva->data, "qom-path"),
505 qdict_get_str(evb->data, "qom-path"));
506 }
507
508 return TRUE;
509}
510
511int 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
522
523
524 aio_notify(iothread_get_aio_context(mon_iothread));
525 }
526
527 trace_monitor_suspend(mon, 1);
528 return 0;
529}
530
531static void monitor_accept_input(void *opaque)
532{
533 Monitor *mon = opaque;
534
535 qemu_chr_fe_accept_input(&mon->chr);
536}
537
538void 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
565int monitor_can_read(void *opaque)
566{
567 Monitor *mon = opaque;
568
569 return !qatomic_mb_read(&mon->suspend_cnt);
570}
571
572void monitor_list_append(Monitor *mon)
573{
574 qemu_mutex_lock(&monitor_lock);
575
576
577
578
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
592static void monitor_iothread_init(void)
593{
594 mon_iothread = iothread_create("mon_iothread", &error_abort);
595}
596
597void 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 = g_string_new(NULL);
606 mon->skip_flush = skip_flush;
607 mon->use_io_thread = use_io_thread;
608}
609
610void 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 g_string_free(mon->outbuf, true);
620 qemu_mutex_destroy(&mon->mon_lock);
621}
622
623void monitor_cleanup(void)
624{
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640 qmp_dispatcher_co_shutdown = true;
641 if (!qatomic_xchg(&qmp_dispatcher_co_busy, true)) {
642 aio_co_wake(qmp_dispatcher_co);
643 }
644
645 AIO_WAIT_WHILE(qemu_get_aio_context(),
646 (aio_poll(iohandler_get_aio_context(), false),
647 qatomic_mb_read(&qmp_dispatcher_co_busy)));
648
649
650
651
652
653
654
655 if (mon_iothread) {
656 iothread_stop(mon_iothread);
657 }
658
659
660 qemu_mutex_lock(&monitor_lock);
661 monitor_destroyed = true;
662 while (!QTAILQ_EMPTY(&mon_list)) {
663 Monitor *mon = QTAILQ_FIRST(&mon_list);
664 QTAILQ_REMOVE(&mon_list, mon, entry);
665
666 qemu_mutex_unlock(&monitor_lock);
667 monitor_flush(mon);
668 monitor_data_destroy(mon);
669 qemu_mutex_lock(&monitor_lock);
670 g_free(mon);
671 }
672 qemu_mutex_unlock(&monitor_lock);
673
674 if (mon_iothread) {
675 iothread_destroy(mon_iothread);
676 mon_iothread = NULL;
677 }
678}
679
680static void monitor_qapi_event_init(void)
681{
682 monitor_qapi_event_state = g_hash_table_new(qapi_event_throttle_hash,
683 qapi_event_throttle_equal);
684}
685
686void monitor_init_globals_core(void)
687{
688 monitor_qapi_event_init();
689 qemu_mutex_init(&monitor_lock);
690 coroutine_mon = g_hash_table_new(NULL, NULL);
691
692
693
694
695
696
697 qmp_dispatcher_co = qemu_coroutine_create(monitor_qmp_dispatcher_co, NULL);
698 qatomic_mb_set(&qmp_dispatcher_co_busy, true);
699 aio_co_schedule(iohandler_get_aio_context(), qmp_dispatcher_co);
700}
701
702int monitor_init(MonitorOptions *opts, bool allow_hmp, Error **errp)
703{
704 Chardev *chr;
705 Error *local_err = NULL;
706
707 chr = qemu_chr_find(opts->chardev);
708 if (chr == NULL) {
709 error_setg(errp, "chardev \"%s\" not found", opts->chardev);
710 return -1;
711 }
712
713 if (!opts->has_mode) {
714 opts->mode = allow_hmp ? MONITOR_MODE_READLINE : MONITOR_MODE_CONTROL;
715 }
716
717 switch (opts->mode) {
718 case MONITOR_MODE_CONTROL:
719 monitor_init_qmp(chr, opts->pretty, &local_err);
720 break;
721 case MONITOR_MODE_READLINE:
722 if (!allow_hmp) {
723 error_setg(errp, "Only QMP is supported");
724 return -1;
725 }
726 if (opts->pretty) {
727 error_setg(errp, "'pretty' is not compatible with HMP monitors");
728 return -1;
729 }
730 monitor_init_hmp(chr, true, &local_err);
731 break;
732 default:
733 g_assert_not_reached();
734 }
735
736 if (local_err) {
737 error_propagate(errp, local_err);
738 return -1;
739 }
740 return 0;
741}
742
743int monitor_init_opts(QemuOpts *opts, Error **errp)
744{
745 Visitor *v;
746 MonitorOptions *options;
747 int ret;
748
749 v = opts_visitor_new(opts);
750 visit_type_MonitorOptions(v, NULL, &options, errp);
751 visit_free(v);
752 if (!options) {
753 return -1;
754 }
755
756 ret = monitor_init(options, true, errp);
757 qapi_free_MonitorOptions(options);
758 return ret;
759}
760
761QemuOptsList qemu_mon_opts = {
762 .name = "mon",
763 .implied_opt_name = "chardev",
764 .head = QTAILQ_HEAD_INITIALIZER(qemu_mon_opts.head),
765 .desc = {
766 {
767 .name = "mode",
768 .type = QEMU_OPT_STRING,
769 },{
770 .name = "chardev",
771 .type = QEMU_OPT_STRING,
772 },{
773 .name = "pretty",
774 .type = QEMU_OPT_BOOL,
775 },
776 { }
777 },
778};
779