]> git.ipfire.org Git - thirdparty/qemu.git/blame - monitor.c
projects / thirdparty / qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
char: generalize qemu_chr_write_all()
[thirdparty/qemu.git] / monitor.c
CommitLineData
9dc39cba
FB		 1/*
2 * QEMU monitor
5fafdf24 3 *
9dc39cba 4 * Copyright (c) 2003-2004 Fabrice Bellard
5fafdf24 5 *
9dc39cba
FB		 6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
d38ea87a 24#include "qemu/osdep.h"
511d2b14 25#include <dirent.h>
33c11879
PB		 26#include "qemu-common.h"
27#include "cpu.h"
87ecb68b 28#include "hw/hw.h"
b4a42f81 29#include "monitor/qdev.h"
87ecb68b 30#include "hw/usb.h"
0d09e41a 31#include "hw/i386/pc.h"
a2cb15b0 32#include "hw/pci/pci.h"
0d09e41a 33#include "sysemu/watchdog.h"
45a50b16 34#include "hw/loader.h"
022c62cb 35#include "exec/gdbstub.h"
1422e32d 36#include "net/net.h"
68ac40d2 37#include "net/slirp.h"
8228e353 38#include "chardev/char.h"
7572150c 39#include "ui/qemu-spice.h"
e35704ba 40#include "sysemu/numa.h"
83c9089e 41#include "monitor/monitor.h"
213dcb06 42#include "qemu/config-file.h"
0150cd81 43#include "qemu/readline.h"
28ecbaee 44#include "ui/console.h"
c751a74a 45#include "ui/input.h"
9c17d615 46#include "sysemu/blockdev.h"
da27a00e 47#include "sysemu/block-backend.h"
87ecb68b 48#include "audio/audio.h"
76cad711 49#include "disas/disas.h"
9c17d615 50#include "sysemu/balloon.h"
1de7afc9 51#include "qemu/timer.h"
b3946626 52#include "sysemu/hw_accel.h"
1de7afc9 53#include "qemu/acl.h"
bdee56f5 54#include "sysemu/tpm.h"
cc7a8ea7 55#include "qapi/qmp/qerror.h"
c7eb39cb 56#include "qapi/qmp/types.h"
7b1b5d19
PB		 57#include "qapi/qmp/qjson.h"
58#include "qapi/qmp/json-streamer.h"
59#include "qapi/qmp/json-parser.h"
a9c94277 60#include "qom/object_interfaces.h"
0ab8ed18 61#include "trace-root.h"
31965ae2 62#include "trace/control.h"
bf957284 63#include "monitor/hmp-target.h"
6d8a764e 64#ifdef CONFIG_TRACE_SIMPLE
31965ae2 65#include "trace/simple.h"
22890ab5 66#endif
022c62cb 67#include "exec/memory.h"
63c91552 68#include "exec/exec-all.h"
03dd024f 69#include "qemu/log.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"
39a18158 76#include "qmp-introspect.h"
dc599978 77#include "sysemu/qtest.h"
d2528bdc 78#include "sysemu/cpus.h"
f348b6d1 79#include "qemu/cutils.h"
edcfaefe 80#include "qapi/qmp/dispatch.h"
6a5bd307 81
a4538a5c
JH		 82#if defined(TARGET_S390X)
83#include "hw/s390x/storage-keys.h"
84#endif
85
9307c4c1
FB		 86/*
87 * Supported types:
5fafdf24 88 *
9307c4c1 89 * 'F' filename
81d0912d 90 * 'B' block device name
9307c4c1 91 * 's' string (accept optional quote)
129be006 92 * 'S' it just appends the rest of the string (accept optional quote)
361127df
MA		 93 * 'O' option string of the form NAME=VALUE,...
94 * parsed according to QemuOptsList given by its name
95 * Example: 'device:O' uses qemu_device_opts.
96 * Restriction: only lists with empty desc are supported
97 * TODO lift the restriction
92a31b1f
FB		 98 * 'i' 32 bit integer
99 * 'l' target long (32 or 64 bit)
91162849
LC		 100 * 'M' Non-negative target long (32 or 64 bit), in user mode the
101 * value is multiplied by 2^20 (think Mebibyte)
dbc0c67f 102 * 'o' octets (aka bytes)
5e00984a
KW		 103 * user mode accepts an optional E, e, P, p, T, t, G, g, M, m,
104 * K, k suffix, which multiplies the value by 2^60 for suffixes E
105 * and e, 2^50 for suffixes P and p, 2^40 for suffixes T and t,
106 * 2^30 for suffixes G and g, 2^20 for M and m, 2^10 for K and k
fccfb11e
MA		 107 * 'T' double
108 * user mode accepts an optional ms, us, ns suffix,
109 * which divides the value by 1e3, 1e6, 1e9, respectively
9307c4c1
FB		 110 * '/' optional gdb-like print format (like "/10x")
111 *
fb46660e
LC		 112 * '?' optional type (for all types, except '/')
113 * '.' other form of optional type (for 'i' and 'l')
942cd1f2
MA		 114 * 'b' boolean
115 * user mode accepts "on" or "off"
fb46660e 116 * '-' optional parameter (eg. '-f')
9307c4c1
FB		 117 *
118 */
119
c227f099 120typedef struct mon_cmd_t {
9dc39cba 121 const char *name;
9307c4c1 122 const char *args_type;
9dc39cba
FB		 123 const char *params;
124 const char *help;
2b9e3576
MAL		 125 void (*cmd)(Monitor *mon, const QDict *qdict);
126 /* @sub_table is a list of 2nd level of commands. If it does not exist,
127 * cmd should be used. If it exists, sub_table[?].cmd should be
128 * used, and cmd of 1st level plays the role of help function.
5f3d335f
WX		 129 */
130 struct mon_cmd_t *sub_table;
bfa40f77 131 void (*command_completion)(ReadLineState *rs, int nb_args, const char *str);
c227f099 132} mon_cmd_t;
9dc39cba 133
f07918fd 134/* file descriptors passed via SCM_RIGHTS */
c227f099
AL		 135typedef struct mon_fd_t mon_fd_t;
136struct mon_fd_t {
f07918fd
MM		 137 char *name;
138 int fd;
c227f099 139 QLIST_ENTRY(mon_fd_t) next;
f07918fd
MM		 140};
141
ba1c048a
CB		 142/* file descriptor associated with a file descriptor set */
143typedef struct MonFdsetFd MonFdsetFd;
144struct MonFdsetFd {
145 int fd;
146 bool removed;
147 char *opaque;
148 QLIST_ENTRY(MonFdsetFd) next;
149};
150
151/* file descriptor set containing fds passed via SCM_RIGHTS */
152typedef struct MonFdset MonFdset;
153struct MonFdset {
154 int64_t id;
155 QLIST_HEAD(, MonFdsetFd) fds;
adb696f3 156 QLIST_HEAD(, MonFdsetFd) dup_fds;
ba1c048a
CB		 157 QLIST_ENTRY(MonFdset) next;
158};
159
74358f2a 160typedef struct {
5fa737a4 161 JSONMessageParser parser;
f994b258
MA		 162 /*
163 * When a client connects, we're in capabilities negotiation mode.
164 * When command qmp_capabilities succeeds, we go into command
165 * mode.
166 */
635db18f 167 QmpCommandList *commands;
74358f2a 168} MonitorQMP;
5fa737a4 169
afeecec2
DB		 170/*
171 * To prevent flooding clients, events can be throttled. The
172 * throttling is calculated globally, rather than per-Monitor
173 * instance.
174 */
43a14cfc 175typedef struct MonitorQAPIEventState {
7de0be65
MA		 176 QAPIEvent event; /* Throttling state for this event type and... */
177 QDict *data; /* ... data, see qapi_event_throttle_equal() */
afeecec2 178 QEMUTimer *timer; /* Timer for handling delayed events */
688b4b7d 179 QDict *qdict; /* Delayed event (if any) */
43a14cfc 180} MonitorQAPIEventState;
afeecec2 181
b9b03ab0
MA		 182typedef struct {
183 int64_t rate; /* Minimum time (in ns) between two events */
184} MonitorQAPIEventConf;
185
87127161 186struct Monitor {
32a6ebec 187 CharBackend chr;
a7aec5da 188 int reset_seen;
731b0364
AL		 189 int flags;
190 int suspend_cnt;
48c043d0 191 bool skip_flush;
6cff3e85
PB		 192
193 QemuMutex out_lock;
e1f2641b 194 QString *outbuf;
6cff3e85
PB		 195 guint out_watch;
196
197 /* Read under either BQL or out_lock, written with BQL+out_lock. */
198 int mux_out;
199
731b0364 200 ReadLineState *rs;
74358f2a 201 MonitorQMP qmp;
cb446eca 202 CPUState *mon_cpu;
097310b5 203 BlockCompletionFunc *password_completion_cb;
731b0364 204 void *password_opaque;
7717239d 205 mon_cmd_t *cmd_table;
c227f099 206 QLIST_HEAD(,mon_fd_t) fds;
72cf2d4f 207 QLIST_ENTRY(Monitor) entry;
87127161
AL		 208};
209
2dbc8db0
LC		 210/* QMP checker flags */
211#define QMP_ACCEPT_UNKNOWNS 1
212
d622cb58
PB		 213/* Protects mon_list, monitor_event_state. */
214static QemuMutex monitor_lock;
215
72cf2d4f 216static QLIST_HEAD(mon_list, Monitor) mon_list;
ba1c048a 217static QLIST_HEAD(mon_fdsets, MonFdset) mon_fdsets;
efb87c16 218static int mon_refcount;
7e2515e8 219
816f8925
WX		 220static mon_cmd_t mon_cmds[];
221static mon_cmd_t info_cmds[];
9dc39cba 222
635db18f 223QmpCommandList qmp_commands, qmp_cap_negotiation_commands;
1527badb 224
8631b608 225Monitor *cur_mon;
376253ec 226
dc599978
AG		 227static QEMUClockType event_clock_type = QEMU_CLOCK_REALTIME;
228
c60bf339
SH		 229static void monitor_command_cb(void *opaque, const char *cmdline,
230 void *readline_opaque);
83ab7950 231
9f3982f2
MA		 232/**
233 * Is @mon a QMP monitor?
234 */
235static inline bool monitor_is_qmp(const Monitor *mon)
418173c7
LC		 236{
237 return (mon->flags & MONITOR_USE_CONTROL);
238}
239
489653b5
MA		 240/**
241 * Is the current monitor, if any, a QMP monitor?
242 */
243bool monitor_cur_is_qmp(void)
6620d3ce 244{
9f3982f2 245 return cur_mon && monitor_is_qmp(cur_mon);
6620d3ce
MA		 246}
247
7060b478 248void monitor_read_command(Monitor *mon, int show_prompt)
731b0364 249{
183e6e52
LC		 250 if (!mon->rs)
251 return;
252
731b0364
AL		 253 readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL);
254 if (show_prompt)
255 readline_show_prompt(mon->rs);
256}
6a00d601 257
7060b478
AL		 258int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
259 void *opaque)
bb5fc20f 260{
bcf5d19c 261 if (mon->rs) {
cde76ee1
AL		 262 readline_start(mon->rs, "Password: ", 1, readline_func, opaque);
263 /* prompt is printed on return from the command handler */
264 return 0;
265 } else {
266 monitor_printf(mon, "terminal does not support password prompting\n");
267 return -ENOTTY;
268 }
bb5fc20f
AL		 269}
270
6cff3e85
PB		 271static void monitor_flush_locked(Monitor *mon);
272
f628926b
GH		 273static gboolean monitor_unblocked(GIOChannel *chan, GIOCondition cond,
274 void *opaque)
275{
293d2a00
LE		 276 Monitor *mon = opaque;
277
6cff3e85
PB		 278 qemu_mutex_lock(&mon->out_lock);
279 mon->out_watch = 0;
280 monitor_flush_locked(mon);
281 qemu_mutex_unlock(&mon->out_lock);
f628926b
GH		 282 return FALSE;
283}
284
6cff3e85
PB		 285/* Called with mon->out_lock held. */
286static void monitor_flush_locked(Monitor *mon)
7e2515e8 287{
f628926b 288 int rc;
e1f2641b
LC		 289 size_t len;
290 const char *buf;
291
48c043d0
LC		 292 if (mon->skip_flush) {
293 return;
294 }
295
e1f2641b
LC		 296 buf = qstring_get_str(mon->outbuf);
297 len = qstring_get_length(mon->outbuf);
f628926b 298
a4cc73d6 299 if (len && !mon->mux_out) {
5345fdb4 300 rc = qemu_chr_fe_write(&mon->chr, (const uint8_t *) buf, len);
056f49ff
SP		 301 if ((rc < 0 && errno != EAGAIN) || (rc == len)) {
302 /* all flushed or error */
e1f2641b
LC		 303 QDECREF(mon->outbuf);
304 mon->outbuf = qstring_new();
f628926b
GH		 305 return;
306 }
307 if (rc > 0) {
3b7c78c8 308 /* partial write */
e1f2641b
LC		 309 QString *tmp = qstring_from_str(buf + rc);
310 QDECREF(mon->outbuf);
311 mon->outbuf = tmp;
f628926b 312 }
6cff3e85 313 if (mon->out_watch == 0) {
32a6ebec 314 mon->out_watch =
5345fdb4 315 qemu_chr_fe_add_watch(&mon->chr, G_IO_OUT | G_IO_HUP,
32a6ebec 316 monitor_unblocked, mon);
293d2a00 317 }
7e2515e8
FB		 318 }
319}
320
6cff3e85
PB		 321void monitor_flush(Monitor *mon)
322{
323 qemu_mutex_lock(&mon->out_lock);
324 monitor_flush_locked(mon);
325 qemu_mutex_unlock(&mon->out_lock);
326}
327
e1f2641b 328/* flush at every end of line */
376253ec 329static void monitor_puts(Monitor *mon, const char *str)
7e2515e8 330{
60fe76f3 331 char c;
731b0364 332
6cff3e85 333 qemu_mutex_lock(&mon->out_lock);
7e2515e8
FB		 334 for(;;) {
335 c = *str++;
336 if (c == '\0')
337 break;
e1f2641b
LC		 338 if (c == '\n') {
339 qstring_append_chr(mon->outbuf, '\r');
340 }
341 qstring_append_chr(mon->outbuf, c);
342 if (c == '\n') {
6cff3e85 343 monitor_flush_locked(mon);
e1f2641b 344 }
7e2515e8 345 }
6cff3e85 346 qemu_mutex_unlock(&mon->out_lock);
7e2515e8
FB		 347}
348
376253ec 349void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
9dc39cba 350{
e1f2641b 351 char *buf;
b8b08266 352
2daa1191
LC		 353 if (!mon)
354 return;
355
9f3982f2 356 if (monitor_is_qmp(mon)) {
b8b08266 357 return;
4a29a85d 358 }
b8b08266 359
e1f2641b 360 buf = g_strdup_vprintf(fmt, ap);
b8b08266 361 monitor_puts(mon, buf);
e1f2641b 362 g_free(buf);
9dc39cba
FB		 363}
364
376253ec 365void monitor_printf(Monitor *mon, const char *fmt, ...)
9dc39cba 366{
7e2515e8
FB		 367 va_list ap;
368 va_start(ap, fmt);
376253ec 369 monitor_vprintf(mon, fmt, ap);
7e2515e8 370 va_end(ap);
9dc39cba
FB		 371}
372
caf15319 373int monitor_fprintf(FILE *stream, const char *fmt, ...)
7fe48483
FB		 374{
375 va_list ap;
376 va_start(ap, fmt);
376253ec 377 monitor_vprintf((Monitor *)stream, fmt, ap);
7fe48483
FB		 378 va_end(ap);
379 return 0;
380}
381
9b57c02e
LC		 382static void monitor_json_emitter(Monitor *mon, const QObject *data)
383{
384 QString *json;
385
83a27d4d
LC		 386 json = mon->flags & MONITOR_USE_PRETTY ? qobject_to_json_pretty(data) :
387 qobject_to_json(data);
9b57c02e
LC		 388 assert(json != NULL);
389
b8b08266
LC		 390 qstring_append_chr(json, '\n');
391 monitor_puts(mon, qstring_get_str(json));
4a29a85d 392
9b57c02e
LC		 393 QDECREF(json);
394}
395
7fb1cf16 396static MonitorQAPIEventConf monitor_qapi_event_conf[QAPI_EVENT__MAX] = {
b9b03ab0
MA		 397 /* Limit guest-triggerable events to 1 per second */
398 [QAPI_EVENT_RTC_CHANGE] = { 1000 * SCALE_MS },
399 [QAPI_EVENT_WATCHDOG] = { 1000 * SCALE_MS },
400 [QAPI_EVENT_BALLOON_CHANGE] = { 1000 * SCALE_MS },
401 [QAPI_EVENT_QUORUM_REPORT_BAD] = { 1000 * SCALE_MS },
402 [QAPI_EVENT_QUORUM_FAILURE] = { 1000 * SCALE_MS },
403 [QAPI_EVENT_VSERPORT_CHANGE] = { 1000 * SCALE_MS },
404};
405
a24712af 406GHashTable *monitor_qapi_event_state;
afeecec2
DB		 407
408/*
43a14cfc 409 * Emits the event to every monitor instance, @event is only used for trace
d622cb58 410 * Called with monitor_lock held.
afeecec2 411 */
688b4b7d 412static void monitor_qapi_event_emit(QAPIEvent event, QDict *qdict)
afeecec2
DB		 413{
414 Monitor *mon;
415
688b4b7d 416 trace_monitor_protocol_event_emit(event, qdict);
afeecec2 417 QLIST_FOREACH(mon, &mon_list, entry) {
635db18f
MA		 418 if (monitor_is_qmp(mon)
419 && mon->qmp.commands != &qmp_cap_negotiation_commands) {
688b4b7d 420 monitor_json_emitter(mon, QOBJECT(qdict));
afeecec2
DB		 421 }
422 }
423}
424
a24712af
MA		 425static void monitor_qapi_event_handler(void *opaque);
426
afeecec2
DB		 427/*
428 * Queue a new event for emission to Monitor instances,
429 * applying any rate limiting if required.
430 */
431static void
688b4b7d 432monitor_qapi_event_queue(QAPIEvent event, QDict *qdict, Error **errp)
afeecec2 433{
b9b03ab0 434 MonitorQAPIEventConf *evconf;
43a14cfc 435 MonitorQAPIEventState *evstate;
afeecec2 436
7fb1cf16 437 assert(event < QAPI_EVENT__MAX);
b9b03ab0 438 evconf = &monitor_qapi_event_conf[event];
b9b03ab0 439 trace_monitor_protocol_event_queue(event, qdict, evconf->rate);
afeecec2 440
d622cb58 441 qemu_mutex_lock(&monitor_lock);
93f8f982 442
b9b03ab0 443 if (!evconf->rate) {
93f8f982 444 /* Unthrottled event */
688b4b7d 445 monitor_qapi_event_emit(event, qdict);
afeecec2 446 } else {
7de0be65
MA		 447 QDict *data = qobject_to_qdict(qdict_get(qdict, "data"));
448 MonitorQAPIEventState key = { .event = event, .data = data };
a24712af
MA		 449
450 evstate = g_hash_table_lookup(monitor_qapi_event_state, &key);
451 assert(!evstate || timer_pending(evstate->timer));
452
453 if (evstate) {
93f8f982 454 /*
b9b03ab0 455 * Timer is pending for (at least) evconf->rate ns after
93f8f982
MA		 456 * last send. Store event for sending when timer fires,
457 * replacing a prior stored event if any.
afeecec2 458 */
93f8f982 459 QDECREF(evstate->qdict);
688b4b7d
MA		 460 evstate->qdict = qdict;
461 QINCREF(evstate->qdict);
afeecec2 462 } else {
93f8f982 463 /*
b9b03ab0 464 * Last send was (at least) evconf->rate ns ago.
93f8f982 465 * Send immediately, and arm the timer to call
b9b03ab0 466 * monitor_qapi_event_handler() in evconf->rate ns. Any
93f8f982
MA		 467 * events arriving before then will be delayed until then.
468 */
dc599978 469 int64_t now = qemu_clock_get_ns(event_clock_type);
93f8f982 470
688b4b7d 471 monitor_qapi_event_emit(event, qdict);
a24712af
MA		 472
473 evstate = g_new(MonitorQAPIEventState, 1);
474 evstate->event = event;
7de0be65
MA		 475 evstate->data = data;
476 QINCREF(evstate->data);
a24712af 477 evstate->qdict = NULL;
dc599978 478 evstate->timer = timer_new_ns(event_clock_type,
a24712af
MA		 479 monitor_qapi_event_handler,
480 evstate);
481 g_hash_table_add(monitor_qapi_event_state, evstate);
b9b03ab0 482 timer_mod_ns(evstate->timer, now + evconf->rate);
afeecec2
DB		 483 }
484 }
93f8f982 485
d622cb58 486 qemu_mutex_unlock(&monitor_lock);
afeecec2
DB		 487}
488
afeecec2 489/*
b9b03ab0 490 * This function runs evconf->rate ns after sending a throttled
93f8f982
MA		 491 * event.
492 * If another event has since been stored, send it.
afeecec2 493 */
43a14cfc 494static void monitor_qapi_event_handler(void *opaque)
afeecec2 495{
43a14cfc 496 MonitorQAPIEventState *evstate = opaque;
b9b03ab0 497 MonitorQAPIEventConf *evconf = &monitor_qapi_event_conf[evstate->event];
afeecec2 498
93f8f982 499 trace_monitor_protocol_event_handler(evstate->event, evstate->qdict);
d622cb58 500 qemu_mutex_lock(&monitor_lock);
93f8f982 501
688b4b7d 502 if (evstate->qdict) {
dc599978 503 int64_t now = qemu_clock_get_ns(event_clock_type);
93f8f982 504
688b4b7d
MA		 505 monitor_qapi_event_emit(evstate->event, evstate->qdict);
506 QDECREF(evstate->qdict);
507 evstate->qdict = NULL;
b9b03ab0 508 timer_mod_ns(evstate->timer, now + evconf->rate);
a24712af
MA		 509 } else {
510 g_hash_table_remove(monitor_qapi_event_state, evstate);
7de0be65 511 QDECREF(evstate->data);
a24712af
MA		 512 timer_free(evstate->timer);
513 g_free(evstate);
afeecec2 514 }
93f8f982 515
d622cb58 516 qemu_mutex_unlock(&monitor_lock);
afeecec2
DB		 517}
518
a24712af 519static unsigned int qapi_event_throttle_hash(const void *key)
afeecec2 520{
a24712af 521 const MonitorQAPIEventState *evstate = key;
7de0be65 522 unsigned int hash = evstate->event * 255;
afeecec2 523
7de0be65
MA		 524 if (evstate->event == QAPI_EVENT_VSERPORT_CHANGE) {
525 hash += g_str_hash(qdict_get_str(evstate->data, "id"));
526 }
527
6d425eb9
AG		 528 if (evstate->event == QAPI_EVENT_QUORUM_REPORT_BAD) {
529 hash += g_str_hash(qdict_get_str(evstate->data, "node-name"));
530 }
531
7de0be65 532 return hash;
a24712af 533}
0d1ea871 534
a24712af
MA		 535static gboolean qapi_event_throttle_equal(const void *a, const void *b)
536{
537 const MonitorQAPIEventState *eva = a;
538 const MonitorQAPIEventState *evb = b;
539
7de0be65
MA		 540 if (eva->event != evb->event) {
541 return FALSE;
542 }
543
544 if (eva->event == QAPI_EVENT_VSERPORT_CHANGE) {
545 return !strcmp(qdict_get_str(eva->data, "id"),
546 qdict_get_str(evb->data, "id"));
547 }
548
6d425eb9
AG		 549 if (eva->event == QAPI_EVENT_QUORUM_REPORT_BAD) {
550 return !strcmp(qdict_get_str(eva->data, "node-name"),
551 qdict_get_str(evb->data, "node-name"));
552 }
553
7de0be65 554 return TRUE;
a24712af
MA		 555}
556
557static void monitor_qapi_event_init(void)
558{
dc599978
AG		 559 if (qtest_enabled()) {
560 event_clock_type = QEMU_CLOCK_VIRTUAL;
561 }
562
a24712af
MA		 563 monitor_qapi_event_state = g_hash_table_new(qapi_event_throttle_hash,
564 qapi_event_throttle_equal);
43a14cfc 565 qmp_event_set_func_emit(monitor_qapi_event_queue);
0d1ea871
LC		 566}
567
7ef6cf63 568static void handle_hmp_command(Monitor *mon, const char *cmdline);
0268d97c 569
b01fe89e
WX		 570static void monitor_data_init(Monitor *mon)
571{
572 memset(mon, 0, sizeof(Monitor));
6cff3e85 573 qemu_mutex_init(&mon->out_lock);
b01fe89e 574 mon->outbuf = qstring_new();
7717239d
WX		 575 /* Use *mon_cmds by default. */
576 mon->cmd_table = mon_cmds;
b01fe89e
WX		 577}
578
579static void monitor_data_destroy(Monitor *mon)
580{
c39860e6 581 qemu_chr_fe_deinit(&mon->chr);
2ef45716
MAL		 582 if (monitor_is_qmp(mon)) {
583 json_message_parser_destroy(&mon->qmp.parser);
584 }
585 g_free(mon->rs);
b01fe89e 586 QDECREF(mon->outbuf);
6cff3e85 587 qemu_mutex_destroy(&mon->out_lock);
b01fe89e
WX		 588}
589
d51a67b4
LC		 590char *qmp_human_monitor_command(const char *command_line, bool has_cpu_index,
591 int64_t cpu_index, Error **errp)
0268d97c 592{
d51a67b4 593 char *output = NULL;
0268d97c 594 Monitor *old_mon, hmp;
0268d97c 595
b01fe89e 596 monitor_data_init(&hmp);
48c043d0 597 hmp.skip_flush = true;
0268d97c
LC		 598
599 old_mon = cur_mon;
600 cur_mon = &hmp;
601
d51a67b4
LC		 602 if (has_cpu_index) {
603 int ret = monitor_set_cpu(cpu_index);
0268d97c
LC		 604 if (ret < 0) {
605 cur_mon = old_mon;
c6bd8c70
MA		 606 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
607 "a CPU number");
0268d97c
LC		 608 goto out;
609 }
610 }
611
7ef6cf63 612 handle_hmp_command(&hmp, command_line);
0268d97c
LC		 613 cur_mon = old_mon;
614
6cff3e85 615 qemu_mutex_lock(&hmp.out_lock);
48c043d0
LC		 616 if (qstring_get_length(hmp.outbuf) > 0) {
617 output = g_strdup(qstring_get_str(hmp.outbuf));
d51a67b4
LC		 618 } else {
619 output = g_strdup("");
0268d97c 620 }
6cff3e85 621 qemu_mutex_unlock(&hmp.out_lock);
0268d97c
LC		 622
623out:
b01fe89e 624 monitor_data_destroy(&hmp);
d51a67b4 625 return output;
0268d97c
LC		 626}
627
9dc39cba
FB		 628static int compare_cmd(const char *name, const char *list)
629{
630 const char *p, *pstart;
631 int len;
632 len = strlen(name);
633 p = list;
634 for(;;) {
635 pstart = p;
636 p = strchr(p, '|');
637 if (!p)
638 p = pstart + strlen(pstart);
639 if ((p - pstart) == len && !memcmp(pstart, name, len))
640 return 1;
641 if (*p == '\0')
642 break;
643 p++;
644 }
645 return 0;
646}
647
f5438c05
WX		 648static int get_str(char *buf, int buf_size, const char **pp)
649{
650 const char *p;
651 char *q;
652 int c;
653
654 q = buf;
655 p = *pp;
656 while (qemu_isspace(*p)) {
657 p++;
658 }
659 if (*p == '\0') {
660 fail:
661 *q = '\0';
662 *pp = p;
663 return -1;
664 }
665 if (*p == '\"') {
666 p++;
667 while (*p != '\0' && *p != '\"') {
668 if (*p == '\\') {
669 p++;
670 c = *p++;
671 switch (c) {
672 case 'n':
673 c = '\n';
674 break;
675 case 'r':
676 c = '\r';
677 break;
678 case '\\':
679 case '\'':
680 case '\"':
681 break;
682 default:
71baf787 683 printf("unsupported escape code: '\\%c'\n", c);
f5438c05
WX		 684 goto fail;
685 }
686 if ((q - buf) < buf_size - 1) {
687 *q++ = c;
688 }
689 } else {
690 if ((q - buf) < buf_size - 1) {
691 *q++ = *p;
692 }
693 p++;
694 }
695 }
696 if (*p != '\"') {
71baf787 697 printf("unterminated string\n");
f5438c05
WX		 698 goto fail;
699 }
700 p++;
701 } else {
702 while (*p != '\0' && !qemu_isspace(*p)) {
703 if ((q - buf) < buf_size - 1) {
704 *q++ = *p;
705 }
706 p++;
707 }
708 }
709 *q = '\0';
710 *pp = p;
711 return 0;
712}
713
714#define MAX_ARGS 16
715
dcc70cdf
WX		 716static void free_cmdline_args(char **args, int nb_args)
717{
718 int i;
719
720 assert(nb_args <= MAX_ARGS);
721
722 for (i = 0; i < nb_args; i++) {
723 g_free(args[i]);
724 }
725
726}
727
728/*
729 * Parse the command line to get valid args.
730 * @cmdline: command line to be parsed.
731 * @pnb_args: location to store the number of args, must NOT be NULL.
732 * @args: location to store the args, which should be freed by caller, must
733 * NOT be NULL.
734 *
735 * Returns 0 on success, negative on failure.
736 *
737 * NOTE: this parser is an approximate form of the real command parser. Number
738 * of args have a limit of MAX_ARGS. If cmdline contains more, it will
739 * return with failure.
740 */
741static int parse_cmdline(const char *cmdline,
742 int *pnb_args, char **args)
f5438c05
WX		 743{
744 const char *p;
745 int nb_args, ret;
746 char buf[1024];
747
748 p = cmdline;
749 nb_args = 0;
750 for (;;) {
751 while (qemu_isspace(*p)) {
752 p++;
753 }
754 if (*p == '\0') {
755 break;
756 }
757 if (nb_args >= MAX_ARGS) {
dcc70cdf 758 goto fail;
f5438c05
WX		 759 }
760 ret = get_str(buf, sizeof(buf), &p);
f5438c05 761 if (ret < 0) {
dcc70cdf 762 goto fail;
f5438c05 763 }
dcc70cdf
WX		 764 args[nb_args] = g_strdup(buf);
765 nb_args++;
f5438c05
WX		 766 }
767 *pnb_args = nb_args;
dcc70cdf
WX		 768 return 0;
769
770 fail:
771 free_cmdline_args(args, nb_args);
772 return -1;
f5438c05
WX		 773}
774
66855495
WX		 775static void help_cmd_dump_one(Monitor *mon,
776 const mon_cmd_t *cmd,
777 char **prefix_args,
778 int prefix_args_nb)
779{
780 int i;
781
782 for (i = 0; i < prefix_args_nb; i++) {
783 monitor_printf(mon, "%s ", prefix_args[i]);
784 }
785 monitor_printf(mon, "%s %s -- %s\n", cmd->name, cmd->params, cmd->help);
786}
787
788/* @args[@arg_index] is the valid command need to find in @cmds */
c227f099 789static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
66855495 790 char **args, int nb_args, int arg_index)
9dc39cba 791{
c227f099 792 const mon_cmd_t *cmd;
9dc39cba 793
66855495
WX		 794 /* No valid arg need to compare with, dump all in *cmds */
795 if (arg_index >= nb_args) {
796 for (cmd = cmds; cmd->name != NULL; cmd++) {
797 help_cmd_dump_one(mon, cmd, args, arg_index);
798 }
799 return;
800 }
801
802 /* Find one entry to dump */
803 for (cmd = cmds; cmd->name != NULL; cmd++) {
804 if (compare_cmd(args[arg_index], cmd->name)) {
805 if (cmd->sub_table) {
806 /* continue with next arg */
807 help_cmd_dump(mon, cmd->sub_table,
808 args, nb_args, arg_index + 1);
809 } else {
810 help_cmd_dump_one(mon, cmd, args, arg_index);
811 }
812 break;
813 }
9dc39cba
FB		 814 }
815}
816
376253ec 817static void help_cmd(Monitor *mon, const char *name)
9dc39cba 818{
66855495
WX		 819 char *args[MAX_ARGS];
820 int nb_args = 0;
821
822 /* 1. parse user input */
823 if (name) {
824 /* special case for log, directly dump and return */
825 if (!strcmp(name, "log")) {
38dad9e5 826 const QEMULogItem *item;
376253ec
AL		 827 monitor_printf(mon, "Log items (comma separated):\n");
828 monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");
38dad9e5 829 for (item = qemu_log_items; item->mask != 0; item++) {
376253ec 830 monitor_printf(mon, "%-10s %s\n", item->name, item->help);
f193c797 831 }
66855495
WX		 832 return;
833 }
834
835 if (parse_cmdline(name, &nb_args, args) < 0) {
836 return;
f193c797 837 }
9dc39cba 838 }
66855495
WX		 839
840 /* 2. dump the contents according to parsed args */
841 help_cmd_dump(mon, mon->cmd_table, args, nb_args, 0);
842
843 free_cmdline_args(args, nb_args);
9dc39cba
FB		 844}
845
d54908a5 846static void do_help_cmd(Monitor *mon, const QDict *qdict)
38183186 847{
d54908a5 848 help_cmd(mon, qdict_get_try_str(qdict, "name"));
38183186
LC		 849}
850
3e5a50d6 851static void hmp_trace_event(Monitor *mon, const QDict *qdict)
22890ab5
PS		 852{
853 const char *tp_name = qdict_get_str(qdict, "name");
854 bool new_state = qdict_get_bool(qdict, "option");
77e2b172
LV		 855 bool has_vcpu = qdict_haskey(qdict, "vcpu");
856 int vcpu = qdict_get_try_int(qdict, "vcpu", 0);
14101d02 857 Error *local_err = NULL;
f871d689 858
77e2b172
LV		 859 if (vcpu < 0) {
860 monitor_printf(mon, "argument vcpu must be positive");
861 return;
862 }
863
864 qmp_trace_event_set_state(tp_name, new_state, true, true, has_vcpu, vcpu, &local_err);
14101d02 865 if (local_err) {
091e38b7 866 error_report_err(local_err);
f871d689 867 }
22890ab5 868}
c5ceb523 869
c45a8168 870#ifdef CONFIG_TRACE_SIMPLE
3e5a50d6 871static void hmp_trace_file(Monitor *mon, const QDict *qdict)
c5ceb523
SH		 872{
873 const char *op = qdict_get_try_str(qdict, "op");
874 const char *arg = qdict_get_try_str(qdict, "arg");
875
876 if (!op) {
877 st_print_trace_file_status((FILE *)mon, &monitor_fprintf);
878 } else if (!strcmp(op, "on")) {
879 st_set_trace_file_enabled(true);
880 } else if (!strcmp(op, "off")) {
881 st_set_trace_file_enabled(false);
882 } else if (!strcmp(op, "flush")) {
883 st_flush_trace_buffer();
884 } else if (!strcmp(op, "set")) {
885 if (arg) {
886 st_set_trace_file(arg);
887 }
888 } else {
889 monitor_printf(mon, "unexpected argument \"%s\"\n", op);
890 help_cmd(mon, "trace-file");
891 }
892}
22890ab5
PS		 893#endif
894
3e5a50d6 895static void hmp_info_help(Monitor *mon, const QDict *qdict)
9dc39cba 896{
13c7425e 897 help_cmd(mon, "info");
9dc39cba
FB		 898}
899
9e812b6a 900static void query_commands_cb(QmpCommand *cmd, void *opaque)
e3bba9d0 901{
9e812b6a 902 CommandInfoList *info, **list = opaque;
e3bba9d0 903
9e812b6a
MAL		 904 if (!cmd->enabled) {
905 return;
e3bba9d0
LC		 906 }
907
9e812b6a
MAL		 908 info = g_malloc0(sizeof(*info));
909 info->value = g_malloc0(sizeof(*info->value));
910 info->value->name = g_strdup(cmd->name);
911 info->next = *list;
912 *list = info;
913}
914
915CommandInfoList *qmp_query_commands(Error **errp)
916{
917 CommandInfoList *list = NULL;
918
635db18f 919 qmp_for_each_command(cur_mon->qmp.commands, query_commands_cb, &list);
9e812b6a
MAL		 920
921 return list;
a36e69dd
TS		 922}
923
4860853d
DB		 924EventInfoList *qmp_query_events(Error **errp)
925{
926 EventInfoList *info, *ev_list = NULL;
75175173 927 QAPIEvent e;
4860853d 928
7fb1cf16 929 for (e = 0 ; e < QAPI_EVENT__MAX ; e++) {
75175173 930 const char *event_name = QAPIEvent_lookup[e];
4860853d
DB		 931 assert(event_name != NULL);
932 info = g_malloc0(sizeof(*info));
933 info->value = g_malloc0(sizeof(*info->value));
934 info->value->name = g_strdup(event_name);
935
936 info->next = ev_list;
937 ev_list = info;
938 }
939
940 return ev_list;
941}
942
39a18158
MA		 943/*
944 * Minor hack: generated marshalling suppressed for this command
945 * ('gen': false in the schema) so we can parse the JSON string
946 * directly into QObject instead of first parsing it with
947 * visit_type_SchemaInfoList() into a SchemaInfoList, then marshal it
948 * to QObject with generated output marshallers, every time. Instead,
b3db211f 949 * we do it in test-qobject-input-visitor.c, just to make sure
39a18158
MA		 950 * qapi-introspect.py's output actually conforms to the schema.
951 */
952static void qmp_query_qmp_schema(QDict *qdict, QObject **ret_data,
953 Error **errp)
954{
b0f36b23 955 *ret_data = qobject_from_json(qmp_schema_json, &error_abort);
39a18158
MA		 956}
957
5032a16d 958/*
5032a16d
MAL		 959 * We used to define commands in qmp-commands.hx in addition to the
960 * QAPI schema. This permitted defining some of them only in certain
961 * configurations. query-commands has always reflected that (good,
962 * because it lets QMP clients figure out what's actually available),
963 * while query-qmp-schema never did (not so good). This function is a
964 * hack to keep the configuration-specific commands defined exactly as
965 * before, even though qmp-commands.hx is gone.
966 *
967 * FIXME Educate the QAPI schema on configuration-specific commands,
968 * and drop this hack.
969 */
970static void qmp_unregister_commands_hack(void)
971{
972#ifndef CONFIG_SPICE
1527badb 973 qmp_unregister_command(&qmp_commands, "query-spice");
5032a16d 974#endif
38bb54f3
MA		 975#ifndef CONFIG_REPLICATION
976 qmp_unregister_command(&qmp_commands, "xen-set-replication");
977 qmp_unregister_command(&qmp_commands, "query-xen-replication-status");
978 qmp_unregister_command(&qmp_commands, "xen-colo-do-checkpoint");
979#endif
5032a16d 980#ifndef TARGET_I386
1527badb 981 qmp_unregister_command(&qmp_commands, "rtc-reset-reinjection");
5032a16d
MAL		 982#endif
983#ifndef TARGET_S390X
1527badb 984 qmp_unregister_command(&qmp_commands, "dump-skeys");
5032a16d
MAL		 985#endif
986#ifndef TARGET_ARM
1527badb 987 qmp_unregister_command(&qmp_commands, "query-gic-capabilities");
5032a16d 988#endif
f99fd7ca 989#if !defined(TARGET_S390X) && !defined(TARGET_I386)
1527badb 990 qmp_unregister_command(&qmp_commands, "query-cpu-model-expansion");
f99fd7ca
EH		 991#endif
992#if !defined(TARGET_S390X)
1527badb
MA		 993 qmp_unregister_command(&qmp_commands, "query-cpu-model-baseline");
994 qmp_unregister_command(&qmp_commands, "query-cpu-model-comparison");
728b1429
EH		 995#endif
996#if !defined(TARGET_PPC) && !defined(TARGET_ARM) && !defined(TARGET_I386) \
997 && !defined(TARGET_S390X)
1527badb 998 qmp_unregister_command(&qmp_commands, "query-cpu-definitions");
728b1429 999#endif
5032a16d
MAL		 1000}
1001
05875687 1002void monitor_init_qmp_commands(void)
edcfaefe 1003{
635db18f
MA		 1004 /*
1005 * Two command lists:
1006 * - qmp_commands contains all QMP commands
1007 * - qmp_cap_negotiation_commands contains just
1008 * "qmp_capabilities", to enforce capability negotiation
1009 */
1010
1527badb 1011 qmp_init_marshal(&qmp_commands);
05875687 1012
1527badb
MA		 1013 qmp_register_command(&qmp_commands, "query-qmp-schema",
1014 qmp_query_qmp_schema,
edcfaefe 1015 QCO_NO_OPTIONS);
1527badb 1016 qmp_register_command(&qmp_commands, "device_add", qmp_device_add,
edcfaefe 1017 QCO_NO_OPTIONS);
1527badb 1018 qmp_register_command(&qmp_commands, "netdev_add", qmp_netdev_add,
edcfaefe 1019 QCO_NO_OPTIONS);
5032a16d 1020
05875687 1021 qmp_unregister_commands_hack();
635db18f
MA		 1022
1023 QTAILQ_INIT(&qmp_cap_negotiation_commands);
1024 qmp_register_command(&qmp_cap_negotiation_commands, "qmp_capabilities",
1025 qmp_marshal_qmp_capabilities, QCO_NO_OPTIONS);
1026}
1027
1028void qmp_qmp_capabilities(Error **errp)
1029{
1030 if (cur_mon->qmp.commands == &qmp_commands) {
1031 error_set(errp, ERROR_CLASS_COMMAND_NOT_FOUND,
1032 "Capabilities negotiation is already complete, command "
1033 "ignored");
1034 return;
1035 }
1036
1037 cur_mon->qmp.commands = &qmp_commands;
edcfaefe
MAL		 1038}
1039
b025c8b4
LC		 1040/* set the current CPU defined by the user */
1041int monitor_set_cpu(int cpu_index)
6a00d601 1042{
55e5c285 1043 CPUState *cpu;
6a00d601 1044
1c8bb3cc
AF		 1045 cpu = qemu_get_cpu(cpu_index);
1046 if (cpu == NULL) {
1047 return -1;
6a00d601 1048 }
cb446eca 1049 cur_mon->mon_cpu = cpu;
1c8bb3cc 1050 return 0;
6a00d601
FB		 1051}
1052
caf15319 1053CPUState *mon_get_cpu(void)
6a00d601 1054{
731b0364 1055 if (!cur_mon->mon_cpu) {
854e67fe
TH		 1056 if (!first_cpu) {
1057 return NULL;
1058 }
27a83f8e 1059 monitor_set_cpu(first_cpu->cpu_index);
6a00d601 1060 }
4c0960c0 1061 cpu_synchronize_state(cur_mon->mon_cpu);
5bcda5f7
PC		 1062 return cur_mon->mon_cpu;
1063}
1064
bf957284 1065CPUArchState *mon_get_cpu_env(void)
5bcda5f7 1066{
854e67fe
TH		 1067 CPUState *cs = mon_get_cpu();
1068
1069 return cs ? cs->env_ptr : NULL;
6a00d601
FB		 1070}
1071
99b7796f
LC		 1072int monitor_get_cpu_index(void)
1073{
854e67fe
TH		 1074 CPUState *cs = mon_get_cpu();
1075
1076 return cs ? cs->cpu_index : UNASSIGNED_CPU_INDEX;
99b7796f
LC		 1077}
1078
1ce6be24 1079static void hmp_info_registers(Monitor *mon, const QDict *qdict)
9307c4c1 1080{
854e67fe
TH		 1081 CPUState *cs = mon_get_cpu();
1082
1083 if (!cs) {
1084 monitor_printf(mon, "No CPU available\n");
1085 return;
1086 }
1087 cpu_dump_state(cs, (FILE *)mon, monitor_fprintf, CPU_DUMP_FPU);
9307c4c1
FB		 1088}
1089
1ce6be24 1090static void hmp_info_jit(Monitor *mon, const QDict *qdict)
e3db7226 1091{
b7da97ee
TH		 1092 if (!tcg_enabled()) {
1093 error_report("JIT information is only available with accel=tcg");
1094 return;
1095 }
1096
376253ec 1097 dump_exec_info((FILE *)mon, monitor_fprintf);
27498bef 1098 dump_drift_info((FILE *)mon, monitor_fprintf);
e3db7226
FB		 1099}
1100
1ce6be24 1101static void hmp_info_opcount(Monitor *mon, const QDict *qdict)
246ae24d
MF		 1102{
1103 dump_opcount_info((FILE *)mon, monitor_fprintf);
1104}
1105
1ce6be24 1106static void hmp_info_history(Monitor *mon, const QDict *qdict)
aa455485
FB		 1107{
1108 int i;
7e2515e8 1109 const char *str;
3b46e624 1110
cde76ee1
AL		 1111 if (!mon->rs)
1112 return;
7e2515e8
FB		 1113 i = 0;
1114 for(;;) {
731b0364 1115 str = readline_get_history(mon->rs, i);
7e2515e8
FB		 1116 if (!str)
1117 break;
376253ec 1118 monitor_printf(mon, "%d: '%s'\n", i, str);
8e3a9fd2 1119 i++;
aa455485
FB		 1120 }
1121}
1122
1ce6be24 1123static void hmp_info_cpustats(Monitor *mon, const QDict *qdict)
76a66253 1124{
854e67fe
TH		 1125 CPUState *cs = mon_get_cpu();
1126
1127 if (!cs) {
1128 monitor_printf(mon, "No CPU available\n");
1129 return;
1130 }
1131 cpu_dump_statistics(cs, (FILE *)mon, &monitor_fprintf, 0);
76a66253 1132}
76a66253 1133
1ce6be24 1134static void hmp_info_trace_events(Monitor *mon, const QDict *qdict)
22890ab5 1135{
bd71211d 1136 const char *name = qdict_get_try_str(qdict, "name");
77e2b172
LV		 1137 bool has_vcpu = qdict_haskey(qdict, "vcpu");
1138 int vcpu = qdict_get_try_int(qdict, "vcpu", 0);
bd71211d 1139 TraceEventInfoList *events;
14101d02 1140 TraceEventInfoList *elem;
bd71211d
LV		 1141 Error *local_err = NULL;
1142
1143 if (name == NULL) {
1144 name = "*";
1145 }
77e2b172
LV		 1146 if (vcpu < 0) {
1147 monitor_printf(mon, "argument vcpu must be positive");
1148 return;
1149 }
bd71211d 1150
77e2b172 1151 events = qmp_trace_event_get_state(name, has_vcpu, vcpu, &local_err);
bd71211d
LV		 1152 if (local_err) {
1153 error_report_err(local_err);
1154 return;
1155 }
14101d02
LV		 1156
1157 for (elem = events; elem != NULL; elem = elem->next) {
1158 monitor_printf(mon, "%s : state %u\n",
1159 elem->value->name,
1160 elem->value->state == TRACE_EVENT_STATE_ENABLED ? 1 : 0);
1161 }
1162 qapi_free_TraceEventInfoList(events);
22890ab5 1163}
22890ab5 1164
b8a185bc
MA		 1165void qmp_client_migrate_info(const char *protocol, const char *hostname,
1166 bool has_port, int64_t port,
1167 bool has_tls_port, int64_t tls_port,
1168 bool has_cert_subject, const char *cert_subject,
1169 Error **errp)
e866e239 1170{
e866e239 1171 if (strcmp(protocol, "spice") == 0) {
b8a185bc
MA		 1172 if (!qemu_using_spice(errp)) {
1173 return;
e866e239
GH		 1174 }
1175
b8a185bc 1176 if (!has_port && !has_tls_port) {
c6bd8c70 1177 error_setg(errp, QERR_MISSING_PARAMETER, "port/tls-port");
b8a185bc 1178 return;
6ec5dae5
YH		 1179 }
1180
b8a185bc
MA		 1181 if (qemu_spice_migrate_info(hostname,
1182 has_port ? port : -1,
1183 has_tls_port ? tls_port : -1,
1184 cert_subject)) {
c6bd8c70 1185 error_setg(errp, QERR_UNDEFINED_ERROR);
b8a185bc 1186 return;
e866e239 1187 }
b8a185bc 1188 return;
e866e239
GH		 1189 }
1190
c6bd8c70 1191 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "protocol", "spice");
e866e239
GH		 1192}
1193
3e5a50d6 1194static void hmp_logfile(Monitor *mon, const QDict *qdict)
e735b91c 1195{
daa76aa4
MA		 1196 Error *err = NULL;
1197
1198 qemu_set_log_filename(qdict_get_str(qdict, "filename"), &err);
1199 if (err) {
1200 error_report_err(err);
1201 }
e735b91c
PB		 1202}
1203
3e5a50d6 1204static void hmp_log(Monitor *mon, const QDict *qdict)
f193c797
FB		 1205{
1206 int mask;
d54908a5 1207 const char *items = qdict_get_str(qdict, "items");
3b46e624 1208
9307c4c1 1209 if (!strcmp(items, "none")) {
f193c797
FB		 1210 mask = 0;
1211 } else {
4fde1eba 1212 mask = qemu_str_to_log_mask(items);
f193c797 1213 if (!mask) {
376253ec 1214 help_cmd(mon, "log");
f193c797
FB		 1215 return;
1216 }
1217 }
24537a01 1218 qemu_set_log(mask);
f193c797
FB		 1219}
1220
3e5a50d6 1221static void hmp_singlestep(Monitor *mon, const QDict *qdict)
1b530a6d 1222{
d54908a5 1223 const char *option = qdict_get_try_str(qdict, "option");
1b530a6d
AJ		 1224 if (!option || !strcmp(option, "on")) {
1225 singlestep = 1;
1226 } else if (!strcmp(option, "off")) {
1227 singlestep = 0;
1228 } else {
1229 monitor_printf(mon, "unexpected option %s\n", option);
1230 }
1231}
1232
3e5a50d6 1233static void hmp_gdbserver(Monitor *mon, const QDict *qdict)
59030a8c 1234{
d54908a5 1235 const char *device = qdict_get_try_str(qdict, "device");
59030a8c
AL		 1236 if (!device)
1237 device = "tcp::" DEFAULT_GDBSTUB_PORT;
1238 if (gdbserver_start(device) < 0) {
1239 monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
1240 device);
1241 } else if (strcmp(device, "none") == 0) {
36556b20 1242 monitor_printf(mon, "Disabled gdbserver\n");
8a7ddc38 1243 } else {
59030a8c
AL		 1244 monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
1245 device);
8a7ddc38
FB		 1246 }
1247}
1248
3e5a50d6 1249static void hmp_watchdog_action(Monitor *mon, const QDict *qdict)
9dd986cc 1250{
d54908a5 1251 const char *action = qdict_get_str(qdict, "action");
9dd986cc
RJ		 1252 if (select_watchdog_action(action) == -1) {
1253 monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
1254 }
1255}
1256
376253ec 1257static void monitor_printc(Monitor *mon, int c)
9307c4c1 1258{
376253ec 1259 monitor_printf(mon, "'");
9307c4c1
FB		 1260 switch(c) {
1261 case '\'':
376253ec 1262 monitor_printf(mon, "\\'");
9307c4c1
FB		 1263 break;
1264 case '\\':
376253ec 1265 monitor_printf(mon, "\\\\");
9307c4c1
FB		 1266 break;
1267 case '\n':
376253ec 1268 monitor_printf(mon, "\\n");
9307c4c1
FB		 1269 break;
1270 case '\r':
376253ec 1271 monitor_printf(mon, "\\r");
9307c4c1
FB		 1272 break;
1273 default:
1274 if (c >= 32 && c <= 126) {
376253ec 1275 monitor_printf(mon, "%c", c);
9307c4c1 1276 } else {
376253ec 1277 monitor_printf(mon, "\\x%02x", c);
9307c4c1
FB		 1278 }
1279 break;
1280 }
376253ec 1281 monitor_printf(mon, "'");
9307c4c1
FB		 1282}
1283
376253ec 1284static void memory_dump(Monitor *mon, int count, int format, int wsize,
a8170e5e 1285 hwaddr addr, int is_physical)
9307c4c1 1286{
23842aab 1287 int l, line_size, i, max_digits, len;
9307c4c1
FB		 1288 uint8_t buf[16];
1289 uint64_t v;
854e67fe
TH		 1290 CPUState *cs = mon_get_cpu();
1291
1292 if (!cs && (format == 'i' || !is_physical)) {
1293 monitor_printf(mon, "Can not dump without CPU\n");
1294 return;
1295 }
9307c4c1
FB		 1296
1297 if (format == 'i') {
5bcda5f7 1298 int flags = 0;
9307c4c1 1299#ifdef TARGET_I386
5bcda5f7 1300 CPUArchState *env = mon_get_cpu_env();
4c27ba27 1301 if (wsize == 2) {
9307c4c1 1302 flags = 1;
4c27ba27
FB		 1303 } else if (wsize == 4) {
1304 flags = 0;
1305 } else {
6a15fd12 1306 /* as default we use the current CS size */
4c27ba27 1307 flags = 0;
6a15fd12
FB		 1308 if (env) {
1309#ifdef TARGET_X86_64
5fafdf24 1310 if ((env->efer & MSR_EFER_LMA) &&
6a15fd12
FB		 1311 (env->segs[R_CS].flags & DESC_L_MASK))
1312 flags = 2;
1313 else
1314#endif
1315 if (!(env->segs[R_CS].flags & DESC_B_MASK))
1316 flags = 1;
1317 }
4c27ba27 1318 }
1c38f843
TM		 1319#endif
1320#ifdef TARGET_PPC
5bcda5f7 1321 CPUArchState *env = mon_get_cpu_env();
1c38f843
TM		 1322 flags = msr_le << 16;
1323 flags |= env->bfd_mach;
4c27ba27 1324#endif
854e67fe 1325 monitor_disas(mon, cs, addr, count, is_physical, flags);
9307c4c1
FB		 1326 return;
1327 }
1328
1329 len = wsize * count;
1330 if (wsize == 1)
1331 line_size = 8;
1332 else
1333 line_size = 16;
9307c4c1
FB		 1334 max_digits = 0;
1335
1336 switch(format) {
1337 case 'o':
1338 max_digits = (wsize * 8 + 2) / 3;
1339 break;
1340 default:
1341 case 'x':
1342 max_digits = (wsize * 8) / 4;
1343 break;
1344 case 'u':
1345 case 'd':
1346 max_digits = (wsize * 8 * 10 + 32) / 33;
1347 break;
1348 case 'c':
1349 wsize = 1;
1350 break;
1351 }
1352
1353 while (len > 0) {
7743e588 1354 if (is_physical)
376253ec 1355 monitor_printf(mon, TARGET_FMT_plx ":", addr);
7743e588 1356 else
376253ec 1357 monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
9307c4c1
FB		 1358 l = len;
1359 if (l > line_size)
1360 l = line_size;
1361 if (is_physical) {
54f7b4a3 1362 cpu_physical_memory_read(addr, buf, l);
9307c4c1 1363 } else {
854e67fe 1364 if (cpu_memory_rw_debug(cs, addr, buf, l, 0) < 0) {
376253ec 1365 monitor_printf(mon, " Cannot access memory\n");
c8f79b67
AL		 1366 break;
1367 }
9307c4c1 1368 }
5fafdf24 1369 i = 0;
9307c4c1
FB		 1370 while (i < l) {
1371 switch(wsize) {
1372 default:
1373 case 1:
24e60305 1374 v = ldub_p(buf + i);
9307c4c1
FB		 1375 break;
1376 case 2:
24e60305 1377 v = lduw_p(buf + i);
9307c4c1
FB		 1378 break;
1379 case 4:
24e60305 1380 v = (uint32_t)ldl_p(buf + i);
9307c4c1
FB		 1381 break;
1382 case 8:
24e60305 1383 v = ldq_p(buf + i);
9307c4c1
FB		 1384 break;
1385 }
376253ec 1386 monitor_printf(mon, " ");
9307c4c1
FB		 1387 switch(format) {
1388 case 'o':
376253ec 1389 monitor_printf(mon, "%#*" PRIo64, max_digits, v);
9307c4c1
FB		 1390 break;
1391 case 'x':
376253ec 1392 monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
9307c4c1
FB		 1393 break;
1394 case 'u':
376253ec 1395 monitor_printf(mon, "%*" PRIu64, max_digits, v);
9307c4c1
FB		 1396 break;
1397 case 'd':
376253ec 1398 monitor_printf(mon, "%*" PRId64, max_digits, v);
9307c4c1
FB		 1399 break;
1400 case 'c':
376253ec 1401 monitor_printc(mon, v);
9307c4c1
FB		 1402 break;
1403 }
1404 i += wsize;
1405 }
376253ec 1406 monitor_printf(mon, "\n");
9307c4c1
FB		 1407 addr += l;
1408 len -= l;
1409 }
1410}
1411
3e5a50d6 1412static void hmp_memory_dump(Monitor *mon, const QDict *qdict)
9307c4c1 1413{
1bd1442e
LC		 1414 int count = qdict_get_int(qdict, "count");
1415 int format = qdict_get_int(qdict, "format");
1416 int size = qdict_get_int(qdict, "size");
1417 target_long addr = qdict_get_int(qdict, "addr");
1418
376253ec 1419 memory_dump(mon, count, format, size, addr, 0);
9307c4c1
FB		 1420}
1421
3e5a50d6 1422static void hmp_physical_memory_dump(Monitor *mon, const QDict *qdict)
9307c4c1 1423{
1bd1442e
LC		 1424 int count = qdict_get_int(qdict, "count");
1425 int format = qdict_get_int(qdict, "format");
1426 int size = qdict_get_int(qdict, "size");
a8170e5e 1427 hwaddr addr = qdict_get_int(qdict, "addr");
1bd1442e 1428
376253ec 1429 memory_dump(mon, count, format, size, addr, 1);
9307c4c1
FB		 1430}
1431
e9628441
PB		 1432static void *gpa2hva(MemoryRegion **p_mr, hwaddr addr, Error **errp)
1433{
1434 MemoryRegionSection mrs = memory_region_find(get_system_memory(),
1435 addr, 1);
1436
1437 if (!mrs.mr) {
1438 error_setg(errp, "No memory is mapped at address 0x%" HWADDR_PRIx, addr);
1439 return NULL;
1440 }
1441
1442 if (!memory_region_is_ram(mrs.mr) && !memory_region_is_romd(mrs.mr)) {
1443 error_setg(errp, "Memory at address 0x%" HWADDR_PRIx "is not RAM", addr);
1444 memory_region_unref(mrs.mr);
1445 return NULL;
1446 }
1447
1448 *p_mr = mrs.mr;
1449 return qemu_map_ram_ptr(mrs.mr->ram_block, mrs.offset_within_region);
1450}
1451
1452static void hmp_gpa2hva(Monitor *mon, const QDict *qdict)
1453{
1454 hwaddr addr = qdict_get_int(qdict, "addr");
1455 Error *local_err = NULL;
1456 MemoryRegion *mr = NULL;
1457 void *ptr;
1458
1459 ptr = gpa2hva(&mr, addr, &local_err);
1460 if (local_err) {
1461 error_report_err(local_err);
1462 return;
1463 }
1464
1465 monitor_printf(mon, "Host virtual address for 0x%" HWADDR_PRIx
1466 " (%s) is %p\n",
1467 addr, mr->name, ptr);
1468
1469 memory_region_unref(mr);
1470}
1471
1472#ifdef CONFIG_LINUX
1473static uint64_t vtop(void *ptr, Error **errp)
1474{
1475 uint64_t pinfo;
1476 uint64_t ret = -1;
1477 uintptr_t addr = (uintptr_t) ptr;
1478 uintptr_t pagesize = getpagesize();
1479 off_t offset = addr / pagesize * sizeof(pinfo);
1480 int fd;
1481
1482 fd = open("/proc/self/pagemap", O_RDONLY);
1483 if (fd == -1) {
1484 error_setg_errno(errp, errno, "Cannot open /proc/self/pagemap");
1485 return -1;
1486 }
1487
1488 /* Force copy-on-write if necessary. */
1489 atomic_add((uint8_t *)ptr, 0);
1490
1491 if (pread(fd, &pinfo, sizeof(pinfo), offset) != sizeof(pinfo)) {
1492 error_setg_errno(errp, errno, "Cannot read pagemap");
1493 goto out;
1494 }
1495 if ((pinfo & (1ull << 63)) == 0) {
1496 error_setg(errp, "Page not present");
1497 goto out;
1498 }
1499 ret = ((pinfo & 0x007fffffffffffffull) * pagesize) | (addr & (pagesize - 1));
1500
1501out:
1502 close(fd);
1503 return ret;
1504}
1505
1506static void hmp_gpa2hpa(Monitor *mon, const QDict *qdict)
1507{
1508 hwaddr addr = qdict_get_int(qdict, "addr");
1509 Error *local_err = NULL;
1510 MemoryRegion *mr = NULL;
1511 void *ptr;
1512 uint64_t physaddr;
1513
1514 ptr = gpa2hva(&mr, addr, &local_err);
1515 if (local_err) {
1516 error_report_err(local_err);
1517 return;
1518 }
1519
1520 physaddr = vtop(ptr, &local_err);
1521 if (local_err) {
1522 error_report_err(local_err);
1523 } else {
1524 monitor_printf(mon, "Host physical address for 0x%" HWADDR_PRIx
1525 " (%s) is 0x%" PRIx64 "\n",
1526 addr, mr->name, (uint64_t) physaddr);
1527 }
1528
1529 memory_region_unref(mr);
1530}
1531#endif
1532
1bd1442e 1533static void do_print(Monitor *mon, const QDict *qdict)
9307c4c1 1534{
1bd1442e 1535 int format = qdict_get_int(qdict, "format");
a8170e5e 1536 hwaddr val = qdict_get_int(qdict, "val");
1bd1442e 1537
9307c4c1
FB		 1538 switch(format) {
1539 case 'o':
a8170e5e 1540 monitor_printf(mon, "%#" HWADDR_PRIo, val);
9307c4c1
FB		 1541 break;
1542 case 'x':
a8170e5e 1543 monitor_printf(mon, "%#" HWADDR_PRIx, val);
9307c4c1
FB		 1544 break;
1545 case 'u':
a8170e5e 1546 monitor_printf(mon, "%" HWADDR_PRIu, val);
9307c4c1
FB		 1547 break;
1548 default:
1549 case 'd':
a8170e5e 1550 monitor_printf(mon, "%" HWADDR_PRId, val);
9307c4c1
FB		 1551 break;
1552 case 'c':
376253ec 1553 monitor_printc(mon, val);
9307c4c1
FB		 1554 break;
1555 }
376253ec 1556 monitor_printf(mon, "\n");
9307c4c1
FB		 1557}
1558
3e5a50d6 1559static void hmp_sum(Monitor *mon, const QDict *qdict)
e4cf1adc
FB		 1560{
1561 uint32_t addr;
e4cf1adc 1562 uint16_t sum;
f18c16de
LC		 1563 uint32_t start = qdict_get_int(qdict, "start");
1564 uint32_t size = qdict_get_int(qdict, "size");
e4cf1adc
FB		 1565
1566 sum = 0;
1567 for(addr = start; addr < (start + size); addr++) {
42874d3a
PM		 1568 uint8_t val = address_space_ldub(&address_space_memory, addr,
1569 MEMTXATTRS_UNSPECIFIED, NULL);
e4cf1adc
FB		 1570 /* BSD sum algorithm ('sum' Unix command) */
1571 sum = (sum >> 1) | (sum << 15);
54f7b4a3 1572 sum += val;
e4cf1adc 1573 }
376253ec 1574 monitor_printf(mon, "%05d\n", sum);
e4cf1adc
FB		 1575}
1576
13224a87
FB		 1577static int mouse_button_state;
1578
3e5a50d6 1579static void hmp_mouse_move(Monitor *mon, const QDict *qdict)
13224a87 1580{
c751a74a 1581 int dx, dy, dz, button;
1d4daa91
LC		 1582 const char *dx_str = qdict_get_str(qdict, "dx_str");
1583 const char *dy_str = qdict_get_str(qdict, "dy_str");
1584 const char *dz_str = qdict_get_try_str(qdict, "dz_str");
c751a74a 1585
13224a87
FB		 1586 dx = strtol(dx_str, NULL, 0);
1587 dy = strtol(dy_str, NULL, 0);
c751a74a
GH		 1588 qemu_input_queue_rel(NULL, INPUT_AXIS_X, dx);
1589 qemu_input_queue_rel(NULL, INPUT_AXIS_Y, dy);
1590
1591 if (dz_str) {
13224a87 1592 dz = strtol(dz_str, NULL, 0);
c751a74a 1593 if (dz != 0) {
f22d0af0 1594 button = (dz > 0) ? INPUT_BUTTON_WHEEL_UP : INPUT_BUTTON_WHEEL_DOWN;
c751a74a
GH		 1595 qemu_input_queue_btn(NULL, button, true);
1596 qemu_input_event_sync();
1597 qemu_input_queue_btn(NULL, button, false);
1598 }
1599 }
1600 qemu_input_event_sync();
13224a87
FB		 1601}
1602
3e5a50d6 1603static void hmp_mouse_button(Monitor *mon, const QDict *qdict)
13224a87 1604{
7fb1cf16 1605 static uint32_t bmap[INPUT_BUTTON__MAX] = {
c751a74a
GH		 1606 [INPUT_BUTTON_LEFT] = MOUSE_EVENT_LBUTTON,
1607 [INPUT_BUTTON_MIDDLE] = MOUSE_EVENT_MBUTTON,
1608 [INPUT_BUTTON_RIGHT] = MOUSE_EVENT_RBUTTON,
1609 };
d54908a5 1610 int button_state = qdict_get_int(qdict, "button_state");
c751a74a
GH		 1611
1612 if (mouse_button_state == button_state) {
1613 return;
1614 }
1615 qemu_input_update_buttons(NULL, bmap, mouse_button_state, button_state);
1616 qemu_input_event_sync();
13224a87 1617 mouse_button_state = button_state;
13224a87
FB		 1618}
1619
3e5a50d6 1620static void hmp_ioport_read(Monitor *mon, const QDict *qdict)
3440557b 1621{
aa93e39c
LC		 1622 int size = qdict_get_int(qdict, "size");
1623 int addr = qdict_get_int(qdict, "addr");
1624 int has_index = qdict_haskey(qdict, "index");
3440557b
FB		 1625 uint32_t val;
1626 int suffix;
1627
1628 if (has_index) {
aa93e39c 1629 int index = qdict_get_int(qdict, "index");
afcea8cb 1630 cpu_outb(addr & IOPORTS_MASK, index & 0xff);
3440557b
FB		 1631 addr++;
1632 }
1633 addr &= 0xffff;
1634
1635 switch(size) {
1636 default:
1637 case 1:
afcea8cb 1638 val = cpu_inb(addr);
3440557b
FB		 1639 suffix = 'b';
1640 break;
1641 case 2:
afcea8cb 1642 val = cpu_inw(addr);
3440557b
FB		 1643 suffix = 'w';
1644 break;
1645 case 4:
afcea8cb 1646 val = cpu_inl(addr);
3440557b
FB		 1647 suffix = 'l';
1648 break;
1649 }
376253ec
AL		 1650 monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
1651 suffix, addr, size * 2, val);
3440557b 1652}
a3a91a35 1653
3e5a50d6 1654static void hmp_ioport_write(Monitor *mon, const QDict *qdict)
f114784f 1655{
1bd1442e
LC		 1656 int size = qdict_get_int(qdict, "size");
1657 int addr = qdict_get_int(qdict, "addr");
1658 int val = qdict_get_int(qdict, "val");
1659
f114784f
JK		 1660 addr &= IOPORTS_MASK;
1661
1662 switch (size) {
1663 default:
1664 case 1:
afcea8cb 1665 cpu_outb(addr, val);
f114784f
JK		 1666 break;
1667 case 2:
afcea8cb 1668 cpu_outw(addr, val);
f114784f
JK		 1669 break;
1670 case 4:
afcea8cb 1671 cpu_outl(addr, val);
f114784f
JK		 1672 break;
1673 }
1674}
1675
3e5a50d6 1676static void hmp_boot_set(Monitor *mon, const QDict *qdict)
0ecdffbb 1677{
f1839938 1678 Error *local_err = NULL;
d54908a5 1679 const char *bootdevice = qdict_get_str(qdict, "bootdevice");
0ecdffbb 1680
f1839938
GA		 1681 qemu_boot_set(bootdevice, &local_err);
1682 if (local_err) {
193227f9 1683 error_report_err(local_err);
0ecdffbb 1684 } else {
f1839938 1685 monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
0ecdffbb
AJ		 1686 }
1687}
1688
1ce6be24 1689static void hmp_info_mtree(Monitor *mon, const QDict *qdict)
314e2987 1690{
57bb40c9
PX		 1691 bool flatview = qdict_get_try_bool(qdict, "flatview", false);
1692
1693 mtree_info((fprintf_function)monitor_printf, mon, flatview);
314e2987
BS		 1694}
1695
1ce6be24 1696static void hmp_info_numa(Monitor *mon, const QDict *qdict)
030ea37b 1697{
b28b6230 1698 int i;
1b1ed8dc 1699 CPUState *cpu;
5b009e40 1700 uint64_t *node_mem;
030ea37b 1701
5b009e40
HZ		 1702 node_mem = g_new0(uint64_t, nb_numa_nodes);
1703 query_numa_node_mem(node_mem);
030ea37b
AL		 1704 monitor_printf(mon, "%d nodes\n", nb_numa_nodes);
1705 for (i = 0; i < nb_numa_nodes; i++) {
1706 monitor_printf(mon, "node %d cpus:", i);
bdc44640 1707 CPU_FOREACH(cpu) {
1b1ed8dc 1708 if (cpu->numa_node == i) {
55e5c285 1709 monitor_printf(mon, " %d", cpu->cpu_index);
030ea37b
AL		 1710 }
1711 }
1712 monitor_printf(mon, "\n");
1713 monitor_printf(mon, "node %d size: %" PRId64 " MB\n", i,
5b009e40 1714 node_mem[i] >> 20);
030ea37b 1715 }
5b009e40 1716 g_free(node_mem);
030ea37b
AL		 1717}
1718
5f1ce948
FB		 1719#ifdef CONFIG_PROFILER
1720
89d5cbdd 1721int64_t tcg_time;
e9a6625e
AJ		 1722int64_t dev_time;
1723
1ce6be24 1724static void hmp_info_profile(Monitor *mon, const QDict *qdict)
5f1ce948 1725{
376253ec 1726 monitor_printf(mon, "async time %" PRId64 " (%0.3f)\n",
73bcb24d 1727 dev_time, dev_time / (double)NANOSECONDS_PER_SECOND);
376253ec 1728 monitor_printf(mon, "qemu time %" PRId64 " (%0.3f)\n",
73bcb24d 1729 tcg_time, tcg_time / (double)NANOSECONDS_PER_SECOND);
89d5cbdd 1730 tcg_time = 0;
5f1ce948 1731 dev_time = 0;
5f1ce948
FB		 1732}
1733#else
1ce6be24 1734static void hmp_info_profile(Monitor *mon, const QDict *qdict)
5f1ce948 1735{
376253ec 1736 monitor_printf(mon, "Internal profiler not compiled\n");
5f1ce948
FB		 1737}
1738#endif
1739
ec36b695 1740/* Capture support */
72cf2d4f 1741static QLIST_HEAD (capture_list_head, CaptureState) capture_head;
ec36b695 1742
1ce6be24 1743static void hmp_info_capture(Monitor *mon, const QDict *qdict)
ec36b695
FB		 1744{
1745 int i;
1746 CaptureState *s;
1747
1748 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
376253ec 1749 monitor_printf(mon, "[%d]: ", i);
ec36b695
FB		 1750 s->ops.info (s->opaque);
1751 }
1752}
1753
3e5a50d6 1754static void hmp_stopcapture(Monitor *mon, const QDict *qdict)
ec36b695
FB		 1755{
1756 int i;
d54908a5 1757 int n = qdict_get_int(qdict, "n");
ec36b695
FB		 1758 CaptureState *s;
1759
1760 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
1761 if (i == n) {
1762 s->ops.destroy (s->opaque);
72cf2d4f 1763 QLIST_REMOVE (s, entries);
7267c094 1764 g_free (s);
ec36b695
FB		 1765 return;
1766 }
1767 }
1768}
1769
3e5a50d6 1770static void hmp_wavcapture(Monitor *mon, const QDict *qdict)
c1925484
LC		 1771{
1772 const char *path = qdict_get_str(qdict, "path");
1773 int has_freq = qdict_haskey(qdict, "freq");
1774 int freq = qdict_get_try_int(qdict, "freq", -1);
1775 int has_bits = qdict_haskey(qdict, "bits");
1776 int bits = qdict_get_try_int(qdict, "bits", -1);
1777 int has_channels = qdict_haskey(qdict, "nchannels");
1778 int nchannels = qdict_get_try_int(qdict, "nchannels", -1);
ec36b695
FB		 1779 CaptureState *s;
1780
7267c094 1781 s = g_malloc0 (sizeof (*s));
ec36b695
FB		 1782
1783 freq = has_freq ? freq : 44100;
1784 bits = has_bits ? bits : 16;
1785 nchannels = has_channels ? nchannels : 2;
1786
1787 if (wav_start_capture (s, path, freq, bits, nchannels)) {
d00b2618 1788 monitor_printf(mon, "Failed to add wave capture\n");
7267c094 1789 g_free (s);
d00b2618 1790 return;
ec36b695 1791 }
72cf2d4f 1792 QLIST_INSERT_HEAD (&capture_head, s, entries);
ec36b695 1793}
ec36b695 1794
15dfcd45 1795static qemu_acl *find_acl(Monitor *mon, const char *name)
76655d6d 1796{
15dfcd45 1797 qemu_acl *acl = qemu_acl_find(name);
76655d6d 1798
76655d6d 1799 if (!acl) {
15dfcd45 1800 monitor_printf(mon, "acl: unknown list '%s'\n", name);
76655d6d 1801 }
15dfcd45
JK		 1802 return acl;
1803}
1804
3e5a50d6 1805static void hmp_acl_show(Monitor *mon, const QDict *qdict)
15dfcd45 1806{
d54908a5 1807 const char *aclname = qdict_get_str(qdict, "aclname");
15dfcd45
JK		 1808 qemu_acl *acl = find_acl(mon, aclname);
1809 qemu_acl_entry *entry;
1810 int i = 0;
76655d6d 1811
15dfcd45 1812 if (acl) {
28a76be8 1813 monitor_printf(mon, "policy: %s\n",
76655d6d 1814 acl->defaultDeny ? "deny" : "allow");
72cf2d4f 1815 QTAILQ_FOREACH(entry, &acl->entries, next) {
28a76be8
AL		 1816 i++;
1817 monitor_printf(mon, "%d: %s %s\n", i,
15dfcd45 1818 entry->deny ? "deny" : "allow", entry->match);
28a76be8 1819 }
15dfcd45
JK		 1820 }
1821}
1822
3e5a50d6 1823static void hmp_acl_reset(Monitor *mon, const QDict *qdict)
15dfcd45 1824{
d54908a5 1825 const char *aclname = qdict_get_str(qdict, "aclname");
15dfcd45
JK		 1826 qemu_acl *acl = find_acl(mon, aclname);
1827
1828 if (acl) {
28a76be8
AL		 1829 qemu_acl_reset(acl);
1830 monitor_printf(mon, "acl: removed all rules\n");
15dfcd45
JK		 1831 }
1832}
1833
3e5a50d6 1834static void hmp_acl_policy(Monitor *mon, const QDict *qdict)
15dfcd45 1835{
f18c16de
LC		 1836 const char *aclname = qdict_get_str(qdict, "aclname");
1837 const char *policy = qdict_get_str(qdict, "policy");
15dfcd45 1838 qemu_acl *acl = find_acl(mon, aclname);
28a76be8 1839
15dfcd45
JK		 1840 if (acl) {
1841 if (strcmp(policy, "allow") == 0) {
28a76be8
AL		 1842 acl->defaultDeny = 0;
1843 monitor_printf(mon, "acl: policy set to 'allow'\n");
15dfcd45 1844 } else if (strcmp(policy, "deny") == 0) {
28a76be8
AL		 1845 acl->defaultDeny = 1;
1846 monitor_printf(mon, "acl: policy set to 'deny'\n");
1847 } else {
15dfcd45
JK		 1848 monitor_printf(mon, "acl: unknown policy '%s', "
1849 "expected 'deny' or 'allow'\n", policy);
28a76be8 1850 }
15dfcd45
JK		 1851 }
1852}
28a76be8 1853
3e5a50d6 1854static void hmp_acl_add(Monitor *mon, const QDict *qdict)
15dfcd45 1855{
1bd1442e
LC		 1856 const char *aclname = qdict_get_str(qdict, "aclname");
1857 const char *match = qdict_get_str(qdict, "match");
1858 const char *policy = qdict_get_str(qdict, "policy");
1859 int has_index = qdict_haskey(qdict, "index");
1860 int index = qdict_get_try_int(qdict, "index", -1);
15dfcd45
JK		 1861 qemu_acl *acl = find_acl(mon, aclname);
1862 int deny, ret;
1863
1864 if (acl) {
1865 if (strcmp(policy, "allow") == 0) {
1866 deny = 0;
1867 } else if (strcmp(policy, "deny") == 0) {
1868 deny = 1;
1869 } else {
1870 monitor_printf(mon, "acl: unknown policy '%s', "
1871 "expected 'deny' or 'allow'\n", policy);
28a76be8
AL		 1872 return;
1873 }
28a76be8
AL		 1874 if (has_index)
1875 ret = qemu_acl_insert(acl, deny, match, index);
1876 else
1877 ret = qemu_acl_append(acl, deny, match);
1878 if (ret < 0)
1879 monitor_printf(mon, "acl: unable to add acl entry\n");
1880 else
1881 monitor_printf(mon, "acl: added rule at position %d\n", ret);
15dfcd45
JK		 1882 }
1883}
28a76be8 1884
3e5a50d6 1885static void hmp_acl_remove(Monitor *mon, const QDict *qdict)
15dfcd45 1886{
f18c16de
LC		 1887 const char *aclname = qdict_get_str(qdict, "aclname");
1888 const char *match = qdict_get_str(qdict, "match");
15dfcd45
JK		 1889 qemu_acl *acl = find_acl(mon, aclname);
1890 int ret;
28a76be8 1891
15dfcd45 1892 if (acl) {
28a76be8
AL		 1893 ret = qemu_acl_remove(acl, match);
1894 if (ret < 0)
1895 monitor_printf(mon, "acl: no matching acl entry\n");
1896 else
1897 monitor_printf(mon, "acl: removed rule at position %d\n", ret);
76655d6d
AL		 1898 }
1899}
1900
208c9d1b 1901void qmp_getfd(const char *fdname, Error **errp)
f07918fd 1902{
c227f099 1903 mon_fd_t *monfd;
f07918fd
MM		 1904 int fd;
1905
5345fdb4 1906 fd = qemu_chr_fe_get_msgfd(&cur_mon->chr);
f07918fd 1907 if (fd == -1) {
c6bd8c70 1908 error_setg(errp, QERR_FD_NOT_SUPPLIED);
208c9d1b 1909 return;
f07918fd
MM		 1910 }
1911
1912 if (qemu_isdigit(fdname[0])) {
0b9f0e2f 1913 close(fd);
c6bd8c70
MA		 1914 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdname",
1915 "a name not starting with a digit");
208c9d1b 1916 return;
f07918fd
MM		 1917 }
1918
208c9d1b 1919 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
f07918fd
MM		 1920 if (strcmp(monfd->name, fdname) != 0) {
1921 continue;
1922 }
1923
1924 close(monfd->fd);
1925 monfd->fd = fd;
208c9d1b 1926 return;
f07918fd
MM		 1927 }
1928
7267c094
AL		 1929 monfd = g_malloc0(sizeof(mon_fd_t));
1930 monfd->name = g_strdup(fdname);
f07918fd
MM		 1931 monfd->fd = fd;
1932
208c9d1b 1933 QLIST_INSERT_HEAD(&cur_mon->fds, monfd, next);
f07918fd
MM		 1934}
1935
208c9d1b 1936void qmp_closefd(const char *fdname, Error **errp)
f07918fd 1937{
c227f099 1938 mon_fd_t *monfd;
f07918fd 1939
208c9d1b 1940 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
f07918fd
MM		 1941 if (strcmp(monfd->name, fdname) != 0) {
1942 continue;
1943 }
1944
72cf2d4f 1945 QLIST_REMOVE(monfd, next);
f07918fd 1946 close(monfd->fd);
7267c094
AL		 1947 g_free(monfd->name);
1948 g_free(monfd);
208c9d1b 1949 return;
f07918fd
MM		 1950 }
1951
c6bd8c70 1952 error_setg(errp, QERR_FD_NOT_FOUND, fdname);
f07918fd
MM		 1953}
1954
a9940fc4 1955int monitor_get_fd(Monitor *mon, const char *fdname, Error **errp)
7768e04c 1956{
c227f099 1957 mon_fd_t *monfd;
7768e04c 1958
72cf2d4f 1959 QLIST_FOREACH(monfd, &mon->fds, next) {
7768e04c
MM		 1960 int fd;
1961
1962 if (strcmp(monfd->name, fdname) != 0) {
1963 continue;
1964 }
1965
1966 fd = monfd->fd;
1967
1968 /* caller takes ownership of fd */
72cf2d4f 1969 QLIST_REMOVE(monfd, next);
7267c094
AL		 1970 g_free(monfd->name);
1971 g_free(monfd);
7768e04c
MM		 1972
1973 return fd;
1974 }
1975
a9940fc4 1976 error_setg(errp, "File descriptor named '%s' has not been found", fdname);
7768e04c
MM		 1977 return -1;
1978}
1979
ba1c048a
CB		 1980static void monitor_fdset_cleanup(MonFdset *mon_fdset)
1981{
1982 MonFdsetFd *mon_fdset_fd;
1983 MonFdsetFd *mon_fdset_fd_next;
1984
1985 QLIST_FOREACH_SAFE(mon_fdset_fd, &mon_fdset->fds, next, mon_fdset_fd_next) {
ebe52b59
CB		 1986 if ((mon_fdset_fd->removed ||
1987 (QLIST_EMPTY(&mon_fdset->dup_fds) && mon_refcount == 0)) &&
1988 runstate_is_running()) {
ba1c048a
CB		 1989 close(mon_fdset_fd->fd);
1990 g_free(mon_fdset_fd->opaque);
1991 QLIST_REMOVE(mon_fdset_fd, next);
1992 g_free(mon_fdset_fd);
1993 }
1994 }
1995
adb696f3 1996 if (QLIST_EMPTY(&mon_fdset->fds) && QLIST_EMPTY(&mon_fdset->dup_fds)) {
ba1c048a
CB		 1997 QLIST_REMOVE(mon_fdset, next);
1998 g_free(mon_fdset);
1999 }
2000}
2001
efb87c16
CB		 2002static void monitor_fdsets_cleanup(void)
2003{
2004 MonFdset *mon_fdset;
2005 MonFdset *mon_fdset_next;
2006
2007 QLIST_FOREACH_SAFE(mon_fdset, &mon_fdsets, next, mon_fdset_next) {
2008 monitor_fdset_cleanup(mon_fdset);
2009 }
2010}
2011
ba1c048a
CB		 2012AddfdInfo *qmp_add_fd(bool has_fdset_id, int64_t fdset_id, bool has_opaque,
2013 const char *opaque, Error **errp)
2014{
2015 int fd;
2016 Monitor *mon = cur_mon;
ba1c048a
CB		 2017 AddfdInfo *fdinfo;
2018
5345fdb4 2019 fd = qemu_chr_fe_get_msgfd(&mon->chr);
ba1c048a 2020 if (fd == -1) {
c6bd8c70 2021 error_setg(errp, QERR_FD_NOT_SUPPLIED);
ba1c048a
CB		 2022 goto error;
2023 }
2024
e446f70d
CB		 2025 fdinfo = monitor_fdset_add_fd(fd, has_fdset_id, fdset_id,
2026 has_opaque, opaque, errp);
2027 if (fdinfo) {
2028 return fdinfo;
ba1c048a 2029 }
ba1c048a
CB		 2030
2031error:
2032 if (fd != -1) {
2033 close(fd);
2034 }
2035 return NULL;
2036}
2037
2038void qmp_remove_fd(int64_t fdset_id, bool has_fd, int64_t fd, Error **errp)
2039{
2040 MonFdset *mon_fdset;
2041 MonFdsetFd *mon_fdset_fd;
2042 char fd_str[60];
2043
2044 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2045 if (mon_fdset->id != fdset_id) {
2046 continue;
2047 }
2048 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2049 if (has_fd) {
2050 if (mon_fdset_fd->fd != fd) {
2051 continue;
2052 }
2053 mon_fdset_fd->removed = true;
2054 break;
2055 } else {
2056 mon_fdset_fd->removed = true;
2057 }
2058 }
2059 if (has_fd && !mon_fdset_fd) {
2060 goto error;
2061 }
2062 monitor_fdset_cleanup(mon_fdset);
2063 return;
2064 }
2065
2066error:
2067 if (has_fd) {
2068 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64 ", fd:%" PRId64,
2069 fdset_id, fd);
2070 } else {
2071 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64, fdset_id);
2072 }
c6bd8c70 2073 error_setg(errp, QERR_FD_NOT_FOUND, fd_str);
ba1c048a
CB		 2074}
2075
2076FdsetInfoList *qmp_query_fdsets(Error **errp)
2077{
2078 MonFdset *mon_fdset;
2079 MonFdsetFd *mon_fdset_fd;
2080 FdsetInfoList *fdset_list = NULL;
2081
2082 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2083 FdsetInfoList *fdset_info = g_malloc0(sizeof(*fdset_info));
2084 FdsetFdInfoList *fdsetfd_list = NULL;
2085
2086 fdset_info->value = g_malloc0(sizeof(*fdset_info->value));
2087 fdset_info->value->fdset_id = mon_fdset->id;
2088
2089 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2090 FdsetFdInfoList *fdsetfd_info;
2091
2092 fdsetfd_info = g_malloc0(sizeof(*fdsetfd_info));
2093 fdsetfd_info->value = g_malloc0(sizeof(*fdsetfd_info->value));
2094 fdsetfd_info->value->fd = mon_fdset_fd->fd;
2095 if (mon_fdset_fd->opaque) {
2096 fdsetfd_info->value->has_opaque = true;
2097 fdsetfd_info->value->opaque = g_strdup(mon_fdset_fd->opaque);
2098 } else {
2099 fdsetfd_info->value->has_opaque = false;
2100 }
2101
2102 fdsetfd_info->next = fdsetfd_list;
2103 fdsetfd_list = fdsetfd_info;
2104 }
2105
2106 fdset_info->value->fds = fdsetfd_list;
2107
2108 fdset_info->next = fdset_list;
2109 fdset_list = fdset_info;
2110 }
2111
2112 return fdset_list;
2113}
2114
e446f70d
CB		 2115AddfdInfo *monitor_fdset_add_fd(int fd, bool has_fdset_id, int64_t fdset_id,
2116 bool has_opaque, const char *opaque,
2117 Error **errp)
2118{
2119 MonFdset *mon_fdset = NULL;
2120 MonFdsetFd *mon_fdset_fd;
2121 AddfdInfo *fdinfo;
2122
2123 if (has_fdset_id) {
2124 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2125 /* Break if match found or match impossible due to ordering by ID */
2126 if (fdset_id <= mon_fdset->id) {
2127 if (fdset_id < mon_fdset->id) {
2128 mon_fdset = NULL;
2129 }
2130 break;
2131 }
2132 }
2133 }
2134
2135 if (mon_fdset == NULL) {
2136 int64_t fdset_id_prev = -1;
2137 MonFdset *mon_fdset_cur = QLIST_FIRST(&mon_fdsets);
2138
2139 if (has_fdset_id) {
2140 if (fdset_id < 0) {
c6bd8c70
MA		 2141 error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "fdset-id",
2142 "a non-negative value");
e446f70d
CB		 2143 return NULL;
2144 }
2145 /* Use specified fdset ID */
2146 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2147 mon_fdset_cur = mon_fdset;
2148 if (fdset_id < mon_fdset_cur->id) {
2149 break;
2150 }
2151 }
2152 } else {
2153 /* Use first available fdset ID */
2154 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2155 mon_fdset_cur = mon_fdset;
2156 if (fdset_id_prev == mon_fdset_cur->id - 1) {
2157 fdset_id_prev = mon_fdset_cur->id;
2158 continue;
2159 }
2160 break;
2161 }
2162 }
2163
2164 mon_fdset = g_malloc0(sizeof(*mon_fdset));
2165 if (has_fdset_id) {
2166 mon_fdset->id = fdset_id;
2167 } else {
2168 mon_fdset->id = fdset_id_prev + 1;
2169 }
2170
2171 /* The fdset list is ordered by fdset ID */
2172 if (!mon_fdset_cur) {
2173 QLIST_INSERT_HEAD(&mon_fdsets, mon_fdset, next);
2174 } else if (mon_fdset->id < mon_fdset_cur->id) {
2175 QLIST_INSERT_BEFORE(mon_fdset_cur, mon_fdset, next);
2176 } else {
2177 QLIST_INSERT_AFTER(mon_fdset_cur, mon_fdset, next);
2178 }
2179 }
2180
2181 mon_fdset_fd = g_malloc0(sizeof(*mon_fdset_fd));
2182 mon_fdset_fd->fd = fd;
2183 mon_fdset_fd->removed = false;
2184 if (has_opaque) {
2185 mon_fdset_fd->opaque = g_strdup(opaque);
2186 }
2187 QLIST_INSERT_HEAD(&mon_fdset->fds, mon_fdset_fd, next);
2188
2189 fdinfo = g_malloc0(sizeof(*fdinfo));
2190 fdinfo->fdset_id = mon_fdset->id;
2191 fdinfo->fd = mon_fdset_fd->fd;
2192
2193 return fdinfo;
2194}
2195
adb696f3
CB		 2196int monitor_fdset_get_fd(int64_t fdset_id, int flags)
2197{
b2dc64c3 2198#ifndef _WIN32
adb696f3
CB		 2199 MonFdset *mon_fdset;
2200 MonFdsetFd *mon_fdset_fd;
2201 int mon_fd_flags;
2202
adb696f3
CB		 2203 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2204 if (mon_fdset->id != fdset_id) {
2205 continue;
2206 }
2207 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2208 mon_fd_flags = fcntl(mon_fdset_fd->fd, F_GETFL);
2209 if (mon_fd_flags == -1) {
2210 return -1;
2211 }
2212
2213 if ((flags & O_ACCMODE) == (mon_fd_flags & O_ACCMODE)) {
2214 return mon_fdset_fd->fd;
2215 }
2216 }
2217 errno = EACCES;
2218 return -1;
2219 }
2220#endif
2221
2222 errno = ENOENT;
2223 return -1;
2224}
2225
2226int monitor_fdset_dup_fd_add(int64_t fdset_id, int dup_fd)
2227{
2228 MonFdset *mon_fdset;
2229 MonFdsetFd *mon_fdset_fd_dup;
2230
2231 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2232 if (mon_fdset->id != fdset_id) {
2233 continue;
2234 }
2235 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2236 if (mon_fdset_fd_dup->fd == dup_fd) {
2237 return -1;
2238 }
2239 }
2240 mon_fdset_fd_dup = g_malloc0(sizeof(*mon_fdset_fd_dup));
2241 mon_fdset_fd_dup->fd = dup_fd;
2242 QLIST_INSERT_HEAD(&mon_fdset->dup_fds, mon_fdset_fd_dup, next);
2243 return 0;
2244 }
2245 return -1;
2246}
2247
2248static int monitor_fdset_dup_fd_find_remove(int dup_fd, bool remove)
2249{
2250 MonFdset *mon_fdset;
2251 MonFdsetFd *mon_fdset_fd_dup;
2252
2253 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2254 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2255 if (mon_fdset_fd_dup->fd == dup_fd) {
2256 if (remove) {
2257 QLIST_REMOVE(mon_fdset_fd_dup, next);
2258 if (QLIST_EMPTY(&mon_fdset->dup_fds)) {
2259 monitor_fdset_cleanup(mon_fdset);
2260 }
b3dd1b8c
MT		 2261 return -1;
2262 } else {
2263 return mon_fdset->id;
adb696f3 2264 }
adb696f3
CB		 2265 }
2266 }
2267 }
2268 return -1;
2269}
2270
2271int monitor_fdset_dup_fd_find(int dup_fd)
2272{
2273 return monitor_fdset_dup_fd_find_remove(dup_fd, false);
2274}
2275
b3dd1b8c 2276void monitor_fdset_dup_fd_remove(int dup_fd)
adb696f3 2277{
b3dd1b8c 2278 monitor_fdset_dup_fd_find_remove(dup_fd, true);
adb696f3
CB		 2279}
2280
1677f4c6 2281int monitor_fd_param(Monitor *mon, const char *fdname, Error **errp)
5906366e
LE		 2282{
2283 int fd;
2284 Error *local_err = NULL;
a96ed02f 2285
5906366e 2286 if (!qemu_isdigit(fdname[0]) && mon) {
a9940fc4 2287 fd = monitor_get_fd(mon, fdname, &local_err);
5906366e
LE		 2288 } else {
2289 fd = qemu_parse_fd(fdname);
a96ed02f 2290 if (fd == -1) {
5906366e
LE		 2291 error_setg(&local_err, "Invalid file descriptor number '%s'",
2292 fdname);
a96ed02f 2293 }
5906366e
LE		 2294 }
2295 if (local_err) {
2296 error_propagate(errp, local_err);
2297 assert(fd == -1);
a96ed02f 2298 } else {
5906366e 2299 assert(fd != -1);
a96ed02f
NB		 2300 }
2301
2302 return fd;
2303}
2304
acd0a093 2305/* Please update hmp-commands.hx when adding or changing commands */
816f8925 2306static mon_cmd_t info_cmds[] = {
da76ee76
PB		 2307#include "hmp-commands-info.h"
2308 { NULL, NULL, },
9dc39cba
FB		 2309};
2310
a13ced59
WX		 2311/* mon_cmds and info_cmds would be sorted at runtime */
2312static mon_cmd_t mon_cmds[] = {
2313#include "hmp-commands.h"
2314 { NULL, NULL, },
2315};
2316
9307c4c1
FB		 2317/*******************************************************************/
2318
2319static const char *pch;
6ab7e546 2320static sigjmp_buf expr_env;
9307c4c1 2321
9307c4c1 2322
9c3175cc
SW		 2323static void GCC_FMT_ATTR(2, 3) QEMU_NORETURN
2324expr_error(Monitor *mon, const char *fmt, ...)
9dc39cba 2325{
277acfe8
FZ		 2326 va_list ap;
2327 va_start(ap, fmt);
2328 monitor_vprintf(mon, fmt, ap);
2329 monitor_printf(mon, "\n");
2330 va_end(ap);
6ab7e546 2331 siglongjmp(expr_env, 1);
9307c4c1
FB		 2332}
2333
09b9418c 2334/* return 0 if OK, -1 if not found */
92a31b1f 2335static int get_monitor_def(target_long *pval, const char *name)
9307c4c1 2336{
bf957284 2337 const MonitorDef *md = target_monitor_defs();
854e67fe 2338 CPUState *cs = mon_get_cpu();
92a31b1f 2339 void *ptr;
0a9516c2
AK		 2340 uint64_t tmp = 0;
2341 int ret;
92a31b1f 2342
854e67fe 2343 if (cs == NULL || md == NULL) {
bf957284
PB		 2344 return -1;
2345 }
2346
2347 for(; md->name != NULL; md++) {
9307c4c1
FB		 2348 if (compare_cmd(name, md->name)) {
2349 if (md->get_value) {
e95c8d51 2350 *pval = md->get_value(md, md->offset);
9307c4c1 2351 } else {
5bcda5f7 2352 CPUArchState *env = mon_get_cpu_env();
6a00d601 2353 ptr = (uint8_t *)env + md->offset;
92a31b1f
FB		 2354 switch(md->type) {
2355 case MD_I32:
2356 *pval = *(int32_t *)ptr;
2357 break;
2358 case MD_TLONG:
2359 *pval = *(target_long *)ptr;
2360 break;
2361 default:
2362 *pval = 0;
2363 break;
2364 }
9307c4c1
FB		 2365 }
2366 return 0;
2367 }
2368 }
0a9516c2 2369
854e67fe 2370 ret = target_get_monitor_def(cs, name, &tmp);
0a9516c2
AK		 2371 if (!ret) {
2372 *pval = (target_long) tmp;
2373 }
2374
2375 return ret;
9307c4c1
FB		 2376}
2377
2378static void next(void)
2379{
660f11be 2380 if (*pch != '\0') {
9307c4c1 2381 pch++;
cd390083 2382 while (qemu_isspace(*pch))
9307c4c1
FB		 2383 pch++;
2384 }
2385}
2386
376253ec 2387static int64_t expr_sum(Monitor *mon);
9307c4c1 2388
376253ec 2389static int64_t expr_unary(Monitor *mon)
9307c4c1 2390{
c2efc95d 2391 int64_t n;
9307c4c1 2392 char *p;
6a00d601 2393 int ret;
9307c4c1
FB		 2394
2395 switch(*pch) {
2396 case '+':
2397 next();
376253ec 2398 n = expr_unary(mon);
9307c4c1
FB		 2399 break;
2400 case '-':
2401 next();
376253ec 2402 n = -expr_unary(mon);
9307c4c1
FB		 2403 break;
2404 case '~':
2405 next();
376253ec 2406 n = ~expr_unary(mon);
9307c4c1
FB		 2407 break;
2408 case '(':
2409 next();
376253ec 2410 n = expr_sum(mon);
9307c4c1 2411 if (*pch != ')') {
376253ec 2412 expr_error(mon, "')' expected");
9307c4c1
FB		 2413 }
2414 next();
2415 break;
81d0912d
FB		 2416 case '\'':
2417 pch++;
2418 if (*pch == '\0')
376253ec 2419 expr_error(mon, "character constant expected");
81d0912d
FB		 2420 n = *pch;
2421 pch++;
2422 if (*pch != '\'')
376253ec 2423 expr_error(mon, "missing terminating \' character");
81d0912d
FB		 2424 next();
2425 break;
9307c4c1
FB		 2426 case '$':
2427 {
2428 char buf[128], *q;
69b34976 2429 target_long reg=0;
3b46e624 2430
9307c4c1
FB		 2431 pch++;
2432 q = buf;
2433 while ((*pch >= 'a' && *pch <= 'z') ||
2434 (*pch >= 'A' && *pch <= 'Z') ||
2435 (*pch >= '0' && *pch <= '9') ||
57206fd4 2436 *pch == '_' || *pch == '.') {
9307c4c1
FB		 2437 if ((q - buf) < sizeof(buf) - 1)
2438 *q++ = *pch;
2439 pch++;
2440 }
cd390083 2441 while (qemu_isspace(*pch))
9307c4c1
FB		 2442 pch++;
2443 *q = 0;
7743e588 2444 ret = get_monitor_def(&reg, buf);
09b9418c 2445 if (ret < 0)
376253ec 2446 expr_error(mon, "unknown register");
7743e588 2447 n = reg;
9307c4c1
FB		 2448 }
2449 break;
2450 case '\0':
376253ec 2451 expr_error(mon, "unexpected end of expression");
9307c4c1
FB		 2452 n = 0;
2453 break;
2454 default:
6b0e33be 2455 errno = 0;
4f4fbf77 2456 n = strtoull(pch, &p, 0);
6b0e33be
LC		 2457 if (errno == ERANGE) {
2458 expr_error(mon, "number too large");
2459 }
9307c4c1 2460 if (pch == p) {
277acfe8 2461 expr_error(mon, "invalid char '%c' in expression", *p);
9307c4c1
FB		 2462 }
2463 pch = p;
cd390083 2464 while (qemu_isspace(*pch))
9307c4c1
FB		 2465 pch++;
2466 break;
2467 }
2468 return n;
2469}
2470
2471
376253ec 2472static int64_t expr_prod(Monitor *mon)
9307c4c1 2473{
c2efc95d 2474 int64_t val, val2;
92a31b1f 2475 int op;
3b46e624 2476
376253ec 2477 val = expr_unary(mon);
9307c4c1
FB		 2478 for(;;) {
2479 op = *pch;
2480 if (op != '*' && op != '/' && op != '%')
2481 break;
2482 next();
376253ec 2483 val2 = expr_unary(mon);
9307c4c1
FB		 2484 switch(op) {
2485 default:
2486 case '*':
2487 val *= val2;
2488 break;
2489 case '/':
2490 case '%':
5fafdf24 2491 if (val2 == 0)
376253ec 2492 expr_error(mon, "division by zero");
9307c4c1
FB		 2493 if (op == '/')
2494 val /= val2;
2495 else
2496 val %= val2;
2497 break;
2498 }
2499 }
2500 return val;
2501}
2502
376253ec 2503static int64_t expr_logic(Monitor *mon)
9307c4c1 2504{
c2efc95d 2505 int64_t val, val2;
92a31b1f 2506 int op;
9307c4c1 2507
376253ec 2508 val = expr_prod(mon);
9307c4c1
FB		 2509 for(;;) {
2510 op = *pch;
2511 if (op != '&' && op != '|' && op != '^')
2512 break;
2513 next();
376253ec 2514 val2 = expr_prod(mon);
9307c4c1
FB		 2515 switch(op) {
2516 default:
2517 case '&':
2518 val &= val2;
2519 break;
2520 case '|':
2521 val |= val2;
2522 break;
2523 case '^':
2524 val ^= val2;
2525 break;
2526 }
2527 }
2528 return val;
2529}
2530
376253ec 2531static int64_t expr_sum(Monitor *mon)
9307c4c1 2532{
c2efc95d 2533 int64_t val, val2;
92a31b1f 2534 int op;
9307c4c1 2535
376253ec 2536 val = expr_logic(mon);
9307c4c1
FB		 2537 for(;;) {
2538 op = *pch;
2539 if (op != '+' && op != '-')
2540 break;
2541 next();
376253ec 2542 val2 = expr_logic(mon);
9307c4c1
FB		 2543 if (op == '+')
2544 val += val2;
2545 else
2546 val -= val2;
2547 }
2548 return val;
2549}
2550
376253ec 2551static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
9307c4c1
FB		 2552{
2553 pch = *pp;
6ab7e546 2554 if (sigsetjmp(expr_env, 0)) {
9307c4c1
FB		 2555 *pp = pch;
2556 return -1;
2557 }
cd390083 2558 while (qemu_isspace(*pch))
9307c4c1 2559 pch++;
376253ec 2560 *pval = expr_sum(mon);
9307c4c1
FB		 2561 *pp = pch;
2562 return 0;
2563}
2564
3350a4dd
MA		 2565static int get_double(Monitor *mon, double *pval, const char **pp)
2566{
2567 const char *p = *pp;
2568 char *tailp;
2569 double d;
2570
2571 d = strtod(p, &tailp);
2572 if (tailp == p) {
2573 monitor_printf(mon, "Number expected\n");
2574 return -1;
2575 }
2576 if (d != d || d - d != 0) {
2577 /* NaN or infinity */
2578 monitor_printf(mon, "Bad number\n");
2579 return -1;
2580 }
2581 *pval = d;
2582 *pp = tailp;
2583 return 0;
2584}
2585
4590fd80
LC		 2586/*
2587 * Store the command-name in cmdname, and return a pointer to
2588 * the remaining of the command string.
2589 */
2590static const char *get_command_name(const char *cmdline,
2591 char *cmdname, size_t nlen)
2592{
2593 size_t len;
2594 const char *p, *pstart;
2595
2596 p = cmdline;
2597 while (qemu_isspace(*p))
2598 p++;
2599 if (*p == '\0')
2600 return NULL;
2601 pstart = p;
2602 while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
2603 p++;
2604 len = p - pstart;
2605 if (len > nlen - 1)
2606 len = nlen - 1;
2607 memcpy(cmdname, pstart, len);
2608 cmdname[len] = '\0';
2609 return p;
2610}
2611
4d76d2ba
LC		 2612/**
2613 * Read key of 'type' into 'key' and return the current
2614 * 'type' pointer.
2615 */
2616static char *key_get_info(const char *type, char **key)
2617{
2618 size_t len;
2619 char *p, *str;
2620
2621 if (*type == ',')
2622 type++;
2623
2624 p = strchr(type, ':');
2625 if (!p) {
2626 *key = NULL;
2627 return NULL;
2628 }
2629 len = p - type;
2630
7267c094 2631 str = g_malloc(len + 1);
4d76d2ba
LC		 2632 memcpy(str, type, len);
2633 str[len] = '\0';
2634
2635 *key = str;
2636 return ++p;
2637}
2638
9307c4c1
FB		 2639static int default_fmt_format = 'x';
2640static int default_fmt_size = 4;
2641
fbc3d96c
LS		 2642static int is_valid_option(const char *c, const char *typestr)
2643{
2644 char option[3];
2645
2646 option[0] = '-';
2647 option[1] = *c;
2648 option[2] = '\0';
2649
2650 typestr = strstr(typestr, option);
2651 return (typestr != NULL);
2652}
2653
945c5ac8
LC		 2654static const mon_cmd_t *search_dispatch_table(const mon_cmd_t *disp_table,
2655 const char *cmdname)
7fd669a1
LC		 2656{
2657 const mon_cmd_t *cmd;
2658
945c5ac8 2659 for (cmd = disp_table; cmd->name != NULL; cmd++) {
7fd669a1
LC		 2660 if (compare_cmd(cmdname, cmd->name)) {
2661 return cmd;
2662 }
2663 }
2664
2665 return NULL;
2666}
2667
5f3d335f 2668/*
ae50212f
BD		 2669 * Parse command name from @cmdp according to command table @table.
2670 * If blank, return NULL.
2671 * Else, if no valid command can be found, report to @mon, and return
2672 * NULL.
2673 * Else, change @cmdp to point right behind the name, and return its
2674 * command table entry.
2675 * Do not assume the return value points into @table! It doesn't when
2676 * the command is found in a sub-command table.
5f3d335f 2677 */
c227f099 2678static const mon_cmd_t *monitor_parse_command(Monitor *mon,
ae50212f
BD		 2679 const char **cmdp,
2680 mon_cmd_t *table)
9307c4c1 2681{
ae50212f 2682 const char *p;
c227f099 2683 const mon_cmd_t *cmd;
9307c4c1 2684 char cmdname[256];
9dc39cba 2685
9307c4c1 2686 /* extract the command name */
ae50212f 2687 p = get_command_name(*cmdp, cmdname, sizeof(cmdname));
4590fd80 2688 if (!p)
55f81d96 2689 return NULL;
3b46e624 2690
5f3d335f 2691 cmd = search_dispatch_table(table, cmdname);
7fd669a1 2692 if (!cmd) {
5f3d335f 2693 monitor_printf(mon, "unknown command: '%.*s'\n",
ae50212f 2694 (int)(p - *cmdp), *cmdp);
55f81d96 2695 return NULL;
9307c4c1 2696 }
9307c4c1 2697
5f3d335f
WX		 2698 /* filter out following useless space */
2699 while (qemu_isspace(*p)) {
2700 p++;
2701 }
ae50212f
BD		 2702
2703 *cmdp = p;
5f3d335f 2704 /* search sub command */
ae50212f
BD		 2705 if (cmd->sub_table != NULL && *p != '\0') {
2706 return monitor_parse_command(mon, cmdp, cmd->sub_table);
5f3d335f
WX		 2707 }
2708
ae50212f
BD		 2709 return cmd;
2710}
2711
2712/*
2713 * Parse arguments for @cmd.
2714 * If it can't be parsed, report to @mon, and return NULL.
2715 * Else, insert command arguments into a QDict, and return it.
2716 * Note: On success, caller has to free the QDict structure.
2717 */
2718
2719static QDict *monitor_parse_arguments(Monitor *mon,
2720 const char **endp,
2721 const mon_cmd_t *cmd)
2722{
2723 const char *typestr;
2724 char *key;
2725 int c;
2726 const char *p = *endp;
2727 char buf[1024];
2728 QDict *qdict = qdict_new();
2729
9307c4c1
FB		 2730 /* parse the parameters */
2731 typestr = cmd->args_type;
9dc39cba 2732 for(;;) {
4d76d2ba
LC		 2733 typestr = key_get_info(typestr, &key);
2734 if (!typestr)
9dc39cba 2735 break;
4d76d2ba 2736 c = *typestr;
9307c4c1
FB		 2737 typestr++;
2738 switch(c) {
2739 case 'F':
81d0912d 2740 case 'B':
9307c4c1
FB		 2741 case 's':
2742 {
2743 int ret;
3b46e624 2744
cd390083 2745 while (qemu_isspace(*p))
9307c4c1
FB		 2746 p++;
2747 if (*typestr == '?') {
2748 typestr++;
2749 if (*p == '\0') {
2750 /* no optional string: NULL argument */
53773581 2751 break;
9307c4c1
FB		 2752 }
2753 }
2754 ret = get_str(buf, sizeof(buf), &p);
2755 if (ret < 0) {
81d0912d
FB		 2756 switch(c) {
2757 case 'F':
376253ec 2758 monitor_printf(mon, "%s: filename expected\n",
ae50212f 2759 cmd->name);
81d0912d
FB		 2760 break;
2761 case 'B':
376253ec 2762 monitor_printf(mon, "%s: block device name expected\n",
ae50212f 2763 cmd->name);
81d0912d
FB		 2764 break;
2765 default:
ae50212f 2766 monitor_printf(mon, "%s: string expected\n", cmd->name);
81d0912d
FB		 2767 break;
2768 }
9307c4c1
FB		 2769 goto fail;
2770 }
46f5ac20 2771 qdict_put_str(qdict, key, buf);
9307c4c1 2772 }
9dc39cba 2773 break;
361127df
MA		 2774 case 'O':
2775 {
2776 QemuOptsList *opts_list;
2777 QemuOpts *opts;
2778
2779 opts_list = qemu_find_opts(key);
2780 if (!opts_list || opts_list->desc->name) {
2781 goto bad_type;
2782 }
2783 while (qemu_isspace(*p)) {
2784 p++;
2785 }
2786 if (!*p)
2787 break;
2788 if (get_str(buf, sizeof(buf), &p) < 0) {
2789 goto fail;
2790 }
70b94331 2791 opts = qemu_opts_parse_noisily(opts_list, buf, true);
361127df
MA		 2792 if (!opts) {
2793 goto fail;
2794 }
2795 qemu_opts_to_qdict(opts, qdict);
2796 qemu_opts_del(opts);
2797 }
2798 break;
9307c4c1
FB		 2799 case '/':
2800 {
2801 int count, format, size;
3b46e624 2802
cd390083 2803 while (qemu_isspace(*p))
9307c4c1
FB		 2804 p++;
2805 if (*p == '/') {
2806 /* format found */
2807 p++;
2808 count = 1;
cd390083 2809 if (qemu_isdigit(*p)) {
9307c4c1 2810 count = 0;
cd390083 2811 while (qemu_isdigit(*p)) {
9307c4c1
FB		 2812 count = count * 10 + (*p - '0');
2813 p++;
2814 }
2815 }
2816 size = -1;
2817 format = -1;
2818 for(;;) {
2819 switch(*p) {
2820 case 'o':
2821 case 'd':
2822 case 'u':
2823 case 'x':
2824 case 'i':
2825 case 'c':
2826 format = *p++;
2827 break;
2828 case 'b':
2829 size = 1;
2830 p++;
2831 break;
2832 case 'h':
2833 size = 2;
2834 p++;
2835 break;
2836 case 'w':
2837 size = 4;
2838 p++;
2839 break;
2840 case 'g':
2841 case 'L':
2842 size = 8;
2843 p++;
2844 break;
2845 default:
2846 goto next;
2847 }
2848 }
2849 next:
cd390083 2850 if (*p != '\0' && !qemu_isspace(*p)) {
376253ec
AL		 2851 monitor_printf(mon, "invalid char in format: '%c'\n",
2852 *p);
9307c4c1
FB		 2853 goto fail;
2854 }
9307c4c1
FB		 2855 if (format < 0)
2856 format = default_fmt_format;
4c27ba27
FB		 2857 if (format != 'i') {
2858 /* for 'i', not specifying a size gives -1 as size */
2859 if (size < 0)
2860 size = default_fmt_size;
e90f009b 2861 default_fmt_size = size;
4c27ba27 2862 }
9307c4c1
FB		 2863 default_fmt_format = format;
2864 } else {
2865 count = 1;
2866 format = default_fmt_format;
4c27ba27
FB		 2867 if (format != 'i') {
2868 size = default_fmt_size;
2869 } else {
2870 size = -1;
2871 }
9307c4c1 2872 }
46f5ac20
EB		 2873 qdict_put_int(qdict, "count", count);
2874 qdict_put_int(qdict, "format", format);
2875 qdict_put_int(qdict, "size", size);
9307c4c1 2876 }
9dc39cba 2877 break;
9307c4c1 2878 case 'i':
92a31b1f 2879 case 'l':
b6e098d7 2880 case 'M':
9307c4c1 2881 {
c2efc95d 2882 int64_t val;
7743e588 2883
cd390083 2884 while (qemu_isspace(*p))
9307c4c1 2885 p++;
3440557b 2886 if (*typestr == '?' || *typestr == '.') {
3440557b 2887 if (*typestr == '?') {
53773581
LC		 2888 if (*p == '\0') {
2889 typestr++;
2890 break;
2891 }
3440557b
FB		 2892 } else {
2893 if (*p == '.') {
2894 p++;
cd390083 2895 while (qemu_isspace(*p))
3440557b 2896 p++;
3440557b 2897 } else {
53773581
LC		 2898 typestr++;
2899 break;
3440557b
FB		 2900 }
2901 }
13224a87 2902 typestr++;
9307c4c1 2903 }
376253ec 2904 if (get_expr(mon, &val, &p))
9307c4c1 2905 goto fail;
675ebef9
LC		 2906 /* Check if 'i' is greater than 32-bit */
2907 if ((c == 'i') && ((val >> 32) & 0xffffffff)) {
ae50212f 2908 monitor_printf(mon, "\'%s\' has failed: ", cmd->name);
675ebef9
LC		 2909 monitor_printf(mon, "integer is for 32-bit values\n");
2910 goto fail;
b6e098d7 2911 } else if (c == 'M') {
91162849
LC		 2912 if (val < 0) {
2913 monitor_printf(mon, "enter a positive value\n");
2914 goto fail;
2915 }
b6e098d7 2916 val <<= 20;
675ebef9 2917 }
46f5ac20 2918 qdict_put_int(qdict, key, val);
9307c4c1
FB		 2919 }
2920 break;
dbc0c67f
JS		 2921 case 'o':
2922 {
f17fd4fd 2923 int ret;
f46bfdbf 2924 uint64_t val;
dbc0c67f
JS		 2925 char *end;
2926
2927 while (qemu_isspace(*p)) {
2928 p++;
2929 }
2930 if (*typestr == '?') {
2931 typestr++;
2932 if (*p == '\0') {
2933 break;
2934 }
2935 }
f17fd4fd 2936 ret = qemu_strtosz_MiB(p, &end, &val);
f46bfdbf 2937 if (ret < 0 || val > INT64_MAX) {
dbc0c67f
JS		 2938 monitor_printf(mon, "invalid size\n");
2939 goto fail;
2940 }
46f5ac20 2941 qdict_put_int(qdict, key, val);
dbc0c67f
JS		 2942 p = end;
2943 }
2944 break;
fccfb11e 2945 case 'T':
3350a4dd
MA		 2946 {
2947 double val;
2948
2949 while (qemu_isspace(*p))
2950 p++;
2951 if (*typestr == '?') {
2952 typestr++;
2953 if (*p == '\0') {
2954 break;
2955 }
2956 }
2957 if (get_double(mon, &val, &p) < 0) {
2958 goto fail;
2959 }
07de3e60 2960 if (p[0] && p[1] == 's') {
fccfb11e
MA		 2961 switch (*p) {
2962 case 'm':
2963 val /= 1e3; p += 2; break;
2964 case 'u':
2965 val /= 1e6; p += 2; break;
2966 case 'n':
2967 val /= 1e9; p += 2; break;
2968 }
2969 }
3350a4dd
MA		 2970 if (*p && !qemu_isspace(*p)) {
2971 monitor_printf(mon, "Unknown unit suffix\n");
2972 goto fail;
2973 }
2974 qdict_put(qdict, key, qfloat_from_double(val));
2975 }
2976 break;
942cd1f2
MA		 2977 case 'b':
2978 {
2979 const char *beg;
fc48ffc3 2980 bool val;
942cd1f2
MA		 2981
2982 while (qemu_isspace(*p)) {
2983 p++;
2984 }
2985 beg = p;
2986 while (qemu_isgraph(*p)) {
2987 p++;
2988 }
2989 if (p - beg == 2 && !memcmp(beg, "on", p - beg)) {
fc48ffc3 2990 val = true;
942cd1f2 2991 } else if (p - beg == 3 && !memcmp(beg, "off", p - beg)) {
fc48ffc3 2992 val = false;
942cd1f2
MA		 2993 } else {
2994 monitor_printf(mon, "Expected 'on' or 'off'\n");
2995 goto fail;
2996 }
46f5ac20 2997 qdict_put_bool(qdict, key, val);
942cd1f2
MA		 2998 }
2999 break;
9307c4c1
FB		 3000 case '-':
3001 {
fbc3d96c 3002 const char *tmp = p;
eb159d13 3003 int skip_key = 0;
9307c4c1 3004 /* option */
3b46e624 3005
9307c4c1
FB		 3006 c = *typestr++;
3007 if (c == '\0')
3008 goto bad_type;
cd390083 3009 while (qemu_isspace(*p))
9307c4c1 3010 p++;
9307c4c1
FB		 3011 if (*p == '-') {
3012 p++;
fbc3d96c
LS		 3013 if(c != *p) {
3014 if(!is_valid_option(p, typestr)) {
3015
3016 monitor_printf(mon, "%s: unsupported option -%c\n",
ae50212f 3017 cmd->name, *p);
fbc3d96c
LS		 3018 goto fail;
3019 } else {
3020 skip_key = 1;
3021 }
3022 }
3023 if(skip_key) {
3024 p = tmp;
3025 } else {
eb159d13 3026 /* has option */
fbc3d96c 3027 p++;
46f5ac20 3028 qdict_put_bool(qdict, key, true);
9307c4c1 3029 }
9307c4c1 3030 }
9307c4c1
FB		 3031 }
3032 break;
129be006
WX		 3033 case 'S':
3034 {
3035 /* package all remaining string */
3036 int len;
3037
3038 while (qemu_isspace(*p)) {
3039 p++;
3040 }
3041 if (*typestr == '?') {
3042 typestr++;
3043 if (*p == '\0') {
3044 /* no remaining string: NULL argument */
3045 break;
3046 }
3047 }
3048 len = strlen(p);
3049 if (len <= 0) {
3050 monitor_printf(mon, "%s: string expected\n",
ae50212f 3051 cmd->name);
e549d2aa 3052 goto fail;
129be006 3053 }
46f5ac20 3054 qdict_put_str(qdict, key, p);
129be006
WX		 3055 p += len;
3056 }
3057 break;
9307c4c1
FB		 3058 default:
3059 bad_type:
ae50212f 3060 monitor_printf(mon, "%s: unknown type '%c'\n", cmd->name, c);
9307c4c1
FB		 3061 goto fail;
3062 }
7267c094 3063 g_free(key);
4d76d2ba 3064 key = NULL;
9dc39cba 3065 }
9307c4c1 3066 /* check that all arguments were parsed */
cd390083 3067 while (qemu_isspace(*p))
9307c4c1
FB		 3068 p++;
3069 if (*p != '\0') {
376253ec 3070 monitor_printf(mon, "%s: extraneous characters at the end of line\n",
ae50212f 3071 cmd->name);
9307c4c1 3072 goto fail;
9dc39cba 3073 }
9307c4c1 3074
ae50212f 3075 return qdict;
ac7531ec 3076
55f81d96 3077fail:
ae50212f 3078 QDECREF(qdict);
7267c094 3079 g_free(key);
55f81d96
LC		 3080 return NULL;
3081}
3082
7ef6cf63 3083static void handle_hmp_command(Monitor *mon, const char *cmdline)
55f81d96 3084{
55f81d96 3085 QDict *qdict;
c227f099 3086 const mon_cmd_t *cmd;
55f81d96 3087
ae50212f
BD		 3088 cmd = monitor_parse_command(mon, &cmdline, mon->cmd_table);
3089 if (!cmd) {
3090 return;
3091 }
55f81d96 3092
ae50212f
BD		 3093 qdict = monitor_parse_arguments(mon, &cmdline, cmd);
3094 if (!qdict) {
dd41eea7
BD		 3095 monitor_printf(mon, "Try \"help %s\" for more information\n",
3096 cmd->name);
ae50212f 3097 return;
55f81d96
LC		 3098 }
3099
2b9e3576 3100 cmd->cmd(mon, qdict);
f7188bbe 3101 QDECREF(qdict);
9dc39cba
FB		 3102}
3103
cd5c6bba 3104static void cmd_completion(Monitor *mon, const char *name, const char *list)
81d0912d
FB		 3105{
3106 const char *p, *pstart;
3107 char cmd[128];
3108 int len;
3109
3110 p = list;
3111 for(;;) {
3112 pstart = p;
3113 p = strchr(p, '|');
3114 if (!p)
3115 p = pstart + strlen(pstart);
3116 len = p - pstart;
3117 if (len > sizeof(cmd) - 2)
3118 len = sizeof(cmd) - 2;
3119 memcpy(cmd, pstart, len);
3120 cmd[len] = '\0';
3121 if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
cd5c6bba 3122 readline_add_completion(mon->rs, cmd);
81d0912d
FB		 3123 }
3124 if (*p == '\0')
3125 break;
3126 p++;
3127 }
3128}
3129
cb8f68b1 3130static void file_completion(Monitor *mon, const char *input)
81d0912d
FB		 3131{
3132 DIR *ffs;
3133 struct dirent *d;
3134 char path[1024];
3135 char file[1024], file_prefix[1024];
3136 int input_path_len;
3137 const char *p;
3138
5fafdf24 3139 p = strrchr(input, '/');
81d0912d
FB		 3140 if (!p) {
3141 input_path_len = 0;
3142 pstrcpy(file_prefix, sizeof(file_prefix), input);
363a37d5 3143 pstrcpy(path, sizeof(path), ".");
81d0912d
FB		 3144 } else {
3145 input_path_len = p - input + 1;
3146 memcpy(path, input, input_path_len);
3147 if (input_path_len > sizeof(path) - 1)
3148 input_path_len = sizeof(path) - 1;
3149 path[input_path_len] = '\0';
3150 pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
3151 }
19f2db5c 3152
81d0912d
FB		 3153 ffs = opendir(path);
3154 if (!ffs)
3155 return;
3156 for(;;) {
3157 struct stat sb;
3158 d = readdir(ffs);
3159 if (!d)
3160 break;
46c7fc18
KK		 3161
3162 if (strcmp(d->d_name, ".") == 0 || strcmp(d->d_name, "..") == 0) {
3163 continue;
3164 }
3165
81d0912d
FB		 3166 if (strstart(d->d_name, file_prefix, NULL)) {
3167 memcpy(file, input, input_path_len);
363a37d5
BS		 3168 if (input_path_len < sizeof(file))
3169 pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
3170 d->d_name);
81d0912d
FB		 3171 /* stat the file to find out if it's a directory.
3172 * In that case add a slash to speed up typing long paths
3173 */
c951d9a6 3174 if (stat(file, &sb) == 0 && S_ISDIR(sb.st_mode)) {
363a37d5 3175 pstrcat(file, sizeof(file), "/");
c951d9a6 3176 }
cb8f68b1 3177 readline_add_completion(mon->rs, file);
81d0912d
FB		 3178 }
3179 }
3180 closedir(ffs);
3181}
3182
4d76d2ba
LC		 3183static const char *next_arg_type(const char *typestr)
3184{
3185 const char *p = strchr(typestr, ':');
3186 return (p != NULL ? ++p : typestr);
3187}
3188
40d19394
HB		 3189static void add_completion_option(ReadLineState *rs, const char *str,
3190 const char *option)
3191{
3192 if (!str || !option) {
3193 return;
3194 }
3195 if (!strncmp(option, str, strlen(str))) {
3196 readline_add_completion(rs, option);
3197 }
3198}
3199
13e315da
HB		 3200void chardev_add_completion(ReadLineState *rs, int nb_args, const char *str)
3201{
3202 size_t len;
3203 ChardevBackendInfoList *list, *start;
3204
3205 if (nb_args != 2) {
3206 return;
3207 }
3208 len = strlen(str);
3209 readline_set_completion_index(rs, len);
3210
3211 start = list = qmp_query_chardev_backends(NULL);
3212 while (list) {
3213 const char *chr_name = list->value->name;
3214
3215 if (!strncmp(chr_name, str, len)) {
3216 readline_add_completion(rs, chr_name);
3217 }
3218 list = list->next;
3219 }
3220 qapi_free_ChardevBackendInfoList(start);
3221}
3222
b162b49a
HB		 3223void netdev_add_completion(ReadLineState *rs, int nb_args, const char *str)
3224{
3225 size_t len;
3226 int i;
3227
3228 if (nb_args != 2) {
3229 return;
3230 }
3231 len = strlen(str);
3232 readline_set_completion_index(rs, len);
f394b2e2
EB		 3233 for (i = 0; NetClientDriver_lookup[i]; i++) {
3234 add_completion_option(rs, str, NetClientDriver_lookup[i]);
b162b49a
HB		 3235 }
3236}
3237
2da1b3ab 3238void device_add_completion(ReadLineState *rs, int nb_args, const char *str)
992d3e64
HB		 3239{
3240 GSList *list, *elt;
3241 size_t len;
3242
2da1b3ab
HB		 3243 if (nb_args != 2) {
3244 return;
3245 }
3246
992d3e64
HB		 3247 len = strlen(str);
3248 readline_set_completion_index(rs, len);
3249 list = elt = object_class_get_list(TYPE_DEVICE, false);
3250 while (elt) {
3251 const char *name;
3252 DeviceClass *dc = OBJECT_CLASS_CHECK(DeviceClass, elt->data,
3253 TYPE_DEVICE);
3254 name = object_class_get_name(OBJECT_CLASS(dc));
2da1b3ab 3255
e90f2a8c 3256 if (dc->user_creatable
2da1b3ab 3257 && !strncmp(name, str, len)) {
992d3e64
HB		 3258 readline_add_completion(rs, name);
3259 }
3260 elt = elt->next;
3261 }
3262 g_slist_free(list);
3263}
3264
bfa40f77 3265void object_add_completion(ReadLineState *rs, int nb_args, const char *str)
1094fd3a
HB		 3266{
3267 GSList *list, *elt;
3268 size_t len;
3269
bfa40f77
HB		 3270 if (nb_args != 2) {
3271 return;
3272 }
3273
1094fd3a
HB		 3274 len = strlen(str);
3275 readline_set_completion_index(rs, len);
3276 list = elt = object_class_get_list(TYPE_USER_CREATABLE, false);
3277 while (elt) {
3278 const char *name;
3279
3280 name = object_class_get_name(OBJECT_CLASS(elt->data));
3281 if (!strncmp(name, str, len) && strcmp(name, TYPE_USER_CREATABLE)) {
3282 readline_add_completion(rs, name);
3283 }
3284 elt = elt->next;
3285 }
3286 g_slist_free(list);
3287}
3288
6a1fa9f5
ZG		 3289static void peripheral_device_del_completion(ReadLineState *rs,
3290 const char *str, size_t len)
3291{
4cae4d5a
MA		 3292 Object *peripheral = container_get(qdev_get_machine(), "/peripheral");
3293 GSList *list, *item;
6a1fa9f5 3294
4cae4d5a
MA		 3295 list = qdev_build_hotpluggable_device_list(peripheral);
3296 if (!list) {
6a1fa9f5
ZG		 3297 return;
3298 }
3299
6a1fa9f5
ZG		 3300 for (item = list; item; item = g_slist_next(item)) {
3301 DeviceState *dev = item->data;
3302
3303 if (dev->id && !strncmp(str, dev->id, len)) {
3304 readline_add_completion(rs, dev->id);
3305 }
3306 }
3307
3308 g_slist_free(list);
3309}
3310
6297d9a2
HB		 3311void chardev_remove_completion(ReadLineState *rs, int nb_args, const char *str)
3312{
3313 size_t len;
3314 ChardevInfoList *list, *start;
3315
3316 if (nb_args != 2) {
3317 return;
3318 }
3319 len = strlen(str);
3320 readline_set_completion_index(rs, len);
3321
3322 start = list = qmp_query_chardev(NULL);
3323 while (list) {
3324 ChardevInfo *chr = list->value;
3325
3326 if (!strncmp(chr->label, str, len)) {
3327 readline_add_completion(rs, chr->label);
3328 }
3329 list = list->next;
3330 }
3331 qapi_free_ChardevInfoList(start);
3332}
3333
8e597779
HB		 3334static void ringbuf_completion(ReadLineState *rs, const char *str)
3335{
3336 size_t len;
3337 ChardevInfoList *list, *start;
3338
3339 len = strlen(str);
3340 readline_set_completion_index(rs, len);
3341
3342 start = list = qmp_query_chardev(NULL);
3343 while (list) {
3344 ChardevInfo *chr_info = list->value;
3345
3346 if (!strncmp(chr_info->label, str, len)) {
0ec7b3e7 3347 Chardev *chr = qemu_chr_find(chr_info->label);
777357d7 3348 if (chr && CHARDEV_IS_RINGBUF(chr)) {
8e597779
HB		 3349 readline_add_completion(rs, chr_info->label);
3350 }
3351 }
3352 list = list->next;
3353 }
3354 qapi_free_ChardevInfoList(start);
3355}
3356
8e597779
HB		 3357void ringbuf_write_completion(ReadLineState *rs, int nb_args, const char *str)
3358{
3359 if (nb_args != 2) {
3360 return;
3361 }
3362 ringbuf_completion(rs, str);
3363}
3364
2da1b3ab
HB		 3365void device_del_completion(ReadLineState *rs, int nb_args, const char *str)
3366{
3367 size_t len;
3368
3369 if (nb_args != 2) {
3370 return;
3371 }
3372
3373 len = strlen(str);
3374 readline_set_completion_index(rs, len);
6a1fa9f5 3375 peripheral_device_del_completion(rs, str, len);
2da1b3ab
HB		 3376}
3377
bfa40f77 3378void object_del_completion(ReadLineState *rs, int nb_args, const char *str)
b48fa074
HB		 3379{
3380 ObjectPropertyInfoList *list, *start;
3381 size_t len;
3382
bfa40f77
HB		 3383 if (nb_args != 2) {
3384 return;
3385 }
b48fa074
HB		 3386 len = strlen(str);
3387 readline_set_completion_index(rs, len);
3388
3389 start = list = qmp_qom_list("/objects", NULL);
3390 while (list) {
3391 ObjectPropertyInfo *info = list->value;
3392
3393 if (!strncmp(info->type, "child<", 5)
3394 && !strncmp(info->name, str, len)) {
3395 readline_add_completion(rs, info->name);
3396 }
3397 list = list->next;
3398 }
3399 qapi_free_ObjectPropertyInfoList(start);
3400}
3401
29136cd8
HB		 3402void sendkey_completion(ReadLineState *rs, int nb_args, const char *str)
3403{
3404 int i;
3405 char *sep;
3406 size_t len;
3407
3408 if (nb_args != 2) {
3409 return;
3410 }
3411 sep = strrchr(str, '-');
3412 if (sep) {
3413 str = sep + 1;
3414 }
3415 len = strlen(str);
3416 readline_set_completion_index(rs, len);
7fb1cf16 3417 for (i = 0; i < Q_KEY_CODE__MAX; i++) {
29136cd8
HB		 3418 if (!strncmp(str, QKeyCode_lookup[i], len)) {
3419 readline_add_completion(rs, QKeyCode_lookup[i]);
3420 }
3421 }
3422}
3423
40d19394
HB		 3424void set_link_completion(ReadLineState *rs, int nb_args, const char *str)
3425{
3426 size_t len;
3427
3428 len = strlen(str);
3429 readline_set_completion_index(rs, len);
3430 if (nb_args == 2) {
eaed483c 3431 NetClientState *ncs[MAX_QUEUE_NUM];
40d19394
HB		 3432 int count, i;
3433 count = qemu_find_net_clients_except(NULL, ncs,
f394b2e2 3434 NET_CLIENT_DRIVER_NONE,
eaed483c 3435 MAX_QUEUE_NUM);
bcfa4d60 3436 for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
40d19394
HB		 3437 const char *name = ncs[i]->name;
3438 if (!strncmp(str, name, len)) {
3439 readline_add_completion(rs, name);
3440 }
3441 }
3442 } else if (nb_args == 3) {
3443 add_completion_option(rs, str, "on");
3444 add_completion_option(rs, str, "off");
3445 }
3446}
3447
11b389f2
HB		 3448void netdev_del_completion(ReadLineState *rs, int nb_args, const char *str)
3449{
3450 int len, count, i;
eaed483c 3451 NetClientState *ncs[MAX_QUEUE_NUM];
11b389f2
HB		 3452
3453 if (nb_args != 2) {
3454 return;
3455 }
3456
3457 len = strlen(str);
3458 readline_set_completion_index(rs, len);
f394b2e2 3459 count = qemu_find_net_clients_except(NULL, ncs, NET_CLIENT_DRIVER_NIC,
eaed483c 3460 MAX_QUEUE_NUM);
bcfa4d60 3461 for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
11b389f2
HB		 3462 QemuOpts *opts;
3463 const char *name = ncs[i]->name;
3464 if (strncmp(str, name, len)) {
3465 continue;
3466 }
3467 opts = qemu_opts_find(qemu_find_opts_err("netdev", NULL), name);
3468 if (opts) {
3469 readline_add_completion(rs, name);
3470 }
3471 }
3472}
3473
bd71211d
LV		 3474void info_trace_events_completion(ReadLineState *rs, int nb_args, const char *str)
3475{
3476 size_t len;
3477
3478 len = strlen(str);
3479 readline_set_completion_index(rs, len);
3480 if (nb_args == 2) {
0d4e995c
DB		 3481 TraceEventIter iter;
3482 TraceEvent *ev;
3483 char *pattern = g_strdup_printf("%s*", str);
3484 trace_event_iter_init(&iter, pattern);
3485 while ((ev = trace_event_iter_next(&iter)) != NULL) {
3486 readline_add_completion(rs, trace_event_get_name(ev));
bd71211d 3487 }
0d4e995c 3488 g_free(pattern);
bd71211d
LV		 3489 }
3490}
3491
987bd270
DDAG		 3492void trace_event_completion(ReadLineState *rs, int nb_args, const char *str)
3493{
3494 size_t len;
3495
3496 len = strlen(str);
3497 readline_set_completion_index(rs, len);
3498 if (nb_args == 2) {
0d4e995c
DB		 3499 TraceEventIter iter;
3500 TraceEvent *ev;
3501 char *pattern = g_strdup_printf("%s*", str);
3502 trace_event_iter_init(&iter, pattern);
3503 while ((ev = trace_event_iter_next(&iter)) != NULL) {
3504 readline_add_completion(rs, trace_event_get_name(ev));
3505 }
3506 g_free(pattern);
987bd270
DDAG		 3507 } else if (nb_args == 3) {
3508 add_completion_option(rs, str, "on");
3509 add_completion_option(rs, str, "off");
3510 }
3511}
3512
d0ece345
HB		 3513void watchdog_action_completion(ReadLineState *rs, int nb_args, const char *str)
3514{
4bb08af3
HB		 3515 int i;
3516
d0ece345
HB		 3517 if (nb_args != 2) {
3518 return;
3519 }
3520 readline_set_completion_index(rs, strlen(str));
4bb08af3
HB		 3521 for (i = 0; WatchdogExpirationAction_lookup[i]; i++) {
3522 add_completion_option(rs, str, WatchdogExpirationAction_lookup[i]);
3523 }
d0ece345
HB		 3524}
3525
c68a0409
HB		 3526void migrate_set_capability_completion(ReadLineState *rs, int nb_args,
3527 const char *str)
3528{
3529 size_t len;
3530
3531 len = strlen(str);
3532 readline_set_completion_index(rs, len);
3533 if (nb_args == 2) {
3534 int i;
7fb1cf16 3535 for (i = 0; i < MIGRATION_CAPABILITY__MAX; i++) {
c68a0409
HB		 3536 const char *name = MigrationCapability_lookup[i];
3537 if (!strncmp(str, name, len)) {
3538 readline_add_completion(rs, name);
3539 }
3540 }
3541 } else if (nb_args == 3) {
3542 add_completion_option(rs, str, "on");
3543 add_completion_option(rs, str, "off");
3544 }
3545}
3546
50e9a629
LL		 3547void migrate_set_parameter_completion(ReadLineState *rs, int nb_args,
3548 const char *str)
3549{
3550 size_t len;
3551
3552 len = strlen(str);
3553 readline_set_completion_index(rs, len);
3554 if (nb_args == 2) {
3555 int i;
7fb1cf16 3556 for (i = 0; i < MIGRATION_PARAMETER__MAX; i++) {
50e9a629
LL		 3557 const char *name = MigrationParameter_lookup[i];
3558 if (!strncmp(str, name, len)) {
3559 readline_add_completion(rs, name);
3560 }
3561 }
3562 }
3563}
3564
e3bb532c
HB		 3565void host_net_add_completion(ReadLineState *rs, int nb_args, const char *str)
3566{
3567 int i;
3568 size_t len;
3569 if (nb_args != 2) {
3570 return;
3571 }
3572 len = strlen(str);
3573 readline_set_completion_index(rs, len);
3574 for (i = 0; host_net_devices[i]; i++) {
3575 if (!strncmp(host_net_devices[i], str, len)) {
3576 readline_add_completion(rs, host_net_devices[i]);
3577 }
3578 }
3579}
3580
ddd6b45c
HB		 3581void host_net_remove_completion(ReadLineState *rs, int nb_args, const char *str)
3582{
eaed483c 3583 NetClientState *ncs[MAX_QUEUE_NUM];
ddd6b45c
HB		 3584 int count, i, len;
3585
3586 len = strlen(str);
3587 readline_set_completion_index(rs, len);
3588 if (nb_args == 2) {
3589 count = qemu_find_net_clients_except(NULL, ncs,
f394b2e2 3590 NET_CLIENT_DRIVER_NONE,
eaed483c 3591 MAX_QUEUE_NUM);
bcfa4d60 3592 for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
ddd6b45c
HB		 3593 int id;
3594 char name[16];
3595
3596 if (net_hub_id_for_client(ncs[i], &id)) {
3597 continue;
3598 }
3599 snprintf(name, sizeof(name), "%d", id);
3600 if (!strncmp(str, name, len)) {
3601 readline_add_completion(rs, name);
3602 }
3603 }
3604 return;
3605 } else if (nb_args == 3) {
3606 count = qemu_find_net_clients_except(NULL, ncs,
f394b2e2 3607 NET_CLIENT_DRIVER_NIC,
eaed483c 3608 MAX_QUEUE_NUM);
bcfa4d60 3609 for (i = 0; i < MIN(count, MAX_QUEUE_NUM); i++) {
2c4681f5 3610 int id;
ddd6b45c
HB		 3611 const char *name;
3612
f394b2e2 3613 if (ncs[i]->info->type == NET_CLIENT_DRIVER_HUBPORT ||
2c4681f5
JW		 3614 net_hub_id_for_client(ncs[i], &id)) {
3615 continue;
3616 }
ddd6b45c
HB		 3617 name = ncs[i]->name;
3618 if (!strncmp(str, name, len)) {
3619 readline_add_completion(rs, name);
3620 }
3621 }
3622 return;
3623 }
3624}
3625
b21631f3
HB		 3626static void vm_completion(ReadLineState *rs, const char *str)
3627{
3628 size_t len;
7c8eece4 3629 BlockDriverState *bs;
88be7b4b 3630 BdrvNextIterator it;
b21631f3
HB		 3631
3632 len = strlen(str);
3633 readline_set_completion_index(rs, len);
7c8eece4 3634
88be7b4b 3635 for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
b21631f3 3636 SnapshotInfoList *snapshots, *snapshot;
6bf1faa8
DL		 3637 AioContext *ctx = bdrv_get_aio_context(bs);
3638 bool ok = false;
b21631f3 3639
6bf1faa8
DL		 3640 aio_context_acquire(ctx);
3641 if (bdrv_can_snapshot(bs)) {
3642 ok = bdrv_query_snapshot_info_list(bs, &snapshots, NULL) == 0;
b21631f3 3643 }
6bf1faa8
DL		 3644 aio_context_release(ctx);
3645 if (!ok) {
b21631f3
HB		 3646 continue;
3647 }
6bf1faa8 3648
b21631f3
HB		 3649 snapshot = snapshots;
3650 while (snapshot) {
3651 char *completion = snapshot->value->name;
3652 if (!strncmp(str, completion, len)) {
3653 readline_add_completion(rs, completion);
3654 }
3655 completion = snapshot->value->id;
3656 if (!strncmp(str, completion, len)) {
3657 readline_add_completion(rs, completion);
3658 }
3659 snapshot = snapshot->next;
3660 }
3661 qapi_free_SnapshotInfoList(snapshots);
3662 }
3663
3664}
3665
3666void delvm_completion(ReadLineState *rs, int nb_args, const char *str)
3667{
3668 if (nb_args == 2) {
3669 vm_completion(rs, str);
3670 }
3671}
3672
3673void loadvm_completion(ReadLineState *rs, int nb_args, const char *str)
3674{
3675 if (nb_args == 2) {
3676 vm_completion(rs, str);
3677 }
3678}
3679
c35b6400
WX		 3680static void monitor_find_completion_by_table(Monitor *mon,
3681 const mon_cmd_t *cmd_table,
3682 char **args,
3683 int nb_args)
81d0912d
FB		 3684{
3685 const char *cmdname;
c35b6400 3686 int i;
fea68bb6 3687 const char *ptype, *str, *name;
c227f099 3688 const mon_cmd_t *cmd;
da27a00e 3689 BlockBackend *blk = NULL;
81d0912d 3690
81d0912d
FB		 3691 if (nb_args <= 1) {
3692 /* command completion */
3693 if (nb_args == 0)
3694 cmdname = "";
3695 else
3696 cmdname = args[0];
d2674b2c 3697 readline_set_completion_index(mon->rs, strlen(cmdname));
c35b6400 3698 for (cmd = cmd_table; cmd->name != NULL; cmd++) {
cd5c6bba 3699 cmd_completion(mon, cmdname, cmd->name);
81d0912d
FB		 3700 }
3701 } else {
3702 /* find the command */
c35b6400 3703 for (cmd = cmd_table; cmd->name != NULL; cmd++) {
03a63484
JK		 3704 if (compare_cmd(args[0], cmd->name)) {
3705 break;
3706 }
81d0912d 3707 }
03a63484 3708 if (!cmd->name) {
c35b6400 3709 return;
03a63484
JK		 3710 }
3711
d903a779
WX		 3712 if (cmd->sub_table) {
3713 /* do the job again */
e7ae771f
SW		 3714 monitor_find_completion_by_table(mon, cmd->sub_table,
3715 &args[1], nb_args - 1);
3716 return;
d903a779 3717 }
bfa40f77 3718 if (cmd->command_completion) {
e7ae771f
SW		 3719 cmd->command_completion(mon->rs, nb_args, args[nb_args - 1]);
3720 return;
bfa40f77 3721 }
d903a779 3722
4d76d2ba 3723 ptype = next_arg_type(cmd->args_type);
81d0912d
FB		 3724 for(i = 0; i < nb_args - 2; i++) {
3725 if (*ptype != '\0') {
4d76d2ba 3726 ptype = next_arg_type(ptype);
81d0912d 3727 while (*ptype == '?')
4d76d2ba 3728 ptype = next_arg_type(ptype);
81d0912d
FB		 3729 }
3730 }
3731 str = args[nb_args - 1];
48fe86f6 3732 while (*ptype == '-' && ptype[1] != '\0') {
3b6dbf27 3733 ptype = next_arg_type(ptype);
2a1704a7 3734 }
81d0912d
FB		 3735 switch(*ptype) {
3736 case 'F':
3737 /* file completion */
d2674b2c 3738 readline_set_completion_index(mon->rs, strlen(str));
cb8f68b1 3739 file_completion(mon, str);
81d0912d
FB		 3740 break;
3741 case 'B':
3742 /* block device name completion */
599a926a 3743 readline_set_completion_index(mon->rs, strlen(str));
da27a00e
HR		 3744 while ((blk = blk_next(blk)) != NULL) {
3745 name = blk_name(blk);
fea68bb6
MA		 3746 if (str[0] == '\0' ||
3747 !strncmp(name, str, strlen(str))) {
3748 readline_add_completion(mon->rs, name);
3749 }
3750 }
81d0912d 3751 break;
7fe48483 3752 case 's':
129be006 3753 case 'S':
29136cd8 3754 if (!strcmp(cmd->name, "help|?")) {
7ca0e061
WX		 3755 monitor_find_completion_by_table(mon, cmd_table,
3756 &args[1], nb_args - 1);
7fe48483
FB		 3757 }
3758 break;
81d0912d
FB		 3759 default:
3760 break;
3761 }
3762 }
c35b6400
WX		 3763}
3764
c60bf339 3765static void monitor_find_completion(void *opaque,
c35b6400
WX		 3766 const char *cmdline)
3767{
c60bf339 3768 Monitor *mon = opaque;
c35b6400
WX		 3769 char *args[MAX_ARGS];
3770 int nb_args, len;
3771
3772 /* 1. parse the cmdline */
3773 if (parse_cmdline(cmdline, &nb_args, args) < 0) {
3774 return;
3775 }
c35b6400
WX		 3776
3777 /* if the line ends with a space, it means we want to complete the
3778 next arg */
3779 len = strlen(cmdline);
3780 if (len > 0 && qemu_isspace(cmdline[len - 1])) {
3781 if (nb_args >= MAX_ARGS) {
3782 goto cleanup;
3783 }
3784 args[nb_args++] = g_strdup("");
3785 }
3786
3787 /* 2. auto complete according to args */
3788 monitor_find_completion_by_table(mon, mon->cmd_table, args, nb_args);
03a63484
JK		 3789
3790cleanup:
dcc70cdf 3791 free_cmdline_args(args, nb_args);
81d0912d
FB		 3792}
3793
731b0364 3794static int monitor_can_read(void *opaque)
9dc39cba 3795{
731b0364
AL		 3796 Monitor *mon = opaque;
3797
c62313bb 3798 return (mon->suspend_cnt == 0) ? 1 : 0;
9dc39cba
FB		 3799}
3800
95385fe9 3801static void handle_qmp_command(JSONMessageParser *parser, GQueue *tokens)
5fa737a4 3802{
5c678ee8
MAL		 3803 QObject *req, *rsp = NULL, *id = NULL;
3804 QDict *qdict = NULL;
5fa737a4 3805 Monitor *mon = cur_mon;
5c678ee8 3806 Error *err = NULL;
5fa737a4 3807
5c678ee8 3808 req = json_parser_parse_err(tokens, NULL, &err);
bbf1028a
MA		 3809 if (!req && !err) {
3810 /* json_parser_parse_err() sucks: can fail without setting @err */
3811 error_setg(&err, QERR_JSON_PARSING);
3812 }
3813 if (err) {
5fa737a4 3814 goto err_out;
5fa737a4
LC		 3815 }
3816
104fc302
MA		 3817 qdict = qobject_to_qdict(req);
3818 if (qdict) {
3819 id = qdict_get(qdict, "id");
3820 qobject_incref(id);
3821 qdict_del(qdict, "id");
3822 } /* else will fail qmp_dispatch() */
5c678ee8 3823
635db18f 3824 rsp = qmp_dispatch(cur_mon->qmp.commands, req);
5fa737a4 3825
635db18f
MA		 3826 if (mon->qmp.commands == &qmp_cap_negotiation_commands) {
3827 qdict = qdict_get_qdict(qobject_to_qdict(rsp), "error");
3828 if (qdict
3829 && !g_strcmp0(qdict_get_try_str(qdict, "class"),
3830 QapiErrorClass_lookup[ERROR_CLASS_COMMAND_NOT_FOUND])) {
3831 /* Provide a more useful error message */
3832 qdict_del(qdict, "desc");
46f5ac20
EB		 3833 qdict_put_str(qdict, "desc", "Expecting capabilities negotiation"
3834 " with 'qmp_capabilities'");
635db18f
MA		 3835 }
3836 }
5fa737a4 3837
5c678ee8
MAL		 3838err_out:
3839 if (err) {
3840 qdict = qdict_new();
3841 qdict_put_obj(qdict, "error", qmp_build_error_object(err));
3842 error_free(err);
3843 rsp = QOBJECT(qdict);
5fa737a4
LC		 3844 }
3845
5c678ee8
MAL		 3846 if (rsp) {
3847 if (id) {
3848 qdict_put_obj(qobject_to_qdict(rsp), "id", id);
3849 id = NULL;
3850 }
5fa737a4 3851
5c678ee8
MAL		 3852 monitor_json_emitter(mon, rsp);
3853 }
3854
3855 qobject_decref(id);
3856 qobject_decref(rsp);
3857 qobject_decref(req);
5fa737a4
LC		 3858}
3859
c83fe23b 3860static void monitor_qmp_read(void *opaque, const uint8_t *buf, int size)
9b57c02e
LC		 3861{
3862 Monitor *old_mon = cur_mon;
3863
3864 cur_mon = opaque;
3865
74358f2a 3866 json_message_parser_feed(&cur_mon->qmp.parser, (const char *) buf, size);
9b57c02e
LC		 3867
3868 cur_mon = old_mon;
3869}
3870
731b0364 3871static void monitor_read(void *opaque, const uint8_t *buf, int size)
9dc39cba 3872{
731b0364 3873 Monitor *old_mon = cur_mon;
7e2515e8 3874 int i;
376253ec 3875
731b0364
AL		 3876 cur_mon = opaque;
3877
cde76ee1
AL		 3878 if (cur_mon->rs) {
3879 for (i = 0; i < size; i++)
3880 readline_handle_byte(cur_mon->rs, buf[i]);
3881 } else {
3882 if (size == 0 || buf[size - 1] != 0)
3883 monitor_printf(cur_mon, "corrupted command\n");
3884 else
7ef6cf63 3885 handle_hmp_command(cur_mon, (char *)buf);
cde76ee1 3886 }
9dc39cba 3887
731b0364
AL		 3888 cur_mon = old_mon;
3889}
d8f44609 3890
c60bf339
SH		 3891static void monitor_command_cb(void *opaque, const char *cmdline,
3892 void *readline_opaque)
aa455485 3893{
c60bf339
SH		 3894 Monitor *mon = opaque;
3895
731b0364 3896 monitor_suspend(mon);
7ef6cf63 3897 handle_hmp_command(mon, cmdline);
731b0364 3898 monitor_resume(mon);
d8f44609
AL		 3899}
3900
cde76ee1 3901int monitor_suspend(Monitor *mon)
d8f44609 3902{
cde76ee1
AL		 3903 if (!mon->rs)
3904 return -ENOTTY;
731b0364 3905 mon->suspend_cnt++;
cde76ee1 3906 return 0;
d8f44609
AL		 3907}
3908
376253ec 3909void monitor_resume(Monitor *mon)
d8f44609 3910{
cde76ee1
AL		 3911 if (!mon->rs)
3912 return;
731b0364
AL		 3913 if (--mon->suspend_cnt == 0)
3914 readline_show_prompt(mon->rs);
aa455485
FB		 3915}
3916
ca9567e2
LC		 3917static QObject *get_qmp_greeting(void)
3918{
b9c15f16 3919 QObject *ver = NULL;
ca9567e2 3920
7fad30f0 3921 qmp_marshal_query_version(NULL, &ver, NULL);
c823501e
MAL		 3922
3923 return qobject_from_jsonf("{'QMP': {'version': %p, 'capabilities': []}}",
3924 ver);
ca9567e2
LC		 3925}
3926
c83fe23b 3927static void monitor_qmp_event(void *opaque, int event)
9b57c02e 3928{
47116d1c
LC		 3929 QObject *data;
3930 Monitor *mon = opaque;
9b57c02e 3931
47116d1c
LC		 3932 switch (event) {
3933 case CHR_EVENT_OPENED:
635db18f 3934 mon->qmp.commands = &qmp_cap_negotiation_commands;
ca9567e2 3935 data = get_qmp_greeting();
9b57c02e
LC		 3936 monitor_json_emitter(mon, data);
3937 qobject_decref(data);
efb87c16 3938 mon_refcount++;
47116d1c
LC		 3939 break;
3940 case CHR_EVENT_CLOSED:
74358f2a
MA		 3941 json_message_parser_destroy(&mon->qmp.parser);
3942 json_message_parser_init(&mon->qmp.parser, handle_qmp_command);
efb87c16
CB		 3943 mon_refcount--;
3944 monitor_fdsets_cleanup();
47116d1c 3945 break;
9b57c02e
LC		 3946 }
3947}
3948
731b0364 3949static void monitor_event(void *opaque, int event)
86e94dea 3950{
376253ec
AL		 3951 Monitor *mon = opaque;
3952
2724b180
AL		 3953 switch (event) {
3954 case CHR_EVENT_MUX_IN:
6cff3e85 3955 qemu_mutex_lock(&mon->out_lock);
a7aec5da 3956 mon->mux_out = 0;
6cff3e85 3957 qemu_mutex_unlock(&mon->out_lock);
a7aec5da
GH		 3958 if (mon->reset_seen) {
3959 readline_restart(mon->rs);
3960 monitor_resume(mon);
3961 monitor_flush(mon);
3962 } else {
3963 mon->suspend_cnt = 0;
3964 }
2724b180
AL		 3965 break;
3966
3967 case CHR_EVENT_MUX_OUT:
a7aec5da
GH		 3968 if (mon->reset_seen) {
3969 if (mon->suspend_cnt == 0) {
3970 monitor_printf(mon, "\n");
3971 }
3972 monitor_flush(mon);
3973 monitor_suspend(mon);
3974 } else {
3975 mon->suspend_cnt++;
3976 }
6cff3e85 3977 qemu_mutex_lock(&mon->out_lock);
a7aec5da 3978 mon->mux_out = 1;
6cff3e85 3979 qemu_mutex_unlock(&mon->out_lock);
2724b180 3980 break;
86e94dea 3981
b6b8df56 3982 case CHR_EVENT_OPENED:
2724b180
AL		 3983 monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
3984 "information\n", QEMU_VERSION);
a7aec5da 3985 if (!mon->mux_out) {
e5554e20 3986 readline_restart(mon->rs);
2724b180 3987 readline_show_prompt(mon->rs);
a7aec5da
GH		 3988 }
3989 mon->reset_seen = 1;
efb87c16
CB		 3990 mon_refcount++;
3991 break;
3992
3993 case CHR_EVENT_CLOSED:
3994 mon_refcount--;
3995 monitor_fdsets_cleanup();
2724b180
AL		 3996 break;
3997 }
86e94dea
TS		 3998}
3999
816f8925
WX		 4000static int
4001compare_mon_cmd(const void *a, const void *b)
4002{
4003 return strcmp(((const mon_cmd_t *)a)->name,
4004 ((const mon_cmd_t *)b)->name);
4005}
4006
4007static void sortcmdlist(void)
4008{
4009 int array_num;
4010 int elem_size = sizeof(mon_cmd_t);
4011
4012 array_num = sizeof(mon_cmds)/elem_size-1;
4013 qsort((void *)mon_cmds, array_num, elem_size, compare_mon_cmd);
4014
4015 array_num = sizeof(info_cmds)/elem_size-1;
4016 qsort((void *)info_cmds, array_num, elem_size, compare_mon_cmd);
4017}
4018
c60bf339
SH		 4019/* These functions just adapt the readline interface in a typesafe way. We
4020 * could cast function pointers but that discards compiler checks.
4021 */
d5d1507b
SW		 4022static void GCC_FMT_ATTR(2, 3) monitor_readline_printf(void *opaque,
4023 const char *fmt, ...)
c60bf339
SH		 4024{
4025 va_list ap;
4026 va_start(ap, fmt);
4027 monitor_vprintf(opaque, fmt, ap);
4028 va_end(ap);
4029}
4030
4031static void monitor_readline_flush(void *opaque)
4032{
4033 monitor_flush(opaque);
4034}
4035
397d30e9
PB		 4036/*
4037 * Print to current monitor if we have one, else to stderr.
4038 * TODO should return int, so callers can calculate width, but that
4039 * requires surgery to monitor_vprintf(). Left for another day.
4040 */
4041void error_vprintf(const char *fmt, va_list ap)
4042{
4043 if (cur_mon && !monitor_cur_is_qmp()) {
4044 monitor_vprintf(cur_mon, fmt, ap);
4045 } else {
4046 vfprintf(stderr, fmt, ap);
4047 }
4048}
4049
4050void error_vprintf_unless_qmp(const char *fmt, va_list ap)
4051{
4052 if (cur_mon && !monitor_cur_is_qmp()) {
4053 monitor_vprintf(cur_mon, fmt, ap);
0d6b50d4
MAL		 4054 } else if (!cur_mon) {
4055 vfprintf(stderr, fmt, ap);
397d30e9
PB		 4056 }
4057}
4058
d622cb58
PB		 4059static void __attribute__((constructor)) monitor_lock_init(void)
4060{
4061 qemu_mutex_init(&monitor_lock);
4062}
4063
0ec7b3e7 4064void monitor_init(Chardev *chr, int flags)
aa455485 4065{
731b0364 4066 static int is_first_init = 1;
87127161 4067 Monitor *mon;
20d8a3ed
TS		 4068
4069 if (is_first_init) {
43a14cfc 4070 monitor_qapi_event_init();
d038317c 4071 sortcmdlist();
20d8a3ed
TS		 4072 is_first_init = 0;
4073 }
87127161 4074
b01fe89e
WX		 4075 mon = g_malloc(sizeof(*mon));
4076 monitor_data_init(mon);
20d8a3ed 4077
32a6ebec 4078 qemu_chr_fe_init(&mon->chr, chr, &error_abort);
731b0364 4079 mon->flags = flags;
cde76ee1 4080 if (flags & MONITOR_USE_READLINE) {
c60bf339
SH		 4081 mon->rs = readline_init(monitor_readline_printf,
4082 monitor_readline_flush,
4083 mon,
4084 monitor_find_completion);
cde76ee1
AL		 4085 monitor_read_command(mon, 0);
4086 }
87127161 4087
9f3982f2 4088 if (monitor_is_qmp(mon)) {
5345fdb4 4089 qemu_chr_fe_set_handlers(&mon->chr, monitor_can_read, monitor_qmp_read,
39ab61c6 4090 monitor_qmp_event, mon, NULL, true);
5345fdb4 4091 qemu_chr_fe_set_echo(&mon->chr, true);
74358f2a 4092 json_message_parser_init(&mon->qmp.parser, handle_qmp_command);
9b57c02e 4093 } else {
5345fdb4 4094 qemu_chr_fe_set_handlers(&mon->chr, monitor_can_read, monitor_read,
39ab61c6 4095 monitor_event, mon, NULL, true);
9b57c02e 4096 }
87127161 4097
d622cb58 4098 qemu_mutex_lock(&monitor_lock);
72cf2d4f 4099 QLIST_INSERT_HEAD(&mon_list, mon, entry);
d622cb58 4100 qemu_mutex_unlock(&monitor_lock);
aa455485
FB		 4101}
4102
2ef45716
MAL		 4103void monitor_cleanup(void)
4104{
4105 Monitor *mon, *next;
4106
4107 qemu_mutex_lock(&monitor_lock);
4108 QLIST_FOREACH_SAFE(mon, &mon_list, entry, next) {
4109 QLIST_REMOVE(mon, entry);
4110 monitor_data_destroy(mon);
4111 g_free(mon);
4112 }
4113 qemu_mutex_unlock(&monitor_lock);
4114}
4115
c60bf339
SH		 4116static void bdrv_password_cb(void *opaque, const char *password,
4117 void *readline_opaque)
81d0912d 4118{
c60bf339
SH		 4119 Monitor *mon = opaque;
4120 BlockDriverState *bs = readline_opaque;
bb5fc20f 4121 int ret = 0;
4d2855a3 4122 Error *local_err = NULL;
81d0912d 4123
4d2855a3
MA		 4124 bdrv_add_key(bs, password, &local_err);
4125 if (local_err) {
193227f9 4126 error_report_err(local_err);
bb5fc20f 4127 ret = -EPERM;
9dc39cba 4128 }
731b0364
AL		 4129 if (mon->password_completion_cb)
4130 mon->password_completion_cb(mon->password_opaque, ret);
bb5fc20f 4131
731b0364 4132 monitor_read_command(mon, 1);
9dc39cba 4133}
c0f4ce77 4134
0bbc47bb 4135int monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
097310b5 4136 BlockCompletionFunc *completion_cb,
0bbc47bb 4137 void *opaque)
c0f4ce77 4138{
cde76ee1
AL		 4139 int err;
4140
376253ec
AL		 4141 monitor_printf(mon, "%s (%s) is encrypted.\n", bdrv_get_device_name(bs),
4142 bdrv_get_encrypted_filename(bs));
bb5fc20f 4143
731b0364
AL		 4144 mon->password_completion_cb = completion_cb;
4145 mon->password_opaque = opaque;
bb5fc20f 4146
cde76ee1
AL		 4147 err = monitor_read_password(mon, bdrv_password_cb, bs);
4148
4149 if (err && completion_cb)
4150 completion_cb(opaque, err);
0bbc47bb
LC		 4151
4152 return err;
c0f4ce77 4153}
e42e818b
LC		 4154
4155int monitor_read_block_device_key(Monitor *mon, const char *device,
097310b5 4156 BlockCompletionFunc *completion_cb,
e42e818b
LC		 4157 void *opaque)
4158{
9b14e0ef 4159 Error *err = NULL;
5560625b 4160 BlockBackend *blk;
e42e818b 4161
5560625b
FZ		 4162 blk = blk_by_name(device);
4163 if (!blk) {
e42e818b
LC		 4164 monitor_printf(mon, "Device not found %s\n", device);
4165 return -1;
4166 }
5433c24f
HR		 4167 if (!blk_bs(blk)) {
4168 monitor_printf(mon, "Device '%s' has no medium\n", device);
4169 return -1;
4170 }
e42e818b 4171
9b14e0ef
MA		 4172 bdrv_add_key(blk_bs(blk), NULL, &err);
4173 if (err) {
4174 error_free(err);
4175 return monitor_read_bdrv_key_start(mon, blk_bs(blk), completion_cb, opaque);
4176 }
4177
4178 if (completion_cb) {
4179 completion_cb(opaque, 0);
4180 }
4181 return 0;
e42e818b 4182}
4d454574
PB		 4183
4184QemuOptsList qemu_mon_opts = {
4185 .name = "mon",
4186 .implied_opt_name = "chardev",
4187 .head = QTAILQ_HEAD_INITIALIZER(qemu_mon_opts.head),
4188 .desc = {
4189 {
4190 .name = "mode",
4191 .type = QEMU_OPT_STRING,
4192 },{
4193 .name = "chardev",
4194 .type = QEMU_OPT_STRING,
4195 },{
bdbcb547 4196 .name = "default", /* deprecated */
4d454574
PB		 4197 .type = QEMU_OPT_BOOL,
4198 },{
4199 .name = "pretty",
4200 .type = QEMU_OPT_BOOL,
4201 },
4202 { /* end of list */ }
4203 },
4204};
f2ae8abf
MT		 4205
4206#ifndef TARGET_I386
4207void qmp_rtc_reset_reinjection(Error **errp)
4208{
c6bd8c70 4209 error_setg(errp, QERR_FEATURE_DISABLED, "rtc-reset-reinjection");
f2ae8abf
MT		 4210}
4211#endif
7ee0c3e3
JH		 4212
4213#ifndef TARGET_S390X
4214void qmp_dump_skeys(const char *filename, Error **errp)
4215{
4216 error_setg(errp, QERR_FEATURE_DISABLED, "dump-skeys");
4217}
4218#endif
ae50a770
PX		 4219
4220#ifndef TARGET_ARM
4221GICCapabilityList *qmp_query_gic_capabilities(Error **errp)
4222{
4223 error_setg(errp, QERR_FEATURE_DISABLED, "query-gic-capabilities");
4224 return NULL;
4225}
4226#endif
d4633541
IM		 4227
4228HotpluggableCPUList *qmp_query_hotpluggable_cpus(Error **errp)
4229{
4230 MachineState *ms = MACHINE(qdev_get_machine());
4231 MachineClass *mc = MACHINE_GET_CLASS(ms);
4232
c5514d0e 4233 if (!mc->has_hotpluggable_cpus) {
d4633541
IM		 4234 error_setg(errp, QERR_FEATURE_DISABLED, "query-hotpluggable-cpus");
4235 return NULL;
4236 }
4237
c5514d0e 4238 return machine_query_hotpluggable_cpus(ms);
d4633541 4239}
Mirror of https://git.qemu.org/git/qemu.git