?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Introduce a default qmp session
[qemu/aliguori-queue.git] / monitor.c
blob0448a70c102dafafbbbef24480cfbcf78b46d016
1 /*
2 * QEMU monitor
3 *
4 * Copyright (c) 2003-2004 Fabrice Bellard
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24 #include <dirent.h>
25 #include "hw/hw.h"
26 #include "hw/qdev.h"
27 #include "hw/usb.h"
28 #include "hw/pcmcia.h"
29 #include "hw/pc.h"
30 #include "hw/pci.h"
31 #include "hw/watchdog.h"
32 #include "hw/loader.h"
33 #include "gdbstub.h"
34 #include "net.h"
35 #include "net/slirp.h"
36 #include "qemu-char.h"
37 #include "sysemu.h"
38 #include "monitor.h"
39 #include "readline.h"
40 #include "console.h"
41 #include "block.h"
42 #include "audio/audio.h"
43 #include "disas.h"
44 #include "balloon.h"
45 #include "qemu-timer.h"
46 #include "migration.h"
47 #include "kvm.h"
48 #include "acl.h"
49 #include "qint.h"
50 #include "qfloat.h"
51 #include "qlist.h"
52 #include "qdict.h"
53 #include "qbool.h"
54 #include "qstring.h"
55 #include "qerror.h"
56 #include "qjson.h"
57 #include "json-streamer.h"
58 #include "json-parser.h"
59 #include "osdep.h"
60
61 //#define DEBUG
62 //#define DEBUG_COMPLETION
63
64 /*
65 * Supported types:
66 *
67 * 'F' filename
68 * 'B' block device name
69 * 's' string (accept optional quote)
70 * 'O' option string of the form NAME=VALUE,...
71 * parsed according to QemuOptsList given by its name
72 * Example: 'device:O' uses qemu_device_opts.
73 * Restriction: only lists with empty desc are supported
74 * TODO lift the restriction
75 * 'i' 32 bit integer
76 * 'l' target long (32 or 64 bit)
77 * 'M' just like 'l', except in user mode the value is
78 * multiplied by 2^20 (think Mebibyte)
79 * 'b' double
80 * user mode accepts an optional G, g, M, m, K, k suffix,
81 * which multiplies the value by 2^30 for suffixes G and
82 * g, 2^20 for M and m, 2^10 for K and k
83 * 'T' double
84 * user mode accepts an optional ms, us, ns suffix,
85 * which divides the value by 1e3, 1e6, 1e9, respectively
86 * '/' optional gdb-like print format (like "/10x")
87 *
88 * '?' optional type (for all types, except '/')
89 * '.' other form of optional type (for 'i' and 'l')
90 * '-' optional parameter (eg. '-f')
91 *
92 */
93
94 typedef struct MonitorCompletionData MonitorCompletionData;
95 struct MonitorCompletionData {
96 Monitor *mon;
97 void (*user_print)(Monitor *mon, const QObject *data);
98 };
99
100 typedef struct mon_cmd_t {
101 const char *name;
102 const char *args_type;
103 const char *params;
104 const char *help;
105 void (*user_print)(Monitor *mon, const QObject *data);
106 union {
107 void (*info)(Monitor *mon);
108 void (*info_new)(Monitor *mon, QObject **ret_data);
109 int (*info_async)(Monitor *mon, MonitorCompletion *cb, void *opaque);
110 void (*cmd)(Monitor *mon, const QDict *qdict);
111 int (*cmd_new)(Monitor *mon, const QDict *params, QObject **ret_data);
112 int (*cmd_async)(Monitor *mon, const QDict *params,
113 MonitorCompletion *cb, void *opaque);
114 } mhandler;
115 int async;
116 } mon_cmd_t;
117
118 /* file descriptors passed via SCM_RIGHTS */
119 typedef struct mon_fd_t mon_fd_t;
120 struct mon_fd_t {
121 char *name;
122 int fd;
123 QLIST_ENTRY(mon_fd_t) next;
124 };
125
126 typedef struct MonitorControl {
127 QObject *id;
128 JSONMessageParser parser;
129 int command_mode;
130 } MonitorControl;
131
132 struct Monitor {
133 CharDriverState *chr;
134 int mux_out;
135 int reset_seen;
136 int flags;
137 int suspend_cnt;
138 uint8_t outbuf[1024];
139 int outbuf_index;
140 ReadLineState *rs;
141 MonitorControl *mc;
142 CPUState *mon_cpu;
143 BlockDriverCompletionFunc *password_completion_cb;
144 void *password_opaque;
145 #ifdef CONFIG_DEBUG_MONITOR
146 int print_calls_nr;
147 #endif
148 QError *error;
149 QLIST_HEAD(,mon_fd_t) fds;
150 QLIST_ENTRY(Monitor) entry;
151 };
152
153 #ifdef CONFIG_DEBUG_MONITOR
154 #define MON_DEBUG(fmt, ...) do { \
155 fprintf(stderr, "Monitor: "); \
156 fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
157
158 static inline void mon_print_count_inc(Monitor *mon)
159 {
160 mon->print_calls_nr++;
161 }
162
163 static inline void mon_print_count_init(Monitor *mon)
164 {
165 mon->print_calls_nr = 0;
166 }
167
168 static inline int mon_print_count_get(const Monitor *mon)
169 {
170 return mon->print_calls_nr;
171 }
172
173 #else /* !CONFIG_DEBUG_MONITOR */
174 #define MON_DEBUG(fmt, ...) do { } while (0)
175 static inline void mon_print_count_inc(Monitor *mon) { }
176 static inline void mon_print_count_init(Monitor *mon) { }
177 static inline int mon_print_count_get(const Monitor *mon) { return 0; }
178 #endif /* CONFIG_DEBUG_MONITOR */
179
180 static QLIST_HEAD(mon_list, Monitor) mon_list;
181
182 static const mon_cmd_t mon_cmds[];
183 static const mon_cmd_t info_cmds[];
184
185 Monitor *cur_mon;
186 Monitor *default_mon;
187
188 static void monitor_command_cb(Monitor *mon, const char *cmdline,
189 void *opaque);
190
191 static inline int qmp_cmd_mode(const Monitor *mon)
192 {
193 return (mon->mc ? mon->mc->command_mode : 0);
194 }
195
196 /* Return true if in control mode, false otherwise */
197 static inline int monitor_ctrl_mode(const Monitor *mon)
198 {
199 return (mon->flags & MONITOR_USE_CONTROL);
200 }
201
202 /* Return non-zero iff we have a current monitor, and it is in QMP mode. */
203 int monitor_cur_is_qmp(void)
204 {
205 return cur_mon && monitor_ctrl_mode(cur_mon);
206 }
207
208 static void monitor_read_command(Monitor *mon, int show_prompt)
209 {
210 if (!mon->rs)
211 return;
212
213 readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL);
214 if (show_prompt)
215 readline_show_prompt(mon->rs);
216 }
217
218 static int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
219 void *opaque)
220 {
221 if (monitor_ctrl_mode(mon)) {
222 qerror_report(QERR_MISSING_PARAMETER, "password");
223 return -EINVAL;
224 } else if (mon->rs) {
225 readline_start(mon->rs, "Password: ", 1, readline_func, opaque);
226 /* prompt is printed on return from the command handler */
227 return 0;
228 } else {
229 monitor_printf(mon, "terminal does not support password prompting\n");
230 return -ENOTTY;
231 }
232 }
233
234 void monitor_flush(Monitor *mon)
235 {
236 if (mon && mon->outbuf_index != 0 && !mon->mux_out) {
237 qemu_chr_write(mon->chr, mon->outbuf, mon->outbuf_index);
238 mon->outbuf_index = 0;
239 }
240 }
241
242 /* flush at every end of line or if the buffer is full */
243 static void monitor_puts(Monitor *mon, const char *str)
244 {
245 char c;
246
247 for(;;) {
248 c = *str++;
249 if (c == '\0')
250 break;
251 if (c == '\n')
252 mon->outbuf[mon->outbuf_index++] = '\r';
253 mon->outbuf[mon->outbuf_index++] = c;
254 if (mon->outbuf_index >= (sizeof(mon->outbuf) - 1)
255 || c == '\n')
256 monitor_flush(mon);
257 }
258 }
259
260 void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
261 {
262 char buf[4096];
263
264 if (!mon)
265 return;
266
267 mon_print_count_inc(mon);
268
269 if (monitor_ctrl_mode(mon)) {
270 return;
271 }
272
273 vsnprintf(buf, sizeof(buf), fmt, ap);
274 monitor_puts(mon, buf);
275 }
276
277 void monitor_printf(Monitor *mon, const char *fmt, ...)
278 {
279 va_list ap;
280 va_start(ap, fmt);
281 monitor_vprintf(mon, fmt, ap);
282 va_end(ap);
283 }
284
285 void monitor_print_filename(Monitor *mon, const char *filename)
286 {
287 int i;
288
289 for (i = 0; filename[i]; i++) {
290 switch (filename[i]) {
291 case ' ':
292 case '"':
293 case '\\':
294 monitor_printf(mon, "\\%c", filename[i]);
295 break;
296 case '\t':
297 monitor_printf(mon, "\\t");
298 break;
299 case '\r':
300 monitor_printf(mon, "\\r");
301 break;
302 case '\n':
303 monitor_printf(mon, "\\n");
304 break;
305 default:
306 monitor_printf(mon, "%c", filename[i]);
307 break;
308 }
309 }
310 }
311
312 static int monitor_fprintf(FILE *stream, const char *fmt, ...)
313 {
314 va_list ap;
315 va_start(ap, fmt);
316 monitor_vprintf((Monitor *)stream, fmt, ap);
317 va_end(ap);
318 return 0;
319 }
320
321 static void monitor_user_noop(Monitor *mon, const QObject *data) { }
322
323 static inline int monitor_handler_ported(const mon_cmd_t *cmd)
324 {
325 return cmd->user_print != NULL;
326 }
327
328 static inline bool monitor_handler_is_async(const mon_cmd_t *cmd)
329 {
330 return cmd->async != 0;
331 }
332
333 static inline int monitor_has_error(const Monitor *mon)
334 {
335 return mon->error != NULL;
336 }
337
338 static void monitor_json_emitter(Monitor *mon, const QObject *data)
339 {
340 QString *json;
341
342 json = qobject_to_json(data);
343 assert(json != NULL);
344
345 qstring_append_chr(json, '\n');
346 monitor_puts(mon, qstring_get_str(json));
347
348 QDECREF(json);
349 }
350
351 static void monitor_protocol_emitter(Monitor *mon, QObject *data)
352 {
353 QDict *qmp;
354
355 qmp = qdict_new();
356
357 if (!monitor_has_error(mon)) {
358 /* success response */
359 if (data) {
360 qobject_incref(data);
361 qdict_put_obj(qmp, "return", data);
362 } else {
363 /* return an empty QDict by default */
364 qdict_put(qmp, "return", qdict_new());
365 }
366 } else {
367 /* error response */
368 qdict_put(mon->error->error, "desc", qerror_human(mon->error));
369 qdict_put(qmp, "error", mon->error->error);
370 QINCREF(mon->error->error);
371 QDECREF(mon->error);
372 mon->error = NULL;
373 }
374
375 if (mon->mc->id) {
376 qdict_put_obj(qmp, "id", mon->mc->id);
377 mon->mc->id = NULL;
378 }
379
380 monitor_json_emitter(mon, QOBJECT(qmp));
381 QDECREF(qmp);
382 }
383
384 static void timestamp_put(QDict *qdict)
385 {
386 int err;
387 QObject *obj;
388 qemu_timeval tv;
389
390 err = qemu_gettimeofday(&tv);
391 if (err < 0)
392 return;
393
394 obj = qobject_from_jsonf("{ 'seconds': %" PRId64 ", "
395 "'microseconds': %" PRId64 " }",
396 (int64_t) tv.tv_sec, (int64_t) tv.tv_usec);
397 qdict_put_obj(qdict, "timestamp", obj);
398 }
399
400 /**
401 * monitor_protocol_event(): Generate a Monitor event
402 *
403 * Event-specific data can be emitted through the (optional) 'data' parameter.
404 */
405 void monitor_protocol_event(MonitorEvent event, QObject *data)
406 {
407 QDict *qmp;
408 const char *event_name;
409 Monitor *mon;
410
411 assert(event < QEVENT_MAX);
412
413 switch (event) {
414 case QEVENT_SHUTDOWN:
415 event_name = "SHUTDOWN";
416 break;
417 case QEVENT_RESET:
418 event_name = "RESET";
419 break;
420 case QEVENT_POWERDOWN:
421 event_name = "POWERDOWN";
422 break;
423 case QEVENT_STOP:
424 event_name = "STOP";
425 break;
426 case QEVENT_VNC_CONNECTED:
427 event_name = "VNC_CONNECTED";
428 break;
429 case QEVENT_VNC_INITIALIZED:
430 event_name = "VNC_INITIALIZED";
431 break;
432 case QEVENT_VNC_DISCONNECTED:
433 event_name = "VNC_DISCONNECTED";
434 break;
435 case QEVENT_BLOCK_IO_ERROR:
436 event_name = "BLOCK_IO_ERROR";
437 break;
438 case QEVENT_RTC_CHANGE:
439 event_name = "RTC_CHANGE";
440 break;
441 case QEVENT_WATCHDOG:
442 event_name = "WATCHDOG";
443 break;
444 default:
445 abort();
446 break;
447 }
448
449 qmp = qdict_new();
450 timestamp_put(qmp);
451 qdict_put(qmp, "event", qstring_from_str(event_name));
452 if (data) {
453 qobject_incref(data);
454 qdict_put_obj(qmp, "data", data);
455 }
456
457 QLIST_FOREACH(mon, &mon_list, entry) {
458 if (monitor_ctrl_mode(mon) && qmp_cmd_mode(mon)) {
459 monitor_json_emitter(mon, QOBJECT(qmp));
460 }
461 }
462 QDECREF(qmp);
463 }
464
465 static int do_qmp_capabilities(Monitor *mon, const QDict *params,
466 QObject **ret_data)
467 {
468 /* Will setup QMP capabilities in the future */
469 if (monitor_ctrl_mode(mon)) {
470 mon->mc->command_mode = 1;
471 }
472
473 return 0;
474 }
475
476 static int compare_cmd(const char *name, const char *list)
477 {
478 const char *p, *pstart;
479 int len;
480 len = strlen(name);
481 p = list;
482 for(;;) {
483 pstart = p;
484 p = strchr(p, '|');
485 if (!p)
486 p = pstart + strlen(pstart);
487 if ((p - pstart) == len && !memcmp(pstart, name, len))
488 return 1;
489 if (*p == '\0')
490 break;
491 p++;
492 }
493 return 0;
494 }
495
496 static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
497 const char *prefix, const char *name)
498 {
499 const mon_cmd_t *cmd;
500
501 for(cmd = cmds; cmd->name != NULL; cmd++) {
502 if (!name || !strcmp(name, cmd->name))
503 monitor_printf(mon, "%s%s %s -- %s\n", prefix, cmd->name,
504 cmd->params, cmd->help);
505 }
506 }
507
508 static void help_cmd(Monitor *mon, const char *name)
509 {
510 if (name && !strcmp(name, "info")) {
511 help_cmd_dump(mon, info_cmds, "info ", NULL);
512 } else {
513 help_cmd_dump(mon, mon_cmds, "", name);
514 if (name && !strcmp(name, "log")) {
515 const CPULogItem *item;
516 monitor_printf(mon, "Log items (comma separated):\n");
517 monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");
518 for(item = cpu_log_items; item->mask != 0; item++) {
519 monitor_printf(mon, "%-10s %s\n", item->name, item->help);
520 }
521 }
522 }
523 }
524
525 static void do_help_cmd(Monitor *mon, const QDict *qdict)
526 {
527 help_cmd(mon, qdict_get_try_str(qdict, "name"));
528 }
529
530 static void do_commit(Monitor *mon, const QDict *qdict)
531 {
532 int all_devices;
533 DriveInfo *dinfo;
534 const char *device = qdict_get_str(qdict, "device");
535
536 all_devices = !strcmp(device, "all");
537 QTAILQ_FOREACH(dinfo, &drives, next) {
538 if (!all_devices)
539 if (strcmp(bdrv_get_device_name(dinfo->bdrv), device))
540 continue;
541 bdrv_commit(dinfo->bdrv);
542 }
543 }
544
545 static void user_monitor_complete(void *opaque, QObject *ret_data)
546 {
547 MonitorCompletionData *data = (MonitorCompletionData *)opaque;
548
549 if (ret_data) {
550 data->user_print(data->mon, ret_data);
551 }
552 monitor_resume(data->mon);
553 qemu_free(data);
554 }
555
556 static void qmp_monitor_complete(void *opaque, QObject *ret_data)
557 {
558 monitor_protocol_emitter(opaque, ret_data);
559 }
560
561 static void qmp_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,
562 const QDict *params)
563 {
564 cmd->mhandler.cmd_async(mon, params, qmp_monitor_complete, mon);
565 }
566
567 static void qmp_async_info_handler(Monitor *mon, const mon_cmd_t *cmd)
568 {
569 cmd->mhandler.info_async(mon, qmp_monitor_complete, mon);
570 }
571
572 static void user_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,
573 const QDict *params)
574 {
575 int ret;
576
577 MonitorCompletionData *cb_data = qemu_malloc(sizeof(*cb_data));
578 cb_data->mon = mon;
579 cb_data->user_print = cmd->user_print;
580 monitor_suspend(mon);
581 ret = cmd->mhandler.cmd_async(mon, params,
582 user_monitor_complete, cb_data);
583 if (ret < 0) {
584 monitor_resume(mon);
585 qemu_free(cb_data);
586 }
587 }
588
589 static void user_async_info_handler(Monitor *mon, const mon_cmd_t *cmd)
590 {
591 int ret;
592
593 MonitorCompletionData *cb_data = qemu_malloc(sizeof(*cb_data));
594 cb_data->mon = mon;
595 cb_data->user_print = cmd->user_print;
596 monitor_suspend(mon);
597 ret = cmd->mhandler.info_async(mon, user_monitor_complete, cb_data);
598 if (ret < 0) {
599 monitor_resume(mon);
600 qemu_free(cb_data);
601 }
602 }
603
604 static int do_info(Monitor *mon, const QDict *qdict, QObject **ret_data)
605 {
606 const mon_cmd_t *cmd;
607 const char *item = qdict_get_try_str(qdict, "item");
608
609 if (!item) {
610 assert(monitor_ctrl_mode(mon) == 0);
611 goto help;
612 }
613
614 for (cmd = info_cmds; cmd->name != NULL; cmd++) {
615 if (compare_cmd(item, cmd->name))
616 break;
617 }
618
619 if (cmd->name == NULL) {
620 if (monitor_ctrl_mode(mon)) {
621 qerror_report(QERR_COMMAND_NOT_FOUND, item);
622 return -1;
623 }
624 goto help;
625 }
626
627 if (monitor_handler_is_async(cmd)) {
628 if (monitor_ctrl_mode(mon)) {
629 qmp_async_info_handler(mon, cmd);
630 } else {
631 user_async_info_handler(mon, cmd);
632 }
633 /*
634 * Indicate that this command is asynchronous and will not return any
635 * data (not even empty). Instead, the data will be returned via a
636 * completion callback.
637 */
638 *ret_data = qobject_from_jsonf("{ '__mon_async': 'return' }");
639 } else if (monitor_handler_ported(cmd)) {
640 cmd->mhandler.info_new(mon, ret_data);
641
642 if (!monitor_ctrl_mode(mon)) {
643 /*
644 * User Protocol function is called here, Monitor Protocol is
645 * handled by monitor_call_handler()
646 */
647 if (*ret_data)
648 cmd->user_print(mon, *ret_data);
649 }
650 } else {
651 if (monitor_ctrl_mode(mon)) {
652 /* handler not converted yet */
653 qerror_report(QERR_COMMAND_NOT_FOUND, item);
654 return -1;
655 } else {
656 cmd->mhandler.info(mon);
657 }
658 }
659
660 return 0;
661
662 help:
663 help_cmd(mon, "info");
664 return 0;
665 }
666
667 static void do_info_version_print(Monitor *mon, const QObject *data)
668 {
669 QDict *qdict;
670
671 qdict = qobject_to_qdict(data);
672
673 monitor_printf(mon, "%s%s\n", qdict_get_str(qdict, "qemu"),
674 qdict_get_str(qdict, "package"));
675 }
676
677 /**
678 * do_info_version(): Show QEMU version
679 *
680 * Return a QDict with the following information:
681 *
682 * - "qemu": QEMU's version
683 * - "package": package's version
684 *
685 * Example:
686 *
687 * { "qemu": "0.11.50", "package": "" }
688 */
689 static void do_info_version(Monitor *mon, QObject **ret_data)
690 {
691 *ret_data = qobject_from_jsonf("{ 'qemu': %s, 'package': %s }",
692 QEMU_VERSION, QEMU_PKGVERSION);
693 }
694
695 static void do_info_name_print(Monitor *mon, const QObject *data)
696 {
697 QDict *qdict;
698
699 qdict = qobject_to_qdict(data);
700 if (qdict_size(qdict) == 0) {
701 return;
702 }
703
704 monitor_printf(mon, "%s\n", qdict_get_str(qdict, "name"));
705 }
706
707 /**
708 * do_info_name(): Show VM name
709 *
710 * Return a QDict with the following information:
711 *
712 * - "name": VM's name (optional)
713 *
714 * Example:
715 *
716 * { "name": "qemu-name" }
717 */
718 static void do_info_name(Monitor *mon, QObject **ret_data)
719 {
720 *ret_data = qemu_name ? qobject_from_jsonf("{'name': %s }", qemu_name) :
721 qobject_from_jsonf("{}");
722 }
723
724 static QObject *get_cmd_dict(const char *name)
725 {
726 const char *p;
727
728 /* Remove '|' from some commands */
729 p = strchr(name, '|');
730 if (p) {
731 p++;
732 } else {
733 p = name;
734 }
735
736 return qobject_from_jsonf("{ 'name': %s }", p);
737 }
738
739 /**
740 * do_info_commands(): List QMP available commands
741 *
742 * Each command is represented by a QDict, the returned QObject is a QList
743 * of all commands.
744 *
745 * The QDict contains:
746 *
747 * - "name": command's name
748 *
749 * Example:
750 *
751 * { [ { "name": "query-balloon" }, { "name": "system_powerdown" } ] }
752 */
753 static void do_info_commands(Monitor *mon, QObject **ret_data)
754 {
755 QList *cmd_list;
756 const mon_cmd_t *cmd;
757
758 cmd_list = qlist_new();
759
760 for (cmd = mon_cmds; cmd->name != NULL; cmd++) {
761 if (monitor_handler_ported(cmd) && !compare_cmd(cmd->name, "info")) {
762 qlist_append_obj(cmd_list, get_cmd_dict(cmd->name));
763 }
764 }
765
766 for (cmd = info_cmds; cmd->name != NULL; cmd++) {
767 if (monitor_handler_ported(cmd)) {
768 char buf[128];
769 snprintf(buf, sizeof(buf), "query-%s", cmd->name);
770 qlist_append_obj(cmd_list, get_cmd_dict(buf));
771 }
772 }
773
774 *ret_data = QOBJECT(cmd_list);
775 }
776
777 #if defined(TARGET_I386)
778 static void do_info_hpet_print(Monitor *mon, const QObject *data)
779 {
780 monitor_printf(mon, "HPET is %s by QEMU\n",
781 qdict_get_bool(qobject_to_qdict(data), "enabled") ?
782 "enabled" : "disabled");
783 }
784
785 /**
786 * do_info_hpet(): Show HPET state
787 *
788 * Return a QDict with the following information:
789 *
790 * - "enabled": true if hpet if enabled, false otherwise
791 *
792 * Example:
793 *
794 * { "enabled": true }
795 */
796 static void do_info_hpet(Monitor *mon, QObject **ret_data)
797 {
798 *ret_data = qobject_from_jsonf("{ 'enabled': %i }", !no_hpet);
799 }
800 #endif
801
802 static void do_info_uuid_print(Monitor *mon, const QObject *data)
803 {
804 monitor_printf(mon, "%s\n", qdict_get_str(qobject_to_qdict(data), "UUID"));
805 }
806
807 /**
808 * do_info_uuid(): Show VM UUID
809 *
810 * Return a QDict with the following information:
811 *
812 * - "UUID": Universally Unique Identifier
813 *
814 * Example:
815 *
816 * { "UUID": "550e8400-e29b-41d4-a716-446655440000" }
817 */
818 static void do_info_uuid(Monitor *mon, QObject **ret_data)
819 {
820 char uuid[64];
821
822 snprintf(uuid, sizeof(uuid), UUID_FMT, qemu_uuid[0], qemu_uuid[1],
823 qemu_uuid[2], qemu_uuid[3], qemu_uuid[4], qemu_uuid[5],
824 qemu_uuid[6], qemu_uuid[7], qemu_uuid[8], qemu_uuid[9],
825 qemu_uuid[10], qemu_uuid[11], qemu_uuid[12], qemu_uuid[13],
826 qemu_uuid[14], qemu_uuid[15]);
827 *ret_data = qobject_from_jsonf("{ 'UUID': %s }", uuid);
828 }
829
830 /* get the current CPU defined by the user */
831 static int mon_set_cpu(int cpu_index)
832 {
833 CPUState *env;
834
835 for(env = first_cpu; env != NULL; env = env->next_cpu) {
836 if (env->cpu_index == cpu_index) {
837 cur_mon->mon_cpu = env;
838 return 0;
839 }
840 }
841 return -1;
842 }
843
844 static CPUState *mon_get_cpu(void)
845 {
846 if (!cur_mon->mon_cpu) {
847 mon_set_cpu(0);
848 }
849 cpu_synchronize_state(cur_mon->mon_cpu);
850 return cur_mon->mon_cpu;
851 }
852
853 static void do_info_registers(Monitor *mon)
854 {
855 CPUState *env;
856 env = mon_get_cpu();
857 #ifdef TARGET_I386
858 cpu_dump_state(env, (FILE *)mon, monitor_fprintf,
859 X86_DUMP_FPU);
860 #else
861 cpu_dump_state(env, (FILE *)mon, monitor_fprintf,
862 0);
863 #endif
864 }
865
866 static void print_cpu_iter(QObject *obj, void *opaque)
867 {
868 QDict *cpu;
869 int active = ' ';
870 Monitor *mon = opaque;
871
872 assert(qobject_type(obj) == QTYPE_QDICT);
873 cpu = qobject_to_qdict(obj);
874
875 if (qdict_get_bool(cpu, "current")) {
876 active = '*';
877 }
878
879 monitor_printf(mon, "%c CPU #%d: ", active, (int)qdict_get_int(cpu, "CPU"));
880
881 #if defined(TARGET_I386)
882 monitor_printf(mon, "pc=0x" TARGET_FMT_lx,
883 (target_ulong) qdict_get_int(cpu, "pc"));
884 #elif defined(TARGET_PPC)
885 monitor_printf(mon, "nip=0x" TARGET_FMT_lx,
886 (target_long) qdict_get_int(cpu, "nip"));
887 #elif defined(TARGET_SPARC)
888 monitor_printf(mon, "pc=0x " TARGET_FMT_lx,
889 (target_long) qdict_get_int(cpu, "pc"));
890 monitor_printf(mon, "npc=0x" TARGET_FMT_lx,
891 (target_long) qdict_get_int(cpu, "npc"));
892 #elif defined(TARGET_MIPS)
893 monitor_printf(mon, "PC=0x" TARGET_FMT_lx,
894 (target_long) qdict_get_int(cpu, "PC"));
895 #endif
896
897 if (qdict_get_bool(cpu, "halted")) {
898 monitor_printf(mon, " (halted)");
899 }
900
901 monitor_printf(mon, "\n");
902 }
903
904 static void monitor_print_cpus(Monitor *mon, const QObject *data)
905 {
906 QList *cpu_list;
907
908 assert(qobject_type(data) == QTYPE_QLIST);
909 cpu_list = qobject_to_qlist(data);
910 qlist_iter(cpu_list, print_cpu_iter, mon);
911 }
912
913 /**
914 * do_info_cpus(): Show CPU information
915 *
916 * Return a QList. Each CPU is represented by a QDict, which contains:
917 *
918 * - "cpu": CPU index
919 * - "current": true if this is the current CPU, false otherwise
920 * - "halted": true if the cpu is halted, false otherwise
921 * - Current program counter. The key's name depends on the architecture:
922 * "pc": i386/x86)64
923 * "nip": PPC
924 * "pc" and "npc": sparc
925 * "PC": mips
926 *
927 * Example:
928 *
929 * [ { "CPU": 0, "current": true, "halted": false, "pc": 3227107138 },
930 * { "CPU": 1, "current": false, "halted": true, "pc": 7108165 } ]
931 */
932 static void do_info_cpus(Monitor *mon, QObject **ret_data)
933 {
934 CPUState *env;
935 QList *cpu_list;
936
937 cpu_list = qlist_new();
938
939 /* just to set the default cpu if not already done */
940 mon_get_cpu();
941
942 for(env = first_cpu; env != NULL; env = env->next_cpu) {
943 QDict *cpu;
944 QObject *obj;
945
946 cpu_synchronize_state(env);
947
948 obj = qobject_from_jsonf("{ 'CPU': %d, 'current': %i, 'halted': %i }",
949 env->cpu_index, env == mon->mon_cpu,
950 env->halted);
951
952 cpu = qobject_to_qdict(obj);
953
954 #if defined(TARGET_I386)
955 qdict_put(cpu, "pc", qint_from_int(env->eip + env->segs[R_CS].base));
956 #elif defined(TARGET_PPC)
957 qdict_put(cpu, "nip", qint_from_int(env->nip));
958 #elif defined(TARGET_SPARC)
959 qdict_put(cpu, "pc", qint_from_int(env->pc));
960 qdict_put(cpu, "npc", qint_from_int(env->npc));
961 #elif defined(TARGET_MIPS)
962 qdict_put(cpu, "PC", qint_from_int(env->active_tc.PC));
963 #endif
964
965 qlist_append(cpu_list, cpu);
966 }
967
968 *ret_data = QOBJECT(cpu_list);
969 }
970
971 static int do_cpu_set(Monitor *mon, const QDict *qdict, QObject **ret_data)
972 {
973 int index = qdict_get_int(qdict, "index");
974 if (mon_set_cpu(index) < 0) {
975 qerror_report(QERR_INVALID_PARAMETER, "index");
976 return -1;
977 }
978 return 0;
979 }
980
981 static void do_info_jit(Monitor *mon)
982 {
983 dump_exec_info((FILE *)mon, monitor_fprintf);
984 }
985
986 static void do_info_history(Monitor *mon)
987 {
988 int i;
989 const char *str;
990
991 if (!mon->rs)
992 return;
993 i = 0;
994 for(;;) {
995 str = readline_get_history(mon->rs, i);
996 if (!str)
997 break;
998 monitor_printf(mon, "%d: '%s'\n", i, str);
999 i++;
1000 }
1001 }
1002
1003 #if defined(TARGET_PPC)
1004 /* XXX: not implemented in other targets */
1005 static void do_info_cpu_stats(Monitor *mon)
1006 {
1007 CPUState *env;
1008
1009 env = mon_get_cpu();
1010 cpu_dump_statistics(env, (FILE *)mon, &monitor_fprintf, 0);
1011 }
1012 #endif
1013
1014 /**
1015 * do_quit(): Quit QEMU execution
1016 */
1017 static int do_quit(Monitor *mon, const QDict *qdict, QObject **ret_data)
1018 {
1019 exit(0);
1020 return 0;
1021 }
1022
1023 static int eject_device(Monitor *mon, BlockDriverState *bs, int force)
1024 {
1025 if (bdrv_is_inserted(bs)) {
1026 if (!force) {
1027 if (!bdrv_is_removable(bs)) {
1028 qerror_report(QERR_DEVICE_NOT_REMOVABLE,
1029 bdrv_get_device_name(bs));
1030 return -1;
1031 }
1032 if (bdrv_is_locked(bs)) {
1033 qerror_report(QERR_DEVICE_LOCKED, bdrv_get_device_name(bs));
1034 return -1;
1035 }
1036 }
1037 bdrv_close(bs);
1038 }
1039 return 0;
1040 }
1041
1042 static int do_eject(Monitor *mon, const QDict *qdict, QObject **ret_data)
1043 {
1044 BlockDriverState *bs;
1045 int force = qdict_get_int(qdict, "force");
1046 const char *filename = qdict_get_str(qdict, "device");
1047
1048 bs = bdrv_find(filename);
1049 if (!bs) {
1050 qerror_report(QERR_DEVICE_NOT_FOUND, filename);
1051 return -1;
1052 }
1053 return eject_device(mon, bs, force);
1054 }
1055
1056 static int do_block_set_passwd(Monitor *mon, const QDict *qdict,
1057 QObject **ret_data)
1058 {
1059 BlockDriverState *bs;
1060 int err;
1061
1062 bs = bdrv_find(qdict_get_str(qdict, "device"));
1063 if (!bs) {
1064 qerror_report(QERR_DEVICE_NOT_FOUND, qdict_get_str(qdict, "device"));
1065 return -1;
1066 }
1067
1068 err = bdrv_set_key(bs, qdict_get_str(qdict, "password"));
1069 if (err == -EINVAL) {
1070 qerror_report(QERR_DEVICE_NOT_ENCRYPTED, bdrv_get_device_name(bs));
1071 return -1;
1072 } else if (err < 0) {
1073 qerror_report(QERR_INVALID_PASSWORD);
1074 return -1;
1075 }
1076
1077 return 0;
1078 }
1079
1080 static int do_change_block(Monitor *mon, const char *device,
1081 const char *filename, const char *fmt)
1082 {
1083 BlockDriverState *bs;
1084 BlockDriver *drv = NULL;
1085
1086 bs = bdrv_find(device);
1087 if (!bs) {
1088 qerror_report(QERR_DEVICE_NOT_FOUND, device);
1089 return -1;
1090 }
1091 if (fmt) {
1092 drv = bdrv_find_whitelisted_format(fmt);
1093 if (!drv) {
1094 qerror_report(QERR_INVALID_BLOCK_FORMAT, fmt);
1095 return -1;
1096 }
1097 }
1098 if (eject_device(mon, bs, 0) < 0) {
1099 return -1;
1100 }
1101 if (bdrv_open2(bs, filename, BDRV_O_RDWR, drv) < 0) {
1102 return -1;
1103 }
1104 return monitor_read_bdrv_key_start(mon, bs, NULL, NULL);
1105 }
1106
1107 static int change_vnc_password(const char *password)
1108 {
1109 if (vnc_display_password(NULL, password) < 0) {
1110 qerror_report(QERR_SET_PASSWD_FAILED);
1111 return -1;
1112 }
1113
1114 return 0;
1115 }
1116
1117 static void change_vnc_password_cb(Monitor *mon, const char *password,
1118 void *opaque)
1119 {
1120 change_vnc_password(password);
1121 monitor_read_command(mon, 1);
1122 }
1123
1124 static int do_change_vnc(Monitor *mon, const char *target, const char *arg)
1125 {
1126 if (strcmp(target, "passwd") == 0 ||
1127 strcmp(target, "password") == 0) {
1128 if (arg) {
1129 char password[9];
1130 strncpy(password, arg, sizeof(password));
1131 password[sizeof(password) - 1] = '\0';
1132 return change_vnc_password(password);
1133 } else {
1134 return monitor_read_password(mon, change_vnc_password_cb, NULL);
1135 }
1136 } else {
1137 if (vnc_display_open(NULL, target) < 0) {
1138 qerror_report(QERR_VNC_SERVER_FAILED, target);
1139 return -1;
1140 }
1141 }
1142
1143 return 0;
1144 }
1145
1146 /**
1147 * do_change(): Change a removable medium, or VNC configuration
1148 */
1149 static int do_change(Monitor *mon, const QDict *qdict, QObject **ret_data)
1150 {
1151 const char *device = qdict_get_str(qdict, "device");
1152 const char *target = qdict_get_str(qdict, "target");
1153 const char *arg = qdict_get_try_str(qdict, "arg");
1154 int ret;
1155
1156 if (strcmp(device, "vnc") == 0) {
1157 ret = do_change_vnc(mon, target, arg);
1158 } else {
1159 ret = do_change_block(mon, device, target, arg);
1160 }
1161
1162 return ret;
1163 }
1164
1165 static void do_screen_dump(Monitor *mon, const QDict *qdict)
1166 {
1167 vga_hw_screen_dump(qdict_get_str(qdict, "filename"));
1168 }
1169
1170 static void do_logfile(Monitor *mon, const QDict *qdict)
1171 {
1172 cpu_set_log_filename(qdict_get_str(qdict, "filename"));
1173 }
1174
1175 static void do_log(Monitor *mon, const QDict *qdict)
1176 {
1177 int mask;
1178 const char *items = qdict_get_str(qdict, "items");
1179
1180 if (!strcmp(items, "none")) {
1181 mask = 0;
1182 } else {
1183 mask = cpu_str_to_log_mask(items);
1184 if (!mask) {
1185 help_cmd(mon, "log");
1186 return;
1187 }
1188 }
1189 cpu_set_log(mask);
1190 }
1191
1192 static void do_singlestep(Monitor *mon, const QDict *qdict)
1193 {
1194 const char *option = qdict_get_try_str(qdict, "option");
1195 if (!option || !strcmp(option, "on")) {
1196 singlestep = 1;
1197 } else if (!strcmp(option, "off")) {
1198 singlestep = 0;
1199 } else {
1200 monitor_printf(mon, "unexpected option %s\n", option);
1201 }
1202 }
1203
1204 /**
1205 * do_stop(): Stop VM execution
1206 */
1207 static int do_stop(Monitor *mon, const QDict *qdict, QObject **ret_data)
1208 {
1209 vm_stop(EXCP_INTERRUPT);
1210 return 0;
1211 }
1212
1213 static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs);
1214
1215 struct bdrv_iterate_context {
1216 Monitor *mon;
1217 int err;
1218 };
1219
1220 /**
1221 * do_cont(): Resume emulation.
1222 */
1223 static int do_cont(Monitor *mon, const QDict *qdict, QObject **ret_data)
1224 {
1225 struct bdrv_iterate_context context = { mon, 0 };
1226
1227 bdrv_iterate(encrypted_bdrv_it, &context);
1228 /* only resume the vm if all keys are set and valid */
1229 if (!context.err) {
1230 vm_start();
1231 return 0;
1232 } else {
1233 return -1;
1234 }
1235 }
1236
1237 static void bdrv_key_cb(void *opaque, int err)
1238 {
1239 Monitor *mon = opaque;
1240
1241 /* another key was set successfully, retry to continue */
1242 if (!err)
1243 do_cont(mon, NULL, NULL);
1244 }
1245
1246 static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs)
1247 {
1248 struct bdrv_iterate_context *context = opaque;
1249
1250 if (!context->err && bdrv_key_required(bs)) {
1251 context->err = -EBUSY;
1252 monitor_read_bdrv_key_start(context->mon, bs, bdrv_key_cb,
1253 context->mon);
1254 }
1255 }
1256
1257 static void do_gdbserver(Monitor *mon, const QDict *qdict)
1258 {
1259 const char *device = qdict_get_try_str(qdict, "device");
1260 if (!device)
1261 device = "tcp::" DEFAULT_GDBSTUB_PORT;
1262 if (gdbserver_start(device) < 0) {
1263 monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
1264 device);
1265 } else if (strcmp(device, "none") == 0) {
1266 monitor_printf(mon, "Disabled gdbserver\n");
1267 } else {
1268 monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
1269 device);
1270 }
1271 }
1272
1273 static void do_watchdog_action(Monitor *mon, const QDict *qdict)
1274 {
1275 const char *action = qdict_get_str(qdict, "action");
1276 if (select_watchdog_action(action) == -1) {
1277 monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
1278 }
1279 }
1280
1281 static void monitor_printc(Monitor *mon, int c)
1282 {
1283 monitor_printf(mon, "'");
1284 switch(c) {
1285 case '\'':
1286 monitor_printf(mon, "\\'");
1287 break;
1288 case '\\':
1289 monitor_printf(mon, "\\\\");
1290 break;
1291 case '\n':
1292 monitor_printf(mon, "\\n");
1293 break;
1294 case '\r':
1295 monitor_printf(mon, "\\r");
1296 break;
1297 default:
1298 if (c >= 32 && c <= 126) {
1299 monitor_printf(mon, "%c", c);
1300 } else {
1301 monitor_printf(mon, "\\x%02x", c);
1302 }
1303 break;
1304 }
1305 monitor_printf(mon, "'");
1306 }
1307
1308 static void memory_dump(Monitor *mon, int count, int format, int wsize,
1309 target_phys_addr_t addr, int is_physical)
1310 {
1311 CPUState *env;
1312 int l, line_size, i, max_digits, len;
1313 uint8_t buf[16];
1314 uint64_t v;
1315
1316 if (format == 'i') {
1317 int flags;
1318 flags = 0;
1319 env = mon_get_cpu();
1320 #ifdef TARGET_I386
1321 if (wsize == 2) {
1322 flags = 1;
1323 } else if (wsize == 4) {
1324 flags = 0;
1325 } else {
1326 /* as default we use the current CS size */
1327 flags = 0;
1328 if (env) {
1329 #ifdef TARGET_X86_64
1330 if ((env->efer & MSR_EFER_LMA) &&
1331 (env->segs[R_CS].flags & DESC_L_MASK))
1332 flags = 2;
1333 else
1334 #endif
1335 if (!(env->segs[R_CS].flags & DESC_B_MASK))
1336 flags = 1;
1337 }
1338 }
1339 #endif
1340 monitor_disas(mon, env, addr, count, is_physical, flags);
1341 return;
1342 }
1343
1344 len = wsize * count;
1345 if (wsize == 1)
1346 line_size = 8;
1347 else
1348 line_size = 16;
1349 max_digits = 0;
1350
1351 switch(format) {
1352 case 'o':
1353 max_digits = (wsize * 8 + 2) / 3;
1354 break;
1355 default:
1356 case 'x':
1357 max_digits = (wsize * 8) / 4;
1358 break;
1359 case 'u':
1360 case 'd':
1361 max_digits = (wsize * 8 * 10 + 32) / 33;
1362 break;
1363 case 'c':
1364 wsize = 1;
1365 break;
1366 }
1367
1368 while (len > 0) {
1369 if (is_physical)
1370 monitor_printf(mon, TARGET_FMT_plx ":", addr);
1371 else
1372 monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
1373 l = len;
1374 if (l > line_size)
1375 l = line_size;
1376 if (is_physical) {
1377 cpu_physical_memory_rw(addr, buf, l, 0);
1378 } else {
1379 env = mon_get_cpu();
1380 if (cpu_memory_rw_debug(env, addr, buf, l, 0) < 0) {
1381 monitor_printf(mon, " Cannot access memory\n");
1382 break;
1383 }
1384 }
1385 i = 0;
1386 while (i < l) {
1387 switch(wsize) {
1388 default:
1389 case 1:
1390 v = ldub_raw(buf + i);
1391 break;
1392 case 2:
1393 v = lduw_raw(buf + i);
1394 break;
1395 case 4:
1396 v = (uint32_t)ldl_raw(buf + i);
1397 break;
1398 case 8:
1399 v = ldq_raw(buf + i);
1400 break;
1401 }
1402 monitor_printf(mon, " ");
1403 switch(format) {
1404 case 'o':
1405 monitor_printf(mon, "%#*" PRIo64, max_digits, v);
1406 break;
1407 case 'x':
1408 monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
1409 break;
1410 case 'u':
1411 monitor_printf(mon, "%*" PRIu64, max_digits, v);
1412 break;
1413 case 'd':
1414 monitor_printf(mon, "%*" PRId64, max_digits, v);
1415 break;
1416 case 'c':
1417 monitor_printc(mon, v);
1418 break;
1419 }
1420 i += wsize;
1421 }
1422 monitor_printf(mon, "\n");
1423 addr += l;
1424 len -= l;
1425 }
1426 }
1427
1428 static void do_memory_dump(Monitor *mon, const QDict *qdict)
1429 {
1430 int count = qdict_get_int(qdict, "count");
1431 int format = qdict_get_int(qdict, "format");
1432 int size = qdict_get_int(qdict, "size");
1433 target_long addr = qdict_get_int(qdict, "addr");
1434
1435 memory_dump(mon, count, format, size, addr, 0);
1436 }
1437
1438 static void do_physical_memory_dump(Monitor *mon, const QDict *qdict)
1439 {
1440 int count = qdict_get_int(qdict, "count");
1441 int format = qdict_get_int(qdict, "format");
1442 int size = qdict_get_int(qdict, "size");
1443 target_phys_addr_t addr = qdict_get_int(qdict, "addr");
1444
1445 memory_dump(mon, count, format, size, addr, 1);
1446 }
1447
1448 static void do_print(Monitor *mon, const QDict *qdict)
1449 {
1450 int format = qdict_get_int(qdict, "format");
1451 target_phys_addr_t val = qdict_get_int(qdict, "val");
1452
1453 #if TARGET_PHYS_ADDR_BITS == 32
1454 switch(format) {
1455 case 'o':
1456 monitor_printf(mon, "%#o", val);
1457 break;
1458 case 'x':
1459 monitor_printf(mon, "%#x", val);
1460 break;
1461 case 'u':
1462 monitor_printf(mon, "%u", val);
1463 break;
1464 default:
1465 case 'd':
1466 monitor_printf(mon, "%d", val);
1467 break;
1468 case 'c':
1469 monitor_printc(mon, val);
1470 break;
1471 }
1472 #else
1473 switch(format) {
1474 case 'o':
1475 monitor_printf(mon, "%#" PRIo64, val);
1476 break;
1477 case 'x':
1478 monitor_printf(mon, "%#" PRIx64, val);
1479 break;
1480 case 'u':
1481 monitor_printf(mon, "%" PRIu64, val);
1482 break;
1483 default:
1484 case 'd':
1485 monitor_printf(mon, "%" PRId64, val);
1486 break;
1487 case 'c':
1488 monitor_printc(mon, val);
1489 break;
1490 }
1491 #endif
1492 monitor_printf(mon, "\n");
1493 }
1494
1495 static int do_memory_save(Monitor *mon, const QDict *qdict, QObject **ret_data)
1496 {
1497 FILE *f;
1498 uint32_t size = qdict_get_int(qdict, "size");
1499 const char *filename = qdict_get_str(qdict, "filename");
1500 target_long addr = qdict_get_int(qdict, "val");
1501 uint32_t l;
1502 CPUState *env;
1503 uint8_t buf[1024];
1504 int ret = -1;
1505
1506 env = mon_get_cpu();
1507
1508 f = fopen(filename, "wb");
1509 if (!f) {
1510 qerror_report(QERR_OPEN_FILE_FAILED, filename);
1511 return -1;
1512 }
1513 while (size != 0) {
1514 l = sizeof(buf);
1515 if (l > size)
1516 l = size;
1517 cpu_memory_rw_debug(env, addr, buf, l, 0);
1518 if (fwrite(buf, 1, l, f) != l) {
1519 monitor_printf(mon, "fwrite() error in do_memory_save\n");
1520 goto exit;
1521 }
1522 addr += l;
1523 size -= l;
1524 }
1525
1526 ret = 0;
1527
1528 exit:
1529 fclose(f);
1530 return ret;
1531 }
1532
1533 static int do_physical_memory_save(Monitor *mon, const QDict *qdict,
1534 QObject **ret_data)
1535 {
1536 FILE *f;
1537 uint32_t l;
1538 uint8_t buf[1024];
1539 uint32_t size = qdict_get_int(qdict, "size");
1540 const char *filename = qdict_get_str(qdict, "filename");
1541 target_phys_addr_t addr = qdict_get_int(qdict, "val");
1542 int ret = -1;
1543
1544 f = fopen(filename, "wb");
1545 if (!f) {
1546 qerror_report(QERR_OPEN_FILE_FAILED, filename);
1547 return -1;
1548 }
1549 while (size != 0) {
1550 l = sizeof(buf);
1551 if (l > size)
1552 l = size;
1553 cpu_physical_memory_rw(addr, buf, l, 0);
1554 if (fwrite(buf, 1, l, f) != l) {
1555 monitor_printf(mon, "fwrite() error in do_physical_memory_save\n");
1556 goto exit;
1557 }
1558 fflush(f);
1559 addr += l;
1560 size -= l;
1561 }
1562
1563 ret = 0;
1564
1565 exit:
1566 fclose(f);
1567 return ret;
1568 }
1569
1570 static void do_sum(Monitor *mon, const QDict *qdict)
1571 {
1572 uint32_t addr;
1573 uint8_t buf[1];
1574 uint16_t sum;
1575 uint32_t start = qdict_get_int(qdict, "start");
1576 uint32_t size = qdict_get_int(qdict, "size");
1577
1578 sum = 0;
1579 for(addr = start; addr < (start + size); addr++) {
1580 cpu_physical_memory_rw(addr, buf, 1, 0);
1581 /* BSD sum algorithm ('sum' Unix command) */
1582 sum = (sum >> 1) | (sum << 15);
1583 sum += buf[0];
1584 }
1585 monitor_printf(mon, "%05d\n", sum);
1586 }
1587
1588 typedef struct {
1589 int keycode;
1590 const char *name;
1591 } KeyDef;
1592
1593 static const KeyDef key_defs[] = {
1594 { 0x2a, "shift" },
1595 { 0x36, "shift_r" },
1596
1597 { 0x38, "alt" },
1598 { 0xb8, "alt_r" },
1599 { 0x64, "altgr" },
1600 { 0xe4, "altgr_r" },
1601 { 0x1d, "ctrl" },
1602 { 0x9d, "ctrl_r" },
1603
1604 { 0xdd, "menu" },
1605
1606 { 0x01, "esc" },
1607
1608 { 0x02, "1" },
1609 { 0x03, "2" },
1610 { 0x04, "3" },
1611 { 0x05, "4" },
1612 { 0x06, "5" },
1613 { 0x07, "6" },
1614 { 0x08, "7" },
1615 { 0x09, "8" },
1616 { 0x0a, "9" },
1617 { 0x0b, "0" },
1618 { 0x0c, "minus" },
1619 { 0x0d, "equal" },
1620 { 0x0e, "backspace" },
1621
1622 { 0x0f, "tab" },
1623 { 0x10, "q" },
1624 { 0x11, "w" },
1625 { 0x12, "e" },
1626 { 0x13, "r" },
1627 { 0x14, "t" },
1628 { 0x15, "y" },
1629 { 0x16, "u" },
1630 { 0x17, "i" },
1631 { 0x18, "o" },
1632 { 0x19, "p" },
1633
1634 { 0x1c, "ret" },
1635
1636 { 0x1e, "a" },
1637 { 0x1f, "s" },
1638 { 0x20, "d" },
1639 { 0x21, "f" },
1640 { 0x22, "g" },
1641 { 0x23, "h" },
1642 { 0x24, "j" },
1643 { 0x25, "k" },
1644 { 0x26, "l" },
1645
1646 { 0x2c, "z" },
1647 { 0x2d, "x" },
1648 { 0x2e, "c" },
1649 { 0x2f, "v" },
1650 { 0x30, "b" },
1651 { 0x31, "n" },
1652 { 0x32, "m" },
1653 { 0x33, "comma" },
1654 { 0x34, "dot" },
1655 { 0x35, "slash" },
1656
1657 { 0x37, "asterisk" },
1658
1659 { 0x39, "spc" },
1660 { 0x3a, "caps_lock" },
1661 { 0x3b, "f1" },
1662 { 0x3c, "f2" },
1663 { 0x3d, "f3" },
1664 { 0x3e, "f4" },
1665 { 0x3f, "f5" },
1666 { 0x40, "f6" },
1667 { 0x41, "f7" },
1668 { 0x42, "f8" },
1669 { 0x43, "f9" },
1670 { 0x44, "f10" },
1671 { 0x45, "num_lock" },
1672 { 0x46, "scroll_lock" },
1673
1674 { 0xb5, "kp_divide" },
1675 { 0x37, "kp_multiply" },
1676 { 0x4a, "kp_subtract" },
1677 { 0x4e, "kp_add" },
1678 { 0x9c, "kp_enter" },
1679 { 0x53, "kp_decimal" },
1680 { 0x54, "sysrq" },
1681
1682 { 0x52, "kp_0" },
1683 { 0x4f, "kp_1" },
1684 { 0x50, "kp_2" },
1685 { 0x51, "kp_3" },
1686 { 0x4b, "kp_4" },
1687 { 0x4c, "kp_5" },
1688 { 0x4d, "kp_6" },
1689 { 0x47, "kp_7" },
1690 { 0x48, "kp_8" },
1691 { 0x49, "kp_9" },
1692
1693 { 0x56, "<" },
1694
1695 { 0x57, "f11" },
1696 { 0x58, "f12" },
1697
1698 { 0xb7, "print" },
1699
1700 { 0xc7, "home" },
1701 { 0xc9, "pgup" },
1702 { 0xd1, "pgdn" },
1703 { 0xcf, "end" },
1704
1705 { 0xcb, "left" },
1706 { 0xc8, "up" },
1707 { 0xd0, "down" },
1708 { 0xcd, "right" },
1709
1710 { 0xd2, "insert" },
1711 { 0xd3, "delete" },
1712 #if defined(TARGET_SPARC) && !defined(TARGET_SPARC64)
1713 { 0xf0, "stop" },
1714 { 0xf1, "again" },
1715 { 0xf2, "props" },
1716 { 0xf3, "undo" },
1717 { 0xf4, "front" },
1718 { 0xf5, "copy" },
1719 { 0xf6, "open" },
1720 { 0xf7, "paste" },
1721 { 0xf8, "find" },
1722 { 0xf9, "cut" },
1723 { 0xfa, "lf" },
1724 { 0xfb, "help" },
1725 { 0xfc, "meta_l" },
1726 { 0xfd, "meta_r" },
1727 { 0xfe, "compose" },
1728 #endif
1729 { 0, NULL },
1730 };
1731
1732 static int get_keycode(const char *key)
1733 {
1734 const KeyDef *p;
1735 char *endp;
1736 int ret;
1737
1738 for(p = key_defs; p->name != NULL; p++) {
1739 if (!strcmp(key, p->name))
1740 return p->keycode;
1741 }
1742 if (strstart(key, "0x", NULL)) {
1743 ret = strtoul(key, &endp, 0);
1744 if (*endp == '\0' && ret >= 0x01 && ret <= 0xff)
1745 return ret;
1746 }
1747 return -1;
1748 }
1749
1750 #define MAX_KEYCODES 16
1751 static uint8_t keycodes[MAX_KEYCODES];
1752 static int nb_pending_keycodes;
1753 static QEMUTimer *key_timer;
1754
1755 static void release_keys(void *opaque)
1756 {
1757 int keycode;
1758
1759 while (nb_pending_keycodes > 0) {
1760 nb_pending_keycodes--;
1761 keycode = keycodes[nb_pending_keycodes];
1762 if (keycode & 0x80)
1763 kbd_put_keycode(0xe0);
1764 kbd_put_keycode(keycode | 0x80);
1765 }
1766 }
1767
1768 static void do_sendkey(Monitor *mon, const QDict *qdict)
1769 {
1770 char keyname_buf[16];
1771 char *separator;
1772 int keyname_len, keycode, i;
1773 const char *string = qdict_get_str(qdict, "string");
1774 int has_hold_time = qdict_haskey(qdict, "hold_time");
1775 int hold_time = qdict_get_try_int(qdict, "hold_time", -1);
1776
1777 if (nb_pending_keycodes > 0) {
1778 qemu_del_timer(key_timer);
1779 release_keys(NULL);
1780 }
1781 if (!has_hold_time)
1782 hold_time = 100;
1783 i = 0;
1784 while (1) {
1785 separator = strchr(string, '-');
1786 keyname_len = separator ? separator - string : strlen(string);
1787 if (keyname_len > 0) {
1788 pstrcpy(keyname_buf, sizeof(keyname_buf), string);
1789 if (keyname_len > sizeof(keyname_buf) - 1) {
1790 monitor_printf(mon, "invalid key: '%s...'\n", keyname_buf);
1791 return;
1792 }
1793 if (i == MAX_KEYCODES) {
1794 monitor_printf(mon, "too many keys\n");
1795 return;
1796 }
1797 keyname_buf[keyname_len] = 0;
1798 keycode = get_keycode(keyname_buf);
1799 if (keycode < 0) {
1800 monitor_printf(mon, "unknown key: '%s'\n", keyname_buf);
1801 return;
1802 }
1803 keycodes[i++] = keycode;
1804 }
1805 if (!separator)
1806 break;
1807 string = separator + 1;
1808 }
1809 nb_pending_keycodes = i;
1810 /* key down events */
1811 for (i = 0; i < nb_pending_keycodes; i++) {
1812 keycode = keycodes[i];
1813 if (keycode & 0x80)
1814 kbd_put_keycode(0xe0);
1815 kbd_put_keycode(keycode & 0x7f);
1816 }
1817 /* delayed key up events */
1818 qemu_mod_timer(key_timer, qemu_get_clock(vm_clock) +
1819 muldiv64(get_ticks_per_sec(), hold_time, 1000));
1820 }
1821
1822 static int mouse_button_state;
1823
1824 static void do_mouse_move(Monitor *mon, const QDict *qdict)
1825 {
1826 int dx, dy, dz;
1827 const char *dx_str = qdict_get_str(qdict, "dx_str");
1828 const char *dy_str = qdict_get_str(qdict, "dy_str");
1829 const char *dz_str = qdict_get_try_str(qdict, "dz_str");
1830 dx = strtol(dx_str, NULL, 0);
1831 dy = strtol(dy_str, NULL, 0);
1832 dz = 0;
1833 if (dz_str)
1834 dz = strtol(dz_str, NULL, 0);
1835 kbd_mouse_event(dx, dy, dz, mouse_button_state);
1836 }
1837
1838 static void do_mouse_button(Monitor *mon, const QDict *qdict)
1839 {
1840 int button_state = qdict_get_int(qdict, "button_state");
1841 mouse_button_state = button_state;
1842 kbd_mouse_event(0, 0, 0, mouse_button_state);
1843 }
1844
1845 static void do_ioport_read(Monitor *mon, const QDict *qdict)
1846 {
1847 int size = qdict_get_int(qdict, "size");
1848 int addr = qdict_get_int(qdict, "addr");
1849 int has_index = qdict_haskey(qdict, "index");
1850 uint32_t val;
1851 int suffix;
1852
1853 if (has_index) {
1854 int index = qdict_get_int(qdict, "index");
1855 cpu_outb(addr & IOPORTS_MASK, index & 0xff);
1856 addr++;
1857 }
1858 addr &= 0xffff;
1859
1860 switch(size) {
1861 default:
1862 case 1:
1863 val = cpu_inb(addr);
1864 suffix = 'b';
1865 break;
1866 case 2:
1867 val = cpu_inw(addr);
1868 suffix = 'w';
1869 break;
1870 case 4:
1871 val = cpu_inl(addr);
1872 suffix = 'l';
1873 break;
1874 }
1875 monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
1876 suffix, addr, size * 2, val);
1877 }
1878
1879 static void do_ioport_write(Monitor *mon, const QDict *qdict)
1880 {
1881 int size = qdict_get_int(qdict, "size");
1882 int addr = qdict_get_int(qdict, "addr");
1883 int val = qdict_get_int(qdict, "val");
1884
1885 addr &= IOPORTS_MASK;
1886
1887 switch (size) {
1888 default:
1889 case 1:
1890 cpu_outb(addr, val);
1891 break;
1892 case 2:
1893 cpu_outw(addr, val);
1894 break;
1895 case 4:
1896 cpu_outl(addr, val);
1897 break;
1898 }
1899 }
1900
1901 static void do_boot_set(Monitor *mon, const QDict *qdict)
1902 {
1903 int res;
1904 const char *bootdevice = qdict_get_str(qdict, "bootdevice");
1905
1906 res = qemu_boot_set(bootdevice);
1907 if (res == 0) {
1908 monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
1909 } else if (res > 0) {
1910 monitor_printf(mon, "setting boot device list failed\n");
1911 } else {
1912 monitor_printf(mon, "no function defined to set boot device list for "
1913 "this architecture\n");
1914 }
1915 }
1916
1917 /**
1918 * do_system_reset(): Issue a machine reset
1919 */
1920 static int do_system_reset(Monitor *mon, const QDict *qdict,
1921 QObject **ret_data)
1922 {
1923 qemu_system_reset_request();
1924 return 0;
1925 }
1926
1927 /**
1928 * do_system_powerdown(): Issue a machine powerdown
1929 */
1930 static int do_system_powerdown(Monitor *mon, const QDict *qdict,
1931 QObject **ret_data)
1932 {
1933 qemu_system_powerdown_request();
1934 return 0;
1935 }
1936
1937 #if defined(TARGET_I386)
1938 static void print_pte(Monitor *mon, uint32_t addr, uint32_t pte, uint32_t mask)
1939 {
1940 monitor_printf(mon, "%08x: %08x %c%c%c%c%c%c%c%c\n",
1941 addr,
1942 pte & mask,
1943 pte & PG_GLOBAL_MASK ? 'G' : '-',
1944 pte & PG_PSE_MASK ? 'P' : '-',
1945 pte & PG_DIRTY_MASK ? 'D' : '-',
1946 pte & PG_ACCESSED_MASK ? 'A' : '-',
1947 pte & PG_PCD_MASK ? 'C' : '-',
1948 pte & PG_PWT_MASK ? 'T' : '-',
1949 pte & PG_USER_MASK ? 'U' : '-',
1950 pte & PG_RW_MASK ? 'W' : '-');
1951 }
1952
1953 static void tlb_info(Monitor *mon)
1954 {
1955 CPUState *env;
1956 int l1, l2;
1957 uint32_t pgd, pde, pte;
1958
1959 env = mon_get_cpu();
1960
1961 if (!(env->cr[0] & CR0_PG_MASK)) {
1962 monitor_printf(mon, "PG disabled\n");
1963 return;
1964 }
1965 pgd = env->cr[3] & ~0xfff;
1966 for(l1 = 0; l1 < 1024; l1++) {
1967 cpu_physical_memory_read(pgd + l1 * 4, (uint8_t *)&pde, 4);
1968 pde = le32_to_cpu(pde);
1969 if (pde & PG_PRESENT_MASK) {
1970 if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
1971 print_pte(mon, (l1 << 22), pde, ~((1 << 20) - 1));
1972 } else {
1973 for(l2 = 0; l2 < 1024; l2++) {
1974 cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
1975 (uint8_t *)&pte, 4);
1976 pte = le32_to_cpu(pte);
1977 if (pte & PG_PRESENT_MASK) {
1978 print_pte(mon, (l1 << 22) + (l2 << 12),
1979 pte & ~PG_PSE_MASK,
1980 ~0xfff);
1981 }
1982 }
1983 }
1984 }
1985 }
1986 }
1987
1988 static void mem_print(Monitor *mon, uint32_t *pstart, int *plast_prot,
1989 uint32_t end, int prot)
1990 {
1991 int prot1;
1992 prot1 = *plast_prot;
1993 if (prot != prot1) {
1994 if (*pstart != -1) {
1995 monitor_printf(mon, "%08x-%08x %08x %c%c%c\n",
1996 *pstart, end, end - *pstart,
1997 prot1 & PG_USER_MASK ? 'u' : '-',
1998 'r',
1999 prot1 & PG_RW_MASK ? 'w' : '-');
2000 }
2001 if (prot != 0)
2002 *pstart = end;
2003 else
2004 *pstart = -1;
2005 *plast_prot = prot;
2006 }
2007 }
2008
2009 static void mem_info(Monitor *mon)
2010 {
2011 CPUState *env;
2012 int l1, l2, prot, last_prot;
2013 uint32_t pgd, pde, pte, start, end;
2014
2015 env = mon_get_cpu();
2016
2017 if (!(env->cr[0] & CR0_PG_MASK)) {
2018 monitor_printf(mon, "PG disabled\n");
2019 return;
2020 }
2021 pgd = env->cr[3] & ~0xfff;
2022 last_prot = 0;
2023 start = -1;
2024 for(l1 = 0; l1 < 1024; l1++) {
2025 cpu_physical_memory_read(pgd + l1 * 4, (uint8_t *)&pde, 4);
2026 pde = le32_to_cpu(pde);
2027 end = l1 << 22;
2028 if (pde & PG_PRESENT_MASK) {
2029 if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
2030 prot = pde & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
2031 mem_print(mon, &start, &last_prot, end, prot);
2032 } else {
2033 for(l2 = 0; l2 < 1024; l2++) {
2034 cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
2035 (uint8_t *)&pte, 4);
2036 pte = le32_to_cpu(pte);
2037 end = (l1 << 22) + (l2 << 12);
2038 if (pte & PG_PRESENT_MASK) {
2039 prot = pte & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
2040 } else {
2041 prot = 0;
2042 }
2043 mem_print(mon, &start, &last_prot, end, prot);
2044 }
2045 }
2046 } else {
2047 prot = 0;
2048 mem_print(mon, &start, &last_prot, end, prot);
2049 }
2050 }
2051 }
2052 #endif
2053
2054 #if defined(TARGET_SH4)
2055
2056 static void print_tlb(Monitor *mon, int idx, tlb_t *tlb)
2057 {
2058 monitor_printf(mon, " tlb%i:\t"
2059 "asid=%hhu vpn=%x\tppn=%x\tsz=%hhu size=%u\t"
2060 "v=%hhu shared=%hhu cached=%hhu prot=%hhu "
2061 "dirty=%hhu writethrough=%hhu\n",
2062 idx,
2063 tlb->asid, tlb->vpn, tlb->ppn, tlb->sz, tlb->size,
2064 tlb->v, tlb->sh, tlb->c, tlb->pr,
2065 tlb->d, tlb->wt);
2066 }
2067
2068 static void tlb_info(Monitor *mon)
2069 {
2070 CPUState *env = mon_get_cpu();
2071 int i;
2072
2073 monitor_printf (mon, "ITLB:\n");
2074 for (i = 0 ; i < ITLB_SIZE ; i++)
2075 print_tlb (mon, i, &env->itlb[i]);
2076 monitor_printf (mon, "UTLB:\n");
2077 for (i = 0 ; i < UTLB_SIZE ; i++)
2078 print_tlb (mon, i, &env->utlb[i]);
2079 }
2080
2081 #endif
2082
2083 static void do_info_kvm_print(Monitor *mon, const QObject *data)
2084 {
2085 QDict *qdict;
2086
2087 qdict = qobject_to_qdict(data);
2088
2089 monitor_printf(mon, "kvm support: ");
2090 if (qdict_get_bool(qdict, "present")) {
2091 monitor_printf(mon, "%s\n", qdict_get_bool(qdict, "enabled") ?
2092 "enabled" : "disabled");
2093 } else {
2094 monitor_printf(mon, "not compiled\n");
2095 }
2096 }
2097
2098 /**
2099 * do_info_kvm(): Show KVM information
2100 *
2101 * Return a QDict with the following information:
2102 *
2103 * - "enabled": true if KVM support is enabled, false otherwise
2104 * - "present": true if QEMU has KVM support, false otherwise
2105 *
2106 * Example:
2107 *
2108 * { "enabled": true, "present": true }
2109 */
2110 static void do_info_kvm(Monitor *mon, QObject **ret_data)
2111 {
2112 #ifdef CONFIG_KVM
2113 *ret_data = qobject_from_jsonf("{ 'enabled': %i, 'present': true }",
2114 kvm_enabled());
2115 #else
2116 *ret_data = qobject_from_jsonf("{ 'enabled': false, 'present': false }");
2117 #endif
2118 }
2119
2120 static void do_info_numa(Monitor *mon)
2121 {
2122 int i;
2123 CPUState *env;
2124
2125 monitor_printf(mon, "%d nodes\n", nb_numa_nodes);
2126 for (i = 0; i < nb_numa_nodes; i++) {
2127 monitor_printf(mon, "node %d cpus:", i);
2128 for (env = first_cpu; env != NULL; env = env->next_cpu) {
2129 if (env->numa_node == i) {
2130 monitor_printf(mon, " %d", env->cpu_index);
2131 }
2132 }
2133 monitor_printf(mon, "\n");
2134 monitor_printf(mon, "node %d size: %" PRId64 " MB\n", i,
2135 node_mem[i] >> 20);
2136 }
2137 }
2138
2139 #ifdef CONFIG_PROFILER
2140
2141 int64_t qemu_time;
2142 int64_t dev_time;
2143
2144 static void do_info_profile(Monitor *mon)
2145 {
2146 int64_t total;
2147 total = qemu_time;
2148 if (total == 0)
2149 total = 1;
2150 monitor_printf(mon, "async time %" PRId64 " (%0.3f)\n",
2151 dev_time, dev_time / (double)get_ticks_per_sec());
2152 monitor_printf(mon, "qemu time %" PRId64 " (%0.3f)\n",
2153 qemu_time, qemu_time / (double)get_ticks_per_sec());
2154 qemu_time = 0;
2155 dev_time = 0;
2156 }
2157 #else
2158 static void do_info_profile(Monitor *mon)
2159 {
2160 monitor_printf(mon, "Internal profiler not compiled\n");
2161 }
2162 #endif
2163
2164 /* Capture support */
2165 static QLIST_HEAD (capture_list_head, CaptureState) capture_head;
2166
2167 static void do_info_capture(Monitor *mon)
2168 {
2169 int i;
2170 CaptureState *s;
2171
2172 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
2173 monitor_printf(mon, "[%d]: ", i);
2174 s->ops.info (s->opaque);
2175 }
2176 }
2177
2178 #ifdef HAS_AUDIO
2179 static void do_stop_capture(Monitor *mon, const QDict *qdict)
2180 {
2181 int i;
2182 int n = qdict_get_int(qdict, "n");
2183 CaptureState *s;
2184
2185 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
2186 if (i == n) {
2187 s->ops.destroy (s->opaque);
2188 QLIST_REMOVE (s, entries);
2189 qemu_free (s);
2190 return;
2191 }
2192 }
2193 }
2194
2195 static void do_wav_capture(Monitor *mon, const QDict *qdict)
2196 {
2197 const char *path = qdict_get_str(qdict, "path");
2198 int has_freq = qdict_haskey(qdict, "freq");
2199 int freq = qdict_get_try_int(qdict, "freq", -1);
2200 int has_bits = qdict_haskey(qdict, "bits");
2201 int bits = qdict_get_try_int(qdict, "bits", -1);
2202 int has_channels = qdict_haskey(qdict, "nchannels");
2203 int nchannels = qdict_get_try_int(qdict, "nchannels", -1);
2204 CaptureState *s;
2205
2206 s = qemu_mallocz (sizeof (*s));
2207
2208 freq = has_freq ? freq : 44100;
2209 bits = has_bits ? bits : 16;
2210 nchannels = has_channels ? nchannels : 2;
2211
2212 if (wav_start_capture (s, path, freq, bits, nchannels)) {
2213 monitor_printf(mon, "Faied to add wave capture\n");
2214 qemu_free (s);
2215 }
2216 QLIST_INSERT_HEAD (&capture_head, s, entries);
2217 }
2218 #endif
2219
2220 #if defined(TARGET_I386)
2221 static void do_inject_nmi(Monitor *mon, const QDict *qdict)
2222 {
2223 CPUState *env;
2224 int cpu_index = qdict_get_int(qdict, "cpu_index");
2225
2226 for (env = first_cpu; env != NULL; env = env->next_cpu)
2227 if (env->cpu_index == cpu_index) {
2228 cpu_interrupt(env, CPU_INTERRUPT_NMI);
2229 break;
2230 }
2231 }
2232 #endif
2233
2234 static void do_info_status_print(Monitor *mon, const QObject *data)
2235 {
2236 QDict *qdict;
2237
2238 qdict = qobject_to_qdict(data);
2239
2240 monitor_printf(mon, "VM status: ");
2241 if (qdict_get_bool(qdict, "running")) {
2242 monitor_printf(mon, "running");
2243 if (qdict_get_bool(qdict, "singlestep")) {
2244 monitor_printf(mon, " (single step mode)");
2245 }
2246 } else {
2247 monitor_printf(mon, "paused");
2248 }
2249
2250 monitor_printf(mon, "\n");
2251 }
2252
2253 /**
2254 * do_info_status(): VM status
2255 *
2256 * Return a QDict with the following information:
2257 *
2258 * - "running": true if the VM is running, or false if it is paused
2259 * - "singlestep": true if the VM is in single step mode, false otherwise
2260 *
2261 * Example:
2262 *
2263 * { "running": true, "singlestep": false }
2264 */
2265 static void do_info_status(Monitor *mon, QObject **ret_data)
2266 {
2267 *ret_data = qobject_from_jsonf("{ 'running': %i, 'singlestep': %i }",
2268 vm_running, singlestep);
2269 }
2270
2271 static void print_balloon_stat(const char *key, QObject *obj, void *opaque)
2272 {
2273 Monitor *mon = opaque;
2274
2275 if (strcmp(key, "actual"))
2276 monitor_printf(mon, ",%s=%" PRId64, key,
2277 qint_get_int(qobject_to_qint(obj)));
2278 }
2279
2280 static void monitor_print_balloon(Monitor *mon, const QObject *data)
2281 {
2282 QDict *qdict;
2283
2284 qdict = qobject_to_qdict(data);
2285 if (!qdict_haskey(qdict, "actual"))
2286 return;
2287
2288 monitor_printf(mon, "balloon: actual=%" PRId64,
2289 qdict_get_int(qdict, "actual") >> 20);
2290 qdict_iter(qdict, print_balloon_stat, mon);
2291 monitor_printf(mon, "\n");
2292 }
2293
2294 /**
2295 * do_info_balloon(): Balloon information
2296 *
2297 * Make an asynchronous request for balloon info. When the request completes
2298 * a QDict will be returned according to the following specification:
2299 *
2300 * - "actual": current balloon value in bytes
2301 * The following fields may or may not be present:
2302 * - "mem_swapped_in": Amount of memory swapped in (bytes)
2303 * - "mem_swapped_out": Amount of memory swapped out (bytes)
2304 * - "major_page_faults": Number of major faults
2305 * - "minor_page_faults": Number of minor faults
2306 * - "free_mem": Total amount of free and unused memory (bytes)
2307 * - "total_mem": Total amount of available memory (bytes)
2308 *
2309 * Example:
2310 *
2311 * { "actual": 1073741824, "mem_swapped_in": 0, "mem_swapped_out": 0,
2312 * "major_page_faults": 142, "minor_page_faults": 239245,
2313 * "free_mem": 1014185984, "total_mem": 1044668416 }
2314 */
2315 static int do_info_balloon(Monitor *mon, MonitorCompletion cb, void *opaque)
2316 {
2317 int ret;
2318
2319 if (kvm_enabled() && !kvm_has_sync_mmu()) {
2320 qerror_report(QERR_KVM_MISSING_CAP, "synchronous MMU", "balloon");
2321 return -1;
2322 }
2323
2324 ret = qemu_balloon_status(cb, opaque);
2325 if (!ret) {
2326 qerror_report(QERR_DEVICE_NOT_ACTIVE, "balloon");
2327 return -1;
2328 }
2329
2330 return 0;
2331 }
2332
2333 /**
2334 * do_balloon(): Request VM to change its memory allocation
2335 */
2336 static int do_balloon(Monitor *mon, const QDict *params,
2337 MonitorCompletion cb, void *opaque)
2338 {
2339 int ret;
2340
2341 if (kvm_enabled() && !kvm_has_sync_mmu()) {
2342 qerror_report(QERR_KVM_MISSING_CAP, "synchronous MMU", "balloon");
2343 return -1;
2344 }
2345
2346 ret = qemu_balloon(qdict_get_int(params, "value"), cb, opaque);
2347 if (ret == 0) {
2348 qerror_report(QERR_DEVICE_NOT_ACTIVE, "balloon");
2349 return -1;
2350 }
2351
2352 cb(opaque, NULL);
2353 return 0;
2354 }
2355
2356 static qemu_acl *find_acl(Monitor *mon, const char *name)
2357 {
2358 qemu_acl *acl = qemu_acl_find(name);
2359
2360 if (!acl) {
2361 monitor_printf(mon, "acl: unknown list '%s'\n", name);
2362 }
2363 return acl;
2364 }
2365
2366 static void do_acl_show(Monitor *mon, const QDict *qdict)
2367 {
2368 const char *aclname = qdict_get_str(qdict, "aclname");
2369 qemu_acl *acl = find_acl(mon, aclname);
2370 qemu_acl_entry *entry;
2371 int i = 0;
2372
2373 if (acl) {
2374 monitor_printf(mon, "policy: %s\n",
2375 acl->defaultDeny ? "deny" : "allow");
2376 QTAILQ_FOREACH(entry, &acl->entries, next) {
2377 i++;
2378 monitor_printf(mon, "%d: %s %s\n", i,
2379 entry->deny ? "deny" : "allow", entry->match);
2380 }
2381 }
2382 }
2383
2384 static void do_acl_reset(Monitor *mon, const QDict *qdict)
2385 {
2386 const char *aclname = qdict_get_str(qdict, "aclname");
2387 qemu_acl *acl = find_acl(mon, aclname);
2388
2389 if (acl) {
2390 qemu_acl_reset(acl);
2391 monitor_printf(mon, "acl: removed all rules\n");
2392 }
2393 }
2394
2395 static void do_acl_policy(Monitor *mon, const QDict *qdict)
2396 {
2397 const char *aclname = qdict_get_str(qdict, "aclname");
2398 const char *policy = qdict_get_str(qdict, "policy");
2399 qemu_acl *acl = find_acl(mon, aclname);
2400
2401 if (acl) {
2402 if (strcmp(policy, "allow") == 0) {
2403 acl->defaultDeny = 0;
2404 monitor_printf(mon, "acl: policy set to 'allow'\n");
2405 } else if (strcmp(policy, "deny") == 0) {
2406 acl->defaultDeny = 1;
2407 monitor_printf(mon, "acl: policy set to 'deny'\n");
2408 } else {
2409 monitor_printf(mon, "acl: unknown policy '%s', "
2410 "expected 'deny' or 'allow'\n", policy);
2411 }
2412 }
2413 }
2414
2415 static void do_acl_add(Monitor *mon, const QDict *qdict)
2416 {
2417 const char *aclname = qdict_get_str(qdict, "aclname");
2418 const char *match = qdict_get_str(qdict, "match");
2419 const char *policy = qdict_get_str(qdict, "policy");
2420 int has_index = qdict_haskey(qdict, "index");
2421 int index = qdict_get_try_int(qdict, "index", -1);
2422 qemu_acl *acl = find_acl(mon, aclname);
2423 int deny, ret;
2424
2425 if (acl) {
2426 if (strcmp(policy, "allow") == 0) {
2427 deny = 0;
2428 } else if (strcmp(policy, "deny") == 0) {
2429 deny = 1;
2430 } else {
2431 monitor_printf(mon, "acl: unknown policy '%s', "
2432 "expected 'deny' or 'allow'\n", policy);
2433 return;
2434 }
2435 if (has_index)
2436 ret = qemu_acl_insert(acl, deny, match, index);
2437 else
2438 ret = qemu_acl_append(acl, deny, match);
2439 if (ret < 0)
2440 monitor_printf(mon, "acl: unable to add acl entry\n");
2441 else
2442 monitor_printf(mon, "acl: added rule at position %d\n", ret);
2443 }
2444 }
2445
2446 static void do_acl_remove(Monitor *mon, const QDict *qdict)
2447 {
2448 const char *aclname = qdict_get_str(qdict, "aclname");
2449 const char *match = qdict_get_str(qdict, "match");
2450 qemu_acl *acl = find_acl(mon, aclname);
2451 int ret;
2452
2453 if (acl) {
2454 ret = qemu_acl_remove(acl, match);
2455 if (ret < 0)
2456 monitor_printf(mon, "acl: no matching acl entry\n");
2457 else
2458 monitor_printf(mon, "acl: removed rule at position %d\n", ret);
2459 }
2460 }
2461
2462 #if defined(TARGET_I386)
2463 static void do_inject_mce(Monitor *mon, const QDict *qdict)
2464 {
2465 CPUState *cenv;
2466 int cpu_index = qdict_get_int(qdict, "cpu_index");
2467 int bank = qdict_get_int(qdict, "bank");
2468 uint64_t status = qdict_get_int(qdict, "status");
2469 uint64_t mcg_status = qdict_get_int(qdict, "mcg_status");
2470 uint64_t addr = qdict_get_int(qdict, "addr");
2471 uint64_t misc = qdict_get_int(qdict, "misc");
2472
2473 for (cenv = first_cpu; cenv != NULL; cenv = cenv->next_cpu)
2474 if (cenv->cpu_index == cpu_index && cenv->mcg_cap) {
2475 cpu_inject_x86_mce(cenv, bank, status, mcg_status, addr, misc);
2476 break;
2477 }
2478 }
2479 #endif
2480
2481 static int do_getfd(Monitor *mon, const QDict *qdict, QObject **ret_data)
2482 {
2483 const char *fdname = qdict_get_str(qdict, "fdname");
2484 mon_fd_t *monfd;
2485 int fd;
2486
2487 fd = qemu_chr_get_msgfd(mon->chr);
2488 if (fd == -1) {
2489 qerror_report(QERR_FD_NOT_SUPPLIED);
2490 return -1;
2491 }
2492
2493 if (qemu_isdigit(fdname[0])) {
2494 qerror_report(QERR_INVALID_PARAMETER, "fdname");
2495 return -1;
2496 }
2497
2498 fd = dup(fd);
2499 if (fd == -1) {
2500 if (errno == EMFILE)
2501 qerror_report(QERR_TOO_MANY_FILES);
2502 else
2503 qerror_report(QERR_UNDEFINED_ERROR);
2504 return -1;
2505 }
2506
2507 QLIST_FOREACH(monfd, &mon->fds, next) {
2508 if (strcmp(monfd->name, fdname) != 0) {
2509 continue;
2510 }
2511
2512 close(monfd->fd);
2513 monfd->fd = fd;
2514 return 0;
2515 }
2516
2517 monfd = qemu_mallocz(sizeof(mon_fd_t));
2518 monfd->name = qemu_strdup(fdname);
2519 monfd->fd = fd;
2520
2521 QLIST_INSERT_HEAD(&mon->fds, monfd, next);
2522 return 0;
2523 }
2524
2525 static int do_closefd(Monitor *mon, const QDict *qdict, QObject **ret_data)
2526 {
2527 const char *fdname = qdict_get_str(qdict, "fdname");
2528 mon_fd_t *monfd;
2529
2530 QLIST_FOREACH(monfd, &mon->fds, next) {
2531 if (strcmp(monfd->name, fdname) != 0) {
2532 continue;
2533 }
2534
2535 QLIST_REMOVE(monfd, next);
2536 close(monfd->fd);
2537 qemu_free(monfd->name);
2538 qemu_free(monfd);
2539 return 0;
2540 }
2541
2542 qerror_report(QERR_FD_NOT_FOUND, fdname);
2543 return -1;
2544 }
2545
2546 static void do_loadvm(Monitor *mon, const QDict *qdict)
2547 {
2548 int saved_vm_running = vm_running;
2549 const char *name = qdict_get_str(qdict, "name");
2550
2551 vm_stop(0);
2552
2553 if (load_vmstate(name) >= 0 && saved_vm_running)
2554 vm_start();
2555 }
2556
2557 int monitor_get_fd(Monitor *mon, const char *fdname)
2558 {
2559 mon_fd_t *monfd;
2560
2561 QLIST_FOREACH(monfd, &mon->fds, next) {
2562 int fd;
2563
2564 if (strcmp(monfd->name, fdname) != 0) {
2565 continue;
2566 }
2567
2568 fd = monfd->fd;
2569
2570 /* caller takes ownership of fd */
2571 QLIST_REMOVE(monfd, next);
2572 qemu_free(monfd->name);
2573 qemu_free(monfd);
2574
2575 return fd;
2576 }
2577
2578 return -1;
2579 }
2580
2581 static const mon_cmd_t mon_cmds[] = {
2582 #include "qemu-monitor.h"
2583 { NULL, NULL, },
2584 };
2585
2586 /* Please update qemu-monitor.hx when adding or changing commands */
2587 static const mon_cmd_t info_cmds[] = {
2588 {
2589 .name = "version",
2590 .args_type = "",
2591 .params = "",
2592 .help = "show the version of QEMU",
2593 .user_print = do_info_version_print,
2594 .mhandler.info_new = do_info_version,
2595 },
2596 {
2597 .name = "commands",
2598 .args_type = "",
2599 .params = "",
2600 .help = "list QMP available commands",
2601 .user_print = monitor_user_noop,
2602 .mhandler.info_new = do_info_commands,
2603 },
2604 {
2605 .name = "network",
2606 .args_type = "",
2607 .params = "",
2608 .help = "show the network state",
2609 .mhandler.info = do_info_network,
2610 },
2611 {
2612 .name = "chardev",
2613 .args_type = "",
2614 .params = "",
2615 .help = "show the character devices",
2616 .user_print = qemu_chr_info_print,
2617 .mhandler.info_new = qemu_chr_info,
2618 },
2619 {
2620 .name = "block",
2621 .args_type = "",
2622 .params = "",
2623 .help = "show the block devices",
2624 .user_print = bdrv_info_print,
2625 .mhandler.info_new = bdrv_info,
2626 },
2627 {
2628 .name = "blockstats",
2629 .args_type = "",
2630 .params = "",
2631 .help = "show block device statistics",
2632 .user_print = bdrv_stats_print,
2633 .mhandler.info_new = bdrv_info_stats,
2634 },
2635 {
2636 .name = "registers",
2637 .args_type = "",
2638 .params = "",
2639 .help = "show the cpu registers",
2640 .mhandler.info = do_info_registers,
2641 },
2642 {
2643 .name = "cpus",
2644 .args_type = "",
2645 .params = "",
2646 .help = "show infos for each CPU",
2647 .user_print = monitor_print_cpus,
2648 .mhandler.info_new = do_info_cpus,
2649 },
2650 {
2651 .name = "history",
2652 .args_type = "",
2653 .params = "",
2654 .help = "show the command line history",
2655 .mhandler.info = do_info_history,
2656 },
2657 {
2658 .name = "irq",
2659 .args_type = "",
2660 .params = "",
2661 .help = "show the interrupts statistics (if available)",
2662 .mhandler.info = irq_info,
2663 },
2664 {
2665 .name = "pic",
2666 .args_type = "",
2667 .params = "",
2668 .help = "show i8259 (PIC) state",
2669 .mhandler.info = pic_info,
2670 },
2671 {
2672 .name = "pci",
2673 .args_type = "",
2674 .params = "",
2675 .help = "show PCI info",
2676 .user_print = do_pci_info_print,
2677 .mhandler.info_new = do_pci_info,
2678 },
2679 #if defined(TARGET_I386) || defined(TARGET_SH4)
2680 {
2681 .name = "tlb",
2682 .args_type = "",
2683 .params = "",
2684 .help = "show virtual to physical memory mappings",
2685 .mhandler.info = tlb_info,
2686 },
2687 #endif
2688 #if defined(TARGET_I386)
2689 {
2690 .name = "mem",
2691 .args_type = "",
2692 .params = "",
2693 .help = "show the active virtual memory mappings",
2694 .mhandler.info = mem_info,
2695 },
2696 {
2697 .name = "hpet",
2698 .args_type = "",
2699 .params = "",
2700 .help = "show state of HPET",
2701 .user_print = do_info_hpet_print,
2702 .mhandler.info_new = do_info_hpet,
2703 },
2704 #endif
2705 {
2706 .name = "jit",
2707 .args_type = "",
2708 .params = "",
2709 .help = "show dynamic compiler info",
2710 .mhandler.info = do_info_jit,
2711 },
2712 {
2713 .name = "kvm",
2714 .args_type = "",
2715 .params = "",
2716 .help = "show KVM information",
2717 .user_print = do_info_kvm_print,
2718 .mhandler.info_new = do_info_kvm,
2719 },
2720 {
2721 .name = "numa",
2722 .args_type = "",
2723 .params = "",
2724 .help = "show NUMA information",
2725 .mhandler.info = do_info_numa,
2726 },
2727 {
2728 .name = "usb",
2729 .args_type = "",
2730 .params = "",
2731 .help = "show guest USB devices",
2732 .mhandler.info = usb_info,
2733 },
2734 {
2735 .name = "usbhost",
2736 .args_type = "",
2737 .params = "",
2738 .help = "show host USB devices",
2739 .mhandler.info = usb_host_info,
2740 },
2741 {
2742 .name = "profile",
2743 .args_type = "",
2744 .params = "",
2745 .help = "show profiling information",
2746 .mhandler.info = do_info_profile,
2747 },
2748 {
2749 .name = "capture",
2750 .args_type = "",
2751 .params = "",
2752 .help = "show capture information",
2753 .mhandler.info = do_info_capture,
2754 },
2755 {
2756 .name = "snapshots",
2757 .args_type = "",
2758 .params = "",
2759 .help = "show the currently saved VM snapshots",
2760 .mhandler.info = do_info_snapshots,
2761 },
2762 {
2763 .name = "status",
2764 .args_type = "",
2765 .params = "",
2766 .help = "show the current VM status (running|paused)",
2767 .user_print = do_info_status_print,
2768 .mhandler.info_new = do_info_status,
2769 },
2770 {
2771 .name = "pcmcia",
2772 .args_type = "",
2773 .params = "",
2774 .help = "show guest PCMCIA status",
2775 .mhandler.info = pcmcia_info,
2776 },
2777 {
2778 .name = "mice",
2779 .args_type = "",
2780 .params = "",
2781 .help = "show which guest mouse is receiving events",
2782 .user_print = do_info_mice_print,
2783 .mhandler.info_new = do_info_mice,
2784 },
2785 {
2786 .name = "vnc",
2787 .args_type = "",
2788 .params = "",
2789 .help = "show the vnc server status",
2790 .user_print = do_info_vnc_print,
2791 .mhandler.info_new = do_info_vnc,
2792 },
2793 {
2794 .name = "name",
2795 .args_type = "",
2796 .params = "",
2797 .help = "show the current VM name",
2798 .user_print = do_info_name_print,
2799 .mhandler.info_new = do_info_name,
2800 },
2801 {
2802 .name = "uuid",
2803 .args_type = "",
2804 .params = "",
2805 .help = "show the current VM UUID",
2806 .user_print = do_info_uuid_print,
2807 .mhandler.info_new = do_info_uuid,
2808 },
2809 #if defined(TARGET_PPC)
2810 {
2811 .name = "cpustats",
2812 .args_type = "",
2813 .params = "",
2814 .help = "show CPU statistics",
2815 .mhandler.info = do_info_cpu_stats,
2816 },
2817 #endif
2818 #if defined(CONFIG_SLIRP)
2819 {
2820 .name = "usernet",
2821 .args_type = "",
2822 .params = "",
2823 .help = "show user network stack connection states",
2824 .mhandler.info = do_info_usernet,
2825 },
2826 #endif
2827 {
2828 .name = "migrate",
2829 .args_type = "",
2830 .params = "",
2831 .help = "show migration status",
2832 .user_print = do_info_migrate_print,
2833 .mhandler.info_new = do_info_migrate,
2834 },
2835 {
2836 .name = "balloon",
2837 .args_type = "",
2838 .params = "",
2839 .help = "show balloon information",
2840 .user_print = monitor_print_balloon,
2841 .mhandler.info_async = do_info_balloon,
2842 .async = 1,
2843 },
2844 {
2845 .name = "qtree",
2846 .args_type = "",
2847 .params = "",
2848 .help = "show device tree",
2849 .mhandler.info = do_info_qtree,
2850 },
2851 {
2852 .name = "qdm",
2853 .args_type = "",
2854 .params = "",
2855 .help = "show qdev device model list",
2856 .mhandler.info = do_info_qdm,
2857 },
2858 {
2859 .name = "roms",
2860 .args_type = "",
2861 .params = "",
2862 .help = "show roms",
2863 .mhandler.info = do_info_roms,
2864 },
2865 {
2866 .name = NULL,
2867 },
2868 };
2869
2870 /*******************************************************************/
2871
2872 static const char *pch;
2873 static jmp_buf expr_env;
2874
2875 #define MD_TLONG 0
2876 #define MD_I32 1
2877
2878 typedef struct MonitorDef {
2879 const char *name;
2880 int offset;
2881 target_long (*get_value)(const struct MonitorDef *md, int val);
2882 int type;
2883 } MonitorDef;
2884
2885 #if defined(TARGET_I386)
2886 static target_long monitor_get_pc (const struct MonitorDef *md, int val)
2887 {
2888 CPUState *env = mon_get_cpu();
2889 return env->eip + env->segs[R_CS].base;
2890 }
2891 #endif
2892
2893 #if defined(TARGET_PPC)
2894 static target_long monitor_get_ccr (const struct MonitorDef *md, int val)
2895 {
2896 CPUState *env = mon_get_cpu();
2897 unsigned int u;
2898 int i;
2899
2900 u = 0;
2901 for (i = 0; i < 8; i++)
2902 u |= env->crf[i] << (32 - (4 * i));
2903
2904 return u;
2905 }
2906
2907 static target_long monitor_get_msr (const struct MonitorDef *md, int val)
2908 {
2909 CPUState *env = mon_get_cpu();
2910 return env->msr;
2911 }
2912
2913 static target_long monitor_get_xer (const struct MonitorDef *md, int val)
2914 {
2915 CPUState *env = mon_get_cpu();
2916 return env->xer;
2917 }
2918
2919 static target_long monitor_get_decr (const struct MonitorDef *md, int val)
2920 {
2921 CPUState *env = mon_get_cpu();
2922 return cpu_ppc_load_decr(env);
2923 }
2924
2925 static target_long monitor_get_tbu (const struct MonitorDef *md, int val)
2926 {
2927 CPUState *env = mon_get_cpu();
2928 return cpu_ppc_load_tbu(env);
2929 }
2930
2931 static target_long monitor_get_tbl (const struct MonitorDef *md, int val)
2932 {
2933 CPUState *env = mon_get_cpu();
2934 return cpu_ppc_load_tbl(env);
2935 }
2936 #endif
2937
2938 #if defined(TARGET_SPARC)
2939 #ifndef TARGET_SPARC64
2940 static target_long monitor_get_psr (const struct MonitorDef *md, int val)
2941 {
2942 CPUState *env = mon_get_cpu();
2943 return GET_PSR(env);
2944 }
2945 #endif
2946
2947 static target_long monitor_get_reg(const struct MonitorDef *md, int val)
2948 {
2949 CPUState *env = mon_get_cpu();
2950 return env->regwptr[val];
2951 }
2952 #endif
2953
2954 static const MonitorDef monitor_defs[] = {
2955 #ifdef TARGET_I386
2956
2957 #define SEG(name, seg) \
2958 { name, offsetof(CPUState, segs[seg].selector), NULL, MD_I32 },\
2959 { name ".base", offsetof(CPUState, segs[seg].base) },\
2960 { name ".limit", offsetof(CPUState, segs[seg].limit), NULL, MD_I32 },
2961
2962 { "eax", offsetof(CPUState, regs[0]) },
2963 { "ecx", offsetof(CPUState, regs[1]) },
2964 { "edx", offsetof(CPUState, regs[2]) },
2965 { "ebx", offsetof(CPUState, regs[3]) },
2966 { "esp|sp", offsetof(CPUState, regs[4]) },
2967 { "ebp|fp", offsetof(CPUState, regs[5]) },
2968 { "esi", offsetof(CPUState, regs[6]) },
2969 { "edi", offsetof(CPUState, regs[7]) },
2970 #ifdef TARGET_X86_64
2971 { "r8", offsetof(CPUState, regs[8]) },
2972 { "r9", offsetof(CPUState, regs[9]) },
2973 { "r10", offsetof(CPUState, regs[10]) },
2974 { "r11", offsetof(CPUState, regs[11]) },
2975 { "r12", offsetof(CPUState, regs[12]) },
2976 { "r13", offsetof(CPUState, regs[13]) },
2977 { "r14", offsetof(CPUState, regs[14]) },
2978 { "r15", offsetof(CPUState, regs[15]) },
2979 #endif
2980 { "eflags", offsetof(CPUState, eflags) },
2981 { "eip", offsetof(CPUState, eip) },
2982 SEG("cs", R_CS)
2983 SEG("ds", R_DS)
2984 SEG("es", R_ES)
2985 SEG("ss", R_SS)
2986 SEG("fs", R_FS)
2987 SEG("gs", R_GS)
2988 { "pc", 0, monitor_get_pc, },
2989 #elif defined(TARGET_PPC)
2990 /* General purpose registers */
2991 { "r0", offsetof(CPUState, gpr[0]) },
2992 { "r1", offsetof(CPUState, gpr[1]) },
2993 { "r2", offsetof(CPUState, gpr[2]) },
2994 { "r3", offsetof(CPUState, gpr[3]) },
2995 { "r4", offsetof(CPUState, gpr[4]) },
2996 { "r5", offsetof(CPUState, gpr[5]) },
2997 { "r6", offsetof(CPUState, gpr[6]) },
2998 { "r7", offsetof(CPUState, gpr[7]) },
2999 { "r8", offsetof(CPUState, gpr[8]) },
3000 { "r9", offsetof(CPUState, gpr[9]) },
3001 { "r10", offsetof(CPUState, gpr[10]) },
3002 { "r11", offsetof(CPUState, gpr[11]) },
3003 { "r12", offsetof(CPUState, gpr[12]) },
3004 { "r13", offsetof(CPUState, gpr[13]) },
3005 { "r14", offsetof(CPUState, gpr[14]) },
3006 { "r15", offsetof(CPUState, gpr[15]) },
3007 { "r16", offsetof(CPUState, gpr[16]) },
3008 { "r17", offsetof(CPUState, gpr[17]) },
3009 { "r18", offsetof(CPUState, gpr[18]) },
3010 { "r19", offsetof(CPUState, gpr[19]) },
3011 { "r20", offsetof(CPUState, gpr[20]) },
3012 { "r21", offsetof(CPUState, gpr[21]) },
3013 { "r22", offsetof(CPUState, gpr[22]) },
3014 { "r23", offsetof(CPUState, gpr[23]) },
3015 { "r24", offsetof(CPUState, gpr[24]) },
3016 { "r25", offsetof(CPUState, gpr[25]) },
3017 { "r26", offsetof(CPUState, gpr[26]) },
3018 { "r27", offsetof(CPUState, gpr[27]) },
3019 { "r28", offsetof(CPUState, gpr[28]) },
3020 { "r29", offsetof(CPUState, gpr[29]) },
3021 { "r30", offsetof(CPUState, gpr[30]) },
3022 { "r31", offsetof(CPUState, gpr[31]) },
3023 /* Floating point registers */
3024 { "f0", offsetof(CPUState, fpr[0]) },
3025 { "f1", offsetof(CPUState, fpr[1]) },
3026 { "f2", offsetof(CPUState, fpr[2]) },
3027 { "f3", offsetof(CPUState, fpr[3]) },
3028 { "f4", offsetof(CPUState, fpr[4]) },
3029 { "f5", offsetof(CPUState, fpr[5]) },
3030 { "f6", offsetof(CPUState, fpr[6]) },
3031 { "f7", offsetof(CPUState, fpr[7]) },
3032 { "f8", offsetof(CPUState, fpr[8]) },
3033 { "f9", offsetof(CPUState, fpr[9]) },
3034 { "f10", offsetof(CPUState, fpr[10]) },
3035 { "f11", offsetof(CPUState, fpr[11]) },
3036 { "f12", offsetof(CPUState, fpr[12]) },
3037 { "f13", offsetof(CPUState, fpr[13]) },
3038 { "f14", offsetof(CPUState, fpr[14]) },
3039 { "f15", offsetof(CPUState, fpr[15]) },
3040 { "f16", offsetof(CPUState, fpr[16]) },
3041 { "f17", offsetof(CPUState, fpr[17]) },
3042 { "f18", offsetof(CPUState, fpr[18]) },
3043 { "f19", offsetof(CPUState, fpr[19]) },
3044 { "f20", offsetof(CPUState, fpr[20]) },
3045 { "f21", offsetof(CPUState, fpr[21]) },
3046 { "f22", offsetof(CPUState, fpr[22]) },
3047 { "f23", offsetof(CPUState, fpr[23]) },
3048 { "f24", offsetof(CPUState, fpr[24]) },
3049 { "f25", offsetof(CPUState, fpr[25]) },
3050 { "f26", offsetof(CPUState, fpr[26]) },
3051 { "f27", offsetof(CPUState, fpr[27]) },
3052 { "f28", offsetof(CPUState, fpr[28]) },
3053 { "f29", offsetof(CPUState, fpr[29]) },
3054 { "f30", offsetof(CPUState, fpr[30]) },
3055 { "f31", offsetof(CPUState, fpr[31]) },
3056 { "fpscr", offsetof(CPUState, fpscr) },
3057 /* Next instruction pointer */
3058 { "nip|pc", offsetof(CPUState, nip) },
3059 { "lr", offsetof(CPUState, lr) },
3060 { "ctr", offsetof(CPUState, ctr) },
3061 { "decr", 0, &monitor_get_decr, },
3062 { "ccr", 0, &monitor_get_ccr, },
3063 /* Machine state register */
3064 { "msr", 0, &monitor_get_msr, },
3065 { "xer", 0, &monitor_get_xer, },
3066 { "tbu", 0, &monitor_get_tbu, },
3067 { "tbl", 0, &monitor_get_tbl, },
3068 #if defined(TARGET_PPC64)
3069 /* Address space register */
3070 { "asr", offsetof(CPUState, asr) },
3071 #endif
3072 /* Segment registers */
3073 { "sdr1", offsetof(CPUState, sdr1) },
3074 { "sr0", offsetof(CPUState, sr[0]) },
3075 { "sr1", offsetof(CPUState, sr[1]) },
3076 { "sr2", offsetof(CPUState, sr[2]) },
3077 { "sr3", offsetof(CPUState, sr[3]) },
3078 { "sr4", offsetof(CPUState, sr[4]) },
3079 { "sr5", offsetof(CPUState, sr[5]) },
3080 { "sr6", offsetof(CPUState, sr[6]) },
3081 { "sr7", offsetof(CPUState, sr[7]) },
3082 { "sr8", offsetof(CPUState, sr[8]) },
3083 { "sr9", offsetof(CPUState, sr[9]) },
3084 { "sr10", offsetof(CPUState, sr[10]) },
3085 { "sr11", offsetof(CPUState, sr[11]) },
3086 { "sr12", offsetof(CPUState, sr[12]) },
3087 { "sr13", offsetof(CPUState, sr[13]) },
3088 { "sr14", offsetof(CPUState, sr[14]) },
3089 { "sr15", offsetof(CPUState, sr[15]) },
3090 /* Too lazy to put BATs and SPRs ... */
3091 #elif defined(TARGET_SPARC)
3092 { "g0", offsetof(CPUState, gregs[0]) },
3093 { "g1", offsetof(CPUState, gregs[1]) },
3094 { "g2", offsetof(CPUState, gregs[2]) },
3095 { "g3", offsetof(CPUState, gregs[3]) },
3096 { "g4", offsetof(CPUState, gregs[4]) },
3097 { "g5", offsetof(CPUState, gregs[5]) },
3098 { "g6", offsetof(CPUState, gregs[6]) },
3099 { "g7", offsetof(CPUState, gregs[7]) },
3100 { "o0", 0, monitor_get_reg },
3101 { "o1", 1, monitor_get_reg },
3102 { "o2", 2, monitor_get_reg },
3103 { "o3", 3, monitor_get_reg },
3104 { "o4", 4, monitor_get_reg },
3105 { "o5", 5, monitor_get_reg },
3106 { "o6", 6, monitor_get_reg },
3107 { "o7", 7, monitor_get_reg },
3108 { "l0", 8, monitor_get_reg },
3109 { "l1", 9, monitor_get_reg },
3110 { "l2", 10, monitor_get_reg },
3111 { "l3", 11, monitor_get_reg },
3112 { "l4", 12, monitor_get_reg },
3113 { "l5", 13, monitor_get_reg },
3114 { "l6", 14, monitor_get_reg },
3115 { "l7", 15, monitor_get_reg },
3116 { "i0", 16, monitor_get_reg },
3117 { "i1", 17, monitor_get_reg },
3118 { "i2", 18, monitor_get_reg },
3119 { "i3", 19, monitor_get_reg },
3120 { "i4", 20, monitor_get_reg },
3121 { "i5", 21, monitor_get_reg },
3122 { "i6", 22, monitor_get_reg },
3123 { "i7", 23, monitor_get_reg },
3124 { "pc", offsetof(CPUState, pc) },
3125 { "npc", offsetof(CPUState, npc) },
3126 { "y", offsetof(CPUState, y) },
3127 #ifndef TARGET_SPARC64
3128 { "psr", 0, &monitor_get_psr, },
3129 { "wim", offsetof(CPUState, wim) },
3130 #endif
3131 { "tbr", offsetof(CPUState, tbr) },
3132 { "fsr", offsetof(CPUState, fsr) },
3133 { "f0", offsetof(CPUState, fpr[0]) },
3134 { "f1", offsetof(CPUState, fpr[1]) },
3135 { "f2", offsetof(CPUState, fpr[2]) },
3136 { "f3", offsetof(CPUState, fpr[3]) },
3137 { "f4", offsetof(CPUState, fpr[4]) },
3138 { "f5", offsetof(CPUState, fpr[5]) },
3139 { "f6", offsetof(CPUState, fpr[6]) },
3140 { "f7", offsetof(CPUState, fpr[7]) },
3141 { "f8", offsetof(CPUState, fpr[8]) },
3142 { "f9", offsetof(CPUState, fpr[9]) },
3143 { "f10", offsetof(CPUState, fpr[10]) },
3144 { "f11", offsetof(CPUState, fpr[11]) },
3145 { "f12", offsetof(CPUState, fpr[12]) },
3146 { "f13", offsetof(CPUState, fpr[13]) },
3147 { "f14", offsetof(CPUState, fpr[14]) },
3148 { "f15", offsetof(CPUState, fpr[15]) },
3149 { "f16", offsetof(CPUState, fpr[16]) },
3150 { "f17", offsetof(CPUState, fpr[17]) },
3151 { "f18", offsetof(CPUState, fpr[18]) },
3152 { "f19", offsetof(CPUState, fpr[19]) },
3153 { "f20", offsetof(CPUState, fpr[20]) },
3154 { "f21", offsetof(CPUState, fpr[21]) },
3155 { "f22", offsetof(CPUState, fpr[22]) },
3156 { "f23", offsetof(CPUState, fpr[23]) },
3157 { "f24", offsetof(CPUState, fpr[24]) },
3158 { "f25", offsetof(CPUState, fpr[25]) },
3159 { "f26", offsetof(CPUState, fpr[26]) },
3160 { "f27", offsetof(CPUState, fpr[27]) },
3161 { "f28", offsetof(CPUState, fpr[28]) },
3162 { "f29", offsetof(CPUState, fpr[29]) },
3163 { "f30", offsetof(CPUState, fpr[30]) },
3164 { "f31", offsetof(CPUState, fpr[31]) },
3165 #ifdef TARGET_SPARC64
3166 { "f32", offsetof(CPUState, fpr[32]) },
3167 { "f34", offsetof(CPUState, fpr[34]) },
3168 { "f36", offsetof(CPUState, fpr[36]) },
3169 { "f38", offsetof(CPUState, fpr[38]) },
3170 { "f40", offsetof(CPUState, fpr[40]) },
3171 { "f42", offsetof(CPUState, fpr[42]) },
3172 { "f44", offsetof(CPUState, fpr[44]) },
3173 { "f46", offsetof(CPUState, fpr[46]) },
3174 { "f48", offsetof(CPUState, fpr[48]) },
3175 { "f50", offsetof(CPUState, fpr[50]) },
3176 { "f52", offsetof(CPUState, fpr[52]) },
3177 { "f54", offsetof(CPUState, fpr[54]) },
3178 { "f56", offsetof(CPUState, fpr[56]) },
3179 { "f58", offsetof(CPUState, fpr[58]) },
3180 { "f60", offsetof(CPUState, fpr[60]) },
3181 { "f62", offsetof(CPUState, fpr[62]) },
3182 { "asi", offsetof(CPUState, asi) },
3183 { "pstate", offsetof(CPUState, pstate) },
3184 { "cansave", offsetof(CPUState, cansave) },
3185 { "canrestore", offsetof(CPUState, canrestore) },
3186 { "otherwin", offsetof(CPUState, otherwin) },
3187 { "wstate", offsetof(CPUState, wstate) },
3188 { "cleanwin", offsetof(CPUState, cleanwin) },
3189 { "fprs", offsetof(CPUState, fprs) },
3190 #endif
3191 #endif
3192 { NULL },
3193 };
3194
3195 static void expr_error(Monitor *mon, const char *msg)
3196 {
3197 monitor_printf(mon, "%s\n", msg);
3198 longjmp(expr_env, 1);
3199 }
3200
3201 /* return 0 if OK, -1 if not found */
3202 static int get_monitor_def(target_long *pval, const char *name)
3203 {
3204 const MonitorDef *md;
3205 void *ptr;
3206
3207 for(md = monitor_defs; md->name != NULL; md++) {
3208 if (compare_cmd(name, md->name)) {
3209 if (md->get_value) {
3210 *pval = md->get_value(md, md->offset);
3211 } else {
3212 CPUState *env = mon_get_cpu();
3213 ptr = (uint8_t *)env + md->offset;
3214 switch(md->type) {
3215 case MD_I32:
3216 *pval = *(int32_t *)ptr;
3217 break;
3218 case MD_TLONG:
3219 *pval = *(target_long *)ptr;
3220 break;
3221 default:
3222 *pval = 0;
3223 break;
3224 }
3225 }
3226 return 0;
3227 }
3228 }
3229 return -1;
3230 }
3231
3232 static void next(void)
3233 {
3234 if (*pch != '\0') {
3235 pch++;
3236 while (qemu_isspace(*pch))
3237 pch++;
3238 }
3239 }
3240
3241 static int64_t expr_sum(Monitor *mon);
3242
3243 static int64_t expr_unary(Monitor *mon)
3244 {
3245 int64_t n;
3246 char *p;
3247 int ret;
3248
3249 switch(*pch) {
3250 case '+':
3251 next();
3252 n = expr_unary(mon);
3253 break;
3254 case '-':
3255 next();
3256 n = -expr_unary(mon);
3257 break;
3258 case '~':
3259 next();
3260 n = ~expr_unary(mon);
3261 break;
3262 case '(':
3263 next();
3264 n = expr_sum(mon);
3265 if (*pch != ')') {
3266 expr_error(mon, "')' expected");
3267 }
3268 next();
3269 break;
3270 case '\'':
3271 pch++;
3272 if (*pch == '\0')
3273 expr_error(mon, "character constant expected");
3274 n = *pch;
3275 pch++;
3276 if (*pch != '\'')
3277 expr_error(mon, "missing terminating \' character");
3278 next();
3279 break;
3280 case '$':
3281 {
3282 char buf[128], *q;
3283 target_long reg=0;
3284
3285 pch++;
3286 q = buf;
3287 while ((*pch >= 'a' && *pch <= 'z') ||
3288 (*pch >= 'A' && *pch <= 'Z') ||
3289 (*pch >= '0' && *pch <= '9') ||
3290 *pch == '_' || *pch == '.') {
3291 if ((q - buf) < sizeof(buf) - 1)
3292 *q++ = *pch;
3293 pch++;
3294 }
3295 while (qemu_isspace(*pch))
3296 pch++;
3297 *q = 0;
3298 ret = get_monitor_def(&reg, buf);
3299 if (ret < 0)
3300 expr_error(mon, "unknown register");
3301 n = reg;
3302 }
3303 break;
3304 case '\0':
3305 expr_error(mon, "unexpected end of expression");
3306 n = 0;
3307 break;
3308 default:
3309 #if TARGET_PHYS_ADDR_BITS > 32
3310 n = strtoull(pch, &p, 0);
3311 #else
3312 n = strtoul(pch, &p, 0);
3313 #endif
3314 if (pch == p) {
3315 expr_error(mon, "invalid char in expression");
3316 }
3317 pch = p;
3318 while (qemu_isspace(*pch))
3319 pch++;
3320 break;
3321 }
3322 return n;
3323 }
3324
3325
3326 static int64_t expr_prod(Monitor *mon)
3327 {
3328 int64_t val, val2;
3329 int op;
3330
3331 val = expr_unary(mon);
3332 for(;;) {
3333 op = *pch;
3334 if (op != '*' && op != '/' && op != '%')
3335 break;
3336 next();
3337 val2 = expr_unary(mon);
3338 switch(op) {
3339 default:
3340 case '*':
3341 val *= val2;
3342 break;
3343 case '/':
3344 case '%':
3345 if (val2 == 0)
3346 expr_error(mon, "division by zero");
3347 if (op == '/')
3348 val /= val2;
3349 else
3350 val %= val2;
3351 break;
3352 }
3353 }
3354 return val;
3355 }
3356
3357 static int64_t expr_logic(Monitor *mon)
3358 {
3359 int64_t val, val2;
3360 int op;
3361
3362 val = expr_prod(mon);
3363 for(;;) {
3364 op = *pch;
3365 if (op != '&' && op != '|' && op != '^')
3366 break;
3367 next();
3368 val2 = expr_prod(mon);
3369 switch(op) {
3370 default:
3371 case '&':
3372 val &= val2;
3373 break;
3374 case '|':
3375 val |= val2;
3376 break;
3377 case '^':
3378 val ^= val2;
3379 break;
3380 }
3381 }
3382 return val;
3383 }
3384
3385 static int64_t expr_sum(Monitor *mon)
3386 {
3387 int64_t val, val2;
3388 int op;
3389
3390 val = expr_logic(mon);
3391 for(;;) {
3392 op = *pch;
3393 if (op != '+' && op != '-')
3394 break;
3395 next();
3396 val2 = expr_logic(mon);
3397 if (op == '+')
3398 val += val2;
3399 else
3400 val -= val2;
3401 }
3402 return val;
3403 }
3404
3405 static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
3406 {
3407 pch = *pp;
3408 if (setjmp(expr_env)) {
3409 *pp = pch;
3410 return -1;
3411 }
3412 while (qemu_isspace(*pch))
3413 pch++;
3414 *pval = expr_sum(mon);
3415 *pp = pch;
3416 return 0;
3417 }
3418
3419 static int get_double(Monitor *mon, double *pval, const char **pp)
3420 {
3421 const char *p = *pp;
3422 char *tailp;
3423 double d;
3424
3425 d = strtod(p, &tailp);
3426 if (tailp == p) {
3427 monitor_printf(mon, "Number expected\n");
3428 return -1;
3429 }
3430 if (d != d || d - d != 0) {
3431 /* NaN or infinity */
3432 monitor_printf(mon, "Bad number\n");
3433 return -1;
3434 }
3435 *pval = d;
3436 *pp = tailp;
3437 return 0;
3438 }
3439
3440 static int get_str(char *buf, int buf_size, const char **pp)
3441 {
3442 const char *p;
3443 char *q;
3444 int c;
3445
3446 q = buf;
3447 p = *pp;
3448 while (qemu_isspace(*p))
3449 p++;
3450 if (*p == '\0') {
3451 fail:
3452 *q = '\0';
3453 *pp = p;
3454 return -1;
3455 }
3456 if (*p == '\"') {
3457 p++;
3458 while (*p != '\0' && *p != '\"') {
3459 if (*p == '\\') {
3460 p++;
3461 c = *p++;
3462 switch(c) {
3463 case 'n':
3464 c = '\n';
3465 break;
3466 case 'r':
3467 c = '\r';
3468 break;
3469 case '\\':
3470 case '\'':
3471 case '\"':
3472 break;
3473 default:
3474 qemu_printf("unsupported escape code: '\\%c'\n", c);
3475 goto fail;
3476 }
3477 if ((q - buf) < buf_size - 1) {
3478 *q++ = c;
3479 }
3480 } else {
3481 if ((q - buf) < buf_size - 1) {
3482 *q++ = *p;
3483 }
3484 p++;
3485 }
3486 }
3487 if (*p != '\"') {
3488 qemu_printf("unterminated string\n");
3489 goto fail;
3490 }
3491 p++;
3492 } else {
3493 while (*p != '\0' && !qemu_isspace(*p)) {
3494 if ((q - buf) < buf_size - 1) {
3495 *q++ = *p;
3496 }
3497 p++;
3498 }
3499 }
3500 *q = '\0';
3501 *pp = p;
3502 return 0;
3503 }
3504
3505 /*
3506 * Store the command-name in cmdname, and return a pointer to
3507 * the remaining of the command string.
3508 */
3509 static const char *get_command_name(const char *cmdline,
3510 char *cmdname, size_t nlen)
3511 {
3512 size_t len;
3513 const char *p, *pstart;
3514
3515 p = cmdline;
3516 while (qemu_isspace(*p))
3517 p++;
3518 if (*p == '\0')
3519 return NULL;
3520 pstart = p;
3521 while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
3522 p++;
3523 len = p - pstart;
3524 if (len > nlen - 1)
3525 len = nlen - 1;
3526 memcpy(cmdname, pstart, len);
3527 cmdname[len] = '\0';
3528 return p;
3529 }
3530
3531 /**
3532 * Read key of 'type' into 'key' and return the current
3533 * 'type' pointer.
3534 */
3535 static char *key_get_info(const char *type, char **key)
3536 {
3537 size_t len;
3538 char *p, *str;
3539
3540 if (*type == ',')
3541 type++;
3542
3543 p = strchr(type, ':');
3544 if (!p) {
3545 *key = NULL;
3546 return NULL;
3547 }
3548 len = p - type;
3549
3550 str = qemu_malloc(len + 1);
3551 memcpy(str, type, len);
3552 str[len] = '\0';
3553
3554 *key = str;
3555 return ++p;
3556 }
3557
3558 static int default_fmt_format = 'x';
3559 static int default_fmt_size = 4;
3560
3561 #define MAX_ARGS 16
3562
3563 static int is_valid_option(const char *c, const char *typestr)
3564 {
3565 char option[3];
3566
3567 option[0] = '-';
3568 option[1] = *c;
3569 option[2] = '\0';
3570
3571 typestr = strstr(typestr, option);
3572 return (typestr != NULL);
3573 }
3574
3575 static const mon_cmd_t *monitor_find_command(const char *cmdname)
3576 {
3577 const mon_cmd_t *cmd;
3578
3579 for (cmd = mon_cmds; cmd->name != NULL; cmd++) {
3580 if (compare_cmd(cmdname, cmd->name)) {
3581 return cmd;
3582 }
3583 }
3584
3585 return NULL;
3586 }
3587
3588 static const mon_cmd_t *monitor_parse_command(Monitor *mon,
3589 const char *cmdline,
3590 QDict *qdict)
3591 {
3592 const char *p, *typestr;
3593 int c;
3594 const mon_cmd_t *cmd;
3595 char cmdname[256];
3596 char buf[1024];
3597 char *key;
3598
3599 #ifdef DEBUG
3600 monitor_printf(mon, "command='%s'\n", cmdline);
3601 #endif
3602
3603 /* extract the command name */
3604 p = get_command_name(cmdline, cmdname, sizeof(cmdname));
3605 if (!p)
3606 return NULL;
3607
3608 cmd = monitor_find_command(cmdname);
3609 if (!cmd) {
3610 monitor_printf(mon, "unknown command: '%s'\n", cmdname);
3611 return NULL;
3612 }
3613
3614 /* parse the parameters */
3615 typestr = cmd->args_type;
3616 for(;;) {
3617 typestr = key_get_info(typestr, &key);
3618 if (!typestr)
3619 break;
3620 c = *typestr;
3621 typestr++;
3622 switch(c) {
3623 case 'F':
3624 case 'B':
3625 case 's':
3626 {
3627 int ret;
3628
3629 while (qemu_isspace(*p))
3630 p++;
3631 if (*typestr == '?') {
3632 typestr++;
3633 if (*p == '\0') {
3634 /* no optional string: NULL argument */
3635 break;
3636 }
3637 }
3638 ret = get_str(buf, sizeof(buf), &p);
3639 if (ret < 0) {
3640 switch(c) {
3641 case 'F':
3642 monitor_printf(mon, "%s: filename expected\n",
3643 cmdname);
3644 break;
3645 case 'B':
3646 monitor_printf(mon, "%s: block device name expected\n",
3647 cmdname);
3648 break;
3649 default:
3650 monitor_printf(mon, "%s: string expected\n", cmdname);
3651 break;
3652 }
3653 goto fail;
3654 }
3655 qdict_put(qdict, key, qstring_from_str(buf));
3656 }
3657 break;
3658 case 'O':
3659 {
3660 QemuOptsList *opts_list;
3661 QemuOpts *opts;
3662
3663 opts_list = qemu_find_opts(key);
3664 if (!opts_list || opts_list->desc->name) {
3665 goto bad_type;
3666 }
3667 while (qemu_isspace(*p)) {
3668 p++;
3669 }
3670 if (!*p)
3671 break;
3672 if (get_str(buf, sizeof(buf), &p) < 0) {
3673 goto fail;
3674 }
3675 opts = qemu_opts_parse(opts_list, buf, 1);
3676 if (!opts) {
3677 goto fail;
3678 }
3679 qemu_opts_to_qdict(opts, qdict);
3680 qemu_opts_del(opts);
3681 }
3682 break;
3683 case '/':
3684 {
3685 int count, format, size;
3686
3687 while (qemu_isspace(*p))
3688 p++;
3689 if (*p == '/') {
3690 /* format found */
3691 p++;
3692 count = 1;
3693 if (qemu_isdigit(*p)) {
3694 count = 0;
3695 while (qemu_isdigit(*p)) {
3696 count = count * 10 + (*p - '0');
3697 p++;
3698 }
3699 }
3700 size = -1;
3701 format = -1;
3702 for(;;) {
3703 switch(*p) {
3704 case 'o':
3705 case 'd':
3706 case 'u':
3707 case 'x':
3708 case 'i':
3709 case 'c':
3710 format = *p++;
3711 break;
3712 case 'b':
3713 size = 1;
3714 p++;
3715 break;
3716 case 'h':
3717 size = 2;
3718 p++;
3719 break;
3720 case 'w':
3721 size = 4;
3722 p++;
3723 break;
3724 case 'g':
3725 case 'L':
3726 size = 8;
3727 p++;
3728 break;
3729 default:
3730 goto next;
3731 }
3732 }
3733 next:
3734 if (*p != '\0' && !qemu_isspace(*p)) {
3735 monitor_printf(mon, "invalid char in format: '%c'\n",
3736 *p);
3737 goto fail;
3738 }
3739 if (format < 0)
3740 format = default_fmt_format;
3741 if (format != 'i') {
3742 /* for 'i', not specifying a size gives -1 as size */
3743 if (size < 0)
3744 size = default_fmt_size;
3745 default_fmt_size = size;
3746 }
3747 default_fmt_format = format;
3748 } else {
3749 count = 1;
3750 format = default_fmt_format;
3751 if (format != 'i') {
3752 size = default_fmt_size;
3753 } else {
3754 size = -1;
3755 }
3756 }
3757 qdict_put(qdict, "count", qint_from_int(count));
3758 qdict_put(qdict, "format", qint_from_int(format));
3759 qdict_put(qdict, "size", qint_from_int(size));
3760 }
3761 break;
3762 case 'i':
3763 case 'l':
3764 case 'M':
3765 {
3766 int64_t val;
3767
3768 while (qemu_isspace(*p))
3769 p++;
3770 if (*typestr == '?' || *typestr == '.') {
3771 if (*typestr == '?') {
3772 if (*p == '\0') {
3773 typestr++;
3774 break;
3775 }
3776 } else {
3777 if (*p == '.') {
3778 p++;
3779 while (qemu_isspace(*p))
3780 p++;
3781 } else {
3782 typestr++;
3783 break;
3784 }
3785 }
3786 typestr++;
3787 }
3788 if (get_expr(mon, &val, &p))
3789 goto fail;
3790 /* Check if 'i' is greater than 32-bit */
3791 if ((c == 'i') && ((val >> 32) & 0xffffffff)) {
3792 monitor_printf(mon, "\'%s\' has failed: ", cmdname);
3793 monitor_printf(mon, "integer is for 32-bit values\n");
3794 goto fail;
3795 } else if (c == 'M') {
3796 val <<= 20;
3797 }
3798 qdict_put(qdict, key, qint_from_int(val));
3799 }
3800 break;
3801 case 'b':
3802 case 'T':
3803 {
3804 double val;
3805
3806 while (qemu_isspace(*p))
3807 p++;
3808 if (*typestr == '?') {
3809 typestr++;
3810 if (*p == '\0') {
3811 break;
3812 }
3813 }
3814 if (get_double(mon, &val, &p) < 0) {
3815 goto fail;
3816 }
3817 if (c == 'b' && *p) {
3818 switch (*p) {
3819 case 'K': case 'k':
3820 val *= 1 << 10; p++; break;
3821 case 'M': case 'm':
3822 val *= 1 << 20; p++; break;
3823 case 'G': case 'g':
3824 val *= 1 << 30; p++; break;
3825 }
3826 }
3827 if (c == 'T' && p[0] && p[1] == 's') {
3828 switch (*p) {
3829 case 'm':
3830 val /= 1e3; p += 2; break;
3831 case 'u':
3832 val /= 1e6; p += 2; break;
3833 case 'n':
3834 val /= 1e9; p += 2; break;
3835 }
3836 }
3837 if (*p && !qemu_isspace(*p)) {
3838 monitor_printf(mon, "Unknown unit suffix\n");
3839 goto fail;
3840 }
3841 qdict_put(qdict, key, qfloat_from_double(val));
3842 }
3843 break;
3844 case '-':
3845 {
3846 const char *tmp = p;
3847 int has_option, skip_key = 0;
3848 /* option */
3849
3850 c = *typestr++;
3851 if (c == '\0')
3852 goto bad_type;
3853 while (qemu_isspace(*p))
3854 p++;
3855 has_option = 0;
3856 if (*p == '-') {
3857 p++;
3858 if(c != *p) {
3859 if(!is_valid_option(p, typestr)) {
3860
3861 monitor_printf(mon, "%s: unsupported option -%c\n",
3862 cmdname, *p);
3863 goto fail;
3864 } else {
3865 skip_key = 1;
3866 }
3867 }
3868 if(skip_key) {
3869 p = tmp;
3870 } else {
3871 p++;
3872 has_option = 1;
3873 }
3874 }
3875 qdict_put(qdict, key, qint_from_int(has_option));
3876 }
3877 break;
3878 default:
3879 bad_type:
3880 monitor_printf(mon, "%s: unknown type '%c'\n", cmdname, c);
3881 goto fail;
3882 }
3883 qemu_free(key);
3884 key = NULL;
3885 }
3886 /* check that all arguments were parsed */
3887 while (qemu_isspace(*p))
3888 p++;
3889 if (*p != '\0') {
3890 monitor_printf(mon, "%s: extraneous characters at the end of line\n",
3891 cmdname);
3892 goto fail;
3893 }
3894
3895 return cmd;
3896
3897 fail:
3898 qemu_free(key);
3899 return NULL;
3900 }
3901
3902 void monitor_set_error(Monitor *mon, QError *qerror)
3903 {
3904 /* report only the first error */
3905 if (!mon->error) {
3906 mon->error = qerror;
3907 } else {
3908 MON_DEBUG("Additional error report at %s:%d\n",
3909 qerror->file, qerror->linenr);
3910 QDECREF(qerror);
3911 }
3912 }
3913
3914 static int is_async_return(const QObject *data)
3915 {
3916 if (data && qobject_type(data) == QTYPE_QDICT) {
3917 return qdict_haskey(qobject_to_qdict(data), "__mon_async");
3918 }
3919
3920 return 0;
3921 }
3922
3923 static void handler_audit(Monitor *mon, const mon_cmd_t *cmd, int ret)
3924 {
3925 if (monitor_ctrl_mode(mon)) {
3926 if (ret && !monitor_has_error(mon)) {
3927 /*
3928 * If it returns failure, it must have passed on error.
3929 *
3930 * Action: Report an internal error to the client if in QMP.
3931 */
3932 qerror_report(QERR_UNDEFINED_ERROR);
3933 MON_DEBUG("command '%s' returned failure but did not pass an error\n",
3934 cmd->name);
3935 }
3936
3937 #ifdef CONFIG_DEBUG_MONITOR
3938 if (!ret && monitor_has_error(mon)) {
3939 /*
3940 * If it returns success, it must not have passed an error.
3941 *
3942 * Action: Report the passed error to the client.
3943 */
3944 MON_DEBUG("command '%s' returned success but passed an error\n",
3945 cmd->name);
3946 }
3947
3948 if (mon_print_count_get(mon) > 0 && strcmp(cmd->name, "info") != 0) {
3949 /*
3950 * Handlers should not call Monitor print functions.
3951 *
3952 * Action: Ignore them in QMP.
3953 *
3954 * (XXX: we don't check any 'info' or 'query' command here
3955 * because the user print function _is_ called by do_info(), hence
3956 * we will trigger this check. This problem will go away when we
3957 * make 'query' commands real and kill do_info())
3958 */
3959 MON_DEBUG("command '%s' called print functions %d time(s)\n",
3960 cmd->name, mon_print_count_get(mon));
3961 }
3962 #endif
3963 } else {
3964 assert(!monitor_has_error(mon));
3965 QDECREF(mon->error);
3966 mon->error = NULL;
3967 }
3968 }
3969
3970 static void monitor_call_handler(Monitor *mon, const mon_cmd_t *cmd,
3971 const QDict *params)
3972 {
3973 int ret;
3974 QObject *data = NULL;
3975
3976 mon_print_count_init(mon);
3977
3978 ret = cmd->mhandler.cmd_new(mon, params, &data);
3979 handler_audit(mon, cmd, ret);
3980
3981 if (is_async_return(data)) {
3982 /*
3983 * Asynchronous commands have no initial return data but they can
3984 * generate errors. Data is returned via the async completion handler.
3985 */
3986 if (monitor_ctrl_mode(mon) && monitor_has_error(mon)) {
3987 monitor_protocol_emitter(mon, NULL);
3988 }
3989 } else if (monitor_ctrl_mode(mon)) {
3990 /* Monitor Protocol */
3991 monitor_protocol_emitter(mon, data);
3992 } else {
3993 /* User Protocol */
3994 if (data)
3995 cmd->user_print(mon, data);
3996 }
3997
3998 qobject_decref(data);
3999 }
4000
4001 static void handle_user_command(Monitor *mon, const char *cmdline)
4002 {
4003 QDict *qdict;
4004 const mon_cmd_t *cmd;
4005
4006 qdict = qdict_new();
4007
4008 cmd = monitor_parse_command(mon, cmdline, qdict);
4009 if (!cmd)
4010 goto out;
4011
4012 if (monitor_handler_is_async(cmd)) {
4013 user_async_cmd_handler(mon, cmd, qdict);
4014 } else if (monitor_handler_ported(cmd)) {
4015 monitor_call_handler(mon, cmd, qdict);
4016 } else {
4017 cmd->mhandler.cmd(mon, qdict);
4018 }
4019
4020 out:
4021 QDECREF(qdict);
4022 }
4023
4024 static void cmd_completion(const char *name, const char *list)
4025 {
4026 const char *p, *pstart;
4027 char cmd[128];
4028 int len;
4029
4030 p = list;
4031 for(;;) {
4032 pstart = p;
4033 p = strchr(p, '|');
4034 if (!p)
4035 p = pstart + strlen(pstart);
4036 len = p - pstart;
4037 if (len > sizeof(cmd) - 2)
4038 len = sizeof(cmd) - 2;
4039 memcpy(cmd, pstart, len);
4040 cmd[len] = '\0';
4041 if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
4042 readline_add_completion(cur_mon->rs, cmd);
4043 }
4044 if (*p == '\0')
4045 break;
4046 p++;
4047 }
4048 }
4049
4050 static void file_completion(const char *input)
4051 {
4052 DIR *ffs;
4053 struct dirent *d;
4054 char path[1024];
4055 char file[1024], file_prefix[1024];
4056 int input_path_len;
4057 const char *p;
4058
4059 p = strrchr(input, '/');
4060 if (!p) {
4061 input_path_len = 0;
4062 pstrcpy(file_prefix, sizeof(file_prefix), input);
4063 pstrcpy(path, sizeof(path), ".");
4064 } else {
4065 input_path_len = p - input + 1;
4066 memcpy(path, input, input_path_len);
4067 if (input_path_len > sizeof(path) - 1)
4068 input_path_len = sizeof(path) - 1;
4069 path[input_path_len] = '\0';
4070 pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
4071 }
4072 #ifdef DEBUG_COMPLETION
4073 monitor_printf(cur_mon, "input='%s' path='%s' prefix='%s'\n",
4074 input, path, file_prefix);
4075 #endif
4076 ffs = opendir(path);
4077 if (!ffs)
4078 return;
4079 for(;;) {
4080 struct stat sb;
4081 d = readdir(ffs);
4082 if (!d)
4083 break;
4084 if (strstart(d->d_name, file_prefix, NULL)) {
4085 memcpy(file, input, input_path_len);
4086 if (input_path_len < sizeof(file))
4087 pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
4088 d->d_name);
4089 /* stat the file to find out if it's a directory.
4090 * In that case add a slash to speed up typing long paths
4091 */
4092 stat(file, &sb);
4093 if(S_ISDIR(sb.st_mode))
4094 pstrcat(file, sizeof(file), "/");
4095 readline_add_completion(cur_mon->rs, file);
4096 }
4097 }
4098 closedir(ffs);
4099 }
4100
4101 static void block_completion_it(void *opaque, BlockDriverState *bs)
4102 {
4103 const char *name = bdrv_get_device_name(bs);
4104 const char *input = opaque;
4105
4106 if (input[0] == '\0' ||
4107 !strncmp(name, (char *)input, strlen(input))) {
4108 readline_add_completion(cur_mon->rs, name);
4109 }
4110 }
4111
4112 /* NOTE: this parser is an approximate form of the real command parser */
4113 static void parse_cmdline(const char *cmdline,
4114 int *pnb_args, char **args)
4115 {
4116 const char *p;
4117 int nb_args, ret;
4118 char buf[1024];
4119
4120 p = cmdline;
4121 nb_args = 0;
4122 for(;;) {
4123 while (qemu_isspace(*p))
4124 p++;
4125 if (*p == '\0')
4126 break;
4127 if (nb_args >= MAX_ARGS)
4128 break;
4129 ret = get_str(buf, sizeof(buf), &p);
4130 args[nb_args] = qemu_strdup(buf);
4131 nb_args++;
4132 if (ret < 0)
4133 break;
4134 }
4135 *pnb_args = nb_args;
4136 }
4137
4138 static const char *next_arg_type(const char *typestr)
4139 {
4140 const char *p = strchr(typestr, ':');
4141 return (p != NULL ? ++p : typestr);
4142 }
4143
4144 static void monitor_find_completion(const char *cmdline)
4145 {
4146 const char *cmdname;
4147 char *args[MAX_ARGS];
4148 int nb_args, i, len;
4149 const char *ptype, *str;
4150 const mon_cmd_t *cmd;
4151 const KeyDef *key;
4152
4153 parse_cmdline(cmdline, &nb_args, args);
4154 #ifdef DEBUG_COMPLETION
4155 for(i = 0; i < nb_args; i++) {
4156 monitor_printf(cur_mon, "arg%d = '%s'\n", i, (char *)args[i]);
4157 }
4158 #endif
4159
4160 /* if the line ends with a space, it means we want to complete the
4161 next arg */
4162 len = strlen(cmdline);
4163 if (len > 0 && qemu_isspace(cmdline[len - 1])) {
4164 if (nb_args >= MAX_ARGS)
4165 return;
4166 args[nb_args++] = qemu_strdup("");
4167 }
4168 if (nb_args <= 1) {
4169 /* command completion */
4170 if (nb_args == 0)
4171 cmdname = "";
4172 else
4173 cmdname = args[0];
4174 readline_set_completion_index(cur_mon->rs, strlen(cmdname));
4175 for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
4176 cmd_completion(cmdname, cmd->name);
4177 }
4178 } else {
4179 /* find the command */
4180 for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
4181 if (compare_cmd(args[0], cmd->name))
4182 goto found;
4183 }
4184 return;
4185 found:
4186 ptype = next_arg_type(cmd->args_type);
4187 for(i = 0; i < nb_args - 2; i++) {
4188 if (*ptype != '\0') {
4189 ptype = next_arg_type(ptype);
4190 while (*ptype == '?')
4191 ptype = next_arg_type(ptype);
4192 }
4193 }
4194 str = args[nb_args - 1];
4195 if (*ptype == '-' && ptype[1] != '\0') {
4196 ptype += 2;
4197 }
4198 switch(*ptype) {
4199 case 'F':
4200 /* file completion */
4201 readline_set_completion_index(cur_mon->rs, strlen(str));
4202 file_completion(str);
4203 break;
4204 case 'B':
4205 /* block device name completion */
4206 readline_set_completion_index(cur_mon->rs, strlen(str));
4207 bdrv_iterate(block_completion_it, (void *)str);
4208 break;
4209 case 's':
4210 /* XXX: more generic ? */
4211 if (!strcmp(cmd->name, "info")) {
4212 readline_set_completion_index(cur_mon->rs, strlen(str));
4213 for(cmd = info_cmds; cmd->name != NULL; cmd++) {
4214 cmd_completion(str, cmd->name);
4215 }
4216 } else if (!strcmp(cmd->name, "sendkey")) {
4217 char *sep = strrchr(str, '-');
4218 if (sep)
4219 str = sep + 1;
4220 readline_set_completion_index(cur_mon->rs, strlen(str));
4221 for(key = key_defs; key->name != NULL; key++) {
4222 cmd_completion(str, key->name);
4223 }
4224 } else if (!strcmp(cmd->name, "help|?")) {
4225 readline_set_completion_index(cur_mon->rs, strlen(str));
4226 for (cmd = mon_cmds; cmd->name != NULL; cmd++) {
4227 cmd_completion(str, cmd->name);
4228 }
4229 }
4230 break;
4231 default:
4232 break;
4233 }
4234 }
4235 for(i = 0; i < nb_args; i++)
4236 qemu_free(args[i]);
4237 }
4238
4239 static int monitor_can_read(void *opaque)
4240 {
4241 Monitor *mon = opaque;
4242
4243 return (mon->suspend_cnt == 0) ? 1 : 0;
4244 }
4245
4246 typedef struct CmdArgs {
4247 QString *name;
4248 int type;
4249 int flag;
4250 int optional;
4251 } CmdArgs;
4252
4253 static int check_opt(const CmdArgs *cmd_args, const char *name, QDict *args)
4254 {
4255 if (!cmd_args->optional) {
4256 qerror_report(QERR_MISSING_PARAMETER, name);
4257 return -1;
4258 }
4259
4260 if (cmd_args->type == '-') {
4261 /* handlers expect a value, they need to be changed */
4262 qdict_put(args, name, qint_from_int(0));
4263 }
4264
4265 return 0;
4266 }
4267
4268 static int check_arg(const CmdArgs *cmd_args, QDict *args)
4269 {
4270 QObject *value;
4271 const char *name;
4272
4273 name = qstring_get_str(cmd_args->name);
4274
4275 if (!args) {
4276 return check_opt(cmd_args, name, args);
4277 }
4278
4279 value = qdict_get(args, name);
4280 if (!value) {
4281 return check_opt(cmd_args, name, args);
4282 }
4283
4284 switch (cmd_args->type) {
4285 case 'F':
4286 case 'B':
4287 case 's':
4288 if (qobject_type(value) != QTYPE_QSTRING) {
4289 qerror_report(QERR_INVALID_PARAMETER_TYPE, name, "string");
4290 return -1;
4291 }
4292 break;
4293 case '/': {
4294 int i;
4295 const char *keys[] = { "count", "format", "size", NULL };
4296
4297 for (i = 0; keys[i]; i++) {
4298 QObject *obj = qdict_get(args, keys[i]);
4299 if (!obj) {
4300 qerror_report(QERR_MISSING_PARAMETER, name);
4301 return -1;
4302 }
4303 if (qobject_type(obj) != QTYPE_QINT) {
4304 qerror_report(QERR_INVALID_PARAMETER_TYPE, name, "int");
4305 return -1;
4306 }
4307 }
4308 break;
4309 }
4310 case 'i':
4311 case 'l':
4312 case 'M':
4313 if (qobject_type(value) != QTYPE_QINT) {
4314 qerror_report(QERR_INVALID_PARAMETER_TYPE, name, "int");
4315 return -1;
4316 }
4317 break;
4318 case 'b':
4319 case 'T':
4320 if (qobject_type(value) != QTYPE_QINT && qobject_type(value) != QTYPE_QFLOAT) {
4321 qerror_report(QERR_INVALID_PARAMETER_TYPE, name, "number");
4322 return -1;
4323 }
4324 break;
4325 case '-':
4326 if (qobject_type(value) != QTYPE_QINT &&
4327 qobject_type(value) != QTYPE_QBOOL) {
4328 qerror_report(QERR_INVALID_PARAMETER_TYPE, name, "bool");
4329 return -1;
4330 }
4331 if (qobject_type(value) == QTYPE_QBOOL) {
4332 /* handlers expect a QInt, they need to be changed */
4333 qdict_put(args, name,
4334 qint_from_int(qbool_get_int(qobject_to_qbool(value))));
4335 }
4336 break;
4337 case 'O':
4338 default:
4339 /* impossible */
4340 abort();
4341 }
4342
4343 return 0;
4344 }
4345
4346 static void cmd_args_init(CmdArgs *cmd_args)
4347 {
4348 cmd_args->name = qstring_new();
4349 cmd_args->type = cmd_args->flag = cmd_args->optional = 0;
4350 }
4351
4352 static int check_opts(QemuOptsList *opts_list, QDict *args)
4353 {
4354 assert(!opts_list->desc->name);
4355 return 0;
4356 }
4357
4358 /*
4359 * This is not trivial, we have to parse Monitor command's argument
4360 * type syntax to be able to check the arguments provided by clients.
4361 *
4362 * In the near future we will be using an array for that and will be
4363 * able to drop all this parsing...
4364 */
4365 static int monitor_check_qmp_args(const mon_cmd_t *cmd, QDict *args)
4366 {
4367 int err;
4368 const char *p;
4369 CmdArgs cmd_args;
4370 QemuOptsList *opts_list;
4371
4372 if (cmd->args_type == NULL) {
4373 return (qdict_size(args) == 0 ? 0 : -1);
4374 }
4375
4376 err = 0;
4377 cmd_args_init(&cmd_args);
4378 opts_list = NULL;
4379
4380 for (p = cmd->args_type;; p++) {
4381 if (*p == ':') {
4382 cmd_args.type = *++p;
4383 p++;
4384 if (cmd_args.type == '-') {
4385 cmd_args.flag = *p++;
4386 cmd_args.optional = 1;
4387 } else if (cmd_args.type == 'O') {
4388 opts_list = qemu_find_opts(qstring_get_str(cmd_args.name));
4389 assert(opts_list);
4390 } else if (*p == '?') {
4391 cmd_args.optional = 1;
4392 p++;
4393 }
4394
4395 assert(*p == ',' || *p == '\0');
4396 if (opts_list) {
4397 err = check_opts(opts_list, args);
4398 opts_list = NULL;
4399 } else {
4400 err = check_arg(&cmd_args, args);
4401 QDECREF(cmd_args.name);
4402 cmd_args_init(&cmd_args);
4403 }
4404
4405 if (err < 0) {
4406 break;
4407 }
4408 } else {
4409 qstring_append_chr(cmd_args.name, *p);
4410 }
4411
4412 if (*p == '\0') {
4413 break;
4414 }
4415 }
4416
4417 QDECREF(cmd_args.name);
4418 return err;
4419 }
4420
4421 static int invalid_qmp_mode(const Monitor *mon, const char *cmd_name)
4422 {
4423 int is_cap = compare_cmd(cmd_name, "qmp_capabilities");
4424 return (qmp_cmd_mode(mon) ? is_cap : !is_cap);
4425 }
4426
4427 static void handle_qmp_command(JSONMessageParser *parser, QList *tokens)
4428 {
4429 int err;
4430 QObject *obj;
4431 QDict *input, *args;
4432 const mon_cmd_t *cmd;
4433 Monitor *mon = cur_mon;
4434 const char *cmd_name, *info_item;
4435
4436 args = NULL;
4437
4438 obj = json_parser_parse(tokens, NULL);
4439 if (!obj) {
4440 // FIXME: should be triggered in json_parser_parse()
4441 qerror_report(QERR_JSON_PARSING);
4442 goto err_out;
4443 } else if (qobject_type(obj) != QTYPE_QDICT) {
4444 qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "object");
4445 qobject_decref(obj);
4446 goto err_out;
4447 }
4448
4449 input = qobject_to_qdict(obj);
4450
4451 mon->mc->id = qdict_get(input, "id");
4452 qobject_incref(mon->mc->id);
4453
4454 obj = qdict_get(input, "execute");
4455 if (!obj) {
4456 qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "execute");
4457 goto err_input;
4458 } else if (qobject_type(obj) != QTYPE_QSTRING) {
4459 qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "string");
4460 goto err_input;
4461 }
4462
4463 cmd_name = qstring_get_str(qobject_to_qstring(obj));
4464
4465 if (invalid_qmp_mode(mon, cmd_name)) {
4466 qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);
4467 goto err_input;
4468 }
4469
4470 /*
4471 * XXX: We need this special case until we get info handlers
4472 * converted into 'query-' commands
4473 */
4474 if (compare_cmd(cmd_name, "info")) {
4475 qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);
4476 goto err_input;
4477 } else if (strstart(cmd_name, "query-", &info_item)) {
4478 cmd = monitor_find_command("info");
4479 qdict_put_obj(input, "arguments",
4480 qobject_from_jsonf("{ 'item': %s }", info_item));
4481 } else {
4482 cmd = monitor_find_command(cmd_name);
4483 if (!cmd || !monitor_handler_ported(cmd)) {
4484 qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);
4485 goto err_input;
4486 }
4487 }
4488
4489 obj = qdict_get(input, "arguments");
4490 if (!obj) {
4491 args = qdict_new();
4492 } else {
4493 args = qobject_to_qdict(obj);
4494 QINCREF(args);
4495 }
4496
4497 QDECREF(input);
4498
4499 err = monitor_check_qmp_args(cmd, args);
4500 if (err < 0) {
4501 goto err_out;
4502 }
4503
4504 if (monitor_handler_is_async(cmd)) {
4505 qmp_async_cmd_handler(mon, cmd, args);
4506 } else {
4507 monitor_call_handler(mon, cmd, args);
4508 }
4509 goto out;
4510
4511 err_input:
4512 QDECREF(input);
4513 err_out:
4514 monitor_protocol_emitter(mon, NULL);
4515 out:
4516 QDECREF(args);
4517 }
4518
4519 /**
4520 * monitor_control_read(): Read and handle QMP input
4521 */
4522 static void monitor_control_read(void *opaque, const uint8_t *buf, int size)
4523 {
4524 Monitor *old_mon = cur_mon;
4525
4526 cur_mon = opaque;
4527
4528 json_message_parser_feed(&cur_mon->mc->parser, (const char *) buf, size);
4529
4530 cur_mon = old_mon;
4531 }
4532
4533 static void monitor_read(void *opaque, const uint8_t *buf, int size)
4534 {
4535 Monitor *old_mon = cur_mon;
4536 int i;
4537
4538 cur_mon = opaque;
4539
4540 if (cur_mon->rs) {
4541 for (i = 0; i < size; i++)
4542 readline_handle_byte(cur_mon->rs, buf[i]);
4543 } else {
4544 if (size == 0 || buf[size - 1] != 0)
4545 monitor_printf(cur_mon, "corrupted command\n");
4546 else
4547 handle_user_command(cur_mon, (char *)buf);
4548 }
4549
4550 cur_mon = old_mon;
4551 }
4552
4553 static void monitor_command_cb(Monitor *mon, const char *cmdline, void *opaque)
4554 {
4555 monitor_suspend(mon);
4556 handle_user_command(mon, cmdline);
4557 monitor_resume(mon);
4558 }
4559
4560 int monitor_suspend(Monitor *mon)
4561 {
4562 if (!mon->rs)
4563 return -ENOTTY;
4564 mon->suspend_cnt++;
4565 return 0;
4566 }
4567
4568 void monitor_resume(Monitor *mon)
4569 {
4570 if (!mon->rs)
4571 return;
4572 if (--mon->suspend_cnt == 0)
4573 readline_show_prompt(mon->rs);
4574 }
4575
4576 static QObject *get_qmp_greeting(void)
4577 {
4578 QObject *ver;
4579
4580 do_info_version(NULL, &ver);
4581 return qobject_from_jsonf("{'QMP':{'version': %p,'capabilities': []}}",ver);
4582 }
4583
4584 /**
4585 * monitor_control_event(): Print QMP gretting
4586 */
4587 static void monitor_control_event(void *opaque, int event)
4588 {
4589 QObject *data;
4590 Monitor *mon = opaque;
4591
4592 switch (event) {
4593 case CHR_EVENT_OPENED:
4594 mon->mc->command_mode = 0;
4595 json_message_parser_init(&mon->mc->parser, handle_qmp_command);
4596 data = get_qmp_greeting();
4597 monitor_json_emitter(mon, data);
4598 qobject_decref(data);
4599 break;
4600 case CHR_EVENT_CLOSED:
4601 json_message_parser_destroy(&mon->mc->parser);
4602 break;
4603 }
4604 }
4605
4606 static void monitor_event(void *opaque, int event)
4607 {
4608 Monitor *mon = opaque;
4609
4610 switch (event) {
4611 case CHR_EVENT_MUX_IN:
4612 mon->mux_out = 0;
4613 if (mon->reset_seen) {
4614 readline_restart(mon->rs);
4615 monitor_resume(mon);
4616 monitor_flush(mon);
4617 } else {
4618 mon->suspend_cnt = 0;
4619 }
4620 break;
4621
4622 case CHR_EVENT_MUX_OUT:
4623 if (mon->reset_seen) {
4624 if (mon->suspend_cnt == 0) {
4625 monitor_printf(mon, "\n");
4626 }
4627 monitor_flush(mon);
4628 monitor_suspend(mon);
4629 } else {
4630 mon->suspend_cnt++;
4631 }
4632 mon->mux_out = 1;
4633 break;
4634
4635 case CHR_EVENT_OPENED:
4636 monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
4637 "information\n", QEMU_VERSION);
4638 if (!mon->mux_out) {
4639 readline_show_prompt(mon->rs);
4640 }
4641 mon->reset_seen = 1;
4642 break;
4643 }
4644 }
4645
4646
4647 /*
4648 * Local variables:
4649 * c-indent-level: 4
4650 * c-basic-offset: 4
4651 * tab-width: 8
4652 * End:
4653 */
4654
4655 void monitor_init(CharDriverState *chr, int flags)
4656 {
4657 static int is_first_init = 1;
4658 Monitor *mon;
4659
4660 if (is_first_init) {
4661 key_timer = qemu_new_timer(vm_clock, release_keys, NULL);
4662 is_first_init = 0;
4663 }
4664
4665 mon = qemu_mallocz(sizeof(*mon));
4666
4667 mon->chr = chr;
4668 mon->flags = flags;
4669 if (flags & MONITOR_USE_READLINE) {
4670 mon->rs = readline_init(mon, monitor_find_completion);
4671 monitor_read_command(mon, 0);
4672 }
4673
4674 if (monitor_ctrl_mode(mon)) {
4675 mon->mc = qemu_mallocz(sizeof(MonitorControl));
4676 /* Control mode requires special handlers */
4677 qemu_chr_add_handlers(chr, monitor_can_read, monitor_control_read,
4678 monitor_control_event, mon);
4679 } else {
4680 qemu_chr_add_handlers(chr, monitor_can_read, monitor_read,
4681 monitor_event, mon);
4682 }
4683
4684 QLIST_INSERT_HEAD(&mon_list, mon, entry);
4685 if (!default_mon || (flags & MONITOR_IS_DEFAULT))
4686 default_mon = mon;
4687 }
4688
4689 static void bdrv_password_cb(Monitor *mon, const char *password, void *opaque)
4690 {
4691 BlockDriverState *bs = opaque;
4692 int ret = 0;
4693
4694 if (bdrv_set_key(bs, password) != 0) {
4695 monitor_printf(mon, "invalid password\n");
4696 ret = -EPERM;
4697 }
4698 if (mon->password_completion_cb)
4699 mon->password_completion_cb(mon->password_opaque, ret);
4700
4701 monitor_read_command(mon, 1);
4702 }
4703
4704 int monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
4705 BlockDriverCompletionFunc *completion_cb,
4706 void *opaque)
4707 {
4708 int err;
4709
4710 if (!bdrv_key_required(bs)) {
4711 if (completion_cb)
4712 completion_cb(opaque, 0);
4713 return 0;
4714 }
4715
4716 if (monitor_ctrl_mode(mon)) {
4717 qerror_report(QERR_DEVICE_ENCRYPTED, bdrv_get_device_name(bs));
4718 return -1;
4719 }
4720
4721 monitor_printf(mon, "%s (%s) is encrypted.\n", bdrv_get_device_name(bs),
4722 bdrv_get_encrypted_filename(bs));
4723
4724 mon->password_completion_cb = completion_cb;
4725 mon->password_opaque = opaque;
4726
4727 err = monitor_read_password(mon, bdrv_password_cb, bs);
4728
4729 if (err && completion_cb)
4730 completion_cb(opaque, err);
4731
4732 return err;
4733 }
Anthony Liguori's QEMU queue