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