]> git.proxmox.com Git - qemu.git/blame - monitor.c
projects / qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
monitor: Convert do_quit() do QObject
[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"
35#include "qemu-char.h"
36#include "sysemu.h"
376253ec
AL		 37#include "monitor.h"
38#include "readline.h"
87ecb68b
PB		 39#include "console.h"
40#include "block.h"
41#include "audio/audio.h"
9307c4c1 42#include "disas.h"
df751fa8 43#include "balloon.h"
c8256f9d 44#include "qemu-timer.h"
5bb7910a 45#include "migration.h"
7ba1e619 46#include "kvm.h"
76655d6d 47#include "acl.h"
f7188bbe
LC		 48#include "qint.h"
49#include "qdict.h"
50#include "qstring.h"
6a5bd307 51
9dc39cba 52//#define DEBUG
81d0912d 53//#define DEBUG_COMPLETION
9dc39cba 54
9307c4c1
FB		 55/*
56 * Supported types:
5fafdf24 57 *
9307c4c1 58 * 'F' filename
81d0912d 59 * 'B' block device name
9307c4c1 60 * 's' string (accept optional quote)
92a31b1f
FB		 61 * 'i' 32 bit integer
62 * 'l' target long (32 or 64 bit)
9307c4c1
FB		 63 * '/' optional gdb-like print format (like "/10x")
64 *
fb46660e
LC		 65 * '?' optional type (for all types, except '/')
66 * '.' other form of optional type (for 'i' and 'l')
67 * '-' optional parameter (eg. '-f')
9307c4c1
FB		 68 *
69 */
70
c227f099 71typedef struct mon_cmd_t {
9dc39cba 72 const char *name;
9307c4c1 73 const char *args_type;
9dc39cba
FB		 74 const char *params;
75 const char *help;
a2876f59 76 void (*user_print)(Monitor *mon, const QObject *data);
910df89d
LC		 77 union {
78 void (*info)(Monitor *mon);
13c7425e 79 void (*info_new)(Monitor *mon, QObject **ret_data);
af4ce882 80 void (*cmd)(Monitor *mon, const QDict *qdict);
13917bee 81 void (*cmd_new)(Monitor *mon, const QDict *params, QObject **ret_data);
910df89d 82 } mhandler;
c227f099 83} mon_cmd_t;
9dc39cba 84
f07918fd 85/* file descriptors passed via SCM_RIGHTS */
c227f099
AL		 86typedef struct mon_fd_t mon_fd_t;
87struct mon_fd_t {
f07918fd
MM		 88 char *name;
89 int fd;
c227f099 90 QLIST_ENTRY(mon_fd_t) next;
f07918fd
MM		 91};
92
87127161
AL		 93struct Monitor {
94 CharDriverState *chr;
a7aec5da
GH		 95 int mux_out;
96 int reset_seen;
731b0364
AL		 97 int flags;
98 int suspend_cnt;
99 uint8_t outbuf[1024];
100 int outbuf_index;
101 ReadLineState *rs;
102 CPUState *mon_cpu;
103 BlockDriverCompletionFunc *password_completion_cb;
104 void *password_opaque;
c227f099 105 QLIST_HEAD(,mon_fd_t) fds;
72cf2d4f 106 QLIST_ENTRY(Monitor) entry;
87127161
AL		 107};
108
72cf2d4f 109static QLIST_HEAD(mon_list, Monitor) mon_list;
7e2515e8 110
c227f099
AL		 111static const mon_cmd_t mon_cmds[];
112static const mon_cmd_t info_cmds[];
9dc39cba 113
87127161 114Monitor *cur_mon = NULL;
376253ec 115
731b0364
AL		 116static void monitor_command_cb(Monitor *mon, const char *cmdline,
117 void *opaque);
83ab7950 118
731b0364
AL		 119static void monitor_read_command(Monitor *mon, int show_prompt)
120{
121 readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL);
122 if (show_prompt)
123 readline_show_prompt(mon->rs);
124}
6a00d601 125
cde76ee1
AL		 126static int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
127 void *opaque)
bb5fc20f 128{
cde76ee1
AL		 129 if (mon->rs) {
130 readline_start(mon->rs, "Password: ", 1, readline_func, opaque);
131 /* prompt is printed on return from the command handler */
132 return 0;
133 } else {
134 monitor_printf(mon, "terminal does not support password prompting\n");
135 return -ENOTTY;
136 }
bb5fc20f
AL		 137}
138
376253ec 139void monitor_flush(Monitor *mon)
7e2515e8 140{
a7aec5da 141 if (mon && mon->outbuf_index != 0 && !mon->mux_out) {
731b0364
AL		 142 qemu_chr_write(mon->chr, mon->outbuf, mon->outbuf_index);
143 mon->outbuf_index = 0;
7e2515e8
FB		 144 }
145}
146
147/* flush at every end of line or if the buffer is full */
376253ec 148static void monitor_puts(Monitor *mon, const char *str)
7e2515e8 149{
60fe76f3 150 char c;
731b0364
AL		 151
152 if (!mon)
153 return;
154
7e2515e8
FB		 155 for(;;) {
156 c = *str++;
157 if (c == '\0')
158 break;
7ba1260a 159 if (c == '\n')
731b0364
AL		 160 mon->outbuf[mon->outbuf_index++] = '\r';
161 mon->outbuf[mon->outbuf_index++] = c;
162 if (mon->outbuf_index >= (sizeof(mon->outbuf) - 1)
163 || c == '\n')
376253ec 164 monitor_flush(mon);
7e2515e8
FB		 165 }
166}
167
376253ec 168void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
9dc39cba 169{
81d0912d 170 char buf[4096];
81d0912d 171 vsnprintf(buf, sizeof(buf), fmt, ap);
376253ec 172 monitor_puts(mon, buf);
9dc39cba
FB		 173}
174
376253ec 175void monitor_printf(Monitor *mon, const char *fmt, ...)
9dc39cba 176{
7e2515e8
FB		 177 va_list ap;
178 va_start(ap, fmt);
376253ec 179 monitor_vprintf(mon, fmt, ap);
7e2515e8 180 va_end(ap);
9dc39cba
FB		 181}
182
376253ec 183void monitor_print_filename(Monitor *mon, const char *filename)
fef30743
TS		 184{
185 int i;
186
187 for (i = 0; filename[i]; i++) {
28a76be8
AL		 188 switch (filename[i]) {
189 case ' ':
190 case '"':
191 case '\\':
192 monitor_printf(mon, "\\%c", filename[i]);
193 break;
194 case '\t':
195 monitor_printf(mon, "\\t");
196 break;
197 case '\r':
198 monitor_printf(mon, "\\r");
199 break;
200 case '\n':
201 monitor_printf(mon, "\\n");
202 break;
203 default:
204 monitor_printf(mon, "%c", filename[i]);
205 break;
206 }
fef30743
TS		 207 }
208}
209
7fe48483
FB		 210static int monitor_fprintf(FILE *stream, const char *fmt, ...)
211{
212 va_list ap;
213 va_start(ap, fmt);
376253ec 214 monitor_vprintf((Monitor *)stream, fmt, ap);
7fe48483
FB		 215 va_end(ap);
216 return 0;
217}
218
13c7425e
LC		 219static void monitor_user_noop(Monitor *mon, const QObject *data) { }
220
13917bee
LC		 221static inline int monitor_handler_ported(const mon_cmd_t *cmd)
222{
223 return cmd->user_print != NULL;
224}
225
9dc39cba
FB		 226static int compare_cmd(const char *name, const char *list)
227{
228 const char *p, *pstart;
229 int len;
230 len = strlen(name);
231 p = list;
232 for(;;) {
233 pstart = p;
234 p = strchr(p, '|');
235 if (!p)
236 p = pstart + strlen(pstart);
237 if ((p - pstart) == len && !memcmp(pstart, name, len))
238 return 1;
239 if (*p == '\0')
240 break;
241 p++;
242 }
243 return 0;
244}
245
c227f099 246static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
376253ec 247 const char *prefix, const char *name)
9dc39cba 248{
c227f099 249 const mon_cmd_t *cmd;
9dc39cba
FB		 250
251 for(cmd = cmds; cmd->name != NULL; cmd++) {
252 if (!name || !strcmp(name, cmd->name))
376253ec
AL		 253 monitor_printf(mon, "%s%s %s -- %s\n", prefix, cmd->name,
254 cmd->params, cmd->help);
9dc39cba
FB		 255 }
256}
257
376253ec 258static void help_cmd(Monitor *mon, const char *name)
9dc39cba
FB		 259{
260 if (name && !strcmp(name, "info")) {
376253ec 261 help_cmd_dump(mon, info_cmds, "info ", NULL);
9dc39cba 262 } else {
376253ec 263 help_cmd_dump(mon, mon_cmds, "", name);
f193c797 264 if (name && !strcmp(name, "log")) {
8662d656 265 const CPULogItem *item;
376253ec
AL		 266 monitor_printf(mon, "Log items (comma separated):\n");
267 monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");
f193c797 268 for(item = cpu_log_items; item->mask != 0; item++) {
376253ec 269 monitor_printf(mon, "%-10s %s\n", item->name, item->help);
f193c797
FB		 270 }
271 }
9dc39cba
FB		 272 }
273}
274
d54908a5 275static void do_help_cmd(Monitor *mon, const QDict *qdict)
38183186 276{
d54908a5 277 help_cmd(mon, qdict_get_try_str(qdict, "name"));
38183186
LC		 278}
279
d54908a5 280static void do_commit(Monitor *mon, const QDict *qdict)
9dc39cba 281{
751c6a17
GH		 282 int all_devices;
283 DriveInfo *dinfo;
d54908a5 284 const char *device = qdict_get_str(qdict, "device");
2dc7b602 285
7954c734 286 all_devices = !strcmp(device, "all");
72cf2d4f 287 QTAILQ_FOREACH(dinfo, &drives, next) {
751c6a17 288 if (!all_devices)
73006d2a 289 if (strcmp(bdrv_get_device_name(dinfo->bdrv), device))
751c6a17
GH		 290 continue;
291 bdrv_commit(dinfo->bdrv);
9dc39cba
FB		 292 }
293}
294
13c7425e 295static void do_info(Monitor *mon, const QDict *qdict, QObject **ret_data)
9dc39cba 296{
c227f099 297 const mon_cmd_t *cmd;
d54908a5 298 const char *item = qdict_get_try_str(qdict, "item");
9dc39cba 299
9307c4c1 300 if (!item)
9dc39cba 301 goto help;
13c7425e
LC		 302
303 for (cmd = info_cmds; cmd->name != NULL; cmd++) {
5fafdf24 304 if (compare_cmd(item, cmd->name))
13c7425e 305 break;
9dc39cba 306 }
13c7425e
LC		 307
308 if (cmd->name == NULL)
309 goto help;
310
311 if (monitor_handler_ported(cmd)) {
312 cmd->mhandler.info_new(mon, ret_data);
313 if (*ret_data)
314 cmd->user_print(mon, *ret_data);
315 } else {
316 cmd->mhandler.info(mon);
317 }
318
9dc39cba 319 return;
13c7425e
LC		 320
321help:
322 help_cmd(mon, "info");
9dc39cba
FB		 323}
324
376253ec 325static void do_info_version(Monitor *mon)
9bc9d1c7 326{
4a19f1ec 327 monitor_printf(mon, "%s\n", QEMU_VERSION QEMU_PKGVERSION);
9bc9d1c7
FB		 328}
329
376253ec 330static void do_info_name(Monitor *mon)
c35734b2
TS		 331{
332 if (qemu_name)
376253ec 333 monitor_printf(mon, "%s\n", qemu_name);
c35734b2
TS		 334}
335
bf4f74c0 336#if defined(TARGET_I386)
376253ec 337static void do_info_hpet(Monitor *mon)
16b29ae1 338{
376253ec
AL		 339 monitor_printf(mon, "HPET is %s by QEMU\n",
340 (no_hpet) ? "disabled" : "enabled");
16b29ae1 341}
bf4f74c0 342#endif
16b29ae1 343
376253ec 344static void do_info_uuid(Monitor *mon)
a36e69dd 345{
376253ec
AL		 346 monitor_printf(mon, UUID_FMT "\n", qemu_uuid[0], qemu_uuid[1],
347 qemu_uuid[2], qemu_uuid[3], qemu_uuid[4], qemu_uuid[5],
348 qemu_uuid[6], qemu_uuid[7], qemu_uuid[8], qemu_uuid[9],
349 qemu_uuid[10], qemu_uuid[11], qemu_uuid[12], qemu_uuid[13],
350 qemu_uuid[14], qemu_uuid[15]);
a36e69dd
TS		 351}
352
6a00d601 353/* get the current CPU defined by the user */
9596ebb7 354static int mon_set_cpu(int cpu_index)
6a00d601
FB		 355{
356 CPUState *env;
357
358 for(env = first_cpu; env != NULL; env = env->next_cpu) {
359 if (env->cpu_index == cpu_index) {
731b0364 360 cur_mon->mon_cpu = env;
6a00d601
FB		 361 return 0;
362 }
363 }
364 return -1;
365}
366
9596ebb7 367static CPUState *mon_get_cpu(void)
6a00d601 368{
731b0364 369 if (!cur_mon->mon_cpu) {
6a00d601
FB		 370 mon_set_cpu(0);
371 }
4c0960c0 372 cpu_synchronize_state(cur_mon->mon_cpu);
731b0364 373 return cur_mon->mon_cpu;
6a00d601
FB		 374}
375
376253ec 376static void do_info_registers(Monitor *mon)
9307c4c1 377{
6a00d601
FB		 378 CPUState *env;
379 env = mon_get_cpu();
380 if (!env)
381 return;
9307c4c1 382#ifdef TARGET_I386
376253ec 383 cpu_dump_state(env, (FILE *)mon, monitor_fprintf,
d24b15a8 384 X86_DUMP_FPU);
9307c4c1 385#else
376253ec 386 cpu_dump_state(env, (FILE *)mon, monitor_fprintf,
7fe48483 387 0);
9307c4c1
FB		 388#endif
389}
390
376253ec 391static void do_info_cpus(Monitor *mon)
6a00d601
FB		 392{
393 CPUState *env;
394
395 /* just to set the default cpu if not already done */
396 mon_get_cpu();
397
398 for(env = first_cpu; env != NULL; env = env->next_cpu) {
4c0960c0 399 cpu_synchronize_state(env);
376253ec 400 monitor_printf(mon, "%c CPU #%d:",
731b0364 401 (env == mon->mon_cpu) ? '*' : ' ',
376253ec 402 env->cpu_index);
6a00d601 403#if defined(TARGET_I386)
376253ec
AL		 404 monitor_printf(mon, " pc=0x" TARGET_FMT_lx,
405 env->eip + env->segs[R_CS].base);
e80e1cc4 406#elif defined(TARGET_PPC)
376253ec 407 monitor_printf(mon, " nip=0x" TARGET_FMT_lx, env->nip);
ba3c64fb 408#elif defined(TARGET_SPARC)
376253ec
AL		 409 monitor_printf(mon, " pc=0x" TARGET_FMT_lx " npc=0x" TARGET_FMT_lx,
410 env->pc, env->npc);
ead9360e 411#elif defined(TARGET_MIPS)
376253ec 412 monitor_printf(mon, " PC=0x" TARGET_FMT_lx, env->active_tc.PC);
ce5232c5 413#endif
ead9360e 414 if (env->halted)
376253ec
AL		 415 monitor_printf(mon, " (halted)");
416 monitor_printf(mon, "\n");
6a00d601
FB		 417 }
418}
419
d54908a5 420static void do_cpu_set(Monitor *mon, const QDict *qdict)
6a00d601 421{
d54908a5 422 int index = qdict_get_int(qdict, "index");
6a00d601 423 if (mon_set_cpu(index) < 0)
376253ec 424 monitor_printf(mon, "Invalid CPU index\n");
6a00d601
FB		 425}
426
376253ec 427static void do_info_jit(Monitor *mon)
e3db7226 428{
376253ec 429 dump_exec_info((FILE *)mon, monitor_fprintf);
e3db7226
FB		 430}
431
376253ec 432static void do_info_history(Monitor *mon)
aa455485
FB		 433{
434 int i;
7e2515e8 435 const char *str;
3b46e624 436
cde76ee1
AL		 437 if (!mon->rs)
438 return;
7e2515e8
FB		 439 i = 0;
440 for(;;) {
731b0364 441 str = readline_get_history(mon->rs, i);
7e2515e8
FB		 442 if (!str)
443 break;
376253ec 444 monitor_printf(mon, "%d: '%s'\n", i, str);
8e3a9fd2 445 i++;
aa455485
FB		 446 }
447}
448
76a66253
JM		 449#if defined(TARGET_PPC)
450/* XXX: not implemented in other targets */
376253ec 451static void do_info_cpu_stats(Monitor *mon)
76a66253
JM		 452{
453 CPUState *env;
454
455 env = mon_get_cpu();
376253ec 456 cpu_dump_statistics(env, (FILE *)mon, &monitor_fprintf, 0);
76a66253
JM		 457}
458#endif
459
b223f35f
LC		 460/**
461 * do_quit(): Quit QEMU execution
462 */
463static void do_quit(Monitor *mon, const QDict *qdict, QObject **ret_data)
9dc39cba
FB		 464{
465 exit(0);
466}
467
376253ec 468static int eject_device(Monitor *mon, BlockDriverState *bs, int force)
9dc39cba
FB		 469{
470 if (bdrv_is_inserted(bs)) {
471 if (!force) {
472 if (!bdrv_is_removable(bs)) {
376253ec 473 monitor_printf(mon, "device is not removable\n");
9dc39cba
FB		 474 return -1;
475 }
476 if (bdrv_is_locked(bs)) {
376253ec 477 monitor_printf(mon, "device is locked\n");
9dc39cba
FB		 478 return -1;
479 }
480 }
481 bdrv_close(bs);
482 }
483 return 0;
484}
485
f18c16de 486static void do_eject(Monitor *mon, const QDict *qdict)
9dc39cba
FB		 487{
488 BlockDriverState *bs;
f18c16de
LC		 489 int force = qdict_get_int(qdict, "force");
490 const char *filename = qdict_get_str(qdict, "filename");
9dc39cba 491
9307c4c1 492 bs = bdrv_find(filename);
9dc39cba 493 if (!bs) {
376253ec 494 monitor_printf(mon, "device not found\n");
9dc39cba
FB		 495 return;
496 }
376253ec 497 eject_device(mon, bs, force);
9dc39cba
FB		 498}
499
376253ec
AL		 500static void do_change_block(Monitor *mon, const char *device,
501 const char *filename, const char *fmt)
9dc39cba
FB		 502{
503 BlockDriverState *bs;
2ecea9b8 504 BlockDriver *drv = NULL;
9dc39cba 505
9307c4c1 506 bs = bdrv_find(device);
9dc39cba 507 if (!bs) {
376253ec 508 monitor_printf(mon, "device not found\n");
9dc39cba
FB		 509 return;
510 }
2ecea9b8
AJ		 511 if (fmt) {
512 drv = bdrv_find_format(fmt);
513 if (!drv) {
376253ec 514 monitor_printf(mon, "invalid format %s\n", fmt);
2ecea9b8
AJ		 515 return;
516 }
517 }
376253ec 518 if (eject_device(mon, bs, 0) < 0)
9dc39cba 519 return;
2ecea9b8 520 bdrv_open2(bs, filename, 0, drv);
376253ec 521 monitor_read_bdrv_key_start(mon, bs, NULL, NULL);
bb5fc20f
AL		 522}
523
376253ec
AL		 524static void change_vnc_password_cb(Monitor *mon, const char *password,
525 void *opaque)
bb5fc20f
AL		 526{
527 if (vnc_display_password(NULL, password) < 0)
376253ec 528 monitor_printf(mon, "could not set VNC server password\n");
bb5fc20f 529
731b0364 530 monitor_read_command(mon, 1);
9dc39cba
FB		 531}
532
376253ec 533static void do_change_vnc(Monitor *mon, const char *target, const char *arg)
e25a5822 534{
70848515 535 if (strcmp(target, "passwd") == 0 ||
28a76be8
AL		 536 strcmp(target, "password") == 0) {
537 if (arg) {
bb5fc20f 538 char password[9];
28a76be8
AL		 539 strncpy(password, arg, sizeof(password));
540 password[sizeof(password) - 1] = '\0';
376253ec 541 change_vnc_password_cb(mon, password, NULL);
bb5fc20f 542 } else {
376253ec 543 monitor_read_password(mon, change_vnc_password_cb, NULL);
bb5fc20f 544 }
70848515 545 } else {
28a76be8 546 if (vnc_display_open(NULL, target) < 0)
376253ec 547 monitor_printf(mon, "could not start VNC server on %s\n", target);
70848515 548 }
e25a5822
TS		 549}
550
1d4daa91 551static void do_change(Monitor *mon, const QDict *qdict)
e25a5822 552{
1d4daa91
LC		 553 const char *device = qdict_get_str(qdict, "device");
554 const char *target = qdict_get_str(qdict, "target");
555 const char *arg = qdict_get_try_str(qdict, "arg");
e25a5822 556 if (strcmp(device, "vnc") == 0) {
28a76be8 557 do_change_vnc(mon, target, arg);
e25a5822 558 } else {
28a76be8 559 do_change_block(mon, device, target, arg);
e25a5822
TS		 560 }
561}
562
d54908a5 563static void do_screen_dump(Monitor *mon, const QDict *qdict)
59a983b9 564{
d54908a5 565 vga_hw_screen_dump(qdict_get_str(qdict, "filename"));
59a983b9
FB		 566}
567
d54908a5 568static void do_logfile(Monitor *mon, const QDict *qdict)
e735b91c 569{
d54908a5 570 cpu_set_log_filename(qdict_get_str(qdict, "filename"));
e735b91c
PB		 571}
572
d54908a5 573static void do_log(Monitor *mon, const QDict *qdict)
f193c797
FB		 574{
575 int mask;
d54908a5 576 const char *items = qdict_get_str(qdict, "items");
3b46e624 577
9307c4c1 578 if (!strcmp(items, "none")) {
f193c797
FB		 579 mask = 0;
580 } else {
9307c4c1 581 mask = cpu_str_to_log_mask(items);
f193c797 582 if (!mask) {
376253ec 583 help_cmd(mon, "log");
f193c797
FB		 584 return;
585 }
586 }
587 cpu_set_log(mask);
588}
589
d54908a5 590static void do_singlestep(Monitor *mon, const QDict *qdict)
1b530a6d 591{
d54908a5 592 const char *option = qdict_get_try_str(qdict, "option");
1b530a6d
AJ		 593 if (!option || !strcmp(option, "on")) {
594 singlestep = 1;
595 } else if (!strcmp(option, "off")) {
596 singlestep = 0;
597 } else {
598 monitor_printf(mon, "unexpected option %s\n", option);
599 }
600}
601
f96fc8a0 602static void do_stop(Monitor *mon, const QDict *qdict)
8a7ddc38
FB		 603{
604 vm_stop(EXCP_INTERRUPT);
605}
606
bb5fc20f 607static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs);
c0f4ce77 608
376253ec
AL		 609struct bdrv_iterate_context {
610 Monitor *mon;
611 int err;
612};
613
f96fc8a0 614static void do_cont(Monitor *mon, const QDict *qdict)
8a7ddc38 615{
376253ec 616 struct bdrv_iterate_context context = { mon, 0 };
c0f4ce77 617
376253ec 618 bdrv_iterate(encrypted_bdrv_it, &context);
c0f4ce77 619 /* only resume the vm if all keys are set and valid */
376253ec 620 if (!context.err)
c0f4ce77 621 vm_start();
8a7ddc38
FB		 622}
623
bb5fc20f
AL		 624static void bdrv_key_cb(void *opaque, int err)
625{
376253ec
AL		 626 Monitor *mon = opaque;
627
bb5fc20f
AL		 628 /* another key was set successfully, retry to continue */
629 if (!err)
f96fc8a0 630 do_cont(mon, NULL);
bb5fc20f
AL		 631}
632
633static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs)
634{
376253ec 635 struct bdrv_iterate_context *context = opaque;
bb5fc20f 636
376253ec
AL		 637 if (!context->err && bdrv_key_required(bs)) {
638 context->err = -EBUSY;
639 monitor_read_bdrv_key_start(context->mon, bs, bdrv_key_cb,
640 context->mon);
bb5fc20f
AL		 641 }
642}
643
d54908a5 644static void do_gdbserver(Monitor *mon, const QDict *qdict)
59030a8c 645{
d54908a5 646 const char *device = qdict_get_try_str(qdict, "device");
59030a8c
AL		 647 if (!device)
648 device = "tcp::" DEFAULT_GDBSTUB_PORT;
649 if (gdbserver_start(device) < 0) {
650 monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
651 device);
652 } else if (strcmp(device, "none") == 0) {
36556b20 653 monitor_printf(mon, "Disabled gdbserver\n");
8a7ddc38 654 } else {
59030a8c
AL		 655 monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
656 device);
8a7ddc38
FB		 657 }
658}
659
d54908a5 660static void do_watchdog_action(Monitor *mon, const QDict *qdict)
9dd986cc 661{
d54908a5 662 const char *action = qdict_get_str(qdict, "action");
9dd986cc
RJ		 663 if (select_watchdog_action(action) == -1) {
664 monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
665 }
666}
667
376253ec 668static void monitor_printc(Monitor *mon, int c)
9307c4c1 669{
376253ec 670 monitor_printf(mon, "'");
9307c4c1
FB		 671 switch(c) {
672 case '\'':
376253ec 673 monitor_printf(mon, "\\'");
9307c4c1
FB		 674 break;
675 case '\\':
376253ec 676 monitor_printf(mon, "\\\\");
9307c4c1
FB		 677 break;
678 case '\n':
376253ec 679 monitor_printf(mon, "\\n");
9307c4c1
FB		 680 break;
681 case '\r':
376253ec 682 monitor_printf(mon, "\\r");
9307c4c1
FB		 683 break;
684 default:
685 if (c >= 32 && c <= 126) {
376253ec 686 monitor_printf(mon, "%c", c);
9307c4c1 687 } else {
376253ec 688 monitor_printf(mon, "\\x%02x", c);
9307c4c1
FB		 689 }
690 break;
691 }
376253ec 692 monitor_printf(mon, "'");
9307c4c1
FB		 693}
694
376253ec 695static void memory_dump(Monitor *mon, int count, int format, int wsize,
c227f099 696 target_phys_addr_t addr, int is_physical)
9307c4c1 697{
6a00d601 698 CPUState *env;
9307c4c1
FB		 699 int nb_per_line, l, line_size, i, max_digits, len;
700 uint8_t buf[16];
701 uint64_t v;
702
703 if (format == 'i') {
704 int flags;
705 flags = 0;
6a00d601
FB		 706 env = mon_get_cpu();
707 if (!env && !is_physical)
708 return;
9307c4c1 709#ifdef TARGET_I386
4c27ba27 710 if (wsize == 2) {
9307c4c1 711 flags = 1;
4c27ba27
FB		 712 } else if (wsize == 4) {
713 flags = 0;
714 } else {
6a15fd12 715 /* as default we use the current CS size */
4c27ba27 716 flags = 0;
6a15fd12
FB		 717 if (env) {
718#ifdef TARGET_X86_64
5fafdf24 719 if ((env->efer & MSR_EFER_LMA) &&
6a15fd12
FB		 720 (env->segs[R_CS].flags & DESC_L_MASK))
721 flags = 2;
722 else
723#endif
724 if (!(env->segs[R_CS].flags & DESC_B_MASK))
725 flags = 1;
726 }
4c27ba27
FB		 727 }
728#endif
376253ec 729 monitor_disas(mon, env, addr, count, is_physical, flags);
9307c4c1
FB		 730 return;
731 }
732
733 len = wsize * count;
734 if (wsize == 1)
735 line_size = 8;
736 else
737 line_size = 16;
738 nb_per_line = line_size / wsize;
739 max_digits = 0;
740
741 switch(format) {
742 case 'o':
743 max_digits = (wsize * 8 + 2) / 3;
744 break;
745 default:
746 case 'x':
747 max_digits = (wsize * 8) / 4;
748 break;
749 case 'u':
750 case 'd':
751 max_digits = (wsize * 8 * 10 + 32) / 33;
752 break;
753 case 'c':
754 wsize = 1;
755 break;
756 }
757
758 while (len > 0) {
7743e588 759 if (is_physical)
376253ec 760 monitor_printf(mon, TARGET_FMT_plx ":", addr);
7743e588 761 else
376253ec 762 monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
9307c4c1
FB		 763 l = len;
764 if (l > line_size)
765 l = line_size;
766 if (is_physical) {
767 cpu_physical_memory_rw(addr, buf, l, 0);
768 } else {
6a00d601
FB		 769 env = mon_get_cpu();
770 if (!env)
771 break;
c8f79b67 772 if (cpu_memory_rw_debug(env, addr, buf, l, 0) < 0) {
376253ec 773 monitor_printf(mon, " Cannot access memory\n");
c8f79b67
AL		 774 break;
775 }
9307c4c1 776 }
5fafdf24 777 i = 0;
9307c4c1
FB		 778 while (i < l) {
779 switch(wsize) {
780 default:
781 case 1:
782 v = ldub_raw(buf + i);
783 break;
784 case 2:
785 v = lduw_raw(buf + i);
786 break;
787 case 4:
92a31b1f 788 v = (uint32_t)ldl_raw(buf + i);
9307c4c1
FB		 789 break;
790 case 8:
791 v = ldq_raw(buf + i);
792 break;
793 }
376253ec 794 monitor_printf(mon, " ");
9307c4c1
FB		 795 switch(format) {
796 case 'o':
376253ec 797 monitor_printf(mon, "%#*" PRIo64, max_digits, v);
9307c4c1
FB		 798 break;
799 case 'x':
376253ec 800 monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
9307c4c1
FB		 801 break;
802 case 'u':
376253ec 803 monitor_printf(mon, "%*" PRIu64, max_digits, v);
9307c4c1
FB		 804 break;
805 case 'd':
376253ec 806 monitor_printf(mon, "%*" PRId64, max_digits, v);
9307c4c1
FB		 807 break;
808 case 'c':
376253ec 809 monitor_printc(mon, v);
9307c4c1
FB		 810 break;
811 }
812 i += wsize;
813 }
376253ec 814 monitor_printf(mon, "\n");
9307c4c1
FB		 815 addr += l;
816 len -= l;
817 }
818}
819
1bd1442e 820static void do_memory_dump(Monitor *mon, const QDict *qdict)
9307c4c1 821{
1bd1442e
LC		 822 int count = qdict_get_int(qdict, "count");
823 int format = qdict_get_int(qdict, "format");
824 int size = qdict_get_int(qdict, "size");
825 target_long addr = qdict_get_int(qdict, "addr");
826
376253ec 827 memory_dump(mon, count, format, size, addr, 0);
9307c4c1
FB		 828}
829
1bd1442e 830static void do_physical_memory_dump(Monitor *mon, const QDict *qdict)
9307c4c1 831{
1bd1442e
LC		 832 int count = qdict_get_int(qdict, "count");
833 int format = qdict_get_int(qdict, "format");
834 int size = qdict_get_int(qdict, "size");
c227f099 835 target_phys_addr_t addr = qdict_get_int(qdict, "addr");
1bd1442e 836
376253ec 837 memory_dump(mon, count, format, size, addr, 1);
9307c4c1
FB		 838}
839
1bd1442e 840static void do_print(Monitor *mon, const QDict *qdict)
9307c4c1 841{
1bd1442e 842 int format = qdict_get_int(qdict, "format");
c227f099 843 target_phys_addr_t val = qdict_get_int(qdict, "val");
1bd1442e 844
7743e588 845#if TARGET_PHYS_ADDR_BITS == 32
9307c4c1
FB		 846 switch(format) {
847 case 'o':
376253ec 848 monitor_printf(mon, "%#o", val);
9307c4c1
FB		 849 break;
850 case 'x':
376253ec 851 monitor_printf(mon, "%#x", val);
9307c4c1
FB		 852 break;
853 case 'u':
376253ec 854 monitor_printf(mon, "%u", val);
9307c4c1
FB		 855 break;
856 default:
857 case 'd':
376253ec 858 monitor_printf(mon, "%d", val);
9307c4c1
FB		 859 break;
860 case 'c':
376253ec 861 monitor_printc(mon, val);
9307c4c1
FB		 862 break;
863 }
92a31b1f
FB		 864#else
865 switch(format) {
866 case 'o':
376253ec 867 monitor_printf(mon, "%#" PRIo64, val);
92a31b1f
FB		 868 break;
869 case 'x':
376253ec 870 monitor_printf(mon, "%#" PRIx64, val);
92a31b1f
FB		 871 break;
872 case 'u':
376253ec 873 monitor_printf(mon, "%" PRIu64, val);
92a31b1f
FB		 874 break;
875 default:
876 case 'd':
376253ec 877 monitor_printf(mon, "%" PRId64, val);
92a31b1f
FB		 878 break;
879 case 'c':
376253ec 880 monitor_printc(mon, val);
92a31b1f
FB		 881 break;
882 }
883#endif
376253ec 884 monitor_printf(mon, "\n");
9307c4c1
FB		 885}
886
afe67ef2 887static void do_memory_save(Monitor *mon, const QDict *qdict)
b371dc59
FB		 888{
889 FILE *f;
afe67ef2
LC		 890 uint32_t size = qdict_get_int(qdict, "size");
891 const char *filename = qdict_get_str(qdict, "filename");
892 target_long addr = qdict_get_int(qdict, "val");
b371dc59
FB		 893 uint32_t l;
894 CPUState *env;
895 uint8_t buf[1024];
896
897 env = mon_get_cpu();
898 if (!env)
899 return;
900
901 f = fopen(filename, "wb");
902 if (!f) {
376253ec 903 monitor_printf(mon, "could not open '%s'\n", filename);
b371dc59
FB		 904 return;
905 }
906 while (size != 0) {
907 l = sizeof(buf);
908 if (l > size)
909 l = size;
910 cpu_memory_rw_debug(env, addr, buf, l, 0);
911 fwrite(buf, 1, l, f);
912 addr += l;
913 size -= l;
914 }
915 fclose(f);
916}
917
afe67ef2 918static void do_physical_memory_save(Monitor *mon, const QDict *qdict)
a8bdf7a6
AJ		 919{
920 FILE *f;
921 uint32_t l;
922 uint8_t buf[1024];
afe67ef2
LC		 923 uint32_t size = qdict_get_int(qdict, "size");
924 const char *filename = qdict_get_str(qdict, "filename");
c227f099 925 target_phys_addr_t addr = qdict_get_int(qdict, "val");
a8bdf7a6
AJ		 926
927 f = fopen(filename, "wb");
928 if (!f) {
376253ec 929 monitor_printf(mon, "could not open '%s'\n", filename);
a8bdf7a6
AJ		 930 return;
931 }
932 while (size != 0) {
933 l = sizeof(buf);
934 if (l > size)
935 l = size;
936 cpu_physical_memory_rw(addr, buf, l, 0);
937 fwrite(buf, 1, l, f);
938 fflush(f);
939 addr += l;
940 size -= l;
941 }
942 fclose(f);
943}
944
f18c16de 945static void do_sum(Monitor *mon, const QDict *qdict)
e4cf1adc
FB		 946{
947 uint32_t addr;
948 uint8_t buf[1];
949 uint16_t sum;
f18c16de
LC		 950 uint32_t start = qdict_get_int(qdict, "start");
951 uint32_t size = qdict_get_int(qdict, "size");
e4cf1adc
FB		 952
953 sum = 0;
954 for(addr = start; addr < (start + size); addr++) {
955 cpu_physical_memory_rw(addr, buf, 1, 0);
956 /* BSD sum algorithm ('sum' Unix command) */
957 sum = (sum >> 1) | (sum << 15);
958 sum += buf[0];
959 }
376253ec 960 monitor_printf(mon, "%05d\n", sum);
e4cf1adc
FB		 961}
962
a3a91a35
FB		 963typedef struct {
964 int keycode;
965 const char *name;
966} KeyDef;
967
968static const KeyDef key_defs[] = {
969 { 0x2a, "shift" },
970 { 0x36, "shift_r" },
3b46e624 971
a3a91a35
FB		 972 { 0x38, "alt" },
973 { 0xb8, "alt_r" },
2ba27c7f
TS		 974 { 0x64, "altgr" },
975 { 0xe4, "altgr_r" },
a3a91a35
FB		 976 { 0x1d, "ctrl" },
977 { 0x9d, "ctrl_r" },
978
979 { 0xdd, "menu" },
980
981 { 0x01, "esc" },
982
983 { 0x02, "1" },
984 { 0x03, "2" },
985 { 0x04, "3" },
986 { 0x05, "4" },
987 { 0x06, "5" },
988 { 0x07, "6" },
989 { 0x08, "7" },
990 { 0x09, "8" },
991 { 0x0a, "9" },
992 { 0x0b, "0" },
64866c3d
FB		 993 { 0x0c, "minus" },
994 { 0x0d, "equal" },
a3a91a35
FB		 995 { 0x0e, "backspace" },
996
997 { 0x0f, "tab" },
998 { 0x10, "q" },
999 { 0x11, "w" },
1000 { 0x12, "e" },
1001 { 0x13, "r" },
1002 { 0x14, "t" },
1003 { 0x15, "y" },
1004 { 0x16, "u" },
1005 { 0x17, "i" },
1006 { 0x18, "o" },
1007 { 0x19, "p" },
1008
1009 { 0x1c, "ret" },
1010
1011 { 0x1e, "a" },
1012 { 0x1f, "s" },
1013 { 0x20, "d" },
1014 { 0x21, "f" },
1015 { 0x22, "g" },
1016 { 0x23, "h" },
1017 { 0x24, "j" },
1018 { 0x25, "k" },
1019 { 0x26, "l" },
1020
1021 { 0x2c, "z" },
1022 { 0x2d, "x" },
1023 { 0x2e, "c" },
1024 { 0x2f, "v" },
1025 { 0x30, "b" },
1026 { 0x31, "n" },
1027 { 0x32, "m" },
9155fc45
AJ		 1028 { 0x33, "comma" },
1029 { 0x34, "dot" },
1030 { 0x35, "slash" },
3b46e624 1031
4d3b6f6e
AZ		 1032 { 0x37, "asterisk" },
1033
a3a91a35 1034 { 0x39, "spc" },
00ffa62a 1035 { 0x3a, "caps_lock" },
a3a91a35
FB		 1036 { 0x3b, "f1" },
1037 { 0x3c, "f2" },
1038 { 0x3d, "f3" },
1039 { 0x3e, "f4" },
1040 { 0x3f, "f5" },
1041 { 0x40, "f6" },
1042 { 0x41, "f7" },
1043 { 0x42, "f8" },
1044 { 0x43, "f9" },
1045 { 0x44, "f10" },
00ffa62a 1046 { 0x45, "num_lock" },
a3a91a35
FB		 1047 { 0x46, "scroll_lock" },
1048
64866c3d
FB		 1049 { 0xb5, "kp_divide" },
1050 { 0x37, "kp_multiply" },
0cfec834 1051 { 0x4a, "kp_subtract" },
64866c3d
FB		 1052 { 0x4e, "kp_add" },
1053 { 0x9c, "kp_enter" },
1054 { 0x53, "kp_decimal" },
f2289cb6 1055 { 0x54, "sysrq" },
64866c3d
FB		 1056
1057 { 0x52, "kp_0" },
1058 { 0x4f, "kp_1" },
1059 { 0x50, "kp_2" },
1060 { 0x51, "kp_3" },
1061 { 0x4b, "kp_4" },
1062 { 0x4c, "kp_5" },
1063 { 0x4d, "kp_6" },
1064 { 0x47, "kp_7" },
1065 { 0x48, "kp_8" },
1066 { 0x49, "kp_9" },
3b46e624 1067
a3a91a35
FB		 1068 { 0x56, "<" },
1069
1070 { 0x57, "f11" },
1071 { 0x58, "f12" },
1072
1073 { 0xb7, "print" },
1074
1075 { 0xc7, "home" },
1076 { 0xc9, "pgup" },
1077 { 0xd1, "pgdn" },
1078 { 0xcf, "end" },
1079
1080 { 0xcb, "left" },
1081 { 0xc8, "up" },
1082 { 0xd0, "down" },
1083 { 0xcd, "right" },
1084
1085 { 0xd2, "insert" },
1086 { 0xd3, "delete" },
c0b5b109
BS		 1087#if defined(TARGET_SPARC) && !defined(TARGET_SPARC64)
1088 { 0xf0, "stop" },
1089 { 0xf1, "again" },
1090 { 0xf2, "props" },
1091 { 0xf3, "undo" },
1092 { 0xf4, "front" },
1093 { 0xf5, "copy" },
1094 { 0xf6, "open" },
1095 { 0xf7, "paste" },
1096 { 0xf8, "find" },
1097 { 0xf9, "cut" },
1098 { 0xfa, "lf" },
1099 { 0xfb, "help" },
1100 { 0xfc, "meta_l" },
1101 { 0xfd, "meta_r" },
1102 { 0xfe, "compose" },
1103#endif
a3a91a35
FB		 1104 { 0, NULL },
1105};
1106
1107static int get_keycode(const char *key)
1108{
1109 const KeyDef *p;
64866c3d
FB		 1110 char *endp;
1111 int ret;
a3a91a35
FB		 1112
1113 for(p = key_defs; p->name != NULL; p++) {
1114 if (!strcmp(key, p->name))
1115 return p->keycode;
1116 }
64866c3d
FB		 1117 if (strstart(key, "0x", NULL)) {
1118 ret = strtoul(key, &endp, 0);
1119 if (*endp == '\0' && ret >= 0x01 && ret <= 0xff)
1120 return ret;
1121 }
a3a91a35
FB		 1122 return -1;
1123}
1124
c8256f9d
AZ		 1125#define MAX_KEYCODES 16
1126static uint8_t keycodes[MAX_KEYCODES];
1127static int nb_pending_keycodes;
1128static QEMUTimer *key_timer;
1129
1130static void release_keys(void *opaque)
1131{
1132 int keycode;
1133
1134 while (nb_pending_keycodes > 0) {
1135 nb_pending_keycodes--;
1136 keycode = keycodes[nb_pending_keycodes];
1137 if (keycode & 0x80)
1138 kbd_put_keycode(0xe0);
1139 kbd_put_keycode(keycode | 0x80);
1140 }
1141}
1142
1d4daa91 1143static void do_sendkey(Monitor *mon, const QDict *qdict)
a3a91a35 1144{
3401c0d9
AZ		 1145 char keyname_buf[16];
1146 char *separator;
1147 int keyname_len, keycode, i;
1d4daa91
LC		 1148 const char *string = qdict_get_str(qdict, "string");
1149 int has_hold_time = qdict_haskey(qdict, "hold_time");
1150 int hold_time = qdict_get_try_int(qdict, "hold_time", -1);
3401c0d9 1151
c8256f9d
AZ		 1152 if (nb_pending_keycodes > 0) {
1153 qemu_del_timer(key_timer);
1154 release_keys(NULL);
1155 }
1156 if (!has_hold_time)
1157 hold_time = 100;
1158 i = 0;
3401c0d9
AZ		 1159 while (1) {
1160 separator = strchr(string, '-');
1161 keyname_len = separator ? separator - string : strlen(string);
1162 if (keyname_len > 0) {
1163 pstrcpy(keyname_buf, sizeof(keyname_buf), string);
1164 if (keyname_len > sizeof(keyname_buf) - 1) {
376253ec 1165 monitor_printf(mon, "invalid key: '%s...'\n", keyname_buf);
3401c0d9 1166 return;
a3a91a35 1167 }
c8256f9d 1168 if (i == MAX_KEYCODES) {
376253ec 1169 monitor_printf(mon, "too many keys\n");
3401c0d9
AZ		 1170 return;
1171 }
1172 keyname_buf[keyname_len] = 0;
1173 keycode = get_keycode(keyname_buf);
1174 if (keycode < 0) {
376253ec 1175 monitor_printf(mon, "unknown key: '%s'\n", keyname_buf);
3401c0d9
AZ		 1176 return;
1177 }
c8256f9d 1178 keycodes[i++] = keycode;
a3a91a35 1179 }
3401c0d9 1180 if (!separator)
a3a91a35 1181 break;
3401c0d9 1182 string = separator + 1;
a3a91a35 1183 }
c8256f9d 1184 nb_pending_keycodes = i;
a3a91a35 1185 /* key down events */
c8256f9d 1186 for (i = 0; i < nb_pending_keycodes; i++) {
a3a91a35
FB		 1187 keycode = keycodes[i];
1188 if (keycode & 0x80)
1189 kbd_put_keycode(0xe0);
1190 kbd_put_keycode(keycode & 0x7f);
1191 }
c8256f9d 1192 /* delayed key up events */
f227f17d 1193 qemu_mod_timer(key_timer, qemu_get_clock(vm_clock) +
6ee093c9 1194 muldiv64(get_ticks_per_sec(), hold_time, 1000));
a3a91a35
FB		 1195}
1196
13224a87
FB		 1197static int mouse_button_state;
1198
1d4daa91 1199static void do_mouse_move(Monitor *mon, const QDict *qdict)
13224a87
FB		 1200{
1201 int dx, dy, dz;
1d4daa91
LC		 1202 const char *dx_str = qdict_get_str(qdict, "dx_str");
1203 const char *dy_str = qdict_get_str(qdict, "dy_str");
1204 const char *dz_str = qdict_get_try_str(qdict, "dz_str");
13224a87
FB		 1205 dx = strtol(dx_str, NULL, 0);
1206 dy = strtol(dy_str, NULL, 0);
1207 dz = 0;
5fafdf24 1208 if (dz_str)
13224a87
FB		 1209 dz = strtol(dz_str, NULL, 0);
1210 kbd_mouse_event(dx, dy, dz, mouse_button_state);
1211}
1212
d54908a5 1213static void do_mouse_button(Monitor *mon, const QDict *qdict)
13224a87 1214{
d54908a5 1215 int button_state = qdict_get_int(qdict, "button_state");
13224a87
FB		 1216 mouse_button_state = button_state;
1217 kbd_mouse_event(0, 0, 0, mouse_button_state);
1218}
1219
aa93e39c 1220static void do_ioport_read(Monitor *mon, const QDict *qdict)
3440557b 1221{
aa93e39c
LC		 1222 int size = qdict_get_int(qdict, "size");
1223 int addr = qdict_get_int(qdict, "addr");
1224 int has_index = qdict_haskey(qdict, "index");
3440557b
FB		 1225 uint32_t val;
1226 int suffix;
1227
1228 if (has_index) {
aa93e39c 1229 int index = qdict_get_int(qdict, "index");
afcea8cb 1230 cpu_outb(addr & IOPORTS_MASK, index & 0xff);
3440557b
FB		 1231 addr++;
1232 }
1233 addr &= 0xffff;
1234
1235 switch(size) {
1236 default:
1237 case 1:
afcea8cb 1238 val = cpu_inb(addr);
3440557b
FB		 1239 suffix = 'b';
1240 break;
1241 case 2:
afcea8cb 1242 val = cpu_inw(addr);
3440557b
FB		 1243 suffix = 'w';
1244 break;
1245 case 4:
afcea8cb 1246 val = cpu_inl(addr);
3440557b
FB		 1247 suffix = 'l';
1248 break;
1249 }
376253ec
AL		 1250 monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
1251 suffix, addr, size * 2, val);
3440557b 1252}
a3a91a35 1253
1bd1442e 1254static void do_ioport_write(Monitor *mon, const QDict *qdict)
f114784f 1255{
1bd1442e
LC		 1256 int size = qdict_get_int(qdict, "size");
1257 int addr = qdict_get_int(qdict, "addr");
1258 int val = qdict_get_int(qdict, "val");
1259
f114784f
JK		 1260 addr &= IOPORTS_MASK;
1261
1262 switch (size) {
1263 default:
1264 case 1:
afcea8cb 1265 cpu_outb(addr, val);
f114784f
JK		 1266 break;
1267 case 2:
afcea8cb 1268 cpu_outw(addr, val);
f114784f
JK		 1269 break;
1270 case 4:
afcea8cb 1271 cpu_outl(addr, val);
f114784f
JK		 1272 break;
1273 }
1274}
1275
d54908a5 1276static void do_boot_set(Monitor *mon, const QDict *qdict)
0ecdffbb
AJ		 1277{
1278 int res;
d54908a5 1279 const char *bootdevice = qdict_get_str(qdict, "bootdevice");
0ecdffbb 1280
76e30d0f
JK		 1281 res = qemu_boot_set(bootdevice);
1282 if (res == 0) {
1283 monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
1284 } else if (res > 0) {
1285 monitor_printf(mon, "setting boot device list failed\n");
0ecdffbb 1286 } else {
376253ec
AL		 1287 monitor_printf(mon, "no function defined to set boot device list for "
1288 "this architecture\n");
0ecdffbb
AJ		 1289 }
1290}
1291
f96fc8a0 1292static void do_system_reset(Monitor *mon, const QDict *qdict)
e4f9082b
FB		 1293{
1294 qemu_system_reset_request();
1295}
1296
f96fc8a0 1297static void do_system_powerdown(Monitor *mon, const QDict *qdict)
3475187d
FB		 1298{
1299 qemu_system_powerdown_request();
1300}
1301
b86bda5b 1302#if defined(TARGET_I386)
376253ec 1303static void print_pte(Monitor *mon, uint32_t addr, uint32_t pte, uint32_t mask)
b86bda5b 1304{
376253ec
AL		 1305 monitor_printf(mon, "%08x: %08x %c%c%c%c%c%c%c%c\n",
1306 addr,
1307 pte & mask,
1308 pte & PG_GLOBAL_MASK ? 'G' : '-',
1309 pte & PG_PSE_MASK ? 'P' : '-',
1310 pte & PG_DIRTY_MASK ? 'D' : '-',
1311 pte & PG_ACCESSED_MASK ? 'A' : '-',
1312 pte & PG_PCD_MASK ? 'C' : '-',
1313 pte & PG_PWT_MASK ? 'T' : '-',
1314 pte & PG_USER_MASK ? 'U' : '-',
1315 pte & PG_RW_MASK ? 'W' : '-');
b86bda5b
FB		 1316}
1317
376253ec 1318static void tlb_info(Monitor *mon)
b86bda5b 1319{
6a00d601 1320 CPUState *env;
b86bda5b
FB		 1321 int l1, l2;
1322 uint32_t pgd, pde, pte;
1323
6a00d601
FB		 1324 env = mon_get_cpu();
1325 if (!env)
1326 return;
1327
b86bda5b 1328 if (!(env->cr[0] & CR0_PG_MASK)) {
376253ec 1329 monitor_printf(mon, "PG disabled\n");
b86bda5b
FB		 1330 return;
1331 }
1332 pgd = env->cr[3] & ~0xfff;
1333 for(l1 = 0; l1 < 1024; l1++) {
1334 cpu_physical_memory_read(pgd + l1 * 4, (uint8_t *)&pde, 4);
1335 pde = le32_to_cpu(pde);
1336 if (pde & PG_PRESENT_MASK) {
1337 if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
376253ec 1338 print_pte(mon, (l1 << 22), pde, ~((1 << 20) - 1));
b86bda5b
FB		 1339 } else {
1340 for(l2 = 0; l2 < 1024; l2++) {
5fafdf24 1341 cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
b86bda5b
FB		 1342 (uint8_t *)&pte, 4);
1343 pte = le32_to_cpu(pte);
1344 if (pte & PG_PRESENT_MASK) {
376253ec 1345 print_pte(mon, (l1 << 22) + (l2 << 12),
5fafdf24 1346 pte & ~PG_PSE_MASK,
b86bda5b
FB		 1347 ~0xfff);
1348 }
1349 }
1350 }
1351 }
1352 }
1353}
1354
376253ec 1355static void mem_print(Monitor *mon, uint32_t *pstart, int *plast_prot,
b86bda5b
FB		 1356 uint32_t end, int prot)
1357{
9746b15b
FB		 1358 int prot1;
1359 prot1 = *plast_prot;
1360 if (prot != prot1) {
b86bda5b 1361 if (*pstart != -1) {
376253ec
AL		 1362 monitor_printf(mon, "%08x-%08x %08x %c%c%c\n",
1363 *pstart, end, end - *pstart,
1364 prot1 & PG_USER_MASK ? 'u' : '-',
1365 'r',
1366 prot1 & PG_RW_MASK ? 'w' : '-');
b86bda5b
FB		 1367 }
1368 if (prot != 0)
1369 *pstart = end;
1370 else
1371 *pstart = -1;
1372 *plast_prot = prot;
1373 }
1374}
1375
376253ec 1376static void mem_info(Monitor *mon)
b86bda5b 1377{
6a00d601 1378 CPUState *env;
b86bda5b
FB		 1379 int l1, l2, prot, last_prot;
1380 uint32_t pgd, pde, pte, start, end;
1381
6a00d601
FB		 1382 env = mon_get_cpu();
1383 if (!env)
1384 return;
1385
b86bda5b 1386 if (!(env->cr[0] & CR0_PG_MASK)) {
376253ec 1387 monitor_printf(mon, "PG disabled\n");
b86bda5b
FB		 1388 return;
1389 }
1390 pgd = env->cr[3] & ~0xfff;
1391 last_prot = 0;
1392 start = -1;
1393 for(l1 = 0; l1 < 1024; l1++) {
1394 cpu_physical_memory_read(pgd + l1 * 4, (uint8_t *)&pde, 4);
1395 pde = le32_to_cpu(pde);
1396 end = l1 << 22;
1397 if (pde & PG_PRESENT_MASK) {
1398 if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
1399 prot = pde & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
376253ec 1400 mem_print(mon, &start, &last_prot, end, prot);
b86bda5b
FB		 1401 } else {
1402 for(l2 = 0; l2 < 1024; l2++) {
5fafdf24 1403 cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
b86bda5b
FB		 1404 (uint8_t *)&pte, 4);
1405 pte = le32_to_cpu(pte);
1406 end = (l1 << 22) + (l2 << 12);
1407 if (pte & PG_PRESENT_MASK) {
1408 prot = pte & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
1409 } else {
1410 prot = 0;
1411 }
376253ec 1412 mem_print(mon, &start, &last_prot, end, prot);
b86bda5b
FB		 1413 }
1414 }
1415 } else {
1416 prot = 0;
376253ec 1417 mem_print(mon, &start, &last_prot, end, prot);
b86bda5b
FB		 1418 }
1419 }
1420}
1421#endif
1422
7c664e2f
AJ		 1423#if defined(TARGET_SH4)
1424
376253ec 1425static void print_tlb(Monitor *mon, int idx, tlb_t *tlb)
7c664e2f 1426{
376253ec
AL		 1427 monitor_printf(mon, " tlb%i:\t"
1428 "asid=%hhu vpn=%x\tppn=%x\tsz=%hhu size=%u\t"
1429 "v=%hhu shared=%hhu cached=%hhu prot=%hhu "
1430 "dirty=%hhu writethrough=%hhu\n",
1431 idx,
1432 tlb->asid, tlb->vpn, tlb->ppn, tlb->sz, tlb->size,
1433 tlb->v, tlb->sh, tlb->c, tlb->pr,
1434 tlb->d, tlb->wt);
7c664e2f
AJ		 1435}
1436
376253ec 1437static void tlb_info(Monitor *mon)
7c664e2f
AJ		 1438{
1439 CPUState *env = mon_get_cpu();
1440 int i;
1441
376253ec 1442 monitor_printf (mon, "ITLB:\n");
7c664e2f 1443 for (i = 0 ; i < ITLB_SIZE ; i++)
376253ec
AL		 1444 print_tlb (mon, i, &env->itlb[i]);
1445 monitor_printf (mon, "UTLB:\n");
7c664e2f 1446 for (i = 0 ; i < UTLB_SIZE ; i++)
376253ec 1447 print_tlb (mon, i, &env->utlb[i]);
7c664e2f
AJ		 1448}
1449
1450#endif
1451
376253ec 1452static void do_info_kvm(Monitor *mon)
7ba1e619
AL		 1453{
1454#ifdef CONFIG_KVM
376253ec 1455 monitor_printf(mon, "kvm support: ");
7ba1e619 1456 if (kvm_enabled())
376253ec 1457 monitor_printf(mon, "enabled\n");
7ba1e619 1458 else
376253ec 1459 monitor_printf(mon, "disabled\n");
7ba1e619 1460#else
376253ec 1461 monitor_printf(mon, "kvm support: not compiled\n");
7ba1e619
AL		 1462#endif
1463}
1464
030ea37b
AL		 1465static void do_info_numa(Monitor *mon)
1466{
b28b6230 1467 int i;
030ea37b
AL		 1468 CPUState *env;
1469
1470 monitor_printf(mon, "%d nodes\n", nb_numa_nodes);
1471 for (i = 0; i < nb_numa_nodes; i++) {
1472 monitor_printf(mon, "node %d cpus:", i);
1473 for (env = first_cpu; env != NULL; env = env->next_cpu) {
1474 if (env->numa_node == i) {
1475 monitor_printf(mon, " %d", env->cpu_index);
1476 }
1477 }
1478 monitor_printf(mon, "\n");
1479 monitor_printf(mon, "node %d size: %" PRId64 " MB\n", i,
1480 node_mem[i] >> 20);
1481 }
1482}
1483
5f1ce948
FB		 1484#ifdef CONFIG_PROFILER
1485
e9a6625e
AJ		 1486int64_t qemu_time;
1487int64_t dev_time;
1488
376253ec 1489static void do_info_profile(Monitor *mon)
5f1ce948
FB		 1490{
1491 int64_t total;
1492 total = qemu_time;
1493 if (total == 0)
1494 total = 1;
376253ec 1495 monitor_printf(mon, "async time %" PRId64 " (%0.3f)\n",
6ee093c9 1496 dev_time, dev_time / (double)get_ticks_per_sec());
376253ec 1497 monitor_printf(mon, "qemu time %" PRId64 " (%0.3f)\n",
6ee093c9 1498 qemu_time, qemu_time / (double)get_ticks_per_sec());
5f1ce948 1499 qemu_time = 0;
5f1ce948 1500 dev_time = 0;
5f1ce948
FB		 1501}
1502#else
376253ec 1503static void do_info_profile(Monitor *mon)
5f1ce948 1504{
376253ec 1505 monitor_printf(mon, "Internal profiler not compiled\n");
5f1ce948
FB		 1506}
1507#endif
1508
ec36b695 1509/* Capture support */
72cf2d4f 1510static QLIST_HEAD (capture_list_head, CaptureState) capture_head;
ec36b695 1511
376253ec 1512static void do_info_capture(Monitor *mon)
ec36b695
FB		 1513{
1514 int i;
1515 CaptureState *s;
1516
1517 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
376253ec 1518 monitor_printf(mon, "[%d]: ", i);
ec36b695
FB		 1519 s->ops.info (s->opaque);
1520 }
1521}
1522
2313086a 1523#ifdef HAS_AUDIO
d54908a5 1524static void do_stop_capture(Monitor *mon, const QDict *qdict)
ec36b695
FB		 1525{
1526 int i;
d54908a5 1527 int n = qdict_get_int(qdict, "n");
ec36b695
FB		 1528 CaptureState *s;
1529
1530 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
1531 if (i == n) {
1532 s->ops.destroy (s->opaque);
72cf2d4f 1533 QLIST_REMOVE (s, entries);
ec36b695
FB		 1534 qemu_free (s);
1535 return;
1536 }
1537 }
1538}
1539
c1925484
LC		 1540static void do_wav_capture(Monitor *mon, const QDict *qdict)
1541{
1542 const char *path = qdict_get_str(qdict, "path");
1543 int has_freq = qdict_haskey(qdict, "freq");
1544 int freq = qdict_get_try_int(qdict, "freq", -1);
1545 int has_bits = qdict_haskey(qdict, "bits");
1546 int bits = qdict_get_try_int(qdict, "bits", -1);
1547 int has_channels = qdict_haskey(qdict, "nchannels");
1548 int nchannels = qdict_get_try_int(qdict, "nchannels", -1);
ec36b695
FB		 1549 CaptureState *s;
1550
1551 s = qemu_mallocz (sizeof (*s));
ec36b695
FB		 1552
1553 freq = has_freq ? freq : 44100;
1554 bits = has_bits ? bits : 16;
1555 nchannels = has_channels ? nchannels : 2;
1556
1557 if (wav_start_capture (s, path, freq, bits, nchannels)) {
376253ec 1558 monitor_printf(mon, "Faied to add wave capture\n");
ec36b695
FB		 1559 qemu_free (s);
1560 }
72cf2d4f 1561 QLIST_INSERT_HEAD (&capture_head, s, entries);
ec36b695
FB		 1562}
1563#endif
1564
dc1c0b74 1565#if defined(TARGET_I386)
d54908a5 1566static void do_inject_nmi(Monitor *mon, const QDict *qdict)
dc1c0b74
AJ		 1567{
1568 CPUState *env;
d54908a5 1569 int cpu_index = qdict_get_int(qdict, "cpu_index");
dc1c0b74
AJ		 1570
1571 for (env = first_cpu; env != NULL; env = env->next_cpu)
1572 if (env->cpu_index == cpu_index) {
1573 cpu_interrupt(env, CPU_INTERRUPT_NMI);
1574 break;
1575 }
1576}
1577#endif
1578
376253ec 1579static void do_info_status(Monitor *mon)
6f9c5ee7 1580{
1b530a6d
AJ		 1581 if (vm_running) {
1582 if (singlestep) {
1583 monitor_printf(mon, "VM status: running (single step mode)\n");
1584 } else {
1585 monitor_printf(mon, "VM status: running\n");
1586 }
1587 } else
376253ec 1588 monitor_printf(mon, "VM status: paused\n");
6f9c5ee7
AJ		 1589}
1590
1591
d54908a5 1592static void do_balloon(Monitor *mon, const QDict *qdict)
df751fa8 1593{
d54908a5 1594 int value = qdict_get_int(qdict, "value");
c227f099 1595 ram_addr_t target = value;
df751fa8
AL		 1596 qemu_balloon(target << 20);
1597}
1598
376253ec 1599static void do_info_balloon(Monitor *mon)
df751fa8 1600{
c227f099 1601 ram_addr_t actual;
df751fa8
AL		 1602
1603 actual = qemu_balloon_status();
bd322087 1604 if (kvm_enabled() && !kvm_has_sync_mmu())
376253ec
AL		 1605 monitor_printf(mon, "Using KVM without synchronous MMU, "
1606 "ballooning disabled\n");
bd322087 1607 else if (actual == 0)
376253ec 1608 monitor_printf(mon, "Ballooning not activated in VM\n");
df751fa8 1609 else
376253ec 1610 monitor_printf(mon, "balloon: actual=%d\n", (int)(actual >> 20));
df751fa8
AL		 1611}
1612
15dfcd45 1613static qemu_acl *find_acl(Monitor *mon, const char *name)
76655d6d 1614{
15dfcd45 1615 qemu_acl *acl = qemu_acl_find(name);
76655d6d 1616
76655d6d 1617 if (!acl) {
15dfcd45 1618 monitor_printf(mon, "acl: unknown list '%s'\n", name);
76655d6d 1619 }
15dfcd45
JK		 1620 return acl;
1621}
1622
d54908a5 1623static void do_acl_show(Monitor *mon, const QDict *qdict)
15dfcd45 1624{
d54908a5 1625 const char *aclname = qdict_get_str(qdict, "aclname");
15dfcd45
JK		 1626 qemu_acl *acl = find_acl(mon, aclname);
1627 qemu_acl_entry *entry;
1628 int i = 0;
76655d6d 1629
15dfcd45 1630 if (acl) {
28a76be8 1631 monitor_printf(mon, "policy: %s\n",
76655d6d 1632 acl->defaultDeny ? "deny" : "allow");
72cf2d4f 1633 QTAILQ_FOREACH(entry, &acl->entries, next) {
28a76be8
AL		 1634 i++;
1635 monitor_printf(mon, "%d: %s %s\n", i,
15dfcd45 1636 entry->deny ? "deny" : "allow", entry->match);
28a76be8 1637 }
15dfcd45
JK		 1638 }
1639}
1640
d54908a5 1641static void do_acl_reset(Monitor *mon, const QDict *qdict)
15dfcd45 1642{
d54908a5 1643 const char *aclname = qdict_get_str(qdict, "aclname");
15dfcd45
JK		 1644 qemu_acl *acl = find_acl(mon, aclname);
1645
1646 if (acl) {
28a76be8
AL		 1647 qemu_acl_reset(acl);
1648 monitor_printf(mon, "acl: removed all rules\n");
15dfcd45
JK		 1649 }
1650}
1651
f18c16de 1652static void do_acl_policy(Monitor *mon, const QDict *qdict)
15dfcd45 1653{
f18c16de
LC		 1654 const char *aclname = qdict_get_str(qdict, "aclname");
1655 const char *policy = qdict_get_str(qdict, "policy");
15dfcd45 1656 qemu_acl *acl = find_acl(mon, aclname);
28a76be8 1657
15dfcd45
JK		 1658 if (acl) {
1659 if (strcmp(policy, "allow") == 0) {
28a76be8
AL		 1660 acl->defaultDeny = 0;
1661 monitor_printf(mon, "acl: policy set to 'allow'\n");
15dfcd45 1662 } else if (strcmp(policy, "deny") == 0) {
28a76be8
AL		 1663 acl->defaultDeny = 1;
1664 monitor_printf(mon, "acl: policy set to 'deny'\n");
1665 } else {
15dfcd45
JK		 1666 monitor_printf(mon, "acl: unknown policy '%s', "
1667 "expected 'deny' or 'allow'\n", policy);
28a76be8 1668 }
15dfcd45
JK		 1669 }
1670}
28a76be8 1671
1bd1442e 1672static void do_acl_add(Monitor *mon, const QDict *qdict)
15dfcd45 1673{
1bd1442e
LC		 1674 const char *aclname = qdict_get_str(qdict, "aclname");
1675 const char *match = qdict_get_str(qdict, "match");
1676 const char *policy = qdict_get_str(qdict, "policy");
1677 int has_index = qdict_haskey(qdict, "index");
1678 int index = qdict_get_try_int(qdict, "index", -1);
15dfcd45
JK		 1679 qemu_acl *acl = find_acl(mon, aclname);
1680 int deny, ret;
1681
1682 if (acl) {
1683 if (strcmp(policy, "allow") == 0) {
1684 deny = 0;
1685 } else if (strcmp(policy, "deny") == 0) {
1686 deny = 1;
1687 } else {
1688 monitor_printf(mon, "acl: unknown policy '%s', "
1689 "expected 'deny' or 'allow'\n", policy);
28a76be8
AL		 1690 return;
1691 }
28a76be8
AL		 1692 if (has_index)
1693 ret = qemu_acl_insert(acl, deny, match, index);
1694 else
1695 ret = qemu_acl_append(acl, deny, match);
1696 if (ret < 0)
1697 monitor_printf(mon, "acl: unable to add acl entry\n");
1698 else
1699 monitor_printf(mon, "acl: added rule at position %d\n", ret);
15dfcd45
JK		 1700 }
1701}
28a76be8 1702
f18c16de 1703static void do_acl_remove(Monitor *mon, const QDict *qdict)
15dfcd45 1704{
f18c16de
LC		 1705 const char *aclname = qdict_get_str(qdict, "aclname");
1706 const char *match = qdict_get_str(qdict, "match");
15dfcd45
JK		 1707 qemu_acl *acl = find_acl(mon, aclname);
1708 int ret;
28a76be8 1709
15dfcd45 1710 if (acl) {
28a76be8
AL		 1711 ret = qemu_acl_remove(acl, match);
1712 if (ret < 0)
1713 monitor_printf(mon, "acl: no matching acl entry\n");
1714 else
1715 monitor_printf(mon, "acl: removed rule at position %d\n", ret);
76655d6d
AL		 1716 }
1717}
1718
79c4f6b0 1719#if defined(TARGET_I386)
37b7ad48 1720static void do_inject_mce(Monitor *mon, const QDict *qdict)
79c4f6b0
HY		 1721{
1722 CPUState *cenv;
37b7ad48
LC		 1723 int cpu_index = qdict_get_int(qdict, "cpu_index");
1724 int bank = qdict_get_int(qdict, "bank");
1725 uint64_t status = qdict_get_int(qdict, "status");
1726 uint64_t mcg_status = qdict_get_int(qdict, "mcg_status");
1727 uint64_t addr = qdict_get_int(qdict, "addr");
1728 uint64_t misc = qdict_get_int(qdict, "misc");
79c4f6b0
HY		 1729
1730 for (cenv = first_cpu; cenv != NULL; cenv = cenv->next_cpu)
1731 if (cenv->cpu_index == cpu_index && cenv->mcg_cap) {
1732 cpu_inject_x86_mce(cenv, bank, status, mcg_status, addr, misc);
1733 break;
1734 }
1735}
1736#endif
1737
d54908a5 1738static void do_getfd(Monitor *mon, const QDict *qdict)
f07918fd 1739{
d54908a5 1740 const char *fdname = qdict_get_str(qdict, "fdname");
c227f099 1741 mon_fd_t *monfd;
f07918fd
MM		 1742 int fd;
1743
1744 fd = qemu_chr_get_msgfd(mon->chr);
1745 if (fd == -1) {
1746 monitor_printf(mon, "getfd: no file descriptor supplied via SCM_RIGHTS\n");
1747 return;
1748 }
1749
1750 if (qemu_isdigit(fdname[0])) {
1751 monitor_printf(mon, "getfd: monitor names may not begin with a number\n");
1752 return;
1753 }
1754
1755 fd = dup(fd);
1756 if (fd == -1) {
1757 monitor_printf(mon, "Failed to dup() file descriptor: %s\n",
1758 strerror(errno));
1759 return;
1760 }
1761
72cf2d4f 1762 QLIST_FOREACH(monfd, &mon->fds, next) {
f07918fd
MM		 1763 if (strcmp(monfd->name, fdname) != 0) {
1764 continue;
1765 }
1766
1767 close(monfd->fd);
1768 monfd->fd = fd;
1769 return;
1770 }
1771
c227f099 1772 monfd = qemu_mallocz(sizeof(mon_fd_t));
f07918fd
MM		 1773 monfd->name = qemu_strdup(fdname);
1774 monfd->fd = fd;
1775
72cf2d4f 1776 QLIST_INSERT_HEAD(&mon->fds, monfd, next);
f07918fd
MM		 1777}
1778
d54908a5 1779static void do_closefd(Monitor *mon, const QDict *qdict)
f07918fd 1780{
d54908a5 1781 const char *fdname = qdict_get_str(qdict, "fdname");
c227f099 1782 mon_fd_t *monfd;
f07918fd 1783
72cf2d4f 1784 QLIST_FOREACH(monfd, &mon->fds, next) {
f07918fd
MM		 1785 if (strcmp(monfd->name, fdname) != 0) {
1786 continue;
1787 }
1788
72cf2d4f 1789 QLIST_REMOVE(monfd, next);
f07918fd
MM		 1790 close(monfd->fd);
1791 qemu_free(monfd->name);
1792 qemu_free(monfd);
1793 return;
1794 }
1795
1796 monitor_printf(mon, "Failed to find file descriptor named %s\n",
1797 fdname);
1798}
1799
d54908a5 1800static void do_loadvm(Monitor *mon, const QDict *qdict)
c8d41b2c
JQ		 1801{
1802 int saved_vm_running = vm_running;
d54908a5 1803 const char *name = qdict_get_str(qdict, "name");
c8d41b2c
JQ		 1804
1805 vm_stop(0);
1806
05f2401e 1807 if (load_vmstate(mon, name) >= 0 && saved_vm_running)
c8d41b2c
JQ		 1808 vm_start();
1809}
1810
7768e04c
MM		 1811int monitor_get_fd(Monitor *mon, const char *fdname)
1812{
c227f099 1813 mon_fd_t *monfd;
7768e04c 1814
72cf2d4f 1815 QLIST_FOREACH(monfd, &mon->fds, next) {
7768e04c
MM		 1816 int fd;
1817
1818 if (strcmp(monfd->name, fdname) != 0) {
1819 continue;
1820 }
1821
1822 fd = monfd->fd;
1823
1824 /* caller takes ownership of fd */
72cf2d4f 1825 QLIST_REMOVE(monfd, next);
7768e04c
MM		 1826 qemu_free(monfd->name);
1827 qemu_free(monfd);
1828
1829 return fd;
1830 }
1831
1832 return -1;
1833}
1834
c227f099 1835static const mon_cmd_t mon_cmds[] = {
2313086a 1836#include "qemu-monitor.h"
5fafdf24 1837 { NULL, NULL, },
9dc39cba
FB		 1838};
1839
2313086a 1840/* Please update qemu-monitor.hx when adding or changing commands */
c227f099 1841static const mon_cmd_t info_cmds[] = {
d7f9b689
LC		 1842 {
1843 .name = "version",
1844 .args_type = "",
d7f9b689
LC		 1845 .params = "",
1846 .help = "show the version of QEMU",
910df89d 1847 .mhandler.info = do_info_version,
d7f9b689
LC		 1848 },
1849 {
1850 .name = "network",
1851 .args_type = "",
d7f9b689
LC		 1852 .params = "",
1853 .help = "show the network state",
910df89d 1854 .mhandler.info = do_info_network,
d7f9b689
LC		 1855 },
1856 {
1857 .name = "chardev",
1858 .args_type = "",
d7f9b689
LC		 1859 .params = "",
1860 .help = "show the character devices",
910df89d 1861 .mhandler.info = qemu_chr_info,
d7f9b689
LC		 1862 },
1863 {
1864 .name = "block",
1865 .args_type = "",
d7f9b689
LC		 1866 .params = "",
1867 .help = "show the block devices",
910df89d 1868 .mhandler.info = bdrv_info,
d7f9b689
LC		 1869 },
1870 {
1871 .name = "blockstats",
1872 .args_type = "",
d7f9b689
LC		 1873 .params = "",
1874 .help = "show block device statistics",
910df89d 1875 .mhandler.info = bdrv_info_stats,
d7f9b689
LC		 1876 },
1877 {
1878 .name = "registers",
1879 .args_type = "",
d7f9b689
LC		 1880 .params = "",
1881 .help = "show the cpu registers",
910df89d 1882 .mhandler.info = do_info_registers,
d7f9b689
LC		 1883 },
1884 {
1885 .name = "cpus",
1886 .args_type = "",
d7f9b689
LC		 1887 .params = "",
1888 .help = "show infos for each CPU",
910df89d 1889 .mhandler.info = do_info_cpus,
d7f9b689
LC		 1890 },
1891 {
1892 .name = "history",
1893 .args_type = "",
d7f9b689
LC		 1894 .params = "",
1895 .help = "show the command line history",
910df89d 1896 .mhandler.info = do_info_history,
d7f9b689
LC		 1897 },
1898 {
1899 .name = "irq",
1900 .args_type = "",
d7f9b689
LC		 1901 .params = "",
1902 .help = "show the interrupts statistics (if available)",
910df89d 1903 .mhandler.info = irq_info,
d7f9b689
LC		 1904 },
1905 {
1906 .name = "pic",
1907 .args_type = "",
d7f9b689
LC		 1908 .params = "",
1909 .help = "show i8259 (PIC) state",
910df89d 1910 .mhandler.info = pic_info,
d7f9b689
LC		 1911 },
1912 {
1913 .name = "pci",
1914 .args_type = "",
d7f9b689
LC		 1915 .params = "",
1916 .help = "show PCI info",
910df89d 1917 .mhandler.info = pci_info,
d7f9b689 1918 },
7c664e2f 1919#if defined(TARGET_I386) || defined(TARGET_SH4)
d7f9b689
LC		 1920 {
1921 .name = "tlb",
1922 .args_type = "",
d7f9b689
LC		 1923 .params = "",
1924 .help = "show virtual to physical memory mappings",
910df89d 1925 .mhandler.info = tlb_info,
d7f9b689 1926 },
7c664e2f
AJ		 1927#endif
1928#if defined(TARGET_I386)
d7f9b689
LC		 1929 {
1930 .name = "mem",
1931 .args_type = "",
d7f9b689
LC		 1932 .params = "",
1933 .help = "show the active virtual memory mappings",
910df89d 1934 .mhandler.info = mem_info,
d7f9b689
LC		 1935 },
1936 {
1937 .name = "hpet",
1938 .args_type = "",
d7f9b689
LC		 1939 .params = "",
1940 .help = "show state of HPET",
910df89d 1941 .mhandler.info = do_info_hpet,
d7f9b689 1942 },
b86bda5b 1943#endif
d7f9b689
LC		 1944 {
1945 .name = "jit",
1946 .args_type = "",
d7f9b689
LC		 1947 .params = "",
1948 .help = "show dynamic compiler info",
910df89d 1949 .mhandler.info = do_info_jit,
d7f9b689
LC		 1950 },
1951 {
1952 .name = "kvm",
1953 .args_type = "",
d7f9b689
LC		 1954 .params = "",
1955 .help = "show KVM information",
910df89d 1956 .mhandler.info = do_info_kvm,
d7f9b689
LC		 1957 },
1958 {
1959 .name = "numa",
1960 .args_type = "",
d7f9b689
LC		 1961 .params = "",
1962 .help = "show NUMA information",
910df89d 1963 .mhandler.info = do_info_numa,
d7f9b689
LC		 1964 },
1965 {
1966 .name = "usb",
1967 .args_type = "",
d7f9b689
LC		 1968 .params = "",
1969 .help = "show guest USB devices",
910df89d 1970 .mhandler.info = usb_info,
d7f9b689
LC		 1971 },
1972 {
1973 .name = "usbhost",
1974 .args_type = "",
d7f9b689
LC		 1975 .params = "",
1976 .help = "show host USB devices",
910df89d 1977 .mhandler.info = usb_host_info,
d7f9b689
LC		 1978 },
1979 {
1980 .name = "profile",
1981 .args_type = "",
d7f9b689
LC		 1982 .params = "",
1983 .help = "show profiling information",
910df89d 1984 .mhandler.info = do_info_profile,
d7f9b689
LC		 1985 },
1986 {
1987 .name = "capture",
1988 .args_type = "",
d7f9b689
LC		 1989 .params = "",
1990 .help = "show capture information",
910df89d 1991 .mhandler.info = do_info_capture,
d7f9b689
LC		 1992 },
1993 {
1994 .name = "snapshots",
1995 .args_type = "",
d7f9b689
LC		 1996 .params = "",
1997 .help = "show the currently saved VM snapshots",
910df89d 1998 .mhandler.info = do_info_snapshots,
d7f9b689
LC		 1999 },
2000 {
2001 .name = "status",
2002 .args_type = "",
d7f9b689
LC		 2003 .params = "",
2004 .help = "show the current VM status (running|paused)",
910df89d 2005 .mhandler.info = do_info_status,
d7f9b689
LC		 2006 },
2007 {
2008 .name = "pcmcia",
2009 .args_type = "",
d7f9b689
LC		 2010 .params = "",
2011 .help = "show guest PCMCIA status",
910df89d 2012 .mhandler.info = pcmcia_info,
d7f9b689
LC		 2013 },
2014 {
2015 .name = "mice",
2016 .args_type = "",
d7f9b689
LC		 2017 .params = "",
2018 .help = "show which guest mouse is receiving events",
910df89d 2019 .mhandler.info = do_info_mice,
d7f9b689
LC		 2020 },
2021 {
2022 .name = "vnc",
2023 .args_type = "",
d7f9b689
LC		 2024 .params = "",
2025 .help = "show the vnc server status",
910df89d 2026 .mhandler.info = do_info_vnc,
d7f9b689
LC		 2027 },
2028 {
2029 .name = "name",
2030 .args_type = "",
d7f9b689
LC		 2031 .params = "",
2032 .help = "show the current VM name",
910df89d 2033 .mhandler.info = do_info_name,
d7f9b689
LC		 2034 },
2035 {
2036 .name = "uuid",
2037 .args_type = "",
d7f9b689
LC		 2038 .params = "",
2039 .help = "show the current VM UUID",
910df89d 2040 .mhandler.info = do_info_uuid,
d7f9b689 2041 },
76a66253 2042#if defined(TARGET_PPC)
d7f9b689
LC		 2043 {
2044 .name = "cpustats",
2045 .args_type = "",
d7f9b689
LC		 2046 .params = "",
2047 .help = "show CPU statistics",
910df89d 2048 .mhandler.info = do_info_cpu_stats,
d7f9b689 2049 },
76a66253 2050#endif
31a60e22 2051#if defined(CONFIG_SLIRP)
d7f9b689
LC		 2052 {
2053 .name = "usernet",
2054 .args_type = "",
d7f9b689
LC		 2055 .params = "",
2056 .help = "show user network stack connection states",
910df89d 2057 .mhandler.info = do_info_usernet,
d7f9b689 2058 },
31a60e22 2059#endif
d7f9b689
LC		 2060 {
2061 .name = "migrate",
2062 .args_type = "",
d7f9b689
LC		 2063 .params = "",
2064 .help = "show migration status",
910df89d 2065 .mhandler.info = do_info_migrate,
d7f9b689
LC		 2066 },
2067 {
2068 .name = "balloon",
2069 .args_type = "",
d7f9b689
LC		 2070 .params = "",
2071 .help = "show balloon information",
910df89d 2072 .mhandler.info = do_info_balloon,
d7f9b689
LC		 2073 },
2074 {
2075 .name = "qtree",
2076 .args_type = "",
d7f9b689
LC		 2077 .params = "",
2078 .help = "show device tree",
910df89d 2079 .mhandler.info = do_info_qtree,
d7f9b689
LC		 2080 },
2081 {
2082 .name = "qdm",
2083 .args_type = "",
d7f9b689
LC		 2084 .params = "",
2085 .help = "show qdev device model list",
910df89d 2086 .mhandler.info = do_info_qdm,
d7f9b689
LC		 2087 },
2088 {
2089 .name = "roms",
2090 .args_type = "",
d7f9b689
LC		 2091 .params = "",
2092 .help = "show roms",
910df89d 2093 .mhandler.info = do_info_roms,
d7f9b689
LC		 2094 },
2095 {
2096 .name = NULL,
2097 },
9dc39cba
FB		 2098};
2099
9307c4c1
FB		 2100/*******************************************************************/
2101
2102static const char *pch;
2103static jmp_buf expr_env;
2104
92a31b1f
FB		 2105#define MD_TLONG 0
2106#define MD_I32 1
2107
9307c4c1
FB		 2108typedef struct MonitorDef {
2109 const char *name;
2110 int offset;
8662d656 2111 target_long (*get_value)(const struct MonitorDef *md, int val);
92a31b1f 2112 int type;
9307c4c1
FB		 2113} MonitorDef;
2114
57206fd4 2115#if defined(TARGET_I386)
8662d656 2116static target_long monitor_get_pc (const struct MonitorDef *md, int val)
57206fd4 2117{
6a00d601
FB		 2118 CPUState *env = mon_get_cpu();
2119 if (!env)
2120 return 0;
2121 return env->eip + env->segs[R_CS].base;
57206fd4
FB		 2122}
2123#endif
2124
a541f297 2125#if defined(TARGET_PPC)
8662d656 2126static target_long monitor_get_ccr (const struct MonitorDef *md, int val)
a541f297 2127{
6a00d601 2128 CPUState *env = mon_get_cpu();
a541f297
FB		 2129 unsigned int u;
2130 int i;
2131
6a00d601
FB		 2132 if (!env)
2133 return 0;
2134
a541f297
FB		 2135 u = 0;
2136 for (i = 0; i < 8; i++)
28a76be8 2137 u |= env->crf[i] << (32 - (4 * i));
a541f297
FB		 2138
2139 return u;
2140}
2141
8662d656 2142static target_long monitor_get_msr (const struct MonitorDef *md, int val)
a541f297 2143{
6a00d601
FB		 2144 CPUState *env = mon_get_cpu();
2145 if (!env)
2146 return 0;
0411a972 2147 return env->msr;
a541f297
FB		 2148}
2149
8662d656 2150static target_long monitor_get_xer (const struct MonitorDef *md, int val)
a541f297 2151{
6a00d601
FB		 2152 CPUState *env = mon_get_cpu();
2153 if (!env)
2154 return 0;
3d7b417e 2155 return env->xer;
a541f297 2156}
9fddaa0c 2157
8662d656 2158static target_long monitor_get_decr (const struct MonitorDef *md, int val)
9fddaa0c 2159{
6a00d601
FB		 2160 CPUState *env = mon_get_cpu();
2161 if (!env)
2162 return 0;
2163 return cpu_ppc_load_decr(env);
9fddaa0c
FB		 2164}
2165
8662d656 2166static target_long monitor_get_tbu (const struct MonitorDef *md, int val)
9fddaa0c 2167{
6a00d601
FB		 2168 CPUState *env = mon_get_cpu();
2169 if (!env)
2170 return 0;
2171 return cpu_ppc_load_tbu(env);
9fddaa0c
FB		 2172}
2173
8662d656 2174static target_long monitor_get_tbl (const struct MonitorDef *md, int val)
9fddaa0c 2175{
6a00d601
FB		 2176 CPUState *env = mon_get_cpu();
2177 if (!env)
2178 return 0;
2179 return cpu_ppc_load_tbl(env);
9fddaa0c 2180}
a541f297
FB		 2181#endif
2182
e95c8d51 2183#if defined(TARGET_SPARC)
7b936c0c 2184#ifndef TARGET_SPARC64
8662d656 2185static target_long monitor_get_psr (const struct MonitorDef *md, int val)
e95c8d51 2186{
6a00d601
FB		 2187 CPUState *env = mon_get_cpu();
2188 if (!env)
2189 return 0;
2190 return GET_PSR(env);
e95c8d51 2191}
7b936c0c 2192#endif
e95c8d51 2193
8662d656 2194static target_long monitor_get_reg(const struct MonitorDef *md, int val)
e95c8d51 2195{
6a00d601
FB		 2196 CPUState *env = mon_get_cpu();
2197 if (!env)
2198 return 0;
2199 return env->regwptr[val];
e95c8d51
FB		 2200}
2201#endif
2202
8662d656 2203static const MonitorDef monitor_defs[] = {
9307c4c1 2204#ifdef TARGET_I386
57206fd4
FB		 2205
2206#define SEG(name, seg) \
92a31b1f 2207 { name, offsetof(CPUState, segs[seg].selector), NULL, MD_I32 },\
57206fd4 2208 { name ".base", offsetof(CPUState, segs[seg].base) },\
92a31b1f 2209 { name ".limit", offsetof(CPUState, segs[seg].limit), NULL, MD_I32 },
57206fd4 2210
9307c4c1
FB		 2211 { "eax", offsetof(CPUState, regs[0]) },
2212 { "ecx", offsetof(CPUState, regs[1]) },
2213 { "edx", offsetof(CPUState, regs[2]) },
2214 { "ebx", offsetof(CPUState, regs[3]) },
2215 { "esp|sp", offsetof(CPUState, regs[4]) },
2216 { "ebp|fp", offsetof(CPUState, regs[5]) },
2217 { "esi", offsetof(CPUState, regs[6]) },
01038d2a 2218 { "edi", offsetof(CPUState, regs[7]) },
92a31b1f
FB		 2219#ifdef TARGET_X86_64
2220 { "r8", offsetof(CPUState, regs[8]) },
2221 { "r9", offsetof(CPUState, regs[9]) },
2222 { "r10", offsetof(CPUState, regs[10]) },
2223 { "r11", offsetof(CPUState, regs[11]) },
2224 { "r12", offsetof(CPUState, regs[12]) },
2225 { "r13", offsetof(CPUState, regs[13]) },
2226 { "r14", offsetof(CPUState, regs[14]) },
2227 { "r15", offsetof(CPUState, regs[15]) },
2228#endif
9307c4c1 2229 { "eflags", offsetof(CPUState, eflags) },
57206fd4
FB		 2230 { "eip", offsetof(CPUState, eip) },
2231 SEG("cs", R_CS)
2232 SEG("ds", R_DS)
2233 SEG("es", R_ES)
01038d2a 2234 SEG("ss", R_SS)
57206fd4
FB		 2235 SEG("fs", R_FS)
2236 SEG("gs", R_GS)
2237 { "pc", 0, monitor_get_pc, },
a541f297 2238#elif defined(TARGET_PPC)
ff937dba 2239 /* General purpose registers */
a541f297
FB		 2240 { "r0", offsetof(CPUState, gpr[0]) },
2241 { "r1", offsetof(CPUState, gpr[1]) },
2242 { "r2", offsetof(CPUState, gpr[2]) },
2243 { "r3", offsetof(CPUState, gpr[3]) },
2244 { "r4", offsetof(CPUState, gpr[4]) },
2245 { "r5", offsetof(CPUState, gpr[5]) },
2246 { "r6", offsetof(CPUState, gpr[6]) },
2247 { "r7", offsetof(CPUState, gpr[7]) },
2248 { "r8", offsetof(CPUState, gpr[8]) },
2249 { "r9", offsetof(CPUState, gpr[9]) },
2250 { "r10", offsetof(CPUState, gpr[10]) },
2251 { "r11", offsetof(CPUState, gpr[11]) },
2252 { "r12", offsetof(CPUState, gpr[12]) },
2253 { "r13", offsetof(CPUState, gpr[13]) },
2254 { "r14", offsetof(CPUState, gpr[14]) },
2255 { "r15", offsetof(CPUState, gpr[15]) },
2256 { "r16", offsetof(CPUState, gpr[16]) },
2257 { "r17", offsetof(CPUState, gpr[17]) },
2258 { "r18", offsetof(CPUState, gpr[18]) },
2259 { "r19", offsetof(CPUState, gpr[19]) },
2260 { "r20", offsetof(CPUState, gpr[20]) },
2261 { "r21", offsetof(CPUState, gpr[21]) },
2262 { "r22", offsetof(CPUState, gpr[22]) },
2263 { "r23", offsetof(CPUState, gpr[23]) },
2264 { "r24", offsetof(CPUState, gpr[24]) },
2265 { "r25", offsetof(CPUState, gpr[25]) },
2266 { "r26", offsetof(CPUState, gpr[26]) },
2267 { "r27", offsetof(CPUState, gpr[27]) },
2268 { "r28", offsetof(CPUState, gpr[28]) },
2269 { "r29", offsetof(CPUState, gpr[29]) },
2270 { "r30", offsetof(CPUState, gpr[30]) },
2271 { "r31", offsetof(CPUState, gpr[31]) },
ff937dba
JM		 2272 /* Floating point registers */
2273 { "f0", offsetof(CPUState, fpr[0]) },
2274 { "f1", offsetof(CPUState, fpr[1]) },
2275 { "f2", offsetof(CPUState, fpr[2]) },
2276 { "f3", offsetof(CPUState, fpr[3]) },
2277 { "f4", offsetof(CPUState, fpr[4]) },
2278 { "f5", offsetof(CPUState, fpr[5]) },
2279 { "f6", offsetof(CPUState, fpr[6]) },
2280 { "f7", offsetof(CPUState, fpr[7]) },
2281 { "f8", offsetof(CPUState, fpr[8]) },
2282 { "f9", offsetof(CPUState, fpr[9]) },
2283 { "f10", offsetof(CPUState, fpr[10]) },
2284 { "f11", offsetof(CPUState, fpr[11]) },
2285 { "f12", offsetof(CPUState, fpr[12]) },
2286 { "f13", offsetof(CPUState, fpr[13]) },
2287 { "f14", offsetof(CPUState, fpr[14]) },
2288 { "f15", offsetof(CPUState, fpr[15]) },
2289 { "f16", offsetof(CPUState, fpr[16]) },
2290 { "f17", offsetof(CPUState, fpr[17]) },
2291 { "f18", offsetof(CPUState, fpr[18]) },
2292 { "f19", offsetof(CPUState, fpr[19]) },
2293 { "f20", offsetof(CPUState, fpr[20]) },
2294 { "f21", offsetof(CPUState, fpr[21]) },
2295 { "f22", offsetof(CPUState, fpr[22]) },
2296 { "f23", offsetof(CPUState, fpr[23]) },
2297 { "f24", offsetof(CPUState, fpr[24]) },
2298 { "f25", offsetof(CPUState, fpr[25]) },
2299 { "f26", offsetof(CPUState, fpr[26]) },
2300 { "f27", offsetof(CPUState, fpr[27]) },
2301 { "f28", offsetof(CPUState, fpr[28]) },
2302 { "f29", offsetof(CPUState, fpr[29]) },
2303 { "f30", offsetof(CPUState, fpr[30]) },
2304 { "f31", offsetof(CPUState, fpr[31]) },
2305 { "fpscr", offsetof(CPUState, fpscr) },
2306 /* Next instruction pointer */
57206fd4 2307 { "nip|pc", offsetof(CPUState, nip) },
a541f297
FB		 2308 { "lr", offsetof(CPUState, lr) },
2309 { "ctr", offsetof(CPUState, ctr) },
9fddaa0c 2310 { "decr", 0, &monitor_get_decr, },
a541f297 2311 { "ccr", 0, &monitor_get_ccr, },
ff937dba 2312 /* Machine state register */
a541f297
FB		 2313 { "msr", 0, &monitor_get_msr, },
2314 { "xer", 0, &monitor_get_xer, },
9fddaa0c
FB		 2315 { "tbu", 0, &monitor_get_tbu, },
2316 { "tbl", 0, &monitor_get_tbl, },
ff937dba
JM		 2317#if defined(TARGET_PPC64)
2318 /* Address space register */
2319 { "asr", offsetof(CPUState, asr) },
2320#endif
2321 /* Segment registers */
a541f297
FB		 2322 { "sdr1", offsetof(CPUState, sdr1) },
2323 { "sr0", offsetof(CPUState, sr[0]) },
2324 { "sr1", offsetof(CPUState, sr[1]) },
2325 { "sr2", offsetof(CPUState, sr[2]) },
2326 { "sr3", offsetof(CPUState, sr[3]) },
2327 { "sr4", offsetof(CPUState, sr[4]) },
2328 { "sr5", offsetof(CPUState, sr[5]) },
2329 { "sr6", offsetof(CPUState, sr[6]) },
2330 { "sr7", offsetof(CPUState, sr[7]) },
2331 { "sr8", offsetof(CPUState, sr[8]) },
2332 { "sr9", offsetof(CPUState, sr[9]) },
2333 { "sr10", offsetof(CPUState, sr[10]) },
2334 { "sr11", offsetof(CPUState, sr[11]) },
2335 { "sr12", offsetof(CPUState, sr[12]) },
2336 { "sr13", offsetof(CPUState, sr[13]) },
2337 { "sr14", offsetof(CPUState, sr[14]) },
2338 { "sr15", offsetof(CPUState, sr[15]) },
2339 /* Too lazy to put BATs and SPRs ... */
e95c8d51
FB		 2340#elif defined(TARGET_SPARC)
2341 { "g0", offsetof(CPUState, gregs[0]) },
2342 { "g1", offsetof(CPUState, gregs[1]) },
2343 { "g2", offsetof(CPUState, gregs[2]) },
2344 { "g3", offsetof(CPUState, gregs[3]) },
2345 { "g4", offsetof(CPUState, gregs[4]) },
2346 { "g5", offsetof(CPUState, gregs[5]) },
2347 { "g6", offsetof(CPUState, gregs[6]) },
2348 { "g7", offsetof(CPUState, gregs[7]) },
2349 { "o0", 0, monitor_get_reg },
2350 { "o1", 1, monitor_get_reg },
2351 { "o2", 2, monitor_get_reg },
2352 { "o3", 3, monitor_get_reg },
2353 { "o4", 4, monitor_get_reg },
2354 { "o5", 5, monitor_get_reg },
2355 { "o6", 6, monitor_get_reg },
2356 { "o7", 7, monitor_get_reg },
2357 { "l0", 8, monitor_get_reg },
2358 { "l1", 9, monitor_get_reg },
2359 { "l2", 10, monitor_get_reg },
2360 { "l3", 11, monitor_get_reg },
2361 { "l4", 12, monitor_get_reg },
2362 { "l5", 13, monitor_get_reg },
2363 { "l6", 14, monitor_get_reg },
2364 { "l7", 15, monitor_get_reg },
2365 { "i0", 16, monitor_get_reg },
2366 { "i1", 17, monitor_get_reg },
2367 { "i2", 18, monitor_get_reg },
2368 { "i3", 19, monitor_get_reg },
2369 { "i4", 20, monitor_get_reg },
2370 { "i5", 21, monitor_get_reg },
2371 { "i6", 22, monitor_get_reg },
2372 { "i7", 23, monitor_get_reg },
2373 { "pc", offsetof(CPUState, pc) },
2374 { "npc", offsetof(CPUState, npc) },
2375 { "y", offsetof(CPUState, y) },
7b936c0c 2376#ifndef TARGET_SPARC64
e95c8d51
FB		 2377 { "psr", 0, &monitor_get_psr, },
2378 { "wim", offsetof(CPUState, wim) },
7b936c0c 2379#endif
e95c8d51
FB		 2380 { "tbr", offsetof(CPUState, tbr) },
2381 { "fsr", offsetof(CPUState, fsr) },
2382 { "f0", offsetof(CPUState, fpr[0]) },
2383 { "f1", offsetof(CPUState, fpr[1]) },
2384 { "f2", offsetof(CPUState, fpr[2]) },
2385 { "f3", offsetof(CPUState, fpr[3]) },
2386 { "f4", offsetof(CPUState, fpr[4]) },
2387 { "f5", offsetof(CPUState, fpr[5]) },
2388 { "f6", offsetof(CPUState, fpr[6]) },
2389 { "f7", offsetof(CPUState, fpr[7]) },
2390 { "f8", offsetof(CPUState, fpr[8]) },
2391 { "f9", offsetof(CPUState, fpr[9]) },
2392 { "f10", offsetof(CPUState, fpr[10]) },
2393 { "f11", offsetof(CPUState, fpr[11]) },
2394 { "f12", offsetof(CPUState, fpr[12]) },
2395 { "f13", offsetof(CPUState, fpr[13]) },
2396 { "f14", offsetof(CPUState, fpr[14]) },
2397 { "f15", offsetof(CPUState, fpr[15]) },
2398 { "f16", offsetof(CPUState, fpr[16]) },
2399 { "f17", offsetof(CPUState, fpr[17]) },
2400 { "f18", offsetof(CPUState, fpr[18]) },
2401 { "f19", offsetof(CPUState, fpr[19]) },
2402 { "f20", offsetof(CPUState, fpr[20]) },
2403 { "f21", offsetof(CPUState, fpr[21]) },
2404 { "f22", offsetof(CPUState, fpr[22]) },
2405 { "f23", offsetof(CPUState, fpr[23]) },
2406 { "f24", offsetof(CPUState, fpr[24]) },
2407 { "f25", offsetof(CPUState, fpr[25]) },
2408 { "f26", offsetof(CPUState, fpr[26]) },
2409 { "f27", offsetof(CPUState, fpr[27]) },
2410 { "f28", offsetof(CPUState, fpr[28]) },
2411 { "f29", offsetof(CPUState, fpr[29]) },
2412 { "f30", offsetof(CPUState, fpr[30]) },
2413 { "f31", offsetof(CPUState, fpr[31]) },
7b936c0c
FB		 2414#ifdef TARGET_SPARC64
2415 { "f32", offsetof(CPUState, fpr[32]) },
2416 { "f34", offsetof(CPUState, fpr[34]) },
2417 { "f36", offsetof(CPUState, fpr[36]) },
2418 { "f38", offsetof(CPUState, fpr[38]) },
2419 { "f40", offsetof(CPUState, fpr[40]) },
2420 { "f42", offsetof(CPUState, fpr[42]) },
2421 { "f44", offsetof(CPUState, fpr[44]) },
2422 { "f46", offsetof(CPUState, fpr[46]) },
2423 { "f48", offsetof(CPUState, fpr[48]) },
2424 { "f50", offsetof(CPUState, fpr[50]) },
2425 { "f52", offsetof(CPUState, fpr[52]) },
2426 { "f54", offsetof(CPUState, fpr[54]) },
2427 { "f56", offsetof(CPUState, fpr[56]) },
2428 { "f58", offsetof(CPUState, fpr[58]) },
2429 { "f60", offsetof(CPUState, fpr[60]) },
2430 { "f62", offsetof(CPUState, fpr[62]) },
2431 { "asi", offsetof(CPUState, asi) },
2432 { "pstate", offsetof(CPUState, pstate) },
2433 { "cansave", offsetof(CPUState, cansave) },
2434 { "canrestore", offsetof(CPUState, canrestore) },
2435 { "otherwin", offsetof(CPUState, otherwin) },
2436 { "wstate", offsetof(CPUState, wstate) },
2437 { "cleanwin", offsetof(CPUState, cleanwin) },
2438 { "fprs", offsetof(CPUState, fprs) },
2439#endif
9307c4c1
FB		 2440#endif
2441 { NULL },
2442};
2443
376253ec 2444static void expr_error(Monitor *mon, const char *msg)
9dc39cba 2445{
376253ec 2446 monitor_printf(mon, "%s\n", msg);
9307c4c1
FB		 2447 longjmp(expr_env, 1);
2448}
2449
6a00d601 2450/* return 0 if OK, -1 if not found, -2 if no CPU defined */
92a31b1f 2451static int get_monitor_def(target_long *pval, const char *name)
9307c4c1 2452{
8662d656 2453 const MonitorDef *md;
92a31b1f
FB		 2454 void *ptr;
2455
9307c4c1
FB		 2456 for(md = monitor_defs; md->name != NULL; md++) {
2457 if (compare_cmd(name, md->name)) {
2458 if (md->get_value) {
e95c8d51 2459 *pval = md->get_value(md, md->offset);
9307c4c1 2460 } else {
6a00d601
FB		 2461 CPUState *env = mon_get_cpu();
2462 if (!env)
2463 return -2;
2464 ptr = (uint8_t *)env + md->offset;
92a31b1f
FB		 2465 switch(md->type) {
2466 case MD_I32:
2467 *pval = *(int32_t *)ptr;
2468 break;
2469 case MD_TLONG:
2470 *pval = *(target_long *)ptr;
2471 break;
2472 default:
2473 *pval = 0;
2474 break;
2475 }
9307c4c1
FB		 2476 }
2477 return 0;
2478 }
2479 }
2480 return -1;
2481}
2482
2483static void next(void)
2484{
660f11be 2485 if (*pch != '\0') {
9307c4c1 2486 pch++;
cd390083 2487 while (qemu_isspace(*pch))
9307c4c1
FB		 2488 pch++;
2489 }
2490}
2491
376253ec 2492static int64_t expr_sum(Monitor *mon);
9307c4c1 2493
376253ec 2494static int64_t expr_unary(Monitor *mon)
9307c4c1 2495{
c2efc95d 2496 int64_t n;
9307c4c1 2497 char *p;
6a00d601 2498 int ret;
9307c4c1
FB		 2499
2500 switch(*pch) {
2501 case '+':
2502 next();
376253ec 2503 n = expr_unary(mon);
9307c4c1
FB		 2504 break;
2505 case '-':
2506 next();
376253ec 2507 n = -expr_unary(mon);
9307c4c1
FB		 2508 break;
2509 case '~':
2510 next();
376253ec 2511 n = ~expr_unary(mon);
9307c4c1
FB		 2512 break;
2513 case '(':
2514 next();
376253ec 2515 n = expr_sum(mon);
9307c4c1 2516 if (*pch != ')') {
376253ec 2517 expr_error(mon, "')' expected");
9307c4c1
FB		 2518 }
2519 next();
2520 break;
81d0912d
FB		 2521 case '\'':
2522 pch++;
2523 if (*pch == '\0')
376253ec 2524 expr_error(mon, "character constant expected");
81d0912d
FB		 2525 n = *pch;
2526 pch++;
2527 if (*pch != '\'')
376253ec 2528 expr_error(mon, "missing terminating \' character");
81d0912d
FB		 2529 next();
2530 break;
9307c4c1
FB		 2531 case '$':
2532 {
2533 char buf[128], *q;
69b34976 2534 target_long reg=0;
3b46e624 2535
9307c4c1
FB		 2536 pch++;
2537 q = buf;
2538 while ((*pch >= 'a' && *pch <= 'z') ||
2539 (*pch >= 'A' && *pch <= 'Z') ||
2540 (*pch >= '0' && *pch <= '9') ||
57206fd4 2541 *pch == '_' || *pch == '.') {
9307c4c1
FB		 2542 if ((q - buf) < sizeof(buf) - 1)
2543 *q++ = *pch;
2544 pch++;
2545 }
cd390083 2546 while (qemu_isspace(*pch))
9307c4c1
FB		 2547 pch++;
2548 *q = 0;
7743e588 2549 ret = get_monitor_def(&reg, buf);
6a00d601 2550 if (ret == -1)
376253ec 2551 expr_error(mon, "unknown register");
5fafdf24 2552 else if (ret == -2)
376253ec 2553 expr_error(mon, "no cpu defined");
7743e588 2554 n = reg;
9307c4c1
FB		 2555 }
2556 break;
2557 case '\0':
376253ec 2558 expr_error(mon, "unexpected end of expression");
9307c4c1
FB		 2559 n = 0;
2560 break;
2561 default:
7743e588 2562#if TARGET_PHYS_ADDR_BITS > 32
4f4fbf77
FB		 2563 n = strtoull(pch, &p, 0);
2564#else
9307c4c1 2565 n = strtoul(pch, &p, 0);
4f4fbf77 2566#endif
9307c4c1 2567 if (pch == p) {
376253ec 2568 expr_error(mon, "invalid char in expression");
9307c4c1
FB		 2569 }
2570 pch = p;
cd390083 2571 while (qemu_isspace(*pch))
9307c4c1
FB		 2572 pch++;
2573 break;
2574 }
2575 return n;
2576}
2577
2578
376253ec 2579static int64_t expr_prod(Monitor *mon)
9307c4c1 2580{
c2efc95d 2581 int64_t val, val2;
92a31b1f 2582 int op;
3b46e624 2583
376253ec 2584 val = expr_unary(mon);
9307c4c1
FB		 2585 for(;;) {
2586 op = *pch;
2587 if (op != '*' && op != '/' && op != '%')
2588 break;
2589 next();
376253ec 2590 val2 = expr_unary(mon);
9307c4c1
FB		 2591 switch(op) {
2592 default:
2593 case '*':
2594 val *= val2;
2595 break;
2596 case '/':
2597 case '%':
5fafdf24 2598 if (val2 == 0)
376253ec 2599 expr_error(mon, "division by zero");
9307c4c1
FB		 2600 if (op == '/')
2601 val /= val2;
2602 else
2603 val %= val2;
2604 break;
2605 }
2606 }
2607 return val;
2608}
2609
376253ec 2610static int64_t expr_logic(Monitor *mon)
9307c4c1 2611{
c2efc95d 2612 int64_t val, val2;
92a31b1f 2613 int op;
9307c4c1 2614
376253ec 2615 val = expr_prod(mon);
9307c4c1
FB		 2616 for(;;) {
2617 op = *pch;
2618 if (op != '&' && op != '|' && op != '^')
2619 break;
2620 next();
376253ec 2621 val2 = expr_prod(mon);
9307c4c1
FB		 2622 switch(op) {
2623 default:
2624 case '&':
2625 val &= val2;
2626 break;
2627 case '|':
2628 val |= val2;
2629 break;
2630 case '^':
2631 val ^= val2;
2632 break;
2633 }
2634 }
2635 return val;
2636}
2637
376253ec 2638static int64_t expr_sum(Monitor *mon)
9307c4c1 2639{
c2efc95d 2640 int64_t val, val2;
92a31b1f 2641 int op;
9307c4c1 2642
376253ec 2643 val = expr_logic(mon);
9307c4c1
FB		 2644 for(;;) {
2645 op = *pch;
2646 if (op != '+' && op != '-')
2647 break;
2648 next();
376253ec 2649 val2 = expr_logic(mon);
9307c4c1
FB		 2650 if (op == '+')
2651 val += val2;
2652 else
2653 val -= val2;
2654 }
2655 return val;
2656}
2657
376253ec 2658static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
9307c4c1
FB		 2659{
2660 pch = *pp;
2661 if (setjmp(expr_env)) {
2662 *pp = pch;
2663 return -1;
2664 }
cd390083 2665 while (qemu_isspace(*pch))
9307c4c1 2666 pch++;
376253ec 2667 *pval = expr_sum(mon);
9307c4c1
FB		 2668 *pp = pch;
2669 return 0;
2670}
2671
2672static int get_str(char *buf, int buf_size, const char **pp)
2673{
2674 const char *p;
2675 char *q;
2676 int c;
2677
81d0912d 2678 q = buf;
9307c4c1 2679 p = *pp;
cd390083 2680 while (qemu_isspace(*p))
9307c4c1
FB		 2681 p++;
2682 if (*p == '\0') {
2683 fail:
81d0912d 2684 *q = '\0';
9307c4c1
FB		 2685 *pp = p;
2686 return -1;
2687 }
9307c4c1
FB		 2688 if (*p == '\"') {
2689 p++;
2690 while (*p != '\0' && *p != '\"') {
2691 if (*p == '\\') {
2692 p++;
2693 c = *p++;
2694 switch(c) {
2695 case 'n':
2696 c = '\n';
2697 break;
2698 case 'r':
2699 c = '\r';
2700 break;
2701 case '\\':
2702 case '\'':
2703 case '\"':
2704 break;
2705 default:
2706 qemu_printf("unsupported escape code: '\\%c'\n", c);
2707 goto fail;
2708 }
2709 if ((q - buf) < buf_size - 1) {
2710 *q++ = c;
2711 }
2712 } else {
2713 if ((q - buf) < buf_size - 1) {
2714 *q++ = *p;
2715 }
2716 p++;
2717 }
2718 }
2719 if (*p != '\"') {
5b60212f 2720 qemu_printf("unterminated string\n");
9307c4c1
FB		 2721 goto fail;
2722 }
2723 p++;
2724 } else {
cd390083 2725 while (*p != '\0' && !qemu_isspace(*p)) {
9307c4c1
FB		 2726 if ((q - buf) < buf_size - 1) {
2727 *q++ = *p;
2728 }
2729 p++;
2730 }
9307c4c1 2731 }
81d0912d 2732 *q = '\0';
9307c4c1
FB		 2733 *pp = p;
2734 return 0;
2735}
2736
4590fd80
LC		 2737/*
2738 * Store the command-name in cmdname, and return a pointer to
2739 * the remaining of the command string.
2740 */
2741static const char *get_command_name(const char *cmdline,
2742 char *cmdname, size_t nlen)
2743{
2744 size_t len;
2745 const char *p, *pstart;
2746
2747 p = cmdline;
2748 while (qemu_isspace(*p))
2749 p++;
2750 if (*p == '\0')
2751 return NULL;
2752 pstart = p;
2753 while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
2754 p++;
2755 len = p - pstart;
2756 if (len > nlen - 1)
2757 len = nlen - 1;
2758 memcpy(cmdname, pstart, len);
2759 cmdname[len] = '\0';
2760 return p;
2761}
2762
4d76d2ba
LC		 2763/**
2764 * Read key of 'type' into 'key' and return the current
2765 * 'type' pointer.
2766 */
2767static char *key_get_info(const char *type, char **key)
2768{
2769 size_t len;
2770 char *p, *str;
2771
2772 if (*type == ',')
2773 type++;
2774
2775 p = strchr(type, ':');
2776 if (!p) {
2777 *key = NULL;
2778 return NULL;
2779 }
2780 len = p - type;
2781
2782 str = qemu_malloc(len + 1);
2783 memcpy(str, type, len);
2784 str[len] = '\0';
2785
2786 *key = str;
2787 return ++p;
2788}
2789
9307c4c1
FB		 2790static int default_fmt_format = 'x';
2791static int default_fmt_size = 4;
2792
2793#define MAX_ARGS 16
2794
c227f099 2795static const mon_cmd_t *monitor_parse_command(Monitor *mon,
55f81d96 2796 const char *cmdline,
55f81d96 2797 QDict *qdict)
9307c4c1 2798{
4590fd80 2799 const char *p, *typestr;
53773581 2800 int c;
c227f099 2801 const mon_cmd_t *cmd;
9307c4c1
FB		 2802 char cmdname[256];
2803 char buf[1024];
4d76d2ba 2804 char *key;
9dc39cba
FB		 2805
2806#ifdef DEBUG
376253ec 2807 monitor_printf(mon, "command='%s'\n", cmdline);
9dc39cba 2808#endif
3b46e624 2809
9307c4c1 2810 /* extract the command name */
4590fd80
LC		 2811 p = get_command_name(cmdline, cmdname, sizeof(cmdname));
2812 if (!p)
55f81d96 2813 return NULL;
3b46e624 2814
9307c4c1 2815 /* find the command */
376253ec 2816 for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
5fafdf24 2817 if (compare_cmd(cmdname, cmd->name))
d91d9bf6
LC		 2818 break;
2819 }
2820
2821 if (cmd->name == NULL) {
2822 monitor_printf(mon, "unknown command: '%s'\n", cmdname);
55f81d96 2823 return NULL;
9307c4c1 2824 }
9307c4c1 2825
9307c4c1
FB		 2826 /* parse the parameters */
2827 typestr = cmd->args_type;
9dc39cba 2828 for(;;) {
4d76d2ba
LC		 2829 typestr = key_get_info(typestr, &key);
2830 if (!typestr)
9dc39cba 2831 break;
4d76d2ba 2832 c = *typestr;
9307c4c1
FB		 2833 typestr++;
2834 switch(c) {
2835 case 'F':
81d0912d 2836 case 'B':
9307c4c1
FB		 2837 case 's':
2838 {
2839 int ret;
3b46e624 2840
cd390083 2841 while (qemu_isspace(*p))
9307c4c1
FB		 2842 p++;
2843 if (*typestr == '?') {
2844 typestr++;
2845 if (*p == '\0') {
2846 /* no optional string: NULL argument */
53773581 2847 break;
9307c4c1
FB		 2848 }
2849 }
2850 ret = get_str(buf, sizeof(buf), &p);
2851 if (ret < 0) {
81d0912d
FB		 2852 switch(c) {
2853 case 'F':
376253ec
AL		 2854 monitor_printf(mon, "%s: filename expected\n",
2855 cmdname);
81d0912d
FB		 2856 break;
2857 case 'B':
376253ec
AL		 2858 monitor_printf(mon, "%s: block device name expected\n",
2859 cmdname);
81d0912d
FB		 2860 break;
2861 default:
376253ec 2862 monitor_printf(mon, "%s: string expected\n", cmdname);
81d0912d
FB		 2863 break;
2864 }
9307c4c1
FB		 2865 goto fail;
2866 }
53773581 2867 qdict_put(qdict, key, qstring_from_str(buf));
9307c4c1 2868 }
9dc39cba 2869 break;
9307c4c1
FB		 2870 case '/':
2871 {
2872 int count, format, size;
3b46e624 2873
cd390083 2874 while (qemu_isspace(*p))
9307c4c1
FB		 2875 p++;
2876 if (*p == '/') {
2877 /* format found */
2878 p++;
2879 count = 1;
cd390083 2880 if (qemu_isdigit(*p)) {
9307c4c1 2881 count = 0;
cd390083 2882 while (qemu_isdigit(*p)) {
9307c4c1
FB		 2883 count = count * 10 + (*p - '0');
2884 p++;
2885 }
2886 }
2887 size = -1;
2888 format = -1;
2889 for(;;) {
2890 switch(*p) {
2891 case 'o':
2892 case 'd':
2893 case 'u':
2894 case 'x':
2895 case 'i':
2896 case 'c':
2897 format = *p++;
2898 break;
2899 case 'b':
2900 size = 1;
2901 p++;
2902 break;
2903 case 'h':
2904 size = 2;
2905 p++;
2906 break;
2907 case 'w':
2908 size = 4;
2909 p++;
2910 break;
2911 case 'g':
2912 case 'L':
2913 size = 8;
2914 p++;
2915 break;
2916 default:
2917 goto next;
2918 }
2919 }
2920 next:
cd390083 2921 if (*p != '\0' && !qemu_isspace(*p)) {
376253ec
AL		 2922 monitor_printf(mon, "invalid char in format: '%c'\n",
2923 *p);
9307c4c1
FB		 2924 goto fail;
2925 }
9307c4c1
FB		 2926 if (format < 0)
2927 format = default_fmt_format;
4c27ba27
FB		 2928 if (format != 'i') {
2929 /* for 'i', not specifying a size gives -1 as size */
2930 if (size < 0)
2931 size = default_fmt_size;
e90f009b 2932 default_fmt_size = size;
4c27ba27 2933 }
9307c4c1
FB		 2934 default_fmt_format = format;
2935 } else {
2936 count = 1;
2937 format = default_fmt_format;
4c27ba27
FB		 2938 if (format != 'i') {
2939 size = default_fmt_size;
2940 } else {
2941 size = -1;
2942 }
9307c4c1 2943 }
f7188bbe
LC		 2944 qdict_put(qdict, "count", qint_from_int(count));
2945 qdict_put(qdict, "format", qint_from_int(format));
2946 qdict_put(qdict, "size", qint_from_int(size));
9307c4c1 2947 }
9dc39cba 2948 break;
9307c4c1 2949 case 'i':
92a31b1f 2950 case 'l':
9307c4c1 2951 {
c2efc95d 2952 int64_t val;
7743e588 2953
cd390083 2954 while (qemu_isspace(*p))
9307c4c1 2955 p++;
3440557b 2956 if (*typestr == '?' || *typestr == '.') {
3440557b 2957 if (*typestr == '?') {
53773581
LC		 2958 if (*p == '\0') {
2959 typestr++;
2960 break;
2961 }
3440557b
FB		 2962 } else {
2963 if (*p == '.') {
2964 p++;
cd390083 2965 while (qemu_isspace(*p))
3440557b 2966 p++;
3440557b 2967 } else {
53773581
LC		 2968 typestr++;
2969 break;
3440557b
FB		 2970 }
2971 }
13224a87 2972 typestr++;
9307c4c1 2973 }
376253ec 2974 if (get_expr(mon, &val, &p))
9307c4c1 2975 goto fail;
675ebef9
LC		 2976 /* Check if 'i' is greater than 32-bit */
2977 if ((c == 'i') && ((val >> 32) & 0xffffffff)) {
2978 monitor_printf(mon, "\'%s\' has failed: ", cmdname);
2979 monitor_printf(mon, "integer is for 32-bit values\n");
2980 goto fail;
2981 }
53773581 2982 qdict_put(qdict, key, qint_from_int(val));
9307c4c1
FB		 2983 }
2984 break;
2985 case '-':
2986 {
2987 int has_option;
2988 /* option */
3b46e624 2989
9307c4c1
FB		 2990 c = *typestr++;
2991 if (c == '\0')
2992 goto bad_type;
cd390083 2993 while (qemu_isspace(*p))
9307c4c1
FB		 2994 p++;
2995 has_option = 0;
2996 if (*p == '-') {
2997 p++;
2998 if (*p != c) {
376253ec
AL		 2999 monitor_printf(mon, "%s: unsupported option -%c\n",
3000 cmdname, *p);
9307c4c1
FB		 3001 goto fail;
3002 }
3003 p++;
3004 has_option = 1;
3005 }
f7188bbe 3006 qdict_put(qdict, key, qint_from_int(has_option));
9307c4c1
FB		 3007 }
3008 break;
3009 default:
3010 bad_type:
376253ec 3011 monitor_printf(mon, "%s: unknown type '%c'\n", cmdname, c);
9307c4c1
FB		 3012 goto fail;
3013 }
4d76d2ba
LC		 3014 qemu_free(key);
3015 key = NULL;
9dc39cba 3016 }
9307c4c1 3017 /* check that all arguments were parsed */
cd390083 3018 while (qemu_isspace(*p))
9307c4c1
FB		 3019 p++;
3020 if (*p != '\0') {
376253ec
AL		 3021 monitor_printf(mon, "%s: extraneous characters at the end of line\n",
3022 cmdname);
9307c4c1 3023 goto fail;
9dc39cba 3024 }
9307c4c1 3025
55f81d96 3026 return cmd;
ac7531ec 3027
55f81d96 3028fail:
4d76d2ba 3029 qemu_free(key);
55f81d96
LC		 3030 return NULL;
3031}
3032
3033static void monitor_handle_command(Monitor *mon, const char *cmdline)
3034{
55f81d96 3035 QDict *qdict;
c227f099 3036 const mon_cmd_t *cmd;
55f81d96
LC		 3037
3038 qdict = qdict_new();
3039
590fb3b7 3040 cmd = monitor_parse_command(mon, cmdline, qdict);
13917bee
LC		 3041 if (!cmd)
3042 goto out;
3043
3044 qemu_errors_to_mon(mon);
3045
3046 if (monitor_handler_ported(cmd)) {
3047 QObject *data = NULL;
3048
3049 cmd->mhandler.cmd_new(mon, qdict, &data);
3050 if (data)
3051 cmd->user_print(mon, data);
3052
3053 qobject_decref(data);
3054 } else {
af4ce882 3055 cmd->mhandler.cmd(mon, qdict);
55f81d96
LC		 3056 }
3057
13917bee
LC		 3058 qemu_errors_to_previous();
3059
3060out:
f7188bbe 3061 QDECREF(qdict);
9dc39cba
FB		 3062}
3063
81d0912d
FB		 3064static void cmd_completion(const char *name, const char *list)
3065{
3066 const char *p, *pstart;
3067 char cmd[128];
3068 int len;
3069
3070 p = list;
3071 for(;;) {
3072 pstart = p;
3073 p = strchr(p, '|');
3074 if (!p)
3075 p = pstart + strlen(pstart);
3076 len = p - pstart;
3077 if (len > sizeof(cmd) - 2)
3078 len = sizeof(cmd) - 2;
3079 memcpy(cmd, pstart, len);
3080 cmd[len] = '\0';
3081 if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
731b0364 3082 readline_add_completion(cur_mon->rs, cmd);
81d0912d
FB		 3083 }
3084 if (*p == '\0')
3085 break;
3086 p++;
3087 }
3088}
3089
3090static void file_completion(const char *input)
3091{
3092 DIR *ffs;
3093 struct dirent *d;
3094 char path[1024];
3095 char file[1024], file_prefix[1024];
3096 int input_path_len;
3097 const char *p;
3098
5fafdf24 3099 p = strrchr(input, '/');
81d0912d
FB		 3100 if (!p) {
3101 input_path_len = 0;
3102 pstrcpy(file_prefix, sizeof(file_prefix), input);
363a37d5 3103 pstrcpy(path, sizeof(path), ".");
81d0912d
FB		 3104 } else {
3105 input_path_len = p - input + 1;
3106 memcpy(path, input, input_path_len);
3107 if (input_path_len > sizeof(path) - 1)
3108 input_path_len = sizeof(path) - 1;
3109 path[input_path_len] = '\0';
3110 pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
3111 }
3112#ifdef DEBUG_COMPLETION
376253ec
AL		 3113 monitor_printf(cur_mon, "input='%s' path='%s' prefix='%s'\n",
3114 input, path, file_prefix);
81d0912d
FB		 3115#endif
3116 ffs = opendir(path);
3117 if (!ffs)
3118 return;
3119 for(;;) {
3120 struct stat sb;
3121 d = readdir(ffs);
3122 if (!d)
3123 break;
3124 if (strstart(d->d_name, file_prefix, NULL)) {
3125 memcpy(file, input, input_path_len);
363a37d5
BS		 3126 if (input_path_len < sizeof(file))
3127 pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
3128 d->d_name);
81d0912d
FB		 3129 /* stat the file to find out if it's a directory.
3130 * In that case add a slash to speed up typing long paths
3131 */
3132 stat(file, &sb);
3133 if(S_ISDIR(sb.st_mode))
363a37d5 3134 pstrcat(file, sizeof(file), "/");
731b0364 3135 readline_add_completion(cur_mon->rs, file);
81d0912d
FB		 3136 }
3137 }
3138 closedir(ffs);
3139}
3140
51de9760 3141static void block_completion_it(void *opaque, BlockDriverState *bs)
81d0912d 3142{
51de9760 3143 const char *name = bdrv_get_device_name(bs);
81d0912d
FB		 3144 const char *input = opaque;
3145
3146 if (input[0] == '\0' ||
3147 !strncmp(name, (char *)input, strlen(input))) {
731b0364 3148 readline_add_completion(cur_mon->rs, name);
81d0912d
FB		 3149 }
3150}
3151
3152/* NOTE: this parser is an approximate form of the real command parser */
3153static void parse_cmdline(const char *cmdline,
3154 int *pnb_args, char **args)
3155{
3156 const char *p;
3157 int nb_args, ret;
3158 char buf[1024];
3159
3160 p = cmdline;
3161 nb_args = 0;
3162 for(;;) {
cd390083 3163 while (qemu_isspace(*p))
81d0912d
FB		 3164 p++;
3165 if (*p == '\0')
3166 break;
3167 if (nb_args >= MAX_ARGS)
3168 break;
3169 ret = get_str(buf, sizeof(buf), &p);
3170 args[nb_args] = qemu_strdup(buf);
3171 nb_args++;
3172 if (ret < 0)
3173 break;
3174 }
3175 *pnb_args = nb_args;
3176}
3177
4d76d2ba
LC		 3178static const char *next_arg_type(const char *typestr)
3179{
3180 const char *p = strchr(typestr, ':');
3181 return (p != NULL ? ++p : typestr);
3182}
3183
4c36ba32 3184static void monitor_find_completion(const char *cmdline)
81d0912d
FB		 3185{
3186 const char *cmdname;
3187 char *args[MAX_ARGS];
3188 int nb_args, i, len;
3189 const char *ptype, *str;
c227f099 3190 const mon_cmd_t *cmd;
64866c3d 3191 const KeyDef *key;
81d0912d
FB		 3192
3193 parse_cmdline(cmdline, &nb_args, args);
3194#ifdef DEBUG_COMPLETION
3195 for(i = 0; i < nb_args; i++) {
376253ec 3196 monitor_printf(cur_mon, "arg%d = '%s'\n", i, (char *)args[i]);
81d0912d
FB		 3197 }
3198#endif
3199
3200 /* if the line ends with a space, it means we want to complete the
3201 next arg */
3202 len = strlen(cmdline);
cd390083 3203 if (len > 0 && qemu_isspace(cmdline[len - 1])) {
81d0912d
FB		 3204 if (nb_args >= MAX_ARGS)
3205 return;
3206 args[nb_args++] = qemu_strdup("");
3207 }
3208 if (nb_args <= 1) {
3209 /* command completion */
3210 if (nb_args == 0)
3211 cmdname = "";
3212 else
3213 cmdname = args[0];
731b0364 3214 readline_set_completion_index(cur_mon->rs, strlen(cmdname));
376253ec 3215 for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
81d0912d
FB		 3216 cmd_completion(cmdname, cmd->name);
3217 }
3218 } else {
3219 /* find the command */
376253ec 3220 for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
81d0912d
FB		 3221 if (compare_cmd(args[0], cmd->name))
3222 goto found;
3223 }
3224 return;
3225 found:
4d76d2ba 3226 ptype = next_arg_type(cmd->args_type);
81d0912d
FB		 3227 for(i = 0; i < nb_args - 2; i++) {
3228 if (*ptype != '\0') {
4d76d2ba 3229 ptype = next_arg_type(ptype);
81d0912d 3230 while (*ptype == '?')
4d76d2ba 3231 ptype = next_arg_type(ptype);
81d0912d
FB		 3232 }
3233 }
3234 str = args[nb_args - 1];
2a1704a7
BS		 3235 if (*ptype == '-' && ptype[1] != '\0') {
3236 ptype += 2;
3237 }
81d0912d
FB		 3238 switch(*ptype) {
3239 case 'F':
3240 /* file completion */
731b0364 3241 readline_set_completion_index(cur_mon->rs, strlen(str));
81d0912d
FB		 3242 file_completion(str);
3243 break;
3244 case 'B':
3245 /* block device name completion */
731b0364 3246 readline_set_completion_index(cur_mon->rs, strlen(str));
81d0912d
FB		 3247 bdrv_iterate(block_completion_it, (void *)str);
3248 break;
7fe48483
FB		 3249 case 's':
3250 /* XXX: more generic ? */
3251 if (!strcmp(cmd->name, "info")) {
731b0364 3252 readline_set_completion_index(cur_mon->rs, strlen(str));
7fe48483
FB		 3253 for(cmd = info_cmds; cmd->name != NULL; cmd++) {
3254 cmd_completion(str, cmd->name);
3255 }
64866c3d 3256 } else if (!strcmp(cmd->name, "sendkey")) {
e600d1ef
BS		 3257 char *sep = strrchr(str, '-');
3258 if (sep)
3259 str = sep + 1;
731b0364 3260 readline_set_completion_index(cur_mon->rs, strlen(str));
64866c3d
FB		 3261 for(key = key_defs; key->name != NULL; key++) {
3262 cmd_completion(str, key->name);
3263 }
f3353c6b
JK		 3264 } else if (!strcmp(cmd->name, "help|?")) {
3265 readline_set_completion_index(cur_mon->rs, strlen(str));
3266 for (cmd = mon_cmds; cmd->name != NULL; cmd++) {
3267 cmd_completion(str, cmd->name);
3268 }
7fe48483
FB		 3269 }
3270 break;
81d0912d
FB		 3271 default:
3272 break;
3273 }
3274 }
3275 for(i = 0; i < nb_args; i++)
3276 qemu_free(args[i]);
3277}
3278
731b0364 3279static int monitor_can_read(void *opaque)
9dc39cba 3280{
731b0364
AL		 3281 Monitor *mon = opaque;
3282
3283 return (mon->suspend_cnt == 0) ? 128 : 0;
9dc39cba
FB		 3284}
3285
731b0364 3286static void monitor_read(void *opaque, const uint8_t *buf, int size)
9dc39cba 3287{
731b0364 3288 Monitor *old_mon = cur_mon;
7e2515e8 3289 int i;
376253ec 3290
731b0364
AL		 3291 cur_mon = opaque;
3292
cde76ee1
AL		 3293 if (cur_mon->rs) {
3294 for (i = 0; i < size; i++)
3295 readline_handle_byte(cur_mon->rs, buf[i]);
3296 } else {
3297 if (size == 0 || buf[size - 1] != 0)
3298 monitor_printf(cur_mon, "corrupted command\n");
3299 else
3300 monitor_handle_command(cur_mon, (char *)buf);
3301 }
9dc39cba 3302
731b0364
AL		 3303 cur_mon = old_mon;
3304}
d8f44609 3305
376253ec 3306static void monitor_command_cb(Monitor *mon, const char *cmdline, void *opaque)
aa455485 3307{
731b0364 3308 monitor_suspend(mon);
376253ec 3309 monitor_handle_command(mon, cmdline);
731b0364 3310 monitor_resume(mon);
d8f44609
AL		 3311}
3312
cde76ee1 3313int monitor_suspend(Monitor *mon)
d8f44609 3314{
cde76ee1
AL		 3315 if (!mon->rs)
3316 return -ENOTTY;
731b0364 3317 mon->suspend_cnt++;
cde76ee1 3318 return 0;
d8f44609
AL		 3319}
3320
376253ec 3321void monitor_resume(Monitor *mon)
d8f44609 3322{
cde76ee1
AL		 3323 if (!mon->rs)
3324 return;
731b0364
AL		 3325 if (--mon->suspend_cnt == 0)
3326 readline_show_prompt(mon->rs);
aa455485
FB		 3327}
3328
731b0364 3329static void monitor_event(void *opaque, int event)
86e94dea 3330{
376253ec
AL		 3331 Monitor *mon = opaque;
3332
2724b180
AL		 3333 switch (event) {
3334 case CHR_EVENT_MUX_IN:
a7aec5da
GH		 3335 mon->mux_out = 0;
3336 if (mon->reset_seen) {
3337 readline_restart(mon->rs);
3338 monitor_resume(mon);
3339 monitor_flush(mon);
3340 } else {
3341 mon->suspend_cnt = 0;
3342 }
2724b180
AL		 3343 break;
3344
3345 case CHR_EVENT_MUX_OUT:
a7aec5da
GH		 3346 if (mon->reset_seen) {
3347 if (mon->suspend_cnt == 0) {
3348 monitor_printf(mon, "\n");
3349 }
3350 monitor_flush(mon);
3351 monitor_suspend(mon);
3352 } else {
3353 mon->suspend_cnt++;
3354 }
3355 mon->mux_out = 1;
2724b180 3356 break;
86e94dea 3357
2724b180
AL		 3358 case CHR_EVENT_RESET:
3359 monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
3360 "information\n", QEMU_VERSION);
a7aec5da 3361 if (!mon->mux_out) {
2724b180 3362 readline_show_prompt(mon->rs);
a7aec5da
GH		 3363 }
3364 mon->reset_seen = 1;
2724b180
AL		 3365 break;
3366 }
86e94dea
TS		 3367}
3368
76655d6d
AL		 3369
3370/*
3371 * Local variables:
3372 * c-indent-level: 4
3373 * c-basic-offset: 4
3374 * tab-width: 8
3375 * End:
3376 */
3377
731b0364 3378void monitor_init(CharDriverState *chr, int flags)
aa455485 3379{
731b0364 3380 static int is_first_init = 1;
87127161 3381 Monitor *mon;
20d8a3ed
TS		 3382
3383 if (is_first_init) {
c8256f9d 3384 key_timer = qemu_new_timer(vm_clock, release_keys, NULL);
20d8a3ed
TS		 3385 is_first_init = 0;
3386 }
87127161
AL		 3387
3388 mon = qemu_mallocz(sizeof(*mon));
20d8a3ed 3389
87127161 3390 mon->chr = chr;
731b0364 3391 mon->flags = flags;
cde76ee1
AL		 3392 if (flags & MONITOR_USE_READLINE) {
3393 mon->rs = readline_init(mon, monitor_find_completion);
3394 monitor_read_command(mon, 0);
3395 }
87127161 3396
731b0364
AL		 3397 qemu_chr_add_handlers(chr, monitor_can_read, monitor_read, monitor_event,
3398 mon);
87127161 3399
72cf2d4f 3400 QLIST_INSERT_HEAD(&mon_list, mon, entry);
731b0364 3401 if (!cur_mon || (flags & MONITOR_IS_DEFAULT))
87127161 3402 cur_mon = mon;
aa455485
FB		 3403}
3404
376253ec 3405static void bdrv_password_cb(Monitor *mon, const char *password, void *opaque)
81d0912d 3406{
bb5fc20f
AL		 3407 BlockDriverState *bs = opaque;
3408 int ret = 0;
81d0912d 3409
bb5fc20f 3410 if (bdrv_set_key(bs, password) != 0) {
376253ec 3411 monitor_printf(mon, "invalid password\n");
bb5fc20f 3412 ret = -EPERM;
9dc39cba 3413 }
731b0364
AL		 3414 if (mon->password_completion_cb)
3415 mon->password_completion_cb(mon->password_opaque, ret);
bb5fc20f 3416
731b0364 3417 monitor_read_command(mon, 1);
9dc39cba 3418}
c0f4ce77 3419
376253ec 3420void monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
bb5fc20f
AL		 3421 BlockDriverCompletionFunc *completion_cb,
3422 void *opaque)
c0f4ce77 3423{
cde76ee1
AL		 3424 int err;
3425
bb5fc20f
AL		 3426 if (!bdrv_key_required(bs)) {
3427 if (completion_cb)
3428 completion_cb(opaque, 0);
3429 return;
3430 }
c0f4ce77 3431
376253ec
AL		 3432 monitor_printf(mon, "%s (%s) is encrypted.\n", bdrv_get_device_name(bs),
3433 bdrv_get_encrypted_filename(bs));
bb5fc20f 3434
731b0364
AL		 3435 mon->password_completion_cb = completion_cb;
3436 mon->password_opaque = opaque;
bb5fc20f 3437
cde76ee1
AL		 3438 err = monitor_read_password(mon, bdrv_password_cb, bs);
3439
3440 if (err && completion_cb)
3441 completion_cb(opaque, err);
c0f4ce77 3442}
ac7531ec
GH		 3443
3444typedef struct QemuErrorSink QemuErrorSink;
3445struct QemuErrorSink {
3446 enum {
3447 ERR_SINK_FILE,
3448 ERR_SINK_MONITOR,
3449 } dest;
3450 union {
3451 FILE *fp;
3452 Monitor *mon;
3453 };
3454 QemuErrorSink *previous;
3455};
3456
528e93a9 3457static QemuErrorSink *qemu_error_sink;
ac7531ec
GH		 3458
3459void qemu_errors_to_file(FILE *fp)
3460{
3461 QemuErrorSink *sink;
3462
3463 sink = qemu_mallocz(sizeof(*sink));
3464 sink->dest = ERR_SINK_FILE;
3465 sink->fp = fp;
3466 sink->previous = qemu_error_sink;
3467 qemu_error_sink = sink;
3468}
3469
3470void qemu_errors_to_mon(Monitor *mon)
3471{
3472 QemuErrorSink *sink;
3473
3474 sink = qemu_mallocz(sizeof(*sink));
3475 sink->dest = ERR_SINK_MONITOR;
3476 sink->mon = mon;
3477 sink->previous = qemu_error_sink;
3478 qemu_error_sink = sink;
3479}
3480
3481void qemu_errors_to_previous(void)
3482{
3483 QemuErrorSink *sink;
3484
3485 assert(qemu_error_sink != NULL);
3486 sink = qemu_error_sink;
3487 qemu_error_sink = sink->previous;
3488 qemu_free(sink);
3489}
3490
3491void qemu_error(const char *fmt, ...)
3492{
3493 va_list args;
3494
3495 assert(qemu_error_sink != NULL);
3496 switch (qemu_error_sink->dest) {
3497 case ERR_SINK_FILE:
3498 va_start(args, fmt);
3499 vfprintf(qemu_error_sink->fp, fmt, args);
3500 va_end(args);
3501 break;
3502 case ERR_SINK_MONITOR:
3503 va_start(args, fmt);
3504 monitor_vprintf(qemu_error_sink->mon, fmt, args);
3505 va_end(args);
3506 break;
3507 }
3508}
Qemu copy for testing