?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Remove magic numbers for VNC message IDs from code
[qemu/kraxel.git] / monitor.c
blob5659991b872f2c2445c2ad8a5b4e4fc2448f0cde
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 qemu_acl *find_acl(Monitor *mon, const char *name)
2270 {
2271 qemu_acl *acl = qemu_acl_find(name);
2272
2273 if (!acl) {
2274 monitor_printf(mon, "acl: unknown list '%s'\n", name);
2275 }
2276 return acl;
2277 }
2278
2279 static void do_acl_show(Monitor *mon, const QDict *qdict)
2280 {
2281 const char *aclname = qdict_get_str(qdict, "aclname");
2282 qemu_acl *acl = find_acl(mon, aclname);
2283 qemu_acl_entry *entry;
2284 int i = 0;
2285
2286 if (acl) {
2287 monitor_printf(mon, "policy: %s\n",
2288 acl->defaultDeny ? "deny" : "allow");
2289 QTAILQ_FOREACH(entry, &acl->entries, next) {
2290 i++;
2291 monitor_printf(mon, "%d: %s %s\n", i,
2292 entry->deny ? "deny" : "allow", entry->match);
2293 }
2294 }
2295 }
2296
2297 static void do_acl_reset(Monitor *mon, const QDict *qdict)
2298 {
2299 const char *aclname = qdict_get_str(qdict, "aclname");
2300 qemu_acl *acl = find_acl(mon, aclname);
2301
2302 if (acl) {
2303 qemu_acl_reset(acl);
2304 monitor_printf(mon, "acl: removed all rules\n");
2305 }
2306 }
2307
2308 static void do_acl_policy(Monitor *mon, const QDict *qdict)
2309 {
2310 const char *aclname = qdict_get_str(qdict, "aclname");
2311 const char *policy = qdict_get_str(qdict, "policy");
2312 qemu_acl *acl = find_acl(mon, aclname);
2313
2314 if (acl) {
2315 if (strcmp(policy, "allow") == 0) {
2316 acl->defaultDeny = 0;
2317 monitor_printf(mon, "acl: policy set to 'allow'\n");
2318 } else if (strcmp(policy, "deny") == 0) {
2319 acl->defaultDeny = 1;
2320 monitor_printf(mon, "acl: policy set to 'deny'\n");
2321 } else {
2322 monitor_printf(mon, "acl: unknown policy '%s', "
2323 "expected 'deny' or 'allow'\n", policy);
2324 }
2325 }
2326 }
2327
2328 static void do_acl_add(Monitor *mon, const QDict *qdict)
2329 {
2330 const char *aclname = qdict_get_str(qdict, "aclname");
2331 const char *match = qdict_get_str(qdict, "match");
2332 const char *policy = qdict_get_str(qdict, "policy");
2333 int has_index = qdict_haskey(qdict, "index");
2334 int index = qdict_get_try_int(qdict, "index", -1);
2335 qemu_acl *acl = find_acl(mon, aclname);
2336 int deny, ret;
2337
2338 if (acl) {
2339 if (strcmp(policy, "allow") == 0) {
2340 deny = 0;
2341 } else if (strcmp(policy, "deny") == 0) {
2342 deny = 1;
2343 } else {
2344 monitor_printf(mon, "acl: unknown policy '%s', "
2345 "expected 'deny' or 'allow'\n", policy);
2346 return;
2347 }
2348 if (has_index)
2349 ret = qemu_acl_insert(acl, deny, match, index);
2350 else
2351 ret = qemu_acl_append(acl, deny, match);
2352 if (ret < 0)
2353 monitor_printf(mon, "acl: unable to add acl entry\n");
2354 else
2355 monitor_printf(mon, "acl: added rule at position %d\n", ret);
2356 }
2357 }
2358
2359 static void do_acl_remove(Monitor *mon, const QDict *qdict)
2360 {
2361 const char *aclname = qdict_get_str(qdict, "aclname");
2362 const char *match = qdict_get_str(qdict, "match");
2363 qemu_acl *acl = find_acl(mon, aclname);
2364 int ret;
2365
2366 if (acl) {
2367 ret = qemu_acl_remove(acl, match);
2368 if (ret < 0)
2369 monitor_printf(mon, "acl: no matching acl entry\n");
2370 else
2371 monitor_printf(mon, "acl: removed rule at position %d\n", ret);
2372 }
2373 }
2374
2375 #if defined(TARGET_I386)
2376 static void do_inject_mce(Monitor *mon, const QDict *qdict)
2377 {
2378 CPUState *cenv;
2379 int cpu_index = qdict_get_int(qdict, "cpu_index");
2380 int bank = qdict_get_int(qdict, "bank");
2381 uint64_t status = qdict_get_int(qdict, "status");
2382 uint64_t mcg_status = qdict_get_int(qdict, "mcg_status");
2383 uint64_t addr = qdict_get_int(qdict, "addr");
2384 uint64_t misc = qdict_get_int(qdict, "misc");
2385
2386 for (cenv = first_cpu; cenv != NULL; cenv = cenv->next_cpu)
2387 if (cenv->cpu_index == cpu_index && cenv->mcg_cap) {
2388 cpu_inject_x86_mce(cenv, bank, status, mcg_status, addr, misc);
2389 break;
2390 }
2391 }
2392 #endif
2393
2394 static int do_getfd(Monitor *mon, const QDict *qdict, QObject **ret_data)
2395 {
2396 const char *fdname = qdict_get_str(qdict, "fdname");
2397 mon_fd_t *monfd;
2398 int fd;
2399
2400 fd = qemu_chr_get_msgfd(mon->chr);
2401 if (fd == -1) {
2402 qerror_report(QERR_FD_NOT_SUPPLIED);
2403 return -1;
2404 }
2405
2406 if (qemu_isdigit(fdname[0])) {
2407 qerror_report(QERR_INVALID_PARAMETER, "fdname");
2408 return -1;
2409 }
2410
2411 fd = dup(fd);
2412 if (fd == -1) {
2413 if (errno == EMFILE)
2414 qerror_report(QERR_TOO_MANY_FILES);
2415 else
2416 qerror_report(QERR_UNDEFINED_ERROR);
2417 return -1;
2418 }
2419
2420 QLIST_FOREACH(monfd, &mon->fds, next) {
2421 if (strcmp(monfd->name, fdname) != 0) {
2422 continue;
2423 }
2424
2425 close(monfd->fd);
2426 monfd->fd = fd;
2427 return 0;
2428 }
2429
2430 monfd = qemu_mallocz(sizeof(mon_fd_t));
2431 monfd->name = qemu_strdup(fdname);
2432 monfd->fd = fd;
2433
2434 QLIST_INSERT_HEAD(&mon->fds, monfd, next);
2435 return 0;
2436 }
2437
2438 static int do_closefd(Monitor *mon, const QDict *qdict, QObject **ret_data)
2439 {
2440 const char *fdname = qdict_get_str(qdict, "fdname");
2441 mon_fd_t *monfd;
2442
2443 QLIST_FOREACH(monfd, &mon->fds, next) {
2444 if (strcmp(monfd->name, fdname) != 0) {
2445 continue;
2446 }
2447
2448 QLIST_REMOVE(monfd, next);
2449 close(monfd->fd);
2450 qemu_free(monfd->name);
2451 qemu_free(monfd);
2452 return 0;
2453 }
2454
2455 qerror_report(QERR_FD_NOT_FOUND, fdname);
2456 return -1;
2457 }
2458
2459 static void do_loadvm(Monitor *mon, const QDict *qdict)
2460 {
2461 int saved_vm_running = vm_running;
2462 const char *name = qdict_get_str(qdict, "name");
2463
2464 vm_stop(0);
2465
2466 if (load_vmstate(name) >= 0 && saved_vm_running)
2467 vm_start();
2468 }
2469
2470 int monitor_get_fd(Monitor *mon, const char *fdname)
2471 {
2472 mon_fd_t *monfd;
2473
2474 QLIST_FOREACH(monfd, &mon->fds, next) {
2475 int fd;
2476
2477 if (strcmp(monfd->name, fdname) != 0) {
2478 continue;
2479 }
2480
2481 fd = monfd->fd;
2482
2483 /* caller takes ownership of fd */
2484 QLIST_REMOVE(monfd, next);
2485 qemu_free(monfd->name);
2486 qemu_free(monfd);
2487
2488 return fd;
2489 }
2490
2491 return -1;
2492 }
2493
2494 static const mon_cmd_t mon_cmds[] = {
2495 #include "qemu-monitor.h"
2496 { NULL, NULL, },
2497 };
2498
2499 /* Please update qemu-monitor.hx when adding or changing commands */
2500 static const mon_cmd_t info_cmds[] = {
2501 {
2502 .name = "version",
2503 .args_type = "",
2504 .params = "",
2505 .help = "show the version of QEMU",
2506 .user_print = do_info_version_print,
2507 .mhandler.info_new = do_info_version,
2508 },
2509 {
2510 .name = "commands",
2511 .args_type = "",
2512 .params = "",
2513 .help = "list QMP available commands",
2514 .user_print = monitor_user_noop,
2515 .mhandler.info_new = do_info_commands,
2516 },
2517 {
2518 .name = "network",
2519 .args_type = "",
2520 .params = "",
2521 .help = "show the network state",
2522 .mhandler.info = do_info_network,
2523 },
2524 {
2525 .name = "chardev",
2526 .args_type = "",
2527 .params = "",
2528 .help = "show the character devices",
2529 .user_print = qemu_chr_info_print,
2530 .mhandler.info_new = qemu_chr_info,
2531 },
2532 {
2533 .name = "block",
2534 .args_type = "",
2535 .params = "",
2536 .help = "show the block devices",
2537 .user_print = bdrv_info_print,
2538 .mhandler.info_new = bdrv_info,
2539 },
2540 {
2541 .name = "blockstats",
2542 .args_type = "",
2543 .params = "",
2544 .help = "show block device statistics",
2545 .user_print = bdrv_stats_print,
2546 .mhandler.info_new = bdrv_info_stats,
2547 },
2548 {
2549 .name = "registers",
2550 .args_type = "",
2551 .params = "",
2552 .help = "show the cpu registers",
2553 .mhandler.info = do_info_registers,
2554 },
2555 {
2556 .name = "cpus",
2557 .args_type = "",
2558 .params = "",
2559 .help = "show infos for each CPU",
2560 .user_print = monitor_print_cpus,
2561 .mhandler.info_new = do_info_cpus,
2562 },
2563 {
2564 .name = "history",
2565 .args_type = "",
2566 .params = "",
2567 .help = "show the command line history",
2568 .mhandler.info = do_info_history,
2569 },
2570 {
2571 .name = "irq",
2572 .args_type = "",
2573 .params = "",
2574 .help = "show the interrupts statistics (if available)",
2575 .mhandler.info = irq_info,
2576 },
2577 {
2578 .name = "pic",
2579 .args_type = "",
2580 .params = "",
2581 .help = "show i8259 (PIC) state",
2582 .mhandler.info = pic_info,
2583 },
2584 {
2585 .name = "pci",
2586 .args_type = "",
2587 .params = "",
2588 .help = "show PCI info",
2589 .user_print = do_pci_info_print,
2590 .mhandler.info_new = do_pci_info,
2591 },
2592 #if defined(TARGET_I386) || defined(TARGET_SH4)
2593 {
2594 .name = "tlb",
2595 .args_type = "",
2596 .params = "",
2597 .help = "show virtual to physical memory mappings",
2598 .mhandler.info = tlb_info,
2599 },
2600 #endif
2601 #if defined(TARGET_I386)
2602 {
2603 .name = "mem",
2604 .args_type = "",
2605 .params = "",
2606 .help = "show the active virtual memory mappings",
2607 .mhandler.info = mem_info,
2608 },
2609 {
2610 .name = "hpet",
2611 .args_type = "",
2612 .params = "",
2613 .help = "show state of HPET",
2614 .user_print = do_info_hpet_print,
2615 .mhandler.info_new = do_info_hpet,
2616 },
2617 #endif
2618 {
2619 .name = "jit",
2620 .args_type = "",
2621 .params = "",
2622 .help = "show dynamic compiler info",
2623 .mhandler.info = do_info_jit,
2624 },
2625 {
2626 .name = "kvm",
2627 .args_type = "",
2628 .params = "",
2629 .help = "show KVM information",
2630 .user_print = do_info_kvm_print,
2631 .mhandler.info_new = do_info_kvm,
2632 },
2633 {
2634 .name = "numa",
2635 .args_type = "",
2636 .params = "",
2637 .help = "show NUMA information",
2638 .mhandler.info = do_info_numa,
2639 },
2640 {
2641 .name = "usb",
2642 .args_type = "",
2643 .params = "",
2644 .help = "show guest USB devices",
2645 .mhandler.info = usb_info,
2646 },
2647 {
2648 .name = "usbhost",
2649 .args_type = "",
2650 .params = "",
2651 .help = "show host USB devices",
2652 .mhandler.info = usb_host_info,
2653 },
2654 {
2655 .name = "profile",
2656 .args_type = "",
2657 .params = "",
2658 .help = "show profiling information",
2659 .mhandler.info = do_info_profile,
2660 },
2661 {
2662 .name = "capture",
2663 .args_type = "",
2664 .params = "",
2665 .help = "show capture information",
2666 .mhandler.info = do_info_capture,
2667 },
2668 {
2669 .name = "snapshots",
2670 .args_type = "",
2671 .params = "",
2672 .help = "show the currently saved VM snapshots",
2673 .mhandler.info = do_info_snapshots,
2674 },
2675 {
2676 .name = "status",
2677 .args_type = "",
2678 .params = "",
2679 .help = "show the current VM status (running|paused)",
2680 .user_print = do_info_status_print,
2681 .mhandler.info_new = do_info_status,
2682 },
2683 {
2684 .name = "pcmcia",
2685 .args_type = "",
2686 .params = "",
2687 .help = "show guest PCMCIA status",
2688 .mhandler.info = pcmcia_info,
2689 },
2690 {
2691 .name = "mice",
2692 .args_type = "",
2693 .params = "",
2694 .help = "show which guest mouse is receiving events",
2695 .user_print = do_info_mice_print,
2696 .mhandler.info_new = do_info_mice,
2697 },
2698 {
2699 .name = "vnc",
2700 .args_type = "",
2701 .params = "",
2702 .help = "show the vnc server status",
2703 .user_print = do_info_vnc_print,
2704 .mhandler.info_new = do_info_vnc,
2705 },
2706 {
2707 .name = "name",
2708 .args_type = "",
2709 .params = "",
2710 .help = "show the current VM name",
2711 .user_print = do_info_name_print,
2712 .mhandler.info_new = do_info_name,
2713 },
2714 {
2715 .name = "uuid",
2716 .args_type = "",
2717 .params = "",
2718 .help = "show the current VM UUID",
2719 .user_print = do_info_uuid_print,
2720 .mhandler.info_new = do_info_uuid,
2721 },
2722 #if defined(TARGET_PPC)
2723 {
2724 .name = "cpustats",
2725 .args_type = "",
2726 .params = "",
2727 .help = "show CPU statistics",
2728 .mhandler.info = do_info_cpu_stats,
2729 },
2730 #endif
2731 #if defined(CONFIG_SLIRP)
2732 {
2733 .name = "usernet",
2734 .args_type = "",
2735 .params = "",
2736 .help = "show user network stack connection states",
2737 .mhandler.info = do_info_usernet,
2738 },
2739 #endif
2740 {
2741 .name = "migrate",
2742 .args_type = "",
2743 .params = "",
2744 .help = "show migration status",
2745 .user_print = do_info_migrate_print,
2746 .mhandler.info_new = do_info_migrate,
2747 },
2748 {
2749 .name = "balloon",
2750 .args_type = "",
2751 .params = "",
2752 .help = "show balloon information",
2753 .user_print = monitor_print_balloon,
2754 .mhandler.info_async = do_info_balloon,
2755 .async = 1,
2756 },
2757 {
2758 .name = "qtree",
2759 .args_type = "",
2760 .params = "",
2761 .help = "show device tree",
2762 .mhandler.info = do_info_qtree,
2763 },
2764 {
2765 .name = "qdm",
2766 .args_type = "",
2767 .params = "",
2768 .help = "show qdev device model list",
2769 .mhandler.info = do_info_qdm,
2770 },
2771 {
2772 .name = "roms",
2773 .args_type = "",
2774 .params = "",
2775 .help = "show roms",
2776 .mhandler.info = do_info_roms,
2777 },
2778 {
2779 .name = NULL,
2780 },
2781 };
2782
2783 /*******************************************************************/
2784
2785 static const char *pch;
2786 static jmp_buf expr_env;
2787
2788 #define MD_TLONG 0
2789 #define MD_I32 1
2790
2791 typedef struct MonitorDef {
2792 const char *name;
2793 int offset;
2794 target_long (*get_value)(const struct MonitorDef *md, int val);
2795 int type;
2796 } MonitorDef;
2797
2798 #if defined(TARGET_I386)
2799 static target_long monitor_get_pc (const struct MonitorDef *md, int val)
2800 {
2801 CPUState *env = mon_get_cpu();
2802 return env->eip + env->segs[R_CS].base;
2803 }
2804 #endif
2805
2806 #if defined(TARGET_PPC)
2807 static target_long monitor_get_ccr (const struct MonitorDef *md, int val)
2808 {
2809 CPUState *env = mon_get_cpu();
2810 unsigned int u;
2811 int i;
2812
2813 u = 0;
2814 for (i = 0; i < 8; i++)
2815 u |= env->crf[i] << (32 - (4 * i));
2816
2817 return u;
2818 }
2819
2820 static target_long monitor_get_msr (const struct MonitorDef *md, int val)
2821 {
2822 CPUState *env = mon_get_cpu();
2823 return env->msr;
2824 }
2825
2826 static target_long monitor_get_xer (const struct MonitorDef *md, int val)
2827 {
2828 CPUState *env = mon_get_cpu();
2829 return env->xer;
2830 }
2831
2832 static target_long monitor_get_decr (const struct MonitorDef *md, int val)
2833 {
2834 CPUState *env = mon_get_cpu();
2835 return cpu_ppc_load_decr(env);
2836 }
2837
2838 static target_long monitor_get_tbu (const struct MonitorDef *md, int val)
2839 {
2840 CPUState *env = mon_get_cpu();
2841 return cpu_ppc_load_tbu(env);
2842 }
2843
2844 static target_long monitor_get_tbl (const struct MonitorDef *md, int val)
2845 {
2846 CPUState *env = mon_get_cpu();
2847 return cpu_ppc_load_tbl(env);
2848 }
2849 #endif
2850
2851 #if defined(TARGET_SPARC)
2852 #ifndef TARGET_SPARC64
2853 static target_long monitor_get_psr (const struct MonitorDef *md, int val)
2854 {
2855 CPUState *env = mon_get_cpu();
2856 return GET_PSR(env);
2857 }
2858 #endif
2859
2860 static target_long monitor_get_reg(const struct MonitorDef *md, int val)
2861 {
2862 CPUState *env = mon_get_cpu();
2863 return env->regwptr[val];
2864 }
2865 #endif
2866
2867 static const MonitorDef monitor_defs[] = {
2868 #ifdef TARGET_I386
2869
2870 #define SEG(name, seg) \
2871 { name, offsetof(CPUState, segs[seg].selector), NULL, MD_I32 },\
2872 { name ".base", offsetof(CPUState, segs[seg].base) },\
2873 { name ".limit", offsetof(CPUState, segs[seg].limit), NULL, MD_I32 },
2874
2875 { "eax", offsetof(CPUState, regs[0]) },
2876 { "ecx", offsetof(CPUState, regs[1]) },
2877 { "edx", offsetof(CPUState, regs[2]) },
2878 { "ebx", offsetof(CPUState, regs[3]) },
2879 { "esp|sp", offsetof(CPUState, regs[4]) },
2880 { "ebp|fp", offsetof(CPUState, regs[5]) },
2881 { "esi", offsetof(CPUState, regs[6]) },
2882 { "edi", offsetof(CPUState, regs[7]) },
2883 #ifdef TARGET_X86_64
2884 { "r8", offsetof(CPUState, regs[8]) },
2885 { "r9", offsetof(CPUState, regs[9]) },
2886 { "r10", offsetof(CPUState, regs[10]) },
2887 { "r11", offsetof(CPUState, regs[11]) },
2888 { "r12", offsetof(CPUState, regs[12]) },
2889 { "r13", offsetof(CPUState, regs[13]) },
2890 { "r14", offsetof(CPUState, regs[14]) },
2891 { "r15", offsetof(CPUState, regs[15]) },
2892 #endif
2893 { "eflags", offsetof(CPUState, eflags) },
2894 { "eip", offsetof(CPUState, eip) },
2895 SEG("cs", R_CS)
2896 SEG("ds", R_DS)
2897 SEG("es", R_ES)
2898 SEG("ss", R_SS)
2899 SEG("fs", R_FS)
2900 SEG("gs", R_GS)
2901 { "pc", 0, monitor_get_pc, },
2902 #elif defined(TARGET_PPC)
2903 /* General purpose registers */
2904 { "r0", offsetof(CPUState, gpr[0]) },
2905 { "r1", offsetof(CPUState, gpr[1]) },
2906 { "r2", offsetof(CPUState, gpr[2]) },
2907 { "r3", offsetof(CPUState, gpr[3]) },
2908 { "r4", offsetof(CPUState, gpr[4]) },
2909 { "r5", offsetof(CPUState, gpr[5]) },
2910 { "r6", offsetof(CPUState, gpr[6]) },
2911 { "r7", offsetof(CPUState, gpr[7]) },
2912 { "r8", offsetof(CPUState, gpr[8]) },
2913 { "r9", offsetof(CPUState, gpr[9]) },
2914 { "r10", offsetof(CPUState, gpr[10]) },
2915 { "r11", offsetof(CPUState, gpr[11]) },
2916 { "r12", offsetof(CPUState, gpr[12]) },
2917 { "r13", offsetof(CPUState, gpr[13]) },
2918 { "r14", offsetof(CPUState, gpr[14]) },
2919 { "r15", offsetof(CPUState, gpr[15]) },
2920 { "r16", offsetof(CPUState, gpr[16]) },
2921 { "r17", offsetof(CPUState, gpr[17]) },
2922 { "r18", offsetof(CPUState, gpr[18]) },
2923 { "r19", offsetof(CPUState, gpr[19]) },
2924 { "r20", offsetof(CPUState, gpr[20]) },
2925 { "r21", offsetof(CPUState, gpr[21]) },
2926 { "r22", offsetof(CPUState, gpr[22]) },
2927 { "r23", offsetof(CPUState, gpr[23]) },
2928 { "r24", offsetof(CPUState, gpr[24]) },
2929 { "r25", offsetof(CPUState, gpr[25]) },
2930 { "r26", offsetof(CPUState, gpr[26]) },
2931 { "r27", offsetof(CPUState, gpr[27]) },
2932 { "r28", offsetof(CPUState, gpr[28]) },
2933 { "r29", offsetof(CPUState, gpr[29]) },
2934 { "r30", offsetof(CPUState, gpr[30]) },
2935 { "r31", offsetof(CPUState, gpr[31]) },
2936 /* Floating point registers */
2937 { "f0", offsetof(CPUState, fpr[0]) },
2938 { "f1", offsetof(CPUState, fpr[1]) },
2939 { "f2", offsetof(CPUState, fpr[2]) },
2940 { "f3", offsetof(CPUState, fpr[3]) },
2941 { "f4", offsetof(CPUState, fpr[4]) },
2942 { "f5", offsetof(CPUState, fpr[5]) },
2943 { "f6", offsetof(CPUState, fpr[6]) },
2944 { "f7", offsetof(CPUState, fpr[7]) },
2945 { "f8", offsetof(CPUState, fpr[8]) },
2946 { "f9", offsetof(CPUState, fpr[9]) },
2947 { "f10", offsetof(CPUState, fpr[10]) },
2948 { "f11", offsetof(CPUState, fpr[11]) },
2949 { "f12", offsetof(CPUState, fpr[12]) },
2950 { "f13", offsetof(CPUState, fpr[13]) },
2951 { "f14", offsetof(CPUState, fpr[14]) },
2952 { "f15", offsetof(CPUState, fpr[15]) },
2953 { "f16", offsetof(CPUState, fpr[16]) },
2954 { "f17", offsetof(CPUState, fpr[17]) },
2955 { "f18", offsetof(CPUState, fpr[18]) },
2956 { "f19", offsetof(CPUState, fpr[19]) },
2957 { "f20", offsetof(CPUState, fpr[20]) },
2958 { "f21", offsetof(CPUState, fpr[21]) },
2959 { "f22", offsetof(CPUState, fpr[22]) },
2960 { "f23", offsetof(CPUState, fpr[23]) },
2961 { "f24", offsetof(CPUState, fpr[24]) },
2962 { "f25", offsetof(CPUState, fpr[25]) },
2963 { "f26", offsetof(CPUState, fpr[26]) },
2964 { "f27", offsetof(CPUState, fpr[27]) },
2965 { "f28", offsetof(CPUState, fpr[28]) },
2966 { "f29", offsetof(CPUState, fpr[29]) },
2967 { "f30", offsetof(CPUState, fpr[30]) },
2968 { "f31", offsetof(CPUState, fpr[31]) },
2969 { "fpscr", offsetof(CPUState, fpscr) },
2970 /* Next instruction pointer */
2971 { "nip|pc", offsetof(CPUState, nip) },
2972 { "lr", offsetof(CPUState, lr) },
2973 { "ctr", offsetof(CPUState, ctr) },
2974 { "decr", 0, &monitor_get_decr, },
2975 { "ccr", 0, &monitor_get_ccr, },
2976 /* Machine state register */
2977 { "msr", 0, &monitor_get_msr, },
2978 { "xer", 0, &monitor_get_xer, },
2979 { "tbu", 0, &monitor_get_tbu, },
2980 { "tbl", 0, &monitor_get_tbl, },
2981 #if defined(TARGET_PPC64)
2982 /* Address space register */
2983 { "asr", offsetof(CPUState, asr) },
2984 #endif
2985 /* Segment registers */
2986 { "sdr1", offsetof(CPUState, sdr1) },
2987 { "sr0", offsetof(CPUState, sr[0]) },
2988 { "sr1", offsetof(CPUState, sr[1]) },
2989 { "sr2", offsetof(CPUState, sr[2]) },
2990 { "sr3", offsetof(CPUState, sr[3]) },
2991 { "sr4", offsetof(CPUState, sr[4]) },
2992 { "sr5", offsetof(CPUState, sr[5]) },
2993 { "sr6", offsetof(CPUState, sr[6]) },
2994 { "sr7", offsetof(CPUState, sr[7]) },
2995 { "sr8", offsetof(CPUState, sr[8]) },
2996 { "sr9", offsetof(CPUState, sr[9]) },
2997 { "sr10", offsetof(CPUState, sr[10]) },
2998 { "sr11", offsetof(CPUState, sr[11]) },
2999 { "sr12", offsetof(CPUState, sr[12]) },
3000 { "sr13", offsetof(CPUState, sr[13]) },
3001 { "sr14", offsetof(CPUState, sr[14]) },
3002 { "sr15", offsetof(CPUState, sr[15]) },
3003 /* Too lazy to put BATs and SPRs ... */
3004 #elif defined(TARGET_SPARC)
3005 { "g0", offsetof(CPUState, gregs[0]) },
3006 { "g1", offsetof(CPUState, gregs[1]) },
3007 { "g2", offsetof(CPUState, gregs[2]) },
3008 { "g3", offsetof(CPUState, gregs[3]) },
3009 { "g4", offsetof(CPUState, gregs[4]) },
3010 { "g5", offsetof(CPUState, gregs[5]) },
3011 { "g6", offsetof(CPUState, gregs[6]) },
3012 { "g7", offsetof(CPUState, gregs[7]) },
3013 { "o0", 0, monitor_get_reg },
3014 { "o1", 1, monitor_get_reg },
3015 { "o2", 2, monitor_get_reg },
3016 { "o3", 3, monitor_get_reg },
3017 { "o4", 4, monitor_get_reg },
3018 { "o5", 5, monitor_get_reg },
3019 { "o6", 6, monitor_get_reg },
3020 { "o7", 7, monitor_get_reg },
3021 { "l0", 8, monitor_get_reg },
3022 { "l1", 9, monitor_get_reg },
3023 { "l2", 10, monitor_get_reg },
3024 { "l3", 11, monitor_get_reg },
3025 { "l4", 12, monitor_get_reg },
3026 { "l5", 13, monitor_get_reg },
3027 { "l6", 14, monitor_get_reg },
3028 { "l7", 15, monitor_get_reg },
3029 { "i0", 16, monitor_get_reg },
3030 { "i1", 17, monitor_get_reg },
3031 { "i2", 18, monitor_get_reg },
3032 { "i3", 19, monitor_get_reg },
3033 { "i4", 20, monitor_get_reg },
3034 { "i5", 21, monitor_get_reg },
3035 { "i6", 22, monitor_get_reg },
3036 { "i7", 23, monitor_get_reg },
3037 { "pc", offsetof(CPUState, pc) },
3038 { "npc", offsetof(CPUState, npc) },
3039 { "y", offsetof(CPUState, y) },
3040 #ifndef TARGET_SPARC64
3041 { "psr", 0, &monitor_get_psr, },
3042 { "wim", offsetof(CPUState, wim) },
3043 #endif
3044 { "tbr", offsetof(CPUState, tbr) },
3045 { "fsr", offsetof(CPUState, fsr) },
3046 { "f0", offsetof(CPUState, fpr[0]) },
3047 { "f1", offsetof(CPUState, fpr[1]) },
3048 { "f2", offsetof(CPUState, fpr[2]) },
3049 { "f3", offsetof(CPUState, fpr[3]) },
3050 { "f4", offsetof(CPUState, fpr[4]) },
3051 { "f5", offsetof(CPUState, fpr[5]) },
3052 { "f6", offsetof(CPUState, fpr[6]) },
3053 { "f7", offsetof(CPUState, fpr[7]) },
3054 { "f8", offsetof(CPUState, fpr[8]) },
3055 { "f9", offsetof(CPUState, fpr[9]) },
3056 { "f10", offsetof(CPUState, fpr[10]) },
3057 { "f11", offsetof(CPUState, fpr[11]) },
3058 { "f12", offsetof(CPUState, fpr[12]) },
3059 { "f13", offsetof(CPUState, fpr[13]) },
3060 { "f14", offsetof(CPUState, fpr[14]) },
3061 { "f15", offsetof(CPUState, fpr[15]) },
3062 { "f16", offsetof(CPUState, fpr[16]) },
3063 { "f17", offsetof(CPUState, fpr[17]) },
3064 { "f18", offsetof(CPUState, fpr[18]) },
3065 { "f19", offsetof(CPUState, fpr[19]) },
3066 { "f20", offsetof(CPUState, fpr[20]) },
3067 { "f21", offsetof(CPUState, fpr[21]) },
3068 { "f22", offsetof(CPUState, fpr[22]) },
3069 { "f23", offsetof(CPUState, fpr[23]) },
3070 { "f24", offsetof(CPUState, fpr[24]) },
3071 { "f25", offsetof(CPUState, fpr[25]) },
3072 { "f26", offsetof(CPUState, fpr[26]) },
3073 { "f27", offsetof(CPUState, fpr[27]) },
3074 { "f28", offsetof(CPUState, fpr[28]) },
3075 { "f29", offsetof(CPUState, fpr[29]) },
3076 { "f30", offsetof(CPUState, fpr[30]) },
3077 { "f31", offsetof(CPUState, fpr[31]) },
3078 #ifdef TARGET_SPARC64
3079 { "f32", offsetof(CPUState, fpr[32]) },
3080 { "f34", offsetof(CPUState, fpr[34]) },
3081 { "f36", offsetof(CPUState, fpr[36]) },
3082 { "f38", offsetof(CPUState, fpr[38]) },
3083 { "f40", offsetof(CPUState, fpr[40]) },
3084 { "f42", offsetof(CPUState, fpr[42]) },
3085 { "f44", offsetof(CPUState, fpr[44]) },
3086 { "f46", offsetof(CPUState, fpr[46]) },
3087 { "f48", offsetof(CPUState, fpr[48]) },
3088 { "f50", offsetof(CPUState, fpr[50]) },
3089 { "f52", offsetof(CPUState, fpr[52]) },
3090 { "f54", offsetof(CPUState, fpr[54]) },
3091 { "f56", offsetof(CPUState, fpr[56]) },
3092 { "f58", offsetof(CPUState, fpr[58]) },
3093 { "f60", offsetof(CPUState, fpr[60]) },
3094 { "f62", offsetof(CPUState, fpr[62]) },
3095 { "asi", offsetof(CPUState, asi) },
3096 { "pstate", offsetof(CPUState, pstate) },
3097 { "cansave", offsetof(CPUState, cansave) },
3098 { "canrestore", offsetof(CPUState, canrestore) },
3099 { "otherwin", offsetof(CPUState, otherwin) },
3100 { "wstate", offsetof(CPUState, wstate) },
3101 { "cleanwin", offsetof(CPUState, cleanwin) },
3102 { "fprs", offsetof(CPUState, fprs) },
3103 #endif
3104 #endif
3105 { NULL },
3106 };
3107
3108 static void expr_error(Monitor *mon, const char *msg)
3109 {
3110 monitor_printf(mon, "%s\n", msg);
3111 longjmp(expr_env, 1);
3112 }
3113
3114 /* return 0 if OK, -1 if not found */
3115 static int get_monitor_def(target_long *pval, const char *name)
3116 {
3117 const MonitorDef *md;
3118 void *ptr;
3119
3120 for(md = monitor_defs; md->name != NULL; md++) {
3121 if (compare_cmd(name, md->name)) {
3122 if (md->get_value) {
3123 *pval = md->get_value(md, md->offset);
3124 } else {
3125 CPUState *env = mon_get_cpu();
3126 ptr = (uint8_t *)env + md->offset;
3127 switch(md->type) {
3128 case MD_I32:
3129 *pval = *(int32_t *)ptr;
3130 break;
3131 case MD_TLONG:
3132 *pval = *(target_long *)ptr;
3133 break;
3134 default:
3135 *pval = 0;
3136 break;
3137 }
3138 }
3139 return 0;
3140 }
3141 }
3142 return -1;
3143 }
3144
3145 static void next(void)
3146 {
3147 if (*pch != '\0') {
3148 pch++;
3149 while (qemu_isspace(*pch))
3150 pch++;
3151 }
3152 }
3153
3154 static int64_t expr_sum(Monitor *mon);
3155
3156 static int64_t expr_unary(Monitor *mon)
3157 {
3158 int64_t n;
3159 char *p;
3160 int ret;
3161
3162 switch(*pch) {
3163 case '+':
3164 next();
3165 n = expr_unary(mon);
3166 break;
3167 case '-':
3168 next();
3169 n = -expr_unary(mon);
3170 break;
3171 case '~':
3172 next();
3173 n = ~expr_unary(mon);
3174 break;
3175 case '(':
3176 next();
3177 n = expr_sum(mon);
3178 if (*pch != ')') {
3179 expr_error(mon, "')' expected");
3180 }
3181 next();
3182 break;
3183 case '\'':
3184 pch++;
3185 if (*pch == '\0')
3186 expr_error(mon, "character constant expected");
3187 n = *pch;
3188 pch++;
3189 if (*pch != '\'')
3190 expr_error(mon, "missing terminating \' character");
3191 next();
3192 break;
3193 case '$':
3194 {
3195 char buf[128], *q;
3196 target_long reg=0;
3197
3198 pch++;
3199 q = buf;
3200 while ((*pch >= 'a' && *pch <= 'z') ||
3201 (*pch >= 'A' && *pch <= 'Z') ||
3202 (*pch >= '0' && *pch <= '9') ||
3203 *pch == '_' || *pch == '.') {
3204 if ((q - buf) < sizeof(buf) - 1)
3205 *q++ = *pch;
3206 pch++;
3207 }
3208 while (qemu_isspace(*pch))
3209 pch++;
3210 *q = 0;
3211 ret = get_monitor_def(&reg, buf);
3212 if (ret < 0)
3213 expr_error(mon, "unknown register");
3214 n = reg;
3215 }
3216 break;
3217 case '\0':
3218 expr_error(mon, "unexpected end of expression");
3219 n = 0;
3220 break;
3221 default:
3222 #if TARGET_PHYS_ADDR_BITS > 32
3223 n = strtoull(pch, &p, 0);
3224 #else
3225 n = strtoul(pch, &p, 0);
3226 #endif
3227 if (pch == p) {
3228 expr_error(mon, "invalid char in expression");
3229 }
3230 pch = p;
3231 while (qemu_isspace(*pch))
3232 pch++;
3233 break;
3234 }
3235 return n;
3236 }
3237
3238
3239 static int64_t expr_prod(Monitor *mon)
3240 {
3241 int64_t val, val2;
3242 int op;
3243
3244 val = expr_unary(mon);
3245 for(;;) {
3246 op = *pch;
3247 if (op != '*' && op != '/' && op != '%')
3248 break;
3249 next();
3250 val2 = expr_unary(mon);
3251 switch(op) {
3252 default:
3253 case '*':
3254 val *= val2;
3255 break;
3256 case '/':
3257 case '%':
3258 if (val2 == 0)
3259 expr_error(mon, "division by zero");
3260 if (op == '/')
3261 val /= val2;
3262 else
3263 val %= val2;
3264 break;
3265 }
3266 }
3267 return val;
3268 }
3269
3270 static int64_t expr_logic(Monitor *mon)
3271 {
3272 int64_t val, val2;
3273 int op;
3274
3275 val = expr_prod(mon);
3276 for(;;) {
3277 op = *pch;
3278 if (op != '&' && op != '|' && op != '^')
3279 break;
3280 next();
3281 val2 = expr_prod(mon);
3282 switch(op) {
3283 default:
3284 case '&':
3285 val &= val2;
3286 break;
3287 case '|':
3288 val |= val2;
3289 break;
3290 case '^':
3291 val ^= val2;
3292 break;
3293 }
3294 }
3295 return val;
3296 }
3297
3298 static int64_t expr_sum(Monitor *mon)
3299 {
3300 int64_t val, val2;
3301 int op;
3302
3303 val = expr_logic(mon);
3304 for(;;) {
3305 op = *pch;
3306 if (op != '+' && op != '-')
3307 break;
3308 next();
3309 val2 = expr_logic(mon);
3310 if (op == '+')
3311 val += val2;
3312 else
3313 val -= val2;
3314 }
3315 return val;
3316 }
3317
3318 static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
3319 {
3320 pch = *pp;
3321 if (setjmp(expr_env)) {
3322 *pp = pch;
3323 return -1;
3324 }
3325 while (qemu_isspace(*pch))
3326 pch++;
3327 *pval = expr_sum(mon);
3328 *pp = pch;
3329 return 0;
3330 }
3331
3332 static int get_double(Monitor *mon, double *pval, const char **pp)
3333 {
3334 const char *p = *pp;
3335 char *tailp;
3336 double d;
3337
3338 d = strtod(p, &tailp);
3339 if (tailp == p) {
3340 monitor_printf(mon, "Number expected\n");
3341 return -1;
3342 }
3343 if (d != d || d - d != 0) {
3344 /* NaN or infinity */
3345 monitor_printf(mon, "Bad number\n");
3346 return -1;
3347 }
3348 *pval = d;
3349 *pp = tailp;
3350 return 0;
3351 }
3352
3353 static int get_str(char *buf, int buf_size, const char **pp)
3354 {
3355 const char *p;
3356 char *q;
3357 int c;
3358
3359 q = buf;
3360 p = *pp;
3361 while (qemu_isspace(*p))
3362 p++;
3363 if (*p == '\0') {
3364 fail:
3365 *q = '\0';
3366 *pp = p;
3367 return -1;
3368 }
3369 if (*p == '\"') {
3370 p++;
3371 while (*p != '\0' && *p != '\"') {
3372 if (*p == '\\') {
3373 p++;
3374 c = *p++;
3375 switch(c) {
3376 case 'n':
3377 c = '\n';
3378 break;
3379 case 'r':
3380 c = '\r';
3381 break;
3382 case '\\':
3383 case '\'':
3384 case '\"':
3385 break;
3386 default:
3387 qemu_printf("unsupported escape code: '\\%c'\n", c);
3388 goto fail;
3389 }
3390 if ((q - buf) < buf_size - 1) {
3391 *q++ = c;
3392 }
3393 } else {
3394 if ((q - buf) < buf_size - 1) {
3395 *q++ = *p;
3396 }
3397 p++;
3398 }
3399 }
3400 if (*p != '\"') {
3401 qemu_printf("unterminated string\n");
3402 goto fail;
3403 }
3404 p++;
3405 } else {
3406 while (*p != '\0' && !qemu_isspace(*p)) {
3407 if ((q - buf) < buf_size - 1) {
3408 *q++ = *p;
3409 }
3410 p++;
3411 }
3412 }
3413 *q = '\0';
3414 *pp = p;
3415 return 0;
3416 }
3417
3418 /*
3419 * Store the command-name in cmdname, and return a pointer to
3420 * the remaining of the command string.
3421 */
3422 static const char *get_command_name(const char *cmdline,
3423 char *cmdname, size_t nlen)
3424 {
3425 size_t len;
3426 const char *p, *pstart;
3427
3428 p = cmdline;
3429 while (qemu_isspace(*p))
3430 p++;
3431 if (*p == '\0')
3432 return NULL;
3433 pstart = p;
3434 while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
3435 p++;
3436 len = p - pstart;
3437 if (len > nlen - 1)
3438 len = nlen - 1;
3439 memcpy(cmdname, pstart, len);
3440 cmdname[len] = '\0';
3441 return p;
3442 }
3443
3444 /**
3445 * Read key of 'type' into 'key' and return the current
3446 * 'type' pointer.
3447 */
3448 static char *key_get_info(const char *type, char **key)
3449 {
3450 size_t len;
3451 char *p, *str;
3452
3453 if (*type == ',')
3454 type++;
3455
3456 p = strchr(type, ':');
3457 if (!p) {
3458 *key = NULL;
3459 return NULL;
3460 }
3461 len = p - type;
3462
3463 str = qemu_malloc(len + 1);
3464 memcpy(str, type, len);
3465 str[len] = '\0';
3466
3467 *key = str;
3468 return ++p;
3469 }
3470
3471 static int default_fmt_format = 'x';
3472 static int default_fmt_size = 4;
3473
3474 #define MAX_ARGS 16
3475
3476 static int is_valid_option(const char *c, const char *typestr)
3477 {
3478 char option[3];
3479
3480 option[0] = '-';
3481 option[1] = *c;
3482 option[2] = '\0';
3483
3484 typestr = strstr(typestr, option);
3485 return (typestr != NULL);
3486 }
3487
3488 static const mon_cmd_t *monitor_find_command(const char *cmdname)
3489 {
3490 const mon_cmd_t *cmd;
3491
3492 for (cmd = mon_cmds; cmd->name != NULL; cmd++) {
3493 if (compare_cmd(cmdname, cmd->name)) {
3494 return cmd;
3495 }
3496 }
3497
3498 return NULL;
3499 }
3500
3501 static const mon_cmd_t *monitor_parse_command(Monitor *mon,
3502 const char *cmdline,
3503 QDict *qdict)
3504 {
3505 const char *p, *typestr;
3506 int c;
3507 const mon_cmd_t *cmd;
3508 char cmdname[256];
3509 char buf[1024];
3510 char *key;
3511
3512 #ifdef DEBUG
3513 monitor_printf(mon, "command='%s'\n", cmdline);
3514 #endif
3515
3516 /* extract the command name */
3517 p = get_command_name(cmdline, cmdname, sizeof(cmdname));
3518 if (!p)
3519 return NULL;
3520
3521 cmd = monitor_find_command(cmdname);
3522 if (!cmd) {
3523 monitor_printf(mon, "unknown command: '%s'\n", cmdname);
3524 return NULL;
3525 }
3526
3527 /* parse the parameters */
3528 typestr = cmd->args_type;
3529 for(;;) {
3530 typestr = key_get_info(typestr, &key);
3531 if (!typestr)
3532 break;
3533 c = *typestr;
3534 typestr++;
3535 switch(c) {
3536 case 'F':
3537 case 'B':
3538 case 's':
3539 {
3540 int ret;
3541
3542 while (qemu_isspace(*p))
3543 p++;
3544 if (*typestr == '?') {
3545 typestr++;
3546 if (*p == '\0') {
3547 /* no optional string: NULL argument */
3548 break;
3549 }
3550 }
3551 ret = get_str(buf, sizeof(buf), &p);
3552 if (ret < 0) {
3553 switch(c) {
3554 case 'F':
3555 monitor_printf(mon, "%s: filename expected\n",
3556 cmdname);
3557 break;
3558 case 'B':
3559 monitor_printf(mon, "%s: block device name expected\n",
3560 cmdname);
3561 break;
3562 default:
3563 monitor_printf(mon, "%s: string expected\n", cmdname);
3564 break;
3565 }
3566 goto fail;
3567 }
3568 qdict_put(qdict, key, qstring_from_str(buf));
3569 }
3570 break;
3571 case 'O':
3572 {
3573 QemuOptsList *opts_list;
3574 QemuOpts *opts;
3575
3576 opts_list = qemu_find_opts(key);
3577 if (!opts_list || opts_list->desc->name) {
3578 goto bad_type;
3579 }
3580 while (qemu_isspace(*p)) {
3581 p++;
3582 }
3583 if (!*p)
3584 break;
3585 if (get_str(buf, sizeof(buf), &p) < 0) {
3586 goto fail;
3587 }
3588 opts = qemu_opts_parse(opts_list, buf, 1);
3589 if (!opts) {
3590 goto fail;
3591 }
3592 qemu_opts_to_qdict(opts, qdict);
3593 qemu_opts_del(opts);
3594 }
3595 break;
3596 case '/':
3597 {
3598 int count, format, size;
3599
3600 while (qemu_isspace(*p))
3601 p++;
3602 if (*p == '/') {
3603 /* format found */
3604 p++;
3605 count = 1;
3606 if (qemu_isdigit(*p)) {
3607 count = 0;
3608 while (qemu_isdigit(*p)) {
3609 count = count * 10 + (*p - '0');
3610 p++;
3611 }
3612 }
3613 size = -1;
3614 format = -1;
3615 for(;;) {
3616 switch(*p) {
3617 case 'o':
3618 case 'd':
3619 case 'u':
3620 case 'x':
3621 case 'i':
3622 case 'c':
3623 format = *p++;
3624 break;
3625 case 'b':
3626 size = 1;
3627 p++;
3628 break;
3629 case 'h':
3630 size = 2;
3631 p++;
3632 break;
3633 case 'w':
3634 size = 4;
3635 p++;
3636 break;
3637 case 'g':
3638 case 'L':
3639 size = 8;
3640 p++;
3641 break;
3642 default:
3643 goto next;
3644 }
3645 }
3646 next:
3647 if (*p != '\0' && !qemu_isspace(*p)) {
3648 monitor_printf(mon, "invalid char in format: '%c'\n",
3649 *p);
3650 goto fail;
3651 }
3652 if (format < 0)
3653 format = default_fmt_format;
3654 if (format != 'i') {
3655 /* for 'i', not specifying a size gives -1 as size */
3656 if (size < 0)
3657 size = default_fmt_size;
3658 default_fmt_size = size;
3659 }
3660 default_fmt_format = format;
3661 } else {
3662 count = 1;
3663 format = default_fmt_format;
3664 if (format != 'i') {
3665 size = default_fmt_size;
3666 } else {
3667 size = -1;
3668 }
3669 }
3670 qdict_put(qdict, "count", qint_from_int(count));
3671 qdict_put(qdict, "format", qint_from_int(format));
3672 qdict_put(qdict, "size", qint_from_int(size));
3673 }
3674 break;
3675 case 'i':
3676 case 'l':
3677 case 'M':
3678 {
3679 int64_t val;
3680
3681 while (qemu_isspace(*p))
3682 p++;
3683 if (*typestr == '?' || *typestr == '.') {
3684 if (*typestr == '?') {
3685 if (*p == '\0') {
3686 typestr++;
3687 break;
3688 }
3689 } else {
3690 if (*p == '.') {
3691 p++;
3692 while (qemu_isspace(*p))
3693 p++;
3694 } else {
3695 typestr++;
3696 break;
3697 }
3698 }
3699 typestr++;
3700 }
3701 if (get_expr(mon, &val, &p))
3702 goto fail;
3703 /* Check if 'i' is greater than 32-bit */
3704 if ((c == 'i') && ((val >> 32) & 0xffffffff)) {
3705 monitor_printf(mon, "\'%s\' has failed: ", cmdname);
3706 monitor_printf(mon, "integer is for 32-bit values\n");
3707 goto fail;
3708 } else if (c == 'M') {
3709 val <<= 20;
3710 }
3711 qdict_put(qdict, key, qint_from_int(val));
3712 }
3713 break;
3714 case 'b':
3715 case 'T':
3716 {
3717 double val;
3718
3719 while (qemu_isspace(*p))
3720 p++;
3721 if (*typestr == '?') {
3722 typestr++;
3723 if (*p == '\0') {
3724 break;
3725 }
3726 }
3727 if (get_double(mon, &val, &p) < 0) {
3728 goto fail;
3729 }
3730 if (c == 'b' && *p) {
3731 switch (*p) {
3732 case 'K': case 'k':
3733 val *= 1 << 10; p++; break;
3734 case 'M': case 'm':
3735 val *= 1 << 20; p++; break;
3736 case 'G': case 'g':
3737 val *= 1 << 30; p++; break;
3738 }
3739 }
3740 if (c == 'T' && p[0] && p[1] == 's') {
3741 switch (*p) {
3742 case 'm':
3743 val /= 1e3; p += 2; break;
3744 case 'u':
3745 val /= 1e6; p += 2; break;
3746 case 'n':
3747 val /= 1e9; p += 2; break;
3748 }
3749 }
3750 if (*p && !qemu_isspace(*p)) {
3751 monitor_printf(mon, "Unknown unit suffix\n");
3752 goto fail;
3753 }
3754 qdict_put(qdict, key, qfloat_from_double(val));
3755 }
3756 break;
3757 case '-':
3758 {
3759 const char *tmp = p;
3760 int has_option, skip_key = 0;
3761 /* option */
3762
3763 c = *typestr++;
3764 if (c == '\0')
3765 goto bad_type;
3766 while (qemu_isspace(*p))
3767 p++;
3768 has_option = 0;
3769 if (*p == '-') {
3770 p++;
3771 if(c != *p) {
3772 if(!is_valid_option(p, typestr)) {
3773
3774 monitor_printf(mon, "%s: unsupported option -%c\n",
3775 cmdname, *p);
3776 goto fail;
3777 } else {
3778 skip_key = 1;
3779 }
3780 }
3781 if(skip_key) {
3782 p = tmp;
3783 } else {
3784 p++;
3785 has_option = 1;
3786 }
3787 }
3788 qdict_put(qdict, key, qint_from_int(has_option));
3789 }
3790 break;
3791 default:
3792 bad_type:
3793 monitor_printf(mon, "%s: unknown type '%c'\n", cmdname, c);
3794 goto fail;
3795 }
3796 qemu_free(key);
3797 key = NULL;
3798 }
3799 /* check that all arguments were parsed */
3800 while (qemu_isspace(*p))
3801 p++;
3802 if (*p != '\0') {
3803 monitor_printf(mon, "%s: extraneous characters at the end of line\n",
3804 cmdname);
3805 goto fail;
3806 }
3807
3808 return cmd;
3809
3810 fail:
3811 qemu_free(key);
3812 return NULL;
3813 }
3814
3815 void monitor_set_error(Monitor *mon, QError *qerror)
3816 {
3817 /* report only the first error */
3818 if (!mon->error) {
3819 mon->error = qerror;
3820 } else {
3821 MON_DEBUG("Additional error report at %s:%d\n",
3822 qerror->file, qerror->linenr);
3823 QDECREF(qerror);
3824 }
3825 }
3826
3827 static int is_async_return(const QObject *data)
3828 {
3829 if (data && qobject_type(data) == QTYPE_QDICT) {
3830 return qdict_haskey(qobject_to_qdict(data), "__mon_async");
3831 }
3832
3833 return 0;
3834 }
3835
3836 static void handler_audit(Monitor *mon, const mon_cmd_t *cmd, int ret)
3837 {
3838 if (monitor_ctrl_mode(mon)) {
3839 if (ret && !monitor_has_error(mon)) {
3840 /*
3841 * If it returns failure, it must have passed on error.
3842 *
3843 * Action: Report an internal error to the client if in QMP.
3844 */
3845 qerror_report(QERR_UNDEFINED_ERROR);
3846 MON_DEBUG("command '%s' returned failure but did not pass an error\n",
3847 cmd->name);
3848 }
3849
3850 #ifdef CONFIG_DEBUG_MONITOR
3851 if (!ret && monitor_has_error(mon)) {
3852 /*
3853 * If it returns success, it must not have passed an error.
3854 *
3855 * Action: Report the passed error to the client.
3856 */
3857 MON_DEBUG("command '%s' returned success but passed an error\n",
3858 cmd->name);
3859 }
3860
3861 if (mon_print_count_get(mon) > 0 && strcmp(cmd->name, "info") != 0) {
3862 /*
3863 * Handlers should not call Monitor print functions.
3864 *
3865 * Action: Ignore them in QMP.
3866 *
3867 * (XXX: we don't check any 'info' or 'query' command here
3868 * because the user print function _is_ called by do_info(), hence
3869 * we will trigger this check. This problem will go away when we
3870 * make 'query' commands real and kill do_info())
3871 */
3872 MON_DEBUG("command '%s' called print functions %d time(s)\n",
3873 cmd->name, mon_print_count_get(mon));
3874 }
3875 #endif
3876 } else {
3877 assert(!monitor_has_error(mon));
3878 QDECREF(mon->error);
3879 mon->error = NULL;
3880 }
3881 }
3882
3883 static void monitor_call_handler(Monitor *mon, const mon_cmd_t *cmd,
3884 const QDict *params)
3885 {
3886 int ret;
3887 QObject *data = NULL;
3888
3889 mon_print_count_init(mon);
3890
3891 ret = cmd->mhandler.cmd_new(mon, params, &data);
3892 handler_audit(mon, cmd, ret);
3893
3894 if (is_async_return(data)) {
3895 /*
3896 * Asynchronous commands have no initial return data but they can
3897 * generate errors. Data is returned via the async completion handler.
3898 */
3899 if (monitor_ctrl_mode(mon) && monitor_has_error(mon)) {
3900 monitor_protocol_emitter(mon, NULL);
3901 }
3902 } else if (monitor_ctrl_mode(mon)) {
3903 /* Monitor Protocol */
3904 monitor_protocol_emitter(mon, data);
3905 } else {
3906 /* User Protocol */
3907 if (data)
3908 cmd->user_print(mon, data);
3909 }
3910
3911 qobject_decref(data);
3912 }
3913
3914 static void handle_user_command(Monitor *mon, const char *cmdline)
3915 {
3916 QDict *qdict;
3917 const mon_cmd_t *cmd;
3918
3919 qdict = qdict_new();
3920
3921 cmd = monitor_parse_command(mon, cmdline, qdict);
3922 if (!cmd)
3923 goto out;
3924
3925 if (monitor_handler_is_async(cmd)) {
3926 user_async_cmd_handler(mon, cmd, qdict);
3927 } else if (monitor_handler_ported(cmd)) {
3928 monitor_call_handler(mon, cmd, qdict);
3929 } else {
3930 cmd->mhandler.cmd(mon, qdict);
3931 }
3932
3933 out:
3934 QDECREF(qdict);
3935 }
3936
3937 static void cmd_completion(const char *name, const char *list)
3938 {
3939 const char *p, *pstart;
3940 char cmd[128];
3941 int len;
3942
3943 p = list;
3944 for(;;) {
3945 pstart = p;
3946 p = strchr(p, '|');
3947 if (!p)
3948 p = pstart + strlen(pstart);
3949 len = p - pstart;
3950 if (len > sizeof(cmd) - 2)
3951 len = sizeof(cmd) - 2;
3952 memcpy(cmd, pstart, len);
3953 cmd[len] = '\0';
3954 if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
3955 readline_add_completion(cur_mon->rs, cmd);
3956 }
3957 if (*p == '\0')
3958 break;
3959 p++;
3960 }
3961 }
3962
3963 static void file_completion(const char *input)
3964 {
3965 DIR *ffs;
3966 struct dirent *d;
3967 char path[1024];
3968 char file[1024], file_prefix[1024];
3969 int input_path_len;
3970 const char *p;
3971
3972 p = strrchr(input, '/');
3973 if (!p) {
3974 input_path_len = 0;
3975 pstrcpy(file_prefix, sizeof(file_prefix), input);
3976 pstrcpy(path, sizeof(path), ".");
3977 } else {
3978 input_path_len = p - input + 1;
3979 memcpy(path, input, input_path_len);
3980 if (input_path_len > sizeof(path) - 1)
3981 input_path_len = sizeof(path) - 1;
3982 path[input_path_len] = '\0';
3983 pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
3984 }
3985 #ifdef DEBUG_COMPLETION
3986 monitor_printf(cur_mon, "input='%s' path='%s' prefix='%s'\n",
3987 input, path, file_prefix);
3988 #endif
3989 ffs = opendir(path);
3990 if (!ffs)
3991 return;
3992 for(;;) {
3993 struct stat sb;
3994 d = readdir(ffs);
3995 if (!d)
3996 break;
3997 if (strstart(d->d_name, file_prefix, NULL)) {
3998 memcpy(file, input, input_path_len);
3999 if (input_path_len < sizeof(file))
4000 pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
4001 d->d_name);
4002 /* stat the file to find out if it's a directory.
4003 * In that case add a slash to speed up typing long paths
4004 */
4005 stat(file, &sb);
4006 if(S_ISDIR(sb.st_mode))
4007 pstrcat(file, sizeof(file), "/");
4008 readline_add_completion(cur_mon->rs, file);
4009 }
4010 }
4011 closedir(ffs);
4012 }
4013
4014 static void block_completion_it(void *opaque, BlockDriverState *bs)
4015 {
4016 const char *name = bdrv_get_device_name(bs);
4017 const char *input = opaque;
4018
4019 if (input[0] == '\0' ||
4020 !strncmp(name, (char *)input, strlen(input))) {
4021 readline_add_completion(cur_mon->rs, name);
4022 }
4023 }
4024
4025 /* NOTE: this parser is an approximate form of the real command parser */
4026 static void parse_cmdline(const char *cmdline,
4027 int *pnb_args, char **args)
4028 {
4029 const char *p;
4030 int nb_args, ret;
4031 char buf[1024];
4032
4033 p = cmdline;
4034 nb_args = 0;
4035 for(;;) {
4036 while (qemu_isspace(*p))
4037 p++;
4038 if (*p == '\0')
4039 break;
4040 if (nb_args >= MAX_ARGS)
4041 break;
4042 ret = get_str(buf, sizeof(buf), &p);
4043 args[nb_args] = qemu_strdup(buf);
4044 nb_args++;
4045 if (ret < 0)
4046 break;
4047 }
4048 *pnb_args = nb_args;
4049 }
4050
4051 static const char *next_arg_type(const char *typestr)
4052 {
4053 const char *p = strchr(typestr, ':');
4054 return (p != NULL ? ++p : typestr);
4055 }
4056
4057 static void monitor_find_completion(const char *cmdline)
4058 {
4059 const char *cmdname;
4060 char *args[MAX_ARGS];
4061 int nb_args, i, len;
4062 const char *ptype, *str;
4063 const mon_cmd_t *cmd;
4064 const KeyDef *key;
4065
4066 parse_cmdline(cmdline, &nb_args, args);
4067 #ifdef DEBUG_COMPLETION
4068 for(i = 0; i < nb_args; i++) {
4069 monitor_printf(cur_mon, "arg%d = '%s'\n", i, (char *)args[i]);
4070 }
4071 #endif
4072
4073 /* if the line ends with a space, it means we want to complete the
4074 next arg */
4075 len = strlen(cmdline);
4076 if (len > 0 && qemu_isspace(cmdline[len - 1])) {
4077 if (nb_args >= MAX_ARGS)
4078 return;
4079 args[nb_args++] = qemu_strdup("");
4080 }
4081 if (nb_args <= 1) {
4082 /* command completion */
4083 if (nb_args == 0)
4084 cmdname = "";
4085 else
4086 cmdname = args[0];
4087 readline_set_completion_index(cur_mon->rs, strlen(cmdname));
4088 for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
4089 cmd_completion(cmdname, cmd->name);
4090 }
4091 } else {
4092 /* find the command */
4093 for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
4094 if (compare_cmd(args[0], cmd->name))
4095 goto found;
4096 }
4097 return;
4098 found:
4099 ptype = next_arg_type(cmd->args_type);
4100 for(i = 0; i < nb_args - 2; i++) {
4101 if (*ptype != '\0') {
4102 ptype = next_arg_type(ptype);
4103 while (*ptype == '?')
4104 ptype = next_arg_type(ptype);
4105 }
4106 }
4107 str = args[nb_args - 1];
4108 if (*ptype == '-' && ptype[1] != '\0') {
4109 ptype += 2;
4110 }
4111 switch(*ptype) {
4112 case 'F':
4113 /* file completion */
4114 readline_set_completion_index(cur_mon->rs, strlen(str));
4115 file_completion(str);
4116 break;
4117 case 'B':
4118 /* block device name completion */
4119 readline_set_completion_index(cur_mon->rs, strlen(str));
4120 bdrv_iterate(block_completion_it, (void *)str);
4121 break;
4122 case 's':
4123 /* XXX: more generic ? */
4124 if (!strcmp(cmd->name, "info")) {
4125 readline_set_completion_index(cur_mon->rs, strlen(str));
4126 for(cmd = info_cmds; cmd->name != NULL; cmd++) {
4127 cmd_completion(str, cmd->name);
4128 }
4129 } else if (!strcmp(cmd->name, "sendkey")) {
4130 char *sep = strrchr(str, '-');
4131 if (sep)
4132 str = sep + 1;
4133 readline_set_completion_index(cur_mon->rs, strlen(str));
4134 for(key = key_defs; key->name != NULL; key++) {
4135 cmd_completion(str, key->name);
4136 }
4137 } else if (!strcmp(cmd->name, "help|?")) {
4138 readline_set_completion_index(cur_mon->rs, strlen(str));
4139 for (cmd = mon_cmds; cmd->name != NULL; cmd++) {
4140 cmd_completion(str, cmd->name);
4141 }
4142 }
4143 break;
4144 default:
4145 break;
4146 }
4147 }
4148 for(i = 0; i < nb_args; i++)
4149 qemu_free(args[i]);
4150 }
4151
4152 static int monitor_can_read(void *opaque)
4153 {
4154 Monitor *mon = opaque;
4155
4156 return (mon->suspend_cnt == 0) ? 1 : 0;
4157 }
4158
4159 typedef struct CmdArgs {
4160 QString *name;
4161 int type;
4162 int flag;
4163 int optional;
4164 } CmdArgs;
4165
4166 static int check_opt(const CmdArgs *cmd_args, const char *name, QDict *args)
4167 {
4168 if (!cmd_args->optional) {
4169 qerror_report(QERR_MISSING_PARAMETER, name);
4170 return -1;
4171 }
4172
4173 if (cmd_args->type == '-') {
4174 /* handlers expect a value, they need to be changed */
4175 qdict_put(args, name, qint_from_int(0));
4176 }
4177
4178 return 0;
4179 }
4180
4181 static int check_arg(const CmdArgs *cmd_args, QDict *args)
4182 {
4183 QObject *value;
4184 const char *name;
4185
4186 name = qstring_get_str(cmd_args->name);
4187
4188 if (!args) {
4189 return check_opt(cmd_args, name, args);
4190 }
4191
4192 value = qdict_get(args, name);
4193 if (!value) {
4194 return check_opt(cmd_args, name, args);
4195 }
4196
4197 switch (cmd_args->type) {
4198 case 'F':
4199 case 'B':
4200 case 's':
4201 if (qobject_type(value) != QTYPE_QSTRING) {
4202 qerror_report(QERR_INVALID_PARAMETER_TYPE, name, "string");
4203 return -1;
4204 }
4205 break;
4206 case '/': {
4207 int i;
4208 const char *keys[] = { "count", "format", "size", NULL };
4209
4210 for (i = 0; keys[i]; i++) {
4211 QObject *obj = qdict_get(args, keys[i]);
4212 if (!obj) {
4213 qerror_report(QERR_MISSING_PARAMETER, name);
4214 return -1;
4215 }
4216 if (qobject_type(obj) != QTYPE_QINT) {
4217 qerror_report(QERR_INVALID_PARAMETER_TYPE, name, "int");
4218 return -1;
4219 }
4220 }
4221 break;
4222 }
4223 case 'i':
4224 case 'l':
4225 case 'M':
4226 if (qobject_type(value) != QTYPE_QINT) {
4227 qerror_report(QERR_INVALID_PARAMETER_TYPE, name, "int");
4228 return -1;
4229 }
4230 break;
4231 case 'b':
4232 case 'T':
4233 if (qobject_type(value) != QTYPE_QINT && qobject_type(value) != QTYPE_QFLOAT) {
4234 qerror_report(QERR_INVALID_PARAMETER_TYPE, name, "number");
4235 return -1;
4236 }
4237 break;
4238 case '-':
4239 if (qobject_type(value) != QTYPE_QINT &&
4240 qobject_type(value) != QTYPE_QBOOL) {
4241 qerror_report(QERR_INVALID_PARAMETER_TYPE, name, "bool");
4242 return -1;
4243 }
4244 if (qobject_type(value) == QTYPE_QBOOL) {
4245 /* handlers expect a QInt, they need to be changed */
4246 qdict_put(args, name,
4247 qint_from_int(qbool_get_int(qobject_to_qbool(value))));
4248 }
4249 break;
4250 case 'O':
4251 default:
4252 /* impossible */
4253 abort();
4254 }
4255
4256 return 0;
4257 }
4258
4259 static void cmd_args_init(CmdArgs *cmd_args)
4260 {
4261 cmd_args->name = qstring_new();
4262 cmd_args->type = cmd_args->flag = cmd_args->optional = 0;
4263 }
4264
4265 static int check_opts(QemuOptsList *opts_list, QDict *args)
4266 {
4267 assert(!opts_list->desc->name);
4268 return 0;
4269 }
4270
4271 /*
4272 * This is not trivial, we have to parse Monitor command's argument
4273 * type syntax to be able to check the arguments provided by clients.
4274 *
4275 * In the near future we will be using an array for that and will be
4276 * able to drop all this parsing...
4277 */
4278 static int monitor_check_qmp_args(const mon_cmd_t *cmd, QDict *args)
4279 {
4280 int err;
4281 const char *p;
4282 CmdArgs cmd_args;
4283 QemuOptsList *opts_list;
4284
4285 if (cmd->args_type == NULL) {
4286 return (qdict_size(args) == 0 ? 0 : -1);
4287 }
4288
4289 err = 0;
4290 cmd_args_init(&cmd_args);
4291 opts_list = NULL;
4292
4293 for (p = cmd->args_type;; p++) {
4294 if (*p == ':') {
4295 cmd_args.type = *++p;
4296 p++;
4297 if (cmd_args.type == '-') {
4298 cmd_args.flag = *p++;
4299 cmd_args.optional = 1;
4300 } else if (cmd_args.type == 'O') {
4301 opts_list = qemu_find_opts(qstring_get_str(cmd_args.name));
4302 assert(opts_list);
4303 } else if (*p == '?') {
4304 cmd_args.optional = 1;
4305 p++;
4306 }
4307
4308 assert(*p == ',' || *p == '\0');
4309 if (opts_list) {
4310 err = check_opts(opts_list, args);
4311 opts_list = NULL;
4312 } else {
4313 err = check_arg(&cmd_args, args);
4314 QDECREF(cmd_args.name);
4315 cmd_args_init(&cmd_args);
4316 }
4317
4318 if (err < 0) {
4319 break;
4320 }
4321 } else {
4322 qstring_append_chr(cmd_args.name, *p);
4323 }
4324
4325 if (*p == '\0') {
4326 break;
4327 }
4328 }
4329
4330 QDECREF(cmd_args.name);
4331 return err;
4332 }
4333
4334 static int invalid_qmp_mode(const Monitor *mon, const char *cmd_name)
4335 {
4336 int is_cap = compare_cmd(cmd_name, "qmp_capabilities");
4337 return (qmp_cmd_mode(mon) ? is_cap : !is_cap);
4338 }
4339
4340 static void handle_qmp_command(JSONMessageParser *parser, QList *tokens)
4341 {
4342 int err;
4343 QObject *obj;
4344 QDict *input, *args;
4345 const mon_cmd_t *cmd;
4346 Monitor *mon = cur_mon;
4347 const char *cmd_name, *info_item;
4348
4349 args = NULL;
4350
4351 obj = json_parser_parse(tokens, NULL);
4352 if (!obj) {
4353 // FIXME: should be triggered in json_parser_parse()
4354 qerror_report(QERR_JSON_PARSING);
4355 goto err_out;
4356 } else if (qobject_type(obj) != QTYPE_QDICT) {
4357 qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "object");
4358 qobject_decref(obj);
4359 goto err_out;
4360 }
4361
4362 input = qobject_to_qdict(obj);
4363
4364 mon->mc->id = qdict_get(input, "id");
4365 qobject_incref(mon->mc->id);
4366
4367 obj = qdict_get(input, "execute");
4368 if (!obj) {
4369 qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "execute");
4370 goto err_input;
4371 } else if (qobject_type(obj) != QTYPE_QSTRING) {
4372 qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "string");
4373 goto err_input;
4374 }
4375
4376 cmd_name = qstring_get_str(qobject_to_qstring(obj));
4377
4378 if (invalid_qmp_mode(mon, cmd_name)) {
4379 qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);
4380 goto err_input;
4381 }
4382
4383 /*
4384 * XXX: We need this special case until we get info handlers
4385 * converted into 'query-' commands
4386 */
4387 if (compare_cmd(cmd_name, "info")) {
4388 qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);
4389 goto err_input;
4390 } else if (strstart(cmd_name, "query-", &info_item)) {
4391 cmd = monitor_find_command("info");
4392 qdict_put_obj(input, "arguments",
4393 qobject_from_jsonf("{ 'item': %s }", info_item));
4394 } else {
4395 cmd = monitor_find_command(cmd_name);
4396 if (!cmd || !monitor_handler_ported(cmd)) {
4397 qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);
4398 goto err_input;
4399 }
4400 }
4401
4402 obj = qdict_get(input, "arguments");
4403 if (!obj) {
4404 args = qdict_new();
4405 } else {
4406 args = qobject_to_qdict(obj);
4407 QINCREF(args);
4408 }
4409
4410 QDECREF(input);
4411
4412 err = monitor_check_qmp_args(cmd, args);
4413 if (err < 0) {
4414 goto err_out;
4415 }
4416
4417 if (monitor_handler_is_async(cmd)) {
4418 qmp_async_cmd_handler(mon, cmd, args);
4419 } else {
4420 monitor_call_handler(mon, cmd, args);
4421 }
4422 goto out;
4423
4424 err_input:
4425 QDECREF(input);
4426 err_out:
4427 monitor_protocol_emitter(mon, NULL);
4428 out:
4429 QDECREF(args);
4430 }
4431
4432 /**
4433 * monitor_control_read(): Read and handle QMP input
4434 */
4435 static void monitor_control_read(void *opaque, const uint8_t *buf, int size)
4436 {
4437 Monitor *old_mon = cur_mon;
4438
4439 cur_mon = opaque;
4440
4441 json_message_parser_feed(&cur_mon->mc->parser, (const char *) buf, size);
4442
4443 cur_mon = old_mon;
4444 }
4445
4446 static void monitor_read(void *opaque, const uint8_t *buf, int size)
4447 {
4448 Monitor *old_mon = cur_mon;
4449 int i;
4450
4451 cur_mon = opaque;
4452
4453 if (cur_mon->rs) {
4454 for (i = 0; i < size; i++)
4455 readline_handle_byte(cur_mon->rs, buf[i]);
4456 } else {
4457 if (size == 0 || buf[size - 1] != 0)
4458 monitor_printf(cur_mon, "corrupted command\n");
4459 else
4460 handle_user_command(cur_mon, (char *)buf);
4461 }
4462
4463 cur_mon = old_mon;
4464 }
4465
4466 static void monitor_command_cb(Monitor *mon, const char *cmdline, void *opaque)
4467 {
4468 monitor_suspend(mon);
4469 handle_user_command(mon, cmdline);
4470 monitor_resume(mon);
4471 }
4472
4473 int monitor_suspend(Monitor *mon)
4474 {
4475 if (!mon->rs)
4476 return -ENOTTY;
4477 mon->suspend_cnt++;
4478 return 0;
4479 }
4480
4481 void monitor_resume(Monitor *mon)
4482 {
4483 if (!mon->rs)
4484 return;
4485 if (--mon->suspend_cnt == 0)
4486 readline_show_prompt(mon->rs);
4487 }
4488
4489 static QObject *get_qmp_greeting(void)
4490 {
4491 QObject *ver;
4492
4493 do_info_version(NULL, &ver);
4494 return qobject_from_jsonf("{'QMP':{'version': %p,'capabilities': []}}",ver);
4495 }
4496
4497 /**
4498 * monitor_control_event(): Print QMP gretting
4499 */
4500 static void monitor_control_event(void *opaque, int event)
4501 {
4502 QObject *data;
4503 Monitor *mon = opaque;
4504
4505 switch (event) {
4506 case CHR_EVENT_OPENED:
4507 mon->mc->command_mode = 0;
4508 json_message_parser_init(&mon->mc->parser, handle_qmp_command);
4509 data = get_qmp_greeting();
4510 monitor_json_emitter(mon, data);
4511 qobject_decref(data);
4512 break;
4513 case CHR_EVENT_CLOSED:
4514 json_message_parser_destroy(&mon->mc->parser);
4515 break;
4516 }
4517 }
4518
4519 static void monitor_event(void *opaque, int event)
4520 {
4521 Monitor *mon = opaque;
4522
4523 switch (event) {
4524 case CHR_EVENT_MUX_IN:
4525 mon->mux_out = 0;
4526 if (mon->reset_seen) {
4527 readline_restart(mon->rs);
4528 monitor_resume(mon);
4529 monitor_flush(mon);
4530 } else {
4531 mon->suspend_cnt = 0;
4532 }
4533 break;
4534
4535 case CHR_EVENT_MUX_OUT:
4536 if (mon->reset_seen) {
4537 if (mon->suspend_cnt == 0) {
4538 monitor_printf(mon, "\n");
4539 }
4540 monitor_flush(mon);
4541 monitor_suspend(mon);
4542 } else {
4543 mon->suspend_cnt++;
4544 }
4545 mon->mux_out = 1;
4546 break;
4547
4548 case CHR_EVENT_OPENED:
4549 monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
4550 "information\n", QEMU_VERSION);
4551 if (!mon->mux_out) {
4552 readline_show_prompt(mon->rs);
4553 }
4554 mon->reset_seen = 1;
4555 break;
4556 }
4557 }
4558
4559
4560 /*
4561 * Local variables:
4562 * c-indent-level: 4
4563 * c-basic-offset: 4
4564 * tab-width: 8
4565 * End:
4566 */
4567
4568 void monitor_init(CharDriverState *chr, int flags)
4569 {
4570 static int is_first_init = 1;
4571 Monitor *mon;
4572
4573 if (is_first_init) {
4574 key_timer = qemu_new_timer(vm_clock, release_keys, NULL);
4575 is_first_init = 0;
4576 }
4577
4578 mon = qemu_mallocz(sizeof(*mon));
4579
4580 mon->chr = chr;
4581 mon->flags = flags;
4582 if (flags & MONITOR_USE_READLINE) {
4583 mon->rs = readline_init(mon, monitor_find_completion);
4584 monitor_read_command(mon, 0);
4585 }
4586
4587 if (monitor_ctrl_mode(mon)) {
4588 mon->mc = qemu_mallocz(sizeof(MonitorControl));
4589 /* Control mode requires special handlers */
4590 qemu_chr_add_handlers(chr, monitor_can_read, monitor_control_read,
4591 monitor_control_event, mon);
4592 } else {
4593 qemu_chr_add_handlers(chr, monitor_can_read, monitor_read,
4594 monitor_event, mon);
4595 }
4596
4597 QLIST_INSERT_HEAD(&mon_list, mon, entry);
4598 if (!default_mon || (flags & MONITOR_IS_DEFAULT))
4599 default_mon = mon;
4600 }
4601
4602 static void bdrv_password_cb(Monitor *mon, const char *password, void *opaque)
4603 {
4604 BlockDriverState *bs = opaque;
4605 int ret = 0;
4606
4607 if (bdrv_set_key(bs, password) != 0) {
4608 monitor_printf(mon, "invalid password\n");
4609 ret = -EPERM;
4610 }
4611 if (mon->password_completion_cb)
4612 mon->password_completion_cb(mon->password_opaque, ret);
4613
4614 monitor_read_command(mon, 1);
4615 }
4616
4617 int monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
4618 BlockDriverCompletionFunc *completion_cb,
4619 void *opaque)
4620 {
4621 int err;
4622
4623 if (!bdrv_key_required(bs)) {
4624 if (completion_cb)
4625 completion_cb(opaque, 0);
4626 return 0;
4627 }
4628
4629 if (monitor_ctrl_mode(mon)) {
4630 qerror_report(QERR_DEVICE_ENCRYPTED, bdrv_get_device_name(bs));
4631 return -1;
4632 }
4633
4634 monitor_printf(mon, "%s (%s) is encrypted.\n", bdrv_get_device_name(bs),
4635 bdrv_get_encrypted_filename(bs));
4636
4637 mon->password_completion_cb = completion_cb;
4638 mon->password_opaque = opaque;
4639
4640 err = monitor_read_password(mon, bdrv_password_cb, bs);
4641
4642 if (err && completion_cb)
4643 completion_cb(opaque, err);
4644
4645 return err;
4646 }
kraxel's qemu bits