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