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 "qemu/units.h"
27#include <dirent.h>
28#include "cpu.h"
29#include "hw/hw.h"
30#include "monitor/qdev.h"
31#include "hw/usb.h"
32#include "hw/pci/pci.h"
33#include "sysemu/watchdog.h"
34#include "hw/loader.h"
35#include "exec/gdbstub.h"
36#include "net/net.h"
37#include "net/slirp.h"
38#include "chardev/char-fe.h"
39#include "chardev/char-io.h"
40#include "chardev/char-mux.h"
41#include "ui/qemu-spice.h"
42#include "sysemu/numa.h"
43#include "monitor/monitor.h"
44#include "qemu/config-file.h"
45#include "qemu/readline.h"
46#include "ui/console.h"
47#include "ui/input.h"
48#include "sysemu/block-backend.h"
49#include "audio/audio.h"
50#include "disas/disas.h"
51#include "sysemu/balloon.h"
52#include "qemu/timer.h"
53#include "sysemu/hw_accel.h"
54#include "qemu/acl.h"
55#include "sysemu/tpm.h"
56#include "qapi/qmp/qdict.h"
57#include "qapi/qmp/qerror.h"
58#include "qapi/qmp/qnum.h"
59#include "qapi/qmp/qstring.h"
60#include "qapi/qmp/qjson.h"
61#include "qapi/qmp/json-parser.h"
62#include "qapi/qmp/qlist.h"
63#include "qom/object_interfaces.h"
64#include "trace-root.h"
65#include "trace/control.h"
66#include "monitor/hmp-target.h"
67#ifdef CONFIG_TRACE_SIMPLE
68#include "trace/simple.h"
69#endif
70#include "exec/memory.h"
71#include "exec/exec-all.h"
72#include "qemu/log.h"
73#include "qemu/option.h"
74#include "hmp.h"
75#include "qemu/thread.h"
76#include "block/qapi.h"
77#include "qapi/qapi-commands.h"
78#include "qapi/qapi-events.h"
79#include "qapi/error.h"
80#include "qapi/qmp-event.h"
81#include "qapi/qapi-introspect.h"
82#include "sysemu/qtest.h"
83#include "sysemu/cpus.h"
84#include "sysemu/iothread.h"
85#include "qemu/cutils.h"
86#include "tcg/tcg.h"
87
88#if defined(TARGET_S390X)
89#include "hw/s390x/storage-keys.h"
90#include "hw/s390x/storage-attributes.h"
91#endif
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127typedef struct mon_cmd_t {
128 const char *name;
129 const char *args_type;
130 const char *params;
131 const char *help;
132 const char *flags;
133 void (*cmd)(Monitor *mon, const QDict *qdict);
134
135
136
137
138 struct mon_cmd_t *sub_table;
139 void (*command_completion)(ReadLineState *rs, int nb_args, const char *str);
140} mon_cmd_t;
141
142
143typedef struct mon_fd_t mon_fd_t;
144struct mon_fd_t {
145 char *name;
146 int fd;
147 QLIST_ENTRY(mon_fd_t) next;
148};
149
150
151typedef struct MonFdsetFd MonFdsetFd;
152struct MonFdsetFd {
153 int fd;
154 bool removed;
155 char *opaque;
156 QLIST_ENTRY(MonFdsetFd) next;
157};
158
159
160typedef struct MonFdset MonFdset;
161struct MonFdset {
162 int64_t id;
163 QLIST_HEAD(, MonFdsetFd) fds;
164 QLIST_HEAD(, MonFdsetFd) dup_fds;
165 QLIST_ENTRY(MonFdset) next;
166};
167
168typedef struct {
169 JSONMessageParser parser;
170
171
172
173
174
175
176 QmpCommandList *commands;
177 bool capab_offered[QMP_CAPABILITY__MAX];
178 bool capab[QMP_CAPABILITY__MAX];
179
180
181
182
183 QemuMutex qmp_queue_lock;
184
185 GQueue *qmp_requests;
186} MonitorQMP;
187
188
189
190
191
192
193typedef struct MonitorQAPIEventState {
194 QAPIEvent event;
195 QDict *data;
196 QEMUTimer *timer;
197 QDict *qdict;
198} MonitorQAPIEventState;
199
200typedef struct {
201 int64_t rate;
202} MonitorQAPIEventConf;
203
204struct Monitor {
205 CharBackend chr;
206 int reset_seen;
207 int flags;
208 int suspend_cnt;
209 bool skip_flush;
210 bool use_io_thread;
211
212
213
214
215
216
217
218 ReadLineState *rs;
219
220 MonitorQMP qmp;
221 gchar *mon_cpu_path;
222 BlockCompletionFunc *password_completion_cb;
223 void *password_opaque;
224 mon_cmd_t *cmd_table;
225 QTAILQ_ENTRY(Monitor) entry;
226
227
228
229
230
231 QemuMutex mon_lock;
232
233
234
235
236 QLIST_HEAD(, mon_fd_t) fds;
237 QString *outbuf;
238 guint out_watch;
239
240 int mux_out;
241};
242
243
244IOThread *mon_iothread;
245
246
247QEMUBH *qmp_dispatcher_bh;
248
249struct QMPRequest {
250
251 Monitor *mon;
252
253 QObject *id;
254
255
256
257
258 QObject *req;
259 Error *err;
260};
261typedef struct QMPRequest QMPRequest;
262
263
264#define QMP_ACCEPT_UNKNOWNS 1
265
266
267static QemuMutex monitor_lock;
268static GHashTable *monitor_qapi_event_state;
269static QTAILQ_HEAD(mon_list, Monitor) mon_list;
270
271
272static QemuMutex mon_fdsets_lock;
273static QLIST_HEAD(mon_fdsets, MonFdset) mon_fdsets;
274
275static int mon_refcount;
276
277static mon_cmd_t mon_cmds[];
278static mon_cmd_t info_cmds[];
279
280QmpCommandList qmp_commands, qmp_cap_negotiation_commands;
281
282__thread Monitor *cur_mon;
283
284static void monitor_command_cb(void *opaque, const char *cmdline,
285 void *readline_opaque);
286
287
288
289
290static inline bool monitor_is_qmp(const Monitor *mon)
291{
292 return (mon->flags & MONITOR_USE_CONTROL);
293}
294
295
296
297
298
299
300static inline bool monitor_uses_readline(const Monitor *mon)
301{
302 return mon->flags & MONITOR_USE_READLINE;
303}
304
305static inline bool monitor_is_hmp_non_interactive(const Monitor *mon)
306{
307 return !monitor_is_qmp(mon) && !monitor_uses_readline(mon);
308}
309
310
311
312
313
314
315
316static inline QEMUClockType monitor_get_event_clock(void)
317{
318 return qtest_enabled() ? QEMU_CLOCK_VIRTUAL : QEMU_CLOCK_REALTIME;
319}
320
321
322
323
324bool monitor_cur_is_qmp(void)
325{
326 return cur_mon && monitor_is_qmp(cur_mon);
327}
328
329void monitor_read_command(Monitor *mon, int show_prompt)
330{
331 if (!mon->rs)
332 return;
333
334 readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL);
335 if (show_prompt)
336 readline_show_prompt(mon->rs);
337}
338
339int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
340 void *opaque)
341{
342 if (mon->rs) {
343 readline_start(mon->rs, "Password: ", 1, readline_func, opaque);
344
345 return 0;
346 } else {
347 monitor_printf(mon, "terminal does not support password prompting\n");
348 return -ENOTTY;
349 }
350}
351
352static void qmp_request_free(QMPRequest *req)
353{
354 qobject_unref(req->id);
355 qobject_unref(req->req);
356 error_free(req->err);
357 g_free(req);
358}
359
360
361static void monitor_qmp_cleanup_req_queue_locked(Monitor *mon)
362{
363 while (!g_queue_is_empty(mon->qmp.qmp_requests)) {
364 qmp_request_free(g_queue_pop_head(mon->qmp.qmp_requests));
365 }
366}
367
368static void monitor_qmp_cleanup_queues(Monitor *mon)
369{
370 qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
371 monitor_qmp_cleanup_req_queue_locked(mon);
372 qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
373}
374
375
376static void monitor_flush_locked(Monitor *mon);
377
378static gboolean monitor_unblocked(GIOChannel *chan, GIOCondition cond,
379 void *opaque)
380{
381 Monitor *mon = opaque;
382
383 qemu_mutex_lock(&mon->mon_lock);
384 mon->out_watch = 0;
385 monitor_flush_locked(mon);
386 qemu_mutex_unlock(&mon->mon_lock);
387 return FALSE;
388}
389
390
391static void monitor_flush_locked(Monitor *mon)
392{
393 int rc;
394 size_t len;
395 const char *buf;
396
397 if (mon->skip_flush) {
398 return;
399 }
400
401 buf = qstring_get_str(mon->outbuf);
402 len = qstring_get_length(mon->outbuf);
403
404 if (len && !mon->mux_out) {
405 rc = qemu_chr_fe_write(&mon->chr, (const uint8_t *) buf, len);
406 if ((rc < 0 && errno != EAGAIN) || (rc == len)) {
407
408 qobject_unref(mon->outbuf);
409 mon->outbuf = qstring_new();
410 return;
411 }
412 if (rc > 0) {
413
414 QString *tmp = qstring_from_str(buf + rc);
415 qobject_unref(mon->outbuf);
416 mon->outbuf = tmp;
417 }
418 if (mon->out_watch == 0) {
419 mon->out_watch =
420 qemu_chr_fe_add_watch(&mon->chr, G_IO_OUT | G_IO_HUP,
421 monitor_unblocked, mon);
422 }
423 }
424}
425
426void monitor_flush(Monitor *mon)
427{
428 qemu_mutex_lock(&mon->mon_lock);
429 monitor_flush_locked(mon);
430 qemu_mutex_unlock(&mon->mon_lock);
431}
432
433
434static void monitor_puts(Monitor *mon, const char *str)
435{
436 char c;
437
438 qemu_mutex_lock(&mon->mon_lock);
439 for(;;) {
440 c = *str++;
441 if (c == '\0')
442 break;
443 if (c == '\n') {
444 qstring_append_chr(mon->outbuf, '\r');
445 }
446 qstring_append_chr(mon->outbuf, c);
447 if (c == '\n') {
448 monitor_flush_locked(mon);
449 }
450 }
451 qemu_mutex_unlock(&mon->mon_lock);
452}
453
454void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
455{
456 char *buf;
457
458 if (!mon)
459 return;
460
461 if (monitor_is_qmp(mon)) {
462 return;
463 }
464
465 buf = g_strdup_vprintf(fmt, ap);
466 monitor_puts(mon, buf);
467 g_free(buf);
468}
469
470void monitor_printf(Monitor *mon, const char *fmt, ...)
471{
472 va_list ap;
473 va_start(ap, fmt);
474 monitor_vprintf(mon, fmt, ap);
475 va_end(ap);
476}
477
478int monitor_fprintf(FILE *stream, const char *fmt, ...)
479{
480 va_list ap;
481 va_start(ap, fmt);
482 monitor_vprintf((Monitor *)stream, fmt, ap);
483 va_end(ap);
484 return 0;
485}
486
487static void qmp_send_response(Monitor *mon, const QDict *rsp)
488{
489 const QObject *data = QOBJECT(rsp);
490 QString *json;
491
492 json = mon->flags & MONITOR_USE_PRETTY ? qobject_to_json_pretty(data) :
493 qobject_to_json(data);
494 assert(json != NULL);
495
496 qstring_append_chr(json, '\n');
497 monitor_puts(mon, qstring_get_str(json));
498
499 qobject_unref(json);
500}
501
502static MonitorQAPIEventConf monitor_qapi_event_conf[QAPI_EVENT__MAX] = {
503
504 [QAPI_EVENT_RTC_CHANGE] = { 1000 * SCALE_MS },
505 [QAPI_EVENT_WATCHDOG] = { 1000 * SCALE_MS },
506 [QAPI_EVENT_BALLOON_CHANGE] = { 1000 * SCALE_MS },
507 [QAPI_EVENT_QUORUM_REPORT_BAD] = { 1000 * SCALE_MS },
508 [QAPI_EVENT_QUORUM_FAILURE] = { 1000 * SCALE_MS },
509 [QAPI_EVENT_VSERPORT_CHANGE] = { 1000 * SCALE_MS },
510};
511
512
513
514
515
516
517static void monitor_qapi_event_emit(QAPIEvent event, QDict *qdict)
518{
519 Monitor *mon;
520
521 trace_monitor_protocol_event_emit(event, qdict);
522 QTAILQ_FOREACH(mon, &mon_list, entry) {
523 if (monitor_is_qmp(mon)
524 && mon->qmp.commands != &qmp_cap_negotiation_commands) {
525 qmp_send_response(mon, qdict);
526 }
527 }
528}
529
530static void monitor_qapi_event_handler(void *opaque);
531
532
533
534
535
536static void
537monitor_qapi_event_queue_no_reenter(QAPIEvent event, QDict *qdict)
538{
539 MonitorQAPIEventConf *evconf;
540 MonitorQAPIEventState *evstate;
541
542 assert(event < QAPI_EVENT__MAX);
543 evconf = &monitor_qapi_event_conf[event];
544 trace_monitor_protocol_event_queue(event, qdict, evconf->rate);
545
546 qemu_mutex_lock(&monitor_lock);
547
548 if (!evconf->rate) {
549
550 monitor_qapi_event_emit(event, qdict);
551 } else {
552 QDict *data = qobject_to(QDict, qdict_get(qdict, "data"));
553 MonitorQAPIEventState key = { .event = event, .data = data };
554
555 evstate = g_hash_table_lookup(monitor_qapi_event_state, &key);
556 assert(!evstate || timer_pending(evstate->timer));
557
558 if (evstate) {
559
560
561
562
563
564 qobject_unref(evstate->qdict);
565 evstate->qdict = qobject_ref(qdict);
566 } else {
567
568
569
570
571
572
573 int64_t now = qemu_clock_get_ns(monitor_get_event_clock());
574
575 monitor_qapi_event_emit(event, qdict);
576
577 evstate = g_new(MonitorQAPIEventState, 1);
578 evstate->event = event;
579 evstate->data = qobject_ref(data);
580 evstate->qdict = NULL;
581 evstate->timer = timer_new_ns(monitor_get_event_clock(),
582 monitor_qapi_event_handler,
583 evstate);
584 g_hash_table_add(monitor_qapi_event_state, evstate);
585 timer_mod_ns(evstate->timer, now + evconf->rate);
586 }
587 }
588
589 qemu_mutex_unlock(&monitor_lock);
590}
591
592static void
593monitor_qapi_event_queue(QAPIEvent event, QDict *qdict)
594{
595
596
597
598
599
600
601 typedef struct MonitorQapiEvent {
602 QAPIEvent event;
603 QDict *qdict;
604 QSIMPLEQ_ENTRY(MonitorQapiEvent) entry;
605 } MonitorQapiEvent;
606 static __thread QSIMPLEQ_HEAD(, MonitorQapiEvent) event_queue;
607 static __thread bool reentered;
608 MonitorQapiEvent *ev;
609
610 if (!reentered) {
611 QSIMPLEQ_INIT(&event_queue);
612 }
613
614 ev = g_new(MonitorQapiEvent, 1);
615 ev->qdict = qobject_ref(qdict);
616 ev->event = event;
617 QSIMPLEQ_INSERT_TAIL(&event_queue, ev, entry);
618 if (reentered) {
619 return;
620 }
621
622 reentered = true;
623
624 while ((ev = QSIMPLEQ_FIRST(&event_queue)) != NULL) {
625 QSIMPLEQ_REMOVE_HEAD(&event_queue, entry);
626 monitor_qapi_event_queue_no_reenter(ev->event, ev->qdict);
627 qobject_unref(ev->qdict);
628 g_free(ev);
629 }
630
631 reentered = false;
632}
633
634
635
636
637
638
639static void monitor_qapi_event_handler(void *opaque)
640{
641 MonitorQAPIEventState *evstate = opaque;
642 MonitorQAPIEventConf *evconf = &monitor_qapi_event_conf[evstate->event];
643
644 trace_monitor_protocol_event_handler(evstate->event, evstate->qdict);
645 qemu_mutex_lock(&monitor_lock);
646
647 if (evstate->qdict) {
648 int64_t now = qemu_clock_get_ns(monitor_get_event_clock());
649
650 monitor_qapi_event_emit(evstate->event, evstate->qdict);
651 qobject_unref(evstate->qdict);
652 evstate->qdict = NULL;
653 timer_mod_ns(evstate->timer, now + evconf->rate);
654 } else {
655 g_hash_table_remove(monitor_qapi_event_state, evstate);
656 qobject_unref(evstate->data);
657 timer_free(evstate->timer);
658 g_free(evstate);
659 }
660
661 qemu_mutex_unlock(&monitor_lock);
662}
663
664static unsigned int qapi_event_throttle_hash(const void *key)
665{
666 const MonitorQAPIEventState *evstate = key;
667 unsigned int hash = evstate->event * 255;
668
669 if (evstate->event == QAPI_EVENT_VSERPORT_CHANGE) {
670 hash += g_str_hash(qdict_get_str(evstate->data, "id"));
671 }
672
673 if (evstate->event == QAPI_EVENT_QUORUM_REPORT_BAD) {
674 hash += g_str_hash(qdict_get_str(evstate->data, "node-name"));
675 }
676
677 return hash;
678}
679
680static gboolean qapi_event_throttle_equal(const void *a, const void *b)
681{
682 const MonitorQAPIEventState *eva = a;
683 const MonitorQAPIEventState *evb = b;
684
685 if (eva->event != evb->event) {
686 return FALSE;
687 }
688
689 if (eva->event == QAPI_EVENT_VSERPORT_CHANGE) {
690 return !strcmp(qdict_get_str(eva->data, "id"),
691 qdict_get_str(evb->data, "id"));
692 }
693
694 if (eva->event == QAPI_EVENT_QUORUM_REPORT_BAD) {
695 return !strcmp(qdict_get_str(eva->data, "node-name"),
696 qdict_get_str(evb->data, "node-name"));
697 }
698
699 return TRUE;
700}
701
702static void monitor_qapi_event_init(void)
703{
704 monitor_qapi_event_state = g_hash_table_new(qapi_event_throttle_hash,
705 qapi_event_throttle_equal);
706 qmp_event_set_func_emit(monitor_qapi_event_queue);
707}
708
709static void handle_hmp_command(Monitor *mon, const char *cmdline);
710
711static void monitor_iothread_init(void);
712
713static void monitor_data_init(Monitor *mon, bool skip_flush,
714 bool use_io_thread)
715{
716 if (use_io_thread && !mon_iothread) {
717 monitor_iothread_init();
718 }
719 memset(mon, 0, sizeof(Monitor));
720 qemu_mutex_init(&mon->mon_lock);
721 qemu_mutex_init(&mon->qmp.qmp_queue_lock);
722 mon->outbuf = qstring_new();
723
724 mon->cmd_table = mon_cmds;
725 mon->skip_flush = skip_flush;
726 mon->use_io_thread = use_io_thread;
727 mon->qmp.qmp_requests = g_queue_new();
728}
729
730static void monitor_data_destroy(Monitor *mon)
731{
732 g_free(mon->mon_cpu_path);
733 qemu_chr_fe_deinit(&mon->chr, false);
734 if (monitor_is_qmp(mon)) {
735 json_message_parser_destroy(&mon->qmp.parser);
736 }
737 readline_free(mon->rs);
738 qobject_unref(mon->outbuf);
739 qemu_mutex_destroy(&mon->mon_lock);
740 qemu_mutex_destroy(&mon->qmp.qmp_queue_lock);
741 monitor_qmp_cleanup_req_queue_locked(mon);
742 g_queue_free(mon->qmp.qmp_requests);
743}
744
745char *qmp_human_monitor_command(const char *command_line, bool has_cpu_index,
746 int64_t cpu_index, Error **errp)
747{
748 char *output = NULL;
749 Monitor *old_mon, hmp;
750
751 monitor_data_init(&hmp, true, false);
752
753 old_mon = cur_mon;
754 cur_mon = &hmp;
755
756 if (has_cpu_index) {
757 int ret = monitor_set_cpu(cpu_index);
758 if (ret < 0) {
759 cur_mon = old_mon;
760 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
761 "a CPU number");
762 goto out;
763 }
764 }
765
766 handle_hmp_command(&hmp, command_line);
767 cur_mon = old_mon;
768
769 qemu_mutex_lock(&hmp.mon_lock);
770 if (qstring_get_length(hmp.outbuf) > 0) {
771 output = g_strdup(qstring_get_str(hmp.outbuf));
772 } else {
773 output = g_strdup("");
774 }
775 qemu_mutex_unlock(&hmp.mon_lock);
776
777out:
778 monitor_data_destroy(&hmp);
779 return output;
780}
781
782static int compare_cmd(const char *name, const char *list)
783{
784 const char *p, *pstart;
785 int len;
786 len = strlen(name);
787 p = list;
788 for(;;) {
789 pstart = p;
790 p = qemu_strchrnul(p, '|');
791 if ((p - pstart) == len && !memcmp(pstart, name, len))
792 return 1;
793 if (*p == '\0')
794 break;
795 p++;
796 }
797 return 0;
798}
799
800static int get_str(char *buf, int buf_size, const char **pp)
801{
802 const char *p;
803 char *q;
804 int c;
805
806 q = buf;
807 p = *pp;
808 while (qemu_isspace(*p)) {
809 p++;
810 }
811 if (*p == '\0') {
812 fail:
813 *q = '\0';
814 *pp = p;
815 return -1;
816 }
817 if (*p == '\"') {
818 p++;
819 while (*p != '\0' && *p != '\"') {
820 if (*p == '\\') {
821 p++;
822 c = *p++;
823 switch (c) {
824 case 'n':
825 c = '\n';
826 break;
827 case 'r':
828 c = '\r';
829 break;
830 case '\\':
831 case '\'':
832 case '\"':
833 break;
834 default:
835 printf("unsupported escape code: '\\%c'\n", c);
836 goto fail;
837 }
838 if ((q - buf) < buf_size - 1) {
839 *q++ = c;
840 }
841 } else {
842 if ((q - buf) < buf_size - 1) {
843 *q++ = *p;
844 }
845 p++;
846 }
847 }
848 if (*p != '\"') {
849 printf("unterminated string\n");
850 goto fail;
851 }
852 p++;
853 } else {
854 while (*p != '\0' && !qemu_isspace(*p)) {
855 if ((q - buf) < buf_size - 1) {
856 *q++ = *p;
857 }
858 p++;
859 }
860 }
861 *q = '\0';
862 *pp = p;
863 return 0;
864}
865
866#define MAX_ARGS 16
867
868static void free_cmdline_args(char **args, int nb_args)
869{
870 int i;
871
872 assert(nb_args <= MAX_ARGS);
873
874 for (i = 0; i < nb_args; i++) {
875 g_free(args[i]);
876 }
877
878}
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893static int parse_cmdline(const char *cmdline,
894 int *pnb_args, char **args)
895{
896 const char *p;
897 int nb_args, ret;
898 char buf[1024];
899
900 p = cmdline;
901 nb_args = 0;
902 for (;;) {
903 while (qemu_isspace(*p)) {
904 p++;
905 }
906 if (*p == '\0') {
907 break;
908 }
909 if (nb_args >= MAX_ARGS) {
910 goto fail;
911 }
912 ret = get_str(buf, sizeof(buf), &p);
913 if (ret < 0) {
914 goto fail;
915 }
916 args[nb_args] = g_strdup(buf);
917 nb_args++;
918 }
919 *pnb_args = nb_args;
920 return 0;
921
922 fail:
923 free_cmdline_args(args, nb_args);
924 return -1;
925}
926
927
928
929
930static bool cmd_can_preconfig(const mon_cmd_t *cmd)
931{
932 if (!cmd->flags) {
933 return false;
934 }
935
936 return strchr(cmd->flags, 'p');
937}
938
939static void help_cmd_dump_one(Monitor *mon,
940 const mon_cmd_t *cmd,
941 char **prefix_args,
942 int prefix_args_nb)
943{
944 int i;
945
946 if (runstate_check(RUN_STATE_PRECONFIG) && !cmd_can_preconfig(cmd)) {
947 return;
948 }
949
950 for (i = 0; i < prefix_args_nb; i++) {
951 monitor_printf(mon, "%s ", prefix_args[i]);
952 }
953 monitor_printf(mon, "%s %s -- %s\n", cmd->name, cmd->params, cmd->help);
954}
955
956
957static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
958 char **args, int nb_args, int arg_index)
959{
960 const mon_cmd_t *cmd;
961 size_t i;
962
963
964 if (arg_index >= nb_args) {
965 for (cmd = cmds; cmd->name != NULL; cmd++) {
966 help_cmd_dump_one(mon, cmd, args, arg_index);
967 }
968 return;
969 }
970
971
972 for (cmd = cmds; cmd->name != NULL; cmd++) {
973 if (compare_cmd(args[arg_index], cmd->name) &&
974 ((!runstate_check(RUN_STATE_PRECONFIG) ||
975 cmd_can_preconfig(cmd)))) {
976 if (cmd->sub_table) {
977
978 help_cmd_dump(mon, cmd->sub_table,
979 args, nb_args, arg_index + 1);
980 } else {
981 help_cmd_dump_one(mon, cmd, args, arg_index);
982 }
983 return;
984 }
985 }
986
987
988 monitor_printf(mon, "unknown command: '");
989 for (i = 0; i <= arg_index; i++) {
990 monitor_printf(mon, "%s%s", args[i], i == arg_index ? "'\n" : " ");
991 }
992}
993
994static void help_cmd(Monitor *mon, const char *name)
995{
996 char *args[MAX_ARGS];
997 int nb_args = 0;
998
999
1000 if (name) {
1001
1002 if (!strcmp(name, "log")) {
1003 const QEMULogItem *item;
1004 monitor_printf(mon, "Log items (comma separated):\n");
1005 monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");
1006 for (item = qemu_log_items; item->mask != 0; item++) {
1007 monitor_printf(mon, "%-10s %s\n", item->name, item->help);
1008 }
1009 return;
1010 }
1011
1012 if (parse_cmdline(name, &nb_args, args) < 0) {
1013 return;
1014 }
1015 }
1016
1017
1018 help_cmd_dump(mon, mon->cmd_table, args, nb_args, 0);
1019
1020 free_cmdline_args(args, nb_args);
1021}
1022
1023static void do_help_cmd(Monitor *mon, const QDict *qdict)
1024{
1025 help_cmd(mon, qdict_get_try_str(qdict, "name"));
1026}
1027
1028static void hmp_trace_event(Monitor *mon, const QDict *qdict)
1029{
1030 const char *tp_name = qdict_get_str(qdict, "name");
1031 bool new_state = qdict_get_bool(qdict, "option");
1032 bool has_vcpu = qdict_haskey(qdict, "vcpu");
1033 int vcpu = qdict_get_try_int(qdict, "vcpu", 0);
1034 Error *local_err = NULL;
1035
1036 if (vcpu < 0) {
1037 monitor_printf(mon, "argument vcpu must be positive");
1038 return;
1039 }
1040
1041 qmp_trace_event_set_state(tp_name, new_state, true, true, has_vcpu, vcpu, &local_err);
1042 if (local_err) {
1043 error_report_err(local_err);
1044 }
1045}
1046
1047#ifdef CONFIG_TRACE_SIMPLE
1048static void hmp_trace_file(Monitor *mon, const QDict *qdict)
1049{
1050 const char *op = qdict_get_try_str(qdict, "op");
1051 const char *arg = qdict_get_try_str(qdict, "arg");
1052
1053 if (!op) {
1054 st_print_trace_file_status((FILE *)mon, &monitor_fprintf);
1055 } else if (!strcmp(op, "on")) {
1056 st_set_trace_file_enabled(true);
1057 } else if (!strcmp(op, "off")) {
1058 st_set_trace_file_enabled(false);
1059 } else if (!strcmp(op, "flush")) {
1060 st_flush_trace_buffer();
1061 } else if (!strcmp(op, "set")) {
1062 if (arg) {
1063 st_set_trace_file(arg);
1064 }
1065 } else {
1066 monitor_printf(mon, "unexpected argument \"%s\"\n", op);
1067 help_cmd(mon, "trace-file");
1068 }
1069}
1070#endif
1071
1072static void hmp_info_help(Monitor *mon, const QDict *qdict)
1073{
1074 help_cmd(mon, "info");
1075}
1076
1077static void query_commands_cb(QmpCommand *cmd, void *opaque)
1078{
1079 CommandInfoList *info, **list = opaque;
1080
1081 if (!cmd->enabled) {
1082 return;
1083 }
1084
1085 info = g_malloc0(sizeof(*info));
1086 info->value = g_malloc0(sizeof(*info->value));
1087 info->value->name = g_strdup(cmd->name);
1088 info->next = *list;
1089 *list = info;
1090}
1091
1092CommandInfoList *qmp_query_commands(Error **errp)
1093{
1094 CommandInfoList *list = NULL;
1095
1096 qmp_for_each_command(cur_mon->qmp.commands, query_commands_cb, &list);
1097
1098 return list;
1099}
1100
1101EventInfoList *qmp_query_events(Error **errp)
1102{
1103 EventInfoList *info, *ev_list = NULL;
1104 QAPIEvent e;
1105
1106 for (e = 0 ; e < QAPI_EVENT__MAX ; e++) {
1107 const char *event_name = QAPIEvent_str(e);
1108 assert(event_name != NULL);
1109 info = g_malloc0(sizeof(*info));
1110 info->value = g_malloc0(sizeof(*info->value));
1111 info->value->name = g_strdup(event_name);
1112
1113 info->next = ev_list;
1114 ev_list = info;
1115 }
1116
1117 return ev_list;
1118}
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129static void qmp_query_qmp_schema(QDict *qdict, QObject **ret_data,
1130 Error **errp)
1131{
1132 *ret_data = qobject_from_qlit(&qmp_schema_qlit);
1133}
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147static void qmp_unregister_commands_hack(void)
1148{
1149#ifndef CONFIG_REPLICATION
1150 qmp_unregister_command(&qmp_commands, "xen-set-replication");
1151 qmp_unregister_command(&qmp_commands, "query-xen-replication-status");
1152 qmp_unregister_command(&qmp_commands, "xen-colo-do-checkpoint");
1153#endif
1154#ifndef TARGET_I386
1155 qmp_unregister_command(&qmp_commands, "rtc-reset-reinjection");
1156 qmp_unregister_command(&qmp_commands, "query-sev");
1157 qmp_unregister_command(&qmp_commands, "query-sev-launch-measure");
1158 qmp_unregister_command(&qmp_commands, "query-sev-capabilities");
1159#endif
1160#ifndef TARGET_S390X
1161 qmp_unregister_command(&qmp_commands, "dump-skeys");
1162#endif
1163#ifndef TARGET_ARM
1164 qmp_unregister_command(&qmp_commands, "query-gic-capabilities");
1165#endif
1166#if !defined(TARGET_S390X) && !defined(TARGET_I386)
1167 qmp_unregister_command(&qmp_commands, "query-cpu-model-expansion");
1168#endif
1169#if !defined(TARGET_S390X)
1170 qmp_unregister_command(&qmp_commands, "query-cpu-model-baseline");
1171 qmp_unregister_command(&qmp_commands, "query-cpu-model-comparison");
1172#endif
1173#if !defined(TARGET_PPC) && !defined(TARGET_ARM) && !defined(TARGET_I386) \
1174 && !defined(TARGET_S390X)
1175 qmp_unregister_command(&qmp_commands, "query-cpu-definitions");
1176#endif
1177}
1178
1179static void monitor_init_qmp_commands(void)
1180{
1181
1182
1183
1184
1185
1186
1187
1188 qmp_init_marshal(&qmp_commands);
1189
1190 qmp_register_command(&qmp_commands, "query-qmp-schema",
1191 qmp_query_qmp_schema, QCO_ALLOW_PRECONFIG);
1192 qmp_register_command(&qmp_commands, "device_add", qmp_device_add,
1193 QCO_NO_OPTIONS);
1194 qmp_register_command(&qmp_commands, "netdev_add", qmp_netdev_add,
1195 QCO_NO_OPTIONS);
1196
1197 qmp_unregister_commands_hack();
1198
1199 QTAILQ_INIT(&qmp_cap_negotiation_commands);
1200 qmp_register_command(&qmp_cap_negotiation_commands, "qmp_capabilities",
1201 qmp_marshal_qmp_capabilities, QCO_ALLOW_PRECONFIG);
1202}
1203
1204static bool qmp_oob_enabled(Monitor *mon)
1205{
1206 return mon->qmp.capab[QMP_CAPABILITY_OOB];
1207}
1208
1209static void monitor_qmp_caps_reset(Monitor *mon)
1210{
1211 memset(mon->qmp.capab_offered, 0, sizeof(mon->qmp.capab_offered));
1212 memset(mon->qmp.capab, 0, sizeof(mon->qmp.capab));
1213 mon->qmp.capab_offered[QMP_CAPABILITY_OOB] = mon->use_io_thread;
1214}
1215
1216
1217
1218
1219
1220
1221static bool qmp_caps_accept(Monitor *mon, QMPCapabilityList *list,
1222 Error **errp)
1223{
1224 GString *unavailable = NULL;
1225 bool capab[QMP_CAPABILITY__MAX];
1226
1227 memset(capab, 0, sizeof(capab));
1228
1229 for (; list; list = list->next) {
1230 if (!mon->qmp.capab_offered[list->value]) {
1231 if (!unavailable) {
1232 unavailable = g_string_new(QMPCapability_str(list->value));
1233 } else {
1234 g_string_append_printf(unavailable, ", %s",
1235 QMPCapability_str(list->value));
1236 }
1237 }
1238 capab[list->value] = true;
1239 }
1240
1241 if (unavailable) {
1242 error_setg(errp, "Capability %s not available", unavailable->str);
1243 g_string_free(unavailable, true);
1244 return false;
1245 }
1246
1247 memcpy(mon->qmp.capab, capab, sizeof(capab));
1248 return true;
1249}
1250
1251void qmp_qmp_capabilities(bool has_enable, QMPCapabilityList *enable,
1252 Error **errp)
1253{
1254 if (cur_mon->qmp.commands == &qmp_commands) {
1255 error_set(errp, ERROR_CLASS_COMMAND_NOT_FOUND,
1256 "Capabilities negotiation is already complete, command "
1257 "ignored");
1258 return;
1259 }
1260
1261 if (!qmp_caps_accept(cur_mon, enable, errp)) {
1262 return;
1263 }
1264
1265 cur_mon->qmp.commands = &qmp_commands;
1266}
1267
1268
1269int monitor_set_cpu(int cpu_index)
1270{
1271 CPUState *cpu;
1272
1273 cpu = qemu_get_cpu(cpu_index);
1274 if (cpu == NULL) {
1275 return -1;
1276 }
1277 g_free(cur_mon->mon_cpu_path);
1278 cur_mon->mon_cpu_path = object_get_canonical_path(OBJECT(cpu));
1279 return 0;
1280}
1281
1282
1283static CPUState *mon_get_cpu_sync(bool synchronize)
1284{
1285 CPUState *cpu;
1286
1287 if (cur_mon->mon_cpu_path) {
1288 cpu = (CPUState *) object_resolve_path_type(cur_mon->mon_cpu_path,
1289 TYPE_CPU, NULL);
1290 if (!cpu) {
1291 g_free(cur_mon->mon_cpu_path);
1292 cur_mon->mon_cpu_path = NULL;
1293 }
1294 }
1295 if (!cur_mon->mon_cpu_path) {
1296 if (!first_cpu) {
1297 return NULL;
1298 }
1299 monitor_set_cpu(first_cpu->cpu_index);
1300 cpu = first_cpu;
1301 }
1302 if (synchronize) {
1303 cpu_synchronize_state(cpu);
1304 }
1305 return cpu;
1306}
1307
1308CPUState *mon_get_cpu(void)
1309{
1310 return mon_get_cpu_sync(true);
1311}
1312
1313CPUArchState *mon_get_cpu_env(void)
1314{
1315 CPUState *cs = mon_get_cpu();
1316
1317 return cs ? cs->env_ptr : NULL;
1318}
1319
1320int monitor_get_cpu_index(void)
1321{
1322 CPUState *cs = mon_get_cpu_sync(false);
1323
1324 return cs ? cs->cpu_index : UNASSIGNED_CPU_INDEX;
1325}
1326
1327static void hmp_info_registers(Monitor *mon, const QDict *qdict)
1328{
1329 bool all_cpus = qdict_get_try_bool(qdict, "cpustate_all", false);
1330 CPUState *cs;
1331
1332 if (all_cpus) {
1333 CPU_FOREACH(cs) {
1334 monitor_printf(mon, "\nCPU#%d\n", cs->cpu_index);
1335 cpu_dump_state(cs, (FILE *)mon, monitor_fprintf, CPU_DUMP_FPU);
1336 }
1337 } else {
1338 cs = mon_get_cpu();
1339
1340 if (!cs) {
1341 monitor_printf(mon, "No CPU available\n");
1342 return;
1343 }
1344
1345 cpu_dump_state(cs, (FILE *)mon, monitor_fprintf, CPU_DUMP_FPU);
1346 }
1347}
1348
1349#ifdef CONFIG_TCG
1350static void hmp_info_jit(Monitor *mon, const QDict *qdict)
1351{
1352 if (!tcg_enabled()) {
1353 error_report("JIT information is only available with accel=tcg");
1354 return;
1355 }
1356
1357 dump_exec_info((FILE *)mon, monitor_fprintf);
1358 dump_drift_info((FILE *)mon, monitor_fprintf);
1359}
1360
1361static void hmp_info_opcount(Monitor *mon, const QDict *qdict)
1362{
1363 dump_opcount_info((FILE *)mon, monitor_fprintf);
1364}
1365#endif
1366
1367static void hmp_info_sync_profile(Monitor *mon, const QDict *qdict)
1368{
1369 int64_t max = qdict_get_try_int(qdict, "max", 10);
1370 bool mean = qdict_get_try_bool(qdict, "mean", false);
1371 bool coalesce = !qdict_get_try_bool(qdict, "no_coalesce", false);
1372 enum QSPSortBy sort_by;
1373
1374 sort_by = mean ? QSP_SORT_BY_AVG_WAIT_TIME : QSP_SORT_BY_TOTAL_WAIT_TIME;
1375 qsp_report((FILE *)mon, monitor_fprintf, max, sort_by, coalesce);
1376}
1377
1378static void hmp_info_history(Monitor *mon, const QDict *qdict)
1379{
1380 int i;
1381 const char *str;
1382
1383 if (!mon->rs)
1384 return;
1385 i = 0;
1386 for(;;) {
1387 str = readline_get_history(mon->rs, i);
1388 if (!str)
1389 break;
1390 monitor_printf(mon, "%d: '%s'\n", i, str);
1391 i++;
1392 }
1393}
1394
1395static void hmp_info_cpustats(Monitor *mon, const QDict *qdict)
1396{
1397 CPUState *cs = mon_get_cpu();
1398
1399 if (!cs) {
1400 monitor_printf(mon, "No CPU available\n");
1401 return;
1402 }
1403 cpu_dump_statistics(cs, (FILE *)mon, &monitor_fprintf, 0);
1404}
1405
1406static void hmp_info_trace_events(Monitor *mon, const QDict *qdict)
1407{
1408 const char *name = qdict_get_try_str(qdict, "name");
1409 bool has_vcpu = qdict_haskey(qdict, "vcpu");
1410 int vcpu = qdict_get_try_int(qdict, "vcpu", 0);
1411 TraceEventInfoList *events;
1412 TraceEventInfoList *elem;
1413 Error *local_err = NULL;
1414
1415 if (name == NULL) {
1416 name = "*";
1417 }
1418 if (vcpu < 0) {
1419 monitor_printf(mon, "argument vcpu must be positive");
1420 return;
1421 }
1422
1423 events = qmp_trace_event_get_state(name, has_vcpu, vcpu, &local_err);
1424 if (local_err) {
1425 error_report_err(local_err);
1426 return;
1427 }
1428
1429 for (elem = events; elem != NULL; elem = elem->next) {
1430 monitor_printf(mon, "%s : state %u\n",
1431 elem->value->name,
1432 elem->value->state == TRACE_EVENT_STATE_ENABLED ? 1 : 0);
1433 }
1434 qapi_free_TraceEventInfoList(events);
1435}
1436
1437void qmp_client_migrate_info(const char *protocol, const char *hostname,
1438 bool has_port, int64_t port,
1439 bool has_tls_port, int64_t tls_port,
1440 bool has_cert_subject, const char *cert_subject,
1441 Error **errp)
1442{
1443 if (strcmp(protocol, "spice") == 0) {
1444 if (!qemu_using_spice(errp)) {
1445 return;
1446 }
1447
1448 if (!has_port && !has_tls_port) {
1449 error_setg(errp, QERR_MISSING_PARAMETER, "port/tls-port");
1450 return;
1451 }
1452
1453 if (qemu_spice_migrate_info(hostname,
1454 has_port ? port : -1,
1455 has_tls_port ? tls_port : -1,
1456 cert_subject)) {
1457 error_setg(errp, QERR_UNDEFINED_ERROR);
1458 return;
1459 }
1460 return;
1461 }
1462
1463 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "protocol", "spice");
1464}
1465
1466static void hmp_logfile(Monitor *mon, const QDict *qdict)
1467{
1468 Error *err = NULL;
1469
1470 qemu_set_log_filename(qdict_get_str(qdict, "filename"), &err);
1471 if (err) {
1472 error_report_err(err);
1473 }
1474}
1475
1476static void hmp_log(Monitor *mon, const QDict *qdict)
1477{
1478 int mask;
1479 const char *items = qdict_get_str(qdict, "items");
1480
1481 if (!strcmp(items, "none")) {
1482 mask = 0;
1483 } else {
1484 mask = qemu_str_to_log_mask(items);
1485 if (!mask) {
1486 help_cmd(mon, "log");
1487 return;
1488 }
1489 }
1490 qemu_set_log(mask);
1491}
1492
1493static void hmp_singlestep(Monitor *mon, const QDict *qdict)
1494{
1495 const char *option = qdict_get_try_str(qdict, "option");
1496 if (!option || !strcmp(option, "on")) {
1497 singlestep = 1;
1498 } else if (!strcmp(option, "off")) {
1499 singlestep = 0;
1500 } else {
1501 monitor_printf(mon, "unexpected option %s\n", option);
1502 }
1503}
1504
1505static void hmp_gdbserver(Monitor *mon, const QDict *qdict)
1506{
1507 const char *device = qdict_get_try_str(qdict, "device");
1508 if (!device)
1509 device = "tcp::" DEFAULT_GDBSTUB_PORT;
1510 if (gdbserver_start(device) < 0) {
1511 monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
1512 device);
1513 } else if (strcmp(device, "none") == 0) {
1514 monitor_printf(mon, "Disabled gdbserver\n");
1515 } else {
1516 monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
1517 device);
1518 }
1519}
1520
1521static void hmp_watchdog_action(Monitor *mon, const QDict *qdict)
1522{
1523 const char *action = qdict_get_str(qdict, "action");
1524 if (select_watchdog_action(action) == -1) {
1525 monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
1526 }
1527}
1528
1529static void monitor_printc(Monitor *mon, int c)
1530{
1531 monitor_printf(mon, "'");
1532 switch(c) {
1533 case '\'':
1534 monitor_printf(mon, "\\'");
1535 break;
1536 case '\\':
1537 monitor_printf(mon, "\\\\");
1538 break;
1539 case '\n':
1540 monitor_printf(mon, "\\n");
1541 break;
1542 case '\r':
1543 monitor_printf(mon, "\\r");
1544 break;
1545 default:
1546 if (c >= 32 && c <= 126) {
1547 monitor_printf(mon, "%c", c);
1548 } else {
1549 monitor_printf(mon, "\\x%02x", c);
1550 }
1551 break;
1552 }
1553 monitor_printf(mon, "'");
1554}
1555
1556static void memory_dump(Monitor *mon, int count, int format, int wsize,
1557 hwaddr addr, int is_physical)
1558{
1559 int l, line_size, i, max_digits, len;
1560 uint8_t buf[16];
1561 uint64_t v;
1562 CPUState *cs = mon_get_cpu();
1563
1564 if (!cs && (format == 'i' || !is_physical)) {
1565 monitor_printf(mon, "Can not dump without CPU\n");
1566 return;
1567 }
1568
1569 if (format == 'i') {
1570 monitor_disas(mon, cs, addr, count, is_physical);
1571 return;
1572 }
1573
1574 len = wsize * count;
1575 if (wsize == 1)
1576 line_size = 8;
1577 else
1578 line_size = 16;
1579 max_digits = 0;
1580
1581 switch(format) {
1582 case 'o':
1583 max_digits = DIV_ROUND_UP(wsize * 8, 3);
1584 break;
1585 default:
1586 case 'x':
1587 max_digits = (wsize * 8) / 4;
1588 break;
1589 case 'u':
1590 case 'd':
1591 max_digits = DIV_ROUND_UP(wsize * 8 * 10, 33);
1592 break;
1593 case 'c':
1594 wsize = 1;
1595 break;
1596 }
1597
1598 while (len > 0) {
1599 if (is_physical)
1600 monitor_printf(mon, TARGET_FMT_plx ":", addr);
1601 else
1602 monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
1603 l = len;
1604 if (l > line_size)
1605 l = line_size;
1606 if (is_physical) {
1607 cpu_physical_memory_read(addr, buf, l);
1608 } else {
1609 if (cpu_memory_rw_debug(cs, addr, buf, l, 0) < 0) {
1610 monitor_printf(mon, " Cannot access memory\n");
1611 break;
1612 }
1613 }
1614 i = 0;
1615 while (i < l) {
1616 switch(wsize) {
1617 default:
1618 case 1:
1619 v = ldub_p(buf + i);
1620 break;
1621 case 2:
1622 v = lduw_p(buf + i);
1623 break;
1624 case 4:
1625 v = (uint32_t)ldl_p(buf + i);
1626 break;
1627 case 8:
1628 v = ldq_p(buf + i);
1629 break;
1630 }
1631 monitor_printf(mon, " ");
1632 switch(format) {
1633 case 'o':
1634 monitor_printf(mon, "%#*" PRIo64, max_digits, v);
1635 break;
1636 case 'x':
1637 monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
1638 break;
1639 case 'u':
1640 monitor_printf(mon, "%*" PRIu64, max_digits, v);
1641 break;
1642 case 'd':
1643 monitor_printf(mon, "%*" PRId64, max_digits, v);
1644 break;
1645 case 'c':
1646 monitor_printc(mon, v);
1647 break;
1648 }
1649 i += wsize;
1650 }
1651 monitor_printf(mon, "\n");
1652 addr += l;
1653 len -= l;
1654 }
1655}
1656
1657static void hmp_memory_dump(Monitor *mon, const QDict *qdict)
1658{
1659 int count = qdict_get_int(qdict, "count");
1660 int format = qdict_get_int(qdict, "format");
1661 int size = qdict_get_int(qdict, "size");
1662 target_long addr = qdict_get_int(qdict, "addr");
1663
1664 memory_dump(mon, count, format, size, addr, 0);
1665}
1666
1667static void hmp_physical_memory_dump(Monitor *mon, const QDict *qdict)
1668{
1669 int count = qdict_get_int(qdict, "count");
1670 int format = qdict_get_int(qdict, "format");
1671 int size = qdict_get_int(qdict, "size");
1672 hwaddr addr = qdict_get_int(qdict, "addr");
1673
1674 memory_dump(mon, count, format, size, addr, 1);
1675}
1676
1677static void *gpa2hva(MemoryRegion **p_mr, hwaddr addr, Error **errp)
1678{
1679 MemoryRegionSection mrs = memory_region_find(get_system_memory(),
1680 addr, 1);
1681
1682 if (!mrs.mr) {
1683 error_setg(errp, "No memory is mapped at address 0x%" HWADDR_PRIx, addr);
1684 return NULL;
1685 }
1686
1687 if (!memory_region_is_ram(mrs.mr) && !memory_region_is_romd(mrs.mr)) {
1688 error_setg(errp, "Memory at address 0x%" HWADDR_PRIx "is not RAM", addr);
1689 memory_region_unref(mrs.mr);
1690 return NULL;
1691 }
1692
1693 *p_mr = mrs.mr;
1694 return qemu_map_ram_ptr(mrs.mr->ram_block, mrs.offset_within_region);
1695}
1696
1697static void hmp_gpa2hva(Monitor *mon, const QDict *qdict)
1698{
1699 hwaddr addr = qdict_get_int(qdict, "addr");
1700 Error *local_err = NULL;
1701 MemoryRegion *mr = NULL;
1702 void *ptr;
1703
1704 ptr = gpa2hva(&mr, addr, &local_err);
1705 if (local_err) {
1706 error_report_err(local_err);
1707 return;
1708 }
1709
1710 monitor_printf(mon, "Host virtual address for 0x%" HWADDR_PRIx
1711 " (%s) is %p\n",
1712 addr, mr->name, ptr);
1713
1714 memory_region_unref(mr);
1715}
1716
1717#ifdef CONFIG_LINUX
1718static uint64_t vtop(void *ptr, Error **errp)
1719{
1720 uint64_t pinfo;
1721 uint64_t ret = -1;
1722 uintptr_t addr = (uintptr_t) ptr;
1723 uintptr_t pagesize = getpagesize();
1724 off_t offset = addr / pagesize * sizeof(pinfo);
1725 int fd;
1726
1727 fd = open("/proc/self/pagemap", O_RDONLY);
1728 if (fd == -1) {
1729 error_setg_errno(errp, errno, "Cannot open /proc/self/pagemap");
1730 return -1;
1731 }
1732
1733
1734 atomic_add((uint8_t *)ptr, 0);
1735
1736 if (pread(fd, &pinfo, sizeof(pinfo), offset) != sizeof(pinfo)) {
1737 error_setg_errno(errp, errno, "Cannot read pagemap");
1738 goto out;
1739 }
1740 if ((pinfo & (1ull << 63)) == 0) {
1741 error_setg(errp, "Page not present");
1742 goto out;
1743 }
1744 ret = ((pinfo & 0x007fffffffffffffull) * pagesize) | (addr & (pagesize - 1));
1745
1746out:
1747 close(fd);
1748 return ret;
1749}
1750
1751static void hmp_gpa2hpa(Monitor *mon, const QDict *qdict)
1752{
1753 hwaddr addr = qdict_get_int(qdict, "addr");
1754 Error *local_err = NULL;
1755 MemoryRegion *mr = NULL;
1756 void *ptr;
1757 uint64_t physaddr;
1758
1759 ptr = gpa2hva(&mr, addr, &local_err);
1760 if (local_err) {
1761 error_report_err(local_err);
1762 return;
1763 }
1764
1765 physaddr = vtop(ptr, &local_err);
1766 if (local_err) {
1767 error_report_err(local_err);
1768 } else {
1769 monitor_printf(mon, "Host physical address for 0x%" HWADDR_PRIx
1770 " (%s) is 0x%" PRIx64 "\n",
1771 addr, mr->name, (uint64_t) physaddr);
1772 }
1773
1774 memory_region_unref(mr);
1775}
1776#endif
1777
1778static void do_print(Monitor *mon, const QDict *qdict)
1779{
1780 int format = qdict_get_int(qdict, "format");
1781 hwaddr val = qdict_get_int(qdict, "val");
1782
1783 switch(format) {
1784 case 'o':
1785 monitor_printf(mon, "%#" HWADDR_PRIo, val);
1786 break;
1787 case 'x':
1788 monitor_printf(mon, "%#" HWADDR_PRIx, val);
1789 break;
1790 case 'u':
1791 monitor_printf(mon, "%" HWADDR_PRIu, val);
1792 break;
1793 default:
1794 case 'd':
1795 monitor_printf(mon, "%" HWADDR_PRId, val);
1796 break;
1797 case 'c':
1798 monitor_printc(mon, val);
1799 break;
1800 }
1801 monitor_printf(mon, "\n");
1802}
1803
1804static void hmp_sum(Monitor *mon, const QDict *qdict)
1805{
1806 uint32_t addr;
1807 uint16_t sum;
1808 uint32_t start = qdict_get_int(qdict, "start");
1809 uint32_t size = qdict_get_int(qdict, "size");
1810
1811 sum = 0;
1812 for(addr = start; addr < (start + size); addr++) {
1813 uint8_t val = address_space_ldub(&address_space_memory, addr,
1814 MEMTXATTRS_UNSPECIFIED, NULL);
1815
1816 sum = (sum >> 1) | (sum << 15);
1817 sum += val;
1818 }
1819 monitor_printf(mon, "%05d\n", sum);
1820}
1821
1822static int mouse_button_state;
1823
1824static void hmp_mouse_move(Monitor *mon, const QDict *qdict)
1825{
1826 int dx, dy, dz, button;
1827 const char *dx_str = qdict_get_str(qdict, "dx_str");
1828 const char *dy_str = qdict_get_str(qdict, "dy_str");
1829 const char *dz_str = qdict_get_try_str(qdict, "dz_str");
1830
1831 dx = strtol(dx_str, NULL, 0);
1832 dy = strtol(dy_str, NULL, 0);
1833 qemu_input_queue_rel(NULL, INPUT_AXIS_X, dx);
1834 qemu_input_queue_rel(NULL, INPUT_AXIS_Y, dy);
1835
1836 if (dz_str) {
1837 dz = strtol(dz_str, NULL, 0);
1838 if (dz != 0) {
1839 button = (dz > 0) ? INPUT_BUTTON_WHEEL_UP : INPUT_BUTTON_WHEEL_DOWN;
1840 qemu_input_queue_btn(NULL, button, true);
1841 qemu_input_event_sync();
1842 qemu_input_queue_btn(NULL, button, false);
1843 }
1844 }
1845 qemu_input_event_sync();
1846}
1847
1848static void hmp_mouse_button(Monitor *mon, const QDict *qdict)
1849{
1850 static uint32_t bmap[INPUT_BUTTON__MAX] = {
1851 [INPUT_BUTTON_LEFT] = MOUSE_EVENT_LBUTTON,
1852 [INPUT_BUTTON_MIDDLE] = MOUSE_EVENT_MBUTTON,
1853 [INPUT_BUTTON_RIGHT] = MOUSE_EVENT_RBUTTON,
1854 };
1855 int button_state = qdict_get_int(qdict, "button_state");
1856
1857 if (mouse_button_state == button_state) {
1858 return;
1859 }
1860 qemu_input_update_buttons(NULL, bmap, mouse_button_state, button_state);
1861 qemu_input_event_sync();
1862 mouse_button_state = button_state;
1863}
1864
1865static void hmp_ioport_read(Monitor *mon, const QDict *qdict)
1866{
1867 int size = qdict_get_int(qdict, "size");
1868 int addr = qdict_get_int(qdict, "addr");
1869 int has_index = qdict_haskey(qdict, "index");
1870 uint32_t val;
1871 int suffix;
1872
1873 if (has_index) {
1874 int index = qdict_get_int(qdict, "index");
1875 cpu_outb(addr & IOPORTS_MASK, index & 0xff);
1876 addr++;
1877 }
1878 addr &= 0xffff;
1879
1880 switch(size) {
1881 default:
1882 case 1:
1883 val = cpu_inb(addr);
1884 suffix = 'b';
1885 break;
1886 case 2:
1887 val = cpu_inw(addr);
1888 suffix = 'w';
1889 break;
1890 case 4:
1891 val = cpu_inl(addr);
1892 suffix = 'l';
1893 break;
1894 }
1895 monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
1896 suffix, addr, size * 2, val);
1897}
1898
1899static void hmp_ioport_write(Monitor *mon, const QDict *qdict)
1900{
1901 int size = qdict_get_int(qdict, "size");
1902 int addr = qdict_get_int(qdict, "addr");
1903 int val = qdict_get_int(qdict, "val");
1904
1905 addr &= IOPORTS_MASK;
1906
1907 switch (size) {
1908 default:
1909 case 1:
1910 cpu_outb(addr, val);
1911 break;
1912 case 2:
1913 cpu_outw(addr, val);
1914 break;
1915 case 4:
1916 cpu_outl(addr, val);
1917 break;
1918 }
1919}
1920
1921static void hmp_boot_set(Monitor *mon, const QDict *qdict)
1922{
1923 Error *local_err = NULL;
1924 const char *bootdevice = qdict_get_str(qdict, "bootdevice");
1925
1926 qemu_boot_set(bootdevice, &local_err);
1927 if (local_err) {
1928 error_report_err(local_err);
1929 } else {
1930 monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
1931 }
1932}
1933
1934static void hmp_info_mtree(Monitor *mon, const QDict *qdict)
1935{
1936 bool flatview = qdict_get_try_bool(qdict, "flatview", false);
1937 bool dispatch_tree = qdict_get_try_bool(qdict, "dispatch_tree", false);
1938 bool owner = qdict_get_try_bool(qdict, "owner", false);
1939
1940 mtree_info((fprintf_function)monitor_printf, mon, flatview, dispatch_tree,
1941 owner);
1942}
1943
1944static void hmp_info_numa(Monitor *mon, const QDict *qdict)
1945{
1946 int i;
1947 NumaNodeMem *node_mem;
1948 CpuInfoList *cpu_list, *cpu;
1949
1950 cpu_list = qmp_query_cpus(&error_abort);
1951 node_mem = g_new0(NumaNodeMem, nb_numa_nodes);
1952
1953 query_numa_node_mem(node_mem);
1954 monitor_printf(mon, "%d nodes\n", nb_numa_nodes);
1955 for (i = 0; i < nb_numa_nodes; i++) {
1956 monitor_printf(mon, "node %d cpus:", i);
1957 for (cpu = cpu_list; cpu; cpu = cpu->next) {
1958 if (cpu->value->has_props && cpu->value->props->has_node_id &&
1959 cpu->value->props->node_id == i) {
1960 monitor_printf(mon, " %" PRIi64, cpu->value->CPU);
1961 }
1962 }
1963 monitor_printf(mon, "\n");
1964 monitor_printf(mon, "node %d size: %" PRId64 " MB\n", i,
1965 node_mem[i].node_mem >> 20);
1966 monitor_printf(mon, "node %d plugged: %" PRId64 " MB\n", i,
1967 node_mem[i].node_plugged_mem >> 20);
1968 }
1969 qapi_free_CpuInfoList(cpu_list);
1970 g_free(node_mem);
1971}
1972
1973#ifdef CONFIG_PROFILER
1974
1975int64_t dev_time;
1976
1977static void hmp_info_profile(Monitor *mon, const QDict *qdict)
1978{
1979 static int64_t last_cpu_exec_time;
1980 int64_t cpu_exec_time;
1981 int64_t delta;
1982
1983 cpu_exec_time = tcg_cpu_exec_time();
1984 delta = cpu_exec_time - last_cpu_exec_time;
1985
1986 monitor_printf(mon, "async time %" PRId64 " (%0.3f)\n",
1987 dev_time, dev_time / (double)NANOSECONDS_PER_SECOND);
1988 monitor_printf(mon, "qemu time %" PRId64 " (%0.3f)\n",
1989 delta, delta / (double)NANOSECONDS_PER_SECOND);
1990 last_cpu_exec_time = cpu_exec_time;
1991 dev_time = 0;
1992}
1993#else
1994static void hmp_info_profile(Monitor *mon, const QDict *qdict)
1995{
1996 monitor_printf(mon, "Internal profiler not compiled\n");
1997}
1998#endif
1999
2000
2001static QLIST_HEAD (capture_list_head, CaptureState) capture_head;
2002
2003static void hmp_info_capture(Monitor *mon, const QDict *qdict)
2004{
2005 int i;
2006 CaptureState *s;
2007
2008 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
2009 monitor_printf(mon, "[%d]: ", i);
2010 s->ops.info (s->opaque);
2011 }
2012}
2013
2014static void hmp_stopcapture(Monitor *mon, const QDict *qdict)
2015{
2016 int i;
2017 int n = qdict_get_int(qdict, "n");
2018 CaptureState *s;
2019
2020 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
2021 if (i == n) {
2022 s->ops.destroy (s->opaque);
2023 QLIST_REMOVE (s, entries);
2024 g_free (s);
2025 return;
2026 }
2027 }
2028}
2029
2030static void hmp_wavcapture(Monitor *mon, const QDict *qdict)
2031{
2032 const char *path = qdict_get_str(qdict, "path");
2033 int has_freq = qdict_haskey(qdict, "freq");
2034 int freq = qdict_get_try_int(qdict, "freq", -1);
2035 int has_bits = qdict_haskey(qdict, "bits");
2036 int bits = qdict_get_try_int(qdict, "bits", -1);
2037 int has_channels = qdict_haskey(qdict, "nchannels");
2038 int nchannels = qdict_get_try_int(qdict, "nchannels", -1);
2039 CaptureState *s;
2040
2041 s = g_malloc0 (sizeof (*s));
2042
2043 freq = has_freq ? freq : 44100;
2044 bits = has_bits ? bits : 16;
2045 nchannels = has_channels ? nchannels : 2;
2046
2047 if (wav_start_capture (s, path, freq, bits, nchannels)) {
2048 monitor_printf(mon, "Failed to add wave capture\n");
2049 g_free (s);
2050 return;
2051 }
2052 QLIST_INSERT_HEAD (&capture_head, s, entries);
2053}
2054
2055static qemu_acl *find_acl(Monitor *mon, const char *name)
2056{
2057 qemu_acl *acl = qemu_acl_find(name);
2058
2059 if (!acl) {
2060 monitor_printf(mon, "acl: unknown list '%s'\n", name);
2061 }
2062 return acl;
2063}
2064
2065static void hmp_acl_show(Monitor *mon, const QDict *qdict)
2066{
2067 const char *aclname = qdict_get_str(qdict, "aclname");
2068 qemu_acl *acl = find_acl(mon, aclname);
2069 qemu_acl_entry *entry;
2070 int i = 0;
2071
2072 if (acl) {
2073 monitor_printf(mon, "policy: %s\n",
2074 acl->defaultDeny ? "deny" : "allow");
2075 QTAILQ_FOREACH(entry, &acl->entries, next) {
2076 i++;
2077 monitor_printf(mon, "%d: %s %s\n", i,
2078 entry->deny ? "deny" : "allow", entry->match);
2079 }
2080 }
2081}
2082
2083static void hmp_acl_reset(Monitor *mon, const QDict *qdict)
2084{
2085 const char *aclname = qdict_get_str(qdict, "aclname");
2086 qemu_acl *acl = find_acl(mon, aclname);
2087
2088 if (acl) {
2089 qemu_acl_reset(acl);
2090 monitor_printf(mon, "acl: removed all rules\n");
2091 }
2092}
2093
2094static void hmp_acl_policy(Monitor *mon, const QDict *qdict)
2095{
2096 const char *aclname = qdict_get_str(qdict, "aclname");
2097 const char *policy = qdict_get_str(qdict, "policy");
2098 qemu_acl *acl = find_acl(mon, aclname);
2099
2100 if (acl) {
2101 if (strcmp(policy, "allow") == 0) {
2102 acl->defaultDeny = 0;
2103 monitor_printf(mon, "acl: policy set to 'allow'\n");
2104 } else if (strcmp(policy, "deny") == 0) {
2105 acl->defaultDeny = 1;
2106 monitor_printf(mon, "acl: policy set to 'deny'\n");
2107 } else {
2108 monitor_printf(mon, "acl: unknown policy '%s', "
2109 "expected 'deny' or 'allow'\n", policy);
2110 }
2111 }
2112}
2113
2114static void hmp_acl_add(Monitor *mon, const QDict *qdict)
2115{
2116 const char *aclname = qdict_get_str(qdict, "aclname");
2117 const char *match = qdict_get_str(qdict, "match");
2118 const char *policy = qdict_get_str(qdict, "policy");
2119 int has_index = qdict_haskey(qdict, "index");
2120 int index = qdict_get_try_int(qdict, "index", -1);
2121 qemu_acl *acl = find_acl(mon, aclname);
2122 int deny, ret;
2123
2124 if (acl) {
2125 if (strcmp(policy, "allow") == 0) {
2126 deny = 0;
2127 } else if (strcmp(policy, "deny") == 0) {
2128 deny = 1;
2129 } else {
2130 monitor_printf(mon, "acl: unknown policy '%s', "
2131 "expected 'deny' or 'allow'\n", policy);
2132 return;
2133 }
2134 if (has_index)
2135 ret = qemu_acl_insert(acl, deny, match, index);
2136 else
2137 ret = qemu_acl_append(acl, deny, match);
2138 if (ret < 0)
2139 monitor_printf(mon, "acl: unable to add acl entry\n");
2140 else
2141 monitor_printf(mon, "acl: added rule at position %d\n", ret);
2142 }
2143}
2144
2145static void hmp_acl_remove(Monitor *mon, const QDict *qdict)
2146{
2147 const char *aclname = qdict_get_str(qdict, "aclname");
2148 const char *match = qdict_get_str(qdict, "match");
2149 qemu_acl *acl = find_acl(mon, aclname);
2150 int ret;
2151
2152 if (acl) {
2153 ret = qemu_acl_remove(acl, match);
2154 if (ret < 0)
2155 monitor_printf(mon, "acl: no matching acl entry\n");
2156 else
2157 monitor_printf(mon, "acl: removed rule at position %d\n", ret);
2158 }
2159}
2160
2161void qmp_getfd(const char *fdname, Error **errp)
2162{
2163 mon_fd_t *monfd;
2164 int fd, tmp_fd;
2165
2166 fd = qemu_chr_fe_get_msgfd(&cur_mon->chr);
2167 if (fd == -1) {
2168 error_setg(errp, QERR_FD_NOT_SUPPLIED);
2169 return;
2170 }
2171
2172 if (qemu_isdigit(fdname[0])) {
2173 close(fd);
2174 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdname",
2175 "a name not starting with a digit");
2176 return;
2177 }
2178
2179 qemu_mutex_lock(&cur_mon->mon_lock);
2180 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
2181 if (strcmp(monfd->name, fdname) != 0) {
2182 continue;
2183 }
2184
2185 tmp_fd = monfd->fd;
2186 monfd->fd = fd;
2187 qemu_mutex_unlock(&cur_mon->mon_lock);
2188
2189 close(tmp_fd);
2190 return;
2191 }
2192
2193 monfd = g_malloc0(sizeof(mon_fd_t));
2194 monfd->name = g_strdup(fdname);
2195 monfd->fd = fd;
2196
2197 QLIST_INSERT_HEAD(&cur_mon->fds, monfd, next);
2198 qemu_mutex_unlock(&cur_mon->mon_lock);
2199}
2200
2201void qmp_closefd(const char *fdname, Error **errp)
2202{
2203 mon_fd_t *monfd;
2204 int tmp_fd;
2205
2206 qemu_mutex_lock(&cur_mon->mon_lock);
2207 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
2208 if (strcmp(monfd->name, fdname) != 0) {
2209 continue;
2210 }
2211
2212 QLIST_REMOVE(monfd, next);
2213 tmp_fd = monfd->fd;
2214 g_free(monfd->name);
2215 g_free(monfd);
2216 qemu_mutex_unlock(&cur_mon->mon_lock);
2217
2218 close(tmp_fd);
2219 return;
2220 }
2221
2222 qemu_mutex_unlock(&cur_mon->mon_lock);
2223 error_setg(errp, QERR_FD_NOT_FOUND, fdname);
2224}
2225
2226int monitor_get_fd(Monitor *mon, const char *fdname, Error **errp)
2227{
2228 mon_fd_t *monfd;
2229
2230 qemu_mutex_lock(&mon->mon_lock);
2231 QLIST_FOREACH(monfd, &mon->fds, next) {
2232 int fd;
2233
2234 if (strcmp(monfd->name, fdname) != 0) {
2235 continue;
2236 }
2237
2238 fd = monfd->fd;
2239
2240
2241 QLIST_REMOVE(monfd, next);
2242 g_free(monfd->name);
2243 g_free(monfd);
2244 qemu_mutex_unlock(&mon->mon_lock);
2245
2246 return fd;
2247 }
2248
2249 qemu_mutex_unlock(&mon->mon_lock);
2250 error_setg(errp, "File descriptor named '%s' has not been found", fdname);
2251 return -1;
2252}
2253
2254static void monitor_fdset_cleanup(MonFdset *mon_fdset)
2255{
2256 MonFdsetFd *mon_fdset_fd;
2257 MonFdsetFd *mon_fdset_fd_next;
2258
2259 QLIST_FOREACH_SAFE(mon_fdset_fd, &mon_fdset->fds, next, mon_fdset_fd_next) {
2260 if ((mon_fdset_fd->removed ||
2261 (QLIST_EMPTY(&mon_fdset->dup_fds) && mon_refcount == 0)) &&
2262 runstate_is_running()) {
2263 close(mon_fdset_fd->fd);
2264 g_free(mon_fdset_fd->opaque);
2265 QLIST_REMOVE(mon_fdset_fd, next);
2266 g_free(mon_fdset_fd);
2267 }
2268 }
2269
2270 if (QLIST_EMPTY(&mon_fdset->fds) && QLIST_EMPTY(&mon_fdset->dup_fds)) {
2271 QLIST_REMOVE(mon_fdset, next);
2272 g_free(mon_fdset);
2273 }
2274}
2275
2276static void monitor_fdsets_cleanup(void)
2277{
2278 MonFdset *mon_fdset;
2279 MonFdset *mon_fdset_next;
2280
2281 qemu_mutex_lock(&mon_fdsets_lock);
2282 QLIST_FOREACH_SAFE(mon_fdset, &mon_fdsets, next, mon_fdset_next) {
2283 monitor_fdset_cleanup(mon_fdset);
2284 }
2285 qemu_mutex_unlock(&mon_fdsets_lock);
2286}
2287
2288AddfdInfo *qmp_add_fd(bool has_fdset_id, int64_t fdset_id, bool has_opaque,
2289 const char *opaque, Error **errp)
2290{
2291 int fd;
2292 Monitor *mon = cur_mon;
2293 AddfdInfo *fdinfo;
2294
2295 fd = qemu_chr_fe_get_msgfd(&mon->chr);
2296 if (fd == -1) {
2297 error_setg(errp, QERR_FD_NOT_SUPPLIED);
2298 goto error;
2299 }
2300
2301 fdinfo = monitor_fdset_add_fd(fd, has_fdset_id, fdset_id,
2302 has_opaque, opaque, errp);
2303 if (fdinfo) {
2304 return fdinfo;
2305 }
2306
2307error:
2308 if (fd != -1) {
2309 close(fd);
2310 }
2311 return NULL;
2312}
2313
2314void qmp_remove_fd(int64_t fdset_id, bool has_fd, int64_t fd, Error **errp)
2315{
2316 MonFdset *mon_fdset;
2317 MonFdsetFd *mon_fdset_fd;
2318 char fd_str[60];
2319
2320 qemu_mutex_lock(&mon_fdsets_lock);
2321 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2322 if (mon_fdset->id != fdset_id) {
2323 continue;
2324 }
2325 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2326 if (has_fd) {
2327 if (mon_fdset_fd->fd != fd) {
2328 continue;
2329 }
2330 mon_fdset_fd->removed = true;
2331 break;
2332 } else {
2333 mon_fdset_fd->removed = true;
2334 }
2335 }
2336 if (has_fd && !mon_fdset_fd) {
2337 goto error;
2338 }
2339 monitor_fdset_cleanup(mon_fdset);
2340 qemu_mutex_unlock(&mon_fdsets_lock);
2341 return;
2342 }
2343
2344error:
2345 qemu_mutex_unlock(&mon_fdsets_lock);
2346 if (has_fd) {
2347 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64 ", fd:%" PRId64,
2348 fdset_id, fd);
2349 } else {
2350 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64, fdset_id);
2351 }
2352 error_setg(errp, QERR_FD_NOT_FOUND, fd_str);
2353}
2354
2355FdsetInfoList *qmp_query_fdsets(Error **errp)
2356{
2357 MonFdset *mon_fdset;
2358 MonFdsetFd *mon_fdset_fd;
2359 FdsetInfoList *fdset_list = NULL;
2360
2361 qemu_mutex_lock(&mon_fdsets_lock);
2362 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2363 FdsetInfoList *fdset_info = g_malloc0(sizeof(*fdset_info));
2364 FdsetFdInfoList *fdsetfd_list = NULL;
2365
2366 fdset_info->value = g_malloc0(sizeof(*fdset_info->value));
2367 fdset_info->value->fdset_id = mon_fdset->id;
2368
2369 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2370 FdsetFdInfoList *fdsetfd_info;
2371
2372 fdsetfd_info = g_malloc0(sizeof(*fdsetfd_info));
2373 fdsetfd_info->value = g_malloc0(sizeof(*fdsetfd_info->value));
2374 fdsetfd_info->value->fd = mon_fdset_fd->fd;
2375 if (mon_fdset_fd->opaque) {
2376 fdsetfd_info->value->has_opaque = true;
2377 fdsetfd_info->value->opaque = g_strdup(mon_fdset_fd->opaque);
2378 } else {
2379 fdsetfd_info->value->has_opaque = false;
2380 }
2381
2382 fdsetfd_info->next = fdsetfd_list;
2383 fdsetfd_list = fdsetfd_info;
2384 }
2385
2386 fdset_info->value->fds = fdsetfd_list;
2387
2388 fdset_info->next = fdset_list;
2389 fdset_list = fdset_info;
2390 }
2391 qemu_mutex_unlock(&mon_fdsets_lock);
2392
2393 return fdset_list;
2394}
2395
2396AddfdInfo *monitor_fdset_add_fd(int fd, bool has_fdset_id, int64_t fdset_id,
2397 bool has_opaque, const char *opaque,
2398 Error **errp)
2399{
2400 MonFdset *mon_fdset = NULL;
2401 MonFdsetFd *mon_fdset_fd;
2402 AddfdInfo *fdinfo;
2403
2404 qemu_mutex_lock(&mon_fdsets_lock);
2405 if (has_fdset_id) {
2406 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2407
2408 if (fdset_id <= mon_fdset->id) {
2409 if (fdset_id < mon_fdset->id) {
2410 mon_fdset = NULL;
2411 }
2412 break;
2413 }
2414 }
2415 }
2416
2417 if (mon_fdset == NULL) {
2418 int64_t fdset_id_prev = -1;
2419 MonFdset *mon_fdset_cur = QLIST_FIRST(&mon_fdsets);
2420
2421 if (has_fdset_id) {
2422 if (fdset_id < 0) {
2423 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdset-id",
2424 "a non-negative value");
2425 qemu_mutex_unlock(&mon_fdsets_lock);
2426 return NULL;
2427 }
2428
2429 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2430 mon_fdset_cur = mon_fdset;
2431 if (fdset_id < mon_fdset_cur->id) {
2432 break;
2433 }
2434 }
2435 } else {
2436
2437 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2438 mon_fdset_cur = mon_fdset;
2439 if (fdset_id_prev == mon_fdset_cur->id - 1) {
2440 fdset_id_prev = mon_fdset_cur->id;
2441 continue;
2442 }
2443 break;
2444 }
2445 }
2446
2447 mon_fdset = g_malloc0(sizeof(*mon_fdset));
2448 if (has_fdset_id) {
2449 mon_fdset->id = fdset_id;
2450 } else {
2451 mon_fdset->id = fdset_id_prev + 1;
2452 }
2453
2454
2455 if (!mon_fdset_cur) {
2456 QLIST_INSERT_HEAD(&mon_fdsets, mon_fdset, next);
2457 } else if (mon_fdset->id < mon_fdset_cur->id) {
2458 QLIST_INSERT_BEFORE(mon_fdset_cur, mon_fdset, next);
2459 } else {
2460 QLIST_INSERT_AFTER(mon_fdset_cur, mon_fdset, next);
2461 }
2462 }
2463
2464 mon_fdset_fd = g_malloc0(sizeof(*mon_fdset_fd));
2465 mon_fdset_fd->fd = fd;
2466 mon_fdset_fd->removed = false;
2467 if (has_opaque) {
2468 mon_fdset_fd->opaque = g_strdup(opaque);
2469 }
2470 QLIST_INSERT_HEAD(&mon_fdset->fds, mon_fdset_fd, next);
2471
2472 fdinfo = g_malloc0(sizeof(*fdinfo));
2473 fdinfo->fdset_id = mon_fdset->id;
2474 fdinfo->fd = mon_fdset_fd->fd;
2475
2476 qemu_mutex_unlock(&mon_fdsets_lock);
2477 return fdinfo;
2478}
2479
2480int monitor_fdset_get_fd(int64_t fdset_id, int flags)
2481{
2482#ifdef _WIN32
2483 return -ENOENT;
2484#else
2485 MonFdset *mon_fdset;
2486 MonFdsetFd *mon_fdset_fd;
2487 int mon_fd_flags;
2488 int ret;
2489
2490 qemu_mutex_lock(&mon_fdsets_lock);
2491 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2492 if (mon_fdset->id != fdset_id) {
2493 continue;
2494 }
2495 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2496 mon_fd_flags = fcntl(mon_fdset_fd->fd, F_GETFL);
2497 if (mon_fd_flags == -1) {
2498 ret = -errno;
2499 goto out;
2500 }
2501
2502 if ((flags & O_ACCMODE) == (mon_fd_flags & O_ACCMODE)) {
2503 ret = mon_fdset_fd->fd;
2504 goto out;
2505 }
2506 }
2507 ret = -EACCES;
2508 goto out;
2509 }
2510 ret = -ENOENT;
2511
2512out:
2513 qemu_mutex_unlock(&mon_fdsets_lock);
2514 return ret;
2515#endif
2516}
2517
2518int monitor_fdset_dup_fd_add(int64_t fdset_id, int dup_fd)
2519{
2520 MonFdset *mon_fdset;
2521 MonFdsetFd *mon_fdset_fd_dup;
2522
2523 qemu_mutex_lock(&mon_fdsets_lock);
2524 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2525 if (mon_fdset->id != fdset_id) {
2526 continue;
2527 }
2528 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2529 if (mon_fdset_fd_dup->fd == dup_fd) {
2530 goto err;
2531 }
2532 }
2533 mon_fdset_fd_dup = g_malloc0(sizeof(*mon_fdset_fd_dup));
2534 mon_fdset_fd_dup->fd = dup_fd;
2535 QLIST_INSERT_HEAD(&mon_fdset->dup_fds, mon_fdset_fd_dup, next);
2536 qemu_mutex_unlock(&mon_fdsets_lock);
2537 return 0;
2538 }
2539
2540err:
2541 qemu_mutex_unlock(&mon_fdsets_lock);
2542 return -1;
2543}
2544
2545static int monitor_fdset_dup_fd_find_remove(int dup_fd, bool remove)
2546{
2547 MonFdset *mon_fdset;
2548 MonFdsetFd *mon_fdset_fd_dup;
2549
2550 qemu_mutex_lock(&mon_fdsets_lock);
2551 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2552 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2553 if (mon_fdset_fd_dup->fd == dup_fd) {
2554 if (remove) {
2555 QLIST_REMOVE(mon_fdset_fd_dup, next);
2556 if (QLIST_EMPTY(&mon_fdset->dup_fds)) {
2557 monitor_fdset_cleanup(mon_fdset);
2558 }
2559 goto err;
2560 } else {
2561 qemu_mutex_unlock(&mon_fdsets_lock);
2562 return mon_fdset->id;
2563 }
2564 }
2565 }
2566 }
2567
2568err:
2569 qemu_mutex_unlock(&mon_fdsets_lock);
2570 return -1;
2571}
2572
2573int monitor_fdset_dup_fd_find(int dup_fd)
2574{
2575 return monitor_fdset_dup_fd_find_remove(dup_fd, false);
2576}
2577
2578void monitor_fdset_dup_fd_remove(int dup_fd)
2579{
2580 monitor_fdset_dup_fd_find_remove(dup_fd, true);
2581}
2582
2583int monitor_fd_param(Monitor *mon, const char *fdname, Error **errp)
2584{
2585 int fd;
2586 Error *local_err = NULL;
2587
2588 if (!qemu_isdigit(fdname[0]) && mon) {
2589 fd = monitor_get_fd(mon, fdname, &local_err);
2590 } else {
2591 fd = qemu_parse_fd(fdname);
2592 if (fd == -1) {
2593 error_setg(&local_err, "Invalid file descriptor number '%s'",
2594 fdname);
2595 }
2596 }
2597 if (local_err) {
2598 error_propagate(errp, local_err);
2599 assert(fd == -1);
2600 } else {
2601 assert(fd != -1);
2602 }
2603
2604 return fd;
2605}
2606
2607
2608static mon_cmd_t info_cmds[] = {
2609#include "hmp-commands-info.h"
2610 { NULL, NULL, },
2611};
2612
2613
2614static mon_cmd_t mon_cmds[] = {
2615#include "hmp-commands.h"
2616 { NULL, NULL, },
2617};
2618
2619
2620
2621static const char *pch;
2622static sigjmp_buf expr_env;
2623
2624
2625static void GCC_FMT_ATTR(2, 3) QEMU_NORETURN
2626expr_error(Monitor *mon, const char *fmt, ...)
2627{
2628 va_list ap;
2629 va_start(ap, fmt);
2630 monitor_vprintf(mon, fmt, ap);
2631 monitor_printf(mon, "\n");
2632 va_end(ap);
2633 siglongjmp(expr_env, 1);
2634}
2635
2636
2637static int get_monitor_def(target_long *pval, const char *name)
2638{
2639 const MonitorDef *md = target_monitor_defs();
2640 CPUState *cs = mon_get_cpu();
2641 void *ptr;
2642 uint64_t tmp = 0;
2643 int ret;
2644
2645 if (cs == NULL || md == NULL) {
2646 return -1;
2647 }
2648
2649 for(; md->name != NULL; md++) {
2650 if (compare_cmd(name, md->name)) {
2651 if (md->get_value) {
2652 *pval = md->get_value(md, md->offset);
2653 } else {
2654 CPUArchState *env = mon_get_cpu_env();
2655 ptr = (uint8_t *)env + md->offset;
2656 switch(md->type) {
2657 case MD_I32:
2658 *pval = *(int32_t *)ptr;
2659 break;
2660 case MD_TLONG:
2661 *pval = *(target_long *)ptr;
2662 break;
2663 default:
2664 *pval = 0;
2665 break;
2666 }
2667 }
2668 return 0;
2669 }
2670 }
2671
2672 ret = target_get_monitor_def(cs, name, &tmp);
2673 if (!ret) {
2674 *pval = (target_long) tmp;
2675 }
2676
2677 return ret;
2678}
2679
2680static void next(void)
2681{
2682 if (*pch != '\0') {
2683 pch++;
2684 while (qemu_isspace(*pch))
2685 pch++;
2686 }
2687}
2688
2689static int64_t expr_sum(Monitor *mon);
2690
2691static int64_t expr_unary(Monitor *mon)
2692{
2693 int64_t n;
2694 char *p;
2695 int ret;
2696
2697 switch(*pch) {
2698 case '+':
2699 next();
2700 n = expr_unary(mon);
2701 break;
2702 case '-':
2703 next();
2704 n = -expr_unary(mon);
2705 break;
2706 case '~':
2707 next();
2708 n = ~expr_unary(mon);
2709 break;
2710 case '(':
2711 next();
2712 n = expr_sum(mon);
2713 if (*pch != ')') {
2714 expr_error(mon, "')' expected");
2715 }
2716 next();
2717 break;
2718 case '\'':
2719 pch++;
2720 if (*pch == '\0')
2721 expr_error(mon, "character constant expected");
2722 n = *pch;
2723 pch++;
2724 if (*pch != '\'')
2725 expr_error(mon, "missing terminating \' character");
2726 next();
2727 break;
2728 case '$':
2729 {
2730 char buf[128], *q;
2731 target_long reg=0;
2732
2733 pch++;
2734 q = buf;
2735 while ((*pch >= 'a' && *pch <= 'z') ||
2736 (*pch >= 'A' && *pch <= 'Z') ||
2737 (*pch >= '0' && *pch <= '9') ||
2738 *pch == '_' || *pch == '.') {
2739 if ((q - buf) < sizeof(buf) - 1)
2740 *q++ = *pch;
2741 pch++;
2742 }
2743 while (qemu_isspace(*pch))
2744 pch++;
2745 *q = 0;
2746 ret = get_monitor_def(®, buf);
2747 if (ret < 0)
2748 expr_error(mon, "unknown register");
2749 n = reg;
2750 }
2751 break;
2752 case '\0':
2753 expr_error(mon, "unexpected end of expression");
2754 n = 0;
2755 break;
2756 default:
2757 errno = 0;
2758 n = strtoull(pch, &p, 0);
2759 if (errno == ERANGE) {
2760 expr_error(mon, "number too large");
2761 }
2762 if (pch == p) {
2763 expr_error(mon, "invalid char '%c' in expression", *p);
2764 }
2765 pch = p;
2766 while (qemu_isspace(*pch))
2767 pch++;
2768 break;
2769 }
2770 return n;
2771}
2772
2773
2774static int64_t expr_prod(Monitor *mon)
2775{
2776 int64_t val, val2;
2777 int op;
2778
2779 val = expr_unary(mon);
2780 for(;;) {
2781 op = *pch;
2782 if (op != '*' && op != '/' && op != '%')
2783 break;
2784 next();
2785 val2 = expr_unary(mon);
2786 switch(op) {
2787 default:
2788 case '*':
2789 val *= val2;
2790 break;
2791 case '/':
2792 case '%':
2793 if (val2 == 0)
2794 expr_error(mon, "division by zero");
2795 if (op == '/')
2796 val /= val2;
2797 else
2798 val %= val2;
2799 break;
2800 }
2801 }
2802 return val;
2803}
2804
2805static int64_t expr_logic(Monitor *mon)
2806{
2807 int64_t val, val2;
2808 int op;
2809
2810 val = expr_prod(mon);
2811 for(;;) {
2812 op = *pch;
2813 if (op != '&' && op != '|' && op != '^')
2814 break;
2815 next();
2816 val2 = expr_prod(mon);
2817 switch(op) {
2818 default:
2819 case '&':
2820 val &= val2;
2821 break;
2822 case '|':
2823 val |= val2;
2824 break;
2825 case '^':
2826 val ^= val2;
2827 break;
2828 }
2829 }
2830 return val;
2831}
2832
2833static int64_t expr_sum(Monitor *mon)
2834{
2835 int64_t val, val2;
2836 int op;
2837
2838 val = expr_logic(mon);
2839 for(;;) {
2840 op = *pch;
2841 if (op != '+' && op != '-')
2842 break;
2843 next();
2844 val2 = expr_logic(mon);
2845 if (op == '+')
2846 val += val2;
2847 else
2848 val -= val2;
2849 }
2850 return val;
2851}
2852
2853static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
2854{
2855 pch = *pp;
2856 if (sigsetjmp(expr_env, 0)) {
2857 *pp = pch;
2858 return -1;
2859 }
2860 while (qemu_isspace(*pch))
2861 pch++;
2862 *pval = expr_sum(mon);
2863 *pp = pch;
2864 return 0;
2865}
2866
2867static int get_double(Monitor *mon, double *pval, const char **pp)
2868{
2869 const char *p = *pp;
2870 char *tailp;
2871 double d;
2872
2873 d = strtod(p, &tailp);
2874 if (tailp == p) {
2875 monitor_printf(mon, "Number expected\n");
2876 return -1;
2877 }
2878 if (d != d || d - d != 0) {
2879
2880 monitor_printf(mon, "Bad number\n");
2881 return -1;
2882 }
2883 *pval = d;
2884 *pp = tailp;
2885 return 0;
2886}
2887
2888
2889
2890
2891
2892static const char *get_command_name(const char *cmdline,
2893 char *cmdname, size_t nlen)
2894{
2895 size_t len;
2896 const char *p, *pstart;
2897
2898 p = cmdline;
2899 while (qemu_isspace(*p))
2900 p++;
2901 if (*p == '\0')
2902 return NULL;
2903 pstart = p;
2904 while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
2905 p++;
2906 len = p - pstart;
2907 if (len > nlen - 1)
2908 len = nlen - 1;
2909 memcpy(cmdname, pstart, len);
2910 cmdname[len] = '\0';
2911 return p;
2912}
2913
2914
2915
2916
2917
2918static char *key_get_info(const char *type, char **key)
2919{
2920 size_t len;
2921 char *p, *str;
2922
2923 if (*type == ',')
2924 type++;
2925
2926 p = strchr(type, ':');
2927 if (!p) {
2928 *key = NULL;
2929 return NULL;
2930 }
2931 len = p - type;
2932
2933 str = g_malloc(len + 1);
2934 memcpy(str, type, len);
2935 str[len] = '\0';
2936
2937 *key = str;
2938 return ++p;
2939}
2940
2941static int default_fmt_format = 'x';
2942static int default_fmt_size = 4;
2943
2944static int is_valid_option(const char *c, const char *typestr)
2945{
2946 char option[3];
2947
2948 option[0] = '-';
2949 option[1] = *c;
2950 option[2] = '\0';
2951
2952 typestr = strstr(typestr, option);
2953 return (typestr != NULL);
2954}
2955
2956static const mon_cmd_t *search_dispatch_table(const mon_cmd_t *disp_table,
2957 const char *cmdname)
2958{
2959 const mon_cmd_t *cmd;
2960
2961 for (cmd = disp_table; cmd->name != NULL; cmd++) {
2962 if (compare_cmd(cmdname, cmd->name)) {
2963 return cmd;
2964 }
2965 }
2966
2967 return NULL;
2968}
2969
2970
2971
2972
2973
2974
2975
2976
2977
2978
2979
2980static const mon_cmd_t *monitor_parse_command(Monitor *mon,
2981 const char *cmdp_start,
2982 const char **cmdp,
2983 mon_cmd_t *table)
2984{
2985 const char *p;
2986 const mon_cmd_t *cmd;
2987 char cmdname[256];
2988
2989
2990 p = get_command_name(*cmdp, cmdname, sizeof(cmdname));
2991 if (!p)
2992 return NULL;
2993
2994 cmd = search_dispatch_table(table, cmdname);
2995 if (!cmd) {
2996 monitor_printf(mon, "unknown command: '%.*s'\n",
2997 (int)(p - cmdp_start), cmdp_start);
2998 return NULL;
2999 }
3000 if (runstate_check(RUN_STATE_PRECONFIG) && !cmd_can_preconfig(cmd)) {
3001 monitor_printf(mon, "Command '%.*s' not available with -preconfig "
3002 "until after exit_preconfig.\n",
3003 (int)(p - cmdp_start), cmdp_start);
3004 return NULL;
3005 }
3006
3007
3008 while (qemu_isspace(*p)) {
3009 p++;
3010 }
3011
3012 *cmdp = p;
3013
3014 if (cmd->sub_table != NULL && *p != '\0') {
3015 return monitor_parse_command(mon, cmdp_start, cmdp, cmd->sub_table);
3016 }
3017
3018 return cmd;
3019}
3020
3021
3022
3023
3024
3025
3026
3027
3028static QDict *monitor_parse_arguments(Monitor *mon,
3029 const char **endp,
3030 const mon_cmd_t *cmd)
3031{
3032 const char *typestr;
3033 char *key;
3034 int c;
3035 const char *p = *endp;
3036 char buf[1024];
3037 QDict *qdict = qdict_new();
3038
3039
3040 typestr = cmd->args_type;
3041 for(;;) {
3042 typestr = key_get_info(typestr, &key);
3043 if (!typestr)
3044 break;
3045 c = *typestr;
3046 typestr++;
3047 switch(c) {
3048 case 'F':
3049 case 'B':
3050 case 's':
3051 {
3052 int ret;
3053
3054 while (qemu_isspace(*p))
3055 p++;
3056 if (*typestr == '?') {
3057 typestr++;
3058 if (*p == '\0') {
3059
3060 break;
3061 }
3062 }
3063 ret = get_str(buf, sizeof(buf), &p);
3064 if (ret < 0) {
3065 switch(c) {
3066 case 'F':
3067 monitor_printf(mon, "%s: filename expected\n",
3068 cmd->name);
3069 break;
3070 case 'B':
3071 monitor_printf(mon, "%s: block device name expected\n",
3072 cmd->name);
3073 break;
3074 default:
3075 monitor_printf(mon, "%s: string expected\n", cmd->name);
3076 break;
3077 }
3078 goto fail;
3079 }
3080 qdict_put_str(qdict, key, buf);
3081 }
3082 break;
3083 case 'O':
3084 {
3085 QemuOptsList *opts_list;
3086 QemuOpts *opts;
3087
3088 opts_list = qemu_find_opts(key);
3089 if (!opts_list || opts_list->desc->name) {
3090 goto bad_type;
3091 }
3092 while (qemu_isspace(*p)) {
3093 p++;
3094 }
3095 if (!*p)
3096 break;
3097 if (get_str(buf, sizeof(buf), &p) < 0) {
3098 goto fail;
3099 }
3100 opts = qemu_opts_parse_noisily(opts_list, buf, true);
3101 if (!opts) {
3102 goto fail;
3103 }
3104 qemu_opts_to_qdict(opts, qdict);
3105 qemu_opts_del(opts);
3106 }
3107 break;
3108 case '/':
3109 {
3110 int count, format, size;
3111
3112 while (qemu_isspace(*p))
3113 p++;
3114 if (*p == '/') {
3115
3116 p++;
3117 count = 1;
3118 if (qemu_isdigit(*p)) {
3119 count = 0;
3120 while (qemu_isdigit(*p)) {
3121 count = count * 10 + (*p - '0');
3122 p++;
3123 }
3124 }
3125 size = -1;
3126 format = -1;
3127 for(;;) {
3128 switch(*p) {
3129 case 'o':
3130 case 'd':
3131 case 'u':
3132 case 'x':
3133 case 'i':
3134 case 'c':
3135 format = *p++;
3136 break;
3137 case 'b':
3138 size = 1;
3139 p++;
3140 break;
3141 case 'h':
3142 size = 2;
3143 p++;
3144 break;
3145 case 'w':
3146 size = 4;
3147 p++;
3148 break;
3149 case 'g':
3150 case 'L':
3151 size = 8;
3152 p++;
3153 break;
3154 default:
3155 goto next;
3156 }
3157 }
3158 next:
3159 if (*p != '\0' && !qemu_isspace(*p)) {
3160 monitor_printf(mon, "invalid char in format: '%c'\n",
3161 *p);
3162 goto fail;
3163 }
3164 if (format < 0)
3165 format = default_fmt_format;
3166 if (format != 'i') {
3167
3168 if (size < 0)
3169 size = default_fmt_size;
3170 default_fmt_size = size;
3171 }
3172 default_fmt_format = format;
3173 } else {
3174 count = 1;
3175 format = default_fmt_format;
3176 if (format != 'i') {
3177 size = default_fmt_size;
3178 } else {
3179 size = -1;
3180 }
3181 }
3182 qdict_put_int(qdict, "count", count);
3183 qdict_put_int(qdict, "format", format);
3184 qdict_put_int(qdict, "size", size);
3185 }
3186 break;
3187 case 'i':
3188 case 'l':
3189 case 'M':
3190 {
3191 int64_t val;
3192
3193 while (qemu_isspace(*p))
3194 p++;
3195 if (*typestr == '?' || *typestr == '.') {
3196 if (*typestr == '?') {
3197 if (*p == '\0') {
3198 typestr++;
3199 break;
3200 }
3201 } else {
3202 if (*p == '.') {
3203 p++;
3204 while (qemu_isspace(*p))
3205 p++;
3206 } else {
3207 typestr++;
3208 break;
3209 }
3210 }
3211 typestr++;
3212 }
3213 if (get_expr(mon, &val, &p))
3214 goto fail;
3215
3216 if ((c == 'i') && ((val >> 32) & 0xffffffff)) {
3217 monitor_printf(mon, "\'%s\' has failed: ", cmd->name);
3218 monitor_printf(mon, "integer is for 32-bit values\n");
3219 goto fail;
3220 } else if (c == 'M') {
3221 if (val < 0) {
3222 monitor_printf(mon, "enter a positive value\n");
3223 goto fail;
3224 }
3225 val *= MiB;
3226 }
3227 qdict_put_int(qdict, key, val);
3228 }
3229 break;
3230 case 'o':
3231 {
3232 int ret;
3233 uint64_t val;
3234 char *end;
3235
3236 while (qemu_isspace(*p)) {
3237 p++;
3238 }
3239 if (*typestr == '?') {
3240 typestr++;
3241 if (*p == '\0') {
3242 break;
3243 }
3244 }
3245 ret = qemu_strtosz_MiB(p, &end, &val);
3246 if (ret < 0 || val > INT64_MAX) {
3247 monitor_printf(mon, "invalid size\n");
3248 goto fail;
3249 }
3250 qdict_put_int(qdict, key, val);
3251 p = end;
3252 }
3253 break;
3254 case 'T':
3255 {
3256 double val;
3257
3258 while (qemu_isspace(*p))
3259 p++;
3260 if (*typestr == '?') {
3261 typestr++;
3262 if (*p == '\0') {
3263 break;
3264 }
3265 }
3266 if (get_double(mon, &val, &p) < 0) {
3267 goto fail;
3268 }
3269 if (p[0] && p[1] == 's') {
3270 switch (*p) {
3271 case 'm':
3272 val /= 1e3; p += 2; break;
3273 case 'u':
3274 val /= 1e6; p += 2; break;
3275 case 'n':
3276 val /= 1e9; p += 2; break;
3277 }
3278 }
3279 if (*p && !qemu_isspace(*p)) {
3280 monitor_printf(mon, "Unknown unit suffix\n");
3281 goto fail;
3282 }
3283 qdict_put(qdict, key, qnum_from_double(val));
3284 }
3285 break;
3286 case 'b':
3287 {
3288 const char *beg;
3289 bool val;
3290
3291 while (qemu_isspace(*p)) {
3292 p++;
3293 }
3294 beg = p;
3295 while (qemu_isgraph(*p)) {
3296 p++;
3297 }
3298 if (p - beg == 2 && !memcmp(beg, "on", p - beg)) {
3299 val = true;
3300 } else if (p - beg == 3 && !memcmp(beg, "off", p - beg)) {
3301 val = false;
3302 } else {
3303 monitor_printf(mon, "Expected 'on' or 'off'\n");
3304 goto fail;
3305 }
3306 qdict_put_bool(qdict, key, val);
3307 }
3308 break;
3309 case '-':
3310 {
3311 const char *tmp = p;
3312 int skip_key = 0;
3313
3314
3315 c = *typestr++;
3316 if (c == '\0')
3317 goto bad_type;
3318 while (qemu_isspace(*p))
3319 p++;
3320 if (*p == '-') {
3321 p++;
3322 if(c != *p) {
3323 if(!is_valid_option(p, typestr)) {
3324
3325 monitor_printf(mon, "%s: unsupported option -%c\n",
3326 cmd->name, *p);
3327 goto fail;
3328 } else {
3329 skip_key = 1;
3330 }
3331 }
3332 if(skip_key) {
3333 p = tmp;
3334 } else {
3335
3336 p++;
3337 qdict_put_bool(qdict, key, true);
3338 }
3339 }
3340 }
3341 break;
3342 case 'S':
3343 {
3344
3345 int len;
3346
3347 while (qemu_isspace(*p)) {
3348 p++;
3349 }
3350 if (*typestr == '?') {
3351 typestr++;
3352 if (*p == '\0') {
3353
3354 break;
3355 }
3356 }
3357 len = strlen(p);
3358 if (len <= 0) {
3359 monitor_printf(mon, "%s: string expected\n",
3360 cmd->name);
3361 goto fail;
3362 }
3363 qdict_put_str(qdict, key, p);
3364 p += len;
3365 }
3366 break;
3367 default:
3368 bad_type:
3369 monitor_printf(mon, "%s: unknown type '%c'\n", cmd->name, c);
3370 goto fail;
3371 }
3372 g_free(key);
3373 key = NULL;
3374 }
3375
3376 while (qemu_isspace(*p))
3377 p++;
3378 if (*p != '\0') {
3379 monitor_printf(mon, "%s: extraneous characters at the end of line\n",
3380 cmd->name);
3381 goto fail;
3382 }
3383
3384 return qdict;
3385
3386fail:
3387 qobject_unref(qdict);
3388 g_free(key);
3389 return NULL;
3390}
3391
3392static void handle_hmp_command(Monitor *mon, const char *cmdline)
3393{
3394 QDict *qdict;
3395 const mon_cmd_t *cmd;
3396 const char *cmd_start = cmdline;
3397
3398 trace_handle_hmp_command(mon, cmdline);
3399
3400 cmd = monitor_parse_command(mon, cmdline, &cmdline, mon->cmd_table);
3401 if (!cmd) {
3402 return;
3403 }
3404
3405 qdict = monitor_parse_arguments(mon, &cmdline, cmd);
3406 if (!qdict) {
3407 while (cmdline > cmd_start && qemu_isspace(cmdline[-1])) {
3408 cmdline--;
3409 }
3410 monitor_printf(mon, "Try \"help %.*s\" for more information\n",
3411 (int)(cmdline - cmd_start), cmd_start);
3412 return;
3413 }
3414
3415 cmd->cmd(mon, qdict);
3416 qobject_unref(qdict);
3417}
3418
3419static void cmd_completion(Monitor *mon, const char *name, const char *list)
3420{
3421 const char *p, *pstart;
3422 char cmd[128];
3423 int len;
3424
3425 p = list;
3426 for(;;) {
3427 pstart = p;
3428 p = qemu_strchrnul(p, '|');
3429 len = p - pstart;
3430 if (len > sizeof(cmd) - 2)
3431 len = sizeof(cmd) - 2;
3432 memcpy(cmd, pstart, len);
3433 cmd[len] = '\0';
3434 if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
3435 readline_add_completion(mon->rs, cmd);
3436 }
3437 if (*p == '\0')
3438 break;
3439 p++;
3440 }
3441}
3442
3443static void file_completion(Monitor *mon, const char *input)
3444{
3445 DIR *ffs;
3446 struct dirent *d;
3447 char path[1024];
3448 char file[1024], file_prefix[1024];
3449 int input_path_len;
3450 const char *p;
3451
3452 p = strrchr(input, '/');
3453 if (!p) {
3454 input_path_len = 0;
3455 pstrcpy(file_prefix, sizeof(file_prefix), input);
3456 pstrcpy(path, sizeof(path), ".");
3457 } else {
3458 input_path_len = p - input + 1;
3459 memcpy(path, input, input_path_len);
3460 if (input_path_len > sizeof(path) - 1)
3461 input_path_len = sizeof(path) - 1;
3462 path[input_path_len] = '\0';
3463 pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
3464 }
3465
3466 ffs = opendir(path);
3467 if (!ffs)
3468 return;
3469 for(;;) {
3470 struct stat sb;
3471 d = readdir(ffs);
3472 if (!d)
3473 break;
3474
3475 if (strcmp(d->d_name, ".") == 0 || strcmp(d->d_name, "..") == 0) {
3476 continue;
3477 }
3478
3479 if (strstart(d->d_name, file_prefix, NULL)) {
3480 memcpy(file, input, input_path_len);
3481 if (input_path_len < sizeof(file))
3482 pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
3483 d->d_name);
3484
3485
3486
3487 if (stat(file, &sb) == 0 && S_ISDIR(sb.st_mode)) {
3488 pstrcat(file, sizeof(file), "/");
3489 }
3490 readline_add_completion(mon->rs, file);
3491 }
3492 }
3493 closedir(ffs);
3494}
3495
3496static const char *next_arg_type(const char *typestr)
3497{
3498 const char *p = strchr(typestr, ':');
3499 return (p != NULL ? ++p : typestr);
3500}
3501
3502static void add_completion_option(ReadLineState *rs, const char *str,
3503 const char *option)
3504{
3505 if (!str || !option) {
3506 return;
3507 }
3508 if (!strncmp(option, str, strlen(str))) {
3509 readline_add_completion(rs, option);
3510 }
3511}
3512
3513void chardev_add_completion(ReadLineState *rs, int nb_args, const char *str)
3514{
3515 size_t len;
3516 ChardevBackendInfoList *list, *start;
3517
3518 if (nb_args != 2) {
3519 return;
3520 }
3521 len = strlen(str);
3522 readline_set_completion_index(rs, len);
3523
3524 start = list = qmp_query_chardev_backends(NULL);
3525 while (list) {
3526 const char *chr_name = list->value->name;
3527
3528 if (!strncmp(chr_name, str, len)) {
3529 readline_add_completion(rs, chr_name);
3530 }
3531 list = list->next;
3532 }
3533 qapi_free_ChardevBackendInfoList(start);
3534}
3535
3536void netdev_add_completion(ReadLineState *rs, int nb_args, const char *str)
3537{
3538 size_t len;
3539 int i;
3540
3541 if (nb_args != 2) {
3542 return;
3543 }
3544 len = strlen(str);
3545 readline_set_completion_index(rs, len);
3546 for (i = 0; i < NET_CLIENT_DRIVER__MAX; i++) {
3547 add_completion_option(rs, str, NetClientDriver_str(i));
3548 }
3549}
3550
3551void device_add_completion(ReadLineState *rs, int nb_args, const char *str)
3552{
3553 GSList *list, *elt;
3554 size_t len;
3555
3556 if (nb_args != 2) {
3557 return;
3558 }
3559
3560 len = strlen(str);
3561 readline_set_completion_index(rs, len);
3562 list = elt = object_class_get_list(TYPE_DEVICE, false);
3563 while (elt) {
3564 const char *name;
3565 DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data,
3566 TYPE_DEVICE);
3567 name = object_class_get_name(OBJECT_CLASS(dc));
3568
3569 if (dc->user_creatable
3570 && !strncmp(name, str, len)) {
3571 readline_add_completion(rs, name);
3572 }
3573 elt = elt->next;
3574 }
3575 g_slist_free(list);
3576}
3577
3578void object_add_completion(ReadLineState *rs, int nb_args, const char *str)
3579{
3580 GSList *list, *elt;
3581 size_t len;
3582
3583 if (nb_args != 2) {
3584 return;
3585 }
3586
3587 len = strlen(str);
3588 readline_set_completion_index(rs, len);
3589 list = elt = object_class_get_list(TYPE_USER_CREATABLE, false);
3590 while (elt) {
3591 const char *name;
3592
3593 name = object_class_get_name(OBJECT_CLASS(elt->data));
3594 if (!strncmp(name, str, len) && strcmp(name, TYPE_USER_CREATABLE)) {
3595 readline_add_completion(rs, name);
3596 }
3597 elt = elt->next;
3598 }
3599 g_slist_free(list);
3600}
3601
3602static void peripheral_device_del_completion(ReadLineState *rs,
3603 const char *str, size_t len)
3604{
3605 Object *peripheral = container_get(qdev_get_machine(), "/peripheral");
3606 GSList *list, *item;
3607
3608 list = qdev_build_hotpluggable_device_list(peripheral);
3609 if (!list) {
3610 return;
3611 }
3612
3613 for (item = list; item; item = g_slist_next(item)) {
3614 DeviceState *dev = item->data;
3615
3616 if (dev->id && !strncmp(str, dev->id, len)) {
3617 readline_add_completion(rs, dev->id);
3618 }
3619 }
3620
3621 g_slist_free(list);
3622}
3623
3624void chardev_remove_completion(ReadLineState *rs, int nb_args, const char *str)
3625{
3626 size_t len;
3627 ChardevInfoList *list, *start;
3628
3629 if (nb_args != 2) {
3630 return;
3631 }
3632 len = strlen(str);
3633 readline_set_completion_index(rs, len);
3634
3635 start = list = qmp_query_chardev(NULL);
3636 while (list) {
3637 ChardevInfo *chr = list->value;
3638
3639 if (!strncmp(chr->label, str, len)) {
3640 readline_add_completion(rs, chr->label);
3641 }
3642 list = list->next;
3643 }
3644 qapi_free_ChardevInfoList(start);
3645}
3646
3647static void ringbuf_completion(ReadLineState *rs, const char *str)
3648{
3649 size_t len;
3650 ChardevInfoList *list, *start;
3651
3652 len = strlen(str);
3653 readline_set_completion_index(rs, len);
3654
3655 start = list = qmp_query_chardev(NULL);
3656 while (list) {
3657 ChardevInfo *chr_info = list->value;
3658
3659 if (!strncmp(chr_info->label, str, len)) {
3660 Chardev *chr = qemu_chr_find(chr_info->label);
3661 if (chr && CHARDEV_IS_RINGBUF(chr)) {
3662 readline_add_completion(rs, chr_info->label);
3663 }
3664 }
3665 list = list->next;
3666 }
3667 qapi_free_ChardevInfoList(start);
3668}
3669
3670void ringbuf_write_completion(ReadLineState *rs, int nb_args, const char *str)
3671{
3672 if (nb_args != 2) {
3673 return;
3674 }
3675 ringbuf_completion(rs, str);
3676}
3677
3678void device_del_completion(ReadLineState *rs, int nb_args, const char *str)
3679{
3680 size_t len;
3681
3682 if (nb_args != 2) {
3683 return;
3684 }
3685
3686 len = strlen(str);
3687 readline_set_completion_index(rs, len);
3688 peripheral_device_del_completion(rs, str, len);
3689}
3690
3691void object_del_completion(ReadLineState *rs, int nb_args, const char *str)
3692{
3693 ObjectPropertyInfoList *list, *start;
3694 size_t len;
3695
3696 if (nb_args != 2) {
3697 return;
3698 }
3699 len = strlen(str);
3700 readline_set_completion_index(rs, len);
3701
3702 start = list = qmp_qom_list("/objects", NULL);
3703 while (list) {
3704 ObjectPropertyInfo *info = list->value;
3705
3706 if (!strncmp(info->type, "child<", 5)
3707 && !strncmp(info->name, str, len)) {
3708 readline_add_completion(rs, info->name);
3709 }
3710 list = list->next;
3711 }
3712 qapi_free_ObjectPropertyInfoList(start);
3713}
3714
3715void sendkey_completion(ReadLineState *rs, int nb_args, const char *str)
3716{
3717 int i;
3718 char *sep;
3719 size_t len;
3720
3721 if (nb_args != 2) {
3722 return;
3723 }
3724 sep = strrchr(str, '-');
3725 if (sep) {
3726 str = sep + 1;
3727 }
3728 len = strlen(str);
3729 readline_set_completion_index(rs, len);
3730 for (i = 0; i < Q_KEY_CODE__MAX; i++) {
3731 if (!strncmp(str, QKeyCode_str(i), len)) {
3732 readline_add_completion(rs, QKeyCode_str(i));
3733 }
3734 }
3735}
3736
3737void set_link_completion(ReadLineState *rs, int nb_args, const char *str)
3738{
3739 size_t len;
3740
3741 len = strlen(str);
3742 readline_set_completion_index(rs, len);
3743 if (nb_args == 2) {
3744 NetClientState *ncs[MAX_QUEUE_NUM];
3745 int count, i;
3746 count = qemu_find_net_clients_except(NULL, ncs,
3747 NET_CLIENT_DRIVER_NONE,
3748 MAX_QUEUE_NUM);
3749 for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
3750 const char *name = ncs[i]->name;
3751 if (!strncmp(str, name, len)) {
3752 readline_add_completion(rs, name);
3753 }
3754 }
3755 } else if (nb_args == 3) {
3756 add_completion_option(rs, str, "on");
3757 add_completion_option(rs, str, "off");
3758 }
3759}
3760
3761void netdev_del_completion(ReadLineState *rs, int nb_args, const char *str)
3762{
3763 int len, count, i;
3764 NetClientState *ncs[MAX_QUEUE_NUM];
3765
3766 if (nb_args != 2) {
3767 return;
3768 }
3769
3770 len = strlen(str);
3771 readline_set_completion_index(rs, len);
3772 count = qemu_find_net_clients_except(NULL, ncs, NET_CLIENT_DRIVER_NIC,
3773 MAX_QUEUE_NUM);
3774 for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
3775 QemuOpts *opts;
3776 const char *name = ncs[i]->name;
3777 if (strncmp(str, name, len)) {
3778 continue;
3779 }
3780 opts = qemu_opts_find(qemu_find_opts_err("netdev", NULL), name);
3781 if (opts) {
3782 readline_add_completion(rs, name);
3783 }
3784 }
3785}
3786
3787void info_trace_events_completion(ReadLineState *rs, int nb_args, const char *str)
3788{
3789 size_t len;
3790
3791 len = strlen(str);
3792 readline_set_completion_index(rs, len);
3793 if (nb_args == 2) {
3794 TraceEventIter iter;
3795 TraceEvent *ev;
3796 char *pattern = g_strdup_printf("%s*", str);
3797 trace_event_iter_init(&iter, pattern);
3798 while ((ev = trace_event_iter_next(&iter)) != NULL) {
3799 readline_add_completion(rs, trace_event_get_name(ev));
3800 }
3801 g_free(pattern);
3802 }
3803}
3804
3805void trace_event_completion(ReadLineState *rs, int nb_args, const char *str)
3806{
3807 size_t len;
3808
3809 len = strlen(str);
3810 readline_set_completion_index(rs, len);
3811 if (nb_args == 2) {
3812 TraceEventIter iter;
3813 TraceEvent *ev;
3814 char *pattern = g_strdup_printf("%s*", str);
3815 trace_event_iter_init(&iter, pattern);
3816 while ((ev = trace_event_iter_next(&iter)) != NULL) {
3817 readline_add_completion(rs, trace_event_get_name(ev));
3818 }
3819 g_free(pattern);
3820 } else if (nb_args == 3) {
3821 add_completion_option(rs, str, "on");
3822 add_completion_option(rs, str, "off");
3823 }
3824}
3825
3826void watchdog_action_completion(ReadLineState *rs, int nb_args, const char *str)
3827{
3828 int i;
3829
3830 if (nb_args != 2) {
3831 return;
3832 }
3833 readline_set_completion_index(rs, strlen(str));
3834 for (i = 0; i < WATCHDOG_ACTION__MAX; i++) {
3835 add_completion_option(rs, str, WatchdogAction_str(i));
3836 }
3837}
3838
3839void migrate_set_capability_completion(ReadLineState *rs, int nb_args,
3840 const char *str)
3841{
3842 size_t len;
3843
3844 len = strlen(str);
3845 readline_set_completion_index(rs, len);
3846 if (nb_args == 2) {
3847 int i;
3848 for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
3849 const char *name = MigrationCapability_str(i);
3850 if (!strncmp(str, name, len)) {
3851 readline_add_completion(rs, name);
3852 }
3853 }
3854 } else if (nb_args == 3) {
3855 add_completion_option(rs, str, "on");
3856 add_completion_option(rs, str, "off");
3857 }
3858}
3859
3860void migrate_set_parameter_completion(ReadLineState *rs, int nb_args,
3861 const char *str)
3862{
3863 size_t len;
3864
3865 len = strlen(str);
3866 readline_set_completion_index(rs, len);
3867 if (nb_args == 2) {
3868 int i;
3869 for (i = 0; i < MIGRATION_PARAMETER__MAX; i++) {
3870 const char *name = MigrationParameter_str(i);
3871 if (!strncmp(str, name, len)) {
3872 readline_add_completion(rs, name);
3873 }
3874 }
3875 }
3876}
3877
3878static void vm_completion(ReadLineState *rs, const char *str)
3879{
3880 size_t len;
3881 BlockDriverState *bs;
3882 BdrvNextIterator it;
3883
3884 len = strlen(str);
3885 readline_set_completion_index(rs, len);
3886
3887 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
3888 SnapshotInfoList *snapshots, *snapshot;
3889 AioContext *ctx = bdrv_get_aio_context(bs);
3890 bool ok = false;
3891
3892 aio_context_acquire(ctx);
3893 if (bdrv_can_snapshot(bs)) {
3894 ok = bdrv_query_snapshot_info_list(bs, &snapshots, NULL) == 0;
3895 }
3896 aio_context_release(ctx);
3897 if (!ok) {
3898 continue;
3899 }
3900
3901 snapshot = snapshots;
3902 while (snapshot) {
3903 char *completion = snapshot->value->name;
3904 if (!strncmp(str, completion, len)) {
3905 readline_add_completion(rs, completion);
3906 }
3907 completion = snapshot->value->id;
3908 if (!strncmp(str, completion, len)) {
3909 readline_add_completion(rs, completion);
3910 }
3911 snapshot = snapshot->next;
3912 }
3913 qapi_free_SnapshotInfoList(snapshots);
3914 }
3915
3916}
3917
3918void delvm_completion(ReadLineState *rs, int nb_args, const char *str)
3919{
3920 if (nb_args == 2) {
3921 vm_completion(rs, str);
3922 }
3923}
3924
3925void loadvm_completion(ReadLineState *rs, int nb_args, const char *str)
3926{
3927 if (nb_args == 2) {
3928 vm_completion(rs, str);
3929 }
3930}
3931
3932static void monitor_find_completion_by_table(Monitor *mon,
3933 const mon_cmd_t *cmd_table,
3934 char **args,
3935 int nb_args)
3936{
3937 const char *cmdname;
3938 int i;
3939 const char *ptype, *old_ptype, *str, *name;
3940 const mon_cmd_t *cmd;
3941 BlockBackend *blk = NULL;
3942
3943 if (nb_args <= 1) {
3944
3945 if (nb_args == 0)
3946 cmdname = "";
3947 else
3948 cmdname = args[0];
3949 readline_set_completion_index(mon->rs, strlen(cmdname));
3950 for (cmd = cmd_table; cmd->name != NULL; cmd++) {
3951 if (!runstate_check(RUN_STATE_PRECONFIG) ||
3952 cmd_can_preconfig(cmd)) {
3953 cmd_completion(mon, cmdname, cmd->name);
3954 }
3955 }
3956 } else {
3957
3958 for (cmd = cmd_table; cmd->name != NULL; cmd++) {
3959 if (compare_cmd(args[0], cmd->name) &&
3960 (!runstate_check(RUN_STATE_PRECONFIG) ||
3961 cmd_can_preconfig(cmd))) {
3962 break;
3963 }
3964 }
3965 if (!cmd->name) {
3966 return;
3967 }
3968
3969 if (cmd->sub_table) {
3970
3971 monitor_find_completion_by_table(mon, cmd->sub_table,
3972 &args[1], nb_args - 1);
3973 return;
3974 }
3975 if (cmd->command_completion) {
3976 cmd->command_completion(mon->rs, nb_args, args[nb_args - 1]);
3977 return;
3978 }
3979
3980 ptype = next_arg_type(cmd->args_type);
3981 for(i = 0; i < nb_args - 2; i++) {
3982 if (*ptype != '\0') {
3983 ptype = next_arg_type(ptype);
3984 while (*ptype == '?')
3985 ptype = next_arg_type(ptype);
3986 }
3987 }
3988 str = args[nb_args - 1];
3989 old_ptype = NULL;
3990 while (*ptype == '-' && old_ptype != ptype) {
3991 old_ptype = ptype;
3992 ptype = next_arg_type(ptype);
3993 }
3994 switch(*ptype) {
3995 case 'F':
3996
3997 readline_set_completion_index(mon->rs, strlen(str));
3998 file_completion(mon, str);
3999 break;
4000 case 'B':
4001
4002 readline_set_completion_index(mon->rs, strlen(str));
4003 while ((blk = blk_next(blk)) != NULL) {
4004 name = blk_name(blk);
4005 if (str[0] == '\0' ||
4006 !strncmp(name, str, strlen(str))) {
4007 readline_add_completion(mon->rs, name);
4008 }
4009 }
4010 break;
4011 case 's':
4012 case 'S':
4013 if (!strcmp(cmd->name, "help|?")) {
4014 monitor_find_completion_by_table(mon, cmd_table,
4015 &args[1], nb_args - 1);
4016 }
4017 break;
4018 default:
4019 break;
4020 }
4021 }
4022}
4023
4024static void monitor_find_completion(void *opaque,
4025 const char *cmdline)
4026{
4027 Monitor *mon = opaque;
4028 char *args[MAX_ARGS];
4029 int nb_args, len;
4030
4031
4032 if (parse_cmdline(cmdline, &nb_args, args) < 0) {
4033 return;
4034 }
4035
4036
4037
4038 len = strlen(cmdline);
4039 if (len > 0 && qemu_isspace(cmdline[len - 1])) {
4040 if (nb_args >= MAX_ARGS) {
4041 goto cleanup;
4042 }
4043 args[nb_args++] = g_strdup("");
4044 }
4045
4046
4047 monitor_find_completion_by_table(mon, mon->cmd_table, args, nb_args);
4048
4049cleanup:
4050 free_cmdline_args(args, nb_args);
4051}
4052
4053static int monitor_can_read(void *opaque)
4054{
4055 Monitor *mon = opaque;
4056
4057 return !atomic_mb_read(&mon->suspend_cnt);
4058}
4059
4060
4061
4062
4063
4064
4065static void monitor_qmp_respond(Monitor *mon, QDict *rsp, QObject *id)
4066{
4067 if (rsp) {
4068 if (id) {
4069 qdict_put_obj(rsp, "id", qobject_ref(id));
4070 }
4071
4072 qmp_send_response(mon, rsp);
4073 }
4074}
4075
4076static void monitor_qmp_dispatch(Monitor *mon, QObject *req, QObject *id)
4077{
4078 Monitor *old_mon;
4079 QDict *rsp;
4080 QDict *error;
4081
4082 old_mon = cur_mon;
4083 cur_mon = mon;
4084
4085 rsp = qmp_dispatch(mon->qmp.commands, req, qmp_oob_enabled(mon));
4086
4087 cur_mon = old_mon;
4088
4089 if (mon->qmp.commands == &qmp_cap_negotiation_commands) {
4090 error = qdict_get_qdict(rsp, "error");
4091 if (error
4092 && !g_strcmp0(qdict_get_try_str(error, "class"),
4093 QapiErrorClass_str(ERROR_CLASS_COMMAND_NOT_FOUND))) {
4094
4095 qdict_del(error, "desc");
4096 qdict_put_str(error, "desc", "Expecting capabilities negotiation"
4097 " with 'qmp_capabilities'");
4098 }
4099 }
4100
4101 monitor_qmp_respond(mon, rsp, id);
4102 qobject_unref(rsp);
4103}
4104
4105
4106
4107
4108
4109
4110
4111
4112
4113static QMPRequest *monitor_qmp_requests_pop_any(void)
4114{
4115 QMPRequest *req_obj = NULL;
4116 Monitor *mon;
4117
4118 qemu_mutex_lock(&monitor_lock);
4119
4120 QTAILQ_FOREACH(mon, &mon_list, entry) {
4121 qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
4122 req_obj = g_queue_pop_head(mon->qmp.qmp_requests);
4123 qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
4124 if (req_obj) {
4125 break;
4126 }
4127 }
4128
4129 if (req_obj) {
4130
4131
4132
4133
4134 QTAILQ_REMOVE(&mon_list, mon, entry);
4135 QTAILQ_INSERT_TAIL(&mon_list, mon, entry);
4136 }
4137
4138 qemu_mutex_unlock(&monitor_lock);
4139
4140 return req_obj;
4141}
4142
4143static void monitor_qmp_bh_dispatcher(void *data)
4144{
4145 QMPRequest *req_obj = monitor_qmp_requests_pop_any();
4146 QDict *rsp;
4147 bool need_resume;
4148
4149 if (!req_obj) {
4150 return;
4151 }
4152
4153
4154 need_resume = !qmp_oob_enabled(req_obj->mon);
4155 if (req_obj->req) {
4156 trace_monitor_qmp_cmd_in_band(qobject_get_try_str(req_obj->id) ?: "");
4157 monitor_qmp_dispatch(req_obj->mon, req_obj->req, req_obj->id);
4158 } else {
4159 assert(req_obj->err);
4160 rsp = qmp_error_response(req_obj->err);
4161 req_obj->err = NULL;
4162 monitor_qmp_respond(req_obj->mon, rsp, NULL);
4163 qobject_unref(rsp);
4164 }
4165
4166 if (need_resume) {
4167
4168 monitor_resume(req_obj->mon);
4169 }
4170 qmp_request_free(req_obj);
4171
4172
4173 qemu_bh_schedule(qmp_dispatcher_bh);
4174}
4175
4176#define QMP_REQ_QUEUE_LEN_MAX (8)
4177
4178static void handle_qmp_command(void *opaque, QObject *req, Error *err)
4179{
4180 Monitor *mon = opaque;
4181 QObject *id = NULL;
4182 QDict *qdict;
4183 QMPRequest *req_obj;
4184
4185 assert(!req != !err);
4186
4187 qdict = qobject_to(QDict, req);
4188 if (qdict) {
4189 id = qobject_ref(qdict_get(qdict, "id"));
4190 qdict_del(qdict, "id");
4191 }
4192
4193 if (req && trace_event_get_state_backends(TRACE_HANDLE_QMP_COMMAND)) {
4194 QString *req_json = qobject_to_json(req);
4195 trace_handle_qmp_command(mon, qstring_get_str(req_json));
4196 qobject_unref(req_json);
4197 }
4198
4199 if (qdict && qmp_is_oob(qdict)) {
4200
4201 trace_monitor_qmp_cmd_out_of_band(qobject_get_try_str(id)
4202 ?: "");
4203 monitor_qmp_dispatch(mon, req, id);
4204 qobject_unref(req);
4205 qobject_unref(id);
4206 return;
4207 }
4208
4209 req_obj = g_new0(QMPRequest, 1);
4210 req_obj->mon = mon;
4211 req_obj->id = id;
4212 req_obj->req = req;
4213 req_obj->err = err;
4214
4215
4216 qemu_mutex_lock(&mon->qmp.qmp_queue_lock);
4217
4218
4219
4220
4221
4222
4223
4224 if (!qmp_oob_enabled(mon)) {
4225 monitor_suspend(mon);
4226 } else {
4227
4228 if (mon->qmp.qmp_requests->length >= QMP_REQ_QUEUE_LEN_MAX) {
4229 qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
4230
4231
4232
4233
4234
4235
4236 qapi_event_send_command_dropped(id,
4237 COMMAND_DROP_REASON_QUEUE_FULL);
4238 qmp_request_free(req_obj);
4239 return;
4240 }
4241 }
4242
4243
4244
4245
4246
4247
4248 g_queue_push_tail(mon->qmp.qmp_requests, req_obj);
4249 qemu_mutex_unlock(&mon->qmp.qmp_queue_lock);
4250
4251
4252 qemu_bh_schedule(qmp_dispatcher_bh);
4253}
4254
4255static void monitor_qmp_read(void *opaque, const uint8_t *buf, int size)
4256{
4257 Monitor *mon = opaque;
4258
4259 json_message_parser_feed(&mon->qmp.parser, (const char *) buf, size);
4260}
4261
4262static void monitor_read(void *opaque, const uint8_t *buf, int size)
4263{
4264 Monitor *old_mon = cur_mon;
4265 int i;
4266
4267 cur_mon = opaque;
4268
4269 if (cur_mon->rs) {
4270 for (i = 0; i < size; i++)
4271 readline_handle_byte(cur_mon->rs, buf[i]);
4272 } else {
4273 if (size == 0 || buf[size - 1] != 0)
4274 monitor_printf(cur_mon, "corrupted command\n");
4275 else
4276 handle_hmp_command(cur_mon, (char *)buf);
4277 }
4278
4279 cur_mon = old_mon;
4280}
4281
4282static void monitor_command_cb(void *opaque, const char *cmdline,
4283 void *readline_opaque)
4284{
4285 Monitor *mon = opaque;
4286
4287 monitor_suspend(mon);
4288 handle_hmp_command(mon, cmdline);
4289 monitor_resume(mon);
4290}
4291
4292int monitor_suspend(Monitor *mon)
4293{
4294 if (monitor_is_hmp_non_interactive(mon)) {
4295 return -ENOTTY;
4296 }
4297
4298 atomic_inc(&mon->suspend_cnt);
4299
4300 if (monitor_is_qmp(mon) && mon->use_io_thread) {
4301
4302
4303
4304
4305 aio_notify(iothread_get_aio_context(mon_iothread));
4306 }
4307
4308 trace_monitor_suspend(mon, 1);
4309 return 0;
4310}
4311
4312void monitor_resume(Monitor *mon)
4313{
4314 if (monitor_is_hmp_non_interactive(mon)) {
4315 return;
4316 }
4317
4318 if (atomic_dec_fetch(&mon->suspend_cnt) == 0) {
4319 if (monitor_is_qmp(mon)) {
4320
4321
4322
4323
4324 if (mon->use_io_thread) {
4325 aio_notify(iothread_get_aio_context(mon_iothread));
4326 }
4327 } else {
4328 assert(mon->rs);
4329 readline_show_prompt(mon->rs);
4330 }
4331 qemu_chr_fe_accept_input(&mon->chr);
4332 }
4333 trace_monitor_suspend(mon, -1);
4334}
4335
4336static QDict *qmp_greeting(Monitor *mon)
4337{
4338 QList *cap_list = qlist_new();
4339 QObject *ver = NULL;
4340 QMPCapability cap;
4341
4342 qmp_marshal_query_version(NULL, &ver, NULL);
4343
4344 for (cap = 0; cap < QMP_CAPABILITY__MAX; cap++) {
4345 if (mon->qmp.capab_offered[cap]) {
4346 qlist_append_str(cap_list, QMPCapability_str(cap));
4347 }
4348 }
4349
4350 return qdict_from_jsonf_nofail(
4351 "{'QMP': {'version': %p, 'capabilities': %p}}",
4352 ver, cap_list);
4353}
4354
4355static void monitor_qmp_event(void *opaque, int event)
4356{
4357 QDict *data;
4358 Monitor *mon = opaque;
4359
4360 switch (event) {
4361 case CHR_EVENT_OPENED:
4362 mon->qmp.commands = &qmp_cap_negotiation_commands;
4363 monitor_qmp_caps_reset(mon);
4364 data = qmp_greeting(mon);
4365 qmp_send_response(mon, data);
4366 qobject_unref(data);
4367 mon_refcount++;
4368 break;
4369 case CHR_EVENT_CLOSED:
4370
4371
4372
4373
4374
4375
4376 monitor_qmp_cleanup_queues(mon);
4377 json_message_parser_destroy(&mon->qmp.parser);
4378 json_message_parser_init(&mon->qmp.parser, handle_qmp_command,
4379 mon, NULL);
4380 mon_refcount--;
4381 monitor_fdsets_cleanup();
4382 break;
4383 }
4384}
4385
4386static void monitor_event(void *opaque, int event)
4387{
4388 Monitor *mon = opaque;
4389
4390 switch (event) {
4391 case CHR_EVENT_MUX_IN:
4392 qemu_mutex_lock(&mon->mon_lock);
4393 mon->mux_out = 0;
4394 qemu_mutex_unlock(&mon->mon_lock);
4395 if (mon->reset_seen) {
4396 readline_restart(mon->rs);
4397 monitor_resume(mon);
4398 monitor_flush(mon);
4399 } else {
4400 atomic_mb_set(&mon->suspend_cnt, 0);
4401 }
4402 break;
4403
4404 case CHR_EVENT_MUX_OUT:
4405 if (mon->reset_seen) {
4406 if (atomic_mb_read(&mon->suspend_cnt) == 0) {
4407 monitor_printf(mon, "\n");
4408 }
4409 monitor_flush(mon);
4410 monitor_suspend(mon);
4411 } else {
4412 atomic_inc(&mon->suspend_cnt);
4413 }
4414 qemu_mutex_lock(&mon->mon_lock);
4415 mon->mux_out = 1;
4416 qemu_mutex_unlock(&mon->mon_lock);
4417 break;
4418
4419 case CHR_EVENT_OPENED:
4420 monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
4421 "information\n", QEMU_VERSION);
4422 if (!mon->mux_out) {
4423 readline_restart(mon->rs);
4424 readline_show_prompt(mon->rs);
4425 }
4426 mon->reset_seen = 1;
4427 mon_refcount++;
4428 break;
4429
4430 case CHR_EVENT_CLOSED:
4431 mon_refcount--;
4432 monitor_fdsets_cleanup();
4433 break;
4434 }
4435}
4436
4437static int
4438compare_mon_cmd(const void *a, const void *b)
4439{
4440 return strcmp(((const mon_cmd_t *)a)->name,
4441 ((const mon_cmd_t *)b)->name);
4442}
4443
4444static void sortcmdlist(void)
4445{
4446 int array_num;
4447 int elem_size = sizeof(mon_cmd_t);
4448
4449 array_num = sizeof(mon_cmds)/elem_size-1;
4450 qsort((void *)mon_cmds, array_num, elem_size, compare_mon_cmd);
4451
4452 array_num = sizeof(info_cmds)/elem_size-1;
4453 qsort((void *)info_cmds, array_num, elem_size, compare_mon_cmd);
4454}
4455
4456static GMainContext *monitor_get_io_context(void)
4457{
4458 return iothread_get_g_main_context(mon_iothread);
4459}
4460
4461static AioContext *monitor_get_aio_context(void)
4462{
4463 return iothread_get_aio_context(mon_iothread);
4464}
4465
4466static void monitor_iothread_init(void)
4467{
4468 mon_iothread = iothread_create("mon_iothread", &error_abort);
4469}
4470
4471void monitor_init_globals(void)
4472{
4473 monitor_init_qmp_commands();
4474 monitor_qapi_event_init();
4475 sortcmdlist();
4476 qemu_mutex_init(&monitor_lock);
4477 qemu_mutex_init(&mon_fdsets_lock);
4478
4479
4480
4481
4482
4483
4484 qmp_dispatcher_bh = aio_bh_new(iohandler_get_aio_context(),
4485 monitor_qmp_bh_dispatcher,
4486 NULL);
4487}
4488
4489
4490
4491
4492static void GCC_FMT_ATTR(2, 3) monitor_readline_printf(void *opaque,
4493 const char *fmt, ...)
4494{
4495 va_list ap;
4496 va_start(ap, fmt);
4497 monitor_vprintf(opaque, fmt, ap);
4498 va_end(ap);
4499}
4500
4501static void monitor_readline_flush(void *opaque)
4502{
4503 monitor_flush(opaque);
4504}
4505
4506
4507
4508
4509
4510
4511void monitor_vfprintf(FILE *stream, const char *fmt, va_list ap)
4512{
4513 if (cur_mon && !monitor_cur_is_qmp()) {
4514 monitor_vprintf(cur_mon, fmt, ap);
4515 } else {
4516 vfprintf(stream, fmt, ap);
4517 }
4518}
4519
4520
4521
4522
4523
4524
4525void error_vprintf(const char *fmt, va_list ap)
4526{
4527 monitor_vfprintf(stderr, fmt, ap);
4528}
4529
4530void error_vprintf_unless_qmp(const char *fmt, va_list ap)
4531{
4532 if (cur_mon && !monitor_cur_is_qmp()) {
4533 monitor_vprintf(cur_mon, fmt, ap);
4534 } else if (!cur_mon) {
4535 vfprintf(stderr, fmt, ap);
4536 }
4537}
4538
4539static void monitor_list_append(Monitor *mon)
4540{
4541 qemu_mutex_lock(&monitor_lock);
4542 QTAILQ_INSERT_HEAD(&mon_list, mon, entry);
4543 qemu_mutex_unlock(&monitor_lock);
4544}
4545
4546static void monitor_qmp_setup_handlers_bh(void *opaque)
4547{
4548 Monitor *mon = opaque;
4549 GMainContext *context;
4550
4551 assert(mon->use_io_thread);
4552 context = monitor_get_io_context();
4553 assert(context);
4554 qemu_chr_fe_set_handlers(&mon->chr, monitor_can_read, monitor_qmp_read,
4555 monitor_qmp_event, NULL, mon, context, true);
4556 monitor_list_append(mon);
4557}
4558
4559void monitor_init(Chardev *chr, int flags)
4560{
4561 Monitor *mon = g_malloc(sizeof(*mon));
4562 bool use_readline = flags & MONITOR_USE_READLINE;
4563 bool use_oob = flags & MONITOR_USE_OOB;
4564
4565 if (use_oob) {
4566 if (CHARDEV_IS_MUX(chr)) {
4567 error_report("Monitor out-of-band is not supported with "
4568 "MUX typed chardev backend");
4569 exit(1);
4570 }
4571 if (use_readline) {
4572 error_report("Monitor out-of-band is only supported by QMP");
4573 exit(1);
4574 }
4575 }
4576
4577 monitor_data_init(mon, false, use_oob);
4578
4579 qemu_chr_fe_init(&mon->chr, chr, &error_abort);
4580 mon->flags = flags;
4581 if (use_readline) {
4582 mon->rs = readline_init(monitor_readline_printf,
4583 monitor_readline_flush,
4584 mon,
4585 monitor_find_completion);
4586 monitor_read_command(mon, 0);
4587 }
4588
4589 if (monitor_is_qmp(mon)) {
4590 qemu_chr_fe_set_echo(&mon->chr, true);
4591 json_message_parser_init(&mon->qmp.parser, handle_qmp_command,
4592 mon, NULL);
4593 if (mon->use_io_thread) {
4594
4595
4596
4597
4598 remove_fd_in_watch(chr);
4599
4600
4601
4602
4603
4604 aio_bh_schedule_oneshot(monitor_get_aio_context(),
4605 monitor_qmp_setup_handlers_bh, mon);
4606
4607 return;
4608 } else {
4609 qemu_chr_fe_set_handlers(&mon->chr, monitor_can_read,
4610 monitor_qmp_read, monitor_qmp_event,
4611 NULL, mon, NULL, true);
4612 }
4613 } else {
4614 qemu_chr_fe_set_handlers(&mon->chr, monitor_can_read, monitor_read,
4615 monitor_event, NULL, mon, NULL, true);
4616 }
4617
4618 monitor_list_append(mon);
4619}
4620
4621void monitor_cleanup(void)
4622{
4623 Monitor *mon, *next;
4624
4625
4626
4627
4628
4629
4630
4631 if (mon_iothread) {
4632 iothread_stop(mon_iothread);
4633 }
4634
4635
4636 qemu_mutex_lock(&monitor_lock);
4637 QTAILQ_FOREACH_SAFE(mon, &mon_list, entry, next) {
4638 QTAILQ_REMOVE(&mon_list, mon, entry);
4639 monitor_flush(mon);
4640 monitor_data_destroy(mon);
4641 g_free(mon);
4642 }
4643 qemu_mutex_unlock(&monitor_lock);
4644
4645
4646 qemu_bh_delete(qmp_dispatcher_bh);
4647 qmp_dispatcher_bh = NULL;
4648 if (mon_iothread) {
4649 iothread_destroy(mon_iothread);
4650 mon_iothread = NULL;
4651 }
4652}
4653
4654QemuOptsList qemu_mon_opts = {
4655 .name = "mon",
4656 .implied_opt_name = "chardev",
4657 .head = QTAILQ_HEAD_INITIALIZER(qemu_mon_opts.head),
4658 .desc = {
4659 {
4660 .name = "mode",
4661 .type = QEMU_OPT_STRING,
4662 },{
4663 .name = "chardev",
4664 .type = QEMU_OPT_STRING,
4665 },{
4666 .name = "pretty",
4667 .type = QEMU_OPT_BOOL,
4668 },{
4669 .name = "x-oob",
4670 .type = QEMU_OPT_BOOL,
4671 },
4672 { }
4673 },
4674};
4675
4676#ifndef TARGET_I386
4677void qmp_rtc_reset_reinjection(Error **errp)
4678{
4679 error_setg(errp, QERR_FEATURE_DISABLED, "rtc-reset-reinjection");
4680}
4681
4682SevInfo *qmp_query_sev(Error **errp)
4683{
4684 error_setg(errp, QERR_FEATURE_DISABLED, "query-sev");
4685 return NULL;
4686}
4687
4688SevLaunchMeasureInfo *qmp_query_sev_launch_measure(Error **errp)
4689{
4690 error_setg(errp, QERR_FEATURE_DISABLED, "query-sev-launch-measure");
4691 return NULL;
4692}
4693
4694SevCapability *qmp_query_sev_capabilities(Error **errp)
4695{
4696 error_setg(errp, QERR_FEATURE_DISABLED, "query-sev-capabilities");
4697 return NULL;
4698}
4699#endif
4700
4701#ifndef TARGET_S390X
4702void qmp_dump_skeys(const char *filename, Error **errp)
4703{
4704 error_setg(errp, QERR_FEATURE_DISABLED, "dump-skeys");
4705}
4706#endif
4707
4708#ifndef TARGET_ARM
4709GICCapabilityList *qmp_query_gic_capabilities(Error **errp)
4710{
4711 error_setg(errp, QERR_FEATURE_DISABLED, "query-gic-capabilities");
4712 return NULL;
4713}
4714#endif
4715
4716HotpluggableCPUList *qmp_query_hotpluggable_cpus(Error **errp)
4717{
4718 MachineState *ms = MACHINE(qdev_get_machine());
4719 MachineClass *mc = MACHINE_GET_CLASS(ms);
4720
4721 if (!mc->has_hotpluggable_cpus) {
4722 error_setg(errp, QERR_FEATURE_DISABLED, "query-hotpluggable-cpus");
4723 return NULL;
4724 }
4725
4726 return machine_query_hotpluggable_cpus(ms);
4727}
4728