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