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