blob: c24235e90917c81f03549baf4a77470943823d4e [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"
Gerd Hoffmanncae49562009-06-05 15:53:17 +010026#include "hw/qdev.h"
pbrook87ecb682007-11-17 17:14:51 +000027#include "hw/usb.h"
28#include "hw/pcmcia.h"
29#include "hw/pc.h"
30#include "hw/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"
pbrook87ecb682007-11-17 17:14:51 +000033#include "gdbstub.h"
34#include "net.h"
Mark McLoughlin68ac40d2009-11-25 18:48:54 +000035#include "net/slirp.h"
pbrook87ecb682007-11-17 17:14:51 +000036#include "qemu-char.h"
Gerd Hoffmann75721502010-10-07 12:22:54 +020037#include "ui/qemu-spice.h"
pbrook87ecb682007-11-17 17:14:51 +000038#include "sysemu.h"
aliguori376253e2009-03-05 23:01:23 +000039#include "monitor.h"
40#include "readline.h"
pbrook87ecb682007-11-17 17:14:51 +000041#include "console.h"
Markus Armbruster666daa62010-06-02 18:48:27 +020042#include "blockdev.h"
pbrook87ecb682007-11-17 17:14:51 +000043#include "audio/audio.h"
bellard9307c4c2004-04-04 12:57:25 +000044#include "disas.h"
aliguoridf751fa2008-12-04 20:19:35 +000045#include "balloon.h"
balrogc8256f92008-06-08 22:45:01 +000046#include "qemu-timer.h"
aliguori5bb79102008-10-13 03:12:02 +000047#include "migration.h"
aliguori7ba1e612008-11-05 16:04:33 +000048#include "kvm.h"
aliguori76655d62009-03-06 20:27:37 +000049#include "acl.h"
Luiz Capitulinof7188bb2009-08-28 15:27:10 -030050#include "qint.h"
Markus Armbruster3350a4d2010-01-25 14:23:03 +010051#include "qfloat.h"
Luiz Capitulino8f3cec02009-10-07 13:42:04 -030052#include "qlist.h"
Luiz Capitulino5fa737a2009-11-26 22:59:01 -020053#include "qbool.h"
Luiz Capitulinof7188bb2009-08-28 15:27:10 -030054#include "qstring.h"
Luiz Capitulino9b57c022009-11-26 22:58:58 -020055#include "qjson.h"
Luiz Capitulino5fa737a2009-11-26 22:59:01 -020056#include "json-streamer.h"
57#include "json-parser.h"
Blue Swirld08d6f02009-12-04 18:06:39 +000058#include "osdep.h"
Blue Swirl2b41f102011-06-19 20:38:22 +000059#include "cpu.h"
Stefan Hajnoczi89bd8202011-09-23 08:23:06 +010060#include "trace.h"
Lluís31965ae2011-08-31 20:31:24 +020061#include "trace/control.h"
Lluís6d8a7642011-08-31 20:30:43 +020062#ifdef CONFIG_TRACE_SIMPLE
Lluís31965ae2011-08-31 20:31:24 +020063#include "trace/simple.h"
Prerna Saxena22890ab2010-06-24 17:04:53 +053064#endif
Gerd Hoffmann6f8c63f2010-10-11 18:03:51 +020065#include "ui/qemu-spice.h"
Blue Swirl314e2982011-09-11 20:22:05 +000066#include "memory.h"
Anthony Liguori48a32be2011-09-02 12:34:48 -050067#include "qmp-commands.h"
68#include "hmp.h"
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +010069#include "qemu-thread.h"
ths6a5bd302007-12-03 17:05:38 +000070
Jan Kiszka661f1922011-10-16 11:53:13 +020071/* for pic/irq_info */
72#if defined(TARGET_SPARC)
73#include "hw/sun4m.h"
74#endif
75#include "hw/lm32_pic.h"
76
bellard9dc39cb2004-03-14 21:38:27 +000077//#define DEBUG
bellard81d09122004-07-14 17:21:37 +000078//#define DEBUG_COMPLETION
bellard9dc39cb2004-03-14 21:38:27 +000079
bellard9307c4c2004-04-04 12:57:25 +000080/*
81 * Supported types:
ths5fafdf22007-09-16 21:08:06 +000082 *
bellard9307c4c2004-04-04 12:57:25 +000083 * 'F' filename
bellard81d09122004-07-14 17:21:37 +000084 * 'B' block device name
bellard9307c4c2004-04-04 12:57:25 +000085 * 's' string (accept optional quote)
Markus Armbruster361127d2010-02-10 20:24:35 +010086 * 'O' option string of the form NAME=VALUE,...
87 * parsed according to QemuOptsList given by its name
88 * Example: 'device:O' uses qemu_device_opts.
89 * Restriction: only lists with empty desc are supported
90 * TODO lift the restriction
bellard92a31b12005-02-10 22:00:52 +000091 * 'i' 32 bit integer
92 * 'l' target long (32 or 64 bit)
Luiz Capitulino91162842012-04-26 17:34:30 -030093 * 'M' Non-negative target long (32 or 64 bit), in user mode the
94 * value is multiplied by 2^20 (think Mebibyte)
Jes Sorensendbc0c672010-10-21 17:15:47 +020095 * 'o' octets (aka bytes)
96 * user mode accepts an optional T, t, G, g, M, m, K, k
97 * suffix, which multiplies the value by 2^40 for
98 * suffixes T and t, 2^30 for suffixes G and g, 2^20 for
99 * M and m, 2^10 for K and k
Markus Armbrusterfccfb11e2010-01-25 14:23:06 +0100100 * 'T' double
101 * user mode accepts an optional ms, us, ns suffix,
102 * which divides the value by 1e3, 1e6, 1e9, respectively
bellard9307c4c2004-04-04 12:57:25 +0000103 * '/' optional gdb-like print format (like "/10x")
104 *
Luiz Capitulinofb466602009-08-28 15:27:27 -0300105 * '?' optional type (for all types, except '/')
106 * '.' other form of optional type (for 'i' and 'l')
Markus Armbruster942cd1f2010-03-26 09:07:09 +0100107 * 'b' boolean
108 * user mode accepts "on" or "off"
Luiz Capitulinofb466602009-08-28 15:27:27 -0300109 * '-' optional parameter (eg. '-f')
bellard9307c4c2004-04-04 12:57:25 +0000110 *
111 */
112
Adam Litke940cc302010-01-25 12:18:44 -0600113typedef struct MonitorCompletionData MonitorCompletionData;
114struct MonitorCompletionData {
115 Monitor *mon;
116 void (*user_print)(Monitor *mon, const QObject *data);
117};
118
Anthony Liguoric227f092009-10-01 16:12:16 -0500119typedef struct mon_cmd_t {
bellard9dc39cb2004-03-14 21:38:27 +0000120 const char *name;
bellard9307c4c2004-04-04 12:57:25 +0000121 const char *args_type;
bellard9dc39cb2004-03-14 21:38:27 +0000122 const char *params;
123 const char *help;
Luiz Capitulinoa2876f52009-10-07 13:41:53 -0300124 void (*user_print)(Monitor *mon, const QObject *data);
Luiz Capitulino910df892009-10-07 13:41:51 -0300125 union {
126 void (*info)(Monitor *mon);
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;
Anthony Liguoric227f092009-10-01 16:12:16 -0500133} mon_cmd_t;
bellard9dc39cb2004-03-14 21:38:27 +0000134
Mark McLoughlinf07918f2009-07-22 09:11:40 +0100135/* file descriptors passed via SCM_RIGHTS */
Anthony Liguoric227f092009-10-01 16:12:16 -0500136typedef struct mon_fd_t mon_fd_t;
137struct mon_fd_t {
Mark McLoughlinf07918f2009-07-22 09:11:40 +0100138 char *name;
139 int fd;
Anthony Liguoric227f092009-10-01 16:12:16 -0500140 QLIST_ENTRY(mon_fd_t) next;
Mark McLoughlinf07918f2009-07-22 09:11:40 +0100141};
142
Corey Bryantba1c0482012-08-14 16:43:43 -0400143/* file descriptor associated with a file descriptor set */
144typedef struct MonFdsetFd MonFdsetFd;
145struct MonFdsetFd {
146 int fd;
147 bool removed;
148 char *opaque;
149 QLIST_ENTRY(MonFdsetFd) next;
150};
151
152/* file descriptor set containing fds passed via SCM_RIGHTS */
153typedef struct MonFdset MonFdset;
154struct MonFdset {
155 int64_t id;
156 QLIST_HEAD(, MonFdsetFd) fds;
Corey Bryantadb696f2012-08-14 16:43:47 -0400157 QLIST_HEAD(, MonFdsetFd) dup_fds;
Corey Bryantba1c0482012-08-14 16:43:43 -0400158 QLIST_ENTRY(MonFdset) next;
159};
160
Luiz Capitulino5fa737a2009-11-26 22:59:01 -0200161typedef struct MonitorControl {
162 QObject *id;
163 JSONMessageParser parser;
Luiz Capitulino4a7e1192010-02-04 18:10:05 -0200164 int command_mode;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -0200165} MonitorControl;
166
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100167/*
168 * To prevent flooding clients, events can be throttled. The
169 * throttling is calculated globally, rather than per-Monitor
170 * instance.
171 */
172typedef struct MonitorEventState {
173 MonitorEvent event; /* Event being tracked */
174 int64_t rate; /* Period over which to throttle. 0 to disable */
175 int64_t last; /* Time at which event was last emitted */
176 QEMUTimer *timer; /* Timer for handling delayed events */
177 QObject *data; /* Event pending delayed dispatch */
178} MonitorEventState;
179
aliguori87127162009-03-05 23:01:29 +0000180struct Monitor {
181 CharDriverState *chr;
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +0200182 int mux_out;
183 int reset_seen;
aliguori731b0362009-03-05 23:01:42 +0000184 int flags;
185 int suspend_cnt;
186 uint8_t outbuf[1024];
187 int outbuf_index;
188 ReadLineState *rs;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -0200189 MonitorControl *mc;
Andreas Färber9349b4f2012-03-14 01:38:32 +0100190 CPUArchState *mon_cpu;
aliguori731b0362009-03-05 23:01:42 +0000191 BlockDriverCompletionFunc *password_completion_cb;
192 void *password_opaque;
Luiz Capitulino8204a912009-11-18 23:05:31 -0200193 QError *error;
Anthony Liguoric227f092009-10-01 16:12:16 -0500194 QLIST_HEAD(,mon_fd_t) fds;
Blue Swirl72cf2d42009-09-12 07:36:22 +0000195 QLIST_ENTRY(Monitor) entry;
aliguori87127162009-03-05 23:01:29 +0000196};
197
Luiz Capitulino2dbc8db2010-05-26 16:13:09 -0300198/* QMP checker flags */
199#define QMP_ACCEPT_UNKNOWNS 1
200
Blue Swirl72cf2d42009-09-12 07:36:22 +0000201static QLIST_HEAD(mon_list, Monitor) mon_list;
Corey Bryantba1c0482012-08-14 16:43:43 -0400202static QLIST_HEAD(mon_fdsets, MonFdset) mon_fdsets;
Corey Bryantefb87c12012-08-14 16:43:48 -0400203static int mon_refcount;
bellard7e2515e2004-08-01 21:52:19 +0000204
Wayne Xia816f8922011-10-12 11:32:41 +0800205static mon_cmd_t mon_cmds[];
206static mon_cmd_t info_cmds[];
bellard9dc39cb2004-03-14 21:38:27 +0000207
Luiz Capitulinof36b4af2010-09-15 17:17:45 -0300208static const mon_cmd_t qmp_cmds[];
209
Markus Armbruster8631b602010-02-18 11:41:55 +0100210Monitor *cur_mon;
211Monitor *default_mon;
aliguori376253e2009-03-05 23:01:23 +0000212
aliguori731b0362009-03-05 23:01:42 +0000213static void monitor_command_cb(Monitor *mon, const char *cmdline,
214 void *opaque);
aliguori83ab7952008-08-19 14:44:22 +0000215
Luiz Capitulino09069b12010-02-04 18:10:06 -0200216static inline int qmp_cmd_mode(const Monitor *mon)
217{
218 return (mon->mc ? mon->mc->command_mode : 0);
219}
220
Luiz Capitulino418173c2009-11-26 22:58:51 -0200221/* Return true if in control mode, false otherwise */
222static inline int monitor_ctrl_mode(const Monitor *mon)
223{
224 return (mon->flags & MONITOR_USE_CONTROL);
225}
226
Markus Armbruster6620d3c2010-02-11 17:05:43 +0100227/* Return non-zero iff we have a current monitor, and it is in QMP mode. */
228int monitor_cur_is_qmp(void)
229{
230 return cur_mon && monitor_ctrl_mode(cur_mon);
231}
232
Anthony Liguori7060b472011-09-02 12:34:50 -0500233void monitor_read_command(Monitor *mon, int show_prompt)
aliguori731b0362009-03-05 23:01:42 +0000234{
Luiz Capitulino183e6e52009-12-14 18:53:23 -0200235 if (!mon->rs)
236 return;
237
aliguori731b0362009-03-05 23:01:42 +0000238 readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL);
239 if (show_prompt)
240 readline_show_prompt(mon->rs);
241}
bellard6a00d602005-11-21 23:25:50 +0000242
Anthony Liguori7060b472011-09-02 12:34:50 -0500243int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
244 void *opaque)
aliguoribb5fc202009-03-05 23:01:15 +0000245{
Luiz Capitulino94171e12009-12-07 21:37:00 +0100246 if (monitor_ctrl_mode(mon)) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +0100247 qerror_report(QERR_MISSING_PARAMETER, "password");
Luiz Capitulino94171e12009-12-07 21:37:00 +0100248 return -EINVAL;
249 } else if (mon->rs) {
aliguoricde76ee2009-03-05 23:01:51 +0000250 readline_start(mon->rs, "Password: ", 1, readline_func, opaque);
251 /* prompt is printed on return from the command handler */
252 return 0;
253 } else {
254 monitor_printf(mon, "terminal does not support password prompting\n");
255 return -ENOTTY;
256 }
aliguoribb5fc202009-03-05 23:01:15 +0000257}
258
aliguori376253e2009-03-05 23:01:23 +0000259void monitor_flush(Monitor *mon)
bellard9dc39cb2004-03-14 21:38:27 +0000260{
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +0200261 if (mon && mon->outbuf_index != 0 && !mon->mux_out) {
Anthony Liguori2cc6e0a2011-08-15 11:17:28 -0500262 qemu_chr_fe_write(mon->chr, mon->outbuf, mon->outbuf_index);
aliguori731b0362009-03-05 23:01:42 +0000263 mon->outbuf_index = 0;
bellard7e2515e2004-08-01 21:52:19 +0000264 }
265}
266
267/* flush at every end of line or if the buffer is full */
aliguori376253e2009-03-05 23:01:23 +0000268static void monitor_puts(Monitor *mon, const char *str)
bellard7e2515e2004-08-01 21:52:19 +0000269{
ths60fe76f2007-12-16 03:02:09 +0000270 char c;
aliguori731b0362009-03-05 23:01:42 +0000271
bellard7e2515e2004-08-01 21:52:19 +0000272 for(;;) {
273 c = *str++;
274 if (c == '\0')
275 break;
bellard7ba12602006-07-14 20:26:42 +0000276 if (c == '\n')
aliguori731b0362009-03-05 23:01:42 +0000277 mon->outbuf[mon->outbuf_index++] = '\r';
278 mon->outbuf[mon->outbuf_index++] = c;
279 if (mon->outbuf_index >= (sizeof(mon->outbuf) - 1)
280 || c == '\n')
aliguori376253e2009-03-05 23:01:23 +0000281 monitor_flush(mon);
bellard7e2515e2004-08-01 21:52:19 +0000282 }
283}
284
aliguori376253e2009-03-05 23:01:23 +0000285void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
bellard7e2515e2004-08-01 21:52:19 +0000286{
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200287 char buf[4096];
288
Luiz Capitulino2daa1192009-12-14 18:53:24 -0200289 if (!mon)
290 return;
291
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200292 if (monitor_ctrl_mode(mon)) {
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200293 return;
Luiz Capitulino4a29a852009-11-26 22:59:05 -0200294 }
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200295
296 vsnprintf(buf, sizeof(buf), fmt, ap);
297 monitor_puts(mon, buf);
bellard7e2515e2004-08-01 21:52:19 +0000298}
299
aliguori376253e2009-03-05 23:01:23 +0000300void monitor_printf(Monitor *mon, const char *fmt, ...)
bellard7e2515e2004-08-01 21:52:19 +0000301{
302 va_list ap;
303 va_start(ap, fmt);
aliguori376253e2009-03-05 23:01:23 +0000304 monitor_vprintf(mon, fmt, ap);
bellard7e2515e2004-08-01 21:52:19 +0000305 va_end(ap);
bellard9dc39cb2004-03-14 21:38:27 +0000306}
307
aliguori376253e2009-03-05 23:01:23 +0000308void monitor_print_filename(Monitor *mon, const char *filename)
thsfef30742006-12-22 14:11:32 +0000309{
310 int i;
311
312 for (i = 0; filename[i]; i++) {
aliguori28a76be2009-03-06 20:27:40 +0000313 switch (filename[i]) {
314 case ' ':
315 case '"':
316 case '\\':
317 monitor_printf(mon, "\\%c", filename[i]);
318 break;
319 case '\t':
320 monitor_printf(mon, "\\t");
321 break;
322 case '\r':
323 monitor_printf(mon, "\\r");
324 break;
325 case '\n':
326 monitor_printf(mon, "\\n");
327 break;
328 default:
329 monitor_printf(mon, "%c", filename[i]);
330 break;
331 }
thsfef30742006-12-22 14:11:32 +0000332 }
333}
334
Stefan Weil8b7968f2010-09-23 21:28:05 +0200335static int GCC_FMT_ATTR(2, 3) monitor_fprintf(FILE *stream,
336 const char *fmt, ...)
bellard7fe48482004-10-09 18:08:01 +0000337{
338 va_list ap;
339 va_start(ap, fmt);
aliguori376253e2009-03-05 23:01:23 +0000340 monitor_vprintf((Monitor *)stream, fmt, ap);
bellard7fe48482004-10-09 18:08:01 +0000341 va_end(ap);
342 return 0;
343}
344
Luiz Capitulino13c74252009-10-07 13:41:55 -0300345static void monitor_user_noop(Monitor *mon, const QObject *data) { }
346
Luiz Capitulino9e807212010-09-16 10:58:59 -0300347static inline int handler_is_qobject(const mon_cmd_t *cmd)
Luiz Capitulino13917be2009-10-07 13:41:54 -0300348{
349 return cmd->user_print != NULL;
350}
351
Luiz Capitulino4903de02010-09-16 11:01:32 -0300352static inline bool handler_is_async(const mon_cmd_t *cmd)
Adam Litke940cc302010-01-25 12:18:44 -0600353{
Jan Kiszka8ac470c2010-06-16 00:38:39 +0200354 return cmd->flags & MONITOR_CMD_ASYNC;
Adam Litke940cc302010-01-25 12:18:44 -0600355}
356
Luiz Capitulino8204a912009-11-18 23:05:31 -0200357static inline int monitor_has_error(const Monitor *mon)
358{
359 return mon->error != NULL;
360}
361
Luiz Capitulino9b57c022009-11-26 22:58:58 -0200362static void monitor_json_emitter(Monitor *mon, const QObject *data)
363{
364 QString *json;
365
Luiz Capitulino83a27d42010-11-22 17:10:37 -0200366 json = mon->flags & MONITOR_USE_PRETTY ? qobject_to_json_pretty(data) :
367 qobject_to_json(data);
Luiz Capitulino9b57c022009-11-26 22:58:58 -0200368 assert(json != NULL);
369
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200370 qstring_append_chr(json, '\n');
371 monitor_puts(mon, qstring_get_str(json));
Luiz Capitulino4a29a852009-11-26 22:59:05 -0200372
Luiz Capitulino9b57c022009-11-26 22:58:58 -0200373 QDECREF(json);
374}
375
Luiz Capitulinode253f12012-07-27 16:18:16 -0300376static QDict *build_qmp_error_dict(const QError *err)
377{
378 QObject *obj;
379
380 obj = qobject_from_jsonf("{ 'error': { 'class': %s, 'desc': %p } }",
381 ErrorClass_lookup[err->err_class],
382 qerror_human(err));
383
384 return qobject_to_qdict(obj);
385}
386
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200387static void monitor_protocol_emitter(Monitor *mon, QObject *data)
388{
389 QDict *qmp;
390
Stefan Hajnoczi89bd8202011-09-23 08:23:06 +0100391 trace_monitor_protocol_emitter(mon);
392
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200393 if (!monitor_has_error(mon)) {
394 /* success response */
Luiz Capitulinode253f12012-07-27 16:18:16 -0300395 qmp = qdict_new();
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200396 if (data) {
397 qobject_incref(data);
398 qdict_put_obj(qmp, "return", data);
399 } else {
Luiz Capitulino0abc6572009-12-18 13:25:00 -0200400 /* return an empty QDict by default */
401 qdict_put(qmp, "return", qdict_new());
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200402 }
403 } else {
404 /* error response */
Luiz Capitulinode253f12012-07-27 16:18:16 -0300405 qmp = build_qmp_error_dict(mon->error);
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200406 QDECREF(mon->error);
407 mon->error = NULL;
408 }
409
Luiz Capitulino5fa737a2009-11-26 22:59:01 -0200410 if (mon->mc->id) {
411 qdict_put_obj(qmp, "id", mon->mc->id);
412 mon->mc->id = NULL;
413 }
414
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200415 monitor_json_emitter(mon, QOBJECT(qmp));
416 QDECREF(qmp);
417}
418
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200419static void timestamp_put(QDict *qdict)
420{
421 int err;
422 QObject *obj;
Blue Swirld08d6f02009-12-04 18:06:39 +0000423 qemu_timeval tv;
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200424
Blue Swirld08d6f02009-12-04 18:06:39 +0000425 err = qemu_gettimeofday(&tv);
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200426 if (err < 0)
427 return;
428
429 obj = qobject_from_jsonf("{ 'seconds': %" PRId64 ", "
430 "'microseconds': %" PRId64 " }",
431 (int64_t) tv.tv_sec, (int64_t) tv.tv_usec);
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200432 qdict_put_obj(qdict, "timestamp", obj);
433}
434
Daniel P. Berrange48608532012-05-21 17:59:51 +0100435
436static const char *monitor_event_names[] = {
437 [QEVENT_SHUTDOWN] = "SHUTDOWN",
438 [QEVENT_RESET] = "RESET",
439 [QEVENT_POWERDOWN] = "POWERDOWN",
440 [QEVENT_STOP] = "STOP",
441 [QEVENT_RESUME] = "RESUME",
442 [QEVENT_VNC_CONNECTED] = "VNC_CONNECTED",
443 [QEVENT_VNC_INITIALIZED] = "VNC_INITIALIZED",
444 [QEVENT_VNC_DISCONNECTED] = "VNC_DISCONNECTED",
445 [QEVENT_BLOCK_IO_ERROR] = "BLOCK_IO_ERROR",
446 [QEVENT_RTC_CHANGE] = "RTC_CHANGE",
447 [QEVENT_WATCHDOG] = "WATCHDOG",
448 [QEVENT_SPICE_CONNECTED] = "SPICE_CONNECTED",
449 [QEVENT_SPICE_INITIALIZED] = "SPICE_INITIALIZED",
450 [QEVENT_SPICE_DISCONNECTED] = "SPICE_DISCONNECTED",
451 [QEVENT_BLOCK_JOB_COMPLETED] = "BLOCK_JOB_COMPLETED",
452 [QEVENT_BLOCK_JOB_CANCELLED] = "BLOCK_JOB_CANCELLED",
453 [QEVENT_DEVICE_TRAY_MOVED] = "DEVICE_TRAY_MOVED",
454 [QEVENT_SUSPEND] = "SUSPEND",
Luiz Capitulino25df49f2012-08-08 17:03:01 -0300455 [QEVENT_SUSPEND_DISK] = "SUSPEND_DISK",
Daniel P. Berrange48608532012-05-21 17:59:51 +0100456 [QEVENT_WAKEUP] = "WAKEUP",
Daniel P. Berrange973603a2012-06-14 18:12:56 +0100457 [QEVENT_BALLOON_CHANGE] = "BALLOON_CHANGE",
Yonit Halperin2fdd16e2012-08-21 11:51:57 +0300458 [QEVENT_SPICE_MIGRATE_COMPLETED] = "SPICE_MIGRATE_COMPLETED",
Daniel P. Berrange48608532012-05-21 17:59:51 +0100459};
460QEMU_BUILD_BUG_ON(ARRAY_SIZE(monitor_event_names) != QEVENT_MAX)
461
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100462MonitorEventState monitor_event_state[QEVENT_MAX];
463QemuMutex monitor_event_state_lock;
464
465/*
466 * Emits the event to every monitor instance
467 */
468static void
469monitor_protocol_event_emit(MonitorEvent event,
470 QObject *data)
471{
472 Monitor *mon;
473
474 trace_monitor_protocol_event_emit(event, data);
475 QLIST_FOREACH(mon, &mon_list, entry) {
476 if (monitor_ctrl_mode(mon) && qmp_cmd_mode(mon)) {
477 monitor_json_emitter(mon, data);
478 }
479 }
480}
481
482
483/*
484 * Queue a new event for emission to Monitor instances,
485 * applying any rate limiting if required.
486 */
487static void
488monitor_protocol_event_queue(MonitorEvent event,
489 QObject *data)
490{
491 MonitorEventState *evstate;
492 int64_t now = qemu_get_clock_ns(rt_clock);
493 assert(event < QEVENT_MAX);
494
495 qemu_mutex_lock(&monitor_event_state_lock);
496 evstate = &(monitor_event_state[event]);
497 trace_monitor_protocol_event_queue(event,
498 data,
499 evstate->rate,
500 evstate->last,
501 now);
502
503 /* Rate limit of 0 indicates no throttling */
504 if (!evstate->rate) {
505 monitor_protocol_event_emit(event, data);
506 evstate->last = now;
507 } else {
508 int64_t delta = now - evstate->last;
509 if (evstate->data ||
510 delta < evstate->rate) {
511 /* If there's an existing event pending, replace
512 * it with the new event, otherwise schedule a
513 * timer for delayed emission
514 */
515 if (evstate->data) {
516 qobject_decref(evstate->data);
517 } else {
518 int64_t then = evstate->last + evstate->rate;
519 qemu_mod_timer_ns(evstate->timer, then);
520 }
521 evstate->data = data;
522 qobject_incref(evstate->data);
523 } else {
524 monitor_protocol_event_emit(event, data);
525 evstate->last = now;
526 }
527 }
528 qemu_mutex_unlock(&monitor_event_state_lock);
529}
530
531
532/*
533 * The callback invoked by QemuTimer when a delayed
534 * event is ready to be emitted
535 */
536static void monitor_protocol_event_handler(void *opaque)
537{
538 MonitorEventState *evstate = opaque;
539 int64_t now = qemu_get_clock_ns(rt_clock);
540
541 qemu_mutex_lock(&monitor_event_state_lock);
542
543 trace_monitor_protocol_event_handler(evstate->event,
544 evstate->data,
545 evstate->last,
546 now);
547 if (evstate->data) {
548 monitor_protocol_event_emit(evstate->event, evstate->data);
549 qobject_decref(evstate->data);
550 evstate->data = NULL;
551 }
552 evstate->last = now;
553 qemu_mutex_unlock(&monitor_event_state_lock);
554}
555
556
557/*
558 * @event: the event ID to be limited
559 * @rate: the rate limit in milliseconds
560 *
561 * Sets a rate limit on a particular event, so no
562 * more than 1 event will be emitted within @rate
563 * milliseconds
564 */
565static void
566monitor_protocol_event_throttle(MonitorEvent event,
567 int64_t rate)
568{
569 MonitorEventState *evstate;
570 assert(event < QEVENT_MAX);
571
572 evstate = &(monitor_event_state[event]);
573
574 trace_monitor_protocol_event_throttle(event, rate);
575 evstate->event = event;
576 evstate->rate = rate * SCALE_MS;
577 evstate->timer = qemu_new_timer(rt_clock,
578 SCALE_MS,
579 monitor_protocol_event_handler,
580 evstate);
581 evstate->last = 0;
582 evstate->data = NULL;
583}
584
585
586/* Global, one-time initializer to configure the rate limiting
587 * and initialize state */
588static void monitor_protocol_event_init(void)
589{
590 qemu_mutex_init(&monitor_event_state_lock);
591 /* Limit RTC & BALLOON events to 1 per second */
592 monitor_protocol_event_throttle(QEVENT_RTC_CHANGE, 1000);
593 monitor_protocol_event_throttle(QEVENT_BALLOON_CHANGE, 1000);
594 monitor_protocol_event_throttle(QEVENT_WATCHDOG, 1000);
595}
596
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200597/**
598 * monitor_protocol_event(): Generate a Monitor event
599 *
600 * Event-specific data can be emitted through the (optional) 'data' parameter.
601 */
602void monitor_protocol_event(MonitorEvent event, QObject *data)
603{
604 QDict *qmp;
605 const char *event_name;
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200606
Blue Swirl242cd002009-12-04 18:05:45 +0000607 assert(event < QEVENT_MAX);
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200608
Daniel P. Berrange48608532012-05-21 17:59:51 +0100609 event_name = monitor_event_names[event];
610 assert(event_name != NULL);
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200611
612 qmp = qdict_new();
613 timestamp_put(qmp);
614 qdict_put(qmp, "event", qstring_from_str(event_name));
Luiz Capitulino3d72f9a2010-01-08 16:45:53 -0200615 if (data) {
616 qobject_incref(data);
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200617 qdict_put_obj(qmp, "data", data);
Luiz Capitulino3d72f9a2010-01-08 16:45:53 -0200618 }
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200619
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +0100620 trace_monitor_protocol_event(event, event_name, qmp);
621 monitor_protocol_event_queue(event, QOBJECT(qmp));
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200622 QDECREF(qmp);
623}
624
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -0200625static int do_qmp_capabilities(Monitor *mon, const QDict *params,
626 QObject **ret_data)
Luiz Capitulino4a7e1192010-02-04 18:10:05 -0200627{
628 /* Will setup QMP capabilities in the future */
629 if (monitor_ctrl_mode(mon)) {
630 mon->mc->command_mode = 1;
631 }
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -0200632
633 return 0;
Luiz Capitulino4a7e1192010-02-04 18:10:05 -0200634}
635
Luiz Capitulino0268d972010-10-22 10:08:02 -0200636static void handle_user_command(Monitor *mon, const char *cmdline);
637
Luiz Capitulinod51a67b2011-11-25 17:52:45 -0200638char *qmp_human_monitor_command(const char *command_line, bool has_cpu_index,
639 int64_t cpu_index, Error **errp)
Luiz Capitulino0268d972010-10-22 10:08:02 -0200640{
Luiz Capitulinod51a67b2011-11-25 17:52:45 -0200641 char *output = NULL;
Luiz Capitulino0268d972010-10-22 10:08:02 -0200642 Monitor *old_mon, hmp;
643 CharDriverState mchar;
644
645 memset(&hmp, 0, sizeof(hmp));
646 qemu_chr_init_mem(&mchar);
647 hmp.chr = &mchar;
648
649 old_mon = cur_mon;
650 cur_mon = &hmp;
651
Luiz Capitulinod51a67b2011-11-25 17:52:45 -0200652 if (has_cpu_index) {
653 int ret = monitor_set_cpu(cpu_index);
Luiz Capitulino0268d972010-10-22 10:08:02 -0200654 if (ret < 0) {
655 cur_mon = old_mon;
Luiz Capitulinod51a67b2011-11-25 17:52:45 -0200656 error_set(errp, QERR_INVALID_PARAMETER_VALUE, "cpu-index",
657 "a CPU number");
Luiz Capitulino0268d972010-10-22 10:08:02 -0200658 goto out;
659 }
660 }
661
Luiz Capitulinod51a67b2011-11-25 17:52:45 -0200662 handle_user_command(&hmp, command_line);
Luiz Capitulino0268d972010-10-22 10:08:02 -0200663 cur_mon = old_mon;
664
665 if (qemu_chr_mem_osize(hmp.chr) > 0) {
Luiz Capitulinod51a67b2011-11-25 17:52:45 -0200666 QString *str = qemu_chr_mem_to_qs(hmp.chr);
667 output = g_strdup(qstring_get_str(str));
668 QDECREF(str);
669 } else {
670 output = g_strdup("");
Luiz Capitulino0268d972010-10-22 10:08:02 -0200671 }
672
673out:
674 qemu_chr_close_mem(hmp.chr);
Luiz Capitulinod51a67b2011-11-25 17:52:45 -0200675 return output;
Luiz Capitulino0268d972010-10-22 10:08:02 -0200676}
677
bellard9dc39cb2004-03-14 21:38:27 +0000678static int compare_cmd(const char *name, const char *list)
679{
680 const char *p, *pstart;
681 int len;
682 len = strlen(name);
683 p = list;
684 for(;;) {
685 pstart = p;
686 p = strchr(p, '|');
687 if (!p)
688 p = pstart + strlen(pstart);
689 if ((p - pstart) == len && !memcmp(pstart, name, len))
690 return 1;
691 if (*p == '\0')
692 break;
693 p++;
694 }
695 return 0;
696}
697
Anthony Liguoric227f092009-10-01 16:12:16 -0500698static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
aliguori376253e2009-03-05 23:01:23 +0000699 const char *prefix, const char *name)
bellard9dc39cb2004-03-14 21:38:27 +0000700{
Anthony Liguoric227f092009-10-01 16:12:16 -0500701 const mon_cmd_t *cmd;
bellard9dc39cb2004-03-14 21:38:27 +0000702
703 for(cmd = cmds; cmd->name != NULL; cmd++) {
704 if (!name || !strcmp(name, cmd->name))
aliguori376253e2009-03-05 23:01:23 +0000705 monitor_printf(mon, "%s%s %s -- %s\n", prefix, cmd->name,
706 cmd->params, cmd->help);
bellard9dc39cb2004-03-14 21:38:27 +0000707 }
708}
709
aliguori376253e2009-03-05 23:01:23 +0000710static void help_cmd(Monitor *mon, const char *name)
bellard9dc39cb2004-03-14 21:38:27 +0000711{
712 if (name && !strcmp(name, "info")) {
aliguori376253e2009-03-05 23:01:23 +0000713 help_cmd_dump(mon, info_cmds, "info ", NULL);
bellard9dc39cb2004-03-14 21:38:27 +0000714 } else {
aliguori376253e2009-03-05 23:01:23 +0000715 help_cmd_dump(mon, mon_cmds, "", name);
bellardf193c792004-03-21 17:06:25 +0000716 if (name && !strcmp(name, "log")) {
blueswir18662d652008-10-02 18:32:44 +0000717 const CPULogItem *item;
aliguori376253e2009-03-05 23:01:23 +0000718 monitor_printf(mon, "Log items (comma separated):\n");
719 monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");
bellardf193c792004-03-21 17:06:25 +0000720 for(item = cpu_log_items; item->mask != 0; item++) {
aliguori376253e2009-03-05 23:01:23 +0000721 monitor_printf(mon, "%-10s %s\n", item->name, item->help);
bellardf193c792004-03-21 17:06:25 +0000722 }
723 }
bellard9dc39cb2004-03-14 21:38:27 +0000724 }
725}
726
Luiz Capitulinod54908a2009-08-28 15:27:13 -0300727static void do_help_cmd(Monitor *mon, const QDict *qdict)
Luiz Capitulino38183182009-08-28 15:27:08 -0300728{
Luiz Capitulinod54908a2009-08-28 15:27:13 -0300729 help_cmd(mon, qdict_get_try_str(qdict, "name"));
Luiz Capitulino38183182009-08-28 15:27:08 -0300730}
731
Lluísfc764102011-08-31 20:31:18 +0200732static void do_trace_event_set_state(Monitor *mon, const QDict *qdict)
Prerna Saxena22890ab2010-06-24 17:04:53 +0530733{
734 const char *tp_name = qdict_get_str(qdict, "name");
735 bool new_state = qdict_get_bool(qdict, "option");
Lluísfc764102011-08-31 20:31:18 +0200736 int ret = trace_event_set_state(tp_name, new_state);
Blue Swirlf871d682010-10-13 19:14:29 +0000737
738 if (!ret) {
739 monitor_printf(mon, "unknown event name \"%s\"\n", tp_name);
740 }
Prerna Saxena22890ab2010-06-24 17:04:53 +0530741}
Stefan Hajnoczic5ceb522010-07-13 09:26:33 +0100742
Michael Rothc45a8162011-10-02 08:44:37 -0500743#ifdef CONFIG_TRACE_SIMPLE
Stefan Hajnoczic5ceb522010-07-13 09:26:33 +0100744static void do_trace_file(Monitor *mon, const QDict *qdict)
745{
746 const char *op = qdict_get_try_str(qdict, "op");
747 const char *arg = qdict_get_try_str(qdict, "arg");
748
749 if (!op) {
750 st_print_trace_file_status((FILE *)mon, &monitor_fprintf);
751 } else if (!strcmp(op, "on")) {
752 st_set_trace_file_enabled(true);
753 } else if (!strcmp(op, "off")) {
754 st_set_trace_file_enabled(false);
755 } else if (!strcmp(op, "flush")) {
756 st_flush_trace_buffer();
757 } else if (!strcmp(op, "set")) {
758 if (arg) {
759 st_set_trace_file(arg);
760 }
761 } else {
762 monitor_printf(mon, "unexpected argument \"%s\"\n", op);
763 help_cmd(mon, "trace-file");
764 }
765}
Prerna Saxena22890ab2010-06-24 17:04:53 +0530766#endif
767
Adam Litke940cc302010-01-25 12:18:44 -0600768static void user_monitor_complete(void *opaque, QObject *ret_data)
769{
770 MonitorCompletionData *data = (MonitorCompletionData *)opaque;
771
772 if (ret_data) {
773 data->user_print(data->mon, ret_data);
774 }
775 monitor_resume(data->mon);
Anthony Liguori7267c092011-08-20 22:09:37 -0500776 g_free(data);
Adam Litke940cc302010-01-25 12:18:44 -0600777}
778
779static void qmp_monitor_complete(void *opaque, QObject *ret_data)
780{
781 monitor_protocol_emitter(opaque, ret_data);
782}
783
Luiz Capitulino5af7bba2010-06-22 19:10:46 -0300784static int qmp_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,
785 const QDict *params)
Adam Litke940cc302010-01-25 12:18:44 -0600786{
Luiz Capitulino5af7bba2010-06-22 19:10:46 -0300787 return cmd->mhandler.cmd_async(mon, params, qmp_monitor_complete, mon);
Adam Litke940cc302010-01-25 12:18:44 -0600788}
789
Adam Litke940cc302010-01-25 12:18:44 -0600790static void user_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,
791 const QDict *params)
792{
793 int ret;
794
Anthony Liguori7267c092011-08-20 22:09:37 -0500795 MonitorCompletionData *cb_data = g_malloc(sizeof(*cb_data));
Adam Litke940cc302010-01-25 12:18:44 -0600796 cb_data->mon = mon;
797 cb_data->user_print = cmd->user_print;
798 monitor_suspend(mon);
799 ret = cmd->mhandler.cmd_async(mon, params,
800 user_monitor_complete, cb_data);
801 if (ret < 0) {
802 monitor_resume(mon);
Anthony Liguori7267c092011-08-20 22:09:37 -0500803 g_free(cb_data);
Adam Litke940cc302010-01-25 12:18:44 -0600804 }
805}
806
Luiz Capitulino1162daa2010-09-13 12:15:26 -0300807static void do_info(Monitor *mon, const QDict *qdict)
bellard9dc39cb2004-03-14 21:38:27 +0000808{
Anthony Liguoric227f092009-10-01 16:12:16 -0500809 const mon_cmd_t *cmd;
Luiz Capitulinod54908a2009-08-28 15:27:13 -0300810 const char *item = qdict_get_try_str(qdict, "item");
bellard9dc39cb2004-03-14 21:38:27 +0000811
Luiz Capitulino956f1a02009-11-26 22:59:00 -0200812 if (!item) {
bellard9dc39cb2004-03-14 21:38:27 +0000813 goto help;
Luiz Capitulino956f1a02009-11-26 22:59:00 -0200814 }
Luiz Capitulino13c74252009-10-07 13:41:55 -0300815
816 for (cmd = info_cmds; cmd->name != NULL; cmd++) {
ths5fafdf22007-09-16 21:08:06 +0000817 if (compare_cmd(item, cmd->name))
Luiz Capitulino13c74252009-10-07 13:41:55 -0300818 break;
bellard9dc39cb2004-03-14 21:38:27 +0000819 }
Luiz Capitulino13c74252009-10-07 13:41:55 -0300820
Luiz Capitulino956f1a02009-11-26 22:59:00 -0200821 if (cmd->name == NULL) {
Luiz Capitulino13c74252009-10-07 13:41:55 -0300822 goto help;
Luiz Capitulino956f1a02009-11-26 22:59:00 -0200823 }
Luiz Capitulino13c74252009-10-07 13:41:55 -0300824
Luiz Capitulinob5c30582011-10-21 16:24:28 -0200825 cmd->mhandler.info(mon);
Luiz Capitulino1162daa2010-09-13 12:15:26 -0300826 return;
Luiz Capitulino13c74252009-10-07 13:41:55 -0300827
828help:
829 help_cmd(mon, "info");
bellard9dc39cb2004-03-14 21:38:27 +0000830}
831
Luiz Capitulinoaa9b79b2011-09-21 14:31:51 -0300832CommandInfoList *qmp_query_commands(Error **errp)
bellard9bc9d1c2004-10-10 15:15:51 +0000833{
Luiz Capitulinoaa9b79b2011-09-21 14:31:51 -0300834 CommandInfoList *info, *cmd_list = NULL;
Luiz Capitulinoe3bba9d2009-11-26 22:58:56 -0200835 const mon_cmd_t *cmd;
836
Luiz Capitulinof36b4af2010-09-15 17:17:45 -0300837 for (cmd = qmp_cmds; cmd->name != NULL; cmd++) {
Luiz Capitulino40e5a012011-10-21 16:15:31 -0200838 info = g_malloc0(sizeof(*info));
839 info->value = g_malloc0(sizeof(*info->value));
840 info->value->name = g_strdup(cmd->name);
Luiz Capitulinoe3bba9d2009-11-26 22:58:56 -0200841
Luiz Capitulinoaa9b79b2011-09-21 14:31:51 -0300842 info->next = cmd_list;
843 cmd_list = info;
Luiz Capitulinoe3bba9d2009-11-26 22:58:56 -0200844 }
845
Luiz Capitulinoaa9b79b2011-09-21 14:31:51 -0300846 return cmd_list;
thsa36e69d2007-12-02 05:18:19 +0000847}
848
Daniel P. Berrange48608532012-05-21 17:59:51 +0100849EventInfoList *qmp_query_events(Error **errp)
850{
851 EventInfoList *info, *ev_list = NULL;
852 MonitorEvent e;
853
854 for (e = 0 ; e < QEVENT_MAX ; e++) {
855 const char *event_name = monitor_event_names[e];
856 assert(event_name != NULL);
857 info = g_malloc0(sizeof(*info));
858 info->value = g_malloc0(sizeof(*info->value));
859 info->value->name = g_strdup(event_name);
860
861 info->next = ev_list;
862 ev_list = info;
863 }
864
865 return ev_list;
866}
867
Luiz Capitulinob025c8b2011-10-06 14:02:57 -0300868/* set the current CPU defined by the user */
869int monitor_set_cpu(int cpu_index)
bellard6a00d602005-11-21 23:25:50 +0000870{
Andreas Färber9349b4f2012-03-14 01:38:32 +0100871 CPUArchState *env;
bellard6a00d602005-11-21 23:25:50 +0000872
873 for(env = first_cpu; env != NULL; env = env->next_cpu) {
874 if (env->cpu_index == cpu_index) {
aliguori731b0362009-03-05 23:01:42 +0000875 cur_mon->mon_cpu = env;
bellard6a00d602005-11-21 23:25:50 +0000876 return 0;
877 }
878 }
879 return -1;
880}
881
Andreas Färber9349b4f2012-03-14 01:38:32 +0100882static CPUArchState *mon_get_cpu(void)
bellard6a00d602005-11-21 23:25:50 +0000883{
aliguori731b0362009-03-05 23:01:42 +0000884 if (!cur_mon->mon_cpu) {
Luiz Capitulinob025c8b2011-10-06 14:02:57 -0300885 monitor_set_cpu(0);
bellard6a00d602005-11-21 23:25:50 +0000886 }
Avi Kivity4c0960c2009-08-17 23:19:53 +0300887 cpu_synchronize_state(cur_mon->mon_cpu);
aliguori731b0362009-03-05 23:01:42 +0000888 return cur_mon->mon_cpu;
bellard6a00d602005-11-21 23:25:50 +0000889}
890
Luiz Capitulino99b77962011-10-24 10:53:44 -0200891int monitor_get_cpu_index(void)
892{
893 return mon_get_cpu()->cpu_index;
894}
895
aliguori376253e2009-03-05 23:01:23 +0000896static void do_info_registers(Monitor *mon)
bellard9307c4c2004-04-04 12:57:25 +0000897{
Andreas Färber9349b4f2012-03-14 01:38:32 +0100898 CPUArchState *env;
bellard6a00d602005-11-21 23:25:50 +0000899 env = mon_get_cpu();
bellard9307c4c2004-04-04 12:57:25 +0000900#ifdef TARGET_I386
aliguori376253e2009-03-05 23:01:23 +0000901 cpu_dump_state(env, (FILE *)mon, monitor_fprintf,
bellardd24b15a2005-07-03 21:28:00 +0000902 X86_DUMP_FPU);
bellard9307c4c2004-04-04 12:57:25 +0000903#else
aliguori376253e2009-03-05 23:01:23 +0000904 cpu_dump_state(env, (FILE *)mon, monitor_fprintf,
bellard7fe48482004-10-09 18:08:01 +0000905 0);
bellard9307c4c2004-04-04 12:57:25 +0000906#endif
907}
908
aliguori376253e2009-03-05 23:01:23 +0000909static void do_info_jit(Monitor *mon)
bellarde3db7222005-01-26 22:00:47 +0000910{
aliguori376253e2009-03-05 23:01:23 +0000911 dump_exec_info((FILE *)mon, monitor_fprintf);
bellarde3db7222005-01-26 22:00:47 +0000912}
913
aliguori376253e2009-03-05 23:01:23 +0000914static void do_info_history(Monitor *mon)
bellardaa455482004-04-04 13:07:25 +0000915{
916 int i;
bellard7e2515e2004-08-01 21:52:19 +0000917 const char *str;
ths3b46e622007-09-17 08:09:54 +0000918
aliguoricde76ee2009-03-05 23:01:51 +0000919 if (!mon->rs)
920 return;
bellard7e2515e2004-08-01 21:52:19 +0000921 i = 0;
922 for(;;) {
aliguori731b0362009-03-05 23:01:42 +0000923 str = readline_get_history(mon->rs, i);
bellard7e2515e2004-08-01 21:52:19 +0000924 if (!str)
925 break;
aliguori376253e2009-03-05 23:01:23 +0000926 monitor_printf(mon, "%d: '%s'\n", i, str);
bellard8e3a9fd2004-10-09 17:32:58 +0000927 i++;
bellardaa455482004-04-04 13:07:25 +0000928 }
929}
930
j_mayer76a66252007-03-07 08:32:30 +0000931#if defined(TARGET_PPC)
932/* XXX: not implemented in other targets */
aliguori376253e2009-03-05 23:01:23 +0000933static void do_info_cpu_stats(Monitor *mon)
j_mayer76a66252007-03-07 08:32:30 +0000934{
Andreas Färber9349b4f2012-03-14 01:38:32 +0100935 CPUArchState *env;
j_mayer76a66252007-03-07 08:32:30 +0000936
937 env = mon_get_cpu();
aliguori376253e2009-03-05 23:01:23 +0000938 cpu_dump_statistics(env, (FILE *)mon, &monitor_fprintf, 0);
j_mayer76a66252007-03-07 08:32:30 +0000939}
940#endif
941
Lluísfc764102011-08-31 20:31:18 +0200942static void do_trace_print_events(Monitor *mon)
Prerna Saxena22890ab2010-06-24 17:04:53 +0530943{
Lluísfc764102011-08-31 20:31:18 +0200944 trace_print_events((FILE *)mon, &monitor_fprintf);
Prerna Saxena22890ab2010-06-24 17:04:53 +0530945}
Prerna Saxena22890ab2010-06-24 17:04:53 +0530946
Daniel P. Berrange13661082011-06-23 13:31:42 +0100947static int add_graphics_client(Monitor *mon, const QDict *qdict, QObject **ret_data)
948{
949 const char *protocol = qdict_get_str(qdict, "protocol");
950 const char *fdname = qdict_get_str(qdict, "fdname");
Daniel P. Berrange13661082011-06-23 13:31:42 +0100951 CharDriverState *s;
952
953 if (strcmp(protocol, "spice") == 0) {
Paolo Bonzinia9940fc2012-09-20 16:50:32 +0200954 int fd = monitor_get_fd(mon, fdname, NULL);
Daniel P. Berrangef1f5f402012-02-13 13:43:08 +0000955 int skipauth = qdict_get_try_bool(qdict, "skipauth", 0);
956 int tls = qdict_get_try_bool(qdict, "tls", 0);
Daniel P. Berrange13661082011-06-23 13:31:42 +0100957 if (!using_spice) {
958 /* correct one? spice isn't a device ,,, */
959 qerror_report(QERR_DEVICE_NOT_ACTIVE, "spice");
960 return -1;
961 }
Daniel P. Berrangef1f5f402012-02-13 13:43:08 +0000962 if (qemu_spice_display_add_client(fd, skipauth, tls) < 0) {
963 close(fd);
964 }
965 return 0;
TeLeManc62f6d12011-07-25 16:29:14 +0800966#ifdef CONFIG_VNC
Daniel P. Berrange13661082011-06-23 13:31:42 +0100967 } else if (strcmp(protocol, "vnc") == 0) {
Paolo Bonzinia9940fc2012-09-20 16:50:32 +0200968 int fd = monitor_get_fd(mon, fdname, NULL);
Jamie Iles860341f2011-08-10 15:18:42 +0100969 int skipauth = qdict_get_try_bool(qdict, "skipauth", 0);
Daniel P. Berrange13661082011-06-23 13:31:42 +0100970 vnc_display_add_client(NULL, fd, skipauth);
971 return 0;
TeLeManc62f6d12011-07-25 16:29:14 +0800972#endif
Daniel P. Berrange13661082011-06-23 13:31:42 +0100973 } else if ((s = qemu_chr_find(protocol)) != NULL) {
Paolo Bonzinia9940fc2012-09-20 16:50:32 +0200974 int fd = monitor_get_fd(mon, fdname, NULL);
Daniel P. Berrange13661082011-06-23 13:31:42 +0100975 if (qemu_chr_add_client(s, fd) < 0) {
976 qerror_report(QERR_ADD_CLIENT_FAILED);
977 return -1;
978 }
979 return 0;
980 }
981
982 qerror_report(QERR_INVALID_PARAMETER, "protocol");
983 return -1;
984}
985
Yonit Halperinedc5cb12011-10-17 10:03:18 +0200986static int client_migrate_info(Monitor *mon, const QDict *qdict,
987 MonitorCompletion cb, void *opaque)
Gerd Hoffmanne866e232010-04-23 13:28:21 +0200988{
989 const char *protocol = qdict_get_str(qdict, "protocol");
990 const char *hostname = qdict_get_str(qdict, "hostname");
991 const char *subject = qdict_get_try_str(qdict, "cert-subject");
992 int port = qdict_get_try_int(qdict, "port", -1);
993 int tls_port = qdict_get_try_int(qdict, "tls-port", -1);
994 int ret;
995
996 if (strcmp(protocol, "spice") == 0) {
997 if (!using_spice) {
998 qerror_report(QERR_DEVICE_NOT_ACTIVE, "spice");
999 return -1;
1000 }
1001
Yonit Halperin6ec5dae2012-03-18 09:42:39 +02001002 if (port == -1 && tls_port == -1) {
1003 qerror_report(QERR_MISSING_PARAMETER, "port/tls-port");
1004 return -1;
1005 }
1006
Yonit Halperinedc5cb12011-10-17 10:03:18 +02001007 ret = qemu_spice_migrate_info(hostname, port, tls_port, subject,
1008 cb, opaque);
Gerd Hoffmanne866e232010-04-23 13:28:21 +02001009 if (ret != 0) {
1010 qerror_report(QERR_UNDEFINED_ERROR);
1011 return -1;
1012 }
1013 return 0;
1014 }
1015
1016 qerror_report(QERR_INVALID_PARAMETER, "protocol");
1017 return -1;
1018}
1019
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001020static void do_logfile(Monitor *mon, const QDict *qdict)
pbrooke735b912007-06-30 13:53:24 +00001021{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001022 cpu_set_log_filename(qdict_get_str(qdict, "filename"));
pbrooke735b912007-06-30 13:53:24 +00001023}
1024
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001025static void do_log(Monitor *mon, const QDict *qdict)
bellardf193c792004-03-21 17:06:25 +00001026{
1027 int mask;
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001028 const char *items = qdict_get_str(qdict, "items");
ths3b46e622007-09-17 08:09:54 +00001029
bellard9307c4c2004-04-04 12:57:25 +00001030 if (!strcmp(items, "none")) {
bellardf193c792004-03-21 17:06:25 +00001031 mask = 0;
1032 } else {
bellard9307c4c2004-04-04 12:57:25 +00001033 mask = cpu_str_to_log_mask(items);
bellardf193c792004-03-21 17:06:25 +00001034 if (!mask) {
aliguori376253e2009-03-05 23:01:23 +00001035 help_cmd(mon, "log");
bellardf193c792004-03-21 17:06:25 +00001036 return;
1037 }
1038 }
1039 cpu_set_log(mask);
1040}
1041
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001042static void do_singlestep(Monitor *mon, const QDict *qdict)
aurel321b530a62009-04-05 20:08:59 +00001043{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001044 const char *option = qdict_get_try_str(qdict, "option");
aurel321b530a62009-04-05 20:08:59 +00001045 if (!option || !strcmp(option, "on")) {
1046 singlestep = 1;
1047 } else if (!strcmp(option, "off")) {
1048 singlestep = 0;
1049 } else {
1050 monitor_printf(mon, "unexpected option %s\n", option);
1051 }
1052}
1053
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001054static void do_gdbserver(Monitor *mon, const QDict *qdict)
bellard8a7ddc32004-03-31 19:00:16 +00001055{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001056 const char *device = qdict_get_try_str(qdict, "device");
aliguori59030a82009-04-05 18:43:41 +00001057 if (!device)
1058 device = "tcp::" DEFAULT_GDBSTUB_PORT;
1059 if (gdbserver_start(device) < 0) {
1060 monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
1061 device);
1062 } else if (strcmp(device, "none") == 0) {
aliguori36556b22009-03-28 18:05:53 +00001063 monitor_printf(mon, "Disabled gdbserver\n");
bellard8a7ddc32004-03-31 19:00:16 +00001064 } else {
aliguori59030a82009-04-05 18:43:41 +00001065 monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
1066 device);
bellard8a7ddc32004-03-31 19:00:16 +00001067 }
1068}
1069
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001070static void do_watchdog_action(Monitor *mon, const QDict *qdict)
Richard W.M. Jones9dd986c2009-04-25 13:56:19 +01001071{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001072 const char *action = qdict_get_str(qdict, "action");
Richard W.M. Jones9dd986c2009-04-25 13:56:19 +01001073 if (select_watchdog_action(action) == -1) {
1074 monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
1075 }
1076}
1077
aliguori376253e2009-03-05 23:01:23 +00001078static void monitor_printc(Monitor *mon, int c)
bellard9307c4c2004-04-04 12:57:25 +00001079{
aliguori376253e2009-03-05 23:01:23 +00001080 monitor_printf(mon, "'");
bellard9307c4c2004-04-04 12:57:25 +00001081 switch(c) {
1082 case '\'':
aliguori376253e2009-03-05 23:01:23 +00001083 monitor_printf(mon, "\\'");
bellard9307c4c2004-04-04 12:57:25 +00001084 break;
1085 case '\\':
aliguori376253e2009-03-05 23:01:23 +00001086 monitor_printf(mon, "\\\\");
bellard9307c4c2004-04-04 12:57:25 +00001087 break;
1088 case '\n':
aliguori376253e2009-03-05 23:01:23 +00001089 monitor_printf(mon, "\\n");
bellard9307c4c2004-04-04 12:57:25 +00001090 break;
1091 case '\r':
aliguori376253e2009-03-05 23:01:23 +00001092 monitor_printf(mon, "\\r");
bellard9307c4c2004-04-04 12:57:25 +00001093 break;
1094 default:
1095 if (c >= 32 && c <= 126) {
aliguori376253e2009-03-05 23:01:23 +00001096 monitor_printf(mon, "%c", c);
bellard9307c4c2004-04-04 12:57:25 +00001097 } else {
aliguori376253e2009-03-05 23:01:23 +00001098 monitor_printf(mon, "\\x%02x", c);
bellard9307c4c2004-04-04 12:57:25 +00001099 }
1100 break;
1101 }
aliguori376253e2009-03-05 23:01:23 +00001102 monitor_printf(mon, "'");
bellard9307c4c2004-04-04 12:57:25 +00001103}
1104
aliguori376253e2009-03-05 23:01:23 +00001105static void memory_dump(Monitor *mon, int count, int format, int wsize,
Anthony Liguoric227f092009-10-01 16:12:16 -05001106 target_phys_addr_t addr, int is_physical)
bellard9307c4c2004-04-04 12:57:25 +00001107{
Andreas Färber9349b4f2012-03-14 01:38:32 +01001108 CPUArchState *env;
Blue Swirl23842aa2010-01-12 20:27:43 +00001109 int l, line_size, i, max_digits, len;
bellard9307c4c2004-04-04 12:57:25 +00001110 uint8_t buf[16];
1111 uint64_t v;
1112
1113 if (format == 'i') {
1114 int flags;
1115 flags = 0;
bellard6a00d602005-11-21 23:25:50 +00001116 env = mon_get_cpu();
bellard9307c4c2004-04-04 12:57:25 +00001117#ifdef TARGET_I386
bellard4c27ba22004-04-25 18:05:08 +00001118 if (wsize == 2) {
bellard9307c4c2004-04-04 12:57:25 +00001119 flags = 1;
bellard4c27ba22004-04-25 18:05:08 +00001120 } else if (wsize == 4) {
1121 flags = 0;
1122 } else {
bellard6a15fd12006-04-12 21:07:07 +00001123 /* as default we use the current CS size */
bellard4c27ba22004-04-25 18:05:08 +00001124 flags = 0;
bellard6a15fd12006-04-12 21:07:07 +00001125 if (env) {
1126#ifdef TARGET_X86_64
ths5fafdf22007-09-16 21:08:06 +00001127 if ((env->efer & MSR_EFER_LMA) &&
bellard6a15fd12006-04-12 21:07:07 +00001128 (env->segs[R_CS].flags & DESC_L_MASK))
1129 flags = 2;
1130 else
1131#endif
1132 if (!(env->segs[R_CS].flags & DESC_B_MASK))
1133 flags = 1;
1134 }
bellard4c27ba22004-04-25 18:05:08 +00001135 }
1136#endif
aliguori376253e2009-03-05 23:01:23 +00001137 monitor_disas(mon, env, addr, count, is_physical, flags);
bellard9307c4c2004-04-04 12:57:25 +00001138 return;
1139 }
1140
1141 len = wsize * count;
1142 if (wsize == 1)
1143 line_size = 8;
1144 else
1145 line_size = 16;
bellard9307c4c2004-04-04 12:57:25 +00001146 max_digits = 0;
1147
1148 switch(format) {
1149 case 'o':
1150 max_digits = (wsize * 8 + 2) / 3;
1151 break;
1152 default:
1153 case 'x':
1154 max_digits = (wsize * 8) / 4;
1155 break;
1156 case 'u':
1157 case 'd':
1158 max_digits = (wsize * 8 * 10 + 32) / 33;
1159 break;
1160 case 'c':
1161 wsize = 1;
1162 break;
1163 }
1164
1165 while (len > 0) {
blueswir17743e582007-09-24 18:39:04 +00001166 if (is_physical)
aliguori376253e2009-03-05 23:01:23 +00001167 monitor_printf(mon, TARGET_FMT_plx ":", addr);
blueswir17743e582007-09-24 18:39:04 +00001168 else
aliguori376253e2009-03-05 23:01:23 +00001169 monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
bellard9307c4c2004-04-04 12:57:25 +00001170 l = len;
1171 if (l > line_size)
1172 l = line_size;
1173 if (is_physical) {
Stefan Weil54f7b4a2011-04-10 18:23:39 +02001174 cpu_physical_memory_read(addr, buf, l);
bellard9307c4c2004-04-04 12:57:25 +00001175 } else {
bellard6a00d602005-11-21 23:25:50 +00001176 env = mon_get_cpu();
aliguoric8f79b62008-08-18 14:00:20 +00001177 if (cpu_memory_rw_debug(env, addr, buf, l, 0) < 0) {
aliguori376253e2009-03-05 23:01:23 +00001178 monitor_printf(mon, " Cannot access memory\n");
aliguoric8f79b62008-08-18 14:00:20 +00001179 break;
1180 }
bellard9307c4c2004-04-04 12:57:25 +00001181 }
ths5fafdf22007-09-16 21:08:06 +00001182 i = 0;
bellard9307c4c2004-04-04 12:57:25 +00001183 while (i < l) {
1184 switch(wsize) {
1185 default:
1186 case 1:
1187 v = ldub_raw(buf + i);
1188 break;
1189 case 2:
1190 v = lduw_raw(buf + i);
1191 break;
1192 case 4:
bellard92a31b12005-02-10 22:00:52 +00001193 v = (uint32_t)ldl_raw(buf + i);
bellard9307c4c2004-04-04 12:57:25 +00001194 break;
1195 case 8:
1196 v = ldq_raw(buf + i);
1197 break;
1198 }
aliguori376253e2009-03-05 23:01:23 +00001199 monitor_printf(mon, " ");
bellard9307c4c2004-04-04 12:57:25 +00001200 switch(format) {
1201 case 'o':
aliguori376253e2009-03-05 23:01:23 +00001202 monitor_printf(mon, "%#*" PRIo64, max_digits, v);
bellard9307c4c2004-04-04 12:57:25 +00001203 break;
1204 case 'x':
aliguori376253e2009-03-05 23:01:23 +00001205 monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
bellard9307c4c2004-04-04 12:57:25 +00001206 break;
1207 case 'u':
aliguori376253e2009-03-05 23:01:23 +00001208 monitor_printf(mon, "%*" PRIu64, max_digits, v);
bellard9307c4c2004-04-04 12:57:25 +00001209 break;
1210 case 'd':
aliguori376253e2009-03-05 23:01:23 +00001211 monitor_printf(mon, "%*" PRId64, max_digits, v);
bellard9307c4c2004-04-04 12:57:25 +00001212 break;
1213 case 'c':
aliguori376253e2009-03-05 23:01:23 +00001214 monitor_printc(mon, v);
bellard9307c4c2004-04-04 12:57:25 +00001215 break;
1216 }
1217 i += wsize;
1218 }
aliguori376253e2009-03-05 23:01:23 +00001219 monitor_printf(mon, "\n");
bellard9307c4c2004-04-04 12:57:25 +00001220 addr += l;
1221 len -= l;
1222 }
1223}
1224
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001225static void do_memory_dump(Monitor *mon, const QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +00001226{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001227 int count = qdict_get_int(qdict, "count");
1228 int format = qdict_get_int(qdict, "format");
1229 int size = qdict_get_int(qdict, "size");
1230 target_long addr = qdict_get_int(qdict, "addr");
1231
aliguori376253e2009-03-05 23:01:23 +00001232 memory_dump(mon, count, format, size, addr, 0);
bellard9307c4c2004-04-04 12:57:25 +00001233}
1234
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001235static void do_physical_memory_dump(Monitor *mon, const QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +00001236{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001237 int count = qdict_get_int(qdict, "count");
1238 int format = qdict_get_int(qdict, "format");
1239 int size = qdict_get_int(qdict, "size");
Anthony Liguoric227f092009-10-01 16:12:16 -05001240 target_phys_addr_t addr = qdict_get_int(qdict, "addr");
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001241
aliguori376253e2009-03-05 23:01:23 +00001242 memory_dump(mon, count, format, size, addr, 1);
bellard9307c4c2004-04-04 12:57:25 +00001243}
1244
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001245static void do_print(Monitor *mon, const QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +00001246{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001247 int format = qdict_get_int(qdict, "format");
Anthony Liguoric227f092009-10-01 16:12:16 -05001248 target_phys_addr_t val = qdict_get_int(qdict, "val");
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001249
bellard9307c4c2004-04-04 12:57:25 +00001250 switch(format) {
1251 case 'o':
Peter Maydell66f27e62012-06-25 16:52:24 +01001252 monitor_printf(mon, "%#" TARGET_PRIoPHYS, val);
bellard9307c4c2004-04-04 12:57:25 +00001253 break;
1254 case 'x':
Peter Maydell66f27e62012-06-25 16:52:24 +01001255 monitor_printf(mon, "%#" TARGET_PRIxPHYS, val);
bellard9307c4c2004-04-04 12:57:25 +00001256 break;
1257 case 'u':
Peter Maydell66f27e62012-06-25 16:52:24 +01001258 monitor_printf(mon, "%" TARGET_PRIuPHYS, val);
bellard9307c4c2004-04-04 12:57:25 +00001259 break;
1260 default:
1261 case 'd':
Peter Maydell66f27e62012-06-25 16:52:24 +01001262 monitor_printf(mon, "%" TARGET_PRIdPHYS, val);
bellard9307c4c2004-04-04 12:57:25 +00001263 break;
1264 case 'c':
aliguori376253e2009-03-05 23:01:23 +00001265 monitor_printc(mon, val);
bellard9307c4c2004-04-04 12:57:25 +00001266 break;
1267 }
aliguori376253e2009-03-05 23:01:23 +00001268 monitor_printf(mon, "\n");
bellard9307c4c2004-04-04 12:57:25 +00001269}
1270
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03001271static void do_sum(Monitor *mon, const QDict *qdict)
bellarde4cf1ad2005-06-04 20:15:57 +00001272{
1273 uint32_t addr;
bellarde4cf1ad2005-06-04 20:15:57 +00001274 uint16_t sum;
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03001275 uint32_t start = qdict_get_int(qdict, "start");
1276 uint32_t size = qdict_get_int(qdict, "size");
bellarde4cf1ad2005-06-04 20:15:57 +00001277
1278 sum = 0;
1279 for(addr = start; addr < (start + size); addr++) {
Stefan Weil54f7b4a2011-04-10 18:23:39 +02001280 uint8_t val = ldub_phys(addr);
bellarde4cf1ad2005-06-04 20:15:57 +00001281 /* BSD sum algorithm ('sum' Unix command) */
1282 sum = (sum >> 1) | (sum << 15);
Stefan Weil54f7b4a2011-04-10 18:23:39 +02001283 sum += val;
bellarde4cf1ad2005-06-04 20:15:57 +00001284 }
aliguori376253e2009-03-05 23:01:23 +00001285 monitor_printf(mon, "%05d\n", sum);
bellarde4cf1ad2005-06-04 20:15:57 +00001286}
1287
bellard13224a82006-07-14 22:03:35 +00001288static int mouse_button_state;
1289
Luiz Capitulino1d4daa92009-08-28 15:27:15 -03001290static void do_mouse_move(Monitor *mon, const QDict *qdict)
bellard13224a82006-07-14 22:03:35 +00001291{
1292 int dx, dy, dz;
Luiz Capitulino1d4daa92009-08-28 15:27:15 -03001293 const char *dx_str = qdict_get_str(qdict, "dx_str");
1294 const char *dy_str = qdict_get_str(qdict, "dy_str");
1295 const char *dz_str = qdict_get_try_str(qdict, "dz_str");
bellard13224a82006-07-14 22:03:35 +00001296 dx = strtol(dx_str, NULL, 0);
1297 dy = strtol(dy_str, NULL, 0);
1298 dz = 0;
ths5fafdf22007-09-16 21:08:06 +00001299 if (dz_str)
bellard13224a82006-07-14 22:03:35 +00001300 dz = strtol(dz_str, NULL, 0);
1301 kbd_mouse_event(dx, dy, dz, mouse_button_state);
1302}
1303
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001304static void do_mouse_button(Monitor *mon, const QDict *qdict)
bellard13224a82006-07-14 22:03:35 +00001305{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001306 int button_state = qdict_get_int(qdict, "button_state");
bellard13224a82006-07-14 22:03:35 +00001307 mouse_button_state = button_state;
1308 kbd_mouse_event(0, 0, 0, mouse_button_state);
1309}
1310
Luiz Capitulinoaa93e392009-08-28 15:27:18 -03001311static void do_ioport_read(Monitor *mon, const QDict *qdict)
bellard34405572004-06-08 00:55:58 +00001312{
Luiz Capitulinoaa93e392009-08-28 15:27:18 -03001313 int size = qdict_get_int(qdict, "size");
1314 int addr = qdict_get_int(qdict, "addr");
1315 int has_index = qdict_haskey(qdict, "index");
bellard34405572004-06-08 00:55:58 +00001316 uint32_t val;
1317 int suffix;
1318
1319 if (has_index) {
Luiz Capitulinoaa93e392009-08-28 15:27:18 -03001320 int index = qdict_get_int(qdict, "index");
Blue Swirlafcea8c2009-09-20 16:05:47 +00001321 cpu_outb(addr & IOPORTS_MASK, index & 0xff);
bellard34405572004-06-08 00:55:58 +00001322 addr++;
1323 }
1324 addr &= 0xffff;
1325
1326 switch(size) {
1327 default:
1328 case 1:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001329 val = cpu_inb(addr);
bellard34405572004-06-08 00:55:58 +00001330 suffix = 'b';
1331 break;
1332 case 2:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001333 val = cpu_inw(addr);
bellard34405572004-06-08 00:55:58 +00001334 suffix = 'w';
1335 break;
1336 case 4:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001337 val = cpu_inl(addr);
bellard34405572004-06-08 00:55:58 +00001338 suffix = 'l';
1339 break;
1340 }
aliguori376253e2009-03-05 23:01:23 +00001341 monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
1342 suffix, addr, size * 2, val);
bellard34405572004-06-08 00:55:58 +00001343}
bellarda3a91a32004-06-04 11:06:21 +00001344
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001345static void do_ioport_write(Monitor *mon, const QDict *qdict)
Jan Kiszkaf1147842009-07-14 10:20:11 +02001346{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001347 int size = qdict_get_int(qdict, "size");
1348 int addr = qdict_get_int(qdict, "addr");
1349 int val = qdict_get_int(qdict, "val");
1350
Jan Kiszkaf1147842009-07-14 10:20:11 +02001351 addr &= IOPORTS_MASK;
1352
1353 switch (size) {
1354 default:
1355 case 1:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001356 cpu_outb(addr, val);
Jan Kiszkaf1147842009-07-14 10:20:11 +02001357 break;
1358 case 2:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001359 cpu_outw(addr, val);
Jan Kiszkaf1147842009-07-14 10:20:11 +02001360 break;
1361 case 4:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001362 cpu_outl(addr, val);
Jan Kiszkaf1147842009-07-14 10:20:11 +02001363 break;
1364 }
1365}
1366
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001367static void do_boot_set(Monitor *mon, const QDict *qdict)
aurel320ecdffb2008-05-04 20:11:34 +00001368{
1369 int res;
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001370 const char *bootdevice = qdict_get_str(qdict, "bootdevice");
aurel320ecdffb2008-05-04 20:11:34 +00001371
Jan Kiszka76e30d02009-07-02 00:19:02 +02001372 res = qemu_boot_set(bootdevice);
1373 if (res == 0) {
1374 monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
1375 } else if (res > 0) {
1376 monitor_printf(mon, "setting boot device list failed\n");
aurel320ecdffb2008-05-04 20:11:34 +00001377 } else {
aliguori376253e2009-03-05 23:01:23 +00001378 monitor_printf(mon, "no function defined to set boot device list for "
1379 "this architecture\n");
aurel320ecdffb2008-05-04 20:11:34 +00001380 }
1381}
1382
bellardb86bda52004-09-18 19:32:46 +00001383#if defined(TARGET_I386)
Blue Swirld65aaf32010-12-11 18:56:24 +00001384static void print_pte(Monitor *mon, target_phys_addr_t addr,
1385 target_phys_addr_t pte,
1386 target_phys_addr_t mask)
bellardb86bda52004-09-18 19:32:46 +00001387{
Blue Swirld65aaf32010-12-11 18:56:24 +00001388#ifdef TARGET_X86_64
1389 if (addr & (1ULL << 47)) {
1390 addr |= -1LL << 48;
1391 }
1392#endif
1393 monitor_printf(mon, TARGET_FMT_plx ": " TARGET_FMT_plx
1394 " %c%c%c%c%c%c%c%c%c\n",
aliguori376253e2009-03-05 23:01:23 +00001395 addr,
1396 pte & mask,
Blue Swirld65aaf32010-12-11 18:56:24 +00001397 pte & PG_NX_MASK ? 'X' : '-',
aliguori376253e2009-03-05 23:01:23 +00001398 pte & PG_GLOBAL_MASK ? 'G' : '-',
1399 pte & PG_PSE_MASK ? 'P' : '-',
1400 pte & PG_DIRTY_MASK ? 'D' : '-',
1401 pte & PG_ACCESSED_MASK ? 'A' : '-',
1402 pte & PG_PCD_MASK ? 'C' : '-',
1403 pte & PG_PWT_MASK ? 'T' : '-',
1404 pte & PG_USER_MASK ? 'U' : '-',
1405 pte & PG_RW_MASK ? 'W' : '-');
bellardb86bda52004-09-18 19:32:46 +00001406}
1407
Andreas Färber9349b4f2012-03-14 01:38:32 +01001408static void tlb_info_32(Monitor *mon, CPUArchState *env)
bellardb86bda52004-09-18 19:32:46 +00001409{
Austin Clements94ac5cd2011-08-21 14:49:45 -04001410 unsigned int l1, l2;
bellardb86bda52004-09-18 19:32:46 +00001411 uint32_t pgd, pde, pte;
1412
bellardb86bda52004-09-18 19:32:46 +00001413 pgd = env->cr[3] & ~0xfff;
1414 for(l1 = 0; l1 < 1024; l1++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001415 cpu_physical_memory_read(pgd + l1 * 4, &pde, 4);
bellardb86bda52004-09-18 19:32:46 +00001416 pde = le32_to_cpu(pde);
1417 if (pde & PG_PRESENT_MASK) {
1418 if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
Blue Swirld65aaf32010-12-11 18:56:24 +00001419 /* 4M pages */
1420 print_pte(mon, (l1 << 22), pde, ~((1 << 21) - 1));
bellardb86bda52004-09-18 19:32:46 +00001421 } else {
1422 for(l2 = 0; l2 < 1024; l2++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001423 cpu_physical_memory_read((pde & ~0xfff) + l2 * 4, &pte, 4);
bellardb86bda52004-09-18 19:32:46 +00001424 pte = le32_to_cpu(pte);
1425 if (pte & PG_PRESENT_MASK) {
aliguori376253e2009-03-05 23:01:23 +00001426 print_pte(mon, (l1 << 22) + (l2 << 12),
ths5fafdf22007-09-16 21:08:06 +00001427 pte & ~PG_PSE_MASK,
bellardb86bda52004-09-18 19:32:46 +00001428 ~0xfff);
1429 }
1430 }
1431 }
1432 }
1433 }
1434}
1435
Andreas Färber9349b4f2012-03-14 01:38:32 +01001436static void tlb_info_pae32(Monitor *mon, CPUArchState *env)
Blue Swirld65aaf32010-12-11 18:56:24 +00001437{
Austin Clements94ac5cd2011-08-21 14:49:45 -04001438 unsigned int l1, l2, l3;
Blue Swirld65aaf32010-12-11 18:56:24 +00001439 uint64_t pdpe, pde, pte;
1440 uint64_t pdp_addr, pd_addr, pt_addr;
1441
1442 pdp_addr = env->cr[3] & ~0x1f;
1443 for (l1 = 0; l1 < 4; l1++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001444 cpu_physical_memory_read(pdp_addr + l1 * 8, &pdpe, 8);
Blue Swirld65aaf32010-12-11 18:56:24 +00001445 pdpe = le64_to_cpu(pdpe);
1446 if (pdpe & PG_PRESENT_MASK) {
1447 pd_addr = pdpe & 0x3fffffffff000ULL;
1448 for (l2 = 0; l2 < 512; l2++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001449 cpu_physical_memory_read(pd_addr + l2 * 8, &pde, 8);
Blue Swirld65aaf32010-12-11 18:56:24 +00001450 pde = le64_to_cpu(pde);
1451 if (pde & PG_PRESENT_MASK) {
1452 if (pde & PG_PSE_MASK) {
1453 /* 2M pages with PAE, CR4.PSE is ignored */
1454 print_pte(mon, (l1 << 30 ) + (l2 << 21), pde,
1455 ~((target_phys_addr_t)(1 << 20) - 1));
1456 } else {
1457 pt_addr = pde & 0x3fffffffff000ULL;
1458 for (l3 = 0; l3 < 512; l3++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001459 cpu_physical_memory_read(pt_addr + l3 * 8, &pte, 8);
Blue Swirld65aaf32010-12-11 18:56:24 +00001460 pte = le64_to_cpu(pte);
1461 if (pte & PG_PRESENT_MASK) {
1462 print_pte(mon, (l1 << 30 ) + (l2 << 21)
1463 + (l3 << 12),
1464 pte & ~PG_PSE_MASK,
1465 ~(target_phys_addr_t)0xfff);
1466 }
1467 }
1468 }
1469 }
1470 }
1471 }
1472 }
1473}
1474
1475#ifdef TARGET_X86_64
Andreas Färber9349b4f2012-03-14 01:38:32 +01001476static void tlb_info_64(Monitor *mon, CPUArchState *env)
Blue Swirld65aaf32010-12-11 18:56:24 +00001477{
1478 uint64_t l1, l2, l3, l4;
1479 uint64_t pml4e, pdpe, pde, pte;
1480 uint64_t pml4_addr, pdp_addr, pd_addr, pt_addr;
1481
1482 pml4_addr = env->cr[3] & 0x3fffffffff000ULL;
1483 for (l1 = 0; l1 < 512; l1++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001484 cpu_physical_memory_read(pml4_addr + l1 * 8, &pml4e, 8);
Blue Swirld65aaf32010-12-11 18:56:24 +00001485 pml4e = le64_to_cpu(pml4e);
1486 if (pml4e & PG_PRESENT_MASK) {
1487 pdp_addr = pml4e & 0x3fffffffff000ULL;
1488 for (l2 = 0; l2 < 512; l2++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001489 cpu_physical_memory_read(pdp_addr + l2 * 8, &pdpe, 8);
Blue Swirld65aaf32010-12-11 18:56:24 +00001490 pdpe = le64_to_cpu(pdpe);
1491 if (pdpe & PG_PRESENT_MASK) {
1492 if (pdpe & PG_PSE_MASK) {
1493 /* 1G pages, CR4.PSE is ignored */
1494 print_pte(mon, (l1 << 39) + (l2 << 30), pdpe,
1495 0x3ffffc0000000ULL);
1496 } else {
1497 pd_addr = pdpe & 0x3fffffffff000ULL;
1498 for (l3 = 0; l3 < 512; l3++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001499 cpu_physical_memory_read(pd_addr + l3 * 8, &pde, 8);
Blue Swirld65aaf32010-12-11 18:56:24 +00001500 pde = le64_to_cpu(pde);
1501 if (pde & PG_PRESENT_MASK) {
1502 if (pde & PG_PSE_MASK) {
1503 /* 2M pages, CR4.PSE is ignored */
1504 print_pte(mon, (l1 << 39) + (l2 << 30) +
1505 (l3 << 21), pde,
1506 0x3ffffffe00000ULL);
1507 } else {
1508 pt_addr = pde & 0x3fffffffff000ULL;
1509 for (l4 = 0; l4 < 512; l4++) {
1510 cpu_physical_memory_read(pt_addr
1511 + l4 * 8,
Stefan Weilb8b79322011-03-26 21:11:05 +01001512 &pte, 8);
Blue Swirld65aaf32010-12-11 18:56:24 +00001513 pte = le64_to_cpu(pte);
1514 if (pte & PG_PRESENT_MASK) {
1515 print_pte(mon, (l1 << 39) +
1516 (l2 << 30) +
1517 (l3 << 21) + (l4 << 12),
1518 pte & ~PG_PSE_MASK,
1519 0x3fffffffff000ULL);
1520 }
1521 }
1522 }
1523 }
1524 }
1525 }
1526 }
1527 }
1528 }
1529 }
1530}
1531#endif
1532
1533static void tlb_info(Monitor *mon)
1534{
Andreas Färber9349b4f2012-03-14 01:38:32 +01001535 CPUArchState *env;
Blue Swirld65aaf32010-12-11 18:56:24 +00001536
1537 env = mon_get_cpu();
1538
1539 if (!(env->cr[0] & CR0_PG_MASK)) {
1540 monitor_printf(mon, "PG disabled\n");
1541 return;
1542 }
1543 if (env->cr[4] & CR4_PAE_MASK) {
1544#ifdef TARGET_X86_64
1545 if (env->hflags & HF_LMA_MASK) {
1546 tlb_info_64(mon, env);
1547 } else
1548#endif
1549 {
1550 tlb_info_pae32(mon, env);
1551 }
1552 } else {
1553 tlb_info_32(mon, env);
1554 }
1555}
1556
Blue Swirl1b3cba62010-12-11 18:56:27 +00001557static void mem_print(Monitor *mon, target_phys_addr_t *pstart,
1558 int *plast_prot,
1559 target_phys_addr_t end, int prot)
bellardb86bda52004-09-18 19:32:46 +00001560{
bellard9746b152004-11-11 18:30:24 +00001561 int prot1;
1562 prot1 = *plast_prot;
1563 if (prot != prot1) {
bellardb86bda52004-09-18 19:32:46 +00001564 if (*pstart != -1) {
Blue Swirl1b3cba62010-12-11 18:56:27 +00001565 monitor_printf(mon, TARGET_FMT_plx "-" TARGET_FMT_plx " "
1566 TARGET_FMT_plx " %c%c%c\n",
aliguori376253e2009-03-05 23:01:23 +00001567 *pstart, end, end - *pstart,
1568 prot1 & PG_USER_MASK ? 'u' : '-',
1569 'r',
1570 prot1 & PG_RW_MASK ? 'w' : '-');
bellardb86bda52004-09-18 19:32:46 +00001571 }
1572 if (prot != 0)
1573 *pstart = end;
1574 else
1575 *pstart = -1;
1576 *plast_prot = prot;
1577 }
1578}
1579
Andreas Färber9349b4f2012-03-14 01:38:32 +01001580static void mem_info_32(Monitor *mon, CPUArchState *env)
bellardb86bda52004-09-18 19:32:46 +00001581{
Austin Clementsb49ca722011-08-14 23:19:21 -04001582 unsigned int l1, l2;
1583 int prot, last_prot;
Blue Swirl1b3cba62010-12-11 18:56:27 +00001584 uint32_t pgd, pde, pte;
1585 target_phys_addr_t start, end;
bellardb86bda52004-09-18 19:32:46 +00001586
bellardb86bda52004-09-18 19:32:46 +00001587 pgd = env->cr[3] & ~0xfff;
1588 last_prot = 0;
1589 start = -1;
1590 for(l1 = 0; l1 < 1024; l1++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001591 cpu_physical_memory_read(pgd + l1 * 4, &pde, 4);
bellardb86bda52004-09-18 19:32:46 +00001592 pde = le32_to_cpu(pde);
1593 end = l1 << 22;
1594 if (pde & PG_PRESENT_MASK) {
1595 if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
1596 prot = pde & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
aliguori376253e2009-03-05 23:01:23 +00001597 mem_print(mon, &start, &last_prot, end, prot);
bellardb86bda52004-09-18 19:32:46 +00001598 } else {
1599 for(l2 = 0; l2 < 1024; l2++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001600 cpu_physical_memory_read((pde & ~0xfff) + l2 * 4, &pte, 4);
bellardb86bda52004-09-18 19:32:46 +00001601 pte = le32_to_cpu(pte);
1602 end = (l1 << 22) + (l2 << 12);
1603 if (pte & PG_PRESENT_MASK) {
Austin Clementsc76c8412011-08-14 23:22:28 -04001604 prot = pte & pde &
1605 (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
bellardb86bda52004-09-18 19:32:46 +00001606 } else {
1607 prot = 0;
1608 }
aliguori376253e2009-03-05 23:01:23 +00001609 mem_print(mon, &start, &last_prot, end, prot);
bellardb86bda52004-09-18 19:32:46 +00001610 }
1611 }
1612 } else {
1613 prot = 0;
aliguori376253e2009-03-05 23:01:23 +00001614 mem_print(mon, &start, &last_prot, end, prot);
bellardb86bda52004-09-18 19:32:46 +00001615 }
1616 }
Austin Clements8a94b8ca2011-08-14 23:22:04 -04001617 /* Flush last range */
1618 mem_print(mon, &start, &last_prot, (target_phys_addr_t)1 << 32, 0);
bellardb86bda52004-09-18 19:32:46 +00001619}
Blue Swirl1b3cba62010-12-11 18:56:27 +00001620
Andreas Färber9349b4f2012-03-14 01:38:32 +01001621static void mem_info_pae32(Monitor *mon, CPUArchState *env)
Blue Swirl1b3cba62010-12-11 18:56:27 +00001622{
Austin Clementsb49ca722011-08-14 23:19:21 -04001623 unsigned int l1, l2, l3;
1624 int prot, last_prot;
Blue Swirl1b3cba62010-12-11 18:56:27 +00001625 uint64_t pdpe, pde, pte;
1626 uint64_t pdp_addr, pd_addr, pt_addr;
1627 target_phys_addr_t start, end;
1628
1629 pdp_addr = env->cr[3] & ~0x1f;
1630 last_prot = 0;
1631 start = -1;
1632 for (l1 = 0; l1 < 4; l1++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001633 cpu_physical_memory_read(pdp_addr + l1 * 8, &pdpe, 8);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001634 pdpe = le64_to_cpu(pdpe);
1635 end = l1 << 30;
1636 if (pdpe & PG_PRESENT_MASK) {
1637 pd_addr = pdpe & 0x3fffffffff000ULL;
1638 for (l2 = 0; l2 < 512; l2++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001639 cpu_physical_memory_read(pd_addr + l2 * 8, &pde, 8);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001640 pde = le64_to_cpu(pde);
1641 end = (l1 << 30) + (l2 << 21);
1642 if (pde & PG_PRESENT_MASK) {
1643 if (pde & PG_PSE_MASK) {
1644 prot = pde & (PG_USER_MASK | PG_RW_MASK |
1645 PG_PRESENT_MASK);
1646 mem_print(mon, &start, &last_prot, end, prot);
1647 } else {
1648 pt_addr = pde & 0x3fffffffff000ULL;
1649 for (l3 = 0; l3 < 512; l3++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001650 cpu_physical_memory_read(pt_addr + l3 * 8, &pte, 8);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001651 pte = le64_to_cpu(pte);
1652 end = (l1 << 30) + (l2 << 21) + (l3 << 12);
1653 if (pte & PG_PRESENT_MASK) {
Austin Clementsc76c8412011-08-14 23:22:28 -04001654 prot = pte & pde & (PG_USER_MASK | PG_RW_MASK |
1655 PG_PRESENT_MASK);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001656 } else {
1657 prot = 0;
1658 }
1659 mem_print(mon, &start, &last_prot, end, prot);
1660 }
1661 }
1662 } else {
1663 prot = 0;
1664 mem_print(mon, &start, &last_prot, end, prot);
1665 }
1666 }
1667 } else {
1668 prot = 0;
1669 mem_print(mon, &start, &last_prot, end, prot);
1670 }
1671 }
Austin Clements8a94b8ca2011-08-14 23:22:04 -04001672 /* Flush last range */
1673 mem_print(mon, &start, &last_prot, (target_phys_addr_t)1 << 32, 0);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001674}
1675
1676
1677#ifdef TARGET_X86_64
Andreas Färber9349b4f2012-03-14 01:38:32 +01001678static void mem_info_64(Monitor *mon, CPUArchState *env)
Blue Swirl1b3cba62010-12-11 18:56:27 +00001679{
1680 int prot, last_prot;
1681 uint64_t l1, l2, l3, l4;
1682 uint64_t pml4e, pdpe, pde, pte;
1683 uint64_t pml4_addr, pdp_addr, pd_addr, pt_addr, start, end;
1684
1685 pml4_addr = env->cr[3] & 0x3fffffffff000ULL;
1686 last_prot = 0;
1687 start = -1;
1688 for (l1 = 0; l1 < 512; l1++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001689 cpu_physical_memory_read(pml4_addr + l1 * 8, &pml4e, 8);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001690 pml4e = le64_to_cpu(pml4e);
1691 end = l1 << 39;
1692 if (pml4e & PG_PRESENT_MASK) {
1693 pdp_addr = pml4e & 0x3fffffffff000ULL;
1694 for (l2 = 0; l2 < 512; l2++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001695 cpu_physical_memory_read(pdp_addr + l2 * 8, &pdpe, 8);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001696 pdpe = le64_to_cpu(pdpe);
1697 end = (l1 << 39) + (l2 << 30);
1698 if (pdpe & PG_PRESENT_MASK) {
1699 if (pdpe & PG_PSE_MASK) {
Blue Swirl2d5b5072011-01-15 08:31:00 +00001700 prot = pdpe & (PG_USER_MASK | PG_RW_MASK |
1701 PG_PRESENT_MASK);
Austin Clementsc76c8412011-08-14 23:22:28 -04001702 prot &= pml4e;
Blue Swirl1b3cba62010-12-11 18:56:27 +00001703 mem_print(mon, &start, &last_prot, end, prot);
1704 } else {
1705 pd_addr = pdpe & 0x3fffffffff000ULL;
1706 for (l3 = 0; l3 < 512; l3++) {
Stefan Weilb8b79322011-03-26 21:11:05 +01001707 cpu_physical_memory_read(pd_addr + l3 * 8, &pde, 8);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001708 pde = le64_to_cpu(pde);
1709 end = (l1 << 39) + (l2 << 30) + (l3 << 21);
1710 if (pde & PG_PRESENT_MASK) {
1711 if (pde & PG_PSE_MASK) {
1712 prot = pde & (PG_USER_MASK | PG_RW_MASK |
1713 PG_PRESENT_MASK);
Austin Clementsc76c8412011-08-14 23:22:28 -04001714 prot &= pml4e & pdpe;
Blue Swirl1b3cba62010-12-11 18:56:27 +00001715 mem_print(mon, &start, &last_prot, end, prot);
1716 } else {
1717 pt_addr = pde & 0x3fffffffff000ULL;
1718 for (l4 = 0; l4 < 512; l4++) {
1719 cpu_physical_memory_read(pt_addr
1720 + l4 * 8,
Stefan Weilb8b79322011-03-26 21:11:05 +01001721 &pte, 8);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001722 pte = le64_to_cpu(pte);
1723 end = (l1 << 39) + (l2 << 30) +
1724 (l3 << 21) + (l4 << 12);
1725 if (pte & PG_PRESENT_MASK) {
1726 prot = pte & (PG_USER_MASK | PG_RW_MASK |
1727 PG_PRESENT_MASK);
Austin Clementsc76c8412011-08-14 23:22:28 -04001728 prot &= pml4e & pdpe & pde;
Blue Swirl1b3cba62010-12-11 18:56:27 +00001729 } else {
1730 prot = 0;
1731 }
1732 mem_print(mon, &start, &last_prot, end, prot);
1733 }
1734 }
1735 } else {
1736 prot = 0;
1737 mem_print(mon, &start, &last_prot, end, prot);
1738 }
1739 }
1740 }
1741 } else {
1742 prot = 0;
1743 mem_print(mon, &start, &last_prot, end, prot);
1744 }
1745 }
1746 } else {
1747 prot = 0;
1748 mem_print(mon, &start, &last_prot, end, prot);
1749 }
1750 }
Austin Clements8a94b8ca2011-08-14 23:22:04 -04001751 /* Flush last range */
1752 mem_print(mon, &start, &last_prot, (target_phys_addr_t)1 << 48, 0);
Blue Swirl1b3cba62010-12-11 18:56:27 +00001753}
1754#endif
1755
1756static void mem_info(Monitor *mon)
1757{
Andreas Färber9349b4f2012-03-14 01:38:32 +01001758 CPUArchState *env;
Blue Swirl1b3cba62010-12-11 18:56:27 +00001759
1760 env = mon_get_cpu();
1761
1762 if (!(env->cr[0] & CR0_PG_MASK)) {
1763 monitor_printf(mon, "PG disabled\n");
1764 return;
1765 }
1766 if (env->cr[4] & CR4_PAE_MASK) {
1767#ifdef TARGET_X86_64
1768 if (env->hflags & HF_LMA_MASK) {
1769 mem_info_64(mon, env);
1770 } else
1771#endif
1772 {
1773 mem_info_pae32(mon, env);
1774 }
1775 } else {
1776 mem_info_32(mon, env);
1777 }
1778}
bellardb86bda52004-09-18 19:32:46 +00001779#endif
1780
aurel327c664e22009-03-03 06:12:22 +00001781#if defined(TARGET_SH4)
1782
aliguori376253e2009-03-05 23:01:23 +00001783static void print_tlb(Monitor *mon, int idx, tlb_t *tlb)
aurel327c664e22009-03-03 06:12:22 +00001784{
aliguori376253e2009-03-05 23:01:23 +00001785 monitor_printf(mon, " tlb%i:\t"
1786 "asid=%hhu vpn=%x\tppn=%x\tsz=%hhu size=%u\t"
1787 "v=%hhu shared=%hhu cached=%hhu prot=%hhu "
1788 "dirty=%hhu writethrough=%hhu\n",
1789 idx,
1790 tlb->asid, tlb->vpn, tlb->ppn, tlb->sz, tlb->size,
1791 tlb->v, tlb->sh, tlb->c, tlb->pr,
1792 tlb->d, tlb->wt);
aurel327c664e22009-03-03 06:12:22 +00001793}
1794
aliguori376253e2009-03-05 23:01:23 +00001795static void tlb_info(Monitor *mon)
aurel327c664e22009-03-03 06:12:22 +00001796{
Andreas Färber9349b4f2012-03-14 01:38:32 +01001797 CPUArchState *env = mon_get_cpu();
aurel327c664e22009-03-03 06:12:22 +00001798 int i;
1799
aliguori376253e2009-03-05 23:01:23 +00001800 monitor_printf (mon, "ITLB:\n");
aurel327c664e22009-03-03 06:12:22 +00001801 for (i = 0 ; i < ITLB_SIZE ; i++)
aliguori376253e2009-03-05 23:01:23 +00001802 print_tlb (mon, i, &env->itlb[i]);
1803 monitor_printf (mon, "UTLB:\n");
aurel327c664e22009-03-03 06:12:22 +00001804 for (i = 0 ; i < UTLB_SIZE ; i++)
aliguori376253e2009-03-05 23:01:23 +00001805 print_tlb (mon, i, &env->utlb[i]);
aurel327c664e22009-03-03 06:12:22 +00001806}
1807
1808#endif
1809
Max Filippov692f7372012-01-07 20:02:40 +04001810#if defined(TARGET_SPARC) || defined(TARGET_PPC) || defined(TARGET_XTENSA)
Blue Swirld41160a2010-12-19 13:42:56 +00001811static void tlb_info(Monitor *mon)
1812{
Andreas Färber9349b4f2012-03-14 01:38:32 +01001813 CPUArchState *env1 = mon_get_cpu();
Blue Swirld41160a2010-12-19 13:42:56 +00001814
1815 dump_mmu((FILE*)mon, (fprintf_function)monitor_printf, env1);
1816}
1817#endif
1818
Blue Swirl314e2982011-09-11 20:22:05 +00001819static void do_info_mtree(Monitor *mon)
1820{
1821 mtree_info((fprintf_function)monitor_printf, mon);
1822}
1823
aliguori030ea372009-04-21 22:30:47 +00001824static void do_info_numa(Monitor *mon)
1825{
aliguorib28b6232009-04-22 20:20:29 +00001826 int i;
Andreas Färber9349b4f2012-03-14 01:38:32 +01001827 CPUArchState *env;
aliguori030ea372009-04-21 22:30:47 +00001828
1829 monitor_printf(mon, "%d nodes\n", nb_numa_nodes);
1830 for (i = 0; i < nb_numa_nodes; i++) {
1831 monitor_printf(mon, "node %d cpus:", i);
1832 for (env = first_cpu; env != NULL; env = env->next_cpu) {
1833 if (env->numa_node == i) {
1834 monitor_printf(mon, " %d", env->cpu_index);
1835 }
1836 }
1837 monitor_printf(mon, "\n");
1838 monitor_printf(mon, "node %d size: %" PRId64 " MB\n", i,
1839 node_mem[i] >> 20);
1840 }
1841}
1842
bellard5f1ce942006-02-08 22:40:15 +00001843#ifdef CONFIG_PROFILER
1844
Aurelien Jarnoe9a66252009-09-30 14:09:52 +02001845int64_t qemu_time;
1846int64_t dev_time;
1847
aliguori376253e2009-03-05 23:01:23 +00001848static void do_info_profile(Monitor *mon)
bellard5f1ce942006-02-08 22:40:15 +00001849{
1850 int64_t total;
1851 total = qemu_time;
1852 if (total == 0)
1853 total = 1;
aliguori376253e2009-03-05 23:01:23 +00001854 monitor_printf(mon, "async time %" PRId64 " (%0.3f)\n",
Juan Quintela6ee093c2009-09-10 03:04:26 +02001855 dev_time, dev_time / (double)get_ticks_per_sec());
aliguori376253e2009-03-05 23:01:23 +00001856 monitor_printf(mon, "qemu time %" PRId64 " (%0.3f)\n",
Juan Quintela6ee093c2009-09-10 03:04:26 +02001857 qemu_time, qemu_time / (double)get_ticks_per_sec());
bellard5f1ce942006-02-08 22:40:15 +00001858 qemu_time = 0;
bellard5f1ce942006-02-08 22:40:15 +00001859 dev_time = 0;
bellard5f1ce942006-02-08 22:40:15 +00001860}
1861#else
aliguori376253e2009-03-05 23:01:23 +00001862static void do_info_profile(Monitor *mon)
bellard5f1ce942006-02-08 22:40:15 +00001863{
aliguori376253e2009-03-05 23:01:23 +00001864 monitor_printf(mon, "Internal profiler not compiled\n");
bellard5f1ce942006-02-08 22:40:15 +00001865}
1866#endif
1867
bellardec36b692006-07-16 18:57:03 +00001868/* Capture support */
Blue Swirl72cf2d42009-09-12 07:36:22 +00001869static QLIST_HEAD (capture_list_head, CaptureState) capture_head;
bellardec36b692006-07-16 18:57:03 +00001870
aliguori376253e2009-03-05 23:01:23 +00001871static void do_info_capture(Monitor *mon)
bellardec36b692006-07-16 18:57:03 +00001872{
1873 int i;
1874 CaptureState *s;
1875
1876 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
aliguori376253e2009-03-05 23:01:23 +00001877 monitor_printf(mon, "[%d]: ", i);
bellardec36b692006-07-16 18:57:03 +00001878 s->ops.info (s->opaque);
1879 }
1880}
1881
Blue Swirl23130862009-06-06 08:22:04 +00001882#ifdef HAS_AUDIO
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001883static void do_stop_capture(Monitor *mon, const QDict *qdict)
bellardec36b692006-07-16 18:57:03 +00001884{
1885 int i;
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001886 int n = qdict_get_int(qdict, "n");
bellardec36b692006-07-16 18:57:03 +00001887 CaptureState *s;
1888
1889 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
1890 if (i == n) {
1891 s->ops.destroy (s->opaque);
Blue Swirl72cf2d42009-09-12 07:36:22 +00001892 QLIST_REMOVE (s, entries);
Anthony Liguori7267c092011-08-20 22:09:37 -05001893 g_free (s);
bellardec36b692006-07-16 18:57:03 +00001894 return;
1895 }
1896 }
1897}
1898
Luiz Capitulinoc1925482009-08-28 15:27:19 -03001899static void do_wav_capture(Monitor *mon, const QDict *qdict)
bellardec36b692006-07-16 18:57:03 +00001900{
Luiz Capitulinoc1925482009-08-28 15:27:19 -03001901 const char *path = qdict_get_str(qdict, "path");
1902 int has_freq = qdict_haskey(qdict, "freq");
1903 int freq = qdict_get_try_int(qdict, "freq", -1);
1904 int has_bits = qdict_haskey(qdict, "bits");
1905 int bits = qdict_get_try_int(qdict, "bits", -1);
1906 int has_channels = qdict_haskey(qdict, "nchannels");
1907 int nchannels = qdict_get_try_int(qdict, "nchannels", -1);
bellardec36b692006-07-16 18:57:03 +00001908 CaptureState *s;
1909
Anthony Liguori7267c092011-08-20 22:09:37 -05001910 s = g_malloc0 (sizeof (*s));
bellardec36b692006-07-16 18:57:03 +00001911
1912 freq = has_freq ? freq : 44100;
1913 bits = has_bits ? bits : 16;
1914 nchannels = has_channels ? nchannels : 2;
1915
1916 if (wav_start_capture (s, path, freq, bits, nchannels)) {
Isaku Yamahatad00b2612011-01-21 19:53:55 +09001917 monitor_printf(mon, "Failed to add wave capture\n");
Anthony Liguori7267c092011-08-20 22:09:37 -05001918 g_free (s);
Isaku Yamahatad00b2612011-01-21 19:53:55 +09001919 return;
bellardec36b692006-07-16 18:57:03 +00001920 }
Blue Swirl72cf2d42009-09-12 07:36:22 +00001921 QLIST_INSERT_HEAD (&capture_head, s, entries);
bellardec36b692006-07-16 18:57:03 +00001922}
1923#endif
1924
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001925static qemu_acl *find_acl(Monitor *mon, const char *name)
aliguori76655d62009-03-06 20:27:37 +00001926{
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001927 qemu_acl *acl = qemu_acl_find(name);
aliguori76655d62009-03-06 20:27:37 +00001928
aliguori76655d62009-03-06 20:27:37 +00001929 if (!acl) {
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001930 monitor_printf(mon, "acl: unknown list '%s'\n", name);
aliguori76655d62009-03-06 20:27:37 +00001931 }
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001932 return acl;
1933}
aliguori76655d62009-03-06 20:27:37 +00001934
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001935static void do_acl_show(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001936{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001937 const char *aclname = qdict_get_str(qdict, "aclname");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001938 qemu_acl *acl = find_acl(mon, aclname);
1939 qemu_acl_entry *entry;
1940 int i = 0;
1941
1942 if (acl) {
aliguori28a76be2009-03-06 20:27:40 +00001943 monitor_printf(mon, "policy: %s\n",
aliguori76655d62009-03-06 20:27:37 +00001944 acl->defaultDeny ? "deny" : "allow");
Blue Swirl72cf2d42009-09-12 07:36:22 +00001945 QTAILQ_FOREACH(entry, &acl->entries, next) {
aliguori28a76be2009-03-06 20:27:40 +00001946 i++;
1947 monitor_printf(mon, "%d: %s %s\n", i,
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001948 entry->deny ? "deny" : "allow", entry->match);
aliguori28a76be2009-03-06 20:27:40 +00001949 }
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001950 }
1951}
1952
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001953static void do_acl_reset(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001954{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001955 const char *aclname = qdict_get_str(qdict, "aclname");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001956 qemu_acl *acl = find_acl(mon, aclname);
1957
1958 if (acl) {
aliguori28a76be2009-03-06 20:27:40 +00001959 qemu_acl_reset(acl);
1960 monitor_printf(mon, "acl: removed all rules\n");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001961 }
1962}
aliguori76655d62009-03-06 20:27:37 +00001963
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03001964static void do_acl_policy(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001965{
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03001966 const char *aclname = qdict_get_str(qdict, "aclname");
1967 const char *policy = qdict_get_str(qdict, "policy");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001968 qemu_acl *acl = find_acl(mon, aclname);
1969
1970 if (acl) {
1971 if (strcmp(policy, "allow") == 0) {
aliguori28a76be2009-03-06 20:27:40 +00001972 acl->defaultDeny = 0;
1973 monitor_printf(mon, "acl: policy set to 'allow'\n");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001974 } else if (strcmp(policy, "deny") == 0) {
aliguori28a76be2009-03-06 20:27:40 +00001975 acl->defaultDeny = 1;
1976 monitor_printf(mon, "acl: policy set to 'deny'\n");
1977 } else {
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001978 monitor_printf(mon, "acl: unknown policy '%s', "
1979 "expected 'deny' or 'allow'\n", policy);
aliguori28a76be2009-03-06 20:27:40 +00001980 }
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001981 }
1982}
aliguori76655d62009-03-06 20:27:37 +00001983
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001984static void do_acl_add(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001985{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001986 const char *aclname = qdict_get_str(qdict, "aclname");
1987 const char *match = qdict_get_str(qdict, "match");
1988 const char *policy = qdict_get_str(qdict, "policy");
1989 int has_index = qdict_haskey(qdict, "index");
1990 int index = qdict_get_try_int(qdict, "index", -1);
Jan Kiszka15dfcd42009-06-25 08:22:08 +02001991 qemu_acl *acl = find_acl(mon, aclname);
1992 int deny, ret;
1993
1994 if (acl) {
1995 if (strcmp(policy, "allow") == 0) {
1996 deny = 0;
1997 } else if (strcmp(policy, "deny") == 0) {
1998 deny = 1;
1999 } else {
2000 monitor_printf(mon, "acl: unknown policy '%s', "
2001 "expected 'deny' or 'allow'\n", policy);
aliguori28a76be2009-03-06 20:27:40 +00002002 return;
2003 }
aliguori28a76be2009-03-06 20:27:40 +00002004 if (has_index)
2005 ret = qemu_acl_insert(acl, deny, match, index);
2006 else
2007 ret = qemu_acl_append(acl, deny, match);
2008 if (ret < 0)
2009 monitor_printf(mon, "acl: unable to add acl entry\n");
2010 else
2011 monitor_printf(mon, "acl: added rule at position %d\n", ret);
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002012 }
2013}
aliguori76655d62009-03-06 20:27:37 +00002014
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03002015static void do_acl_remove(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002016{
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03002017 const char *aclname = qdict_get_str(qdict, "aclname");
2018 const char *match = qdict_get_str(qdict, "match");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002019 qemu_acl *acl = find_acl(mon, aclname);
2020 int ret;
aliguori76655d62009-03-06 20:27:37 +00002021
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002022 if (acl) {
aliguori28a76be2009-03-06 20:27:40 +00002023 ret = qemu_acl_remove(acl, match);
2024 if (ret < 0)
2025 monitor_printf(mon, "acl: no matching acl entry\n");
2026 else
2027 monitor_printf(mon, "acl: removed rule at position %d\n", ret);
aliguori76655d62009-03-06 20:27:37 +00002028 }
2029}
2030
Huang Ying79c4f6b2009-06-23 10:05:14 +08002031#if defined(TARGET_I386)
Luiz Capitulino37b7ad42009-08-28 15:27:21 -03002032static void do_inject_mce(Monitor *mon, const QDict *qdict)
Huang Ying79c4f6b2009-06-23 10:05:14 +08002033{
Andreas Färber9349b4f2012-03-14 01:38:32 +01002034 CPUArchState *cenv;
Luiz Capitulino37b7ad42009-08-28 15:27:21 -03002035 int cpu_index = qdict_get_int(qdict, "cpu_index");
2036 int bank = qdict_get_int(qdict, "bank");
2037 uint64_t status = qdict_get_int(qdict, "status");
2038 uint64_t mcg_status = qdict_get_int(qdict, "mcg_status");
2039 uint64_t addr = qdict_get_int(qdict, "addr");
2040 uint64_t misc = qdict_get_int(qdict, "misc");
Jan Kiszka747461c2011-03-02 08:56:10 +01002041 int flags = MCE_INJECT_UNCOND_AO;
Huang Ying79c4f6b2009-06-23 10:05:14 +08002042
Jan Kiszka747461c2011-03-02 08:56:10 +01002043 if (qdict_get_try_bool(qdict, "broadcast", 0)) {
2044 flags |= MCE_INJECT_BROADCAST;
2045 }
Jin Dongming31ce5e02010-12-10 17:21:02 +09002046 for (cenv = first_cpu; cenv != NULL; cenv = cenv->next_cpu) {
Jan Kiszka316378e2011-03-02 08:56:09 +01002047 if (cenv->cpu_index == cpu_index) {
2048 cpu_x86_inject_mce(mon, cenv, bank, status, mcg_status, addr, misc,
Jan Kiszka747461c2011-03-02 08:56:10 +01002049 flags);
Huang Ying79c4f6b2009-06-23 10:05:14 +08002050 break;
2051 }
Jin Dongming31ce5e02010-12-10 17:21:02 +09002052 }
Huang Ying79c4f6b2009-06-23 10:05:14 +08002053}
2054#endif
2055
Corey Bryant208c9d12012-06-22 14:36:09 -04002056void qmp_getfd(const char *fdname, Error **errp)
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002057{
Anthony Liguoric227f092009-10-01 16:12:16 -05002058 mon_fd_t *monfd;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002059 int fd;
2060
Corey Bryant208c9d12012-06-22 14:36:09 -04002061 fd = qemu_chr_fe_get_msgfd(cur_mon->chr);
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002062 if (fd == -1) {
Corey Bryant208c9d12012-06-22 14:36:09 -04002063 error_set(errp, QERR_FD_NOT_SUPPLIED);
2064 return;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002065 }
2066
2067 if (qemu_isdigit(fdname[0])) {
Corey Bryant208c9d12012-06-22 14:36:09 -04002068 error_set(errp, QERR_INVALID_PARAMETER_VALUE, "fdname",
2069 "a name not starting with a digit");
2070 return;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002071 }
2072
Corey Bryant208c9d12012-06-22 14:36:09 -04002073 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002074 if (strcmp(monfd->name, fdname) != 0) {
2075 continue;
2076 }
2077
2078 close(monfd->fd);
2079 monfd->fd = fd;
Corey Bryant208c9d12012-06-22 14:36:09 -04002080 return;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002081 }
2082
Anthony Liguori7267c092011-08-20 22:09:37 -05002083 monfd = g_malloc0(sizeof(mon_fd_t));
2084 monfd->name = g_strdup(fdname);
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002085 monfd->fd = fd;
2086
Corey Bryant208c9d12012-06-22 14:36:09 -04002087 QLIST_INSERT_HEAD(&cur_mon->fds, monfd, next);
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002088}
2089
Corey Bryant208c9d12012-06-22 14:36:09 -04002090void qmp_closefd(const char *fdname, Error **errp)
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002091{
Anthony Liguoric227f092009-10-01 16:12:16 -05002092 mon_fd_t *monfd;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002093
Corey Bryant208c9d12012-06-22 14:36:09 -04002094 QLIST_FOREACH(monfd, &cur_mon->fds, next) {
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002095 if (strcmp(monfd->name, fdname) != 0) {
2096 continue;
2097 }
2098
Blue Swirl72cf2d42009-09-12 07:36:22 +00002099 QLIST_REMOVE(monfd, next);
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002100 close(monfd->fd);
Anthony Liguori7267c092011-08-20 22:09:37 -05002101 g_free(monfd->name);
2102 g_free(monfd);
Corey Bryant208c9d12012-06-22 14:36:09 -04002103 return;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002104 }
2105
Corey Bryant208c9d12012-06-22 14:36:09 -04002106 error_set(errp, QERR_FD_NOT_FOUND, fdname);
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002107}
2108
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002109static void do_loadvm(Monitor *mon, const QDict *qdict)
Juan Quintelac8d41b22009-08-20 19:42:21 +02002110{
Luiz Capitulino13548692011-07-29 15:36:43 -03002111 int saved_vm_running = runstate_is_running();
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002112 const char *name = qdict_get_str(qdict, "name");
Juan Quintelac8d41b22009-08-20 19:42:21 +02002113
Luiz Capitulino0461d5a2011-09-30 14:45:27 -03002114 vm_stop(RUN_STATE_RESTORE_VM);
Juan Quintelac8d41b22009-08-20 19:42:21 +02002115
Miguel Di Ciurcio Filhof0aa7a82010-07-19 15:25:01 -03002116 if (load_vmstate(name) == 0 && saved_vm_running) {
Juan Quintelac8d41b22009-08-20 19:42:21 +02002117 vm_start();
Miguel Di Ciurcio Filhof0aa7a82010-07-19 15:25:01 -03002118 }
Juan Quintelac8d41b22009-08-20 19:42:21 +02002119}
2120
Paolo Bonzinia9940fc2012-09-20 16:50:32 +02002121int monitor_get_fd(Monitor *mon, const char *fdname, Error **errp)
Mark McLoughlin7768e042009-07-22 09:11:41 +01002122{
Anthony Liguoric227f092009-10-01 16:12:16 -05002123 mon_fd_t *monfd;
Mark McLoughlin7768e042009-07-22 09:11:41 +01002124
Blue Swirl72cf2d42009-09-12 07:36:22 +00002125 QLIST_FOREACH(monfd, &mon->fds, next) {
Mark McLoughlin7768e042009-07-22 09:11:41 +01002126 int fd;
2127
2128 if (strcmp(monfd->name, fdname) != 0) {
2129 continue;
2130 }
2131
2132 fd = monfd->fd;
2133
2134 /* caller takes ownership of fd */
Blue Swirl72cf2d42009-09-12 07:36:22 +00002135 QLIST_REMOVE(monfd, next);
Anthony Liguori7267c092011-08-20 22:09:37 -05002136 g_free(monfd->name);
2137 g_free(monfd);
Mark McLoughlin7768e042009-07-22 09:11:41 +01002138
2139 return fd;
2140 }
2141
Paolo Bonzinia9940fc2012-09-20 16:50:32 +02002142 error_setg(errp, "File descriptor named '%s' has not been found", fdname);
Mark McLoughlin7768e042009-07-22 09:11:41 +01002143 return -1;
2144}
2145
Corey Bryantba1c0482012-08-14 16:43:43 -04002146static void monitor_fdset_cleanup(MonFdset *mon_fdset)
2147{
2148 MonFdsetFd *mon_fdset_fd;
2149 MonFdsetFd *mon_fdset_fd_next;
2150
2151 QLIST_FOREACH_SAFE(mon_fdset_fd, &mon_fdset->fds, next, mon_fdset_fd_next) {
Corey Bryantefb87c12012-08-14 16:43:48 -04002152 if (mon_fdset_fd->removed ||
2153 (QLIST_EMPTY(&mon_fdset->dup_fds) && mon_refcount == 0)) {
Corey Bryantba1c0482012-08-14 16:43:43 -04002154 close(mon_fdset_fd->fd);
2155 g_free(mon_fdset_fd->opaque);
2156 QLIST_REMOVE(mon_fdset_fd, next);
2157 g_free(mon_fdset_fd);
2158 }
2159 }
2160
Corey Bryantadb696f2012-08-14 16:43:47 -04002161 if (QLIST_EMPTY(&mon_fdset->fds) && QLIST_EMPTY(&mon_fdset->dup_fds)) {
Corey Bryantba1c0482012-08-14 16:43:43 -04002162 QLIST_REMOVE(mon_fdset, next);
2163 g_free(mon_fdset);
2164 }
2165}
2166
Corey Bryantefb87c12012-08-14 16:43:48 -04002167static void monitor_fdsets_cleanup(void)
2168{
2169 MonFdset *mon_fdset;
2170 MonFdset *mon_fdset_next;
2171
2172 QLIST_FOREACH_SAFE(mon_fdset, &mon_fdsets, next, mon_fdset_next) {
2173 monitor_fdset_cleanup(mon_fdset);
2174 }
2175}
2176
Corey Bryantba1c0482012-08-14 16:43:43 -04002177AddfdInfo *qmp_add_fd(bool has_fdset_id, int64_t fdset_id, bool has_opaque,
2178 const char *opaque, Error **errp)
2179{
2180 int fd;
2181 Monitor *mon = cur_mon;
2182 MonFdset *mon_fdset;
2183 MonFdsetFd *mon_fdset_fd;
2184 AddfdInfo *fdinfo;
2185
2186 fd = qemu_chr_fe_get_msgfd(mon->chr);
2187 if (fd == -1) {
2188 error_set(errp, QERR_FD_NOT_SUPPLIED);
2189 goto error;
2190 }
2191
2192 if (has_fdset_id) {
2193 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2194 if (mon_fdset->id == fdset_id) {
2195 break;
2196 }
2197 }
2198 if (mon_fdset == NULL) {
2199 error_set(errp, QERR_INVALID_PARAMETER_VALUE, "fdset-id",
2200 "an existing fdset-id");
2201 goto error;
2202 }
2203 } else {
2204 int64_t fdset_id_prev = -1;
2205 MonFdset *mon_fdset_cur = QLIST_FIRST(&mon_fdsets);
2206
2207 /* Use first available fdset ID */
2208 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2209 mon_fdset_cur = mon_fdset;
2210 if (fdset_id_prev == mon_fdset_cur->id - 1) {
2211 fdset_id_prev = mon_fdset_cur->id;
2212 continue;
2213 }
2214 break;
2215 }
2216
2217 mon_fdset = g_malloc0(sizeof(*mon_fdset));
2218 mon_fdset->id = fdset_id_prev + 1;
2219
2220 /* The fdset list is ordered by fdset ID */
2221 if (mon_fdset->id == 0) {
2222 QLIST_INSERT_HEAD(&mon_fdsets, mon_fdset, next);
2223 } else if (mon_fdset->id < mon_fdset_cur->id) {
2224 QLIST_INSERT_BEFORE(mon_fdset_cur, mon_fdset, next);
2225 } else {
2226 QLIST_INSERT_AFTER(mon_fdset_cur, mon_fdset, next);
2227 }
2228 }
2229
2230 mon_fdset_fd = g_malloc0(sizeof(*mon_fdset_fd));
2231 mon_fdset_fd->fd = fd;
2232 mon_fdset_fd->removed = false;
2233 if (has_opaque) {
2234 mon_fdset_fd->opaque = g_strdup(opaque);
2235 }
2236 QLIST_INSERT_HEAD(&mon_fdset->fds, mon_fdset_fd, next);
2237
2238 fdinfo = g_malloc0(sizeof(*fdinfo));
2239 fdinfo->fdset_id = mon_fdset->id;
2240 fdinfo->fd = mon_fdset_fd->fd;
2241
2242 return fdinfo;
2243
2244error:
2245 if (fd != -1) {
2246 close(fd);
2247 }
2248 return NULL;
2249}
2250
2251void qmp_remove_fd(int64_t fdset_id, bool has_fd, int64_t fd, Error **errp)
2252{
2253 MonFdset *mon_fdset;
2254 MonFdsetFd *mon_fdset_fd;
2255 char fd_str[60];
2256
2257 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2258 if (mon_fdset->id != fdset_id) {
2259 continue;
2260 }
2261 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2262 if (has_fd) {
2263 if (mon_fdset_fd->fd != fd) {
2264 continue;
2265 }
2266 mon_fdset_fd->removed = true;
2267 break;
2268 } else {
2269 mon_fdset_fd->removed = true;
2270 }
2271 }
2272 if (has_fd && !mon_fdset_fd) {
2273 goto error;
2274 }
2275 monitor_fdset_cleanup(mon_fdset);
2276 return;
2277 }
2278
2279error:
2280 if (has_fd) {
2281 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64 ", fd:%" PRId64,
2282 fdset_id, fd);
2283 } else {
2284 snprintf(fd_str, sizeof(fd_str), "fdset-id:%" PRId64, fdset_id);
2285 }
2286 error_set(errp, QERR_FD_NOT_FOUND, fd_str);
2287}
2288
2289FdsetInfoList *qmp_query_fdsets(Error **errp)
2290{
2291 MonFdset *mon_fdset;
2292 MonFdsetFd *mon_fdset_fd;
2293 FdsetInfoList *fdset_list = NULL;
2294
2295 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2296 FdsetInfoList *fdset_info = g_malloc0(sizeof(*fdset_info));
2297 FdsetFdInfoList *fdsetfd_list = NULL;
2298
2299 fdset_info->value = g_malloc0(sizeof(*fdset_info->value));
2300 fdset_info->value->fdset_id = mon_fdset->id;
2301
2302 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2303 FdsetFdInfoList *fdsetfd_info;
2304
2305 fdsetfd_info = g_malloc0(sizeof(*fdsetfd_info));
2306 fdsetfd_info->value = g_malloc0(sizeof(*fdsetfd_info->value));
2307 fdsetfd_info->value->fd = mon_fdset_fd->fd;
2308 if (mon_fdset_fd->opaque) {
2309 fdsetfd_info->value->has_opaque = true;
2310 fdsetfd_info->value->opaque = g_strdup(mon_fdset_fd->opaque);
2311 } else {
2312 fdsetfd_info->value->has_opaque = false;
2313 }
2314
2315 fdsetfd_info->next = fdsetfd_list;
2316 fdsetfd_list = fdsetfd_info;
2317 }
2318
2319 fdset_info->value->fds = fdsetfd_list;
2320
2321 fdset_info->next = fdset_list;
2322 fdset_list = fdset_info;
2323 }
2324
2325 return fdset_list;
2326}
2327
Corey Bryantadb696f2012-08-14 16:43:47 -04002328int monitor_fdset_get_fd(int64_t fdset_id, int flags)
2329{
Blue Swirlb2dc64c2012-08-18 20:14:54 +00002330#ifndef _WIN32
Corey Bryantadb696f2012-08-14 16:43:47 -04002331 MonFdset *mon_fdset;
2332 MonFdsetFd *mon_fdset_fd;
2333 int mon_fd_flags;
2334
Corey Bryantadb696f2012-08-14 16:43:47 -04002335 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2336 if (mon_fdset->id != fdset_id) {
2337 continue;
2338 }
2339 QLIST_FOREACH(mon_fdset_fd, &mon_fdset->fds, next) {
2340 mon_fd_flags = fcntl(mon_fdset_fd->fd, F_GETFL);
2341 if (mon_fd_flags == -1) {
2342 return -1;
2343 }
2344
2345 if ((flags & O_ACCMODE) == (mon_fd_flags & O_ACCMODE)) {
2346 return mon_fdset_fd->fd;
2347 }
2348 }
2349 errno = EACCES;
2350 return -1;
2351 }
2352#endif
2353
2354 errno = ENOENT;
2355 return -1;
2356}
2357
2358int monitor_fdset_dup_fd_add(int64_t fdset_id, int dup_fd)
2359{
2360 MonFdset *mon_fdset;
2361 MonFdsetFd *mon_fdset_fd_dup;
2362
2363 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2364 if (mon_fdset->id != fdset_id) {
2365 continue;
2366 }
2367 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2368 if (mon_fdset_fd_dup->fd == dup_fd) {
2369 return -1;
2370 }
2371 }
2372 mon_fdset_fd_dup = g_malloc0(sizeof(*mon_fdset_fd_dup));
2373 mon_fdset_fd_dup->fd = dup_fd;
2374 QLIST_INSERT_HEAD(&mon_fdset->dup_fds, mon_fdset_fd_dup, next);
2375 return 0;
2376 }
2377 return -1;
2378}
2379
2380static int monitor_fdset_dup_fd_find_remove(int dup_fd, bool remove)
2381{
2382 MonFdset *mon_fdset;
2383 MonFdsetFd *mon_fdset_fd_dup;
2384
2385 QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
2386 QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
2387 if (mon_fdset_fd_dup->fd == dup_fd) {
2388 if (remove) {
2389 QLIST_REMOVE(mon_fdset_fd_dup, next);
2390 if (QLIST_EMPTY(&mon_fdset->dup_fds)) {
2391 monitor_fdset_cleanup(mon_fdset);
2392 }
2393 }
2394 return mon_fdset->id;
2395 }
2396 }
2397 }
2398 return -1;
2399}
2400
2401int monitor_fdset_dup_fd_find(int dup_fd)
2402{
2403 return monitor_fdset_dup_fd_find_remove(dup_fd, false);
2404}
2405
2406int monitor_fdset_dup_fd_remove(int dup_fd)
2407{
2408 return monitor_fdset_dup_fd_find_remove(dup_fd, true);
2409}
2410
Nicholas Bellingera96ed022012-08-21 20:52:07 +00002411int monitor_handle_fd_param(Monitor *mon, const char *fdname)
2412{
2413 int fd;
Paolo Bonzinia9940fc2012-09-20 16:50:32 +02002414 Error *local_err = NULL;
Nicholas Bellingera96ed022012-08-21 20:52:07 +00002415
2416 if (!qemu_isdigit(fdname[0]) && mon) {
2417
Paolo Bonzinia9940fc2012-09-20 16:50:32 +02002418 fd = monitor_get_fd(mon, fdname, &local_err);
Nicholas Bellingera96ed022012-08-21 20:52:07 +00002419 if (fd == -1) {
Paolo Bonzinia9940fc2012-09-20 16:50:32 +02002420 qerror_report_err(local_err);
2421 error_free(local_err);
Nicholas Bellingera96ed022012-08-21 20:52:07 +00002422 return -1;
2423 }
2424 } else {
2425 fd = qemu_parse_fd(fdname);
2426 }
2427
2428 return fd;
2429}
2430
Wayne Xia816f8922011-10-12 11:32:41 +08002431/* mon_cmds and info_cmds would be sorted at runtime */
2432static mon_cmd_t mon_cmds[] = {
Luiz Capitulinoacd0a092010-09-30 16:00:22 -03002433#include "hmp-commands.h"
ths5fafdf22007-09-16 21:08:06 +00002434 { NULL, NULL, },
bellard9dc39cb2004-03-14 21:38:27 +00002435};
2436
Luiz Capitulinoacd0a092010-09-30 16:00:22 -03002437/* Please update hmp-commands.hx when adding or changing commands */
Wayne Xia816f8922011-10-12 11:32:41 +08002438static mon_cmd_t info_cmds[] = {
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002439 {
2440 .name = "version",
2441 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002442 .params = "",
2443 .help = "show the version of QEMU",
Luiz Capitulinob9c15f12011-08-26 17:38:13 -03002444 .mhandler.info = hmp_info_version,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002445 },
2446 {
2447 .name = "network",
2448 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002449 .params = "",
2450 .help = "show the network state",
Luiz Capitulino910df892009-10-07 13:41:51 -03002451 .mhandler.info = do_info_network,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002452 },
2453 {
2454 .name = "chardev",
2455 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002456 .params = "",
2457 .help = "show the character devices",
Luiz Capitulinoc5a415a2011-09-14 16:05:49 -03002458 .mhandler.info = hmp_info_chardev,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002459 },
2460 {
2461 .name = "block",
2462 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002463 .params = "",
2464 .help = "show the block devices",
Luiz Capitulinob2023812011-09-21 17:16:47 -03002465 .mhandler.info = hmp_info_block,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002466 },
2467 {
2468 .name = "blockstats",
2469 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002470 .params = "",
2471 .help = "show block device statistics",
Luiz Capitulinof11f57e2011-09-22 15:56:36 -03002472 .mhandler.info = hmp_info_blockstats,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002473 },
2474 {
Stefan Hajnoczifb5458c2012-01-18 14:40:49 +00002475 .name = "block-jobs",
2476 .args_type = "",
2477 .params = "",
2478 .help = "show progress of ongoing block device operations",
2479 .mhandler.info = hmp_info_block_jobs,
2480 },
2481 {
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002482 .name = "registers",
2483 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002484 .params = "",
2485 .help = "show the cpu registers",
Luiz Capitulino910df892009-10-07 13:41:51 -03002486 .mhandler.info = do_info_registers,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002487 },
2488 {
2489 .name = "cpus",
2490 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002491 .params = "",
2492 .help = "show infos for each CPU",
Luiz Capitulinode0b36b2011-09-21 16:38:35 -03002493 .mhandler.info = hmp_info_cpus,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002494 },
2495 {
2496 .name = "history",
2497 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002498 .params = "",
2499 .help = "show the command line history",
Luiz Capitulino910df892009-10-07 13:41:51 -03002500 .mhandler.info = do_info_history,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002501 },
Jan Kiszka661f1922011-10-16 11:53:13 +02002502#if defined(TARGET_I386) || defined(TARGET_PPC) || defined(TARGET_MIPS) || \
2503 defined(TARGET_LM32) || (defined(TARGET_SPARC) && !defined(TARGET_SPARC64))
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002504 {
2505 .name = "irq",
2506 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002507 .params = "",
2508 .help = "show the interrupts statistics (if available)",
Jan Kiszka661f1922011-10-16 11:53:13 +02002509#ifdef TARGET_SPARC
2510 .mhandler.info = sun4m_irq_info,
2511#elif defined(TARGET_LM32)
2512 .mhandler.info = lm32_irq_info,
2513#else
Luiz Capitulino910df892009-10-07 13:41:51 -03002514 .mhandler.info = irq_info,
Jan Kiszka661f1922011-10-16 11:53:13 +02002515#endif
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002516 },
2517 {
2518 .name = "pic",
2519 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002520 .params = "",
2521 .help = "show i8259 (PIC) state",
Jan Kiszka661f1922011-10-16 11:53:13 +02002522#ifdef TARGET_SPARC
2523 .mhandler.info = sun4m_pic_info,
2524#elif defined(TARGET_LM32)
2525 .mhandler.info = lm32_do_pic_info,
2526#else
Luiz Capitulino910df892009-10-07 13:41:51 -03002527 .mhandler.info = pic_info,
Jan Kiszka661f1922011-10-16 11:53:13 +02002528#endif
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002529 },
Jan Kiszka661f1922011-10-16 11:53:13 +02002530#endif
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002531 {
2532 .name = "pci",
2533 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002534 .params = "",
2535 .help = "show PCI info",
Luiz Capitulino79627472011-10-21 14:15:33 -02002536 .mhandler.info = hmp_info_pci,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002537 },
Scott Woodbebabbc2011-08-18 10:38:42 +00002538#if defined(TARGET_I386) || defined(TARGET_SH4) || defined(TARGET_SPARC) || \
Max Filippov692f7372012-01-07 20:02:40 +04002539 defined(TARGET_PPC) || defined(TARGET_XTENSA)
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002540 {
2541 .name = "tlb",
2542 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002543 .params = "",
2544 .help = "show virtual to physical memory mappings",
Luiz Capitulino910df892009-10-07 13:41:51 -03002545 .mhandler.info = tlb_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002546 },
aurel327c664e22009-03-03 06:12:22 +00002547#endif
2548#if defined(TARGET_I386)
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002549 {
2550 .name = "mem",
2551 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002552 .params = "",
2553 .help = "show the active virtual memory mappings",
Luiz Capitulino910df892009-10-07 13:41:51 -03002554 .mhandler.info = mem_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002555 },
bellardb86bda52004-09-18 19:32:46 +00002556#endif
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002557 {
Blue Swirl314e2982011-09-11 20:22:05 +00002558 .name = "mtree",
2559 .args_type = "",
2560 .params = "",
2561 .help = "show memory tree",
2562 .mhandler.info = do_info_mtree,
2563 },
2564 {
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002565 .name = "jit",
2566 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002567 .params = "",
2568 .help = "show dynamic compiler info",
Luiz Capitulino910df892009-10-07 13:41:51 -03002569 .mhandler.info = do_info_jit,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002570 },
2571 {
2572 .name = "kvm",
2573 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002574 .params = "",
2575 .help = "show KVM information",
Luiz Capitulino292a2602011-09-12 15:10:53 -03002576 .mhandler.info = hmp_info_kvm,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002577 },
2578 {
2579 .name = "numa",
2580 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002581 .params = "",
2582 .help = "show NUMA information",
Luiz Capitulino910df892009-10-07 13:41:51 -03002583 .mhandler.info = do_info_numa,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002584 },
2585 {
2586 .name = "usb",
2587 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002588 .params = "",
2589 .help = "show guest USB devices",
Luiz Capitulino910df892009-10-07 13:41:51 -03002590 .mhandler.info = usb_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002591 },
2592 {
2593 .name = "usbhost",
2594 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002595 .params = "",
2596 .help = "show host USB devices",
Luiz Capitulino910df892009-10-07 13:41:51 -03002597 .mhandler.info = usb_host_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002598 },
2599 {
2600 .name = "profile",
2601 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002602 .params = "",
2603 .help = "show profiling information",
Luiz Capitulino910df892009-10-07 13:41:51 -03002604 .mhandler.info = do_info_profile,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002605 },
2606 {
2607 .name = "capture",
2608 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002609 .params = "",
2610 .help = "show capture information",
Luiz Capitulino910df892009-10-07 13:41:51 -03002611 .mhandler.info = do_info_capture,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002612 },
2613 {
2614 .name = "snapshots",
2615 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002616 .params = "",
2617 .help = "show the currently saved VM snapshots",
Luiz Capitulino910df892009-10-07 13:41:51 -03002618 .mhandler.info = do_info_snapshots,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002619 },
2620 {
2621 .name = "status",
2622 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002623 .params = "",
2624 .help = "show the current VM status (running|paused)",
Luiz Capitulino1fa9a5e2011-09-12 17:54:20 -03002625 .mhandler.info = hmp_info_status,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002626 },
2627 {
2628 .name = "pcmcia",
2629 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002630 .params = "",
2631 .help = "show guest PCMCIA status",
Luiz Capitulino910df892009-10-07 13:41:51 -03002632 .mhandler.info = pcmcia_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002633 },
2634 {
2635 .name = "mice",
2636 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002637 .params = "",
2638 .help = "show which guest mouse is receiving events",
Luiz Capitulinoe235cec2011-09-21 15:29:55 -03002639 .mhandler.info = hmp_info_mice,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002640 },
2641 {
2642 .name = "vnc",
2643 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002644 .params = "",
2645 .help = "show the vnc server status",
Luiz Capitulino2b54aa82011-10-17 16:41:22 -02002646 .mhandler.info = hmp_info_vnc,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002647 },
Gerd Hoffmanncb42a872010-11-30 11:02:51 +01002648#if defined(CONFIG_SPICE)
2649 {
2650 .name = "spice",
2651 .args_type = "",
2652 .params = "",
2653 .help = "show the spice server status",
Luiz Capitulinod1f29642011-10-20 17:01:33 -02002654 .mhandler.info = hmp_info_spice,
Gerd Hoffmanncb42a872010-11-30 11:02:51 +01002655 },
2656#endif
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002657 {
2658 .name = "name",
2659 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002660 .params = "",
2661 .help = "show the current VM name",
Anthony Liguori48a32be2011-09-02 12:34:48 -05002662 .mhandler.info = hmp_info_name,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002663 },
2664 {
2665 .name = "uuid",
2666 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002667 .params = "",
2668 .help = "show the current VM UUID",
Luiz Capitulinoefab7672011-09-13 17:16:25 -03002669 .mhandler.info = hmp_info_uuid,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002670 },
j_mayer76a66252007-03-07 08:32:30 +00002671#if defined(TARGET_PPC)
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002672 {
2673 .name = "cpustats",
2674 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002675 .params = "",
2676 .help = "show CPU statistics",
Luiz Capitulino910df892009-10-07 13:41:51 -03002677 .mhandler.info = do_info_cpu_stats,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002678 },
j_mayer76a66252007-03-07 08:32:30 +00002679#endif
blueswir131a60e22007-10-26 18:42:59 +00002680#if defined(CONFIG_SLIRP)
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002681 {
2682 .name = "usernet",
2683 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002684 .params = "",
2685 .help = "show user network stack connection states",
Luiz Capitulino910df892009-10-07 13:41:51 -03002686 .mhandler.info = do_info_usernet,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002687 },
blueswir131a60e22007-10-26 18:42:59 +00002688#endif
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002689 {
2690 .name = "migrate",
2691 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002692 .params = "",
2693 .help = "show migration status",
Luiz Capitulino791e7c82011-09-13 17:37:16 -03002694 .mhandler.info = hmp_info_migrate,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002695 },
2696 {
Orit Wassermanbbf6da32012-08-06 21:42:47 +03002697 .name = "migrate_capabilities",
2698 .args_type = "",
2699 .params = "",
2700 .help = "show current migration capabilities",
2701 .mhandler.info = hmp_info_migrate_capabilities,
2702 },
2703 {
Orit Wasserman9e1ba4c2012-08-06 21:42:54 +03002704 .name = "migrate_cache_size",
2705 .args_type = "",
2706 .params = "",
2707 .help = "show current migration xbzrle cache size",
2708 .mhandler.info = hmp_info_migrate_cache_size,
2709 },
2710 {
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002711 .name = "balloon",
2712 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002713 .params = "",
2714 .help = "show balloon information",
Luiz Capitulino96637bc2011-10-21 11:41:37 -02002715 .mhandler.info = hmp_info_balloon,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002716 },
2717 {
2718 .name = "qtree",
2719 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002720 .params = "",
2721 .help = "show device tree",
Luiz Capitulino910df892009-10-07 13:41:51 -03002722 .mhandler.info = do_info_qtree,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002723 },
2724 {
2725 .name = "qdm",
2726 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002727 .params = "",
2728 .help = "show qdev device model list",
Luiz Capitulino910df892009-10-07 13:41:51 -03002729 .mhandler.info = do_info_qdm,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002730 },
2731 {
2732 .name = "roms",
2733 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002734 .params = "",
2735 .help = "show roms",
Luiz Capitulino910df892009-10-07 13:41:51 -03002736 .mhandler.info = do_info_roms,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002737 },
Prerna Saxena22890ab2010-06-24 17:04:53 +05302738 {
2739 .name = "trace-events",
2740 .args_type = "",
2741 .params = "",
2742 .help = "show available trace-events & their state",
Lluísfc764102011-08-31 20:31:18 +02002743 .mhandler.info = do_trace_print_events,
Prerna Saxena22890ab2010-06-24 17:04:53 +05302744 },
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002745 {
2746 .name = NULL,
2747 },
bellard9dc39cb2004-03-14 21:38:27 +00002748};
2749
Luiz Capitulinof36b4af2010-09-15 17:17:45 -03002750static const mon_cmd_t qmp_cmds[] = {
Anthony Liguorie3193602011-09-02 12:34:47 -05002751#include "qmp-commands-old.h"
Luiz Capitulinof36b4af2010-09-15 17:17:45 -03002752 { /* NULL */ },
2753};
2754
bellard9307c4c2004-04-04 12:57:25 +00002755/*******************************************************************/
2756
2757static const char *pch;
2758static jmp_buf expr_env;
2759
bellard92a31b12005-02-10 22:00:52 +00002760#define MD_TLONG 0
2761#define MD_I32 1
2762
bellard9307c4c2004-04-04 12:57:25 +00002763typedef struct MonitorDef {
2764 const char *name;
2765 int offset;
blueswir18662d652008-10-02 18:32:44 +00002766 target_long (*get_value)(const struct MonitorDef *md, int val);
bellard92a31b12005-02-10 22:00:52 +00002767 int type;
bellard9307c4c2004-04-04 12:57:25 +00002768} MonitorDef;
2769
bellard57206fd2004-04-25 18:54:52 +00002770#if defined(TARGET_I386)
blueswir18662d652008-10-02 18:32:44 +00002771static target_long monitor_get_pc (const struct MonitorDef *md, int val)
bellard57206fd2004-04-25 18:54:52 +00002772{
Andreas Färber9349b4f2012-03-14 01:38:32 +01002773 CPUArchState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00002774 return env->eip + env->segs[R_CS].base;
bellard57206fd2004-04-25 18:54:52 +00002775}
2776#endif
2777
bellarda541f292004-04-12 20:39:29 +00002778#if defined(TARGET_PPC)
blueswir18662d652008-10-02 18:32:44 +00002779static target_long monitor_get_ccr (const struct MonitorDef *md, int val)
bellarda541f292004-04-12 20:39:29 +00002780{
Andreas Färber9349b4f2012-03-14 01:38:32 +01002781 CPUArchState *env = mon_get_cpu();
bellarda541f292004-04-12 20:39:29 +00002782 unsigned int u;
2783 int i;
2784
2785 u = 0;
2786 for (i = 0; i < 8; i++)
aliguori28a76be2009-03-06 20:27:40 +00002787 u |= env->crf[i] << (32 - (4 * i));
bellarda541f292004-04-12 20:39:29 +00002788
2789 return u;
2790}
2791
blueswir18662d652008-10-02 18:32:44 +00002792static target_long monitor_get_msr (const struct MonitorDef *md, int val)
bellarda541f292004-04-12 20:39:29 +00002793{
Andreas Färber9349b4f2012-03-14 01:38:32 +01002794 CPUArchState *env = mon_get_cpu();
j_mayer0411a972007-10-25 21:35:50 +00002795 return env->msr;
bellarda541f292004-04-12 20:39:29 +00002796}
2797
blueswir18662d652008-10-02 18:32:44 +00002798static target_long monitor_get_xer (const struct MonitorDef *md, int val)
bellarda541f292004-04-12 20:39:29 +00002799{
Andreas Färber9349b4f2012-03-14 01:38:32 +01002800 CPUArchState *env = mon_get_cpu();
aurel323d7b4172008-10-21 11:28:46 +00002801 return env->xer;
bellarda541f292004-04-12 20:39:29 +00002802}
bellard9fddaa02004-05-21 12:59:32 +00002803
blueswir18662d652008-10-02 18:32:44 +00002804static target_long monitor_get_decr (const struct MonitorDef *md, int val)
bellard9fddaa02004-05-21 12:59:32 +00002805{
Andreas Färber9349b4f2012-03-14 01:38:32 +01002806 CPUArchState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00002807 return cpu_ppc_load_decr(env);
bellard9fddaa02004-05-21 12:59:32 +00002808}
2809
blueswir18662d652008-10-02 18:32:44 +00002810static target_long monitor_get_tbu (const struct MonitorDef *md, int val)
bellard9fddaa02004-05-21 12:59:32 +00002811{
Andreas Färber9349b4f2012-03-14 01:38:32 +01002812 CPUArchState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00002813 return cpu_ppc_load_tbu(env);
bellard9fddaa02004-05-21 12:59:32 +00002814}
2815
blueswir18662d652008-10-02 18:32:44 +00002816static target_long monitor_get_tbl (const struct MonitorDef *md, int val)
bellard9fddaa02004-05-21 12:59:32 +00002817{
Andreas Färber9349b4f2012-03-14 01:38:32 +01002818 CPUArchState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00002819 return cpu_ppc_load_tbl(env);
bellard9fddaa02004-05-21 12:59:32 +00002820}
bellarda541f292004-04-12 20:39:29 +00002821#endif
2822
bellarde95c8d52004-09-30 22:22:08 +00002823#if defined(TARGET_SPARC)
bellard7b936c02005-10-30 17:05:13 +00002824#ifndef TARGET_SPARC64
blueswir18662d652008-10-02 18:32:44 +00002825static target_long monitor_get_psr (const struct MonitorDef *md, int val)
bellarde95c8d52004-09-30 22:22:08 +00002826{
Andreas Färber9349b4f2012-03-14 01:38:32 +01002827 CPUArchState *env = mon_get_cpu();
Blue Swirl5a834bb2010-05-09 20:19:04 +00002828
2829 return cpu_get_psr(env);
bellarde95c8d52004-09-30 22:22:08 +00002830}
bellard7b936c02005-10-30 17:05:13 +00002831#endif
bellarde95c8d52004-09-30 22:22:08 +00002832
blueswir18662d652008-10-02 18:32:44 +00002833static target_long monitor_get_reg(const struct MonitorDef *md, int val)
bellarde95c8d52004-09-30 22:22:08 +00002834{
Andreas Färber9349b4f2012-03-14 01:38:32 +01002835 CPUArchState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00002836 return env->regwptr[val];
bellarde95c8d52004-09-30 22:22:08 +00002837}
2838#endif
2839
blueswir18662d652008-10-02 18:32:44 +00002840static const MonitorDef monitor_defs[] = {
bellard9307c4c2004-04-04 12:57:25 +00002841#ifdef TARGET_I386
bellard57206fd2004-04-25 18:54:52 +00002842
2843#define SEG(name, seg) \
Andreas Färbere59d1672012-02-16 00:40:47 +01002844 { name, offsetof(CPUX86State, segs[seg].selector), NULL, MD_I32 },\
2845 { name ".base", offsetof(CPUX86State, segs[seg].base) },\
2846 { name ".limit", offsetof(CPUX86State, segs[seg].limit), NULL, MD_I32 },
bellard57206fd2004-04-25 18:54:52 +00002847
Andreas Färbere59d1672012-02-16 00:40:47 +01002848 { "eax", offsetof(CPUX86State, regs[0]) },
2849 { "ecx", offsetof(CPUX86State, regs[1]) },
2850 { "edx", offsetof(CPUX86State, regs[2]) },
2851 { "ebx", offsetof(CPUX86State, regs[3]) },
2852 { "esp|sp", offsetof(CPUX86State, regs[4]) },
2853 { "ebp|fp", offsetof(CPUX86State, regs[5]) },
2854 { "esi", offsetof(CPUX86State, regs[6]) },
2855 { "edi", offsetof(CPUX86State, regs[7]) },
bellard92a31b12005-02-10 22:00:52 +00002856#ifdef TARGET_X86_64
Andreas Färbere59d1672012-02-16 00:40:47 +01002857 { "r8", offsetof(CPUX86State, regs[8]) },
2858 { "r9", offsetof(CPUX86State, regs[9]) },
2859 { "r10", offsetof(CPUX86State, regs[10]) },
2860 { "r11", offsetof(CPUX86State, regs[11]) },
2861 { "r12", offsetof(CPUX86State, regs[12]) },
2862 { "r13", offsetof(CPUX86State, regs[13]) },
2863 { "r14", offsetof(CPUX86State, regs[14]) },
2864 { "r15", offsetof(CPUX86State, regs[15]) },
bellard92a31b12005-02-10 22:00:52 +00002865#endif
Andreas Färbere59d1672012-02-16 00:40:47 +01002866 { "eflags", offsetof(CPUX86State, eflags) },
2867 { "eip", offsetof(CPUX86State, eip) },
bellard57206fd2004-04-25 18:54:52 +00002868 SEG("cs", R_CS)
2869 SEG("ds", R_DS)
2870 SEG("es", R_ES)
bellard01038d22004-09-13 21:36:46 +00002871 SEG("ss", R_SS)
bellard57206fd2004-04-25 18:54:52 +00002872 SEG("fs", R_FS)
2873 SEG("gs", R_GS)
2874 { "pc", 0, monitor_get_pc, },
bellarda541f292004-04-12 20:39:29 +00002875#elif defined(TARGET_PPC)
j_mayerff937db2007-09-19 05:49:13 +00002876 /* General purpose registers */
Andreas Färbere59d1672012-02-16 00:40:47 +01002877 { "r0", offsetof(CPUPPCState, gpr[0]) },
2878 { "r1", offsetof(CPUPPCState, gpr[1]) },
2879 { "r2", offsetof(CPUPPCState, gpr[2]) },
2880 { "r3", offsetof(CPUPPCState, gpr[3]) },
2881 { "r4", offsetof(CPUPPCState, gpr[4]) },
2882 { "r5", offsetof(CPUPPCState, gpr[5]) },
2883 { "r6", offsetof(CPUPPCState, gpr[6]) },
2884 { "r7", offsetof(CPUPPCState, gpr[7]) },
2885 { "r8", offsetof(CPUPPCState, gpr[8]) },
2886 { "r9", offsetof(CPUPPCState, gpr[9]) },
2887 { "r10", offsetof(CPUPPCState, gpr[10]) },
2888 { "r11", offsetof(CPUPPCState, gpr[11]) },
2889 { "r12", offsetof(CPUPPCState, gpr[12]) },
2890 { "r13", offsetof(CPUPPCState, gpr[13]) },
2891 { "r14", offsetof(CPUPPCState, gpr[14]) },
2892 { "r15", offsetof(CPUPPCState, gpr[15]) },
2893 { "r16", offsetof(CPUPPCState, gpr[16]) },
2894 { "r17", offsetof(CPUPPCState, gpr[17]) },
2895 { "r18", offsetof(CPUPPCState, gpr[18]) },
2896 { "r19", offsetof(CPUPPCState, gpr[19]) },
2897 { "r20", offsetof(CPUPPCState, gpr[20]) },
2898 { "r21", offsetof(CPUPPCState, gpr[21]) },
2899 { "r22", offsetof(CPUPPCState, gpr[22]) },
2900 { "r23", offsetof(CPUPPCState, gpr[23]) },
2901 { "r24", offsetof(CPUPPCState, gpr[24]) },
2902 { "r25", offsetof(CPUPPCState, gpr[25]) },
2903 { "r26", offsetof(CPUPPCState, gpr[26]) },
2904 { "r27", offsetof(CPUPPCState, gpr[27]) },
2905 { "r28", offsetof(CPUPPCState, gpr[28]) },
2906 { "r29", offsetof(CPUPPCState, gpr[29]) },
2907 { "r30", offsetof(CPUPPCState, gpr[30]) },
2908 { "r31", offsetof(CPUPPCState, gpr[31]) },
j_mayerff937db2007-09-19 05:49:13 +00002909 /* Floating point registers */
Andreas Färbere59d1672012-02-16 00:40:47 +01002910 { "f0", offsetof(CPUPPCState, fpr[0]) },
2911 { "f1", offsetof(CPUPPCState, fpr[1]) },
2912 { "f2", offsetof(CPUPPCState, fpr[2]) },
2913 { "f3", offsetof(CPUPPCState, fpr[3]) },
2914 { "f4", offsetof(CPUPPCState, fpr[4]) },
2915 { "f5", offsetof(CPUPPCState, fpr[5]) },
2916 { "f6", offsetof(CPUPPCState, fpr[6]) },
2917 { "f7", offsetof(CPUPPCState, fpr[7]) },
2918 { "f8", offsetof(CPUPPCState, fpr[8]) },
2919 { "f9", offsetof(CPUPPCState, fpr[9]) },
2920 { "f10", offsetof(CPUPPCState, fpr[10]) },
2921 { "f11", offsetof(CPUPPCState, fpr[11]) },
2922 { "f12", offsetof(CPUPPCState, fpr[12]) },
2923 { "f13", offsetof(CPUPPCState, fpr[13]) },
2924 { "f14", offsetof(CPUPPCState, fpr[14]) },
2925 { "f15", offsetof(CPUPPCState, fpr[15]) },
2926 { "f16", offsetof(CPUPPCState, fpr[16]) },
2927 { "f17", offsetof(CPUPPCState, fpr[17]) },
2928 { "f18", offsetof(CPUPPCState, fpr[18]) },
2929 { "f19", offsetof(CPUPPCState, fpr[19]) },
2930 { "f20", offsetof(CPUPPCState, fpr[20]) },
2931 { "f21", offsetof(CPUPPCState, fpr[21]) },
2932 { "f22", offsetof(CPUPPCState, fpr[22]) },
2933 { "f23", offsetof(CPUPPCState, fpr[23]) },
2934 { "f24", offsetof(CPUPPCState, fpr[24]) },
2935 { "f25", offsetof(CPUPPCState, fpr[25]) },
2936 { "f26", offsetof(CPUPPCState, fpr[26]) },
2937 { "f27", offsetof(CPUPPCState, fpr[27]) },
2938 { "f28", offsetof(CPUPPCState, fpr[28]) },
2939 { "f29", offsetof(CPUPPCState, fpr[29]) },
2940 { "f30", offsetof(CPUPPCState, fpr[30]) },
2941 { "f31", offsetof(CPUPPCState, fpr[31]) },
2942 { "fpscr", offsetof(CPUPPCState, fpscr) },
j_mayerff937db2007-09-19 05:49:13 +00002943 /* Next instruction pointer */
Andreas Färbere59d1672012-02-16 00:40:47 +01002944 { "nip|pc", offsetof(CPUPPCState, nip) },
2945 { "lr", offsetof(CPUPPCState, lr) },
2946 { "ctr", offsetof(CPUPPCState, ctr) },
bellard9fddaa02004-05-21 12:59:32 +00002947 { "decr", 0, &monitor_get_decr, },
bellarda541f292004-04-12 20:39:29 +00002948 { "ccr", 0, &monitor_get_ccr, },
j_mayerff937db2007-09-19 05:49:13 +00002949 /* Machine state register */
bellarda541f292004-04-12 20:39:29 +00002950 { "msr", 0, &monitor_get_msr, },
2951 { "xer", 0, &monitor_get_xer, },
bellard9fddaa02004-05-21 12:59:32 +00002952 { "tbu", 0, &monitor_get_tbu, },
2953 { "tbl", 0, &monitor_get_tbl, },
j_mayerff937db2007-09-19 05:49:13 +00002954#if defined(TARGET_PPC64)
2955 /* Address space register */
Andreas Färbere59d1672012-02-16 00:40:47 +01002956 { "asr", offsetof(CPUPPCState, asr) },
j_mayerff937db2007-09-19 05:49:13 +00002957#endif
2958 /* Segment registers */
Andreas Färbere59d1672012-02-16 00:40:47 +01002959 { "sdr1", offsetof(CPUPPCState, spr[SPR_SDR1]) },
2960 { "sr0", offsetof(CPUPPCState, sr[0]) },
2961 { "sr1", offsetof(CPUPPCState, sr[1]) },
2962 { "sr2", offsetof(CPUPPCState, sr[2]) },
2963 { "sr3", offsetof(CPUPPCState, sr[3]) },
2964 { "sr4", offsetof(CPUPPCState, sr[4]) },
2965 { "sr5", offsetof(CPUPPCState, sr[5]) },
2966 { "sr6", offsetof(CPUPPCState, sr[6]) },
2967 { "sr7", offsetof(CPUPPCState, sr[7]) },
2968 { "sr8", offsetof(CPUPPCState, sr[8]) },
2969 { "sr9", offsetof(CPUPPCState, sr[9]) },
2970 { "sr10", offsetof(CPUPPCState, sr[10]) },
2971 { "sr11", offsetof(CPUPPCState, sr[11]) },
2972 { "sr12", offsetof(CPUPPCState, sr[12]) },
2973 { "sr13", offsetof(CPUPPCState, sr[13]) },
2974 { "sr14", offsetof(CPUPPCState, sr[14]) },
2975 { "sr15", offsetof(CPUPPCState, sr[15]) },
Scott Wood90dc8812011-04-29 17:10:23 -05002976 /* Too lazy to put BATs... */
Andreas Färbere59d1672012-02-16 00:40:47 +01002977 { "pvr", offsetof(CPUPPCState, spr[SPR_PVR]) },
Scott Wood90dc8812011-04-29 17:10:23 -05002978
Andreas Färbere59d1672012-02-16 00:40:47 +01002979 { "srr0", offsetof(CPUPPCState, spr[SPR_SRR0]) },
2980 { "srr1", offsetof(CPUPPCState, spr[SPR_SRR1]) },
2981 { "sprg0", offsetof(CPUPPCState, spr[SPR_SPRG0]) },
2982 { "sprg1", offsetof(CPUPPCState, spr[SPR_SPRG1]) },
2983 { "sprg2", offsetof(CPUPPCState, spr[SPR_SPRG2]) },
2984 { "sprg3", offsetof(CPUPPCState, spr[SPR_SPRG3]) },
2985 { "sprg4", offsetof(CPUPPCState, spr[SPR_SPRG4]) },
2986 { "sprg5", offsetof(CPUPPCState, spr[SPR_SPRG5]) },
2987 { "sprg6", offsetof(CPUPPCState, spr[SPR_SPRG6]) },
2988 { "sprg7", offsetof(CPUPPCState, spr[SPR_SPRG7]) },
2989 { "pid", offsetof(CPUPPCState, spr[SPR_BOOKE_PID]) },
2990 { "csrr0", offsetof(CPUPPCState, spr[SPR_BOOKE_CSRR0]) },
2991 { "csrr1", offsetof(CPUPPCState, spr[SPR_BOOKE_CSRR1]) },
2992 { "esr", offsetof(CPUPPCState, spr[SPR_BOOKE_ESR]) },
2993 { "dear", offsetof(CPUPPCState, spr[SPR_BOOKE_DEAR]) },
2994 { "mcsr", offsetof(CPUPPCState, spr[SPR_BOOKE_MCSR]) },
2995 { "tsr", offsetof(CPUPPCState, spr[SPR_BOOKE_TSR]) },
2996 { "tcr", offsetof(CPUPPCState, spr[SPR_BOOKE_TCR]) },
2997 { "vrsave", offsetof(CPUPPCState, spr[SPR_VRSAVE]) },
2998 { "pir", offsetof(CPUPPCState, spr[SPR_BOOKE_PIR]) },
2999 { "mcsrr0", offsetof(CPUPPCState, spr[SPR_BOOKE_MCSRR0]) },
3000 { "mcsrr1", offsetof(CPUPPCState, spr[SPR_BOOKE_MCSRR1]) },
3001 { "decar", offsetof(CPUPPCState, spr[SPR_BOOKE_DECAR]) },
3002 { "ivpr", offsetof(CPUPPCState, spr[SPR_BOOKE_IVPR]) },
3003 { "epcr", offsetof(CPUPPCState, spr[SPR_BOOKE_EPCR]) },
3004 { "sprg8", offsetof(CPUPPCState, spr[SPR_BOOKE_SPRG8]) },
3005 { "ivor0", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR0]) },
3006 { "ivor1", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR1]) },
3007 { "ivor2", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR2]) },
3008 { "ivor3", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR3]) },
3009 { "ivor4", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR4]) },
3010 { "ivor5", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR5]) },
3011 { "ivor6", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR6]) },
3012 { "ivor7", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR7]) },
3013 { "ivor8", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR8]) },
3014 { "ivor9", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR9]) },
3015 { "ivor10", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR10]) },
3016 { "ivor11", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR11]) },
3017 { "ivor12", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR12]) },
3018 { "ivor13", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR13]) },
3019 { "ivor14", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR14]) },
3020 { "ivor15", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR15]) },
3021 { "ivor32", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR32]) },
3022 { "ivor33", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR33]) },
3023 { "ivor34", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR34]) },
3024 { "ivor35", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR35]) },
3025 { "ivor36", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR36]) },
3026 { "ivor37", offsetof(CPUPPCState, spr[SPR_BOOKE_IVOR37]) },
3027 { "mas0", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS0]) },
3028 { "mas1", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS1]) },
3029 { "mas2", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS2]) },
3030 { "mas3", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS3]) },
3031 { "mas4", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS4]) },
3032 { "mas6", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS6]) },
3033 { "mas7", offsetof(CPUPPCState, spr[SPR_BOOKE_MAS7]) },
3034 { "mmucfg", offsetof(CPUPPCState, spr[SPR_MMUCFG]) },
3035 { "tlb0cfg", offsetof(CPUPPCState, spr[SPR_BOOKE_TLB0CFG]) },
3036 { "tlb1cfg", offsetof(CPUPPCState, spr[SPR_BOOKE_TLB1CFG]) },
3037 { "epr", offsetof(CPUPPCState, spr[SPR_BOOKE_EPR]) },
3038 { "eplc", offsetof(CPUPPCState, spr[SPR_BOOKE_EPLC]) },
3039 { "epsc", offsetof(CPUPPCState, spr[SPR_BOOKE_EPSC]) },
3040 { "svr", offsetof(CPUPPCState, spr[SPR_E500_SVR]) },
3041 { "mcar", offsetof(CPUPPCState, spr[SPR_Exxx_MCAR]) },
3042 { "pid1", offsetof(CPUPPCState, spr[SPR_BOOKE_PID1]) },
3043 { "pid2", offsetof(CPUPPCState, spr[SPR_BOOKE_PID2]) },
3044 { "hid0", offsetof(CPUPPCState, spr[SPR_HID0]) },
Scott Wood90dc8812011-04-29 17:10:23 -05003045
bellarde95c8d52004-09-30 22:22:08 +00003046#elif defined(TARGET_SPARC)
Andreas Färbere59d1672012-02-16 00:40:47 +01003047 { "g0", offsetof(CPUSPARCState, gregs[0]) },
3048 { "g1", offsetof(CPUSPARCState, gregs[1]) },
3049 { "g2", offsetof(CPUSPARCState, gregs[2]) },
3050 { "g3", offsetof(CPUSPARCState, gregs[3]) },
3051 { "g4", offsetof(CPUSPARCState, gregs[4]) },
3052 { "g5", offsetof(CPUSPARCState, gregs[5]) },
3053 { "g6", offsetof(CPUSPARCState, gregs[6]) },
3054 { "g7", offsetof(CPUSPARCState, gregs[7]) },
bellarde95c8d52004-09-30 22:22:08 +00003055 { "o0", 0, monitor_get_reg },
3056 { "o1", 1, monitor_get_reg },
3057 { "o2", 2, monitor_get_reg },
3058 { "o3", 3, monitor_get_reg },
3059 { "o4", 4, monitor_get_reg },
3060 { "o5", 5, monitor_get_reg },
3061 { "o6", 6, monitor_get_reg },
3062 { "o7", 7, monitor_get_reg },
3063 { "l0", 8, monitor_get_reg },
3064 { "l1", 9, monitor_get_reg },
3065 { "l2", 10, monitor_get_reg },
3066 { "l3", 11, monitor_get_reg },
3067 { "l4", 12, monitor_get_reg },
3068 { "l5", 13, monitor_get_reg },
3069 { "l6", 14, monitor_get_reg },
3070 { "l7", 15, monitor_get_reg },
3071 { "i0", 16, monitor_get_reg },
3072 { "i1", 17, monitor_get_reg },
3073 { "i2", 18, monitor_get_reg },
3074 { "i3", 19, monitor_get_reg },
3075 { "i4", 20, monitor_get_reg },
3076 { "i5", 21, monitor_get_reg },
3077 { "i6", 22, monitor_get_reg },
3078 { "i7", 23, monitor_get_reg },
Andreas Färbere59d1672012-02-16 00:40:47 +01003079 { "pc", offsetof(CPUSPARCState, pc) },
3080 { "npc", offsetof(CPUSPARCState, npc) },
3081 { "y", offsetof(CPUSPARCState, y) },
bellard7b936c02005-10-30 17:05:13 +00003082#ifndef TARGET_SPARC64
bellarde95c8d52004-09-30 22:22:08 +00003083 { "psr", 0, &monitor_get_psr, },
Andreas Färbere59d1672012-02-16 00:40:47 +01003084 { "wim", offsetof(CPUSPARCState, wim) },
bellard7b936c02005-10-30 17:05:13 +00003085#endif
Andreas Färbere59d1672012-02-16 00:40:47 +01003086 { "tbr", offsetof(CPUSPARCState, tbr) },
3087 { "fsr", offsetof(CPUSPARCState, fsr) },
3088 { "f0", offsetof(CPUSPARCState, fpr[0].l.upper) },
3089 { "f1", offsetof(CPUSPARCState, fpr[0].l.lower) },
3090 { "f2", offsetof(CPUSPARCState, fpr[1].l.upper) },
3091 { "f3", offsetof(CPUSPARCState, fpr[1].l.lower) },
3092 { "f4", offsetof(CPUSPARCState, fpr[2].l.upper) },
3093 { "f5", offsetof(CPUSPARCState, fpr[2].l.lower) },
3094 { "f6", offsetof(CPUSPARCState, fpr[3].l.upper) },
3095 { "f7", offsetof(CPUSPARCState, fpr[3].l.lower) },
3096 { "f8", offsetof(CPUSPARCState, fpr[4].l.upper) },
3097 { "f9", offsetof(CPUSPARCState, fpr[4].l.lower) },
3098 { "f10", offsetof(CPUSPARCState, fpr[5].l.upper) },
3099 { "f11", offsetof(CPUSPARCState, fpr[5].l.lower) },
3100 { "f12", offsetof(CPUSPARCState, fpr[6].l.upper) },
3101 { "f13", offsetof(CPUSPARCState, fpr[6].l.lower) },
3102 { "f14", offsetof(CPUSPARCState, fpr[7].l.upper) },
3103 { "f15", offsetof(CPUSPARCState, fpr[7].l.lower) },
3104 { "f16", offsetof(CPUSPARCState, fpr[8].l.upper) },
3105 { "f17", offsetof(CPUSPARCState, fpr[8].l.lower) },
3106 { "f18", offsetof(CPUSPARCState, fpr[9].l.upper) },
3107 { "f19", offsetof(CPUSPARCState, fpr[9].l.lower) },
3108 { "f20", offsetof(CPUSPARCState, fpr[10].l.upper) },
3109 { "f21", offsetof(CPUSPARCState, fpr[10].l.lower) },
3110 { "f22", offsetof(CPUSPARCState, fpr[11].l.upper) },
3111 { "f23", offsetof(CPUSPARCState, fpr[11].l.lower) },
3112 { "f24", offsetof(CPUSPARCState, fpr[12].l.upper) },
3113 { "f25", offsetof(CPUSPARCState, fpr[12].l.lower) },
3114 { "f26", offsetof(CPUSPARCState, fpr[13].l.upper) },
3115 { "f27", offsetof(CPUSPARCState, fpr[13].l.lower) },
3116 { "f28", offsetof(CPUSPARCState, fpr[14].l.upper) },
3117 { "f29", offsetof(CPUSPARCState, fpr[14].l.lower) },
3118 { "f30", offsetof(CPUSPARCState, fpr[15].l.upper) },
3119 { "f31", offsetof(CPUSPARCState, fpr[15].l.lower) },
bellard7b936c02005-10-30 17:05:13 +00003120#ifdef TARGET_SPARC64
Andreas Färbere59d1672012-02-16 00:40:47 +01003121 { "f32", offsetof(CPUSPARCState, fpr[16]) },
3122 { "f34", offsetof(CPUSPARCState, fpr[17]) },
3123 { "f36", offsetof(CPUSPARCState, fpr[18]) },
3124 { "f38", offsetof(CPUSPARCState, fpr[19]) },
3125 { "f40", offsetof(CPUSPARCState, fpr[20]) },
3126 { "f42", offsetof(CPUSPARCState, fpr[21]) },
3127 { "f44", offsetof(CPUSPARCState, fpr[22]) },
3128 { "f46", offsetof(CPUSPARCState, fpr[23]) },
3129 { "f48", offsetof(CPUSPARCState, fpr[24]) },
3130 { "f50", offsetof(CPUSPARCState, fpr[25]) },
3131 { "f52", offsetof(CPUSPARCState, fpr[26]) },
3132 { "f54", offsetof(CPUSPARCState, fpr[27]) },
3133 { "f56", offsetof(CPUSPARCState, fpr[28]) },
3134 { "f58", offsetof(CPUSPARCState, fpr[29]) },
3135 { "f60", offsetof(CPUSPARCState, fpr[30]) },
3136 { "f62", offsetof(CPUSPARCState, fpr[31]) },
3137 { "asi", offsetof(CPUSPARCState, asi) },
3138 { "pstate", offsetof(CPUSPARCState, pstate) },
3139 { "cansave", offsetof(CPUSPARCState, cansave) },
3140 { "canrestore", offsetof(CPUSPARCState, canrestore) },
3141 { "otherwin", offsetof(CPUSPARCState, otherwin) },
3142 { "wstate", offsetof(CPUSPARCState, wstate) },
3143 { "cleanwin", offsetof(CPUSPARCState, cleanwin) },
3144 { "fprs", offsetof(CPUSPARCState, fprs) },
bellard7b936c02005-10-30 17:05:13 +00003145#endif
bellard9307c4c2004-04-04 12:57:25 +00003146#endif
3147 { NULL },
3148};
3149
aliguori376253e2009-03-05 23:01:23 +00003150static void expr_error(Monitor *mon, const char *msg)
bellard9dc39cb2004-03-14 21:38:27 +00003151{
aliguori376253e2009-03-05 23:01:23 +00003152 monitor_printf(mon, "%s\n", msg);
bellard9307c4c2004-04-04 12:57:25 +00003153 longjmp(expr_env, 1);
3154}
3155
Markus Armbruster09b94182010-01-20 13:07:30 +01003156/* return 0 if OK, -1 if not found */
bellard92a31b12005-02-10 22:00:52 +00003157static int get_monitor_def(target_long *pval, const char *name)
bellard9307c4c2004-04-04 12:57:25 +00003158{
blueswir18662d652008-10-02 18:32:44 +00003159 const MonitorDef *md;
bellard92a31b12005-02-10 22:00:52 +00003160 void *ptr;
3161
bellard9307c4c2004-04-04 12:57:25 +00003162 for(md = monitor_defs; md->name != NULL; md++) {
3163 if (compare_cmd(name, md->name)) {
3164 if (md->get_value) {
bellarde95c8d52004-09-30 22:22:08 +00003165 *pval = md->get_value(md, md->offset);
bellard9307c4c2004-04-04 12:57:25 +00003166 } else {
Andreas Färber9349b4f2012-03-14 01:38:32 +01003167 CPUArchState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00003168 ptr = (uint8_t *)env + md->offset;
bellard92a31b12005-02-10 22:00:52 +00003169 switch(md->type) {
3170 case MD_I32:
3171 *pval = *(int32_t *)ptr;
3172 break;
3173 case MD_TLONG:
3174 *pval = *(target_long *)ptr;
3175 break;
3176 default:
3177 *pval = 0;
3178 break;
3179 }
bellard9307c4c2004-04-04 12:57:25 +00003180 }
3181 return 0;
3182 }
3183 }
3184 return -1;
3185}
3186
3187static void next(void)
3188{
Blue Swirl660f11b2009-07-31 21:16:51 +00003189 if (*pch != '\0') {
bellard9307c4c2004-04-04 12:57:25 +00003190 pch++;
blueswir1cd390082008-11-16 13:53:32 +00003191 while (qemu_isspace(*pch))
bellard9307c4c2004-04-04 12:57:25 +00003192 pch++;
3193 }
3194}
3195
aliguori376253e2009-03-05 23:01:23 +00003196static int64_t expr_sum(Monitor *mon);
bellard9307c4c2004-04-04 12:57:25 +00003197
aliguori376253e2009-03-05 23:01:23 +00003198static int64_t expr_unary(Monitor *mon)
bellard9307c4c2004-04-04 12:57:25 +00003199{
blueswir1c2efc952007-09-25 17:28:42 +00003200 int64_t n;
bellard9307c4c2004-04-04 12:57:25 +00003201 char *p;
bellard6a00d602005-11-21 23:25:50 +00003202 int ret;
bellard9307c4c2004-04-04 12:57:25 +00003203
3204 switch(*pch) {
3205 case '+':
3206 next();
aliguori376253e2009-03-05 23:01:23 +00003207 n = expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00003208 break;
3209 case '-':
3210 next();
aliguori376253e2009-03-05 23:01:23 +00003211 n = -expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00003212 break;
3213 case '~':
3214 next();
aliguori376253e2009-03-05 23:01:23 +00003215 n = ~expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00003216 break;
3217 case '(':
3218 next();
aliguori376253e2009-03-05 23:01:23 +00003219 n = expr_sum(mon);
bellard9307c4c2004-04-04 12:57:25 +00003220 if (*pch != ')') {
aliguori376253e2009-03-05 23:01:23 +00003221 expr_error(mon, "')' expected");
bellard9307c4c2004-04-04 12:57:25 +00003222 }
3223 next();
3224 break;
bellard81d09122004-07-14 17:21:37 +00003225 case '\'':
3226 pch++;
3227 if (*pch == '\0')
aliguori376253e2009-03-05 23:01:23 +00003228 expr_error(mon, "character constant expected");
bellard81d09122004-07-14 17:21:37 +00003229 n = *pch;
3230 pch++;
3231 if (*pch != '\'')
aliguori376253e2009-03-05 23:01:23 +00003232 expr_error(mon, "missing terminating \' character");
bellard81d09122004-07-14 17:21:37 +00003233 next();
3234 break;
bellard9307c4c2004-04-04 12:57:25 +00003235 case '$':
3236 {
3237 char buf[128], *q;
ths69b34972007-12-17 03:15:52 +00003238 target_long reg=0;
ths3b46e622007-09-17 08:09:54 +00003239
bellard9307c4c2004-04-04 12:57:25 +00003240 pch++;
3241 q = buf;
3242 while ((*pch >= 'a' && *pch <= 'z') ||
3243 (*pch >= 'A' && *pch <= 'Z') ||
3244 (*pch >= '0' && *pch <= '9') ||
bellard57206fd2004-04-25 18:54:52 +00003245 *pch == '_' || *pch == '.') {
bellard9307c4c2004-04-04 12:57:25 +00003246 if ((q - buf) < sizeof(buf) - 1)
3247 *q++ = *pch;
3248 pch++;
3249 }
blueswir1cd390082008-11-16 13:53:32 +00003250 while (qemu_isspace(*pch))
bellard9307c4c2004-04-04 12:57:25 +00003251 pch++;
3252 *q = 0;
blueswir17743e582007-09-24 18:39:04 +00003253 ret = get_monitor_def(&reg, buf);
Markus Armbruster09b94182010-01-20 13:07:30 +01003254 if (ret < 0)
aliguori376253e2009-03-05 23:01:23 +00003255 expr_error(mon, "unknown register");
blueswir17743e582007-09-24 18:39:04 +00003256 n = reg;
bellard9307c4c2004-04-04 12:57:25 +00003257 }
3258 break;
3259 case '\0':
aliguori376253e2009-03-05 23:01:23 +00003260 expr_error(mon, "unexpected end of expression");
bellard9307c4c2004-04-04 12:57:25 +00003261 n = 0;
3262 break;
3263 default:
Luiz Capitulino6b0e33b2012-04-26 16:48:41 -03003264 errno = 0;
blueswir17743e582007-09-24 18:39:04 +00003265#if TARGET_PHYS_ADDR_BITS > 32
bellard4f4fbf72006-06-25 18:28:12 +00003266 n = strtoull(pch, &p, 0);
3267#else
bellard9307c4c2004-04-04 12:57:25 +00003268 n = strtoul(pch, &p, 0);
bellard4f4fbf72006-06-25 18:28:12 +00003269#endif
Luiz Capitulino6b0e33b2012-04-26 16:48:41 -03003270 if (errno == ERANGE) {
3271 expr_error(mon, "number too large");
3272 }
bellard9307c4c2004-04-04 12:57:25 +00003273 if (pch == p) {
aliguori376253e2009-03-05 23:01:23 +00003274 expr_error(mon, "invalid char in expression");
bellard9307c4c2004-04-04 12:57:25 +00003275 }
3276 pch = p;
blueswir1cd390082008-11-16 13:53:32 +00003277 while (qemu_isspace(*pch))
bellard9307c4c2004-04-04 12:57:25 +00003278 pch++;
3279 break;
3280 }
3281 return n;
3282}
3283
3284
aliguori376253e2009-03-05 23:01:23 +00003285static int64_t expr_prod(Monitor *mon)
bellard9307c4c2004-04-04 12:57:25 +00003286{
blueswir1c2efc952007-09-25 17:28:42 +00003287 int64_t val, val2;
bellard92a31b12005-02-10 22:00:52 +00003288 int op;
ths3b46e622007-09-17 08:09:54 +00003289
aliguori376253e2009-03-05 23:01:23 +00003290 val = expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00003291 for(;;) {
3292 op = *pch;
3293 if (op != '*' && op != '/' && op != '%')
3294 break;
3295 next();
aliguori376253e2009-03-05 23:01:23 +00003296 val2 = expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00003297 switch(op) {
3298 default:
3299 case '*':
3300 val *= val2;
3301 break;
3302 case '/':
3303 case '%':
ths5fafdf22007-09-16 21:08:06 +00003304 if (val2 == 0)
aliguori376253e2009-03-05 23:01:23 +00003305 expr_error(mon, "division by zero");
bellard9307c4c2004-04-04 12:57:25 +00003306 if (op == '/')
3307 val /= val2;
3308 else
3309 val %= val2;
3310 break;
3311 }
3312 }
3313 return val;
3314}
3315
aliguori376253e2009-03-05 23:01:23 +00003316static int64_t expr_logic(Monitor *mon)
bellard9307c4c2004-04-04 12:57:25 +00003317{
blueswir1c2efc952007-09-25 17:28:42 +00003318 int64_t val, val2;
bellard92a31b12005-02-10 22:00:52 +00003319 int op;
bellard9307c4c2004-04-04 12:57:25 +00003320
aliguori376253e2009-03-05 23:01:23 +00003321 val = expr_prod(mon);
bellard9307c4c2004-04-04 12:57:25 +00003322 for(;;) {
3323 op = *pch;
3324 if (op != '&' && op != '|' && op != '^')
3325 break;
3326 next();
aliguori376253e2009-03-05 23:01:23 +00003327 val2 = expr_prod(mon);
bellard9307c4c2004-04-04 12:57:25 +00003328 switch(op) {
3329 default:
3330 case '&':
3331 val &= val2;
3332 break;
3333 case '|':
3334 val |= val2;
3335 break;
3336 case '^':
3337 val ^= val2;
3338 break;
3339 }
3340 }
3341 return val;
3342}
3343
aliguori376253e2009-03-05 23:01:23 +00003344static int64_t expr_sum(Monitor *mon)
bellard9307c4c2004-04-04 12:57:25 +00003345{
blueswir1c2efc952007-09-25 17:28:42 +00003346 int64_t val, val2;
bellard92a31b12005-02-10 22:00:52 +00003347 int op;
bellard9307c4c2004-04-04 12:57:25 +00003348
aliguori376253e2009-03-05 23:01:23 +00003349 val = expr_logic(mon);
bellard9307c4c2004-04-04 12:57:25 +00003350 for(;;) {
3351 op = *pch;
3352 if (op != '+' && op != '-')
3353 break;
3354 next();
aliguori376253e2009-03-05 23:01:23 +00003355 val2 = expr_logic(mon);
bellard9307c4c2004-04-04 12:57:25 +00003356 if (op == '+')
3357 val += val2;
3358 else
3359 val -= val2;
3360 }
3361 return val;
3362}
3363
aliguori376253e2009-03-05 23:01:23 +00003364static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
bellard9307c4c2004-04-04 12:57:25 +00003365{
3366 pch = *pp;
3367 if (setjmp(expr_env)) {
3368 *pp = pch;
3369 return -1;
3370 }
blueswir1cd390082008-11-16 13:53:32 +00003371 while (qemu_isspace(*pch))
bellard9307c4c2004-04-04 12:57:25 +00003372 pch++;
aliguori376253e2009-03-05 23:01:23 +00003373 *pval = expr_sum(mon);
bellard9307c4c2004-04-04 12:57:25 +00003374 *pp = pch;
3375 return 0;
3376}
3377
Markus Armbruster3350a4d2010-01-25 14:23:03 +01003378static int get_double(Monitor *mon, double *pval, const char **pp)
3379{
3380 const char *p = *pp;
3381 char *tailp;
3382 double d;
3383
3384 d = strtod(p, &tailp);
3385 if (tailp == p) {
3386 monitor_printf(mon, "Number expected\n");
3387 return -1;
3388 }
3389 if (d != d || d - d != 0) {
3390 /* NaN or infinity */
3391 monitor_printf(mon, "Bad number\n");
3392 return -1;
3393 }
3394 *pval = d;
3395 *pp = tailp;
3396 return 0;
3397}
3398
bellard9307c4c2004-04-04 12:57:25 +00003399static int get_str(char *buf, int buf_size, const char **pp)
3400{
3401 const char *p;
3402 char *q;
3403 int c;
3404
bellard81d09122004-07-14 17:21:37 +00003405 q = buf;
bellard9307c4c2004-04-04 12:57:25 +00003406 p = *pp;
blueswir1cd390082008-11-16 13:53:32 +00003407 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00003408 p++;
3409 if (*p == '\0') {
3410 fail:
bellard81d09122004-07-14 17:21:37 +00003411 *q = '\0';
bellard9307c4c2004-04-04 12:57:25 +00003412 *pp = p;
3413 return -1;
3414 }
bellard9307c4c2004-04-04 12:57:25 +00003415 if (*p == '\"') {
3416 p++;
3417 while (*p != '\0' && *p != '\"') {
3418 if (*p == '\\') {
3419 p++;
3420 c = *p++;
3421 switch(c) {
3422 case 'n':
3423 c = '\n';
3424 break;
3425 case 'r':
3426 c = '\r';
3427 break;
3428 case '\\':
3429 case '\'':
3430 case '\"':
3431 break;
3432 default:
3433 qemu_printf("unsupported escape code: '\\%c'\n", c);
3434 goto fail;
3435 }
3436 if ((q - buf) < buf_size - 1) {
3437 *q++ = c;
3438 }
3439 } else {
3440 if ((q - buf) < buf_size - 1) {
3441 *q++ = *p;
3442 }
3443 p++;
3444 }
3445 }
3446 if (*p != '\"') {
bellard5b602122004-05-22 21:41:05 +00003447 qemu_printf("unterminated string\n");
bellard9307c4c2004-04-04 12:57:25 +00003448 goto fail;
3449 }
3450 p++;
3451 } else {
blueswir1cd390082008-11-16 13:53:32 +00003452 while (*p != '\0' && !qemu_isspace(*p)) {
bellard9307c4c2004-04-04 12:57:25 +00003453 if ((q - buf) < buf_size - 1) {
3454 *q++ = *p;
3455 }
3456 p++;
3457 }
bellard9307c4c2004-04-04 12:57:25 +00003458 }
bellard81d09122004-07-14 17:21:37 +00003459 *q = '\0';
bellard9307c4c2004-04-04 12:57:25 +00003460 *pp = p;
3461 return 0;
3462}
3463
Luiz Capitulino4590fd82009-06-09 18:21:30 -03003464/*
3465 * Store the command-name in cmdname, and return a pointer to
3466 * the remaining of the command string.
3467 */
3468static const char *get_command_name(const char *cmdline,
3469 char *cmdname, size_t nlen)
3470{
3471 size_t len;
3472 const char *p, *pstart;
3473
3474 p = cmdline;
3475 while (qemu_isspace(*p))
3476 p++;
3477 if (*p == '\0')
3478 return NULL;
3479 pstart = p;
3480 while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
3481 p++;
3482 len = p - pstart;
3483 if (len > nlen - 1)
3484 len = nlen - 1;
3485 memcpy(cmdname, pstart, len);
3486 cmdname[len] = '\0';
3487 return p;
3488}
3489
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003490/**
3491 * Read key of 'type' into 'key' and return the current
3492 * 'type' pointer.
3493 */
3494static char *key_get_info(const char *type, char **key)
3495{
3496 size_t len;
3497 char *p, *str;
3498
3499 if (*type == ',')
3500 type++;
3501
3502 p = strchr(type, ':');
3503 if (!p) {
3504 *key = NULL;
3505 return NULL;
3506 }
3507 len = p - type;
3508
Anthony Liguori7267c092011-08-20 22:09:37 -05003509 str = g_malloc(len + 1);
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003510 memcpy(str, type, len);
3511 str[len] = '\0';
3512
3513 *key = str;
3514 return ++p;
3515}
3516
bellard9307c4c2004-04-04 12:57:25 +00003517static int default_fmt_format = 'x';
3518static int default_fmt_size = 4;
3519
3520#define MAX_ARGS 16
3521
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02003522static int is_valid_option(const char *c, const char *typestr)
3523{
3524 char option[3];
3525
3526 option[0] = '-';
3527 option[1] = *c;
3528 option[2] = '\0';
3529
3530 typestr = strstr(typestr, option);
3531 return (typestr != NULL);
3532}
3533
Luiz Capitulino945c5ac2010-09-13 13:17:58 -03003534static const mon_cmd_t *search_dispatch_table(const mon_cmd_t *disp_table,
3535 const char *cmdname)
Luiz Capitulino7fd669a2009-11-26 22:58:54 -02003536{
3537 const mon_cmd_t *cmd;
3538
Luiz Capitulino945c5ac2010-09-13 13:17:58 -03003539 for (cmd = disp_table; cmd->name != NULL; cmd++) {
Luiz Capitulino7fd669a2009-11-26 22:58:54 -02003540 if (compare_cmd(cmdname, cmd->name)) {
3541 return cmd;
3542 }
3543 }
3544
3545 return NULL;
3546}
3547
Luiz Capitulino945c5ac2010-09-13 13:17:58 -03003548static const mon_cmd_t *monitor_find_command(const char *cmdname)
3549{
3550 return search_dispatch_table(mon_cmds, cmdname);
3551}
3552
Luiz Capitulinobead3ce2010-09-15 17:08:39 -03003553static const mon_cmd_t *qmp_find_cmd(const char *cmdname)
3554{
Luiz Capitulinof36b4af2010-09-15 17:17:45 -03003555 return search_dispatch_table(qmp_cmds, cmdname);
Luiz Capitulinobead3ce2010-09-15 17:08:39 -03003556}
3557
Anthony Liguoric227f092009-10-01 16:12:16 -05003558static const mon_cmd_t *monitor_parse_command(Monitor *mon,
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003559 const char *cmdline,
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003560 QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +00003561{
Luiz Capitulino4590fd82009-06-09 18:21:30 -03003562 const char *p, *typestr;
Luiz Capitulino53773582009-08-28 15:27:25 -03003563 int c;
Anthony Liguoric227f092009-10-01 16:12:16 -05003564 const mon_cmd_t *cmd;
bellard9307c4c2004-04-04 12:57:25 +00003565 char cmdname[256];
3566 char buf[1024];
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003567 char *key;
bellard9dc39cb2004-03-14 21:38:27 +00003568
3569#ifdef DEBUG
aliguori376253e2009-03-05 23:01:23 +00003570 monitor_printf(mon, "command='%s'\n", cmdline);
bellard9dc39cb2004-03-14 21:38:27 +00003571#endif
ths3b46e622007-09-17 08:09:54 +00003572
bellard9307c4c2004-04-04 12:57:25 +00003573 /* extract the command name */
Luiz Capitulino4590fd82009-06-09 18:21:30 -03003574 p = get_command_name(cmdline, cmdname, sizeof(cmdname));
3575 if (!p)
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003576 return NULL;
ths3b46e622007-09-17 08:09:54 +00003577
Luiz Capitulino7fd669a2009-11-26 22:58:54 -02003578 cmd = monitor_find_command(cmdname);
3579 if (!cmd) {
Luiz Capitulinod91d9bf2009-06-09 18:21:54 -03003580 monitor_printf(mon, "unknown command: '%s'\n", cmdname);
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003581 return NULL;
Luiz Capitulinod91d9bf2009-06-09 18:21:54 -03003582 }
bellard9307c4c2004-04-04 12:57:25 +00003583
bellard9307c4c2004-04-04 12:57:25 +00003584 /* parse the parameters */
3585 typestr = cmd->args_type;
bellard9307c4c2004-04-04 12:57:25 +00003586 for(;;) {
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003587 typestr = key_get_info(typestr, &key);
3588 if (!typestr)
bellard9307c4c2004-04-04 12:57:25 +00003589 break;
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003590 c = *typestr;
bellard9307c4c2004-04-04 12:57:25 +00003591 typestr++;
3592 switch(c) {
3593 case 'F':
bellard81d09122004-07-14 17:21:37 +00003594 case 'B':
bellard9307c4c2004-04-04 12:57:25 +00003595 case 's':
3596 {
3597 int ret;
ths3b46e622007-09-17 08:09:54 +00003598
blueswir1cd390082008-11-16 13:53:32 +00003599 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00003600 p++;
3601 if (*typestr == '?') {
3602 typestr++;
3603 if (*p == '\0') {
3604 /* no optional string: NULL argument */
Luiz Capitulino53773582009-08-28 15:27:25 -03003605 break;
bellard9307c4c2004-04-04 12:57:25 +00003606 }
3607 }
3608 ret = get_str(buf, sizeof(buf), &p);
3609 if (ret < 0) {
bellard81d09122004-07-14 17:21:37 +00003610 switch(c) {
3611 case 'F':
aliguori376253e2009-03-05 23:01:23 +00003612 monitor_printf(mon, "%s: filename expected\n",
3613 cmdname);
bellard81d09122004-07-14 17:21:37 +00003614 break;
3615 case 'B':
aliguori376253e2009-03-05 23:01:23 +00003616 monitor_printf(mon, "%s: block device name expected\n",
3617 cmdname);
bellard81d09122004-07-14 17:21:37 +00003618 break;
3619 default:
aliguori376253e2009-03-05 23:01:23 +00003620 monitor_printf(mon, "%s: string expected\n", cmdname);
bellard81d09122004-07-14 17:21:37 +00003621 break;
3622 }
bellard9307c4c2004-04-04 12:57:25 +00003623 goto fail;
3624 }
Luiz Capitulino53773582009-08-28 15:27:25 -03003625 qdict_put(qdict, key, qstring_from_str(buf));
bellard9307c4c2004-04-04 12:57:25 +00003626 }
3627 break;
Markus Armbruster361127d2010-02-10 20:24:35 +01003628 case 'O':
3629 {
3630 QemuOptsList *opts_list;
3631 QemuOpts *opts;
3632
3633 opts_list = qemu_find_opts(key);
3634 if (!opts_list || opts_list->desc->name) {
3635 goto bad_type;
3636 }
3637 while (qemu_isspace(*p)) {
3638 p++;
3639 }
3640 if (!*p)
3641 break;
3642 if (get_str(buf, sizeof(buf), &p) < 0) {
3643 goto fail;
3644 }
3645 opts = qemu_opts_parse(opts_list, buf, 1);
3646 if (!opts) {
3647 goto fail;
3648 }
3649 qemu_opts_to_qdict(opts, qdict);
3650 qemu_opts_del(opts);
3651 }
3652 break;
bellard9307c4c2004-04-04 12:57:25 +00003653 case '/':
3654 {
3655 int count, format, size;
ths3b46e622007-09-17 08:09:54 +00003656
blueswir1cd390082008-11-16 13:53:32 +00003657 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00003658 p++;
3659 if (*p == '/') {
3660 /* format found */
3661 p++;
3662 count = 1;
blueswir1cd390082008-11-16 13:53:32 +00003663 if (qemu_isdigit(*p)) {
bellard9307c4c2004-04-04 12:57:25 +00003664 count = 0;
blueswir1cd390082008-11-16 13:53:32 +00003665 while (qemu_isdigit(*p)) {
bellard9307c4c2004-04-04 12:57:25 +00003666 count = count * 10 + (*p - '0');
3667 p++;
3668 }
3669 }
3670 size = -1;
3671 format = -1;
3672 for(;;) {
3673 switch(*p) {
3674 case 'o':
3675 case 'd':
3676 case 'u':
3677 case 'x':
3678 case 'i':
3679 case 'c':
3680 format = *p++;
3681 break;
3682 case 'b':
3683 size = 1;
3684 p++;
3685 break;
3686 case 'h':
3687 size = 2;
3688 p++;
3689 break;
3690 case 'w':
3691 size = 4;
3692 p++;
3693 break;
3694 case 'g':
3695 case 'L':
3696 size = 8;
3697 p++;
3698 break;
3699 default:
3700 goto next;
3701 }
3702 }
3703 next:
blueswir1cd390082008-11-16 13:53:32 +00003704 if (*p != '\0' && !qemu_isspace(*p)) {
aliguori376253e2009-03-05 23:01:23 +00003705 monitor_printf(mon, "invalid char in format: '%c'\n",
3706 *p);
bellard9307c4c2004-04-04 12:57:25 +00003707 goto fail;
3708 }
bellard9307c4c2004-04-04 12:57:25 +00003709 if (format < 0)
3710 format = default_fmt_format;
bellard4c27ba22004-04-25 18:05:08 +00003711 if (format != 'i') {
3712 /* for 'i', not specifying a size gives -1 as size */
3713 if (size < 0)
3714 size = default_fmt_size;
aurel32e90f0092008-10-01 21:45:51 +00003715 default_fmt_size = size;
bellard4c27ba22004-04-25 18:05:08 +00003716 }
bellard9307c4c2004-04-04 12:57:25 +00003717 default_fmt_format = format;
3718 } else {
3719 count = 1;
3720 format = default_fmt_format;
bellard4c27ba22004-04-25 18:05:08 +00003721 if (format != 'i') {
3722 size = default_fmt_size;
3723 } else {
3724 size = -1;
3725 }
bellard9307c4c2004-04-04 12:57:25 +00003726 }
Luiz Capitulinof7188bb2009-08-28 15:27:10 -03003727 qdict_put(qdict, "count", qint_from_int(count));
3728 qdict_put(qdict, "format", qint_from_int(format));
3729 qdict_put(qdict, "size", qint_from_int(size));
bellard9307c4c2004-04-04 12:57:25 +00003730 }
3731 break;
3732 case 'i':
bellard92a31b12005-02-10 22:00:52 +00003733 case 'l':
Luiz Capitulinob6e098d2009-12-18 13:25:04 -02003734 case 'M':
bellard9307c4c2004-04-04 12:57:25 +00003735 {
blueswir1c2efc952007-09-25 17:28:42 +00003736 int64_t val;
blueswir17743e582007-09-24 18:39:04 +00003737
blueswir1cd390082008-11-16 13:53:32 +00003738 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00003739 p++;
bellard34405572004-06-08 00:55:58 +00003740 if (*typestr == '?' || *typestr == '.') {
bellard34405572004-06-08 00:55:58 +00003741 if (*typestr == '?') {
Luiz Capitulino53773582009-08-28 15:27:25 -03003742 if (*p == '\0') {
3743 typestr++;
3744 break;
3745 }
bellard34405572004-06-08 00:55:58 +00003746 } else {
3747 if (*p == '.') {
3748 p++;
blueswir1cd390082008-11-16 13:53:32 +00003749 while (qemu_isspace(*p))
bellard34405572004-06-08 00:55:58 +00003750 p++;
bellard34405572004-06-08 00:55:58 +00003751 } else {
Luiz Capitulino53773582009-08-28 15:27:25 -03003752 typestr++;
3753 break;
bellard34405572004-06-08 00:55:58 +00003754 }
3755 }
bellard13224a82006-07-14 22:03:35 +00003756 typestr++;
bellard9307c4c2004-04-04 12:57:25 +00003757 }
aliguori376253e2009-03-05 23:01:23 +00003758 if (get_expr(mon, &val, &p))
bellard9307c4c2004-04-04 12:57:25 +00003759 goto fail;
Luiz Capitulino675ebef2009-08-28 15:27:26 -03003760 /* Check if 'i' is greater than 32-bit */
3761 if ((c == 'i') && ((val >> 32) & 0xffffffff)) {
3762 monitor_printf(mon, "\'%s\' has failed: ", cmdname);
3763 monitor_printf(mon, "integer is for 32-bit values\n");
3764 goto fail;
Luiz Capitulinob6e098d2009-12-18 13:25:04 -02003765 } else if (c == 'M') {
Luiz Capitulino91162842012-04-26 17:34:30 -03003766 if (val < 0) {
3767 monitor_printf(mon, "enter a positive value\n");
3768 goto fail;
3769 }
Luiz Capitulinob6e098d2009-12-18 13:25:04 -02003770 val <<= 20;
Luiz Capitulino675ebef2009-08-28 15:27:26 -03003771 }
Luiz Capitulino53773582009-08-28 15:27:25 -03003772 qdict_put(qdict, key, qint_from_int(val));
bellard9307c4c2004-04-04 12:57:25 +00003773 }
3774 break;
Jes Sorensendbc0c672010-10-21 17:15:47 +02003775 case 'o':
3776 {
Jes Sorensen70b4f4b2011-01-05 11:41:02 +01003777 int64_t val;
Jes Sorensendbc0c672010-10-21 17:15:47 +02003778 char *end;
3779
3780 while (qemu_isspace(*p)) {
3781 p++;
3782 }
3783 if (*typestr == '?') {
3784 typestr++;
3785 if (*p == '\0') {
3786 break;
3787 }
3788 }
3789 val = strtosz(p, &end);
3790 if (val < 0) {
3791 monitor_printf(mon, "invalid size\n");
3792 goto fail;
3793 }
3794 qdict_put(qdict, key, qint_from_int(val));
3795 p = end;
3796 }
3797 break;
Markus Armbrusterfccfb11e2010-01-25 14:23:06 +01003798 case 'T':
Markus Armbruster3350a4d2010-01-25 14:23:03 +01003799 {
3800 double val;
3801
3802 while (qemu_isspace(*p))
3803 p++;
3804 if (*typestr == '?') {
3805 typestr++;
3806 if (*p == '\0') {
3807 break;
3808 }
3809 }
3810 if (get_double(mon, &val, &p) < 0) {
3811 goto fail;
3812 }
Jes Sorensen07de3e62010-10-21 17:15:49 +02003813 if (p[0] && p[1] == 's') {
Markus Armbrusterfccfb11e2010-01-25 14:23:06 +01003814 switch (*p) {
3815 case 'm':
3816 val /= 1e3; p += 2; break;
3817 case 'u':
3818 val /= 1e6; p += 2; break;
3819 case 'n':
3820 val /= 1e9; p += 2; break;
3821 }
3822 }
Markus Armbruster3350a4d2010-01-25 14:23:03 +01003823 if (*p && !qemu_isspace(*p)) {
3824 monitor_printf(mon, "Unknown unit suffix\n");
3825 goto fail;
3826 }
3827 qdict_put(qdict, key, qfloat_from_double(val));
3828 }
3829 break;
Markus Armbruster942cd1f2010-03-26 09:07:09 +01003830 case 'b':
3831 {
3832 const char *beg;
3833 int val;
3834
3835 while (qemu_isspace(*p)) {
3836 p++;
3837 }
3838 beg = p;
3839 while (qemu_isgraph(*p)) {
3840 p++;
3841 }
3842 if (p - beg == 2 && !memcmp(beg, "on", p - beg)) {
3843 val = 1;
3844 } else if (p - beg == 3 && !memcmp(beg, "off", p - beg)) {
3845 val = 0;
3846 } else {
3847 monitor_printf(mon, "Expected 'on' or 'off'\n");
3848 goto fail;
3849 }
3850 qdict_put(qdict, key, qbool_from_int(val));
3851 }
3852 break;
bellard9307c4c2004-04-04 12:57:25 +00003853 case '-':
3854 {
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02003855 const char *tmp = p;
Luiz Capitulinoeb159d12010-05-28 15:25:24 -03003856 int skip_key = 0;
bellard9307c4c2004-04-04 12:57:25 +00003857 /* option */
ths3b46e622007-09-17 08:09:54 +00003858
bellard9307c4c2004-04-04 12:57:25 +00003859 c = *typestr++;
3860 if (c == '\0')
3861 goto bad_type;
blueswir1cd390082008-11-16 13:53:32 +00003862 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00003863 p++;
bellard9307c4c2004-04-04 12:57:25 +00003864 if (*p == '-') {
3865 p++;
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02003866 if(c != *p) {
3867 if(!is_valid_option(p, typestr)) {
3868
3869 monitor_printf(mon, "%s: unsupported option -%c\n",
3870 cmdname, *p);
3871 goto fail;
3872 } else {
3873 skip_key = 1;
3874 }
bellard9307c4c2004-04-04 12:57:25 +00003875 }
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02003876 if(skip_key) {
3877 p = tmp;
3878 } else {
Luiz Capitulinoeb159d12010-05-28 15:25:24 -03003879 /* has option */
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02003880 p++;
Luiz Capitulinoeb159d12010-05-28 15:25:24 -03003881 qdict_put(qdict, key, qbool_from_int(1));
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02003882 }
bellard9307c4c2004-04-04 12:57:25 +00003883 }
bellard9307c4c2004-04-04 12:57:25 +00003884 }
3885 break;
3886 default:
3887 bad_type:
aliguori376253e2009-03-05 23:01:23 +00003888 monitor_printf(mon, "%s: unknown type '%c'\n", cmdname, c);
bellard9307c4c2004-04-04 12:57:25 +00003889 goto fail;
3890 }
Anthony Liguori7267c092011-08-20 22:09:37 -05003891 g_free(key);
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003892 key = NULL;
bellard9307c4c2004-04-04 12:57:25 +00003893 }
3894 /* check that all arguments were parsed */
blueswir1cd390082008-11-16 13:53:32 +00003895 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00003896 p++;
3897 if (*p != '\0') {
aliguori376253e2009-03-05 23:01:23 +00003898 monitor_printf(mon, "%s: extraneous characters at the end of line\n",
3899 cmdname);
bellard9307c4c2004-04-04 12:57:25 +00003900 goto fail;
3901 }
3902
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003903 return cmd;
Gerd Hoffmannac7531e2009-08-14 10:36:06 +02003904
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003905fail:
Anthony Liguori7267c092011-08-20 22:09:37 -05003906 g_free(key);
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003907 return NULL;
3908}
3909
Markus Armbrusterd6f46832010-02-17 10:52:26 +01003910void monitor_set_error(Monitor *mon, QError *qerror)
3911{
3912 /* report only the first error */
3913 if (!mon->error) {
3914 mon->error = qerror;
3915 } else {
Markus Armbrusterd6f46832010-02-17 10:52:26 +01003916 QDECREF(qerror);
3917 }
3918}
3919
Luiz Capitulinobb89c2e2010-02-10 23:50:05 -02003920static void handler_audit(Monitor *mon, const mon_cmd_t *cmd, int ret)
3921{
Luiz Capitulino6d441432010-11-22 16:35:09 -02003922 if (ret && !monitor_has_error(mon)) {
3923 /*
3924 * If it returns failure, it must have passed on error.
3925 *
3926 * Action: Report an internal error to the client if in QMP.
3927 */
3928 qerror_report(QERR_UNDEFINED_ERROR);
Luiz Capitulino6d441432010-11-22 16:35:09 -02003929 }
Luiz Capitulinobb89c2e2010-02-10 23:50:05 -02003930}
3931
Luiz Capitulinof3c157c2009-11-26 22:58:55 -02003932static void handle_user_command(Monitor *mon, const char *cmdline)
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003933{
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003934 QDict *qdict;
Anthony Liguoric227f092009-10-01 16:12:16 -05003935 const mon_cmd_t *cmd;
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003936
3937 qdict = qdict_new();
3938
Luiz Capitulino590fb3b2009-08-28 15:27:24 -03003939 cmd = monitor_parse_command(mon, cmdline, qdict);
Luiz Capitulino13917be2009-10-07 13:41:54 -03003940 if (!cmd)
3941 goto out;
3942
Luiz Capitulino4903de02010-09-16 11:01:32 -03003943 if (handler_is_async(cmd)) {
Adam Litke940cc302010-01-25 12:18:44 -06003944 user_async_cmd_handler(mon, cmd, qdict);
Luiz Capitulino9e807212010-09-16 10:58:59 -03003945 } else if (handler_is_qobject(cmd)) {
Luiz Capitulinode79ba62010-09-16 11:06:11 -03003946 QObject *data = NULL;
3947
3948 /* XXX: ignores the error code */
3949 cmd->mhandler.cmd_new(mon, qdict, &data);
3950 assert(!monitor_has_error(mon));
3951 if (data) {
3952 cmd->user_print(mon, data);
3953 qobject_decref(data);
3954 }
Luiz Capitulino13917be2009-10-07 13:41:54 -03003955 } else {
Luiz Capitulinoaf4ce882009-10-07 13:41:52 -03003956 cmd->mhandler.cmd(mon, qdict);
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003957 }
3958
Luiz Capitulino13917be2009-10-07 13:41:54 -03003959out:
Luiz Capitulinof7188bb2009-08-28 15:27:10 -03003960 QDECREF(qdict);
bellard9dc39cb2004-03-14 21:38:27 +00003961}
3962
bellard81d09122004-07-14 17:21:37 +00003963static void cmd_completion(const char *name, const char *list)
3964{
3965 const char *p, *pstart;
3966 char cmd[128];
3967 int len;
3968
3969 p = list;
3970 for(;;) {
3971 pstart = p;
3972 p = strchr(p, '|');
3973 if (!p)
3974 p = pstart + strlen(pstart);
3975 len = p - pstart;
3976 if (len > sizeof(cmd) - 2)
3977 len = sizeof(cmd) - 2;
3978 memcpy(cmd, pstart, len);
3979 cmd[len] = '\0';
3980 if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
aliguori731b0362009-03-05 23:01:42 +00003981 readline_add_completion(cur_mon->rs, cmd);
bellard81d09122004-07-14 17:21:37 +00003982 }
3983 if (*p == '\0')
3984 break;
3985 p++;
3986 }
3987}
3988
3989static void file_completion(const char *input)
3990{
3991 DIR *ffs;
3992 struct dirent *d;
3993 char path[1024];
3994 char file[1024], file_prefix[1024];
3995 int input_path_len;
3996 const char *p;
3997
ths5fafdf22007-09-16 21:08:06 +00003998 p = strrchr(input, '/');
bellard81d09122004-07-14 17:21:37 +00003999 if (!p) {
4000 input_path_len = 0;
4001 pstrcpy(file_prefix, sizeof(file_prefix), input);
blueswir1363a37d2008-08-21 17:58:08 +00004002 pstrcpy(path, sizeof(path), ".");
bellard81d09122004-07-14 17:21:37 +00004003 } else {
4004 input_path_len = p - input + 1;
4005 memcpy(path, input, input_path_len);
4006 if (input_path_len > sizeof(path) - 1)
4007 input_path_len = sizeof(path) - 1;
4008 path[input_path_len] = '\0';
4009 pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
4010 }
4011#ifdef DEBUG_COMPLETION
aliguori376253e2009-03-05 23:01:23 +00004012 monitor_printf(cur_mon, "input='%s' path='%s' prefix='%s'\n",
4013 input, path, file_prefix);
bellard81d09122004-07-14 17:21:37 +00004014#endif
4015 ffs = opendir(path);
4016 if (!ffs)
4017 return;
4018 for(;;) {
4019 struct stat sb;
4020 d = readdir(ffs);
4021 if (!d)
4022 break;
Kusanagi Kouichi46c7fc12010-10-20 18:00:01 +09004023
4024 if (strcmp(d->d_name, ".") == 0 || strcmp(d->d_name, "..") == 0) {
4025 continue;
4026 }
4027
bellard81d09122004-07-14 17:21:37 +00004028 if (strstart(d->d_name, file_prefix, NULL)) {
4029 memcpy(file, input, input_path_len);
blueswir1363a37d2008-08-21 17:58:08 +00004030 if (input_path_len < sizeof(file))
4031 pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
4032 d->d_name);
bellard81d09122004-07-14 17:21:37 +00004033 /* stat the file to find out if it's a directory.
4034 * In that case add a slash to speed up typing long paths
4035 */
Markus Armbrusterc951d9a2011-11-16 15:43:47 +01004036 if (stat(file, &sb) == 0 && S_ISDIR(sb.st_mode)) {
blueswir1363a37d2008-08-21 17:58:08 +00004037 pstrcat(file, sizeof(file), "/");
Markus Armbrusterc951d9a2011-11-16 15:43:47 +01004038 }
aliguori731b0362009-03-05 23:01:42 +00004039 readline_add_completion(cur_mon->rs, file);
bellard81d09122004-07-14 17:21:37 +00004040 }
4041 }
4042 closedir(ffs);
4043}
4044
aliguori51de9762009-03-05 23:00:43 +00004045static void block_completion_it(void *opaque, BlockDriverState *bs)
bellard81d09122004-07-14 17:21:37 +00004046{
aliguori51de9762009-03-05 23:00:43 +00004047 const char *name = bdrv_get_device_name(bs);
bellard81d09122004-07-14 17:21:37 +00004048 const char *input = opaque;
4049
4050 if (input[0] == '\0' ||
4051 !strncmp(name, (char *)input, strlen(input))) {
aliguori731b0362009-03-05 23:01:42 +00004052 readline_add_completion(cur_mon->rs, name);
bellard81d09122004-07-14 17:21:37 +00004053 }
4054}
4055
4056/* NOTE: this parser is an approximate form of the real command parser */
4057static void parse_cmdline(const char *cmdline,
4058 int *pnb_args, char **args)
4059{
4060 const char *p;
4061 int nb_args, ret;
4062 char buf[1024];
4063
4064 p = cmdline;
4065 nb_args = 0;
4066 for(;;) {
blueswir1cd390082008-11-16 13:53:32 +00004067 while (qemu_isspace(*p))
bellard81d09122004-07-14 17:21:37 +00004068 p++;
4069 if (*p == '\0')
4070 break;
4071 if (nb_args >= MAX_ARGS)
4072 break;
4073 ret = get_str(buf, sizeof(buf), &p);
Anthony Liguori7267c092011-08-20 22:09:37 -05004074 args[nb_args] = g_strdup(buf);
bellard81d09122004-07-14 17:21:37 +00004075 nb_args++;
4076 if (ret < 0)
4077 break;
4078 }
4079 *pnb_args = nb_args;
4080}
4081
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03004082static const char *next_arg_type(const char *typestr)
4083{
4084 const char *p = strchr(typestr, ':');
4085 return (p != NULL ? ++p : typestr);
4086}
4087
aliguori4c36ba32009-03-05 23:01:37 +00004088static void monitor_find_completion(const char *cmdline)
bellard81d09122004-07-14 17:21:37 +00004089{
4090 const char *cmdname;
4091 char *args[MAX_ARGS];
4092 int nb_args, i, len;
4093 const char *ptype, *str;
Anthony Liguoric227f092009-10-01 16:12:16 -05004094 const mon_cmd_t *cmd;
bellard81d09122004-07-14 17:21:37 +00004095
4096 parse_cmdline(cmdline, &nb_args, args);
4097#ifdef DEBUG_COMPLETION
4098 for(i = 0; i < nb_args; i++) {
aliguori376253e2009-03-05 23:01:23 +00004099 monitor_printf(cur_mon, "arg%d = '%s'\n", i, (char *)args[i]);
bellard81d09122004-07-14 17:21:37 +00004100 }
4101#endif
4102
4103 /* if the line ends with a space, it means we want to complete the
4104 next arg */
4105 len = strlen(cmdline);
blueswir1cd390082008-11-16 13:53:32 +00004106 if (len > 0 && qemu_isspace(cmdline[len - 1])) {
Jan Kiszka03a63482010-06-16 00:38:33 +02004107 if (nb_args >= MAX_ARGS) {
4108 goto cleanup;
4109 }
Anthony Liguori7267c092011-08-20 22:09:37 -05004110 args[nb_args++] = g_strdup("");
bellard81d09122004-07-14 17:21:37 +00004111 }
4112 if (nb_args <= 1) {
4113 /* command completion */
4114 if (nb_args == 0)
4115 cmdname = "";
4116 else
4117 cmdname = args[0];
aliguori731b0362009-03-05 23:01:42 +00004118 readline_set_completion_index(cur_mon->rs, strlen(cmdname));
aliguori376253e2009-03-05 23:01:23 +00004119 for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
bellard81d09122004-07-14 17:21:37 +00004120 cmd_completion(cmdname, cmd->name);
4121 }
4122 } else {
4123 /* find the command */
Jan Kiszka03a63482010-06-16 00:38:33 +02004124 for (cmd = mon_cmds; cmd->name != NULL; cmd++) {
4125 if (compare_cmd(args[0], cmd->name)) {
4126 break;
4127 }
bellard81d09122004-07-14 17:21:37 +00004128 }
Jan Kiszka03a63482010-06-16 00:38:33 +02004129 if (!cmd->name) {
4130 goto cleanup;
4131 }
4132
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03004133 ptype = next_arg_type(cmd->args_type);
bellard81d09122004-07-14 17:21:37 +00004134 for(i = 0; i < nb_args - 2; i++) {
4135 if (*ptype != '\0') {
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03004136 ptype = next_arg_type(ptype);
bellard81d09122004-07-14 17:21:37 +00004137 while (*ptype == '?')
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03004138 ptype = next_arg_type(ptype);
bellard81d09122004-07-14 17:21:37 +00004139 }
4140 }
4141 str = args[nb_args - 1];
Blue Swirl2a1704a2009-08-23 20:10:28 +00004142 if (*ptype == '-' && ptype[1] != '\0') {
Jan Kiszka3b6dbf22010-06-16 00:38:34 +02004143 ptype = next_arg_type(ptype);
Blue Swirl2a1704a2009-08-23 20:10:28 +00004144 }
bellard81d09122004-07-14 17:21:37 +00004145 switch(*ptype) {
4146 case 'F':
4147 /* file completion */
aliguori731b0362009-03-05 23:01:42 +00004148 readline_set_completion_index(cur_mon->rs, strlen(str));
bellard81d09122004-07-14 17:21:37 +00004149 file_completion(str);
4150 break;
4151 case 'B':
4152 /* block device name completion */
aliguori731b0362009-03-05 23:01:42 +00004153 readline_set_completion_index(cur_mon->rs, strlen(str));
bellard81d09122004-07-14 17:21:37 +00004154 bdrv_iterate(block_completion_it, (void *)str);
4155 break;
bellard7fe48482004-10-09 18:08:01 +00004156 case 's':
4157 /* XXX: more generic ? */
4158 if (!strcmp(cmd->name, "info")) {
aliguori731b0362009-03-05 23:01:42 +00004159 readline_set_completion_index(cur_mon->rs, strlen(str));
bellard7fe48482004-10-09 18:08:01 +00004160 for(cmd = info_cmds; cmd->name != NULL; cmd++) {
4161 cmd_completion(str, cmd->name);
4162 }
bellard64866c32006-05-07 18:03:31 +00004163 } else if (!strcmp(cmd->name, "sendkey")) {
blueswir1e600d1e2009-03-08 17:42:02 +00004164 char *sep = strrchr(str, '-');
4165 if (sep)
4166 str = sep + 1;
aliguori731b0362009-03-05 23:01:42 +00004167 readline_set_completion_index(cur_mon->rs, strlen(str));
Amos Kong1048c882012-08-31 10:56:25 +08004168 for (i = 0; i < Q_KEY_CODE_MAX; i++) {
4169 cmd_completion(str, QKeyCode_lookup[i]);
bellard64866c32006-05-07 18:03:31 +00004170 }
Jan Kiszkaf3353c62009-06-25 08:22:02 +02004171 } else if (!strcmp(cmd->name, "help|?")) {
4172 readline_set_completion_index(cur_mon->rs, strlen(str));
4173 for (cmd = mon_cmds; cmd->name != NULL; cmd++) {
4174 cmd_completion(str, cmd->name);
4175 }
bellard7fe48482004-10-09 18:08:01 +00004176 }
4177 break;
bellard81d09122004-07-14 17:21:37 +00004178 default:
4179 break;
4180 }
4181 }
Jan Kiszka03a63482010-06-16 00:38:33 +02004182
4183cleanup:
4184 for (i = 0; i < nb_args; i++) {
Anthony Liguori7267c092011-08-20 22:09:37 -05004185 g_free(args[i]);
Jan Kiszka03a63482010-06-16 00:38:33 +02004186 }
bellard81d09122004-07-14 17:21:37 +00004187}
4188
aliguori731b0362009-03-05 23:01:42 +00004189static int monitor_can_read(void *opaque)
bellard9dc39cb2004-03-14 21:38:27 +00004190{
aliguori731b0362009-03-05 23:01:42 +00004191 Monitor *mon = opaque;
4192
Jan Kiszkac62313b2009-12-04 14:05:29 +01004193 return (mon->suspend_cnt == 0) ? 1 : 0;
bellard9dc39cb2004-03-14 21:38:27 +00004194}
4195
Luiz Capitulino09069b12010-02-04 18:10:06 -02004196static int invalid_qmp_mode(const Monitor *mon, const char *cmd_name)
4197{
4198 int is_cap = compare_cmd(cmd_name, "qmp_capabilities");
4199 return (qmp_cmd_mode(mon) ? is_cap : !is_cap);
4200}
4201
Luiz Capitulino2dbc8db2010-05-26 16:13:09 -03004202/*
Luiz Capitulino4af91932010-06-22 11:44:05 -03004203 * Argument validation rules:
4204 *
4205 * 1. The argument must exist in cmd_args qdict
4206 * 2. The argument type must be the expected one
4207 *
4208 * Special case: If the argument doesn't exist in cmd_args and
4209 * the QMP_ACCEPT_UNKNOWNS flag is set, then the
4210 * checking is skipped for it.
4211 */
4212static int check_client_args_type(const QDict *client_args,
4213 const QDict *cmd_args, int flags)
4214{
4215 const QDictEntry *ent;
4216
4217 for (ent = qdict_first(client_args); ent;ent = qdict_next(client_args,ent)){
4218 QObject *obj;
4219 QString *arg_type;
4220 const QObject *client_arg = qdict_entry_value(ent);
4221 const char *client_arg_name = qdict_entry_key(ent);
4222
4223 obj = qdict_get(cmd_args, client_arg_name);
4224 if (!obj) {
4225 if (flags & QMP_ACCEPT_UNKNOWNS) {
4226 /* handler accepts unknowns */
4227 continue;
4228 }
4229 /* client arg doesn't exist */
4230 qerror_report(QERR_INVALID_PARAMETER, client_arg_name);
4231 return -1;
4232 }
4233
4234 arg_type = qobject_to_qstring(obj);
4235 assert(arg_type != NULL);
4236
4237 /* check if argument's type is correct */
4238 switch (qstring_get_str(arg_type)[0]) {
4239 case 'F':
4240 case 'B':
4241 case 's':
4242 if (qobject_type(client_arg) != QTYPE_QSTRING) {
4243 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4244 "string");
4245 return -1;
4246 }
4247 break;
4248 case 'i':
4249 case 'l':
4250 case 'M':
Jes Sorensendbc0c672010-10-21 17:15:47 +02004251 case 'o':
Luiz Capitulino4af91932010-06-22 11:44:05 -03004252 if (qobject_type(client_arg) != QTYPE_QINT) {
4253 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4254 "int");
4255 return -1;
4256 }
4257 break;
Luiz Capitulino4af91932010-06-22 11:44:05 -03004258 case 'T':
4259 if (qobject_type(client_arg) != QTYPE_QINT &&
4260 qobject_type(client_arg) != QTYPE_QFLOAT) {
4261 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4262 "number");
4263 return -1;
4264 }
4265 break;
4266 case 'b':
4267 case '-':
4268 if (qobject_type(client_arg) != QTYPE_QBOOL) {
4269 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4270 "bool");
4271 return -1;
4272 }
4273 break;
4274 case 'O':
4275 assert(flags & QMP_ACCEPT_UNKNOWNS);
4276 break;
Paolo Bonzinib9f89782012-03-22 12:51:11 +01004277 case 'q':
4278 /* Any QObject can be passed. */
4279 break;
Luiz Capitulino4af91932010-06-22 11:44:05 -03004280 case '/':
4281 case '.':
4282 /*
4283 * These types are not supported by QMP and thus are not
4284 * handled here. Fall through.
4285 */
4286 default:
4287 abort();
4288 }
4289 }
4290
4291 return 0;
4292}
4293
4294/*
Luiz Capitulino2dbc8db2010-05-26 16:13:09 -03004295 * - Check if the client has passed all mandatory args
4296 * - Set special flags for argument validation
4297 */
4298static int check_mandatory_args(const QDict *cmd_args,
4299 const QDict *client_args, int *flags)
4300{
4301 const QDictEntry *ent;
4302
4303 for (ent = qdict_first(cmd_args); ent; ent = qdict_next(cmd_args, ent)) {
4304 const char *cmd_arg_name = qdict_entry_key(ent);
4305 QString *type = qobject_to_qstring(qdict_entry_value(ent));
4306 assert(type != NULL);
4307
4308 if (qstring_get_str(type)[0] == 'O') {
4309 assert((*flags & QMP_ACCEPT_UNKNOWNS) == 0);
4310 *flags |= QMP_ACCEPT_UNKNOWNS;
4311 } else if (qstring_get_str(type)[0] != '-' &&
4312 qstring_get_str(type)[1] != '?' &&
4313 !qdict_haskey(client_args, cmd_arg_name)) {
4314 qerror_report(QERR_MISSING_PARAMETER, cmd_arg_name);
4315 return -1;
4316 }
4317 }
4318
4319 return 0;
4320}
4321
4322static QDict *qdict_from_args_type(const char *args_type)
4323{
4324 int i;
4325 QDict *qdict;
4326 QString *key, *type, *cur_qs;
4327
4328 assert(args_type != NULL);
4329
4330 qdict = qdict_new();
4331
4332 if (args_type == NULL || args_type[0] == '\0') {
4333 /* no args, empty qdict */
4334 goto out;
4335 }
4336
4337 key = qstring_new();
4338 type = qstring_new();
4339
4340 cur_qs = key;
4341
4342 for (i = 0;; i++) {
4343 switch (args_type[i]) {
4344 case ',':
4345 case '\0':
4346 qdict_put(qdict, qstring_get_str(key), type);
4347 QDECREF(key);
4348 if (args_type[i] == '\0') {
4349 goto out;
4350 }
4351 type = qstring_new(); /* qdict has ref */
4352 cur_qs = key = qstring_new();
4353 break;
4354 case ':':
4355 cur_qs = type;
4356 break;
4357 default:
4358 qstring_append_chr(cur_qs, args_type[i]);
4359 break;
4360 }
4361 }
4362
4363out:
4364 return qdict;
4365}
4366
4367/*
4368 * Client argument checking rules:
4369 *
4370 * 1. Client must provide all mandatory arguments
Luiz Capitulino4af91932010-06-22 11:44:05 -03004371 * 2. Each argument provided by the client must be expected
4372 * 3. Each argument provided by the client must have the type expected
4373 * by the command
Luiz Capitulino2dbc8db2010-05-26 16:13:09 -03004374 */
4375static int qmp_check_client_args(const mon_cmd_t *cmd, QDict *client_args)
4376{
4377 int flags, err;
4378 QDict *cmd_args;
4379
4380 cmd_args = qdict_from_args_type(cmd->args_type);
4381
4382 flags = 0;
4383 err = check_mandatory_args(cmd_args, client_args, &flags);
4384 if (err) {
4385 goto out;
4386 }
4387
Luiz Capitulino4af91932010-06-22 11:44:05 -03004388 err = check_client_args_type(client_args, cmd_args, flags);
Luiz Capitulino2dbc8db2010-05-26 16:13:09 -03004389
4390out:
4391 QDECREF(cmd_args);
4392 return err;
4393}
4394
Luiz Capitulinoc917c8f2010-05-31 17:28:01 -03004395/*
4396 * Input object checking rules
4397 *
4398 * 1. Input object must be a dict
4399 * 2. The "execute" key must exist
4400 * 3. The "execute" key must be a string
4401 * 4. If the "arguments" key exists, it must be a dict
4402 * 5. If the "id" key exists, it can be anything (ie. json-value)
4403 * 6. Any argument not listed above is considered invalid
4404 */
4405static QDict *qmp_check_input_obj(QObject *input_obj)
4406{
4407 const QDictEntry *ent;
4408 int has_exec_key = 0;
4409 QDict *input_dict;
4410
4411 if (qobject_type(input_obj) != QTYPE_QDICT) {
4412 qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "object");
4413 return NULL;
4414 }
4415
4416 input_dict = qobject_to_qdict(input_obj);
4417
4418 for (ent = qdict_first(input_dict); ent; ent = qdict_next(input_dict, ent)){
4419 const char *arg_name = qdict_entry_key(ent);
4420 const QObject *arg_obj = qdict_entry_value(ent);
4421
4422 if (!strcmp(arg_name, "execute")) {
4423 if (qobject_type(arg_obj) != QTYPE_QSTRING) {
4424 qerror_report(QERR_QMP_BAD_INPUT_OBJECT_MEMBER, "execute",
4425 "string");
4426 return NULL;
4427 }
4428 has_exec_key = 1;
4429 } else if (!strcmp(arg_name, "arguments")) {
4430 if (qobject_type(arg_obj) != QTYPE_QDICT) {
4431 qerror_report(QERR_QMP_BAD_INPUT_OBJECT_MEMBER, "arguments",
4432 "object");
4433 return NULL;
4434 }
4435 } else if (!strcmp(arg_name, "id")) {
4436 /* FIXME: check duplicated IDs for async commands */
4437 } else {
4438 qerror_report(QERR_QMP_EXTRA_MEMBER, arg_name);
4439 return NULL;
4440 }
4441 }
4442
4443 if (!has_exec_key) {
4444 qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "execute");
4445 return NULL;
4446 }
4447
4448 return input_dict;
4449}
4450
Luiz Capitulinofc29df72010-09-16 11:11:18 -03004451static void qmp_call_cmd(Monitor *mon, const mon_cmd_t *cmd,
4452 const QDict *params)
4453{
4454 int ret;
4455 QObject *data = NULL;
4456
Luiz Capitulinofc29df72010-09-16 11:11:18 -03004457 ret = cmd->mhandler.cmd_new(mon, params, &data);
4458 handler_audit(mon, cmd, ret);
4459 monitor_protocol_emitter(mon, data);
4460 qobject_decref(data);
4461}
4462
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004463static void handle_qmp_command(JSONMessageParser *parser, QList *tokens)
4464{
4465 int err;
4466 QObject *obj;
4467 QDict *input, *args;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004468 const mon_cmd_t *cmd;
Luiz Capitulino40e5a012011-10-21 16:15:31 -02004469 const char *cmd_name;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004470 Monitor *mon = cur_mon;
4471
Luiz Capitulinoe4940c62010-06-24 17:58:20 -03004472 args = input = NULL;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004473
4474 obj = json_parser_parse(tokens, NULL);
4475 if (!obj) {
4476 // FIXME: should be triggered in json_parser_parse()
Markus Armbrusterab5b0272010-03-02 18:15:09 +01004477 qerror_report(QERR_JSON_PARSING);
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004478 goto err_out;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004479 }
4480
Luiz Capitulinoc917c8f2010-05-31 17:28:01 -03004481 input = qmp_check_input_obj(obj);
4482 if (!input) {
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004483 qobject_decref(obj);
4484 goto err_out;
4485 }
4486
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004487 mon->mc->id = qdict_get(input, "id");
4488 qobject_incref(mon->mc->id);
4489
Luiz Capitulino0bbab462010-05-31 17:32:50 -03004490 cmd_name = qdict_get_str(input, "execute");
Stefan Hajnoczi89bd8202011-09-23 08:23:06 +01004491 trace_handle_qmp_command(mon, cmd_name);
Luiz Capitulino09069b12010-02-04 18:10:06 -02004492 if (invalid_qmp_mode(mon, cmd_name)) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01004493 qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);
Luiz Capitulinoe4940c62010-06-24 17:58:20 -03004494 goto err_out;
Luiz Capitulino09069b12010-02-04 18:10:06 -02004495 }
4496
Anthony Liguorie3193602011-09-02 12:34:47 -05004497 cmd = qmp_find_cmd(cmd_name);
Luiz Capitulinod1249ea2010-09-13 14:44:27 -03004498 if (!cmd) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01004499 qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);
Luiz Capitulinoe4940c62010-06-24 17:58:20 -03004500 goto err_out;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004501 }
4502
4503 obj = qdict_get(input, "arguments");
4504 if (!obj) {
4505 args = qdict_new();
4506 } else {
4507 args = qobject_to_qdict(obj);
4508 QINCREF(args);
4509 }
4510
Luiz Capitulino2dbc8db2010-05-26 16:13:09 -03004511 err = qmp_check_client_args(cmd, args);
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004512 if (err < 0) {
4513 goto err_out;
4514 }
4515
Luiz Capitulino40e5a012011-10-21 16:15:31 -02004516 if (handler_is_async(cmd)) {
Luiz Capitulino5af7bba2010-06-22 19:10:46 -03004517 err = qmp_async_cmd_handler(mon, cmd, args);
4518 if (err) {
4519 /* emit the error response */
4520 goto err_out;
4521 }
Adam Litke940cc302010-01-25 12:18:44 -06004522 } else {
Luiz Capitulinofc29df72010-09-16 11:11:18 -03004523 qmp_call_cmd(mon, cmd, args);
Adam Litke940cc302010-01-25 12:18:44 -06004524 }
Luiz Capitulinoe4940c62010-06-24 17:58:20 -03004525
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004526 goto out;
4527
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004528err_out:
4529 monitor_protocol_emitter(mon, NULL);
4530out:
Luiz Capitulinoe4940c62010-06-24 17:58:20 -03004531 QDECREF(input);
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004532 QDECREF(args);
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004533}
4534
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004535/**
4536 * monitor_control_read(): Read and handle QMP input
4537 */
4538static void monitor_control_read(void *opaque, const uint8_t *buf, int size)
4539{
4540 Monitor *old_mon = cur_mon;
4541
4542 cur_mon = opaque;
4543
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004544 json_message_parser_feed(&cur_mon->mc->parser, (const char *) buf, size);
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004545
4546 cur_mon = old_mon;
4547}
4548
aliguori731b0362009-03-05 23:01:42 +00004549static void monitor_read(void *opaque, const uint8_t *buf, int size)
bellard9dc39cb2004-03-14 21:38:27 +00004550{
aliguori731b0362009-03-05 23:01:42 +00004551 Monitor *old_mon = cur_mon;
bellard9dc39cb2004-03-14 21:38:27 +00004552 int i;
aliguori376253e2009-03-05 23:01:23 +00004553
aliguori731b0362009-03-05 23:01:42 +00004554 cur_mon = opaque;
bellard7e2515e2004-08-01 21:52:19 +00004555
aliguoricde76ee2009-03-05 23:01:51 +00004556 if (cur_mon->rs) {
4557 for (i = 0; i < size; i++)
4558 readline_handle_byte(cur_mon->rs, buf[i]);
4559 } else {
4560 if (size == 0 || buf[size - 1] != 0)
4561 monitor_printf(cur_mon, "corrupted command\n");
4562 else
Luiz Capitulinof3c157c2009-11-26 22:58:55 -02004563 handle_user_command(cur_mon, (char *)buf);
aliguoricde76ee2009-03-05 23:01:51 +00004564 }
aliguori731b0362009-03-05 23:01:42 +00004565
4566 cur_mon = old_mon;
4567}
aliguorid8f44602008-10-06 13:52:44 +00004568
aliguori376253e2009-03-05 23:01:23 +00004569static void monitor_command_cb(Monitor *mon, const char *cmdline, void *opaque)
bellard7e2515e2004-08-01 21:52:19 +00004570{
aliguori731b0362009-03-05 23:01:42 +00004571 monitor_suspend(mon);
Luiz Capitulinof3c157c2009-11-26 22:58:55 -02004572 handle_user_command(mon, cmdline);
aliguori731b0362009-03-05 23:01:42 +00004573 monitor_resume(mon);
aliguorid8f44602008-10-06 13:52:44 +00004574}
4575
aliguoricde76ee2009-03-05 23:01:51 +00004576int monitor_suspend(Monitor *mon)
aliguorid8f44602008-10-06 13:52:44 +00004577{
aliguoricde76ee2009-03-05 23:01:51 +00004578 if (!mon->rs)
4579 return -ENOTTY;
aliguori731b0362009-03-05 23:01:42 +00004580 mon->suspend_cnt++;
aliguoricde76ee2009-03-05 23:01:51 +00004581 return 0;
aliguorid8f44602008-10-06 13:52:44 +00004582}
4583
aliguori376253e2009-03-05 23:01:23 +00004584void monitor_resume(Monitor *mon)
aliguorid8f44602008-10-06 13:52:44 +00004585{
aliguoricde76ee2009-03-05 23:01:51 +00004586 if (!mon->rs)
4587 return;
aliguori731b0362009-03-05 23:01:42 +00004588 if (--mon->suspend_cnt == 0)
4589 readline_show_prompt(mon->rs);
bellard7e2515e2004-08-01 21:52:19 +00004590}
4591
Luiz Capitulinoca9567e2010-02-04 18:10:04 -02004592static QObject *get_qmp_greeting(void)
4593{
Luiz Capitulinob9c15f12011-08-26 17:38:13 -03004594 QObject *ver = NULL;
Luiz Capitulinoca9567e2010-02-04 18:10:04 -02004595
Luiz Capitulinob9c15f12011-08-26 17:38:13 -03004596 qmp_marshal_input_query_version(NULL, NULL, &ver);
Luiz Capitulinoca9567e2010-02-04 18:10:04 -02004597 return qobject_from_jsonf("{'QMP':{'version': %p,'capabilities': []}}",ver);
4598}
4599
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004600/**
4601 * monitor_control_event(): Print QMP gretting
4602 */
4603static void monitor_control_event(void *opaque, int event)
4604{
Luiz Capitulino47116d12010-02-08 17:01:30 -02004605 QObject *data;
4606 Monitor *mon = opaque;
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004607
Luiz Capitulino47116d12010-02-08 17:01:30 -02004608 switch (event) {
4609 case CHR_EVENT_OPENED:
Luiz Capitulino4a7e1192010-02-04 18:10:05 -02004610 mon->mc->command_mode = 0;
Luiz Capitulinoca9567e2010-02-04 18:10:04 -02004611 data = get_qmp_greeting();
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004612 monitor_json_emitter(mon, data);
4613 qobject_decref(data);
Corey Bryantefb87c12012-08-14 16:43:48 -04004614 mon_refcount++;
Luiz Capitulino47116d12010-02-08 17:01:30 -02004615 break;
4616 case CHR_EVENT_CLOSED:
4617 json_message_parser_destroy(&mon->mc->parser);
Anthony Liguori58617a72012-08-23 08:03:21 -05004618 json_message_parser_init(&mon->mc->parser, handle_qmp_command);
Corey Bryantefb87c12012-08-14 16:43:48 -04004619 mon_refcount--;
4620 monitor_fdsets_cleanup();
Luiz Capitulino47116d12010-02-08 17:01:30 -02004621 break;
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004622 }
4623}
4624
aliguori731b0362009-03-05 23:01:42 +00004625static void monitor_event(void *opaque, int event)
ths86e94de2007-01-05 22:01:59 +00004626{
aliguori376253e2009-03-05 23:01:23 +00004627 Monitor *mon = opaque;
4628
aliguori2724b182009-03-05 23:01:47 +00004629 switch (event) {
4630 case CHR_EVENT_MUX_IN:
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +02004631 mon->mux_out = 0;
4632 if (mon->reset_seen) {
4633 readline_restart(mon->rs);
4634 monitor_resume(mon);
4635 monitor_flush(mon);
4636 } else {
4637 mon->suspend_cnt = 0;
4638 }
aliguori2724b182009-03-05 23:01:47 +00004639 break;
ths86e94de2007-01-05 22:01:59 +00004640
aliguori2724b182009-03-05 23:01:47 +00004641 case CHR_EVENT_MUX_OUT:
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +02004642 if (mon->reset_seen) {
4643 if (mon->suspend_cnt == 0) {
4644 monitor_printf(mon, "\n");
4645 }
4646 monitor_flush(mon);
4647 monitor_suspend(mon);
4648 } else {
4649 mon->suspend_cnt++;
4650 }
4651 mon->mux_out = 1;
aliguori2724b182009-03-05 23:01:47 +00004652 break;
4653
Amit Shahb6b8df52009-10-07 18:31:16 +05304654 case CHR_EVENT_OPENED:
aliguori2724b182009-03-05 23:01:47 +00004655 monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
4656 "information\n", QEMU_VERSION);
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +02004657 if (!mon->mux_out) {
aliguori2724b182009-03-05 23:01:47 +00004658 readline_show_prompt(mon->rs);
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +02004659 }
4660 mon->reset_seen = 1;
Corey Bryantefb87c12012-08-14 16:43:48 -04004661 mon_refcount++;
4662 break;
4663
4664 case CHR_EVENT_CLOSED:
4665 mon_refcount--;
4666 monitor_fdsets_cleanup();
aliguori2724b182009-03-05 23:01:47 +00004667 break;
4668 }
ths86e94de2007-01-05 22:01:59 +00004669}
4670
Wayne Xia816f8922011-10-12 11:32:41 +08004671static int
4672compare_mon_cmd(const void *a, const void *b)
4673{
4674 return strcmp(((const mon_cmd_t *)a)->name,
4675 ((const mon_cmd_t *)b)->name);
4676}
4677
4678static void sortcmdlist(void)
4679{
4680 int array_num;
4681 int elem_size = sizeof(mon_cmd_t);
4682
4683 array_num = sizeof(mon_cmds)/elem_size-1;
4684 qsort((void *)mon_cmds, array_num, elem_size, compare_mon_cmd);
4685
4686 array_num = sizeof(info_cmds)/elem_size-1;
4687 qsort((void *)info_cmds, array_num, elem_size, compare_mon_cmd);
4688}
4689
aliguori76655d62009-03-06 20:27:37 +00004690
4691/*
4692 * Local variables:
4693 * c-indent-level: 4
4694 * c-basic-offset: 4
4695 * tab-width: 8
4696 * End:
4697 */
4698
aliguori731b0362009-03-05 23:01:42 +00004699void monitor_init(CharDriverState *chr, int flags)
bellard9dc39cb2004-03-14 21:38:27 +00004700{
aliguori731b0362009-03-05 23:01:42 +00004701 static int is_first_init = 1;
aliguori87127162009-03-05 23:01:29 +00004702 Monitor *mon;
ths20d8a3e2007-02-18 17:04:49 +00004703
4704 if (is_first_init) {
Daniel P. Berrangeafeecec2012-06-14 18:12:57 +01004705 monitor_protocol_event_init();
ths20d8a3e2007-02-18 17:04:49 +00004706 is_first_init = 0;
4707 }
aliguori87127162009-03-05 23:01:29 +00004708
Anthony Liguori7267c092011-08-20 22:09:37 -05004709 mon = g_malloc0(sizeof(*mon));
ths20d8a3e2007-02-18 17:04:49 +00004710
aliguori87127162009-03-05 23:01:29 +00004711 mon->chr = chr;
aliguori731b0362009-03-05 23:01:42 +00004712 mon->flags = flags;
aliguoricde76ee2009-03-05 23:01:51 +00004713 if (flags & MONITOR_USE_READLINE) {
4714 mon->rs = readline_init(mon, monitor_find_completion);
4715 monitor_read_command(mon, 0);
4716 }
aliguori87127162009-03-05 23:01:29 +00004717
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004718 if (monitor_ctrl_mode(mon)) {
Anthony Liguori7267c092011-08-20 22:09:37 -05004719 mon->mc = g_malloc0(sizeof(MonitorControl));
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004720 /* Control mode requires special handlers */
4721 qemu_chr_add_handlers(chr, monitor_can_read, monitor_control_read,
4722 monitor_control_event, mon);
Anthony Liguori15f31512011-08-15 11:17:35 -05004723 qemu_chr_fe_set_echo(chr, true);
Anthony Liguori26efaca2012-08-23 13:49:02 -05004724
4725 json_message_parser_init(&mon->mc->parser, handle_qmp_command);
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004726 } else {
4727 qemu_chr_add_handlers(chr, monitor_can_read, monitor_read,
4728 monitor_event, mon);
4729 }
aliguori87127162009-03-05 23:01:29 +00004730
Blue Swirl72cf2d42009-09-12 07:36:22 +00004731 QLIST_INSERT_HEAD(&mon_list, mon, entry);
Markus Armbruster8631b602010-02-18 11:41:55 +01004732 if (!default_mon || (flags & MONITOR_IS_DEFAULT))
4733 default_mon = mon;
Wayne Xia816f8922011-10-12 11:32:41 +08004734
4735 sortcmdlist();
bellard7e2515e2004-08-01 21:52:19 +00004736}
4737
aliguori376253e2009-03-05 23:01:23 +00004738static void bdrv_password_cb(Monitor *mon, const char *password, void *opaque)
bellard7e2515e2004-08-01 21:52:19 +00004739{
aliguoribb5fc202009-03-05 23:01:15 +00004740 BlockDriverState *bs = opaque;
4741 int ret = 0;
bellard7e2515e2004-08-01 21:52:19 +00004742
aliguoribb5fc202009-03-05 23:01:15 +00004743 if (bdrv_set_key(bs, password) != 0) {
aliguori376253e2009-03-05 23:01:23 +00004744 monitor_printf(mon, "invalid password\n");
aliguoribb5fc202009-03-05 23:01:15 +00004745 ret = -EPERM;
bellard7e2515e2004-08-01 21:52:19 +00004746 }
aliguori731b0362009-03-05 23:01:42 +00004747 if (mon->password_completion_cb)
4748 mon->password_completion_cb(mon->password_opaque, ret);
aliguoribb5fc202009-03-05 23:01:15 +00004749
aliguori731b0362009-03-05 23:01:42 +00004750 monitor_read_command(mon, 1);
bellard9dc39cb2004-03-14 21:38:27 +00004751}
aliguoric0f4ce72009-03-05 23:01:01 +00004752
Anthony Liguori7060b472011-09-02 12:34:50 -05004753ReadLineState *monitor_get_rs(Monitor *mon)
4754{
4755 return mon->rs;
4756}
4757
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02004758int monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
4759 BlockDriverCompletionFunc *completion_cb,
4760 void *opaque)
aliguoric0f4ce72009-03-05 23:01:01 +00004761{
aliguoricde76ee2009-03-05 23:01:51 +00004762 int err;
4763
aliguoribb5fc202009-03-05 23:01:15 +00004764 if (!bdrv_key_required(bs)) {
4765 if (completion_cb)
4766 completion_cb(opaque, 0);
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02004767 return 0;
aliguoribb5fc202009-03-05 23:01:15 +00004768 }
aliguoric0f4ce72009-03-05 23:01:01 +00004769
Luiz Capitulino94171e12009-12-07 21:37:00 +01004770 if (monitor_ctrl_mode(mon)) {
Luiz Capitulino903a8812011-12-13 17:18:30 -02004771 qerror_report(QERR_DEVICE_ENCRYPTED, bdrv_get_device_name(bs),
4772 bdrv_get_encrypted_filename(bs));
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02004773 return -1;
Luiz Capitulino94171e12009-12-07 21:37:00 +01004774 }
4775
aliguori376253e2009-03-05 23:01:23 +00004776 monitor_printf(mon, "%s (%s) is encrypted.\n", bdrv_get_device_name(bs),
4777 bdrv_get_encrypted_filename(bs));
aliguoribb5fc202009-03-05 23:01:15 +00004778
aliguori731b0362009-03-05 23:01:42 +00004779 mon->password_completion_cb = completion_cb;
4780 mon->password_opaque = opaque;
aliguoribb5fc202009-03-05 23:01:15 +00004781
aliguoricde76ee2009-03-05 23:01:51 +00004782 err = monitor_read_password(mon, bdrv_password_cb, bs);
4783
4784 if (err && completion_cb)
4785 completion_cb(opaque, err);
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02004786
4787 return err;
aliguoric0f4ce72009-03-05 23:01:01 +00004788}
Luiz Capitulinoe42e8182011-11-22 17:58:31 -02004789
4790int monitor_read_block_device_key(Monitor *mon, const char *device,
4791 BlockDriverCompletionFunc *completion_cb,
4792 void *opaque)
4793{
4794 BlockDriverState *bs;
4795
4796 bs = bdrv_find(device);
4797 if (!bs) {
4798 monitor_printf(mon, "Device not found %s\n", device);
4799 return -1;
4800 }
4801
4802 return monitor_read_bdrv_key_start(mon, bs, completion_cb, opaque);
4803}