blob: 4ec1db980c2f006495b9ea83893d9713951b9a93 [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"
29#include "hw/pc.h"
Michael S. Tsirkina2cb15b2012-12-12 14:24:50 +020030#include "hw/pci/pci.h"
Richard W.M. Jones9dd986c2009-04-25 13:56:19 +010031#include "hw/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 Bonzini927d4872012-12-17 18:20:05 +010036#include "char/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"
Stefan Bergerd1a0cf72013-02-27 12:47:49 -050050#include "tpm/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
Gerd Hoffmann6f8c63f2010-10-11 18:03:51 +020066#include "ui/qemu-spice.h"
Paolo Bonzini022c62c2012-12-17 18:19:49 +010067#include "exec/memory.h"
Anthony Liguori48a32be2011-09-02 12:34:48 -050068#include "qmp-commands.h"
69#include "hmp.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010070#include "qemu/thread.h"
ths6a5bd302007-12-03 17:05:38 +000071
Jan Kiszka661f1922011-10-16 11:53:13 +020072/* for pic/irq_info */
73#if defined(TARGET_SPARC)
74#include "hw/sun4m.h"
75#endif
76#include "hw/lm32_pic.h"
77
bellard9dc39cb2004-03-14 21:38:27 +000078//#define DEBUG
bellard81d09122004-07-14 17:21:37 +000079//#define DEBUG_COMPLETION
bellard9dc39cb2004-03-14 21:38:27 +000080
bellard9307c4c2004-04-04 12:57:25 +000081/*
82 * Supported types:
ths5fafdf22007-09-16 21:08:06 +000083 *
bellard9307c4c2004-04-04 12:57:25 +000084 * 'F' filename
bellard81d09122004-07-14 17:21:37 +000085 * 'B' block device name
bellard9307c4c2004-04-04 12:57:25 +000086 * 's' 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)
97 * user mode accepts an optional T, t, G, g, M, m, K, k
98 * suffix, which multiplies the value by 2^40 for
99 * suffixes T and t, 2^30 for suffixes G and g, 2^20 for
100 * 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;
191 uint8_t outbuf[1024];
192 int outbuf_index;
193 ReadLineState *rs;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -0200194 MonitorControl *mc;
Andreas Färber9349b4f2012-03-14 01:38:32 +0100195 CPUArchState *mon_cpu;
aliguori731b0362009-03-05 23:01:42 +0000196 BlockDriverCompletionFunc *password_completion_cb;
197 void *password_opaque;
Luiz Capitulino8204a912009-11-18 23:05:31 -0200198 QError *error;
Anthony Liguoric227f092009-10-01 16:12:16 -0500199 QLIST_HEAD(,mon_fd_t) fds;
Blue Swirl72cf2d42009-09-12 07:36:22 +0000200 QLIST_ENTRY(Monitor) entry;
aliguori87127162009-03-05 23:01:29 +0000201};
202
Luiz Capitulino2dbc8db2010-05-26 16:13:09 -0300203/* QMP checker flags */
204#define QMP_ACCEPT_UNKNOWNS 1
205
Blue Swirl72cf2d42009-09-12 07:36:22 +0000206static QLIST_HEAD(mon_list, Monitor) mon_list;
Corey Bryantba1c0482012-08-14 16:43:43 -0400207static QLIST_HEAD(mon_fdsets, MonFdset) mon_fdsets;
Corey Bryantefb87c12012-08-14 16:43:48 -0400208static int mon_refcount;
bellard7e2515e2004-08-01 21:52:19 +0000209
Wayne Xia816f8922011-10-12 11:32:41 +0800210static mon_cmd_t mon_cmds[];
211static mon_cmd_t info_cmds[];
bellard9dc39cb2004-03-14 21:38:27 +0000212
Luiz Capitulinof36b4af2010-09-15 17:17:45 -0300213static const mon_cmd_t qmp_cmds[];
214
Markus Armbruster8631b602010-02-18 11:41:55 +0100215Monitor *cur_mon;
216Monitor *default_mon;
aliguori376253e2009-03-05 23:01:23 +0000217
aliguori731b0362009-03-05 23:01:42 +0000218static void monitor_command_cb(Monitor *mon, const char *cmdline,
219 void *opaque);
aliguori83ab7952008-08-19 14:44:22 +0000220
Luiz Capitulino09069b12010-02-04 18:10:06 -0200221static inline int qmp_cmd_mode(const Monitor *mon)
222{
223 return (mon->mc ? mon->mc->command_mode : 0);
224}
225
Luiz Capitulino418173c2009-11-26 22:58:51 -0200226/* Return true if in control mode, false otherwise */
227static inline int monitor_ctrl_mode(const Monitor *mon)
228{
229 return (mon->flags & MONITOR_USE_CONTROL);
230}
231
Markus Armbruster6620d3c2010-02-11 17:05:43 +0100232/* Return non-zero iff we have a current monitor, and it is in QMP mode. */
233int monitor_cur_is_qmp(void)
234{
235 return cur_mon && monitor_ctrl_mode(cur_mon);
236}
237
Anthony Liguori7060b472011-09-02 12:34:50 -0500238void monitor_read_command(Monitor *mon, int show_prompt)
aliguori731b0362009-03-05 23:01:42 +0000239{
Luiz Capitulino183e6e52009-12-14 18:53:23 -0200240 if (!mon->rs)
241 return;
242
aliguori731b0362009-03-05 23:01:42 +0000243 readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL);
244 if (show_prompt)
245 readline_show_prompt(mon->rs);
246}
bellard6a00d602005-11-21 23:25:50 +0000247
Anthony Liguori7060b472011-09-02 12:34:50 -0500248int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
249 void *opaque)
aliguoribb5fc202009-03-05 23:01:15 +0000250{
Luiz Capitulino94171e12009-12-07 21:37:00 +0100251 if (monitor_ctrl_mode(mon)) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +0100252 qerror_report(QERR_MISSING_PARAMETER, "password");
Luiz Capitulino94171e12009-12-07 21:37:00 +0100253 return -EINVAL;
254 } else if (mon->rs) {
aliguoricde76ee2009-03-05 23:01:51 +0000255 readline_start(mon->rs, "Password: ", 1, readline_func, opaque);
256 /* prompt is printed on return from the command handler */
257 return 0;
258 } else {
259 monitor_printf(mon, "terminal does not support password prompting\n");
260 return -ENOTTY;
261 }
aliguoribb5fc202009-03-05 23:01:15 +0000262}
263
Gerd Hoffmannf6289262013-03-19 10:57:56 +0100264static gboolean monitor_unblocked(GIOChannel *chan, GIOCondition cond,
265 void *opaque)
266{
267 monitor_flush(opaque);
268 return FALSE;
269}
270
aliguori376253e2009-03-05 23:01:23 +0000271void monitor_flush(Monitor *mon)
bellard9dc39cb2004-03-14 21:38:27 +0000272{
Gerd Hoffmannf6289262013-03-19 10:57:56 +0100273 int rc;
274
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +0200275 if (mon && mon->outbuf_index != 0 && !mon->mux_out) {
Gerd Hoffmannf6289262013-03-19 10:57:56 +0100276 rc = qemu_chr_fe_write(mon->chr, mon->outbuf, mon->outbuf_index);
277 if (rc == mon->outbuf_index) {
278 /* all flushed */
279 mon->outbuf_index = 0;
280 return;
281 }
282 if (rc > 0) {
283 /* partinal write */
284 memmove(mon->outbuf, mon->outbuf + rc, mon->outbuf_index - rc);
285 mon->outbuf_index -= rc;
286 }
287 qemu_chr_fe_add_watch(mon->chr, G_IO_OUT, monitor_unblocked, mon);
bellard7e2515e2004-08-01 21:52:19 +0000288 }
289}
290
291/* flush at every end of line or if the buffer is full */
aliguori376253e2009-03-05 23:01:23 +0000292static void monitor_puts(Monitor *mon, const char *str)
bellard7e2515e2004-08-01 21:52:19 +0000293{
ths60fe76f2007-12-16 03:02:09 +0000294 char c;
aliguori731b0362009-03-05 23:01:42 +0000295
bellard7e2515e2004-08-01 21:52:19 +0000296 for(;;) {
Markus Armbruster51782342013-01-10 14:10:22 +0100297 assert(mon->outbuf_index < sizeof(mon->outbuf) - 1);
bellard7e2515e2004-08-01 21:52:19 +0000298 c = *str++;
299 if (c == '\0')
300 break;
bellard7ba12602006-07-14 20:26:42 +0000301 if (c == '\n')
aliguori731b0362009-03-05 23:01:42 +0000302 mon->outbuf[mon->outbuf_index++] = '\r';
303 mon->outbuf[mon->outbuf_index++] = c;
304 if (mon->outbuf_index >= (sizeof(mon->outbuf) - 1)
305 || c == '\n')
aliguori376253e2009-03-05 23:01:23 +0000306 monitor_flush(mon);
bellard7e2515e2004-08-01 21:52:19 +0000307 }
308}
309
aliguori376253e2009-03-05 23:01:23 +0000310void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
bellard7e2515e2004-08-01 21:52:19 +0000311{
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200312 char buf[4096];
313
Luiz Capitulino2daa1192009-12-14 18:53:24 -0200314 if (!mon)
315 return;
316
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200317 if (monitor_ctrl_mode(mon)) {
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200318 return;
Luiz Capitulino4a29a852009-11-26 22:59:05 -0200319 }
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200320
321 vsnprintf(buf, sizeof(buf), fmt, ap);
322 monitor_puts(mon, buf);
bellard7e2515e2004-08-01 21:52:19 +0000323}
324
aliguori376253e2009-03-05 23:01:23 +0000325void monitor_printf(Monitor *mon, const char *fmt, ...)
bellard7e2515e2004-08-01 21:52:19 +0000326{
327 va_list ap;
328 va_start(ap, fmt);
aliguori376253e2009-03-05 23:01:23 +0000329 monitor_vprintf(mon, fmt, ap);
bellard7e2515e2004-08-01 21:52:19 +0000330 va_end(ap);
bellard9dc39cb2004-03-14 21:38:27 +0000331}
332
aliguori376253e2009-03-05 23:01:23 +0000333void monitor_print_filename(Monitor *mon, const char *filename)
thsfef30742006-12-22 14:11:32 +0000334{
335 int i;
336
337 for (i = 0; filename[i]; i++) {
aliguori28a76be2009-03-06 20:27:40 +0000338 switch (filename[i]) {
339 case ' ':
340 case '"':
341 case '\\':
342 monitor_printf(mon, "\\%c", filename[i]);
343 break;
344 case '\t':
345 monitor_printf(mon, "\\t");
346 break;
347 case '\r':
348 monitor_printf(mon, "\\r");
349 break;
350 case '\n':
351 monitor_printf(mon, "\\n");
352 break;
353 default:
354 monitor_printf(mon, "%c", filename[i]);
355 break;
356 }
thsfef30742006-12-22 14:11:32 +0000357 }
358}
359
Stefan Weil8b7968f2010-09-23 21:28:05 +0200360static int GCC_FMT_ATTR(2, 3) monitor_fprintf(FILE *stream,
361 const char *fmt, ...)
bellard7fe48482004-10-09 18:08:01 +0000362{
363 va_list ap;
364 va_start(ap, fmt);
aliguori376253e2009-03-05 23:01:23 +0000365 monitor_vprintf((Monitor *)stream, fmt, ap);
bellard7fe48482004-10-09 18:08:01 +0000366 va_end(ap);
367 return 0;
368}
369
Luiz Capitulino13c74252009-10-07 13:41:55 -0300370static void monitor_user_noop(Monitor *mon, const QObject *data) { }
371
Luiz Capitulino9e807212010-09-16 10:58:59 -0300372static inline int handler_is_qobject(const mon_cmd_t *cmd)
Luiz Capitulino13917be2009-10-07 13:41:54 -0300373{
374 return cmd->user_print != NULL;
375}
376
Luiz Capitulino4903de02010-09-16 11:01:32 -0300377static inline bool handler_is_async(const mon_cmd_t *cmd)
Adam Litke940cc302010-01-25 12:18:44 -0600378{
Jan Kiszka8ac470c2010-06-16 00:38:39 +0200379 return cmd->flags & MONITOR_CMD_ASYNC;
Adam Litke940cc302010-01-25 12:18:44 -0600380}
381
Luiz Capitulino8204a912009-11-18 23:05:31 -0200382static inline int monitor_has_error(const Monitor *mon)
383{
384 return mon->error != NULL;
385}
386
Luiz Capitulino9b57c022009-11-26 22:58:58 -0200387static void monitor_json_emitter(Monitor *mon, const QObject *data)
388{
389 QString *json;
390
Luiz Capitulino83a27d42010-11-22 17:10:37 -0200391 json = mon->flags & MONITOR_USE_PRETTY ? qobject_to_json_pretty(data) :
392 qobject_to_json(data);
Luiz Capitulino9b57c022009-11-26 22:58:58 -0200393 assert(json != NULL);
394
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200395 qstring_append_chr(json, '\n');
396 monitor_puts(mon, qstring_get_str(json));
Luiz Capitulino4a29a852009-11-26 22:59:05 -0200397
Luiz Capitulino9b57c022009-11-26 22:58:58 -0200398 QDECREF(json);
399}
400
Luiz Capitulinode253f12012-07-27 16:18:16 -0300401static QDict *build_qmp_error_dict(const QError *err)
402{
403 QObject *obj;
404
405 obj = qobject_from_jsonf("{ 'error': { 'class': %s, 'desc': %p } }",
406 ErrorClass_lookup[err->err_class],
407 qerror_human(err));
408
409 return qobject_to_qdict(obj);
410}
411
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200412static void monitor_protocol_emitter(Monitor *mon, QObject *data)
413{
414 QDict *qmp;
415
Stefan Hajnoczi89bd8202011-09-23 08:23:06 +0100416 trace_monitor_protocol_emitter(mon);
417
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200418 if (!monitor_has_error(mon)) {
419 /* success response */
Luiz Capitulinode253f12012-07-27 16:18:16 -0300420 qmp = qdict_new();
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200421 if (data) {
422 qobject_incref(data);
423 qdict_put_obj(qmp, "return", data);
424 } else {
Luiz Capitulino0abc6572009-12-18 13:25:00 -0200425 /* return an empty QDict by default */
426 qdict_put(qmp, "return", qdict_new());
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200427 }
428 } else {
429 /* error response */
Luiz Capitulinode253f12012-07-27 16:18:16 -0300430 qmp = build_qmp_error_dict(mon->error);
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200431 QDECREF(mon->error);
432 mon->error = NULL;
433 }
434
Luiz Capitulino5fa737a2009-11-26 22:59:01 -0200435 if (mon->mc->id) {
436 qdict_put_obj(qmp, "id", mon->mc->id);
437 mon->mc->id = NULL;
438 }
439
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200440 monitor_json_emitter(mon, QOBJECT(qmp));
441 QDECREF(qmp);
442}
443
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200444static void timestamp_put(QDict *qdict)
445{
446 int err;
447 QObject *obj;
Blue Swirld08d6f02009-12-04 18:06:39 +0000448 qemu_timeval tv;
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200449
Blue Swirld08d6f02009-12-04 18:06:39 +0000450 err = qemu_gettimeofday(&tv);
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200451 if (err < 0)
452 return;
453
454 obj = qobject_from_jsonf("{ 'seconds': %" PRId64 ", "
455 "'microseconds': %" PRId64 " }",
456 (int64_t) tv.tv_sec, (int64_t) tv.tv_usec);
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200457 qdict_put_obj(qdict, "timestamp", obj);
458}
459
Daniel P. Berrange48608532012-05-21 17:59:51 +0100460
461static const char *monitor_event_names[] = {
462 [QEVENT_SHUTDOWN] = "SHUTDOWN",
463 [QEVENT_RESET] = "RESET",
464 [QEVENT_POWERDOWN] = "POWERDOWN",
465 [QEVENT_STOP] = "STOP",
466 [QEVENT_RESUME] = "RESUME",
467 [QEVENT_VNC_CONNECTED] = "VNC_CONNECTED",
468 [QEVENT_VNC_INITIALIZED] = "VNC_INITIALIZED",
469 [QEVENT_VNC_DISCONNECTED] = "VNC_DISCONNECTED",
470 [QEVENT_BLOCK_IO_ERROR] = "BLOCK_IO_ERROR",
471 [QEVENT_RTC_CHANGE] = "RTC_CHANGE",
472 [QEVENT_WATCHDOG] = "WATCHDOG",
473 [QEVENT_SPICE_CONNECTED] = "SPICE_CONNECTED",
474 [QEVENT_SPICE_INITIALIZED] = "SPICE_INITIALIZED",
475 [QEVENT_SPICE_DISCONNECTED] = "SPICE_DISCONNECTED",
476 [QEVENT_BLOCK_JOB_COMPLETED] = "BLOCK_JOB_COMPLETED",
477 [QEVENT_BLOCK_JOB_CANCELLED] = "BLOCK_JOB_CANCELLED",
Paolo Bonzini32c81a42012-09-28 17:22:58 +0200478 [QEVENT_BLOCK_JOB_ERROR] = "BLOCK_JOB_ERROR",
Paolo Bonzinia66a2a32012-07-23 15:15:47 +0200479 [QEVENT_BLOCK_JOB_READY] = "BLOCK_JOB_READY",
Michael S. Tsirkin0402a5d2013-03-06 14:58:59 +0200480 [QEVENT_DEVICE_DELETED] = "DEVICE_DELETED",
Daniel P. Berrange48608532012-05-21 17:59:51 +0100481 [QEVENT_DEVICE_TRAY_MOVED] = "DEVICE_TRAY_MOVED",
482 [QEVENT_SUSPEND] = "SUSPEND",
Luiz Capitulino25df49f2012-08-08 17:03:01 -0300483 [QEVENT_SUSPEND_DISK] = "SUSPEND_DISK",
Daniel P. Berrange48608532012-05-21 17:59:51 +0100484 [QEVENT_WAKEUP] = "WAKEUP",
Daniel P. Berrange973603a2012-06-14 18:12:56 +0100485 [QEVENT_BALLOON_CHANGE] = "BALLOON_CHANGE",
Yonit Halperin2fdd16e2012-08-21 11:51:57 +0300486 [QEVENT_SPICE_MIGRATE_COMPLETED] = "SPICE_MIGRATE_COMPLETED",
Daniel P. Berrange48608532012-05-21 17:59:51 +0100487};
488QEMU_BUILD_BUG_ON(ARRAY_SIZE(monitor_event_names) != QEVENT_MAX)
489
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100490MonitorEventState monitor_event_state[QEVENT_MAX];
491QemuMutex monitor_event_state_lock;
492
493/*
494 * Emits the event to every monitor instance
495 */
496static void
497monitor_protocol_event_emit(MonitorEvent event,
498 QObject *data)
499{
500 Monitor *mon;
501
502 trace_monitor_protocol_event_emit(event, data);
503 QLIST_FOREACH(mon, &mon_list, entry) {
504 if (monitor_ctrl_mode(mon) && qmp_cmd_mode(mon)) {
505 monitor_json_emitter(mon, data);
506 }
507 }
508}
509
510
511/*
512 * Queue a new event for emission to Monitor instances,
513 * applying any rate limiting if required.
514 */
515static void
516monitor_protocol_event_queue(MonitorEvent event,
517 QObject *data)
518{
519 MonitorEventState *evstate;
520 int64_t now = qemu_get_clock_ns(rt_clock);
521 assert(event < QEVENT_MAX);
522
523 qemu_mutex_lock(&monitor_event_state_lock);
524 evstate = &(monitor_event_state[event]);
525 trace_monitor_protocol_event_queue(event,
526 data,
527 evstate->rate,
528 evstate->last,
529 now);
530
531 /* Rate limit of 0 indicates no throttling */
532 if (!evstate->rate) {
533 monitor_protocol_event_emit(event, data);
534 evstate->last = now;
535 } else {
536 int64_t delta = now - evstate->last;
537 if (evstate->data ||
538 delta < evstate->rate) {
539 /* If there's an existing event pending, replace
540 * it with the new event, otherwise schedule a
541 * timer for delayed emission
542 */
543 if (evstate->data) {
544 qobject_decref(evstate->data);
545 } else {
546 int64_t then = evstate->last + evstate->rate;
547 qemu_mod_timer_ns(evstate->timer, then);
548 }
549 evstate->data = data;
550 qobject_incref(evstate->data);
551 } else {
552 monitor_protocol_event_emit(event, data);
553 evstate->last = now;
554 }
555 }
556 qemu_mutex_unlock(&monitor_event_state_lock);
557}
558
559
560/*
561 * The callback invoked by QemuTimer when a delayed
562 * event is ready to be emitted
563 */
564static void monitor_protocol_event_handler(void *opaque)
565{
566 MonitorEventState *evstate = opaque;
567 int64_t now = qemu_get_clock_ns(rt_clock);
568
569 qemu_mutex_lock(&monitor_event_state_lock);
570
571 trace_monitor_protocol_event_handler(evstate->event,
572 evstate->data,
573 evstate->last,
574 now);
575 if (evstate->data) {
576 monitor_protocol_event_emit(evstate->event, evstate->data);
577 qobject_decref(evstate->data);
578 evstate->data = NULL;
579 }
580 evstate->last = now;
581 qemu_mutex_unlock(&monitor_event_state_lock);
582}
583
584
585/*
586 * @event: the event ID to be limited
587 * @rate: the rate limit in milliseconds
588 *
589 * Sets a rate limit on a particular event, so no
590 * more than 1 event will be emitted within @rate
591 * milliseconds
592 */
593static void
594monitor_protocol_event_throttle(MonitorEvent event,
595 int64_t rate)
596{
597 MonitorEventState *evstate;
598 assert(event < QEVENT_MAX);
599
600 evstate = &(monitor_event_state[event]);
601
602 trace_monitor_protocol_event_throttle(event, rate);
603 evstate->event = event;
604 evstate->rate = rate * SCALE_MS;
605 evstate->timer = qemu_new_timer(rt_clock,
606 SCALE_MS,
607 monitor_protocol_event_handler,
608 evstate);
609 evstate->last = 0;
610 evstate->data = NULL;
611}
612
613
614/* Global, one-time initializer to configure the rate limiting
615 * and initialize state */
616static void monitor_protocol_event_init(void)
617{
618 qemu_mutex_init(&monitor_event_state_lock);
619 /* Limit RTC & BALLOON events to 1 per second */
620 monitor_protocol_event_throttle(QEVENT_RTC_CHANGE, 1000);
621 monitor_protocol_event_throttle(QEVENT_BALLOON_CHANGE, 1000);
622 monitor_protocol_event_throttle(QEVENT_WATCHDOG, 1000);
623}
624
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200625/**
626 * monitor_protocol_event(): Generate a Monitor event
627 *
628 * Event-specific data can be emitted through the (optional) 'data' parameter.
629 */
630void monitor_protocol_event(MonitorEvent event, QObject *data)
631{
632 QDict *qmp;
633 const char *event_name;
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200634
Blue Swirl242cd002009-12-04 18:05:45 +0000635 assert(event < QEVENT_MAX);
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200636
Daniel P. Berrange48608532012-05-21 17:59:51 +0100637 event_name = monitor_event_names[event];
638 assert(event_name != NULL);
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200639
640 qmp = qdict_new();
641 timestamp_put(qmp);
642 qdict_put(qmp, "event", qstring_from_str(event_name));
Luiz Capitulino3d72f9a2010-01-08 16:45:53 -0200643 if (data) {
644 qobject_incref(data);
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200645 qdict_put_obj(qmp, "data", data);
Luiz Capitulino3d72f9a2010-01-08 16:45:53 -0200646 }
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200647
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100648 trace_monitor_protocol_event(event, event_name, qmp);
649 monitor_protocol_event_queue(event, QOBJECT(qmp));
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200650 QDECREF(qmp);
651}
652
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -0200653static int do_qmp_capabilities(Monitor *mon, const QDict *params,
654 QObject **ret_data)
Luiz Capitulino4a7e1192010-02-04 18:10:05 -0200655{
656 /* Will setup QMP capabilities in the future */
657 if (monitor_ctrl_mode(mon)) {
658 mon->mc->command_mode = 1;
659 }
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -0200660
661 return 0;
Luiz Capitulino4a7e1192010-02-04 18:10:05 -0200662}
663
Luiz Capitulino0268d972010-10-22 10:08:02 -0200664static void handle_user_command(Monitor *mon, const char *cmdline);
665
Luiz Capitulinod51a67b2011-11-25 17:52:45 -0200666char *qmp_human_monitor_command(const char *command_line, bool has_cpu_index,
667 int64_t cpu_index, Error **errp)
Luiz Capitulino0268d972010-10-22 10:08:02 -0200668{
Luiz Capitulinod51a67b2011-11-25 17:52:45 -0200669 char *output = NULL;
Luiz Capitulino0268d972010-10-22 10:08:02 -0200670 Monitor *old_mon, hmp;
671 CharDriverState mchar;
672
673 memset(&hmp, 0, sizeof(hmp));
674 qemu_chr_init_mem(&mchar);
675 hmp.chr = &mchar;
676
677 old_mon = cur_mon;
678 cur_mon = &hmp;
679
Luiz Capitulinod51a67b2011-11-25 17:52:45 -0200680 if (has_cpu_index) {
681 int ret = monitor_set_cpu(cpu_index);
Luiz Capitulino0268d972010-10-22 10:08:02 -0200682 if (ret < 0) {
683 cur_mon = old_mon;
Luiz Capitulinod51a67b2011-11-25 17:52:45 -0200684 error_set(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
685 "a CPU number");
Luiz Capitulino0268d972010-10-22 10:08:02 -0200686 goto out;
687 }
688 }
689
Luiz Capitulinod51a67b2011-11-25 17:52:45 -0200690 handle_user_command(&hmp, command_line);
Luiz Capitulino0268d972010-10-22 10:08:02 -0200691 cur_mon = old_mon;
692
693 if (qemu_chr_mem_osize(hmp.chr) > 0) {
Luiz Capitulinod51a67b2011-11-25 17:52:45 -0200694 QString *str = qemu_chr_mem_to_qs(hmp.chr);
695 output = g_strdup(qstring_get_str(str));
696 QDECREF(str);
697 } else {
698 output = g_strdup("");
Luiz Capitulino0268d972010-10-22 10:08:02 -0200699 }
700
701out:
702 qemu_chr_close_mem(hmp.chr);
Luiz Capitulinod51a67b2011-11-25 17:52:45 -0200703 return output;
Luiz Capitulino0268d972010-10-22 10:08:02 -0200704}
705
bellard9dc39cb2004-03-14 21:38:27 +0000706static int compare_cmd(const char *name, const char *list)
707{
708 const char *p, *pstart;
709 int len;
710 len = strlen(name);
711 p = list;
712 for(;;) {
713 pstart = p;
714 p = strchr(p, '|');
715 if (!p)
716 p = pstart + strlen(pstart);
717 if ((p - pstart) == len && !memcmp(pstart, name, len))
718 return 1;
719 if (*p == '\0')
720 break;
721 p++;
722 }
723 return 0;
724}
725
Anthony Liguoric227f092009-10-01 16:12:16 -0500726static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
aliguori376253e2009-03-05 23:01:23 +0000727 const char *prefix, const char *name)
bellard9dc39cb2004-03-14 21:38:27 +0000728{
Anthony Liguoric227f092009-10-01 16:12:16 -0500729 const mon_cmd_t *cmd;
bellard9dc39cb2004-03-14 21:38:27 +0000730
731 for(cmd = cmds; cmd->name != NULL; cmd++) {
732 if (!name || !strcmp(name, cmd->name))
aliguori376253e2009-03-05 23:01:23 +0000733 monitor_printf(mon, "%s%s %s -- %s\n", prefix, cmd->name,
734 cmd->params, cmd->help);
bellard9dc39cb2004-03-14 21:38:27 +0000735 }
736}
737
aliguori376253e2009-03-05 23:01:23 +0000738static void help_cmd(Monitor *mon, const char *name)
bellard9dc39cb2004-03-14 21:38:27 +0000739{
740 if (name && !strcmp(name, "info")) {
aliguori376253e2009-03-05 23:01:23 +0000741 help_cmd_dump(mon, info_cmds, "info ", NULL);
bellard9dc39cb2004-03-14 21:38:27 +0000742 } else {
aliguori376253e2009-03-05 23:01:23 +0000743 help_cmd_dump(mon, mon_cmds, "", name);
bellardf193c792004-03-21 17:06:25 +0000744 if (name && !strcmp(name, "log")) {
Peter Maydell38dad9e2013-02-11 16:41:25 +0000745 const QEMULogItem *item;
aliguori376253e2009-03-05 23:01:23 +0000746 monitor_printf(mon, "Log items (comma separated):\n");
747 monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");
Peter Maydell38dad9e2013-02-11 16:41:25 +0000748 for (item = qemu_log_items; item->mask != 0; item++) {
aliguori376253e2009-03-05 23:01:23 +0000749 monitor_printf(mon, "%-10s %s\n", item->name, item->help);
bellardf193c792004-03-21 17:06:25 +0000750 }
751 }
bellard9dc39cb2004-03-14 21:38:27 +0000752 }
753}
754
Luiz Capitulinod54908a2009-08-28 15:27:13 -0300755static void do_help_cmd(Monitor *mon, const QDict *qdict)
Luiz Capitulino38183182009-08-28 15:27:08 -0300756{
Luiz Capitulinod54908a2009-08-28 15:27:13 -0300757 help_cmd(mon, qdict_get_try_str(qdict, "name"));
Luiz Capitulino38183182009-08-28 15:27:08 -0300758}
759
Lluísfc764102011-08-31 20:31:18 +0200760static void do_trace_event_set_state(Monitor *mon, const QDict *qdict)
Prerna Saxena22890ab2010-06-24 17:04:53 +0530761{
762 const char *tp_name = qdict_get_str(qdict, "name");
763 bool new_state = qdict_get_bool(qdict, "option");
Blue Swirlf871d682010-10-13 19:14:29 +0000764
Lluís Vilanovaca285c32013-03-05 14:47:43 +0100765 bool found = false;
766 TraceEvent *ev = NULL;
767 while ((ev = trace_event_pattern(tp_name, ev)) != NULL) {
768 found = true;
769 if (!trace_event_get_state_static(ev)) {
770 monitor_printf(mon, "event \"%s\" is not traceable\n", tp_name);
771 } else {
772 trace_event_set_state_dynamic(ev, new_state);
773 }
774 }
775 if (!trace_event_is_pattern(tp_name) && !found) {
Blue Swirlf871d682010-10-13 19:14:29 +0000776 monitor_printf(mon, "unknown event name \"%s\"\n", tp_name);
777 }
Prerna Saxena22890ab2010-06-24 17:04:53 +0530778}
Stefan Hajnoczic5ceb522010-07-13 09:26:33 +0100779
Michael Rothc45a8162011-10-02 08:44:37 -0500780#ifdef CONFIG_TRACE_SIMPLE
Stefan Hajnoczic5ceb522010-07-13 09:26:33 +0100781static void do_trace_file(Monitor *mon, const QDict *qdict)
782{
783 const char *op = qdict_get_try_str(qdict, "op");
784 const char *arg = qdict_get_try_str(qdict, "arg");
785
786 if (!op) {
787 st_print_trace_file_status((FILE *)mon, &monitor_fprintf);
788 } else if (!strcmp(op, "on")) {
789 st_set_trace_file_enabled(true);
790 } else if (!strcmp(op, "off")) {
791 st_set_trace_file_enabled(false);
792 } else if (!strcmp(op, "flush")) {
793 st_flush_trace_buffer();
794 } else if (!strcmp(op, "set")) {
795 if (arg) {
796 st_set_trace_file(arg);
797 }
798 } else {
799 monitor_printf(mon, "unexpected argument \"%s\"\n", op);
800 help_cmd(mon, "trace-file");
801 }
802}
Prerna Saxena22890ab2010-06-24 17:04:53 +0530803#endif
804
Adam Litke940cc302010-01-25 12:18:44 -0600805static void user_monitor_complete(void *opaque, QObject *ret_data)
806{
807 MonitorCompletionData *data = (MonitorCompletionData *)opaque;
808
809 if (ret_data) {
810 data->user_print(data->mon, ret_data);
811 }
812 monitor_resume(data->mon);
Anthony Liguori7267c092011-08-20 22:09:37 -0500813 g_free(data);
Adam Litke940cc302010-01-25 12:18:44 -0600814}
815
816static void qmp_monitor_complete(void *opaque, QObject *ret_data)
817{
818 monitor_protocol_emitter(opaque, ret_data);
819}
820
Luiz Capitulino5af7bba2010-06-22 19:10:46 -0300821static int qmp_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,
822 const QDict *params)
Adam Litke940cc302010-01-25 12:18:44 -0600823{
Luiz Capitulino5af7bba2010-06-22 19:10:46 -0300824 return cmd->mhandler.cmd_async(mon, params, qmp_monitor_complete, mon);
Adam Litke940cc302010-01-25 12:18:44 -0600825}
826
Adam Litke940cc302010-01-25 12:18:44 -0600827static void user_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,
828 const QDict *params)
829{
830 int ret;
831
Anthony Liguori7267c092011-08-20 22:09:37 -0500832 MonitorCompletionData *cb_data = g_malloc(sizeof(*cb_data));
Adam Litke940cc302010-01-25 12:18:44 -0600833 cb_data->mon = mon;
834 cb_data->user_print = cmd->user_print;
835 monitor_suspend(mon);
836 ret = cmd->mhandler.cmd_async(mon, params,
837 user_monitor_complete, cb_data);
838 if (ret < 0) {
839 monitor_resume(mon);
Anthony Liguori7267c092011-08-20 22:09:37 -0500840 g_free(cb_data);
Adam Litke940cc302010-01-25 12:18:44 -0600841 }
842}
843
Wenchao Xia84c44612013-01-14 14:06:29 +0800844static void do_info_help(Monitor *mon, const QDict *qdict)
bellard9dc39cb2004-03-14 21:38:27 +0000845{
Luiz Capitulino13c74252009-10-07 13:41:55 -0300846 help_cmd(mon, "info");
bellard9dc39cb2004-03-14 21:38:27 +0000847}
848
Luiz Capitulinoaa9b79b2011-09-21 14:31:51 -0300849CommandInfoList *qmp_query_commands(Error **errp)
bellard9bc9d1c2004-10-10 15:15:51 +0000850{
Luiz Capitulinoaa9b79b2011-09-21 14:31:51 -0300851 CommandInfoList *info, *cmd_list = NULL;
Luiz Capitulinoe3bba9d2009-11-26 22:58:56 -0200852 const mon_cmd_t *cmd;
853
Luiz Capitulinof36b4af2010-09-15 17:17:45 -0300854 for (cmd = qmp_cmds; cmd->name != NULL; cmd++) {
Luiz Capitulino40e5a012011-10-21 16:15:31 -0200855 info = g_malloc0(sizeof(*info));
856 info->value = g_malloc0(sizeof(*info->value));
857 info->value->name = g_strdup(cmd->name);
Luiz Capitulinoe3bba9d2009-11-26 22:58:56 -0200858
Luiz Capitulinoaa9b79b2011-09-21 14:31:51 -0300859 info->next = cmd_list;
860 cmd_list = info;
Luiz Capitulinoe3bba9d2009-11-26 22:58:56 -0200861 }
862
Luiz Capitulinoaa9b79b2011-09-21 14:31:51 -0300863 return cmd_list;
thsa36e69d2007-12-02 05:18:19 +0000864}
865
Daniel P. Berrange48608532012-05-21 17:59:51 +0100866EventInfoList *qmp_query_events(Error **errp)
867{
868 EventInfoList *info, *ev_list = NULL;
869 MonitorEvent e;
870
871 for (e = 0 ; e < QEVENT_MAX ; e++) {
872 const char *event_name = monitor_event_names[e];
873 assert(event_name != NULL);
874 info = g_malloc0(sizeof(*info));
875 info->value = g_malloc0(sizeof(*info->value));
876 info->value->name = g_strdup(event_name);
877
878 info->next = ev_list;
879 ev_list = info;
880 }
881
882 return ev_list;
883}
884
Luiz Capitulinob025c8b2011-10-06 14:02:57 -0300885/* set the current CPU defined by the user */
886int monitor_set_cpu(int cpu_index)
bellard6a00d602005-11-21 23:25:50 +0000887{
Andreas Färber55e5c282012-12-17 06:18:02 +0100888 CPUState *cpu;
bellard6a00d602005-11-21 23:25:50 +0000889
Andreas Färber1c8bb3c2013-02-15 17:01:09 +0100890 cpu = qemu_get_cpu(cpu_index);
891 if (cpu == NULL) {
892 return -1;
bellard6a00d602005-11-21 23:25:50 +0000893 }
Andreas Färber1c8bb3c2013-02-15 17:01:09 +0100894 cur_mon->mon_cpu = cpu->env_ptr;
895 return 0;
bellard6a00d602005-11-21 23:25:50 +0000896}
897
Andreas Färber9349b4f2012-03-14 01:38:32 +0100898static CPUArchState *mon_get_cpu(void)
bellard6a00d602005-11-21 23:25:50 +0000899{
aliguori731b0362009-03-05 23:01:42 +0000900 if (!cur_mon->mon_cpu) {
Luiz Capitulinob025c8b2011-10-06 14:02:57 -0300901 monitor_set_cpu(0);
bellard6a00d602005-11-21 23:25:50 +0000902 }
Avi Kivity4c0960c2009-08-17 23:19:53 +0300903 cpu_synchronize_state(cur_mon->mon_cpu);
aliguori731b0362009-03-05 23:01:42 +0000904 return cur_mon->mon_cpu;
bellard6a00d602005-11-21 23:25:50 +0000905}
906
Luiz Capitulino99b77962011-10-24 10:53:44 -0200907int monitor_get_cpu_index(void)
908{
Andreas Färber55e5c282012-12-17 06:18:02 +0100909 CPUState *cpu = ENV_GET_CPU(mon_get_cpu());
910 return cpu->cpu_index;
Luiz Capitulino99b77962011-10-24 10:53:44 -0200911}
912
Wenchao Xia84f2d0e2013-01-14 14:06:25 +0800913static void do_info_registers(Monitor *mon, const QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +0000914{
Andreas Färber9349b4f2012-03-14 01:38:32 +0100915 CPUArchState *env;
bellard6a00d602005-11-21 23:25:50 +0000916 env = mon_get_cpu();
Peter Maydell6fd2a022012-10-05 15:04:43 +0100917 cpu_dump_state(env, (FILE *)mon, monitor_fprintf, CPU_DUMP_FPU);
bellard9307c4c2004-04-04 12:57:25 +0000918}
919
Wenchao Xia84f2d0e2013-01-14 14:06:25 +0800920static void do_info_jit(Monitor *mon, const QDict *qdict)
bellarde3db7222005-01-26 22:00:47 +0000921{
aliguori376253e2009-03-05 23:01:23 +0000922 dump_exec_info((FILE *)mon, monitor_fprintf);
bellarde3db7222005-01-26 22:00:47 +0000923}
924
Wenchao Xia84f2d0e2013-01-14 14:06:25 +0800925static void do_info_history(Monitor *mon, const QDict *qdict)
bellardaa455482004-04-04 13:07:25 +0000926{
927 int i;
bellard7e2515e2004-08-01 21:52:19 +0000928 const char *str;
ths3b46e622007-09-17 08:09:54 +0000929
aliguoricde76ee2009-03-05 23:01:51 +0000930 if (!mon->rs)
931 return;
bellard7e2515e2004-08-01 21:52:19 +0000932 i = 0;
933 for(;;) {
aliguori731b0362009-03-05 23:01:42 +0000934 str = readline_get_history(mon->rs, i);
bellard7e2515e2004-08-01 21:52:19 +0000935 if (!str)
936 break;
aliguori376253e2009-03-05 23:01:23 +0000937 monitor_printf(mon, "%d: '%s'\n", i, str);
bellard8e3a9fd2004-10-09 17:32:58 +0000938 i++;
bellardaa455482004-04-04 13:07:25 +0000939 }
940}
941
j_mayer76a66252007-03-07 08:32:30 +0000942#if defined(TARGET_PPC)
943/* XXX: not implemented in other targets */
Wenchao Xia84f2d0e2013-01-14 14:06:25 +0800944static void do_info_cpu_stats(Monitor *mon, const QDict *qdict)
j_mayer76a66252007-03-07 08:32:30 +0000945{
Andreas Färber9349b4f2012-03-14 01:38:32 +0100946 CPUArchState *env;
j_mayer76a66252007-03-07 08:32:30 +0000947
948 env = mon_get_cpu();
aliguori376253e2009-03-05 23:01:23 +0000949 cpu_dump_statistics(env, (FILE *)mon, &monitor_fprintf, 0);
j_mayer76a66252007-03-07 08:32:30 +0000950}
951#endif
952
Wenchao Xia84f2d0e2013-01-14 14:06:25 +0800953static void do_trace_print_events(Monitor *mon, const QDict *qdict)
Prerna Saxena22890ab2010-06-24 17:04:53 +0530954{
Lluísfc764102011-08-31 20:31:18 +0200955 trace_print_events((FILE *)mon, &monitor_fprintf);
Prerna Saxena22890ab2010-06-24 17:04:53 +0530956}
Prerna Saxena22890ab2010-06-24 17:04:53 +0530957
Yonit Halperinedc5cb12011-10-17 10:03:18 +0200958static int client_migrate_info(Monitor *mon, const QDict *qdict,
959 MonitorCompletion cb, void *opaque)
Gerd Hoffmanne866e232010-04-23 13:28:21 +0200960{
961 const char *protocol = qdict_get_str(qdict, "protocol");
962 const char *hostname = qdict_get_str(qdict, "hostname");
963 const char *subject = qdict_get_try_str(qdict, "cert-subject");
964 int port = qdict_get_try_int(qdict, "port", -1);
965 int tls_port = qdict_get_try_int(qdict, "tls-port", -1);
966 int ret;
967
968 if (strcmp(protocol, "spice") == 0) {
969 if (!using_spice) {
970 qerror_report(QERR_DEVICE_NOT_ACTIVE, "spice");
971 return -1;
972 }
973
Yonit Halperin6ec5dae2012-03-18 09:42:39 +0200974 if (port == -1 && tls_port == -1) {
975 qerror_report(QERR_MISSING_PARAMETER, "port/tls-port");
976 return -1;
977 }
978
Yonit Halperinedc5cb12011-10-17 10:03:18 +0200979 ret = qemu_spice_migrate_info(hostname, port, tls_port, subject,
980 cb, opaque);
Gerd Hoffmanne866e232010-04-23 13:28:21 +0200981 if (ret != 0) {
982 qerror_report(QERR_UNDEFINED_ERROR);
983 return -1;
984 }
985 return 0;
986 }
987
988 qerror_report(QERR_INVALID_PARAMETER, "protocol");
989 return -1;
990}
991
Luiz Capitulinod54908a2009-08-28 15:27:13 -0300992static void do_logfile(Monitor *mon, const QDict *qdict)
pbrooke735b912007-06-30 13:53:24 +0000993{
Peter Maydell9a7e5422013-02-11 16:41:20 +0000994 qemu_set_log_filename(qdict_get_str(qdict, "filename"));
pbrooke735b912007-06-30 13:53:24 +0000995}
996
Luiz Capitulinod54908a2009-08-28 15:27:13 -0300997static void do_log(Monitor *mon, const QDict *qdict)
bellardf193c792004-03-21 17:06:25 +0000998{
999 int mask;
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001000 const char *items = qdict_get_str(qdict, "items");
ths3b46e622007-09-17 08:09:54 +00001001
bellard9307c4c2004-04-04 12:57:25 +00001002 if (!strcmp(items, "none")) {
bellardf193c792004-03-21 17:06:25 +00001003 mask = 0;
1004 } else {
Peter Maydell4fde1eb2013-02-11 16:41:22 +00001005 mask = qemu_str_to_log_mask(items);
bellardf193c792004-03-21 17:06:25 +00001006 if (!mask) {
aliguori376253e2009-03-05 23:01:23 +00001007 help_cmd(mon, "log");
bellardf193c792004-03-21 17:06:25 +00001008 return;
1009 }
1010 }
Peter Maydell24537a02013-02-11 16:41:23 +00001011 qemu_set_log(mask);
bellardf193c792004-03-21 17:06:25 +00001012}
1013
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001014static void do_singlestep(Monitor *mon, const QDict *qdict)
aurel321b530a62009-04-05 20:08:59 +00001015{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001016 const char *option = qdict_get_try_str(qdict, "option");
aurel321b530a62009-04-05 20:08:59 +00001017 if (!option || !strcmp(option, "on")) {
1018 singlestep = 1;
1019 } else if (!strcmp(option, "off")) {
1020 singlestep = 0;
1021 } else {
1022 monitor_printf(mon, "unexpected option %s\n", option);
1023 }
1024}
1025
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001026static void do_gdbserver(Monitor *mon, const QDict *qdict)
bellard8a7ddc32004-03-31 19:00:16 +00001027{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001028 const char *device = qdict_get_try_str(qdict, "device");
aliguori59030a82009-04-05 18:43:41 +00001029 if (!device)
1030 device = "tcp::" DEFAULT_GDBSTUB_PORT;
1031 if (gdbserver_start(device) < 0) {
1032 monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
1033 device);
1034 } else if (strcmp(device, "none") == 0) {
aliguori36556b22009-03-28 18:05:53 +00001035 monitor_printf(mon, "Disabled gdbserver\n");
bellard8a7ddc32004-03-31 19:00:16 +00001036 } else {
aliguori59030a82009-04-05 18:43:41 +00001037 monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
1038 device);
bellard8a7ddc32004-03-31 19:00:16 +00001039 }
1040}
1041
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001042static void do_watchdog_action(Monitor *mon, const QDict *qdict)
Richard W.M. Jones9dd986c2009-04-25 13:56:19 +01001043{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001044 const char *action = qdict_get_str(qdict, "action");
Richard W.M. Jones9dd986c2009-04-25 13:56:19 +01001045 if (select_watchdog_action(action) == -1) {
1046 monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
1047 }
1048}
1049
aliguori376253e2009-03-05 23:01:23 +00001050static void monitor_printc(Monitor *mon, int c)
bellard9307c4c2004-04-04 12:57:25 +00001051{
aliguori376253e2009-03-05 23:01:23 +00001052 monitor_printf(mon, "'");
bellard9307c4c2004-04-04 12:57:25 +00001053 switch(c) {
1054 case '\'':
aliguori376253e2009-03-05 23:01:23 +00001055 monitor_printf(mon, "\\'");
bellard9307c4c2004-04-04 12:57:25 +00001056 break;
1057 case '\\':
aliguori376253e2009-03-05 23:01:23 +00001058 monitor_printf(mon, "\\\\");
bellard9307c4c2004-04-04 12:57:25 +00001059 break;
1060 case '\n':
aliguori376253e2009-03-05 23:01:23 +00001061 monitor_printf(mon, "\\n");
bellard9307c4c2004-04-04 12:57:25 +00001062 break;
1063 case '\r':
aliguori376253e2009-03-05 23:01:23 +00001064 monitor_printf(mon, "\\r");
bellard9307c4c2004-04-04 12:57:25 +00001065 break;
1066 default:
1067 if (c >= 32 && c <= 126) {
aliguori376253e2009-03-05 23:01:23 +00001068 monitor_printf(mon, "%c", c);
bellard9307c4c2004-04-04 12:57:25 +00001069 } else {
aliguori376253e2009-03-05 23:01:23 +00001070 monitor_printf(mon, "\\x%02x", c);
bellard9307c4c2004-04-04 12:57:25 +00001071 }
1072 break;
1073 }
aliguori376253e2009-03-05 23:01:23 +00001074 monitor_printf(mon, "'");
bellard9307c4c2004-04-04 12:57:25 +00001075}
1076
aliguori376253e2009-03-05 23:01:23 +00001077static void memory_dump(Monitor *mon, int count, int format, int wsize,
Avi Kivitya8170e52012-10-23 12:30:10 +02001078 hwaddr addr, int is_physical)
bellard9307c4c2004-04-04 12:57:25 +00001079{
Andreas Färber9349b4f2012-03-14 01:38:32 +01001080 CPUArchState *env;
Blue Swirl23842aa2010-01-12 20:27:43 +00001081 int l, line_size, i, max_digits, len;
bellard9307c4c2004-04-04 12:57:25 +00001082 uint8_t buf[16];
1083 uint64_t v;
1084
1085 if (format == 'i') {
1086 int flags;
1087 flags = 0;
bellard6a00d602005-11-21 23:25:50 +00001088 env = mon_get_cpu();
bellard9307c4c2004-04-04 12:57:25 +00001089#ifdef TARGET_I386
bellard4c27ba22004-04-25 18:05:08 +00001090 if (wsize == 2) {
bellard9307c4c2004-04-04 12:57:25 +00001091 flags = 1;
bellard4c27ba22004-04-25 18:05:08 +00001092 } else if (wsize == 4) {
1093 flags = 0;
1094 } else {
bellard6a15fd12006-04-12 21:07:07 +00001095 /* as default we use the current CS size */
bellard4c27ba22004-04-25 18:05:08 +00001096 flags = 0;
bellard6a15fd12006-04-12 21:07:07 +00001097 if (env) {
1098#ifdef TARGET_X86_64
ths5fafdf22007-09-16 21:08:06 +00001099 if ((env->efer & MSR_EFER_LMA) &&
bellard6a15fd12006-04-12 21:07:07 +00001100 (env->segs[R_CS].flags & DESC_L_MASK))
1101 flags = 2;
1102 else
1103#endif
1104 if (!(env->segs[R_CS].flags & DESC_B_MASK))
1105 flags = 1;
1106 }
bellard4c27ba22004-04-25 18:05:08 +00001107 }
1108#endif
aliguori376253e2009-03-05 23:01:23 +00001109 monitor_disas(mon, env, addr, count, is_physical, flags);
bellard9307c4c2004-04-04 12:57:25 +00001110 return;
1111 }
1112
1113 len = wsize * count;
1114 if (wsize == 1)
1115 line_size = 8;
1116 else
1117 line_size = 16;
bellard9307c4c2004-04-04 12:57:25 +00001118 max_digits = 0;
1119
1120 switch(format) {
1121 case 'o':
1122 max_digits = (wsize * 8 + 2) / 3;
1123 break;
1124 default:
1125 case 'x':
1126 max_digits = (wsize * 8) / 4;
1127 break;
1128 case 'u':
1129 case 'd':
1130 max_digits = (wsize * 8 * 10 + 32) / 33;
1131 break;
1132 case 'c':
1133 wsize = 1;
1134 break;
1135 }
1136
1137 while (len > 0) {
blueswir17743e582007-09-24 18:39:04 +00001138 if (is_physical)
aliguori376253e2009-03-05 23:01:23 +00001139 monitor_printf(mon, TARGET_FMT_plx ":", addr);
blueswir17743e582007-09-24 18:39:04 +00001140 else
aliguori376253e2009-03-05 23:01:23 +00001141 monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
bellard9307c4c2004-04-04 12:57:25 +00001142 l = len;
1143 if (l > line_size)
1144 l = line_size;
1145 if (is_physical) {
Stefan Weil54f7b4a2011-04-10 18:23:39 +02001146 cpu_physical_memory_read(addr, buf, l);
bellard9307c4c2004-04-04 12:57:25 +00001147 } else {
bellard6a00d602005-11-21 23:25:50 +00001148 env = mon_get_cpu();
aliguoric8f79b62008-08-18 14:00:20 +00001149 if (cpu_memory_rw_debug(env, addr, buf, l, 0) < 0) {
aliguori376253e2009-03-05 23:01:23 +00001150 monitor_printf(mon, " Cannot access memory\n");
aliguoric8f79b62008-08-18 14:00:20 +00001151 break;
1152 }
bellard9307c4c2004-04-04 12:57:25 +00001153 }
ths5fafdf22007-09-16 21:08:06 +00001154 i = 0;
bellard9307c4c2004-04-04 12:57:25 +00001155 while (i < l) {
1156 switch(wsize) {
1157 default:
1158 case 1:
1159 v = ldub_raw(buf + i);
1160 break;
1161 case 2:
1162 v = lduw_raw(buf + i);
1163 break;
1164 case 4:
bellard92a31b12005-02-10 22:00:52 +00001165 v = (uint32_t)ldl_raw(buf + i);
bellard9307c4c2004-04-04 12:57:25 +00001166 break;
1167 case 8:
1168 v = ldq_raw(buf + i);
1169 break;
1170 }
aliguori376253e2009-03-05 23:01:23 +00001171 monitor_printf(mon, " ");
bellard9307c4c2004-04-04 12:57:25 +00001172 switch(format) {
1173 case 'o':
aliguori376253e2009-03-05 23:01:23 +00001174 monitor_printf(mon, "%#*" PRIo64, max_digits, v);
bellard9307c4c2004-04-04 12:57:25 +00001175 break;
1176 case 'x':
aliguori376253e2009-03-05 23:01:23 +00001177 monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
bellard9307c4c2004-04-04 12:57:25 +00001178 break;
1179 case 'u':
aliguori376253e2009-03-05 23:01:23 +00001180 monitor_printf(mon, "%*" PRIu64, max_digits, v);
bellard9307c4c2004-04-04 12:57:25 +00001181 break;
1182 case 'd':
aliguori376253e2009-03-05 23:01:23 +00001183 monitor_printf(mon, "%*" PRId64, max_digits, v);
bellard9307c4c2004-04-04 12:57:25 +00001184 break;
1185 case 'c':
aliguori376253e2009-03-05 23:01:23 +00001186 monitor_printc(mon, v);
bellard9307c4c2004-04-04 12:57:25 +00001187 break;
1188 }
1189 i += wsize;
1190 }
aliguori376253e2009-03-05 23:01:23 +00001191 monitor_printf(mon, "\n");
bellard9307c4c2004-04-04 12:57:25 +00001192 addr += l;
1193 len -= l;
1194 }
1195}
1196
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001197static void do_memory_dump(Monitor *mon, const QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +00001198{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001199 int count = qdict_get_int(qdict, "count");
1200 int format = qdict_get_int(qdict, "format");
1201 int size = qdict_get_int(qdict, "size");
1202 target_long addr = qdict_get_int(qdict, "addr");
1203
aliguori376253e2009-03-05 23:01:23 +00001204 memory_dump(mon, count, format, size, addr, 0);
bellard9307c4c2004-04-04 12:57:25 +00001205}
1206
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001207static void do_physical_memory_dump(Monitor *mon, const QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +00001208{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001209 int count = qdict_get_int(qdict, "count");
1210 int format = qdict_get_int(qdict, "format");
1211 int size = qdict_get_int(qdict, "size");
Avi Kivitya8170e52012-10-23 12:30:10 +02001212 hwaddr addr = qdict_get_int(qdict, "addr");
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001213
aliguori376253e2009-03-05 23:01:23 +00001214 memory_dump(mon, count, format, size, addr, 1);
bellard9307c4c2004-04-04 12:57:25 +00001215}
1216
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001217static void do_print(Monitor *mon, const QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +00001218{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001219 int format = qdict_get_int(qdict, "format");
Avi Kivitya8170e52012-10-23 12:30:10 +02001220 hwaddr val = qdict_get_int(qdict, "val");
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001221
bellard9307c4c2004-04-04 12:57:25 +00001222 switch(format) {
1223 case 'o':
Avi Kivitya8170e52012-10-23 12:30:10 +02001224 monitor_printf(mon, "%#" HWADDR_PRIo, val);
bellard9307c4c2004-04-04 12:57:25 +00001225 break;
1226 case 'x':
Avi Kivitya8170e52012-10-23 12:30:10 +02001227 monitor_printf(mon, "%#" HWADDR_PRIx, val);
bellard9307c4c2004-04-04 12:57:25 +00001228 break;
1229 case 'u':
Avi Kivitya8170e52012-10-23 12:30:10 +02001230 monitor_printf(mon, "%" HWADDR_PRIu, val);
bellard9307c4c2004-04-04 12:57:25 +00001231 break;
1232 default:
1233 case 'd':
Avi Kivitya8170e52012-10-23 12:30:10 +02001234 monitor_printf(mon, "%" HWADDR_PRId, val);
bellard9307c4c2004-04-04 12:57:25 +00001235 break;
1236 case 'c':
aliguori376253e2009-03-05 23:01:23 +00001237 monitor_printc(mon, val);
bellard9307c4c2004-04-04 12:57:25 +00001238 break;
1239 }
aliguori376253e2009-03-05 23:01:23 +00001240 monitor_printf(mon, "\n");
bellard9307c4c2004-04-04 12:57:25 +00001241}
1242
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03001243static void do_sum(Monitor *mon, const QDict *qdict)
bellarde4cf1ad2005-06-04 20:15:57 +00001244{
1245 uint32_t addr;
bellarde4cf1ad2005-06-04 20:15:57 +00001246 uint16_t sum;
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03001247 uint32_t start = qdict_get_int(qdict, "start");
1248 uint32_t size = qdict_get_int(qdict, "size");
bellarde4cf1ad2005-06-04 20:15:57 +00001249
1250 sum = 0;
1251 for(addr = start; addr < (start + size); addr++) {
Stefan Weil54f7b4a2011-04-10 18:23:39 +02001252 uint8_t val = ldub_phys(addr);
bellarde4cf1ad2005-06-04 20:15:57 +00001253 /* BSD sum algorithm ('sum' Unix command) */
1254 sum = (sum >> 1) | (sum << 15);
Stefan Weil54f7b4a2011-04-10 18:23:39 +02001255 sum += val;
bellarde4cf1ad2005-06-04 20:15:57 +00001256 }
aliguori376253e2009-03-05 23:01:23 +00001257 monitor_printf(mon, "%05d\n", sum);
bellarde4cf1ad2005-06-04 20:15:57 +00001258}
1259
bellard13224a82006-07-14 22:03:35 +00001260static int mouse_button_state;
1261
Luiz Capitulino1d4daa92009-08-28 15:27:15 -03001262static void do_mouse_move(Monitor *mon, const QDict *qdict)
bellard13224a82006-07-14 22:03:35 +00001263{
1264 int dx, dy, dz;
Luiz Capitulino1d4daa92009-08-28 15:27:15 -03001265 const char *dx_str = qdict_get_str(qdict, "dx_str");
1266 const char *dy_str = qdict_get_str(qdict, "dy_str");
1267 const char *dz_str = qdict_get_try_str(qdict, "dz_str");
bellard13224a82006-07-14 22:03:35 +00001268 dx = strtol(dx_str, NULL, 0);
1269 dy = strtol(dy_str, NULL, 0);
1270 dz = 0;
ths5fafdf22007-09-16 21:08:06 +00001271 if (dz_str)
bellard13224a82006-07-14 22:03:35 +00001272 dz = strtol(dz_str, NULL, 0);
1273 kbd_mouse_event(dx, dy, dz, mouse_button_state);
1274}
1275
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001276static void do_mouse_button(Monitor *mon, const QDict *qdict)
bellard13224a82006-07-14 22:03:35 +00001277{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001278 int button_state = qdict_get_int(qdict, "button_state");
bellard13224a82006-07-14 22:03:35 +00001279 mouse_button_state = button_state;
1280 kbd_mouse_event(0, 0, 0, mouse_button_state);
1281}
1282
Luiz Capitulinoaa93e392009-08-28 15:27:18 -03001283static void do_ioport_read(Monitor *mon, const QDict *qdict)
bellard34405572004-06-08 00:55:58 +00001284{
Luiz Capitulinoaa93e392009-08-28 15:27:18 -03001285 int size = qdict_get_int(qdict, "size");
1286 int addr = qdict_get_int(qdict, "addr");
1287 int has_index = qdict_haskey(qdict, "index");
bellard34405572004-06-08 00:55:58 +00001288 uint32_t val;
1289 int suffix;
1290
1291 if (has_index) {
Luiz Capitulinoaa93e392009-08-28 15:27:18 -03001292 int index = qdict_get_int(qdict, "index");
Blue Swirlafcea8c2009-09-20 16:05:47 +00001293 cpu_outb(addr & IOPORTS_MASK, index & 0xff);
bellard34405572004-06-08 00:55:58 +00001294 addr++;
1295 }
1296 addr &= 0xffff;
1297
1298 switch(size) {
1299 default:
1300 case 1:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001301 val = cpu_inb(addr);
bellard34405572004-06-08 00:55:58 +00001302 suffix = 'b';
1303 break;
1304 case 2:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001305 val = cpu_inw(addr);
bellard34405572004-06-08 00:55:58 +00001306 suffix = 'w';
1307 break;
1308 case 4:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001309 val = cpu_inl(addr);
bellard34405572004-06-08 00:55:58 +00001310 suffix = 'l';
1311 break;
1312 }
aliguori376253e2009-03-05 23:01:23 +00001313 monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
1314 suffix, addr, size * 2, val);
bellard34405572004-06-08 00:55:58 +00001315}
bellarda3a91a32004-06-04 11:06:21 +00001316
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001317static void do_ioport_write(Monitor *mon, const QDict *qdict)
Jan Kiszkaf1147842009-07-14 10:20:11 +02001318{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001319 int size = qdict_get_int(qdict, "size");
1320 int addr = qdict_get_int(qdict, "addr");
1321 int val = qdict_get_int(qdict, "val");
1322
Jan Kiszkaf1147842009-07-14 10:20:11 +02001323 addr &= IOPORTS_MASK;
1324
1325 switch (size) {
1326 default:
1327 case 1:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001328 cpu_outb(addr, val);
Jan Kiszkaf1147842009-07-14 10:20:11 +02001329 break;
1330 case 2:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001331 cpu_outw(addr, val);
Jan Kiszkaf1147842009-07-14 10:20:11 +02001332 break;
1333 case 4:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001334 cpu_outl(addr, val);
Jan Kiszkaf1147842009-07-14 10:20:11 +02001335 break;
1336 }
1337}
1338
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001339static void do_boot_set(Monitor *mon, const QDict *qdict)
aurel320ecdffb2008-05-04 20:11:34 +00001340{
1341 int res;
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001342 const char *bootdevice = qdict_get_str(qdict, "bootdevice");
aurel320ecdffb2008-05-04 20:11:34 +00001343
Jan Kiszka76e30d02009-07-02 00:19:02 +02001344 res = qemu_boot_set(bootdevice);
1345 if (res == 0) {
1346 monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
1347 } else if (res > 0) {
1348 monitor_printf(mon, "setting boot device list failed\n");
aurel320ecdffb2008-05-04 20:11:34 +00001349 } else {
aliguori376253e2009-03-05 23:01:23 +00001350 monitor_printf(mon, "no function defined to set boot device list for "
1351 "this architecture\n");
aurel320ecdffb2008-05-04 20:11:34 +00001352 }
1353}
1354
bellardb86bda52004-09-18 19:32:46 +00001355#if defined(TARGET_I386)
Avi Kivitya8170e52012-10-23 12:30:10 +02001356static void print_pte(Monitor *mon, hwaddr addr,
1357 hwaddr pte,
1358 hwaddr mask)
bellardb86bda52004-09-18 19:32:46 +00001359{
Blue Swirld65aaf32010-12-11 18:56:24 +00001360#ifdef TARGET_X86_64
1361 if (addr & (1ULL << 47)) {
1362 addr |= -1LL << 48;
1363 }
1364#endif
1365 monitor_printf(mon, TARGET_FMT_plx ": " TARGET_FMT_plx
1366 " %c%c%c%c%c%c%c%c%c\n",
aliguori376253e2009-03-05 23:01:23 +00001367 addr,
1368 pte & mask,
Blue Swirld65aaf32010-12-11 18:56:24 +00001369 pte & PG_NX_MASK ? 'X' : '-',
aliguori376253e2009-03-05 23:01:23 +00001370 pte & PG_GLOBAL_MASK ? 'G' : '-',
1371 pte & PG_PSE_MASK ? 'P' : '-',
1372 pte & PG_DIRTY_MASK ? 'D' : '-',
1373 pte & PG_ACCESSED_MASK ? 'A' : '-',
1374 pte & PG_PCD_MASK ? 'C' : '-',
1375 pte & PG_PWT_MASK ? 'T' : '-',
1376 pte & PG_USER_MASK ? 'U' : '-',
1377 pte & PG_RW_MASK ? 'W' : '-');
bellardb86bda52004-09-18 19:32:46 +00001378}
1379
Andreas Färber9349b4f2012-03-14 01:38:32 +01001380static void tlb_info_32(Monitor *mon, CPUArchState *env)
bellardb86bda52004-09-18 19:32:46 +00001381{
Austin Clements94ac5cd2011-08-21 14:49:45 -04001382 unsigned int l1, l2;
bellardb86bda52004-09-18 19:32:46 +00001383 uint32_t pgd, pde, pte;
1384
bellardb86bda52004-09-18 19:32:46 +00001385 pgd = env->cr[3] & ~0xfff;
1386 for(l1 = 0; l1 < 1024; l1++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001387 cpu_physical_memory_read(pgd + l1 * 4, &pde, 4);
bellardb86bda52004-09-18 19:32:46 +00001388 pde = le32_to_cpu(pde);
1389 if (pde & PG_PRESENT_MASK) {
1390 if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
Blue Swirld65aaf32010-12-11 18:56:24 +00001391 /* 4M pages */
1392 print_pte(mon, (l1 << 22), pde, ~((1 << 21) - 1));
bellardb86bda52004-09-18 19:32:46 +00001393 } else {
1394 for(l2 = 0; l2 < 1024; l2++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001395 cpu_physical_memory_read((pde & ~0xfff) + l2 * 4, &pte, 4);
bellardb86bda52004-09-18 19:32:46 +00001396 pte = le32_to_cpu(pte);
1397 if (pte & PG_PRESENT_MASK) {
aliguori376253e2009-03-05 23:01:23 +00001398 print_pte(mon, (l1 << 22) + (l2 << 12),
ths5fafdf22007-09-16 21:08:06 +00001399 pte & ~PG_PSE_MASK,
bellardb86bda52004-09-18 19:32:46 +00001400 ~0xfff);
1401 }
1402 }
1403 }
1404 }
1405 }
1406}
1407
Andreas Färber9349b4f2012-03-14 01:38:32 +01001408static void tlb_info_pae32(Monitor *mon, CPUArchState *env)
Blue Swirld65aaf32010-12-11 18:56:24 +00001409{
Austin Clements94ac5cd2011-08-21 14:49:45 -04001410 unsigned int l1, l2, l3;
Blue Swirld65aaf32010-12-11 18:56:24 +00001411 uint64_t pdpe, pde, pte;
1412 uint64_t pdp_addr, pd_addr, pt_addr;
1413
1414 pdp_addr = env->cr[3] & ~0x1f;
1415 for (l1 = 0; l1 < 4; l1++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001416 cpu_physical_memory_read(pdp_addr + l1 * 8, &pdpe, 8);
Blue Swirld65aaf32010-12-11 18:56:24 +00001417 pdpe = le64_to_cpu(pdpe);
1418 if (pdpe & PG_PRESENT_MASK) {
1419 pd_addr = pdpe & 0x3fffffffff000ULL;
1420 for (l2 = 0; l2 < 512; l2++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001421 cpu_physical_memory_read(pd_addr + l2 * 8, &pde, 8);
Blue Swirld65aaf32010-12-11 18:56:24 +00001422 pde = le64_to_cpu(pde);
1423 if (pde & PG_PRESENT_MASK) {
1424 if (pde & PG_PSE_MASK) {
1425 /* 2M pages with PAE, CR4.PSE is ignored */
1426 print_pte(mon, (l1 << 30 ) + (l2 << 21), pde,
Avi Kivitya8170e52012-10-23 12:30:10 +02001427 ~((hwaddr)(1 << 20) - 1));
Blue Swirld65aaf32010-12-11 18:56:24 +00001428 } else {
1429 pt_addr = pde & 0x3fffffffff000ULL;
1430 for (l3 = 0; l3 < 512; l3++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001431 cpu_physical_memory_read(pt_addr + l3 * 8, &pte, 8);
Blue Swirld65aaf32010-12-11 18:56:24 +00001432 pte = le64_to_cpu(pte);
1433 if (pte & PG_PRESENT_MASK) {
1434 print_pte(mon, (l1 << 30 ) + (l2 << 21)
1435 + (l3 << 12),
1436 pte & ~PG_PSE_MASK,
Avi Kivitya8170e52012-10-23 12:30:10 +02001437 ~(hwaddr)0xfff);
Blue Swirld65aaf32010-12-11 18:56:24 +00001438 }
1439 }
1440 }
1441 }
1442 }
1443 }
1444 }
1445}
1446
1447#ifdef TARGET_X86_64
Andreas Färber9349b4f2012-03-14 01:38:32 +01001448static void tlb_info_64(Monitor *mon, CPUArchState *env)
Blue Swirld65aaf32010-12-11 18:56:24 +00001449{
1450 uint64_t l1, l2, l3, l4;
1451 uint64_t pml4e, pdpe, pde, pte;
1452 uint64_t pml4_addr, pdp_addr, pd_addr, pt_addr;
1453
1454 pml4_addr = env->cr[3] & 0x3fffffffff000ULL;
1455 for (l1 = 0; l1 < 512; l1++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001456 cpu_physical_memory_read(pml4_addr + l1 * 8, &pml4e, 8);
Blue Swirld65aaf32010-12-11 18:56:24 +00001457 pml4e = le64_to_cpu(pml4e);
1458 if (pml4e & PG_PRESENT_MASK) {
1459 pdp_addr = pml4e & 0x3fffffffff000ULL;
1460 for (l2 = 0; l2 < 512; l2++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001461 cpu_physical_memory_read(pdp_addr + l2 * 8, &pdpe, 8);
Blue Swirld65aaf32010-12-11 18:56:24 +00001462 pdpe = le64_to_cpu(pdpe);
1463 if (pdpe & PG_PRESENT_MASK) {
1464 if (pdpe & PG_PSE_MASK) {
1465 /* 1G pages, CR4.PSE is ignored */
1466 print_pte(mon, (l1 << 39) + (l2 << 30), pdpe,
1467 0x3ffffc0000000ULL);
1468 } else {
1469 pd_addr = pdpe & 0x3fffffffff000ULL;
1470 for (l3 = 0; l3 < 512; l3++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001471 cpu_physical_memory_read(pd_addr + l3 * 8, &pde, 8);
Blue Swirld65aaf32010-12-11 18:56:24 +00001472 pde = le64_to_cpu(pde);
1473 if (pde & PG_PRESENT_MASK) {
1474 if (pde & PG_PSE_MASK) {
1475 /* 2M pages, CR4.PSE is ignored */
1476 print_pte(mon, (l1 << 39) + (l2 << 30) +
1477 (l3 << 21), pde,
1478 0x3ffffffe00000ULL);
1479 } else {
1480 pt_addr = pde & 0x3fffffffff000ULL;
1481 for (l4 = 0; l4 < 512; l4++) {
1482 cpu_physical_memory_read(pt_addr
1483 + l4 * 8,
Stefan Weilb8b79322011-03-26 21:11:05 +01001484 &pte, 8);
Blue Swirld65aaf32010-12-11 18:56:24 +00001485 pte = le64_to_cpu(pte);
1486 if (pte & PG_PRESENT_MASK) {
1487 print_pte(mon, (l1 << 39) +
1488 (l2 << 30) +
1489 (l3 << 21) + (l4 << 12),
1490 pte & ~PG_PSE_MASK,
1491 0x3fffffffff000ULL);
1492 }
1493 }
1494 }
1495 }
1496 }
1497 }
1498 }
1499 }
1500 }
1501 }
1502}
1503#endif
1504
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08001505static void tlb_info(Monitor *mon, const QDict *qdict)
Blue Swirld65aaf32010-12-11 18:56:24 +00001506{
Andreas Färber9349b4f2012-03-14 01:38:32 +01001507 CPUArchState *env;
Blue Swirld65aaf32010-12-11 18:56:24 +00001508
1509 env = mon_get_cpu();
1510
1511 if (!(env->cr[0] & CR0_PG_MASK)) {
1512 monitor_printf(mon, "PG disabled\n");
1513 return;
1514 }
1515 if (env->cr[4] & CR4_PAE_MASK) {
1516#ifdef TARGET_X86_64
1517 if (env->hflags & HF_LMA_MASK) {
1518 tlb_info_64(mon, env);
1519 } else
1520#endif
1521 {
1522 tlb_info_pae32(mon, env);
1523 }
1524 } else {
1525 tlb_info_32(mon, env);
1526 }
1527}
1528
Avi Kivitya8170e52012-10-23 12:30:10 +02001529static void mem_print(Monitor *mon, hwaddr *pstart,
Blue Swirl1b3cba62010-12-11 18:56:27 +00001530 int *plast_prot,
Avi Kivitya8170e52012-10-23 12:30:10 +02001531 hwaddr end, int prot)
bellardb86bda52004-09-18 19:32:46 +00001532{
bellard9746b152004-11-11 18:30:24 +00001533 int prot1;
1534 prot1 = *plast_prot;
1535 if (prot != prot1) {
bellardb86bda52004-09-18 19:32:46 +00001536 if (*pstart != -1) {
Blue Swirl1b3cba62010-12-11 18:56:27 +00001537 monitor_printf(mon, TARGET_FMT_plx "-" TARGET_FMT_plx " "
1538 TARGET_FMT_plx " %c%c%c\n",
aliguori376253e2009-03-05 23:01:23 +00001539 *pstart, end, end - *pstart,
1540 prot1 & PG_USER_MASK ? 'u' : '-',
1541 'r',
1542 prot1 & PG_RW_MASK ? 'w' : '-');
bellardb86bda52004-09-18 19:32:46 +00001543 }
1544 if (prot != 0)
1545 *pstart = end;
1546 else
1547 *pstart = -1;
1548 *plast_prot = prot;
1549 }
1550}
1551
Andreas Färber9349b4f2012-03-14 01:38:32 +01001552static void mem_info_32(Monitor *mon, CPUArchState *env)
bellardb86bda52004-09-18 19:32:46 +00001553{
Austin Clementsb49ca722011-08-14 23:19:21 -04001554 unsigned int l1, l2;
1555 int prot, last_prot;
Blue Swirl1b3cba62010-12-11 18:56:27 +00001556 uint32_t pgd, pde, pte;
Avi Kivitya8170e52012-10-23 12:30:10 +02001557 hwaddr start, end;
bellardb86bda52004-09-18 19:32:46 +00001558
bellardb86bda52004-09-18 19:32:46 +00001559 pgd = env->cr[3] & ~0xfff;
1560 last_prot = 0;
1561 start = -1;
1562 for(l1 = 0; l1 < 1024; l1++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001563 cpu_physical_memory_read(pgd + l1 * 4, &pde, 4);
bellardb86bda52004-09-18 19:32:46 +00001564 pde = le32_to_cpu(pde);
1565 end = l1 << 22;
1566 if (pde & PG_PRESENT_MASK) {
1567 if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
1568 prot = pde & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
aliguori376253e2009-03-05 23:01:23 +00001569 mem_print(mon, &start, &last_prot, end, prot);
bellardb86bda52004-09-18 19:32:46 +00001570 } else {
1571 for(l2 = 0; l2 < 1024; l2++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001572 cpu_physical_memory_read((pde & ~0xfff) + l2 * 4, &pte, 4);
bellardb86bda52004-09-18 19:32:46 +00001573 pte = le32_to_cpu(pte);
1574 end = (l1 << 22) + (l2 << 12);
1575 if (pte & PG_PRESENT_MASK) {
Austin Clementsc76c8412011-08-14 23:22:28 -04001576 prot = pte & pde &
1577 (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
bellardb86bda52004-09-18 19:32:46 +00001578 } else {
1579 prot = 0;
1580 }
aliguori376253e2009-03-05 23:01:23 +00001581 mem_print(mon, &start, &last_prot, end, prot);
bellardb86bda52004-09-18 19:32:46 +00001582 }
1583 }
1584 } else {
1585 prot = 0;
aliguori376253e2009-03-05 23:01:23 +00001586 mem_print(mon, &start, &last_prot, end, prot);
bellardb86bda52004-09-18 19:32:46 +00001587 }
1588 }
Austin Clements8a94b8ca2011-08-14 23:22:04 -04001589 /* Flush last range */
Avi Kivitya8170e52012-10-23 12:30:10 +02001590 mem_print(mon, &start, &last_prot, (hwaddr)1 << 32, 0);
bellardb86bda52004-09-18 19:32:46 +00001591}
Blue Swirl1b3cba62010-12-11 18:56:27 +00001592
Andreas Färber9349b4f2012-03-14 01:38:32 +01001593static void mem_info_pae32(Monitor *mon, CPUArchState *env)
Blue Swirl1b3cba62010-12-11 18:56:27 +00001594{
Austin Clementsb49ca722011-08-14 23:19:21 -04001595 unsigned int l1, l2, l3;
1596 int prot, last_prot;
Blue Swirl1b3cba62010-12-11 18:56:27 +00001597 uint64_t pdpe, pde, pte;
1598 uint64_t pdp_addr, pd_addr, pt_addr;
Avi Kivitya8170e52012-10-23 12:30:10 +02001599 hwaddr start, end;
Blue Swirl1b3cba62010-12-11 18:56:27 +00001600
1601 pdp_addr = env->cr[3] & ~0x1f;
1602 last_prot = 0;
1603 start = -1;
1604 for (l1 = 0; l1 < 4; l1++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001605 cpu_physical_memory_read(pdp_addr + l1 * 8, &pdpe, 8);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001606 pdpe = le64_to_cpu(pdpe);
1607 end = l1 << 30;
1608 if (pdpe & PG_PRESENT_MASK) {
1609 pd_addr = pdpe & 0x3fffffffff000ULL;
1610 for (l2 = 0; l2 < 512; l2++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001611 cpu_physical_memory_read(pd_addr + l2 * 8, &pde, 8);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001612 pde = le64_to_cpu(pde);
1613 end = (l1 << 30) + (l2 << 21);
1614 if (pde & PG_PRESENT_MASK) {
1615 if (pde & PG_PSE_MASK) {
1616 prot = pde & (PG_USER_MASK | PG_RW_MASK |
1617 PG_PRESENT_MASK);
1618 mem_print(mon, &start, &last_prot, end, prot);
1619 } else {
1620 pt_addr = pde & 0x3fffffffff000ULL;
1621 for (l3 = 0; l3 < 512; l3++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001622 cpu_physical_memory_read(pt_addr + l3 * 8, &pte, 8);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001623 pte = le64_to_cpu(pte);
1624 end = (l1 << 30) + (l2 << 21) + (l3 << 12);
1625 if (pte & PG_PRESENT_MASK) {
Austin Clementsc76c8412011-08-14 23:22:28 -04001626 prot = pte & pde & (PG_USER_MASK | PG_RW_MASK |
1627 PG_PRESENT_MASK);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001628 } else {
1629 prot = 0;
1630 }
1631 mem_print(mon, &start, &last_prot, end, prot);
1632 }
1633 }
1634 } else {
1635 prot = 0;
1636 mem_print(mon, &start, &last_prot, end, prot);
1637 }
1638 }
1639 } else {
1640 prot = 0;
1641 mem_print(mon, &start, &last_prot, end, prot);
1642 }
1643 }
Austin Clements8a94b8ca2011-08-14 23:22:04 -04001644 /* Flush last range */
Avi Kivitya8170e52012-10-23 12:30:10 +02001645 mem_print(mon, &start, &last_prot, (hwaddr)1 << 32, 0);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001646}
1647
1648
1649#ifdef TARGET_X86_64
Andreas Färber9349b4f2012-03-14 01:38:32 +01001650static void mem_info_64(Monitor *mon, CPUArchState *env)
Blue Swirl1b3cba62010-12-11 18:56:27 +00001651{
1652 int prot, last_prot;
1653 uint64_t l1, l2, l3, l4;
1654 uint64_t pml4e, pdpe, pde, pte;
1655 uint64_t pml4_addr, pdp_addr, pd_addr, pt_addr, start, end;
1656
1657 pml4_addr = env->cr[3] & 0x3fffffffff000ULL;
1658 last_prot = 0;
1659 start = -1;
1660 for (l1 = 0; l1 < 512; l1++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001661 cpu_physical_memory_read(pml4_addr + l1 * 8, &pml4e, 8);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001662 pml4e = le64_to_cpu(pml4e);
1663 end = l1 << 39;
1664 if (pml4e & PG_PRESENT_MASK) {
1665 pdp_addr = pml4e & 0x3fffffffff000ULL;
1666 for (l2 = 0; l2 < 512; l2++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001667 cpu_physical_memory_read(pdp_addr + l2 * 8, &pdpe, 8);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001668 pdpe = le64_to_cpu(pdpe);
1669 end = (l1 << 39) + (l2 << 30);
1670 if (pdpe & PG_PRESENT_MASK) {
1671 if (pdpe & PG_PSE_MASK) {
Blue Swirl2d5b5072011-01-15 08:31:00 +00001672 prot = pdpe & (PG_USER_MASK | PG_RW_MASK |
1673 PG_PRESENT_MASK);
Austin Clementsc76c8412011-08-14 23:22:28 -04001674 prot &= pml4e;
Blue Swirl1b3cba62010-12-11 18:56:27 +00001675 mem_print(mon, &start, &last_prot, end, prot);
1676 } else {
1677 pd_addr = pdpe & 0x3fffffffff000ULL;
1678 for (l3 = 0; l3 < 512; l3++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001679 cpu_physical_memory_read(pd_addr + l3 * 8, &pde, 8);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001680 pde = le64_to_cpu(pde);
1681 end = (l1 << 39) + (l2 << 30) + (l3 << 21);
1682 if (pde & PG_PRESENT_MASK) {
1683 if (pde & PG_PSE_MASK) {
1684 prot = pde & (PG_USER_MASK | PG_RW_MASK |
1685 PG_PRESENT_MASK);
Austin Clementsc76c8412011-08-14 23:22:28 -04001686 prot &= pml4e & pdpe;
Blue Swirl1b3cba62010-12-11 18:56:27 +00001687 mem_print(mon, &start, &last_prot, end, prot);
1688 } else {
1689 pt_addr = pde & 0x3fffffffff000ULL;
1690 for (l4 = 0; l4 < 512; l4++) {
1691 cpu_physical_memory_read(pt_addr
1692 + l4 * 8,
Stefan Weilb8b79322011-03-26 21:11:05 +01001693 &pte, 8);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001694 pte = le64_to_cpu(pte);
1695 end = (l1 << 39) + (l2 << 30) +
1696 (l3 << 21) + (l4 << 12);
1697 if (pte & PG_PRESENT_MASK) {
1698 prot = pte & (PG_USER_MASK | PG_RW_MASK |
1699 PG_PRESENT_MASK);
Austin Clementsc76c8412011-08-14 23:22:28 -04001700 prot &= pml4e & pdpe & pde;
Blue Swirl1b3cba62010-12-11 18:56:27 +00001701 } else {
1702 prot = 0;
1703 }
1704 mem_print(mon, &start, &last_prot, end, prot);
1705 }
1706 }
1707 } else {
1708 prot = 0;
1709 mem_print(mon, &start, &last_prot, end, prot);
1710 }
1711 }
1712 }
1713 } else {
1714 prot = 0;
1715 mem_print(mon, &start, &last_prot, end, prot);
1716 }
1717 }
1718 } else {
1719 prot = 0;
1720 mem_print(mon, &start, &last_prot, end, prot);
1721 }
1722 }
Austin Clements8a94b8ca2011-08-14 23:22:04 -04001723 /* Flush last range */
Avi Kivitya8170e52012-10-23 12:30:10 +02001724 mem_print(mon, &start, &last_prot, (hwaddr)1 << 48, 0);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001725}
1726#endif
1727
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08001728static void mem_info(Monitor *mon, const QDict *qdict)
Blue Swirl1b3cba62010-12-11 18:56:27 +00001729{
Andreas Färber9349b4f2012-03-14 01:38:32 +01001730 CPUArchState *env;
Blue Swirl1b3cba62010-12-11 18:56:27 +00001731
1732 env = mon_get_cpu();
1733
1734 if (!(env->cr[0] & CR0_PG_MASK)) {
1735 monitor_printf(mon, "PG disabled\n");
1736 return;
1737 }
1738 if (env->cr[4] & CR4_PAE_MASK) {
1739#ifdef TARGET_X86_64
1740 if (env->hflags & HF_LMA_MASK) {
1741 mem_info_64(mon, env);
1742 } else
1743#endif
1744 {
1745 mem_info_pae32(mon, env);
1746 }
1747 } else {
1748 mem_info_32(mon, env);
1749 }
1750}
bellardb86bda52004-09-18 19:32:46 +00001751#endif
1752
aurel327c664e22009-03-03 06:12:22 +00001753#if defined(TARGET_SH4)
1754
aliguori376253e2009-03-05 23:01:23 +00001755static void print_tlb(Monitor *mon, int idx, tlb_t *tlb)
aurel327c664e22009-03-03 06:12:22 +00001756{
aliguori376253e2009-03-05 23:01:23 +00001757 monitor_printf(mon, " tlb%i:\t"
1758 "asid=%hhu vpn=%x\tppn=%x\tsz=%hhu size=%u\t"
1759 "v=%hhu shared=%hhu cached=%hhu prot=%hhu "
1760 "dirty=%hhu writethrough=%hhu\n",
1761 idx,
1762 tlb->asid, tlb->vpn, tlb->ppn, tlb->sz, tlb->size,
1763 tlb->v, tlb->sh, tlb->c, tlb->pr,
1764 tlb->d, tlb->wt);
aurel327c664e22009-03-03 06:12:22 +00001765}
1766
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08001767static void tlb_info(Monitor *mon, const QDict *qdict)
aurel327c664e22009-03-03 06:12:22 +00001768{
Andreas Färber9349b4f2012-03-14 01:38:32 +01001769 CPUArchState *env = mon_get_cpu();
aurel327c664e22009-03-03 06:12:22 +00001770 int i;
1771
aliguori376253e2009-03-05 23:01:23 +00001772 monitor_printf (mon, "ITLB:\n");
aurel327c664e22009-03-03 06:12:22 +00001773 for (i = 0 ; i < ITLB_SIZE ; i++)
aliguori376253e2009-03-05 23:01:23 +00001774 print_tlb (mon, i, &env->itlb[i]);
1775 monitor_printf (mon, "UTLB:\n");
aurel327c664e22009-03-03 06:12:22 +00001776 for (i = 0 ; i < UTLB_SIZE ; i++)
aliguori376253e2009-03-05 23:01:23 +00001777 print_tlb (mon, i, &env->utlb[i]);
aurel327c664e22009-03-03 06:12:22 +00001778}
1779
1780#endif
1781
Max Filippov692f7372012-01-07 20:02:40 +04001782#if defined(TARGET_SPARC) || defined(TARGET_PPC) || defined(TARGET_XTENSA)
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08001783static void tlb_info(Monitor *mon, const QDict *qdict)
Blue Swirld41160a2010-12-19 13:42:56 +00001784{
Andreas Färber9349b4f2012-03-14 01:38:32 +01001785 CPUArchState *env1 = mon_get_cpu();
Blue Swirld41160a2010-12-19 13:42:56 +00001786
1787 dump_mmu((FILE*)mon, (fprintf_function)monitor_printf, env1);
1788}
1789#endif
1790
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08001791static void do_info_mtree(Monitor *mon, const QDict *qdict)
Blue Swirl314e2982011-09-11 20:22:05 +00001792{
1793 mtree_info((fprintf_function)monitor_printf, mon);
1794}
1795
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08001796static void do_info_numa(Monitor *mon, const QDict *qdict)
aliguori030ea372009-04-21 22:30:47 +00001797{
aliguorib28b6232009-04-22 20:20:29 +00001798 int i;
Andreas Färber9349b4f2012-03-14 01:38:32 +01001799 CPUArchState *env;
Andreas Färber1b1ed8d2012-12-17 04:22:03 +01001800 CPUState *cpu;
aliguori030ea372009-04-21 22:30:47 +00001801
1802 monitor_printf(mon, "%d nodes\n", nb_numa_nodes);
1803 for (i = 0; i < nb_numa_nodes; i++) {
1804 monitor_printf(mon, "node %d cpus:", i);
1805 for (env = first_cpu; env != NULL; env = env->next_cpu) {
Andreas Färber1b1ed8d2012-12-17 04:22:03 +01001806 cpu = ENV_GET_CPU(env);
1807 if (cpu->numa_node == i) {
Andreas Färber55e5c282012-12-17 06:18:02 +01001808 monitor_printf(mon, " %d", cpu->cpu_index);
aliguori030ea372009-04-21 22:30:47 +00001809 }
1810 }
1811 monitor_printf(mon, "\n");
1812 monitor_printf(mon, "node %d size: %" PRId64 " MB\n", i,
1813 node_mem[i] >> 20);
1814 }
1815}
1816
bellard5f1ce942006-02-08 22:40:15 +00001817#ifdef CONFIG_PROFILER
1818
Aurelien Jarnoe9a66252009-09-30 14:09:52 +02001819int64_t qemu_time;
1820int64_t dev_time;
1821
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08001822static void do_info_profile(Monitor *mon, const QDict *qdict)
bellard5f1ce942006-02-08 22:40:15 +00001823{
1824 int64_t total;
1825 total = qemu_time;
1826 if (total == 0)
1827 total = 1;
aliguori376253e2009-03-05 23:01:23 +00001828 monitor_printf(mon, "async time %" PRId64 " (%0.3f)\n",
Juan Quintela6ee093c2009-09-10 03:04:26 +02001829 dev_time, dev_time / (double)get_ticks_per_sec());
aliguori376253e2009-03-05 23:01:23 +00001830 monitor_printf(mon, "qemu time %" PRId64 " (%0.3f)\n",
Juan Quintela6ee093c2009-09-10 03:04:26 +02001831 qemu_time, qemu_time / (double)get_ticks_per_sec());
bellard5f1ce942006-02-08 22:40:15 +00001832 qemu_time = 0;
bellard5f1ce942006-02-08 22:40:15 +00001833 dev_time = 0;
bellard5f1ce942006-02-08 22:40:15 +00001834}
1835#else
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08001836static void do_info_profile(Monitor *mon, const QDict *qdict)
bellard5f1ce942006-02-08 22:40:15 +00001837{
aliguori376253e2009-03-05 23:01:23 +00001838 monitor_printf(mon, "Internal profiler not compiled\n");
bellard5f1ce942006-02-08 22:40:15 +00001839}
1840#endif
1841
bellardec36b692006-07-16 18:57:03 +00001842/* Capture support */
Blue Swirl72cf2d42009-09-12 07:36:22 +00001843static QLIST_HEAD (capture_list_head, CaptureState) capture_head;
bellardec36b692006-07-16 18:57:03 +00001844
Wenchao Xia84f2d0e2013-01-14 14:06:25 +08001845static void do_info_capture(Monitor *mon, const QDict *qdict)
bellardec36b692006-07-16 18:57:03 +00001846{
1847 int i;
1848 CaptureState *s;
1849
1850 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
aliguori376253e2009-03-05 23:01:23 +00001851 monitor_printf(mon, "[%d]: ", i);
bellardec36b692006-07-16 18:57:03 +00001852 s->ops.info (s->opaque);
1853 }
1854}
1855
Blue Swirl23130862009-06-06 08:22:04 +00001856#ifdef HAS_AUDIO
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001857static void do_stop_capture(Monitor *mon, const QDict *qdict)
bellardec36b692006-07-16 18:57:03 +00001858{
1859 int i;
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001860 int n = qdict_get_int(qdict, "n");
bellardec36b692006-07-16 18:57:03 +00001861 CaptureState *s;
1862
1863 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
1864 if (i == n) {
1865 s->ops.destroy (s->opaque);
Blue Swirl72cf2d42009-09-12 07:36:22 +00001866 QLIST_REMOVE (s, entries);
Anthony Liguori7267c092011-08-20 22:09:37 -05001867 g_free (s);
bellardec36b692006-07-16 18:57:03 +00001868 return;
1869 }
1870 }
1871}
1872
Luiz Capitulinoc1925482009-08-28 15:27:19 -03001873static void do_wav_capture(Monitor *mon, const QDict *qdict)
bellardec36b692006-07-16 18:57:03 +00001874{
Luiz Capitulinoc1925482009-08-28 15:27:19 -03001875 const char *path = qdict_get_str(qdict, "path");
1876 int has_freq = qdict_haskey(qdict, "freq");
1877 int freq = qdict_get_try_int(qdict, "freq", -1);
1878 int has_bits = qdict_haskey(qdict, "bits");
1879 int bits = qdict_get_try_int(qdict, "bits", -1);
1880 int has_channels = qdict_haskey(qdict, "nchannels");
1881 int nchannels = qdict_get_try_int(qdict, "nchannels", -1);
bellardec36b692006-07-16 18:57:03 +00001882 CaptureState *s;
1883
Anthony Liguori7267c092011-08-20 22:09:37 -05001884 s = g_malloc0 (sizeof (*s));
bellardec36b692006-07-16 18:57:03 +00001885
1886 freq = has_freq ? freq : 44100;
1887 bits = has_bits ? bits : 16;
1888 nchannels = has_channels ? nchannels : 2;
1889
1890 if (wav_start_capture (s, path, freq, bits, nchannels)) {
Isaku Yamahatad00b2612011-01-21 19:53:55 +09001891 monitor_printf(mon, "Failed to add wave capture\n");
Anthony Liguori7267c092011-08-20 22:09:37 -05001892 g_free (s);
Isaku Yamahatad00b2612011-01-21 19:53:55 +09001893 return;
bellardec36b692006-07-16 18:57:03 +00001894 }
Blue Swirl72cf2d42009-09-12 07:36:22 +00001895 QLIST_INSERT_HEAD (&capture_head, s, entries);
bellardec36b692006-07-16 18:57:03 +00001896}
1897#endif
1898
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001899static qemu_acl *find_acl(Monitor *mon, const char *name)
aliguori76655d62009-03-06 20:27:37 +00001900{
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001901 qemu_acl *acl = qemu_acl_find(name);
aliguori76655d62009-03-06 20:27:37 +00001902
aliguori76655d62009-03-06 20:27:37 +00001903 if (!acl) {
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001904 monitor_printf(mon, "acl: unknown list '%s'\n", name);
aliguori76655d62009-03-06 20:27:37 +00001905 }
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001906 return acl;
1907}
aliguori76655d62009-03-06 20:27:37 +00001908
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001909static void do_acl_show(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001910{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001911 const char *aclname = qdict_get_str(qdict, "aclname");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001912 qemu_acl *acl = find_acl(mon, aclname);
1913 qemu_acl_entry *entry;
1914 int i = 0;
1915
1916 if (acl) {
aliguori28a76be2009-03-06 20:27:40 +00001917 monitor_printf(mon, "policy: %s\n",
aliguori76655d62009-03-06 20:27:37 +00001918 acl->defaultDeny ? "deny" : "allow");
Blue Swirl72cf2d42009-09-12 07:36:22 +00001919 QTAILQ_FOREACH(entry, &acl->entries, next) {
aliguori28a76be2009-03-06 20:27:40 +00001920 i++;
1921 monitor_printf(mon, "%d: %s %s\n", i,
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001922 entry->deny ? "deny" : "allow", entry->match);
aliguori28a76be2009-03-06 20:27:40 +00001923 }
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001924 }
1925}
1926
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001927static void do_acl_reset(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001928{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001929 const char *aclname = qdict_get_str(qdict, "aclname");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001930 qemu_acl *acl = find_acl(mon, aclname);
1931
1932 if (acl) {
aliguori28a76be2009-03-06 20:27:40 +00001933 qemu_acl_reset(acl);
1934 monitor_printf(mon, "acl: removed all rules\n");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001935 }
1936}
aliguori76655d62009-03-06 20:27:37 +00001937
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03001938static void do_acl_policy(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001939{
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03001940 const char *aclname = qdict_get_str(qdict, "aclname");
1941 const char *policy = qdict_get_str(qdict, "policy");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001942 qemu_acl *acl = find_acl(mon, aclname);
1943
1944 if (acl) {
1945 if (strcmp(policy, "allow") == 0) {
aliguori28a76be2009-03-06 20:27:40 +00001946 acl->defaultDeny = 0;
1947 monitor_printf(mon, "acl: policy set to 'allow'\n");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001948 } else if (strcmp(policy, "deny") == 0) {
aliguori28a76be2009-03-06 20:27:40 +00001949 acl->defaultDeny = 1;
1950 monitor_printf(mon, "acl: policy set to 'deny'\n");
1951 } else {
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001952 monitor_printf(mon, "acl: unknown policy '%s', "
1953 "expected 'deny' or 'allow'\n", policy);
aliguori28a76be2009-03-06 20:27:40 +00001954 }
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001955 }
1956}
aliguori76655d62009-03-06 20:27:37 +00001957
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001958static void do_acl_add(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001959{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001960 const char *aclname = qdict_get_str(qdict, "aclname");
1961 const char *match = qdict_get_str(qdict, "match");
1962 const char *policy = qdict_get_str(qdict, "policy");
1963 int has_index = qdict_haskey(qdict, "index");
1964 int index = qdict_get_try_int(qdict, "index", -1);
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001965 qemu_acl *acl = find_acl(mon, aclname);
1966 int deny, ret;
1967
1968 if (acl) {
1969 if (strcmp(policy, "allow") == 0) {
1970 deny = 0;
1971 } else if (strcmp(policy, "deny") == 0) {
1972 deny = 1;
1973 } else {
1974 monitor_printf(mon, "acl: unknown policy '%s', "
1975 "expected 'deny' or 'allow'\n", policy);
aliguori28a76be2009-03-06 20:27:40 +00001976 return;
1977 }
aliguori28a76be2009-03-06 20:27:40 +00001978 if (has_index)
1979 ret = qemu_acl_insert(acl, deny, match, index);
1980 else
1981 ret = qemu_acl_append(acl, deny, match);
1982 if (ret < 0)
1983 monitor_printf(mon, "acl: unable to add acl entry\n");
1984 else
1985 monitor_printf(mon, "acl: added rule at position %d\n", ret);
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001986 }
1987}
aliguori76655d62009-03-06 20:27:37 +00001988
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03001989static void do_acl_remove(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001990{
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03001991 const char *aclname = qdict_get_str(qdict, "aclname");
1992 const char *match = qdict_get_str(qdict, "match");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001993 qemu_acl *acl = find_acl(mon, aclname);
1994 int ret;
aliguori76655d62009-03-06 20:27:37 +00001995
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001996 if (acl) {
aliguori28a76be2009-03-06 20:27:40 +00001997 ret = qemu_acl_remove(acl, match);
1998 if (ret < 0)
1999 monitor_printf(mon, "acl: no matching acl entry\n");
2000 else
2001 monitor_printf(mon, "acl: removed rule at position %d\n", ret);
aliguori76655d62009-03-06 20:27:37 +00002002 }
2003}
2004
Huang Ying79c4f6b2009-06-23 10:05:14 +08002005#if defined(TARGET_I386)
Luiz Capitulino37b7ad42009-08-28 15:27:21 -03002006static void do_inject_mce(Monitor *mon, const QDict *qdict)
Huang Ying79c4f6b2009-06-23 10:05:14 +08002007{
Andreas Färber8c5cf3b2012-05-03 15:22:54 +02002008 X86CPU *cpu;
2009 CPUX86State *cenv;
Andreas Färber55e5c282012-12-17 06:18:02 +01002010 CPUState *cs;
Luiz Capitulino37b7ad42009-08-28 15:27:21 -03002011 int cpu_index = qdict_get_int(qdict, "cpu_index");
2012 int bank = qdict_get_int(qdict, "bank");
2013 uint64_t status = qdict_get_int(qdict, "status");
2014 uint64_t mcg_status = qdict_get_int(qdict, "mcg_status");
2015 uint64_t addr = qdict_get_int(qdict, "addr");
2016 uint64_t misc = qdict_get_int(qdict, "misc");
Jan Kiszka747461c2011-03-02 08:56:10 +01002017 int flags = MCE_INJECT_UNCOND_AO;
Huang Ying79c4f6b2009-06-23 10:05:14 +08002018
Jan Kiszka747461c2011-03-02 08:56:10 +01002019 if (qdict_get_try_bool(qdict, "broadcast", 0)) {
2020 flags |= MCE_INJECT_BROADCAST;
2021 }
Jin Dongming31ce5e02010-12-10 17:21:02 +09002022 for (cenv = first_cpu; cenv != NULL; cenv = cenv->next_cpu) {
Andreas Färber8c5cf3b2012-05-03 15:22:54 +02002023 cpu = x86_env_get_cpu(cenv);
Andreas Färber55e5c282012-12-17 06:18:02 +01002024 cs = CPU(cpu);
2025 if (cs->cpu_index == cpu_index) {
Andreas Färber8c5cf3b2012-05-03 15:22:54 +02002026 cpu_x86_inject_mce(mon, cpu, bank, status, mcg_status, addr, misc,
Jan Kiszka747461c2011-03-02 08:56:10 +01002027 flags);
Huang Ying79c4f6b2009-06-23 10:05:14 +08002028 break;
2029 }
Jin Dongming31ce5e02010-12-10 17:21:02 +09002030 }
Huang Ying79c4f6b2009-06-23 10:05:14 +08002031}
2032#endif
2033
Corey Bryant208c9d12012-06-22 14:36:09 -04002034void qmp_getfd(const char *fdname, Error **errp)
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002035{
Anthony Liguoric227f092009-10-01 16:12:16 -05002036 mon_fd_t *monfd;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002037 int fd;
2038
Corey Bryant208c9d12012-06-22 14:36:09 -04002039 fd = qemu_chr_fe_get_msgfd(cur_mon->chr);
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002040 if (fd == -1) {
Corey Bryant208c9d12012-06-22 14:36:09 -04002041 error_set(errp, QERR_FD_NOT_SUPPLIED);
2042 return;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002043 }
2044
2045 if (qemu_isdigit(fdname[0])) {
Corey Bryant208c9d12012-06-22 14:36:09 -04002046 error_set(errp, QERR_INVALID_PARAMETER_VALUE, "fdname",
2047 "a name not starting with a digit");
2048 return;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002049 }
2050
Corey Bryant208c9d12012-06-22 14:36:09 -04002051 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002052 if (strcmp(monfd->name, fdname) != 0) {
2053 continue;
2054 }
2055
2056 close(monfd->fd);
2057 monfd->fd = fd;
Corey Bryant208c9d12012-06-22 14:36:09 -04002058 return;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002059 }
2060
Anthony Liguori7267c092011-08-20 22:09:37 -05002061 monfd = g_malloc0(sizeof(mon_fd_t));
2062 monfd->name = g_strdup(fdname);
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002063 monfd->fd = fd;
2064
Corey Bryant208c9d12012-06-22 14:36:09 -04002065 QLIST_INSERT_HEAD(&cur_mon->fds, monfd, next);
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002066}
2067
Corey Bryant208c9d12012-06-22 14:36:09 -04002068void qmp_closefd(const char *fdname, Error **errp)
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002069{
Anthony Liguoric227f092009-10-01 16:12:16 -05002070 mon_fd_t *monfd;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002071
Corey Bryant208c9d12012-06-22 14:36:09 -04002072 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002073 if (strcmp(monfd->name, fdname) != 0) {
2074 continue;
2075 }
2076
Blue Swirl72cf2d42009-09-12 07:36:22 +00002077 QLIST_REMOVE(monfd, next);
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002078 close(monfd->fd);
Anthony Liguori7267c092011-08-20 22:09:37 -05002079 g_free(monfd->name);
2080 g_free(monfd);
Corey Bryant208c9d12012-06-22 14:36:09 -04002081 return;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002082 }
2083
Corey Bryant208c9d12012-06-22 14:36:09 -04002084 error_set(errp, QERR_FD_NOT_FOUND, fdname);
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002085}
2086
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002087static void do_loadvm(Monitor *mon, const QDict *qdict)
Juan Quintelac8d41b22009-08-20 19:42:21 +02002088{
Luiz Capitulino13548692011-07-29 15:36:43 -03002089 int saved_vm_running = runstate_is_running();
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002090 const char *name = qdict_get_str(qdict, "name");
Juan Quintelac8d41b22009-08-20 19:42:21 +02002091
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03002092 vm_stop(RUN_STATE_RESTORE_VM);
Juan Quintelac8d41b22009-08-20 19:42:21 +02002093
Miguel Di Ciurcio Filhof0aa7a82010-07-19 15:25:01 -03002094 if (load_vmstate(name) == 0 && saved_vm_running) {
Juan Quintelac8d41b22009-08-20 19:42:21 +02002095 vm_start();
Miguel Di Ciurcio Filhof0aa7a82010-07-19 15:25:01 -03002096 }
Juan Quintelac8d41b22009-08-20 19:42:21 +02002097}
2098
Paolo Bonzinia9940fc2012-09-20 16:50:32 +02002099int monitor_get_fd(Monitor *mon, const char *fdname, Error **errp)
Mark McLoughlin7768e042009-07-22 09:11:41 +01002100{
Anthony Liguoric227f092009-10-01 16:12:16 -05002101 mon_fd_t *monfd;
Mark McLoughlin7768e042009-07-22 09:11:41 +01002102
Blue Swirl72cf2d42009-09-12 07:36:22 +00002103 QLIST_FOREACH(monfd, &mon->fds, next) {
Mark McLoughlin7768e042009-07-22 09:11:41 +01002104 int fd;
2105
2106 if (strcmp(monfd->name, fdname) != 0) {
2107 continue;
2108 }
2109
2110 fd = monfd->fd;
2111
2112 /* caller takes ownership of fd */
Blue Swirl72cf2d42009-09-12 07:36:22 +00002113 QLIST_REMOVE(monfd, next);
Anthony Liguori7267c092011-08-20 22:09:37 -05002114 g_free(monfd->name);
2115 g_free(monfd);
Mark McLoughlin7768e042009-07-22 09:11:41 +01002116
2117 return fd;
2118 }
2119
Paolo Bonzinia9940fc2012-09-20 16:50:32 +02002120 error_setg(errp, "File descriptor named '%s' has not been found", fdname);
Mark McLoughlin7768e042009-07-22 09:11:41 +01002121 return -1;
2122}
2123
Corey Bryantba1c0482012-08-14 16:43:43 -04002124static void monitor_fdset_cleanup(MonFdset *mon_fdset)
2125{
2126 MonFdsetFd *mon_fdset_fd;
2127 MonFdsetFd *mon_fdset_fd_next;
2128
2129 QLIST_FOREACH_SAFE(mon_fdset_fd, &mon_fdset->fds, next, mon_fdset_fd_next) {
Corey Bryantebe52b52012-10-18 15:19:33 -04002130 if ((mon_fdset_fd->removed ||
2131 (QLIST_EMPTY(&mon_fdset->dup_fds) && mon_refcount == 0)) &&
2132 runstate_is_running()) {
Corey Bryantba1c0482012-08-14 16:43:43 -04002133 close(mon_fdset_fd->fd);
2134 g_free(mon_fdset_fd->opaque);
2135 QLIST_REMOVE(mon_fdset_fd, next);
2136 g_free(mon_fdset_fd);
2137 }
2138 }
2139
Corey Bryantadb696f2012-08-14 16:43:47 -04002140 if (QLIST_EMPTY(&mon_fdset->fds) && QLIST_EMPTY(&mon_fdset->dup_fds)) {
Corey Bryantba1c0482012-08-14 16:43:43 -04002141 QLIST_REMOVE(mon_fdset, next);
2142 g_free(mon_fdset);
2143 }
2144}
2145
Corey Bryantefb87c12012-08-14 16:43:48 -04002146static void monitor_fdsets_cleanup(void)
2147{
2148 MonFdset *mon_fdset;
2149 MonFdset *mon_fdset_next;
2150
2151 QLIST_FOREACH_SAFE(mon_fdset, &mon_fdsets, next, mon_fdset_next) {
2152 monitor_fdset_cleanup(mon_fdset);
2153 }
2154}
2155
Corey Bryantba1c0482012-08-14 16:43:43 -04002156AddfdInfo *qmp_add_fd(bool has_fdset_id, int64_t fdset_id, bool has_opaque,
2157 const char *opaque, Error **errp)
2158{
2159 int fd;
2160 Monitor *mon = cur_mon;
Corey Bryantba1c0482012-08-14 16:43:43 -04002161 AddfdInfo *fdinfo;
2162
2163 fd = qemu_chr_fe_get_msgfd(mon->chr);
2164 if (fd == -1) {
2165 error_set(errp, QERR_FD_NOT_SUPPLIED);
2166 goto error;
2167 }
2168
Corey Bryante446f702012-10-18 15:19:32 -04002169 fdinfo = monitor_fdset_add_fd(fd, has_fdset_id, fdset_id,
2170 has_opaque, opaque, errp);
2171 if (fdinfo) {
2172 return fdinfo;
Corey Bryant9ac54af2012-10-18 15:19:31 -04002173 }
2174
Corey Bryantba1c0482012-08-14 16:43:43 -04002175error:
2176 if (fd != -1) {
2177 close(fd);
2178 }
2179 return NULL;
2180}
2181
2182void qmp_remove_fd(int64_t fdset_id, bool has_fd, int64_t fd, Error **errp)
2183{
2184 MonFdset *mon_fdset;
2185 MonFdsetFd *mon_fdset_fd;
2186 char fd_str[60];
2187
2188 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2189 if (mon_fdset->id != fdset_id) {
2190 continue;
2191 }
2192 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2193 if (has_fd) {
2194 if (mon_fdset_fd->fd != fd) {
2195 continue;
2196 }
2197 mon_fdset_fd->removed = true;
2198 break;
2199 } else {
2200 mon_fdset_fd->removed = true;
2201 }
2202 }
2203 if (has_fd && !mon_fdset_fd) {
2204 goto error;
2205 }
2206 monitor_fdset_cleanup(mon_fdset);
2207 return;
2208 }
2209
2210error:
2211 if (has_fd) {
2212 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64 ", fd:%" PRId64,
2213 fdset_id, fd);
2214 } else {
2215 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64, fdset_id);
2216 }
2217 error_set(errp, QERR_FD_NOT_FOUND, fd_str);
2218}
2219
2220FdsetInfoList *qmp_query_fdsets(Error **errp)
2221{
2222 MonFdset *mon_fdset;
2223 MonFdsetFd *mon_fdset_fd;
2224 FdsetInfoList *fdset_list = NULL;
2225
2226 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2227 FdsetInfoList *fdset_info = g_malloc0(sizeof(*fdset_info));
2228 FdsetFdInfoList *fdsetfd_list = NULL;
2229
2230 fdset_info->value = g_malloc0(sizeof(*fdset_info->value));
2231 fdset_info->value->fdset_id = mon_fdset->id;
2232
2233 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2234 FdsetFdInfoList *fdsetfd_info;
2235
2236 fdsetfd_info = g_malloc0(sizeof(*fdsetfd_info));
2237 fdsetfd_info->value = g_malloc0(sizeof(*fdsetfd_info->value));
2238 fdsetfd_info->value->fd = mon_fdset_fd->fd;
2239 if (mon_fdset_fd->opaque) {
2240 fdsetfd_info->value->has_opaque = true;
2241 fdsetfd_info->value->opaque = g_strdup(mon_fdset_fd->opaque);
2242 } else {
2243 fdsetfd_info->value->has_opaque = false;
2244 }
2245
2246 fdsetfd_info->next = fdsetfd_list;
2247 fdsetfd_list = fdsetfd_info;
2248 }
2249
2250 fdset_info->value->fds = fdsetfd_list;
2251
2252 fdset_info->next = fdset_list;
2253 fdset_list = fdset_info;
2254 }
2255
2256 return fdset_list;
2257}
2258
Corey Bryante446f702012-10-18 15:19:32 -04002259AddfdInfo *monitor_fdset_add_fd(int fd, bool has_fdset_id, int64_t fdset_id,
2260 bool has_opaque, const char *opaque,
2261 Error **errp)
2262{
2263 MonFdset *mon_fdset = NULL;
2264 MonFdsetFd *mon_fdset_fd;
2265 AddfdInfo *fdinfo;
2266
2267 if (has_fdset_id) {
2268 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2269 /* Break if match found or match impossible due to ordering by ID */
2270 if (fdset_id <= mon_fdset->id) {
2271 if (fdset_id < mon_fdset->id) {
2272 mon_fdset = NULL;
2273 }
2274 break;
2275 }
2276 }
2277 }
2278
2279 if (mon_fdset == NULL) {
2280 int64_t fdset_id_prev = -1;
2281 MonFdset *mon_fdset_cur = QLIST_FIRST(&mon_fdsets);
2282
2283 if (has_fdset_id) {
2284 if (fdset_id < 0) {
2285 error_set(errp, QERR_INVALID_PARAMETER_VALUE, "fdset-id",
2286 "a non-negative value");
2287 return NULL;
2288 }
2289 /* Use specified fdset ID */
2290 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2291 mon_fdset_cur = mon_fdset;
2292 if (fdset_id < mon_fdset_cur->id) {
2293 break;
2294 }
2295 }
2296 } else {
2297 /* Use first available fdset ID */
2298 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2299 mon_fdset_cur = mon_fdset;
2300 if (fdset_id_prev == mon_fdset_cur->id - 1) {
2301 fdset_id_prev = mon_fdset_cur->id;
2302 continue;
2303 }
2304 break;
2305 }
2306 }
2307
2308 mon_fdset = g_malloc0(sizeof(*mon_fdset));
2309 if (has_fdset_id) {
2310 mon_fdset->id = fdset_id;
2311 } else {
2312 mon_fdset->id = fdset_id_prev + 1;
2313 }
2314
2315 /* The fdset list is ordered by fdset ID */
2316 if (!mon_fdset_cur) {
2317 QLIST_INSERT_HEAD(&mon_fdsets, mon_fdset, next);
2318 } else if (mon_fdset->id < mon_fdset_cur->id) {
2319 QLIST_INSERT_BEFORE(mon_fdset_cur, mon_fdset, next);
2320 } else {
2321 QLIST_INSERT_AFTER(mon_fdset_cur, mon_fdset, next);
2322 }
2323 }
2324
2325 mon_fdset_fd = g_malloc0(sizeof(*mon_fdset_fd));
2326 mon_fdset_fd->fd = fd;
2327 mon_fdset_fd->removed = false;
2328 if (has_opaque) {
2329 mon_fdset_fd->opaque = g_strdup(opaque);
2330 }
2331 QLIST_INSERT_HEAD(&mon_fdset->fds, mon_fdset_fd, next);
2332
2333 fdinfo = g_malloc0(sizeof(*fdinfo));
2334 fdinfo->fdset_id = mon_fdset->id;
2335 fdinfo->fd = mon_fdset_fd->fd;
2336
2337 return fdinfo;
2338}
2339
Corey Bryantadb696f2012-08-14 16:43:47 -04002340int monitor_fdset_get_fd(int64_t fdset_id, int flags)
2341{
Blue Swirlb2dc64c2012-08-18 20:14:54 +00002342#ifndef _WIN32
Corey Bryantadb696f2012-08-14 16:43:47 -04002343 MonFdset *mon_fdset;
2344 MonFdsetFd *mon_fdset_fd;
2345 int mon_fd_flags;
2346
Corey Bryantadb696f2012-08-14 16:43:47 -04002347 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2348 if (mon_fdset->id != fdset_id) {
2349 continue;
2350 }
2351 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2352 mon_fd_flags = fcntl(mon_fdset_fd->fd, F_GETFL);
2353 if (mon_fd_flags == -1) {
2354 return -1;
2355 }
2356
2357 if ((flags & O_ACCMODE) == (mon_fd_flags & O_ACCMODE)) {
2358 return mon_fdset_fd->fd;
2359 }
2360 }
2361 errno = EACCES;
2362 return -1;
2363 }
2364#endif
2365
2366 errno = ENOENT;
2367 return -1;
2368}
2369
2370int monitor_fdset_dup_fd_add(int64_t fdset_id, int dup_fd)
2371{
2372 MonFdset *mon_fdset;
2373 MonFdsetFd *mon_fdset_fd_dup;
2374
2375 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2376 if (mon_fdset->id != fdset_id) {
2377 continue;
2378 }
2379 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2380 if (mon_fdset_fd_dup->fd == dup_fd) {
2381 return -1;
2382 }
2383 }
2384 mon_fdset_fd_dup = g_malloc0(sizeof(*mon_fdset_fd_dup));
2385 mon_fdset_fd_dup->fd = dup_fd;
2386 QLIST_INSERT_HEAD(&mon_fdset->dup_fds, mon_fdset_fd_dup, next);
2387 return 0;
2388 }
2389 return -1;
2390}
2391
2392static int monitor_fdset_dup_fd_find_remove(int dup_fd, bool remove)
2393{
2394 MonFdset *mon_fdset;
2395 MonFdsetFd *mon_fdset_fd_dup;
2396
2397 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2398 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2399 if (mon_fdset_fd_dup->fd == dup_fd) {
2400 if (remove) {
2401 QLIST_REMOVE(mon_fdset_fd_dup, next);
2402 if (QLIST_EMPTY(&mon_fdset->dup_fds)) {
2403 monitor_fdset_cleanup(mon_fdset);
2404 }
2405 }
2406 return mon_fdset->id;
2407 }
2408 }
2409 }
2410 return -1;
2411}
2412
2413int monitor_fdset_dup_fd_find(int dup_fd)
2414{
2415 return monitor_fdset_dup_fd_find_remove(dup_fd, false);
2416}
2417
2418int monitor_fdset_dup_fd_remove(int dup_fd)
2419{
2420 return monitor_fdset_dup_fd_find_remove(dup_fd, true);
2421}
2422
Nicholas Bellingera96ed022012-08-21 20:52:07 +00002423int monitor_handle_fd_param(Monitor *mon, const char *fdname)
2424{
2425 int fd;
Paolo Bonzinia9940fc2012-09-20 16:50:32 +02002426 Error *local_err = NULL;
Nicholas Bellingera96ed022012-08-21 20:52:07 +00002427
2428 if (!qemu_isdigit(fdname[0]) && mon) {
2429
Paolo Bonzinia9940fc2012-09-20 16:50:32 +02002430 fd = monitor_get_fd(mon, fdname, &local_err);
Nicholas Bellingera96ed022012-08-21 20:52:07 +00002431 if (fd == -1) {
Paolo Bonzinia9940fc2012-09-20 16:50:32 +02002432 qerror_report_err(local_err);
2433 error_free(local_err);
Nicholas Bellingera96ed022012-08-21 20:52:07 +00002434 return -1;
2435 }
2436 } else {
2437 fd = qemu_parse_fd(fdname);
2438 }
2439
2440 return fd;
2441}
2442
Luiz Capitulinoacd0a092010-09-30 16:00:22 -03002443/* Please update hmp-commands.hx when adding or changing commands */
Wayne Xia816f8922011-10-12 11:32:41 +08002444static mon_cmd_t info_cmds[] = {
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002445 {
2446 .name = "version",
2447 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002448 .params = "",
2449 .help = "show the version of QEMU",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002450 .mhandler.cmd = hmp_info_version,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002451 },
2452 {
2453 .name = "network",
2454 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002455 .params = "",
2456 .help = "show the network state",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002457 .mhandler.cmd = do_info_network,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002458 },
2459 {
2460 .name = "chardev",
2461 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002462 .params = "",
2463 .help = "show the character devices",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002464 .mhandler.cmd = hmp_info_chardev,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002465 },
2466 {
2467 .name = "block",
2468 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002469 .params = "",
2470 .help = "show the block devices",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002471 .mhandler.cmd = hmp_info_block,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002472 },
2473 {
2474 .name = "blockstats",
2475 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002476 .params = "",
2477 .help = "show block device statistics",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002478 .mhandler.cmd = hmp_info_blockstats,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002479 },
2480 {
Stefan Hajnoczifb5458c2012-01-18 14:40:49 +00002481 .name = "block-jobs",
2482 .args_type = "",
2483 .params = "",
2484 .help = "show progress of ongoing block device operations",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002485 .mhandler.cmd = hmp_info_block_jobs,
Stefan Hajnoczifb5458c2012-01-18 14:40:49 +00002486 },
2487 {
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002488 .name = "registers",
2489 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002490 .params = "",
2491 .help = "show the cpu registers",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002492 .mhandler.cmd = do_info_registers,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002493 },
2494 {
2495 .name = "cpus",
2496 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002497 .params = "",
2498 .help = "show infos for each CPU",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002499 .mhandler.cmd = hmp_info_cpus,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002500 },
2501 {
2502 .name = "history",
2503 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002504 .params = "",
2505 .help = "show the command line history",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002506 .mhandler.cmd = do_info_history,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002507 },
Jan Kiszka661f1922011-10-16 11:53:13 +02002508#if defined(TARGET_I386) || defined(TARGET_PPC) || defined(TARGET_MIPS) || \
2509 defined(TARGET_LM32) || (defined(TARGET_SPARC) && !defined(TARGET_SPARC64))
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002510 {
2511 .name = "irq",
2512 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002513 .params = "",
2514 .help = "show the interrupts statistics (if available)",
Jan Kiszka661f1922011-10-16 11:53:13 +02002515#ifdef TARGET_SPARC
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002516 .mhandler.cmd = sun4m_irq_info,
Jan Kiszka661f1922011-10-16 11:53:13 +02002517#elif defined(TARGET_LM32)
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002518 .mhandler.cmd = lm32_irq_info,
Jan Kiszka661f1922011-10-16 11:53:13 +02002519#else
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002520 .mhandler.cmd = irq_info,
Jan Kiszka661f1922011-10-16 11:53:13 +02002521#endif
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002522 },
2523 {
2524 .name = "pic",
2525 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002526 .params = "",
2527 .help = "show i8259 (PIC) state",
Jan Kiszka661f1922011-10-16 11:53:13 +02002528#ifdef TARGET_SPARC
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002529 .mhandler.cmd = sun4m_pic_info,
Jan Kiszka661f1922011-10-16 11:53:13 +02002530#elif defined(TARGET_LM32)
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002531 .mhandler.cmd = lm32_do_pic_info,
Jan Kiszka661f1922011-10-16 11:53:13 +02002532#else
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002533 .mhandler.cmd = pic_info,
Jan Kiszka661f1922011-10-16 11:53:13 +02002534#endif
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002535 },
Jan Kiszka661f1922011-10-16 11:53:13 +02002536#endif
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002537 {
2538 .name = "pci",
2539 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002540 .params = "",
2541 .help = "show PCI info",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002542 .mhandler.cmd = hmp_info_pci,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002543 },
Scott Woodbebabbc2011-08-18 10:38:42 +00002544#if defined(TARGET_I386) || defined(TARGET_SH4) || defined(TARGET_SPARC) || \
Max Filippov692f7372012-01-07 20:02:40 +04002545 defined(TARGET_PPC) || defined(TARGET_XTENSA)
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002546 {
2547 .name = "tlb",
2548 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002549 .params = "",
2550 .help = "show virtual to physical memory mappings",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002551 .mhandler.cmd = tlb_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002552 },
aurel327c664e22009-03-03 06:12:22 +00002553#endif
2554#if defined(TARGET_I386)
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002555 {
2556 .name = "mem",
2557 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002558 .params = "",
2559 .help = "show the active virtual memory mappings",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002560 .mhandler.cmd = mem_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002561 },
bellardb86bda52004-09-18 19:32:46 +00002562#endif
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002563 {
Blue Swirl314e2982011-09-11 20:22:05 +00002564 .name = "mtree",
2565 .args_type = "",
2566 .params = "",
2567 .help = "show memory tree",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002568 .mhandler.cmd = do_info_mtree,
Blue Swirl314e2982011-09-11 20:22:05 +00002569 },
2570 {
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002571 .name = "jit",
2572 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002573 .params = "",
2574 .help = "show dynamic compiler info",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002575 .mhandler.cmd = do_info_jit,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002576 },
2577 {
2578 .name = "kvm",
2579 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002580 .params = "",
2581 .help = "show KVM information",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002582 .mhandler.cmd = hmp_info_kvm,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002583 },
2584 {
2585 .name = "numa",
2586 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002587 .params = "",
2588 .help = "show NUMA information",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002589 .mhandler.cmd = do_info_numa,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002590 },
2591 {
2592 .name = "usb",
2593 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002594 .params = "",
2595 .help = "show guest USB devices",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002596 .mhandler.cmd = usb_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002597 },
2598 {
2599 .name = "usbhost",
2600 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002601 .params = "",
2602 .help = "show host USB devices",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002603 .mhandler.cmd = usb_host_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002604 },
2605 {
2606 .name = "profile",
2607 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002608 .params = "",
2609 .help = "show profiling information",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002610 .mhandler.cmd = do_info_profile,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002611 },
2612 {
2613 .name = "capture",
2614 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002615 .params = "",
2616 .help = "show capture information",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002617 .mhandler.cmd = do_info_capture,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002618 },
2619 {
2620 .name = "snapshots",
2621 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002622 .params = "",
2623 .help = "show the currently saved VM snapshots",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002624 .mhandler.cmd = do_info_snapshots,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002625 },
2626 {
2627 .name = "status",
2628 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002629 .params = "",
2630 .help = "show the current VM status (running|paused)",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002631 .mhandler.cmd = hmp_info_status,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002632 },
2633 {
2634 .name = "pcmcia",
2635 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002636 .params = "",
2637 .help = "show guest PCMCIA status",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002638 .mhandler.cmd = pcmcia_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002639 },
2640 {
2641 .name = "mice",
2642 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002643 .params = "",
2644 .help = "show which guest mouse is receiving events",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002645 .mhandler.cmd = hmp_info_mice,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002646 },
2647 {
2648 .name = "vnc",
2649 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002650 .params = "",
2651 .help = "show the vnc server status",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002652 .mhandler.cmd = hmp_info_vnc,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002653 },
Gerd Hoffmanncb42a872010-11-30 11:02:51 +01002654#if defined(CONFIG_SPICE)
2655 {
2656 .name = "spice",
2657 .args_type = "",
2658 .params = "",
2659 .help = "show the spice server status",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002660 .mhandler.cmd = hmp_info_spice,
Gerd Hoffmanncb42a872010-11-30 11:02:51 +01002661 },
2662#endif
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002663 {
2664 .name = "name",
2665 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002666 .params = "",
2667 .help = "show the current VM name",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002668 .mhandler.cmd = hmp_info_name,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002669 },
2670 {
2671 .name = "uuid",
2672 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002673 .params = "",
2674 .help = "show the current VM UUID",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002675 .mhandler.cmd = hmp_info_uuid,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002676 },
j_mayer76a66252007-03-07 08:32:30 +00002677#if defined(TARGET_PPC)
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002678 {
2679 .name = "cpustats",
2680 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002681 .params = "",
2682 .help = "show CPU statistics",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002683 .mhandler.cmd = do_info_cpu_stats,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002684 },
j_mayer76a66252007-03-07 08:32:30 +00002685#endif
blueswir131a60e22007-10-26 18:42:59 +00002686#if defined(CONFIG_SLIRP)
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002687 {
2688 .name = "usernet",
2689 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002690 .params = "",
2691 .help = "show user network stack connection states",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002692 .mhandler.cmd = do_info_usernet,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002693 },
blueswir131a60e22007-10-26 18:42:59 +00002694#endif
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002695 {
2696 .name = "migrate",
2697 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002698 .params = "",
2699 .help = "show migration status",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002700 .mhandler.cmd = hmp_info_migrate,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002701 },
2702 {
Orit Wassermanbbf6da32012-08-06 21:42:47 +03002703 .name = "migrate_capabilities",
2704 .args_type = "",
2705 .params = "",
2706 .help = "show current migration capabilities",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002707 .mhandler.cmd = hmp_info_migrate_capabilities,
Orit Wassermanbbf6da32012-08-06 21:42:47 +03002708 },
2709 {
Orit Wasserman9e1ba4c2012-08-06 21:42:54 +03002710 .name = "migrate_cache_size",
2711 .args_type = "",
2712 .params = "",
2713 .help = "show current migration xbzrle cache size",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002714 .mhandler.cmd = hmp_info_migrate_cache_size,
Orit Wasserman9e1ba4c2012-08-06 21:42:54 +03002715 },
2716 {
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002717 .name = "balloon",
2718 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002719 .params = "",
2720 .help = "show balloon information",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002721 .mhandler.cmd = hmp_info_balloon,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002722 },
2723 {
2724 .name = "qtree",
2725 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002726 .params = "",
2727 .help = "show device tree",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002728 .mhandler.cmd = do_info_qtree,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002729 },
2730 {
2731 .name = "qdm",
2732 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002733 .params = "",
2734 .help = "show qdev device model list",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002735 .mhandler.cmd = do_info_qdm,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002736 },
2737 {
2738 .name = "roms",
2739 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002740 .params = "",
2741 .help = "show roms",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002742 .mhandler.cmd = do_info_roms,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002743 },
Prerna Saxena22890ab2010-06-24 17:04:53 +05302744 {
2745 .name = "trace-events",
2746 .args_type = "",
2747 .params = "",
2748 .help = "show available trace-events & their state",
Wenchao Xia5f11cb02013-01-14 14:06:26 +08002749 .mhandler.cmd = do_trace_print_events,
Prerna Saxena22890ab2010-06-24 17:04:53 +05302750 },
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002751 {
Stefan Bergerd1a0cf72013-02-27 12:47:49 -05002752 .name = "tpm",
2753 .args_type = "",
2754 .params = "",
2755 .help = "show the TPM device",
2756 .mhandler.cmd = hmp_info_tpm,
2757 },
2758 {
Michal Novotny4d700432013-03-25 17:31:33 +01002759 .name = "cpu_max",
2760 .args_type = "",
2761 .params = "",
2762 .help = "Get maximum number of VCPUs supported by machine",
2763 .mhandler.cmd = hmp_query_cpu_max,
2764 },
2765 {
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002766 .name = NULL,
2767 },
bellard9dc39cb2004-03-14 21:38:27 +00002768};
2769
Wenchao Xiaa13ced52013-01-14 14:06:28 +08002770/* mon_cmds and info_cmds would be sorted at runtime */
2771static mon_cmd_t mon_cmds[] = {
2772#include "hmp-commands.h"
2773 { NULL, NULL, },
2774};
2775
Luiz Capitulinof36b4af2010-09-15 17:17:45 -03002776static const mon_cmd_t qmp_cmds[] = {
Anthony Liguorie3193602011-09-02 12:34:47 -05002777#include "qmp-commands-old.h"
Luiz Capitulinof36b4af2010-09-15 17:17:45 -03002778 { /* NULL */ },
2779};
2780
bellard9307c4c2004-04-04 12:57:25 +00002781/*******************************************************************/
2782
2783static const char *pch;
Peter Maydell6ab7e542013-02-20 15:21:09 +00002784static sigjmp_buf expr_env;
bellard9307c4c2004-04-04 12:57:25 +00002785
bellard92a31b12005-02-10 22:00:52 +00002786#define MD_TLONG 0
2787#define MD_I32 1
2788
bellard9307c4c2004-04-04 12:57:25 +00002789typedef struct MonitorDef {
2790 const char *name;
2791 int offset;
blueswir18662d652008-10-02 18:32:44 +00002792 target_long (*get_value)(const struct MonitorDef *md, int val);
bellard92a31b12005-02-10 22:00:52 +00002793 int type;
bellard9307c4c2004-04-04 12:57:25 +00002794} MonitorDef;
2795
bellard57206fd2004-04-25 18:54:52 +00002796#if defined(TARGET_I386)
blueswir18662d652008-10-02 18:32:44 +00002797static target_long monitor_get_pc (const struct MonitorDef *md, int val)
bellard57206fd2004-04-25 18:54:52 +00002798{
Andreas Färber9349b4f2012-03-14 01:38:32 +01002799 CPUArchState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00002800 return env->eip + env->segs[R_CS].base;
bellard57206fd2004-04-25 18:54:52 +00002801}
2802#endif
2803
bellarda541f292004-04-12 20:39:29 +00002804#if defined(TARGET_PPC)
blueswir18662d652008-10-02 18:32:44 +00002805static target_long monitor_get_ccr (const struct MonitorDef *md, int val)
bellarda541f292004-04-12 20:39:29 +00002806{
Andreas Färber9349b4f2012-03-14 01:38:32 +01002807 CPUArchState *env = mon_get_cpu();
bellarda541f292004-04-12 20:39:29 +00002808 unsigned int u;
2809 int i;
2810
2811 u = 0;
2812 for (i = 0; i < 8; i++)
aliguori28a76be2009-03-06 20:27:40 +00002813 u |= env->crf[i] << (32 - (4 * i));
bellarda541f292004-04-12 20:39:29 +00002814
2815 return u;
2816}
2817
blueswir18662d652008-10-02 18:32:44 +00002818static target_long monitor_get_msr (const struct MonitorDef *md, int val)
bellarda541f292004-04-12 20:39:29 +00002819{
Andreas Färber9349b4f2012-03-14 01:38:32 +01002820 CPUArchState *env = mon_get_cpu();
j_mayer0411a972007-10-25 21:35:50 +00002821 return env->msr;
bellarda541f292004-04-12 20:39:29 +00002822}
2823
blueswir18662d652008-10-02 18:32:44 +00002824static target_long monitor_get_xer (const struct MonitorDef *md, int val)
bellarda541f292004-04-12 20:39:29 +00002825{
Andreas Färber9349b4f2012-03-14 01:38:32 +01002826 CPUArchState *env = mon_get_cpu();
aurel323d7b4172008-10-21 11:28:46 +00002827 return env->xer;
bellarda541f292004-04-12 20:39:29 +00002828}
bellard9fddaa02004-05-21 12:59:32 +00002829
blueswir18662d652008-10-02 18:32:44 +00002830static target_long monitor_get_decr (const struct MonitorDef *md, int val)
bellard9fddaa02004-05-21 12:59:32 +00002831{
Andreas Färber9349b4f2012-03-14 01:38:32 +01002832 CPUArchState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00002833 return cpu_ppc_load_decr(env);
bellard9fddaa02004-05-21 12:59:32 +00002834}
2835
blueswir18662d652008-10-02 18:32:44 +00002836static target_long monitor_get_tbu (const struct MonitorDef *md, int val)
bellard9fddaa02004-05-21 12:59:32 +00002837{
Andreas Färber9349b4f2012-03-14 01:38:32 +01002838 CPUArchState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00002839 return cpu_ppc_load_tbu(env);
bellard9fddaa02004-05-21 12:59:32 +00002840}
2841
blueswir18662d652008-10-02 18:32:44 +00002842static target_long monitor_get_tbl (const struct MonitorDef *md, int val)
bellard9fddaa02004-05-21 12:59:32 +00002843{
Andreas Färber9349b4f2012-03-14 01:38:32 +01002844 CPUArchState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00002845 return cpu_ppc_load_tbl(env);
bellard9fddaa02004-05-21 12:59:32 +00002846}
bellarda541f292004-04-12 20:39:29 +00002847#endif
2848
bellarde95c8d52004-09-30 22:22:08 +00002849#if defined(TARGET_SPARC)
bellard7b936c02005-10-30 17:05:13 +00002850#ifndef TARGET_SPARC64
blueswir18662d652008-10-02 18:32:44 +00002851static target_long monitor_get_psr (const struct MonitorDef *md, int val)
bellarde95c8d52004-09-30 22:22:08 +00002852{
Andreas Färber9349b4f2012-03-14 01:38:32 +01002853 CPUArchState *env = mon_get_cpu();
Blue Swirl5a834bb2010-05-09 20:19:04 +00002854
2855 return cpu_get_psr(env);
bellarde95c8d52004-09-30 22:22:08 +00002856}
bellard7b936c02005-10-30 17:05:13 +00002857#endif
bellarde95c8d52004-09-30 22:22:08 +00002858
blueswir18662d652008-10-02 18:32:44 +00002859static target_long monitor_get_reg(const struct MonitorDef *md, int val)
bellarde95c8d52004-09-30 22:22:08 +00002860{
Andreas Färber9349b4f2012-03-14 01:38:32 +01002861 CPUArchState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00002862 return env->regwptr[val];
bellarde95c8d52004-09-30 22:22:08 +00002863}
2864#endif
2865
blueswir18662d652008-10-02 18:32:44 +00002866static const MonitorDef monitor_defs[] = {
bellard9307c4c2004-04-04 12:57:25 +00002867#ifdef TARGET_I386
bellard57206fd2004-04-25 18:54:52 +00002868
2869#define SEG(name, seg) \
Andreas Färbere59d1672012-02-16 00:40:47 +01002870 { name, offsetof(CPUX86State, segs[seg].selector), NULL, MD_I32 },\
2871 { name ".base", offsetof(CPUX86State, segs[seg].base) },\
2872 { name ".limit", offsetof(CPUX86State, segs[seg].limit), NULL, MD_I32 },
bellard57206fd2004-04-25 18:54:52 +00002873
Andreas Färbere59d1672012-02-16 00:40:47 +01002874 { "eax", offsetof(CPUX86State, regs[0]) },
2875 { "ecx", offsetof(CPUX86State, regs[1]) },
2876 { "edx", offsetof(CPUX86State, regs[2]) },
2877 { "ebx", offsetof(CPUX86State, regs[3]) },
2878 { "esp|sp", offsetof(CPUX86State, regs[4]) },
2879 { "ebp|fp", offsetof(CPUX86State, regs[5]) },
2880 { "esi", offsetof(CPUX86State, regs[6]) },
2881 { "edi", offsetof(CPUX86State, regs[7]) },
bellard92a31b12005-02-10 22:00:52 +00002882#ifdef TARGET_X86_64
Andreas Färbere59d1672012-02-16 00:40:47 +01002883 { "r8", offsetof(CPUX86State, regs[8]) },
2884 { "r9", offsetof(CPUX86State, regs[9]) },
2885 { "r10", offsetof(CPUX86State, regs[10]) },
2886 { "r11", offsetof(CPUX86State, regs[11]) },
2887 { "r12", offsetof(CPUX86State, regs[12]) },
2888 { "r13", offsetof(CPUX86State, regs[13]) },
2889 { "r14", offsetof(CPUX86State, regs[14]) },
2890 { "r15", offsetof(CPUX86State, regs[15]) },
bellard92a31b12005-02-10 22:00:52 +00002891#endif
Andreas Färbere59d1672012-02-16 00:40:47 +01002892 { "eflags", offsetof(CPUX86State, eflags) },
2893 { "eip", offsetof(CPUX86State, eip) },
bellard57206fd2004-04-25 18:54:52 +00002894 SEG("cs", R_CS)
2895 SEG("ds", R_DS)
2896 SEG("es", R_ES)
bellard01038d22004-09-13 21:36:46 +00002897 SEG("ss", R_SS)
bellard57206fd2004-04-25 18:54:52 +00002898 SEG("fs", R_FS)
2899 SEG("gs", R_GS)
2900 { "pc", 0, monitor_get_pc, },
bellarda541f292004-04-12 20:39:29 +00002901#elif defined(TARGET_PPC)
j_mayerff937db2007-09-19 05:49:13 +00002902 /* General purpose registers */
Andreas Färbere59d1672012-02-16 00:40:47 +01002903 { "r0", offsetof(CPUPPCState, gpr[0]) },
2904 { "r1", offsetof(CPUPPCState, gpr[1]) },
2905 { "r2", offsetof(CPUPPCState, gpr[2]) },
2906 { "r3", offsetof(CPUPPCState, gpr[3]) },
2907 { "r4", offsetof(CPUPPCState, gpr[4]) },
2908 { "r5", offsetof(CPUPPCState, gpr[5]) },
2909 { "r6", offsetof(CPUPPCState, gpr[6]) },
2910 { "r7", offsetof(CPUPPCState, gpr[7]) },
2911 { "r8", offsetof(CPUPPCState, gpr[8]) },
2912 { "r9", offsetof(CPUPPCState, gpr[9]) },
2913 { "r10", offsetof(CPUPPCState, gpr[10]) },
2914 { "r11", offsetof(CPUPPCState, gpr[11]) },
2915 { "r12", offsetof(CPUPPCState, gpr[12]) },
2916 { "r13", offsetof(CPUPPCState, gpr[13]) },
2917 { "r14", offsetof(CPUPPCState, gpr[14]) },
2918 { "r15", offsetof(CPUPPCState, gpr[15]) },
2919 { "r16", offsetof(CPUPPCState, gpr[16]) },
2920 { "r17", offsetof(CPUPPCState, gpr[17]) },
2921 { "r18", offsetof(CPUPPCState, gpr[18]) },
2922 { "r19", offsetof(CPUPPCState, gpr[19]) },
2923 { "r20", offsetof(CPUPPCState, gpr[20]) },
2924 { "r21", offsetof(CPUPPCState, gpr[21]) },
2925 { "r22", offsetof(CPUPPCState, gpr[22]) },
2926 { "r23", offsetof(CPUPPCState, gpr[23]) },
2927 { "r24", offsetof(CPUPPCState, gpr[24]) },
2928 { "r25", offsetof(CPUPPCState, gpr[25]) },
2929 { "r26", offsetof(CPUPPCState, gpr[26]) },
2930 { "r27", offsetof(CPUPPCState, gpr[27]) },
2931 { "r28", offsetof(CPUPPCState, gpr[28]) },
2932 { "r29", offsetof(CPUPPCState, gpr[29]) },
2933 { "r30", offsetof(CPUPPCState, gpr[30]) },
2934 { "r31", offsetof(CPUPPCState, gpr[31]) },
j_mayerff937db2007-09-19 05:49:13 +00002935 /* Floating point registers */
Andreas Färbere59d1672012-02-16 00:40:47 +01002936 { "f0", offsetof(CPUPPCState, fpr[0]) },
2937 { "f1", offsetof(CPUPPCState, fpr[1]) },
2938 { "f2", offsetof(CPUPPCState, fpr[2]) },
2939 { "f3", offsetof(CPUPPCState, fpr[3]) },
2940 { "f4", offsetof(CPUPPCState, fpr[4]) },
2941 { "f5", offsetof(CPUPPCState, fpr[5]) },
2942 { "f6", offsetof(CPUPPCState, fpr[6]) },
2943 { "f7", offsetof(CPUPPCState, fpr[7]) },
2944 { "f8", offsetof(CPUPPCState, fpr[8]) },
2945 { "f9", offsetof(CPUPPCState, fpr[9]) },
2946 { "f10", offsetof(CPUPPCState, fpr[10]) },
2947 { "f11", offsetof(CPUPPCState, fpr[11]) },
2948 { "f12", offsetof(CPUPPCState, fpr[12]) },
2949 { "f13", offsetof(CPUPPCState, fpr[13]) },
2950 { "f14", offsetof(CPUPPCState, fpr[14]) },
2951 { "f15", offsetof(CPUPPCState, fpr[15]) },
2952 { "f16", offsetof(CPUPPCState, fpr[16]) },
2953 { "f17", offsetof(CPUPPCState, fpr[17]) },
2954 { "f18", offsetof(CPUPPCState, fpr[18]) },
2955 { "f19", offsetof(CPUPPCState, fpr[19]) },
2956 { "f20", offsetof(CPUPPCState, fpr[20]) },
2957 { "f21", offsetof(CPUPPCState, fpr[21]) },
2958 { "f22", offsetof(CPUPPCState, fpr[22]) },
2959 { "f23", offsetof(CPUPPCState, fpr[23]) },
2960 { "f24", offsetof(CPUPPCState, fpr[24]) },
2961 { "f25", offsetof(CPUPPCState, fpr[25]) },
2962 { "f26", offsetof(CPUPPCState, fpr[26]) },
2963 { "f27", offsetof(CPUPPCState, fpr[27]) },
2964 { "f28", offsetof(CPUPPCState, fpr[28]) },
2965 { "f29", offsetof(CPUPPCState, fpr[29]) },
2966 { "f30", offsetof(CPUPPCState, fpr[30]) },
2967 { "f31", offsetof(CPUPPCState, fpr[31]) },
2968 { "fpscr", offsetof(CPUPPCState, fpscr) },
j_mayerff937db2007-09-19 05:49:13 +00002969 /* Next instruction pointer */
Andreas Färbere59d1672012-02-16 00:40:47 +01002970 { "nip|pc", offsetof(CPUPPCState, nip) },
2971 { "lr", offsetof(CPUPPCState, lr) },
2972 { "ctr", offsetof(CPUPPCState, ctr) },
bellard9fddaa02004-05-21 12:59:32 +00002973 { "decr", 0, &monitor_get_decr, },
bellarda541f292004-04-12 20:39:29 +00002974 { "ccr", 0, &monitor_get_ccr, },
j_mayerff937db2007-09-19 05:49:13 +00002975 /* Machine state register */
bellarda541f292004-04-12 20:39:29 +00002976 { "msr", 0, &monitor_get_msr, },
2977 { "xer", 0, &monitor_get_xer, },
bellard9fddaa02004-05-21 12:59:32 +00002978 { "tbu", 0, &monitor_get_tbu, },
2979 { "tbl", 0, &monitor_get_tbl, },
j_mayerff937db2007-09-19 05:49:13 +00002980 /* Segment registers */
Andreas Färbere59d1672012-02-16 00:40:47 +01002981 { "sdr1", offsetof(CPUPPCState, spr[SPR_SDR1]) },
2982 { "sr0", offsetof(CPUPPCState, sr[0]) },
2983 { "sr1", offsetof(CPUPPCState, sr[1]) },
2984 { "sr2", offsetof(CPUPPCState, sr[2]) },
2985 { "sr3", offsetof(CPUPPCState, sr[3]) },
2986 { "sr4", offsetof(CPUPPCState, sr[4]) },
2987 { "sr5", offsetof(CPUPPCState, sr[5]) },
2988 { "sr6", offsetof(CPUPPCState, sr[6]) },
2989 { "sr7", offsetof(CPUPPCState, sr[7]) },
2990 { "sr8", offsetof(CPUPPCState, sr[8]) },
2991 { "sr9", offsetof(CPUPPCState, sr[9]) },
2992 { "sr10", offsetof(CPUPPCState, sr[10]) },
2993 { "sr11", offsetof(CPUPPCState, sr[11]) },
2994 { "sr12", offsetof(CPUPPCState, sr[12]) },
2995 { "sr13", offsetof(CPUPPCState, sr[13]) },
2996 { "sr14", offsetof(CPUPPCState, sr[14]) },
2997 { "sr15", offsetof(CPUPPCState, sr[15]) },
Scott Wood90dc8812011-04-29 17:10:23 -05002998 /* Too lazy to put BATs... */
Andreas Färbere59d1672012-02-16 00:40:47 +01002999 { "pvr", offsetof(CPUPPCState, spr[SPR_PVR]) },
Scott Wood90dc8812011-04-29 17:10:23 -05003000
Andreas Färbere59d1672012-02-16 00:40:47 +01003001 { "srr0", offsetof(CPUPPCState, spr[SPR_SRR0]) },
3002 { "srr1", offsetof(CPUPPCState, spr[SPR_SRR1]) },
3003 { "sprg0", offsetof(CPUPPCState, spr[SPR_SPRG0]) },
3004 { "sprg1", offsetof(CPUPPCState, spr[SPR_SPRG1]) },
3005 { "sprg2", offsetof(CPUPPCState, spr[SPR_SPRG2]) },
3006 { "sprg3", offsetof(CPUPPCState, spr[SPR_SPRG3]) },
3007 { "sprg4", offsetof(CPUPPCState, spr[SPR_SPRG4]) },
3008 { "sprg5", offsetof(CPUPPCState, spr[SPR_SPRG5]) },
3009 { "sprg6", offsetof(CPUPPCState, spr[SPR_SPRG6]) },
3010 { "sprg7", offsetof(CPUPPCState, spr[SPR_SPRG7]) },
3011 { "pid", offsetof(CPUPPCState, spr[SPR_BOOKE_PID]) },
3012 { "csrr0", offsetof(CPUPPCState, spr[SPR_BOOKE_CSRR0]) },
3013 { "csrr1", offsetof(CPUPPCState, spr[SPR_BOOKE_CSRR1]) },
3014 { "esr", offsetof(CPUPPCState, spr[SPR_BOOKE_ESR]) },
3015 { "dear", offsetof(CPUPPCState, spr[SPR_BOOKE_DEAR]) },
3016 { "mcsr", offsetof(CPUPPCState, spr[SPR_BOOKE_MCSR]) },
3017 { "tsr", offsetof(CPUPPCState, spr[SPR_BOOKE_TSR]) },
3018 { "tcr", offsetof(CPUPPCState, spr[SPR_BOOKE_TCR]) },
3019 { "vrsave", offsetof(CPUPPCState, spr[SPR_VRSAVE]) },
3020 { "pir", offsetof(CPUPPCState, spr[SPR_BOOKE_PIR]) },
3021 { "mcsrr0", offsetof(CPUPPCState, spr[SPR_BOOKE_MCSRR0]) },
3022 { "mcsrr1", offsetof(CPUPPCState, spr[SPR_BOOKE_MCSRR1]) },
3023 { "decar", offsetof(CPUPPCState, spr[SPR_BOOKE_DECAR]) },
3024 { "ivpr", offsetof(CPUPPCState, spr[SPR_BOOKE_IVPR]) },
3025 { "epcr", offsetof(CPUPPCState, spr[SPR_BOOKE_EPCR]) },
3026 { "sprg8", offsetof(CPUPPCState, spr[SPR_BOOKE_SPRG8]) },
3027 { "ivor0", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR0]) },
3028 { "ivor1", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR1]) },
3029 { "ivor2", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR2]) },
3030 { "ivor3", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR3]) },
3031 { "ivor4", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR4]) },
3032 { "ivor5", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR5]) },
3033 { "ivor6", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR6]) },
3034 { "ivor7", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR7]) },
3035 { "ivor8", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR8]) },
3036 { "ivor9", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR9]) },
3037 { "ivor10", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR10]) },
3038 { "ivor11", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR11]) },
3039 { "ivor12", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR12]) },
3040 { "ivor13", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR13]) },
3041 { "ivor14", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR14]) },
3042 { "ivor15", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR15]) },
3043 { "ivor32", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR32]) },
3044 { "ivor33", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR33]) },
3045 { "ivor34", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR34]) },
3046 { "ivor35", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR35]) },
3047 { "ivor36", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR36]) },
3048 { "ivor37", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR37]) },
3049 { "mas0", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS0]) },
3050 { "mas1", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS1]) },
3051 { "mas2", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS2]) },
3052 { "mas3", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS3]) },
3053 { "mas4", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS4]) },
3054 { "mas6", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS6]) },
3055 { "mas7", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS7]) },
3056 { "mmucfg", offsetof(CPUPPCState, spr[SPR_MMUCFG]) },
3057 { "tlb0cfg", offsetof(CPUPPCState, spr[SPR_BOOKE_TLB0CFG]) },
3058 { "tlb1cfg", offsetof(CPUPPCState, spr[SPR_BOOKE_TLB1CFG]) },
3059 { "epr", offsetof(CPUPPCState, spr[SPR_BOOKE_EPR]) },
3060 { "eplc", offsetof(CPUPPCState, spr[SPR_BOOKE_EPLC]) },
3061 { "epsc", offsetof(CPUPPCState, spr[SPR_BOOKE_EPSC]) },
3062 { "svr", offsetof(CPUPPCState, spr[SPR_E500_SVR]) },
3063 { "mcar", offsetof(CPUPPCState, spr[SPR_Exxx_MCAR]) },
3064 { "pid1", offsetof(CPUPPCState, spr[SPR_BOOKE_PID1]) },
3065 { "pid2", offsetof(CPUPPCState, spr[SPR_BOOKE_PID2]) },
3066 { "hid0", offsetof(CPUPPCState, spr[SPR_HID0]) },
Scott Wood90dc8812011-04-29 17:10:23 -05003067
bellarde95c8d52004-09-30 22:22:08 +00003068#elif defined(TARGET_SPARC)
Andreas Färbere59d1672012-02-16 00:40:47 +01003069 { "g0", offsetof(CPUSPARCState, gregs[0]) },
3070 { "g1", offsetof(CPUSPARCState, gregs[1]) },
3071 { "g2", offsetof(CPUSPARCState, gregs[2]) },
3072 { "g3", offsetof(CPUSPARCState, gregs[3]) },
3073 { "g4", offsetof(CPUSPARCState, gregs[4]) },
3074 { "g5", offsetof(CPUSPARCState, gregs[5]) },
3075 { "g6", offsetof(CPUSPARCState, gregs[6]) },
3076 { "g7", offsetof(CPUSPARCState, gregs[7]) },
bellarde95c8d52004-09-30 22:22:08 +00003077 { "o0", 0, monitor_get_reg },
3078 { "o1", 1, monitor_get_reg },
3079 { "o2", 2, monitor_get_reg },
3080 { "o3", 3, monitor_get_reg },
3081 { "o4", 4, monitor_get_reg },
3082 { "o5", 5, monitor_get_reg },
3083 { "o6", 6, monitor_get_reg },
3084 { "o7", 7, monitor_get_reg },
3085 { "l0", 8, monitor_get_reg },
3086 { "l1", 9, monitor_get_reg },
3087 { "l2", 10, monitor_get_reg },
3088 { "l3", 11, monitor_get_reg },
3089 { "l4", 12, monitor_get_reg },
3090 { "l5", 13, monitor_get_reg },
3091 { "l6", 14, monitor_get_reg },
3092 { "l7", 15, monitor_get_reg },
3093 { "i0", 16, monitor_get_reg },
3094 { "i1", 17, monitor_get_reg },
3095 { "i2", 18, monitor_get_reg },
3096 { "i3", 19, monitor_get_reg },
3097 { "i4", 20, monitor_get_reg },
3098 { "i5", 21, monitor_get_reg },
3099 { "i6", 22, monitor_get_reg },
3100 { "i7", 23, monitor_get_reg },
Andreas Färbere59d1672012-02-16 00:40:47 +01003101 { "pc", offsetof(CPUSPARCState, pc) },
3102 { "npc", offsetof(CPUSPARCState, npc) },
3103 { "y", offsetof(CPUSPARCState, y) },
bellard7b936c02005-10-30 17:05:13 +00003104#ifndef TARGET_SPARC64
bellarde95c8d52004-09-30 22:22:08 +00003105 { "psr", 0, &monitor_get_psr, },
Andreas Färbere59d1672012-02-16 00:40:47 +01003106 { "wim", offsetof(CPUSPARCState, wim) },
bellard7b936c02005-10-30 17:05:13 +00003107#endif
Andreas Färbere59d1672012-02-16 00:40:47 +01003108 { "tbr", offsetof(CPUSPARCState, tbr) },
3109 { "fsr", offsetof(CPUSPARCState, fsr) },
3110 { "f0", offsetof(CPUSPARCState, fpr[0].l.upper) },
3111 { "f1", offsetof(CPUSPARCState, fpr[0].l.lower) },
3112 { "f2", offsetof(CPUSPARCState, fpr[1].l.upper) },
3113 { "f3", offsetof(CPUSPARCState, fpr[1].l.lower) },
3114 { "f4", offsetof(CPUSPARCState, fpr[2].l.upper) },
3115 { "f5", offsetof(CPUSPARCState, fpr[2].l.lower) },
3116 { "f6", offsetof(CPUSPARCState, fpr[3].l.upper) },
3117 { "f7", offsetof(CPUSPARCState, fpr[3].l.lower) },
3118 { "f8", offsetof(CPUSPARCState, fpr[4].l.upper) },
3119 { "f9", offsetof(CPUSPARCState, fpr[4].l.lower) },
3120 { "f10", offsetof(CPUSPARCState, fpr[5].l.upper) },
3121 { "f11", offsetof(CPUSPARCState, fpr[5].l.lower) },
3122 { "f12", offsetof(CPUSPARCState, fpr[6].l.upper) },
3123 { "f13", offsetof(CPUSPARCState, fpr[6].l.lower) },
3124 { "f14", offsetof(CPUSPARCState, fpr[7].l.upper) },
3125 { "f15", offsetof(CPUSPARCState, fpr[7].l.lower) },
3126 { "f16", offsetof(CPUSPARCState, fpr[8].l.upper) },
3127 { "f17", offsetof(CPUSPARCState, fpr[8].l.lower) },
3128 { "f18", offsetof(CPUSPARCState, fpr[9].l.upper) },
3129 { "f19", offsetof(CPUSPARCState, fpr[9].l.lower) },
3130 { "f20", offsetof(CPUSPARCState, fpr[10].l.upper) },
3131 { "f21", offsetof(CPUSPARCState, fpr[10].l.lower) },
3132 { "f22", offsetof(CPUSPARCState, fpr[11].l.upper) },
3133 { "f23", offsetof(CPUSPARCState, fpr[11].l.lower) },
3134 { "f24", offsetof(CPUSPARCState, fpr[12].l.upper) },
3135 { "f25", offsetof(CPUSPARCState, fpr[12].l.lower) },
3136 { "f26", offsetof(CPUSPARCState, fpr[13].l.upper) },
3137 { "f27", offsetof(CPUSPARCState, fpr[13].l.lower) },
3138 { "f28", offsetof(CPUSPARCState, fpr[14].l.upper) },
3139 { "f29", offsetof(CPUSPARCState, fpr[14].l.lower) },
3140 { "f30", offsetof(CPUSPARCState, fpr[15].l.upper) },
3141 { "f31", offsetof(CPUSPARCState, fpr[15].l.lower) },
bellard7b936c02005-10-30 17:05:13 +00003142#ifdef TARGET_SPARC64
Andreas Färbere59d1672012-02-16 00:40:47 +01003143 { "f32", offsetof(CPUSPARCState, fpr[16]) },
3144 { "f34", offsetof(CPUSPARCState, fpr[17]) },
3145 { "f36", offsetof(CPUSPARCState, fpr[18]) },
3146 { "f38", offsetof(CPUSPARCState, fpr[19]) },
3147 { "f40", offsetof(CPUSPARCState, fpr[20]) },
3148 { "f42", offsetof(CPUSPARCState, fpr[21]) },
3149 { "f44", offsetof(CPUSPARCState, fpr[22]) },
3150 { "f46", offsetof(CPUSPARCState, fpr[23]) },
3151 { "f48", offsetof(CPUSPARCState, fpr[24]) },
3152 { "f50", offsetof(CPUSPARCState, fpr[25]) },
3153 { "f52", offsetof(CPUSPARCState, fpr[26]) },
3154 { "f54", offsetof(CPUSPARCState, fpr[27]) },
3155 { "f56", offsetof(CPUSPARCState, fpr[28]) },
3156 { "f58", offsetof(CPUSPARCState, fpr[29]) },
3157 { "f60", offsetof(CPUSPARCState, fpr[30]) },
3158 { "f62", offsetof(CPUSPARCState, fpr[31]) },
3159 { "asi", offsetof(CPUSPARCState, asi) },
3160 { "pstate", offsetof(CPUSPARCState, pstate) },
3161 { "cansave", offsetof(CPUSPARCState, cansave) },
3162 { "canrestore", offsetof(CPUSPARCState, canrestore) },
3163 { "otherwin", offsetof(CPUSPARCState, otherwin) },
3164 { "wstate", offsetof(CPUSPARCState, wstate) },
3165 { "cleanwin", offsetof(CPUSPARCState, cleanwin) },
3166 { "fprs", offsetof(CPUSPARCState, fprs) },
bellard7b936c02005-10-30 17:05:13 +00003167#endif
bellard9307c4c2004-04-04 12:57:25 +00003168#endif
3169 { NULL },
3170};
3171
aliguori376253e2009-03-05 23:01:23 +00003172static void expr_error(Monitor *mon, const char *msg)
bellard9dc39cb2004-03-14 21:38:27 +00003173{
aliguori376253e2009-03-05 23:01:23 +00003174 monitor_printf(mon, "%s\n", msg);
Peter Maydell6ab7e542013-02-20 15:21:09 +00003175 siglongjmp(expr_env, 1);
bellard9307c4c2004-04-04 12:57:25 +00003176}
3177
Markus Armbruster09b94182010-01-20 13:07:30 +01003178/* return 0 if OK, -1 if not found */
bellard92a31b12005-02-10 22:00:52 +00003179static int get_monitor_def(target_long *pval, const char *name)
bellard9307c4c2004-04-04 12:57:25 +00003180{
blueswir18662d652008-10-02 18:32:44 +00003181 const MonitorDef *md;
bellard92a31b12005-02-10 22:00:52 +00003182 void *ptr;
3183
bellard9307c4c2004-04-04 12:57:25 +00003184 for(md = monitor_defs; md->name != NULL; md++) {
3185 if (compare_cmd(name, md->name)) {
3186 if (md->get_value) {
bellarde95c8d52004-09-30 22:22:08 +00003187 *pval = md->get_value(md, md->offset);
bellard9307c4c2004-04-04 12:57:25 +00003188 } else {
Andreas Färber9349b4f2012-03-14 01:38:32 +01003189 CPUArchState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00003190 ptr = (uint8_t *)env + md->offset;
bellard92a31b12005-02-10 22:00:52 +00003191 switch(md->type) {
3192 case MD_I32:
3193 *pval = *(int32_t *)ptr;
3194 break;
3195 case MD_TLONG:
3196 *pval = *(target_long *)ptr;
3197 break;
3198 default:
3199 *pval = 0;
3200 break;
3201 }
bellard9307c4c2004-04-04 12:57:25 +00003202 }
3203 return 0;
3204 }
3205 }
3206 return -1;
3207}
3208
3209static void next(void)
3210{
Blue Swirl660f11b2009-07-31 21:16:51 +00003211 if (*pch != '\0') {
bellard9307c4c2004-04-04 12:57:25 +00003212 pch++;
blueswir1cd390082008-11-16 13:53:32 +00003213 while (qemu_isspace(*pch))
bellard9307c4c2004-04-04 12:57:25 +00003214 pch++;
3215 }
3216}
3217
aliguori376253e2009-03-05 23:01:23 +00003218static int64_t expr_sum(Monitor *mon);
bellard9307c4c2004-04-04 12:57:25 +00003219
aliguori376253e2009-03-05 23:01:23 +00003220static int64_t expr_unary(Monitor *mon)
bellard9307c4c2004-04-04 12:57:25 +00003221{
blueswir1c2efc952007-09-25 17:28:42 +00003222 int64_t n;
bellard9307c4c2004-04-04 12:57:25 +00003223 char *p;
bellard6a00d602005-11-21 23:25:50 +00003224 int ret;
bellard9307c4c2004-04-04 12:57:25 +00003225
3226 switch(*pch) {
3227 case '+':
3228 next();
aliguori376253e2009-03-05 23:01:23 +00003229 n = expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00003230 break;
3231 case '-':
3232 next();
aliguori376253e2009-03-05 23:01:23 +00003233 n = -expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00003234 break;
3235 case '~':
3236 next();
aliguori376253e2009-03-05 23:01:23 +00003237 n = ~expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00003238 break;
3239 case '(':
3240 next();
aliguori376253e2009-03-05 23:01:23 +00003241 n = expr_sum(mon);
bellard9307c4c2004-04-04 12:57:25 +00003242 if (*pch != ')') {
aliguori376253e2009-03-05 23:01:23 +00003243 expr_error(mon, "')' expected");
bellard9307c4c2004-04-04 12:57:25 +00003244 }
3245 next();
3246 break;
bellard81d09122004-07-14 17:21:37 +00003247 case '\'':
3248 pch++;
3249 if (*pch == '\0')
aliguori376253e2009-03-05 23:01:23 +00003250 expr_error(mon, "character constant expected");
bellard81d09122004-07-14 17:21:37 +00003251 n = *pch;
3252 pch++;
3253 if (*pch != '\'')
aliguori376253e2009-03-05 23:01:23 +00003254 expr_error(mon, "missing terminating \' character");
bellard81d09122004-07-14 17:21:37 +00003255 next();
3256 break;
bellard9307c4c2004-04-04 12:57:25 +00003257 case '$':
3258 {
3259 char buf[128], *q;
ths69b34972007-12-17 03:15:52 +00003260 target_long reg=0;
ths3b46e622007-09-17 08:09:54 +00003261
bellard9307c4c2004-04-04 12:57:25 +00003262 pch++;
3263 q = buf;
3264 while ((*pch >= 'a' && *pch <= 'z') ||
3265 (*pch >= 'A' && *pch <= 'Z') ||
3266 (*pch >= '0' && *pch <= '9') ||
bellard57206fd2004-04-25 18:54:52 +00003267 *pch == '_' || *pch == '.') {
bellard9307c4c2004-04-04 12:57:25 +00003268 if ((q - buf) < sizeof(buf) - 1)
3269 *q++ = *pch;
3270 pch++;
3271 }
blueswir1cd390082008-11-16 13:53:32 +00003272 while (qemu_isspace(*pch))
bellard9307c4c2004-04-04 12:57:25 +00003273 pch++;
3274 *q = 0;
blueswir17743e582007-09-24 18:39:04 +00003275 ret = get_monitor_def(&reg, buf);
Markus Armbruster09b94182010-01-20 13:07:30 +01003276 if (ret < 0)
aliguori376253e2009-03-05 23:01:23 +00003277 expr_error(mon, "unknown register");
blueswir17743e582007-09-24 18:39:04 +00003278 n = reg;
bellard9307c4c2004-04-04 12:57:25 +00003279 }
3280 break;
3281 case '\0':
aliguori376253e2009-03-05 23:01:23 +00003282 expr_error(mon, "unexpected end of expression");
bellard9307c4c2004-04-04 12:57:25 +00003283 n = 0;
3284 break;
3285 default:
Luiz Capitulino6b0e33b2012-04-26 16:48:41 -03003286 errno = 0;
bellard4f4fbf72006-06-25 18:28:12 +00003287 n = strtoull(pch, &p, 0);
Luiz Capitulino6b0e33b2012-04-26 16:48:41 -03003288 if (errno == ERANGE) {
3289 expr_error(mon, "number too large");
3290 }
bellard9307c4c2004-04-04 12:57:25 +00003291 if (pch == p) {
aliguori376253e2009-03-05 23:01:23 +00003292 expr_error(mon, "invalid char in expression");
bellard9307c4c2004-04-04 12:57:25 +00003293 }
3294 pch = p;
blueswir1cd390082008-11-16 13:53:32 +00003295 while (qemu_isspace(*pch))
bellard9307c4c2004-04-04 12:57:25 +00003296 pch++;
3297 break;
3298 }
3299 return n;
3300}
3301
3302
aliguori376253e2009-03-05 23:01:23 +00003303static int64_t expr_prod(Monitor *mon)
bellard9307c4c2004-04-04 12:57:25 +00003304{
blueswir1c2efc952007-09-25 17:28:42 +00003305 int64_t val, val2;
bellard92a31b12005-02-10 22:00:52 +00003306 int op;
ths3b46e622007-09-17 08:09:54 +00003307
aliguori376253e2009-03-05 23:01:23 +00003308 val = expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00003309 for(;;) {
3310 op = *pch;
3311 if (op != '*' && op != '/' && op != '%')
3312 break;
3313 next();
aliguori376253e2009-03-05 23:01:23 +00003314 val2 = expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00003315 switch(op) {
3316 default:
3317 case '*':
3318 val *= val2;
3319 break;
3320 case '/':
3321 case '%':
ths5fafdf22007-09-16 21:08:06 +00003322 if (val2 == 0)
aliguori376253e2009-03-05 23:01:23 +00003323 expr_error(mon, "division by zero");
bellard9307c4c2004-04-04 12:57:25 +00003324 if (op == '/')
3325 val /= val2;
3326 else
3327 val %= val2;
3328 break;
3329 }
3330 }
3331 return val;
3332}
3333
aliguori376253e2009-03-05 23:01:23 +00003334static int64_t expr_logic(Monitor *mon)
bellard9307c4c2004-04-04 12:57:25 +00003335{
blueswir1c2efc952007-09-25 17:28:42 +00003336 int64_t val, val2;
bellard92a31b12005-02-10 22:00:52 +00003337 int op;
bellard9307c4c2004-04-04 12:57:25 +00003338
aliguori376253e2009-03-05 23:01:23 +00003339 val = expr_prod(mon);
bellard9307c4c2004-04-04 12:57:25 +00003340 for(;;) {
3341 op = *pch;
3342 if (op != '&' && op != '|' && op != '^')
3343 break;
3344 next();
aliguori376253e2009-03-05 23:01:23 +00003345 val2 = expr_prod(mon);
bellard9307c4c2004-04-04 12:57:25 +00003346 switch(op) {
3347 default:
3348 case '&':
3349 val &= val2;
3350 break;
3351 case '|':
3352 val |= val2;
3353 break;
3354 case '^':
3355 val ^= val2;
3356 break;
3357 }
3358 }
3359 return val;
3360}
3361
aliguori376253e2009-03-05 23:01:23 +00003362static int64_t expr_sum(Monitor *mon)
bellard9307c4c2004-04-04 12:57:25 +00003363{
blueswir1c2efc952007-09-25 17:28:42 +00003364 int64_t val, val2;
bellard92a31b12005-02-10 22:00:52 +00003365 int op;
bellard9307c4c2004-04-04 12:57:25 +00003366
aliguori376253e2009-03-05 23:01:23 +00003367 val = expr_logic(mon);
bellard9307c4c2004-04-04 12:57:25 +00003368 for(;;) {
3369 op = *pch;
3370 if (op != '+' && op != '-')
3371 break;
3372 next();
aliguori376253e2009-03-05 23:01:23 +00003373 val2 = expr_logic(mon);
bellard9307c4c2004-04-04 12:57:25 +00003374 if (op == '+')
3375 val += val2;
3376 else
3377 val -= val2;
3378 }
3379 return val;
3380}
3381
aliguori376253e2009-03-05 23:01:23 +00003382static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
bellard9307c4c2004-04-04 12:57:25 +00003383{
3384 pch = *pp;
Peter Maydell6ab7e542013-02-20 15:21:09 +00003385 if (sigsetjmp(expr_env, 0)) {
bellard9307c4c2004-04-04 12:57:25 +00003386 *pp = pch;
3387 return -1;
3388 }
blueswir1cd390082008-11-16 13:53:32 +00003389 while (qemu_isspace(*pch))
bellard9307c4c2004-04-04 12:57:25 +00003390 pch++;
aliguori376253e2009-03-05 23:01:23 +00003391 *pval = expr_sum(mon);
bellard9307c4c2004-04-04 12:57:25 +00003392 *pp = pch;
3393 return 0;
3394}
3395
Markus Armbruster3350a4d2010-01-25 14:23:03 +01003396static int get_double(Monitor *mon, double *pval, const char **pp)
3397{
3398 const char *p = *pp;
3399 char *tailp;
3400 double d;
3401
3402 d = strtod(p, &tailp);
3403 if (tailp == p) {
3404 monitor_printf(mon, "Number expected\n");
3405 return -1;
3406 }
3407 if (d != d || d - d != 0) {
3408 /* NaN or infinity */
3409 monitor_printf(mon, "Bad number\n");
3410 return -1;
3411 }
3412 *pval = d;
3413 *pp = tailp;
3414 return 0;
3415}
3416
bellard9307c4c2004-04-04 12:57:25 +00003417static int get_str(char *buf, int buf_size, const char **pp)
3418{
3419 const char *p;
3420 char *q;
3421 int c;
3422
bellard81d09122004-07-14 17:21:37 +00003423 q = buf;
bellard9307c4c2004-04-04 12:57:25 +00003424 p = *pp;
blueswir1cd390082008-11-16 13:53:32 +00003425 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00003426 p++;
3427 if (*p == '\0') {
3428 fail:
bellard81d09122004-07-14 17:21:37 +00003429 *q = '\0';
bellard9307c4c2004-04-04 12:57:25 +00003430 *pp = p;
3431 return -1;
3432 }
bellard9307c4c2004-04-04 12:57:25 +00003433 if (*p == '\"') {
3434 p++;
3435 while (*p != '\0' && *p != '\"') {
3436 if (*p == '\\') {
3437 p++;
3438 c = *p++;
3439 switch(c) {
3440 case 'n':
3441 c = '\n';
3442 break;
3443 case 'r':
3444 c = '\r';
3445 break;
3446 case '\\':
3447 case '\'':
3448 case '\"':
3449 break;
3450 default:
3451 qemu_printf("unsupported escape code: '\\%c'\n", c);
3452 goto fail;
3453 }
3454 if ((q - buf) < buf_size - 1) {
3455 *q++ = c;
3456 }
3457 } else {
3458 if ((q - buf) < buf_size - 1) {
3459 *q++ = *p;
3460 }
3461 p++;
3462 }
3463 }
3464 if (*p != '\"') {
bellard5b602122004-05-22 21:41:05 +00003465 qemu_printf("unterminated string\n");
bellard9307c4c2004-04-04 12:57:25 +00003466 goto fail;
3467 }
3468 p++;
3469 } else {
blueswir1cd390082008-11-16 13:53:32 +00003470 while (*p != '\0' && !qemu_isspace(*p)) {
bellard9307c4c2004-04-04 12:57:25 +00003471 if ((q - buf) < buf_size - 1) {
3472 *q++ = *p;
3473 }
3474 p++;
3475 }
bellard9307c4c2004-04-04 12:57:25 +00003476 }
bellard81d09122004-07-14 17:21:37 +00003477 *q = '\0';
bellard9307c4c2004-04-04 12:57:25 +00003478 *pp = p;
3479 return 0;
3480}
3481
Luiz Capitulino4590fd82009-06-09 18:21:30 -03003482/*
3483 * Store the command-name in cmdname, and return a pointer to
3484 * the remaining of the command string.
3485 */
3486static const char *get_command_name(const char *cmdline,
3487 char *cmdname, size_t nlen)
3488{
3489 size_t len;
3490 const char *p, *pstart;
3491
3492 p = cmdline;
3493 while (qemu_isspace(*p))
3494 p++;
3495 if (*p == '\0')
3496 return NULL;
3497 pstart = p;
3498 while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
3499 p++;
3500 len = p - pstart;
3501 if (len > nlen - 1)
3502 len = nlen - 1;
3503 memcpy(cmdname, pstart, len);
3504 cmdname[len] = '\0';
3505 return p;
3506}
3507
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003508/**
3509 * Read key of 'type' into 'key' and return the current
3510 * 'type' pointer.
3511 */
3512static char *key_get_info(const char *type, char **key)
3513{
3514 size_t len;
3515 char *p, *str;
3516
3517 if (*type == ',')
3518 type++;
3519
3520 p = strchr(type, ':');
3521 if (!p) {
3522 *key = NULL;
3523 return NULL;
3524 }
3525 len = p - type;
3526
Anthony Liguori7267c092011-08-20 22:09:37 -05003527 str = g_malloc(len + 1);
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003528 memcpy(str, type, len);
3529 str[len] = '\0';
3530
3531 *key = str;
3532 return ++p;
3533}
3534
bellard9307c4c2004-04-04 12:57:25 +00003535static int default_fmt_format = 'x';
3536static int default_fmt_size = 4;
3537
3538#define MAX_ARGS 16
3539
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02003540static int is_valid_option(const char *c, const char *typestr)
3541{
3542 char option[3];
3543
3544 option[0] = '-';
3545 option[1] = *c;
3546 option[2] = '\0';
3547
3548 typestr = strstr(typestr, option);
3549 return (typestr != NULL);
3550}
3551
Luiz Capitulino945c5ac2010-09-13 13:17:58 -03003552static const mon_cmd_t *search_dispatch_table(const mon_cmd_t *disp_table,
3553 const char *cmdname)
Luiz Capitulino7fd669a2009-11-26 22:58:54 -02003554{
3555 const mon_cmd_t *cmd;
3556
Luiz Capitulino945c5ac2010-09-13 13:17:58 -03003557 for (cmd = disp_table; cmd->name != NULL; cmd++) {
Luiz Capitulino7fd669a2009-11-26 22:58:54 -02003558 if (compare_cmd(cmdname, cmd->name)) {
3559 return cmd;
3560 }
3561 }
3562
3563 return NULL;
3564}
3565
Luiz Capitulinobead3ce2010-09-15 17:08:39 -03003566static const mon_cmd_t *qmp_find_cmd(const char *cmdname)
3567{
Luiz Capitulinof36b4af2010-09-15 17:17:45 -03003568 return search_dispatch_table(qmp_cmds, cmdname);
Luiz Capitulinobead3ce2010-09-15 17:08:39 -03003569}
3570
Wenchao Xia5f3d3352013-01-14 14:06:27 +08003571/*
3572 * Parse @cmdline according to command table @table.
3573 * If @cmdline is blank, return NULL.
3574 * If it can't be parsed, report to @mon, and return NULL.
3575 * Else, insert command arguments into @qdict, and return the command.
Peter Maydell085d8132013-03-18 17:20:07 +00003576 * If a sub-command table exists, and if @cmdline contains an additional string
3577 * for a sub-command, this function will try to search the sub-command table.
3578 * If no additional string for a sub-command is present, this function will
3579 * return the command found in @table.
Wenchao Xia5f3d3352013-01-14 14:06:27 +08003580 * Do not assume the returned command points into @table! It doesn't
3581 * when the command is a sub-command.
3582 */
Anthony Liguoric227f092009-10-01 16:12:16 -05003583static const mon_cmd_t *monitor_parse_command(Monitor *mon,
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003584 const char *cmdline,
Wenchao Xia5f3d3352013-01-14 14:06:27 +08003585 int start,
3586 mon_cmd_t *table,
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003587 QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +00003588{
Luiz Capitulino4590fd82009-06-09 18:21:30 -03003589 const char *p, *typestr;
Luiz Capitulino53773582009-08-28 15:27:25 -03003590 int c;
Anthony Liguoric227f092009-10-01 16:12:16 -05003591 const mon_cmd_t *cmd;
bellard9307c4c2004-04-04 12:57:25 +00003592 char cmdname[256];
3593 char buf[1024];
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003594 char *key;
bellard9dc39cb2004-03-14 21:38:27 +00003595
3596#ifdef DEBUG
Wenchao Xia5f3d3352013-01-14 14:06:27 +08003597 monitor_printf(mon, "command='%s', start='%d'\n", cmdline, start);
bellard9dc39cb2004-03-14 21:38:27 +00003598#endif
ths3b46e622007-09-17 08:09:54 +00003599
bellard9307c4c2004-04-04 12:57:25 +00003600 /* extract the command name */
Wenchao Xia5f3d3352013-01-14 14:06:27 +08003601 p = get_command_name(cmdline + start, cmdname, sizeof(cmdname));
Luiz Capitulino4590fd82009-06-09 18:21:30 -03003602 if (!p)
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003603 return NULL;
ths3b46e622007-09-17 08:09:54 +00003604
Wenchao Xia5f3d3352013-01-14 14:06:27 +08003605 cmd = search_dispatch_table(table, cmdname);
Luiz Capitulino7fd669a2009-11-26 22:58:54 -02003606 if (!cmd) {
Wenchao Xia5f3d3352013-01-14 14:06:27 +08003607 monitor_printf(mon, "unknown command: '%.*s'\n",
3608 (int)(p - cmdline), cmdline);
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003609 return NULL;
Luiz Capitulinod91d9bf2009-06-09 18:21:54 -03003610 }
bellard9307c4c2004-04-04 12:57:25 +00003611
Wenchao Xia5f3d3352013-01-14 14:06:27 +08003612 /* filter out following useless space */
3613 while (qemu_isspace(*p)) {
3614 p++;
3615 }
3616 /* search sub command */
3617 if (cmd->sub_table != NULL) {
3618 /* check if user set additional command */
3619 if (*p == '\0') {
3620 return cmd;
3621 }
3622 return monitor_parse_command(mon, cmdline, p - cmdline,
3623 cmd->sub_table, qdict);
3624 }
3625
bellard9307c4c2004-04-04 12:57:25 +00003626 /* parse the parameters */
3627 typestr = cmd->args_type;
bellard9307c4c2004-04-04 12:57:25 +00003628 for(;;) {
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003629 typestr = key_get_info(typestr, &key);
3630 if (!typestr)
bellard9307c4c2004-04-04 12:57:25 +00003631 break;
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003632 c = *typestr;
bellard9307c4c2004-04-04 12:57:25 +00003633 typestr++;
3634 switch(c) {
3635 case 'F':
bellard81d09122004-07-14 17:21:37 +00003636 case 'B':
bellard9307c4c2004-04-04 12:57:25 +00003637 case 's':
3638 {
3639 int ret;
ths3b46e622007-09-17 08:09:54 +00003640
blueswir1cd390082008-11-16 13:53:32 +00003641 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00003642 p++;
3643 if (*typestr == '?') {
3644 typestr++;
3645 if (*p == '\0') {
3646 /* no optional string: NULL argument */
Luiz Capitulino53773582009-08-28 15:27:25 -03003647 break;
bellard9307c4c2004-04-04 12:57:25 +00003648 }
3649 }
3650 ret = get_str(buf, sizeof(buf), &p);
3651 if (ret < 0) {
bellard81d09122004-07-14 17:21:37 +00003652 switch(c) {
3653 case 'F':
aliguori376253e2009-03-05 23:01:23 +00003654 monitor_printf(mon, "%s: filename expected\n",
3655 cmdname);
bellard81d09122004-07-14 17:21:37 +00003656 break;
3657 case 'B':
aliguori376253e2009-03-05 23:01:23 +00003658 monitor_printf(mon, "%s: block device name expected\n",
3659 cmdname);
bellard81d09122004-07-14 17:21:37 +00003660 break;
3661 default:
aliguori376253e2009-03-05 23:01:23 +00003662 monitor_printf(mon, "%s: string expected\n", cmdname);
bellard81d09122004-07-14 17:21:37 +00003663 break;
3664 }
bellard9307c4c2004-04-04 12:57:25 +00003665 goto fail;
3666 }
Luiz Capitulino53773582009-08-28 15:27:25 -03003667 qdict_put(qdict, key, qstring_from_str(buf));
bellard9307c4c2004-04-04 12:57:25 +00003668 }
3669 break;
Markus Armbruster361127d2010-02-10 20:24:35 +01003670 case 'O':
3671 {
3672 QemuOptsList *opts_list;
3673 QemuOpts *opts;
3674
3675 opts_list = qemu_find_opts(key);
3676 if (!opts_list || opts_list->desc->name) {
3677 goto bad_type;
3678 }
3679 while (qemu_isspace(*p)) {
3680 p++;
3681 }
3682 if (!*p)
3683 break;
3684 if (get_str(buf, sizeof(buf), &p) < 0) {
3685 goto fail;
3686 }
3687 opts = qemu_opts_parse(opts_list, buf, 1);
3688 if (!opts) {
3689 goto fail;
3690 }
3691 qemu_opts_to_qdict(opts, qdict);
3692 qemu_opts_del(opts);
3693 }
3694 break;
bellard9307c4c2004-04-04 12:57:25 +00003695 case '/':
3696 {
3697 int count, format, size;
ths3b46e622007-09-17 08:09:54 +00003698
blueswir1cd390082008-11-16 13:53:32 +00003699 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00003700 p++;
3701 if (*p == '/') {
3702 /* format found */
3703 p++;
3704 count = 1;
blueswir1cd390082008-11-16 13:53:32 +00003705 if (qemu_isdigit(*p)) {
bellard9307c4c2004-04-04 12:57:25 +00003706 count = 0;
blueswir1cd390082008-11-16 13:53:32 +00003707 while (qemu_isdigit(*p)) {
bellard9307c4c2004-04-04 12:57:25 +00003708 count = count * 10 + (*p - '0');
3709 p++;
3710 }
3711 }
3712 size = -1;
3713 format = -1;
3714 for(;;) {
3715 switch(*p) {
3716 case 'o':
3717 case 'd':
3718 case 'u':
3719 case 'x':
3720 case 'i':
3721 case 'c':
3722 format = *p++;
3723 break;
3724 case 'b':
3725 size = 1;
3726 p++;
3727 break;
3728 case 'h':
3729 size = 2;
3730 p++;
3731 break;
3732 case 'w':
3733 size = 4;
3734 p++;
3735 break;
3736 case 'g':
3737 case 'L':
3738 size = 8;
3739 p++;
3740 break;
3741 default:
3742 goto next;
3743 }
3744 }
3745 next:
blueswir1cd390082008-11-16 13:53:32 +00003746 if (*p != '\0' && !qemu_isspace(*p)) {
aliguori376253e2009-03-05 23:01:23 +00003747 monitor_printf(mon, "invalid char in format: '%c'\n",
3748 *p);
bellard9307c4c2004-04-04 12:57:25 +00003749 goto fail;
3750 }
bellard9307c4c2004-04-04 12:57:25 +00003751 if (format < 0)
3752 format = default_fmt_format;
bellard4c27ba22004-04-25 18:05:08 +00003753 if (format != 'i') {
3754 /* for 'i', not specifying a size gives -1 as size */
3755 if (size < 0)
3756 size = default_fmt_size;
aurel32e90f0092008-10-01 21:45:51 +00003757 default_fmt_size = size;
bellard4c27ba22004-04-25 18:05:08 +00003758 }
bellard9307c4c2004-04-04 12:57:25 +00003759 default_fmt_format = format;
3760 } else {
3761 count = 1;
3762 format = default_fmt_format;
bellard4c27ba22004-04-25 18:05:08 +00003763 if (format != 'i') {
3764 size = default_fmt_size;
3765 } else {
3766 size = -1;
3767 }
bellard9307c4c2004-04-04 12:57:25 +00003768 }
Luiz Capitulinof7188bb2009-08-28 15:27:10 -03003769 qdict_put(qdict, "count", qint_from_int(count));
3770 qdict_put(qdict, "format", qint_from_int(format));
3771 qdict_put(qdict, "size", qint_from_int(size));
bellard9307c4c2004-04-04 12:57:25 +00003772 }
3773 break;
3774 case 'i':
bellard92a31b12005-02-10 22:00:52 +00003775 case 'l':
Luiz Capitulinob6e098d2009-12-18 13:25:04 -02003776 case 'M':
bellard9307c4c2004-04-04 12:57:25 +00003777 {
blueswir1c2efc952007-09-25 17:28:42 +00003778 int64_t val;
blueswir17743e582007-09-24 18:39:04 +00003779
blueswir1cd390082008-11-16 13:53:32 +00003780 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00003781 p++;
bellard34405572004-06-08 00:55:58 +00003782 if (*typestr == '?' || *typestr == '.') {
bellard34405572004-06-08 00:55:58 +00003783 if (*typestr == '?') {
Luiz Capitulino53773582009-08-28 15:27:25 -03003784 if (*p == '\0') {
3785 typestr++;
3786 break;
3787 }
bellard34405572004-06-08 00:55:58 +00003788 } else {
3789 if (*p == '.') {
3790 p++;
blueswir1cd390082008-11-16 13:53:32 +00003791 while (qemu_isspace(*p))
bellard34405572004-06-08 00:55:58 +00003792 p++;
bellard34405572004-06-08 00:55:58 +00003793 } else {
Luiz Capitulino53773582009-08-28 15:27:25 -03003794 typestr++;
3795 break;
bellard34405572004-06-08 00:55:58 +00003796 }
3797 }
bellard13224a82006-07-14 22:03:35 +00003798 typestr++;
bellard9307c4c2004-04-04 12:57:25 +00003799 }
aliguori376253e2009-03-05 23:01:23 +00003800 if (get_expr(mon, &val, &p))
bellard9307c4c2004-04-04 12:57:25 +00003801 goto fail;
Luiz Capitulino675ebef2009-08-28 15:27:26 -03003802 /* Check if 'i' is greater than 32-bit */
3803 if ((c == 'i') && ((val >> 32) & 0xffffffff)) {
3804 monitor_printf(mon, "\'%s\' has failed: ", cmdname);
3805 monitor_printf(mon, "integer is for 32-bit values\n");
3806 goto fail;
Luiz Capitulinob6e098d2009-12-18 13:25:04 -02003807 } else if (c == 'M') {
Luiz Capitulino91162842012-04-26 17:34:30 -03003808 if (val < 0) {
3809 monitor_printf(mon, "enter a positive value\n");
3810 goto fail;
3811 }
Luiz Capitulinob6e098d2009-12-18 13:25:04 -02003812 val <<= 20;
Luiz Capitulino675ebef2009-08-28 15:27:26 -03003813 }
Luiz Capitulino53773582009-08-28 15:27:25 -03003814 qdict_put(qdict, key, qint_from_int(val));
bellard9307c4c2004-04-04 12:57:25 +00003815 }
3816 break;
Jes Sorensendbc0c672010-10-21 17:15:47 +02003817 case 'o':
3818 {
Jes Sorensen70b4f4b2011-01-05 11:41:02 +01003819 int64_t val;
Jes Sorensendbc0c672010-10-21 17:15:47 +02003820 char *end;
3821
3822 while (qemu_isspace(*p)) {
3823 p++;
3824 }
3825 if (*typestr == '?') {
3826 typestr++;
3827 if (*p == '\0') {
3828 break;
3829 }
3830 }
3831 val = strtosz(p, &end);
3832 if (val < 0) {
3833 monitor_printf(mon, "invalid size\n");
3834 goto fail;
3835 }
3836 qdict_put(qdict, key, qint_from_int(val));
3837 p = end;
3838 }
3839 break;
Markus Armbrusterfccfb11e2010-01-25 14:23:06 +01003840 case 'T':
Markus Armbruster3350a4d2010-01-25 14:23:03 +01003841 {
3842 double val;
3843
3844 while (qemu_isspace(*p))
3845 p++;
3846 if (*typestr == '?') {
3847 typestr++;
3848 if (*p == '\0') {
3849 break;
3850 }
3851 }
3852 if (get_double(mon, &val, &p) < 0) {
3853 goto fail;
3854 }
Jes Sorensen07de3e62010-10-21 17:15:49 +02003855 if (p[0] && p[1] == 's') {
Markus Armbrusterfccfb11e2010-01-25 14:23:06 +01003856 switch (*p) {
3857 case 'm':
3858 val /= 1e3; p += 2; break;
3859 case 'u':
3860 val /= 1e6; p += 2; break;
3861 case 'n':
3862 val /= 1e9; p += 2; break;
3863 }
3864 }
Markus Armbruster3350a4d2010-01-25 14:23:03 +01003865 if (*p && !qemu_isspace(*p)) {
3866 monitor_printf(mon, "Unknown unit suffix\n");
3867 goto fail;
3868 }
3869 qdict_put(qdict, key, qfloat_from_double(val));
3870 }
3871 break;
Markus Armbruster942cd1f2010-03-26 09:07:09 +01003872 case 'b':
3873 {
3874 const char *beg;
3875 int val;
3876
3877 while (qemu_isspace(*p)) {
3878 p++;
3879 }
3880 beg = p;
3881 while (qemu_isgraph(*p)) {
3882 p++;
3883 }
3884 if (p - beg == 2 && !memcmp(beg, "on", p - beg)) {
3885 val = 1;
3886 } else if (p - beg == 3 && !memcmp(beg, "off", p - beg)) {
3887 val = 0;
3888 } else {
3889 monitor_printf(mon, "Expected 'on' or 'off'\n");
3890 goto fail;
3891 }
3892 qdict_put(qdict, key, qbool_from_int(val));
3893 }
3894 break;
bellard9307c4c2004-04-04 12:57:25 +00003895 case '-':
3896 {
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02003897 const char *tmp = p;
Luiz Capitulinoeb159d12010-05-28 15:25:24 -03003898 int skip_key = 0;
bellard9307c4c2004-04-04 12:57:25 +00003899 /* option */
ths3b46e622007-09-17 08:09:54 +00003900
bellard9307c4c2004-04-04 12:57:25 +00003901 c = *typestr++;
3902 if (c == '\0')
3903 goto bad_type;
blueswir1cd390082008-11-16 13:53:32 +00003904 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00003905 p++;
bellard9307c4c2004-04-04 12:57:25 +00003906 if (*p == '-') {
3907 p++;
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02003908 if(c != *p) {
3909 if(!is_valid_option(p, typestr)) {
3910
3911 monitor_printf(mon, "%s: unsupported option -%c\n",
3912 cmdname, *p);
3913 goto fail;
3914 } else {
3915 skip_key = 1;
3916 }
bellard9307c4c2004-04-04 12:57:25 +00003917 }
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02003918 if(skip_key) {
3919 p = tmp;
3920 } else {
Luiz Capitulinoeb159d12010-05-28 15:25:24 -03003921 /* has option */
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02003922 p++;
Luiz Capitulinoeb159d12010-05-28 15:25:24 -03003923 qdict_put(qdict, key, qbool_from_int(1));
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02003924 }
bellard9307c4c2004-04-04 12:57:25 +00003925 }
bellard9307c4c2004-04-04 12:57:25 +00003926 }
3927 break;
3928 default:
3929 bad_type:
aliguori376253e2009-03-05 23:01:23 +00003930 monitor_printf(mon, "%s: unknown type '%c'\n", cmdname, c);
bellard9307c4c2004-04-04 12:57:25 +00003931 goto fail;
3932 }
Anthony Liguori7267c092011-08-20 22:09:37 -05003933 g_free(key);
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003934 key = NULL;
bellard9307c4c2004-04-04 12:57:25 +00003935 }
3936 /* check that all arguments were parsed */
blueswir1cd390082008-11-16 13:53:32 +00003937 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00003938 p++;
3939 if (*p != '\0') {
aliguori376253e2009-03-05 23:01:23 +00003940 monitor_printf(mon, "%s: extraneous characters at the end of line\n",
3941 cmdname);
bellard9307c4c2004-04-04 12:57:25 +00003942 goto fail;
3943 }
3944
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003945 return cmd;
Gerd Hoffmannac7531e2009-08-14 10:36:06 +02003946
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003947fail:
Anthony Liguori7267c092011-08-20 22:09:37 -05003948 g_free(key);
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003949 return NULL;
3950}
3951
Markus Armbrusterd6f46832010-02-17 10:52:26 +01003952void monitor_set_error(Monitor *mon, QError *qerror)
3953{
3954 /* report only the first error */
3955 if (!mon->error) {
3956 mon->error = qerror;
3957 } else {
Markus Armbrusterd6f46832010-02-17 10:52:26 +01003958 QDECREF(qerror);
3959 }
3960}
3961
Luiz Capitulinobb89c2e2010-02-10 23:50:05 -02003962static void handler_audit(Monitor *mon, const mon_cmd_t *cmd, int ret)
3963{
Luiz Capitulino6d441432010-11-22 16:35:09 -02003964 if (ret && !monitor_has_error(mon)) {
3965 /*
3966 * If it returns failure, it must have passed on error.
3967 *
3968 * Action: Report an internal error to the client if in QMP.
3969 */
3970 qerror_report(QERR_UNDEFINED_ERROR);
Luiz Capitulino6d441432010-11-22 16:35:09 -02003971 }
Luiz Capitulinobb89c2e2010-02-10 23:50:05 -02003972}
3973
Luiz Capitulinof3c157c2009-11-26 22:58:55 -02003974static void handle_user_command(Monitor *mon, const char *cmdline)
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003975{
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003976 QDict *qdict;
Anthony Liguoric227f092009-10-01 16:12:16 -05003977 const mon_cmd_t *cmd;
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003978
3979 qdict = qdict_new();
3980
Wenchao Xia5f3d3352013-01-14 14:06:27 +08003981 cmd = monitor_parse_command(mon, cmdline, 0, mon_cmds, qdict);
Luiz Capitulino13917be2009-10-07 13:41:54 -03003982 if (!cmd)
3983 goto out;
3984
Luiz Capitulino4903de02010-09-16 11:01:32 -03003985 if (handler_is_async(cmd)) {
Adam Litke940cc302010-01-25 12:18:44 -06003986 user_async_cmd_handler(mon, cmd, qdict);
Luiz Capitulino9e807212010-09-16 10:58:59 -03003987 } else if (handler_is_qobject(cmd)) {
Luiz Capitulinode79ba62010-09-16 11:06:11 -03003988 QObject *data = NULL;
3989
3990 /* XXX: ignores the error code */
3991 cmd->mhandler.cmd_new(mon, qdict, &data);
3992 assert(!monitor_has_error(mon));
3993 if (data) {
3994 cmd->user_print(mon, data);
3995 qobject_decref(data);
3996 }
Luiz Capitulino13917be2009-10-07 13:41:54 -03003997 } else {
Luiz Capitulinoaf4ce882009-10-07 13:41:52 -03003998 cmd->mhandler.cmd(mon, qdict);
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003999 }
4000
Luiz Capitulino13917be2009-10-07 13:41:54 -03004001out:
Luiz Capitulinof7188bb2009-08-28 15:27:10 -03004002 QDECREF(qdict);
bellard9dc39cb2004-03-14 21:38:27 +00004003}
4004
bellard81d09122004-07-14 17:21:37 +00004005static void cmd_completion(const char *name, const char *list)
4006{
4007 const char *p, *pstart;
4008 char cmd[128];
4009 int len;
4010
4011 p = list;
4012 for(;;) {
4013 pstart = p;
4014 p = strchr(p, '|');
4015 if (!p)
4016 p = pstart + strlen(pstart);
4017 len = p - pstart;
4018 if (len > sizeof(cmd) - 2)
4019 len = sizeof(cmd) - 2;
4020 memcpy(cmd, pstart, len);
4021 cmd[len] = '\0';
4022 if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
aliguori731b0362009-03-05 23:01:42 +00004023 readline_add_completion(cur_mon->rs, cmd);
bellard81d09122004-07-14 17:21:37 +00004024 }
4025 if (*p == '\0')
4026 break;
4027 p++;
4028 }
4029}
4030
4031static void file_completion(const char *input)
4032{
4033 DIR *ffs;
4034 struct dirent *d;
4035 char path[1024];
4036 char file[1024], file_prefix[1024];
4037 int input_path_len;
4038 const char *p;
4039
ths5fafdf22007-09-16 21:08:06 +00004040 p = strrchr(input, '/');
bellard81d09122004-07-14 17:21:37 +00004041 if (!p) {
4042 input_path_len = 0;
4043 pstrcpy(file_prefix, sizeof(file_prefix), input);
blueswir1363a37d2008-08-21 17:58:08 +00004044 pstrcpy(path, sizeof(path), ".");
bellard81d09122004-07-14 17:21:37 +00004045 } else {
4046 input_path_len = p - input + 1;
4047 memcpy(path, input, input_path_len);
4048 if (input_path_len > sizeof(path) - 1)
4049 input_path_len = sizeof(path) - 1;
4050 path[input_path_len] = '\0';
4051 pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
4052 }
4053#ifdef DEBUG_COMPLETION
aliguori376253e2009-03-05 23:01:23 +00004054 monitor_printf(cur_mon, "input='%s' path='%s' prefix='%s'\n",
4055 input, path, file_prefix);
bellard81d09122004-07-14 17:21:37 +00004056#endif
4057 ffs = opendir(path);
4058 if (!ffs)
4059 return;
4060 for(;;) {
4061 struct stat sb;
4062 d = readdir(ffs);
4063 if (!d)
4064 break;
Kusanagi Kouichi46c7fc12010-10-20 18:00:01 +09004065
4066 if (strcmp(d->d_name, ".") == 0 || strcmp(d->d_name, "..") == 0) {
4067 continue;
4068 }
4069
bellard81d09122004-07-14 17:21:37 +00004070 if (strstart(d->d_name, file_prefix, NULL)) {
4071 memcpy(file, input, input_path_len);
blueswir1363a37d2008-08-21 17:58:08 +00004072 if (input_path_len < sizeof(file))
4073 pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
4074 d->d_name);
bellard81d09122004-07-14 17:21:37 +00004075 /* stat the file to find out if it's a directory.
4076 * In that case add a slash to speed up typing long paths
4077 */
Markus Armbrusterc951d9a2011-11-16 15:43:47 +01004078 if (stat(file, &sb) == 0 && S_ISDIR(sb.st_mode)) {
blueswir1363a37d2008-08-21 17:58:08 +00004079 pstrcat(file, sizeof(file), "/");
Markus Armbrusterc951d9a2011-11-16 15:43:47 +01004080 }
aliguori731b0362009-03-05 23:01:42 +00004081 readline_add_completion(cur_mon->rs, file);
bellard81d09122004-07-14 17:21:37 +00004082 }
4083 }
4084 closedir(ffs);
4085}
4086
aliguori51de9762009-03-05 23:00:43 +00004087static void block_completion_it(void *opaque, BlockDriverState *bs)
bellard81d09122004-07-14 17:21:37 +00004088{
aliguori51de9762009-03-05 23:00:43 +00004089 const char *name = bdrv_get_device_name(bs);
bellard81d09122004-07-14 17:21:37 +00004090 const char *input = opaque;
4091
4092 if (input[0] == '\0' ||
4093 !strncmp(name, (char *)input, strlen(input))) {
aliguori731b0362009-03-05 23:01:42 +00004094 readline_add_completion(cur_mon->rs, name);
bellard81d09122004-07-14 17:21:37 +00004095 }
4096}
4097
4098/* NOTE: this parser is an approximate form of the real command parser */
4099static void parse_cmdline(const char *cmdline,
4100 int *pnb_args, char **args)
4101{
4102 const char *p;
4103 int nb_args, ret;
4104 char buf[1024];
4105
4106 p = cmdline;
4107 nb_args = 0;
4108 for(;;) {
blueswir1cd390082008-11-16 13:53:32 +00004109 while (qemu_isspace(*p))
bellard81d09122004-07-14 17:21:37 +00004110 p++;
4111 if (*p == '\0')
4112 break;
4113 if (nb_args >= MAX_ARGS)
4114 break;
4115 ret = get_str(buf, sizeof(buf), &p);
Anthony Liguori7267c092011-08-20 22:09:37 -05004116 args[nb_args] = g_strdup(buf);
bellard81d09122004-07-14 17:21:37 +00004117 nb_args++;
4118 if (ret < 0)
4119 break;
4120 }
4121 *pnb_args = nb_args;
4122}
4123
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03004124static const char *next_arg_type(const char *typestr)
4125{
4126 const char *p = strchr(typestr, ':');
4127 return (p != NULL ? ++p : typestr);
4128}
4129
aliguori4c36ba32009-03-05 23:01:37 +00004130static void monitor_find_completion(const char *cmdline)
bellard81d09122004-07-14 17:21:37 +00004131{
4132 const char *cmdname;
4133 char *args[MAX_ARGS];
4134 int nb_args, i, len;
4135 const char *ptype, *str;
Anthony Liguoric227f092009-10-01 16:12:16 -05004136 const mon_cmd_t *cmd;
bellard81d09122004-07-14 17:21:37 +00004137
4138 parse_cmdline(cmdline, &nb_args, args);
4139#ifdef DEBUG_COMPLETION
4140 for(i = 0; i < nb_args; i++) {
aliguori376253e2009-03-05 23:01:23 +00004141 monitor_printf(cur_mon, "arg%d = '%s'\n", i, (char *)args[i]);
bellard81d09122004-07-14 17:21:37 +00004142 }
4143#endif
4144
4145 /* if the line ends with a space, it means we want to complete the
4146 next arg */
4147 len = strlen(cmdline);
blueswir1cd390082008-11-16 13:53:32 +00004148 if (len > 0 && qemu_isspace(cmdline[len - 1])) {
Jan Kiszka03a63482010-06-16 00:38:33 +02004149 if (nb_args >= MAX_ARGS) {
4150 goto cleanup;
4151 }
Anthony Liguori7267c092011-08-20 22:09:37 -05004152 args[nb_args++] = g_strdup("");
bellard81d09122004-07-14 17:21:37 +00004153 }
4154 if (nb_args <= 1) {
4155 /* command completion */
4156 if (nb_args == 0)
4157 cmdname = "";
4158 else
4159 cmdname = args[0];
aliguori731b0362009-03-05 23:01:42 +00004160 readline_set_completion_index(cur_mon->rs, strlen(cmdname));
aliguori376253e2009-03-05 23:01:23 +00004161 for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
bellard81d09122004-07-14 17:21:37 +00004162 cmd_completion(cmdname, cmd->name);
4163 }
4164 } else {
4165 /* find the command */
Jan Kiszka03a63482010-06-16 00:38:33 +02004166 for (cmd = mon_cmds; cmd->name != NULL; cmd++) {
4167 if (compare_cmd(args[0], cmd->name)) {
4168 break;
4169 }
bellard81d09122004-07-14 17:21:37 +00004170 }
Jan Kiszka03a63482010-06-16 00:38:33 +02004171 if (!cmd->name) {
4172 goto cleanup;
4173 }
4174
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03004175 ptype = next_arg_type(cmd->args_type);
bellard81d09122004-07-14 17:21:37 +00004176 for(i = 0; i < nb_args - 2; i++) {
4177 if (*ptype != '\0') {
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03004178 ptype = next_arg_type(ptype);
bellard81d09122004-07-14 17:21:37 +00004179 while (*ptype == '?')
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03004180 ptype = next_arg_type(ptype);
bellard81d09122004-07-14 17:21:37 +00004181 }
4182 }
4183 str = args[nb_args - 1];
Blue Swirl2a1704a2009-08-23 20:10:28 +00004184 if (*ptype == '-' && ptype[1] != '\0') {
Jan Kiszka3b6dbf22010-06-16 00:38:34 +02004185 ptype = next_arg_type(ptype);
Blue Swirl2a1704a2009-08-23 20:10:28 +00004186 }
bellard81d09122004-07-14 17:21:37 +00004187 switch(*ptype) {
4188 case 'F':
4189 /* file completion */
aliguori731b0362009-03-05 23:01:42 +00004190 readline_set_completion_index(cur_mon->rs, strlen(str));
bellard81d09122004-07-14 17:21:37 +00004191 file_completion(str);
4192 break;
4193 case 'B':
4194 /* block device name completion */
aliguori731b0362009-03-05 23:01:42 +00004195 readline_set_completion_index(cur_mon->rs, strlen(str));
bellard81d09122004-07-14 17:21:37 +00004196 bdrv_iterate(block_completion_it, (void *)str);
4197 break;
bellard7fe48482004-10-09 18:08:01 +00004198 case 's':
4199 /* XXX: more generic ? */
4200 if (!strcmp(cmd->name, "info")) {
aliguori731b0362009-03-05 23:01:42 +00004201 readline_set_completion_index(cur_mon->rs, strlen(str));
bellard7fe48482004-10-09 18:08:01 +00004202 for(cmd = info_cmds; cmd->name != NULL; cmd++) {
4203 cmd_completion(str, cmd->name);
4204 }
bellard64866c32006-05-07 18:03:31 +00004205 } else if (!strcmp(cmd->name, "sendkey")) {
blueswir1e600d1e2009-03-08 17:42:02 +00004206 char *sep = strrchr(str, '-');
4207 if (sep)
4208 str = sep + 1;
aliguori731b0362009-03-05 23:01:42 +00004209 readline_set_completion_index(cur_mon->rs, strlen(str));
Amos Kong1048c882012-08-31 10:56:25 +08004210 for (i = 0; i < Q_KEY_CODE_MAX; i++) {
4211 cmd_completion(str, QKeyCode_lookup[i]);
bellard64866c32006-05-07 18:03:31 +00004212 }
Jan Kiszkaf3353c62009-06-25 08:22:02 +02004213 } else if (!strcmp(cmd->name, "help|?")) {
4214 readline_set_completion_index(cur_mon->rs, strlen(str));
4215 for (cmd = mon_cmds; cmd->name != NULL; cmd++) {
4216 cmd_completion(str, cmd->name);
4217 }
bellard7fe48482004-10-09 18:08:01 +00004218 }
4219 break;
bellard81d09122004-07-14 17:21:37 +00004220 default:
4221 break;
4222 }
4223 }
Jan Kiszka03a63482010-06-16 00:38:33 +02004224
4225cleanup:
4226 for (i = 0; i < nb_args; i++) {
Anthony Liguori7267c092011-08-20 22:09:37 -05004227 g_free(args[i]);
Jan Kiszka03a63482010-06-16 00:38:33 +02004228 }
bellard81d09122004-07-14 17:21:37 +00004229}
4230
aliguori731b0362009-03-05 23:01:42 +00004231static int monitor_can_read(void *opaque)
bellard9dc39cb2004-03-14 21:38:27 +00004232{
aliguori731b0362009-03-05 23:01:42 +00004233 Monitor *mon = opaque;
4234
Jan Kiszkac62313b2009-12-04 14:05:29 +01004235 return (mon->suspend_cnt == 0) ? 1 : 0;
bellard9dc39cb2004-03-14 21:38:27 +00004236}
4237
Luiz Capitulino09069b12010-02-04 18:10:06 -02004238static int invalid_qmp_mode(const Monitor *mon, const char *cmd_name)
4239{
4240 int is_cap = compare_cmd(cmd_name, "qmp_capabilities");
4241 return (qmp_cmd_mode(mon) ? is_cap : !is_cap);
4242}
4243
Luiz Capitulino2dbc8db2010-05-26 16:13:09 -03004244/*
Luiz Capitulino4af91932010-06-22 11:44:05 -03004245 * Argument validation rules:
4246 *
4247 * 1. The argument must exist in cmd_args qdict
4248 * 2. The argument type must be the expected one
4249 *
4250 * Special case: If the argument doesn't exist in cmd_args and
4251 * the QMP_ACCEPT_UNKNOWNS flag is set, then the
4252 * checking is skipped for it.
4253 */
4254static int check_client_args_type(const QDict *client_args,
4255 const QDict *cmd_args, int flags)
4256{
4257 const QDictEntry *ent;
4258
4259 for (ent = qdict_first(client_args); ent;ent = qdict_next(client_args,ent)){
4260 QObject *obj;
4261 QString *arg_type;
4262 const QObject *client_arg = qdict_entry_value(ent);
4263 const char *client_arg_name = qdict_entry_key(ent);
4264
4265 obj = qdict_get(cmd_args, client_arg_name);
4266 if (!obj) {
4267 if (flags & QMP_ACCEPT_UNKNOWNS) {
4268 /* handler accepts unknowns */
4269 continue;
4270 }
4271 /* client arg doesn't exist */
4272 qerror_report(QERR_INVALID_PARAMETER, client_arg_name);
4273 return -1;
4274 }
4275
4276 arg_type = qobject_to_qstring(obj);
4277 assert(arg_type != NULL);
4278
4279 /* check if argument's type is correct */
4280 switch (qstring_get_str(arg_type)[0]) {
4281 case 'F':
4282 case 'B':
4283 case 's':
4284 if (qobject_type(client_arg) != QTYPE_QSTRING) {
4285 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4286 "string");
4287 return -1;
4288 }
4289 break;
4290 case 'i':
4291 case 'l':
4292 case 'M':
Jes Sorensendbc0c672010-10-21 17:15:47 +02004293 case 'o':
Luiz Capitulino4af91932010-06-22 11:44:05 -03004294 if (qobject_type(client_arg) != QTYPE_QINT) {
4295 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4296 "int");
4297 return -1;
4298 }
4299 break;
Luiz Capitulino4af91932010-06-22 11:44:05 -03004300 case 'T':
4301 if (qobject_type(client_arg) != QTYPE_QINT &&
4302 qobject_type(client_arg) != QTYPE_QFLOAT) {
4303 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4304 "number");
4305 return -1;
4306 }
4307 break;
4308 case 'b':
4309 case '-':
4310 if (qobject_type(client_arg) != QTYPE_QBOOL) {
4311 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4312 "bool");
4313 return -1;
4314 }
4315 break;
4316 case 'O':
4317 assert(flags & QMP_ACCEPT_UNKNOWNS);
4318 break;
Paolo Bonzinib9f89782012-03-22 12:51:11 +01004319 case 'q':
4320 /* Any QObject can be passed. */
4321 break;
Luiz Capitulino4af91932010-06-22 11:44:05 -03004322 case '/':
4323 case '.':
4324 /*
4325 * These types are not supported by QMP and thus are not
4326 * handled here. Fall through.
4327 */
4328 default:
4329 abort();
4330 }
4331 }
4332
4333 return 0;
4334}
4335
4336/*
Luiz Capitulino2dbc8db2010-05-26 16:13:09 -03004337 * - Check if the client has passed all mandatory args
4338 * - Set special flags for argument validation
4339 */
4340static int check_mandatory_args(const QDict *cmd_args,
4341 const QDict *client_args, int *flags)
4342{
4343 const QDictEntry *ent;
4344
4345 for (ent = qdict_first(cmd_args); ent; ent = qdict_next(cmd_args, ent)) {
4346 const char *cmd_arg_name = qdict_entry_key(ent);
4347 QString *type = qobject_to_qstring(qdict_entry_value(ent));
4348 assert(type != NULL);
4349
4350 if (qstring_get_str(type)[0] == 'O') {
4351 assert((*flags & QMP_ACCEPT_UNKNOWNS) == 0);
4352 *flags |= QMP_ACCEPT_UNKNOWNS;
4353 } else if (qstring_get_str(type)[0] != '-' &&
4354 qstring_get_str(type)[1] != '?' &&
4355 !qdict_haskey(client_args, cmd_arg_name)) {
4356 qerror_report(QERR_MISSING_PARAMETER, cmd_arg_name);
4357 return -1;
4358 }
4359 }
4360
4361 return 0;
4362}
4363
4364static QDict *qdict_from_args_type(const char *args_type)
4365{
4366 int i;
4367 QDict *qdict;
4368 QString *key, *type, *cur_qs;
4369
4370 assert(args_type != NULL);
4371
4372 qdict = qdict_new();
4373
4374 if (args_type == NULL || args_type[0] == '\0') {
4375 /* no args, empty qdict */
4376 goto out;
4377 }
4378
4379 key = qstring_new();
4380 type = qstring_new();
4381
4382 cur_qs = key;
4383
4384 for (i = 0;; i++) {
4385 switch (args_type[i]) {
4386 case ',':
4387 case '\0':
4388 qdict_put(qdict, qstring_get_str(key), type);
4389 QDECREF(key);
4390 if (args_type[i] == '\0') {
4391 goto out;
4392 }
4393 type = qstring_new(); /* qdict has ref */
4394 cur_qs = key = qstring_new();
4395 break;
4396 case ':':
4397 cur_qs = type;
4398 break;
4399 default:
4400 qstring_append_chr(cur_qs, args_type[i]);
4401 break;
4402 }
4403 }
4404
4405out:
4406 return qdict;
4407}
4408
4409/*
4410 * Client argument checking rules:
4411 *
4412 * 1. Client must provide all mandatory arguments
Luiz Capitulino4af91932010-06-22 11:44:05 -03004413 * 2. Each argument provided by the client must be expected
4414 * 3. Each argument provided by the client must have the type expected
4415 * by the command
Luiz Capitulino2dbc8db2010-05-26 16:13:09 -03004416 */
4417static int qmp_check_client_args(const mon_cmd_t *cmd, QDict *client_args)
4418{
4419 int flags, err;
4420 QDict *cmd_args;
4421
4422 cmd_args = qdict_from_args_type(cmd->args_type);
4423
4424 flags = 0;
4425 err = check_mandatory_args(cmd_args, client_args, &flags);
4426 if (err) {
4427 goto out;
4428 }
4429
Luiz Capitulino4af91932010-06-22 11:44:05 -03004430 err = check_client_args_type(client_args, cmd_args, flags);
Luiz Capitulino2dbc8db2010-05-26 16:13:09 -03004431
4432out:
4433 QDECREF(cmd_args);
4434 return err;
4435}
4436
Luiz Capitulinoc917c8f2010-05-31 17:28:01 -03004437/*
4438 * Input object checking rules
4439 *
4440 * 1. Input object must be a dict
4441 * 2. The "execute" key must exist
4442 * 3. The "execute" key must be a string
4443 * 4. If the "arguments" key exists, it must be a dict
4444 * 5. If the "id" key exists, it can be anything (ie. json-value)
4445 * 6. Any argument not listed above is considered invalid
4446 */
4447static QDict *qmp_check_input_obj(QObject *input_obj)
4448{
4449 const QDictEntry *ent;
4450 int has_exec_key = 0;
4451 QDict *input_dict;
4452
4453 if (qobject_type(input_obj) != QTYPE_QDICT) {
4454 qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "object");
4455 return NULL;
4456 }
4457
4458 input_dict = qobject_to_qdict(input_obj);
4459
4460 for (ent = qdict_first(input_dict); ent; ent = qdict_next(input_dict, ent)){
4461 const char *arg_name = qdict_entry_key(ent);
4462 const QObject *arg_obj = qdict_entry_value(ent);
4463
4464 if (!strcmp(arg_name, "execute")) {
4465 if (qobject_type(arg_obj) != QTYPE_QSTRING) {
4466 qerror_report(QERR_QMP_BAD_INPUT_OBJECT_MEMBER, "execute",
4467 "string");
4468 return NULL;
4469 }
4470 has_exec_key = 1;
4471 } else if (!strcmp(arg_name, "arguments")) {
4472 if (qobject_type(arg_obj) != QTYPE_QDICT) {
4473 qerror_report(QERR_QMP_BAD_INPUT_OBJECT_MEMBER, "arguments",
4474 "object");
4475 return NULL;
4476 }
4477 } else if (!strcmp(arg_name, "id")) {
4478 /* FIXME: check duplicated IDs for async commands */
4479 } else {
4480 qerror_report(QERR_QMP_EXTRA_MEMBER, arg_name);
4481 return NULL;
4482 }
4483 }
4484
4485 if (!has_exec_key) {
4486 qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "execute");
4487 return NULL;
4488 }
4489
4490 return input_dict;
4491}
4492
Luiz Capitulinofc29df72010-09-16 11:11:18 -03004493static void qmp_call_cmd(Monitor *mon, const mon_cmd_t *cmd,
4494 const QDict *params)
4495{
4496 int ret;
4497 QObject *data = NULL;
4498
Luiz Capitulinofc29df72010-09-16 11:11:18 -03004499 ret = cmd->mhandler.cmd_new(mon, params, &data);
4500 handler_audit(mon, cmd, ret);
4501 monitor_protocol_emitter(mon, data);
4502 qobject_decref(data);
4503}
4504
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004505static void handle_qmp_command(JSONMessageParser *parser, QList *tokens)
4506{
4507 int err;
4508 QObject *obj;
4509 QDict *input, *args;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004510 const mon_cmd_t *cmd;
Luiz Capitulino40e5a012011-10-21 16:15:31 -02004511 const char *cmd_name;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004512 Monitor *mon = cur_mon;
4513
Luiz Capitulinoe4940c62010-06-24 17:58:20 -03004514 args = input = NULL;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004515
4516 obj = json_parser_parse(tokens, NULL);
4517 if (!obj) {
4518 // FIXME: should be triggered in json_parser_parse()
Markus Armbrusterab5b0272010-03-02 18:15:09 +01004519 qerror_report(QERR_JSON_PARSING);
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004520 goto err_out;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004521 }
4522
Luiz Capitulinoc917c8f2010-05-31 17:28:01 -03004523 input = qmp_check_input_obj(obj);
4524 if (!input) {
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004525 qobject_decref(obj);
4526 goto err_out;
4527 }
4528
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004529 mon->mc->id = qdict_get(input, "id");
4530 qobject_incref(mon->mc->id);
4531
Luiz Capitulino0bbab462010-05-31 17:32:50 -03004532 cmd_name = qdict_get_str(input, "execute");
Stefan Hajnoczi89bd8202011-09-23 08:23:06 +01004533 trace_handle_qmp_command(mon, cmd_name);
Luiz Capitulino09069b12010-02-04 18:10:06 -02004534 if (invalid_qmp_mode(mon, cmd_name)) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01004535 qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);
Luiz Capitulinoe4940c62010-06-24 17:58:20 -03004536 goto err_out;
Luiz Capitulino09069b12010-02-04 18:10:06 -02004537 }
4538
Anthony Liguorie3193602011-09-02 12:34:47 -05004539 cmd = qmp_find_cmd(cmd_name);
Luiz Capitulinod1249ea2010-09-13 14:44:27 -03004540 if (!cmd) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01004541 qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);
Luiz Capitulinoe4940c62010-06-24 17:58:20 -03004542 goto err_out;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004543 }
4544
4545 obj = qdict_get(input, "arguments");
4546 if (!obj) {
4547 args = qdict_new();
4548 } else {
4549 args = qobject_to_qdict(obj);
4550 QINCREF(args);
4551 }
4552
Luiz Capitulino2dbc8db2010-05-26 16:13:09 -03004553 err = qmp_check_client_args(cmd, args);
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004554 if (err < 0) {
4555 goto err_out;
4556 }
4557
Luiz Capitulino40e5a012011-10-21 16:15:31 -02004558 if (handler_is_async(cmd)) {
Luiz Capitulino5af7bba2010-06-22 19:10:46 -03004559 err = qmp_async_cmd_handler(mon, cmd, args);
4560 if (err) {
4561 /* emit the error response */
4562 goto err_out;
4563 }
Adam Litke940cc302010-01-25 12:18:44 -06004564 } else {
Luiz Capitulinofc29df72010-09-16 11:11:18 -03004565 qmp_call_cmd(mon, cmd, args);
Adam Litke940cc302010-01-25 12:18:44 -06004566 }
Luiz Capitulinoe4940c62010-06-24 17:58:20 -03004567
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004568 goto out;
4569
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004570err_out:
4571 monitor_protocol_emitter(mon, NULL);
4572out:
Luiz Capitulinoe4940c62010-06-24 17:58:20 -03004573 QDECREF(input);
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004574 QDECREF(args);
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004575}
4576
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004577/**
4578 * monitor_control_read(): Read and handle QMP input
4579 */
4580static void monitor_control_read(void *opaque, const uint8_t *buf, int size)
4581{
4582 Monitor *old_mon = cur_mon;
4583
4584 cur_mon = opaque;
4585
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004586 json_message_parser_feed(&cur_mon->mc->parser, (const char *) buf, size);
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004587
4588 cur_mon = old_mon;
4589}
4590
aliguori731b0362009-03-05 23:01:42 +00004591static void monitor_read(void *opaque, const uint8_t *buf, int size)
bellard9dc39cb2004-03-14 21:38:27 +00004592{
aliguori731b0362009-03-05 23:01:42 +00004593 Monitor *old_mon = cur_mon;
bellard9dc39cb2004-03-14 21:38:27 +00004594 int i;
aliguori376253e2009-03-05 23:01:23 +00004595
aliguori731b0362009-03-05 23:01:42 +00004596 cur_mon = opaque;
bellard7e2515e2004-08-01 21:52:19 +00004597
aliguoricde76ee2009-03-05 23:01:51 +00004598 if (cur_mon->rs) {
4599 for (i = 0; i < size; i++)
4600 readline_handle_byte(cur_mon->rs, buf[i]);
4601 } else {
4602 if (size == 0 || buf[size - 1] != 0)
4603 monitor_printf(cur_mon, "corrupted command\n");
4604 else
Luiz Capitulinof3c157c2009-11-26 22:58:55 -02004605 handle_user_command(cur_mon, (char *)buf);
aliguoricde76ee2009-03-05 23:01:51 +00004606 }
aliguori731b0362009-03-05 23:01:42 +00004607
4608 cur_mon = old_mon;
4609}
aliguorid8f44602008-10-06 13:52:44 +00004610
aliguori376253e2009-03-05 23:01:23 +00004611static void monitor_command_cb(Monitor *mon, const char *cmdline, void *opaque)
bellard7e2515e2004-08-01 21:52:19 +00004612{
aliguori731b0362009-03-05 23:01:42 +00004613 monitor_suspend(mon);
Luiz Capitulinof3c157c2009-11-26 22:58:55 -02004614 handle_user_command(mon, cmdline);
aliguori731b0362009-03-05 23:01:42 +00004615 monitor_resume(mon);
aliguorid8f44602008-10-06 13:52:44 +00004616}
4617
aliguoricde76ee2009-03-05 23:01:51 +00004618int monitor_suspend(Monitor *mon)
aliguorid8f44602008-10-06 13:52:44 +00004619{
aliguoricde76ee2009-03-05 23:01:51 +00004620 if (!mon->rs)
4621 return -ENOTTY;
aliguori731b0362009-03-05 23:01:42 +00004622 mon->suspend_cnt++;
aliguoricde76ee2009-03-05 23:01:51 +00004623 return 0;
aliguorid8f44602008-10-06 13:52:44 +00004624}
4625
aliguori376253e2009-03-05 23:01:23 +00004626void monitor_resume(Monitor *mon)
aliguorid8f44602008-10-06 13:52:44 +00004627{
aliguoricde76ee2009-03-05 23:01:51 +00004628 if (!mon->rs)
4629 return;
aliguori731b0362009-03-05 23:01:42 +00004630 if (--mon->suspend_cnt == 0)
4631 readline_show_prompt(mon->rs);
bellard7e2515e2004-08-01 21:52:19 +00004632}
4633
Luiz Capitulinoca9567e2010-02-04 18:10:04 -02004634static QObject *get_qmp_greeting(void)
4635{
Luiz Capitulinob9c15f12011-08-26 17:38:13 -03004636 QObject *ver = NULL;
Luiz Capitulinoca9567e2010-02-04 18:10:04 -02004637
Luiz Capitulinob9c15f12011-08-26 17:38:13 -03004638 qmp_marshal_input_query_version(NULL, NULL, &ver);
Luiz Capitulinoca9567e2010-02-04 18:10:04 -02004639 return qobject_from_jsonf("{'QMP':{'version': %p,'capabilities': []}}",ver);
4640}
4641
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004642/**
4643 * monitor_control_event(): Print QMP gretting
4644 */
4645static void monitor_control_event(void *opaque, int event)
4646{
Luiz Capitulino47116d12010-02-08 17:01:30 -02004647 QObject *data;
4648 Monitor *mon = opaque;
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004649
Luiz Capitulino47116d12010-02-08 17:01:30 -02004650 switch (event) {
4651 case CHR_EVENT_OPENED:
Luiz Capitulino4a7e1192010-02-04 18:10:05 -02004652 mon->mc->command_mode = 0;
Luiz Capitulinoca9567e2010-02-04 18:10:04 -02004653 data = get_qmp_greeting();
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004654 monitor_json_emitter(mon, data);
4655 qobject_decref(data);
Corey Bryantefb87c12012-08-14 16:43:48 -04004656 mon_refcount++;
Luiz Capitulino47116d12010-02-08 17:01:30 -02004657 break;
4658 case CHR_EVENT_CLOSED:
4659 json_message_parser_destroy(&mon->mc->parser);
Anthony Liguori58617a72012-08-23 08:03:21 -05004660 json_message_parser_init(&mon->mc->parser, handle_qmp_command);
Corey Bryantefb87c12012-08-14 16:43:48 -04004661 mon_refcount--;
4662 monitor_fdsets_cleanup();
Luiz Capitulino47116d12010-02-08 17:01:30 -02004663 break;
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004664 }
4665}
4666
aliguori731b0362009-03-05 23:01:42 +00004667static void monitor_event(void *opaque, int event)
ths86e94de2007-01-05 22:01:59 +00004668{
aliguori376253e2009-03-05 23:01:23 +00004669 Monitor *mon = opaque;
4670
aliguori2724b182009-03-05 23:01:47 +00004671 switch (event) {
4672 case CHR_EVENT_MUX_IN:
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +02004673 mon->mux_out = 0;
4674 if (mon->reset_seen) {
4675 readline_restart(mon->rs);
4676 monitor_resume(mon);
4677 monitor_flush(mon);
4678 } else {
4679 mon->suspend_cnt = 0;
4680 }
aliguori2724b182009-03-05 23:01:47 +00004681 break;
ths86e94de2007-01-05 22:01:59 +00004682
aliguori2724b182009-03-05 23:01:47 +00004683 case CHR_EVENT_MUX_OUT:
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +02004684 if (mon->reset_seen) {
4685 if (mon->suspend_cnt == 0) {
4686 monitor_printf(mon, "\n");
4687 }
4688 monitor_flush(mon);
4689 monitor_suspend(mon);
4690 } else {
4691 mon->suspend_cnt++;
4692 }
4693 mon->mux_out = 1;
aliguori2724b182009-03-05 23:01:47 +00004694 break;
4695
Amit Shahb6b8df52009-10-07 18:31:16 +05304696 case CHR_EVENT_OPENED:
aliguori2724b182009-03-05 23:01:47 +00004697 monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
4698 "information\n", QEMU_VERSION);
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +02004699 if (!mon->mux_out) {
aliguori2724b182009-03-05 23:01:47 +00004700 readline_show_prompt(mon->rs);
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +02004701 }
4702 mon->reset_seen = 1;
Corey Bryantefb87c12012-08-14 16:43:48 -04004703 mon_refcount++;
4704 break;
4705
4706 case CHR_EVENT_CLOSED:
4707 mon_refcount--;
4708 monitor_fdsets_cleanup();
aliguori2724b182009-03-05 23:01:47 +00004709 break;
4710 }
ths86e94de2007-01-05 22:01:59 +00004711}
4712
Wayne Xia816f8922011-10-12 11:32:41 +08004713static int
4714compare_mon_cmd(const void *a, const void *b)
4715{
4716 return strcmp(((const mon_cmd_t *)a)->name,
4717 ((const mon_cmd_t *)b)->name);
4718}
4719
4720static void sortcmdlist(void)
4721{
4722 int array_num;
4723 int elem_size = sizeof(mon_cmd_t);
4724
4725 array_num = sizeof(mon_cmds)/elem_size-1;
4726 qsort((void *)mon_cmds, array_num, elem_size, compare_mon_cmd);
4727
4728 array_num = sizeof(info_cmds)/elem_size-1;
4729 qsort((void *)info_cmds, array_num, elem_size, compare_mon_cmd);
4730}
4731
aliguori76655d62009-03-06 20:27:37 +00004732
4733/*
4734 * Local variables:
4735 * c-indent-level: 4
4736 * c-basic-offset: 4
4737 * tab-width: 8
4738 * End:
4739 */
4740
aliguori731b0362009-03-05 23:01:42 +00004741void monitor_init(CharDriverState *chr, int flags)
bellard9dc39cb2004-03-14 21:38:27 +00004742{
aliguori731b0362009-03-05 23:01:42 +00004743 static int is_first_init = 1;
aliguori87127162009-03-05 23:01:29 +00004744 Monitor *mon;
ths20d8a3e2007-02-18 17:04:49 +00004745
4746 if (is_first_init) {
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +01004747 monitor_protocol_event_init();
ths20d8a3e2007-02-18 17:04:49 +00004748 is_first_init = 0;
4749 }
aliguori87127162009-03-05 23:01:29 +00004750
Anthony Liguori7267c092011-08-20 22:09:37 -05004751 mon = g_malloc0(sizeof(*mon));
ths20d8a3e2007-02-18 17:04:49 +00004752
aliguori87127162009-03-05 23:01:29 +00004753 mon->chr = chr;
aliguori731b0362009-03-05 23:01:42 +00004754 mon->flags = flags;
aliguoricde76ee2009-03-05 23:01:51 +00004755 if (flags & MONITOR_USE_READLINE) {
4756 mon->rs = readline_init(mon, monitor_find_completion);
4757 monitor_read_command(mon, 0);
4758 }
aliguori87127162009-03-05 23:01:29 +00004759
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004760 if (monitor_ctrl_mode(mon)) {
Anthony Liguori7267c092011-08-20 22:09:37 -05004761 mon->mc = g_malloc0(sizeof(MonitorControl));
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004762 /* Control mode requires special handlers */
4763 qemu_chr_add_handlers(chr, monitor_can_read, monitor_control_read,
4764 monitor_control_event, mon);
Anthony Liguori15f31512011-08-15 11:17:35 -05004765 qemu_chr_fe_set_echo(chr, true);
Anthony Liguori26efaca2012-08-23 13:49:02 -05004766
4767 json_message_parser_init(&mon->mc->parser, handle_qmp_command);
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004768 } else {
4769 qemu_chr_add_handlers(chr, monitor_can_read, monitor_read,
4770 monitor_event, mon);
4771 }
aliguori87127162009-03-05 23:01:29 +00004772
Blue Swirl72cf2d42009-09-12 07:36:22 +00004773 QLIST_INSERT_HEAD(&mon_list, mon, entry);
Markus Armbruster8631b602010-02-18 11:41:55 +01004774 if (!default_mon || (flags & MONITOR_IS_DEFAULT))
4775 default_mon = mon;
Wayne Xia816f8922011-10-12 11:32:41 +08004776
4777 sortcmdlist();
bellard7e2515e2004-08-01 21:52:19 +00004778}
4779
aliguori376253e2009-03-05 23:01:23 +00004780static void bdrv_password_cb(Monitor *mon, const char *password, void *opaque)
bellard7e2515e2004-08-01 21:52:19 +00004781{
aliguoribb5fc202009-03-05 23:01:15 +00004782 BlockDriverState *bs = opaque;
4783 int ret = 0;
bellard7e2515e2004-08-01 21:52:19 +00004784
aliguoribb5fc202009-03-05 23:01:15 +00004785 if (bdrv_set_key(bs, password) != 0) {
aliguori376253e2009-03-05 23:01:23 +00004786 monitor_printf(mon, "invalid password\n");
aliguoribb5fc202009-03-05 23:01:15 +00004787 ret = -EPERM;
bellard7e2515e2004-08-01 21:52:19 +00004788 }
aliguori731b0362009-03-05 23:01:42 +00004789 if (mon->password_completion_cb)
4790 mon->password_completion_cb(mon->password_opaque, ret);
aliguoribb5fc202009-03-05 23:01:15 +00004791
aliguori731b0362009-03-05 23:01:42 +00004792 monitor_read_command(mon, 1);
bellard9dc39cb2004-03-14 21:38:27 +00004793}
aliguoric0f4ce72009-03-05 23:01:01 +00004794
Anthony Liguori7060b472011-09-02 12:34:50 -05004795ReadLineState *monitor_get_rs(Monitor *mon)
4796{
4797 return mon->rs;
4798}
4799
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02004800int monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
4801 BlockDriverCompletionFunc *completion_cb,
4802 void *opaque)
aliguoric0f4ce72009-03-05 23:01:01 +00004803{
aliguoricde76ee2009-03-05 23:01:51 +00004804 int err;
4805
aliguoribb5fc202009-03-05 23:01:15 +00004806 if (!bdrv_key_required(bs)) {
4807 if (completion_cb)
4808 completion_cb(opaque, 0);
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02004809 return 0;
aliguoribb5fc202009-03-05 23:01:15 +00004810 }
aliguoric0f4ce72009-03-05 23:01:01 +00004811
Luiz Capitulino94171e12009-12-07 21:37:00 +01004812 if (monitor_ctrl_mode(mon)) {
Luiz Capitulino903a8812011-12-13 17:18:30 -02004813 qerror_report(QERR_DEVICE_ENCRYPTED, bdrv_get_device_name(bs),
4814 bdrv_get_encrypted_filename(bs));
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02004815 return -1;
Luiz Capitulino94171e12009-12-07 21:37:00 +01004816 }
4817
aliguori376253e2009-03-05 23:01:23 +00004818 monitor_printf(mon, "%s (%s) is encrypted.\n", bdrv_get_device_name(bs),
4819 bdrv_get_encrypted_filename(bs));
aliguoribb5fc202009-03-05 23:01:15 +00004820
aliguori731b0362009-03-05 23:01:42 +00004821 mon->password_completion_cb = completion_cb;
4822 mon->password_opaque = opaque;
aliguoribb5fc202009-03-05 23:01:15 +00004823
aliguoricde76ee2009-03-05 23:01:51 +00004824 err = monitor_read_password(mon, bdrv_password_cb, bs);
4825
4826 if (err && completion_cb)
4827 completion_cb(opaque, err);
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02004828
4829 return err;
aliguoric0f4ce72009-03-05 23:01:01 +00004830}
Luiz Capitulinoe42e8182011-11-22 17:58:31 -02004831
4832int monitor_read_block_device_key(Monitor *mon, const char *device,
4833 BlockDriverCompletionFunc *completion_cb,
4834 void *opaque)
4835{
4836 BlockDriverState *bs;
4837
4838 bs = bdrv_find(device);
4839 if (!bs) {
4840 monitor_printf(mon, "Device not found %s\n", device);
4841 return -1;
4842 }
4843
4844 return monitor_read_bdrv_key_start(mon, bs, completion_cb, opaque);
4845}
Paolo Bonzini4d454572012-11-26 16:03:42 +01004846
4847QemuOptsList qemu_mon_opts = {
4848 .name = "mon",
4849 .implied_opt_name = "chardev",
4850 .head = QTAILQ_HEAD_INITIALIZER(qemu_mon_opts.head),
4851 .desc = {
4852 {
4853 .name = "mode",
4854 .type = QEMU_OPT_STRING,
4855 },{
4856 .name = "chardev",
4857 .type = QEMU_OPT_STRING,
4858 },{
4859 .name = "default",
4860 .type = QEMU_OPT_BOOL,
4861 },{
4862 .name = "pretty",
4863 .type = QEMU_OPT_BOOL,
4864 },
4865 { /* end of list */ }
4866 },
4867};