blob: 845f608665373923ed583b8f312ec8810d4a0266 [file] [log] [blame]
bellard9dc39cb2004-03-14 21:38:27 +00001/*
2 * QEMU monitor
ths5fafdf22007-09-16 21:08:06 +00003 *
bellard9dc39cb2004-03-14 21:38:27 +00004 * Copyright (c) 2003-2004 Fabrice Bellard
ths5fafdf22007-09-16 21:08:06 +00005 *
bellard9dc39cb2004-03-14 21:38:27 +00006 * 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 */
blueswir1511d2b12009-03-07 15:32:56 +000024#include <dirent.h>
pbrook87ecb682007-11-17 17:14:51 +000025#include "hw/hw.h"
Paolo Bonzinib4a42f82013-02-04 11:37:52 +010026#include "monitor/qdev.h"
pbrook87ecb682007-11-17 17:14:51 +000027#include "hw/usb.h"
28#include "hw/pcmcia.h"
Paolo Bonzini0d09e412013-02-05 17:06:20 +010029#include "hw/i386/pc.h"
Michael S. Tsirkina2cb15b2012-12-12 14:24:50 +020030#include "hw/pci/pci.h"
Paolo Bonzini0d09e412013-02-05 17:06:20 +010031#include "sysemu/watchdog.h"
Gerd Hoffmann45a50b12009-10-01 16:42:33 +020032#include "hw/loader.h"
Paolo Bonzini022c62c2012-12-17 18:19:49 +010033#include "exec/gdbstub.h"
Paolo Bonzini1422e322012-10-24 08:43:34 +020034#include "net/net.h"
Mark McLoughlin68ac40d2009-11-25 18:48:54 +000035#include "net/slirp.h"
Paolo Bonzinidccfcd02013-04-08 16:55:25 +020036#include "sysemu/char.h"
Gerd Hoffmann75721502010-10-07 12:22:54 +020037#include "ui/qemu-spice.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010038#include "sysemu/sysemu.h"
Paolo Bonzini83c90892012-12-17 18:19:49 +010039#include "monitor/monitor.h"
40#include "monitor/readline.h"
Paolo Bonzini28ecbae2012-11-28 12:06:30 +010041#include "ui/console.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010042#include "sysemu/blockdev.h"
pbrook87ecb682007-11-17 17:14:51 +000043#include "audio/audio.h"
Paolo Bonzini76cad712012-10-24 11:12:21 +020044#include "disas/disas.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010045#include "sysemu/balloon.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010046#include "qemu/timer.h"
Paolo Bonzinicaf71f82012-12-17 18:19:50 +010047#include "migration/migration.h"
Paolo Bonzini9c17d612012-12-17 18:20:04 +010048#include "sysemu/kvm.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010049#include "qemu/acl.h"
Paolo Bonzinibdee56f2013-04-02 18:28:41 +020050#include "sysemu/tpm.h"
Paolo Bonzini7b1b5d12012-12-17 18:19:43 +010051#include "qapi/qmp/qint.h"
52#include "qapi/qmp/qfloat.h"
53#include "qapi/qmp/qlist.h"
54#include "qapi/qmp/qbool.h"
55#include "qapi/qmp/qstring.h"
56#include "qapi/qmp/qjson.h"
57#include "qapi/qmp/json-streamer.h"
58#include "qapi/qmp/json-parser.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010059#include "qemu/osdep.h"
Blue Swirl2b41f102011-06-19 20:38:22 +000060#include "cpu.h"
Stefan Hajnoczi89bd8202011-09-23 08:23:06 +010061#include "trace.h"
Lluís31965ae2011-08-31 20:31:24 +020062#include "trace/control.h"
Lluís6d8a7642011-08-31 20:30:43 +020063#ifdef CONFIG_TRACE_SIMPLE
Lluís31965ae2011-08-31 20:31:24 +020064#include "trace/simple.h"
Prerna Saxena22890ab2010-06-24 17:04:53 +053065#endif
Paolo Bonzini022c62c2012-12-17 18:19:49 +010066#include "exec/memory.h"
Anthony Liguori48a32be2011-09-02 12:34:48 -050067#include "qmp-commands.h"
68#include "hmp.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010069#include "qemu/thread.h"
ths6a5bd302007-12-03 17:05:38 +000070
Jan Kiszka661f1922011-10-16 11:53:13 +020071/* for pic/irq_info */
72#if defined(TARGET_SPARC)
Paolo Bonzini0d09e412013-02-05 17:06:20 +010073#include "hw/sparc/sun4m.h"
Jan Kiszka661f1922011-10-16 11:53:13 +020074#endif
Paolo Bonzini0d09e412013-02-05 17:06:20 +010075#include "hw/lm32/lm32_pic.h"
Jan Kiszka661f1922011-10-16 11:53:13 +020076
bellard9dc39cb2004-03-14 21:38:27 +000077//#define DEBUG
bellard81d09122004-07-14 17:21:37 +000078//#define DEBUG_COMPLETION
bellard9dc39cb2004-03-14 21:38:27 +000079
bellard9307c4c2004-04-04 12:57:25 +000080/*
81 * Supported types:
ths5fafdf22007-09-16 21:08:06 +000082 *
bellard9307c4c2004-04-04 12:57:25 +000083 * 'F' filename
bellard81d09122004-07-14 17:21:37 +000084 * 'B' block device name
bellard9307c4c2004-04-04 12:57:25 +000085 * 's' string (accept optional quote)
Wenchao Xia129be002013-08-27 20:38:26 +080086 * 'S' it just appends the rest of the string (accept optional quote)
Markus Armbruster361127d2010-02-10 20:24:35 +010087 * 'O' option string of the form NAME=VALUE,...
88 * parsed according to QemuOptsList given by its name
89 * Example: 'device:O' uses qemu_device_opts.
90 * Restriction: only lists with empty desc are supported
91 * TODO lift the restriction
bellard92a31b12005-02-10 22:00:52 +000092 * 'i' 32 bit integer
93 * 'l' target long (32 or 64 bit)
Luiz Capitulino91162842012-04-26 17:34:30 -030094 * 'M' Non-negative target long (32 or 64 bit), in user mode the
95 * value is multiplied by 2^20 (think Mebibyte)
Jes Sorensendbc0c672010-10-21 17:15:47 +020096 * 'o' octets (aka bytes)
Kevin Wolf5e009842013-06-05 14:19:27 +020097 * user mode accepts an optional E, e, P, p, T, t, G, g, M, m,
98 * K, k suffix, which multiplies the value by 2^60 for suffixes E
99 * and e, 2^50 for suffixes P and p, 2^40 for suffixes T and t,
100 * 2^30 for suffixes G and g, 2^20 for M and m, 2^10 for K and k
Markus Armbrusterfccfb11e2010-01-25 14:23:06 +0100101 * 'T' double
102 * user mode accepts an optional ms, us, ns suffix,
103 * which divides the value by 1e3, 1e6, 1e9, respectively
bellard9307c4c2004-04-04 12:57:25 +0000104 * '/' optional gdb-like print format (like "/10x")
105 *
Luiz Capitulinofb466602009-08-28 15:27:27 -0300106 * '?' optional type (for all types, except '/')
107 * '.' other form of optional type (for 'i' and 'l')
Markus Armbruster942cd1f2010-03-26 09:07:09 +0100108 * 'b' boolean
109 * user mode accepts "on" or "off"
Luiz Capitulinofb466602009-08-28 15:27:27 -0300110 * '-' optional parameter (eg. '-f')
bellard9307c4c2004-04-04 12:57:25 +0000111 *
112 */
113
Adam Litke940cc302010-01-25 12:18:44 -0600114typedef struct MonitorCompletionData MonitorCompletionData;
115struct MonitorCompletionData {
116 Monitor *mon;
117 void (*user_print)(Monitor *mon, const QObject *data);
118};
119
Anthony Liguoric227f092009-10-01 16:12:16 -0500120typedef struct mon_cmd_t {
bellard9dc39cb2004-03-14 21:38:27 +0000121 const char *name;
bellard9307c4c2004-04-04 12:57:25 +0000122 const char *args_type;
bellard9dc39cb2004-03-14 21:38:27 +0000123 const char *params;
124 const char *help;
Luiz Capitulinoa2876f52009-10-07 13:41:53 -0300125 void (*user_print)(Monitor *mon, const QObject *data);
Luiz Capitulino910df892009-10-07 13:41:51 -0300126 union {
Luiz Capitulinoaf4ce882009-10-07 13:41:52 -0300127 void (*cmd)(Monitor *mon, const QDict *qdict);
Luiz Capitulino261394d2010-02-10 23:50:02 -0200128 int (*cmd_new)(Monitor *mon, const QDict *params, QObject **ret_data);
Adam Litke940cc302010-01-25 12:18:44 -0600129 int (*cmd_async)(Monitor *mon, const QDict *params,
130 MonitorCompletion *cb, void *opaque);
Luiz Capitulino910df892009-10-07 13:41:51 -0300131 } mhandler;
Jan Kiszka8ac470c2010-06-16 00:38:39 +0200132 int flags;
Wenchao Xia5f3d3352013-01-14 14:06:27 +0800133 /* @sub_table is a list of 2nd level of commands. If it do not exist,
134 * mhandler should be used. If it exist, sub_table[?].mhandler should be
135 * used, and mhandler of 1st level plays the role of help function.
136 */
137 struct mon_cmd_t *sub_table;
Anthony Liguoric227f092009-10-01 16:12:16 -0500138} mon_cmd_t;
bellard9dc39cb2004-03-14 21:38:27 +0000139
Mark McLoughlinf07918f2009-07-22 09:11:40 +0100140/* file descriptors passed via SCM_RIGHTS */
Anthony Liguoric227f092009-10-01 16:12:16 -0500141typedef struct mon_fd_t mon_fd_t;
142struct mon_fd_t {
Mark McLoughlinf07918f2009-07-22 09:11:40 +0100143 char *name;
144 int fd;
Anthony Liguoric227f092009-10-01 16:12:16 -0500145 QLIST_ENTRY(mon_fd_t) next;
Mark McLoughlinf07918f2009-07-22 09:11:40 +0100146};
147
Corey Bryantba1c0482012-08-14 16:43:43 -0400148/* file descriptor associated with a file descriptor set */
149typedef struct MonFdsetFd MonFdsetFd;
150struct MonFdsetFd {
151 int fd;
152 bool removed;
153 char *opaque;
154 QLIST_ENTRY(MonFdsetFd) next;
155};
156
157/* file descriptor set containing fds passed via SCM_RIGHTS */
158typedef struct MonFdset MonFdset;
159struct MonFdset {
160 int64_t id;
161 QLIST_HEAD(, MonFdsetFd) fds;
Corey Bryantadb696f2012-08-14 16:43:47 -0400162 QLIST_HEAD(, MonFdsetFd) dup_fds;
Corey Bryantba1c0482012-08-14 16:43:43 -0400163 QLIST_ENTRY(MonFdset) next;
164};
165
Luiz Capitulino5fa737a2009-11-26 22:59:01 -0200166typedef struct MonitorControl {
167 QObject *id;
168 JSONMessageParser parser;
Luiz Capitulino4a7e1192010-02-04 18:10:05 -0200169 int command_mode;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -0200170} MonitorControl;
171
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100172/*
173 * To prevent flooding clients, events can be throttled. The
174 * throttling is calculated globally, rather than per-Monitor
175 * instance.
176 */
177typedef struct MonitorEventState {
178 MonitorEvent event; /* Event being tracked */
179 int64_t rate; /* Period over which to throttle. 0 to disable */
180 int64_t last; /* Time at which event was last emitted */
181 QEMUTimer *timer; /* Timer for handling delayed events */
182 QObject *data; /* Event pending delayed dispatch */
183} MonitorEventState;
184
aliguori87127162009-03-05 23:01:29 +0000185struct Monitor {
186 CharDriverState *chr;
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +0200187 int mux_out;
188 int reset_seen;
aliguori731b0362009-03-05 23:01:42 +0000189 int flags;
190 int suspend_cnt;
Luiz Capitulino48c043d2013-04-02 15:07:33 -0400191 bool skip_flush;
Luiz Capitulinoe1f26412013-03-25 13:52:26 -0400192 QString *outbuf;
Laszlo Ersek293d2a02013-07-16 20:19:41 +0200193 guint watch;
aliguori731b0362009-03-05 23:01:42 +0000194 ReadLineState *rs;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -0200195 MonitorControl *mc;
Andreas Färbercb446ec2013-05-01 14:24:52 +0200196 CPUState *mon_cpu;
aliguori731b0362009-03-05 23:01:42 +0000197 BlockDriverCompletionFunc *password_completion_cb;
198 void *password_opaque;
Wenchao Xia77172392013-08-27 20:38:20 +0800199 mon_cmd_t *cmd_table;
Luiz Capitulino8204a912009-11-18 23:05:31 -0200200 QError *error;
Anthony Liguoric227f092009-10-01 16:12:16 -0500201 QLIST_HEAD(,mon_fd_t) fds;
Blue Swirl72cf2d42009-09-12 07:36:22 +0000202 QLIST_ENTRY(Monitor) entry;
aliguori87127162009-03-05 23:01:29 +0000203};
204
Luiz Capitulino2dbc8db2010-05-26 16:13:09 -0300205/* QMP checker flags */
206#define QMP_ACCEPT_UNKNOWNS 1
207
Blue Swirl72cf2d42009-09-12 07:36:22 +0000208static QLIST_HEAD(mon_list, Monitor) mon_list;
Corey Bryantba1c0482012-08-14 16:43:43 -0400209static QLIST_HEAD(mon_fdsets, MonFdset) mon_fdsets;
Corey Bryantefb87c12012-08-14 16:43:48 -0400210static int mon_refcount;
bellard7e2515e2004-08-01 21:52:19 +0000211
Wayne Xia816f8922011-10-12 11:32:41 +0800212static mon_cmd_t mon_cmds[];
213static mon_cmd_t info_cmds[];
bellard9dc39cb2004-03-14 21:38:27 +0000214
Luiz Capitulinof36b4af2010-09-15 17:17:45 -0300215static const mon_cmd_t qmp_cmds[];
216
Markus Armbruster8631b602010-02-18 11:41:55 +0100217Monitor *cur_mon;
218Monitor *default_mon;
aliguori376253e2009-03-05 23:01:23 +0000219
aliguori731b0362009-03-05 23:01:42 +0000220static void monitor_command_cb(Monitor *mon, const char *cmdline,
221 void *opaque);
aliguori83ab7952008-08-19 14:44:22 +0000222
Luiz Capitulino09069b12010-02-04 18:10:06 -0200223static inline int qmp_cmd_mode(const Monitor *mon)
224{
225 return (mon->mc ? mon->mc->command_mode : 0);
226}
227
Luiz Capitulino418173c2009-11-26 22:58:51 -0200228/* Return true if in control mode, false otherwise */
229static inline int monitor_ctrl_mode(const Monitor *mon)
230{
231 return (mon->flags & MONITOR_USE_CONTROL);
232}
233
Markus Armbruster6620d3c2010-02-11 17:05:43 +0100234/* Return non-zero iff we have a current monitor, and it is in QMP mode. */
235int monitor_cur_is_qmp(void)
236{
237 return cur_mon && monitor_ctrl_mode(cur_mon);
238}
239
Anthony Liguori7060b472011-09-02 12:34:50 -0500240void monitor_read_command(Monitor *mon, int show_prompt)
aliguori731b0362009-03-05 23:01:42 +0000241{
Luiz Capitulino183e6e52009-12-14 18:53:23 -0200242 if (!mon->rs)
243 return;
244
aliguori731b0362009-03-05 23:01:42 +0000245 readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL);
246 if (show_prompt)
247 readline_show_prompt(mon->rs);
248}
bellard6a00d602005-11-21 23:25:50 +0000249
Anthony Liguori7060b472011-09-02 12:34:50 -0500250int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
251 void *opaque)
aliguoribb5fc202009-03-05 23:01:15 +0000252{
Luiz Capitulino94171e12009-12-07 21:37:00 +0100253 if (monitor_ctrl_mode(mon)) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +0100254 qerror_report(QERR_MISSING_PARAMETER, "password");
Luiz Capitulino94171e12009-12-07 21:37:00 +0100255 return -EINVAL;
256 } else if (mon->rs) {
aliguoricde76ee2009-03-05 23:01:51 +0000257 readline_start(mon->rs, "Password: ", 1, readline_func, opaque);
258 /* prompt is printed on return from the command handler */
259 return 0;
260 } else {
261 monitor_printf(mon, "terminal does not support password prompting\n");
262 return -ENOTTY;
263 }
aliguoribb5fc202009-03-05 23:01:15 +0000264}
265
Gerd Hoffmannf6289262013-03-19 10:57:56 +0100266static gboolean monitor_unblocked(GIOChannel *chan, GIOCondition cond,
267 void *opaque)
268{
Laszlo Ersek293d2a02013-07-16 20:19:41 +0200269 Monitor *mon = opaque;
270
271 mon->watch = 0;
272 monitor_flush(mon);
Gerd Hoffmannf6289262013-03-19 10:57:56 +0100273 return FALSE;
274}
275
aliguori376253e2009-03-05 23:01:23 +0000276void monitor_flush(Monitor *mon)
bellard9dc39cb2004-03-14 21:38:27 +0000277{
Gerd Hoffmannf6289262013-03-19 10:57:56 +0100278 int rc;
Luiz Capitulinoe1f26412013-03-25 13:52:26 -0400279 size_t len;
280 const char *buf;
Gerd Hoffmannf6289262013-03-19 10:57:56 +0100281
Luiz Capitulino48c043d2013-04-02 15:07:33 -0400282 if (mon->skip_flush) {
283 return;
284 }
285
Luiz Capitulinoe1f26412013-03-25 13:52:26 -0400286 buf = qstring_get_str(mon->outbuf);
287 len = qstring_get_length(mon->outbuf);
288
Paolo Bonzinia4cc73d2013-05-31 14:00:27 +0200289 if (len && !mon->mux_out) {
Luiz Capitulinoe1f26412013-03-25 13:52:26 -0400290 rc = qemu_chr_fe_write(mon->chr, (const uint8_t *) buf, len);
291 if (rc == len) {
Gerd Hoffmannf6289262013-03-19 10:57:56 +0100292 /* all flushed */
Luiz Capitulinoe1f26412013-03-25 13:52:26 -0400293 QDECREF(mon->outbuf);
294 mon->outbuf = qstring_new();
Gerd Hoffmannf6289262013-03-19 10:57:56 +0100295 return;
296 }
297 if (rc > 0) {
298 /* partinal write */
Luiz Capitulinoe1f26412013-03-25 13:52:26 -0400299 QString *tmp = qstring_from_str(buf + rc);
300 QDECREF(mon->outbuf);
301 mon->outbuf = tmp;
Gerd Hoffmannf6289262013-03-19 10:57:56 +0100302 }
Laszlo Ersek293d2a02013-07-16 20:19:41 +0200303 if (mon->watch == 0) {
304 mon->watch = qemu_chr_fe_add_watch(mon->chr, G_IO_OUT,
305 monitor_unblocked, mon);
306 }
bellard7e2515e2004-08-01 21:52:19 +0000307 }
308}
309
Luiz Capitulinoe1f26412013-03-25 13:52:26 -0400310/* flush at every end of line */
aliguori376253e2009-03-05 23:01:23 +0000311static void monitor_puts(Monitor *mon, const char *str)
bellard7e2515e2004-08-01 21:52:19 +0000312{
ths60fe76f2007-12-16 03:02:09 +0000313 char c;
aliguori731b0362009-03-05 23:01:42 +0000314
bellard7e2515e2004-08-01 21:52:19 +0000315 for(;;) {
316 c = *str++;
317 if (c == '\0')
318 break;
Luiz Capitulinoe1f26412013-03-25 13:52:26 -0400319 if (c == '\n') {
320 qstring_append_chr(mon->outbuf, '\r');
321 }
322 qstring_append_chr(mon->outbuf, c);
323 if (c == '\n') {
aliguori376253e2009-03-05 23:01:23 +0000324 monitor_flush(mon);
Luiz Capitulinoe1f26412013-03-25 13:52:26 -0400325 }
bellard7e2515e2004-08-01 21:52:19 +0000326 }
327}
328
aliguori376253e2009-03-05 23:01:23 +0000329void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
bellard7e2515e2004-08-01 21:52:19 +0000330{
Luiz Capitulinoe1f26412013-03-25 13:52:26 -0400331 char *buf;
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200332
Luiz Capitulino2daa1192009-12-14 18:53:24 -0200333 if (!mon)
334 return;
335
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200336 if (monitor_ctrl_mode(mon)) {
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200337 return;
Luiz Capitulino4a29a852009-11-26 22:59:05 -0200338 }
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200339
Luiz Capitulinoe1f26412013-03-25 13:52:26 -0400340 buf = g_strdup_vprintf(fmt, ap);
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200341 monitor_puts(mon, buf);
Luiz Capitulinoe1f26412013-03-25 13:52:26 -0400342 g_free(buf);
bellard7e2515e2004-08-01 21:52:19 +0000343}
344
aliguori376253e2009-03-05 23:01:23 +0000345void monitor_printf(Monitor *mon, const char *fmt, ...)
bellard7e2515e2004-08-01 21:52:19 +0000346{
347 va_list ap;
348 va_start(ap, fmt);
aliguori376253e2009-03-05 23:01:23 +0000349 monitor_vprintf(mon, fmt, ap);
bellard7e2515e2004-08-01 21:52:19 +0000350 va_end(ap);
bellard9dc39cb2004-03-14 21:38:27 +0000351}
352
aliguori376253e2009-03-05 23:01:23 +0000353void monitor_print_filename(Monitor *mon, const char *filename)
thsfef30742006-12-22 14:11:32 +0000354{
355 int i;
356
357 for (i = 0; filename[i]; i++) {
aliguori28a76be2009-03-06 20:27:40 +0000358 switch (filename[i]) {
359 case ' ':
360 case '"':
361 case '\\':
362 monitor_printf(mon, "\\%c", filename[i]);
363 break;
364 case '\t':
365 monitor_printf(mon, "\\t");
366 break;
367 case '\r':
368 monitor_printf(mon, "\\r");
369 break;
370 case '\n':
371 monitor_printf(mon, "\\n");
372 break;
373 default:
374 monitor_printf(mon, "%c", filename[i]);
375 break;
376 }
thsfef30742006-12-22 14:11:32 +0000377 }
378}
379
Stefan Weil8b7968f2010-09-23 21:28:05 +0200380static int GCC_FMT_ATTR(2, 3) monitor_fprintf(FILE *stream,
381 const char *fmt, ...)
bellard7fe48482004-10-09 18:08:01 +0000382{
383 va_list ap;
384 va_start(ap, fmt);
aliguori376253e2009-03-05 23:01:23 +0000385 monitor_vprintf((Monitor *)stream, fmt, ap);
bellard7fe48482004-10-09 18:08:01 +0000386 va_end(ap);
387 return 0;
388}
389
Luiz Capitulino13c74252009-10-07 13:41:55 -0300390static void monitor_user_noop(Monitor *mon, const QObject *data) { }
391
Luiz Capitulino9e807212010-09-16 10:58:59 -0300392static inline int handler_is_qobject(const mon_cmd_t *cmd)
Luiz Capitulino13917be2009-10-07 13:41:54 -0300393{
394 return cmd->user_print != NULL;
395}
396
Luiz Capitulino4903de02010-09-16 11:01:32 -0300397static inline bool handler_is_async(const mon_cmd_t *cmd)
Adam Litke940cc302010-01-25 12:18:44 -0600398{
Jan Kiszka8ac470c2010-06-16 00:38:39 +0200399 return cmd->flags & MONITOR_CMD_ASYNC;
Adam Litke940cc302010-01-25 12:18:44 -0600400}
401
Luiz Capitulino8204a912009-11-18 23:05:31 -0200402static inline int monitor_has_error(const Monitor *mon)
403{
404 return mon->error != NULL;
405}
406
Luiz Capitulino9b57c022009-11-26 22:58:58 -0200407static void monitor_json_emitter(Monitor *mon, const QObject *data)
408{
409 QString *json;
410
Luiz Capitulino83a27d42010-11-22 17:10:37 -0200411 json = mon->flags & MONITOR_USE_PRETTY ? qobject_to_json_pretty(data) :
412 qobject_to_json(data);
Luiz Capitulino9b57c022009-11-26 22:58:58 -0200413 assert(json != NULL);
414
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200415 qstring_append_chr(json, '\n');
416 monitor_puts(mon, qstring_get_str(json));
Luiz Capitulino4a29a852009-11-26 22:59:05 -0200417
Luiz Capitulino9b57c022009-11-26 22:58:58 -0200418 QDECREF(json);
419}
420
Luiz Capitulinode253f12012-07-27 16:18:16 -0300421static QDict *build_qmp_error_dict(const QError *err)
422{
423 QObject *obj;
424
425 obj = qobject_from_jsonf("{ 'error': { 'class': %s, 'desc': %p } }",
426 ErrorClass_lookup[err->err_class],
427 qerror_human(err));
428
429 return qobject_to_qdict(obj);
430}
431
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200432static void monitor_protocol_emitter(Monitor *mon, QObject *data)
433{
434 QDict *qmp;
435
Stefan Hajnoczi89bd8202011-09-23 08:23:06 +0100436 trace_monitor_protocol_emitter(mon);
437
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200438 if (!monitor_has_error(mon)) {
439 /* success response */
Luiz Capitulinode253f12012-07-27 16:18:16 -0300440 qmp = qdict_new();
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200441 if (data) {
442 qobject_incref(data);
443 qdict_put_obj(qmp, "return", data);
444 } else {
Luiz Capitulino0abc6572009-12-18 13:25:00 -0200445 /* return an empty QDict by default */
446 qdict_put(qmp, "return", qdict_new());
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200447 }
448 } else {
449 /* error response */
Luiz Capitulinode253f12012-07-27 16:18:16 -0300450 qmp = build_qmp_error_dict(mon->error);
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200451 QDECREF(mon->error);
452 mon->error = NULL;
453 }
454
Luiz Capitulino5fa737a2009-11-26 22:59:01 -0200455 if (mon->mc->id) {
456 qdict_put_obj(qmp, "id", mon->mc->id);
457 mon->mc->id = NULL;
458 }
459
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200460 monitor_json_emitter(mon, QOBJECT(qmp));
461 QDECREF(qmp);
462}
463
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200464static void timestamp_put(QDict *qdict)
465{
466 int err;
467 QObject *obj;
Blue Swirld08d6f02009-12-04 18:06:39 +0000468 qemu_timeval tv;
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200469
Blue Swirld08d6f02009-12-04 18:06:39 +0000470 err = qemu_gettimeofday(&tv);
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200471 if (err < 0)
472 return;
473
474 obj = qobject_from_jsonf("{ 'seconds': %" PRId64 ", "
475 "'microseconds': %" PRId64 " }",
476 (int64_t) tv.tv_sec, (int64_t) tv.tv_usec);
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200477 qdict_put_obj(qdict, "timestamp", obj);
478}
479
Daniel P. Berrange48608532012-05-21 17:59:51 +0100480
481static const char *monitor_event_names[] = {
482 [QEVENT_SHUTDOWN] = "SHUTDOWN",
483 [QEVENT_RESET] = "RESET",
484 [QEVENT_POWERDOWN] = "POWERDOWN",
485 [QEVENT_STOP] = "STOP",
486 [QEVENT_RESUME] = "RESUME",
487 [QEVENT_VNC_CONNECTED] = "VNC_CONNECTED",
488 [QEVENT_VNC_INITIALIZED] = "VNC_INITIALIZED",
489 [QEVENT_VNC_DISCONNECTED] = "VNC_DISCONNECTED",
490 [QEVENT_BLOCK_IO_ERROR] = "BLOCK_IO_ERROR",
491 [QEVENT_RTC_CHANGE] = "RTC_CHANGE",
492 [QEVENT_WATCHDOG] = "WATCHDOG",
493 [QEVENT_SPICE_CONNECTED] = "SPICE_CONNECTED",
494 [QEVENT_SPICE_INITIALIZED] = "SPICE_INITIALIZED",
495 [QEVENT_SPICE_DISCONNECTED] = "SPICE_DISCONNECTED",
496 [QEVENT_BLOCK_JOB_COMPLETED] = "BLOCK_JOB_COMPLETED",
497 [QEVENT_BLOCK_JOB_CANCELLED] = "BLOCK_JOB_CANCELLED",
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200498 [QEVENT_BLOCK_JOB_ERROR] = "BLOCK_JOB_ERROR",
Paolo Bonzinia66a2a32012-07-23 15:15:47 +0200499 [QEVENT_BLOCK_JOB_READY] = "BLOCK_JOB_READY",
Michael S. Tsirkin0402a5d2013-03-06 14:58:59 +0200500 [QEVENT_DEVICE_DELETED] = "DEVICE_DELETED",
Daniel P. Berrange48608532012-05-21 17:59:51 +0100501 [QEVENT_DEVICE_TRAY_MOVED] = "DEVICE_TRAY_MOVED",
Amos Kongb1be4282013-06-14 15:45:52 +0800502 [QEVENT_NIC_RX_FILTER_CHANGED] = "NIC_RX_FILTER_CHANGED",
Daniel P. Berrange48608532012-05-21 17:59:51 +0100503 [QEVENT_SUSPEND] = "SUSPEND",
Luiz Capitulino25df49f2012-08-08 17:03:01 -0300504 [QEVENT_SUSPEND_DISK] = "SUSPEND_DISK",
Daniel P. Berrange48608532012-05-21 17:59:51 +0100505 [QEVENT_WAKEUP] = "WAKEUP",
Daniel P. Berrange973603a2012-06-14 18:12:56 +0100506 [QEVENT_BALLOON_CHANGE] = "BALLOON_CHANGE",
Yonit Halperin2fdd16e2012-08-21 11:51:57 +0300507 [QEVENT_SPICE_MIGRATE_COMPLETED] = "SPICE_MIGRATE_COMPLETED",
Hu Taoc401a8a2013-04-26 11:24:41 +0800508 [QEVENT_GUEST_PANICKED] = "GUEST_PANICKED",
Max Reitza40f1c22013-08-30 14:34:25 +0200509 [QEVENT_BLOCK_IMAGE_CORRUPTED] = "BLOCK_IMAGE_CORRUPTED",
Daniel P. Berrange48608532012-05-21 17:59:51 +0100510};
511QEMU_BUILD_BUG_ON(ARRAY_SIZE(monitor_event_names) != QEVENT_MAX)
512
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100513MonitorEventState monitor_event_state[QEVENT_MAX];
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100514
515/*
516 * Emits the event to every monitor instance
517 */
518static void
519monitor_protocol_event_emit(MonitorEvent event,
520 QObject *data)
521{
522 Monitor *mon;
523
524 trace_monitor_protocol_event_emit(event, data);
525 QLIST_FOREACH(mon, &mon_list, entry) {
526 if (monitor_ctrl_mode(mon) && qmp_cmd_mode(mon)) {
527 monitor_json_emitter(mon, data);
528 }
529 }
530}
531
532
533/*
534 * Queue a new event for emission to Monitor instances,
535 * applying any rate limiting if required.
536 */
537static void
538monitor_protocol_event_queue(MonitorEvent event,
539 QObject *data)
540{
541 MonitorEventState *evstate;
Alex Blighbc72ad62013-08-21 16:03:08 +0100542 int64_t now = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100543 assert(event < QEVENT_MAX);
544
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100545 evstate = &(monitor_event_state[event]);
546 trace_monitor_protocol_event_queue(event,
547 data,
548 evstate->rate,
549 evstate->last,
550 now);
551
552 /* Rate limit of 0 indicates no throttling */
553 if (!evstate->rate) {
554 monitor_protocol_event_emit(event, data);
555 evstate->last = now;
556 } else {
557 int64_t delta = now - evstate->last;
558 if (evstate->data ||
559 delta < evstate->rate) {
560 /* If there's an existing event pending, replace
561 * it with the new event, otherwise schedule a
562 * timer for delayed emission
563 */
564 if (evstate->data) {
565 qobject_decref(evstate->data);
566 } else {
567 int64_t then = evstate->last + evstate->rate;
Alex Blighbc72ad62013-08-21 16:03:08 +0100568 timer_mod_ns(evstate->timer, then);
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100569 }
570 evstate->data = data;
571 qobject_incref(evstate->data);
572 } else {
573 monitor_protocol_event_emit(event, data);
574 evstate->last = now;
575 }
576 }
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100577}
578
579
580/*
581 * The callback invoked by QemuTimer when a delayed
582 * event is ready to be emitted
583 */
584static void monitor_protocol_event_handler(void *opaque)
585{
586 MonitorEventState *evstate = opaque;
Alex Blighbc72ad62013-08-21 16:03:08 +0100587 int64_t now = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100588
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100589
590 trace_monitor_protocol_event_handler(evstate->event,
591 evstate->data,
592 evstate->last,
593 now);
594 if (evstate->data) {
595 monitor_protocol_event_emit(evstate->event, evstate->data);
596 qobject_decref(evstate->data);
597 evstate->data = NULL;
598 }
599 evstate->last = now;
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100600}
601
602
603/*
604 * @event: the event ID to be limited
605 * @rate: the rate limit in milliseconds
606 *
607 * Sets a rate limit on a particular event, so no
608 * more than 1 event will be emitted within @rate
609 * milliseconds
610 */
611static void
612monitor_protocol_event_throttle(MonitorEvent event,
613 int64_t rate)
614{
615 MonitorEventState *evstate;
616 assert(event < QEVENT_MAX);
617
618 evstate = &(monitor_event_state[event]);
619
620 trace_monitor_protocol_event_throttle(event, rate);
621 evstate->event = event;
622 evstate->rate = rate * SCALE_MS;
Alex Blighbc72ad62013-08-21 16:03:08 +0100623 evstate->timer = timer_new(QEMU_CLOCK_REALTIME,
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100624 SCALE_MS,
625 monitor_protocol_event_handler,
626 evstate);
627 evstate->last = 0;
628 evstate->data = NULL;
629}
630
631
632/* Global, one-time initializer to configure the rate limiting
633 * and initialize state */
634static void monitor_protocol_event_init(void)
635{
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100636 /* Limit RTC & BALLOON events to 1 per second */
637 monitor_protocol_event_throttle(QEVENT_RTC_CHANGE, 1000);
638 monitor_protocol_event_throttle(QEVENT_BALLOON_CHANGE, 1000);
639 monitor_protocol_event_throttle(QEVENT_WATCHDOG, 1000);
640}
641
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200642/**
643 * monitor_protocol_event(): Generate a Monitor event
644 *
645 * Event-specific data can be emitted through the (optional) 'data' parameter.
646 */
647void monitor_protocol_event(MonitorEvent event, QObject *data)
648{
649 QDict *qmp;
650 const char *event_name;
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200651
Blue Swirl242cd002009-12-04 18:05:45 +0000652 assert(event < QEVENT_MAX);
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200653
Daniel P. Berrange48608532012-05-21 17:59:51 +0100654 event_name = monitor_event_names[event];
655 assert(event_name != NULL);
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200656
657 qmp = qdict_new();
658 timestamp_put(qmp);
659 qdict_put(qmp, "event", qstring_from_str(event_name));
Luiz Capitulino3d72f9a2010-01-08 16:45:53 -0200660 if (data) {
661 qobject_incref(data);
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200662 qdict_put_obj(qmp, "data", data);
Luiz Capitulino3d72f9a2010-01-08 16:45:53 -0200663 }
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200664
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100665 trace_monitor_protocol_event(event, event_name, qmp);
666 monitor_protocol_event_queue(event, QOBJECT(qmp));
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200667 QDECREF(qmp);
668}
669
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -0200670static int do_qmp_capabilities(Monitor *mon, const QDict *params,
671 QObject **ret_data)
Luiz Capitulino4a7e1192010-02-04 18:10:05 -0200672{
673 /* Will setup QMP capabilities in the future */
674 if (monitor_ctrl_mode(mon)) {
675 mon->mc->command_mode = 1;
676 }
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -0200677
678 return 0;
Luiz Capitulino4a7e1192010-02-04 18:10:05 -0200679}
680
Luiz Capitulino0268d972010-10-22 10:08:02 -0200681static void handle_user_command(Monitor *mon, const char *cmdline);
682
Wenchao Xiab01fe892013-08-27 20:38:19 +0800683static void monitor_data_init(Monitor *mon)
684{
685 memset(mon, 0, sizeof(Monitor));
686 mon->outbuf = qstring_new();
Wenchao Xia77172392013-08-27 20:38:20 +0800687 /* Use *mon_cmds by default. */
688 mon->cmd_table = mon_cmds;
Wenchao Xiab01fe892013-08-27 20:38:19 +0800689}
690
691static void monitor_data_destroy(Monitor *mon)
692{
693 QDECREF(mon->outbuf);
694}
695
Luiz Capitulinod51a67b2011-11-25 17:52:45 -0200696char *qmp_human_monitor_command(const char *command_line, bool has_cpu_index,
697 int64_t cpu_index, Error **errp)
Luiz Capitulino0268d972010-10-22 10:08:02 -0200698{
Luiz Capitulinod51a67b2011-11-25 17:52:45 -0200699 char *output = NULL;
Luiz Capitulino0268d972010-10-22 10:08:02 -0200700 Monitor *old_mon, hmp;
Luiz Capitulino0268d972010-10-22 10:08:02 -0200701
Wenchao Xiab01fe892013-08-27 20:38:19 +0800702 monitor_data_init(&hmp);
Luiz Capitulino48c043d2013-04-02 15:07:33 -0400703 hmp.skip_flush = true;
Luiz Capitulino0268d972010-10-22 10:08:02 -0200704
705 old_mon = cur_mon;
706 cur_mon = &hmp;
707
Luiz Capitulinod51a67b2011-11-25 17:52:45 -0200708 if (has_cpu_index) {
709 int ret = monitor_set_cpu(cpu_index);
Luiz Capitulino0268d972010-10-22 10:08:02 -0200710 if (ret < 0) {
711 cur_mon = old_mon;
Luiz Capitulinod51a67b2011-11-25 17:52:45 -0200712 error_set(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
713 "a CPU number");
Luiz Capitulino0268d972010-10-22 10:08:02 -0200714 goto out;
715 }
716 }
717
Luiz Capitulinod51a67b2011-11-25 17:52:45 -0200718 handle_user_command(&hmp, command_line);
Luiz Capitulino0268d972010-10-22 10:08:02 -0200719 cur_mon = old_mon;
720
Luiz Capitulino48c043d2013-04-02 15:07:33 -0400721 if (qstring_get_length(hmp.outbuf) > 0) {
722 output = g_strdup(qstring_get_str(hmp.outbuf));
Luiz Capitulinod51a67b2011-11-25 17:52:45 -0200723 } else {
724 output = g_strdup("");
Luiz Capitulino0268d972010-10-22 10:08:02 -0200725 }
726
727out:
Wenchao Xiab01fe892013-08-27 20:38:19 +0800728 monitor_data_destroy(&hmp);
Luiz Capitulinod51a67b2011-11-25 17:52:45 -0200729 return output;
Luiz Capitulino0268d972010-10-22 10:08:02 -0200730}
731
bellard9dc39cb2004-03-14 21:38:27 +0000732static int compare_cmd(const char *name, const char *list)
733{
734 const char *p, *pstart;
735 int len;
736 len = strlen(name);
737 p = list;
738 for(;;) {
739 pstart = p;
740 p = strchr(p, '|');
741 if (!p)
742 p = pstart + strlen(pstart);
743 if ((p - pstart) == len && !memcmp(pstart, name, len))
744 return 1;
745 if (*p == '\0')
746 break;
747 p++;
748 }
749 return 0;
750}
751
Wenchao Xiaf5438c02013-08-27 20:38:21 +0800752static int get_str(char *buf, int buf_size, const char **pp)
753{
754 const char *p;
755 char *q;
756 int c;
757
758 q = buf;
759 p = *pp;
760 while (qemu_isspace(*p)) {
761 p++;
762 }
763 if (*p == '\0') {
764 fail:
765 *q = '\0';
766 *pp = p;
767 return -1;
768 }
769 if (*p == '\"') {
770 p++;
771 while (*p != '\0' && *p != '\"') {
772 if (*p == '\\') {
773 p++;
774 c = *p++;
775 switch (c) {
776 case 'n':
777 c = '\n';
778 break;
779 case 'r':
780 c = '\r';
781 break;
782 case '\\':
783 case '\'':
784 case '\"':
785 break;
786 default:
787 qemu_printf("unsupported escape code: '\\%c'\n", c);
788 goto fail;
789 }
790 if ((q - buf) < buf_size - 1) {
791 *q++ = c;
792 }
793 } else {
794 if ((q - buf) < buf_size - 1) {
795 *q++ = *p;
796 }
797 p++;
798 }
799 }
800 if (*p != '\"') {
801 qemu_printf("unterminated string\n");
802 goto fail;
803 }
804 p++;
805 } else {
806 while (*p != '\0' && !qemu_isspace(*p)) {
807 if ((q - buf) < buf_size - 1) {
808 *q++ = *p;
809 }
810 p++;
811 }
812 }
813 *q = '\0';
814 *pp = p;
815 return 0;
816}
817
818#define MAX_ARGS 16
819
Wenchao Xiadcc70cd2013-08-27 20:38:22 +0800820static void free_cmdline_args(char **args, int nb_args)
821{
822 int i;
823
824 assert(nb_args <= MAX_ARGS);
825
826 for (i = 0; i < nb_args; i++) {
827 g_free(args[i]);
828 }
829
830}
831
832/*
833 * Parse the command line to get valid args.
834 * @cmdline: command line to be parsed.
835 * @pnb_args: location to store the number of args, must NOT be NULL.
836 * @args: location to store the args, which should be freed by caller, must
837 * NOT be NULL.
838 *
839 * Returns 0 on success, negative on failure.
840 *
841 * NOTE: this parser is an approximate form of the real command parser. Number
842 * of args have a limit of MAX_ARGS. If cmdline contains more, it will
843 * return with failure.
844 */
845static int parse_cmdline(const char *cmdline,
846 int *pnb_args, char **args)
Wenchao Xiaf5438c02013-08-27 20:38:21 +0800847{
848 const char *p;
849 int nb_args, ret;
850 char buf[1024];
851
852 p = cmdline;
853 nb_args = 0;
854 for (;;) {
855 while (qemu_isspace(*p)) {
856 p++;
857 }
858 if (*p == '\0') {
859 break;
860 }
861 if (nb_args >= MAX_ARGS) {
Wenchao Xiadcc70cd2013-08-27 20:38:22 +0800862 goto fail;
Wenchao Xiaf5438c02013-08-27 20:38:21 +0800863 }
864 ret = get_str(buf, sizeof(buf), &p);
Wenchao Xiadcc70cd2013-08-27 20:38:22 +0800865 if (ret < 0) {
866 goto fail;
867 }
Wenchao Xiaf5438c02013-08-27 20:38:21 +0800868 args[nb_args] = g_strdup(buf);
869 nb_args++;
Wenchao Xiaf5438c02013-08-27 20:38:21 +0800870 }
871 *pnb_args = nb_args;
Wenchao Xiadcc70cd2013-08-27 20:38:22 +0800872 return 0;
873
874 fail:
875 free_cmdline_args(args, nb_args);
876 return -1;
Wenchao Xiaf5438c02013-08-27 20:38:21 +0800877}
878
Wenchao Xia66855492013-08-27 20:38:23 +0800879static void help_cmd_dump_one(Monitor *mon,
880 const mon_cmd_t *cmd,
881 char **prefix_args,
882 int prefix_args_nb)
883{
884 int i;
885
886 for (i = 0; i < prefix_args_nb; i++) {
887 monitor_printf(mon, "%s ", prefix_args[i]);
888 }
889 monitor_printf(mon, "%s %s -- %s\n", cmd->name, cmd->params, cmd->help);
890}
891
892/* @args[@arg_index] is the valid command need to find in @cmds */
Anthony Liguoric227f092009-10-01 16:12:16 -0500893static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
Wenchao Xia66855492013-08-27 20:38:23 +0800894 char **args, int nb_args, int arg_index)
bellard9dc39cb2004-03-14 21:38:27 +0000895{
Anthony Liguoric227f092009-10-01 16:12:16 -0500896 const mon_cmd_t *cmd;
bellard9dc39cb2004-03-14 21:38:27 +0000897
Wenchao Xia66855492013-08-27 20:38:23 +0800898 /* No valid arg need to compare with, dump all in *cmds */
899 if (arg_index >= nb_args) {
900 for (cmd = cmds; cmd->name != NULL; cmd++) {
901 help_cmd_dump_one(mon, cmd, args, arg_index);
902 }
903 return;
904 }
905
906 /* Find one entry to dump */
907 for (cmd = cmds; cmd->name != NULL; cmd++) {
908 if (compare_cmd(args[arg_index], cmd->name)) {
909 if (cmd->sub_table) {
910 /* continue with next arg */
911 help_cmd_dump(mon, cmd->sub_table,
912 args, nb_args, arg_index + 1);
913 } else {
914 help_cmd_dump_one(mon, cmd, args, arg_index);
915 }
916 break;
917 }
bellard9dc39cb2004-03-14 21:38:27 +0000918 }
919}
920
aliguori376253e2009-03-05 23:01:23 +0000921static void help_cmd(Monitor *mon, const char *name)
bellard9dc39cb2004-03-14 21:38:27 +0000922{
Wenchao Xia66855492013-08-27 20:38:23 +0800923 char *args[MAX_ARGS];
924 int nb_args = 0;
925
926 /* 1. parse user input */
927 if (name) {
928 /* special case for log, directly dump and return */
929 if (!strcmp(name, "log")) {
Peter Maydell38dad9e2013-02-11 16:41:25 +0000930 const QEMULogItem *item;
aliguori376253e2009-03-05 23:01:23 +0000931 monitor_printf(mon, "Log items (comma separated):\n");
932 monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");
Peter Maydell38dad9e2013-02-11 16:41:25 +0000933 for (item = qemu_log_items; item->mask != 0; item++) {
aliguori376253e2009-03-05 23:01:23 +0000934 monitor_printf(mon, "%-10s %s\n", item->name, item->help);
bellardf193c792004-03-21 17:06:25 +0000935 }
Wenchao Xia66855492013-08-27 20:38:23 +0800936 return;
937 }
938
939 if (parse_cmdline(name, &nb_args, args) < 0) {
940 return;
bellardf193c792004-03-21 17:06:25 +0000941 }
bellard9dc39cb2004-03-14 21:38:27 +0000942 }
Wenchao Xia66855492013-08-27 20:38:23 +0800943
944 /* 2. dump the contents according to parsed args */
945 help_cmd_dump(mon, mon->cmd_table, args, nb_args, 0);
946
947 free_cmdline_args(args, nb_args);
bellard9dc39cb2004-03-14 21:38:27 +0000948}
949
Luiz Capitulinod54908a2009-08-28 15:27:13 -0300950static void do_help_cmd(Monitor *mon, const QDict *qdict)
Luiz Capitulino38183182009-08-28 15:27:08 -0300951{
Luiz Capitulinod54908a2009-08-28 15:27:13 -0300952 help_cmd(mon, qdict_get_try_str(qdict, "name"));
Luiz Capitulino38183182009-08-28 15:27:08 -0300953}
954
Lluísfc764102011-08-31 20:31:18 +0200955static void do_trace_event_set_state(Monitor *mon, const QDict *qdict)
Prerna Saxena22890ab2010-06-24 17:04:53 +0530956{
957 const char *tp_name = qdict_get_str(qdict, "name");
958 bool new_state = qdict_get_bool(qdict, "option");
Blue Swirlf871d682010-10-13 19:14:29 +0000959
Lluís Vilanovaca285c32013-03-05 14:47:43 +0100960 bool found = false;
961 TraceEvent *ev = NULL;
962 while ((ev = trace_event_pattern(tp_name, ev)) != NULL) {
963 found = true;
964 if (!trace_event_get_state_static(ev)) {
965 monitor_printf(mon, "event \"%s\" is not traceable\n", tp_name);
966 } else {
967 trace_event_set_state_dynamic(ev, new_state);
968 }
969 }
970 if (!trace_event_is_pattern(tp_name) && !found) {
Blue Swirlf871d682010-10-13 19:14:29 +0000971 monitor_printf(mon, "unknown event name \"%s\"\n", tp_name);
972 }
Prerna Saxena22890ab2010-06-24 17:04:53 +0530973}
Stefan Hajnoczic5ceb522010-07-13 09:26:33 +0100974
Michael Rothc45a8162011-10-02 08:44:37 -0500975#ifdef CONFIG_TRACE_SIMPLE
Stefan Hajnoczic5ceb522010-07-13 09:26:33 +0100976static void do_trace_file(Monitor *mon, const QDict *qdict)
977{
978 const char *op = qdict_get_try_str(qdict, "op");
979 const char *arg = qdict_get_try_str(qdict, "arg");
980
981 if (!op) {
982 st_print_trace_file_status((FILE *)mon, &monitor_fprintf);
983 } else if (!strcmp(op, "on")) {
984 st_set_trace_file_enabled(true);
985 } else if (!strcmp(op, "off")) {
986 st_set_trace_file_enabled(false);
987 } else if (!strcmp(op, "flush")) {
988 st_flush_trace_buffer();
989 } else if (!strcmp(op, "set")) {
990 if (arg) {
991 st_set_trace_file(arg);
992 }
993 } else {
994 monitor_printf(mon, "unexpected argument \"%s\"\n", op);
995 help_cmd(mon, "trace-file");
996 }
997}
Prerna Saxena22890ab2010-06-24 17:04:53 +0530998#endif
999
Adam Litke940cc302010-01-25 12:18:44 -06001000static void user_monitor_complete(void *opaque, QObject *ret_data)
1001{
1002 MonitorCompletionData *data = (MonitorCompletionData *)opaque;
1003
1004 if (ret_data) {
1005 data->user_print(data->mon, ret_data);
1006 }
1007 monitor_resume(data->mon);
Anthony Liguori7267c092011-08-20 22:09:37 -05001008 g_free(data);
Adam Litke940cc302010-01-25 12:18:44 -06001009}
1010
1011static void qmp_monitor_complete(void *opaque, QObject *ret_data)
1012{
1013 monitor_protocol_emitter(opaque, ret_data);
1014}
1015
Luiz Capitulino5af7bba2010-06-22 19:10:46 -03001016static int qmp_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,
1017 const QDict *params)
Adam Litke940cc302010-01-25 12:18:44 -06001018{
Luiz Capitulino5af7bba2010-06-22 19:10:46 -03001019 return cmd->mhandler.cmd_async(mon, params, qmp_monitor_complete, mon);
Adam Litke940cc302010-01-25 12:18:44 -06001020}
1021
Adam Litke940cc302010-01-25 12:18:44 -06001022static void user_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,
1023 const QDict *params)
1024{
1025 int ret;
1026
Anthony Liguori7267c092011-08-20 22:09:37 -05001027 MonitorCompletionData *cb_data = g_malloc(sizeof(*cb_data));
Adam Litke940cc302010-01-25 12:18:44 -06001028 cb_data->mon = mon;
1029 cb_data->user_print = cmd->user_print;
1030 monitor_suspend(mon);
1031 ret = cmd->mhandler.cmd_async(mon, params,
1032 user_monitor_complete, cb_data);
1033 if (ret < 0) {
1034 monitor_resume(mon);
Anthony Liguori7267c092011-08-20 22:09:37 -05001035 g_free(cb_data);
Adam Litke940cc302010-01-25 12:18:44 -06001036 }
1037}
1038
Wenchao Xia84c44612013-01-14 14:06:29 +08001039static void do_info_help(Monitor *mon, const QDict *qdict)
bellard9dc39cb2004-03-14 21:38:27 +00001040{
Luiz Capitulino13c74252009-10-07 13:41:55 -03001041 help_cmd(mon, "info");
bellard9dc39cb2004-03-14 21:38:27 +00001042}
1043
Luiz Capitulinoaa9b79b2011-09-21 14:31:51 -03001044CommandInfoList *qmp_query_commands(Error **errp)
bellard9bc9d1c2004-10-10 15:15:51 +00001045{
Luiz Capitulinoaa9b79b2011-09-21 14:31:51 -03001046 CommandInfoList *info, *cmd_list = NULL;
Luiz Capitulinoe3bba9d2009-11-26 22:58:56 -02001047 const mon_cmd_t *cmd;
1048
Luiz Capitulinof36b4af2010-09-15 17:17:45 -03001049 for (cmd = qmp_cmds; cmd->name != NULL; cmd++) {
Luiz Capitulino40e5a012011-10-21 16:15:31 -02001050 info = g_malloc0(sizeof(*info));
1051 info->value = g_malloc0(sizeof(*info->value));
1052 info->value->name = g_strdup(cmd->name);
Luiz Capitulinoe3bba9d2009-11-26 22:58:56 -02001053
Luiz Capitulinoaa9b79b2011-09-21 14:31:51 -03001054 info->next = cmd_list;
1055 cmd_list = info;
Luiz Capitulinoe3bba9d2009-11-26 22:58:56 -02001056 }
1057
Luiz Capitulinoaa9b79b2011-09-21 14:31:51 -03001058 return cmd_list;
thsa36e69d2007-12-02 05:18:19 +00001059}
1060
Daniel P. Berrange48608532012-05-21 17:59:51 +01001061EventInfoList *qmp_query_events(Error **errp)
1062{
1063 EventInfoList *info, *ev_list = NULL;
1064 MonitorEvent e;
1065
1066 for (e = 0 ; e < QEVENT_MAX ; e++) {
1067 const char *event_name = monitor_event_names[e];
1068 assert(event_name != NULL);
1069 info = g_malloc0(sizeof(*info));
1070 info->value = g_malloc0(sizeof(*info->value));
1071 info->value->name = g_strdup(event_name);
1072
1073 info->next = ev_list;
1074 ev_list = info;
1075 }
1076
1077 return ev_list;
1078}
1079
Luiz Capitulinob025c8b2011-10-06 14:02:57 -03001080/* set the current CPU defined by the user */
1081int monitor_set_cpu(int cpu_index)
bellard6a00d602005-11-21 23:25:50 +00001082{
Andreas Färber55e5c282012-12-17 06:18:02 +01001083 CPUState *cpu;
bellard6a00d602005-11-21 23:25:50 +00001084
Andreas Färber1c8bb3c2013-02-15 17:01:09 +01001085 cpu = qemu_get_cpu(cpu_index);
1086 if (cpu == NULL) {
1087 return -1;
bellard6a00d602005-11-21 23:25:50 +00001088 }
Andreas Färbercb446ec2013-05-01 14:24:52 +02001089 cur_mon->mon_cpu = cpu;
Andreas Färber1c8bb3c2013-02-15 17:01:09 +01001090 return 0;
bellard6a00d602005-11-21 23:25:50 +00001091}
1092
Andreas Färber9349b4f2012-03-14 01:38:32 +01001093static CPUArchState *mon_get_cpu(void)
bellard6a00d602005-11-21 23:25:50 +00001094{
aliguori731b0362009-03-05 23:01:42 +00001095 if (!cur_mon->mon_cpu) {
Luiz Capitulinob025c8b2011-10-06 14:02:57 -03001096 monitor_set_cpu(0);
bellard6a00d602005-11-21 23:25:50 +00001097 }
Avi Kivity4c0960c2009-08-17 23:19:53 +03001098 cpu_synchronize_state(cur_mon->mon_cpu);
Andreas Färbercb446ec2013-05-01 14:24:52 +02001099 return cur_mon->mon_cpu->env_ptr;
bellard6a00d602005-11-21 23:25:50 +00001100}
1101
Luiz Capitulino99b77962011-10-24 10:53:44 -02001102int monitor_get_cpu_index(void)
1103{
Andreas Färber55e5c282012-12-17 06:18:02 +01001104 CPUState *cpu = ENV_GET_CPU(mon_get_cpu());
1105 return cpu->cpu_index;
Luiz Capitulino99b77962011-10-24 10:53:44 -02001106}
1107
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08001108static void do_info_registers(Monitor *mon, const QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +00001109{
Andreas Färber878096e2013-05-27 01:33:50 +02001110 CPUState *cpu;
Andreas Färber9349b4f2012-03-14 01:38:32 +01001111 CPUArchState *env;
bellard6a00d602005-11-21 23:25:50 +00001112 env = mon_get_cpu();
Andreas Färber878096e2013-05-27 01:33:50 +02001113 cpu = ENV_GET_CPU(env);
1114 cpu_dump_state(cpu, (FILE *)mon, monitor_fprintf, CPU_DUMP_FPU);
bellard9307c4c2004-04-04 12:57:25 +00001115}
1116
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08001117static void do_info_jit(Monitor *mon, const QDict *qdict)
bellarde3db7222005-01-26 22:00:47 +00001118{
aliguori376253e2009-03-05 23:01:23 +00001119 dump_exec_info((FILE *)mon, monitor_fprintf);
bellarde3db7222005-01-26 22:00:47 +00001120}
1121
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08001122static void do_info_history(Monitor *mon, const QDict *qdict)
bellardaa455482004-04-04 13:07:25 +00001123{
1124 int i;
bellard7e2515e2004-08-01 21:52:19 +00001125 const char *str;
ths3b46e622007-09-17 08:09:54 +00001126
aliguoricde76ee2009-03-05 23:01:51 +00001127 if (!mon->rs)
1128 return;
bellard7e2515e2004-08-01 21:52:19 +00001129 i = 0;
1130 for(;;) {
aliguori731b0362009-03-05 23:01:42 +00001131 str = readline_get_history(mon->rs, i);
bellard7e2515e2004-08-01 21:52:19 +00001132 if (!str)
1133 break;
aliguori376253e2009-03-05 23:01:23 +00001134 monitor_printf(mon, "%d: '%s'\n", i, str);
bellard8e3a9fd2004-10-09 17:32:58 +00001135 i++;
bellardaa455482004-04-04 13:07:25 +00001136 }
1137}
1138
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08001139static void do_info_cpu_stats(Monitor *mon, const QDict *qdict)
j_mayer76a66252007-03-07 08:32:30 +00001140{
Andreas Färber878096e2013-05-27 01:33:50 +02001141 CPUState *cpu;
Andreas Färber9349b4f2012-03-14 01:38:32 +01001142 CPUArchState *env;
j_mayer76a66252007-03-07 08:32:30 +00001143
1144 env = mon_get_cpu();
Andreas Färber878096e2013-05-27 01:33:50 +02001145 cpu = ENV_GET_CPU(env);
1146 cpu_dump_statistics(cpu, (FILE *)mon, &monitor_fprintf, 0);
j_mayer76a66252007-03-07 08:32:30 +00001147}
j_mayer76a66252007-03-07 08:32:30 +00001148
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08001149static void do_trace_print_events(Monitor *mon, const QDict *qdict)
Prerna Saxena22890ab2010-06-24 17:04:53 +05301150{
Lluísfc764102011-08-31 20:31:18 +02001151 trace_print_events((FILE *)mon, &monitor_fprintf);
Prerna Saxena22890ab2010-06-24 17:04:53 +05301152}
Prerna Saxena22890ab2010-06-24 17:04:53 +05301153
Yonit Halperinedc5cb12011-10-17 10:03:18 +02001154static int client_migrate_info(Monitor *mon, const QDict *qdict,
1155 MonitorCompletion cb, void *opaque)
Gerd Hoffmanne866e232010-04-23 13:28:21 +02001156{
1157 const char *protocol = qdict_get_str(qdict, "protocol");
1158 const char *hostname = qdict_get_str(qdict, "hostname");
1159 const char *subject = qdict_get_try_str(qdict, "cert-subject");
1160 int port = qdict_get_try_int(qdict, "port", -1);
1161 int tls_port = qdict_get_try_int(qdict, "tls-port", -1);
1162 int ret;
1163
1164 if (strcmp(protocol, "spice") == 0) {
1165 if (!using_spice) {
1166 qerror_report(QERR_DEVICE_NOT_ACTIVE, "spice");
1167 return -1;
1168 }
1169
Yonit Halperin6ec5dae2012-03-18 09:42:39 +02001170 if (port == -1 && tls_port == -1) {
1171 qerror_report(QERR_MISSING_PARAMETER, "port/tls-port");
1172 return -1;
1173 }
1174
Yonit Halperinedc5cb12011-10-17 10:03:18 +02001175 ret = qemu_spice_migrate_info(hostname, port, tls_port, subject,
1176 cb, opaque);
Gerd Hoffmanne866e232010-04-23 13:28:21 +02001177 if (ret != 0) {
1178 qerror_report(QERR_UNDEFINED_ERROR);
1179 return -1;
1180 }
1181 return 0;
1182 }
1183
1184 qerror_report(QERR_INVALID_PARAMETER, "protocol");
1185 return -1;
1186}
1187
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001188static void do_logfile(Monitor *mon, const QDict *qdict)
pbrooke735b912007-06-30 13:53:24 +00001189{
Peter Maydell9a7e5422013-02-11 16:41:20 +00001190 qemu_set_log_filename(qdict_get_str(qdict, "filename"));
pbrooke735b912007-06-30 13:53:24 +00001191}
1192
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001193static void do_log(Monitor *mon, const QDict *qdict)
bellardf193c792004-03-21 17:06:25 +00001194{
1195 int mask;
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001196 const char *items = qdict_get_str(qdict, "items");
ths3b46e622007-09-17 08:09:54 +00001197
bellard9307c4c2004-04-04 12:57:25 +00001198 if (!strcmp(items, "none")) {
bellardf193c792004-03-21 17:06:25 +00001199 mask = 0;
1200 } else {
Peter Maydell4fde1eb2013-02-11 16:41:22 +00001201 mask = qemu_str_to_log_mask(items);
bellardf193c792004-03-21 17:06:25 +00001202 if (!mask) {
aliguori376253e2009-03-05 23:01:23 +00001203 help_cmd(mon, "log");
bellardf193c792004-03-21 17:06:25 +00001204 return;
1205 }
1206 }
Peter Maydell24537a02013-02-11 16:41:23 +00001207 qemu_set_log(mask);
bellardf193c792004-03-21 17:06:25 +00001208}
1209
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001210static void do_singlestep(Monitor *mon, const QDict *qdict)
aurel321b530a62009-04-05 20:08:59 +00001211{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001212 const char *option = qdict_get_try_str(qdict, "option");
aurel321b530a62009-04-05 20:08:59 +00001213 if (!option || !strcmp(option, "on")) {
1214 singlestep = 1;
1215 } else if (!strcmp(option, "off")) {
1216 singlestep = 0;
1217 } else {
1218 monitor_printf(mon, "unexpected option %s\n", option);
1219 }
1220}
1221
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001222static void do_gdbserver(Monitor *mon, const QDict *qdict)
bellard8a7ddc32004-03-31 19:00:16 +00001223{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001224 const char *device = qdict_get_try_str(qdict, "device");
aliguori59030a82009-04-05 18:43:41 +00001225 if (!device)
1226 device = "tcp::" DEFAULT_GDBSTUB_PORT;
1227 if (gdbserver_start(device) < 0) {
1228 monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
1229 device);
1230 } else if (strcmp(device, "none") == 0) {
aliguori36556b22009-03-28 18:05:53 +00001231 monitor_printf(mon, "Disabled gdbserver\n");
bellard8a7ddc32004-03-31 19:00:16 +00001232 } else {
aliguori59030a82009-04-05 18:43:41 +00001233 monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
1234 device);
bellard8a7ddc32004-03-31 19:00:16 +00001235 }
1236}
1237
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001238static void do_watchdog_action(Monitor *mon, const QDict *qdict)
Richard W.M. Jones9dd986c2009-04-25 13:56:19 +01001239{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001240 const char *action = qdict_get_str(qdict, "action");
Richard W.M. Jones9dd986c2009-04-25 13:56:19 +01001241 if (select_watchdog_action(action) == -1) {
1242 monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
1243 }
1244}
1245
aliguori376253e2009-03-05 23:01:23 +00001246static void monitor_printc(Monitor *mon, int c)
bellard9307c4c2004-04-04 12:57:25 +00001247{
aliguori376253e2009-03-05 23:01:23 +00001248 monitor_printf(mon, "'");
bellard9307c4c2004-04-04 12:57:25 +00001249 switch(c) {
1250 case '\'':
aliguori376253e2009-03-05 23:01:23 +00001251 monitor_printf(mon, "\\'");
bellard9307c4c2004-04-04 12:57:25 +00001252 break;
1253 case '\\':
aliguori376253e2009-03-05 23:01:23 +00001254 monitor_printf(mon, "\\\\");
bellard9307c4c2004-04-04 12:57:25 +00001255 break;
1256 case '\n':
aliguori376253e2009-03-05 23:01:23 +00001257 monitor_printf(mon, "\\n");
bellard9307c4c2004-04-04 12:57:25 +00001258 break;
1259 case '\r':
aliguori376253e2009-03-05 23:01:23 +00001260 monitor_printf(mon, "\\r");
bellard9307c4c2004-04-04 12:57:25 +00001261 break;
1262 default:
1263 if (c >= 32 && c <= 126) {
aliguori376253e2009-03-05 23:01:23 +00001264 monitor_printf(mon, "%c", c);
bellard9307c4c2004-04-04 12:57:25 +00001265 } else {
aliguori376253e2009-03-05 23:01:23 +00001266 monitor_printf(mon, "\\x%02x", c);
bellard9307c4c2004-04-04 12:57:25 +00001267 }
1268 break;
1269 }
aliguori376253e2009-03-05 23:01:23 +00001270 monitor_printf(mon, "'");
bellard9307c4c2004-04-04 12:57:25 +00001271}
1272
aliguori376253e2009-03-05 23:01:23 +00001273static void memory_dump(Monitor *mon, int count, int format, int wsize,
Avi Kivitya8170e52012-10-23 12:30:10 +02001274 hwaddr addr, int is_physical)
bellard9307c4c2004-04-04 12:57:25 +00001275{
Andreas Färber9349b4f2012-03-14 01:38:32 +01001276 CPUArchState *env;
Blue Swirl23842aa2010-01-12 20:27:43 +00001277 int l, line_size, i, max_digits, len;
bellard9307c4c2004-04-04 12:57:25 +00001278 uint8_t buf[16];
1279 uint64_t v;
1280
1281 if (format == 'i') {
1282 int flags;
1283 flags = 0;
bellard6a00d602005-11-21 23:25:50 +00001284 env = mon_get_cpu();
bellard9307c4c2004-04-04 12:57:25 +00001285#ifdef TARGET_I386
bellard4c27ba22004-04-25 18:05:08 +00001286 if (wsize == 2) {
bellard9307c4c2004-04-04 12:57:25 +00001287 flags = 1;
bellard4c27ba22004-04-25 18:05:08 +00001288 } else if (wsize == 4) {
1289 flags = 0;
1290 } else {
bellard6a15fd12006-04-12 21:07:07 +00001291 /* as default we use the current CS size */
bellard4c27ba22004-04-25 18:05:08 +00001292 flags = 0;
bellard6a15fd12006-04-12 21:07:07 +00001293 if (env) {
1294#ifdef TARGET_X86_64
ths5fafdf22007-09-16 21:08:06 +00001295 if ((env->efer & MSR_EFER_LMA) &&
bellard6a15fd12006-04-12 21:07:07 +00001296 (env->segs[R_CS].flags & DESC_L_MASK))
1297 flags = 2;
1298 else
1299#endif
1300 if (!(env->segs[R_CS].flags & DESC_B_MASK))
1301 flags = 1;
1302 }
bellard4c27ba22004-04-25 18:05:08 +00001303 }
1304#endif
aliguori376253e2009-03-05 23:01:23 +00001305 monitor_disas(mon, env, addr, count, is_physical, flags);
bellard9307c4c2004-04-04 12:57:25 +00001306 return;
1307 }
1308
1309 len = wsize * count;
1310 if (wsize == 1)
1311 line_size = 8;
1312 else
1313 line_size = 16;
bellard9307c4c2004-04-04 12:57:25 +00001314 max_digits = 0;
1315
1316 switch(format) {
1317 case 'o':
1318 max_digits = (wsize * 8 + 2) / 3;
1319 break;
1320 default:
1321 case 'x':
1322 max_digits = (wsize * 8) / 4;
1323 break;
1324 case 'u':
1325 case 'd':
1326 max_digits = (wsize * 8 * 10 + 32) / 33;
1327 break;
1328 case 'c':
1329 wsize = 1;
1330 break;
1331 }
1332
1333 while (len > 0) {
blueswir17743e582007-09-24 18:39:04 +00001334 if (is_physical)
aliguori376253e2009-03-05 23:01:23 +00001335 monitor_printf(mon, TARGET_FMT_plx ":", addr);
blueswir17743e582007-09-24 18:39:04 +00001336 else
aliguori376253e2009-03-05 23:01:23 +00001337 monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
bellard9307c4c2004-04-04 12:57:25 +00001338 l = len;
1339 if (l > line_size)
1340 l = line_size;
1341 if (is_physical) {
Stefan Weil54f7b4a2011-04-10 18:23:39 +02001342 cpu_physical_memory_read(addr, buf, l);
bellard9307c4c2004-04-04 12:57:25 +00001343 } else {
bellard6a00d602005-11-21 23:25:50 +00001344 env = mon_get_cpu();
Andreas Färberf17ec442013-06-29 19:40:58 +02001345 if (cpu_memory_rw_debug(ENV_GET_CPU(env), addr, buf, l, 0) < 0) {
aliguori376253e2009-03-05 23:01:23 +00001346 monitor_printf(mon, " Cannot access memory\n");
aliguoric8f79b62008-08-18 14:00:20 +00001347 break;
1348 }
bellard9307c4c2004-04-04 12:57:25 +00001349 }
ths5fafdf22007-09-16 21:08:06 +00001350 i = 0;
bellard9307c4c2004-04-04 12:57:25 +00001351 while (i < l) {
1352 switch(wsize) {
1353 default:
1354 case 1:
1355 v = ldub_raw(buf + i);
1356 break;
1357 case 2:
1358 v = lduw_raw(buf + i);
1359 break;
1360 case 4:
bellard92a31b12005-02-10 22:00:52 +00001361 v = (uint32_t)ldl_raw(buf + i);
bellard9307c4c2004-04-04 12:57:25 +00001362 break;
1363 case 8:
1364 v = ldq_raw(buf + i);
1365 break;
1366 }
aliguori376253e2009-03-05 23:01:23 +00001367 monitor_printf(mon, " ");
bellard9307c4c2004-04-04 12:57:25 +00001368 switch(format) {
1369 case 'o':
aliguori376253e2009-03-05 23:01:23 +00001370 monitor_printf(mon, "%#*" PRIo64, max_digits, v);
bellard9307c4c2004-04-04 12:57:25 +00001371 break;
1372 case 'x':
aliguori376253e2009-03-05 23:01:23 +00001373 monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
bellard9307c4c2004-04-04 12:57:25 +00001374 break;
1375 case 'u':
aliguori376253e2009-03-05 23:01:23 +00001376 monitor_printf(mon, "%*" PRIu64, max_digits, v);
bellard9307c4c2004-04-04 12:57:25 +00001377 break;
1378 case 'd':
aliguori376253e2009-03-05 23:01:23 +00001379 monitor_printf(mon, "%*" PRId64, max_digits, v);
bellard9307c4c2004-04-04 12:57:25 +00001380 break;
1381 case 'c':
aliguori376253e2009-03-05 23:01:23 +00001382 monitor_printc(mon, v);
bellard9307c4c2004-04-04 12:57:25 +00001383 break;
1384 }
1385 i += wsize;
1386 }
aliguori376253e2009-03-05 23:01:23 +00001387 monitor_printf(mon, "\n");
bellard9307c4c2004-04-04 12:57:25 +00001388 addr += l;
1389 len -= l;
1390 }
1391}
1392
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001393static void do_memory_dump(Monitor *mon, const QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +00001394{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001395 int count = qdict_get_int(qdict, "count");
1396 int format = qdict_get_int(qdict, "format");
1397 int size = qdict_get_int(qdict, "size");
1398 target_long addr = qdict_get_int(qdict, "addr");
1399
aliguori376253e2009-03-05 23:01:23 +00001400 memory_dump(mon, count, format, size, addr, 0);
bellard9307c4c2004-04-04 12:57:25 +00001401}
1402
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001403static void do_physical_memory_dump(Monitor *mon, const QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +00001404{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001405 int count = qdict_get_int(qdict, "count");
1406 int format = qdict_get_int(qdict, "format");
1407 int size = qdict_get_int(qdict, "size");
Avi Kivitya8170e52012-10-23 12:30:10 +02001408 hwaddr addr = qdict_get_int(qdict, "addr");
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001409
aliguori376253e2009-03-05 23:01:23 +00001410 memory_dump(mon, count, format, size, addr, 1);
bellard9307c4c2004-04-04 12:57:25 +00001411}
1412
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001413static void do_print(Monitor *mon, const QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +00001414{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001415 int format = qdict_get_int(qdict, "format");
Avi Kivitya8170e52012-10-23 12:30:10 +02001416 hwaddr val = qdict_get_int(qdict, "val");
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001417
bellard9307c4c2004-04-04 12:57:25 +00001418 switch(format) {
1419 case 'o':
Avi Kivitya8170e52012-10-23 12:30:10 +02001420 monitor_printf(mon, "%#" HWADDR_PRIo, val);
bellard9307c4c2004-04-04 12:57:25 +00001421 break;
1422 case 'x':
Avi Kivitya8170e52012-10-23 12:30:10 +02001423 monitor_printf(mon, "%#" HWADDR_PRIx, val);
bellard9307c4c2004-04-04 12:57:25 +00001424 break;
1425 case 'u':
Avi Kivitya8170e52012-10-23 12:30:10 +02001426 monitor_printf(mon, "%" HWADDR_PRIu, val);
bellard9307c4c2004-04-04 12:57:25 +00001427 break;
1428 default:
1429 case 'd':
Avi Kivitya8170e52012-10-23 12:30:10 +02001430 monitor_printf(mon, "%" HWADDR_PRId, val);
bellard9307c4c2004-04-04 12:57:25 +00001431 break;
1432 case 'c':
aliguori376253e2009-03-05 23:01:23 +00001433 monitor_printc(mon, val);
bellard9307c4c2004-04-04 12:57:25 +00001434 break;
1435 }
aliguori376253e2009-03-05 23:01:23 +00001436 monitor_printf(mon, "\n");
bellard9307c4c2004-04-04 12:57:25 +00001437}
1438
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03001439static void do_sum(Monitor *mon, const QDict *qdict)
bellarde4cf1ad2005-06-04 20:15:57 +00001440{
1441 uint32_t addr;
bellarde4cf1ad2005-06-04 20:15:57 +00001442 uint16_t sum;
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03001443 uint32_t start = qdict_get_int(qdict, "start");
1444 uint32_t size = qdict_get_int(qdict, "size");
bellarde4cf1ad2005-06-04 20:15:57 +00001445
1446 sum = 0;
1447 for(addr = start; addr < (start + size); addr++) {
Stefan Weil54f7b4a2011-04-10 18:23:39 +02001448 uint8_t val = ldub_phys(addr);
bellarde4cf1ad2005-06-04 20:15:57 +00001449 /* BSD sum algorithm ('sum' Unix command) */
1450 sum = (sum >> 1) | (sum << 15);
Stefan Weil54f7b4a2011-04-10 18:23:39 +02001451 sum += val;
bellarde4cf1ad2005-06-04 20:15:57 +00001452 }
aliguori376253e2009-03-05 23:01:23 +00001453 monitor_printf(mon, "%05d\n", sum);
bellarde4cf1ad2005-06-04 20:15:57 +00001454}
1455
bellard13224a82006-07-14 22:03:35 +00001456static int mouse_button_state;
1457
Luiz Capitulino1d4daa92009-08-28 15:27:15 -03001458static void do_mouse_move(Monitor *mon, const QDict *qdict)
bellard13224a82006-07-14 22:03:35 +00001459{
1460 int dx, dy, dz;
Luiz Capitulino1d4daa92009-08-28 15:27:15 -03001461 const char *dx_str = qdict_get_str(qdict, "dx_str");
1462 const char *dy_str = qdict_get_str(qdict, "dy_str");
1463 const char *dz_str = qdict_get_try_str(qdict, "dz_str");
bellard13224a82006-07-14 22:03:35 +00001464 dx = strtol(dx_str, NULL, 0);
1465 dy = strtol(dy_str, NULL, 0);
1466 dz = 0;
ths5fafdf22007-09-16 21:08:06 +00001467 if (dz_str)
bellard13224a82006-07-14 22:03:35 +00001468 dz = strtol(dz_str, NULL, 0);
1469 kbd_mouse_event(dx, dy, dz, mouse_button_state);
1470}
1471
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001472static void do_mouse_button(Monitor *mon, const QDict *qdict)
bellard13224a82006-07-14 22:03:35 +00001473{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001474 int button_state = qdict_get_int(qdict, "button_state");
bellard13224a82006-07-14 22:03:35 +00001475 mouse_button_state = button_state;
1476 kbd_mouse_event(0, 0, 0, mouse_button_state);
1477}
1478
Luiz Capitulinoaa93e392009-08-28 15:27:18 -03001479static void do_ioport_read(Monitor *mon, const QDict *qdict)
bellard34405572004-06-08 00:55:58 +00001480{
Luiz Capitulinoaa93e392009-08-28 15:27:18 -03001481 int size = qdict_get_int(qdict, "size");
1482 int addr = qdict_get_int(qdict, "addr");
1483 int has_index = qdict_haskey(qdict, "index");
bellard34405572004-06-08 00:55:58 +00001484 uint32_t val;
1485 int suffix;
1486
1487 if (has_index) {
Luiz Capitulinoaa93e392009-08-28 15:27:18 -03001488 int index = qdict_get_int(qdict, "index");
Blue Swirlafcea8c2009-09-20 16:05:47 +00001489 cpu_outb(addr & IOPORTS_MASK, index & 0xff);
bellard34405572004-06-08 00:55:58 +00001490 addr++;
1491 }
1492 addr &= 0xffff;
1493
1494 switch(size) {
1495 default:
1496 case 1:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001497 val = cpu_inb(addr);
bellard34405572004-06-08 00:55:58 +00001498 suffix = 'b';
1499 break;
1500 case 2:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001501 val = cpu_inw(addr);
bellard34405572004-06-08 00:55:58 +00001502 suffix = 'w';
1503 break;
1504 case 4:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001505 val = cpu_inl(addr);
bellard34405572004-06-08 00:55:58 +00001506 suffix = 'l';
1507 break;
1508 }
aliguori376253e2009-03-05 23:01:23 +00001509 monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
1510 suffix, addr, size * 2, val);
bellard34405572004-06-08 00:55:58 +00001511}
bellarda3a91a32004-06-04 11:06:21 +00001512
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001513static void do_ioport_write(Monitor *mon, const QDict *qdict)
Jan Kiszkaf1147842009-07-14 10:20:11 +02001514{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001515 int size = qdict_get_int(qdict, "size");
1516 int addr = qdict_get_int(qdict, "addr");
1517 int val = qdict_get_int(qdict, "val");
1518
Jan Kiszkaf1147842009-07-14 10:20:11 +02001519 addr &= IOPORTS_MASK;
1520
1521 switch (size) {
1522 default:
1523 case 1:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001524 cpu_outb(addr, val);
Jan Kiszkaf1147842009-07-14 10:20:11 +02001525 break;
1526 case 2:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001527 cpu_outw(addr, val);
Jan Kiszkaf1147842009-07-14 10:20:11 +02001528 break;
1529 case 4:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001530 cpu_outl(addr, val);
Jan Kiszkaf1147842009-07-14 10:20:11 +02001531 break;
1532 }
1533}
1534
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001535static void do_boot_set(Monitor *mon, const QDict *qdict)
aurel320ecdffb2008-05-04 20:11:34 +00001536{
1537 int res;
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001538 const char *bootdevice = qdict_get_str(qdict, "bootdevice");
aurel320ecdffb2008-05-04 20:11:34 +00001539
Jan Kiszka76e30d02009-07-02 00:19:02 +02001540 res = qemu_boot_set(bootdevice);
1541 if (res == 0) {
1542 monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
1543 } else if (res > 0) {
1544 monitor_printf(mon, "setting boot device list failed\n");
aurel320ecdffb2008-05-04 20:11:34 +00001545 } else {
aliguori376253e2009-03-05 23:01:23 +00001546 monitor_printf(mon, "no function defined to set boot device list for "
1547 "this architecture\n");
aurel320ecdffb2008-05-04 20:11:34 +00001548 }
1549}
1550
bellardb86bda52004-09-18 19:32:46 +00001551#if defined(TARGET_I386)
Avi Kivitya8170e52012-10-23 12:30:10 +02001552static void print_pte(Monitor *mon, hwaddr addr,
1553 hwaddr pte,
1554 hwaddr mask)
bellardb86bda52004-09-18 19:32:46 +00001555{
Blue Swirld65aaf32010-12-11 18:56:24 +00001556#ifdef TARGET_X86_64
1557 if (addr & (1ULL << 47)) {
1558 addr |= -1LL << 48;
1559 }
1560#endif
1561 monitor_printf(mon, TARGET_FMT_plx ": " TARGET_FMT_plx
1562 " %c%c%c%c%c%c%c%c%c\n",
aliguori376253e2009-03-05 23:01:23 +00001563 addr,
1564 pte & mask,
Blue Swirld65aaf32010-12-11 18:56:24 +00001565 pte & PG_NX_MASK ? 'X' : '-',
aliguori376253e2009-03-05 23:01:23 +00001566 pte & PG_GLOBAL_MASK ? 'G' : '-',
1567 pte & PG_PSE_MASK ? 'P' : '-',
1568 pte & PG_DIRTY_MASK ? 'D' : '-',
1569 pte & PG_ACCESSED_MASK ? 'A' : '-',
1570 pte & PG_PCD_MASK ? 'C' : '-',
1571 pte & PG_PWT_MASK ? 'T' : '-',
1572 pte & PG_USER_MASK ? 'U' : '-',
1573 pte & PG_RW_MASK ? 'W' : '-');
bellardb86bda52004-09-18 19:32:46 +00001574}
1575
Andreas Färber9349b4f2012-03-14 01:38:32 +01001576static void tlb_info_32(Monitor *mon, CPUArchState *env)
bellardb86bda52004-09-18 19:32:46 +00001577{
Austin Clements94ac5cd2011-08-21 14:49:45 -04001578 unsigned int l1, l2;
bellardb86bda52004-09-18 19:32:46 +00001579 uint32_t pgd, pde, pte;
1580
bellardb86bda52004-09-18 19:32:46 +00001581 pgd = env->cr[3] & ~0xfff;
1582 for(l1 = 0; l1 < 1024; l1++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001583 cpu_physical_memory_read(pgd + l1 * 4, &pde, 4);
bellardb86bda52004-09-18 19:32:46 +00001584 pde = le32_to_cpu(pde);
1585 if (pde & PG_PRESENT_MASK) {
1586 if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
Blue Swirld65aaf32010-12-11 18:56:24 +00001587 /* 4M pages */
1588 print_pte(mon, (l1 << 22), pde, ~((1 << 21) - 1));
bellardb86bda52004-09-18 19:32:46 +00001589 } else {
1590 for(l2 = 0; l2 < 1024; l2++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001591 cpu_physical_memory_read((pde & ~0xfff) + l2 * 4, &pte, 4);
bellardb86bda52004-09-18 19:32:46 +00001592 pte = le32_to_cpu(pte);
1593 if (pte & PG_PRESENT_MASK) {
aliguori376253e2009-03-05 23:01:23 +00001594 print_pte(mon, (l1 << 22) + (l2 << 12),
ths5fafdf22007-09-16 21:08:06 +00001595 pte & ~PG_PSE_MASK,
bellardb86bda52004-09-18 19:32:46 +00001596 ~0xfff);
1597 }
1598 }
1599 }
1600 }
1601 }
1602}
1603
Andreas Färber9349b4f2012-03-14 01:38:32 +01001604static void tlb_info_pae32(Monitor *mon, CPUArchState *env)
Blue Swirld65aaf32010-12-11 18:56:24 +00001605{
Austin Clements94ac5cd2011-08-21 14:49:45 -04001606 unsigned int l1, l2, l3;
Blue Swirld65aaf32010-12-11 18:56:24 +00001607 uint64_t pdpe, pde, pte;
1608 uint64_t pdp_addr, pd_addr, pt_addr;
1609
1610 pdp_addr = env->cr[3] & ~0x1f;
1611 for (l1 = 0; l1 < 4; l1++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001612 cpu_physical_memory_read(pdp_addr + l1 * 8, &pdpe, 8);
Blue Swirld65aaf32010-12-11 18:56:24 +00001613 pdpe = le64_to_cpu(pdpe);
1614 if (pdpe & PG_PRESENT_MASK) {
1615 pd_addr = pdpe & 0x3fffffffff000ULL;
1616 for (l2 = 0; l2 < 512; l2++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001617 cpu_physical_memory_read(pd_addr + l2 * 8, &pde, 8);
Blue Swirld65aaf32010-12-11 18:56:24 +00001618 pde = le64_to_cpu(pde);
1619 if (pde & PG_PRESENT_MASK) {
1620 if (pde & PG_PSE_MASK) {
1621 /* 2M pages with PAE, CR4.PSE is ignored */
1622 print_pte(mon, (l1 << 30 ) + (l2 << 21), pde,
Avi Kivitya8170e52012-10-23 12:30:10 +02001623 ~((hwaddr)(1 << 20) - 1));
Blue Swirld65aaf32010-12-11 18:56:24 +00001624 } else {
1625 pt_addr = pde & 0x3fffffffff000ULL;
1626 for (l3 = 0; l3 < 512; l3++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001627 cpu_physical_memory_read(pt_addr + l3 * 8, &pte, 8);
Blue Swirld65aaf32010-12-11 18:56:24 +00001628 pte = le64_to_cpu(pte);
1629 if (pte & PG_PRESENT_MASK) {
1630 print_pte(mon, (l1 << 30 ) + (l2 << 21)
1631 + (l3 << 12),
1632 pte & ~PG_PSE_MASK,
Avi Kivitya8170e52012-10-23 12:30:10 +02001633 ~(hwaddr)0xfff);
Blue Swirld65aaf32010-12-11 18:56:24 +00001634 }
1635 }
1636 }
1637 }
1638 }
1639 }
1640 }
1641}
1642
1643#ifdef TARGET_X86_64
Andreas Färber9349b4f2012-03-14 01:38:32 +01001644static void tlb_info_64(Monitor *mon, CPUArchState *env)
Blue Swirld65aaf32010-12-11 18:56:24 +00001645{
1646 uint64_t l1, l2, l3, l4;
1647 uint64_t pml4e, pdpe, pde, pte;
1648 uint64_t pml4_addr, pdp_addr, pd_addr, pt_addr;
1649
1650 pml4_addr = env->cr[3] & 0x3fffffffff000ULL;
1651 for (l1 = 0; l1 < 512; l1++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001652 cpu_physical_memory_read(pml4_addr + l1 * 8, &pml4e, 8);
Blue Swirld65aaf32010-12-11 18:56:24 +00001653 pml4e = le64_to_cpu(pml4e);
1654 if (pml4e & PG_PRESENT_MASK) {
1655 pdp_addr = pml4e & 0x3fffffffff000ULL;
1656 for (l2 = 0; l2 < 512; l2++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001657 cpu_physical_memory_read(pdp_addr + l2 * 8, &pdpe, 8);
Blue Swirld65aaf32010-12-11 18:56:24 +00001658 pdpe = le64_to_cpu(pdpe);
1659 if (pdpe & PG_PRESENT_MASK) {
1660 if (pdpe & PG_PSE_MASK) {
1661 /* 1G pages, CR4.PSE is ignored */
1662 print_pte(mon, (l1 << 39) + (l2 << 30), pdpe,
1663 0x3ffffc0000000ULL);
1664 } else {
1665 pd_addr = pdpe & 0x3fffffffff000ULL;
1666 for (l3 = 0; l3 < 512; l3++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001667 cpu_physical_memory_read(pd_addr + l3 * 8, &pde, 8);
Blue Swirld65aaf32010-12-11 18:56:24 +00001668 pde = le64_to_cpu(pde);
1669 if (pde & PG_PRESENT_MASK) {
1670 if (pde & PG_PSE_MASK) {
1671 /* 2M pages, CR4.PSE is ignored */
1672 print_pte(mon, (l1 << 39) + (l2 << 30) +
1673 (l3 << 21), pde,
1674 0x3ffffffe00000ULL);
1675 } else {
1676 pt_addr = pde & 0x3fffffffff000ULL;
1677 for (l4 = 0; l4 < 512; l4++) {
1678 cpu_physical_memory_read(pt_addr
1679 + l4 * 8,
Stefan Weilb8b79322011-03-26 21:11:05 +01001680 &pte, 8);
Blue Swirld65aaf32010-12-11 18:56:24 +00001681 pte = le64_to_cpu(pte);
1682 if (pte & PG_PRESENT_MASK) {
1683 print_pte(mon, (l1 << 39) +
1684 (l2 << 30) +
1685 (l3 << 21) + (l4 << 12),
1686 pte & ~PG_PSE_MASK,
1687 0x3fffffffff000ULL);
1688 }
1689 }
1690 }
1691 }
1692 }
1693 }
1694 }
1695 }
1696 }
1697 }
1698}
1699#endif
1700
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08001701static void tlb_info(Monitor *mon, const QDict *qdict)
Blue Swirld65aaf32010-12-11 18:56:24 +00001702{
Andreas Färber9349b4f2012-03-14 01:38:32 +01001703 CPUArchState *env;
Blue Swirld65aaf32010-12-11 18:56:24 +00001704
1705 env = mon_get_cpu();
1706
1707 if (!(env->cr[0] & CR0_PG_MASK)) {
1708 monitor_printf(mon, "PG disabled\n");
1709 return;
1710 }
1711 if (env->cr[4] & CR4_PAE_MASK) {
1712#ifdef TARGET_X86_64
1713 if (env->hflags & HF_LMA_MASK) {
1714 tlb_info_64(mon, env);
1715 } else
1716#endif
1717 {
1718 tlb_info_pae32(mon, env);
1719 }
1720 } else {
1721 tlb_info_32(mon, env);
1722 }
1723}
1724
Avi Kivitya8170e52012-10-23 12:30:10 +02001725static void mem_print(Monitor *mon, hwaddr *pstart,
Blue Swirl1b3cba62010-12-11 18:56:27 +00001726 int *plast_prot,
Avi Kivitya8170e52012-10-23 12:30:10 +02001727 hwaddr end, int prot)
bellardb86bda52004-09-18 19:32:46 +00001728{
bellard9746b152004-11-11 18:30:24 +00001729 int prot1;
1730 prot1 = *plast_prot;
1731 if (prot != prot1) {
bellardb86bda52004-09-18 19:32:46 +00001732 if (*pstart != -1) {
Blue Swirl1b3cba62010-12-11 18:56:27 +00001733 monitor_printf(mon, TARGET_FMT_plx "-" TARGET_FMT_plx " "
1734 TARGET_FMT_plx " %c%c%c\n",
aliguori376253e2009-03-05 23:01:23 +00001735 *pstart, end, end - *pstart,
1736 prot1 & PG_USER_MASK ? 'u' : '-',
1737 'r',
1738 prot1 & PG_RW_MASK ? 'w' : '-');
bellardb86bda52004-09-18 19:32:46 +00001739 }
1740 if (prot != 0)
1741 *pstart = end;
1742 else
1743 *pstart = -1;
1744 *plast_prot = prot;
1745 }
1746}
1747
Andreas Färber9349b4f2012-03-14 01:38:32 +01001748static void mem_info_32(Monitor *mon, CPUArchState *env)
bellardb86bda52004-09-18 19:32:46 +00001749{
Austin Clementsb49ca722011-08-14 23:19:21 -04001750 unsigned int l1, l2;
1751 int prot, last_prot;
Blue Swirl1b3cba62010-12-11 18:56:27 +00001752 uint32_t pgd, pde, pte;
Avi Kivitya8170e52012-10-23 12:30:10 +02001753 hwaddr start, end;
bellardb86bda52004-09-18 19:32:46 +00001754
bellardb86bda52004-09-18 19:32:46 +00001755 pgd = env->cr[3] & ~0xfff;
1756 last_prot = 0;
1757 start = -1;
1758 for(l1 = 0; l1 < 1024; l1++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001759 cpu_physical_memory_read(pgd + l1 * 4, &pde, 4);
bellardb86bda52004-09-18 19:32:46 +00001760 pde = le32_to_cpu(pde);
1761 end = l1 << 22;
1762 if (pde & PG_PRESENT_MASK) {
1763 if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
1764 prot = pde & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
aliguori376253e2009-03-05 23:01:23 +00001765 mem_print(mon, &start, &last_prot, end, prot);
bellardb86bda52004-09-18 19:32:46 +00001766 } else {
1767 for(l2 = 0; l2 < 1024; l2++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001768 cpu_physical_memory_read((pde & ~0xfff) + l2 * 4, &pte, 4);
bellardb86bda52004-09-18 19:32:46 +00001769 pte = le32_to_cpu(pte);
1770 end = (l1 << 22) + (l2 << 12);
1771 if (pte & PG_PRESENT_MASK) {
Austin Clementsc76c8412011-08-14 23:22:28 -04001772 prot = pte & pde &
1773 (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
bellardb86bda52004-09-18 19:32:46 +00001774 } else {
1775 prot = 0;
1776 }
aliguori376253e2009-03-05 23:01:23 +00001777 mem_print(mon, &start, &last_prot, end, prot);
bellardb86bda52004-09-18 19:32:46 +00001778 }
1779 }
1780 } else {
1781 prot = 0;
aliguori376253e2009-03-05 23:01:23 +00001782 mem_print(mon, &start, &last_prot, end, prot);
bellardb86bda52004-09-18 19:32:46 +00001783 }
1784 }
Austin Clements8a94b8ca2011-08-14 23:22:04 -04001785 /* Flush last range */
Avi Kivitya8170e52012-10-23 12:30:10 +02001786 mem_print(mon, &start, &last_prot, (hwaddr)1 << 32, 0);
bellardb86bda52004-09-18 19:32:46 +00001787}
Blue Swirl1b3cba62010-12-11 18:56:27 +00001788
Andreas Färber9349b4f2012-03-14 01:38:32 +01001789static void mem_info_pae32(Monitor *mon, CPUArchState *env)
Blue Swirl1b3cba62010-12-11 18:56:27 +00001790{
Austin Clementsb49ca722011-08-14 23:19:21 -04001791 unsigned int l1, l2, l3;
1792 int prot, last_prot;
Blue Swirl1b3cba62010-12-11 18:56:27 +00001793 uint64_t pdpe, pde, pte;
1794 uint64_t pdp_addr, pd_addr, pt_addr;
Avi Kivitya8170e52012-10-23 12:30:10 +02001795 hwaddr start, end;
Blue Swirl1b3cba62010-12-11 18:56:27 +00001796
1797 pdp_addr = env->cr[3] & ~0x1f;
1798 last_prot = 0;
1799 start = -1;
1800 for (l1 = 0; l1 < 4; l1++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001801 cpu_physical_memory_read(pdp_addr + l1 * 8, &pdpe, 8);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001802 pdpe = le64_to_cpu(pdpe);
1803 end = l1 << 30;
1804 if (pdpe & PG_PRESENT_MASK) {
1805 pd_addr = pdpe & 0x3fffffffff000ULL;
1806 for (l2 = 0; l2 < 512; l2++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001807 cpu_physical_memory_read(pd_addr + l2 * 8, &pde, 8);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001808 pde = le64_to_cpu(pde);
1809 end = (l1 << 30) + (l2 << 21);
1810 if (pde & PG_PRESENT_MASK) {
1811 if (pde & PG_PSE_MASK) {
1812 prot = pde & (PG_USER_MASK | PG_RW_MASK |
1813 PG_PRESENT_MASK);
1814 mem_print(mon, &start, &last_prot, end, prot);
1815 } else {
1816 pt_addr = pde & 0x3fffffffff000ULL;
1817 for (l3 = 0; l3 < 512; l3++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001818 cpu_physical_memory_read(pt_addr + l3 * 8, &pte, 8);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001819 pte = le64_to_cpu(pte);
1820 end = (l1 << 30) + (l2 << 21) + (l3 << 12);
1821 if (pte & PG_PRESENT_MASK) {
Austin Clementsc76c8412011-08-14 23:22:28 -04001822 prot = pte & pde & (PG_USER_MASK | PG_RW_MASK |
1823 PG_PRESENT_MASK);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001824 } else {
1825 prot = 0;
1826 }
1827 mem_print(mon, &start, &last_prot, end, prot);
1828 }
1829 }
1830 } else {
1831 prot = 0;
1832 mem_print(mon, &start, &last_prot, end, prot);
1833 }
1834 }
1835 } else {
1836 prot = 0;
1837 mem_print(mon, &start, &last_prot, end, prot);
1838 }
1839 }
Austin Clements8a94b8ca2011-08-14 23:22:04 -04001840 /* Flush last range */
Avi Kivitya8170e52012-10-23 12:30:10 +02001841 mem_print(mon, &start, &last_prot, (hwaddr)1 << 32, 0);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001842}
1843
1844
1845#ifdef TARGET_X86_64
Andreas Färber9349b4f2012-03-14 01:38:32 +01001846static void mem_info_64(Monitor *mon, CPUArchState *env)
Blue Swirl1b3cba62010-12-11 18:56:27 +00001847{
1848 int prot, last_prot;
1849 uint64_t l1, l2, l3, l4;
1850 uint64_t pml4e, pdpe, pde, pte;
1851 uint64_t pml4_addr, pdp_addr, pd_addr, pt_addr, start, end;
1852
1853 pml4_addr = env->cr[3] & 0x3fffffffff000ULL;
1854 last_prot = 0;
1855 start = -1;
1856 for (l1 = 0; l1 < 512; l1++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001857 cpu_physical_memory_read(pml4_addr + l1 * 8, &pml4e, 8);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001858 pml4e = le64_to_cpu(pml4e);
1859 end = l1 << 39;
1860 if (pml4e & PG_PRESENT_MASK) {
1861 pdp_addr = pml4e & 0x3fffffffff000ULL;
1862 for (l2 = 0; l2 < 512; l2++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001863 cpu_physical_memory_read(pdp_addr + l2 * 8, &pdpe, 8);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001864 pdpe = le64_to_cpu(pdpe);
1865 end = (l1 << 39) + (l2 << 30);
1866 if (pdpe & PG_PRESENT_MASK) {
1867 if (pdpe & PG_PSE_MASK) {
Blue Swirl2d5b5072011-01-15 08:31:00 +00001868 prot = pdpe & (PG_USER_MASK | PG_RW_MASK |
1869 PG_PRESENT_MASK);
Austin Clementsc76c8412011-08-14 23:22:28 -04001870 prot &= pml4e;
Blue Swirl1b3cba62010-12-11 18:56:27 +00001871 mem_print(mon, &start, &last_prot, end, prot);
1872 } else {
1873 pd_addr = pdpe & 0x3fffffffff000ULL;
1874 for (l3 = 0; l3 < 512; l3++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001875 cpu_physical_memory_read(pd_addr + l3 * 8, &pde, 8);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001876 pde = le64_to_cpu(pde);
1877 end = (l1 << 39) + (l2 << 30) + (l3 << 21);
1878 if (pde & PG_PRESENT_MASK) {
1879 if (pde & PG_PSE_MASK) {
1880 prot = pde & (PG_USER_MASK | PG_RW_MASK |
1881 PG_PRESENT_MASK);
Austin Clementsc76c8412011-08-14 23:22:28 -04001882 prot &= pml4e & pdpe;
Blue Swirl1b3cba62010-12-11 18:56:27 +00001883 mem_print(mon, &start, &last_prot, end, prot);
1884 } else {
1885 pt_addr = pde & 0x3fffffffff000ULL;
1886 for (l4 = 0; l4 < 512; l4++) {
1887 cpu_physical_memory_read(pt_addr
1888 + l4 * 8,
Stefan Weilb8b79322011-03-26 21:11:05 +01001889 &pte, 8);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001890 pte = le64_to_cpu(pte);
1891 end = (l1 << 39) + (l2 << 30) +
1892 (l3 << 21) + (l4 << 12);
1893 if (pte & PG_PRESENT_MASK) {
1894 prot = pte & (PG_USER_MASK | PG_RW_MASK |
1895 PG_PRESENT_MASK);
Austin Clementsc76c8412011-08-14 23:22:28 -04001896 prot &= pml4e & pdpe & pde;
Blue Swirl1b3cba62010-12-11 18:56:27 +00001897 } else {
1898 prot = 0;
1899 }
1900 mem_print(mon, &start, &last_prot, end, prot);
1901 }
1902 }
1903 } else {
1904 prot = 0;
1905 mem_print(mon, &start, &last_prot, end, prot);
1906 }
1907 }
1908 }
1909 } else {
1910 prot = 0;
1911 mem_print(mon, &start, &last_prot, end, prot);
1912 }
1913 }
1914 } else {
1915 prot = 0;
1916 mem_print(mon, &start, &last_prot, end, prot);
1917 }
1918 }
Austin Clements8a94b8ca2011-08-14 23:22:04 -04001919 /* Flush last range */
Avi Kivitya8170e52012-10-23 12:30:10 +02001920 mem_print(mon, &start, &last_prot, (hwaddr)1 << 48, 0);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001921}
1922#endif
1923
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08001924static void mem_info(Monitor *mon, const QDict *qdict)
Blue Swirl1b3cba62010-12-11 18:56:27 +00001925{
Andreas Färber9349b4f2012-03-14 01:38:32 +01001926 CPUArchState *env;
Blue Swirl1b3cba62010-12-11 18:56:27 +00001927
1928 env = mon_get_cpu();
1929
1930 if (!(env->cr[0] & CR0_PG_MASK)) {
1931 monitor_printf(mon, "PG disabled\n");
1932 return;
1933 }
1934 if (env->cr[4] & CR4_PAE_MASK) {
1935#ifdef TARGET_X86_64
1936 if (env->hflags & HF_LMA_MASK) {
1937 mem_info_64(mon, env);
1938 } else
1939#endif
1940 {
1941 mem_info_pae32(mon, env);
1942 }
1943 } else {
1944 mem_info_32(mon, env);
1945 }
1946}
bellardb86bda52004-09-18 19:32:46 +00001947#endif
1948
aurel327c664e22009-03-03 06:12:22 +00001949#if defined(TARGET_SH4)
1950
aliguori376253e2009-03-05 23:01:23 +00001951static void print_tlb(Monitor *mon, int idx, tlb_t *tlb)
aurel327c664e22009-03-03 06:12:22 +00001952{
aliguori376253e2009-03-05 23:01:23 +00001953 monitor_printf(mon, " tlb%i:\t"
1954 "asid=%hhu vpn=%x\tppn=%x\tsz=%hhu size=%u\t"
1955 "v=%hhu shared=%hhu cached=%hhu prot=%hhu "
1956 "dirty=%hhu writethrough=%hhu\n",
1957 idx,
1958 tlb->asid, tlb->vpn, tlb->ppn, tlb->sz, tlb->size,
1959 tlb->v, tlb->sh, tlb->c, tlb->pr,
1960 tlb->d, tlb->wt);
aurel327c664e22009-03-03 06:12:22 +00001961}
1962
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08001963static void tlb_info(Monitor *mon, const QDict *qdict)
aurel327c664e22009-03-03 06:12:22 +00001964{
Andreas Färber9349b4f2012-03-14 01:38:32 +01001965 CPUArchState *env = mon_get_cpu();
aurel327c664e22009-03-03 06:12:22 +00001966 int i;
1967
aliguori376253e2009-03-05 23:01:23 +00001968 monitor_printf (mon, "ITLB:\n");
aurel327c664e22009-03-03 06:12:22 +00001969 for (i = 0 ; i < ITLB_SIZE ; i++)
aliguori376253e2009-03-05 23:01:23 +00001970 print_tlb (mon, i, &env->itlb[i]);
1971 monitor_printf (mon, "UTLB:\n");
aurel327c664e22009-03-03 06:12:22 +00001972 for (i = 0 ; i < UTLB_SIZE ; i++)
aliguori376253e2009-03-05 23:01:23 +00001973 print_tlb (mon, i, &env->utlb[i]);
aurel327c664e22009-03-03 06:12:22 +00001974}
1975
1976#endif
1977
Max Filippov692f7372012-01-07 20:02:40 +04001978#if defined(TARGET_SPARC) || defined(TARGET_PPC) || defined(TARGET_XTENSA)
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08001979static void tlb_info(Monitor *mon, const QDict *qdict)
Blue Swirld41160a2010-12-19 13:42:56 +00001980{
Andreas Färber9349b4f2012-03-14 01:38:32 +01001981 CPUArchState *env1 = mon_get_cpu();
Blue Swirld41160a2010-12-19 13:42:56 +00001982
1983 dump_mmu((FILE*)mon, (fprintf_function)monitor_printf, env1);
1984}
1985#endif
1986
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08001987static void do_info_mtree(Monitor *mon, const QDict *qdict)
Blue Swirl314e2982011-09-11 20:22:05 +00001988{
1989 mtree_info((fprintf_function)monitor_printf, mon);
1990}
1991
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08001992static void do_info_numa(Monitor *mon, const QDict *qdict)
aliguori030ea372009-04-21 22:30:47 +00001993{
aliguorib28b6232009-04-22 20:20:29 +00001994 int i;
Andreas Färber1b1ed8d2012-12-17 04:22:03 +01001995 CPUState *cpu;
aliguori030ea372009-04-21 22:30:47 +00001996
1997 monitor_printf(mon, "%d nodes\n", nb_numa_nodes);
1998 for (i = 0; i < nb_numa_nodes; i++) {
1999 monitor_printf(mon, "node %d cpus:", i);
Andreas Färberbdc44642013-06-24 23:50:24 +02002000 CPU_FOREACH(cpu) {
Andreas Färber1b1ed8d2012-12-17 04:22:03 +01002001 if (cpu->numa_node == i) {
Andreas Färber55e5c282012-12-17 06:18:02 +01002002 monitor_printf(mon, " %d", cpu->cpu_index);
aliguori030ea372009-04-21 22:30:47 +00002003 }
2004 }
2005 monitor_printf(mon, "\n");
2006 monitor_printf(mon, "node %d size: %" PRId64 " MB\n", i,
2007 node_mem[i] >> 20);
2008 }
2009}
2010
bellard5f1ce942006-02-08 22:40:15 +00002011#ifdef CONFIG_PROFILER
2012
Aurelien Jarnoe9a66252009-09-30 14:09:52 +02002013int64_t qemu_time;
2014int64_t dev_time;
2015
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08002016static void do_info_profile(Monitor *mon, const QDict *qdict)
bellard5f1ce942006-02-08 22:40:15 +00002017{
2018 int64_t total;
2019 total = qemu_time;
2020 if (total == 0)
2021 total = 1;
aliguori376253e2009-03-05 23:01:23 +00002022 monitor_printf(mon, "async time %" PRId64 " (%0.3f)\n",
Juan Quintela6ee093c2009-09-10 03:04:26 +02002023 dev_time, dev_time / (double)get_ticks_per_sec());
aliguori376253e2009-03-05 23:01:23 +00002024 monitor_printf(mon, "qemu time %" PRId64 " (%0.3f)\n",
Juan Quintela6ee093c2009-09-10 03:04:26 +02002025 qemu_time, qemu_time / (double)get_ticks_per_sec());
bellard5f1ce942006-02-08 22:40:15 +00002026 qemu_time = 0;
bellard5f1ce942006-02-08 22:40:15 +00002027 dev_time = 0;
bellard5f1ce942006-02-08 22:40:15 +00002028}
2029#else
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08002030static void do_info_profile(Monitor *mon, const QDict *qdict)
bellard5f1ce942006-02-08 22:40:15 +00002031{
aliguori376253e2009-03-05 23:01:23 +00002032 monitor_printf(mon, "Internal profiler not compiled\n");
bellard5f1ce942006-02-08 22:40:15 +00002033}
2034#endif
2035
bellardec36b692006-07-16 18:57:03 +00002036/* Capture support */
Blue Swirl72cf2d42009-09-12 07:36:22 +00002037static QLIST_HEAD (capture_list_head, CaptureState) capture_head;
bellardec36b692006-07-16 18:57:03 +00002038
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08002039static void do_info_capture(Monitor *mon, const QDict *qdict)
bellardec36b692006-07-16 18:57:03 +00002040{
2041 int i;
2042 CaptureState *s;
2043
2044 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
aliguori376253e2009-03-05 23:01:23 +00002045 monitor_printf(mon, "[%d]: ", i);
bellardec36b692006-07-16 18:57:03 +00002046 s->ops.info (s->opaque);
2047 }
2048}
2049
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002050static void do_stop_capture(Monitor *mon, const QDict *qdict)
bellardec36b692006-07-16 18:57:03 +00002051{
2052 int i;
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002053 int n = qdict_get_int(qdict, "n");
bellardec36b692006-07-16 18:57:03 +00002054 CaptureState *s;
2055
2056 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
2057 if (i == n) {
2058 s->ops.destroy (s->opaque);
Blue Swirl72cf2d42009-09-12 07:36:22 +00002059 QLIST_REMOVE (s, entries);
Anthony Liguori7267c092011-08-20 22:09:37 -05002060 g_free (s);
bellardec36b692006-07-16 18:57:03 +00002061 return;
2062 }
2063 }
2064}
2065
Luiz Capitulinoc1925482009-08-28 15:27:19 -03002066static void do_wav_capture(Monitor *mon, const QDict *qdict)
bellardec36b692006-07-16 18:57:03 +00002067{
Luiz Capitulinoc1925482009-08-28 15:27:19 -03002068 const char *path = qdict_get_str(qdict, "path");
2069 int has_freq = qdict_haskey(qdict, "freq");
2070 int freq = qdict_get_try_int(qdict, "freq", -1);
2071 int has_bits = qdict_haskey(qdict, "bits");
2072 int bits = qdict_get_try_int(qdict, "bits", -1);
2073 int has_channels = qdict_haskey(qdict, "nchannels");
2074 int nchannels = qdict_get_try_int(qdict, "nchannels", -1);
bellardec36b692006-07-16 18:57:03 +00002075 CaptureState *s;
2076
Anthony Liguori7267c092011-08-20 22:09:37 -05002077 s = g_malloc0 (sizeof (*s));
bellardec36b692006-07-16 18:57:03 +00002078
2079 freq = has_freq ? freq : 44100;
2080 bits = has_bits ? bits : 16;
2081 nchannels = has_channels ? nchannels : 2;
2082
2083 if (wav_start_capture (s, path, freq, bits, nchannels)) {
Isaku Yamahatad00b2612011-01-21 19:53:55 +09002084 monitor_printf(mon, "Failed to add wave capture\n");
Anthony Liguori7267c092011-08-20 22:09:37 -05002085 g_free (s);
Isaku Yamahatad00b2612011-01-21 19:53:55 +09002086 return;
bellardec36b692006-07-16 18:57:03 +00002087 }
Blue Swirl72cf2d42009-09-12 07:36:22 +00002088 QLIST_INSERT_HEAD (&capture_head, s, entries);
bellardec36b692006-07-16 18:57:03 +00002089}
bellardec36b692006-07-16 18:57:03 +00002090
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002091static qemu_acl *find_acl(Monitor *mon, const char *name)
aliguori76655d62009-03-06 20:27:37 +00002092{
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002093 qemu_acl *acl = qemu_acl_find(name);
aliguori76655d62009-03-06 20:27:37 +00002094
aliguori76655d62009-03-06 20:27:37 +00002095 if (!acl) {
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002096 monitor_printf(mon, "acl: unknown list '%s'\n", name);
aliguori76655d62009-03-06 20:27:37 +00002097 }
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002098 return acl;
2099}
aliguori76655d62009-03-06 20:27:37 +00002100
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002101static void do_acl_show(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002102{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002103 const char *aclname = qdict_get_str(qdict, "aclname");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002104 qemu_acl *acl = find_acl(mon, aclname);
2105 qemu_acl_entry *entry;
2106 int i = 0;
2107
2108 if (acl) {
aliguori28a76be2009-03-06 20:27:40 +00002109 monitor_printf(mon, "policy: %s\n",
aliguori76655d62009-03-06 20:27:37 +00002110 acl->defaultDeny ? "deny" : "allow");
Blue Swirl72cf2d42009-09-12 07:36:22 +00002111 QTAILQ_FOREACH(entry, &acl->entries, next) {
aliguori28a76be2009-03-06 20:27:40 +00002112 i++;
2113 monitor_printf(mon, "%d: %s %s\n", i,
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002114 entry->deny ? "deny" : "allow", entry->match);
aliguori28a76be2009-03-06 20:27:40 +00002115 }
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002116 }
2117}
2118
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002119static void do_acl_reset(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002120{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002121 const char *aclname = qdict_get_str(qdict, "aclname");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002122 qemu_acl *acl = find_acl(mon, aclname);
2123
2124 if (acl) {
aliguori28a76be2009-03-06 20:27:40 +00002125 qemu_acl_reset(acl);
2126 monitor_printf(mon, "acl: removed all rules\n");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002127 }
2128}
aliguori76655d62009-03-06 20:27:37 +00002129
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03002130static void do_acl_policy(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002131{
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03002132 const char *aclname = qdict_get_str(qdict, "aclname");
2133 const char *policy = qdict_get_str(qdict, "policy");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002134 qemu_acl *acl = find_acl(mon, aclname);
2135
2136 if (acl) {
2137 if (strcmp(policy, "allow") == 0) {
aliguori28a76be2009-03-06 20:27:40 +00002138 acl->defaultDeny = 0;
2139 monitor_printf(mon, "acl: policy set to 'allow'\n");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002140 } else if (strcmp(policy, "deny") == 0) {
aliguori28a76be2009-03-06 20:27:40 +00002141 acl->defaultDeny = 1;
2142 monitor_printf(mon, "acl: policy set to 'deny'\n");
2143 } else {
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002144 monitor_printf(mon, "acl: unknown policy '%s', "
2145 "expected 'deny' or 'allow'\n", policy);
aliguori28a76be2009-03-06 20:27:40 +00002146 }
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002147 }
2148}
aliguori76655d62009-03-06 20:27:37 +00002149
Luiz Capitulino1bd14422009-08-28 15:27:17 -03002150static void do_acl_add(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002151{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03002152 const char *aclname = qdict_get_str(qdict, "aclname");
2153 const char *match = qdict_get_str(qdict, "match");
2154 const char *policy = qdict_get_str(qdict, "policy");
2155 int has_index = qdict_haskey(qdict, "index");
2156 int index = qdict_get_try_int(qdict, "index", -1);
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002157 qemu_acl *acl = find_acl(mon, aclname);
2158 int deny, ret;
2159
2160 if (acl) {
2161 if (strcmp(policy, "allow") == 0) {
2162 deny = 0;
2163 } else if (strcmp(policy, "deny") == 0) {
2164 deny = 1;
2165 } else {
2166 monitor_printf(mon, "acl: unknown policy '%s', "
2167 "expected 'deny' or 'allow'\n", policy);
aliguori28a76be2009-03-06 20:27:40 +00002168 return;
2169 }
aliguori28a76be2009-03-06 20:27:40 +00002170 if (has_index)
2171 ret = qemu_acl_insert(acl, deny, match, index);
2172 else
2173 ret = qemu_acl_append(acl, deny, match);
2174 if (ret < 0)
2175 monitor_printf(mon, "acl: unable to add acl entry\n");
2176 else
2177 monitor_printf(mon, "acl: added rule at position %d\n", ret);
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002178 }
2179}
aliguori76655d62009-03-06 20:27:37 +00002180
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03002181static void do_acl_remove(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002182{
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03002183 const char *aclname = qdict_get_str(qdict, "aclname");
2184 const char *match = qdict_get_str(qdict, "match");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002185 qemu_acl *acl = find_acl(mon, aclname);
2186 int ret;
aliguori76655d62009-03-06 20:27:37 +00002187
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002188 if (acl) {
aliguori28a76be2009-03-06 20:27:40 +00002189 ret = qemu_acl_remove(acl, match);
2190 if (ret < 0)
2191 monitor_printf(mon, "acl: no matching acl entry\n");
2192 else
2193 monitor_printf(mon, "acl: removed rule at position %d\n", ret);
aliguori76655d62009-03-06 20:27:37 +00002194 }
2195}
2196
Huang Ying79c4f6b2009-06-23 10:05:14 +08002197#if defined(TARGET_I386)
Luiz Capitulino37b7ad42009-08-28 15:27:21 -03002198static void do_inject_mce(Monitor *mon, const QDict *qdict)
Huang Ying79c4f6b2009-06-23 10:05:14 +08002199{
Andreas Färber8c5cf3b2012-05-03 15:22:54 +02002200 X86CPU *cpu;
Andreas Färber55e5c282012-12-17 06:18:02 +01002201 CPUState *cs;
Luiz Capitulino37b7ad42009-08-28 15:27:21 -03002202 int cpu_index = qdict_get_int(qdict, "cpu_index");
2203 int bank = qdict_get_int(qdict, "bank");
2204 uint64_t status = qdict_get_int(qdict, "status");
2205 uint64_t mcg_status = qdict_get_int(qdict, "mcg_status");
2206 uint64_t addr = qdict_get_int(qdict, "addr");
2207 uint64_t misc = qdict_get_int(qdict, "misc");
Jan Kiszka747461c2011-03-02 08:56:10 +01002208 int flags = MCE_INJECT_UNCOND_AO;
Huang Ying79c4f6b2009-06-23 10:05:14 +08002209
Jan Kiszka747461c2011-03-02 08:56:10 +01002210 if (qdict_get_try_bool(qdict, "broadcast", 0)) {
2211 flags |= MCE_INJECT_BROADCAST;
2212 }
Andreas Färberc51a9442013-05-17 16:57:52 +02002213 cs = qemu_get_cpu(cpu_index);
2214 if (cs != NULL) {
2215 cpu = X86_CPU(cs);
2216 cpu_x86_inject_mce(mon, cpu, bank, status, mcg_status, addr, misc,
2217 flags);
Jin Dongming31ce5e02010-12-10 17:21:02 +09002218 }
Huang Ying79c4f6b2009-06-23 10:05:14 +08002219}
2220#endif
2221
Corey Bryant208c9d12012-06-22 14:36:09 -04002222void qmp_getfd(const char *fdname, Error **errp)
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002223{
Anthony Liguoric227f092009-10-01 16:12:16 -05002224 mon_fd_t *monfd;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002225 int fd;
2226
Corey Bryant208c9d12012-06-22 14:36:09 -04002227 fd = qemu_chr_fe_get_msgfd(cur_mon->chr);
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002228 if (fd == -1) {
Corey Bryant208c9d12012-06-22 14:36:09 -04002229 error_set(errp, QERR_FD_NOT_SUPPLIED);
2230 return;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002231 }
2232
2233 if (qemu_isdigit(fdname[0])) {
Corey Bryant208c9d12012-06-22 14:36:09 -04002234 error_set(errp, QERR_INVALID_PARAMETER_VALUE, "fdname",
2235 "a name not starting with a digit");
2236 return;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002237 }
2238
Corey Bryant208c9d12012-06-22 14:36:09 -04002239 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002240 if (strcmp(monfd->name, fdname) != 0) {
2241 continue;
2242 }
2243
2244 close(monfd->fd);
2245 monfd->fd = fd;
Corey Bryant208c9d12012-06-22 14:36:09 -04002246 return;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002247 }
2248
Anthony Liguori7267c092011-08-20 22:09:37 -05002249 monfd = g_malloc0(sizeof(mon_fd_t));
2250 monfd->name = g_strdup(fdname);
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002251 monfd->fd = fd;
2252
Corey Bryant208c9d12012-06-22 14:36:09 -04002253 QLIST_INSERT_HEAD(&cur_mon->fds, monfd, next);
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002254}
2255
Corey Bryant208c9d12012-06-22 14:36:09 -04002256void qmp_closefd(const char *fdname, Error **errp)
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002257{
Anthony Liguoric227f092009-10-01 16:12:16 -05002258 mon_fd_t *monfd;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002259
Corey Bryant208c9d12012-06-22 14:36:09 -04002260 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002261 if (strcmp(monfd->name, fdname) != 0) {
2262 continue;
2263 }
2264
Blue Swirl72cf2d42009-09-12 07:36:22 +00002265 QLIST_REMOVE(monfd, next);
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002266 close(monfd->fd);
Anthony Liguori7267c092011-08-20 22:09:37 -05002267 g_free(monfd->name);
2268 g_free(monfd);
Corey Bryant208c9d12012-06-22 14:36:09 -04002269 return;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002270 }
2271
Corey Bryant208c9d12012-06-22 14:36:09 -04002272 error_set(errp, QERR_FD_NOT_FOUND, fdname);
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002273}
2274
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002275static void do_loadvm(Monitor *mon, const QDict *qdict)
Juan Quintelac8d41b22009-08-20 19:42:21 +02002276{
Luiz Capitulino13548692011-07-29 15:36:43 -03002277 int saved_vm_running = runstate_is_running();
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002278 const char *name = qdict_get_str(qdict, "name");
Juan Quintelac8d41b22009-08-20 19:42:21 +02002279
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03002280 vm_stop(RUN_STATE_RESTORE_VM);
Juan Quintelac8d41b22009-08-20 19:42:21 +02002281
Miguel Di Ciurcio Filhof0aa7a82010-07-19 15:25:01 -03002282 if (load_vmstate(name) == 0 && saved_vm_running) {
Juan Quintelac8d41b22009-08-20 19:42:21 +02002283 vm_start();
Miguel Di Ciurcio Filhof0aa7a82010-07-19 15:25:01 -03002284 }
Juan Quintelac8d41b22009-08-20 19:42:21 +02002285}
2286
Paolo Bonzinia9940fc2012-09-20 16:50:32 +02002287int monitor_get_fd(Monitor *mon, const char *fdname, Error **errp)
Mark McLoughlin7768e042009-07-22 09:11:41 +01002288{
Anthony Liguoric227f092009-10-01 16:12:16 -05002289 mon_fd_t *monfd;
Mark McLoughlin7768e042009-07-22 09:11:41 +01002290
Blue Swirl72cf2d42009-09-12 07:36:22 +00002291 QLIST_FOREACH(monfd, &mon->fds, next) {
Mark McLoughlin7768e042009-07-22 09:11:41 +01002292 int fd;
2293
2294 if (strcmp(monfd->name, fdname) != 0) {
2295 continue;
2296 }
2297
2298 fd = monfd->fd;
2299
2300 /* caller takes ownership of fd */
Blue Swirl72cf2d42009-09-12 07:36:22 +00002301 QLIST_REMOVE(monfd, next);
Anthony Liguori7267c092011-08-20 22:09:37 -05002302 g_free(monfd->name);
2303 g_free(monfd);
Mark McLoughlin7768e042009-07-22 09:11:41 +01002304
2305 return fd;
2306 }
2307
Paolo Bonzinia9940fc2012-09-20 16:50:32 +02002308 error_setg(errp, "File descriptor named '%s' has not been found", fdname);
Mark McLoughlin7768e042009-07-22 09:11:41 +01002309 return -1;
2310}
2311
Corey Bryantba1c0482012-08-14 16:43:43 -04002312static void monitor_fdset_cleanup(MonFdset *mon_fdset)
2313{
2314 MonFdsetFd *mon_fdset_fd;
2315 MonFdsetFd *mon_fdset_fd_next;
2316
2317 QLIST_FOREACH_SAFE(mon_fdset_fd, &mon_fdset->fds, next, mon_fdset_fd_next) {
Corey Bryantebe52b52012-10-18 15:19:33 -04002318 if ((mon_fdset_fd->removed ||
2319 (QLIST_EMPTY(&mon_fdset->dup_fds) && mon_refcount == 0)) &&
2320 runstate_is_running()) {
Corey Bryantba1c0482012-08-14 16:43:43 -04002321 close(mon_fdset_fd->fd);
2322 g_free(mon_fdset_fd->opaque);
2323 QLIST_REMOVE(mon_fdset_fd, next);
2324 g_free(mon_fdset_fd);
2325 }
2326 }
2327
Corey Bryantadb696f2012-08-14 16:43:47 -04002328 if (QLIST_EMPTY(&mon_fdset->fds) && QLIST_EMPTY(&mon_fdset->dup_fds)) {
Corey Bryantba1c0482012-08-14 16:43:43 -04002329 QLIST_REMOVE(mon_fdset, next);
2330 g_free(mon_fdset);
2331 }
2332}
2333
Corey Bryantefb87c12012-08-14 16:43:48 -04002334static void monitor_fdsets_cleanup(void)
2335{
2336 MonFdset *mon_fdset;
2337 MonFdset *mon_fdset_next;
2338
2339 QLIST_FOREACH_SAFE(mon_fdset, &mon_fdsets, next, mon_fdset_next) {
2340 monitor_fdset_cleanup(mon_fdset);
2341 }
2342}
2343
Corey Bryantba1c0482012-08-14 16:43:43 -04002344AddfdInfo *qmp_add_fd(bool has_fdset_id, int64_t fdset_id, bool has_opaque,
2345 const char *opaque, Error **errp)
2346{
2347 int fd;
2348 Monitor *mon = cur_mon;
Corey Bryantba1c0482012-08-14 16:43:43 -04002349 AddfdInfo *fdinfo;
2350
2351 fd = qemu_chr_fe_get_msgfd(mon->chr);
2352 if (fd == -1) {
2353 error_set(errp, QERR_FD_NOT_SUPPLIED);
2354 goto error;
2355 }
2356
Corey Bryante446f702012-10-18 15:19:32 -04002357 fdinfo = monitor_fdset_add_fd(fd, has_fdset_id, fdset_id,
2358 has_opaque, opaque, errp);
2359 if (fdinfo) {
2360 return fdinfo;
Corey Bryant9ac54af2012-10-18 15:19:31 -04002361 }
2362
Corey Bryantba1c0482012-08-14 16:43:43 -04002363error:
2364 if (fd != -1) {
2365 close(fd);
2366 }
2367 return NULL;
2368}
2369
2370void qmp_remove_fd(int64_t fdset_id, bool has_fd, int64_t fd, Error **errp)
2371{
2372 MonFdset *mon_fdset;
2373 MonFdsetFd *mon_fdset_fd;
2374 char fd_str[60];
2375
2376 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2377 if (mon_fdset->id != fdset_id) {
2378 continue;
2379 }
2380 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2381 if (has_fd) {
2382 if (mon_fdset_fd->fd != fd) {
2383 continue;
2384 }
2385 mon_fdset_fd->removed = true;
2386 break;
2387 } else {
2388 mon_fdset_fd->removed = true;
2389 }
2390 }
2391 if (has_fd && !mon_fdset_fd) {
2392 goto error;
2393 }
2394 monitor_fdset_cleanup(mon_fdset);
2395 return;
2396 }
2397
2398error:
2399 if (has_fd) {
2400 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64 ", fd:%" PRId64,
2401 fdset_id, fd);
2402 } else {
2403 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64, fdset_id);
2404 }
2405 error_set(errp, QERR_FD_NOT_FOUND, fd_str);
2406}
2407
2408FdsetInfoList *qmp_query_fdsets(Error **errp)
2409{
2410 MonFdset *mon_fdset;
2411 MonFdsetFd *mon_fdset_fd;
2412 FdsetInfoList *fdset_list = NULL;
2413
2414 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2415 FdsetInfoList *fdset_info = g_malloc0(sizeof(*fdset_info));
2416 FdsetFdInfoList *fdsetfd_list = NULL;
2417
2418 fdset_info->value = g_malloc0(sizeof(*fdset_info->value));
2419 fdset_info->value->fdset_id = mon_fdset->id;
2420
2421 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2422 FdsetFdInfoList *fdsetfd_info;
2423
2424 fdsetfd_info = g_malloc0(sizeof(*fdsetfd_info));
2425 fdsetfd_info->value = g_malloc0(sizeof(*fdsetfd_info->value));
2426 fdsetfd_info->value->fd = mon_fdset_fd->fd;
2427 if (mon_fdset_fd->opaque) {
2428 fdsetfd_info->value->has_opaque = true;
2429 fdsetfd_info->value->opaque = g_strdup(mon_fdset_fd->opaque);
2430 } else {
2431 fdsetfd_info->value->has_opaque = false;
2432 }
2433
2434 fdsetfd_info->next = fdsetfd_list;
2435 fdsetfd_list = fdsetfd_info;
2436 }
2437
2438 fdset_info->value->fds = fdsetfd_list;
2439
2440 fdset_info->next = fdset_list;
2441 fdset_list = fdset_info;
2442 }
2443
2444 return fdset_list;
2445}
2446
Corey Bryante446f702012-10-18 15:19:32 -04002447AddfdInfo *monitor_fdset_add_fd(int fd, bool has_fdset_id, int64_t fdset_id,
2448 bool has_opaque, const char *opaque,
2449 Error **errp)
2450{
2451 MonFdset *mon_fdset = NULL;
2452 MonFdsetFd *mon_fdset_fd;
2453 AddfdInfo *fdinfo;
2454
2455 if (has_fdset_id) {
2456 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2457 /* Break if match found or match impossible due to ordering by ID */
2458 if (fdset_id <= mon_fdset->id) {
2459 if (fdset_id < mon_fdset->id) {
2460 mon_fdset = NULL;
2461 }
2462 break;
2463 }
2464 }
2465 }
2466
2467 if (mon_fdset == NULL) {
2468 int64_t fdset_id_prev = -1;
2469 MonFdset *mon_fdset_cur = QLIST_FIRST(&mon_fdsets);
2470
2471 if (has_fdset_id) {
2472 if (fdset_id < 0) {
2473 error_set(errp, QERR_INVALID_PARAMETER_VALUE, "fdset-id",
2474 "a non-negative value");
2475 return NULL;
2476 }
2477 /* Use specified fdset ID */
2478 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2479 mon_fdset_cur = mon_fdset;
2480 if (fdset_id < mon_fdset_cur->id) {
2481 break;
2482 }
2483 }
2484 } else {
2485 /* Use first available fdset ID */
2486 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2487 mon_fdset_cur = mon_fdset;
2488 if (fdset_id_prev == mon_fdset_cur->id - 1) {
2489 fdset_id_prev = mon_fdset_cur->id;
2490 continue;
2491 }
2492 break;
2493 }
2494 }
2495
2496 mon_fdset = g_malloc0(sizeof(*mon_fdset));
2497 if (has_fdset_id) {
2498 mon_fdset->id = fdset_id;
2499 } else {
2500 mon_fdset->id = fdset_id_prev + 1;
2501 }
2502
2503 /* The fdset list is ordered by fdset ID */
2504 if (!mon_fdset_cur) {
2505 QLIST_INSERT_HEAD(&mon_fdsets, mon_fdset, next);
2506 } else if (mon_fdset->id < mon_fdset_cur->id) {
2507 QLIST_INSERT_BEFORE(mon_fdset_cur, mon_fdset, next);
2508 } else {
2509 QLIST_INSERT_AFTER(mon_fdset_cur, mon_fdset, next);
2510 }
2511 }
2512
2513 mon_fdset_fd = g_malloc0(sizeof(*mon_fdset_fd));
2514 mon_fdset_fd->fd = fd;
2515 mon_fdset_fd->removed = false;
2516 if (has_opaque) {
2517 mon_fdset_fd->opaque = g_strdup(opaque);
2518 }
2519 QLIST_INSERT_HEAD(&mon_fdset->fds, mon_fdset_fd, next);
2520
2521 fdinfo = g_malloc0(sizeof(*fdinfo));
2522 fdinfo->fdset_id = mon_fdset->id;
2523 fdinfo->fd = mon_fdset_fd->fd;
2524
2525 return fdinfo;
2526}
2527
Corey Bryantadb696f2012-08-14 16:43:47 -04002528int monitor_fdset_get_fd(int64_t fdset_id, int flags)
2529{
Blue Swirlb2dc64c2012-08-18 20:14:54 +00002530#ifndef _WIN32
Corey Bryantadb696f2012-08-14 16:43:47 -04002531 MonFdset *mon_fdset;
2532 MonFdsetFd *mon_fdset_fd;
2533 int mon_fd_flags;
2534
Corey Bryantadb696f2012-08-14 16:43:47 -04002535 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2536 if (mon_fdset->id != fdset_id) {
2537 continue;
2538 }
2539 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2540 mon_fd_flags = fcntl(mon_fdset_fd->fd, F_GETFL);
2541 if (mon_fd_flags == -1) {
2542 return -1;
2543 }
2544
2545 if ((flags & O_ACCMODE) == (mon_fd_flags & O_ACCMODE)) {
2546 return mon_fdset_fd->fd;
2547 }
2548 }
2549 errno = EACCES;
2550 return -1;
2551 }
2552#endif
2553
2554 errno = ENOENT;
2555 return -1;
2556}
2557
2558int monitor_fdset_dup_fd_add(int64_t fdset_id, int dup_fd)
2559{
2560 MonFdset *mon_fdset;
2561 MonFdsetFd *mon_fdset_fd_dup;
2562
2563 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2564 if (mon_fdset->id != fdset_id) {
2565 continue;
2566 }
2567 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2568 if (mon_fdset_fd_dup->fd == dup_fd) {
2569 return -1;
2570 }
2571 }
2572 mon_fdset_fd_dup = g_malloc0(sizeof(*mon_fdset_fd_dup));
2573 mon_fdset_fd_dup->fd = dup_fd;
2574 QLIST_INSERT_HEAD(&mon_fdset->dup_fds, mon_fdset_fd_dup, next);
2575 return 0;
2576 }
2577 return -1;
2578}
2579
2580static int monitor_fdset_dup_fd_find_remove(int dup_fd, bool remove)
2581{
2582 MonFdset *mon_fdset;
2583 MonFdsetFd *mon_fdset_fd_dup;
2584
2585 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2586 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2587 if (mon_fdset_fd_dup->fd == dup_fd) {
2588 if (remove) {
2589 QLIST_REMOVE(mon_fdset_fd_dup, next);
2590 if (QLIST_EMPTY(&mon_fdset->dup_fds)) {
2591 monitor_fdset_cleanup(mon_fdset);
2592 }
2593 }
2594 return mon_fdset->id;
2595 }
2596 }
2597 }
2598 return -1;
2599}
2600
2601int monitor_fdset_dup_fd_find(int dup_fd)
2602{
2603 return monitor_fdset_dup_fd_find_remove(dup_fd, false);
2604}
2605
2606int monitor_fdset_dup_fd_remove(int dup_fd)
2607{
2608 return monitor_fdset_dup_fd_find_remove(dup_fd, true);
2609}
2610
Nicholas Bellingera96ed022012-08-21 20:52:07 +00002611int monitor_handle_fd_param(Monitor *mon, const char *fdname)
2612{
2613 int fd;
Paolo Bonzinia9940fc2012-09-20 16:50:32 +02002614 Error *local_err = NULL;
Nicholas Bellingera96ed022012-08-21 20:52:07 +00002615
2616 if (!qemu_isdigit(fdname[0]) && mon) {
2617
Paolo Bonzinia9940fc2012-09-20 16:50:32 +02002618 fd = monitor_get_fd(mon, fdname, &local_err);
Nicholas Bellingera96ed022012-08-21 20:52:07 +00002619 if (fd == -1) {
Paolo Bonzinia9940fc2012-09-20 16:50:32 +02002620 qerror_report_err(local_err);
2621 error_free(local_err);
Nicholas Bellingera96ed022012-08-21 20:52:07 +00002622 return -1;
2623 }
2624 } else {
2625 fd = qemu_parse_fd(fdname);
2626 }
2627
2628 return fd;
2629}
2630
Luiz Capitulinoacd0a092010-09-30 16:00:22 -03002631/* Please update hmp-commands.hx when adding or changing commands */
Wayne Xia816f8922011-10-12 11:32:41 +08002632static mon_cmd_t info_cmds[] = {
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002633 {
2634 .name = "version",
2635 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002636 .params = "",
2637 .help = "show the version of QEMU",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002638 .mhandler.cmd = hmp_info_version,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002639 },
2640 {
2641 .name = "network",
2642 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002643 .params = "",
2644 .help = "show the network state",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002645 .mhandler.cmd = do_info_network,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002646 },
2647 {
2648 .name = "chardev",
2649 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002650 .params = "",
2651 .help = "show the character devices",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002652 .mhandler.cmd = hmp_info_chardev,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002653 },
2654 {
2655 .name = "block",
Wenchao Xiae73fe2b2013-06-06 12:28:01 +08002656 .args_type = "verbose:-v,device:B?",
2657 .params = "[-v] [device]",
2658 .help = "show info of one block device or all block devices "
2659 "(and details of images with -v option)",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002660 .mhandler.cmd = hmp_info_block,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002661 },
2662 {
2663 .name = "blockstats",
2664 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002665 .params = "",
2666 .help = "show block device statistics",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002667 .mhandler.cmd = hmp_info_blockstats,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002668 },
2669 {
Stefan Hajnoczifb5458c2012-01-18 14:40:49 +00002670 .name = "block-jobs",
2671 .args_type = "",
2672 .params = "",
2673 .help = "show progress of ongoing block device operations",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002674 .mhandler.cmd = hmp_info_block_jobs,
Stefan Hajnoczifb5458c2012-01-18 14:40:49 +00002675 },
2676 {
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002677 .name = "registers",
2678 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002679 .params = "",
2680 .help = "show the cpu registers",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002681 .mhandler.cmd = do_info_registers,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002682 },
2683 {
2684 .name = "cpus",
2685 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002686 .params = "",
2687 .help = "show infos for each CPU",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002688 .mhandler.cmd = hmp_info_cpus,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002689 },
2690 {
2691 .name = "history",
2692 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002693 .params = "",
2694 .help = "show the command line history",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002695 .mhandler.cmd = do_info_history,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002696 },
Jan Kiszka661f1922011-10-16 11:53:13 +02002697#if defined(TARGET_I386) || defined(TARGET_PPC) || defined(TARGET_MIPS) || \
2698 defined(TARGET_LM32) || (defined(TARGET_SPARC) && !defined(TARGET_SPARC64))
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002699 {
2700 .name = "irq",
2701 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002702 .params = "",
2703 .help = "show the interrupts statistics (if available)",
Jan Kiszka661f1922011-10-16 11:53:13 +02002704#ifdef TARGET_SPARC
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002705 .mhandler.cmd = sun4m_irq_info,
Jan Kiszka661f1922011-10-16 11:53:13 +02002706#elif defined(TARGET_LM32)
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002707 .mhandler.cmd = lm32_irq_info,
Jan Kiszka661f1922011-10-16 11:53:13 +02002708#else
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002709 .mhandler.cmd = irq_info,
Jan Kiszka661f1922011-10-16 11:53:13 +02002710#endif
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002711 },
2712 {
2713 .name = "pic",
2714 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002715 .params = "",
2716 .help = "show i8259 (PIC) state",
Jan Kiszka661f1922011-10-16 11:53:13 +02002717#ifdef TARGET_SPARC
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002718 .mhandler.cmd = sun4m_pic_info,
Jan Kiszka661f1922011-10-16 11:53:13 +02002719#elif defined(TARGET_LM32)
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002720 .mhandler.cmd = lm32_do_pic_info,
Jan Kiszka661f1922011-10-16 11:53:13 +02002721#else
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002722 .mhandler.cmd = pic_info,
Jan Kiszka661f1922011-10-16 11:53:13 +02002723#endif
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002724 },
Jan Kiszka661f1922011-10-16 11:53:13 +02002725#endif
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002726 {
2727 .name = "pci",
2728 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002729 .params = "",
2730 .help = "show PCI info",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002731 .mhandler.cmd = hmp_info_pci,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002732 },
Scott Woodbebabbc2011-08-18 10:38:42 +00002733#if defined(TARGET_I386) || defined(TARGET_SH4) || defined(TARGET_SPARC) || \
Max Filippov692f7372012-01-07 20:02:40 +04002734 defined(TARGET_PPC) || defined(TARGET_XTENSA)
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002735 {
2736 .name = "tlb",
2737 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002738 .params = "",
2739 .help = "show virtual to physical memory mappings",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002740 .mhandler.cmd = tlb_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002741 },
aurel327c664e22009-03-03 06:12:22 +00002742#endif
2743#if defined(TARGET_I386)
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002744 {
2745 .name = "mem",
2746 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002747 .params = "",
2748 .help = "show the active virtual memory mappings",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002749 .mhandler.cmd = mem_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002750 },
bellardb86bda52004-09-18 19:32:46 +00002751#endif
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002752 {
Blue Swirl314e2982011-09-11 20:22:05 +00002753 .name = "mtree",
2754 .args_type = "",
2755 .params = "",
2756 .help = "show memory tree",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002757 .mhandler.cmd = do_info_mtree,
Blue Swirl314e2982011-09-11 20:22:05 +00002758 },
2759 {
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002760 .name = "jit",
2761 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002762 .params = "",
2763 .help = "show dynamic compiler info",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002764 .mhandler.cmd = do_info_jit,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002765 },
2766 {
2767 .name = "kvm",
2768 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002769 .params = "",
2770 .help = "show KVM information",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002771 .mhandler.cmd = hmp_info_kvm,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002772 },
2773 {
2774 .name = "numa",
2775 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002776 .params = "",
2777 .help = "show NUMA information",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002778 .mhandler.cmd = do_info_numa,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002779 },
2780 {
2781 .name = "usb",
2782 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002783 .params = "",
2784 .help = "show guest USB devices",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002785 .mhandler.cmd = usb_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002786 },
2787 {
2788 .name = "usbhost",
2789 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002790 .params = "",
2791 .help = "show host USB devices",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002792 .mhandler.cmd = usb_host_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002793 },
2794 {
2795 .name = "profile",
2796 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002797 .params = "",
2798 .help = "show profiling information",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002799 .mhandler.cmd = do_info_profile,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002800 },
2801 {
2802 .name = "capture",
2803 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002804 .params = "",
2805 .help = "show capture information",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002806 .mhandler.cmd = do_info_capture,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002807 },
2808 {
2809 .name = "snapshots",
2810 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002811 .params = "",
2812 .help = "show the currently saved VM snapshots",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002813 .mhandler.cmd = do_info_snapshots,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002814 },
2815 {
2816 .name = "status",
2817 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002818 .params = "",
2819 .help = "show the current VM status (running|paused)",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002820 .mhandler.cmd = hmp_info_status,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002821 },
2822 {
2823 .name = "pcmcia",
2824 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002825 .params = "",
2826 .help = "show guest PCMCIA status",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002827 .mhandler.cmd = pcmcia_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002828 },
2829 {
2830 .name = "mice",
2831 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002832 .params = "",
2833 .help = "show which guest mouse is receiving events",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002834 .mhandler.cmd = hmp_info_mice,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002835 },
2836 {
2837 .name = "vnc",
2838 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002839 .params = "",
2840 .help = "show the vnc server status",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002841 .mhandler.cmd = hmp_info_vnc,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002842 },
Gerd Hoffmanncb42a872010-11-30 11:02:51 +01002843#if defined(CONFIG_SPICE)
2844 {
2845 .name = "spice",
2846 .args_type = "",
2847 .params = "",
2848 .help = "show the spice server status",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002849 .mhandler.cmd = hmp_info_spice,
Gerd Hoffmanncb42a872010-11-30 11:02:51 +01002850 },
2851#endif
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002852 {
2853 .name = "name",
2854 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002855 .params = "",
2856 .help = "show the current VM name",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002857 .mhandler.cmd = hmp_info_name,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002858 },
2859 {
2860 .name = "uuid",
2861 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002862 .params = "",
2863 .help = "show the current VM UUID",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002864 .mhandler.cmd = hmp_info_uuid,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002865 },
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002866 {
2867 .name = "cpustats",
2868 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002869 .params = "",
2870 .help = "show CPU statistics",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002871 .mhandler.cmd = do_info_cpu_stats,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002872 },
blueswir131a60e22007-10-26 18:42:59 +00002873#if defined(CONFIG_SLIRP)
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002874 {
2875 .name = "usernet",
2876 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002877 .params = "",
2878 .help = "show user network stack connection states",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002879 .mhandler.cmd = do_info_usernet,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002880 },
blueswir131a60e22007-10-26 18:42:59 +00002881#endif
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002882 {
2883 .name = "migrate",
2884 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002885 .params = "",
2886 .help = "show migration status",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002887 .mhandler.cmd = hmp_info_migrate,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002888 },
2889 {
Orit Wassermanbbf6da32012-08-06 21:42:47 +03002890 .name = "migrate_capabilities",
2891 .args_type = "",
2892 .params = "",
2893 .help = "show current migration capabilities",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002894 .mhandler.cmd = hmp_info_migrate_capabilities,
Orit Wassermanbbf6da32012-08-06 21:42:47 +03002895 },
2896 {
Orit Wasserman9e1ba4c2012-08-06 21:42:54 +03002897 .name = "migrate_cache_size",
2898 .args_type = "",
2899 .params = "",
2900 .help = "show current migration xbzrle cache size",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002901 .mhandler.cmd = hmp_info_migrate_cache_size,
Orit Wasserman9e1ba4c2012-08-06 21:42:54 +03002902 },
2903 {
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002904 .name = "balloon",
2905 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002906 .params = "",
2907 .help = "show balloon information",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002908 .mhandler.cmd = hmp_info_balloon,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002909 },
2910 {
2911 .name = "qtree",
2912 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002913 .params = "",
2914 .help = "show device tree",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002915 .mhandler.cmd = do_info_qtree,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002916 },
2917 {
2918 .name = "qdm",
2919 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002920 .params = "",
2921 .help = "show qdev device model list",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002922 .mhandler.cmd = do_info_qdm,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002923 },
2924 {
2925 .name = "roms",
2926 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002927 .params = "",
2928 .help = "show roms",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002929 .mhandler.cmd = do_info_roms,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002930 },
Prerna Saxena22890ab2010-06-24 17:04:53 +05302931 {
2932 .name = "trace-events",
2933 .args_type = "",
2934 .params = "",
2935 .help = "show available trace-events & their state",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002936 .mhandler.cmd = do_trace_print_events,
Prerna Saxena22890ab2010-06-24 17:04:53 +05302937 },
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002938 {
Stefan Bergerd1a0cf72013-02-27 12:47:49 -05002939 .name = "tpm",
2940 .args_type = "",
2941 .params = "",
2942 .help = "show the TPM device",
2943 .mhandler.cmd = hmp_info_tpm,
2944 },
2945 {
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002946 .name = NULL,
2947 },
bellard9dc39cb2004-03-14 21:38:27 +00002948};
2949
Wenchao Xiaa13ced52013-01-14 14:06:28 +08002950/* mon_cmds and info_cmds would be sorted at runtime */
2951static mon_cmd_t mon_cmds[] = {
2952#include "hmp-commands.h"
2953 { NULL, NULL, },
2954};
2955
Luiz Capitulinof36b4af2010-09-15 17:17:45 -03002956static const mon_cmd_t qmp_cmds[] = {
Anthony Liguorie3193602011-09-02 12:34:47 -05002957#include "qmp-commands-old.h"
Luiz Capitulinof36b4af2010-09-15 17:17:45 -03002958 { /* NULL */ },
2959};
2960
bellard9307c4c2004-04-04 12:57:25 +00002961/*******************************************************************/
2962
2963static const char *pch;
Peter Maydell6ab7e542013-02-20 15:21:09 +00002964static sigjmp_buf expr_env;
bellard9307c4c2004-04-04 12:57:25 +00002965
bellard92a31b12005-02-10 22:00:52 +00002966#define MD_TLONG 0
2967#define MD_I32 1
2968
bellard9307c4c2004-04-04 12:57:25 +00002969typedef struct MonitorDef {
2970 const char *name;
2971 int offset;
blueswir18662d652008-10-02 18:32:44 +00002972 target_long (*get_value)(const struct MonitorDef *md, int val);
bellard92a31b12005-02-10 22:00:52 +00002973 int type;
bellard9307c4c2004-04-04 12:57:25 +00002974} MonitorDef;
2975
bellard57206fd2004-04-25 18:54:52 +00002976#if defined(TARGET_I386)
blueswir18662d652008-10-02 18:32:44 +00002977static target_long monitor_get_pc (const struct MonitorDef *md, int val)
bellard57206fd2004-04-25 18:54:52 +00002978{
Andreas Färber9349b4f2012-03-14 01:38:32 +01002979 CPUArchState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00002980 return env->eip + env->segs[R_CS].base;
bellard57206fd2004-04-25 18:54:52 +00002981}
2982#endif
2983
bellarda541f292004-04-12 20:39:29 +00002984#if defined(TARGET_PPC)
blueswir18662d652008-10-02 18:32:44 +00002985static target_long monitor_get_ccr (const struct MonitorDef *md, int val)
bellarda541f292004-04-12 20:39:29 +00002986{
Andreas Färber9349b4f2012-03-14 01:38:32 +01002987 CPUArchState *env = mon_get_cpu();
bellarda541f292004-04-12 20:39:29 +00002988 unsigned int u;
2989 int i;
2990
2991 u = 0;
2992 for (i = 0; i < 8; i++)
aliguori28a76be2009-03-06 20:27:40 +00002993 u |= env->crf[i] << (32 - (4 * i));
bellarda541f292004-04-12 20:39:29 +00002994
2995 return u;
2996}
2997
blueswir18662d652008-10-02 18:32:44 +00002998static target_long monitor_get_msr (const struct MonitorDef *md, int val)
bellarda541f292004-04-12 20:39:29 +00002999{
Andreas Färber9349b4f2012-03-14 01:38:32 +01003000 CPUArchState *env = mon_get_cpu();
j_mayer0411a972007-10-25 21:35:50 +00003001 return env->msr;
bellarda541f292004-04-12 20:39:29 +00003002}
3003
blueswir18662d652008-10-02 18:32:44 +00003004static target_long monitor_get_xer (const struct MonitorDef *md, int val)
bellarda541f292004-04-12 20:39:29 +00003005{
Andreas Färber9349b4f2012-03-14 01:38:32 +01003006 CPUArchState *env = mon_get_cpu();
aurel323d7b4172008-10-21 11:28:46 +00003007 return env->xer;
bellarda541f292004-04-12 20:39:29 +00003008}
bellard9fddaa02004-05-21 12:59:32 +00003009
blueswir18662d652008-10-02 18:32:44 +00003010static target_long monitor_get_decr (const struct MonitorDef *md, int val)
bellard9fddaa02004-05-21 12:59:32 +00003011{
Andreas Färber9349b4f2012-03-14 01:38:32 +01003012 CPUArchState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00003013 return cpu_ppc_load_decr(env);
bellard9fddaa02004-05-21 12:59:32 +00003014}
3015
blueswir18662d652008-10-02 18:32:44 +00003016static target_long monitor_get_tbu (const struct MonitorDef *md, int val)
bellard9fddaa02004-05-21 12:59:32 +00003017{
Andreas Färber9349b4f2012-03-14 01:38:32 +01003018 CPUArchState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00003019 return cpu_ppc_load_tbu(env);
bellard9fddaa02004-05-21 12:59:32 +00003020}
3021
blueswir18662d652008-10-02 18:32:44 +00003022static target_long monitor_get_tbl (const struct MonitorDef *md, int val)
bellard9fddaa02004-05-21 12:59:32 +00003023{
Andreas Färber9349b4f2012-03-14 01:38:32 +01003024 CPUArchState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00003025 return cpu_ppc_load_tbl(env);
bellard9fddaa02004-05-21 12:59:32 +00003026}
bellarda541f292004-04-12 20:39:29 +00003027#endif
3028
bellarde95c8d52004-09-30 22:22:08 +00003029#if defined(TARGET_SPARC)
bellard7b936c02005-10-30 17:05:13 +00003030#ifndef TARGET_SPARC64
blueswir18662d652008-10-02 18:32:44 +00003031static target_long monitor_get_psr (const struct MonitorDef *md, int val)
bellarde95c8d52004-09-30 22:22:08 +00003032{
Andreas Färber9349b4f2012-03-14 01:38:32 +01003033 CPUArchState *env = mon_get_cpu();
Blue Swirl5a834bb2010-05-09 20:19:04 +00003034
3035 return cpu_get_psr(env);
bellarde95c8d52004-09-30 22:22:08 +00003036}
bellard7b936c02005-10-30 17:05:13 +00003037#endif
bellarde95c8d52004-09-30 22:22:08 +00003038
blueswir18662d652008-10-02 18:32:44 +00003039static target_long monitor_get_reg(const struct MonitorDef *md, int val)
bellarde95c8d52004-09-30 22:22:08 +00003040{
Andreas Färber9349b4f2012-03-14 01:38:32 +01003041 CPUArchState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00003042 return env->regwptr[val];
bellarde95c8d52004-09-30 22:22:08 +00003043}
3044#endif
3045
blueswir18662d652008-10-02 18:32:44 +00003046static const MonitorDef monitor_defs[] = {
bellard9307c4c2004-04-04 12:57:25 +00003047#ifdef TARGET_I386
bellard57206fd2004-04-25 18:54:52 +00003048
3049#define SEG(name, seg) \
Andreas Färbere59d1672012-02-16 00:40:47 +01003050 { name, offsetof(CPUX86State, segs[seg].selector), NULL, MD_I32 },\
3051 { name ".base", offsetof(CPUX86State, segs[seg].base) },\
3052 { name ".limit", offsetof(CPUX86State, segs[seg].limit), NULL, MD_I32 },
bellard57206fd2004-04-25 18:54:52 +00003053
Andreas Färbere59d1672012-02-16 00:40:47 +01003054 { "eax", offsetof(CPUX86State, regs[0]) },
3055 { "ecx", offsetof(CPUX86State, regs[1]) },
3056 { "edx", offsetof(CPUX86State, regs[2]) },
3057 { "ebx", offsetof(CPUX86State, regs[3]) },
3058 { "esp|sp", offsetof(CPUX86State, regs[4]) },
3059 { "ebp|fp", offsetof(CPUX86State, regs[5]) },
3060 { "esi", offsetof(CPUX86State, regs[6]) },
3061 { "edi", offsetof(CPUX86State, regs[7]) },
bellard92a31b12005-02-10 22:00:52 +00003062#ifdef TARGET_X86_64
Andreas Färbere59d1672012-02-16 00:40:47 +01003063 { "r8", offsetof(CPUX86State, regs[8]) },
3064 { "r9", offsetof(CPUX86State, regs[9]) },
3065 { "r10", offsetof(CPUX86State, regs[10]) },
3066 { "r11", offsetof(CPUX86State, regs[11]) },
3067 { "r12", offsetof(CPUX86State, regs[12]) },
3068 { "r13", offsetof(CPUX86State, regs[13]) },
3069 { "r14", offsetof(CPUX86State, regs[14]) },
3070 { "r15", offsetof(CPUX86State, regs[15]) },
bellard92a31b12005-02-10 22:00:52 +00003071#endif
Andreas Färbere59d1672012-02-16 00:40:47 +01003072 { "eflags", offsetof(CPUX86State, eflags) },
3073 { "eip", offsetof(CPUX86State, eip) },
bellard57206fd2004-04-25 18:54:52 +00003074 SEG("cs", R_CS)
3075 SEG("ds", R_DS)
3076 SEG("es", R_ES)
bellard01038d22004-09-13 21:36:46 +00003077 SEG("ss", R_SS)
bellard57206fd2004-04-25 18:54:52 +00003078 SEG("fs", R_FS)
3079 SEG("gs", R_GS)
3080 { "pc", 0, monitor_get_pc, },
bellarda541f292004-04-12 20:39:29 +00003081#elif defined(TARGET_PPC)
j_mayerff937db2007-09-19 05:49:13 +00003082 /* General purpose registers */
Andreas Färbere59d1672012-02-16 00:40:47 +01003083 { "r0", offsetof(CPUPPCState, gpr[0]) },
3084 { "r1", offsetof(CPUPPCState, gpr[1]) },
3085 { "r2", offsetof(CPUPPCState, gpr[2]) },
3086 { "r3", offsetof(CPUPPCState, gpr[3]) },
3087 { "r4", offsetof(CPUPPCState, gpr[4]) },
3088 { "r5", offsetof(CPUPPCState, gpr[5]) },
3089 { "r6", offsetof(CPUPPCState, gpr[6]) },
3090 { "r7", offsetof(CPUPPCState, gpr[7]) },
3091 { "r8", offsetof(CPUPPCState, gpr[8]) },
3092 { "r9", offsetof(CPUPPCState, gpr[9]) },
3093 { "r10", offsetof(CPUPPCState, gpr[10]) },
3094 { "r11", offsetof(CPUPPCState, gpr[11]) },
3095 { "r12", offsetof(CPUPPCState, gpr[12]) },
3096 { "r13", offsetof(CPUPPCState, gpr[13]) },
3097 { "r14", offsetof(CPUPPCState, gpr[14]) },
3098 { "r15", offsetof(CPUPPCState, gpr[15]) },
3099 { "r16", offsetof(CPUPPCState, gpr[16]) },
3100 { "r17", offsetof(CPUPPCState, gpr[17]) },
3101 { "r18", offsetof(CPUPPCState, gpr[18]) },
3102 { "r19", offsetof(CPUPPCState, gpr[19]) },
3103 { "r20", offsetof(CPUPPCState, gpr[20]) },
3104 { "r21", offsetof(CPUPPCState, gpr[21]) },
3105 { "r22", offsetof(CPUPPCState, gpr[22]) },
3106 { "r23", offsetof(CPUPPCState, gpr[23]) },
3107 { "r24", offsetof(CPUPPCState, gpr[24]) },
3108 { "r25", offsetof(CPUPPCState, gpr[25]) },
3109 { "r26", offsetof(CPUPPCState, gpr[26]) },
3110 { "r27", offsetof(CPUPPCState, gpr[27]) },
3111 { "r28", offsetof(CPUPPCState, gpr[28]) },
3112 { "r29", offsetof(CPUPPCState, gpr[29]) },
3113 { "r30", offsetof(CPUPPCState, gpr[30]) },
3114 { "r31", offsetof(CPUPPCState, gpr[31]) },
j_mayerff937db2007-09-19 05:49:13 +00003115 /* Floating point registers */
Andreas Färbere59d1672012-02-16 00:40:47 +01003116 { "f0", offsetof(CPUPPCState, fpr[0]) },
3117 { "f1", offsetof(CPUPPCState, fpr[1]) },
3118 { "f2", offsetof(CPUPPCState, fpr[2]) },
3119 { "f3", offsetof(CPUPPCState, fpr[3]) },
3120 { "f4", offsetof(CPUPPCState, fpr[4]) },
3121 { "f5", offsetof(CPUPPCState, fpr[5]) },
3122 { "f6", offsetof(CPUPPCState, fpr[6]) },
3123 { "f7", offsetof(CPUPPCState, fpr[7]) },
3124 { "f8", offsetof(CPUPPCState, fpr[8]) },
3125 { "f9", offsetof(CPUPPCState, fpr[9]) },
3126 { "f10", offsetof(CPUPPCState, fpr[10]) },
3127 { "f11", offsetof(CPUPPCState, fpr[11]) },
3128 { "f12", offsetof(CPUPPCState, fpr[12]) },
3129 { "f13", offsetof(CPUPPCState, fpr[13]) },
3130 { "f14", offsetof(CPUPPCState, fpr[14]) },
3131 { "f15", offsetof(CPUPPCState, fpr[15]) },
3132 { "f16", offsetof(CPUPPCState, fpr[16]) },
3133 { "f17", offsetof(CPUPPCState, fpr[17]) },
3134 { "f18", offsetof(CPUPPCState, fpr[18]) },
3135 { "f19", offsetof(CPUPPCState, fpr[19]) },
3136 { "f20", offsetof(CPUPPCState, fpr[20]) },
3137 { "f21", offsetof(CPUPPCState, fpr[21]) },
3138 { "f22", offsetof(CPUPPCState, fpr[22]) },
3139 { "f23", offsetof(CPUPPCState, fpr[23]) },
3140 { "f24", offsetof(CPUPPCState, fpr[24]) },
3141 { "f25", offsetof(CPUPPCState, fpr[25]) },
3142 { "f26", offsetof(CPUPPCState, fpr[26]) },
3143 { "f27", offsetof(CPUPPCState, fpr[27]) },
3144 { "f28", offsetof(CPUPPCState, fpr[28]) },
3145 { "f29", offsetof(CPUPPCState, fpr[29]) },
3146 { "f30", offsetof(CPUPPCState, fpr[30]) },
3147 { "f31", offsetof(CPUPPCState, fpr[31]) },
3148 { "fpscr", offsetof(CPUPPCState, fpscr) },
j_mayerff937db2007-09-19 05:49:13 +00003149 /* Next instruction pointer */
Andreas Färbere59d1672012-02-16 00:40:47 +01003150 { "nip|pc", offsetof(CPUPPCState, nip) },
3151 { "lr", offsetof(CPUPPCState, lr) },
3152 { "ctr", offsetof(CPUPPCState, ctr) },
bellard9fddaa02004-05-21 12:59:32 +00003153 { "decr", 0, &monitor_get_decr, },
bellarda541f292004-04-12 20:39:29 +00003154 { "ccr", 0, &monitor_get_ccr, },
j_mayerff937db2007-09-19 05:49:13 +00003155 /* Machine state register */
bellarda541f292004-04-12 20:39:29 +00003156 { "msr", 0, &monitor_get_msr, },
3157 { "xer", 0, &monitor_get_xer, },
bellard9fddaa02004-05-21 12:59:32 +00003158 { "tbu", 0, &monitor_get_tbu, },
3159 { "tbl", 0, &monitor_get_tbl, },
j_mayerff937db2007-09-19 05:49:13 +00003160 /* Segment registers */
Andreas Färbere59d1672012-02-16 00:40:47 +01003161 { "sdr1", offsetof(CPUPPCState, spr[SPR_SDR1]) },
3162 { "sr0", offsetof(CPUPPCState, sr[0]) },
3163 { "sr1", offsetof(CPUPPCState, sr[1]) },
3164 { "sr2", offsetof(CPUPPCState, sr[2]) },
3165 { "sr3", offsetof(CPUPPCState, sr[3]) },
3166 { "sr4", offsetof(CPUPPCState, sr[4]) },
3167 { "sr5", offsetof(CPUPPCState, sr[5]) },
3168 { "sr6", offsetof(CPUPPCState, sr[6]) },
3169 { "sr7", offsetof(CPUPPCState, sr[7]) },
3170 { "sr8", offsetof(CPUPPCState, sr[8]) },
3171 { "sr9", offsetof(CPUPPCState, sr[9]) },
3172 { "sr10", offsetof(CPUPPCState, sr[10]) },
3173 { "sr11", offsetof(CPUPPCState, sr[11]) },
3174 { "sr12", offsetof(CPUPPCState, sr[12]) },
3175 { "sr13", offsetof(CPUPPCState, sr[13]) },
3176 { "sr14", offsetof(CPUPPCState, sr[14]) },
3177 { "sr15", offsetof(CPUPPCState, sr[15]) },
Scott Wood90dc8812011-04-29 17:10:23 -05003178 /* Too lazy to put BATs... */
Andreas Färbere59d1672012-02-16 00:40:47 +01003179 { "pvr", offsetof(CPUPPCState, spr[SPR_PVR]) },
Scott Wood90dc8812011-04-29 17:10:23 -05003180
Andreas Färbere59d1672012-02-16 00:40:47 +01003181 { "srr0", offsetof(CPUPPCState, spr[SPR_SRR0]) },
3182 { "srr1", offsetof(CPUPPCState, spr[SPR_SRR1]) },
Tom Musta04f1f782013-09-25 17:41:13 +10003183 { "dar", offsetof(CPUPPCState, spr[SPR_DAR]) },
3184 { "dsisr", offsetof(CPUPPCState, spr[SPR_DSISR]) },
3185 { "cfar", offsetof(CPUPPCState, spr[SPR_CFAR]) },
Andreas Färbere59d1672012-02-16 00:40:47 +01003186 { "sprg0", offsetof(CPUPPCState, spr[SPR_SPRG0]) },
3187 { "sprg1", offsetof(CPUPPCState, spr[SPR_SPRG1]) },
3188 { "sprg2", offsetof(CPUPPCState, spr[SPR_SPRG2]) },
3189 { "sprg3", offsetof(CPUPPCState, spr[SPR_SPRG3]) },
3190 { "sprg4", offsetof(CPUPPCState, spr[SPR_SPRG4]) },
3191 { "sprg5", offsetof(CPUPPCState, spr[SPR_SPRG5]) },
3192 { "sprg6", offsetof(CPUPPCState, spr[SPR_SPRG6]) },
3193 { "sprg7", offsetof(CPUPPCState, spr[SPR_SPRG7]) },
3194 { "pid", offsetof(CPUPPCState, spr[SPR_BOOKE_PID]) },
3195 { "csrr0", offsetof(CPUPPCState, spr[SPR_BOOKE_CSRR0]) },
3196 { "csrr1", offsetof(CPUPPCState, spr[SPR_BOOKE_CSRR1]) },
3197 { "esr", offsetof(CPUPPCState, spr[SPR_BOOKE_ESR]) },
3198 { "dear", offsetof(CPUPPCState, spr[SPR_BOOKE_DEAR]) },
3199 { "mcsr", offsetof(CPUPPCState, spr[SPR_BOOKE_MCSR]) },
3200 { "tsr", offsetof(CPUPPCState, spr[SPR_BOOKE_TSR]) },
3201 { "tcr", offsetof(CPUPPCState, spr[SPR_BOOKE_TCR]) },
3202 { "vrsave", offsetof(CPUPPCState, spr[SPR_VRSAVE]) },
3203 { "pir", offsetof(CPUPPCState, spr[SPR_BOOKE_PIR]) },
3204 { "mcsrr0", offsetof(CPUPPCState, spr[SPR_BOOKE_MCSRR0]) },
3205 { "mcsrr1", offsetof(CPUPPCState, spr[SPR_BOOKE_MCSRR1]) },
3206 { "decar", offsetof(CPUPPCState, spr[SPR_BOOKE_DECAR]) },
3207 { "ivpr", offsetof(CPUPPCState, spr[SPR_BOOKE_IVPR]) },
3208 { "epcr", offsetof(CPUPPCState, spr[SPR_BOOKE_EPCR]) },
3209 { "sprg8", offsetof(CPUPPCState, spr[SPR_BOOKE_SPRG8]) },
3210 { "ivor0", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR0]) },
3211 { "ivor1", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR1]) },
3212 { "ivor2", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR2]) },
3213 { "ivor3", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR3]) },
3214 { "ivor4", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR4]) },
3215 { "ivor5", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR5]) },
3216 { "ivor6", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR6]) },
3217 { "ivor7", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR7]) },
3218 { "ivor8", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR8]) },
3219 { "ivor9", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR9]) },
3220 { "ivor10", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR10]) },
3221 { "ivor11", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR11]) },
3222 { "ivor12", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR12]) },
3223 { "ivor13", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR13]) },
3224 { "ivor14", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR14]) },
3225 { "ivor15", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR15]) },
3226 { "ivor32", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR32]) },
3227 { "ivor33", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR33]) },
3228 { "ivor34", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR34]) },
3229 { "ivor35", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR35]) },
3230 { "ivor36", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR36]) },
3231 { "ivor37", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR37]) },
3232 { "mas0", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS0]) },
3233 { "mas1", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS1]) },
3234 { "mas2", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS2]) },
3235 { "mas3", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS3]) },
3236 { "mas4", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS4]) },
3237 { "mas6", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS6]) },
3238 { "mas7", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS7]) },
3239 { "mmucfg", offsetof(CPUPPCState, spr[SPR_MMUCFG]) },
3240 { "tlb0cfg", offsetof(CPUPPCState, spr[SPR_BOOKE_TLB0CFG]) },
3241 { "tlb1cfg", offsetof(CPUPPCState, spr[SPR_BOOKE_TLB1CFG]) },
3242 { "epr", offsetof(CPUPPCState, spr[SPR_BOOKE_EPR]) },
3243 { "eplc", offsetof(CPUPPCState, spr[SPR_BOOKE_EPLC]) },
3244 { "epsc", offsetof(CPUPPCState, spr[SPR_BOOKE_EPSC]) },
3245 { "svr", offsetof(CPUPPCState, spr[SPR_E500_SVR]) },
3246 { "mcar", offsetof(CPUPPCState, spr[SPR_Exxx_MCAR]) },
3247 { "pid1", offsetof(CPUPPCState, spr[SPR_BOOKE_PID1]) },
3248 { "pid2", offsetof(CPUPPCState, spr[SPR_BOOKE_PID2]) },
3249 { "hid0", offsetof(CPUPPCState, spr[SPR_HID0]) },
Scott Wood90dc8812011-04-29 17:10:23 -05003250
bellarde95c8d52004-09-30 22:22:08 +00003251#elif defined(TARGET_SPARC)
Andreas Färbere59d1672012-02-16 00:40:47 +01003252 { "g0", offsetof(CPUSPARCState, gregs[0]) },
3253 { "g1", offsetof(CPUSPARCState, gregs[1]) },
3254 { "g2", offsetof(CPUSPARCState, gregs[2]) },
3255 { "g3", offsetof(CPUSPARCState, gregs[3]) },
3256 { "g4", offsetof(CPUSPARCState, gregs[4]) },
3257 { "g5", offsetof(CPUSPARCState, gregs[5]) },
3258 { "g6", offsetof(CPUSPARCState, gregs[6]) },
3259 { "g7", offsetof(CPUSPARCState, gregs[7]) },
bellarde95c8d52004-09-30 22:22:08 +00003260 { "o0", 0, monitor_get_reg },
3261 { "o1", 1, monitor_get_reg },
3262 { "o2", 2, monitor_get_reg },
3263 { "o3", 3, monitor_get_reg },
3264 { "o4", 4, monitor_get_reg },
3265 { "o5", 5, monitor_get_reg },
3266 { "o6", 6, monitor_get_reg },
3267 { "o7", 7, monitor_get_reg },
3268 { "l0", 8, monitor_get_reg },
3269 { "l1", 9, monitor_get_reg },
3270 { "l2", 10, monitor_get_reg },
3271 { "l3", 11, monitor_get_reg },
3272 { "l4", 12, monitor_get_reg },
3273 { "l5", 13, monitor_get_reg },
3274 { "l6", 14, monitor_get_reg },
3275 { "l7", 15, monitor_get_reg },
3276 { "i0", 16, monitor_get_reg },
3277 { "i1", 17, monitor_get_reg },
3278 { "i2", 18, monitor_get_reg },
3279 { "i3", 19, monitor_get_reg },
3280 { "i4", 20, monitor_get_reg },
3281 { "i5", 21, monitor_get_reg },
3282 { "i6", 22, monitor_get_reg },
3283 { "i7", 23, monitor_get_reg },
Andreas Färbere59d1672012-02-16 00:40:47 +01003284 { "pc", offsetof(CPUSPARCState, pc) },
3285 { "npc", offsetof(CPUSPARCState, npc) },
3286 { "y", offsetof(CPUSPARCState, y) },
bellard7b936c02005-10-30 17:05:13 +00003287#ifndef TARGET_SPARC64
bellarde95c8d52004-09-30 22:22:08 +00003288 { "psr", 0, &monitor_get_psr, },
Andreas Färbere59d1672012-02-16 00:40:47 +01003289 { "wim", offsetof(CPUSPARCState, wim) },
bellard7b936c02005-10-30 17:05:13 +00003290#endif
Andreas Färbere59d1672012-02-16 00:40:47 +01003291 { "tbr", offsetof(CPUSPARCState, tbr) },
3292 { "fsr", offsetof(CPUSPARCState, fsr) },
3293 { "f0", offsetof(CPUSPARCState, fpr[0].l.upper) },
3294 { "f1", offsetof(CPUSPARCState, fpr[0].l.lower) },
3295 { "f2", offsetof(CPUSPARCState, fpr[1].l.upper) },
3296 { "f3", offsetof(CPUSPARCState, fpr[1].l.lower) },
3297 { "f4", offsetof(CPUSPARCState, fpr[2].l.upper) },
3298 { "f5", offsetof(CPUSPARCState, fpr[2].l.lower) },
3299 { "f6", offsetof(CPUSPARCState, fpr[3].l.upper) },
3300 { "f7", offsetof(CPUSPARCState, fpr[3].l.lower) },
3301 { "f8", offsetof(CPUSPARCState, fpr[4].l.upper) },
3302 { "f9", offsetof(CPUSPARCState, fpr[4].l.lower) },
3303 { "f10", offsetof(CPUSPARCState, fpr[5].l.upper) },
3304 { "f11", offsetof(CPUSPARCState, fpr[5].l.lower) },
3305 { "f12", offsetof(CPUSPARCState, fpr[6].l.upper) },
3306 { "f13", offsetof(CPUSPARCState, fpr[6].l.lower) },
3307 { "f14", offsetof(CPUSPARCState, fpr[7].l.upper) },
3308 { "f15", offsetof(CPUSPARCState, fpr[7].l.lower) },
3309 { "f16", offsetof(CPUSPARCState, fpr[8].l.upper) },
3310 { "f17", offsetof(CPUSPARCState, fpr[8].l.lower) },
3311 { "f18", offsetof(CPUSPARCState, fpr[9].l.upper) },
3312 { "f19", offsetof(CPUSPARCState, fpr[9].l.lower) },
3313 { "f20", offsetof(CPUSPARCState, fpr[10].l.upper) },
3314 { "f21", offsetof(CPUSPARCState, fpr[10].l.lower) },
3315 { "f22", offsetof(CPUSPARCState, fpr[11].l.upper) },
3316 { "f23", offsetof(CPUSPARCState, fpr[11].l.lower) },
3317 { "f24", offsetof(CPUSPARCState, fpr[12].l.upper) },
3318 { "f25", offsetof(CPUSPARCState, fpr[12].l.lower) },
3319 { "f26", offsetof(CPUSPARCState, fpr[13].l.upper) },
3320 { "f27", offsetof(CPUSPARCState, fpr[13].l.lower) },
3321 { "f28", offsetof(CPUSPARCState, fpr[14].l.upper) },
3322 { "f29", offsetof(CPUSPARCState, fpr[14].l.lower) },
3323 { "f30", offsetof(CPUSPARCState, fpr[15].l.upper) },
3324 { "f31", offsetof(CPUSPARCState, fpr[15].l.lower) },
bellard7b936c02005-10-30 17:05:13 +00003325#ifdef TARGET_SPARC64
Andreas Färbere59d1672012-02-16 00:40:47 +01003326 { "f32", offsetof(CPUSPARCState, fpr[16]) },
3327 { "f34", offsetof(CPUSPARCState, fpr[17]) },
3328 { "f36", offsetof(CPUSPARCState, fpr[18]) },
3329 { "f38", offsetof(CPUSPARCState, fpr[19]) },
3330 { "f40", offsetof(CPUSPARCState, fpr[20]) },
3331 { "f42", offsetof(CPUSPARCState, fpr[21]) },
3332 { "f44", offsetof(CPUSPARCState, fpr[22]) },
3333 { "f46", offsetof(CPUSPARCState, fpr[23]) },
3334 { "f48", offsetof(CPUSPARCState, fpr[24]) },
3335 { "f50", offsetof(CPUSPARCState, fpr[25]) },
3336 { "f52", offsetof(CPUSPARCState, fpr[26]) },
3337 { "f54", offsetof(CPUSPARCState, fpr[27]) },
3338 { "f56", offsetof(CPUSPARCState, fpr[28]) },
3339 { "f58", offsetof(CPUSPARCState, fpr[29]) },
3340 { "f60", offsetof(CPUSPARCState, fpr[30]) },
3341 { "f62", offsetof(CPUSPARCState, fpr[31]) },
3342 { "asi", offsetof(CPUSPARCState, asi) },
3343 { "pstate", offsetof(CPUSPARCState, pstate) },
3344 { "cansave", offsetof(CPUSPARCState, cansave) },
3345 { "canrestore", offsetof(CPUSPARCState, canrestore) },
3346 { "otherwin", offsetof(CPUSPARCState, otherwin) },
3347 { "wstate", offsetof(CPUSPARCState, wstate) },
3348 { "cleanwin", offsetof(CPUSPARCState, cleanwin) },
3349 { "fprs", offsetof(CPUSPARCState, fprs) },
bellard7b936c02005-10-30 17:05:13 +00003350#endif
bellard9307c4c2004-04-04 12:57:25 +00003351#endif
3352 { NULL },
3353};
3354
Stefan Weil9c3175c2013-08-22 21:30:09 +02003355static void GCC_FMT_ATTR(2, 3) QEMU_NORETURN
3356expr_error(Monitor *mon, const char *fmt, ...)
bellard9dc39cb2004-03-14 21:38:27 +00003357{
Fam Zheng277acfe2013-08-20 10:58:21 +08003358 va_list ap;
3359 va_start(ap, fmt);
3360 monitor_vprintf(mon, fmt, ap);
3361 monitor_printf(mon, "\n");
3362 va_end(ap);
Peter Maydell6ab7e542013-02-20 15:21:09 +00003363 siglongjmp(expr_env, 1);
bellard9307c4c2004-04-04 12:57:25 +00003364}
3365
Markus Armbruster09b94182010-01-20 13:07:30 +01003366/* return 0 if OK, -1 if not found */
bellard92a31b12005-02-10 22:00:52 +00003367static int get_monitor_def(target_long *pval, const char *name)
bellard9307c4c2004-04-04 12:57:25 +00003368{
blueswir18662d652008-10-02 18:32:44 +00003369 const MonitorDef *md;
bellard92a31b12005-02-10 22:00:52 +00003370 void *ptr;
3371
bellard9307c4c2004-04-04 12:57:25 +00003372 for(md = monitor_defs; md->name != NULL; md++) {
3373 if (compare_cmd(name, md->name)) {
3374 if (md->get_value) {
bellarde95c8d52004-09-30 22:22:08 +00003375 *pval = md->get_value(md, md->offset);
bellard9307c4c2004-04-04 12:57:25 +00003376 } else {
Andreas Färber9349b4f2012-03-14 01:38:32 +01003377 CPUArchState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00003378 ptr = (uint8_t *)env + md->offset;
bellard92a31b12005-02-10 22:00:52 +00003379 switch(md->type) {
3380 case MD_I32:
3381 *pval = *(int32_t *)ptr;
3382 break;
3383 case MD_TLONG:
3384 *pval = *(target_long *)ptr;
3385 break;
3386 default:
3387 *pval = 0;
3388 break;
3389 }
bellard9307c4c2004-04-04 12:57:25 +00003390 }
3391 return 0;
3392 }
3393 }
3394 return -1;
3395}
3396
3397static void next(void)
3398{
Blue Swirl660f11b2009-07-31 21:16:51 +00003399 if (*pch != '\0') {
bellard9307c4c2004-04-04 12:57:25 +00003400 pch++;
blueswir1cd390082008-11-16 13:53:32 +00003401 while (qemu_isspace(*pch))
bellard9307c4c2004-04-04 12:57:25 +00003402 pch++;
3403 }
3404}
3405
aliguori376253e2009-03-05 23:01:23 +00003406static int64_t expr_sum(Monitor *mon);
bellard9307c4c2004-04-04 12:57:25 +00003407
aliguori376253e2009-03-05 23:01:23 +00003408static int64_t expr_unary(Monitor *mon)
bellard9307c4c2004-04-04 12:57:25 +00003409{
blueswir1c2efc952007-09-25 17:28:42 +00003410 int64_t n;
bellard9307c4c2004-04-04 12:57:25 +00003411 char *p;
bellard6a00d602005-11-21 23:25:50 +00003412 int ret;
bellard9307c4c2004-04-04 12:57:25 +00003413
3414 switch(*pch) {
3415 case '+':
3416 next();
aliguori376253e2009-03-05 23:01:23 +00003417 n = expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00003418 break;
3419 case '-':
3420 next();
aliguori376253e2009-03-05 23:01:23 +00003421 n = -expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00003422 break;
3423 case '~':
3424 next();
aliguori376253e2009-03-05 23:01:23 +00003425 n = ~expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00003426 break;
3427 case '(':
3428 next();
aliguori376253e2009-03-05 23:01:23 +00003429 n = expr_sum(mon);
bellard9307c4c2004-04-04 12:57:25 +00003430 if (*pch != ')') {
aliguori376253e2009-03-05 23:01:23 +00003431 expr_error(mon, "')' expected");
bellard9307c4c2004-04-04 12:57:25 +00003432 }
3433 next();
3434 break;
bellard81d09122004-07-14 17:21:37 +00003435 case '\'':
3436 pch++;
3437 if (*pch == '\0')
aliguori376253e2009-03-05 23:01:23 +00003438 expr_error(mon, "character constant expected");
bellard81d09122004-07-14 17:21:37 +00003439 n = *pch;
3440 pch++;
3441 if (*pch != '\'')
aliguori376253e2009-03-05 23:01:23 +00003442 expr_error(mon, "missing terminating \' character");
bellard81d09122004-07-14 17:21:37 +00003443 next();
3444 break;
bellard9307c4c2004-04-04 12:57:25 +00003445 case '$':
3446 {
3447 char buf[128], *q;
ths69b34972007-12-17 03:15:52 +00003448 target_long reg=0;
ths3b46e622007-09-17 08:09:54 +00003449
bellard9307c4c2004-04-04 12:57:25 +00003450 pch++;
3451 q = buf;
3452 while ((*pch >= 'a' && *pch <= 'z') ||
3453 (*pch >= 'A' && *pch <= 'Z') ||
3454 (*pch >= '0' && *pch <= '9') ||
bellard57206fd2004-04-25 18:54:52 +00003455 *pch == '_' || *pch == '.') {
bellard9307c4c2004-04-04 12:57:25 +00003456 if ((q - buf) < sizeof(buf) - 1)
3457 *q++ = *pch;
3458 pch++;
3459 }
blueswir1cd390082008-11-16 13:53:32 +00003460 while (qemu_isspace(*pch))
bellard9307c4c2004-04-04 12:57:25 +00003461 pch++;
3462 *q = 0;
blueswir17743e582007-09-24 18:39:04 +00003463 ret = get_monitor_def(&reg, buf);
Markus Armbruster09b94182010-01-20 13:07:30 +01003464 if (ret < 0)
aliguori376253e2009-03-05 23:01:23 +00003465 expr_error(mon, "unknown register");
blueswir17743e582007-09-24 18:39:04 +00003466 n = reg;
bellard9307c4c2004-04-04 12:57:25 +00003467 }
3468 break;
3469 case '\0':
aliguori376253e2009-03-05 23:01:23 +00003470 expr_error(mon, "unexpected end of expression");
bellard9307c4c2004-04-04 12:57:25 +00003471 n = 0;
3472 break;
3473 default:
Luiz Capitulino6b0e33b2012-04-26 16:48:41 -03003474 errno = 0;
bellard4f4fbf72006-06-25 18:28:12 +00003475 n = strtoull(pch, &p, 0);
Luiz Capitulino6b0e33b2012-04-26 16:48:41 -03003476 if (errno == ERANGE) {
3477 expr_error(mon, "number too large");
3478 }
bellard9307c4c2004-04-04 12:57:25 +00003479 if (pch == p) {
Fam Zheng277acfe2013-08-20 10:58:21 +08003480 expr_error(mon, "invalid char '%c' in expression", *p);
bellard9307c4c2004-04-04 12:57:25 +00003481 }
3482 pch = p;
blueswir1cd390082008-11-16 13:53:32 +00003483 while (qemu_isspace(*pch))
bellard9307c4c2004-04-04 12:57:25 +00003484 pch++;
3485 break;
3486 }
3487 return n;
3488}
3489
3490
aliguori376253e2009-03-05 23:01:23 +00003491static int64_t expr_prod(Monitor *mon)
bellard9307c4c2004-04-04 12:57:25 +00003492{
blueswir1c2efc952007-09-25 17:28:42 +00003493 int64_t val, val2;
bellard92a31b12005-02-10 22:00:52 +00003494 int op;
ths3b46e622007-09-17 08:09:54 +00003495
aliguori376253e2009-03-05 23:01:23 +00003496 val = expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00003497 for(;;) {
3498 op = *pch;
3499 if (op != '*' && op != '/' && op != '%')
3500 break;
3501 next();
aliguori376253e2009-03-05 23:01:23 +00003502 val2 = expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00003503 switch(op) {
3504 default:
3505 case '*':
3506 val *= val2;
3507 break;
3508 case '/':
3509 case '%':
ths5fafdf22007-09-16 21:08:06 +00003510 if (val2 == 0)
aliguori376253e2009-03-05 23:01:23 +00003511 expr_error(mon, "division by zero");
bellard9307c4c2004-04-04 12:57:25 +00003512 if (op == '/')
3513 val /= val2;
3514 else
3515 val %= val2;
3516 break;
3517 }
3518 }
3519 return val;
3520}
3521
aliguori376253e2009-03-05 23:01:23 +00003522static int64_t expr_logic(Monitor *mon)
bellard9307c4c2004-04-04 12:57:25 +00003523{
blueswir1c2efc952007-09-25 17:28:42 +00003524 int64_t val, val2;
bellard92a31b12005-02-10 22:00:52 +00003525 int op;
bellard9307c4c2004-04-04 12:57:25 +00003526
aliguori376253e2009-03-05 23:01:23 +00003527 val = expr_prod(mon);
bellard9307c4c2004-04-04 12:57:25 +00003528 for(;;) {
3529 op = *pch;
3530 if (op != '&' && op != '|' && op != '^')
3531 break;
3532 next();
aliguori376253e2009-03-05 23:01:23 +00003533 val2 = expr_prod(mon);
bellard9307c4c2004-04-04 12:57:25 +00003534 switch(op) {
3535 default:
3536 case '&':
3537 val &= val2;
3538 break;
3539 case '|':
3540 val |= val2;
3541 break;
3542 case '^':
3543 val ^= val2;
3544 break;
3545 }
3546 }
3547 return val;
3548}
3549
aliguori376253e2009-03-05 23:01:23 +00003550static int64_t expr_sum(Monitor *mon)
bellard9307c4c2004-04-04 12:57:25 +00003551{
blueswir1c2efc952007-09-25 17:28:42 +00003552 int64_t val, val2;
bellard92a31b12005-02-10 22:00:52 +00003553 int op;
bellard9307c4c2004-04-04 12:57:25 +00003554
aliguori376253e2009-03-05 23:01:23 +00003555 val = expr_logic(mon);
bellard9307c4c2004-04-04 12:57:25 +00003556 for(;;) {
3557 op = *pch;
3558 if (op != '+' && op != '-')
3559 break;
3560 next();
aliguori376253e2009-03-05 23:01:23 +00003561 val2 = expr_logic(mon);
bellard9307c4c2004-04-04 12:57:25 +00003562 if (op == '+')
3563 val += val2;
3564 else
3565 val -= val2;
3566 }
3567 return val;
3568}
3569
aliguori376253e2009-03-05 23:01:23 +00003570static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
bellard9307c4c2004-04-04 12:57:25 +00003571{
3572 pch = *pp;
Peter Maydell6ab7e542013-02-20 15:21:09 +00003573 if (sigsetjmp(expr_env, 0)) {
bellard9307c4c2004-04-04 12:57:25 +00003574 *pp = pch;
3575 return -1;
3576 }
blueswir1cd390082008-11-16 13:53:32 +00003577 while (qemu_isspace(*pch))
bellard9307c4c2004-04-04 12:57:25 +00003578 pch++;
aliguori376253e2009-03-05 23:01:23 +00003579 *pval = expr_sum(mon);
bellard9307c4c2004-04-04 12:57:25 +00003580 *pp = pch;
3581 return 0;
3582}
3583
Markus Armbruster3350a4d2010-01-25 14:23:03 +01003584static int get_double(Monitor *mon, double *pval, const char **pp)
3585{
3586 const char *p = *pp;
3587 char *tailp;
3588 double d;
3589
3590 d = strtod(p, &tailp);
3591 if (tailp == p) {
3592 monitor_printf(mon, "Number expected\n");
3593 return -1;
3594 }
3595 if (d != d || d - d != 0) {
3596 /* NaN or infinity */
3597 monitor_printf(mon, "Bad number\n");
3598 return -1;
3599 }
3600 *pval = d;
3601 *pp = tailp;
3602 return 0;
3603}
3604
Luiz Capitulino4590fd82009-06-09 18:21:30 -03003605/*
3606 * Store the command-name in cmdname, and return a pointer to
3607 * the remaining of the command string.
3608 */
3609static const char *get_command_name(const char *cmdline,
3610 char *cmdname, size_t nlen)
3611{
3612 size_t len;
3613 const char *p, *pstart;
3614
3615 p = cmdline;
3616 while (qemu_isspace(*p))
3617 p++;
3618 if (*p == '\0')
3619 return NULL;
3620 pstart = p;
3621 while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
3622 p++;
3623 len = p - pstart;
3624 if (len > nlen - 1)
3625 len = nlen - 1;
3626 memcpy(cmdname, pstart, len);
3627 cmdname[len] = '\0';
3628 return p;
3629}
3630
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003631/**
3632 * Read key of 'type' into 'key' and return the current
3633 * 'type' pointer.
3634 */
3635static char *key_get_info(const char *type, char **key)
3636{
3637 size_t len;
3638 char *p, *str;
3639
3640 if (*type == ',')
3641 type++;
3642
3643 p = strchr(type, ':');
3644 if (!p) {
3645 *key = NULL;
3646 return NULL;
3647 }
3648 len = p - type;
3649
Anthony Liguori7267c092011-08-20 22:09:37 -05003650 str = g_malloc(len + 1);
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003651 memcpy(str, type, len);
3652 str[len] = '\0';
3653
3654 *key = str;
3655 return ++p;
3656}
3657
bellard9307c4c2004-04-04 12:57:25 +00003658static int default_fmt_format = 'x';
3659static int default_fmt_size = 4;
3660
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02003661static int is_valid_option(const char *c, const char *typestr)
3662{
3663 char option[3];
3664
3665 option[0] = '-';
3666 option[1] = *c;
3667 option[2] = '\0';
3668
3669 typestr = strstr(typestr, option);
3670 return (typestr != NULL);
3671}
3672
Luiz Capitulino945c5ac2010-09-13 13:17:58 -03003673static const mon_cmd_t *search_dispatch_table(const mon_cmd_t *disp_table,
3674 const char *cmdname)
Luiz Capitulino7fd669a2009-11-26 22:58:54 -02003675{
3676 const mon_cmd_t *cmd;
3677
Luiz Capitulino945c5ac2010-09-13 13:17:58 -03003678 for (cmd = disp_table; cmd->name != NULL; cmd++) {
Luiz Capitulino7fd669a2009-11-26 22:58:54 -02003679 if (compare_cmd(cmdname, cmd->name)) {
3680 return cmd;
3681 }
3682 }
3683
3684 return NULL;
3685}
3686
Luiz Capitulinobead3ce2010-09-15 17:08:39 -03003687static const mon_cmd_t *qmp_find_cmd(const char *cmdname)
3688{
Luiz Capitulinof36b4af2010-09-15 17:17:45 -03003689 return search_dispatch_table(qmp_cmds, cmdname);
Luiz Capitulinobead3ce2010-09-15 17:08:39 -03003690}
3691
Wenchao Xia5f3d3352013-01-14 14:06:27 +08003692/*
3693 * Parse @cmdline according to command table @table.
3694 * If @cmdline is blank, return NULL.
3695 * If it can't be parsed, report to @mon, and return NULL.
3696 * Else, insert command arguments into @qdict, and return the command.
Peter Maydell085d8132013-03-18 17:20:07 +00003697 * If a sub-command table exists, and if @cmdline contains an additional string
3698 * for a sub-command, this function will try to search the sub-command table.
3699 * If no additional string for a sub-command is present, this function will
3700 * return the command found in @table.
Wenchao Xia5f3d3352013-01-14 14:06:27 +08003701 * Do not assume the returned command points into @table! It doesn't
3702 * when the command is a sub-command.
3703 */
Anthony Liguoric227f092009-10-01 16:12:16 -05003704static const mon_cmd_t *monitor_parse_command(Monitor *mon,
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003705 const char *cmdline,
Wenchao Xia5f3d3352013-01-14 14:06:27 +08003706 int start,
3707 mon_cmd_t *table,
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003708 QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +00003709{
Luiz Capitulino4590fd82009-06-09 18:21:30 -03003710 const char *p, *typestr;
Luiz Capitulino53773582009-08-28 15:27:25 -03003711 int c;
Anthony Liguoric227f092009-10-01 16:12:16 -05003712 const mon_cmd_t *cmd;
bellard9307c4c2004-04-04 12:57:25 +00003713 char cmdname[256];
3714 char buf[1024];
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003715 char *key;
bellard9dc39cb2004-03-14 21:38:27 +00003716
3717#ifdef DEBUG
Wenchao Xia5f3d3352013-01-14 14:06:27 +08003718 monitor_printf(mon, "command='%s', start='%d'\n", cmdline, start);
bellard9dc39cb2004-03-14 21:38:27 +00003719#endif
ths3b46e622007-09-17 08:09:54 +00003720
bellard9307c4c2004-04-04 12:57:25 +00003721 /* extract the command name */
Wenchao Xia5f3d3352013-01-14 14:06:27 +08003722 p = get_command_name(cmdline + start, cmdname, sizeof(cmdname));
Luiz Capitulino4590fd82009-06-09 18:21:30 -03003723 if (!p)
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003724 return NULL;
ths3b46e622007-09-17 08:09:54 +00003725
Wenchao Xia5f3d3352013-01-14 14:06:27 +08003726 cmd = search_dispatch_table(table, cmdname);
Luiz Capitulino7fd669a2009-11-26 22:58:54 -02003727 if (!cmd) {
Wenchao Xia5f3d3352013-01-14 14:06:27 +08003728 monitor_printf(mon, "unknown command: '%.*s'\n",
3729 (int)(p - cmdline), cmdline);
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003730 return NULL;
Luiz Capitulinod91d9bf2009-06-09 18:21:54 -03003731 }
bellard9307c4c2004-04-04 12:57:25 +00003732
Wenchao Xia5f3d3352013-01-14 14:06:27 +08003733 /* filter out following useless space */
3734 while (qemu_isspace(*p)) {
3735 p++;
3736 }
3737 /* search sub command */
3738 if (cmd->sub_table != NULL) {
3739 /* check if user set additional command */
3740 if (*p == '\0') {
3741 return cmd;
3742 }
3743 return monitor_parse_command(mon, cmdline, p - cmdline,
3744 cmd->sub_table, qdict);
3745 }
3746
bellard9307c4c2004-04-04 12:57:25 +00003747 /* parse the parameters */
3748 typestr = cmd->args_type;
bellard9307c4c2004-04-04 12:57:25 +00003749 for(;;) {
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003750 typestr = key_get_info(typestr, &key);
3751 if (!typestr)
bellard9307c4c2004-04-04 12:57:25 +00003752 break;
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003753 c = *typestr;
bellard9307c4c2004-04-04 12:57:25 +00003754 typestr++;
3755 switch(c) {
3756 case 'F':
bellard81d09122004-07-14 17:21:37 +00003757 case 'B':
bellard9307c4c2004-04-04 12:57:25 +00003758 case 's':
3759 {
3760 int ret;
ths3b46e622007-09-17 08:09:54 +00003761
blueswir1cd390082008-11-16 13:53:32 +00003762 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00003763 p++;
3764 if (*typestr == '?') {
3765 typestr++;
3766 if (*p == '\0') {
3767 /* no optional string: NULL argument */
Luiz Capitulino53773582009-08-28 15:27:25 -03003768 break;
bellard9307c4c2004-04-04 12:57:25 +00003769 }
3770 }
3771 ret = get_str(buf, sizeof(buf), &p);
3772 if (ret < 0) {
bellard81d09122004-07-14 17:21:37 +00003773 switch(c) {
3774 case 'F':
aliguori376253e2009-03-05 23:01:23 +00003775 monitor_printf(mon, "%s: filename expected\n",
3776 cmdname);
bellard81d09122004-07-14 17:21:37 +00003777 break;
3778 case 'B':
aliguori376253e2009-03-05 23:01:23 +00003779 monitor_printf(mon, "%s: block device name expected\n",
3780 cmdname);
bellard81d09122004-07-14 17:21:37 +00003781 break;
3782 default:
aliguori376253e2009-03-05 23:01:23 +00003783 monitor_printf(mon, "%s: string expected\n", cmdname);
bellard81d09122004-07-14 17:21:37 +00003784 break;
3785 }
bellard9307c4c2004-04-04 12:57:25 +00003786 goto fail;
3787 }
Luiz Capitulino53773582009-08-28 15:27:25 -03003788 qdict_put(qdict, key, qstring_from_str(buf));
bellard9307c4c2004-04-04 12:57:25 +00003789 }
3790 break;
Markus Armbruster361127d2010-02-10 20:24:35 +01003791 case 'O':
3792 {
3793 QemuOptsList *opts_list;
3794 QemuOpts *opts;
3795
3796 opts_list = qemu_find_opts(key);
3797 if (!opts_list || opts_list->desc->name) {
3798 goto bad_type;
3799 }
3800 while (qemu_isspace(*p)) {
3801 p++;
3802 }
3803 if (!*p)
3804 break;
3805 if (get_str(buf, sizeof(buf), &p) < 0) {
3806 goto fail;
3807 }
3808 opts = qemu_opts_parse(opts_list, buf, 1);
3809 if (!opts) {
3810 goto fail;
3811 }
3812 qemu_opts_to_qdict(opts, qdict);
3813 qemu_opts_del(opts);
3814 }
3815 break;
bellard9307c4c2004-04-04 12:57:25 +00003816 case '/':
3817 {
3818 int count, format, size;
ths3b46e622007-09-17 08:09:54 +00003819
blueswir1cd390082008-11-16 13:53:32 +00003820 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00003821 p++;
3822 if (*p == '/') {
3823 /* format found */
3824 p++;
3825 count = 1;
blueswir1cd390082008-11-16 13:53:32 +00003826 if (qemu_isdigit(*p)) {
bellard9307c4c2004-04-04 12:57:25 +00003827 count = 0;
blueswir1cd390082008-11-16 13:53:32 +00003828 while (qemu_isdigit(*p)) {
bellard9307c4c2004-04-04 12:57:25 +00003829 count = count * 10 + (*p - '0');
3830 p++;
3831 }
3832 }
3833 size = -1;
3834 format = -1;
3835 for(;;) {
3836 switch(*p) {
3837 case 'o':
3838 case 'd':
3839 case 'u':
3840 case 'x':
3841 case 'i':
3842 case 'c':
3843 format = *p++;
3844 break;
3845 case 'b':
3846 size = 1;
3847 p++;
3848 break;
3849 case 'h':
3850 size = 2;
3851 p++;
3852 break;
3853 case 'w':
3854 size = 4;
3855 p++;
3856 break;
3857 case 'g':
3858 case 'L':
3859 size = 8;
3860 p++;
3861 break;
3862 default:
3863 goto next;
3864 }
3865 }
3866 next:
blueswir1cd390082008-11-16 13:53:32 +00003867 if (*p != '\0' && !qemu_isspace(*p)) {
aliguori376253e2009-03-05 23:01:23 +00003868 monitor_printf(mon, "invalid char in format: '%c'\n",
3869 *p);
bellard9307c4c2004-04-04 12:57:25 +00003870 goto fail;
3871 }
bellard9307c4c2004-04-04 12:57:25 +00003872 if (format < 0)
3873 format = default_fmt_format;
bellard4c27ba22004-04-25 18:05:08 +00003874 if (format != 'i') {
3875 /* for 'i', not specifying a size gives -1 as size */
3876 if (size < 0)
3877 size = default_fmt_size;
aurel32e90f0092008-10-01 21:45:51 +00003878 default_fmt_size = size;
bellard4c27ba22004-04-25 18:05:08 +00003879 }
bellard9307c4c2004-04-04 12:57:25 +00003880 default_fmt_format = format;
3881 } else {
3882 count = 1;
3883 format = default_fmt_format;
bellard4c27ba22004-04-25 18:05:08 +00003884 if (format != 'i') {
3885 size = default_fmt_size;
3886 } else {
3887 size = -1;
3888 }
bellard9307c4c2004-04-04 12:57:25 +00003889 }
Luiz Capitulinof7188bb2009-08-28 15:27:10 -03003890 qdict_put(qdict, "count", qint_from_int(count));
3891 qdict_put(qdict, "format", qint_from_int(format));
3892 qdict_put(qdict, "size", qint_from_int(size));
bellard9307c4c2004-04-04 12:57:25 +00003893 }
3894 break;
3895 case 'i':
bellard92a31b12005-02-10 22:00:52 +00003896 case 'l':
Luiz Capitulinob6e098d2009-12-18 13:25:04 -02003897 case 'M':
bellard9307c4c2004-04-04 12:57:25 +00003898 {
blueswir1c2efc952007-09-25 17:28:42 +00003899 int64_t val;
blueswir17743e582007-09-24 18:39:04 +00003900
blueswir1cd390082008-11-16 13:53:32 +00003901 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00003902 p++;
bellard34405572004-06-08 00:55:58 +00003903 if (*typestr == '?' || *typestr == '.') {
bellard34405572004-06-08 00:55:58 +00003904 if (*typestr == '?') {
Luiz Capitulino53773582009-08-28 15:27:25 -03003905 if (*p == '\0') {
3906 typestr++;
3907 break;
3908 }
bellard34405572004-06-08 00:55:58 +00003909 } else {
3910 if (*p == '.') {
3911 p++;
blueswir1cd390082008-11-16 13:53:32 +00003912 while (qemu_isspace(*p))
bellard34405572004-06-08 00:55:58 +00003913 p++;
bellard34405572004-06-08 00:55:58 +00003914 } else {
Luiz Capitulino53773582009-08-28 15:27:25 -03003915 typestr++;
3916 break;
bellard34405572004-06-08 00:55:58 +00003917 }
3918 }
bellard13224a82006-07-14 22:03:35 +00003919 typestr++;
bellard9307c4c2004-04-04 12:57:25 +00003920 }
aliguori376253e2009-03-05 23:01:23 +00003921 if (get_expr(mon, &val, &p))
bellard9307c4c2004-04-04 12:57:25 +00003922 goto fail;
Luiz Capitulino675ebef2009-08-28 15:27:26 -03003923 /* Check if 'i' is greater than 32-bit */
3924 if ((c == 'i') && ((val >> 32) & 0xffffffff)) {
3925 monitor_printf(mon, "\'%s\' has failed: ", cmdname);
3926 monitor_printf(mon, "integer is for 32-bit values\n");
3927 goto fail;
Luiz Capitulinob6e098d2009-12-18 13:25:04 -02003928 } else if (c == 'M') {
Luiz Capitulino91162842012-04-26 17:34:30 -03003929 if (val < 0) {
3930 monitor_printf(mon, "enter a positive value\n");
3931 goto fail;
3932 }
Luiz Capitulinob6e098d2009-12-18 13:25:04 -02003933 val <<= 20;
Luiz Capitulino675ebef2009-08-28 15:27:26 -03003934 }
Luiz Capitulino53773582009-08-28 15:27:25 -03003935 qdict_put(qdict, key, qint_from_int(val));
bellard9307c4c2004-04-04 12:57:25 +00003936 }
3937 break;
Jes Sorensendbc0c672010-10-21 17:15:47 +02003938 case 'o':
3939 {
Jes Sorensen70b4f4b2011-01-05 11:41:02 +01003940 int64_t val;
Jes Sorensendbc0c672010-10-21 17:15:47 +02003941 char *end;
3942
3943 while (qemu_isspace(*p)) {
3944 p++;
3945 }
3946 if (*typestr == '?') {
3947 typestr++;
3948 if (*p == '\0') {
3949 break;
3950 }
3951 }
3952 val = strtosz(p, &end);
3953 if (val < 0) {
3954 monitor_printf(mon, "invalid size\n");
3955 goto fail;
3956 }
3957 qdict_put(qdict, key, qint_from_int(val));
3958 p = end;
3959 }
3960 break;
Markus Armbrusterfccfb11e2010-01-25 14:23:06 +01003961 case 'T':
Markus Armbruster3350a4d2010-01-25 14:23:03 +01003962 {
3963 double val;
3964
3965 while (qemu_isspace(*p))
3966 p++;
3967 if (*typestr == '?') {
3968 typestr++;
3969 if (*p == '\0') {
3970 break;
3971 }
3972 }
3973 if (get_double(mon, &val, &p) < 0) {
3974 goto fail;
3975 }
Jes Sorensen07de3e62010-10-21 17:15:49 +02003976 if (p[0] && p[1] == 's') {
Markus Armbrusterfccfb11e2010-01-25 14:23:06 +01003977 switch (*p) {
3978 case 'm':
3979 val /= 1e3; p += 2; break;
3980 case 'u':
3981 val /= 1e6; p += 2; break;
3982 case 'n':
3983 val /= 1e9; p += 2; break;
3984 }
3985 }
Markus Armbruster3350a4d2010-01-25 14:23:03 +01003986 if (*p && !qemu_isspace(*p)) {
3987 monitor_printf(mon, "Unknown unit suffix\n");
3988 goto fail;
3989 }
3990 qdict_put(qdict, key, qfloat_from_double(val));
3991 }
3992 break;
Markus Armbruster942cd1f2010-03-26 09:07:09 +01003993 case 'b':
3994 {
3995 const char *beg;
3996 int val;
3997
3998 while (qemu_isspace(*p)) {
3999 p++;
4000 }
4001 beg = p;
4002 while (qemu_isgraph(*p)) {
4003 p++;
4004 }
4005 if (p - beg == 2 && !memcmp(beg, "on", p - beg)) {
4006 val = 1;
4007 } else if (p - beg == 3 && !memcmp(beg, "off", p - beg)) {
4008 val = 0;
4009 } else {
4010 monitor_printf(mon, "Expected 'on' or 'off'\n");
4011 goto fail;
4012 }
4013 qdict_put(qdict, key, qbool_from_int(val));
4014 }
4015 break;
bellard9307c4c2004-04-04 12:57:25 +00004016 case '-':
4017 {
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02004018 const char *tmp = p;
Luiz Capitulinoeb159d12010-05-28 15:25:24 -03004019 int skip_key = 0;
bellard9307c4c2004-04-04 12:57:25 +00004020 /* option */
ths3b46e622007-09-17 08:09:54 +00004021
bellard9307c4c2004-04-04 12:57:25 +00004022 c = *typestr++;
4023 if (c == '\0')
4024 goto bad_type;
blueswir1cd390082008-11-16 13:53:32 +00004025 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00004026 p++;
bellard9307c4c2004-04-04 12:57:25 +00004027 if (*p == '-') {
4028 p++;
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02004029 if(c != *p) {
4030 if(!is_valid_option(p, typestr)) {
4031
4032 monitor_printf(mon, "%s: unsupported option -%c\n",
4033 cmdname, *p);
4034 goto fail;
4035 } else {
4036 skip_key = 1;
4037 }
bellard9307c4c2004-04-04 12:57:25 +00004038 }
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02004039 if(skip_key) {
4040 p = tmp;
4041 } else {
Luiz Capitulinoeb159d12010-05-28 15:25:24 -03004042 /* has option */
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02004043 p++;
Luiz Capitulinoeb159d12010-05-28 15:25:24 -03004044 qdict_put(qdict, key, qbool_from_int(1));
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02004045 }
bellard9307c4c2004-04-04 12:57:25 +00004046 }
bellard9307c4c2004-04-04 12:57:25 +00004047 }
4048 break;
Wenchao Xia129be002013-08-27 20:38:26 +08004049 case 'S':
4050 {
4051 /* package all remaining string */
4052 int len;
4053
4054 while (qemu_isspace(*p)) {
4055 p++;
4056 }
4057 if (*typestr == '?') {
4058 typestr++;
4059 if (*p == '\0') {
4060 /* no remaining string: NULL argument */
4061 break;
4062 }
4063 }
4064 len = strlen(p);
4065 if (len <= 0) {
4066 monitor_printf(mon, "%s: string expected\n",
4067 cmdname);
4068 break;
4069 }
4070 qdict_put(qdict, key, qstring_from_str(p));
4071 p += len;
4072 }
4073 break;
bellard9307c4c2004-04-04 12:57:25 +00004074 default:
4075 bad_type:
aliguori376253e2009-03-05 23:01:23 +00004076 monitor_printf(mon, "%s: unknown type '%c'\n", cmdname, c);
bellard9307c4c2004-04-04 12:57:25 +00004077 goto fail;
4078 }
Anthony Liguori7267c092011-08-20 22:09:37 -05004079 g_free(key);
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03004080 key = NULL;
bellard9307c4c2004-04-04 12:57:25 +00004081 }
4082 /* check that all arguments were parsed */
blueswir1cd390082008-11-16 13:53:32 +00004083 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00004084 p++;
4085 if (*p != '\0') {
aliguori376253e2009-03-05 23:01:23 +00004086 monitor_printf(mon, "%s: extraneous characters at the end of line\n",
4087 cmdname);
bellard9307c4c2004-04-04 12:57:25 +00004088 goto fail;
4089 }
4090
Luiz Capitulino55f81d92009-08-28 15:27:22 -03004091 return cmd;
Gerd Hoffmannac7531e2009-08-14 10:36:06 +02004092
Luiz Capitulino55f81d92009-08-28 15:27:22 -03004093fail:
Anthony Liguori7267c092011-08-20 22:09:37 -05004094 g_free(key);
Luiz Capitulino55f81d92009-08-28 15:27:22 -03004095 return NULL;
4096}
4097
Markus Armbrusterd6f46832010-02-17 10:52:26 +01004098void monitor_set_error(Monitor *mon, QError *qerror)
4099{
4100 /* report only the first error */
4101 if (!mon->error) {
4102 mon->error = qerror;
4103 } else {
Markus Armbrusterd6f46832010-02-17 10:52:26 +01004104 QDECREF(qerror);
4105 }
4106}
4107
Luiz Capitulinobb89c2e2010-02-10 23:50:05 -02004108static void handler_audit(Monitor *mon, const mon_cmd_t *cmd, int ret)
4109{
Luiz Capitulino6d441432010-11-22 16:35:09 -02004110 if (ret && !monitor_has_error(mon)) {
4111 /*
4112 * If it returns failure, it must have passed on error.
4113 *
4114 * Action: Report an internal error to the client if in QMP.
4115 */
4116 qerror_report(QERR_UNDEFINED_ERROR);
Luiz Capitulino6d441432010-11-22 16:35:09 -02004117 }
Luiz Capitulinobb89c2e2010-02-10 23:50:05 -02004118}
4119
Luiz Capitulinof3c157c2009-11-26 22:58:55 -02004120static void handle_user_command(Monitor *mon, const char *cmdline)
Luiz Capitulino55f81d92009-08-28 15:27:22 -03004121{
Luiz Capitulino55f81d92009-08-28 15:27:22 -03004122 QDict *qdict;
Anthony Liguoric227f092009-10-01 16:12:16 -05004123 const mon_cmd_t *cmd;
Luiz Capitulino55f81d92009-08-28 15:27:22 -03004124
4125 qdict = qdict_new();
4126
Wenchao Xia77172392013-08-27 20:38:20 +08004127 cmd = monitor_parse_command(mon, cmdline, 0, mon->cmd_table, qdict);
Luiz Capitulino13917be2009-10-07 13:41:54 -03004128 if (!cmd)
4129 goto out;
4130
Luiz Capitulino4903de02010-09-16 11:01:32 -03004131 if (handler_is_async(cmd)) {
Adam Litke940cc302010-01-25 12:18:44 -06004132 user_async_cmd_handler(mon, cmd, qdict);
Luiz Capitulino9e807212010-09-16 10:58:59 -03004133 } else if (handler_is_qobject(cmd)) {
Luiz Capitulinode79ba62010-09-16 11:06:11 -03004134 QObject *data = NULL;
4135
4136 /* XXX: ignores the error code */
4137 cmd->mhandler.cmd_new(mon, qdict, &data);
4138 assert(!monitor_has_error(mon));
4139 if (data) {
4140 cmd->user_print(mon, data);
4141 qobject_decref(data);
4142 }
Luiz Capitulino13917be2009-10-07 13:41:54 -03004143 } else {
Luiz Capitulinoaf4ce882009-10-07 13:41:52 -03004144 cmd->mhandler.cmd(mon, qdict);
Luiz Capitulino55f81d92009-08-28 15:27:22 -03004145 }
4146
Luiz Capitulino13917be2009-10-07 13:41:54 -03004147out:
Luiz Capitulinof7188bb2009-08-28 15:27:10 -03004148 QDECREF(qdict);
bellard9dc39cb2004-03-14 21:38:27 +00004149}
4150
Wenchao Xiacd5c6bb2013-08-27 20:38:13 +08004151static void cmd_completion(Monitor *mon, const char *name, const char *list)
bellard81d09122004-07-14 17:21:37 +00004152{
4153 const char *p, *pstart;
4154 char cmd[128];
4155 int len;
4156
4157 p = list;
4158 for(;;) {
4159 pstart = p;
4160 p = strchr(p, '|');
4161 if (!p)
4162 p = pstart + strlen(pstart);
4163 len = p - pstart;
4164 if (len > sizeof(cmd) - 2)
4165 len = sizeof(cmd) - 2;
4166 memcpy(cmd, pstart, len);
4167 cmd[len] = '\0';
4168 if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
Wenchao Xiacd5c6bb2013-08-27 20:38:13 +08004169 readline_add_completion(mon->rs, cmd);
bellard81d09122004-07-14 17:21:37 +00004170 }
4171 if (*p == '\0')
4172 break;
4173 p++;
4174 }
4175}
4176
Wenchao Xiacb8f68b2013-08-27 20:38:14 +08004177static void file_completion(Monitor *mon, const char *input)
bellard81d09122004-07-14 17:21:37 +00004178{
4179 DIR *ffs;
4180 struct dirent *d;
4181 char path[1024];
4182 char file[1024], file_prefix[1024];
4183 int input_path_len;
4184 const char *p;
4185
ths5fafdf22007-09-16 21:08:06 +00004186 p = strrchr(input, '/');
bellard81d09122004-07-14 17:21:37 +00004187 if (!p) {
4188 input_path_len = 0;
4189 pstrcpy(file_prefix, sizeof(file_prefix), input);
blueswir1363a37d2008-08-21 17:58:08 +00004190 pstrcpy(path, sizeof(path), ".");
bellard81d09122004-07-14 17:21:37 +00004191 } else {
4192 input_path_len = p - input + 1;
4193 memcpy(path, input, input_path_len);
4194 if (input_path_len > sizeof(path) - 1)
4195 input_path_len = sizeof(path) - 1;
4196 path[input_path_len] = '\0';
4197 pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
4198 }
4199#ifdef DEBUG_COMPLETION
Wenchao Xiacb8f68b2013-08-27 20:38:14 +08004200 monitor_printf(mon, "input='%s' path='%s' prefix='%s'\n",
aliguori376253e2009-03-05 23:01:23 +00004201 input, path, file_prefix);
bellard81d09122004-07-14 17:21:37 +00004202#endif
4203 ffs = opendir(path);
4204 if (!ffs)
4205 return;
4206 for(;;) {
4207 struct stat sb;
4208 d = readdir(ffs);
4209 if (!d)
4210 break;
Kusanagi Kouichi46c7fc12010-10-20 18:00:01 +09004211
4212 if (strcmp(d->d_name, ".") == 0 || strcmp(d->d_name, "..") == 0) {
4213 continue;
4214 }
4215
bellard81d09122004-07-14 17:21:37 +00004216 if (strstart(d->d_name, file_prefix, NULL)) {
4217 memcpy(file, input, input_path_len);
blueswir1363a37d2008-08-21 17:58:08 +00004218 if (input_path_len < sizeof(file))
4219 pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
4220 d->d_name);
bellard81d09122004-07-14 17:21:37 +00004221 /* stat the file to find out if it's a directory.
4222 * In that case add a slash to speed up typing long paths
4223 */
Markus Armbrusterc951d9a2011-11-16 15:43:47 +01004224 if (stat(file, &sb) == 0 && S_ISDIR(sb.st_mode)) {
blueswir1363a37d2008-08-21 17:58:08 +00004225 pstrcat(file, sizeof(file), "/");
Markus Armbrusterc951d9a2011-11-16 15:43:47 +01004226 }
Wenchao Xiacb8f68b2013-08-27 20:38:14 +08004227 readline_add_completion(mon->rs, file);
bellard81d09122004-07-14 17:21:37 +00004228 }
4229 }
4230 closedir(ffs);
4231}
4232
Wenchao Xia599a9262013-08-27 20:38:15 +08004233typedef struct MonitorBlockComplete {
4234 Monitor *mon;
4235 const char *input;
4236} MonitorBlockComplete;
4237
aliguori51de9762009-03-05 23:00:43 +00004238static void block_completion_it(void *opaque, BlockDriverState *bs)
bellard81d09122004-07-14 17:21:37 +00004239{
aliguori51de9762009-03-05 23:00:43 +00004240 const char *name = bdrv_get_device_name(bs);
Wenchao Xia599a9262013-08-27 20:38:15 +08004241 MonitorBlockComplete *mbc = opaque;
4242 Monitor *mon = mbc->mon;
4243 const char *input = mbc->input;
bellard81d09122004-07-14 17:21:37 +00004244
4245 if (input[0] == '\0' ||
4246 !strncmp(name, (char *)input, strlen(input))) {
Wenchao Xia599a9262013-08-27 20:38:15 +08004247 readline_add_completion(mon->rs, name);
bellard81d09122004-07-14 17:21:37 +00004248 }
4249}
4250
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03004251static const char *next_arg_type(const char *typestr)
4252{
4253 const char *p = strchr(typestr, ':');
4254 return (p != NULL ? ++p : typestr);
4255}
4256
Wenchao Xiac35b6402013-08-27 20:38:24 +08004257static void monitor_find_completion_by_table(Monitor *mon,
4258 const mon_cmd_t *cmd_table,
4259 char **args,
4260 int nb_args)
bellard81d09122004-07-14 17:21:37 +00004261{
4262 const char *cmdname;
Wenchao Xiac35b6402013-08-27 20:38:24 +08004263 int i;
bellard81d09122004-07-14 17:21:37 +00004264 const char *ptype, *str;
Anthony Liguoric227f092009-10-01 16:12:16 -05004265 const mon_cmd_t *cmd;
Wenchao Xia599a9262013-08-27 20:38:15 +08004266 MonitorBlockComplete mbs;
bellard81d09122004-07-14 17:21:37 +00004267
bellard81d09122004-07-14 17:21:37 +00004268 if (nb_args <= 1) {
4269 /* command completion */
4270 if (nb_args == 0)
4271 cmdname = "";
4272 else
4273 cmdname = args[0];
Wenchao Xiad2674b22013-08-27 20:38:16 +08004274 readline_set_completion_index(mon->rs, strlen(cmdname));
Wenchao Xiac35b6402013-08-27 20:38:24 +08004275 for (cmd = cmd_table; cmd->name != NULL; cmd++) {
Wenchao Xiacd5c6bb2013-08-27 20:38:13 +08004276 cmd_completion(mon, cmdname, cmd->name);
bellard81d09122004-07-14 17:21:37 +00004277 }
4278 } else {
4279 /* find the command */
Wenchao Xiac35b6402013-08-27 20:38:24 +08004280 for (cmd = cmd_table; cmd->name != NULL; cmd++) {
Jan Kiszka03a63482010-06-16 00:38:33 +02004281 if (compare_cmd(args[0], cmd->name)) {
4282 break;
4283 }
bellard81d09122004-07-14 17:21:37 +00004284 }
Jan Kiszka03a63482010-06-16 00:38:33 +02004285 if (!cmd->name) {
Wenchao Xiac35b6402013-08-27 20:38:24 +08004286 return;
Jan Kiszka03a63482010-06-16 00:38:33 +02004287 }
4288
Wenchao Xiad903a772013-08-27 20:38:25 +08004289 if (cmd->sub_table) {
4290 /* do the job again */
4291 return monitor_find_completion_by_table(mon, cmd->sub_table,
4292 &args[1], nb_args - 1);
4293 }
4294
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03004295 ptype = next_arg_type(cmd->args_type);
bellard81d09122004-07-14 17:21:37 +00004296 for(i = 0; i < nb_args - 2; i++) {
4297 if (*ptype != '\0') {
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03004298 ptype = next_arg_type(ptype);
bellard81d09122004-07-14 17:21:37 +00004299 while (*ptype == '?')
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03004300 ptype = next_arg_type(ptype);
bellard81d09122004-07-14 17:21:37 +00004301 }
4302 }
4303 str = args[nb_args - 1];
Blue Swirl2a1704a2009-08-23 20:10:28 +00004304 if (*ptype == '-' && ptype[1] != '\0') {
Jan Kiszka3b6dbf22010-06-16 00:38:34 +02004305 ptype = next_arg_type(ptype);
Blue Swirl2a1704a2009-08-23 20:10:28 +00004306 }
bellard81d09122004-07-14 17:21:37 +00004307 switch(*ptype) {
4308 case 'F':
4309 /* file completion */
Wenchao Xiad2674b22013-08-27 20:38:16 +08004310 readline_set_completion_index(mon->rs, strlen(str));
Wenchao Xiacb8f68b2013-08-27 20:38:14 +08004311 file_completion(mon, str);
bellard81d09122004-07-14 17:21:37 +00004312 break;
4313 case 'B':
4314 /* block device name completion */
Wenchao Xia599a9262013-08-27 20:38:15 +08004315 mbs.mon = mon;
4316 mbs.input = str;
4317 readline_set_completion_index(mon->rs, strlen(str));
4318 bdrv_iterate(block_completion_it, &mbs);
bellard81d09122004-07-14 17:21:37 +00004319 break;
bellard7fe48482004-10-09 18:08:01 +00004320 case 's':
Wenchao Xia129be002013-08-27 20:38:26 +08004321 case 'S':
Wenchao Xiad903a772013-08-27 20:38:25 +08004322 if (!strcmp(cmd->name, "sendkey")) {
blueswir1e600d1e2009-03-08 17:42:02 +00004323 char *sep = strrchr(str, '-');
4324 if (sep)
4325 str = sep + 1;
Wenchao Xiad2674b22013-08-27 20:38:16 +08004326 readline_set_completion_index(mon->rs, strlen(str));
Amos Kong1048c882012-08-31 10:56:25 +08004327 for (i = 0; i < Q_KEY_CODE_MAX; i++) {
Wenchao Xiacd5c6bb2013-08-27 20:38:13 +08004328 cmd_completion(mon, str, QKeyCode_lookup[i]);
bellard64866c32006-05-07 18:03:31 +00004329 }
Jan Kiszkaf3353c62009-06-25 08:22:02 +02004330 } else if (!strcmp(cmd->name, "help|?")) {
Wenchao Xia7ca0e062013-08-27 20:38:27 +08004331 monitor_find_completion_by_table(mon, cmd_table,
4332 &args[1], nb_args - 1);
bellard7fe48482004-10-09 18:08:01 +00004333 }
4334 break;
bellard81d09122004-07-14 17:21:37 +00004335 default:
4336 break;
4337 }
4338 }
Wenchao Xiac35b6402013-08-27 20:38:24 +08004339}
4340
4341static void monitor_find_completion(Monitor *mon,
4342 const char *cmdline)
4343{
4344 char *args[MAX_ARGS];
4345 int nb_args, len;
4346
4347 /* 1. parse the cmdline */
4348 if (parse_cmdline(cmdline, &nb_args, args) < 0) {
4349 return;
4350 }
4351#ifdef DEBUG_COMPLETION
4352 for (i = 0; i < nb_args; i++) {
4353 monitor_printf(mon, "arg%d = '%s'\n", i, args[i]);
4354 }
4355#endif
4356
4357 /* if the line ends with a space, it means we want to complete the
4358 next arg */
4359 len = strlen(cmdline);
4360 if (len > 0 && qemu_isspace(cmdline[len - 1])) {
4361 if (nb_args >= MAX_ARGS) {
4362 goto cleanup;
4363 }
4364 args[nb_args++] = g_strdup("");
4365 }
4366
4367 /* 2. auto complete according to args */
4368 monitor_find_completion_by_table(mon, mon->cmd_table, args, nb_args);
Jan Kiszka03a63482010-06-16 00:38:33 +02004369
4370cleanup:
Wenchao Xiadcc70cd2013-08-27 20:38:22 +08004371 free_cmdline_args(args, nb_args);
bellard81d09122004-07-14 17:21:37 +00004372}
4373
aliguori731b0362009-03-05 23:01:42 +00004374static int monitor_can_read(void *opaque)
bellard9dc39cb2004-03-14 21:38:27 +00004375{
aliguori731b0362009-03-05 23:01:42 +00004376 Monitor *mon = opaque;
4377
Jan Kiszkac62313b2009-12-04 14:05:29 +01004378 return (mon->suspend_cnt == 0) ? 1 : 0;
bellard9dc39cb2004-03-14 21:38:27 +00004379}
4380
Luiz Capitulino09069b12010-02-04 18:10:06 -02004381static int invalid_qmp_mode(const Monitor *mon, const char *cmd_name)
4382{
4383 int is_cap = compare_cmd(cmd_name, "qmp_capabilities");
4384 return (qmp_cmd_mode(mon) ? is_cap : !is_cap);
4385}
4386
Luiz Capitulino2dbc8db2010-05-26 16:13:09 -03004387/*
Luiz Capitulino4af91932010-06-22 11:44:05 -03004388 * Argument validation rules:
4389 *
4390 * 1. The argument must exist in cmd_args qdict
4391 * 2. The argument type must be the expected one
4392 *
4393 * Special case: If the argument doesn't exist in cmd_args and
4394 * the QMP_ACCEPT_UNKNOWNS flag is set, then the
4395 * checking is skipped for it.
4396 */
4397static int check_client_args_type(const QDict *client_args,
4398 const QDict *cmd_args, int flags)
4399{
4400 const QDictEntry *ent;
4401
4402 for (ent = qdict_first(client_args); ent;ent = qdict_next(client_args,ent)){
4403 QObject *obj;
4404 QString *arg_type;
4405 const QObject *client_arg = qdict_entry_value(ent);
4406 const char *client_arg_name = qdict_entry_key(ent);
4407
4408 obj = qdict_get(cmd_args, client_arg_name);
4409 if (!obj) {
4410 if (flags & QMP_ACCEPT_UNKNOWNS) {
4411 /* handler accepts unknowns */
4412 continue;
4413 }
4414 /* client arg doesn't exist */
4415 qerror_report(QERR_INVALID_PARAMETER, client_arg_name);
4416 return -1;
4417 }
4418
4419 arg_type = qobject_to_qstring(obj);
4420 assert(arg_type != NULL);
4421
4422 /* check if argument's type is correct */
4423 switch (qstring_get_str(arg_type)[0]) {
4424 case 'F':
4425 case 'B':
4426 case 's':
4427 if (qobject_type(client_arg) != QTYPE_QSTRING) {
4428 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4429 "string");
4430 return -1;
4431 }
4432 break;
4433 case 'i':
4434 case 'l':
4435 case 'M':
Jes Sorensendbc0c672010-10-21 17:15:47 +02004436 case 'o':
Luiz Capitulino4af91932010-06-22 11:44:05 -03004437 if (qobject_type(client_arg) != QTYPE_QINT) {
4438 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4439 "int");
4440 return -1;
4441 }
4442 break;
Luiz Capitulino4af91932010-06-22 11:44:05 -03004443 case 'T':
4444 if (qobject_type(client_arg) != QTYPE_QINT &&
4445 qobject_type(client_arg) != QTYPE_QFLOAT) {
4446 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4447 "number");
4448 return -1;
4449 }
4450 break;
4451 case 'b':
4452 case '-':
4453 if (qobject_type(client_arg) != QTYPE_QBOOL) {
4454 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4455 "bool");
4456 return -1;
4457 }
4458 break;
4459 case 'O':
4460 assert(flags & QMP_ACCEPT_UNKNOWNS);
4461 break;
Paolo Bonzinib9f89782012-03-22 12:51:11 +01004462 case 'q':
4463 /* Any QObject can be passed. */
4464 break;
Luiz Capitulino4af91932010-06-22 11:44:05 -03004465 case '/':
4466 case '.':
4467 /*
4468 * These types are not supported by QMP and thus are not
4469 * handled here. Fall through.
4470 */
4471 default:
4472 abort();
4473 }
4474 }
4475
4476 return 0;
4477}
4478
4479/*
Luiz Capitulino2dbc8db2010-05-26 16:13:09 -03004480 * - Check if the client has passed all mandatory args
4481 * - Set special flags for argument validation
4482 */
4483static int check_mandatory_args(const QDict *cmd_args,
4484 const QDict *client_args, int *flags)
4485{
4486 const QDictEntry *ent;
4487
4488 for (ent = qdict_first(cmd_args); ent; ent = qdict_next(cmd_args, ent)) {
4489 const char *cmd_arg_name = qdict_entry_key(ent);
4490 QString *type = qobject_to_qstring(qdict_entry_value(ent));
4491 assert(type != NULL);
4492
4493 if (qstring_get_str(type)[0] == 'O') {
4494 assert((*flags & QMP_ACCEPT_UNKNOWNS) == 0);
4495 *flags |= QMP_ACCEPT_UNKNOWNS;
4496 } else if (qstring_get_str(type)[0] != '-' &&
4497 qstring_get_str(type)[1] != '?' &&
4498 !qdict_haskey(client_args, cmd_arg_name)) {
4499 qerror_report(QERR_MISSING_PARAMETER, cmd_arg_name);
4500 return -1;
4501 }
4502 }
4503
4504 return 0;
4505}
4506
4507static QDict *qdict_from_args_type(const char *args_type)
4508{
4509 int i;
4510 QDict *qdict;
4511 QString *key, *type, *cur_qs;
4512
4513 assert(args_type != NULL);
4514
4515 qdict = qdict_new();
4516
4517 if (args_type == NULL || args_type[0] == '\0') {
4518 /* no args, empty qdict */
4519 goto out;
4520 }
4521
4522 key = qstring_new();
4523 type = qstring_new();
4524
4525 cur_qs = key;
4526
4527 for (i = 0;; i++) {
4528 switch (args_type[i]) {
4529 case ',':
4530 case '\0':
4531 qdict_put(qdict, qstring_get_str(key), type);
4532 QDECREF(key);
4533 if (args_type[i] == '\0') {
4534 goto out;
4535 }
4536 type = qstring_new(); /* qdict has ref */
4537 cur_qs = key = qstring_new();
4538 break;
4539 case ':':
4540 cur_qs = type;
4541 break;
4542 default:
4543 qstring_append_chr(cur_qs, args_type[i]);
4544 break;
4545 }
4546 }
4547
4548out:
4549 return qdict;
4550}
4551
4552/*
4553 * Client argument checking rules:
4554 *
4555 * 1. Client must provide all mandatory arguments
Luiz Capitulino4af91932010-06-22 11:44:05 -03004556 * 2. Each argument provided by the client must be expected
4557 * 3. Each argument provided by the client must have the type expected
4558 * by the command
Luiz Capitulino2dbc8db2010-05-26 16:13:09 -03004559 */
4560static int qmp_check_client_args(const mon_cmd_t *cmd, QDict *client_args)
4561{
4562 int flags, err;
4563 QDict *cmd_args;
4564
4565 cmd_args = qdict_from_args_type(cmd->args_type);
4566
4567 flags = 0;
4568 err = check_mandatory_args(cmd_args, client_args, &flags);
4569 if (err) {
4570 goto out;
4571 }
4572
Luiz Capitulino4af91932010-06-22 11:44:05 -03004573 err = check_client_args_type(client_args, cmd_args, flags);
Luiz Capitulino2dbc8db2010-05-26 16:13:09 -03004574
4575out:
4576 QDECREF(cmd_args);
4577 return err;
4578}
4579
Luiz Capitulinoc917c8f2010-05-31 17:28:01 -03004580/*
4581 * Input object checking rules
4582 *
4583 * 1. Input object must be a dict
4584 * 2. The "execute" key must exist
4585 * 3. The "execute" key must be a string
4586 * 4. If the "arguments" key exists, it must be a dict
4587 * 5. If the "id" key exists, it can be anything (ie. json-value)
4588 * 6. Any argument not listed above is considered invalid
4589 */
4590static QDict *qmp_check_input_obj(QObject *input_obj)
4591{
4592 const QDictEntry *ent;
4593 int has_exec_key = 0;
4594 QDict *input_dict;
4595
4596 if (qobject_type(input_obj) != QTYPE_QDICT) {
4597 qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "object");
4598 return NULL;
4599 }
4600
4601 input_dict = qobject_to_qdict(input_obj);
4602
4603 for (ent = qdict_first(input_dict); ent; ent = qdict_next(input_dict, ent)){
4604 const char *arg_name = qdict_entry_key(ent);
4605 const QObject *arg_obj = qdict_entry_value(ent);
4606
4607 if (!strcmp(arg_name, "execute")) {
4608 if (qobject_type(arg_obj) != QTYPE_QSTRING) {
4609 qerror_report(QERR_QMP_BAD_INPUT_OBJECT_MEMBER, "execute",
4610 "string");
4611 return NULL;
4612 }
4613 has_exec_key = 1;
4614 } else if (!strcmp(arg_name, "arguments")) {
4615 if (qobject_type(arg_obj) != QTYPE_QDICT) {
4616 qerror_report(QERR_QMP_BAD_INPUT_OBJECT_MEMBER, "arguments",
4617 "object");
4618 return NULL;
4619 }
4620 } else if (!strcmp(arg_name, "id")) {
4621 /* FIXME: check duplicated IDs for async commands */
4622 } else {
4623 qerror_report(QERR_QMP_EXTRA_MEMBER, arg_name);
4624 return NULL;
4625 }
4626 }
4627
4628 if (!has_exec_key) {
4629 qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "execute");
4630 return NULL;
4631 }
4632
4633 return input_dict;
4634}
4635
Luiz Capitulinofc29df72010-09-16 11:11:18 -03004636static void qmp_call_cmd(Monitor *mon, const mon_cmd_t *cmd,
4637 const QDict *params)
4638{
4639 int ret;
4640 QObject *data = NULL;
4641
Luiz Capitulinofc29df72010-09-16 11:11:18 -03004642 ret = cmd->mhandler.cmd_new(mon, params, &data);
4643 handler_audit(mon, cmd, ret);
4644 monitor_protocol_emitter(mon, data);
4645 qobject_decref(data);
4646}
4647
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004648static void handle_qmp_command(JSONMessageParser *parser, QList *tokens)
4649{
4650 int err;
4651 QObject *obj;
4652 QDict *input, *args;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004653 const mon_cmd_t *cmd;
Luiz Capitulino40e5a012011-10-21 16:15:31 -02004654 const char *cmd_name;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004655 Monitor *mon = cur_mon;
4656
Luiz Capitulinoe4940c62010-06-24 17:58:20 -03004657 args = input = NULL;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004658
4659 obj = json_parser_parse(tokens, NULL);
4660 if (!obj) {
4661 // FIXME: should be triggered in json_parser_parse()
Markus Armbrusterab5b0272010-03-02 18:15:09 +01004662 qerror_report(QERR_JSON_PARSING);
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004663 goto err_out;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004664 }
4665
Luiz Capitulinoc917c8f2010-05-31 17:28:01 -03004666 input = qmp_check_input_obj(obj);
4667 if (!input) {
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004668 qobject_decref(obj);
4669 goto err_out;
4670 }
4671
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004672 mon->mc->id = qdict_get(input, "id");
4673 qobject_incref(mon->mc->id);
4674
Luiz Capitulino0bbab462010-05-31 17:32:50 -03004675 cmd_name = qdict_get_str(input, "execute");
Stefan Hajnoczi89bd8202011-09-23 08:23:06 +01004676 trace_handle_qmp_command(mon, cmd_name);
Luiz Capitulino09069b12010-02-04 18:10:06 -02004677 if (invalid_qmp_mode(mon, cmd_name)) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01004678 qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);
Luiz Capitulinoe4940c62010-06-24 17:58:20 -03004679 goto err_out;
Luiz Capitulino09069b12010-02-04 18:10:06 -02004680 }
4681
Anthony Liguorie3193602011-09-02 12:34:47 -05004682 cmd = qmp_find_cmd(cmd_name);
Luiz Capitulinod1249ea2010-09-13 14:44:27 -03004683 if (!cmd) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01004684 qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);
Luiz Capitulinoe4940c62010-06-24 17:58:20 -03004685 goto err_out;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004686 }
4687
4688 obj = qdict_get(input, "arguments");
4689 if (!obj) {
4690 args = qdict_new();
4691 } else {
4692 args = qobject_to_qdict(obj);
4693 QINCREF(args);
4694 }
4695
Luiz Capitulino2dbc8db2010-05-26 16:13:09 -03004696 err = qmp_check_client_args(cmd, args);
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004697 if (err < 0) {
4698 goto err_out;
4699 }
4700
Luiz Capitulino40e5a012011-10-21 16:15:31 -02004701 if (handler_is_async(cmd)) {
Luiz Capitulino5af7bba2010-06-22 19:10:46 -03004702 err = qmp_async_cmd_handler(mon, cmd, args);
4703 if (err) {
4704 /* emit the error response */
4705 goto err_out;
4706 }
Adam Litke940cc302010-01-25 12:18:44 -06004707 } else {
Luiz Capitulinofc29df72010-09-16 11:11:18 -03004708 qmp_call_cmd(mon, cmd, args);
Adam Litke940cc302010-01-25 12:18:44 -06004709 }
Luiz Capitulinoe4940c62010-06-24 17:58:20 -03004710
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004711 goto out;
4712
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004713err_out:
4714 monitor_protocol_emitter(mon, NULL);
4715out:
Luiz Capitulinoe4940c62010-06-24 17:58:20 -03004716 QDECREF(input);
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004717 QDECREF(args);
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004718}
4719
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004720/**
4721 * monitor_control_read(): Read and handle QMP input
4722 */
4723static void monitor_control_read(void *opaque, const uint8_t *buf, int size)
4724{
4725 Monitor *old_mon = cur_mon;
4726
4727 cur_mon = opaque;
4728
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004729 json_message_parser_feed(&cur_mon->mc->parser, (const char *) buf, size);
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004730
4731 cur_mon = old_mon;
4732}
4733
aliguori731b0362009-03-05 23:01:42 +00004734static void monitor_read(void *opaque, const uint8_t *buf, int size)
bellard9dc39cb2004-03-14 21:38:27 +00004735{
aliguori731b0362009-03-05 23:01:42 +00004736 Monitor *old_mon = cur_mon;
bellard9dc39cb2004-03-14 21:38:27 +00004737 int i;
aliguori376253e2009-03-05 23:01:23 +00004738
aliguori731b0362009-03-05 23:01:42 +00004739 cur_mon = opaque;
bellard7e2515e2004-08-01 21:52:19 +00004740
aliguoricde76ee2009-03-05 23:01:51 +00004741 if (cur_mon->rs) {
4742 for (i = 0; i < size; i++)
4743 readline_handle_byte(cur_mon->rs, buf[i]);
4744 } else {
4745 if (size == 0 || buf[size - 1] != 0)
4746 monitor_printf(cur_mon, "corrupted command\n");
4747 else
Luiz Capitulinof3c157c2009-11-26 22:58:55 -02004748 handle_user_command(cur_mon, (char *)buf);
aliguoricde76ee2009-03-05 23:01:51 +00004749 }
aliguori731b0362009-03-05 23:01:42 +00004750
4751 cur_mon = old_mon;
4752}
aliguorid8f44602008-10-06 13:52:44 +00004753
aliguori376253e2009-03-05 23:01:23 +00004754static void monitor_command_cb(Monitor *mon, const char *cmdline, void *opaque)
bellard7e2515e2004-08-01 21:52:19 +00004755{
aliguori731b0362009-03-05 23:01:42 +00004756 monitor_suspend(mon);
Luiz Capitulinof3c157c2009-11-26 22:58:55 -02004757 handle_user_command(mon, cmdline);
aliguori731b0362009-03-05 23:01:42 +00004758 monitor_resume(mon);
aliguorid8f44602008-10-06 13:52:44 +00004759}
4760
aliguoricde76ee2009-03-05 23:01:51 +00004761int monitor_suspend(Monitor *mon)
aliguorid8f44602008-10-06 13:52:44 +00004762{
aliguoricde76ee2009-03-05 23:01:51 +00004763 if (!mon->rs)
4764 return -ENOTTY;
aliguori731b0362009-03-05 23:01:42 +00004765 mon->suspend_cnt++;
aliguoricde76ee2009-03-05 23:01:51 +00004766 return 0;
aliguorid8f44602008-10-06 13:52:44 +00004767}
4768
aliguori376253e2009-03-05 23:01:23 +00004769void monitor_resume(Monitor *mon)
aliguorid8f44602008-10-06 13:52:44 +00004770{
aliguoricde76ee2009-03-05 23:01:51 +00004771 if (!mon->rs)
4772 return;
aliguori731b0362009-03-05 23:01:42 +00004773 if (--mon->suspend_cnt == 0)
4774 readline_show_prompt(mon->rs);
bellard7e2515e2004-08-01 21:52:19 +00004775}
4776
Luiz Capitulinoca9567e2010-02-04 18:10:04 -02004777static QObject *get_qmp_greeting(void)
4778{
Luiz Capitulinob9c15f12011-08-26 17:38:13 -03004779 QObject *ver = NULL;
Luiz Capitulinoca9567e2010-02-04 18:10:04 -02004780
Luiz Capitulinob9c15f12011-08-26 17:38:13 -03004781 qmp_marshal_input_query_version(NULL, NULL, &ver);
Luiz Capitulinoca9567e2010-02-04 18:10:04 -02004782 return qobject_from_jsonf("{'QMP':{'version': %p,'capabilities': []}}",ver);
4783}
4784
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004785/**
4786 * monitor_control_event(): Print QMP gretting
4787 */
4788static void monitor_control_event(void *opaque, int event)
4789{
Luiz Capitulino47116d12010-02-08 17:01:30 -02004790 QObject *data;
4791 Monitor *mon = opaque;
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004792
Luiz Capitulino47116d12010-02-08 17:01:30 -02004793 switch (event) {
4794 case CHR_EVENT_OPENED:
Luiz Capitulino4a7e1192010-02-04 18:10:05 -02004795 mon->mc->command_mode = 0;
Luiz Capitulinoca9567e2010-02-04 18:10:04 -02004796 data = get_qmp_greeting();
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004797 monitor_json_emitter(mon, data);
4798 qobject_decref(data);
Corey Bryantefb87c12012-08-14 16:43:48 -04004799 mon_refcount++;
Luiz Capitulino47116d12010-02-08 17:01:30 -02004800 break;
4801 case CHR_EVENT_CLOSED:
4802 json_message_parser_destroy(&mon->mc->parser);
Anthony Liguori58617a72012-08-23 08:03:21 -05004803 json_message_parser_init(&mon->mc->parser, handle_qmp_command);
Corey Bryantefb87c12012-08-14 16:43:48 -04004804 mon_refcount--;
4805 monitor_fdsets_cleanup();
Luiz Capitulino47116d12010-02-08 17:01:30 -02004806 break;
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004807 }
4808}
4809
aliguori731b0362009-03-05 23:01:42 +00004810static void monitor_event(void *opaque, int event)
ths86e94de2007-01-05 22:01:59 +00004811{
aliguori376253e2009-03-05 23:01:23 +00004812 Monitor *mon = opaque;
4813
aliguori2724b182009-03-05 23:01:47 +00004814 switch (event) {
4815 case CHR_EVENT_MUX_IN:
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +02004816 mon->mux_out = 0;
4817 if (mon->reset_seen) {
4818 readline_restart(mon->rs);
4819 monitor_resume(mon);
4820 monitor_flush(mon);
4821 } else {
4822 mon->suspend_cnt = 0;
4823 }
aliguori2724b182009-03-05 23:01:47 +00004824 break;
ths86e94de2007-01-05 22:01:59 +00004825
aliguori2724b182009-03-05 23:01:47 +00004826 case CHR_EVENT_MUX_OUT:
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +02004827 if (mon->reset_seen) {
4828 if (mon->suspend_cnt == 0) {
4829 monitor_printf(mon, "\n");
4830 }
4831 monitor_flush(mon);
4832 monitor_suspend(mon);
4833 } else {
4834 mon->suspend_cnt++;
4835 }
4836 mon->mux_out = 1;
aliguori2724b182009-03-05 23:01:47 +00004837 break;
4838
Amit Shahb6b8df52009-10-07 18:31:16 +05304839 case CHR_EVENT_OPENED:
aliguori2724b182009-03-05 23:01:47 +00004840 monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
4841 "information\n", QEMU_VERSION);
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +02004842 if (!mon->mux_out) {
aliguori2724b182009-03-05 23:01:47 +00004843 readline_show_prompt(mon->rs);
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +02004844 }
4845 mon->reset_seen = 1;
Corey Bryantefb87c12012-08-14 16:43:48 -04004846 mon_refcount++;
4847 break;
4848
4849 case CHR_EVENT_CLOSED:
4850 mon_refcount--;
4851 monitor_fdsets_cleanup();
aliguori2724b182009-03-05 23:01:47 +00004852 break;
4853 }
ths86e94de2007-01-05 22:01:59 +00004854}
4855
Wayne Xia816f8922011-10-12 11:32:41 +08004856static int
4857compare_mon_cmd(const void *a, const void *b)
4858{
4859 return strcmp(((const mon_cmd_t *)a)->name,
4860 ((const mon_cmd_t *)b)->name);
4861}
4862
4863static void sortcmdlist(void)
4864{
4865 int array_num;
4866 int elem_size = sizeof(mon_cmd_t);
4867
4868 array_num = sizeof(mon_cmds)/elem_size-1;
4869 qsort((void *)mon_cmds, array_num, elem_size, compare_mon_cmd);
4870
4871 array_num = sizeof(info_cmds)/elem_size-1;
4872 qsort((void *)info_cmds, array_num, elem_size, compare_mon_cmd);
4873}
4874
aliguori76655d62009-03-06 20:27:37 +00004875
4876/*
4877 * Local variables:
4878 * c-indent-level: 4
4879 * c-basic-offset: 4
4880 * tab-width: 8
4881 * End:
4882 */
4883
aliguori731b0362009-03-05 23:01:42 +00004884void monitor_init(CharDriverState *chr, int flags)
bellard9dc39cb2004-03-14 21:38:27 +00004885{
aliguori731b0362009-03-05 23:01:42 +00004886 static int is_first_init = 1;
aliguori87127162009-03-05 23:01:29 +00004887 Monitor *mon;
ths20d8a3e2007-02-18 17:04:49 +00004888
4889 if (is_first_init) {
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +01004890 monitor_protocol_event_init();
Wenchao Xiad0383172013-08-27 20:38:18 +08004891 sortcmdlist();
ths20d8a3e2007-02-18 17:04:49 +00004892 is_first_init = 0;
4893 }
aliguori87127162009-03-05 23:01:29 +00004894
Wenchao Xiab01fe892013-08-27 20:38:19 +08004895 mon = g_malloc(sizeof(*mon));
4896 monitor_data_init(mon);
ths20d8a3e2007-02-18 17:04:49 +00004897
aliguori87127162009-03-05 23:01:29 +00004898 mon->chr = chr;
aliguori731b0362009-03-05 23:01:42 +00004899 mon->flags = flags;
aliguoricde76ee2009-03-05 23:01:51 +00004900 if (flags & MONITOR_USE_READLINE) {
4901 mon->rs = readline_init(mon, monitor_find_completion);
4902 monitor_read_command(mon, 0);
4903 }
aliguori87127162009-03-05 23:01:29 +00004904
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004905 if (monitor_ctrl_mode(mon)) {
Anthony Liguori7267c092011-08-20 22:09:37 -05004906 mon->mc = g_malloc0(sizeof(MonitorControl));
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004907 /* Control mode requires special handlers */
4908 qemu_chr_add_handlers(chr, monitor_can_read, monitor_control_read,
4909 monitor_control_event, mon);
Anthony Liguori15f31512011-08-15 11:17:35 -05004910 qemu_chr_fe_set_echo(chr, true);
Anthony Liguori26efaca2012-08-23 13:49:02 -05004911
4912 json_message_parser_init(&mon->mc->parser, handle_qmp_command);
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004913 } else {
4914 qemu_chr_add_handlers(chr, monitor_can_read, monitor_read,
4915 monitor_event, mon);
4916 }
aliguori87127162009-03-05 23:01:29 +00004917
Blue Swirl72cf2d42009-09-12 07:36:22 +00004918 QLIST_INSERT_HEAD(&mon_list, mon, entry);
Markus Armbruster8631b602010-02-18 11:41:55 +01004919 if (!default_mon || (flags & MONITOR_IS_DEFAULT))
4920 default_mon = mon;
bellard7e2515e2004-08-01 21:52:19 +00004921}
4922
aliguori376253e2009-03-05 23:01:23 +00004923static void bdrv_password_cb(Monitor *mon, const char *password, void *opaque)
bellard7e2515e2004-08-01 21:52:19 +00004924{
aliguoribb5fc202009-03-05 23:01:15 +00004925 BlockDriverState *bs = opaque;
4926 int ret = 0;
bellard7e2515e2004-08-01 21:52:19 +00004927
aliguoribb5fc202009-03-05 23:01:15 +00004928 if (bdrv_set_key(bs, password) != 0) {
aliguori376253e2009-03-05 23:01:23 +00004929 monitor_printf(mon, "invalid password\n");
aliguoribb5fc202009-03-05 23:01:15 +00004930 ret = -EPERM;
bellard7e2515e2004-08-01 21:52:19 +00004931 }
aliguori731b0362009-03-05 23:01:42 +00004932 if (mon->password_completion_cb)
4933 mon->password_completion_cb(mon->password_opaque, ret);
aliguoribb5fc202009-03-05 23:01:15 +00004934
aliguori731b0362009-03-05 23:01:42 +00004935 monitor_read_command(mon, 1);
bellard9dc39cb2004-03-14 21:38:27 +00004936}
aliguoric0f4ce72009-03-05 23:01:01 +00004937
Anthony Liguori7060b472011-09-02 12:34:50 -05004938ReadLineState *monitor_get_rs(Monitor *mon)
4939{
4940 return mon->rs;
4941}
4942
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02004943int monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
4944 BlockDriverCompletionFunc *completion_cb,
4945 void *opaque)
aliguoric0f4ce72009-03-05 23:01:01 +00004946{
aliguoricde76ee2009-03-05 23:01:51 +00004947 int err;
4948
aliguoribb5fc202009-03-05 23:01:15 +00004949 if (!bdrv_key_required(bs)) {
4950 if (completion_cb)
4951 completion_cb(opaque, 0);
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02004952 return 0;
aliguoribb5fc202009-03-05 23:01:15 +00004953 }
aliguoric0f4ce72009-03-05 23:01:01 +00004954
Luiz Capitulino94171e12009-12-07 21:37:00 +01004955 if (monitor_ctrl_mode(mon)) {
Luiz Capitulino903a8812011-12-13 17:18:30 -02004956 qerror_report(QERR_DEVICE_ENCRYPTED, bdrv_get_device_name(bs),
4957 bdrv_get_encrypted_filename(bs));
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02004958 return -1;
Luiz Capitulino94171e12009-12-07 21:37:00 +01004959 }
4960
aliguori376253e2009-03-05 23:01:23 +00004961 monitor_printf(mon, "%s (%s) is encrypted.\n", bdrv_get_device_name(bs),
4962 bdrv_get_encrypted_filename(bs));
aliguoribb5fc202009-03-05 23:01:15 +00004963
aliguori731b0362009-03-05 23:01:42 +00004964 mon->password_completion_cb = completion_cb;
4965 mon->password_opaque = opaque;
aliguoribb5fc202009-03-05 23:01:15 +00004966
aliguoricde76ee2009-03-05 23:01:51 +00004967 err = monitor_read_password(mon, bdrv_password_cb, bs);
4968
4969 if (err && completion_cb)
4970 completion_cb(opaque, err);
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02004971
4972 return err;
aliguoric0f4ce72009-03-05 23:01:01 +00004973}
Luiz Capitulinoe42e8182011-11-22 17:58:31 -02004974
4975int monitor_read_block_device_key(Monitor *mon, const char *device,
4976 BlockDriverCompletionFunc *completion_cb,
4977 void *opaque)
4978{
4979 BlockDriverState *bs;
4980
4981 bs = bdrv_find(device);
4982 if (!bs) {
4983 monitor_printf(mon, "Device not found %s\n", device);
4984 return -1;
4985 }
4986
4987 return monitor_read_bdrv_key_start(mon, bs, completion_cb, opaque);
4988}
Paolo Bonzini4d454572012-11-26 16:03:42 +01004989
4990QemuOptsList qemu_mon_opts = {
4991 .name = "mon",
4992 .implied_opt_name = "chardev",
4993 .head = QTAILQ_HEAD_INITIALIZER(qemu_mon_opts.head),
4994 .desc = {
4995 {
4996 .name = "mode",
4997 .type = QEMU_OPT_STRING,
4998 },{
4999 .name = "chardev",
5000 .type = QEMU_OPT_STRING,
5001 },{
5002 .name = "default",
5003 .type = QEMU_OPT_BOOL,
5004 },{
5005 .name = "pretty",
5006 .type = QEMU_OPT_BOOL,
5007 },
5008 { /* end of list */ }
5009 },
5010};