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