]> git.proxmox.com Git - mirror_qemu.git/blame - monitor.c
virtio-blk: correctly dirty guest memory
[mirror_qemu.git] / monitor.c
CommitLineData
9dc39cba
FB
1/*
2 * QEMU monitor
5fafdf24 3 *
9dc39cba 4 * Copyright (c) 2003-2004 Fabrice Bellard
5fafdf24 5 *
9dc39cba
FB
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
511d2b14 24#include <dirent.h>
87ecb68b 25#include "hw/hw.h"
b4a42f81 26#include "monitor/qdev.h"
87ecb68b 27#include "hw/usb.h"
0d09e41a 28#include "hw/i386/pc.h"
a2cb15b0 29#include "hw/pci/pci.h"
0d09e41a 30#include "sysemu/watchdog.h"
45a50b16 31#include "hw/loader.h"
022c62cb 32#include "exec/gdbstub.h"
1422e32d 33#include "net/net.h"
68ac40d2 34#include "net/slirp.h"
dccfcd0e 35#include "sysemu/char.h"
7572150c 36#include "ui/qemu-spice.h"
9c17d615 37#include "sysemu/sysemu.h"
e35704ba 38#include "sysemu/numa.h"
83c9089e 39#include "monitor/monitor.h"
0150cd81 40#include "qemu/readline.h"
28ecbaee 41#include "ui/console.h"
c751a74a 42#include "ui/input.h"
9c17d615 43#include "sysemu/blockdev.h"
87ecb68b 44#include "audio/audio.h"
76cad711 45#include "disas/disas.h"
9c17d615 46#include "sysemu/balloon.h"
1de7afc9 47#include "qemu/timer.h"
caf71f86 48#include "migration/migration.h"
9c17d615 49#include "sysemu/kvm.h"
1de7afc9 50#include "qemu/acl.h"
bdee56f5 51#include "sysemu/tpm.h"
7b1b5d19
PB
52#include "qapi/qmp/qint.h"
53#include "qapi/qmp/qfloat.h"
54#include "qapi/qmp/qlist.h"
55#include "qapi/qmp/qbool.h"
56#include "qapi/qmp/qstring.h"
57#include "qapi/qmp/qjson.h"
58#include "qapi/qmp/json-streamer.h"
59#include "qapi/qmp/json-parser.h"
1094fd3a 60#include <qom/object_interfaces.h>
1de7afc9 61#include "qemu/osdep.h"
2b41f10e 62#include "cpu.h"
89bd820a 63#include "trace.h"
31965ae2 64#include "trace/control.h"
6d8a764e 65#ifdef CONFIG_TRACE_SIMPLE
31965ae2 66#include "trace/simple.h"
22890ab5 67#endif
022c62cb 68#include "exec/memory.h"
f08b6170 69#include "exec/cpu_ldst.h"
48a32bed
AL
70#include "qmp-commands.h"
71#include "hmp.h"
1de7afc9 72#include "qemu/thread.h"
b21631f3 73#include "block/qapi.h"
43a14cfc
WX
74#include "qapi/qmp-event.h"
75#include "qapi-event.h"
5560625b 76#include "sysemu/block-backend.h"
6a5bd307 77
1ce6be24 78/* for hmp_info_irq/pic */
661f1929 79#if defined(TARGET_SPARC)
0d09e41a 80#include "hw/sparc/sun4m.h"
661f1929 81#endif
0d09e41a 82#include "hw/lm32/lm32_pic.h"
661f1929 83
9dc39cba 84//#define DEBUG
81d0912d 85//#define DEBUG_COMPLETION
9dc39cba 86
9307c4c1
FB
87/*
88 * Supported types:
5fafdf24 89 *
9307c4c1 90 * 'F' filename
81d0912d 91 * 'B' block device name
9307c4c1 92 * 's' string (accept optional quote)
129be006 93 * 'S' it just appends the rest of the string (accept optional quote)
361127df
MA
94 * 'O' option string of the form NAME=VALUE,...
95 * parsed according to QemuOptsList given by its name
96 * Example: 'device:O' uses qemu_device_opts.
97 * Restriction: only lists with empty desc are supported
98 * TODO lift the restriction
92a31b1f
FB
99 * 'i' 32 bit integer
100 * 'l' target long (32 or 64 bit)
91162849
LC
101 * 'M' Non-negative target long (32 or 64 bit), in user mode the
102 * value is multiplied by 2^20 (think Mebibyte)
dbc0c67f 103 * 'o' octets (aka bytes)
5e00984a
KW
104 * user mode accepts an optional E, e, P, p, T, t, G, g, M, m,
105 * K, k suffix, which multiplies the value by 2^60 for suffixes E
106 * and e, 2^50 for suffixes P and p, 2^40 for suffixes T and t,
107 * 2^30 for suffixes G and g, 2^20 for M and m, 2^10 for K and k
fccfb11e
MA
108 * 'T' double
109 * user mode accepts an optional ms, us, ns suffix,
110 * which divides the value by 1e3, 1e6, 1e9, respectively
9307c4c1
FB
111 * '/' optional gdb-like print format (like "/10x")
112 *
fb46660e
LC
113 * '?' optional type (for all types, except '/')
114 * '.' other form of optional type (for 'i' and 'l')
942cd1f2
MA
115 * 'b' boolean
116 * user mode accepts "on" or "off"
fb46660e 117 * '-' optional parameter (eg. '-f')
9307c4c1
FB
118 *
119 */
120
940cc30d
AL
121typedef struct MonitorCompletionData MonitorCompletionData;
122struct MonitorCompletionData {
123 Monitor *mon;
124 void (*user_print)(Monitor *mon, const QObject *data);
125};
126
c227f099 127typedef struct mon_cmd_t {
9dc39cba 128 const char *name;
9307c4c1 129 const char *args_type;
9dc39cba
FB
130 const char *params;
131 const char *help;
a2876f59 132 void (*user_print)(Monitor *mon, const QObject *data);
910df89d 133 union {
af4ce882 134 void (*cmd)(Monitor *mon, const QDict *qdict);
261394db 135 int (*cmd_new)(Monitor *mon, const QDict *params, QObject **ret_data);
940cc30d
AL
136 int (*cmd_async)(Monitor *mon, const QDict *params,
137 MonitorCompletion *cb, void *opaque);
910df89d 138 } mhandler;
8ac470c1 139 int flags;
5f3d335f
WX
140 /* @sub_table is a list of 2nd level of commands. If it do not exist,
141 * mhandler should be used. If it exist, sub_table[?].mhandler should be
142 * used, and mhandler of 1st level plays the role of help function.
143 */
144 struct mon_cmd_t *sub_table;
bfa40f77 145 void (*command_completion)(ReadLineState *rs, int nb_args, const char *str);
c227f099 146} mon_cmd_t;
9dc39cba 147
f07918fd 148/* file descriptors passed via SCM_RIGHTS */
c227f099
AL
149typedef struct mon_fd_t mon_fd_t;
150struct mon_fd_t {
f07918fd
MM
151 char *name;
152 int fd;
c227f099 153 QLIST_ENTRY(mon_fd_t) next;
f07918fd
MM
154};
155
ba1c048a
CB
156/* file descriptor associated with a file descriptor set */
157typedef struct MonFdsetFd MonFdsetFd;
158struct MonFdsetFd {
159 int fd;
160 bool removed;
161 char *opaque;
162 QLIST_ENTRY(MonFdsetFd) next;
163};
164
165/* file descriptor set containing fds passed via SCM_RIGHTS */
166typedef struct MonFdset MonFdset;
167struct MonFdset {
168 int64_t id;
169 QLIST_HEAD(, MonFdsetFd) fds;
adb696f3 170 QLIST_HEAD(, MonFdsetFd) dup_fds;
ba1c048a
CB
171 QLIST_ENTRY(MonFdset) next;
172};
173
5fa737a4
LC
174typedef struct MonitorControl {
175 QObject *id;
176 JSONMessageParser parser;
4a7e1190 177 int command_mode;
5fa737a4
LC
178} MonitorControl;
179
afeecec2
DB
180/*
181 * To prevent flooding clients, events can be throttled. The
182 * throttling is calculated globally, rather than per-Monitor
183 * instance.
184 */
43a14cfc
WX
185typedef struct MonitorQAPIEventState {
186 QAPIEvent event; /* Event being tracked */
187 int64_t rate; /* Minimum time (in ns) between two events */
188 int64_t last; /* QEMU_CLOCK_REALTIME value at last emission */
afeecec2
DB
189 QEMUTimer *timer; /* Timer for handling delayed events */
190 QObject *data; /* Event pending delayed dispatch */
43a14cfc 191} MonitorQAPIEventState;
afeecec2 192
87127161
AL
193struct Monitor {
194 CharDriverState *chr;
a7aec5da 195 int reset_seen;
731b0364
AL
196 int flags;
197 int suspend_cnt;
48c043d0 198 bool skip_flush;
6cff3e85
PB
199
200 QemuMutex out_lock;
e1f2641b 201 QString *outbuf;
6cff3e85
PB
202 guint out_watch;
203
204 /* Read under either BQL or out_lock, written with BQL+out_lock. */
205 int mux_out;
206
731b0364 207 ReadLineState *rs;
5fa737a4 208 MonitorControl *mc;
cb446eca 209 CPUState *mon_cpu;
097310b5 210 BlockCompletionFunc *password_completion_cb;
731b0364 211 void *password_opaque;
7717239d 212 mon_cmd_t *cmd_table;
8204a918 213 QError *error;
c227f099 214 QLIST_HEAD(,mon_fd_t) fds;
72cf2d4f 215 QLIST_ENTRY(Monitor) entry;
87127161
AL
216};
217
2dbc8db0
LC
218/* QMP checker flags */
219#define QMP_ACCEPT_UNKNOWNS 1
220
d622cb58
PB
221/* Protects mon_list, monitor_event_state. */
222static QemuMutex monitor_lock;
223
72cf2d4f 224static QLIST_HEAD(mon_list, Monitor) mon_list;
ba1c048a 225static QLIST_HEAD(mon_fdsets, MonFdset) mon_fdsets;
efb87c16 226static int mon_refcount;
7e2515e8 227
816f8925
WX
228static mon_cmd_t mon_cmds[];
229static mon_cmd_t info_cmds[];
9dc39cba 230
f36b4afb
LC
231static const mon_cmd_t qmp_cmds[];
232
8631b608
MA
233Monitor *cur_mon;
234Monitor *default_mon;
376253ec 235
c60bf339
SH
236static void monitor_command_cb(void *opaque, const char *cmdline,
237 void *readline_opaque);
83ab7950 238
09069b19
LC
239static inline int qmp_cmd_mode(const Monitor *mon)
240{
241 return (mon->mc ? mon->mc->command_mode : 0);
242}
243
418173c7
LC
244/* Return true if in control mode, false otherwise */
245static inline int monitor_ctrl_mode(const Monitor *mon)
246{
247 return (mon->flags & MONITOR_USE_CONTROL);
248}
249
6620d3ce
MA
250/* Return non-zero iff we have a current monitor, and it is in QMP mode. */
251int monitor_cur_is_qmp(void)
252{
253 return cur_mon && monitor_ctrl_mode(cur_mon);
254}
255
7060b478 256void monitor_read_command(Monitor *mon, int show_prompt)
731b0364 257{
183e6e52
LC
258 if (!mon->rs)
259 return;
260
731b0364
AL
261 readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL);
262 if (show_prompt)
263 readline_show_prompt(mon->rs);
264}
6a00d601 265
7060b478
AL
266int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
267 void *opaque)
bb5fc20f 268{
bcf5d19c 269 if (mon->rs) {
cde76ee1
AL
270 readline_start(mon->rs, "Password: ", 1, readline_func, opaque);
271 /* prompt is printed on return from the command handler */
272 return 0;
273 } else {
274 monitor_printf(mon, "terminal does not support password prompting\n");
275 return -ENOTTY;
276 }
bb5fc20f
AL
277}
278
6cff3e85
PB
279static void monitor_flush_locked(Monitor *mon);
280
f628926b
GH
281static gboolean monitor_unblocked(GIOChannel *chan, GIOCondition cond,
282 void *opaque)
283{
293d2a00
LE
284 Monitor *mon = opaque;
285
6cff3e85
PB
286 qemu_mutex_lock(&mon->out_lock);
287 mon->out_watch = 0;
288 monitor_flush_locked(mon);
289 qemu_mutex_unlock(&mon->out_lock);
f628926b
GH
290 return FALSE;
291}
292
6cff3e85
PB
293/* Called with mon->out_lock held. */
294static void monitor_flush_locked(Monitor *mon)
7e2515e8 295{
f628926b 296 int rc;
e1f2641b
LC
297 size_t len;
298 const char *buf;
299
48c043d0
LC
300 if (mon->skip_flush) {
301 return;
302 }
303
e1f2641b
LC
304 buf = qstring_get_str(mon->outbuf);
305 len = qstring_get_length(mon->outbuf);
f628926b 306
a4cc73d6 307 if (len && !mon->mux_out) {
e1f2641b 308 rc = qemu_chr_fe_write(mon->chr, (const uint8_t *) buf, len);
056f49ff
SP
309 if ((rc < 0 && errno != EAGAIN) || (rc == len)) {
310 /* all flushed or error */
e1f2641b
LC
311 QDECREF(mon->outbuf);
312 mon->outbuf = qstring_new();
f628926b
GH
313 return;
314 }
315 if (rc > 0) {
316 /* partinal write */
e1f2641b
LC
317 QString *tmp = qstring_from_str(buf + rc);
318 QDECREF(mon->outbuf);
319 mon->outbuf = tmp;
f628926b 320 }
6cff3e85 321 if (mon->out_watch == 0) {
e02bc6de 322 mon->out_watch = qemu_chr_fe_add_watch(mon->chr, G_IO_OUT|G_IO_HUP,
6cff3e85 323 monitor_unblocked, mon);
293d2a00 324 }
7e2515e8
FB
325 }
326}
327
6cff3e85
PB
328void monitor_flush(Monitor *mon)
329{
330 qemu_mutex_lock(&mon->out_lock);
331 monitor_flush_locked(mon);
332 qemu_mutex_unlock(&mon->out_lock);
333}
334
e1f2641b 335/* flush at every end of line */
376253ec 336static void monitor_puts(Monitor *mon, const char *str)
7e2515e8 337{
60fe76f3 338 char c;
731b0364 339
6cff3e85 340 qemu_mutex_lock(&mon->out_lock);
7e2515e8
FB
341 for(;;) {
342 c = *str++;
343 if (c == '\0')
344 break;
e1f2641b
LC
345 if (c == '\n') {
346 qstring_append_chr(mon->outbuf, '\r');
347 }
348 qstring_append_chr(mon->outbuf, c);
349 if (c == '\n') {
6cff3e85 350 monitor_flush_locked(mon);
e1f2641b 351 }
7e2515e8 352 }
6cff3e85 353 qemu_mutex_unlock(&mon->out_lock);
7e2515e8
FB
354}
355
376253ec 356void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
9dc39cba 357{
e1f2641b 358 char *buf;
b8b08266 359
2daa1191
LC
360 if (!mon)
361 return;
362
b8b08266 363 if (monitor_ctrl_mode(mon)) {
b8b08266 364 return;
4a29a85d 365 }
b8b08266 366
e1f2641b 367 buf = g_strdup_vprintf(fmt, ap);
b8b08266 368 monitor_puts(mon, buf);
e1f2641b 369 g_free(buf);
9dc39cba
FB
370}
371
376253ec 372void monitor_printf(Monitor *mon, const char *fmt, ...)
9dc39cba 373{
7e2515e8
FB
374 va_list ap;
375 va_start(ap, fmt);
376253ec 376 monitor_vprintf(mon, fmt, ap);
7e2515e8 377 va_end(ap);
9dc39cba
FB
378}
379
8b7968f7
SW
380static int GCC_FMT_ATTR(2, 3) monitor_fprintf(FILE *stream,
381 const char *fmt, ...)
7fe48483
FB
382{
383 va_list ap;
384 va_start(ap, fmt);
376253ec 385 monitor_vprintf((Monitor *)stream, fmt, ap);
7fe48483
FB
386 va_end(ap);
387 return 0;
388}
389
13c7425e
LC
390static void monitor_user_noop(Monitor *mon, const QObject *data) { }
391
9e80721e 392static inline int handler_is_qobject(const mon_cmd_t *cmd)
13917bee
LC
393{
394 return cmd->user_print != NULL;
395}
396
4903de0c 397static inline bool handler_is_async(const mon_cmd_t *cmd)
940cc30d 398{
8ac470c1 399 return cmd->flags & MONITOR_CMD_ASYNC;
940cc30d
AL
400}
401
8204a918
LC
402static inline int monitor_has_error(const Monitor *mon)
403{
404 return mon->error != NULL;
405}
406
9b57c02e
LC
407static void monitor_json_emitter(Monitor *mon, const QObject *data)
408{
409 QString *json;
410
83a27d4d
LC
411 json = mon->flags & MONITOR_USE_PRETTY ? qobject_to_json_pretty(data) :
412 qobject_to_json(data);
9b57c02e
LC
413 assert(json != NULL);
414
b8b08266
LC
415 qstring_append_chr(json, '\n');
416 monitor_puts(mon, qstring_get_str(json));
4a29a85d 417
9b57c02e
LC
418 QDECREF(json);
419}
420
de253f14
LC
421static QDict *build_qmp_error_dict(const QError *err)
422{
423 QObject *obj;
424
425 obj = qobject_from_jsonf("{ 'error': { 'class': %s, 'desc': %p } }",
426 ErrorClass_lookup[err->err_class],
427 qerror_human(err));
428
429 return qobject_to_qdict(obj);
430}
431
25b422eb
LC
432static void monitor_protocol_emitter(Monitor *mon, QObject *data)
433{
434 QDict *qmp;
435
89bd820a
SH
436 trace_monitor_protocol_emitter(mon);
437
25b422eb
LC
438 if (!monitor_has_error(mon)) {
439 /* success response */
de253f14 440 qmp = qdict_new();
25b422eb
LC
441 if (data) {
442 qobject_incref(data);
443 qdict_put_obj(qmp, "return", data);
444 } else {
0abc6579
LC
445 /* return an empty QDict by default */
446 qdict_put(qmp, "return", qdict_new());
25b422eb
LC
447 }
448 } else {
449 /* error response */
de253f14 450 qmp = build_qmp_error_dict(mon->error);
25b422eb
LC
451 QDECREF(mon->error);
452 mon->error = NULL;
453 }
454
5fa737a4
LC
455 if (mon->mc->id) {
456 qdict_put_obj(qmp, "id", mon->mc->id);
457 mon->mc->id = NULL;
458 }
459
25b422eb
LC
460 monitor_json_emitter(mon, QOBJECT(qmp));
461 QDECREF(qmp);
462}
463
0d1ea871 464
43a14cfc 465static MonitorQAPIEventState monitor_qapi_event_state[QAPI_EVENT_MAX];
afeecec2
DB
466
467/*
43a14cfc 468 * Emits the event to every monitor instance, @event is only used for trace
d622cb58 469 * Called with monitor_lock held.
afeecec2 470 */
43a14cfc 471static void monitor_qapi_event_emit(QAPIEvent event, QObject *data)
afeecec2
DB
472{
473 Monitor *mon;
474
475 trace_monitor_protocol_event_emit(event, data);
476 QLIST_FOREACH(mon, &mon_list, entry) {
477 if (monitor_ctrl_mode(mon) && qmp_cmd_mode(mon)) {
478 monitor_json_emitter(mon, data);
479 }
480 }
481}
482
afeecec2
DB
483/*
484 * Queue a new event for emission to Monitor instances,
485 * applying any rate limiting if required.
486 */
487static void
43a14cfc 488monitor_qapi_event_queue(QAPIEvent event, QDict *data, Error **errp)
afeecec2 489{
43a14cfc
WX
490 MonitorQAPIEventState *evstate;
491 assert(event < QAPI_EVENT_MAX);
bc72ad67 492 int64_t now = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
afeecec2 493
43a14cfc 494 evstate = &(monitor_qapi_event_state[event]);
afeecec2
DB
495 trace_monitor_protocol_event_queue(event,
496 data,
497 evstate->rate,
498 evstate->last,
499 now);
500
501 /* Rate limit of 0 indicates no throttling */
d622cb58 502 qemu_mutex_lock(&monitor_lock);
afeecec2 503 if (!evstate->rate) {
43a14cfc 504 monitor_qapi_event_emit(event, QOBJECT(data));
afeecec2
DB
505 evstate->last = now;
506 } else {
507 int64_t delta = now - evstate->last;
508 if (evstate->data ||
509 delta < evstate->rate) {
510 /* If there's an existing event pending, replace
511 * it with the new event, otherwise schedule a
512 * timer for delayed emission
513 */
514 if (evstate->data) {
515 qobject_decref(evstate->data);
516 } else {
517 int64_t then = evstate->last + evstate->rate;
bc72ad67 518 timer_mod_ns(evstate->timer, then);
afeecec2 519 }
43a14cfc 520 evstate->data = QOBJECT(data);
afeecec2
DB
521 qobject_incref(evstate->data);
522 } else {
43a14cfc 523 monitor_qapi_event_emit(event, QOBJECT(data));
afeecec2
DB
524 evstate->last = now;
525 }
526 }
d622cb58 527 qemu_mutex_unlock(&monitor_lock);
afeecec2
DB
528}
529
afeecec2
DB
530/*
531 * The callback invoked by QemuTimer when a delayed
532 * event is ready to be emitted
533 */
43a14cfc 534static void monitor_qapi_event_handler(void *opaque)
afeecec2 535{
43a14cfc 536 MonitorQAPIEventState *evstate = opaque;
bc72ad67 537 int64_t now = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
afeecec2 538
afeecec2
DB
539 trace_monitor_protocol_event_handler(evstate->event,
540 evstate->data,
541 evstate->last,
542 now);
d622cb58 543 qemu_mutex_lock(&monitor_lock);
afeecec2 544 if (evstate->data) {
43a14cfc 545 monitor_qapi_event_emit(evstate->event, evstate->data);
afeecec2
DB
546 qobject_decref(evstate->data);
547 evstate->data = NULL;
548 }
549 evstate->last = now;
d622cb58 550 qemu_mutex_unlock(&monitor_lock);
afeecec2
DB
551}
552
afeecec2
DB
553/*
554 * @event: the event ID to be limited
555 * @rate: the rate limit in milliseconds
556 *
557 * Sets a rate limit on a particular event, so no
558 * more than 1 event will be emitted within @rate
559 * milliseconds
560 */
561static void
43a14cfc 562monitor_qapi_event_throttle(QAPIEvent event, int64_t rate)
afeecec2 563{
43a14cfc
WX
564 MonitorQAPIEventState *evstate;
565 assert(event < QAPI_EVENT_MAX);
afeecec2 566
43a14cfc 567 evstate = &(monitor_qapi_event_state[event]);
afeecec2
DB
568
569 trace_monitor_protocol_event_throttle(event, rate);
570 evstate->event = event;
2f44a08b 571 assert(rate * SCALE_MS <= INT64_MAX);
afeecec2 572 evstate->rate = rate * SCALE_MS;
afeecec2
DB
573 evstate->last = 0;
574 evstate->data = NULL;
43a14cfc
WX
575 evstate->timer = timer_new(QEMU_CLOCK_REALTIME,
576 SCALE_MS,
577 monitor_qapi_event_handler,
578 evstate);
afeecec2
DB
579}
580
43a14cfc 581static void monitor_qapi_event_init(void)
afeecec2 582{
e010ad8f
WX
583 /* Limit guest-triggerable events to 1 per second */
584 monitor_qapi_event_throttle(QAPI_EVENT_RTC_CHANGE, 1000);
99eaf09c 585 monitor_qapi_event_throttle(QAPI_EVENT_WATCHDOG, 1000);
aef9d311 586 monitor_qapi_event_throttle(QAPI_EVENT_BALLOON_CHANGE, 1000);
fe069d9d
WX
587 monitor_qapi_event_throttle(QAPI_EVENT_QUORUM_REPORT_BAD, 1000);
588 monitor_qapi_event_throttle(QAPI_EVENT_QUORUM_FAILURE, 1000);
e2ae6159 589 monitor_qapi_event_throttle(QAPI_EVENT_VSERPORT_CHANGE, 1000);
0d1ea871 590
43a14cfc 591 qmp_event_set_func_emit(monitor_qapi_event_queue);
0d1ea871
LC
592}
593
ef4b7eee
LC
594static int do_qmp_capabilities(Monitor *mon, const QDict *params,
595 QObject **ret_data)
4a7e1190
LC
596{
597 /* Will setup QMP capabilities in the future */
598 if (monitor_ctrl_mode(mon)) {
599 mon->mc->command_mode = 1;
600 }
ef4b7eee
LC
601
602 return 0;
4a7e1190
LC
603}
604
0268d97c
LC
605static void handle_user_command(Monitor *mon, const char *cmdline);
606
b01fe89e
WX
607static void monitor_data_init(Monitor *mon)
608{
609 memset(mon, 0, sizeof(Monitor));
6cff3e85 610 qemu_mutex_init(&mon->out_lock);
b01fe89e 611 mon->outbuf = qstring_new();
7717239d
WX
612 /* Use *mon_cmds by default. */
613 mon->cmd_table = mon_cmds;
b01fe89e
WX
614}
615
616static void monitor_data_destroy(Monitor *mon)
617{
618 QDECREF(mon->outbuf);
6cff3e85 619 qemu_mutex_destroy(&mon->out_lock);
b01fe89e
WX
620}
621
d51a67b4
LC
622char *qmp_human_monitor_command(const char *command_line, bool has_cpu_index,
623 int64_t cpu_index, Error **errp)
0268d97c 624{
d51a67b4 625 char *output = NULL;
0268d97c 626 Monitor *old_mon, hmp;
0268d97c 627
b01fe89e 628 monitor_data_init(&hmp);
48c043d0 629 hmp.skip_flush = true;
0268d97c
LC
630
631 old_mon = cur_mon;
632 cur_mon = &hmp;
633
d51a67b4
LC
634 if (has_cpu_index) {
635 int ret = monitor_set_cpu(cpu_index);
0268d97c
LC
636 if (ret < 0) {
637 cur_mon = old_mon;
d51a67b4
LC
638 error_set(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
639 "a CPU number");
0268d97c
LC
640 goto out;
641 }
642 }
643
d51a67b4 644 handle_user_command(&hmp, command_line);
0268d97c
LC
645 cur_mon = old_mon;
646
6cff3e85 647 qemu_mutex_lock(&hmp.out_lock);
48c043d0
LC
648 if (qstring_get_length(hmp.outbuf) > 0) {
649 output = g_strdup(qstring_get_str(hmp.outbuf));
d51a67b4
LC
650 } else {
651 output = g_strdup("");
0268d97c 652 }
6cff3e85 653 qemu_mutex_unlock(&hmp.out_lock);
0268d97c
LC
654
655out:
b01fe89e 656 monitor_data_destroy(&hmp);
d51a67b4 657 return output;
0268d97c
LC
658}
659
9dc39cba
FB
660static int compare_cmd(const char *name, const char *list)
661{
662 const char *p, *pstart;
663 int len;
664 len = strlen(name);
665 p = list;
666 for(;;) {
667 pstart = p;
668 p = strchr(p, '|');
669 if (!p)
670 p = pstart + strlen(pstart);
671 if ((p - pstart) == len && !memcmp(pstart, name, len))
672 return 1;
673 if (*p == '\0')
674 break;
675 p++;
676 }
677 return 0;
678}
679
f5438c05
WX
680static int get_str(char *buf, int buf_size, const char **pp)
681{
682 const char *p;
683 char *q;
684 int c;
685
686 q = buf;
687 p = *pp;
688 while (qemu_isspace(*p)) {
689 p++;
690 }
691 if (*p == '\0') {
692 fail:
693 *q = '\0';
694 *pp = p;
695 return -1;
696 }
697 if (*p == '\"') {
698 p++;
699 while (*p != '\0' && *p != '\"') {
700 if (*p == '\\') {
701 p++;
702 c = *p++;
703 switch (c) {
704 case 'n':
705 c = '\n';
706 break;
707 case 'r':
708 c = '\r';
709 break;
710 case '\\':
711 case '\'':
712 case '\"':
713 break;
714 default:
715 qemu_printf("unsupported escape code: '\\%c'\n", c);
716 goto fail;
717 }
718 if ((q - buf) < buf_size - 1) {
719 *q++ = c;
720 }
721 } else {
722 if ((q - buf) < buf_size - 1) {
723 *q++ = *p;
724 }
725 p++;
726 }
727 }
728 if (*p != '\"') {
729 qemu_printf("unterminated string\n");
730 goto fail;
731 }
732 p++;
733 } else {
734 while (*p != '\0' && !qemu_isspace(*p)) {
735 if ((q - buf) < buf_size - 1) {
736 *q++ = *p;
737 }
738 p++;
739 }
740 }
741 *q = '\0';
742 *pp = p;
743 return 0;
744}
745
746#define MAX_ARGS 16
747
dcc70cdf
WX
748static void free_cmdline_args(char **args, int nb_args)
749{
750 int i;
751
752 assert(nb_args <= MAX_ARGS);
753
754 for (i = 0; i < nb_args; i++) {
755 g_free(args[i]);
756 }
757
758}
759
760/*
761 * Parse the command line to get valid args.
762 * @cmdline: command line to be parsed.
763 * @pnb_args: location to store the number of args, must NOT be NULL.
764 * @args: location to store the args, which should be freed by caller, must
765 * NOT be NULL.
766 *
767 * Returns 0 on success, negative on failure.
768 *
769 * NOTE: this parser is an approximate form of the real command parser. Number
770 * of args have a limit of MAX_ARGS. If cmdline contains more, it will
771 * return with failure.
772 */
773static int parse_cmdline(const char *cmdline,
774 int *pnb_args, char **args)
f5438c05
WX
775{
776 const char *p;
777 int nb_args, ret;
778 char buf[1024];
779
780 p = cmdline;
781 nb_args = 0;
782 for (;;) {
783 while (qemu_isspace(*p)) {
784 p++;
785 }
786 if (*p == '\0') {
787 break;
788 }
789 if (nb_args >= MAX_ARGS) {
dcc70cdf 790 goto fail;
f5438c05
WX
791 }
792 ret = get_str(buf, sizeof(buf), &p);
f5438c05 793 if (ret < 0) {
dcc70cdf 794 goto fail;
f5438c05 795 }
dcc70cdf
WX
796 args[nb_args] = g_strdup(buf);
797 nb_args++;
f5438c05
WX
798 }
799 *pnb_args = nb_args;
dcc70cdf
WX
800 return 0;
801
802 fail:
803 free_cmdline_args(args, nb_args);
804 return -1;
f5438c05
WX
805}
806
66855495
WX
807static void help_cmd_dump_one(Monitor *mon,
808 const mon_cmd_t *cmd,
809 char **prefix_args,
810 int prefix_args_nb)
811{
812 int i;
813
814 for (i = 0; i < prefix_args_nb; i++) {
815 monitor_printf(mon, "%s ", prefix_args[i]);
816 }
817 monitor_printf(mon, "%s %s -- %s\n", cmd->name, cmd->params, cmd->help);
818}
819
820/* @args[@arg_index] is the valid command need to find in @cmds */
c227f099 821static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
66855495 822 char **args, int nb_args, int arg_index)
9dc39cba 823{
c227f099 824 const mon_cmd_t *cmd;
9dc39cba 825
66855495
WX
826 /* No valid arg need to compare with, dump all in *cmds */
827 if (arg_index >= nb_args) {
828 for (cmd = cmds; cmd->name != NULL; cmd++) {
829 help_cmd_dump_one(mon, cmd, args, arg_index);
830 }
831 return;
832 }
833
834 /* Find one entry to dump */
835 for (cmd = cmds; cmd->name != NULL; cmd++) {
836 if (compare_cmd(args[arg_index], cmd->name)) {
837 if (cmd->sub_table) {
838 /* continue with next arg */
839 help_cmd_dump(mon, cmd->sub_table,
840 args, nb_args, arg_index + 1);
841 } else {
842 help_cmd_dump_one(mon, cmd, args, arg_index);
843 }
844 break;
845 }
9dc39cba
FB
846 }
847}
848
376253ec 849static void help_cmd(Monitor *mon, const char *name)
9dc39cba 850{
66855495
WX
851 char *args[MAX_ARGS];
852 int nb_args = 0;
853
854 /* 1. parse user input */
855 if (name) {
856 /* special case for log, directly dump and return */
857 if (!strcmp(name, "log")) {
38dad9e5 858 const QEMULogItem *item;
376253ec
AL
859 monitor_printf(mon, "Log items (comma separated):\n");
860 monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");
38dad9e5 861 for (item = qemu_log_items; item->mask != 0; item++) {
376253ec 862 monitor_printf(mon, "%-10s %s\n", item->name, item->help);
f193c797 863 }
66855495
WX
864 return;
865 }
866
867 if (parse_cmdline(name, &nb_args, args) < 0) {
868 return;
f193c797 869 }
9dc39cba 870 }
66855495
WX
871
872 /* 2. dump the contents according to parsed args */
873 help_cmd_dump(mon, mon->cmd_table, args, nb_args, 0);
874
875 free_cmdline_args(args, nb_args);
9dc39cba
FB
876}
877
d54908a5 878static void do_help_cmd(Monitor *mon, const QDict *qdict)
38183186 879{
d54908a5 880 help_cmd(mon, qdict_get_try_str(qdict, "name"));
38183186
LC
881}
882
3e5a50d6 883static void hmp_trace_event(Monitor *mon, const QDict *qdict)
22890ab5
PS
884{
885 const char *tp_name = qdict_get_str(qdict, "name");
886 bool new_state = qdict_get_bool(qdict, "option");
14101d02 887 Error *local_err = NULL;
f871d689 888
14101d02
LV
889 qmp_trace_event_set_state(tp_name, new_state, true, true, &local_err);
890 if (local_err) {
091e38b7 891 error_report_err(local_err);
f871d689 892 }
22890ab5 893}
c5ceb523 894
c45a8168 895#ifdef CONFIG_TRACE_SIMPLE
3e5a50d6 896static void hmp_trace_file(Monitor *mon, const QDict *qdict)
c5ceb523
SH
897{
898 const char *op = qdict_get_try_str(qdict, "op");
899 const char *arg = qdict_get_try_str(qdict, "arg");
900
901 if (!op) {
902 st_print_trace_file_status((FILE *)mon, &monitor_fprintf);
903 } else if (!strcmp(op, "on")) {
904 st_set_trace_file_enabled(true);
905 } else if (!strcmp(op, "off")) {
906 st_set_trace_file_enabled(false);
907 } else if (!strcmp(op, "flush")) {
908 st_flush_trace_buffer();
909 } else if (!strcmp(op, "set")) {
910 if (arg) {
911 st_set_trace_file(arg);
912 }
913 } else {
914 monitor_printf(mon, "unexpected argument \"%s\"\n", op);
915 help_cmd(mon, "trace-file");
916 }
917}
22890ab5
PS
918#endif
919
940cc30d
AL
920static void user_monitor_complete(void *opaque, QObject *ret_data)
921{
922 MonitorCompletionData *data = (MonitorCompletionData *)opaque;
923
924 if (ret_data) {
925 data->user_print(data->mon, ret_data);
926 }
927 monitor_resume(data->mon);
7267c094 928 g_free(data);
940cc30d
AL
929}
930
931static void qmp_monitor_complete(void *opaque, QObject *ret_data)
932{
933 monitor_protocol_emitter(opaque, ret_data);
934}
935
5af7bbae
LC
936static int qmp_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,
937 const QDict *params)
940cc30d 938{
5af7bbae 939 return cmd->mhandler.cmd_async(mon, params, qmp_monitor_complete, mon);
940cc30d
AL
940}
941
940cc30d
AL
942static void user_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,
943 const QDict *params)
944{
945 int ret;
946
7267c094 947 MonitorCompletionData *cb_data = g_malloc(sizeof(*cb_data));
940cc30d
AL
948 cb_data->mon = mon;
949 cb_data->user_print = cmd->user_print;
950 monitor_suspend(mon);
951 ret = cmd->mhandler.cmd_async(mon, params,
952 user_monitor_complete, cb_data);
953 if (ret < 0) {
954 monitor_resume(mon);
7267c094 955 g_free(cb_data);
940cc30d
AL
956 }
957}
958
3e5a50d6 959static void hmp_info_help(Monitor *mon, const QDict *qdict)
9dc39cba 960{
13c7425e 961 help_cmd(mon, "info");
9dc39cba
FB
962}
963
aa9b79bc 964CommandInfoList *qmp_query_commands(Error **errp)
e3bba9d0 965{
aa9b79bc 966 CommandInfoList *info, *cmd_list = NULL;
e3bba9d0
LC
967 const mon_cmd_t *cmd;
968
f36b4afb 969 for (cmd = qmp_cmds; cmd->name != NULL; cmd++) {
40e5a01d
LC
970 info = g_malloc0(sizeof(*info));
971 info->value = g_malloc0(sizeof(*info->value));
972 info->value->name = g_strdup(cmd->name);
e3bba9d0 973
aa9b79bc
LC
974 info->next = cmd_list;
975 cmd_list = info;
e3bba9d0
LC
976 }
977
aa9b79bc 978 return cmd_list;
a36e69dd
TS
979}
980
4860853d
DB
981EventInfoList *qmp_query_events(Error **errp)
982{
983 EventInfoList *info, *ev_list = NULL;
75175173 984 QAPIEvent e;
4860853d 985
75175173
WX
986 for (e = 0 ; e < QAPI_EVENT_MAX ; e++) {
987 const char *event_name = QAPIEvent_lookup[e];
4860853d
DB
988 assert(event_name != NULL);
989 info = g_malloc0(sizeof(*info));
990 info->value = g_malloc0(sizeof(*info->value));
991 info->value->name = g_strdup(event_name);
992
993 info->next = ev_list;
994 ev_list = info;
995 }
996
997 return ev_list;
998}
999
b025c8b4
LC
1000/* set the current CPU defined by the user */
1001int monitor_set_cpu(int cpu_index)
6a00d601 1002{
55e5c285 1003 CPUState *cpu;
6a00d601 1004
1c8bb3cc
AF
1005 cpu = qemu_get_cpu(cpu_index);
1006 if (cpu == NULL) {
1007 return -1;
6a00d601 1008 }
cb446eca 1009 cur_mon->mon_cpu = cpu;
1c8bb3cc 1010 return 0;
6a00d601
FB
1011}
1012
9349b4f9 1013static CPUArchState *mon_get_cpu(void)
6a00d601 1014{
731b0364 1015 if (!cur_mon->mon_cpu) {
b025c8b4 1016 monitor_set_cpu(0);
6a00d601 1017 }
4c0960c0 1018 cpu_synchronize_state(cur_mon->mon_cpu);
cb446eca 1019 return cur_mon->mon_cpu->env_ptr;
6a00d601
FB
1020}
1021
99b7796f
LC
1022int monitor_get_cpu_index(void)
1023{
55e5c285
AF
1024 CPUState *cpu = ENV_GET_CPU(mon_get_cpu());
1025 return cpu->cpu_index;
99b7796f
LC
1026}
1027
1ce6be24 1028static void hmp_info_registers(Monitor *mon, const QDict *qdict)
9307c4c1 1029{
878096ee 1030 CPUState *cpu;
9349b4f9 1031 CPUArchState *env;
6a00d601 1032 env = mon_get_cpu();
878096ee
AF
1033 cpu = ENV_GET_CPU(env);
1034 cpu_dump_state(cpu, (FILE *)mon, monitor_fprintf, CPU_DUMP_FPU);
9307c4c1
FB
1035}
1036
1ce6be24 1037static void hmp_info_jit(Monitor *mon, const QDict *qdict)
e3db7226 1038{
376253ec 1039 dump_exec_info((FILE *)mon, monitor_fprintf);
27498bef 1040 dump_drift_info((FILE *)mon, monitor_fprintf);
e3db7226
FB
1041}
1042
1ce6be24 1043static void hmp_info_opcount(Monitor *mon, const QDict *qdict)
246ae24d
MF
1044{
1045 dump_opcount_info((FILE *)mon, monitor_fprintf);
1046}
1047
1ce6be24 1048static void hmp_info_history(Monitor *mon, const QDict *qdict)
aa455485
FB
1049{
1050 int i;
7e2515e8 1051 const char *str;
3b46e624 1052
cde76ee1
AL
1053 if (!mon->rs)
1054 return;
7e2515e8
FB
1055 i = 0;
1056 for(;;) {
731b0364 1057 str = readline_get_history(mon->rs, i);
7e2515e8
FB
1058 if (!str)
1059 break;
376253ec 1060 monitor_printf(mon, "%d: '%s'\n", i, str);
8e3a9fd2 1061 i++;
aa455485
FB
1062 }
1063}
1064
1ce6be24 1065static void hmp_info_cpustats(Monitor *mon, const QDict *qdict)
76a66253 1066{
878096ee 1067 CPUState *cpu;
9349b4f9 1068 CPUArchState *env;
76a66253
JM
1069
1070 env = mon_get_cpu();
878096ee
AF
1071 cpu = ENV_GET_CPU(env);
1072 cpu_dump_statistics(cpu, (FILE *)mon, &monitor_fprintf, 0);
76a66253 1073}
76a66253 1074
1ce6be24 1075static void hmp_info_trace_events(Monitor *mon, const QDict *qdict)
22890ab5 1076{
14101d02
LV
1077 TraceEventInfoList *events = qmp_trace_event_get_state("*", NULL);
1078 TraceEventInfoList *elem;
1079
1080 for (elem = events; elem != NULL; elem = elem->next) {
1081 monitor_printf(mon, "%s : state %u\n",
1082 elem->value->name,
1083 elem->value->state == TRACE_EVENT_STATE_ENABLED ? 1 : 0);
1084 }
1085 qapi_free_TraceEventInfoList(events);
22890ab5 1086}
22890ab5 1087
edc5cb1a
YH
1088static int client_migrate_info(Monitor *mon, const QDict *qdict,
1089 MonitorCompletion cb, void *opaque)
e866e239
GH
1090{
1091 const char *protocol = qdict_get_str(qdict, "protocol");
1092 const char *hostname = qdict_get_str(qdict, "hostname");
1093 const char *subject = qdict_get_try_str(qdict, "cert-subject");
1094 int port = qdict_get_try_int(qdict, "port", -1);
1095 int tls_port = qdict_get_try_int(qdict, "tls-port", -1);
606ee8f5 1096 Error *err = NULL;
e866e239
GH
1097 int ret;
1098
1099 if (strcmp(protocol, "spice") == 0) {
b25d81ba
MA
1100 if (!qemu_using_spice(&err)) {
1101 qerror_report_err(err);
606ee8f5 1102 error_free(err);
e866e239
GH
1103 return -1;
1104 }
1105
6ec5dae5
YH
1106 if (port == -1 && tls_port == -1) {
1107 qerror_report(QERR_MISSING_PARAMETER, "port/tls-port");
1108 return -1;
1109 }
1110
edc5cb1a
YH
1111 ret = qemu_spice_migrate_info(hostname, port, tls_port, subject,
1112 cb, opaque);
e866e239
GH
1113 if (ret != 0) {
1114 qerror_report(QERR_UNDEFINED_ERROR);
1115 return -1;
1116 }
1117 return 0;
1118 }
1119
1120 qerror_report(QERR_INVALID_PARAMETER, "protocol");
1121 return -1;
1122}
1123
3e5a50d6 1124static void hmp_logfile(Monitor *mon, const QDict *qdict)
e735b91c 1125{
9a7e5424 1126 qemu_set_log_filename(qdict_get_str(qdict, "filename"));
e735b91c
PB
1127}
1128
3e5a50d6 1129static void hmp_log(Monitor *mon, const QDict *qdict)
f193c797
FB
1130{
1131 int mask;
d54908a5 1132 const char *items = qdict_get_str(qdict, "items");
3b46e624 1133
9307c4c1 1134 if (!strcmp(items, "none")) {
f193c797
FB
1135 mask = 0;
1136 } else {
4fde1eba 1137 mask = qemu_str_to_log_mask(items);
f193c797 1138 if (!mask) {
376253ec 1139 help_cmd(mon, "log");
f193c797
FB
1140 return;
1141 }
1142 }
24537a01 1143 qemu_set_log(mask);
f193c797
FB
1144}
1145
3e5a50d6 1146static void hmp_singlestep(Monitor *mon, const QDict *qdict)
1b530a6d 1147{
d54908a5 1148 const char *option = qdict_get_try_str(qdict, "option");
1b530a6d
AJ
1149 if (!option || !strcmp(option, "on")) {
1150 singlestep = 1;
1151 } else if (!strcmp(option, "off")) {
1152 singlestep = 0;
1153 } else {
1154 monitor_printf(mon, "unexpected option %s\n", option);
1155 }
1156}
1157
3e5a50d6 1158static void hmp_gdbserver(Monitor *mon, const QDict *qdict)
59030a8c 1159{
d54908a5 1160 const char *device = qdict_get_try_str(qdict, "device");
59030a8c
AL
1161 if (!device)
1162 device = "tcp::" DEFAULT_GDBSTUB_PORT;
1163 if (gdbserver_start(device) < 0) {
1164 monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
1165 device);
1166 } else if (strcmp(device, "none") == 0) {
36556b20 1167 monitor_printf(mon, "Disabled gdbserver\n");
8a7ddc38 1168 } else {
59030a8c
AL
1169 monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
1170 device);
8a7ddc38
FB
1171 }
1172}
1173
3e5a50d6 1174static void hmp_watchdog_action(Monitor *mon, const QDict *qdict)
9dd986cc 1175{
d54908a5 1176 const char *action = qdict_get_str(qdict, "action");
9dd986cc
RJ
1177 if (select_watchdog_action(action) == -1) {
1178 monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
1179 }
1180}
1181
376253ec 1182static void monitor_printc(Monitor *mon, int c)
9307c4c1 1183{
376253ec 1184 monitor_printf(mon, "'");
9307c4c1
FB
1185 switch(c) {
1186 case '\'':
376253ec 1187 monitor_printf(mon, "\\'");
9307c4c1
FB
1188 break;
1189 case '\\':
376253ec 1190 monitor_printf(mon, "\\\\");
9307c4c1
FB
1191 break;
1192 case '\n':
376253ec 1193 monitor_printf(mon, "\\n");
9307c4c1
FB
1194 break;
1195 case '\r':
376253ec 1196 monitor_printf(mon, "\\r");
9307c4c1
FB
1197 break;
1198 default:
1199 if (c >= 32 && c <= 126) {
376253ec 1200 monitor_printf(mon, "%c", c);
9307c4c1 1201 } else {
376253ec 1202 monitor_printf(mon, "\\x%02x", c);
9307c4c1
FB
1203 }
1204 break;
1205 }
376253ec 1206 monitor_printf(mon, "'");
9307c4c1
FB
1207}
1208
376253ec 1209static void memory_dump(Monitor *mon, int count, int format, int wsize,
a8170e5e 1210 hwaddr addr, int is_physical)
9307c4c1 1211{
9349b4f9 1212 CPUArchState *env;
23842aab 1213 int l, line_size, i, max_digits, len;
9307c4c1
FB
1214 uint8_t buf[16];
1215 uint64_t v;
1216
1217 if (format == 'i') {
1218 int flags;
1219 flags = 0;
6a00d601 1220 env = mon_get_cpu();
9307c4c1 1221#ifdef TARGET_I386
4c27ba27 1222 if (wsize == 2) {
9307c4c1 1223 flags = 1;
4c27ba27
FB
1224 } else if (wsize == 4) {
1225 flags = 0;
1226 } else {
6a15fd12 1227 /* as default we use the current CS size */
4c27ba27 1228 flags = 0;
6a15fd12
FB
1229 if (env) {
1230#ifdef TARGET_X86_64
5fafdf24 1231 if ((env->efer & MSR_EFER_LMA) &&
6a15fd12
FB
1232 (env->segs[R_CS].flags & DESC_L_MASK))
1233 flags = 2;
1234 else
1235#endif
1236 if (!(env->segs[R_CS].flags & DESC_B_MASK))
1237 flags = 1;
1238 }
4c27ba27 1239 }
1c38f843
TM
1240#endif
1241#ifdef TARGET_PPC
1242 flags = msr_le << 16;
1243 flags |= env->bfd_mach;
4c27ba27 1244#endif
376253ec 1245 monitor_disas(mon, env, addr, count, is_physical, flags);
9307c4c1
FB
1246 return;
1247 }
1248
1249 len = wsize * count;
1250 if (wsize == 1)
1251 line_size = 8;
1252 else
1253 line_size = 16;
9307c4c1
FB
1254 max_digits = 0;
1255
1256 switch(format) {
1257 case 'o':
1258 max_digits = (wsize * 8 + 2) / 3;
1259 break;
1260 default:
1261 case 'x':
1262 max_digits = (wsize * 8) / 4;
1263 break;
1264 case 'u':
1265 case 'd':
1266 max_digits = (wsize * 8 * 10 + 32) / 33;
1267 break;
1268 case 'c':
1269 wsize = 1;
1270 break;
1271 }
1272
1273 while (len > 0) {
7743e588 1274 if (is_physical)
376253ec 1275 monitor_printf(mon, TARGET_FMT_plx ":", addr);
7743e588 1276 else
376253ec 1277 monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
9307c4c1
FB
1278 l = len;
1279 if (l > line_size)
1280 l = line_size;
1281 if (is_physical) {
54f7b4a3 1282 cpu_physical_memory_read(addr, buf, l);
9307c4c1 1283 } else {
6a00d601 1284 env = mon_get_cpu();
f17ec444 1285 if (cpu_memory_rw_debug(ENV_GET_CPU(env), addr, buf, l, 0) < 0) {
376253ec 1286 monitor_printf(mon, " Cannot access memory\n");
c8f79b67
AL
1287 break;
1288 }
9307c4c1 1289 }
5fafdf24 1290 i = 0;
9307c4c1
FB
1291 while (i < l) {
1292 switch(wsize) {
1293 default:
1294 case 1:
24e60305 1295 v = ldub_p(buf + i);
9307c4c1
FB
1296 break;
1297 case 2:
24e60305 1298 v = lduw_p(buf + i);
9307c4c1
FB
1299 break;
1300 case 4:
24e60305 1301 v = (uint32_t)ldl_p(buf + i);
9307c4c1
FB
1302 break;
1303 case 8:
24e60305 1304 v = ldq_p(buf + i);
9307c4c1
FB
1305 break;
1306 }
376253ec 1307 monitor_printf(mon, " ");
9307c4c1
FB
1308 switch(format) {
1309 case 'o':
376253ec 1310 monitor_printf(mon, "%#*" PRIo64, max_digits, v);
9307c4c1
FB
1311 break;
1312 case 'x':
376253ec 1313 monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
9307c4c1
FB
1314 break;
1315 case 'u':
376253ec 1316 monitor_printf(mon, "%*" PRIu64, max_digits, v);
9307c4c1
FB
1317 break;
1318 case 'd':
376253ec 1319 monitor_printf(mon, "%*" PRId64, max_digits, v);
9307c4c1
FB
1320 break;
1321 case 'c':
376253ec 1322 monitor_printc(mon, v);
9307c4c1
FB
1323 break;
1324 }
1325 i += wsize;
1326 }
376253ec 1327 monitor_printf(mon, "\n");
9307c4c1
FB
1328 addr += l;
1329 len -= l;
1330 }
1331}
1332
3e5a50d6 1333static void hmp_memory_dump(Monitor *mon, const QDict *qdict)
9307c4c1 1334{
1bd1442e
LC
1335 int count = qdict_get_int(qdict, "count");
1336 int format = qdict_get_int(qdict, "format");
1337 int size = qdict_get_int(qdict, "size");
1338 target_long addr = qdict_get_int(qdict, "addr");
1339
376253ec 1340 memory_dump(mon, count, format, size, addr, 0);
9307c4c1
FB
1341}
1342
3e5a50d6 1343static void hmp_physical_memory_dump(Monitor *mon, const QDict *qdict)
9307c4c1 1344{
1bd1442e
LC
1345 int count = qdict_get_int(qdict, "count");
1346 int format = qdict_get_int(qdict, "format");
1347 int size = qdict_get_int(qdict, "size");
a8170e5e 1348 hwaddr addr = qdict_get_int(qdict, "addr");
1bd1442e 1349
376253ec 1350 memory_dump(mon, count, format, size, addr, 1);
9307c4c1
FB
1351}
1352
1bd1442e 1353static void do_print(Monitor *mon, const QDict *qdict)
9307c4c1 1354{
1bd1442e 1355 int format = qdict_get_int(qdict, "format");
a8170e5e 1356 hwaddr val = qdict_get_int(qdict, "val");
1bd1442e 1357
9307c4c1
FB
1358 switch(format) {
1359 case 'o':
a8170e5e 1360 monitor_printf(mon, "%#" HWADDR_PRIo, val);
9307c4c1
FB
1361 break;
1362 case 'x':
a8170e5e 1363 monitor_printf(mon, "%#" HWADDR_PRIx, val);
9307c4c1
FB
1364 break;
1365 case 'u':
a8170e5e 1366 monitor_printf(mon, "%" HWADDR_PRIu, val);
9307c4c1
FB
1367 break;
1368 default:
1369 case 'd':
a8170e5e 1370 monitor_printf(mon, "%" HWADDR_PRId, val);
9307c4c1
FB
1371 break;
1372 case 'c':
376253ec 1373 monitor_printc(mon, val);
9307c4c1
FB
1374 break;
1375 }
376253ec 1376 monitor_printf(mon, "\n");
9307c4c1
FB
1377}
1378
3e5a50d6 1379static void hmp_sum(Monitor *mon, const QDict *qdict)
e4cf1adc
FB
1380{
1381 uint32_t addr;
e4cf1adc 1382 uint16_t sum;
f18c16de
LC
1383 uint32_t start = qdict_get_int(qdict, "start");
1384 uint32_t size = qdict_get_int(qdict, "size");
e4cf1adc
FB
1385
1386 sum = 0;
1387 for(addr = start; addr < (start + size); addr++) {
2c17449b 1388 uint8_t val = ldub_phys(&address_space_memory, addr);
e4cf1adc
FB
1389 /* BSD sum algorithm ('sum' Unix command) */
1390 sum = (sum >> 1) | (sum << 15);
54f7b4a3 1391 sum += val;
e4cf1adc 1392 }
376253ec 1393 monitor_printf(mon, "%05d\n", sum);
e4cf1adc
FB
1394}
1395
13224a87
FB
1396static int mouse_button_state;
1397
3e5a50d6 1398static void hmp_mouse_move(Monitor *mon, const QDict *qdict)
13224a87 1399{
c751a74a 1400 int dx, dy, dz, button;
1d4daa91
LC
1401 const char *dx_str = qdict_get_str(qdict, "dx_str");
1402 const char *dy_str = qdict_get_str(qdict, "dy_str");
1403 const char *dz_str = qdict_get_try_str(qdict, "dz_str");
c751a74a 1404
13224a87
FB
1405 dx = strtol(dx_str, NULL, 0);
1406 dy = strtol(dy_str, NULL, 0);
c751a74a
GH
1407 qemu_input_queue_rel(NULL, INPUT_AXIS_X, dx);
1408 qemu_input_queue_rel(NULL, INPUT_AXIS_Y, dy);
1409
1410 if (dz_str) {
13224a87 1411 dz = strtol(dz_str, NULL, 0);
c751a74a
GH
1412 if (dz != 0) {
1413 button = (dz > 0) ? INPUT_BUTTON_WHEEL_UP : INPUT_BUTTON_WHEEL_DOWN;
1414 qemu_input_queue_btn(NULL, button, true);
1415 qemu_input_event_sync();
1416 qemu_input_queue_btn(NULL, button, false);
1417 }
1418 }
1419 qemu_input_event_sync();
13224a87
FB
1420}
1421
3e5a50d6 1422static void hmp_mouse_button(Monitor *mon, const QDict *qdict)
13224a87 1423{
c751a74a
GH
1424 static uint32_t bmap[INPUT_BUTTON_MAX] = {
1425 [INPUT_BUTTON_LEFT] = MOUSE_EVENT_LBUTTON,
1426 [INPUT_BUTTON_MIDDLE] = MOUSE_EVENT_MBUTTON,
1427 [INPUT_BUTTON_RIGHT] = MOUSE_EVENT_RBUTTON,
1428 };
d54908a5 1429 int button_state = qdict_get_int(qdict, "button_state");
c751a74a
GH
1430
1431 if (mouse_button_state == button_state) {
1432 return;
1433 }
1434 qemu_input_update_buttons(NULL, bmap, mouse_button_state, button_state);
1435 qemu_input_event_sync();
13224a87 1436 mouse_button_state = button_state;
13224a87
FB
1437}
1438
3e5a50d6 1439static void hmp_ioport_read(Monitor *mon, const QDict *qdict)
3440557b 1440{
aa93e39c
LC
1441 int size = qdict_get_int(qdict, "size");
1442 int addr = qdict_get_int(qdict, "addr");
1443 int has_index = qdict_haskey(qdict, "index");
3440557b
FB
1444 uint32_t val;
1445 int suffix;
1446
1447 if (has_index) {
aa93e39c 1448 int index = qdict_get_int(qdict, "index");
afcea8cb 1449 cpu_outb(addr & IOPORTS_MASK, index & 0xff);
3440557b
FB
1450 addr++;
1451 }
1452 addr &= 0xffff;
1453
1454 switch(size) {
1455 default:
1456 case 1:
afcea8cb 1457 val = cpu_inb(addr);
3440557b
FB
1458 suffix = 'b';
1459 break;
1460 case 2:
afcea8cb 1461 val = cpu_inw(addr);
3440557b
FB
1462 suffix = 'w';
1463 break;
1464 case 4:
afcea8cb 1465 val = cpu_inl(addr);
3440557b
FB
1466 suffix = 'l';
1467 break;
1468 }
376253ec
AL
1469 monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
1470 suffix, addr, size * 2, val);
3440557b 1471}
a3a91a35 1472
3e5a50d6 1473static void hmp_ioport_write(Monitor *mon, const QDict *qdict)
f114784f 1474{
1bd1442e
LC
1475 int size = qdict_get_int(qdict, "size");
1476 int addr = qdict_get_int(qdict, "addr");
1477 int val = qdict_get_int(qdict, "val");
1478
f114784f
JK
1479 addr &= IOPORTS_MASK;
1480
1481 switch (size) {
1482 default:
1483 case 1:
afcea8cb 1484 cpu_outb(addr, val);
f114784f
JK
1485 break;
1486 case 2:
afcea8cb 1487 cpu_outw(addr, val);
f114784f
JK
1488 break;
1489 case 4:
afcea8cb 1490 cpu_outl(addr, val);
f114784f
JK
1491 break;
1492 }
1493}
1494
3e5a50d6 1495static void hmp_boot_set(Monitor *mon, const QDict *qdict)
0ecdffbb 1496{
f1839938 1497 Error *local_err = NULL;
d54908a5 1498 const char *bootdevice = qdict_get_str(qdict, "bootdevice");
0ecdffbb 1499
f1839938
GA
1500 qemu_boot_set(bootdevice, &local_err);
1501 if (local_err) {
1502 monitor_printf(mon, "%s\n", error_get_pretty(local_err));
1503 error_free(local_err);
0ecdffbb 1504 } else {
f1839938 1505 monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
0ecdffbb
AJ
1506 }
1507}
1508
b86bda5b 1509#if defined(TARGET_I386)
a8170e5e
AK
1510static void print_pte(Monitor *mon, hwaddr addr,
1511 hwaddr pte,
1512 hwaddr mask)
b86bda5b 1513{
d65aaf37
BS
1514#ifdef TARGET_X86_64
1515 if (addr & (1ULL << 47)) {
1516 addr |= -1LL << 48;
1517 }
1518#endif
1519 monitor_printf(mon, TARGET_FMT_plx ": " TARGET_FMT_plx
1520 " %c%c%c%c%c%c%c%c%c\n",
376253ec
AL
1521 addr,
1522 pte & mask,
d65aaf37 1523 pte & PG_NX_MASK ? 'X' : '-',
376253ec
AL
1524 pte & PG_GLOBAL_MASK ? 'G' : '-',
1525 pte & PG_PSE_MASK ? 'P' : '-',
1526 pte & PG_DIRTY_MASK ? 'D' : '-',
1527 pte & PG_ACCESSED_MASK ? 'A' : '-',
1528 pte & PG_PCD_MASK ? 'C' : '-',
1529 pte & PG_PWT_MASK ? 'T' : '-',
1530 pte & PG_USER_MASK ? 'U' : '-',
1531 pte & PG_RW_MASK ? 'W' : '-');
b86bda5b
FB
1532}
1533
9349b4f9 1534static void tlb_info_32(Monitor *mon, CPUArchState *env)
b86bda5b 1535{
94ac5cd2 1536 unsigned int l1, l2;
b86bda5b
FB
1537 uint32_t pgd, pde, pte;
1538
b86bda5b
FB
1539 pgd = env->cr[3] & ~0xfff;
1540 for(l1 = 0; l1 < 1024; l1++) {
b8b79323 1541 cpu_physical_memory_read(pgd + l1 * 4, &pde, 4);
b86bda5b
FB
1542 pde = le32_to_cpu(pde);
1543 if (pde & PG_PRESENT_MASK) {
1544 if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
d65aaf37
BS
1545 /* 4M pages */
1546 print_pte(mon, (l1 << 22), pde, ~((1 << 21) - 1));
b86bda5b
FB
1547 } else {
1548 for(l2 = 0; l2 < 1024; l2++) {
b8b79323 1549 cpu_physical_memory_read((pde & ~0xfff) + l2 * 4, &pte, 4);
b86bda5b
FB
1550 pte = le32_to_cpu(pte);
1551 if (pte & PG_PRESENT_MASK) {
376253ec 1552 print_pte(mon, (l1 << 22) + (l2 << 12),
5fafdf24 1553 pte & ~PG_PSE_MASK,
b86bda5b
FB
1554 ~0xfff);
1555 }
1556 }
1557 }
1558 }
1559 }
1560}
1561
9349b4f9 1562static void tlb_info_pae32(Monitor *mon, CPUArchState *env)
d65aaf37 1563{
94ac5cd2 1564 unsigned int l1, l2, l3;
d65aaf37
BS
1565 uint64_t pdpe, pde, pte;
1566 uint64_t pdp_addr, pd_addr, pt_addr;
1567
1568 pdp_addr = env->cr[3] & ~0x1f;
1569 for (l1 = 0; l1 < 4; l1++) {
b8b79323 1570 cpu_physical_memory_read(pdp_addr + l1 * 8, &pdpe, 8);
d65aaf37
BS
1571 pdpe = le64_to_cpu(pdpe);
1572 if (pdpe & PG_PRESENT_MASK) {
1573 pd_addr = pdpe & 0x3fffffffff000ULL;
1574 for (l2 = 0; l2 < 512; l2++) {
b8b79323 1575 cpu_physical_memory_read(pd_addr + l2 * 8, &pde, 8);
d65aaf37
BS
1576 pde = le64_to_cpu(pde);
1577 if (pde & PG_PRESENT_MASK) {
1578 if (pde & PG_PSE_MASK) {
1579 /* 2M pages with PAE, CR4.PSE is ignored */
1580 print_pte(mon, (l1 << 30 ) + (l2 << 21), pde,
a8170e5e 1581 ~((hwaddr)(1 << 20) - 1));
d65aaf37
BS
1582 } else {
1583 pt_addr = pde & 0x3fffffffff000ULL;
1584 for (l3 = 0; l3 < 512; l3++) {
b8b79323 1585 cpu_physical_memory_read(pt_addr + l3 * 8, &pte, 8);
d65aaf37
BS
1586 pte = le64_to_cpu(pte);
1587 if (pte & PG_PRESENT_MASK) {
1588 print_pte(mon, (l1 << 30 ) + (l2 << 21)
1589 + (l3 << 12),
1590 pte & ~PG_PSE_MASK,
a8170e5e 1591 ~(hwaddr)0xfff);
d65aaf37
BS
1592 }
1593 }
1594 }
1595 }
1596 }
1597 }
1598 }
1599}
1600
1601#ifdef TARGET_X86_64
9349b4f9 1602static void tlb_info_64(Monitor *mon, CPUArchState *env)
d65aaf37
BS
1603{
1604 uint64_t l1, l2, l3, l4;
1605 uint64_t pml4e, pdpe, pde, pte;
1606 uint64_t pml4_addr, pdp_addr, pd_addr, pt_addr;
1607
1608 pml4_addr = env->cr[3] & 0x3fffffffff000ULL;
1609 for (l1 = 0; l1 < 512; l1++) {
b8b79323 1610 cpu_physical_memory_read(pml4_addr + l1 * 8, &pml4e, 8);
d65aaf37
BS
1611 pml4e = le64_to_cpu(pml4e);
1612 if (pml4e & PG_PRESENT_MASK) {
1613 pdp_addr = pml4e & 0x3fffffffff000ULL;
1614 for (l2 = 0; l2 < 512; l2++) {
b8b79323 1615 cpu_physical_memory_read(pdp_addr + l2 * 8, &pdpe, 8);
d65aaf37
BS
1616 pdpe = le64_to_cpu(pdpe);
1617 if (pdpe & PG_PRESENT_MASK) {
1618 if (pdpe & PG_PSE_MASK) {
1619 /* 1G pages, CR4.PSE is ignored */
1620 print_pte(mon, (l1 << 39) + (l2 << 30), pdpe,
1621 0x3ffffc0000000ULL);
1622 } else {
1623 pd_addr = pdpe & 0x3fffffffff000ULL;
1624 for (l3 = 0; l3 < 512; l3++) {
b8b79323 1625 cpu_physical_memory_read(pd_addr + l3 * 8, &pde, 8);
d65aaf37
BS
1626 pde = le64_to_cpu(pde);
1627 if (pde & PG_PRESENT_MASK) {
1628 if (pde & PG_PSE_MASK) {
1629 /* 2M pages, CR4.PSE is ignored */
1630 print_pte(mon, (l1 << 39) + (l2 << 30) +
1631 (l3 << 21), pde,
1632 0x3ffffffe00000ULL);
1633 } else {
1634 pt_addr = pde & 0x3fffffffff000ULL;
1635 for (l4 = 0; l4 < 512; l4++) {
1636 cpu_physical_memory_read(pt_addr
1637 + l4 * 8,
b8b79323 1638 &pte, 8);
d65aaf37
BS
1639 pte = le64_to_cpu(pte);
1640 if (pte & PG_PRESENT_MASK) {
1641 print_pte(mon, (l1 << 39) +
1642 (l2 << 30) +
1643 (l3 << 21) + (l4 << 12),
1644 pte & ~PG_PSE_MASK,
1645 0x3fffffffff000ULL);
1646 }
1647 }
1648 }
1649 }
1650 }
1651 }
1652 }
1653 }
1654 }
1655 }
1656}
1657#endif
1658
1ce6be24 1659static void hmp_info_tlb(Monitor *mon, const QDict *qdict)
d65aaf37 1660{
9349b4f9 1661 CPUArchState *env;
d65aaf37
BS
1662
1663 env = mon_get_cpu();
1664
1665 if (!(env->cr[0] & CR0_PG_MASK)) {
1666 monitor_printf(mon, "PG disabled\n");
1667 return;
1668 }
1669 if (env->cr[4] & CR4_PAE_MASK) {
1670#ifdef TARGET_X86_64
1671 if (env->hflags & HF_LMA_MASK) {
1672 tlb_info_64(mon, env);
1673 } else
1674#endif
1675 {
1676 tlb_info_pae32(mon, env);
1677 }
1678 } else {
1679 tlb_info_32(mon, env);
1680 }
1681}
1682
a8170e5e 1683static void mem_print(Monitor *mon, hwaddr *pstart,
1b3cba6e 1684 int *plast_prot,
a8170e5e 1685 hwaddr end, int prot)
b86bda5b 1686{
9746b15b
FB
1687 int prot1;
1688 prot1 = *plast_prot;
1689 if (prot != prot1) {
b86bda5b 1690 if (*pstart != -1) {
1b3cba6e
BS
1691 monitor_printf(mon, TARGET_FMT_plx "-" TARGET_FMT_plx " "
1692 TARGET_FMT_plx " %c%c%c\n",
376253ec
AL
1693 *pstart, end, end - *pstart,
1694 prot1 & PG_USER_MASK ? 'u' : '-',
1695 'r',
1696 prot1 & PG_RW_MASK ? 'w' : '-');
b86bda5b
FB
1697 }
1698 if (prot != 0)
1699 *pstart = end;
1700 else
1701 *pstart = -1;
1702 *plast_prot = prot;
1703 }
1704}
1705
9349b4f9 1706static void mem_info_32(Monitor *mon, CPUArchState *env)
b86bda5b 1707{
b49ca72d
AC
1708 unsigned int l1, l2;
1709 int prot, last_prot;
1b3cba6e 1710 uint32_t pgd, pde, pte;
a8170e5e 1711 hwaddr start, end;
6a00d601 1712
b86bda5b
FB
1713 pgd = env->cr[3] & ~0xfff;
1714 last_prot = 0;
1715 start = -1;
1716 for(l1 = 0; l1 < 1024; l1++) {
b8b79323 1717 cpu_physical_memory_read(pgd + l1 * 4, &pde, 4);
b86bda5b
FB
1718 pde = le32_to_cpu(pde);
1719 end = l1 << 22;
1720 if (pde & PG_PRESENT_MASK) {
1721 if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
1722 prot = pde & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
376253ec 1723 mem_print(mon, &start, &last_prot, end, prot);
b86bda5b
FB
1724 } else {
1725 for(l2 = 0; l2 < 1024; l2++) {
b8b79323 1726 cpu_physical_memory_read((pde & ~0xfff) + l2 * 4, &pte, 4);
b86bda5b
FB
1727 pte = le32_to_cpu(pte);
1728 end = (l1 << 22) + (l2 << 12);
1729 if (pte & PG_PRESENT_MASK) {
c76c8416
AC
1730 prot = pte & pde &
1731 (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
b86bda5b
FB
1732 } else {
1733 prot = 0;
1734 }
376253ec 1735 mem_print(mon, &start, &last_prot, end, prot);
b86bda5b
FB
1736 }
1737 }
1738 } else {
1739 prot = 0;
376253ec 1740 mem_print(mon, &start, &last_prot, end, prot);
b86bda5b
FB
1741 }
1742 }
8a94b8ca 1743 /* Flush last range */
a8170e5e 1744 mem_print(mon, &start, &last_prot, (hwaddr)1 << 32, 0);
b86bda5b 1745}
1b3cba6e 1746
9349b4f9 1747static void mem_info_pae32(Monitor *mon, CPUArchState *env)
1b3cba6e 1748{
b49ca72d
AC
1749 unsigned int l1, l2, l3;
1750 int prot, last_prot;
1b3cba6e
BS
1751 uint64_t pdpe, pde, pte;
1752 uint64_t pdp_addr, pd_addr, pt_addr;
a8170e5e 1753 hwaddr start, end;
1b3cba6e
BS
1754
1755 pdp_addr = env->cr[3] & ~0x1f;
1756 last_prot = 0;
1757 start = -1;
1758 for (l1 = 0; l1 < 4; l1++) {
b8b79323 1759 cpu_physical_memory_read(pdp_addr + l1 * 8, &pdpe, 8);
1b3cba6e
BS
1760 pdpe = le64_to_cpu(pdpe);
1761 end = l1 << 30;
1762 if (pdpe & PG_PRESENT_MASK) {
1763 pd_addr = pdpe & 0x3fffffffff000ULL;
1764 for (l2 = 0; l2 < 512; l2++) {
b8b79323 1765 cpu_physical_memory_read(pd_addr + l2 * 8, &pde, 8);
1b3cba6e
BS
1766 pde = le64_to_cpu(pde);
1767 end = (l1 << 30) + (l2 << 21);
1768 if (pde & PG_PRESENT_MASK) {
1769 if (pde & PG_PSE_MASK) {
1770 prot = pde & (PG_USER_MASK | PG_RW_MASK |
1771 PG_PRESENT_MASK);
1772 mem_print(mon, &start, &last_prot, end, prot);
1773 } else {
1774 pt_addr = pde & 0x3fffffffff000ULL;
1775 for (l3 = 0; l3 < 512; l3++) {
b8b79323 1776 cpu_physical_memory_read(pt_addr + l3 * 8, &pte, 8);
1b3cba6e
BS
1777 pte = le64_to_cpu(pte);
1778 end = (l1 << 30) + (l2 << 21) + (l3 << 12);
1779 if (pte & PG_PRESENT_MASK) {
c76c8416
AC
1780 prot = pte & pde & (PG_USER_MASK | PG_RW_MASK |
1781 PG_PRESENT_MASK);
1b3cba6e
BS
1782 } else {
1783 prot = 0;
1784 }
1785 mem_print(mon, &start, &last_prot, end, prot);
1786 }
1787 }
1788 } else {
1789 prot = 0;
1790 mem_print(mon, &start, &last_prot, end, prot);
1791 }
1792 }
1793 } else {
1794 prot = 0;
1795 mem_print(mon, &start, &last_prot, end, prot);
1796 }
1797 }
8a94b8ca 1798 /* Flush last range */
a8170e5e 1799 mem_print(mon, &start, &last_prot, (hwaddr)1 << 32, 0);
1b3cba6e
BS
1800}
1801
1802
1803#ifdef TARGET_X86_64
9349b4f9 1804static void mem_info_64(Monitor *mon, CPUArchState *env)
1b3cba6e
BS
1805{
1806 int prot, last_prot;
1807 uint64_t l1, l2, l3, l4;
1808 uint64_t pml4e, pdpe, pde, pte;
1809 uint64_t pml4_addr, pdp_addr, pd_addr, pt_addr, start, end;
1810
1811 pml4_addr = env->cr[3] & 0x3fffffffff000ULL;
1812 last_prot = 0;
1813 start = -1;
1814 for (l1 = 0; l1 < 512; l1++) {
b8b79323 1815 cpu_physical_memory_read(pml4_addr + l1 * 8, &pml4e, 8);
1b3cba6e
BS
1816 pml4e = le64_to_cpu(pml4e);
1817 end = l1 << 39;
1818 if (pml4e & PG_PRESENT_MASK) {
1819 pdp_addr = pml4e & 0x3fffffffff000ULL;
1820 for (l2 = 0; l2 < 512; l2++) {
b8b79323 1821 cpu_physical_memory_read(pdp_addr + l2 * 8, &pdpe, 8);
1b3cba6e
BS
1822 pdpe = le64_to_cpu(pdpe);
1823 end = (l1 << 39) + (l2 << 30);
1824 if (pdpe & PG_PRESENT_MASK) {
1825 if (pdpe & PG_PSE_MASK) {
2d5b5074
BS
1826 prot = pdpe & (PG_USER_MASK | PG_RW_MASK |
1827 PG_PRESENT_MASK);
c76c8416 1828 prot &= pml4e;
1b3cba6e
BS
1829 mem_print(mon, &start, &last_prot, end, prot);
1830 } else {
1831 pd_addr = pdpe & 0x3fffffffff000ULL;
1832 for (l3 = 0; l3 < 512; l3++) {
b8b79323 1833 cpu_physical_memory_read(pd_addr + l3 * 8, &pde, 8);
1b3cba6e
BS
1834 pde = le64_to_cpu(pde);
1835 end = (l1 << 39) + (l2 << 30) + (l3 << 21);
1836 if (pde & PG_PRESENT_MASK) {
1837 if (pde & PG_PSE_MASK) {
1838 prot = pde & (PG_USER_MASK | PG_RW_MASK |
1839 PG_PRESENT_MASK);
c76c8416 1840 prot &= pml4e & pdpe;
1b3cba6e
BS
1841 mem_print(mon, &start, &last_prot, end, prot);
1842 } else {
1843 pt_addr = pde & 0x3fffffffff000ULL;
1844 for (l4 = 0; l4 < 512; l4++) {
1845 cpu_physical_memory_read(pt_addr
1846 + l4 * 8,
b8b79323 1847 &pte, 8);
1b3cba6e
BS
1848 pte = le64_to_cpu(pte);
1849 end = (l1 << 39) + (l2 << 30) +
1850 (l3 << 21) + (l4 << 12);
1851 if (pte & PG_PRESENT_MASK) {
1852 prot = pte & (PG_USER_MASK | PG_RW_MASK |
1853 PG_PRESENT_MASK);
c76c8416 1854 prot &= pml4e & pdpe & pde;
1b3cba6e
BS
1855 } else {
1856 prot = 0;
1857 }
1858 mem_print(mon, &start, &last_prot, end, prot);
1859 }
1860 }
1861 } else {
1862 prot = 0;
1863 mem_print(mon, &start, &last_prot, end, prot);
1864 }
1865 }
1866 }
1867 } else {
1868 prot = 0;
1869 mem_print(mon, &start, &last_prot, end, prot);
1870 }
1871 }
1872 } else {
1873 prot = 0;
1874 mem_print(mon, &start, &last_prot, end, prot);
1875 }
1876 }
8a94b8ca 1877 /* Flush last range */
a8170e5e 1878 mem_print(mon, &start, &last_prot, (hwaddr)1 << 48, 0);
1b3cba6e
BS
1879}
1880#endif
1881
1ce6be24 1882static void hmp_info_mem(Monitor *mon, const QDict *qdict)
1b3cba6e 1883{
9349b4f9 1884 CPUArchState *env;
1b3cba6e
BS
1885
1886 env = mon_get_cpu();
1887
1888 if (!(env->cr[0] & CR0_PG_MASK)) {
1889 monitor_printf(mon, "PG disabled\n");
1890 return;
1891 }
1892 if (env->cr[4] & CR4_PAE_MASK) {
1893#ifdef TARGET_X86_64
1894 if (env->hflags & HF_LMA_MASK) {
1895 mem_info_64(mon, env);
1896 } else
1897#endif
1898 {
1899 mem_info_pae32(mon, env);
1900 }
1901 } else {
1902 mem_info_32(mon, env);
1903 }
1904}
b86bda5b
FB
1905#endif
1906
7c664e2f
AJ
1907#if defined(TARGET_SH4)
1908
376253ec 1909static void print_tlb(Monitor *mon, int idx, tlb_t *tlb)
7c664e2f 1910{
376253ec
AL
1911 monitor_printf(mon, " tlb%i:\t"
1912 "asid=%hhu vpn=%x\tppn=%x\tsz=%hhu size=%u\t"
1913 "v=%hhu shared=%hhu cached=%hhu prot=%hhu "
1914 "dirty=%hhu writethrough=%hhu\n",
1915 idx,
1916 tlb->asid, tlb->vpn, tlb->ppn, tlb->sz, tlb->size,
1917 tlb->v, tlb->sh, tlb->c, tlb->pr,
1918 tlb->d, tlb->wt);
7c664e2f
AJ
1919}
1920
1ce6be24 1921static void hmp_info_tlb(Monitor *mon, const QDict *qdict)
7c664e2f 1922{
9349b4f9 1923 CPUArchState *env = mon_get_cpu();
7c664e2f
AJ
1924 int i;
1925
376253ec 1926 monitor_printf (mon, "ITLB:\n");
7c664e2f 1927 for (i = 0 ; i < ITLB_SIZE ; i++)
376253ec
AL
1928 print_tlb (mon, i, &env->itlb[i]);
1929 monitor_printf (mon, "UTLB:\n");
7c664e2f 1930 for (i = 0 ; i < UTLB_SIZE ; i++)
376253ec 1931 print_tlb (mon, i, &env->utlb[i]);
7c664e2f
AJ
1932}
1933
1934#endif
1935
692f737c 1936#if defined(TARGET_SPARC) || defined(TARGET_PPC) || defined(TARGET_XTENSA)
1ce6be24 1937static void hmp_info_tlb(Monitor *mon, const QDict *qdict)
d41160a3 1938{
9349b4f9 1939 CPUArchState *env1 = mon_get_cpu();
d41160a3
BS
1940
1941 dump_mmu((FILE*)mon, (fprintf_function)monitor_printf, env1);
1942}
1943#endif
1944
1ce6be24 1945static void hmp_info_mtree(Monitor *mon, const QDict *qdict)
314e2987
BS
1946{
1947 mtree_info((fprintf_function)monitor_printf, mon);
1948}
1949
1ce6be24 1950static void hmp_info_numa(Monitor *mon, const QDict *qdict)
030ea37b 1951{
b28b6230 1952 int i;
1b1ed8dc 1953 CPUState *cpu;
5b009e40 1954 uint64_t *node_mem;
030ea37b 1955
5b009e40
HZ
1956 node_mem = g_new0(uint64_t, nb_numa_nodes);
1957 query_numa_node_mem(node_mem);
030ea37b
AL
1958 monitor_printf(mon, "%d nodes\n", nb_numa_nodes);
1959 for (i = 0; i < nb_numa_nodes; i++) {
1960 monitor_printf(mon, "node %d cpus:", i);
bdc44640 1961 CPU_FOREACH(cpu) {
1b1ed8dc 1962 if (cpu->numa_node == i) {
55e5c285 1963 monitor_printf(mon, " %d", cpu->cpu_index);
030ea37b
AL
1964 }
1965 }
1966 monitor_printf(mon, "\n");
1967 monitor_printf(mon, "node %d size: %" PRId64 " MB\n", i,
5b009e40 1968 node_mem[i] >> 20);
030ea37b 1969 }
5b009e40 1970 g_free(node_mem);
030ea37b
AL
1971}
1972
5f1ce948
FB
1973#ifdef CONFIG_PROFILER
1974
89d5cbdd 1975int64_t tcg_time;
e9a6625e
AJ
1976int64_t dev_time;
1977
1ce6be24 1978static void hmp_info_profile(Monitor *mon, const QDict *qdict)
5f1ce948 1979{
376253ec 1980 monitor_printf(mon, "async time %" PRId64 " (%0.3f)\n",
6ee093c9 1981 dev_time, dev_time / (double)get_ticks_per_sec());
376253ec 1982 monitor_printf(mon, "qemu time %" PRId64 " (%0.3f)\n",
89d5cbdd
AK
1983 tcg_time, tcg_time / (double)get_ticks_per_sec());
1984 tcg_time = 0;
5f1ce948 1985 dev_time = 0;
5f1ce948
FB
1986}
1987#else
1ce6be24 1988static void hmp_info_profile(Monitor *mon, const QDict *qdict)
5f1ce948 1989{
376253ec 1990 monitor_printf(mon, "Internal profiler not compiled\n");
5f1ce948
FB
1991}
1992#endif
1993
ec36b695 1994/* Capture support */
72cf2d4f 1995static QLIST_HEAD (capture_list_head, CaptureState) capture_head;
ec36b695 1996
1ce6be24 1997static void hmp_info_capture(Monitor *mon, const QDict *qdict)
ec36b695
FB
1998{
1999 int i;
2000 CaptureState *s;
2001
2002 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
376253ec 2003 monitor_printf(mon, "[%d]: ", i);
ec36b695
FB
2004 s->ops.info (s->opaque);
2005 }
2006}
2007
3e5a50d6 2008static void hmp_stopcapture(Monitor *mon, const QDict *qdict)
ec36b695
FB
2009{
2010 int i;
d54908a5 2011 int n = qdict_get_int(qdict, "n");
ec36b695
FB
2012 CaptureState *s;
2013
2014 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
2015 if (i == n) {
2016 s->ops.destroy (s->opaque);
72cf2d4f 2017 QLIST_REMOVE (s, entries);
7267c094 2018 g_free (s);
ec36b695
FB
2019 return;
2020 }
2021 }
2022}
2023
3e5a50d6 2024static void hmp_wavcapture(Monitor *mon, const QDict *qdict)
c1925484
LC
2025{
2026 const char *path = qdict_get_str(qdict, "path");
2027 int has_freq = qdict_haskey(qdict, "freq");
2028 int freq = qdict_get_try_int(qdict, "freq", -1);
2029 int has_bits = qdict_haskey(qdict, "bits");
2030 int bits = qdict_get_try_int(qdict, "bits", -1);
2031 int has_channels = qdict_haskey(qdict, "nchannels");
2032 int nchannels = qdict_get_try_int(qdict, "nchannels", -1);
ec36b695
FB
2033 CaptureState *s;
2034
7267c094 2035 s = g_malloc0 (sizeof (*s));
ec36b695
FB
2036
2037 freq = has_freq ? freq : 44100;
2038 bits = has_bits ? bits : 16;
2039 nchannels = has_channels ? nchannels : 2;
2040
2041 if (wav_start_capture (s, path, freq, bits, nchannels)) {
d00b2618 2042 monitor_printf(mon, "Failed to add wave capture\n");
7267c094 2043 g_free (s);
d00b2618 2044 return;
ec36b695 2045 }
72cf2d4f 2046 QLIST_INSERT_HEAD (&capture_head, s, entries);
ec36b695 2047}
ec36b695 2048
15dfcd45 2049static qemu_acl *find_acl(Monitor *mon, const char *name)
76655d6d 2050{
15dfcd45 2051 qemu_acl *acl = qemu_acl_find(name);
76655d6d 2052
76655d6d 2053 if (!acl) {
15dfcd45 2054 monitor_printf(mon, "acl: unknown list '%s'\n", name);
76655d6d 2055 }
15dfcd45
JK
2056 return acl;
2057}
2058
3e5a50d6 2059static void hmp_acl_show(Monitor *mon, const QDict *qdict)
15dfcd45 2060{
d54908a5 2061 const char *aclname = qdict_get_str(qdict, "aclname");
15dfcd45
JK
2062 qemu_acl *acl = find_acl(mon, aclname);
2063 qemu_acl_entry *entry;
2064 int i = 0;
76655d6d 2065
15dfcd45 2066 if (acl) {
28a76be8 2067 monitor_printf(mon, "policy: %s\n",
76655d6d 2068 acl->defaultDeny ? "deny" : "allow");
72cf2d4f 2069 QTAILQ_FOREACH(entry, &acl->entries, next) {
28a76be8
AL
2070 i++;
2071 monitor_printf(mon, "%d: %s %s\n", i,
15dfcd45 2072 entry->deny ? "deny" : "allow", entry->match);
28a76be8 2073 }
15dfcd45
JK
2074 }
2075}
2076
3e5a50d6 2077static void hmp_acl_reset(Monitor *mon, const QDict *qdict)
15dfcd45 2078{
d54908a5 2079 const char *aclname = qdict_get_str(qdict, "aclname");
15dfcd45
JK
2080 qemu_acl *acl = find_acl(mon, aclname);
2081
2082 if (acl) {
28a76be8
AL
2083 qemu_acl_reset(acl);
2084 monitor_printf(mon, "acl: removed all rules\n");
15dfcd45
JK
2085 }
2086}
2087
3e5a50d6 2088static void hmp_acl_policy(Monitor *mon, const QDict *qdict)
15dfcd45 2089{
f18c16de
LC
2090 const char *aclname = qdict_get_str(qdict, "aclname");
2091 const char *policy = qdict_get_str(qdict, "policy");
15dfcd45 2092 qemu_acl *acl = find_acl(mon, aclname);
28a76be8 2093
15dfcd45
JK
2094 if (acl) {
2095 if (strcmp(policy, "allow") == 0) {
28a76be8
AL
2096 acl->defaultDeny = 0;
2097 monitor_printf(mon, "acl: policy set to 'allow'\n");
15dfcd45 2098 } else if (strcmp(policy, "deny") == 0) {
28a76be8
AL
2099 acl->defaultDeny = 1;
2100 monitor_printf(mon, "acl: policy set to 'deny'\n");
2101 } else {
15dfcd45
JK
2102 monitor_printf(mon, "acl: unknown policy '%s', "
2103 "expected 'deny' or 'allow'\n", policy);
28a76be8 2104 }
15dfcd45
JK
2105 }
2106}
28a76be8 2107
3e5a50d6 2108static void hmp_acl_add(Monitor *mon, const QDict *qdict)
15dfcd45 2109{
1bd1442e
LC
2110 const char *aclname = qdict_get_str(qdict, "aclname");
2111 const char *match = qdict_get_str(qdict, "match");
2112 const char *policy = qdict_get_str(qdict, "policy");
2113 int has_index = qdict_haskey(qdict, "index");
2114 int index = qdict_get_try_int(qdict, "index", -1);
15dfcd45
JK
2115 qemu_acl *acl = find_acl(mon, aclname);
2116 int deny, ret;
2117
2118 if (acl) {
2119 if (strcmp(policy, "allow") == 0) {
2120 deny = 0;
2121 } else if (strcmp(policy, "deny") == 0) {
2122 deny = 1;
2123 } else {
2124 monitor_printf(mon, "acl: unknown policy '%s', "
2125 "expected 'deny' or 'allow'\n", policy);
28a76be8
AL
2126 return;
2127 }
28a76be8
AL
2128 if (has_index)
2129 ret = qemu_acl_insert(acl, deny, match, index);
2130 else
2131 ret = qemu_acl_append(acl, deny, match);
2132 if (ret < 0)
2133 monitor_printf(mon, "acl: unable to add acl entry\n");
2134 else
2135 monitor_printf(mon, "acl: added rule at position %d\n", ret);
15dfcd45
JK
2136 }
2137}
28a76be8 2138
3e5a50d6 2139static void hmp_acl_remove(Monitor *mon, const QDict *qdict)
15dfcd45 2140{
f18c16de
LC
2141 const char *aclname = qdict_get_str(qdict, "aclname");
2142 const char *match = qdict_get_str(qdict, "match");
15dfcd45
JK
2143 qemu_acl *acl = find_acl(mon, aclname);
2144 int ret;
28a76be8 2145
15dfcd45 2146 if (acl) {
28a76be8
AL
2147 ret = qemu_acl_remove(acl, match);
2148 if (ret < 0)
2149 monitor_printf(mon, "acl: no matching acl entry\n");
2150 else
2151 monitor_printf(mon, "acl: removed rule at position %d\n", ret);
76655d6d
AL
2152 }
2153}
2154
79c4f6b0 2155#if defined(TARGET_I386)
3e5a50d6 2156static void hmp_mce(Monitor *mon, const QDict *qdict)
79c4f6b0 2157{
8c5cf3b6 2158 X86CPU *cpu;
55e5c285 2159 CPUState *cs;
37b7ad48
LC
2160 int cpu_index = qdict_get_int(qdict, "cpu_index");
2161 int bank = qdict_get_int(qdict, "bank");
2162 uint64_t status = qdict_get_int(qdict, "status");
2163 uint64_t mcg_status = qdict_get_int(qdict, "mcg_status");
2164 uint64_t addr = qdict_get_int(qdict, "addr");
2165 uint64_t misc = qdict_get_int(qdict, "misc");
747461c7 2166 int flags = MCE_INJECT_UNCOND_AO;
79c4f6b0 2167
747461c7
JK
2168 if (qdict_get_try_bool(qdict, "broadcast", 0)) {
2169 flags |= MCE_INJECT_BROADCAST;
2170 }
c51a944b
AF
2171 cs = qemu_get_cpu(cpu_index);
2172 if (cs != NULL) {
2173 cpu = X86_CPU(cs);
2174 cpu_x86_inject_mce(mon, cpu, bank, status, mcg_status, addr, misc,
2175 flags);
31ce5e0c 2176 }
79c4f6b0
HY
2177}
2178#endif
2179
208c9d1b 2180void qmp_getfd(const char *fdname, Error **errp)
f07918fd 2181{
c227f099 2182 mon_fd_t *monfd;
f07918fd
MM
2183 int fd;
2184
208c9d1b 2185 fd = qemu_chr_fe_get_msgfd(cur_mon->chr);
f07918fd 2186 if (fd == -1) {
208c9d1b
CB
2187 error_set(errp, QERR_FD_NOT_SUPPLIED);
2188 return;
f07918fd
MM
2189 }
2190
2191 if (qemu_isdigit(fdname[0])) {
0b9f0e2f 2192 close(fd);
208c9d1b
CB
2193 error_set(errp, QERR_INVALID_PARAMETER_VALUE, "fdname",
2194 "a name not starting with a digit");
2195 return;
f07918fd
MM
2196 }
2197
208c9d1b 2198 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
f07918fd
MM
2199 if (strcmp(monfd->name, fdname) != 0) {
2200 continue;
2201 }
2202
2203 close(monfd->fd);
2204 monfd->fd = fd;
208c9d1b 2205 return;
f07918fd
MM
2206 }
2207
7267c094
AL
2208 monfd = g_malloc0(sizeof(mon_fd_t));
2209 monfd->name = g_strdup(fdname);
f07918fd
MM
2210 monfd->fd = fd;
2211
208c9d1b 2212 QLIST_INSERT_HEAD(&cur_mon->fds, monfd, next);
f07918fd
MM
2213}
2214
208c9d1b 2215void qmp_closefd(const char *fdname, Error **errp)
f07918fd 2216{
c227f099 2217 mon_fd_t *monfd;
f07918fd 2218
208c9d1b 2219 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
f07918fd
MM
2220 if (strcmp(monfd->name, fdname) != 0) {
2221 continue;
2222 }
2223
72cf2d4f 2224 QLIST_REMOVE(monfd, next);
f07918fd 2225 close(monfd->fd);
7267c094
AL
2226 g_free(monfd->name);
2227 g_free(monfd);
208c9d1b 2228 return;
f07918fd
MM
2229 }
2230
208c9d1b 2231 error_set(errp, QERR_FD_NOT_FOUND, fdname);
f07918fd
MM
2232}
2233
3e5a50d6 2234static void hmp_loadvm(Monitor *mon, const QDict *qdict)
c8d41b2c 2235{
1354869c 2236 int saved_vm_running = runstate_is_running();
d54908a5 2237 const char *name = qdict_get_str(qdict, "name");
c8d41b2c 2238
0461d5a6 2239 vm_stop(RUN_STATE_RESTORE_VM);
c8d41b2c 2240
f0aa7a8b 2241 if (load_vmstate(name) == 0 && saved_vm_running) {
c8d41b2c 2242 vm_start();
f0aa7a8b 2243 }
c8d41b2c
JQ
2244}
2245
a9940fc4 2246int monitor_get_fd(Monitor *mon, const char *fdname, Error **errp)
7768e04c 2247{
c227f099 2248 mon_fd_t *monfd;
7768e04c 2249
72cf2d4f 2250 QLIST_FOREACH(monfd, &mon->fds, next) {
7768e04c
MM
2251 int fd;
2252
2253 if (strcmp(monfd->name, fdname) != 0) {
2254 continue;
2255 }
2256
2257 fd = monfd->fd;
2258
2259 /* caller takes ownership of fd */
72cf2d4f 2260 QLIST_REMOVE(monfd, next);
7267c094
AL
2261 g_free(monfd->name);
2262 g_free(monfd);
7768e04c
MM
2263
2264 return fd;
2265 }
2266
a9940fc4 2267 error_setg(errp, "File descriptor named '%s' has not been found", fdname);
7768e04c
MM
2268 return -1;
2269}
2270
ba1c048a
CB
2271static void monitor_fdset_cleanup(MonFdset *mon_fdset)
2272{
2273 MonFdsetFd *mon_fdset_fd;
2274 MonFdsetFd *mon_fdset_fd_next;
2275
2276 QLIST_FOREACH_SAFE(mon_fdset_fd, &mon_fdset->fds, next, mon_fdset_fd_next) {
ebe52b59
CB
2277 if ((mon_fdset_fd->removed ||
2278 (QLIST_EMPTY(&mon_fdset->dup_fds) && mon_refcount == 0)) &&
2279 runstate_is_running()) {
ba1c048a
CB
2280 close(mon_fdset_fd->fd);
2281 g_free(mon_fdset_fd->opaque);
2282 QLIST_REMOVE(mon_fdset_fd, next);
2283 g_free(mon_fdset_fd);
2284 }
2285 }
2286
adb696f3 2287 if (QLIST_EMPTY(&mon_fdset->fds) && QLIST_EMPTY(&mon_fdset->dup_fds)) {
ba1c048a
CB
2288 QLIST_REMOVE(mon_fdset, next);
2289 g_free(mon_fdset);
2290 }
2291}
2292
efb87c16
CB
2293static void monitor_fdsets_cleanup(void)
2294{
2295 MonFdset *mon_fdset;
2296 MonFdset *mon_fdset_next;
2297
2298 QLIST_FOREACH_SAFE(mon_fdset, &mon_fdsets, next, mon_fdset_next) {
2299 monitor_fdset_cleanup(mon_fdset);
2300 }
2301}
2302
ba1c048a
CB
2303AddfdInfo *qmp_add_fd(bool has_fdset_id, int64_t fdset_id, bool has_opaque,
2304 const char *opaque, Error **errp)
2305{
2306 int fd;
2307 Monitor *mon = cur_mon;
ba1c048a
CB
2308 AddfdInfo *fdinfo;
2309
2310 fd = qemu_chr_fe_get_msgfd(mon->chr);
2311 if (fd == -1) {
2312 error_set(errp, QERR_FD_NOT_SUPPLIED);
2313 goto error;
2314 }
2315
e446f70d
CB
2316 fdinfo = monitor_fdset_add_fd(fd, has_fdset_id, fdset_id,
2317 has_opaque, opaque, errp);
2318 if (fdinfo) {
2319 return fdinfo;
ba1c048a 2320 }
ba1c048a
CB
2321
2322error:
2323 if (fd != -1) {
2324 close(fd);
2325 }
2326 return NULL;
2327}
2328
2329void qmp_remove_fd(int64_t fdset_id, bool has_fd, int64_t fd, Error **errp)
2330{
2331 MonFdset *mon_fdset;
2332 MonFdsetFd *mon_fdset_fd;
2333 char fd_str[60];
2334
2335 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2336 if (mon_fdset->id != fdset_id) {
2337 continue;
2338 }
2339 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2340 if (has_fd) {
2341 if (mon_fdset_fd->fd != fd) {
2342 continue;
2343 }
2344 mon_fdset_fd->removed = true;
2345 break;
2346 } else {
2347 mon_fdset_fd->removed = true;
2348 }
2349 }
2350 if (has_fd && !mon_fdset_fd) {
2351 goto error;
2352 }
2353 monitor_fdset_cleanup(mon_fdset);
2354 return;
2355 }
2356
2357error:
2358 if (has_fd) {
2359 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64 ", fd:%" PRId64,
2360 fdset_id, fd);
2361 } else {
2362 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64, fdset_id);
2363 }
2364 error_set(errp, QERR_FD_NOT_FOUND, fd_str);
2365}
2366
2367FdsetInfoList *qmp_query_fdsets(Error **errp)
2368{
2369 MonFdset *mon_fdset;
2370 MonFdsetFd *mon_fdset_fd;
2371 FdsetInfoList *fdset_list = NULL;
2372
2373 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2374 FdsetInfoList *fdset_info = g_malloc0(sizeof(*fdset_info));
2375 FdsetFdInfoList *fdsetfd_list = NULL;
2376
2377 fdset_info->value = g_malloc0(sizeof(*fdset_info->value));
2378 fdset_info->value->fdset_id = mon_fdset->id;
2379
2380 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2381 FdsetFdInfoList *fdsetfd_info;
2382
2383 fdsetfd_info = g_malloc0(sizeof(*fdsetfd_info));
2384 fdsetfd_info->value = g_malloc0(sizeof(*fdsetfd_info->value));
2385 fdsetfd_info->value->fd = mon_fdset_fd->fd;
2386 if (mon_fdset_fd->opaque) {
2387 fdsetfd_info->value->has_opaque = true;
2388 fdsetfd_info->value->opaque = g_strdup(mon_fdset_fd->opaque);
2389 } else {
2390 fdsetfd_info->value->has_opaque = false;
2391 }
2392
2393 fdsetfd_info->next = fdsetfd_list;
2394 fdsetfd_list = fdsetfd_info;
2395 }
2396
2397 fdset_info->value->fds = fdsetfd_list;
2398
2399 fdset_info->next = fdset_list;
2400 fdset_list = fdset_info;
2401 }
2402
2403 return fdset_list;
2404}
2405
e446f70d
CB
2406AddfdInfo *monitor_fdset_add_fd(int fd, bool has_fdset_id, int64_t fdset_id,
2407 bool has_opaque, const char *opaque,
2408 Error **errp)
2409{
2410 MonFdset *mon_fdset = NULL;
2411 MonFdsetFd *mon_fdset_fd;
2412 AddfdInfo *fdinfo;
2413
2414 if (has_fdset_id) {
2415 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2416 /* Break if match found or match impossible due to ordering by ID */
2417 if (fdset_id <= mon_fdset->id) {
2418 if (fdset_id < mon_fdset->id) {
2419 mon_fdset = NULL;
2420 }
2421 break;
2422 }
2423 }
2424 }
2425
2426 if (mon_fdset == NULL) {
2427 int64_t fdset_id_prev = -1;
2428 MonFdset *mon_fdset_cur = QLIST_FIRST(&mon_fdsets);
2429
2430 if (has_fdset_id) {
2431 if (fdset_id < 0) {
2432 error_set(errp, QERR_INVALID_PARAMETER_VALUE, "fdset-id",
2433 "a non-negative value");
2434 return NULL;
2435 }
2436 /* Use specified fdset ID */
2437 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2438 mon_fdset_cur = mon_fdset;
2439 if (fdset_id < mon_fdset_cur->id) {
2440 break;
2441 }
2442 }
2443 } else {
2444 /* Use first available fdset ID */
2445 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2446 mon_fdset_cur = mon_fdset;
2447 if (fdset_id_prev == mon_fdset_cur->id - 1) {
2448 fdset_id_prev = mon_fdset_cur->id;
2449 continue;
2450 }
2451 break;
2452 }
2453 }
2454
2455 mon_fdset = g_malloc0(sizeof(*mon_fdset));
2456 if (has_fdset_id) {
2457 mon_fdset->id = fdset_id;
2458 } else {
2459 mon_fdset->id = fdset_id_prev + 1;
2460 }
2461
2462 /* The fdset list is ordered by fdset ID */
2463 if (!mon_fdset_cur) {
2464 QLIST_INSERT_HEAD(&mon_fdsets, mon_fdset, next);
2465 } else if (mon_fdset->id < mon_fdset_cur->id) {
2466 QLIST_INSERT_BEFORE(mon_fdset_cur, mon_fdset, next);
2467 } else {
2468 QLIST_INSERT_AFTER(mon_fdset_cur, mon_fdset, next);
2469 }
2470 }
2471
2472 mon_fdset_fd = g_malloc0(sizeof(*mon_fdset_fd));
2473 mon_fdset_fd->fd = fd;
2474 mon_fdset_fd->removed = false;
2475 if (has_opaque) {
2476 mon_fdset_fd->opaque = g_strdup(opaque);
2477 }
2478 QLIST_INSERT_HEAD(&mon_fdset->fds, mon_fdset_fd, next);
2479
2480 fdinfo = g_malloc0(sizeof(*fdinfo));
2481 fdinfo->fdset_id = mon_fdset->id;
2482 fdinfo->fd = mon_fdset_fd->fd;
2483
2484 return fdinfo;
2485}
2486
adb696f3
CB
2487int monitor_fdset_get_fd(int64_t fdset_id, int flags)
2488{
b2dc64c3 2489#ifndef _WIN32
adb696f3
CB
2490 MonFdset *mon_fdset;
2491 MonFdsetFd *mon_fdset_fd;
2492 int mon_fd_flags;
2493
adb696f3
CB
2494 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2495 if (mon_fdset->id != fdset_id) {
2496 continue;
2497 }
2498 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2499 mon_fd_flags = fcntl(mon_fdset_fd->fd, F_GETFL);
2500 if (mon_fd_flags == -1) {
2501 return -1;
2502 }
2503
2504 if ((flags & O_ACCMODE) == (mon_fd_flags & O_ACCMODE)) {
2505 return mon_fdset_fd->fd;
2506 }
2507 }
2508 errno = EACCES;
2509 return -1;
2510 }
2511#endif
2512
2513 errno = ENOENT;
2514 return -1;
2515}
2516
2517int monitor_fdset_dup_fd_add(int64_t fdset_id, int dup_fd)
2518{
2519 MonFdset *mon_fdset;
2520 MonFdsetFd *mon_fdset_fd_dup;
2521
2522 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2523 if (mon_fdset->id != fdset_id) {
2524 continue;
2525 }
2526 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2527 if (mon_fdset_fd_dup->fd == dup_fd) {
2528 return -1;
2529 }
2530 }
2531 mon_fdset_fd_dup = g_malloc0(sizeof(*mon_fdset_fd_dup));
2532 mon_fdset_fd_dup->fd = dup_fd;
2533 QLIST_INSERT_HEAD(&mon_fdset->dup_fds, mon_fdset_fd_dup, next);
2534 return 0;
2535 }
2536 return -1;
2537}
2538
2539static int monitor_fdset_dup_fd_find_remove(int dup_fd, bool remove)
2540{
2541 MonFdset *mon_fdset;
2542 MonFdsetFd *mon_fdset_fd_dup;
2543
2544 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2545 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2546 if (mon_fdset_fd_dup->fd == dup_fd) {
2547 if (remove) {
2548 QLIST_REMOVE(mon_fdset_fd_dup, next);
2549 if (QLIST_EMPTY(&mon_fdset->dup_fds)) {
2550 monitor_fdset_cleanup(mon_fdset);
2551 }
b3dd1b8c
MT
2552 return -1;
2553 } else {
2554 return mon_fdset->id;
adb696f3 2555 }
adb696f3
CB
2556 }
2557 }
2558 }
2559 return -1;
2560}
2561
2562int monitor_fdset_dup_fd_find(int dup_fd)
2563{
2564 return monitor_fdset_dup_fd_find_remove(dup_fd, false);
2565}
2566
b3dd1b8c 2567void monitor_fdset_dup_fd_remove(int dup_fd)
adb696f3 2568{
b3dd1b8c 2569 monitor_fdset_dup_fd_find_remove(dup_fd, true);
adb696f3
CB
2570}
2571
1677f4c6 2572int monitor_fd_param(Monitor *mon, const char *fdname, Error **errp)
5906366e
LE
2573{
2574 int fd;
2575 Error *local_err = NULL;
a96ed02f 2576
5906366e 2577 if (!qemu_isdigit(fdname[0]) && mon) {
a9940fc4 2578 fd = monitor_get_fd(mon, fdname, &local_err);
5906366e
LE
2579 } else {
2580 fd = qemu_parse_fd(fdname);
a96ed02f 2581 if (fd == -1) {
5906366e
LE
2582 error_setg(&local_err, "Invalid file descriptor number '%s'",
2583 fdname);
a96ed02f 2584 }
5906366e
LE
2585 }
2586 if (local_err) {
2587 error_propagate(errp, local_err);
2588 assert(fd == -1);
a96ed02f 2589 } else {
5906366e 2590 assert(fd != -1);
a96ed02f
NB
2591 }
2592
2593 return fd;
2594}
2595
acd0a093 2596/* Please update hmp-commands.hx when adding or changing commands */
816f8925 2597static mon_cmd_t info_cmds[] = {
d7f9b689
LC
2598 {
2599 .name = "version",
2600 .args_type = "",
d7f9b689
LC
2601 .params = "",
2602 .help = "show the version of QEMU",
5f11cb00 2603 .mhandler.cmd = hmp_info_version,
d7f9b689
LC
2604 },
2605 {
2606 .name = "network",
2607 .args_type = "",
d7f9b689
LC
2608 .params = "",
2609 .help = "show the network state",
1ce6be24 2610 .mhandler.cmd = hmp_info_network,
d7f9b689
LC
2611 },
2612 {
2613 .name = "chardev",
2614 .args_type = "",
d7f9b689
LC
2615 .params = "",
2616 .help = "show the character devices",
5f11cb00 2617 .mhandler.cmd = hmp_info_chardev,
d7f9b689
LC
2618 },
2619 {
2620 .name = "block",
e6bb31ec
KW
2621 .args_type = "nodes:-n,verbose:-v,device:B?",
2622 .params = "[-n] [-v] [device]",
e73fe2b4 2623 .help = "show info of one block device or all block devices "
e6bb31ec 2624 "(-n: show named nodes; -v: show details)",
5f11cb00 2625 .mhandler.cmd = hmp_info_block,
d7f9b689
LC
2626 },
2627 {
2628 .name = "blockstats",
2629 .args_type = "",
d7f9b689
LC
2630 .params = "",
2631 .help = "show block device statistics",
5f11cb00 2632 .mhandler.cmd = hmp_info_blockstats,
d7f9b689 2633 },
fb5458cd
SH
2634 {
2635 .name = "block-jobs",
2636 .args_type = "",
2637 .params = "",
2638 .help = "show progress of ongoing block device operations",
5f11cb00 2639 .mhandler.cmd = hmp_info_block_jobs,
fb5458cd 2640 },
d7f9b689
LC
2641 {
2642 .name = "registers",
2643 .args_type = "",
d7f9b689
LC
2644 .params = "",
2645 .help = "show the cpu registers",
1ce6be24 2646 .mhandler.cmd = hmp_info_registers,
d7f9b689
LC
2647 },
2648 {
2649 .name = "cpus",
2650 .args_type = "",
d7f9b689
LC
2651 .params = "",
2652 .help = "show infos for each CPU",
5f11cb00 2653 .mhandler.cmd = hmp_info_cpus,
d7f9b689
LC
2654 },
2655 {
2656 .name = "history",
2657 .args_type = "",
d7f9b689
LC
2658 .params = "",
2659 .help = "show the command line history",
1ce6be24 2660 .mhandler.cmd = hmp_info_history,
d7f9b689 2661 },
661f1929
JK
2662#if defined(TARGET_I386) || defined(TARGET_PPC) || defined(TARGET_MIPS) || \
2663 defined(TARGET_LM32) || (defined(TARGET_SPARC) && !defined(TARGET_SPARC64))
d7f9b689
LC
2664 {
2665 .name = "irq",
2666 .args_type = "",
d7f9b689
LC
2667 .params = "",
2668 .help = "show the interrupts statistics (if available)",
661f1929 2669#ifdef TARGET_SPARC
1ce6be24 2670 .mhandler.cmd = sun4m_hmp_info_irq,
661f1929 2671#elif defined(TARGET_LM32)
1ce6be24 2672 .mhandler.cmd = lm32_hmp_info_irq,
661f1929 2673#else
1ce6be24 2674 .mhandler.cmd = hmp_info_irq,
661f1929 2675#endif
d7f9b689
LC
2676 },
2677 {
2678 .name = "pic",
2679 .args_type = "",
d7f9b689
LC
2680 .params = "",
2681 .help = "show i8259 (PIC) state",
661f1929 2682#ifdef TARGET_SPARC
1ce6be24 2683 .mhandler.cmd = sun4m_hmp_info_pic,
661f1929 2684#elif defined(TARGET_LM32)
1ce6be24 2685 .mhandler.cmd = lm32_hmp_info_pic,
661f1929 2686#else
1ce6be24 2687 .mhandler.cmd = hmp_info_pic,
661f1929 2688#endif
d7f9b689 2689 },
661f1929 2690#endif
d7f9b689
LC
2691 {
2692 .name = "pci",
2693 .args_type = "",
d7f9b689
LC
2694 .params = "",
2695 .help = "show PCI info",
5f11cb00 2696 .mhandler.cmd = hmp_info_pci,
d7f9b689 2697 },
bebabbc7 2698#if defined(TARGET_I386) || defined(TARGET_SH4) || defined(TARGET_SPARC) || \
692f737c 2699 defined(TARGET_PPC) || defined(TARGET_XTENSA)
d7f9b689
LC
2700 {
2701 .name = "tlb",
2702 .args_type = "",
d7f9b689
LC
2703 .params = "",
2704 .help = "show virtual to physical memory mappings",
1ce6be24 2705 .mhandler.cmd = hmp_info_tlb,
d7f9b689 2706 },
7c664e2f
AJ
2707#endif
2708#if defined(TARGET_I386)
d7f9b689
LC
2709 {
2710 .name = "mem",
2711 .args_type = "",
d7f9b689
LC
2712 .params = "",
2713 .help = "show the active virtual memory mappings",
1ce6be24 2714 .mhandler.cmd = hmp_info_mem,
d7f9b689 2715 },
b86bda5b 2716#endif
314e2987
BS
2717 {
2718 .name = "mtree",
2719 .args_type = "",
2720 .params = "",
2721 .help = "show memory tree",
1ce6be24 2722 .mhandler.cmd = hmp_info_mtree,
314e2987 2723 },
d7f9b689
LC
2724 {
2725 .name = "jit",
2726 .args_type = "",
d7f9b689
LC
2727 .params = "",
2728 .help = "show dynamic compiler info",
1ce6be24 2729 .mhandler.cmd = hmp_info_jit,
d7f9b689 2730 },
246ae24d
MF
2731 {
2732 .name = "opcount",
2733 .args_type = "",
2734 .params = "",
2735 .help = "show dynamic compiler opcode counters",
1ce6be24 2736 .mhandler.cmd = hmp_info_opcount,
246ae24d 2737 },
d7f9b689
LC
2738 {
2739 .name = "kvm",
2740 .args_type = "",
d7f9b689
LC
2741 .params = "",
2742 .help = "show KVM information",
5f11cb00 2743 .mhandler.cmd = hmp_info_kvm,
d7f9b689
LC
2744 },
2745 {
2746 .name = "numa",
2747 .args_type = "",
d7f9b689
LC
2748 .params = "",
2749 .help = "show NUMA information",
1ce6be24 2750 .mhandler.cmd = hmp_info_numa,
d7f9b689
LC
2751 },
2752 {
2753 .name = "usb",
2754 .args_type = "",
d7f9b689
LC
2755 .params = "",
2756 .help = "show guest USB devices",
1ce6be24 2757 .mhandler.cmd = hmp_info_usb,
d7f9b689
LC
2758 },
2759 {
2760 .name = "usbhost",
2761 .args_type = "",
d7f9b689
LC
2762 .params = "",
2763 .help = "show host USB devices",
1ce6be24 2764 .mhandler.cmd = hmp_info_usbhost,
d7f9b689
LC
2765 },
2766 {
2767 .name = "profile",
2768 .args_type = "",
d7f9b689
LC
2769 .params = "",
2770 .help = "show profiling information",
1ce6be24 2771 .mhandler.cmd = hmp_info_profile,
d7f9b689
LC
2772 },
2773 {
2774 .name = "capture",
2775 .args_type = "",
d7f9b689
LC
2776 .params = "",
2777 .help = "show capture information",
1ce6be24 2778 .mhandler.cmd = hmp_info_capture,
d7f9b689
LC
2779 },
2780 {
2781 .name = "snapshots",
2782 .args_type = "",
d7f9b689
LC
2783 .params = "",
2784 .help = "show the currently saved VM snapshots",
1ce6be24 2785 .mhandler.cmd = hmp_info_snapshots,
d7f9b689
LC
2786 },
2787 {
2788 .name = "status",
2789 .args_type = "",
d7f9b689
LC
2790 .params = "",
2791 .help = "show the current VM status (running|paused)",
5f11cb00 2792 .mhandler.cmd = hmp_info_status,
d7f9b689 2793 },
d7f9b689
LC
2794 {
2795 .name = "mice",
2796 .args_type = "",
d7f9b689
LC
2797 .params = "",
2798 .help = "show which guest mouse is receiving events",
5f11cb00 2799 .mhandler.cmd = hmp_info_mice,
d7f9b689
LC
2800 },
2801 {
2802 .name = "vnc",
2803 .args_type = "",
d7f9b689
LC
2804 .params = "",
2805 .help = "show the vnc server status",
5f11cb00 2806 .mhandler.cmd = hmp_info_vnc,
d7f9b689 2807 },
cb42a870
GH
2808#if defined(CONFIG_SPICE)
2809 {
2810 .name = "spice",
2811 .args_type = "",
2812 .params = "",
2813 .help = "show the spice server status",
5f11cb00 2814 .mhandler.cmd = hmp_info_spice,
cb42a870
GH
2815 },
2816#endif
d7f9b689
LC
2817 {
2818 .name = "name",
2819 .args_type = "",
d7f9b689
LC
2820 .params = "",
2821 .help = "show the current VM name",
5f11cb00 2822 .mhandler.cmd = hmp_info_name,
d7f9b689
LC
2823 },
2824 {
2825 .name = "uuid",
2826 .args_type = "",
d7f9b689
LC
2827 .params = "",
2828 .help = "show the current VM UUID",
5f11cb00 2829 .mhandler.cmd = hmp_info_uuid,
d7f9b689 2830 },
d7f9b689
LC
2831 {
2832 .name = "cpustats",
2833 .args_type = "",
d7f9b689
LC
2834 .params = "",
2835 .help = "show CPU statistics",
1ce6be24 2836 .mhandler.cmd = hmp_info_cpustats,
d7f9b689 2837 },
31a60e22 2838#if defined(CONFIG_SLIRP)
d7f9b689
LC
2839 {
2840 .name = "usernet",
2841 .args_type = "",
d7f9b689
LC
2842 .params = "",
2843 .help = "show user network stack connection states",
1ce6be24 2844 .mhandler.cmd = hmp_info_usernet,
d7f9b689 2845 },
31a60e22 2846#endif
d7f9b689
LC
2847 {
2848 .name = "migrate",
2849 .args_type = "",
d7f9b689
LC
2850 .params = "",
2851 .help = "show migration status",
5f11cb00 2852 .mhandler.cmd = hmp_info_migrate,
d7f9b689 2853 },
bbf6da32
OW
2854 {
2855 .name = "migrate_capabilities",
2856 .args_type = "",
2857 .params = "",
2858 .help = "show current migration capabilities",
5f11cb00 2859 .mhandler.cmd = hmp_info_migrate_capabilities,
bbf6da32 2860 },
9e1ba4cc
OW
2861 {
2862 .name = "migrate_cache_size",
2863 .args_type = "",
2864 .params = "",
2865 .help = "show current migration xbzrle cache size",
5f11cb00 2866 .mhandler.cmd = hmp_info_migrate_cache_size,
9e1ba4cc 2867 },
d7f9b689
LC
2868 {
2869 .name = "balloon",
2870 .args_type = "",
d7f9b689
LC
2871 .params = "",
2872 .help = "show balloon information",
5f11cb00 2873 .mhandler.cmd = hmp_info_balloon,
d7f9b689
LC
2874 },
2875 {
2876 .name = "qtree",
2877 .args_type = "",
d7f9b689
LC
2878 .params = "",
2879 .help = "show device tree",
1ce6be24 2880 .mhandler.cmd = hmp_info_qtree,
d7f9b689
LC
2881 },
2882 {
2883 .name = "qdm",
2884 .args_type = "",
d7f9b689
LC
2885 .params = "",
2886 .help = "show qdev device model list",
1ce6be24 2887 .mhandler.cmd = hmp_info_qdm,
d7f9b689 2888 },
a01ff75f
AF
2889 {
2890 .name = "qom-tree",
2891 .args_type = "path:s?",
2892 .params = "[path]",
2893 .help = "show QOM composition tree",
2894 .mhandler.cmd = hmp_info_qom_tree,
2895 },
d7f9b689
LC
2896 {
2897 .name = "roms",
2898 .args_type = "",
d7f9b689
LC
2899 .params = "",
2900 .help = "show roms",
1ce6be24 2901 .mhandler.cmd = hmp_info_roms,
d7f9b689 2902 },
22890ab5
PS
2903 {
2904 .name = "trace-events",
2905 .args_type = "",
2906 .params = "",
2907 .help = "show available trace-events & their state",
1ce6be24 2908 .mhandler.cmd = hmp_info_trace_events,
22890ab5 2909 },
d1a0cf73
SB
2910 {
2911 .name = "tpm",
2912 .args_type = "",
2913 .params = "",
2914 .help = "show the TPM device",
2915 .mhandler.cmd = hmp_info_tpm,
2916 },
eb1539b2
HT
2917 {
2918 .name = "memdev",
2919 .args_type = "",
2920 .params = "",
8f4e5ac3 2921 .help = "show memory backends",
eb1539b2
HT
2922 .mhandler.cmd = hmp_info_memdev,
2923 },
a631892f
ZG
2924 {
2925 .name = "memory-devices",
2926 .args_type = "",
2927 .params = "",
2928 .help = "show memory devices",
2929 .mhandler.cmd = hmp_info_memory_devices,
2930 },
d7f9b689
LC
2931 {
2932 .name = NULL,
2933 },
9dc39cba
FB
2934};
2935
a13ced59
WX
2936/* mon_cmds and info_cmds would be sorted at runtime */
2937static mon_cmd_t mon_cmds[] = {
2938#include "hmp-commands.h"
2939 { NULL, NULL, },
2940};
2941
f36b4afb 2942static const mon_cmd_t qmp_cmds[] = {
e3193601 2943#include "qmp-commands-old.h"
f36b4afb
LC
2944 { /* NULL */ },
2945};
2946
9307c4c1
FB
2947/*******************************************************************/
2948
2949static const char *pch;
6ab7e546 2950static sigjmp_buf expr_env;
9307c4c1 2951
92a31b1f
FB
2952#define MD_TLONG 0
2953#define MD_I32 1
2954
9307c4c1
FB
2955typedef struct MonitorDef {
2956 const char *name;
2957 int offset;
8662d656 2958 target_long (*get_value)(const struct MonitorDef *md, int val);
92a31b1f 2959 int type;
9307c4c1
FB
2960} MonitorDef;
2961
57206fd4 2962#if defined(TARGET_I386)
8662d656 2963static target_long monitor_get_pc (const struct MonitorDef *md, int val)
57206fd4 2964{
9349b4f9 2965 CPUArchState *env = mon_get_cpu();
6a00d601 2966 return env->eip + env->segs[R_CS].base;
57206fd4
FB
2967}
2968#endif
2969
a541f297 2970#if defined(TARGET_PPC)
8662d656 2971static target_long monitor_get_ccr (const struct MonitorDef *md, int val)
a541f297 2972{
9349b4f9 2973 CPUArchState *env = mon_get_cpu();
a541f297
FB
2974 unsigned int u;
2975 int i;
2976
2977 u = 0;
2978 for (i = 0; i < 8; i++)
d2981180 2979 u |= env->crf[i] << (32 - (4 * (i + 1)));
a541f297
FB
2980
2981 return u;
2982}
2983
8662d656 2984static target_long monitor_get_msr (const struct MonitorDef *md, int val)
a541f297 2985{
9349b4f9 2986 CPUArchState *env = mon_get_cpu();
0411a972 2987 return env->msr;
a541f297
FB
2988}
2989
8662d656 2990static target_long monitor_get_xer (const struct MonitorDef *md, int val)
a541f297 2991{
9349b4f9 2992 CPUArchState *env = mon_get_cpu();
3d7b417e 2993 return env->xer;
a541f297 2994}
9fddaa0c 2995
8662d656 2996static target_long monitor_get_decr (const struct MonitorDef *md, int val)
9fddaa0c 2997{
9349b4f9 2998 CPUArchState *env = mon_get_cpu();
6a00d601 2999 return cpu_ppc_load_decr(env);
9fddaa0c
FB
3000}
3001
8662d656 3002static target_long monitor_get_tbu (const struct MonitorDef *md, int val)
9fddaa0c 3003{
9349b4f9 3004 CPUArchState *env = mon_get_cpu();
6a00d601 3005 return cpu_ppc_load_tbu(env);
9fddaa0c
FB
3006}
3007
8662d656 3008static target_long monitor_get_tbl (const struct MonitorDef *md, int val)
9fddaa0c 3009{
9349b4f9 3010 CPUArchState *env = mon_get_cpu();
6a00d601 3011 return cpu_ppc_load_tbl(env);
9fddaa0c 3012}
a541f297
FB
3013#endif
3014
e95c8d51 3015#if defined(TARGET_SPARC)
7b936c0c 3016#ifndef TARGET_SPARC64
8662d656 3017static target_long monitor_get_psr (const struct MonitorDef *md, int val)
e95c8d51 3018{
9349b4f9 3019 CPUArchState *env = mon_get_cpu();
5a834bb4
BS
3020
3021 return cpu_get_psr(env);
e95c8d51 3022}
7b936c0c 3023#endif
e95c8d51 3024
8662d656 3025static target_long monitor_get_reg(const struct MonitorDef *md, int val)
e95c8d51 3026{
9349b4f9 3027 CPUArchState *env = mon_get_cpu();
6a00d601 3028 return env->regwptr[val];
e95c8d51
FB
3029}
3030#endif
3031
8662d656 3032static const MonitorDef monitor_defs[] = {
9307c4c1 3033#ifdef TARGET_I386
57206fd4
FB
3034
3035#define SEG(name, seg) \
e59d167f
AF
3036 { name, offsetof(CPUX86State, segs[seg].selector), NULL, MD_I32 },\
3037 { name ".base", offsetof(CPUX86State, segs[seg].base) },\
3038 { name ".limit", offsetof(CPUX86State, segs[seg].limit), NULL, MD_I32 },
3039
3040 { "eax", offsetof(CPUX86State, regs[0]) },
3041 { "ecx", offsetof(CPUX86State, regs[1]) },
3042 { "edx", offsetof(CPUX86State, regs[2]) },
3043 { "ebx", offsetof(CPUX86State, regs[3]) },
3044 { "esp|sp", offsetof(CPUX86State, regs[4]) },
3045 { "ebp|fp", offsetof(CPUX86State, regs[5]) },
3046 { "esi", offsetof(CPUX86State, regs[6]) },
3047 { "edi", offsetof(CPUX86State, regs[7]) },
92a31b1f 3048#ifdef TARGET_X86_64
e59d167f
AF
3049 { "r8", offsetof(CPUX86State, regs[8]) },
3050 { "r9", offsetof(CPUX86State, regs[9]) },
3051 { "r10", offsetof(CPUX86State, regs[10]) },
3052 { "r11", offsetof(CPUX86State, regs[11]) },
3053 { "r12", offsetof(CPUX86State, regs[12]) },
3054 { "r13", offsetof(CPUX86State, regs[13]) },
3055 { "r14", offsetof(CPUX86State, regs[14]) },
3056 { "r15", offsetof(CPUX86State, regs[15]) },
92a31b1f 3057#endif
e59d167f
AF
3058 { "eflags", offsetof(CPUX86State, eflags) },
3059 { "eip", offsetof(CPUX86State, eip) },
57206fd4
FB
3060 SEG("cs", R_CS)
3061 SEG("ds", R_DS)
3062 SEG("es", R_ES)
01038d2a 3063 SEG("ss", R_SS)
57206fd4
FB
3064 SEG("fs", R_FS)
3065 SEG("gs", R_GS)
3066 { "pc", 0, monitor_get_pc, },
a541f297 3067#elif defined(TARGET_PPC)
ff937dba 3068 /* General purpose registers */
e59d167f
AF
3069 { "r0", offsetof(CPUPPCState, gpr[0]) },
3070 { "r1", offsetof(CPUPPCState, gpr[1]) },
3071 { "r2", offsetof(CPUPPCState, gpr[2]) },
3072 { "r3", offsetof(CPUPPCState, gpr[3]) },
3073 { "r4", offsetof(CPUPPCState, gpr[4]) },
3074 { "r5", offsetof(CPUPPCState, gpr[5]) },
3075 { "r6", offsetof(CPUPPCState, gpr[6]) },
3076 { "r7", offsetof(CPUPPCState, gpr[7]) },
3077 { "r8", offsetof(CPUPPCState, gpr[8]) },
3078 { "r9", offsetof(CPUPPCState, gpr[9]) },
3079 { "r10", offsetof(CPUPPCState, gpr[10]) },
3080 { "r11", offsetof(CPUPPCState, gpr[11]) },
3081 { "r12", offsetof(CPUPPCState, gpr[12]) },
3082 { "r13", offsetof(CPUPPCState, gpr[13]) },
3083 { "r14", offsetof(CPUPPCState, gpr[14]) },
3084 { "r15", offsetof(CPUPPCState, gpr[15]) },
3085 { "r16", offsetof(CPUPPCState, gpr[16]) },
3086 { "r17", offsetof(CPUPPCState, gpr[17]) },
3087 { "r18", offsetof(CPUPPCState, gpr[18]) },
3088 { "r19", offsetof(CPUPPCState, gpr[19]) },
3089 { "r20", offsetof(CPUPPCState, gpr[20]) },
3090 { "r21", offsetof(CPUPPCState, gpr[21]) },
3091 { "r22", offsetof(CPUPPCState, gpr[22]) },
3092 { "r23", offsetof(CPUPPCState, gpr[23]) },
3093 { "r24", offsetof(CPUPPCState, gpr[24]) },
3094 { "r25", offsetof(CPUPPCState, gpr[25]) },
3095 { "r26", offsetof(CPUPPCState, gpr[26]) },
3096 { "r27", offsetof(CPUPPCState, gpr[27]) },
3097 { "r28", offsetof(CPUPPCState, gpr[28]) },
3098 { "r29", offsetof(CPUPPCState, gpr[29]) },
3099 { "r30", offsetof(CPUPPCState, gpr[30]) },
3100 { "r31", offsetof(CPUPPCState, gpr[31]) },
ff937dba 3101 /* Floating point registers */
e59d167f
AF
3102 { "f0", offsetof(CPUPPCState, fpr[0]) },
3103 { "f1", offsetof(CPUPPCState, fpr[1]) },
3104 { "f2", offsetof(CPUPPCState, fpr[2]) },
3105 { "f3", offsetof(CPUPPCState, fpr[3]) },
3106 { "f4", offsetof(CPUPPCState, fpr[4]) },
3107 { "f5", offsetof(CPUPPCState, fpr[5]) },
3108 { "f6", offsetof(CPUPPCState, fpr[6]) },
3109 { "f7", offsetof(CPUPPCState, fpr[7]) },
3110 { "f8", offsetof(CPUPPCState, fpr[8]) },
3111 { "f9", offsetof(CPUPPCState, fpr[9]) },
3112 { "f10", offsetof(CPUPPCState, fpr[10]) },
3113 { "f11", offsetof(CPUPPCState, fpr[11]) },
3114 { "f12", offsetof(CPUPPCState, fpr[12]) },
3115 { "f13", offsetof(CPUPPCState, fpr[13]) },
3116 { "f14", offsetof(CPUPPCState, fpr[14]) },
3117 { "f15", offsetof(CPUPPCState, fpr[15]) },
3118 { "f16", offsetof(CPUPPCState, fpr[16]) },
3119 { "f17", offsetof(CPUPPCState, fpr[17]) },
3120 { "f18", offsetof(CPUPPCState, fpr[18]) },
3121 { "f19", offsetof(CPUPPCState, fpr[19]) },
3122 { "f20", offsetof(CPUPPCState, fpr[20]) },
3123 { "f21", offsetof(CPUPPCState, fpr[21]) },
3124 { "f22", offsetof(CPUPPCState, fpr[22]) },
3125 { "f23", offsetof(CPUPPCState, fpr[23]) },
3126 { "f24", offsetof(CPUPPCState, fpr[24]) },
3127 { "f25", offsetof(CPUPPCState, fpr[25]) },
3128 { "f26", offsetof(CPUPPCState, fpr[26]) },
3129 { "f27", offsetof(CPUPPCState, fpr[27]) },
3130 { "f28", offsetof(CPUPPCState, fpr[28]) },
3131 { "f29", offsetof(CPUPPCState, fpr[29]) },
3132 { "f30", offsetof(CPUPPCState, fpr[30]) },
3133 { "f31", offsetof(CPUPPCState, fpr[31]) },
3134 { "fpscr", offsetof(CPUPPCState, fpscr) },
ff937dba 3135 /* Next instruction pointer */
e59d167f
AF
3136 { "nip|pc", offsetof(CPUPPCState, nip) },
3137 { "lr", offsetof(CPUPPCState, lr) },
3138 { "ctr", offsetof(CPUPPCState, ctr) },
9fddaa0c 3139 { "decr", 0, &monitor_get_decr, },
a541f297 3140 { "ccr", 0, &monitor_get_ccr, },
ff937dba 3141 /* Machine state register */
a541f297
FB
3142 { "msr", 0, &monitor_get_msr, },
3143 { "xer", 0, &monitor_get_xer, },
9fddaa0c
FB
3144 { "tbu", 0, &monitor_get_tbu, },
3145 { "tbl", 0, &monitor_get_tbl, },
ff937dba 3146 /* Segment registers */
e59d167f
AF
3147 { "sdr1", offsetof(CPUPPCState, spr[SPR_SDR1]) },
3148 { "sr0", offsetof(CPUPPCState, sr[0]) },
3149 { "sr1", offsetof(CPUPPCState, sr[1]) },
3150 { "sr2", offsetof(CPUPPCState, sr[2]) },
3151 { "sr3", offsetof(CPUPPCState, sr[3]) },
3152 { "sr4", offsetof(CPUPPCState, sr[4]) },
3153 { "sr5", offsetof(CPUPPCState, sr[5]) },
3154 { "sr6", offsetof(CPUPPCState, sr[6]) },
3155 { "sr7", offsetof(CPUPPCState, sr[7]) },
3156 { "sr8", offsetof(CPUPPCState, sr[8]) },
3157 { "sr9", offsetof(CPUPPCState, sr[9]) },
3158 { "sr10", offsetof(CPUPPCState, sr[10]) },
3159 { "sr11", offsetof(CPUPPCState, sr[11]) },
3160 { "sr12", offsetof(CPUPPCState, sr[12]) },
3161 { "sr13", offsetof(CPUPPCState, sr[13]) },
3162 { "sr14", offsetof(CPUPPCState, sr[14]) },
3163 { "sr15", offsetof(CPUPPCState, sr[15]) },
90dc8812 3164 /* Too lazy to put BATs... */
e59d167f
AF
3165 { "pvr", offsetof(CPUPPCState, spr[SPR_PVR]) },
3166
3167 { "srr0", offsetof(CPUPPCState, spr[SPR_SRR0]) },
3168 { "srr1", offsetof(CPUPPCState, spr[SPR_SRR1]) },
04f1f784
TM
3169 { "dar", offsetof(CPUPPCState, spr[SPR_DAR]) },
3170 { "dsisr", offsetof(CPUPPCState, spr[SPR_DSISR]) },
3171 { "cfar", offsetof(CPUPPCState, spr[SPR_CFAR]) },
e59d167f
AF
3172 { "sprg0", offsetof(CPUPPCState, spr[SPR_SPRG0]) },
3173 { "sprg1", offsetof(CPUPPCState, spr[SPR_SPRG1]) },
3174 { "sprg2", offsetof(CPUPPCState, spr[SPR_SPRG2]) },
3175 { "sprg3", offsetof(CPUPPCState, spr[SPR_SPRG3]) },
3176 { "sprg4", offsetof(CPUPPCState, spr[SPR_SPRG4]) },
3177 { "sprg5", offsetof(CPUPPCState, spr[SPR_SPRG5]) },
3178 { "sprg6", offsetof(CPUPPCState, spr[SPR_SPRG6]) },
3179 { "sprg7", offsetof(CPUPPCState, spr[SPR_SPRG7]) },
3180 { "pid", offsetof(CPUPPCState, spr[SPR_BOOKE_PID]) },
3181 { "csrr0", offsetof(CPUPPCState, spr[SPR_BOOKE_CSRR0]) },
3182 { "csrr1", offsetof(CPUPPCState, spr[SPR_BOOKE_CSRR1]) },
3183 { "esr", offsetof(CPUPPCState, spr[SPR_BOOKE_ESR]) },
3184 { "dear", offsetof(CPUPPCState, spr[SPR_BOOKE_DEAR]) },
3185 { "mcsr", offsetof(CPUPPCState, spr[SPR_BOOKE_MCSR]) },
3186 { "tsr", offsetof(CPUPPCState, spr[SPR_BOOKE_TSR]) },
3187 { "tcr", offsetof(CPUPPCState, spr[SPR_BOOKE_TCR]) },
3188 { "vrsave", offsetof(CPUPPCState, spr[SPR_VRSAVE]) },
3189 { "pir", offsetof(CPUPPCState, spr[SPR_BOOKE_PIR]) },
3190 { "mcsrr0", offsetof(CPUPPCState, spr[SPR_BOOKE_MCSRR0]) },
3191 { "mcsrr1", offsetof(CPUPPCState, spr[SPR_BOOKE_MCSRR1]) },
3192 { "decar", offsetof(CPUPPCState, spr[SPR_BOOKE_DECAR]) },
3193 { "ivpr", offsetof(CPUPPCState, spr[SPR_BOOKE_IVPR]) },
3194 { "epcr", offsetof(CPUPPCState, spr[SPR_BOOKE_EPCR]) },
3195 { "sprg8", offsetof(CPUPPCState, spr[SPR_BOOKE_SPRG8]) },
3196 { "ivor0", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR0]) },
3197 { "ivor1", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR1]) },
3198 { "ivor2", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR2]) },
3199 { "ivor3", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR3]) },
3200 { "ivor4", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR4]) },
3201 { "ivor5", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR5]) },
3202 { "ivor6", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR6]) },
3203 { "ivor7", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR7]) },
3204 { "ivor8", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR8]) },
3205 { "ivor9", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR9]) },
3206 { "ivor10", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR10]) },
3207 { "ivor11", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR11]) },
3208 { "ivor12", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR12]) },
3209 { "ivor13", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR13]) },
3210 { "ivor14", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR14]) },
3211 { "ivor15", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR15]) },
3212 { "ivor32", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR32]) },
3213 { "ivor33", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR33]) },
3214 { "ivor34", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR34]) },
3215 { "ivor35", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR35]) },
3216 { "ivor36", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR36]) },
3217 { "ivor37", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR37]) },
3218 { "mas0", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS0]) },
3219 { "mas1", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS1]) },
3220 { "mas2", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS2]) },
3221 { "mas3", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS3]) },
3222 { "mas4", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS4]) },
3223 { "mas6", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS6]) },
3224 { "mas7", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS7]) },
3225 { "mmucfg", offsetof(CPUPPCState, spr[SPR_MMUCFG]) },
3226 { "tlb0cfg", offsetof(CPUPPCState, spr[SPR_BOOKE_TLB0CFG]) },
3227 { "tlb1cfg", offsetof(CPUPPCState, spr[SPR_BOOKE_TLB1CFG]) },
3228 { "epr", offsetof(CPUPPCState, spr[SPR_BOOKE_EPR]) },
3229 { "eplc", offsetof(CPUPPCState, spr[SPR_BOOKE_EPLC]) },
3230 { "epsc", offsetof(CPUPPCState, spr[SPR_BOOKE_EPSC]) },
3231 { "svr", offsetof(CPUPPCState, spr[SPR_E500_SVR]) },
3232 { "mcar", offsetof(CPUPPCState, spr[SPR_Exxx_MCAR]) },
3233 { "pid1", offsetof(CPUPPCState, spr[SPR_BOOKE_PID1]) },
3234 { "pid2", offsetof(CPUPPCState, spr[SPR_BOOKE_PID2]) },
3235 { "hid0", offsetof(CPUPPCState, spr[SPR_HID0]) },
90dc8812 3236
e95c8d51 3237#elif defined(TARGET_SPARC)
e59d167f
AF
3238 { "g0", offsetof(CPUSPARCState, gregs[0]) },
3239 { "g1", offsetof(CPUSPARCState, gregs[1]) },
3240 { "g2", offsetof(CPUSPARCState, gregs[2]) },
3241 { "g3", offsetof(CPUSPARCState, gregs[3]) },
3242 { "g4", offsetof(CPUSPARCState, gregs[4]) },
3243 { "g5", offsetof(CPUSPARCState, gregs[5]) },
3244 { "g6", offsetof(CPUSPARCState, gregs[6]) },
3245 { "g7", offsetof(CPUSPARCState, gregs[7]) },
e95c8d51
FB
3246 { "o0", 0, monitor_get_reg },
3247 { "o1", 1, monitor_get_reg },
3248 { "o2", 2, monitor_get_reg },
3249 { "o3", 3, monitor_get_reg },
3250 { "o4", 4, monitor_get_reg },
3251 { "o5", 5, monitor_get_reg },
3252 { "o6", 6, monitor_get_reg },
3253 { "o7", 7, monitor_get_reg },
3254 { "l0", 8, monitor_get_reg },
3255 { "l1", 9, monitor_get_reg },
3256 { "l2", 10, monitor_get_reg },
3257 { "l3", 11, monitor_get_reg },
3258 { "l4", 12, monitor_get_reg },
3259 { "l5", 13, monitor_get_reg },
3260 { "l6", 14, monitor_get_reg },
3261 { "l7", 15, monitor_get_reg },
3262 { "i0", 16, monitor_get_reg },
3263 { "i1", 17, monitor_get_reg },
3264 { "i2", 18, monitor_get_reg },
3265 { "i3", 19, monitor_get_reg },
3266 { "i4", 20, monitor_get_reg },
3267 { "i5", 21, monitor_get_reg },
3268 { "i6", 22, monitor_get_reg },
3269 { "i7", 23, monitor_get_reg },
e59d167f
AF
3270 { "pc", offsetof(CPUSPARCState, pc) },
3271 { "npc", offsetof(CPUSPARCState, npc) },
3272 { "y", offsetof(CPUSPARCState, y) },
7b936c0c 3273#ifndef TARGET_SPARC64
e95c8d51 3274 { "psr", 0, &monitor_get_psr, },
e59d167f 3275 { "wim", offsetof(CPUSPARCState, wim) },
7b936c0c 3276#endif
e59d167f
AF
3277 { "tbr", offsetof(CPUSPARCState, tbr) },
3278 { "fsr", offsetof(CPUSPARCState, fsr) },
3279 { "f0", offsetof(CPUSPARCState, fpr[0].l.upper) },
3280 { "f1", offsetof(CPUSPARCState, fpr[0].l.lower) },
3281 { "f2", offsetof(CPUSPARCState, fpr[1].l.upper) },
3282 { "f3", offsetof(CPUSPARCState, fpr[1].l.lower) },
3283 { "f4", offsetof(CPUSPARCState, fpr[2].l.upper) },
3284 { "f5", offsetof(CPUSPARCState, fpr[2].l.lower) },
3285 { "f6", offsetof(CPUSPARCState, fpr[3].l.upper) },
3286 { "f7", offsetof(CPUSPARCState, fpr[3].l.lower) },
3287 { "f8", offsetof(CPUSPARCState, fpr[4].l.upper) },
3288 { "f9", offsetof(CPUSPARCState, fpr[4].l.lower) },
3289 { "f10", offsetof(CPUSPARCState, fpr[5].l.upper) },
3290 { "f11", offsetof(CPUSPARCState, fpr[5].l.lower) },
3291 { "f12", offsetof(CPUSPARCState, fpr[6].l.upper) },
3292 { "f13", offsetof(CPUSPARCState, fpr[6].l.lower) },
3293 { "f14", offsetof(CPUSPARCState, fpr[7].l.upper) },
3294 { "f15", offsetof(CPUSPARCState, fpr[7].l.lower) },
3295 { "f16", offsetof(CPUSPARCState, fpr[8].l.upper) },
3296 { "f17", offsetof(CPUSPARCState, fpr[8].l.lower) },
3297 { "f18", offsetof(CPUSPARCState, fpr[9].l.upper) },
3298 { "f19", offsetof(CPUSPARCState, fpr[9].l.lower) },
3299 { "f20", offsetof(CPUSPARCState, fpr[10].l.upper) },
3300 { "f21", offsetof(CPUSPARCState, fpr[10].l.lower) },
3301 { "f22", offsetof(CPUSPARCState, fpr[11].l.upper) },
3302 { "f23", offsetof(CPUSPARCState, fpr[11].l.lower) },
3303 { "f24", offsetof(CPUSPARCState, fpr[12].l.upper) },
3304 { "f25", offsetof(CPUSPARCState, fpr[12].l.lower) },
3305 { "f26", offsetof(CPUSPARCState, fpr[13].l.upper) },
3306 { "f27", offsetof(CPUSPARCState, fpr[13].l.lower) },
3307 { "f28", offsetof(CPUSPARCState, fpr[14].l.upper) },
3308 { "f29", offsetof(CPUSPARCState, fpr[14].l.lower) },
3309 { "f30", offsetof(CPUSPARCState, fpr[15].l.upper) },
3310 { "f31", offsetof(CPUSPARCState, fpr[15].l.lower) },
7b936c0c 3311#ifdef TARGET_SPARC64
e59d167f
AF
3312 { "f32", offsetof(CPUSPARCState, fpr[16]) },
3313 { "f34", offsetof(CPUSPARCState, fpr[17]) },
3314 { "f36", offsetof(CPUSPARCState, fpr[18]) },
3315 { "f38", offsetof(CPUSPARCState, fpr[19]) },
3316 { "f40", offsetof(CPUSPARCState, fpr[20]) },
3317 { "f42", offsetof(CPUSPARCState, fpr[21]) },
3318 { "f44", offsetof(CPUSPARCState, fpr[22]) },
3319 { "f46", offsetof(CPUSPARCState, fpr[23]) },
3320 { "f48", offsetof(CPUSPARCState, fpr[24]) },
3321 { "f50", offsetof(CPUSPARCState, fpr[25]) },
3322 { "f52", offsetof(CPUSPARCState, fpr[26]) },
3323 { "f54", offsetof(CPUSPARCState, fpr[27]) },
3324 { "f56", offsetof(CPUSPARCState, fpr[28]) },
3325 { "f58", offsetof(CPUSPARCState, fpr[29]) },
3326 { "f60", offsetof(CPUSPARCState, fpr[30]) },
3327 { "f62", offsetof(CPUSPARCState, fpr[31]) },
3328 { "asi", offsetof(CPUSPARCState, asi) },
3329 { "pstate", offsetof(CPUSPARCState, pstate) },
3330 { "cansave", offsetof(CPUSPARCState, cansave) },
3331 { "canrestore", offsetof(CPUSPARCState, canrestore) },
3332 { "otherwin", offsetof(CPUSPARCState, otherwin) },
3333 { "wstate", offsetof(CPUSPARCState, wstate) },
3334 { "cleanwin", offsetof(CPUSPARCState, cleanwin) },
3335 { "fprs", offsetof(CPUSPARCState, fprs) },
7b936c0c 3336#endif
9307c4c1
FB
3337#endif
3338 { NULL },
3339};
3340
9c3175cc
SW
3341static void GCC_FMT_ATTR(2, 3) QEMU_NORETURN
3342expr_error(Monitor *mon, const char *fmt, ...)
9dc39cba 3343{
277acfe8
FZ
3344 va_list ap;
3345 va_start(ap, fmt);
3346 monitor_vprintf(mon, fmt, ap);
3347 monitor_printf(mon, "\n");
3348 va_end(ap);
6ab7e546 3349 siglongjmp(expr_env, 1);
9307c4c1
FB
3350}
3351
09b9418c 3352/* return 0 if OK, -1 if not found */
92a31b1f 3353static int get_monitor_def(target_long *pval, const char *name)
9307c4c1 3354{
8662d656 3355 const MonitorDef *md;
92a31b1f
FB
3356 void *ptr;
3357
9307c4c1
FB
3358 for(md = monitor_defs; md->name != NULL; md++) {
3359 if (compare_cmd(name, md->name)) {
3360 if (md->get_value) {
e95c8d51 3361 *pval = md->get_value(md, md->offset);
9307c4c1 3362 } else {
9349b4f9 3363 CPUArchState *env = mon_get_cpu();
6a00d601 3364 ptr = (uint8_t *)env + md->offset;
92a31b1f
FB
3365 switch(md->type) {
3366 case MD_I32:
3367 *pval = *(int32_t *)ptr;
3368 break;
3369 case MD_TLONG:
3370 *pval = *(target_long *)ptr;
3371 break;
3372 default:
3373 *pval = 0;
3374 break;
3375 }
9307c4c1
FB
3376 }
3377 return 0;
3378 }
3379 }
3380 return -1;
3381}
3382
3383static void next(void)
3384{
660f11be 3385 if (*pch != '\0') {
9307c4c1 3386 pch++;
cd390083 3387 while (qemu_isspace(*pch))
9307c4c1
FB
3388 pch++;
3389 }
3390}
3391
376253ec 3392static int64_t expr_sum(Monitor *mon);
9307c4c1 3393
376253ec 3394static int64_t expr_unary(Monitor *mon)
9307c4c1 3395{
c2efc95d 3396 int64_t n;
9307c4c1 3397 char *p;
6a00d601 3398 int ret;
9307c4c1
FB
3399
3400 switch(*pch) {
3401 case '+':
3402 next();
376253ec 3403 n = expr_unary(mon);
9307c4c1
FB
3404 break;
3405 case '-':
3406 next();
376253ec 3407 n = -expr_unary(mon);
9307c4c1
FB
3408 break;
3409 case '~':
3410 next();
376253ec 3411 n = ~expr_unary(mon);
9307c4c1
FB
3412 break;
3413 case '(':
3414 next();
376253ec 3415 n = expr_sum(mon);
9307c4c1 3416 if (*pch != ')') {
376253ec 3417 expr_error(mon, "')' expected");
9307c4c1
FB
3418 }
3419 next();
3420 break;
81d0912d
FB
3421 case '\'':
3422 pch++;
3423 if (*pch == '\0')
376253ec 3424 expr_error(mon, "character constant expected");
81d0912d
FB
3425 n = *pch;
3426 pch++;
3427 if (*pch != '\'')
376253ec 3428 expr_error(mon, "missing terminating \' character");
81d0912d
FB
3429 next();
3430 break;
9307c4c1
FB
3431 case '$':
3432 {
3433 char buf[128], *q;
69b34976 3434 target_long reg=0;
3b46e624 3435
9307c4c1
FB
3436 pch++;
3437 q = buf;
3438 while ((*pch >= 'a' && *pch <= 'z') ||
3439 (*pch >= 'A' && *pch <= 'Z') ||
3440 (*pch >= '0' && *pch <= '9') ||
57206fd4 3441 *pch == '_' || *pch == '.') {
9307c4c1
FB
3442 if ((q - buf) < sizeof(buf) - 1)
3443 *q++ = *pch;
3444 pch++;
3445 }
cd390083 3446 while (qemu_isspace(*pch))
9307c4c1
FB
3447 pch++;
3448 *q = 0;
7743e588 3449 ret = get_monitor_def(&reg, buf);
09b9418c 3450 if (ret < 0)
376253ec 3451 expr_error(mon, "unknown register");
7743e588 3452 n = reg;
9307c4c1
FB
3453 }
3454 break;
3455 case '\0':
376253ec 3456 expr_error(mon, "unexpected end of expression");
9307c4c1
FB
3457 n = 0;
3458 break;
3459 default:
6b0e33be 3460 errno = 0;
4f4fbf77 3461 n = strtoull(pch, &p, 0);
6b0e33be
LC
3462 if (errno == ERANGE) {
3463 expr_error(mon, "number too large");
3464 }
9307c4c1 3465 if (pch == p) {
277acfe8 3466 expr_error(mon, "invalid char '%c' in expression", *p);
9307c4c1
FB
3467 }
3468 pch = p;
cd390083 3469 while (qemu_isspace(*pch))
9307c4c1
FB
3470 pch++;
3471 break;
3472 }
3473 return n;
3474}
3475
3476
376253ec 3477static int64_t expr_prod(Monitor *mon)
9307c4c1 3478{
c2efc95d 3479 int64_t val, val2;
92a31b1f 3480 int op;
3b46e624 3481
376253ec 3482 val = expr_unary(mon);
9307c4c1
FB
3483 for(;;) {
3484 op = *pch;
3485 if (op != '*' && op != '/' && op != '%')
3486 break;
3487 next();
376253ec 3488 val2 = expr_unary(mon);
9307c4c1
FB
3489 switch(op) {
3490 default:
3491 case '*':
3492 val *= val2;
3493 break;
3494 case '/':
3495 case '%':
5fafdf24 3496 if (val2 == 0)
376253ec 3497 expr_error(mon, "division by zero");
9307c4c1
FB
3498 if (op == '/')
3499 val /= val2;
3500 else
3501 val %= val2;
3502 break;
3503 }
3504 }
3505 return val;
3506}
3507
376253ec 3508static int64_t expr_logic(Monitor *mon)
9307c4c1 3509{
c2efc95d 3510 int64_t val, val2;
92a31b1f 3511 int op;
9307c4c1 3512
376253ec 3513 val = expr_prod(mon);
9307c4c1
FB
3514 for(;;) {
3515 op = *pch;
3516 if (op != '&' && op != '|' && op != '^')
3517 break;
3518 next();
376253ec 3519 val2 = expr_prod(mon);
9307c4c1
FB
3520 switch(op) {
3521 default:
3522 case '&':
3523 val &= val2;
3524 break;
3525 case '|':
3526 val |= val2;
3527 break;
3528 case '^':
3529 val ^= val2;
3530 break;
3531 }
3532 }
3533 return val;
3534}
3535
376253ec 3536static int64_t expr_sum(Monitor *mon)
9307c4c1 3537{
c2efc95d 3538 int64_t val, val2;
92a31b1f 3539 int op;
9307c4c1 3540
376253ec 3541 val = expr_logic(mon);
9307c4c1
FB
3542 for(;;) {
3543 op = *pch;
3544 if (op != '+' && op != '-')
3545 break;
3546 next();
376253ec 3547 val2 = expr_logic(mon);
9307c4c1
FB
3548 if (op == '+')
3549 val += val2;
3550 else
3551 val -= val2;
3552 }
3553 return val;
3554}
3555
376253ec 3556static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
9307c4c1
FB
3557{
3558 pch = *pp;
6ab7e546 3559 if (sigsetjmp(expr_env, 0)) {
9307c4c1
FB
3560 *pp = pch;
3561 return -1;
3562 }
cd390083 3563 while (qemu_isspace(*pch))
9307c4c1 3564 pch++;
376253ec 3565 *pval = expr_sum(mon);
9307c4c1
FB
3566 *pp = pch;
3567 return 0;
3568}
3569
3350a4dd
MA
3570static int get_double(Monitor *mon, double *pval, const char **pp)
3571{
3572 const char *p = *pp;
3573 char *tailp;
3574 double d;
3575
3576 d = strtod(p, &tailp);
3577 if (tailp == p) {
3578 monitor_printf(mon, "Number expected\n");
3579 return -1;
3580 }
3581 if (d != d || d - d != 0) {
3582 /* NaN or infinity */
3583 monitor_printf(mon, "Bad number\n");
3584 return -1;
3585 }
3586 *pval = d;
3587 *pp = tailp;
3588 return 0;
3589}
3590
4590fd80
LC
3591/*
3592 * Store the command-name in cmdname, and return a pointer to
3593 * the remaining of the command string.
3594 */
3595static const char *get_command_name(const char *cmdline,
3596 char *cmdname, size_t nlen)
3597{
3598 size_t len;
3599 const char *p, *pstart;
3600
3601 p = cmdline;
3602 while (qemu_isspace(*p))
3603 p++;
3604 if (*p == '\0')
3605 return NULL;
3606 pstart = p;
3607 while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
3608 p++;
3609 len = p - pstart;
3610 if (len > nlen - 1)
3611 len = nlen - 1;
3612 memcpy(cmdname, pstart, len);
3613 cmdname[len] = '\0';
3614 return p;
3615}
3616
4d76d2ba
LC
3617/**
3618 * Read key of 'type' into 'key' and return the current
3619 * 'type' pointer.
3620 */
3621static char *key_get_info(const char *type, char **key)
3622{
3623 size_t len;
3624 char *p, *str;
3625
3626 if (*type == ',')
3627 type++;
3628
3629 p = strchr(type, ':');
3630 if (!p) {
3631 *key = NULL;
3632 return NULL;
3633 }
3634 len = p - type;
3635
7267c094 3636 str = g_malloc(len + 1);
4d76d2ba
LC
3637 memcpy(str, type, len);
3638 str[len] = '\0';
3639
3640 *key = str;
3641 return ++p;
3642}
3643
9307c4c1
FB
3644static int default_fmt_format = 'x';
3645static int default_fmt_size = 4;
3646
fbc3d96c
LS
3647static int is_valid_option(const char *c, const char *typestr)
3648{
3649 char option[3];
3650
3651 option[0] = '-';
3652 option[1] = *c;
3653 option[2] = '\0';
3654
3655 typestr = strstr(typestr, option);
3656 return (typestr != NULL);
3657}
3658
945c5ac8
LC
3659static const mon_cmd_t *search_dispatch_table(const mon_cmd_t *disp_table,
3660 const char *cmdname)
7fd669a1
LC
3661{
3662 const mon_cmd_t *cmd;
3663
945c5ac8 3664 for (cmd = disp_table; cmd->name != NULL; cmd++) {
7fd669a1
LC
3665 if (compare_cmd(cmdname, cmd->name)) {
3666 return cmd;
3667 }
3668 }
3669
3670 return NULL;
3671}
3672
bead3ce1
LC
3673static const mon_cmd_t *qmp_find_cmd(const char *cmdname)
3674{
f36b4afb 3675 return search_dispatch_table(qmp_cmds, cmdname);
bead3ce1
LC
3676}
3677
5f3d335f
WX
3678/*
3679 * Parse @cmdline according to command table @table.
3680 * If @cmdline is blank, return NULL.
3681 * If it can't be parsed, report to @mon, and return NULL.
3682 * Else, insert command arguments into @qdict, and return the command.
085d8134
PM
3683 * If a sub-command table exists, and if @cmdline contains an additional string
3684 * for a sub-command, this function will try to search the sub-command table.
3685 * If no additional string for a sub-command is present, this function will
3686 * return the command found in @table.
5f3d335f
WX
3687 * Do not assume the returned command points into @table! It doesn't
3688 * when the command is a sub-command.
3689 */
c227f099 3690static const mon_cmd_t *monitor_parse_command(Monitor *mon,
55f81d96 3691 const char *cmdline,
5f3d335f
WX
3692 int start,
3693 mon_cmd_t *table,
55f81d96 3694 QDict *qdict)
9307c4c1 3695{
4590fd80 3696 const char *p, *typestr;
53773581 3697 int c;
c227f099 3698 const mon_cmd_t *cmd;
9307c4c1
FB
3699 char cmdname[256];
3700 char buf[1024];
4d76d2ba 3701 char *key;
9dc39cba
FB
3702
3703#ifdef DEBUG
5f3d335f 3704 monitor_printf(mon, "command='%s', start='%d'\n", cmdline, start);
9dc39cba 3705#endif
3b46e624 3706
9307c4c1 3707 /* extract the command name */
5f3d335f 3708 p = get_command_name(cmdline + start, cmdname, sizeof(cmdname));
4590fd80 3709 if (!p)
55f81d96 3710 return NULL;
3b46e624 3711
5f3d335f 3712 cmd = search_dispatch_table(table, cmdname);
7fd669a1 3713 if (!cmd) {
5f3d335f
WX
3714 monitor_printf(mon, "unknown command: '%.*s'\n",
3715 (int)(p - cmdline), cmdline);
55f81d96 3716 return NULL;
9307c4c1 3717 }
9307c4c1 3718
5f3d335f
WX
3719 /* filter out following useless space */
3720 while (qemu_isspace(*p)) {
3721 p++;
3722 }
3723 /* search sub command */
3724 if (cmd->sub_table != NULL) {
3725 /* check if user set additional command */
3726 if (*p == '\0') {
3727 return cmd;
3728 }
3729 return monitor_parse_command(mon, cmdline, p - cmdline,
3730 cmd->sub_table, qdict);
3731 }
3732
9307c4c1
FB
3733 /* parse the parameters */
3734 typestr = cmd->args_type;
9dc39cba 3735 for(;;) {
4d76d2ba
LC
3736 typestr = key_get_info(typestr, &key);
3737 if (!typestr)
9dc39cba 3738 break;
4d76d2ba 3739 c = *typestr;
9307c4c1
FB
3740 typestr++;
3741 switch(c) {
3742 case 'F':
81d0912d 3743 case 'B':
9307c4c1
FB
3744 case 's':
3745 {
3746 int ret;
3b46e624 3747
cd390083 3748 while (qemu_isspace(*p))
9307c4c1
FB
3749 p++;
3750 if (*typestr == '?') {
3751 typestr++;
3752 if (*p == '\0') {
3753 /* no optional string: NULL argument */
53773581 3754 break;
9307c4c1
FB
3755 }
3756 }
3757 ret = get_str(buf, sizeof(buf), &p);
3758 if (ret < 0) {
81d0912d
FB
3759 switch(c) {
3760 case 'F':
376253ec
AL
3761 monitor_printf(mon, "%s: filename expected\n",
3762 cmdname);
81d0912d
FB
3763 break;
3764 case 'B':
376253ec
AL
3765 monitor_printf(mon, "%s: block device name expected\n",
3766 cmdname);
81d0912d
FB
3767 break;
3768 default:
376253ec 3769 monitor_printf(mon, "%s: string expected\n", cmdname);
81d0912d
FB
3770 break;
3771 }
9307c4c1
FB
3772 goto fail;
3773 }
53773581 3774 qdict_put(qdict, key, qstring_from_str(buf));
9307c4c1 3775 }
9dc39cba 3776 break;
361127df
MA
3777 case 'O':
3778 {
3779 QemuOptsList *opts_list;
3780 QemuOpts *opts;
3781
3782 opts_list = qemu_find_opts(key);
3783 if (!opts_list || opts_list->desc->name) {
3784 goto bad_type;
3785 }
3786 while (qemu_isspace(*p)) {
3787 p++;
3788 }
3789 if (!*p)
3790 break;
3791 if (get_str(buf, sizeof(buf), &p) < 0) {
3792 goto fail;
3793 }
3794 opts = qemu_opts_parse(opts_list, buf, 1);
3795 if (!opts) {
3796 goto fail;
3797 }
3798 qemu_opts_to_qdict(opts, qdict);
3799 qemu_opts_del(opts);
3800 }
3801 break;
9307c4c1
FB
3802 case '/':
3803 {
3804 int count, format, size;
3b46e624 3805
cd390083 3806 while (qemu_isspace(*p))
9307c4c1
FB
3807 p++;
3808 if (*p == '/') {
3809 /* format found */
3810 p++;
3811 count = 1;
cd390083 3812 if (qemu_isdigit(*p)) {
9307c4c1 3813 count = 0;
cd390083 3814 while (qemu_isdigit(*p)) {
9307c4c1
FB
3815 count = count * 10 + (*p - '0');
3816 p++;
3817 }
3818 }
3819 size = -1;
3820 format = -1;
3821 for(;;) {
3822 switch(*p) {
3823 case 'o':
3824 case 'd':
3825 case 'u':
3826 case 'x':
3827 case 'i':
3828 case 'c':
3829 format = *p++;
3830 break;
3831 case 'b':
3832 size = 1;
3833 p++;
3834 break;
3835 case 'h':
3836 size = 2;
3837 p++;
3838 break;
3839 case 'w':
3840 size = 4;
3841 p++;
3842 break;
3843 case 'g':
3844 case 'L':
3845 size = 8;
3846 p++;
3847 break;
3848 default:
3849 goto next;
3850 }
3851 }
3852 next:
cd390083 3853 if (*p != '\0' && !qemu_isspace(*p)) {
376253ec
AL
3854 monitor_printf(mon, "invalid char in format: '%c'\n",
3855 *p);
9307c4c1
FB
3856 goto fail;
3857 }
9307c4c1
FB
3858 if (format < 0)
3859 format = default_fmt_format;
4c27ba27
FB
3860 if (format != 'i') {
3861 /* for 'i', not specifying a size gives -1 as size */
3862 if (size < 0)
3863 size = default_fmt_size;
e90f009b 3864 default_fmt_size = size;
4c27ba27 3865 }
9307c4c1
FB
3866 default_fmt_format = format;
3867 } else {
3868 count = 1;
3869 format = default_fmt_format;
4c27ba27
FB
3870 if (format != 'i') {
3871 size = default_fmt_size;
3872 } else {
3873 size = -1;
3874 }
9307c4c1 3875 }
f7188bbe
LC
3876 qdict_put(qdict, "count", qint_from_int(count));
3877 qdict_put(qdict, "format", qint_from_int(format));
3878 qdict_put(qdict, "size", qint_from_int(size));
9307c4c1 3879 }
9dc39cba 3880 break;
9307c4c1 3881 case 'i':
92a31b1f 3882 case 'l':
b6e098d7 3883 case 'M':
9307c4c1 3884 {
c2efc95d 3885 int64_t val;
7743e588 3886
cd390083 3887 while (qemu_isspace(*p))
9307c4c1 3888 p++;
3440557b 3889 if (*typestr == '?' || *typestr == '.') {
3440557b 3890 if (*typestr == '?') {
53773581
LC
3891 if (*p == '\0') {
3892 typestr++;
3893 break;
3894 }
3440557b
FB
3895 } else {
3896 if (*p == '.') {
3897 p++;
cd390083 3898 while (qemu_isspace(*p))
3440557b 3899 p++;
3440557b 3900 } else {
53773581
LC
3901 typestr++;
3902 break;
3440557b
FB
3903 }
3904 }
13224a87 3905 typestr++;
9307c4c1 3906 }
376253ec 3907 if (get_expr(mon, &val, &p))
9307c4c1 3908 goto fail;
675ebef9
LC
3909 /* Check if 'i' is greater than 32-bit */
3910 if ((c == 'i') && ((val >> 32) & 0xffffffff)) {
3911 monitor_printf(mon, "\'%s\' has failed: ", cmdname);
3912 monitor_printf(mon, "integer is for 32-bit values\n");
3913 goto fail;
b6e098d7 3914 } else if (c == 'M') {
91162849
LC
3915 if (val < 0) {
3916 monitor_printf(mon, "enter a positive value\n");
3917 goto fail;
3918 }
b6e098d7 3919 val <<= 20;
675ebef9 3920 }
53773581 3921 qdict_put(qdict, key, qint_from_int(val));
9307c4c1
FB
3922 }
3923 break;
dbc0c67f
JS
3924 case 'o':
3925 {
70b4f4bb 3926 int64_t val;
dbc0c67f
JS
3927 char *end;
3928
3929 while (qemu_isspace(*p)) {
3930 p++;
3931 }
3932 if (*typestr == '?') {
3933 typestr++;
3934 if (*p == '\0') {
3935 break;
3936 }
3937 }
3938 val = strtosz(p, &end);
3939 if (val < 0) {
3940 monitor_printf(mon, "invalid size\n");
3941 goto fail;
3942 }
3943 qdict_put(qdict, key, qint_from_int(val));
3944 p = end;
3945 }
3946 break;
fccfb11e 3947 case 'T':
3350a4dd
MA
3948 {
3949 double val;
3950
3951 while (qemu_isspace(*p))
3952 p++;
3953 if (*typestr == '?') {
3954 typestr++;
3955 if (*p == '\0') {
3956 break;
3957 }
3958 }
3959 if (get_double(mon, &val, &p) < 0) {
3960 goto fail;
3961 }
07de3e60 3962 if (p[0] && p[1] == 's') {
fccfb11e
MA
3963 switch (*p) {
3964 case 'm':
3965 val /= 1e3; p += 2; break;
3966 case 'u':
3967 val /= 1e6; p += 2; break;
3968 case 'n':
3969 val /= 1e9; p += 2; break;
3970 }
3971 }
3350a4dd
MA
3972 if (*p && !qemu_isspace(*p)) {
3973 monitor_printf(mon, "Unknown unit suffix\n");
3974 goto fail;
3975 }
3976 qdict_put(qdict, key, qfloat_from_double(val));
3977 }
3978 break;
942cd1f2
MA
3979 case 'b':
3980 {
3981 const char *beg;
3982 int val;
3983
3984 while (qemu_isspace(*p)) {
3985 p++;
3986 }
3987 beg = p;
3988 while (qemu_isgraph(*p)) {
3989 p++;
3990 }
3991 if (p - beg == 2 && !memcmp(beg, "on", p - beg)) {
3992 val = 1;
3993 } else if (p - beg == 3 && !memcmp(beg, "off", p - beg)) {
3994 val = 0;
3995 } else {
3996 monitor_printf(mon, "Expected 'on' or 'off'\n");
3997 goto fail;
3998 }
3999 qdict_put(qdict, key, qbool_from_int(val));
4000 }
4001 break;
9307c4c1
FB
4002 case '-':
4003 {
fbc3d96c 4004 const char *tmp = p;
eb159d13 4005 int skip_key = 0;
9307c4c1 4006 /* option */
3b46e624 4007
9307c4c1
FB
4008 c = *typestr++;
4009 if (c == '\0')
4010 goto bad_type;
cd390083 4011 while (qemu_isspace(*p))
9307c4c1 4012 p++;
9307c4c1
FB
4013 if (*p == '-') {
4014 p++;
fbc3d96c
LS
4015 if(c != *p) {
4016 if(!is_valid_option(p, typestr)) {
4017
4018 monitor_printf(mon, "%s: unsupported option -%c\n",
4019 cmdname, *p);
4020 goto fail;
4021 } else {
4022 skip_key = 1;
4023 }
4024 }
4025 if(skip_key) {
4026 p = tmp;
4027 } else {
eb159d13 4028 /* has option */
fbc3d96c 4029 p++;
eb159d13 4030 qdict_put(qdict, key, qbool_from_int(1));
9307c4c1 4031 }
9307c4c1 4032 }
9307c4c1
FB
4033 }
4034 break;
129be006
WX
4035 case 'S':
4036 {
4037 /* package all remaining string */
4038 int len;
4039
4040 while (qemu_isspace(*p)) {
4041 p++;
4042 }
4043 if (*typestr == '?') {
4044 typestr++;
4045 if (*p == '\0') {
4046 /* no remaining string: NULL argument */
4047 break;
4048 }
4049 }
4050 len = strlen(p);
4051 if (len <= 0) {
4052 monitor_printf(mon, "%s: string expected\n",
4053 cmdname);
4054 break;
4055 }
4056 qdict_put(qdict, key, qstring_from_str(p));
4057 p += len;
4058 }
4059 break;
9307c4c1
FB
4060 default:
4061 bad_type:
376253ec 4062 monitor_printf(mon, "%s: unknown type '%c'\n", cmdname, c);
9307c4c1
FB
4063 goto fail;
4064 }
7267c094 4065 g_free(key);
4d76d2ba 4066 key = NULL;
9dc39cba 4067 }
9307c4c1 4068 /* check that all arguments were parsed */
cd390083 4069 while (qemu_isspace(*p))
9307c4c1
FB
4070 p++;
4071 if (*p != '\0') {
376253ec
AL
4072 monitor_printf(mon, "%s: extraneous characters at the end of line\n",
4073 cmdname);
9307c4c1 4074 goto fail;
9dc39cba 4075 }
9307c4c1 4076
55f81d96 4077 return cmd;
ac7531ec 4078
55f81d96 4079fail:
7267c094 4080 g_free(key);
55f81d96
LC
4081 return NULL;
4082}
4083
d6f46833
MA
4084void monitor_set_error(Monitor *mon, QError *qerror)
4085{
4086 /* report only the first error */
4087 if (!mon->error) {
4088 mon->error = qerror;
4089 } else {
d6f46833
MA
4090 QDECREF(qerror);
4091 }
4092}
4093
bb89c2e9
LC
4094static void handler_audit(Monitor *mon, const mon_cmd_t *cmd, int ret)
4095{
6d441430
LC
4096 if (ret && !monitor_has_error(mon)) {
4097 /*
4098 * If it returns failure, it must have passed on error.
4099 *
4100 * Action: Report an internal error to the client if in QMP.
4101 */
4102 qerror_report(QERR_UNDEFINED_ERROR);
6d441430 4103 }
bb89c2e9
LC
4104}
4105
f3c157c4 4106static void handle_user_command(Monitor *mon, const char *cmdline)
55f81d96 4107{
55f81d96 4108 QDict *qdict;
c227f099 4109 const mon_cmd_t *cmd;
55f81d96
LC
4110
4111 qdict = qdict_new();
4112
7717239d 4113 cmd = monitor_parse_command(mon, cmdline, 0, mon->cmd_table, qdict);
13917bee
LC
4114 if (!cmd)
4115 goto out;
4116
4903de0c 4117 if (handler_is_async(cmd)) {
940cc30d 4118 user_async_cmd_handler(mon, cmd, qdict);
9e80721e 4119 } else if (handler_is_qobject(cmd)) {
de79ba6f
LC
4120 QObject *data = NULL;
4121
4122 /* XXX: ignores the error code */
4123 cmd->mhandler.cmd_new(mon, qdict, &data);
4124 assert(!monitor_has_error(mon));
4125 if (data) {
4126 cmd->user_print(mon, data);
4127 qobject_decref(data);
4128 }
13917bee 4129 } else {
af4ce882 4130 cmd->mhandler.cmd(mon, qdict);
55f81d96
LC
4131 }
4132
13917bee 4133out:
f7188bbe 4134 QDECREF(qdict);
9dc39cba
FB
4135}
4136
cd5c6bba 4137static void cmd_completion(Monitor *mon, const char *name, const char *list)
81d0912d
FB
4138{
4139 const char *p, *pstart;
4140 char cmd[128];
4141 int len;
4142
4143 p = list;
4144 for(;;) {
4145 pstart = p;
4146 p = strchr(p, '|');
4147 if (!p)
4148 p = pstart + strlen(pstart);
4149 len = p - pstart;
4150 if (len > sizeof(cmd) - 2)
4151 len = sizeof(cmd) - 2;
4152 memcpy(cmd, pstart, len);
4153 cmd[len] = '\0';
4154 if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
cd5c6bba 4155 readline_add_completion(mon->rs, cmd);
81d0912d
FB
4156 }
4157 if (*p == '\0')
4158 break;
4159 p++;
4160 }
4161}
4162
cb8f68b1 4163static void file_completion(Monitor *mon, const char *input)
81d0912d
FB
4164{
4165 DIR *ffs;
4166 struct dirent *d;
4167 char path[1024];
4168 char file[1024], file_prefix[1024];
4169 int input_path_len;
4170 const char *p;
4171
5fafdf24 4172 p = strrchr(input, '/');
81d0912d
FB
4173 if (!p) {
4174 input_path_len = 0;
4175 pstrcpy(file_prefix, sizeof(file_prefix), input);
363a37d5 4176 pstrcpy(path, sizeof(path), ".");
81d0912d
FB
4177 } else {
4178 input_path_len = p - input + 1;
4179 memcpy(path, input, input_path_len);
4180 if (input_path_len > sizeof(path) - 1)
4181 input_path_len = sizeof(path) - 1;
4182 path[input_path_len] = '\0';
4183 pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
4184 }
4185#ifdef DEBUG_COMPLETION
cb8f68b1 4186 monitor_printf(mon, "input='%s' path='%s' prefix='%s'\n",
376253ec 4187 input, path, file_prefix);
81d0912d
FB
4188#endif
4189 ffs = opendir(path);
4190 if (!ffs)
4191 return;
4192 for(;;) {
4193 struct stat sb;
4194 d = readdir(ffs);
4195 if (!d)
4196 break;
46c7fc18
KK
4197
4198 if (strcmp(d->d_name, ".") == 0 || strcmp(d->d_name, "..") == 0) {
4199 continue;
4200 }
4201
81d0912d
FB
4202 if (strstart(d->d_name, file_prefix, NULL)) {
4203 memcpy(file, input, input_path_len);
363a37d5
BS
4204 if (input_path_len < sizeof(file))
4205 pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
4206 d->d_name);
81d0912d
FB
4207 /* stat the file to find out if it's a directory.
4208 * In that case add a slash to speed up typing long paths
4209 */
c951d9a6 4210 if (stat(file, &sb) == 0 && S_ISDIR(sb.st_mode)) {
363a37d5 4211 pstrcat(file, sizeof(file), "/");
c951d9a6 4212 }
cb8f68b1 4213 readline_add_completion(mon->rs, file);
81d0912d
FB
4214 }
4215 }
4216 closedir(ffs);
4217}
4218
4d76d2ba
LC
4219static const char *next_arg_type(const char *typestr)
4220{
4221 const char *p = strchr(typestr, ':');
4222 return (p != NULL ? ++p : typestr);
4223}
4224
40d19394
HB
4225static void add_completion_option(ReadLineState *rs, const char *str,
4226 const char *option)
4227{
4228 if (!str || !option) {
4229 return;
4230 }
4231 if (!strncmp(option, str, strlen(str))) {
4232 readline_add_completion(rs, option);
4233 }
4234}
4235
13e315da
HB
4236void chardev_add_completion(ReadLineState *rs, int nb_args, const char *str)
4237{
4238 size_t len;
4239 ChardevBackendInfoList *list, *start;
4240
4241 if (nb_args != 2) {
4242 return;
4243 }
4244 len = strlen(str);
4245 readline_set_completion_index(rs, len);
4246
4247 start = list = qmp_query_chardev_backends(NULL);
4248 while (list) {
4249 const char *chr_name = list->value->name;
4250
4251 if (!strncmp(chr_name, str, len)) {
4252 readline_add_completion(rs, chr_name);
4253 }
4254 list = list->next;
4255 }
4256 qapi_free_ChardevBackendInfoList(start);
4257}
4258
b162b49a
HB
4259void netdev_add_completion(ReadLineState *rs, int nb_args, const char *str)
4260{
4261 size_t len;
4262 int i;
4263
4264 if (nb_args != 2) {
4265 return;
4266 }
4267 len = strlen(str);
4268 readline_set_completion_index(rs, len);
4269 for (i = 0; NetClientOptionsKind_lookup[i]; i++) {
4270 add_completion_option(rs, str, NetClientOptionsKind_lookup[i]);
4271 }
4272}
4273
2da1b3ab 4274void device_add_completion(ReadLineState *rs, int nb_args, const char *str)
992d3e64
HB
4275{
4276 GSList *list, *elt;
4277 size_t len;
4278
2da1b3ab
HB
4279 if (nb_args != 2) {
4280 return;
4281 }
4282
992d3e64
HB
4283 len = strlen(str);
4284 readline_set_completion_index(rs, len);
4285 list = elt = object_class_get_list(TYPE_DEVICE, false);
4286 while (elt) {
4287 const char *name;
4288 DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data,
4289 TYPE_DEVICE);
4290 name = object_class_get_name(OBJECT_CLASS(dc));
2da1b3ab
HB
4291
4292 if (!dc->cannot_instantiate_with_device_add_yet
4293 && !strncmp(name, str, len)) {
992d3e64
HB
4294 readline_add_completion(rs, name);
4295 }
4296 elt = elt->next;
4297 }
4298 g_slist_free(list);
4299}
4300
bfa40f77 4301void object_add_completion(ReadLineState *rs, int nb_args, const char *str)
1094fd3a
HB
4302{
4303 GSList *list, *elt;
4304 size_t len;
4305
bfa40f77
HB
4306 if (nb_args != 2) {
4307 return;
4308 }
4309
1094fd3a
HB
4310 len = strlen(str);
4311 readline_set_completion_index(rs, len);
4312 list = elt = object_class_get_list(TYPE_USER_CREATABLE, false);
4313 while (elt) {
4314 const char *name;
4315
4316 name = object_class_get_name(OBJECT_CLASS(elt->data));
4317 if (!strncmp(name, str, len) && strcmp(name, TYPE_USER_CREATABLE)) {
4318 readline_add_completion(rs, name);
4319 }
4320 elt = elt->next;
4321 }
4322 g_slist_free(list);
4323}
4324
6a1fa9f5
ZG
4325static void peripheral_device_del_completion(ReadLineState *rs,
4326 const char *str, size_t len)
4327{
4cae4d5a
MA
4328 Object *peripheral = container_get(qdev_get_machine(), "/peripheral");
4329 GSList *list, *item;
6a1fa9f5 4330
4cae4d5a
MA
4331 list = qdev_build_hotpluggable_device_list(peripheral);
4332 if (!list) {
6a1fa9f5
ZG
4333 return;
4334 }
4335
6a1fa9f5
ZG
4336 for (item = list; item; item = g_slist_next(item)) {
4337 DeviceState *dev = item->data;
4338
4339 if (dev->id && !strncmp(str, dev->id, len)) {
4340 readline_add_completion(rs, dev->id);
4341 }
4342 }
4343
4344 g_slist_free(list);
4345}
4346
6297d9a2
HB
4347void chardev_remove_completion(ReadLineState *rs, int nb_args, const char *str)
4348{
4349 size_t len;
4350 ChardevInfoList *list, *start;
4351
4352 if (nb_args != 2) {
4353 return;
4354 }
4355 len = strlen(str);
4356 readline_set_completion_index(rs, len);
4357
4358 start = list = qmp_query_chardev(NULL);
4359 while (list) {
4360 ChardevInfo *chr = list->value;
4361
4362 if (!strncmp(chr->label, str, len)) {
4363 readline_add_completion(rs, chr->label);
4364 }
4365 list = list->next;
4366 }
4367 qapi_free_ChardevInfoList(start);
4368}
4369
8e597779
HB
4370static void ringbuf_completion(ReadLineState *rs, const char *str)
4371{
4372 size_t len;
4373 ChardevInfoList *list, *start;
4374
4375 len = strlen(str);
4376 readline_set_completion_index(rs, len);
4377
4378 start = list = qmp_query_chardev(NULL);
4379 while (list) {
4380 ChardevInfo *chr_info = list->value;
4381
4382 if (!strncmp(chr_info->label, str, len)) {
4383 CharDriverState *chr = qemu_chr_find(chr_info->label);
4384 if (chr && chr_is_ringbuf(chr)) {
4385 readline_add_completion(rs, chr_info->label);
4386 }
4387 }
4388 list = list->next;
4389 }
4390 qapi_free_ChardevInfoList(start);
4391}
4392
4393void ringbuf_read_completion(ReadLineState *rs, int nb_args, const char *str)
4394{
4395 if (nb_args != 2) {
4396 return;
4397 }
4398 ringbuf_completion(rs, str);
4399}
4400
4401void ringbuf_write_completion(ReadLineState *rs, int nb_args, const char *str)
4402{
4403 if (nb_args != 2) {
4404 return;
4405 }
4406 ringbuf_completion(rs, str);
4407}
4408
2da1b3ab
HB
4409void device_del_completion(ReadLineState *rs, int nb_args, const char *str)
4410{
4411 size_t len;
4412
4413 if (nb_args != 2) {
4414 return;
4415 }
4416
4417 len = strlen(str);
4418 readline_set_completion_index(rs, len);
6a1fa9f5 4419 peripheral_device_del_completion(rs, str, len);
2da1b3ab
HB
4420}
4421
bfa40f77 4422void object_del_completion(ReadLineState *rs, int nb_args, const char *str)
b48fa074
HB
4423{
4424 ObjectPropertyInfoList *list, *start;
4425 size_t len;
4426
bfa40f77
HB
4427 if (nb_args != 2) {
4428 return;
4429 }
b48fa074
HB
4430 len = strlen(str);
4431 readline_set_completion_index(rs, len);
4432
4433 start = list = qmp_qom_list("/objects", NULL);
4434 while (list) {
4435 ObjectPropertyInfo *info = list->value;
4436
4437 if (!strncmp(info->type, "child<", 5)
4438 && !strncmp(info->name, str, len)) {
4439 readline_add_completion(rs, info->name);
4440 }
4441 list = list->next;
4442 }
4443 qapi_free_ObjectPropertyInfoList(start);
4444}
4445
29136cd8
HB
4446void sendkey_completion(ReadLineState *rs, int nb_args, const char *str)
4447{
4448 int i;
4449 char *sep;
4450 size_t len;
4451
4452 if (nb_args != 2) {
4453 return;
4454 }
4455 sep = strrchr(str, '-');
4456 if (sep) {
4457 str = sep + 1;
4458 }
4459 len = strlen(str);
4460 readline_set_completion_index(rs, len);
4461 for (i = 0; i < Q_KEY_CODE_MAX; i++) {
4462 if (!strncmp(str, QKeyCode_lookup[i], len)) {
4463 readline_add_completion(rs, QKeyCode_lookup[i]);
4464 }
4465 }
4466}
4467
40d19394
HB
4468void set_link_completion(ReadLineState *rs, int nb_args, const char *str)
4469{
4470 size_t len;
4471
4472 len = strlen(str);
4473 readline_set_completion_index(rs, len);
4474 if (nb_args == 2) {
4475 NetClientState *ncs[255];
4476 int count, i;
4477 count = qemu_find_net_clients_except(NULL, ncs,
4478 NET_CLIENT_OPTIONS_KIND_NONE, 255);
4479 for (i = 0; i < count; i++) {
4480 const char *name = ncs[i]->name;
4481 if (!strncmp(str, name, len)) {
4482 readline_add_completion(rs, name);
4483 }
4484 }
4485 } else if (nb_args == 3) {
4486 add_completion_option(rs, str, "on");
4487 add_completion_option(rs, str, "off");
4488 }
4489}
4490
11b389f2
HB
4491void netdev_del_completion(ReadLineState *rs, int nb_args, const char *str)
4492{
4493 int len, count, i;
4494 NetClientState *ncs[255];
4495
4496 if (nb_args != 2) {
4497 return;
4498 }
4499
4500 len = strlen(str);
4501 readline_set_completion_index(rs, len);
4502 count = qemu_find_net_clients_except(NULL, ncs, NET_CLIENT_OPTIONS_KIND_NIC,
4503 255);
4504 for (i = 0; i < count; i++) {
4505 QemuOpts *opts;
4506 const char *name = ncs[i]->name;
4507 if (strncmp(str, name, len)) {
4508 continue;
4509 }
4510 opts = qemu_opts_find(qemu_find_opts_err("netdev", NULL), name);
4511 if (opts) {
4512 readline_add_completion(rs, name);
4513 }
4514 }
4515}
4516
d0ece345
HB
4517void watchdog_action_completion(ReadLineState *rs, int nb_args, const char *str)
4518{
4bb08af3
HB
4519 int i;
4520
d0ece345
HB
4521 if (nb_args != 2) {
4522 return;
4523 }
4524 readline_set_completion_index(rs, strlen(str));
4bb08af3
HB
4525 for (i = 0; WatchdogExpirationAction_lookup[i]; i++) {
4526 add_completion_option(rs, str, WatchdogExpirationAction_lookup[i]);
4527 }
d0ece345
HB
4528}
4529
c68a0409
HB
4530void migrate_set_capability_completion(ReadLineState *rs, int nb_args,
4531 const char *str)
4532{
4533 size_t len;
4534
4535 len = strlen(str);
4536 readline_set_completion_index(rs, len);
4537 if (nb_args == 2) {
4538 int i;
4539 for (i = 0; i < MIGRATION_CAPABILITY_MAX; i++) {
4540 const char *name = MigrationCapability_lookup[i];
4541 if (!strncmp(str, name, len)) {
4542 readline_add_completion(rs, name);
4543 }
4544 }
4545 } else if (nb_args == 3) {
4546 add_completion_option(rs, str, "on");
4547 add_completion_option(rs, str, "off");
4548 }
4549}
4550
e3bb532c
HB
4551void host_net_add_completion(ReadLineState *rs, int nb_args, const char *str)
4552{
4553 int i;
4554 size_t len;
4555 if (nb_args != 2) {
4556 return;
4557 }
4558 len = strlen(str);
4559 readline_set_completion_index(rs, len);
4560 for (i = 0; host_net_devices[i]; i++) {
4561 if (!strncmp(host_net_devices[i], str, len)) {
4562 readline_add_completion(rs, host_net_devices[i]);
4563 }
4564 }
4565}
4566
ddd6b45c
HB
4567void host_net_remove_completion(ReadLineState *rs, int nb_args, const char *str)
4568{
4569 NetClientState *ncs[255];
4570 int count, i, len;
4571
4572 len = strlen(str);
4573 readline_set_completion_index(rs, len);
4574 if (nb_args == 2) {
4575 count = qemu_find_net_clients_except(NULL, ncs,
4576 NET_CLIENT_OPTIONS_KIND_NONE, 255);
4577 for (i = 0; i < count; i++) {
4578 int id;
4579 char name[16];
4580
4581 if (net_hub_id_for_client(ncs[i], &id)) {
4582 continue;
4583 }
4584 snprintf(name, sizeof(name), "%d", id);
4585 if (!strncmp(str, name, len)) {
4586 readline_add_completion(rs, name);
4587 }
4588 }
4589 return;
4590 } else if (nb_args == 3) {
4591 count = qemu_find_net_clients_except(NULL, ncs,
4592 NET_CLIENT_OPTIONS_KIND_NIC, 255);
4593 for (i = 0; i < count; i++) {
2c4681f5 4594 int id;
ddd6b45c
HB
4595 const char *name;
4596
2c4681f5
JW
4597 if (ncs[i]->info->type == NET_CLIENT_OPTIONS_KIND_HUBPORT ||
4598 net_hub_id_for_client(ncs[i], &id)) {
4599 continue;
4600 }
ddd6b45c
HB
4601 name = ncs[i]->name;
4602 if (!strncmp(str, name, len)) {
4603 readline_add_completion(rs, name);
4604 }
4605 }
4606 return;
4607 }
4608}
4609
b21631f3
HB
4610static void vm_completion(ReadLineState *rs, const char *str)
4611{
4612 size_t len;
4613 BlockDriverState *bs = NULL;
4614
4615 len = strlen(str);
4616 readline_set_completion_index(rs, len);
4617 while ((bs = bdrv_next(bs))) {
4618 SnapshotInfoList *snapshots, *snapshot;
4619
4620 if (!bdrv_can_snapshot(bs)) {
4621 continue;
4622 }
4623 if (bdrv_query_snapshot_info_list(bs, &snapshots, NULL)) {
4624 continue;
4625 }
4626 snapshot = snapshots;
4627 while (snapshot) {
4628 char *completion = snapshot->value->name;
4629 if (!strncmp(str, completion, len)) {
4630 readline_add_completion(rs, completion);
4631 }
4632 completion = snapshot->value->id;
4633 if (!strncmp(str, completion, len)) {
4634 readline_add_completion(rs, completion);
4635 }
4636 snapshot = snapshot->next;
4637 }
4638 qapi_free_SnapshotInfoList(snapshots);
4639 }
4640
4641}
4642
4643void delvm_completion(ReadLineState *rs, int nb_args, const char *str)
4644{
4645 if (nb_args == 2) {
4646 vm_completion(rs, str);
4647 }
4648}
4649
4650void loadvm_completion(ReadLineState *rs, int nb_args, const char *str)
4651{
4652 if (nb_args == 2) {
4653 vm_completion(rs, str);
4654 }
4655}
4656
c35b6400
WX
4657static void monitor_find_completion_by_table(Monitor *mon,
4658 const mon_cmd_t *cmd_table,
4659 char **args,
4660 int nb_args)
81d0912d
FB
4661{
4662 const char *cmdname;
c35b6400 4663 int i;
fea68bb6 4664 const char *ptype, *str, *name;
c227f099 4665 const mon_cmd_t *cmd;
fea68bb6 4666 BlockDriverState *bs;
81d0912d 4667
81d0912d
FB
4668 if (nb_args <= 1) {
4669 /* command completion */
4670 if (nb_args == 0)
4671 cmdname = "";
4672 else
4673 cmdname = args[0];
d2674b2c 4674 readline_set_completion_index(mon->rs, strlen(cmdname));
c35b6400 4675 for (cmd = cmd_table; cmd->name != NULL; cmd++) {
cd5c6bba 4676 cmd_completion(mon, cmdname, cmd->name);
81d0912d
FB
4677 }
4678 } else {
4679 /* find the command */
c35b6400 4680 for (cmd = cmd_table; cmd->name != NULL; cmd++) {
03a63484
JK
4681 if (compare_cmd(args[0], cmd->name)) {
4682 break;
4683 }
81d0912d 4684 }
03a63484 4685 if (!cmd->name) {
c35b6400 4686 return;
03a63484
JK
4687 }
4688
d903a779
WX
4689 if (cmd->sub_table) {
4690 /* do the job again */
e7ae771f
SW
4691 monitor_find_completion_by_table(mon, cmd->sub_table,
4692 &args[1], nb_args - 1);
4693 return;
d903a779 4694 }
bfa40f77 4695 if (cmd->command_completion) {
e7ae771f
SW
4696 cmd->command_completion(mon->rs, nb_args, args[nb_args - 1]);
4697 return;
bfa40f77 4698 }
d903a779 4699
4d76d2ba 4700 ptype = next_arg_type(cmd->args_type);
81d0912d
FB
4701 for(i = 0; i < nb_args - 2; i++) {
4702 if (*ptype != '\0') {
4d76d2ba 4703 ptype = next_arg_type(ptype);
81d0912d 4704 while (*ptype == '?')
4d76d2ba 4705 ptype = next_arg_type(ptype);
81d0912d
FB
4706 }
4707 }
4708 str = args[nb_args - 1];
48fe86f6 4709 while (*ptype == '-' && ptype[1] != '\0') {
3b6dbf27 4710 ptype = next_arg_type(ptype);
2a1704a7 4711 }
81d0912d
FB
4712 switch(*ptype) {
4713 case 'F':
4714 /* file completion */
d2674b2c 4715 readline_set_completion_index(mon->rs, strlen(str));
cb8f68b1 4716 file_completion(mon, str);
81d0912d
FB
4717 break;
4718 case 'B':
4719 /* block device name completion */
599a926a 4720 readline_set_completion_index(mon->rs, strlen(str));
fea68bb6
MA
4721 for (bs = bdrv_next(NULL); bs; bs = bdrv_next(bs)) {
4722 name = bdrv_get_device_name(bs);
4723 if (str[0] == '\0' ||
4724 !strncmp(name, str, strlen(str))) {
4725 readline_add_completion(mon->rs, name);
4726 }
4727 }
81d0912d 4728 break;
7fe48483 4729 case 's':
129be006 4730 case 'S':
29136cd8 4731 if (!strcmp(cmd->name, "help|?")) {
7ca0e061
WX
4732 monitor_find_completion_by_table(mon, cmd_table,
4733 &args[1], nb_args - 1);
7fe48483
FB
4734 }
4735 break;
81d0912d
FB
4736 default:
4737 break;
4738 }
4739 }
c35b6400
WX
4740}
4741
c60bf339 4742static void monitor_find_completion(void *opaque,
c35b6400
WX
4743 const char *cmdline)
4744{
c60bf339 4745 Monitor *mon = opaque;
c35b6400
WX
4746 char *args[MAX_ARGS];
4747 int nb_args, len;
4748
4749 /* 1. parse the cmdline */
4750 if (parse_cmdline(cmdline, &nb_args, args) < 0) {
4751 return;
4752 }
4753#ifdef DEBUG_COMPLETION
5fb9b5b9
GA
4754 {
4755 int i;
4756 for (i = 0; i < nb_args; i++) {
4757 monitor_printf(mon, "arg%d = '%s'\n", i, args[i]);
4758 }
c35b6400
WX
4759 }
4760#endif
4761
4762 /* if the line ends with a space, it means we want to complete the
4763 next arg */
4764 len = strlen(cmdline);
4765 if (len > 0 && qemu_isspace(cmdline[len - 1])) {
4766 if (nb_args >= MAX_ARGS) {
4767 goto cleanup;
4768 }
4769 args[nb_args++] = g_strdup("");
4770 }
4771
4772 /* 2. auto complete according to args */
4773 monitor_find_completion_by_table(mon, mon->cmd_table, args, nb_args);
03a63484
JK
4774
4775cleanup:
dcc70cdf 4776 free_cmdline_args(args, nb_args);
81d0912d
FB
4777}
4778
731b0364 4779static int monitor_can_read(void *opaque)
9dc39cba 4780{
731b0364
AL
4781 Monitor *mon = opaque;
4782
c62313bb 4783 return (mon->suspend_cnt == 0) ? 1 : 0;
9dc39cba
FB
4784}
4785
bb5224ed 4786static int invalid_qmp_mode(const Monitor *mon, const mon_cmd_t *cmd)
5fa737a4 4787{
bb5224ed 4788 int is_cap = cmd->mhandler.cmd_new == do_qmp_capabilities;
09069b19 4789 return (qmp_cmd_mode(mon) ? is_cap : !is_cap);
5fa737a4
LC
4790}
4791
4af9193a
LC
4792/*
4793 * Argument validation rules:
4794 *
4795 * 1. The argument must exist in cmd_args qdict
4796 * 2. The argument type must be the expected one
4797 *
4798 * Special case: If the argument doesn't exist in cmd_args and
4799 * the QMP_ACCEPT_UNKNOWNS flag is set, then the
4800 * checking is skipped for it.
4801 */
4802static int check_client_args_type(const QDict *client_args,
4803 const QDict *cmd_args, int flags)
5fa737a4 4804{
4af9193a 4805 const QDictEntry *ent;
5fa737a4 4806
4af9193a
LC
4807 for (ent = qdict_first(client_args); ent;ent = qdict_next(client_args,ent)){
4808 QObject *obj;
4809 QString *arg_type;
4810 const QObject *client_arg = qdict_entry_value(ent);
4811 const char *client_arg_name = qdict_entry_key(ent);
4812
4813 obj = qdict_get(cmd_args, client_arg_name);
4814 if (!obj) {
4815 if (flags & QMP_ACCEPT_UNKNOWNS) {
4816 /* handler accepts unknowns */
4817 continue;
4818 }
4819 /* client arg doesn't exist */
4820 qerror_report(QERR_INVALID_PARAMETER, client_arg_name);
4821 return -1;
4822 }
5fa737a4 4823
4af9193a
LC
4824 arg_type = qobject_to_qstring(obj);
4825 assert(arg_type != NULL);
5fa737a4 4826
4af9193a
LC
4827 /* check if argument's type is correct */
4828 switch (qstring_get_str(arg_type)[0]) {
5fa737a4
LC
4829 case 'F':
4830 case 'B':
4831 case 's':
4af9193a
LC
4832 if (qobject_type(client_arg) != QTYPE_QSTRING) {
4833 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4834 "string");
5fa737a4
LC
4835 return -1;
4836 }
4af9193a 4837 break;
5fa737a4
LC
4838 case 'i':
4839 case 'l':
b6e098d7 4840 case 'M':
dbc0c67f 4841 case 'o':
4af9193a
LC
4842 if (qobject_type(client_arg) != QTYPE_QINT) {
4843 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4844 "int");
4845 return -1;
5fa737a4
LC
4846 }
4847 break;
fccfb11e 4848 case 'T':
4af9193a
LC
4849 if (qobject_type(client_arg) != QTYPE_QINT &&
4850 qobject_type(client_arg) != QTYPE_QFLOAT) {
4851 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4852 "number");
4853 return -1;
3350a4dd
MA
4854 }
4855 break;
942cd1f2 4856 case 'b':
5fa737a4 4857 case '-':
4af9193a
LC
4858 if (qobject_type(client_arg) != QTYPE_QBOOL) {
4859 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4860 "bool");
4861 return -1;
5fa737a4
LC
4862 }
4863 break;
361127df 4864 case 'O':
4af9193a
LC
4865 assert(flags & QMP_ACCEPT_UNKNOWNS);
4866 break;
b9f8978c
PB
4867 case 'q':
4868 /* Any QObject can be passed. */
4869 break;
4af9193a
LC
4870 case '/':
4871 case '.':
4872 /*
4873 * These types are not supported by QMP and thus are not
4874 * handled here. Fall through.
4875 */
5fa737a4 4876 default:
5fa737a4 4877 abort();
4af9193a
LC
4878 }
4879 }
4880
4881 return 0;
4882}
4883
2dbc8db0
LC
4884/*
4885 * - Check if the client has passed all mandatory args
4886 * - Set special flags for argument validation
4887 */
4888static int check_mandatory_args(const QDict *cmd_args,
4889 const QDict *client_args, int *flags)
4890{
4891 const QDictEntry *ent;
4892
4893 for (ent = qdict_first(cmd_args); ent; ent = qdict_next(cmd_args, ent)) {
4894 const char *cmd_arg_name = qdict_entry_key(ent);
4895 QString *type = qobject_to_qstring(qdict_entry_value(ent));
4896 assert(type != NULL);
4897
4898 if (qstring_get_str(type)[0] == 'O') {
4899 assert((*flags & QMP_ACCEPT_UNKNOWNS) == 0);
4900 *flags |= QMP_ACCEPT_UNKNOWNS;
4901 } else if (qstring_get_str(type)[0] != '-' &&
4902 qstring_get_str(type)[1] != '?' &&
4903 !qdict_haskey(client_args, cmd_arg_name)) {
4904 qerror_report(QERR_MISSING_PARAMETER, cmd_arg_name);
4905 return -1;
4906 }
5fa737a4
LC
4907 }
4908
4909 return 0;
4910}
4911
2dbc8db0 4912static QDict *qdict_from_args_type(const char *args_type)
5fa737a4 4913{
2dbc8db0
LC
4914 int i;
4915 QDict *qdict;
4916 QString *key, *type, *cur_qs;
4917
4918 assert(args_type != NULL);
4919
4920 qdict = qdict_new();
4921
4922 if (args_type == NULL || args_type[0] == '\0') {
4923 /* no args, empty qdict */
4924 goto out;
4925 }
4926
4927 key = qstring_new();
4928 type = qstring_new();
4929
4930 cur_qs = key;
4931
4932 for (i = 0;; i++) {
4933 switch (args_type[i]) {
4934 case ',':
4935 case '\0':
4936 qdict_put(qdict, qstring_get_str(key), type);
4937 QDECREF(key);
4938 if (args_type[i] == '\0') {
4939 goto out;
4940 }
4941 type = qstring_new(); /* qdict has ref */
4942 cur_qs = key = qstring_new();
4943 break;
4944 case ':':
4945 cur_qs = type;
4946 break;
4947 default:
4948 qstring_append_chr(cur_qs, args_type[i]);
4949 break;
4950 }
4951 }
4952
4953out:
4954 return qdict;
5fa737a4
LC
4955}
4956
2dbc8db0
LC
4957/*
4958 * Client argument checking rules:
4959 *
4960 * 1. Client must provide all mandatory arguments
4af9193a
LC
4961 * 2. Each argument provided by the client must be expected
4962 * 3. Each argument provided by the client must have the type expected
4963 * by the command
2dbc8db0
LC
4964 */
4965static int qmp_check_client_args(const mon_cmd_t *cmd, QDict *client_args)
361127df 4966{
2dbc8db0
LC
4967 int flags, err;
4968 QDict *cmd_args;
4969
4970 cmd_args = qdict_from_args_type(cmd->args_type);
4971
4972 flags = 0;
4973 err = check_mandatory_args(cmd_args, client_args, &flags);
4974 if (err) {
4975 goto out;
4976 }
4977
4af9193a 4978 err = check_client_args_type(client_args, cmd_args, flags);
2dbc8db0
LC
4979
4980out:
4981 QDECREF(cmd_args);
4982 return err;
361127df
MA
4983}
4984
5fa737a4 4985/*
c917c8f3 4986 * Input object checking rules
5fa737a4 4987 *
c917c8f3
LC
4988 * 1. Input object must be a dict
4989 * 2. The "execute" key must exist
4990 * 3. The "execute" key must be a string
4991 * 4. If the "arguments" key exists, it must be a dict
4992 * 5. If the "id" key exists, it can be anything (ie. json-value)
4993 * 6. Any argument not listed above is considered invalid
5fa737a4 4994 */
c917c8f3 4995static QDict *qmp_check_input_obj(QObject *input_obj)
5fa737a4 4996{
c917c8f3
LC
4997 const QDictEntry *ent;
4998 int has_exec_key = 0;
4999 QDict *input_dict;
5fa737a4 5000
c917c8f3
LC
5001 if (qobject_type(input_obj) != QTYPE_QDICT) {
5002 qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "object");
5003 return NULL;
5fa737a4
LC
5004 }
5005
c917c8f3 5006 input_dict = qobject_to_qdict(input_obj);
5fa737a4 5007
c917c8f3
LC
5008 for (ent = qdict_first(input_dict); ent; ent = qdict_next(input_dict, ent)){
5009 const char *arg_name = qdict_entry_key(ent);
5010 const QObject *arg_obj = qdict_entry_value(ent);
5fa737a4 5011
c917c8f3
LC
5012 if (!strcmp(arg_name, "execute")) {
5013 if (qobject_type(arg_obj) != QTYPE_QSTRING) {
5014 qerror_report(QERR_QMP_BAD_INPUT_OBJECT_MEMBER, "execute",
5015 "string");
5016 return NULL;
361127df 5017 }
c917c8f3
LC
5018 has_exec_key = 1;
5019 } else if (!strcmp(arg_name, "arguments")) {
5020 if (qobject_type(arg_obj) != QTYPE_QDICT) {
5021 qerror_report(QERR_QMP_BAD_INPUT_OBJECT_MEMBER, "arguments",
5022 "object");
5023 return NULL;
5fa737a4 5024 }
c917c8f3
LC
5025 } else if (!strcmp(arg_name, "id")) {
5026 /* FIXME: check duplicated IDs for async commands */
5fa737a4 5027 } else {
c917c8f3
LC
5028 qerror_report(QERR_QMP_EXTRA_MEMBER, arg_name);
5029 return NULL;
5fa737a4
LC
5030 }
5031 }
5032
c917c8f3
LC
5033 if (!has_exec_key) {
5034 qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "execute");
5035 return NULL;
5036 }
5fa737a4 5037
c917c8f3 5038 return input_dict;
09069b19
LC
5039}
5040
fc29df75
LC
5041static void qmp_call_cmd(Monitor *mon, const mon_cmd_t *cmd,
5042 const QDict *params)
5043{
5044 int ret;
5045 QObject *data = NULL;
5046
fc29df75
LC
5047 ret = cmd->mhandler.cmd_new(mon, params, &data);
5048 handler_audit(mon, cmd, ret);
5049 monitor_protocol_emitter(mon, data);
5050 qobject_decref(data);
5051}
5052
5fa737a4
LC
5053static void handle_qmp_command(JSONMessageParser *parser, QList *tokens)
5054{
5055 int err;
5056 QObject *obj;
5057 QDict *input, *args;
5fa737a4 5058 const mon_cmd_t *cmd;
40e5a01d 5059 const char *cmd_name;
5fa737a4
LC
5060 Monitor *mon = cur_mon;
5061
e4940c60 5062 args = input = NULL;
5fa737a4
LC
5063
5064 obj = json_parser_parse(tokens, NULL);
5065 if (!obj) {
5066 // FIXME: should be triggered in json_parser_parse()
ab5b027e 5067 qerror_report(QERR_JSON_PARSING);
5fa737a4 5068 goto err_out;
5fa737a4
LC
5069 }
5070
c917c8f3
LC
5071 input = qmp_check_input_obj(obj);
5072 if (!input) {
5fa737a4
LC
5073 qobject_decref(obj);
5074 goto err_out;
5075 }
5076
5fa737a4
LC
5077 mon->mc->id = qdict_get(input, "id");
5078 qobject_incref(mon->mc->id);
5079
0bbab46d 5080 cmd_name = qdict_get_str(input, "execute");
89bd820a 5081 trace_handle_qmp_command(mon, cmd_name);
e3193601 5082 cmd = qmp_find_cmd(cmd_name);
bb5224ed 5083 if (!cmd || invalid_qmp_mode(mon, cmd)) {
a6c90cbc
MA
5084 qerror_report(ERROR_CLASS_COMMAND_NOT_FOUND,
5085 "The command %s has not been found", cmd_name);
e4940c60 5086 goto err_out;
5fa737a4
LC
5087 }
5088
5089 obj = qdict_get(input, "arguments");
5090 if (!obj) {
5091 args = qdict_new();
5092 } else {
5093 args = qobject_to_qdict(obj);
5094 QINCREF(args);
5095 }
5096
2dbc8db0 5097 err = qmp_check_client_args(cmd, args);
5fa737a4
LC
5098 if (err < 0) {
5099 goto err_out;
5100 }
5101
40e5a01d 5102 if (handler_is_async(cmd)) {
5af7bbae
LC
5103 err = qmp_async_cmd_handler(mon, cmd, args);
5104 if (err) {
5105 /* emit the error response */
5106 goto err_out;
5107 }
940cc30d 5108 } else {
fc29df75 5109 qmp_call_cmd(mon, cmd, args);
940cc30d 5110 }
e4940c60 5111
5fa737a4
LC
5112 goto out;
5113
5fa737a4
LC
5114err_out:
5115 monitor_protocol_emitter(mon, NULL);
5116out:
e4940c60 5117 QDECREF(input);
5fa737a4 5118 QDECREF(args);
5fa737a4
LC
5119}
5120
9b57c02e
LC
5121/**
5122 * monitor_control_read(): Read and handle QMP input
5123 */
5124static void monitor_control_read(void *opaque, const uint8_t *buf, int size)
5125{
5126 Monitor *old_mon = cur_mon;
5127
5128 cur_mon = opaque;
5129
5fa737a4 5130 json_message_parser_feed(&cur_mon->mc->parser, (const char *) buf, size);
9b57c02e
LC
5131
5132 cur_mon = old_mon;
5133}
5134
731b0364 5135static void monitor_read(void *opaque, const uint8_t *buf, int size)
9dc39cba 5136{
731b0364 5137 Monitor *old_mon = cur_mon;
7e2515e8 5138 int i;
376253ec 5139
731b0364
AL
5140 cur_mon = opaque;
5141
cde76ee1
AL
5142 if (cur_mon->rs) {
5143 for (i = 0; i < size; i++)
5144 readline_handle_byte(cur_mon->rs, buf[i]);
5145 } else {
5146 if (size == 0 || buf[size - 1] != 0)
5147 monitor_printf(cur_mon, "corrupted command\n");
5148 else
f3c157c4 5149 handle_user_command(cur_mon, (char *)buf);
cde76ee1 5150 }
9dc39cba 5151
731b0364
AL
5152 cur_mon = old_mon;
5153}
d8f44609 5154
c60bf339
SH
5155static void monitor_command_cb(void *opaque, const char *cmdline,
5156 void *readline_opaque)
aa455485 5157{
c60bf339
SH
5158 Monitor *mon = opaque;
5159
731b0364 5160 monitor_suspend(mon);
f3c157c4 5161 handle_user_command(mon, cmdline);
731b0364 5162 monitor_resume(mon);
d8f44609
AL
5163}
5164
cde76ee1 5165int monitor_suspend(Monitor *mon)
d8f44609 5166{
cde76ee1
AL
5167 if (!mon->rs)
5168 return -ENOTTY;
731b0364 5169 mon->suspend_cnt++;
cde76ee1 5170 return 0;
d8f44609
AL
5171}
5172
376253ec 5173void monitor_resume(Monitor *mon)
d8f44609 5174{
cde76ee1
AL
5175 if (!mon->rs)
5176 return;
731b0364
AL
5177 if (--mon->suspend_cnt == 0)
5178 readline_show_prompt(mon->rs);
aa455485
FB
5179}
5180
ca9567e2
LC
5181static QObject *get_qmp_greeting(void)
5182{
b9c15f16 5183 QObject *ver = NULL;
ca9567e2 5184
b9c15f16 5185 qmp_marshal_input_query_version(NULL, NULL, &ver);
ca9567e2
LC
5186 return qobject_from_jsonf("{'QMP':{'version': %p,'capabilities': []}}",ver);
5187}
5188
9b57c02e
LC
5189/**
5190 * monitor_control_event(): Print QMP gretting
5191 */
5192static void monitor_control_event(void *opaque, int event)
5193{
47116d1c
LC
5194 QObject *data;
5195 Monitor *mon = opaque;
9b57c02e 5196
47116d1c
LC
5197 switch (event) {
5198 case CHR_EVENT_OPENED:
4a7e1190 5199 mon->mc->command_mode = 0;
ca9567e2 5200 data = get_qmp_greeting();
9b57c02e
LC
5201 monitor_json_emitter(mon, data);
5202 qobject_decref(data);
efb87c16 5203 mon_refcount++;
47116d1c
LC
5204 break;
5205 case CHR_EVENT_CLOSED:
5206 json_message_parser_destroy(&mon->mc->parser);
58617a79 5207 json_message_parser_init(&mon->mc->parser, handle_qmp_command);
efb87c16
CB
5208 mon_refcount--;
5209 monitor_fdsets_cleanup();
47116d1c 5210 break;
9b57c02e
LC
5211 }
5212}
5213
731b0364 5214static void monitor_event(void *opaque, int event)
86e94dea 5215{
376253ec
AL
5216 Monitor *mon = opaque;
5217
2724b180
AL
5218 switch (event) {
5219 case CHR_EVENT_MUX_IN:
6cff3e85 5220 qemu_mutex_lock(&mon->out_lock);
a7aec5da 5221 mon->mux_out = 0;
6cff3e85 5222 qemu_mutex_unlock(&mon->out_lock);
a7aec5da
GH
5223 if (mon->reset_seen) {
5224 readline_restart(mon->rs);
5225 monitor_resume(mon);
5226 monitor_flush(mon);
5227 } else {
5228 mon->suspend_cnt = 0;
5229 }
2724b180
AL
5230 break;
5231
5232 case CHR_EVENT_MUX_OUT:
a7aec5da
GH
5233 if (mon->reset_seen) {
5234 if (mon->suspend_cnt == 0) {
5235 monitor_printf(mon, "\n");
5236 }
5237 monitor_flush(mon);
5238 monitor_suspend(mon);
5239 } else {
5240 mon->suspend_cnt++;
5241 }
6cff3e85 5242 qemu_mutex_lock(&mon->out_lock);
a7aec5da 5243 mon->mux_out = 1;
6cff3e85 5244 qemu_mutex_unlock(&mon->out_lock);
2724b180 5245 break;
86e94dea 5246
b6b8df56 5247 case CHR_EVENT_OPENED:
2724b180
AL
5248 monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
5249 "information\n", QEMU_VERSION);
a7aec5da 5250 if (!mon->mux_out) {
e5554e20 5251 readline_restart(mon->rs);
2724b180 5252 readline_show_prompt(mon->rs);
a7aec5da
GH
5253 }
5254 mon->reset_seen = 1;
efb87c16
CB
5255 mon_refcount++;
5256 break;
5257
5258 case CHR_EVENT_CLOSED:
5259 mon_refcount--;
5260 monitor_fdsets_cleanup();
2724b180
AL
5261 break;
5262 }
86e94dea
TS
5263}
5264
816f8925
WX
5265static int
5266compare_mon_cmd(const void *a, const void *b)
5267{
5268 return strcmp(((const mon_cmd_t *)a)->name,
5269 ((const mon_cmd_t *)b)->name);
5270}
5271
5272static void sortcmdlist(void)
5273{
5274 int array_num;
5275 int elem_size = sizeof(mon_cmd_t);
5276
5277 array_num = sizeof(mon_cmds)/elem_size-1;
5278 qsort((void *)mon_cmds, array_num, elem_size, compare_mon_cmd);
5279
5280 array_num = sizeof(info_cmds)/elem_size-1;
5281 qsort((void *)info_cmds, array_num, elem_size, compare_mon_cmd);
5282}
5283
76655d6d
AL
5284
5285/*
5286 * Local variables:
5287 * c-indent-level: 4
5288 * c-basic-offset: 4
5289 * tab-width: 8
5290 * End:
5291 */
5292
c60bf339
SH
5293/* These functions just adapt the readline interface in a typesafe way. We
5294 * could cast function pointers but that discards compiler checks.
5295 */
d5d1507b
SW
5296static void GCC_FMT_ATTR(2, 3) monitor_readline_printf(void *opaque,
5297 const char *fmt, ...)
c60bf339
SH
5298{
5299 va_list ap;
5300 va_start(ap, fmt);
5301 monitor_vprintf(opaque, fmt, ap);
5302 va_end(ap);
5303}
5304
5305static void monitor_readline_flush(void *opaque)
5306{
5307 monitor_flush(opaque);
5308}
5309
d622cb58
PB
5310static void __attribute__((constructor)) monitor_lock_init(void)
5311{
5312 qemu_mutex_init(&monitor_lock);
5313}
5314
731b0364 5315void monitor_init(CharDriverState *chr, int flags)
aa455485 5316{
731b0364 5317 static int is_first_init = 1;
87127161 5318 Monitor *mon;
20d8a3ed
TS
5319
5320 if (is_first_init) {
43a14cfc 5321 monitor_qapi_event_init();
d038317c 5322 sortcmdlist();
20d8a3ed
TS
5323 is_first_init = 0;
5324 }
87127161 5325
b01fe89e
WX
5326 mon = g_malloc(sizeof(*mon));
5327 monitor_data_init(mon);
20d8a3ed 5328
87127161 5329 mon->chr = chr;
731b0364 5330 mon->flags = flags;
cde76ee1 5331 if (flags & MONITOR_USE_READLINE) {
c60bf339
SH
5332 mon->rs = readline_init(monitor_readline_printf,
5333 monitor_readline_flush,
5334 mon,
5335 monitor_find_completion);
cde76ee1
AL
5336 monitor_read_command(mon, 0);
5337 }
87127161 5338
9b57c02e 5339 if (monitor_ctrl_mode(mon)) {
7267c094 5340 mon->mc = g_malloc0(sizeof(MonitorControl));
9b57c02e
LC
5341 /* Control mode requires special handlers */
5342 qemu_chr_add_handlers(chr, monitor_can_read, monitor_control_read,
5343 monitor_control_event, mon);
15f31519 5344 qemu_chr_fe_set_echo(chr, true);
26efaca3
AL
5345
5346 json_message_parser_init(&mon->mc->parser, handle_qmp_command);
9b57c02e
LC
5347 } else {
5348 qemu_chr_add_handlers(chr, monitor_can_read, monitor_read,
5349 monitor_event, mon);
5350 }
87127161 5351
d622cb58 5352 qemu_mutex_lock(&monitor_lock);
72cf2d4f 5353 QLIST_INSERT_HEAD(&mon_list, mon, entry);
d622cb58
PB
5354 qemu_mutex_unlock(&monitor_lock);
5355
8631b608
MA
5356 if (!default_mon || (flags & MONITOR_IS_DEFAULT))
5357 default_mon = mon;
aa455485
FB
5358}
5359
c60bf339
SH
5360static void bdrv_password_cb(void *opaque, const char *password,
5361 void *readline_opaque)
81d0912d 5362{
c60bf339
SH
5363 Monitor *mon = opaque;
5364 BlockDriverState *bs = readline_opaque;
bb5fc20f 5365 int ret = 0;
4d2855a3 5366 Error *local_err = NULL;
81d0912d 5367
4d2855a3
MA
5368 bdrv_add_key(bs, password, &local_err);
5369 if (local_err) {
5370 monitor_printf(mon, "%s\n", error_get_pretty(local_err));
5371 error_free(local_err);
bb5fc20f 5372 ret = -EPERM;
9dc39cba 5373 }
731b0364
AL
5374 if (mon->password_completion_cb)
5375 mon->password_completion_cb(mon->password_opaque, ret);
bb5fc20f 5376
731b0364 5377 monitor_read_command(mon, 1);
9dc39cba 5378}
c0f4ce77 5379
7060b478
AL
5380ReadLineState *monitor_get_rs(Monitor *mon)
5381{
5382 return mon->rs;
5383}
5384
0bbc47bb 5385int monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
097310b5 5386 BlockCompletionFunc *completion_cb,
0bbc47bb 5387 void *opaque)
c0f4ce77 5388{
cde76ee1
AL
5389 int err;
5390
376253ec
AL
5391 monitor_printf(mon, "%s (%s) is encrypted.\n", bdrv_get_device_name(bs),
5392 bdrv_get_encrypted_filename(bs));
bb5fc20f 5393
731b0364
AL
5394 mon->password_completion_cb = completion_cb;
5395 mon->password_opaque = opaque;
bb5fc20f 5396
cde76ee1
AL
5397 err = monitor_read_password(mon, bdrv_password_cb, bs);
5398
5399 if (err && completion_cb)
5400 completion_cb(opaque, err);
0bbc47bb
LC
5401
5402 return err;
c0f4ce77 5403}
e42e818b
LC
5404
5405int monitor_read_block_device_key(Monitor *mon, const char *device,
097310b5 5406 BlockCompletionFunc *completion_cb,
e42e818b
LC
5407 void *opaque)
5408{
9b14e0ef 5409 Error *err = NULL;
5560625b 5410 BlockBackend *blk;
e42e818b 5411
5560625b
FZ
5412 blk = blk_by_name(device);
5413 if (!blk) {
e42e818b
LC
5414 monitor_printf(mon, "Device not found %s\n", device);
5415 return -1;
5416 }
5417
9b14e0ef
MA
5418 bdrv_add_key(blk_bs(blk), NULL, &err);
5419 if (err) {
5420 error_free(err);
5421 return monitor_read_bdrv_key_start(mon, blk_bs(blk), completion_cb, opaque);
5422 }
5423
5424 if (completion_cb) {
5425 completion_cb(opaque, 0);
5426 }
5427 return 0;
e42e818b 5428}
4d454574
PB
5429
5430QemuOptsList qemu_mon_opts = {
5431 .name = "mon",
5432 .implied_opt_name = "chardev",
5433 .head = QTAILQ_HEAD_INITIALIZER(qemu_mon_opts.head),
5434 .desc = {
5435 {
5436 .name = "mode",
5437 .type = QEMU_OPT_STRING,
5438 },{
5439 .name = "chardev",
5440 .type = QEMU_OPT_STRING,
5441 },{
5442 .name = "default",
5443 .type = QEMU_OPT_BOOL,
5444 },{
5445 .name = "pretty",
5446 .type = QEMU_OPT_BOOL,
5447 },
5448 { /* end of list */ }
5449 },
5450};
f2ae8abf
MT
5451
5452#ifndef TARGET_I386
5453void qmp_rtc_reset_reinjection(Error **errp)
5454{
5455 error_set(errp, QERR_FEATURE_DISABLED, "rtc-reset-reinjection");
5456}
5457#endif