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