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