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