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