blob: b13a363131a6332465b1f262e89dca008e2de0ed [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"
Paolo Bonzinia88790a2010-06-29 09:58:51 +020059#include "exec-all.h"
Prerna Saxena22890ab2010-06-24 17:04:53 +053060#ifdef CONFIG_SIMPLE_TRACE
61#include "trace.h"
62#endif
Gerd Hoffmann6f8c63f2010-10-11 18:03:51 +020063#include "ui/qemu-spice.h"
ths6a5bd302007-12-03 17:05:38 +000064
bellard9dc39cb2004-03-14 21:38:27 +000065//#define DEBUG
bellard81d09122004-07-14 17:21:37 +000066//#define DEBUG_COMPLETION
bellard9dc39cb2004-03-14 21:38:27 +000067
bellard9307c4c2004-04-04 12:57:25 +000068/*
69 * Supported types:
ths5fafdf22007-09-16 21:08:06 +000070 *
bellard9307c4c2004-04-04 12:57:25 +000071 * 'F' filename
bellard81d09122004-07-14 17:21:37 +000072 * 'B' block device name
bellard9307c4c2004-04-04 12:57:25 +000073 * 's' string (accept optional quote)
Markus Armbruster361127d2010-02-10 20:24:35 +010074 * 'O' option string of the form NAME=VALUE,...
75 * parsed according to QemuOptsList given by its name
76 * Example: 'device:O' uses qemu_device_opts.
77 * Restriction: only lists with empty desc are supported
78 * TODO lift the restriction
bellard92a31b12005-02-10 22:00:52 +000079 * 'i' 32 bit integer
80 * 'l' target long (32 or 64 bit)
Markus Armbruster9fec5432010-01-25 14:23:01 +010081 * 'M' just like 'l', except in user mode the value is
82 * multiplied by 2^20 (think Mebibyte)
Jes Sorensendbc0c672010-10-21 17:15:47 +020083 * 'o' octets (aka bytes)
84 * user mode accepts an optional T, t, G, g, M, m, K, k
85 * suffix, which multiplies the value by 2^40 for
86 * suffixes T and t, 2^30 for suffixes G and g, 2^20 for
87 * M and m, 2^10 for K and k
Markus Armbrusterfccfb11e2010-01-25 14:23:06 +010088 * 'T' double
89 * user mode accepts an optional ms, us, ns suffix,
90 * which divides the value by 1e3, 1e6, 1e9, respectively
bellard9307c4c2004-04-04 12:57:25 +000091 * '/' optional gdb-like print format (like "/10x")
92 *
Luiz Capitulinofb466602009-08-28 15:27:27 -030093 * '?' optional type (for all types, except '/')
94 * '.' other form of optional type (for 'i' and 'l')
Markus Armbruster942cd1f2010-03-26 09:07:09 +010095 * 'b' boolean
96 * user mode accepts "on" or "off"
Luiz Capitulinofb466602009-08-28 15:27:27 -030097 * '-' optional parameter (eg. '-f')
bellard9307c4c2004-04-04 12:57:25 +000098 *
99 */
100
Adam Litke940cc302010-01-25 12:18:44 -0600101typedef struct MonitorCompletionData MonitorCompletionData;
102struct MonitorCompletionData {
103 Monitor *mon;
104 void (*user_print)(Monitor *mon, const QObject *data);
105};
106
Anthony Liguoric227f092009-10-01 16:12:16 -0500107typedef struct mon_cmd_t {
bellard9dc39cb2004-03-14 21:38:27 +0000108 const char *name;
bellard9307c4c2004-04-04 12:57:25 +0000109 const char *args_type;
bellard9dc39cb2004-03-14 21:38:27 +0000110 const char *params;
111 const char *help;
Luiz Capitulinoa2876f52009-10-07 13:41:53 -0300112 void (*user_print)(Monitor *mon, const QObject *data);
Luiz Capitulino910df892009-10-07 13:41:51 -0300113 union {
114 void (*info)(Monitor *mon);
Luiz Capitulino13c74252009-10-07 13:41:55 -0300115 void (*info_new)(Monitor *mon, QObject **ret_data);
Adam Litke940cc302010-01-25 12:18:44 -0600116 int (*info_async)(Monitor *mon, MonitorCompletion *cb, void *opaque);
Luiz Capitulinoaf4ce882009-10-07 13:41:52 -0300117 void (*cmd)(Monitor *mon, const QDict *qdict);
Luiz Capitulino261394d2010-02-10 23:50:02 -0200118 int (*cmd_new)(Monitor *mon, const QDict *params, QObject **ret_data);
Adam Litke940cc302010-01-25 12:18:44 -0600119 int (*cmd_async)(Monitor *mon, const QDict *params,
120 MonitorCompletion *cb, void *opaque);
Luiz Capitulino910df892009-10-07 13:41:51 -0300121 } mhandler;
Jan Kiszka8ac470c2010-06-16 00:38:39 +0200122 int flags;
Anthony Liguoric227f092009-10-01 16:12:16 -0500123} mon_cmd_t;
bellard9dc39cb2004-03-14 21:38:27 +0000124
Mark McLoughlinf07918f2009-07-22 09:11:40 +0100125/* file descriptors passed via SCM_RIGHTS */
Anthony Liguoric227f092009-10-01 16:12:16 -0500126typedef struct mon_fd_t mon_fd_t;
127struct mon_fd_t {
Mark McLoughlinf07918f2009-07-22 09:11:40 +0100128 char *name;
129 int fd;
Anthony Liguoric227f092009-10-01 16:12:16 -0500130 QLIST_ENTRY(mon_fd_t) next;
Mark McLoughlinf07918f2009-07-22 09:11:40 +0100131};
132
Luiz Capitulino5fa737a2009-11-26 22:59:01 -0200133typedef struct MonitorControl {
134 QObject *id;
135 JSONMessageParser parser;
Luiz Capitulino4a7e1192010-02-04 18:10:05 -0200136 int command_mode;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -0200137} MonitorControl;
138
aliguori87127162009-03-05 23:01:29 +0000139struct Monitor {
140 CharDriverState *chr;
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +0200141 int mux_out;
142 int reset_seen;
aliguori731b0362009-03-05 23:01:42 +0000143 int flags;
144 int suspend_cnt;
145 uint8_t outbuf[1024];
146 int outbuf_index;
147 ReadLineState *rs;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -0200148 MonitorControl *mc;
aliguori731b0362009-03-05 23:01:42 +0000149 CPUState *mon_cpu;
150 BlockDriverCompletionFunc *password_completion_cb;
151 void *password_opaque;
Luiz Capitulino10e4f602010-02-10 23:50:06 -0200152#ifdef CONFIG_DEBUG_MONITOR
153 int print_calls_nr;
154#endif
Luiz Capitulino8204a912009-11-18 23:05:31 -0200155 QError *error;
Anthony Liguoric227f092009-10-01 16:12:16 -0500156 QLIST_HEAD(,mon_fd_t) fds;
Blue Swirl72cf2d42009-09-12 07:36:22 +0000157 QLIST_ENTRY(Monitor) entry;
aliguori87127162009-03-05 23:01:29 +0000158};
159
Luiz Capitulinob4475aa2010-02-10 23:50:03 -0200160#ifdef CONFIG_DEBUG_MONITOR
161#define MON_DEBUG(fmt, ...) do { \
162 fprintf(stderr, "Monitor: "); \
163 fprintf(stderr, fmt, ## __VA_ARGS__); } while (0)
Luiz Capitulino10e4f602010-02-10 23:50:06 -0200164
165static inline void mon_print_count_inc(Monitor *mon)
166{
167 mon->print_calls_nr++;
168}
169
170static inline void mon_print_count_init(Monitor *mon)
171{
172 mon->print_calls_nr = 0;
173}
174
175static inline int mon_print_count_get(const Monitor *mon)
176{
177 return mon->print_calls_nr;
178}
179
Luiz Capitulinob4475aa2010-02-10 23:50:03 -0200180#else /* !CONFIG_DEBUG_MONITOR */
181#define MON_DEBUG(fmt, ...) do { } while (0)
Luiz Capitulino10e4f602010-02-10 23:50:06 -0200182static inline void mon_print_count_inc(Monitor *mon) { }
183static inline void mon_print_count_init(Monitor *mon) { }
184static inline int mon_print_count_get(const Monitor *mon) { return 0; }
Luiz Capitulinob4475aa2010-02-10 23:50:03 -0200185#endif /* CONFIG_DEBUG_MONITOR */
186
Luiz Capitulino2dbc8db2010-05-26 16:13:09 -0300187/* QMP checker flags */
188#define QMP_ACCEPT_UNKNOWNS 1
189
Blue Swirl72cf2d42009-09-12 07:36:22 +0000190static QLIST_HEAD(mon_list, Monitor) mon_list;
bellard7e2515e2004-08-01 21:52:19 +0000191
Anthony Liguoric227f092009-10-01 16:12:16 -0500192static const mon_cmd_t mon_cmds[];
193static const mon_cmd_t info_cmds[];
bellard9dc39cb2004-03-14 21:38:27 +0000194
Luiz Capitulinof36b4af2010-09-15 17:17:45 -0300195static const mon_cmd_t qmp_cmds[];
Luiz Capitulino3e12a752010-09-15 17:20:33 -0300196static const mon_cmd_t qmp_query_cmds[];
Luiz Capitulinof36b4af2010-09-15 17:17:45 -0300197
Markus Armbruster8631b602010-02-18 11:41:55 +0100198Monitor *cur_mon;
199Monitor *default_mon;
aliguori376253e2009-03-05 23:01:23 +0000200
aliguori731b0362009-03-05 23:01:42 +0000201static void monitor_command_cb(Monitor *mon, const char *cmdline,
202 void *opaque);
aliguori83ab7952008-08-19 14:44:22 +0000203
Luiz Capitulino09069b12010-02-04 18:10:06 -0200204static inline int qmp_cmd_mode(const Monitor *mon)
205{
206 return (mon->mc ? mon->mc->command_mode : 0);
207}
208
Luiz Capitulino418173c2009-11-26 22:58:51 -0200209/* Return true if in control mode, false otherwise */
210static inline int monitor_ctrl_mode(const Monitor *mon)
211{
212 return (mon->flags & MONITOR_USE_CONTROL);
213}
214
Markus Armbruster6620d3c2010-02-11 17:05:43 +0100215/* Return non-zero iff we have a current monitor, and it is in QMP mode. */
216int monitor_cur_is_qmp(void)
217{
218 return cur_mon && monitor_ctrl_mode(cur_mon);
219}
220
aliguori731b0362009-03-05 23:01:42 +0000221static void monitor_read_command(Monitor *mon, int show_prompt)
222{
Luiz Capitulino183e6e52009-12-14 18:53:23 -0200223 if (!mon->rs)
224 return;
225
aliguori731b0362009-03-05 23:01:42 +0000226 readline_start(mon->rs, "(qemu) ", 0, monitor_command_cb, NULL);
227 if (show_prompt)
228 readline_show_prompt(mon->rs);
229}
bellard6a00d602005-11-21 23:25:50 +0000230
aliguoricde76ee2009-03-05 23:01:51 +0000231static int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
232 void *opaque)
aliguoribb5fc202009-03-05 23:01:15 +0000233{
Luiz Capitulino94171e12009-12-07 21:37:00 +0100234 if (monitor_ctrl_mode(mon)) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +0100235 qerror_report(QERR_MISSING_PARAMETER, "password");
Luiz Capitulino94171e12009-12-07 21:37:00 +0100236 return -EINVAL;
237 } else if (mon->rs) {
aliguoricde76ee2009-03-05 23:01:51 +0000238 readline_start(mon->rs, "Password: ", 1, readline_func, opaque);
239 /* prompt is printed on return from the command handler */
240 return 0;
241 } else {
242 monitor_printf(mon, "terminal does not support password prompting\n");
243 return -ENOTTY;
244 }
aliguoribb5fc202009-03-05 23:01:15 +0000245}
246
aliguori376253e2009-03-05 23:01:23 +0000247void monitor_flush(Monitor *mon)
bellard9dc39cb2004-03-14 21:38:27 +0000248{
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +0200249 if (mon && mon->outbuf_index != 0 && !mon->mux_out) {
aliguori731b0362009-03-05 23:01:42 +0000250 qemu_chr_write(mon->chr, mon->outbuf, mon->outbuf_index);
251 mon->outbuf_index = 0;
bellard7e2515e2004-08-01 21:52:19 +0000252 }
253}
254
255/* flush at every end of line or if the buffer is full */
aliguori376253e2009-03-05 23:01:23 +0000256static void monitor_puts(Monitor *mon, const char *str)
bellard7e2515e2004-08-01 21:52:19 +0000257{
ths60fe76f2007-12-16 03:02:09 +0000258 char c;
aliguori731b0362009-03-05 23:01:42 +0000259
bellard7e2515e2004-08-01 21:52:19 +0000260 for(;;) {
261 c = *str++;
262 if (c == '\0')
263 break;
bellard7ba12602006-07-14 20:26:42 +0000264 if (c == '\n')
aliguori731b0362009-03-05 23:01:42 +0000265 mon->outbuf[mon->outbuf_index++] = '\r';
266 mon->outbuf[mon->outbuf_index++] = c;
267 if (mon->outbuf_index >= (sizeof(mon->outbuf) - 1)
268 || c == '\n')
aliguori376253e2009-03-05 23:01:23 +0000269 monitor_flush(mon);
bellard7e2515e2004-08-01 21:52:19 +0000270 }
271}
272
aliguori376253e2009-03-05 23:01:23 +0000273void monitor_vprintf(Monitor *mon, const char *fmt, va_list ap)
bellard7e2515e2004-08-01 21:52:19 +0000274{
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200275 char buf[4096];
276
Luiz Capitulino2daa1192009-12-14 18:53:24 -0200277 if (!mon)
278 return;
279
Luiz Capitulino10e4f602010-02-10 23:50:06 -0200280 mon_print_count_inc(mon);
281
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200282 if (monitor_ctrl_mode(mon)) {
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200283 return;
Luiz Capitulino4a29a852009-11-26 22:59:05 -0200284 }
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200285
286 vsnprintf(buf, sizeof(buf), fmt, ap);
287 monitor_puts(mon, buf);
bellard7e2515e2004-08-01 21:52:19 +0000288}
289
aliguori376253e2009-03-05 23:01:23 +0000290void monitor_printf(Monitor *mon, const char *fmt, ...)
bellard7e2515e2004-08-01 21:52:19 +0000291{
292 va_list ap;
293 va_start(ap, fmt);
aliguori376253e2009-03-05 23:01:23 +0000294 monitor_vprintf(mon, fmt, ap);
bellard7e2515e2004-08-01 21:52:19 +0000295 va_end(ap);
bellard9dc39cb2004-03-14 21:38:27 +0000296}
297
aliguori376253e2009-03-05 23:01:23 +0000298void monitor_print_filename(Monitor *mon, const char *filename)
thsfef30742006-12-22 14:11:32 +0000299{
300 int i;
301
302 for (i = 0; filename[i]; i++) {
aliguori28a76be2009-03-06 20:27:40 +0000303 switch (filename[i]) {
304 case ' ':
305 case '"':
306 case '\\':
307 monitor_printf(mon, "\\%c", filename[i]);
308 break;
309 case '\t':
310 monitor_printf(mon, "\\t");
311 break;
312 case '\r':
313 monitor_printf(mon, "\\r");
314 break;
315 case '\n':
316 monitor_printf(mon, "\\n");
317 break;
318 default:
319 monitor_printf(mon, "%c", filename[i]);
320 break;
321 }
thsfef30742006-12-22 14:11:32 +0000322 }
323}
324
Stefan Weil8b7968f2010-09-23 21:28:05 +0200325static int GCC_FMT_ATTR(2, 3) monitor_fprintf(FILE *stream,
326 const char *fmt, ...)
bellard7fe48482004-10-09 18:08:01 +0000327{
328 va_list ap;
329 va_start(ap, fmt);
aliguori376253e2009-03-05 23:01:23 +0000330 monitor_vprintf((Monitor *)stream, fmt, ap);
bellard7fe48482004-10-09 18:08:01 +0000331 va_end(ap);
332 return 0;
333}
334
Luiz Capitulino13c74252009-10-07 13:41:55 -0300335static void monitor_user_noop(Monitor *mon, const QObject *data) { }
336
Luiz Capitulino9e807212010-09-16 10:58:59 -0300337static inline int handler_is_qobject(const mon_cmd_t *cmd)
Luiz Capitulino13917be2009-10-07 13:41:54 -0300338{
339 return cmd->user_print != NULL;
340}
341
Luiz Capitulino4903de02010-09-16 11:01:32 -0300342static inline bool handler_is_async(const mon_cmd_t *cmd)
Adam Litke940cc302010-01-25 12:18:44 -0600343{
Jan Kiszka8ac470c2010-06-16 00:38:39 +0200344 return cmd->flags & MONITOR_CMD_ASYNC;
Adam Litke940cc302010-01-25 12:18:44 -0600345}
346
Luiz Capitulino8204a912009-11-18 23:05:31 -0200347static inline int monitor_has_error(const Monitor *mon)
348{
349 return mon->error != NULL;
350}
351
Luiz Capitulino9b57c022009-11-26 22:58:58 -0200352static void monitor_json_emitter(Monitor *mon, const QObject *data)
353{
354 QString *json;
355
Daniel P. Berrange39eaab92010-06-07 15:42:31 +0100356 if (mon->flags & MONITOR_USE_PRETTY)
357 json = qobject_to_json_pretty(data);
358 else
359 json = qobject_to_json(data);
Luiz Capitulino9b57c022009-11-26 22:58:58 -0200360 assert(json != NULL);
361
Luiz Capitulinob8b08262010-02-10 23:50:04 -0200362 qstring_append_chr(json, '\n');
363 monitor_puts(mon, qstring_get_str(json));
Luiz Capitulino4a29a852009-11-26 22:59:05 -0200364
Luiz Capitulino9b57c022009-11-26 22:58:58 -0200365 QDECREF(json);
366}
367
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200368static void monitor_protocol_emitter(Monitor *mon, QObject *data)
369{
370 QDict *qmp;
371
372 qmp = qdict_new();
373
374 if (!monitor_has_error(mon)) {
375 /* success response */
376 if (data) {
377 qobject_incref(data);
378 qdict_put_obj(qmp, "return", data);
379 } else {
Luiz Capitulino0abc6572009-12-18 13:25:00 -0200380 /* return an empty QDict by default */
381 qdict_put(qmp, "return", qdict_new());
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200382 }
383 } else {
384 /* error response */
Markus Armbruster77e595e2009-12-07 21:37:16 +0100385 qdict_put(mon->error->error, "desc", qerror_human(mon->error));
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200386 qdict_put(qmp, "error", mon->error->error);
387 QINCREF(mon->error->error);
388 QDECREF(mon->error);
389 mon->error = NULL;
390 }
391
Luiz Capitulino5fa737a2009-11-26 22:59:01 -0200392 if (mon->mc->id) {
393 qdict_put_obj(qmp, "id", mon->mc->id);
394 mon->mc->id = NULL;
395 }
396
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200397 monitor_json_emitter(mon, QOBJECT(qmp));
398 QDECREF(qmp);
399}
400
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200401static void timestamp_put(QDict *qdict)
402{
403 int err;
404 QObject *obj;
Blue Swirld08d6f02009-12-04 18:06:39 +0000405 qemu_timeval tv;
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200406
Blue Swirld08d6f02009-12-04 18:06:39 +0000407 err = qemu_gettimeofday(&tv);
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200408 if (err < 0)
409 return;
410
411 obj = qobject_from_jsonf("{ 'seconds': %" PRId64 ", "
412 "'microseconds': %" PRId64 " }",
413 (int64_t) tv.tv_sec, (int64_t) tv.tv_usec);
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200414 qdict_put_obj(qdict, "timestamp", obj);
415}
416
417/**
418 * monitor_protocol_event(): Generate a Monitor event
419 *
420 * Event-specific data can be emitted through the (optional) 'data' parameter.
421 */
422void monitor_protocol_event(MonitorEvent event, QObject *data)
423{
424 QDict *qmp;
425 const char *event_name;
Adam Litkef039a562010-01-15 08:34:02 -0600426 Monitor *mon;
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200427
Blue Swirl242cd002009-12-04 18:05:45 +0000428 assert(event < QEVENT_MAX);
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200429
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200430 switch (event) {
Blue Swirl242cd002009-12-04 18:05:45 +0000431 case QEVENT_SHUTDOWN:
Luiz Capitulinob1a15e72009-11-26 22:59:04 -0200432 event_name = "SHUTDOWN";
433 break;
Blue Swirl242cd002009-12-04 18:05:45 +0000434 case QEVENT_RESET:
Luiz Capitulinob1a15e72009-11-26 22:59:04 -0200435 event_name = "RESET";
436 break;
Blue Swirl242cd002009-12-04 18:05:45 +0000437 case QEVENT_POWERDOWN:
Luiz Capitulinob1a15e72009-11-26 22:59:04 -0200438 event_name = "POWERDOWN";
439 break;
Blue Swirl242cd002009-12-04 18:05:45 +0000440 case QEVENT_STOP:
Luiz Capitulinob1a15e72009-11-26 22:59:04 -0200441 event_name = "STOP";
442 break;
Luiz Capitulino6ed2c482010-04-27 20:35:59 -0300443 case QEVENT_RESUME:
444 event_name = "RESUME";
445 break;
Luiz Capitulino586153d2010-01-14 14:50:57 -0200446 case QEVENT_VNC_CONNECTED:
447 event_name = "VNC_CONNECTED";
448 break;
Luiz Capitulino0d2ed462010-01-14 14:50:59 -0200449 case QEVENT_VNC_INITIALIZED:
450 event_name = "VNC_INITIALIZED";
451 break;
Luiz Capitulino0d72f3d2010-01-14 14:50:58 -0200452 case QEVENT_VNC_DISCONNECTED:
453 event_name = "VNC_DISCONNECTED";
454 break;
Luiz Capitulinoaa1db6e2010-02-03 12:41:00 -0200455 case QEVENT_BLOCK_IO_ERROR:
456 event_name = "BLOCK_IO_ERROR";
457 break;
Luiz Capitulino80cd3472010-02-25 12:11:44 -0300458 case QEVENT_RTC_CHANGE:
459 event_name = "RTC_CHANGE";
460 break;
Luiz Capitulino9eedeb32010-02-25 12:13:04 -0300461 case QEVENT_WATCHDOG:
462 event_name = "WATCHDOG";
463 break;
Gerd Hoffmann6f8c63f2010-10-11 18:03:51 +0200464 case QEVENT_SPICE_CONNECTED:
465 event_name = "SPICE_CONNECTED";
466 break;
467 case QEVENT_SPICE_INITIALIZED:
468 event_name = "SPICE_INITIALIZED";
469 break;
470 case QEVENT_SPICE_DISCONNECTED:
471 event_name = "SPICE_DISCONNECTED";
472 break;
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200473 default:
474 abort();
475 break;
476 }
477
478 qmp = qdict_new();
479 timestamp_put(qmp);
480 qdict_put(qmp, "event", qstring_from_str(event_name));
Luiz Capitulino3d72f9a2010-01-08 16:45:53 -0200481 if (data) {
482 qobject_incref(data);
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200483 qdict_put_obj(qmp, "data", data);
Luiz Capitulino3d72f9a2010-01-08 16:45:53 -0200484 }
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200485
Adam Litkef039a562010-01-15 08:34:02 -0600486 QLIST_FOREACH(mon, &mon_list, entry) {
Luiz Capitulino09069b12010-02-04 18:10:06 -0200487 if (monitor_ctrl_mode(mon) && qmp_cmd_mode(mon)) {
Luiz Capitulino23fabed2010-01-20 10:37:59 -0200488 monitor_json_emitter(mon, QOBJECT(qmp));
489 }
Adam Litkef039a562010-01-15 08:34:02 -0600490 }
Luiz Capitulino0d1ea872009-11-26 22:59:03 -0200491 QDECREF(qmp);
492}
493
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -0200494static int do_qmp_capabilities(Monitor *mon, const QDict *params,
495 QObject **ret_data)
Luiz Capitulino4a7e1192010-02-04 18:10:05 -0200496{
497 /* Will setup QMP capabilities in the future */
498 if (monitor_ctrl_mode(mon)) {
499 mon->mc->command_mode = 1;
500 }
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -0200501
502 return 0;
Luiz Capitulino4a7e1192010-02-04 18:10:05 -0200503}
504
Luiz Capitulino0268d972010-10-22 10:08:02 -0200505static int mon_set_cpu(int cpu_index);
506static void handle_user_command(Monitor *mon, const char *cmdline);
507
508static int do_hmp_passthrough(Monitor *mon, const QDict *params,
509 QObject **ret_data)
510{
511 int ret = 0;
512 Monitor *old_mon, hmp;
513 CharDriverState mchar;
514
515 memset(&hmp, 0, sizeof(hmp));
516 qemu_chr_init_mem(&mchar);
517 hmp.chr = &mchar;
518
519 old_mon = cur_mon;
520 cur_mon = &hmp;
521
522 if (qdict_haskey(params, "cpu-index")) {
523 ret = mon_set_cpu(qdict_get_int(params, "cpu-index"));
524 if (ret < 0) {
525 cur_mon = old_mon;
526 qerror_report(QERR_INVALID_PARAMETER_VALUE, "cpu-index", "a CPU number");
527 goto out;
528 }
529 }
530
531 handle_user_command(&hmp, qdict_get_str(params, "command-line"));
532 cur_mon = old_mon;
533
534 if (qemu_chr_mem_osize(hmp.chr) > 0) {
535 *ret_data = QOBJECT(qemu_chr_mem_to_qs(hmp.chr));
536 }
537
538out:
539 qemu_chr_close_mem(hmp.chr);
540 return ret;
541}
542
bellard9dc39cb2004-03-14 21:38:27 +0000543static int compare_cmd(const char *name, const char *list)
544{
545 const char *p, *pstart;
546 int len;
547 len = strlen(name);
548 p = list;
549 for(;;) {
550 pstart = p;
551 p = strchr(p, '|');
552 if (!p)
553 p = pstart + strlen(pstart);
554 if ((p - pstart) == len && !memcmp(pstart, name, len))
555 return 1;
556 if (*p == '\0')
557 break;
558 p++;
559 }
560 return 0;
561}
562
Anthony Liguoric227f092009-10-01 16:12:16 -0500563static void help_cmd_dump(Monitor *mon, const mon_cmd_t *cmds,
aliguori376253e2009-03-05 23:01:23 +0000564 const char *prefix, const char *name)
bellard9dc39cb2004-03-14 21:38:27 +0000565{
Anthony Liguoric227f092009-10-01 16:12:16 -0500566 const mon_cmd_t *cmd;
bellard9dc39cb2004-03-14 21:38:27 +0000567
568 for(cmd = cmds; cmd->name != NULL; cmd++) {
569 if (!name || !strcmp(name, cmd->name))
aliguori376253e2009-03-05 23:01:23 +0000570 monitor_printf(mon, "%s%s %s -- %s\n", prefix, cmd->name,
571 cmd->params, cmd->help);
bellard9dc39cb2004-03-14 21:38:27 +0000572 }
573}
574
aliguori376253e2009-03-05 23:01:23 +0000575static void help_cmd(Monitor *mon, const char *name)
bellard9dc39cb2004-03-14 21:38:27 +0000576{
577 if (name && !strcmp(name, "info")) {
aliguori376253e2009-03-05 23:01:23 +0000578 help_cmd_dump(mon, info_cmds, "info ", NULL);
bellard9dc39cb2004-03-14 21:38:27 +0000579 } else {
aliguori376253e2009-03-05 23:01:23 +0000580 help_cmd_dump(mon, mon_cmds, "", name);
bellardf193c792004-03-21 17:06:25 +0000581 if (name && !strcmp(name, "log")) {
blueswir18662d652008-10-02 18:32:44 +0000582 const CPULogItem *item;
aliguori376253e2009-03-05 23:01:23 +0000583 monitor_printf(mon, "Log items (comma separated):\n");
584 monitor_printf(mon, "%-10s %s\n", "none", "remove all logs");
bellardf193c792004-03-21 17:06:25 +0000585 for(item = cpu_log_items; item->mask != 0; item++) {
aliguori376253e2009-03-05 23:01:23 +0000586 monitor_printf(mon, "%-10s %s\n", item->name, item->help);
bellardf193c792004-03-21 17:06:25 +0000587 }
588 }
bellard9dc39cb2004-03-14 21:38:27 +0000589 }
590}
591
Luiz Capitulinod54908a2009-08-28 15:27:13 -0300592static void do_help_cmd(Monitor *mon, const QDict *qdict)
Luiz Capitulino38183182009-08-28 15:27:08 -0300593{
Luiz Capitulinod54908a2009-08-28 15:27:13 -0300594 help_cmd(mon, qdict_get_try_str(qdict, "name"));
Luiz Capitulino38183182009-08-28 15:27:08 -0300595}
596
Prerna Saxena22890ab2010-06-24 17:04:53 +0530597#ifdef CONFIG_SIMPLE_TRACE
598static void do_change_trace_event_state(Monitor *mon, const QDict *qdict)
599{
600 const char *tp_name = qdict_get_str(qdict, "name");
601 bool new_state = qdict_get_bool(qdict, "option");
Blue Swirlf871d682010-10-13 19:14:29 +0000602 int ret = st_change_trace_event_state(tp_name, new_state);
603
604 if (!ret) {
605 monitor_printf(mon, "unknown event name \"%s\"\n", tp_name);
606 }
Prerna Saxena22890ab2010-06-24 17:04:53 +0530607}
Stefan Hajnoczic5ceb522010-07-13 09:26:33 +0100608
609static void do_trace_file(Monitor *mon, const QDict *qdict)
610{
611 const char *op = qdict_get_try_str(qdict, "op");
612 const char *arg = qdict_get_try_str(qdict, "arg");
613
614 if (!op) {
615 st_print_trace_file_status((FILE *)mon, &monitor_fprintf);
616 } else if (!strcmp(op, "on")) {
617 st_set_trace_file_enabled(true);
618 } else if (!strcmp(op, "off")) {
619 st_set_trace_file_enabled(false);
620 } else if (!strcmp(op, "flush")) {
621 st_flush_trace_buffer();
622 } else if (!strcmp(op, "set")) {
623 if (arg) {
624 st_set_trace_file(arg);
625 }
626 } else {
627 monitor_printf(mon, "unexpected argument \"%s\"\n", op);
628 help_cmd(mon, "trace-file");
629 }
630}
Prerna Saxena22890ab2010-06-24 17:04:53 +0530631#endif
632
Adam Litke940cc302010-01-25 12:18:44 -0600633static void user_monitor_complete(void *opaque, QObject *ret_data)
634{
635 MonitorCompletionData *data = (MonitorCompletionData *)opaque;
636
637 if (ret_data) {
638 data->user_print(data->mon, ret_data);
639 }
640 monitor_resume(data->mon);
641 qemu_free(data);
642}
643
644static void qmp_monitor_complete(void *opaque, QObject *ret_data)
645{
646 monitor_protocol_emitter(opaque, ret_data);
647}
648
Luiz Capitulino5af7bba2010-06-22 19:10:46 -0300649static int qmp_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,
650 const QDict *params)
Adam Litke940cc302010-01-25 12:18:44 -0600651{
Luiz Capitulino5af7bba2010-06-22 19:10:46 -0300652 return cmd->mhandler.cmd_async(mon, params, qmp_monitor_complete, mon);
Adam Litke940cc302010-01-25 12:18:44 -0600653}
654
655static void qmp_async_info_handler(Monitor *mon, const mon_cmd_t *cmd)
656{
657 cmd->mhandler.info_async(mon, qmp_monitor_complete, mon);
658}
659
660static void user_async_cmd_handler(Monitor *mon, const mon_cmd_t *cmd,
661 const QDict *params)
662{
663 int ret;
664
665 MonitorCompletionData *cb_data = qemu_malloc(sizeof(*cb_data));
666 cb_data->mon = mon;
667 cb_data->user_print = cmd->user_print;
668 monitor_suspend(mon);
669 ret = cmd->mhandler.cmd_async(mon, params,
670 user_monitor_complete, cb_data);
671 if (ret < 0) {
672 monitor_resume(mon);
673 qemu_free(cb_data);
674 }
675}
676
677static void user_async_info_handler(Monitor *mon, const mon_cmd_t *cmd)
678{
679 int ret;
680
681 MonitorCompletionData *cb_data = qemu_malloc(sizeof(*cb_data));
682 cb_data->mon = mon;
683 cb_data->user_print = cmd->user_print;
684 monitor_suspend(mon);
685 ret = cmd->mhandler.info_async(mon, user_monitor_complete, cb_data);
686 if (ret < 0) {
687 monitor_resume(mon);
688 qemu_free(cb_data);
689 }
690}
691
Luiz Capitulino1162daa2010-09-13 12:15:26 -0300692static void do_info(Monitor *mon, const QDict *qdict)
bellard9dc39cb2004-03-14 21:38:27 +0000693{
Anthony Liguoric227f092009-10-01 16:12:16 -0500694 const mon_cmd_t *cmd;
Luiz Capitulinod54908a2009-08-28 15:27:13 -0300695 const char *item = qdict_get_try_str(qdict, "item");
bellard9dc39cb2004-03-14 21:38:27 +0000696
Luiz Capitulino956f1a02009-11-26 22:59:00 -0200697 if (!item) {
bellard9dc39cb2004-03-14 21:38:27 +0000698 goto help;
Luiz Capitulino956f1a02009-11-26 22:59:00 -0200699 }
Luiz Capitulino13c74252009-10-07 13:41:55 -0300700
701 for (cmd = info_cmds; cmd->name != NULL; cmd++) {
ths5fafdf22007-09-16 21:08:06 +0000702 if (compare_cmd(item, cmd->name))
Luiz Capitulino13c74252009-10-07 13:41:55 -0300703 break;
bellard9dc39cb2004-03-14 21:38:27 +0000704 }
Luiz Capitulino13c74252009-10-07 13:41:55 -0300705
Luiz Capitulino956f1a02009-11-26 22:59:00 -0200706 if (cmd->name == NULL) {
Luiz Capitulino13c74252009-10-07 13:41:55 -0300707 goto help;
Luiz Capitulino956f1a02009-11-26 22:59:00 -0200708 }
Luiz Capitulino13c74252009-10-07 13:41:55 -0300709
Luiz Capitulino4903de02010-09-16 11:01:32 -0300710 if (handler_is_async(cmd)) {
Luiz Capitulino1dcbd6f2010-09-10 17:00:16 -0300711 user_async_info_handler(mon, cmd);
Luiz Capitulino9e807212010-09-16 10:58:59 -0300712 } else if (handler_is_qobject(cmd)) {
Luiz Capitulino1dcbd6f2010-09-10 17:00:16 -0300713 QObject *info_data = NULL;
Jan Kiszkaa6c4d362010-06-28 18:27:47 +0200714
Luiz Capitulino1dcbd6f2010-09-10 17:00:16 -0300715 cmd->mhandler.info_new(mon, &info_data);
716 if (info_data) {
717 cmd->user_print(mon, info_data);
718 qobject_decref(info_data);
Luiz Capitulino25b422e2009-11-26 22:58:59 -0200719 }
Luiz Capitulino13c74252009-10-07 13:41:55 -0300720 } else {
Luiz Capitulino1dcbd6f2010-09-10 17:00:16 -0300721 cmd->mhandler.info(mon);
Luiz Capitulino13c74252009-10-07 13:41:55 -0300722 }
723
Luiz Capitulino1162daa2010-09-13 12:15:26 -0300724 return;
Luiz Capitulino13c74252009-10-07 13:41:55 -0300725
726help:
727 help_cmd(mon, "info");
bellard9dc39cb2004-03-14 21:38:27 +0000728}
729
Luiz Capitulino45e914c2009-12-10 17:15:58 -0200730static void do_info_version_print(Monitor *mon, const QObject *data)
731{
732 QDict *qdict;
Miguel Di Ciurcio Filho0ec02912010-08-20 16:42:30 -0300733 QDict *qemu;
Luiz Capitulino45e914c2009-12-10 17:15:58 -0200734
735 qdict = qobject_to_qdict(data);
Miguel Di Ciurcio Filho0ec02912010-08-20 16:42:30 -0300736 qemu = qdict_get_qdict(qdict, "qemu");
Luiz Capitulino45e914c2009-12-10 17:15:58 -0200737
Miguel Di Ciurcio Filho0ec02912010-08-20 16:42:30 -0300738 monitor_printf(mon, "%" PRId64 ".%" PRId64 ".%" PRId64 "%s\n",
739 qdict_get_int(qemu, "major"),
740 qdict_get_int(qemu, "minor"),
741 qdict_get_int(qemu, "micro"),
742 qdict_get_str(qdict, "package"));
Luiz Capitulino45e914c2009-12-10 17:15:58 -0200743}
744
Luiz Capitulinoab2d3182009-10-07 13:42:02 -0300745static void do_info_version(Monitor *mon, QObject **ret_data)
bellard9bc9d1c2004-10-10 15:15:51 +0000746{
Miguel Di Ciurcio Filho0ec02912010-08-20 16:42:30 -0300747 const char *version = QEMU_VERSION;
748 int major = 0, minor = 0, micro = 0;
749 char *tmp;
750
751 major = strtol(version, &tmp, 10);
752 tmp++;
753 minor = strtol(tmp, &tmp, 10);
754 tmp++;
755 micro = strtol(tmp, &tmp, 10);
756
757 *ret_data = qobject_from_jsonf("{ 'qemu': { 'major': %d, 'minor': %d, \
758 'micro': %d }, 'package': %s }", major, minor, micro, QEMU_PKGVERSION);
bellard9bc9d1c2004-10-10 15:15:51 +0000759}
760
Luiz Capitulinoe05486c2009-12-10 17:16:01 -0200761static void do_info_name_print(Monitor *mon, const QObject *data)
thsc35734b2007-03-19 15:17:08 +0000762{
Luiz Capitulinoe05486c2009-12-10 17:16:01 -0200763 QDict *qdict;
764
765 qdict = qobject_to_qdict(data);
766 if (qdict_size(qdict) == 0) {
767 return;
768 }
769
770 monitor_printf(mon, "%s\n", qdict_get_str(qdict, "name"));
771}
772
Luiz Capitulinoe05486c2009-12-10 17:16:01 -0200773static void do_info_name(Monitor *mon, QObject **ret_data)
774{
775 *ret_data = qemu_name ? qobject_from_jsonf("{'name': %s }", qemu_name) :
776 qobject_from_jsonf("{}");
thsc35734b2007-03-19 15:17:08 +0000777}
778
Luiz Capitulino1a728672009-12-10 17:15:56 -0200779static QObject *get_cmd_dict(const char *name)
780{
781 const char *p;
782
783 /* Remove '|' from some commands */
784 p = strchr(name, '|');
785 if (p) {
786 p++;
787 } else {
788 p = name;
789 }
790
791 return qobject_from_jsonf("{ 'name': %s }", p);
792}
793
Luiz Capitulinoe3bba9d2009-11-26 22:58:56 -0200794static void do_info_commands(Monitor *mon, QObject **ret_data)
795{
796 QList *cmd_list;
797 const mon_cmd_t *cmd;
798
799 cmd_list = qlist_new();
800
Luiz Capitulinof36b4af2010-09-15 17:17:45 -0300801 for (cmd = qmp_cmds; cmd->name != NULL; cmd++) {
Luiz Capitulino2e061a72010-09-16 10:36:54 -0300802 qlist_append_obj(cmd_list, get_cmd_dict(cmd->name));
Luiz Capitulinoe3bba9d2009-11-26 22:58:56 -0200803 }
804
Luiz Capitulino3e12a752010-09-15 17:20:33 -0300805 for (cmd = qmp_query_cmds; cmd->name != NULL; cmd++) {
Luiz Capitulino2e061a72010-09-16 10:36:54 -0300806 char buf[128];
807 snprintf(buf, sizeof(buf), "query-%s", cmd->name);
808 qlist_append_obj(cmd_list, get_cmd_dict(buf));
Luiz Capitulinoe3bba9d2009-11-26 22:58:56 -0200809 }
810
811 *ret_data = QOBJECT(cmd_list);
812}
813
Luiz Capitulino9603ceb2009-12-10 17:16:03 -0200814static void do_info_uuid_print(Monitor *mon, const QObject *data)
blueswir1f1f23ad2008-09-18 18:30:20 +0000815{
Luiz Capitulino9603ceb2009-12-10 17:16:03 -0200816 monitor_printf(mon, "%s\n", qdict_get_str(qobject_to_qdict(data), "UUID"));
817}
818
Luiz Capitulino9603ceb2009-12-10 17:16:03 -0200819static void do_info_uuid(Monitor *mon, QObject **ret_data)
820{
821 char uuid[64];
822
823 snprintf(uuid, sizeof(uuid), UUID_FMT, qemu_uuid[0], qemu_uuid[1],
aliguori376253e2009-03-05 23:01:23 +0000824 qemu_uuid[2], qemu_uuid[3], qemu_uuid[4], qemu_uuid[5],
825 qemu_uuid[6], qemu_uuid[7], qemu_uuid[8], qemu_uuid[9],
826 qemu_uuid[10], qemu_uuid[11], qemu_uuid[12], qemu_uuid[13],
827 qemu_uuid[14], qemu_uuid[15]);
Luiz Capitulino9603ceb2009-12-10 17:16:03 -0200828 *ret_data = qobject_from_jsonf("{ 'UUID': %s }", uuid);
thsa36e69d2007-12-02 05:18:19 +0000829}
830
bellard6a00d602005-11-21 23:25:50 +0000831/* get the current CPU defined by the user */
pbrook9596ebb2007-11-18 01:44:38 +0000832static int mon_set_cpu(int cpu_index)
bellard6a00d602005-11-21 23:25:50 +0000833{
834 CPUState *env;
835
836 for(env = first_cpu; env != NULL; env = env->next_cpu) {
837 if (env->cpu_index == cpu_index) {
aliguori731b0362009-03-05 23:01:42 +0000838 cur_mon->mon_cpu = env;
bellard6a00d602005-11-21 23:25:50 +0000839 return 0;
840 }
841 }
842 return -1;
843}
844
pbrook9596ebb2007-11-18 01:44:38 +0000845static CPUState *mon_get_cpu(void)
bellard6a00d602005-11-21 23:25:50 +0000846{
aliguori731b0362009-03-05 23:01:42 +0000847 if (!cur_mon->mon_cpu) {
bellard6a00d602005-11-21 23:25:50 +0000848 mon_set_cpu(0);
849 }
Avi Kivity4c0960c2009-08-17 23:19:53 +0300850 cpu_synchronize_state(cur_mon->mon_cpu);
aliguori731b0362009-03-05 23:01:42 +0000851 return cur_mon->mon_cpu;
bellard6a00d602005-11-21 23:25:50 +0000852}
853
aliguori376253e2009-03-05 23:01:23 +0000854static void do_info_registers(Monitor *mon)
bellard9307c4c2004-04-04 12:57:25 +0000855{
bellard6a00d602005-11-21 23:25:50 +0000856 CPUState *env;
857 env = mon_get_cpu();
bellard9307c4c2004-04-04 12:57:25 +0000858#ifdef TARGET_I386
aliguori376253e2009-03-05 23:01:23 +0000859 cpu_dump_state(env, (FILE *)mon, monitor_fprintf,
bellardd24b15a2005-07-03 21:28:00 +0000860 X86_DUMP_FPU);
bellard9307c4c2004-04-04 12:57:25 +0000861#else
aliguori376253e2009-03-05 23:01:23 +0000862 cpu_dump_state(env, (FILE *)mon, monitor_fprintf,
bellard7fe48482004-10-09 18:08:01 +0000863 0);
bellard9307c4c2004-04-04 12:57:25 +0000864#endif
865}
866
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300867static void print_cpu_iter(QObject *obj, void *opaque)
868{
869 QDict *cpu;
870 int active = ' ';
871 Monitor *mon = opaque;
872
873 assert(qobject_type(obj) == QTYPE_QDICT);
874 cpu = qobject_to_qdict(obj);
875
Luiz Capitulino55483ad2009-12-10 17:15:57 -0200876 if (qdict_get_bool(cpu, "current")) {
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300877 active = '*';
Luiz Capitulino55483ad2009-12-10 17:15:57 -0200878 }
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300879
880 monitor_printf(mon, "%c CPU #%d: ", active, (int)qdict_get_int(cpu, "CPU"));
881
882#if defined(TARGET_I386)
883 monitor_printf(mon, "pc=0x" TARGET_FMT_lx,
884 (target_ulong) qdict_get_int(cpu, "pc"));
885#elif defined(TARGET_PPC)
886 monitor_printf(mon, "nip=0x" TARGET_FMT_lx,
887 (target_long) qdict_get_int(cpu, "nip"));
888#elif defined(TARGET_SPARC)
889 monitor_printf(mon, "pc=0x " TARGET_FMT_lx,
890 (target_long) qdict_get_int(cpu, "pc"));
891 monitor_printf(mon, "npc=0x" TARGET_FMT_lx,
892 (target_long) qdict_get_int(cpu, "npc"));
893#elif defined(TARGET_MIPS)
894 monitor_printf(mon, "PC=0x" TARGET_FMT_lx,
895 (target_long) qdict_get_int(cpu, "PC"));
896#endif
897
Luiz Capitulino55483ad2009-12-10 17:15:57 -0200898 if (qdict_get_bool(cpu, "halted")) {
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300899 monitor_printf(mon, " (halted)");
Luiz Capitulino55483ad2009-12-10 17:15:57 -0200900 }
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300901
902 monitor_printf(mon, "\n");
903}
904
905static void monitor_print_cpus(Monitor *mon, const QObject *data)
906{
907 QList *cpu_list;
908
909 assert(qobject_type(data) == QTYPE_QLIST);
910 cpu_list = qobject_to_qlist(data);
911 qlist_iter(cpu_list, print_cpu_iter, mon);
912}
913
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300914static void do_info_cpus(Monitor *mon, QObject **ret_data)
bellard6a00d602005-11-21 23:25:50 +0000915{
916 CPUState *env;
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300917 QList *cpu_list;
918
919 cpu_list = qlist_new();
bellard6a00d602005-11-21 23:25:50 +0000920
921 /* just to set the default cpu if not already done */
922 mon_get_cpu();
923
924 for(env = first_cpu; env != NULL; env = env->next_cpu) {
Luiz Capitulino55483ad2009-12-10 17:15:57 -0200925 QDict *cpu;
926 QObject *obj;
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300927
Avi Kivity4c0960c2009-08-17 23:19:53 +0300928 cpu_synchronize_state(env);
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300929
Luiz Capitulino55483ad2009-12-10 17:15:57 -0200930 obj = qobject_from_jsonf("{ 'CPU': %d, 'current': %i, 'halted': %i }",
931 env->cpu_index, env == mon->mon_cpu,
932 env->halted);
Luiz Capitulino55483ad2009-12-10 17:15:57 -0200933
934 cpu = qobject_to_qdict(obj);
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300935
bellard6a00d602005-11-21 23:25:50 +0000936#if defined(TARGET_I386)
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300937 qdict_put(cpu, "pc", qint_from_int(env->eip + env->segs[R_CS].base));
bellarde80e1cc2005-11-23 22:05:28 +0000938#elif defined(TARGET_PPC)
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300939 qdict_put(cpu, "nip", qint_from_int(env->nip));
bellardba3c64f2005-12-05 20:31:52 +0000940#elif defined(TARGET_SPARC)
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300941 qdict_put(cpu, "pc", qint_from_int(env->pc));
942 qdict_put(cpu, "npc", qint_from_int(env->npc));
thsead93602007-09-06 00:18:15 +0000943#elif defined(TARGET_MIPS)
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300944 qdict_put(cpu, "PC", qint_from_int(env->active_tc.PC));
bellardce5232c2008-05-28 17:14:10 +0000945#endif
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300946
947 qlist_append(cpu_list, cpu);
bellard6a00d602005-11-21 23:25:50 +0000948 }
Luiz Capitulino8f3cec02009-10-07 13:42:04 -0300949
950 *ret_data = QOBJECT(cpu_list);
bellard6a00d602005-11-21 23:25:50 +0000951}
952
Luiz Capitulino584cbdb2010-02-10 23:49:51 -0200953static int do_cpu_set(Monitor *mon, const QDict *qdict, QObject **ret_data)
bellard6a00d602005-11-21 23:25:50 +0000954{
Luiz Capitulinod54908a2009-08-28 15:27:13 -0300955 int index = qdict_get_int(qdict, "index");
Luiz Capitulino584cbdb2010-02-10 23:49:51 -0200956 if (mon_set_cpu(index) < 0) {
Markus Armbrustere17ba872010-03-25 17:22:36 +0100957 qerror_report(QERR_INVALID_PARAMETER_VALUE, "index",
958 "a CPU number");
Luiz Capitulino584cbdb2010-02-10 23:49:51 -0200959 return -1;
960 }
961 return 0;
bellard6a00d602005-11-21 23:25:50 +0000962}
963
aliguori376253e2009-03-05 23:01:23 +0000964static void do_info_jit(Monitor *mon)
bellarde3db7222005-01-26 22:00:47 +0000965{
aliguori376253e2009-03-05 23:01:23 +0000966 dump_exec_info((FILE *)mon, monitor_fprintf);
bellarde3db7222005-01-26 22:00:47 +0000967}
968
aliguori376253e2009-03-05 23:01:23 +0000969static void do_info_history(Monitor *mon)
bellardaa455482004-04-04 13:07:25 +0000970{
971 int i;
bellard7e2515e2004-08-01 21:52:19 +0000972 const char *str;
ths3b46e622007-09-17 08:09:54 +0000973
aliguoricde76ee2009-03-05 23:01:51 +0000974 if (!mon->rs)
975 return;
bellard7e2515e2004-08-01 21:52:19 +0000976 i = 0;
977 for(;;) {
aliguori731b0362009-03-05 23:01:42 +0000978 str = readline_get_history(mon->rs, i);
bellard7e2515e2004-08-01 21:52:19 +0000979 if (!str)
980 break;
aliguori376253e2009-03-05 23:01:23 +0000981 monitor_printf(mon, "%d: '%s'\n", i, str);
bellard8e3a9fd2004-10-09 17:32:58 +0000982 i++;
bellardaa455482004-04-04 13:07:25 +0000983 }
984}
985
j_mayer76a66252007-03-07 08:32:30 +0000986#if defined(TARGET_PPC)
987/* XXX: not implemented in other targets */
aliguori376253e2009-03-05 23:01:23 +0000988static void do_info_cpu_stats(Monitor *mon)
j_mayer76a66252007-03-07 08:32:30 +0000989{
990 CPUState *env;
991
992 env = mon_get_cpu();
aliguori376253e2009-03-05 23:01:23 +0000993 cpu_dump_statistics(env, (FILE *)mon, &monitor_fprintf, 0);
j_mayer76a66252007-03-07 08:32:30 +0000994}
995#endif
996
Prerna Saxena22890ab2010-06-24 17:04:53 +0530997#if defined(CONFIG_SIMPLE_TRACE)
998static void do_info_trace(Monitor *mon)
999{
1000 st_print_trace((FILE *)mon, &monitor_fprintf);
1001}
1002
1003static void do_info_trace_events(Monitor *mon)
1004{
1005 st_print_trace_events((FILE *)mon, &monitor_fprintf);
1006}
1007#endif
1008
Luiz Capitulinob223f352009-10-07 13:41:56 -03001009/**
1010 * do_quit(): Quit QEMU execution
1011 */
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -02001012static int do_quit(Monitor *mon, const QDict *qdict, QObject **ret_data)
bellard9dc39cb2004-03-14 21:38:27 +00001013{
Luiz Capitulino39b59d22010-05-11 18:08:20 -03001014 monitor_suspend(mon);
1015 no_shutdown = 0;
1016 qemu_system_shutdown_request();
1017
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -02001018 return 0;
bellard9dc39cb2004-03-14 21:38:27 +00001019}
1020
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001021static int change_vnc_password(const char *password)
aliguoribb5fc202009-03-05 23:01:15 +00001022{
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001023 if (vnc_display_password(NULL, password) < 0) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01001024 qerror_report(QERR_SET_PASSWD_FAILED);
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001025 return -1;
1026 }
aliguoribb5fc202009-03-05 23:01:15 +00001027
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001028 return 0;
Markus Armbruster2895e072009-12-07 21:37:01 +01001029}
1030
1031static void change_vnc_password_cb(Monitor *mon, const char *password,
1032 void *opaque)
1033{
Markus Armbrusterec3b82a2009-12-07 21:37:09 +01001034 change_vnc_password(password);
aliguori731b0362009-03-05 23:01:42 +00001035 monitor_read_command(mon, 1);
bellard9dc39cb2004-03-14 21:38:27 +00001036}
1037
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001038static int do_change_vnc(Monitor *mon, const char *target, const char *arg)
thse25a5822007-08-25 01:36:20 +00001039{
ths70848512007-08-25 01:37:05 +00001040 if (strcmp(target, "passwd") == 0 ||
aliguori28a76be2009-03-06 20:27:40 +00001041 strcmp(target, "password") == 0) {
1042 if (arg) {
aliguoribb5fc202009-03-05 23:01:15 +00001043 char password[9];
aliguori28a76be2009-03-06 20:27:40 +00001044 strncpy(password, arg, sizeof(password));
1045 password[sizeof(password) - 1] = '\0';
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001046 return change_vnc_password(password);
aliguoribb5fc202009-03-05 23:01:15 +00001047 } else {
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001048 return monitor_read_password(mon, change_vnc_password_cb, NULL);
aliguoribb5fc202009-03-05 23:01:15 +00001049 }
ths70848512007-08-25 01:37:05 +00001050 } else {
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001051 if (vnc_display_open(NULL, target) < 0) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01001052 qerror_report(QERR_VNC_SERVER_FAILED, target);
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001053 return -1;
1054 }
ths70848512007-08-25 01:37:05 +00001055 }
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001056
1057 return 0;
thse25a5822007-08-25 01:36:20 +00001058}
1059
Markus Armbrusterec3b82a2009-12-07 21:37:09 +01001060/**
1061 * do_change(): Change a removable medium, or VNC configuration
1062 */
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001063static int do_change(Monitor *mon, const QDict *qdict, QObject **ret_data)
thse25a5822007-08-25 01:36:20 +00001064{
Luiz Capitulino1d4daa92009-08-28 15:27:15 -03001065 const char *device = qdict_get_str(qdict, "device");
1066 const char *target = qdict_get_str(qdict, "target");
1067 const char *arg = qdict_get_try_str(qdict, "arg");
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001068 int ret;
1069
thse25a5822007-08-25 01:36:20 +00001070 if (strcmp(device, "vnc") == 0) {
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001071 ret = do_change_vnc(mon, target, arg);
thse25a5822007-08-25 01:36:20 +00001072 } else {
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001073 ret = do_change_block(mon, device, target, arg);
thse25a5822007-08-25 01:36:20 +00001074 }
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02001075
1076 return ret;
thse25a5822007-08-25 01:36:20 +00001077}
1078
Gerd Hoffmann75721502010-10-07 12:22:54 +02001079static int set_password(Monitor *mon, const QDict *qdict, QObject **ret_data)
1080{
1081 const char *protocol = qdict_get_str(qdict, "protocol");
1082 const char *password = qdict_get_str(qdict, "password");
1083 const char *connected = qdict_get_try_str(qdict, "connected");
1084 int disconnect_if_connected = 0;
1085 int fail_if_connected = 0;
1086 int rc;
1087
1088 if (connected) {
1089 if (strcmp(connected, "fail") == 0) {
1090 fail_if_connected = 1;
1091 } else if (strcmp(connected, "disconnect") == 0) {
1092 disconnect_if_connected = 1;
1093 } else if (strcmp(connected, "keep") == 0) {
1094 /* nothing */
1095 } else {
1096 qerror_report(QERR_INVALID_PARAMETER, "connected");
1097 return -1;
1098 }
1099 }
1100
1101 if (strcmp(protocol, "spice") == 0) {
1102 if (!using_spice) {
1103 /* correct one? spice isn't a device ,,, */
1104 qerror_report(QERR_DEVICE_NOT_ACTIVE, "spice");
1105 return -1;
1106 }
1107 rc = qemu_spice_set_passwd(password, fail_if_connected,
1108 disconnect_if_connected);
1109 if (rc != 0) {
1110 qerror_report(QERR_SET_PASSWD_FAILED);
1111 return -1;
1112 }
1113 return 0;
1114 }
1115
1116 if (strcmp(protocol, "vnc") == 0) {
1117 if (fail_if_connected || disconnect_if_connected) {
1118 /* vnc supports "connected=keep" only */
1119 qerror_report(QERR_INVALID_PARAMETER, "connected");
1120 return -1;
1121 }
1122 rc = vnc_display_password(NULL, password);
1123 if (rc != 0) {
1124 qerror_report(QERR_SET_PASSWD_FAILED);
1125 return -1;
1126 }
1127 return 0;
1128 }
1129
1130 qerror_report(QERR_INVALID_PARAMETER, "protocol");
1131 return -1;
1132}
1133
1134static int expire_password(Monitor *mon, const QDict *qdict, QObject **ret_data)
1135{
1136 const char *protocol = qdict_get_str(qdict, "protocol");
1137 const char *whenstr = qdict_get_str(qdict, "time");
1138 time_t when;
1139 int rc;
1140
1141 if (strcmp(whenstr, "now")) {
1142 when = 0;
1143 } else if (strcmp(whenstr, "never")) {
1144 when = TIME_MAX;
1145 } else if (whenstr[0] == '+') {
1146 when = time(NULL) + strtoull(whenstr+1, NULL, 10);
1147 } else {
1148 when = strtoull(whenstr, NULL, 10);
1149 }
1150
1151 if (strcmp(protocol, "spice") == 0) {
1152 if (!using_spice) {
1153 /* correct one? spice isn't a device ,,, */
1154 qerror_report(QERR_DEVICE_NOT_ACTIVE, "spice");
1155 return -1;
1156 }
1157 rc = qemu_spice_set_pw_expire(when);
1158 if (rc != 0) {
1159 qerror_report(QERR_SET_PASSWD_FAILED);
1160 return -1;
1161 }
1162 return 0;
1163 }
1164
1165 if (strcmp(protocol, "vnc") == 0) {
1166 rc = vnc_display_pw_expire(NULL, when);
1167 if (rc != 0) {
1168 qerror_report(QERR_SET_PASSWD_FAILED);
1169 return -1;
1170 }
1171 return 0;
1172 }
1173
1174 qerror_report(QERR_INVALID_PARAMETER, "protocol");
1175 return -1;
1176}
1177
Luiz Capitulinof1dc58e2010-03-31 15:21:49 -03001178static int do_screen_dump(Monitor *mon, const QDict *qdict, QObject **ret_data)
bellard59a983b2004-03-17 23:17:16 +00001179{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001180 vga_hw_screen_dump(qdict_get_str(qdict, "filename"));
Luiz Capitulinof1dc58e2010-03-31 15:21:49 -03001181 return 0;
bellard59a983b2004-03-17 23:17:16 +00001182}
1183
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001184static void do_logfile(Monitor *mon, const QDict *qdict)
pbrooke735b912007-06-30 13:53:24 +00001185{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001186 cpu_set_log_filename(qdict_get_str(qdict, "filename"));
pbrooke735b912007-06-30 13:53:24 +00001187}
1188
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001189static void do_log(Monitor *mon, const QDict *qdict)
bellardf193c792004-03-21 17:06:25 +00001190{
1191 int mask;
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001192 const char *items = qdict_get_str(qdict, "items");
ths3b46e622007-09-17 08:09:54 +00001193
bellard9307c4c2004-04-04 12:57:25 +00001194 if (!strcmp(items, "none")) {
bellardf193c792004-03-21 17:06:25 +00001195 mask = 0;
1196 } else {
bellard9307c4c2004-04-04 12:57:25 +00001197 mask = cpu_str_to_log_mask(items);
bellardf193c792004-03-21 17:06:25 +00001198 if (!mask) {
aliguori376253e2009-03-05 23:01:23 +00001199 help_cmd(mon, "log");
bellardf193c792004-03-21 17:06:25 +00001200 return;
1201 }
1202 }
1203 cpu_set_log(mask);
1204}
1205
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001206static void do_singlestep(Monitor *mon, const QDict *qdict)
aurel321b530a62009-04-05 20:08:59 +00001207{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001208 const char *option = qdict_get_try_str(qdict, "option");
aurel321b530a62009-04-05 20:08:59 +00001209 if (!option || !strcmp(option, "on")) {
1210 singlestep = 1;
1211 } else if (!strcmp(option, "off")) {
1212 singlestep = 0;
1213 } else {
1214 monitor_printf(mon, "unexpected option %s\n", option);
1215 }
1216}
1217
Luiz Capitulinoe0c97bd2009-10-07 13:41:57 -03001218/**
1219 * do_stop(): Stop VM execution
1220 */
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -02001221static int do_stop(Monitor *mon, const QDict *qdict, QObject **ret_data)
bellard8a7ddc32004-03-31 19:00:16 +00001222{
1223 vm_stop(EXCP_INTERRUPT);
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -02001224 return 0;
bellard8a7ddc32004-03-31 19:00:16 +00001225}
1226
aliguoribb5fc202009-03-05 23:01:15 +00001227static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs);
aliguoric0f4ce72009-03-05 23:01:01 +00001228
aliguori376253e2009-03-05 23:01:23 +00001229struct bdrv_iterate_context {
1230 Monitor *mon;
1231 int err;
1232};
aliguoric0f4ce72009-03-05 23:01:01 +00001233
Luiz Capitulinoa1f896a2009-10-07 13:42:00 -03001234/**
1235 * do_cont(): Resume emulation.
1236 */
Luiz Capitulinod5a7b382010-02-10 23:49:49 -02001237static int do_cont(Monitor *mon, const QDict *qdict, QObject **ret_data)
aliguori376253e2009-03-05 23:01:23 +00001238{
1239 struct bdrv_iterate_context context = { mon, 0 };
1240
Amit Shah8e848652010-07-27 15:49:19 +05301241 if (incoming_expected) {
1242 qerror_report(QERR_MIGRATION_EXPECTED);
1243 return -1;
1244 }
aliguori376253e2009-03-05 23:01:23 +00001245 bdrv_iterate(encrypted_bdrv_it, &context);
aliguoric0f4ce72009-03-05 23:01:01 +00001246 /* only resume the vm if all keys are set and valid */
Luiz Capitulinod5a7b382010-02-10 23:49:49 -02001247 if (!context.err) {
aliguoric0f4ce72009-03-05 23:01:01 +00001248 vm_start();
Luiz Capitulinod5a7b382010-02-10 23:49:49 -02001249 return 0;
1250 } else {
1251 return -1;
1252 }
bellard8a7ddc32004-03-31 19:00:16 +00001253}
1254
aliguoribb5fc202009-03-05 23:01:15 +00001255static void bdrv_key_cb(void *opaque, int err)
1256{
aliguori376253e2009-03-05 23:01:23 +00001257 Monitor *mon = opaque;
1258
aliguoribb5fc202009-03-05 23:01:15 +00001259 /* another key was set successfully, retry to continue */
1260 if (!err)
Luiz Capitulinoa1f896a2009-10-07 13:42:00 -03001261 do_cont(mon, NULL, NULL);
aliguoribb5fc202009-03-05 23:01:15 +00001262}
1263
1264static void encrypted_bdrv_it(void *opaque, BlockDriverState *bs)
1265{
aliguori376253e2009-03-05 23:01:23 +00001266 struct bdrv_iterate_context *context = opaque;
aliguoribb5fc202009-03-05 23:01:15 +00001267
aliguori376253e2009-03-05 23:01:23 +00001268 if (!context->err && bdrv_key_required(bs)) {
1269 context->err = -EBUSY;
1270 monitor_read_bdrv_key_start(context->mon, bs, bdrv_key_cb,
1271 context->mon);
aliguoribb5fc202009-03-05 23:01:15 +00001272 }
1273}
1274
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001275static void do_gdbserver(Monitor *mon, const QDict *qdict)
bellard8a7ddc32004-03-31 19:00:16 +00001276{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001277 const char *device = qdict_get_try_str(qdict, "device");
aliguori59030a82009-04-05 18:43:41 +00001278 if (!device)
1279 device = "tcp::" DEFAULT_GDBSTUB_PORT;
1280 if (gdbserver_start(device) < 0) {
1281 monitor_printf(mon, "Could not open gdbserver on device '%s'\n",
1282 device);
1283 } else if (strcmp(device, "none") == 0) {
aliguori36556b22009-03-28 18:05:53 +00001284 monitor_printf(mon, "Disabled gdbserver\n");
bellard8a7ddc32004-03-31 19:00:16 +00001285 } else {
aliguori59030a82009-04-05 18:43:41 +00001286 monitor_printf(mon, "Waiting for gdb connection on device '%s'\n",
1287 device);
bellard8a7ddc32004-03-31 19:00:16 +00001288 }
1289}
1290
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001291static void do_watchdog_action(Monitor *mon, const QDict *qdict)
Richard W.M. Jones9dd986c2009-04-25 13:56:19 +01001292{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001293 const char *action = qdict_get_str(qdict, "action");
Richard W.M. Jones9dd986c2009-04-25 13:56:19 +01001294 if (select_watchdog_action(action) == -1) {
1295 monitor_printf(mon, "Unknown watchdog action '%s'\n", action);
1296 }
1297}
1298
aliguori376253e2009-03-05 23:01:23 +00001299static void monitor_printc(Monitor *mon, int c)
bellard9307c4c2004-04-04 12:57:25 +00001300{
aliguori376253e2009-03-05 23:01:23 +00001301 monitor_printf(mon, "'");
bellard9307c4c2004-04-04 12:57:25 +00001302 switch(c) {
1303 case '\'':
aliguori376253e2009-03-05 23:01:23 +00001304 monitor_printf(mon, "\\'");
bellard9307c4c2004-04-04 12:57:25 +00001305 break;
1306 case '\\':
aliguori376253e2009-03-05 23:01:23 +00001307 monitor_printf(mon, "\\\\");
bellard9307c4c2004-04-04 12:57:25 +00001308 break;
1309 case '\n':
aliguori376253e2009-03-05 23:01:23 +00001310 monitor_printf(mon, "\\n");
bellard9307c4c2004-04-04 12:57:25 +00001311 break;
1312 case '\r':
aliguori376253e2009-03-05 23:01:23 +00001313 monitor_printf(mon, "\\r");
bellard9307c4c2004-04-04 12:57:25 +00001314 break;
1315 default:
1316 if (c >= 32 && c <= 126) {
aliguori376253e2009-03-05 23:01:23 +00001317 monitor_printf(mon, "%c", c);
bellard9307c4c2004-04-04 12:57:25 +00001318 } else {
aliguori376253e2009-03-05 23:01:23 +00001319 monitor_printf(mon, "\\x%02x", c);
bellard9307c4c2004-04-04 12:57:25 +00001320 }
1321 break;
1322 }
aliguori376253e2009-03-05 23:01:23 +00001323 monitor_printf(mon, "'");
bellard9307c4c2004-04-04 12:57:25 +00001324}
1325
aliguori376253e2009-03-05 23:01:23 +00001326static void memory_dump(Monitor *mon, int count, int format, int wsize,
Anthony Liguoric227f092009-10-01 16:12:16 -05001327 target_phys_addr_t addr, int is_physical)
bellard9307c4c2004-04-04 12:57:25 +00001328{
bellard6a00d602005-11-21 23:25:50 +00001329 CPUState *env;
Blue Swirl23842aa2010-01-12 20:27:43 +00001330 int l, line_size, i, max_digits, len;
bellard9307c4c2004-04-04 12:57:25 +00001331 uint8_t buf[16];
1332 uint64_t v;
1333
1334 if (format == 'i') {
1335 int flags;
1336 flags = 0;
bellard6a00d602005-11-21 23:25:50 +00001337 env = mon_get_cpu();
bellard9307c4c2004-04-04 12:57:25 +00001338#ifdef TARGET_I386
bellard4c27ba22004-04-25 18:05:08 +00001339 if (wsize == 2) {
bellard9307c4c2004-04-04 12:57:25 +00001340 flags = 1;
bellard4c27ba22004-04-25 18:05:08 +00001341 } else if (wsize == 4) {
1342 flags = 0;
1343 } else {
bellard6a15fd12006-04-12 21:07:07 +00001344 /* as default we use the current CS size */
bellard4c27ba22004-04-25 18:05:08 +00001345 flags = 0;
bellard6a15fd12006-04-12 21:07:07 +00001346 if (env) {
1347#ifdef TARGET_X86_64
ths5fafdf22007-09-16 21:08:06 +00001348 if ((env->efer & MSR_EFER_LMA) &&
bellard6a15fd12006-04-12 21:07:07 +00001349 (env->segs[R_CS].flags & DESC_L_MASK))
1350 flags = 2;
1351 else
1352#endif
1353 if (!(env->segs[R_CS].flags & DESC_B_MASK))
1354 flags = 1;
1355 }
bellard4c27ba22004-04-25 18:05:08 +00001356 }
1357#endif
aliguori376253e2009-03-05 23:01:23 +00001358 monitor_disas(mon, env, addr, count, is_physical, flags);
bellard9307c4c2004-04-04 12:57:25 +00001359 return;
1360 }
1361
1362 len = wsize * count;
1363 if (wsize == 1)
1364 line_size = 8;
1365 else
1366 line_size = 16;
bellard9307c4c2004-04-04 12:57:25 +00001367 max_digits = 0;
1368
1369 switch(format) {
1370 case 'o':
1371 max_digits = (wsize * 8 + 2) / 3;
1372 break;
1373 default:
1374 case 'x':
1375 max_digits = (wsize * 8) / 4;
1376 break;
1377 case 'u':
1378 case 'd':
1379 max_digits = (wsize * 8 * 10 + 32) / 33;
1380 break;
1381 case 'c':
1382 wsize = 1;
1383 break;
1384 }
1385
1386 while (len > 0) {
blueswir17743e582007-09-24 18:39:04 +00001387 if (is_physical)
aliguori376253e2009-03-05 23:01:23 +00001388 monitor_printf(mon, TARGET_FMT_plx ":", addr);
blueswir17743e582007-09-24 18:39:04 +00001389 else
aliguori376253e2009-03-05 23:01:23 +00001390 monitor_printf(mon, TARGET_FMT_lx ":", (target_ulong)addr);
bellard9307c4c2004-04-04 12:57:25 +00001391 l = len;
1392 if (l > line_size)
1393 l = line_size;
1394 if (is_physical) {
1395 cpu_physical_memory_rw(addr, buf, l, 0);
1396 } else {
bellard6a00d602005-11-21 23:25:50 +00001397 env = mon_get_cpu();
aliguoric8f79b62008-08-18 14:00:20 +00001398 if (cpu_memory_rw_debug(env, addr, buf, l, 0) < 0) {
aliguori376253e2009-03-05 23:01:23 +00001399 monitor_printf(mon, " Cannot access memory\n");
aliguoric8f79b62008-08-18 14:00:20 +00001400 break;
1401 }
bellard9307c4c2004-04-04 12:57:25 +00001402 }
ths5fafdf22007-09-16 21:08:06 +00001403 i = 0;
bellard9307c4c2004-04-04 12:57:25 +00001404 while (i < l) {
1405 switch(wsize) {
1406 default:
1407 case 1:
1408 v = ldub_raw(buf + i);
1409 break;
1410 case 2:
1411 v = lduw_raw(buf + i);
1412 break;
1413 case 4:
bellard92a31b12005-02-10 22:00:52 +00001414 v = (uint32_t)ldl_raw(buf + i);
bellard9307c4c2004-04-04 12:57:25 +00001415 break;
1416 case 8:
1417 v = ldq_raw(buf + i);
1418 break;
1419 }
aliguori376253e2009-03-05 23:01:23 +00001420 monitor_printf(mon, " ");
bellard9307c4c2004-04-04 12:57:25 +00001421 switch(format) {
1422 case 'o':
aliguori376253e2009-03-05 23:01:23 +00001423 monitor_printf(mon, "%#*" PRIo64, max_digits, v);
bellard9307c4c2004-04-04 12:57:25 +00001424 break;
1425 case 'x':
aliguori376253e2009-03-05 23:01:23 +00001426 monitor_printf(mon, "0x%0*" PRIx64, max_digits, v);
bellard9307c4c2004-04-04 12:57:25 +00001427 break;
1428 case 'u':
aliguori376253e2009-03-05 23:01:23 +00001429 monitor_printf(mon, "%*" PRIu64, max_digits, v);
bellard9307c4c2004-04-04 12:57:25 +00001430 break;
1431 case 'd':
aliguori376253e2009-03-05 23:01:23 +00001432 monitor_printf(mon, "%*" PRId64, max_digits, v);
bellard9307c4c2004-04-04 12:57:25 +00001433 break;
1434 case 'c':
aliguori376253e2009-03-05 23:01:23 +00001435 monitor_printc(mon, v);
bellard9307c4c2004-04-04 12:57:25 +00001436 break;
1437 }
1438 i += wsize;
1439 }
aliguori376253e2009-03-05 23:01:23 +00001440 monitor_printf(mon, "\n");
bellard9307c4c2004-04-04 12:57:25 +00001441 addr += l;
1442 len -= l;
1443 }
1444}
1445
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001446static void do_memory_dump(Monitor *mon, const QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +00001447{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001448 int count = qdict_get_int(qdict, "count");
1449 int format = qdict_get_int(qdict, "format");
1450 int size = qdict_get_int(qdict, "size");
1451 target_long addr = qdict_get_int(qdict, "addr");
1452
aliguori376253e2009-03-05 23:01:23 +00001453 memory_dump(mon, count, format, size, addr, 0);
bellard9307c4c2004-04-04 12:57:25 +00001454}
1455
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001456static void do_physical_memory_dump(Monitor *mon, const QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +00001457{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001458 int count = qdict_get_int(qdict, "count");
1459 int format = qdict_get_int(qdict, "format");
1460 int size = qdict_get_int(qdict, "size");
Anthony Liguoric227f092009-10-01 16:12:16 -05001461 target_phys_addr_t addr = qdict_get_int(qdict, "addr");
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001462
aliguori376253e2009-03-05 23:01:23 +00001463 memory_dump(mon, count, format, size, addr, 1);
bellard9307c4c2004-04-04 12:57:25 +00001464}
1465
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001466static void do_print(Monitor *mon, const QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +00001467{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001468 int format = qdict_get_int(qdict, "format");
Anthony Liguoric227f092009-10-01 16:12:16 -05001469 target_phys_addr_t val = qdict_get_int(qdict, "val");
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001470
blueswir17743e582007-09-24 18:39:04 +00001471#if TARGET_PHYS_ADDR_BITS == 32
bellard9307c4c2004-04-04 12:57:25 +00001472 switch(format) {
1473 case 'o':
aliguori376253e2009-03-05 23:01:23 +00001474 monitor_printf(mon, "%#o", val);
bellard9307c4c2004-04-04 12:57:25 +00001475 break;
1476 case 'x':
aliguori376253e2009-03-05 23:01:23 +00001477 monitor_printf(mon, "%#x", val);
bellard9307c4c2004-04-04 12:57:25 +00001478 break;
1479 case 'u':
aliguori376253e2009-03-05 23:01:23 +00001480 monitor_printf(mon, "%u", val);
bellard9307c4c2004-04-04 12:57:25 +00001481 break;
1482 default:
1483 case 'd':
aliguori376253e2009-03-05 23:01:23 +00001484 monitor_printf(mon, "%d", val);
bellard9307c4c2004-04-04 12:57:25 +00001485 break;
1486 case 'c':
aliguori376253e2009-03-05 23:01:23 +00001487 monitor_printc(mon, val);
bellard9307c4c2004-04-04 12:57:25 +00001488 break;
1489 }
bellard92a31b12005-02-10 22:00:52 +00001490#else
1491 switch(format) {
1492 case 'o':
aliguori376253e2009-03-05 23:01:23 +00001493 monitor_printf(mon, "%#" PRIo64, val);
bellard92a31b12005-02-10 22:00:52 +00001494 break;
1495 case 'x':
aliguori376253e2009-03-05 23:01:23 +00001496 monitor_printf(mon, "%#" PRIx64, val);
bellard92a31b12005-02-10 22:00:52 +00001497 break;
1498 case 'u':
aliguori376253e2009-03-05 23:01:23 +00001499 monitor_printf(mon, "%" PRIu64, val);
bellard92a31b12005-02-10 22:00:52 +00001500 break;
1501 default:
1502 case 'd':
aliguori376253e2009-03-05 23:01:23 +00001503 monitor_printf(mon, "%" PRId64, val);
bellard92a31b12005-02-10 22:00:52 +00001504 break;
1505 case 'c':
aliguori376253e2009-03-05 23:01:23 +00001506 monitor_printc(mon, val);
bellard92a31b12005-02-10 22:00:52 +00001507 break;
1508 }
1509#endif
aliguori376253e2009-03-05 23:01:23 +00001510 monitor_printf(mon, "\n");
bellard9307c4c2004-04-04 12:57:25 +00001511}
1512
Luiz Capitulino98696222010-02-10 23:49:58 -02001513static int do_memory_save(Monitor *mon, const QDict *qdict, QObject **ret_data)
bellardb371dc52007-01-03 15:20:39 +00001514{
1515 FILE *f;
Luiz Capitulinoafe67ef2009-08-28 15:27:16 -03001516 uint32_t size = qdict_get_int(qdict, "size");
1517 const char *filename = qdict_get_str(qdict, "filename");
1518 target_long addr = qdict_get_int(qdict, "val");
bellardb371dc52007-01-03 15:20:39 +00001519 uint32_t l;
1520 CPUState *env;
1521 uint8_t buf[1024];
Luiz Capitulino98696222010-02-10 23:49:58 -02001522 int ret = -1;
bellardb371dc52007-01-03 15:20:39 +00001523
1524 env = mon_get_cpu();
bellardb371dc52007-01-03 15:20:39 +00001525
1526 f = fopen(filename, "wb");
1527 if (!f) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01001528 qerror_report(QERR_OPEN_FILE_FAILED, filename);
Luiz Capitulino98696222010-02-10 23:49:58 -02001529 return -1;
bellardb371dc52007-01-03 15:20:39 +00001530 }
1531 while (size != 0) {
1532 l = sizeof(buf);
1533 if (l > size)
1534 l = size;
1535 cpu_memory_rw_debug(env, addr, buf, l, 0);
Kirill A. Shutemov27e3ddd2010-01-20 00:56:19 +01001536 if (fwrite(buf, 1, l, f) != l) {
1537 monitor_printf(mon, "fwrite() error in do_memory_save\n");
1538 goto exit;
1539 }
bellardb371dc52007-01-03 15:20:39 +00001540 addr += l;
1541 size -= l;
1542 }
Luiz Capitulino98696222010-02-10 23:49:58 -02001543
1544 ret = 0;
1545
Kirill A. Shutemov27e3ddd2010-01-20 00:56:19 +01001546exit:
bellardb371dc52007-01-03 15:20:39 +00001547 fclose(f);
Luiz Capitulino98696222010-02-10 23:49:58 -02001548 return ret;
bellardb371dc52007-01-03 15:20:39 +00001549}
1550
Luiz Capitulinofe38a322010-02-10 23:49:59 -02001551static int do_physical_memory_save(Monitor *mon, const QDict *qdict,
Luiz Capitulino18f5a8b2009-10-16 12:23:44 -03001552 QObject **ret_data)
aurel32a8bdf7a2008-04-11 21:36:14 +00001553{
1554 FILE *f;
1555 uint32_t l;
1556 uint8_t buf[1024];
Luiz Capitulinoafe67ef2009-08-28 15:27:16 -03001557 uint32_t size = qdict_get_int(qdict, "size");
1558 const char *filename = qdict_get_str(qdict, "filename");
Anthony Liguoric227f092009-10-01 16:12:16 -05001559 target_phys_addr_t addr = qdict_get_int(qdict, "val");
Luiz Capitulinofe38a322010-02-10 23:49:59 -02001560 int ret = -1;
aurel32a8bdf7a2008-04-11 21:36:14 +00001561
1562 f = fopen(filename, "wb");
1563 if (!f) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01001564 qerror_report(QERR_OPEN_FILE_FAILED, filename);
Luiz Capitulinofe38a322010-02-10 23:49:59 -02001565 return -1;
aurel32a8bdf7a2008-04-11 21:36:14 +00001566 }
1567 while (size != 0) {
1568 l = sizeof(buf);
1569 if (l > size)
1570 l = size;
1571 cpu_physical_memory_rw(addr, buf, l, 0);
Kirill A. Shutemov27e3ddd2010-01-20 00:56:19 +01001572 if (fwrite(buf, 1, l, f) != l) {
1573 monitor_printf(mon, "fwrite() error in do_physical_memory_save\n");
1574 goto exit;
1575 }
aurel32a8bdf7a2008-04-11 21:36:14 +00001576 fflush(f);
1577 addr += l;
1578 size -= l;
1579 }
Luiz Capitulinofe38a322010-02-10 23:49:59 -02001580
1581 ret = 0;
1582
Kirill A. Shutemov27e3ddd2010-01-20 00:56:19 +01001583exit:
aurel32a8bdf7a2008-04-11 21:36:14 +00001584 fclose(f);
Luiz Capitulinofe38a322010-02-10 23:49:59 -02001585 return ret;
aurel32a8bdf7a2008-04-11 21:36:14 +00001586}
1587
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03001588static void do_sum(Monitor *mon, const QDict *qdict)
bellarde4cf1ad2005-06-04 20:15:57 +00001589{
1590 uint32_t addr;
1591 uint8_t buf[1];
1592 uint16_t sum;
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03001593 uint32_t start = qdict_get_int(qdict, "start");
1594 uint32_t size = qdict_get_int(qdict, "size");
bellarde4cf1ad2005-06-04 20:15:57 +00001595
1596 sum = 0;
1597 for(addr = start; addr < (start + size); addr++) {
1598 cpu_physical_memory_rw(addr, buf, 1, 0);
1599 /* BSD sum algorithm ('sum' Unix command) */
1600 sum = (sum >> 1) | (sum << 15);
1601 sum += buf[0];
1602 }
aliguori376253e2009-03-05 23:01:23 +00001603 monitor_printf(mon, "%05d\n", sum);
bellarde4cf1ad2005-06-04 20:15:57 +00001604}
1605
bellarda3a91a32004-06-04 11:06:21 +00001606typedef struct {
1607 int keycode;
1608 const char *name;
1609} KeyDef;
1610
1611static const KeyDef key_defs[] = {
1612 { 0x2a, "shift" },
1613 { 0x36, "shift_r" },
ths3b46e622007-09-17 08:09:54 +00001614
bellarda3a91a32004-06-04 11:06:21 +00001615 { 0x38, "alt" },
1616 { 0xb8, "alt_r" },
ths2ba27c72008-08-13 12:54:23 +00001617 { 0x64, "altgr" },
1618 { 0xe4, "altgr_r" },
bellarda3a91a32004-06-04 11:06:21 +00001619 { 0x1d, "ctrl" },
1620 { 0x9d, "ctrl_r" },
1621
1622 { 0xdd, "menu" },
1623
1624 { 0x01, "esc" },
1625
1626 { 0x02, "1" },
1627 { 0x03, "2" },
1628 { 0x04, "3" },
1629 { 0x05, "4" },
1630 { 0x06, "5" },
1631 { 0x07, "6" },
1632 { 0x08, "7" },
1633 { 0x09, "8" },
1634 { 0x0a, "9" },
1635 { 0x0b, "0" },
bellard64866c32006-05-07 18:03:31 +00001636 { 0x0c, "minus" },
1637 { 0x0d, "equal" },
bellarda3a91a32004-06-04 11:06:21 +00001638 { 0x0e, "backspace" },
1639
1640 { 0x0f, "tab" },
1641 { 0x10, "q" },
1642 { 0x11, "w" },
1643 { 0x12, "e" },
1644 { 0x13, "r" },
1645 { 0x14, "t" },
1646 { 0x15, "y" },
1647 { 0x16, "u" },
1648 { 0x17, "i" },
1649 { 0x18, "o" },
1650 { 0x19, "p" },
Bernhard M. Wiedemann49b586a2010-06-02 05:32:30 +02001651 { 0x1a, "bracket_left" },
1652 { 0x1b, "bracket_right" },
bellarda3a91a32004-06-04 11:06:21 +00001653 { 0x1c, "ret" },
1654
1655 { 0x1e, "a" },
1656 { 0x1f, "s" },
1657 { 0x20, "d" },
1658 { 0x21, "f" },
1659 { 0x22, "g" },
1660 { 0x23, "h" },
1661 { 0x24, "j" },
1662 { 0x25, "k" },
1663 { 0x26, "l" },
Bernhard M. Wiedemann49b586a2010-06-02 05:32:30 +02001664 { 0x27, "semicolon" },
1665 { 0x28, "apostrophe" },
1666 { 0x29, "grave_accent" },
bellarda3a91a32004-06-04 11:06:21 +00001667
Bernhard M. Wiedemann49b586a2010-06-02 05:32:30 +02001668 { 0x2b, "backslash" },
bellarda3a91a32004-06-04 11:06:21 +00001669 { 0x2c, "z" },
1670 { 0x2d, "x" },
1671 { 0x2e, "c" },
1672 { 0x2f, "v" },
1673 { 0x30, "b" },
1674 { 0x31, "n" },
1675 { 0x32, "m" },
aurel329155fc42008-10-01 21:46:15 +00001676 { 0x33, "comma" },
1677 { 0x34, "dot" },
1678 { 0x35, "slash" },
ths3b46e622007-09-17 08:09:54 +00001679
balrog4d3b6f62008-02-10 16:33:14 +00001680 { 0x37, "asterisk" },
1681
bellarda3a91a32004-06-04 11:06:21 +00001682 { 0x39, "spc" },
bellard00ffa622004-06-04 13:25:15 +00001683 { 0x3a, "caps_lock" },
bellarda3a91a32004-06-04 11:06:21 +00001684 { 0x3b, "f1" },
1685 { 0x3c, "f2" },
1686 { 0x3d, "f3" },
1687 { 0x3e, "f4" },
1688 { 0x3f, "f5" },
1689 { 0x40, "f6" },
1690 { 0x41, "f7" },
1691 { 0x42, "f8" },
1692 { 0x43, "f9" },
1693 { 0x44, "f10" },
bellard00ffa622004-06-04 13:25:15 +00001694 { 0x45, "num_lock" },
bellarda3a91a32004-06-04 11:06:21 +00001695 { 0x46, "scroll_lock" },
1696
bellard64866c32006-05-07 18:03:31 +00001697 { 0xb5, "kp_divide" },
1698 { 0x37, "kp_multiply" },
ths0cfec832007-06-23 16:02:43 +00001699 { 0x4a, "kp_subtract" },
bellard64866c32006-05-07 18:03:31 +00001700 { 0x4e, "kp_add" },
1701 { 0x9c, "kp_enter" },
1702 { 0x53, "kp_decimal" },
balrogf2289cb2008-06-04 10:14:16 +00001703 { 0x54, "sysrq" },
bellard64866c32006-05-07 18:03:31 +00001704
1705 { 0x52, "kp_0" },
1706 { 0x4f, "kp_1" },
1707 { 0x50, "kp_2" },
1708 { 0x51, "kp_3" },
1709 { 0x4b, "kp_4" },
1710 { 0x4c, "kp_5" },
1711 { 0x4d, "kp_6" },
1712 { 0x47, "kp_7" },
1713 { 0x48, "kp_8" },
1714 { 0x49, "kp_9" },
ths3b46e622007-09-17 08:09:54 +00001715
bellarda3a91a32004-06-04 11:06:21 +00001716 { 0x56, "<" },
1717
1718 { 0x57, "f11" },
1719 { 0x58, "f12" },
1720
1721 { 0xb7, "print" },
1722
1723 { 0xc7, "home" },
1724 { 0xc9, "pgup" },
1725 { 0xd1, "pgdn" },
1726 { 0xcf, "end" },
1727
1728 { 0xcb, "left" },
1729 { 0xc8, "up" },
1730 { 0xd0, "down" },
1731 { 0xcd, "right" },
1732
1733 { 0xd2, "insert" },
1734 { 0xd3, "delete" },
blueswir1c0b5b102008-06-22 07:45:42 +00001735#if defined(TARGET_SPARC) && !defined(TARGET_SPARC64)
1736 { 0xf0, "stop" },
1737 { 0xf1, "again" },
1738 { 0xf2, "props" },
1739 { 0xf3, "undo" },
1740 { 0xf4, "front" },
1741 { 0xf5, "copy" },
1742 { 0xf6, "open" },
1743 { 0xf7, "paste" },
1744 { 0xf8, "find" },
1745 { 0xf9, "cut" },
1746 { 0xfa, "lf" },
1747 { 0xfb, "help" },
1748 { 0xfc, "meta_l" },
1749 { 0xfd, "meta_r" },
1750 { 0xfe, "compose" },
1751#endif
bellarda3a91a32004-06-04 11:06:21 +00001752 { 0, NULL },
1753};
1754
1755static int get_keycode(const char *key)
1756{
1757 const KeyDef *p;
bellard64866c32006-05-07 18:03:31 +00001758 char *endp;
1759 int ret;
bellarda3a91a32004-06-04 11:06:21 +00001760
1761 for(p = key_defs; p->name != NULL; p++) {
1762 if (!strcmp(key, p->name))
1763 return p->keycode;
1764 }
bellard64866c32006-05-07 18:03:31 +00001765 if (strstart(key, "0x", NULL)) {
1766 ret = strtoul(key, &endp, 0);
1767 if (*endp == '\0' && ret >= 0x01 && ret <= 0xff)
1768 return ret;
1769 }
bellarda3a91a32004-06-04 11:06:21 +00001770 return -1;
1771}
1772
balrogc8256f92008-06-08 22:45:01 +00001773#define MAX_KEYCODES 16
1774static uint8_t keycodes[MAX_KEYCODES];
1775static int nb_pending_keycodes;
1776static QEMUTimer *key_timer;
1777
1778static void release_keys(void *opaque)
bellarda3a91a32004-06-04 11:06:21 +00001779{
balrogc8256f92008-06-08 22:45:01 +00001780 int keycode;
1781
1782 while (nb_pending_keycodes > 0) {
1783 nb_pending_keycodes--;
1784 keycode = keycodes[nb_pending_keycodes];
1785 if (keycode & 0x80)
1786 kbd_put_keycode(0xe0);
1787 kbd_put_keycode(keycode | 0x80);
1788 }
1789}
1790
Luiz Capitulino1d4daa92009-08-28 15:27:15 -03001791static void do_sendkey(Monitor *mon, const QDict *qdict)
balrogc8256f92008-06-08 22:45:01 +00001792{
balrog3401c0d2008-06-04 10:05:59 +00001793 char keyname_buf[16];
1794 char *separator;
1795 int keyname_len, keycode, i;
Luiz Capitulino1d4daa92009-08-28 15:27:15 -03001796 const char *string = qdict_get_str(qdict, "string");
1797 int has_hold_time = qdict_haskey(qdict, "hold_time");
1798 int hold_time = qdict_get_try_int(qdict, "hold_time", -1);
ths3b46e622007-09-17 08:09:54 +00001799
balrogc8256f92008-06-08 22:45:01 +00001800 if (nb_pending_keycodes > 0) {
1801 qemu_del_timer(key_timer);
1802 release_keys(NULL);
1803 }
1804 if (!has_hold_time)
1805 hold_time = 100;
1806 i = 0;
balrog3401c0d2008-06-04 10:05:59 +00001807 while (1) {
1808 separator = strchr(string, '-');
1809 keyname_len = separator ? separator - string : strlen(string);
1810 if (keyname_len > 0) {
1811 pstrcpy(keyname_buf, sizeof(keyname_buf), string);
1812 if (keyname_len > sizeof(keyname_buf) - 1) {
aliguori376253e2009-03-05 23:01:23 +00001813 monitor_printf(mon, "invalid key: '%s...'\n", keyname_buf);
balrog3401c0d2008-06-04 10:05:59 +00001814 return;
bellarda3a91a32004-06-04 11:06:21 +00001815 }
balrogc8256f92008-06-08 22:45:01 +00001816 if (i == MAX_KEYCODES) {
aliguori376253e2009-03-05 23:01:23 +00001817 monitor_printf(mon, "too many keys\n");
balrog3401c0d2008-06-04 10:05:59 +00001818 return;
1819 }
1820 keyname_buf[keyname_len] = 0;
1821 keycode = get_keycode(keyname_buf);
1822 if (keycode < 0) {
aliguori376253e2009-03-05 23:01:23 +00001823 monitor_printf(mon, "unknown key: '%s'\n", keyname_buf);
balrog3401c0d2008-06-04 10:05:59 +00001824 return;
1825 }
balrogc8256f92008-06-08 22:45:01 +00001826 keycodes[i++] = keycode;
bellarda3a91a32004-06-04 11:06:21 +00001827 }
balrog3401c0d2008-06-04 10:05:59 +00001828 if (!separator)
bellarda3a91a32004-06-04 11:06:21 +00001829 break;
balrog3401c0d2008-06-04 10:05:59 +00001830 string = separator + 1;
bellarda3a91a32004-06-04 11:06:21 +00001831 }
balrogc8256f92008-06-08 22:45:01 +00001832 nb_pending_keycodes = i;
bellarda3a91a32004-06-04 11:06:21 +00001833 /* key down events */
balrogc8256f92008-06-08 22:45:01 +00001834 for (i = 0; i < nb_pending_keycodes; i++) {
bellarda3a91a32004-06-04 11:06:21 +00001835 keycode = keycodes[i];
1836 if (keycode & 0x80)
1837 kbd_put_keycode(0xe0);
1838 kbd_put_keycode(keycode & 0x7f);
1839 }
balrogc8256f92008-06-08 22:45:01 +00001840 /* delayed key up events */
balrogf227f172008-06-09 00:03:47 +00001841 qemu_mod_timer(key_timer, qemu_get_clock(vm_clock) +
Juan Quintela6ee093c2009-09-10 03:04:26 +02001842 muldiv64(get_ticks_per_sec(), hold_time, 1000));
bellarda3a91a32004-06-04 11:06:21 +00001843}
1844
bellard13224a82006-07-14 22:03:35 +00001845static int mouse_button_state;
1846
Luiz Capitulino1d4daa92009-08-28 15:27:15 -03001847static void do_mouse_move(Monitor *mon, const QDict *qdict)
bellard13224a82006-07-14 22:03:35 +00001848{
1849 int dx, dy, dz;
Luiz Capitulino1d4daa92009-08-28 15:27:15 -03001850 const char *dx_str = qdict_get_str(qdict, "dx_str");
1851 const char *dy_str = qdict_get_str(qdict, "dy_str");
1852 const char *dz_str = qdict_get_try_str(qdict, "dz_str");
bellard13224a82006-07-14 22:03:35 +00001853 dx = strtol(dx_str, NULL, 0);
1854 dy = strtol(dy_str, NULL, 0);
1855 dz = 0;
ths5fafdf22007-09-16 21:08:06 +00001856 if (dz_str)
bellard13224a82006-07-14 22:03:35 +00001857 dz = strtol(dz_str, NULL, 0);
1858 kbd_mouse_event(dx, dy, dz, mouse_button_state);
1859}
1860
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001861static void do_mouse_button(Monitor *mon, const QDict *qdict)
bellard13224a82006-07-14 22:03:35 +00001862{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001863 int button_state = qdict_get_int(qdict, "button_state");
bellard13224a82006-07-14 22:03:35 +00001864 mouse_button_state = button_state;
1865 kbd_mouse_event(0, 0, 0, mouse_button_state);
1866}
1867
Luiz Capitulinoaa93e392009-08-28 15:27:18 -03001868static void do_ioport_read(Monitor *mon, const QDict *qdict)
bellard34405572004-06-08 00:55:58 +00001869{
Luiz Capitulinoaa93e392009-08-28 15:27:18 -03001870 int size = qdict_get_int(qdict, "size");
1871 int addr = qdict_get_int(qdict, "addr");
1872 int has_index = qdict_haskey(qdict, "index");
bellard34405572004-06-08 00:55:58 +00001873 uint32_t val;
1874 int suffix;
1875
1876 if (has_index) {
Luiz Capitulinoaa93e392009-08-28 15:27:18 -03001877 int index = qdict_get_int(qdict, "index");
Blue Swirlafcea8c2009-09-20 16:05:47 +00001878 cpu_outb(addr & IOPORTS_MASK, index & 0xff);
bellard34405572004-06-08 00:55:58 +00001879 addr++;
1880 }
1881 addr &= 0xffff;
1882
1883 switch(size) {
1884 default:
1885 case 1:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001886 val = cpu_inb(addr);
bellard34405572004-06-08 00:55:58 +00001887 suffix = 'b';
1888 break;
1889 case 2:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001890 val = cpu_inw(addr);
bellard34405572004-06-08 00:55:58 +00001891 suffix = 'w';
1892 break;
1893 case 4:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001894 val = cpu_inl(addr);
bellard34405572004-06-08 00:55:58 +00001895 suffix = 'l';
1896 break;
1897 }
aliguori376253e2009-03-05 23:01:23 +00001898 monitor_printf(mon, "port%c[0x%04x] = %#0*x\n",
1899 suffix, addr, size * 2, val);
bellard34405572004-06-08 00:55:58 +00001900}
bellarda3a91a32004-06-04 11:06:21 +00001901
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001902static void do_ioport_write(Monitor *mon, const QDict *qdict)
Jan Kiszkaf1147842009-07-14 10:20:11 +02001903{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03001904 int size = qdict_get_int(qdict, "size");
1905 int addr = qdict_get_int(qdict, "addr");
1906 int val = qdict_get_int(qdict, "val");
1907
Jan Kiszkaf1147842009-07-14 10:20:11 +02001908 addr &= IOPORTS_MASK;
1909
1910 switch (size) {
1911 default:
1912 case 1:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001913 cpu_outb(addr, val);
Jan Kiszkaf1147842009-07-14 10:20:11 +02001914 break;
1915 case 2:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001916 cpu_outw(addr, val);
Jan Kiszkaf1147842009-07-14 10:20:11 +02001917 break;
1918 case 4:
Blue Swirlafcea8c2009-09-20 16:05:47 +00001919 cpu_outl(addr, val);
Jan Kiszkaf1147842009-07-14 10:20:11 +02001920 break;
1921 }
1922}
1923
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001924static void do_boot_set(Monitor *mon, const QDict *qdict)
aurel320ecdffb2008-05-04 20:11:34 +00001925{
1926 int res;
Luiz Capitulinod54908a2009-08-28 15:27:13 -03001927 const char *bootdevice = qdict_get_str(qdict, "bootdevice");
aurel320ecdffb2008-05-04 20:11:34 +00001928
Jan Kiszka76e30d02009-07-02 00:19:02 +02001929 res = qemu_boot_set(bootdevice);
1930 if (res == 0) {
1931 monitor_printf(mon, "boot device list now set to %s\n", bootdevice);
1932 } else if (res > 0) {
1933 monitor_printf(mon, "setting boot device list failed\n");
aurel320ecdffb2008-05-04 20:11:34 +00001934 } else {
aliguori376253e2009-03-05 23:01:23 +00001935 monitor_printf(mon, "no function defined to set boot device list for "
1936 "this architecture\n");
aurel320ecdffb2008-05-04 20:11:34 +00001937 }
1938}
1939
Luiz Capitulinoc80d2592009-10-07 13:41:58 -03001940/**
1941 * do_system_reset(): Issue a machine reset
1942 */
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -02001943static int do_system_reset(Monitor *mon, const QDict *qdict,
1944 QObject **ret_data)
bellarde4f90822004-06-20 12:35:44 +00001945{
1946 qemu_system_reset_request();
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -02001947 return 0;
bellarde4f90822004-06-20 12:35:44 +00001948}
1949
Luiz Capitulino43076662009-10-07 13:41:59 -03001950/**
1951 * do_system_powerdown(): Issue a machine powerdown
1952 */
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -02001953static int do_system_powerdown(Monitor *mon, const QDict *qdict,
1954 QObject **ret_data)
bellard34751872005-07-02 14:31:34 +00001955{
1956 qemu_system_powerdown_request();
Luiz Capitulinoef4b7ee2010-02-10 23:49:48 -02001957 return 0;
bellard34751872005-07-02 14:31:34 +00001958}
1959
bellardb86bda52004-09-18 19:32:46 +00001960#if defined(TARGET_I386)
aliguori376253e2009-03-05 23:01:23 +00001961static void print_pte(Monitor *mon, uint32_t addr, uint32_t pte, uint32_t mask)
bellardb86bda52004-09-18 19:32:46 +00001962{
aliguori376253e2009-03-05 23:01:23 +00001963 monitor_printf(mon, "%08x: %08x %c%c%c%c%c%c%c%c\n",
1964 addr,
1965 pte & mask,
1966 pte & PG_GLOBAL_MASK ? 'G' : '-',
1967 pte & PG_PSE_MASK ? 'P' : '-',
1968 pte & PG_DIRTY_MASK ? 'D' : '-',
1969 pte & PG_ACCESSED_MASK ? 'A' : '-',
1970 pte & PG_PCD_MASK ? 'C' : '-',
1971 pte & PG_PWT_MASK ? 'T' : '-',
1972 pte & PG_USER_MASK ? 'U' : '-',
1973 pte & PG_RW_MASK ? 'W' : '-');
bellardb86bda52004-09-18 19:32:46 +00001974}
1975
aliguori376253e2009-03-05 23:01:23 +00001976static void tlb_info(Monitor *mon)
bellardb86bda52004-09-18 19:32:46 +00001977{
bellard6a00d602005-11-21 23:25:50 +00001978 CPUState *env;
bellardb86bda52004-09-18 19:32:46 +00001979 int l1, l2;
1980 uint32_t pgd, pde, pte;
1981
bellard6a00d602005-11-21 23:25:50 +00001982 env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00001983
bellardb86bda52004-09-18 19:32:46 +00001984 if (!(env->cr[0] & CR0_PG_MASK)) {
aliguori376253e2009-03-05 23:01:23 +00001985 monitor_printf(mon, "PG disabled\n");
bellardb86bda52004-09-18 19:32:46 +00001986 return;
1987 }
1988 pgd = env->cr[3] & ~0xfff;
1989 for(l1 = 0; l1 < 1024; l1++) {
1990 cpu_physical_memory_read(pgd + l1 * 4, (uint8_t *)&pde, 4);
1991 pde = le32_to_cpu(pde);
1992 if (pde & PG_PRESENT_MASK) {
1993 if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
aliguori376253e2009-03-05 23:01:23 +00001994 print_pte(mon, (l1 << 22), pde, ~((1 << 20) - 1));
bellardb86bda52004-09-18 19:32:46 +00001995 } else {
1996 for(l2 = 0; l2 < 1024; l2++) {
ths5fafdf22007-09-16 21:08:06 +00001997 cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
bellardb86bda52004-09-18 19:32:46 +00001998 (uint8_t *)&pte, 4);
1999 pte = le32_to_cpu(pte);
2000 if (pte & PG_PRESENT_MASK) {
aliguori376253e2009-03-05 23:01:23 +00002001 print_pte(mon, (l1 << 22) + (l2 << 12),
ths5fafdf22007-09-16 21:08:06 +00002002 pte & ~PG_PSE_MASK,
bellardb86bda52004-09-18 19:32:46 +00002003 ~0xfff);
2004 }
2005 }
2006 }
2007 }
2008 }
2009}
2010
aliguori376253e2009-03-05 23:01:23 +00002011static void mem_print(Monitor *mon, uint32_t *pstart, int *plast_prot,
bellardb86bda52004-09-18 19:32:46 +00002012 uint32_t end, int prot)
2013{
bellard9746b152004-11-11 18:30:24 +00002014 int prot1;
2015 prot1 = *plast_prot;
2016 if (prot != prot1) {
bellardb86bda52004-09-18 19:32:46 +00002017 if (*pstart != -1) {
aliguori376253e2009-03-05 23:01:23 +00002018 monitor_printf(mon, "%08x-%08x %08x %c%c%c\n",
2019 *pstart, end, end - *pstart,
2020 prot1 & PG_USER_MASK ? 'u' : '-',
2021 'r',
2022 prot1 & PG_RW_MASK ? 'w' : '-');
bellardb86bda52004-09-18 19:32:46 +00002023 }
2024 if (prot != 0)
2025 *pstart = end;
2026 else
2027 *pstart = -1;
2028 *plast_prot = prot;
2029 }
2030}
2031
aliguori376253e2009-03-05 23:01:23 +00002032static void mem_info(Monitor *mon)
bellardb86bda52004-09-18 19:32:46 +00002033{
bellard6a00d602005-11-21 23:25:50 +00002034 CPUState *env;
bellardb86bda52004-09-18 19:32:46 +00002035 int l1, l2, prot, last_prot;
2036 uint32_t pgd, pde, pte, start, end;
2037
bellard6a00d602005-11-21 23:25:50 +00002038 env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00002039
bellardb86bda52004-09-18 19:32:46 +00002040 if (!(env->cr[0] & CR0_PG_MASK)) {
aliguori376253e2009-03-05 23:01:23 +00002041 monitor_printf(mon, "PG disabled\n");
bellardb86bda52004-09-18 19:32:46 +00002042 return;
2043 }
2044 pgd = env->cr[3] & ~0xfff;
2045 last_prot = 0;
2046 start = -1;
2047 for(l1 = 0; l1 < 1024; l1++) {
2048 cpu_physical_memory_read(pgd + l1 * 4, (uint8_t *)&pde, 4);
2049 pde = le32_to_cpu(pde);
2050 end = l1 << 22;
2051 if (pde & PG_PRESENT_MASK) {
2052 if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
2053 prot = pde & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
aliguori376253e2009-03-05 23:01:23 +00002054 mem_print(mon, &start, &last_prot, end, prot);
bellardb86bda52004-09-18 19:32:46 +00002055 } else {
2056 for(l2 = 0; l2 < 1024; l2++) {
ths5fafdf22007-09-16 21:08:06 +00002057 cpu_physical_memory_read((pde & ~0xfff) + l2 * 4,
bellardb86bda52004-09-18 19:32:46 +00002058 (uint8_t *)&pte, 4);
2059 pte = le32_to_cpu(pte);
2060 end = (l1 << 22) + (l2 << 12);
2061 if (pte & PG_PRESENT_MASK) {
2062 prot = pte & (PG_USER_MASK | PG_RW_MASK | PG_PRESENT_MASK);
2063 } else {
2064 prot = 0;
2065 }
aliguori376253e2009-03-05 23:01:23 +00002066 mem_print(mon, &start, &last_prot, end, prot);
bellardb86bda52004-09-18 19:32:46 +00002067 }
2068 }
2069 } else {
2070 prot = 0;
aliguori376253e2009-03-05 23:01:23 +00002071 mem_print(mon, &start, &last_prot, end, prot);
bellardb86bda52004-09-18 19:32:46 +00002072 }
2073 }
2074}
2075#endif
2076
aurel327c664e22009-03-03 06:12:22 +00002077#if defined(TARGET_SH4)
2078
aliguori376253e2009-03-05 23:01:23 +00002079static void print_tlb(Monitor *mon, int idx, tlb_t *tlb)
aurel327c664e22009-03-03 06:12:22 +00002080{
aliguori376253e2009-03-05 23:01:23 +00002081 monitor_printf(mon, " tlb%i:\t"
2082 "asid=%hhu vpn=%x\tppn=%x\tsz=%hhu size=%u\t"
2083 "v=%hhu shared=%hhu cached=%hhu prot=%hhu "
2084 "dirty=%hhu writethrough=%hhu\n",
2085 idx,
2086 tlb->asid, tlb->vpn, tlb->ppn, tlb->sz, tlb->size,
2087 tlb->v, tlb->sh, tlb->c, tlb->pr,
2088 tlb->d, tlb->wt);
aurel327c664e22009-03-03 06:12:22 +00002089}
2090
aliguori376253e2009-03-05 23:01:23 +00002091static void tlb_info(Monitor *mon)
aurel327c664e22009-03-03 06:12:22 +00002092{
2093 CPUState *env = mon_get_cpu();
2094 int i;
2095
aliguori376253e2009-03-05 23:01:23 +00002096 monitor_printf (mon, "ITLB:\n");
aurel327c664e22009-03-03 06:12:22 +00002097 for (i = 0 ; i < ITLB_SIZE ; i++)
aliguori376253e2009-03-05 23:01:23 +00002098 print_tlb (mon, i, &env->itlb[i]);
2099 monitor_printf (mon, "UTLB:\n");
aurel327c664e22009-03-03 06:12:22 +00002100 for (i = 0 ; i < UTLB_SIZE ; i++)
aliguori376253e2009-03-05 23:01:23 +00002101 print_tlb (mon, i, &env->utlb[i]);
aurel327c664e22009-03-03 06:12:22 +00002102}
2103
2104#endif
2105
Luiz Capitulino2af5ba72009-12-10 17:16:00 -02002106static void do_info_kvm_print(Monitor *mon, const QObject *data)
2107{
2108 QDict *qdict;
2109
2110 qdict = qobject_to_qdict(data);
2111
2112 monitor_printf(mon, "kvm support: ");
2113 if (qdict_get_bool(qdict, "present")) {
2114 monitor_printf(mon, "%s\n", qdict_get_bool(qdict, "enabled") ?
2115 "enabled" : "disabled");
2116 } else {
2117 monitor_printf(mon, "not compiled\n");
2118 }
2119}
2120
Luiz Capitulino2af5ba72009-12-10 17:16:00 -02002121static void do_info_kvm(Monitor *mon, QObject **ret_data)
aliguori7ba1e612008-11-05 16:04:33 +00002122{
2123#ifdef CONFIG_KVM
Luiz Capitulino2af5ba72009-12-10 17:16:00 -02002124 *ret_data = qobject_from_jsonf("{ 'enabled': %i, 'present': true }",
2125 kvm_enabled());
aliguori7ba1e612008-11-05 16:04:33 +00002126#else
Luiz Capitulino2af5ba72009-12-10 17:16:00 -02002127 *ret_data = qobject_from_jsonf("{ 'enabled': false, 'present': false }");
aliguori7ba1e612008-11-05 16:04:33 +00002128#endif
2129}
2130
aliguori030ea372009-04-21 22:30:47 +00002131static void do_info_numa(Monitor *mon)
2132{
aliguorib28b6232009-04-22 20:20:29 +00002133 int i;
aliguori030ea372009-04-21 22:30:47 +00002134 CPUState *env;
2135
2136 monitor_printf(mon, "%d nodes\n", nb_numa_nodes);
2137 for (i = 0; i < nb_numa_nodes; i++) {
2138 monitor_printf(mon, "node %d cpus:", i);
2139 for (env = first_cpu; env != NULL; env = env->next_cpu) {
2140 if (env->numa_node == i) {
2141 monitor_printf(mon, " %d", env->cpu_index);
2142 }
2143 }
2144 monitor_printf(mon, "\n");
2145 monitor_printf(mon, "node %d size: %" PRId64 " MB\n", i,
2146 node_mem[i] >> 20);
2147 }
2148}
2149
bellard5f1ce942006-02-08 22:40:15 +00002150#ifdef CONFIG_PROFILER
2151
Aurelien Jarnoe9a66252009-09-30 14:09:52 +02002152int64_t qemu_time;
2153int64_t dev_time;
2154
aliguori376253e2009-03-05 23:01:23 +00002155static void do_info_profile(Monitor *mon)
bellard5f1ce942006-02-08 22:40:15 +00002156{
2157 int64_t total;
2158 total = qemu_time;
2159 if (total == 0)
2160 total = 1;
aliguori376253e2009-03-05 23:01:23 +00002161 monitor_printf(mon, "async time %" PRId64 " (%0.3f)\n",
Juan Quintela6ee093c2009-09-10 03:04:26 +02002162 dev_time, dev_time / (double)get_ticks_per_sec());
aliguori376253e2009-03-05 23:01:23 +00002163 monitor_printf(mon, "qemu time %" PRId64 " (%0.3f)\n",
Juan Quintela6ee093c2009-09-10 03:04:26 +02002164 qemu_time, qemu_time / (double)get_ticks_per_sec());
bellard5f1ce942006-02-08 22:40:15 +00002165 qemu_time = 0;
bellard5f1ce942006-02-08 22:40:15 +00002166 dev_time = 0;
bellard5f1ce942006-02-08 22:40:15 +00002167}
2168#else
aliguori376253e2009-03-05 23:01:23 +00002169static void do_info_profile(Monitor *mon)
bellard5f1ce942006-02-08 22:40:15 +00002170{
aliguori376253e2009-03-05 23:01:23 +00002171 monitor_printf(mon, "Internal profiler not compiled\n");
bellard5f1ce942006-02-08 22:40:15 +00002172}
2173#endif
2174
bellardec36b692006-07-16 18:57:03 +00002175/* Capture support */
Blue Swirl72cf2d42009-09-12 07:36:22 +00002176static QLIST_HEAD (capture_list_head, CaptureState) capture_head;
bellardec36b692006-07-16 18:57:03 +00002177
aliguori376253e2009-03-05 23:01:23 +00002178static void do_info_capture(Monitor *mon)
bellardec36b692006-07-16 18:57:03 +00002179{
2180 int i;
2181 CaptureState *s;
2182
2183 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
aliguori376253e2009-03-05 23:01:23 +00002184 monitor_printf(mon, "[%d]: ", i);
bellardec36b692006-07-16 18:57:03 +00002185 s->ops.info (s->opaque);
2186 }
2187}
2188
Blue Swirl23130862009-06-06 08:22:04 +00002189#ifdef HAS_AUDIO
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002190static void do_stop_capture(Monitor *mon, const QDict *qdict)
bellardec36b692006-07-16 18:57:03 +00002191{
2192 int i;
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002193 int n = qdict_get_int(qdict, "n");
bellardec36b692006-07-16 18:57:03 +00002194 CaptureState *s;
2195
2196 for (s = capture_head.lh_first, i = 0; s; s = s->entries.le_next, ++i) {
2197 if (i == n) {
2198 s->ops.destroy (s->opaque);
Blue Swirl72cf2d42009-09-12 07:36:22 +00002199 QLIST_REMOVE (s, entries);
bellardec36b692006-07-16 18:57:03 +00002200 qemu_free (s);
2201 return;
2202 }
2203 }
2204}
2205
Luiz Capitulinoc1925482009-08-28 15:27:19 -03002206static void do_wav_capture(Monitor *mon, const QDict *qdict)
bellardec36b692006-07-16 18:57:03 +00002207{
Luiz Capitulinoc1925482009-08-28 15:27:19 -03002208 const char *path = qdict_get_str(qdict, "path");
2209 int has_freq = qdict_haskey(qdict, "freq");
2210 int freq = qdict_get_try_int(qdict, "freq", -1);
2211 int has_bits = qdict_haskey(qdict, "bits");
2212 int bits = qdict_get_try_int(qdict, "bits", -1);
2213 int has_channels = qdict_haskey(qdict, "nchannels");
2214 int nchannels = qdict_get_try_int(qdict, "nchannels", -1);
bellardec36b692006-07-16 18:57:03 +00002215 CaptureState *s;
2216
2217 s = qemu_mallocz (sizeof (*s));
bellardec36b692006-07-16 18:57:03 +00002218
2219 freq = has_freq ? freq : 44100;
2220 bits = has_bits ? bits : 16;
2221 nchannels = has_channels ? nchannels : 2;
2222
2223 if (wav_start_capture (s, path, freq, bits, nchannels)) {
aliguori376253e2009-03-05 23:01:23 +00002224 monitor_printf(mon, "Faied to add wave capture\n");
bellardec36b692006-07-16 18:57:03 +00002225 qemu_free (s);
2226 }
Blue Swirl72cf2d42009-09-12 07:36:22 +00002227 QLIST_INSERT_HEAD (&capture_head, s, entries);
bellardec36b692006-07-16 18:57:03 +00002228}
2229#endif
2230
aurel32dc1c0b72008-04-27 23:52:12 +00002231#if defined(TARGET_I386)
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002232static void do_inject_nmi(Monitor *mon, const QDict *qdict)
aurel32dc1c0b72008-04-27 23:52:12 +00002233{
2234 CPUState *env;
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002235 int cpu_index = qdict_get_int(qdict, "cpu_index");
aurel32dc1c0b72008-04-27 23:52:12 +00002236
2237 for (env = first_cpu; env != NULL; env = env->next_cpu)
2238 if (env->cpu_index == cpu_index) {
2239 cpu_interrupt(env, CPU_INTERRUPT_NMI);
2240 break;
2241 }
2242}
2243#endif
2244
Luiz Capitulinoc0e85202009-12-10 17:15:59 -02002245static void do_info_status_print(Monitor *mon, const QObject *data)
aurel326f9c5ee2008-12-18 22:43:56 +00002246{
Luiz Capitulinoc0e85202009-12-10 17:15:59 -02002247 QDict *qdict;
2248
2249 qdict = qobject_to_qdict(data);
2250
2251 monitor_printf(mon, "VM status: ");
2252 if (qdict_get_bool(qdict, "running")) {
2253 monitor_printf(mon, "running");
2254 if (qdict_get_bool(qdict, "singlestep")) {
2255 monitor_printf(mon, " (single step mode)");
aurel321b530a62009-04-05 20:08:59 +00002256 }
Luiz Capitulinoc0e85202009-12-10 17:15:59 -02002257 } else {
2258 monitor_printf(mon, "paused");
2259 }
2260
2261 monitor_printf(mon, "\n");
2262}
2263
Luiz Capitulinoc0e85202009-12-10 17:15:59 -02002264static void do_info_status(Monitor *mon, QObject **ret_data)
2265{
2266 *ret_data = qobject_from_jsonf("{ 'running': %i, 'singlestep': %i }",
2267 vm_running, singlestep);
aurel326f9c5ee2008-12-18 22:43:56 +00002268}
2269
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002270static qemu_acl *find_acl(Monitor *mon, const char *name)
aliguori76655d62009-03-06 20:27:37 +00002271{
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002272 qemu_acl *acl = qemu_acl_find(name);
aliguori76655d62009-03-06 20:27:37 +00002273
aliguori76655d62009-03-06 20:27:37 +00002274 if (!acl) {
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002275 monitor_printf(mon, "acl: unknown list '%s'\n", name);
aliguori76655d62009-03-06 20:27:37 +00002276 }
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002277 return acl;
2278}
aliguori76655d62009-03-06 20:27:37 +00002279
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002280static void do_acl_show(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002281{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002282 const char *aclname = qdict_get_str(qdict, "aclname");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002283 qemu_acl *acl = find_acl(mon, aclname);
2284 qemu_acl_entry *entry;
2285 int i = 0;
2286
2287 if (acl) {
aliguori28a76be2009-03-06 20:27:40 +00002288 monitor_printf(mon, "policy: %s\n",
aliguori76655d62009-03-06 20:27:37 +00002289 acl->defaultDeny ? "deny" : "allow");
Blue Swirl72cf2d42009-09-12 07:36:22 +00002290 QTAILQ_FOREACH(entry, &acl->entries, next) {
aliguori28a76be2009-03-06 20:27:40 +00002291 i++;
2292 monitor_printf(mon, "%d: %s %s\n", i,
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002293 entry->deny ? "deny" : "allow", entry->match);
aliguori28a76be2009-03-06 20:27:40 +00002294 }
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002295 }
2296}
2297
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002298static void do_acl_reset(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002299{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002300 const char *aclname = qdict_get_str(qdict, "aclname");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002301 qemu_acl *acl = find_acl(mon, aclname);
2302
2303 if (acl) {
aliguori28a76be2009-03-06 20:27:40 +00002304 qemu_acl_reset(acl);
2305 monitor_printf(mon, "acl: removed all rules\n");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002306 }
2307}
aliguori76655d62009-03-06 20:27:37 +00002308
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03002309static void do_acl_policy(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002310{
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03002311 const char *aclname = qdict_get_str(qdict, "aclname");
2312 const char *policy = qdict_get_str(qdict, "policy");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002313 qemu_acl *acl = find_acl(mon, aclname);
2314
2315 if (acl) {
2316 if (strcmp(policy, "allow") == 0) {
aliguori28a76be2009-03-06 20:27:40 +00002317 acl->defaultDeny = 0;
2318 monitor_printf(mon, "acl: policy set to 'allow'\n");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002319 } else if (strcmp(policy, "deny") == 0) {
aliguori28a76be2009-03-06 20:27:40 +00002320 acl->defaultDeny = 1;
2321 monitor_printf(mon, "acl: policy set to 'deny'\n");
2322 } else {
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002323 monitor_printf(mon, "acl: unknown policy '%s', "
2324 "expected 'deny' or 'allow'\n", policy);
aliguori28a76be2009-03-06 20:27:40 +00002325 }
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002326 }
2327}
aliguori76655d62009-03-06 20:27:37 +00002328
Luiz Capitulino1bd14422009-08-28 15:27:17 -03002329static void do_acl_add(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002330{
Luiz Capitulino1bd14422009-08-28 15:27:17 -03002331 const char *aclname = qdict_get_str(qdict, "aclname");
2332 const char *match = qdict_get_str(qdict, "match");
2333 const char *policy = qdict_get_str(qdict, "policy");
2334 int has_index = qdict_haskey(qdict, "index");
2335 int index = qdict_get_try_int(qdict, "index", -1);
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002336 qemu_acl *acl = find_acl(mon, aclname);
2337 int deny, ret;
2338
2339 if (acl) {
2340 if (strcmp(policy, "allow") == 0) {
2341 deny = 0;
2342 } else if (strcmp(policy, "deny") == 0) {
2343 deny = 1;
2344 } else {
2345 monitor_printf(mon, "acl: unknown policy '%s', "
2346 "expected 'deny' or 'allow'\n", policy);
aliguori28a76be2009-03-06 20:27:40 +00002347 return;
2348 }
aliguori28a76be2009-03-06 20:27:40 +00002349 if (has_index)
2350 ret = qemu_acl_insert(acl, deny, match, index);
2351 else
2352 ret = qemu_acl_append(acl, deny, match);
2353 if (ret < 0)
2354 monitor_printf(mon, "acl: unable to add acl entry\n");
2355 else
2356 monitor_printf(mon, "acl: added rule at position %d\n", ret);
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002357 }
2358}
aliguori76655d62009-03-06 20:27:37 +00002359
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03002360static void do_acl_remove(Monitor *mon, const QDict *qdict)
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002361{
Luiz Capitulinof18c16d2009-08-28 15:27:14 -03002362 const char *aclname = qdict_get_str(qdict, "aclname");
2363 const char *match = qdict_get_str(qdict, "match");
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002364 qemu_acl *acl = find_acl(mon, aclname);
2365 int ret;
aliguori76655d62009-03-06 20:27:37 +00002366
Jan Kiszka15dfcd42009-06-25 08:22:08 +02002367 if (acl) {
aliguori28a76be2009-03-06 20:27:40 +00002368 ret = qemu_acl_remove(acl, match);
2369 if (ret < 0)
2370 monitor_printf(mon, "acl: no matching acl entry\n");
2371 else
2372 monitor_printf(mon, "acl: removed rule at position %d\n", ret);
aliguori76655d62009-03-06 20:27:37 +00002373 }
2374}
2375
Huang Ying79c4f6b2009-06-23 10:05:14 +08002376#if defined(TARGET_I386)
Luiz Capitulino37b7ad42009-08-28 15:27:21 -03002377static void do_inject_mce(Monitor *mon, const QDict *qdict)
Huang Ying79c4f6b2009-06-23 10:05:14 +08002378{
2379 CPUState *cenv;
Luiz Capitulino37b7ad42009-08-28 15:27:21 -03002380 int cpu_index = qdict_get_int(qdict, "cpu_index");
2381 int bank = qdict_get_int(qdict, "bank");
2382 uint64_t status = qdict_get_int(qdict, "status");
2383 uint64_t mcg_status = qdict_get_int(qdict, "mcg_status");
2384 uint64_t addr = qdict_get_int(qdict, "addr");
2385 uint64_t misc = qdict_get_int(qdict, "misc");
Huang Ying79c4f6b2009-06-23 10:05:14 +08002386
2387 for (cenv = first_cpu; cenv != NULL; cenv = cenv->next_cpu)
2388 if (cenv->cpu_index == cpu_index && cenv->mcg_cap) {
2389 cpu_inject_x86_mce(cenv, bank, status, mcg_status, addr, misc);
2390 break;
2391 }
2392}
2393#endif
2394
Luiz Capitulino6ad3ebd2010-02-10 23:49:53 -02002395static int do_getfd(Monitor *mon, const QDict *qdict, QObject **ret_data)
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002396{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002397 const char *fdname = qdict_get_str(qdict, "fdname");
Anthony Liguoric227f092009-10-01 16:12:16 -05002398 mon_fd_t *monfd;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002399 int fd;
2400
2401 fd = qemu_chr_get_msgfd(mon->chr);
2402 if (fd == -1) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01002403 qerror_report(QERR_FD_NOT_SUPPLIED);
Luiz Capitulino6ad3ebd2010-02-10 23:49:53 -02002404 return -1;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002405 }
2406
2407 if (qemu_isdigit(fdname[0])) {
Markus Armbrustere17ba872010-03-25 17:22:36 +01002408 qerror_report(QERR_INVALID_PARAMETER_VALUE, "fdname",
2409 "a name not starting with a digit");
Luiz Capitulino6ad3ebd2010-02-10 23:49:53 -02002410 return -1;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002411 }
2412
Blue Swirl72cf2d42009-09-12 07:36:22 +00002413 QLIST_FOREACH(monfd, &mon->fds, next) {
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002414 if (strcmp(monfd->name, fdname) != 0) {
2415 continue;
2416 }
2417
2418 close(monfd->fd);
2419 monfd->fd = fd;
Luiz Capitulino6ad3ebd2010-02-10 23:49:53 -02002420 return 0;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002421 }
2422
Anthony Liguoric227f092009-10-01 16:12:16 -05002423 monfd = qemu_mallocz(sizeof(mon_fd_t));
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002424 monfd->name = qemu_strdup(fdname);
2425 monfd->fd = fd;
2426
Blue Swirl72cf2d42009-09-12 07:36:22 +00002427 QLIST_INSERT_HEAD(&mon->fds, monfd, next);
Luiz Capitulino6ad3ebd2010-02-10 23:49:53 -02002428 return 0;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002429}
2430
Luiz Capitulinoaeb91c12010-02-10 23:49:54 -02002431static int do_closefd(Monitor *mon, const QDict *qdict, QObject **ret_data)
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002432{
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002433 const char *fdname = qdict_get_str(qdict, "fdname");
Anthony Liguoric227f092009-10-01 16:12:16 -05002434 mon_fd_t *monfd;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002435
Blue Swirl72cf2d42009-09-12 07:36:22 +00002436 QLIST_FOREACH(monfd, &mon->fds, next) {
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002437 if (strcmp(monfd->name, fdname) != 0) {
2438 continue;
2439 }
2440
Blue Swirl72cf2d42009-09-12 07:36:22 +00002441 QLIST_REMOVE(monfd, next);
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002442 close(monfd->fd);
2443 qemu_free(monfd->name);
2444 qemu_free(monfd);
Luiz Capitulinoaeb91c12010-02-10 23:49:54 -02002445 return 0;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002446 }
2447
Markus Armbrusterab5b0272010-03-02 18:15:09 +01002448 qerror_report(QERR_FD_NOT_FOUND, fdname);
Luiz Capitulinoaeb91c12010-02-10 23:49:54 -02002449 return -1;
Mark McLoughlinf07918f2009-07-22 09:11:40 +01002450}
2451
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002452static void do_loadvm(Monitor *mon, const QDict *qdict)
Juan Quintelac8d41b22009-08-20 19:42:21 +02002453{
2454 int saved_vm_running = vm_running;
Luiz Capitulinod54908a2009-08-28 15:27:13 -03002455 const char *name = qdict_get_str(qdict, "name");
Juan Quintelac8d41b22009-08-20 19:42:21 +02002456
2457 vm_stop(0);
2458
Miguel Di Ciurcio Filhof0aa7a82010-07-19 15:25:01 -03002459 if (load_vmstate(name) == 0 && saved_vm_running) {
Juan Quintelac8d41b22009-08-20 19:42:21 +02002460 vm_start();
Miguel Di Ciurcio Filhof0aa7a82010-07-19 15:25:01 -03002461 }
Juan Quintelac8d41b22009-08-20 19:42:21 +02002462}
2463
Mark McLoughlin7768e042009-07-22 09:11:41 +01002464int monitor_get_fd(Monitor *mon, const char *fdname)
2465{
Anthony Liguoric227f092009-10-01 16:12:16 -05002466 mon_fd_t *monfd;
Mark McLoughlin7768e042009-07-22 09:11:41 +01002467
Blue Swirl72cf2d42009-09-12 07:36:22 +00002468 QLIST_FOREACH(monfd, &mon->fds, next) {
Mark McLoughlin7768e042009-07-22 09:11:41 +01002469 int fd;
2470
2471 if (strcmp(monfd->name, fdname) != 0) {
2472 continue;
2473 }
2474
2475 fd = monfd->fd;
2476
2477 /* caller takes ownership of fd */
Blue Swirl72cf2d42009-09-12 07:36:22 +00002478 QLIST_REMOVE(monfd, next);
Mark McLoughlin7768e042009-07-22 09:11:41 +01002479 qemu_free(monfd->name);
2480 qemu_free(monfd);
2481
2482 return fd;
2483 }
2484
2485 return -1;
2486}
2487
Anthony Liguoric227f092009-10-01 16:12:16 -05002488static const mon_cmd_t mon_cmds[] = {
Luiz Capitulinoacd0a092010-09-30 16:00:22 -03002489#include "hmp-commands.h"
ths5fafdf22007-09-16 21:08:06 +00002490 { NULL, NULL, },
bellard9dc39cb2004-03-14 21:38:27 +00002491};
2492
Luiz Capitulinoacd0a092010-09-30 16:00:22 -03002493/* Please update hmp-commands.hx when adding or changing commands */
Anthony Liguoric227f092009-10-01 16:12:16 -05002494static const mon_cmd_t info_cmds[] = {
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002495 {
2496 .name = "version",
2497 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002498 .params = "",
2499 .help = "show the version of QEMU",
Luiz Capitulino45e914c2009-12-10 17:15:58 -02002500 .user_print = do_info_version_print,
Luiz Capitulinoab2d3182009-10-07 13:42:02 -03002501 .mhandler.info_new = do_info_version,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002502 },
2503 {
2504 .name = "network",
2505 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002506 .params = "",
2507 .help = "show the network state",
Luiz Capitulino910df892009-10-07 13:41:51 -03002508 .mhandler.info = do_info_network,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002509 },
2510 {
2511 .name = "chardev",
2512 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002513 .params = "",
2514 .help = "show the character devices",
Luiz Capitulino588b3832009-12-10 17:16:08 -02002515 .user_print = qemu_chr_info_print,
2516 .mhandler.info_new = qemu_chr_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002517 },
2518 {
2519 .name = "block",
2520 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002521 .params = "",
2522 .help = "show the block devices",
Luiz Capitulinod15e5462009-12-10 17:16:06 -02002523 .user_print = bdrv_info_print,
2524 .mhandler.info_new = bdrv_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002525 },
2526 {
2527 .name = "blockstats",
2528 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002529 .params = "",
2530 .help = "show block device statistics",
Luiz Capitulino218a5362009-12-10 17:16:07 -02002531 .user_print = bdrv_stats_print,
2532 .mhandler.info_new = bdrv_info_stats,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002533 },
2534 {
2535 .name = "registers",
2536 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002537 .params = "",
2538 .help = "show the cpu registers",
Luiz Capitulino910df892009-10-07 13:41:51 -03002539 .mhandler.info = do_info_registers,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002540 },
2541 {
2542 .name = "cpus",
2543 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002544 .params = "",
2545 .help = "show infos for each CPU",
Luiz Capitulino8f3cec02009-10-07 13:42:04 -03002546 .user_print = monitor_print_cpus,
2547 .mhandler.info_new = do_info_cpus,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002548 },
2549 {
2550 .name = "history",
2551 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002552 .params = "",
2553 .help = "show the command line history",
Luiz Capitulino910df892009-10-07 13:41:51 -03002554 .mhandler.info = do_info_history,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002555 },
2556 {
2557 .name = "irq",
2558 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002559 .params = "",
2560 .help = "show the interrupts statistics (if available)",
Luiz Capitulino910df892009-10-07 13:41:51 -03002561 .mhandler.info = irq_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002562 },
2563 {
2564 .name = "pic",
2565 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002566 .params = "",
2567 .help = "show i8259 (PIC) state",
Luiz Capitulino910df892009-10-07 13:41:51 -03002568 .mhandler.info = pic_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002569 },
2570 {
2571 .name = "pci",
2572 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002573 .params = "",
2574 .help = "show PCI info",
Luiz Capitulino163c8a52010-01-21 19:15:40 -02002575 .user_print = do_pci_info_print,
2576 .mhandler.info_new = do_pci_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002577 },
aurel327c664e22009-03-03 06:12:22 +00002578#if defined(TARGET_I386) || defined(TARGET_SH4)
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002579 {
2580 .name = "tlb",
2581 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002582 .params = "",
2583 .help = "show virtual to physical memory mappings",
Luiz Capitulino910df892009-10-07 13:41:51 -03002584 .mhandler.info = tlb_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002585 },
aurel327c664e22009-03-03 06:12:22 +00002586#endif
2587#if defined(TARGET_I386)
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002588 {
2589 .name = "mem",
2590 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002591 .params = "",
2592 .help = "show the active virtual memory mappings",
Luiz Capitulino910df892009-10-07 13:41:51 -03002593 .mhandler.info = mem_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002594 },
bellardb86bda52004-09-18 19:32:46 +00002595#endif
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002596 {
2597 .name = "jit",
2598 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002599 .params = "",
2600 .help = "show dynamic compiler info",
Luiz Capitulino910df892009-10-07 13:41:51 -03002601 .mhandler.info = do_info_jit,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002602 },
2603 {
2604 .name = "kvm",
2605 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002606 .params = "",
2607 .help = "show KVM information",
Luiz Capitulino2af5ba72009-12-10 17:16:00 -02002608 .user_print = do_info_kvm_print,
2609 .mhandler.info_new = do_info_kvm,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002610 },
2611 {
2612 .name = "numa",
2613 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002614 .params = "",
2615 .help = "show NUMA information",
Luiz Capitulino910df892009-10-07 13:41:51 -03002616 .mhandler.info = do_info_numa,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002617 },
2618 {
2619 .name = "usb",
2620 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002621 .params = "",
2622 .help = "show guest USB devices",
Luiz Capitulino910df892009-10-07 13:41:51 -03002623 .mhandler.info = usb_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002624 },
2625 {
2626 .name = "usbhost",
2627 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002628 .params = "",
2629 .help = "show host USB devices",
Luiz Capitulino910df892009-10-07 13:41:51 -03002630 .mhandler.info = usb_host_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002631 },
2632 {
2633 .name = "profile",
2634 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002635 .params = "",
2636 .help = "show profiling information",
Luiz Capitulino910df892009-10-07 13:41:51 -03002637 .mhandler.info = do_info_profile,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002638 },
2639 {
2640 .name = "capture",
2641 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002642 .params = "",
2643 .help = "show capture information",
Luiz Capitulino910df892009-10-07 13:41:51 -03002644 .mhandler.info = do_info_capture,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002645 },
2646 {
2647 .name = "snapshots",
2648 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002649 .params = "",
2650 .help = "show the currently saved VM snapshots",
Luiz Capitulino910df892009-10-07 13:41:51 -03002651 .mhandler.info = do_info_snapshots,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002652 },
2653 {
2654 .name = "status",
2655 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002656 .params = "",
2657 .help = "show the current VM status (running|paused)",
Luiz Capitulinoc0e85202009-12-10 17:15:59 -02002658 .user_print = do_info_status_print,
2659 .mhandler.info_new = do_info_status,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002660 },
2661 {
2662 .name = "pcmcia",
2663 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002664 .params = "",
2665 .help = "show guest PCMCIA status",
Luiz Capitulino910df892009-10-07 13:41:51 -03002666 .mhandler.info = pcmcia_info,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002667 },
2668 {
2669 .name = "mice",
2670 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002671 .params = "",
2672 .help = "show which guest mouse is receiving events",
Luiz Capitulinoe78c48e2009-12-10 17:16:04 -02002673 .user_print = do_info_mice_print,
2674 .mhandler.info_new = do_info_mice,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002675 },
2676 {
2677 .name = "vnc",
2678 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002679 .params = "",
2680 .help = "show the vnc server status",
Luiz Capitulinod96fd292009-12-10 17:16:10 -02002681 .user_print = do_info_vnc_print,
2682 .mhandler.info_new = do_info_vnc,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002683 },
Gerd Hoffmanncb42a872010-11-30 11:02:51 +01002684#if defined(CONFIG_SPICE)
2685 {
2686 .name = "spice",
2687 .args_type = "",
2688 .params = "",
2689 .help = "show the spice server status",
2690 .user_print = do_info_spice_print,
2691 .mhandler.info_new = do_info_spice,
2692 },
2693#endif
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002694 {
2695 .name = "name",
2696 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002697 .params = "",
2698 .help = "show the current VM name",
Luiz Capitulinoe05486c2009-12-10 17:16:01 -02002699 .user_print = do_info_name_print,
2700 .mhandler.info_new = do_info_name,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002701 },
2702 {
2703 .name = "uuid",
2704 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002705 .params = "",
2706 .help = "show the current VM UUID",
Luiz Capitulino9603ceb2009-12-10 17:16:03 -02002707 .user_print = do_info_uuid_print,
2708 .mhandler.info_new = do_info_uuid,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002709 },
j_mayer76a66252007-03-07 08:32:30 +00002710#if defined(TARGET_PPC)
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002711 {
2712 .name = "cpustats",
2713 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002714 .params = "",
2715 .help = "show CPU statistics",
Luiz Capitulino910df892009-10-07 13:41:51 -03002716 .mhandler.info = do_info_cpu_stats,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002717 },
j_mayer76a66252007-03-07 08:32:30 +00002718#endif
blueswir131a60e22007-10-26 18:42:59 +00002719#if defined(CONFIG_SLIRP)
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002720 {
2721 .name = "usernet",
2722 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002723 .params = "",
2724 .help = "show user network stack connection states",
Luiz Capitulino910df892009-10-07 13:41:51 -03002725 .mhandler.info = do_info_usernet,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002726 },
blueswir131a60e22007-10-26 18:42:59 +00002727#endif
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002728 {
2729 .name = "migrate",
2730 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002731 .params = "",
2732 .help = "show migration status",
Luiz Capitulinoc86a6682009-12-10 17:16:05 -02002733 .user_print = do_info_migrate_print,
2734 .mhandler.info_new = do_info_migrate,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002735 },
2736 {
2737 .name = "balloon",
2738 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002739 .params = "",
2740 .help = "show balloon information",
Luiz Capitulinocc1d9c72009-10-07 13:42:03 -03002741 .user_print = monitor_print_balloon,
Adam Litke625a5be2010-01-26 14:17:35 -06002742 .mhandler.info_async = do_info_balloon,
Jan Kiszka8ac470c2010-06-16 00:38:39 +02002743 .flags = MONITOR_CMD_ASYNC,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002744 },
2745 {
2746 .name = "qtree",
2747 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002748 .params = "",
2749 .help = "show device tree",
Luiz Capitulino910df892009-10-07 13:41:51 -03002750 .mhandler.info = do_info_qtree,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002751 },
2752 {
2753 .name = "qdm",
2754 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002755 .params = "",
2756 .help = "show qdev device model list",
Luiz Capitulino910df892009-10-07 13:41:51 -03002757 .mhandler.info = do_info_qdm,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002758 },
2759 {
2760 .name = "roms",
2761 .args_type = "",
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002762 .params = "",
2763 .help = "show roms",
Luiz Capitulino910df892009-10-07 13:41:51 -03002764 .mhandler.info = do_info_roms,
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002765 },
Prerna Saxena22890ab2010-06-24 17:04:53 +05302766#if defined(CONFIG_SIMPLE_TRACE)
2767 {
2768 .name = "trace",
2769 .args_type = "",
2770 .params = "",
2771 .help = "show current contents of trace buffer",
2772 .mhandler.info = do_info_trace,
2773 },
2774 {
2775 .name = "trace-events",
2776 .args_type = "",
2777 .params = "",
2778 .help = "show available trace-events & their state",
2779 .mhandler.info = do_info_trace_events,
2780 },
2781#endif
Luiz Capitulinod7f9b682009-10-07 13:41:50 -03002782 {
2783 .name = NULL,
2784 },
bellard9dc39cb2004-03-14 21:38:27 +00002785};
2786
Luiz Capitulinof36b4af2010-09-15 17:17:45 -03002787static const mon_cmd_t qmp_cmds[] = {
2788#include "qmp-commands.h"
2789 { /* NULL */ },
2790};
2791
Luiz Capitulino3e12a752010-09-15 17:20:33 -03002792static const mon_cmd_t qmp_query_cmds[] = {
2793 {
2794 .name = "version",
2795 .args_type = "",
2796 .params = "",
2797 .help = "show the version of QEMU",
2798 .user_print = do_info_version_print,
2799 .mhandler.info_new = do_info_version,
2800 },
2801 {
2802 .name = "commands",
2803 .args_type = "",
2804 .params = "",
2805 .help = "list QMP available commands",
2806 .user_print = monitor_user_noop,
2807 .mhandler.info_new = do_info_commands,
2808 },
2809 {
2810 .name = "chardev",
2811 .args_type = "",
2812 .params = "",
2813 .help = "show the character devices",
2814 .user_print = qemu_chr_info_print,
2815 .mhandler.info_new = qemu_chr_info,
2816 },
2817 {
2818 .name = "block",
2819 .args_type = "",
2820 .params = "",
2821 .help = "show the block devices",
2822 .user_print = bdrv_info_print,
2823 .mhandler.info_new = bdrv_info,
2824 },
2825 {
2826 .name = "blockstats",
2827 .args_type = "",
2828 .params = "",
2829 .help = "show block device statistics",
2830 .user_print = bdrv_stats_print,
2831 .mhandler.info_new = bdrv_info_stats,
2832 },
2833 {
2834 .name = "cpus",
2835 .args_type = "",
2836 .params = "",
2837 .help = "show infos for each CPU",
2838 .user_print = monitor_print_cpus,
2839 .mhandler.info_new = do_info_cpus,
2840 },
2841 {
2842 .name = "pci",
2843 .args_type = "",
2844 .params = "",
2845 .help = "show PCI info",
2846 .user_print = do_pci_info_print,
2847 .mhandler.info_new = do_pci_info,
2848 },
2849 {
2850 .name = "kvm",
2851 .args_type = "",
2852 .params = "",
2853 .help = "show KVM information",
2854 .user_print = do_info_kvm_print,
2855 .mhandler.info_new = do_info_kvm,
2856 },
2857 {
2858 .name = "status",
2859 .args_type = "",
2860 .params = "",
2861 .help = "show the current VM status (running|paused)",
2862 .user_print = do_info_status_print,
2863 .mhandler.info_new = do_info_status,
2864 },
2865 {
2866 .name = "mice",
2867 .args_type = "",
2868 .params = "",
2869 .help = "show which guest mouse is receiving events",
2870 .user_print = do_info_mice_print,
2871 .mhandler.info_new = do_info_mice,
2872 },
2873 {
2874 .name = "vnc",
2875 .args_type = "",
2876 .params = "",
2877 .help = "show the vnc server status",
2878 .user_print = do_info_vnc_print,
2879 .mhandler.info_new = do_info_vnc,
2880 },
Gerd Hoffmanncb42a872010-11-30 11:02:51 +01002881#if defined(CONFIG_SPICE)
2882 {
2883 .name = "spice",
2884 .args_type = "",
2885 .params = "",
2886 .help = "show the spice server status",
2887 .user_print = do_info_spice_print,
2888 .mhandler.info_new = do_info_spice,
2889 },
2890#endif
Luiz Capitulino3e12a752010-09-15 17:20:33 -03002891 {
2892 .name = "name",
2893 .args_type = "",
2894 .params = "",
2895 .help = "show the current VM name",
2896 .user_print = do_info_name_print,
2897 .mhandler.info_new = do_info_name,
2898 },
2899 {
2900 .name = "uuid",
2901 .args_type = "",
2902 .params = "",
2903 .help = "show the current VM UUID",
2904 .user_print = do_info_uuid_print,
2905 .mhandler.info_new = do_info_uuid,
2906 },
2907 {
2908 .name = "migrate",
2909 .args_type = "",
2910 .params = "",
2911 .help = "show migration status",
2912 .user_print = do_info_migrate_print,
2913 .mhandler.info_new = do_info_migrate,
2914 },
2915 {
2916 .name = "balloon",
2917 .args_type = "",
2918 .params = "",
2919 .help = "show balloon information",
2920 .user_print = monitor_print_balloon,
2921 .mhandler.info_async = do_info_balloon,
2922 .flags = MONITOR_CMD_ASYNC,
2923 },
2924 { /* NULL */ },
2925};
2926
bellard9307c4c2004-04-04 12:57:25 +00002927/*******************************************************************/
2928
2929static const char *pch;
2930static jmp_buf expr_env;
2931
bellard92a31b12005-02-10 22:00:52 +00002932#define MD_TLONG 0
2933#define MD_I32 1
2934
bellard9307c4c2004-04-04 12:57:25 +00002935typedef struct MonitorDef {
2936 const char *name;
2937 int offset;
blueswir18662d652008-10-02 18:32:44 +00002938 target_long (*get_value)(const struct MonitorDef *md, int val);
bellard92a31b12005-02-10 22:00:52 +00002939 int type;
bellard9307c4c2004-04-04 12:57:25 +00002940} MonitorDef;
2941
bellard57206fd2004-04-25 18:54:52 +00002942#if defined(TARGET_I386)
blueswir18662d652008-10-02 18:32:44 +00002943static target_long monitor_get_pc (const struct MonitorDef *md, int val)
bellard57206fd2004-04-25 18:54:52 +00002944{
bellard6a00d602005-11-21 23:25:50 +00002945 CPUState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00002946 return env->eip + env->segs[R_CS].base;
bellard57206fd2004-04-25 18:54:52 +00002947}
2948#endif
2949
bellarda541f292004-04-12 20:39:29 +00002950#if defined(TARGET_PPC)
blueswir18662d652008-10-02 18:32:44 +00002951static target_long monitor_get_ccr (const struct MonitorDef *md, int val)
bellarda541f292004-04-12 20:39:29 +00002952{
bellard6a00d602005-11-21 23:25:50 +00002953 CPUState *env = mon_get_cpu();
bellarda541f292004-04-12 20:39:29 +00002954 unsigned int u;
2955 int i;
2956
2957 u = 0;
2958 for (i = 0; i < 8; i++)
aliguori28a76be2009-03-06 20:27:40 +00002959 u |= env->crf[i] << (32 - (4 * i));
bellarda541f292004-04-12 20:39:29 +00002960
2961 return u;
2962}
2963
blueswir18662d652008-10-02 18:32:44 +00002964static target_long monitor_get_msr (const struct MonitorDef *md, int val)
bellarda541f292004-04-12 20:39:29 +00002965{
bellard6a00d602005-11-21 23:25:50 +00002966 CPUState *env = mon_get_cpu();
j_mayer0411a972007-10-25 21:35:50 +00002967 return env->msr;
bellarda541f292004-04-12 20:39:29 +00002968}
2969
blueswir18662d652008-10-02 18:32:44 +00002970static target_long monitor_get_xer (const struct MonitorDef *md, int val)
bellarda541f292004-04-12 20:39:29 +00002971{
bellard6a00d602005-11-21 23:25:50 +00002972 CPUState *env = mon_get_cpu();
aurel323d7b4172008-10-21 11:28:46 +00002973 return env->xer;
bellarda541f292004-04-12 20:39:29 +00002974}
bellard9fddaa02004-05-21 12:59:32 +00002975
blueswir18662d652008-10-02 18:32:44 +00002976static target_long monitor_get_decr (const struct MonitorDef *md, int val)
bellard9fddaa02004-05-21 12:59:32 +00002977{
bellard6a00d602005-11-21 23:25:50 +00002978 CPUState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00002979 return cpu_ppc_load_decr(env);
bellard9fddaa02004-05-21 12:59:32 +00002980}
2981
blueswir18662d652008-10-02 18:32:44 +00002982static target_long monitor_get_tbu (const struct MonitorDef *md, int val)
bellard9fddaa02004-05-21 12:59:32 +00002983{
bellard6a00d602005-11-21 23:25:50 +00002984 CPUState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00002985 return cpu_ppc_load_tbu(env);
bellard9fddaa02004-05-21 12:59:32 +00002986}
2987
blueswir18662d652008-10-02 18:32:44 +00002988static target_long monitor_get_tbl (const struct MonitorDef *md, int val)
bellard9fddaa02004-05-21 12:59:32 +00002989{
bellard6a00d602005-11-21 23:25:50 +00002990 CPUState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00002991 return cpu_ppc_load_tbl(env);
bellard9fddaa02004-05-21 12:59:32 +00002992}
bellarda541f292004-04-12 20:39:29 +00002993#endif
2994
bellarde95c8d52004-09-30 22:22:08 +00002995#if defined(TARGET_SPARC)
bellard7b936c02005-10-30 17:05:13 +00002996#ifndef TARGET_SPARC64
blueswir18662d652008-10-02 18:32:44 +00002997static target_long monitor_get_psr (const struct MonitorDef *md, int val)
bellarde95c8d52004-09-30 22:22:08 +00002998{
bellard6a00d602005-11-21 23:25:50 +00002999 CPUState *env = mon_get_cpu();
Blue Swirl5a834bb2010-05-09 20:19:04 +00003000
3001 return cpu_get_psr(env);
bellarde95c8d52004-09-30 22:22:08 +00003002}
bellard7b936c02005-10-30 17:05:13 +00003003#endif
bellarde95c8d52004-09-30 22:22:08 +00003004
blueswir18662d652008-10-02 18:32:44 +00003005static target_long monitor_get_reg(const struct MonitorDef *md, int val)
bellarde95c8d52004-09-30 22:22:08 +00003006{
bellard6a00d602005-11-21 23:25:50 +00003007 CPUState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00003008 return env->regwptr[val];
bellarde95c8d52004-09-30 22:22:08 +00003009}
3010#endif
3011
blueswir18662d652008-10-02 18:32:44 +00003012static const MonitorDef monitor_defs[] = {
bellard9307c4c2004-04-04 12:57:25 +00003013#ifdef TARGET_I386
bellard57206fd2004-04-25 18:54:52 +00003014
3015#define SEG(name, seg) \
bellard92a31b12005-02-10 22:00:52 +00003016 { name, offsetof(CPUState, segs[seg].selector), NULL, MD_I32 },\
bellard57206fd2004-04-25 18:54:52 +00003017 { name ".base", offsetof(CPUState, segs[seg].base) },\
bellard92a31b12005-02-10 22:00:52 +00003018 { name ".limit", offsetof(CPUState, segs[seg].limit), NULL, MD_I32 },
bellard57206fd2004-04-25 18:54:52 +00003019
bellard9307c4c2004-04-04 12:57:25 +00003020 { "eax", offsetof(CPUState, regs[0]) },
3021 { "ecx", offsetof(CPUState, regs[1]) },
3022 { "edx", offsetof(CPUState, regs[2]) },
3023 { "ebx", offsetof(CPUState, regs[3]) },
3024 { "esp|sp", offsetof(CPUState, regs[4]) },
3025 { "ebp|fp", offsetof(CPUState, regs[5]) },
3026 { "esi", offsetof(CPUState, regs[6]) },
bellard01038d22004-09-13 21:36:46 +00003027 { "edi", offsetof(CPUState, regs[7]) },
bellard92a31b12005-02-10 22:00:52 +00003028#ifdef TARGET_X86_64
3029 { "r8", offsetof(CPUState, regs[8]) },
3030 { "r9", offsetof(CPUState, regs[9]) },
3031 { "r10", offsetof(CPUState, regs[10]) },
3032 { "r11", offsetof(CPUState, regs[11]) },
3033 { "r12", offsetof(CPUState, regs[12]) },
3034 { "r13", offsetof(CPUState, regs[13]) },
3035 { "r14", offsetof(CPUState, regs[14]) },
3036 { "r15", offsetof(CPUState, regs[15]) },
3037#endif
bellard9307c4c2004-04-04 12:57:25 +00003038 { "eflags", offsetof(CPUState, eflags) },
bellard57206fd2004-04-25 18:54:52 +00003039 { "eip", offsetof(CPUState, eip) },
3040 SEG("cs", R_CS)
3041 SEG("ds", R_DS)
3042 SEG("es", R_ES)
bellard01038d22004-09-13 21:36:46 +00003043 SEG("ss", R_SS)
bellard57206fd2004-04-25 18:54:52 +00003044 SEG("fs", R_FS)
3045 SEG("gs", R_GS)
3046 { "pc", 0, monitor_get_pc, },
bellarda541f292004-04-12 20:39:29 +00003047#elif defined(TARGET_PPC)
j_mayerff937db2007-09-19 05:49:13 +00003048 /* General purpose registers */
bellarda541f292004-04-12 20:39:29 +00003049 { "r0", offsetof(CPUState, gpr[0]) },
3050 { "r1", offsetof(CPUState, gpr[1]) },
3051 { "r2", offsetof(CPUState, gpr[2]) },
3052 { "r3", offsetof(CPUState, gpr[3]) },
3053 { "r4", offsetof(CPUState, gpr[4]) },
3054 { "r5", offsetof(CPUState, gpr[5]) },
3055 { "r6", offsetof(CPUState, gpr[6]) },
3056 { "r7", offsetof(CPUState, gpr[7]) },
3057 { "r8", offsetof(CPUState, gpr[8]) },
3058 { "r9", offsetof(CPUState, gpr[9]) },
3059 { "r10", offsetof(CPUState, gpr[10]) },
3060 { "r11", offsetof(CPUState, gpr[11]) },
3061 { "r12", offsetof(CPUState, gpr[12]) },
3062 { "r13", offsetof(CPUState, gpr[13]) },
3063 { "r14", offsetof(CPUState, gpr[14]) },
3064 { "r15", offsetof(CPUState, gpr[15]) },
3065 { "r16", offsetof(CPUState, gpr[16]) },
3066 { "r17", offsetof(CPUState, gpr[17]) },
3067 { "r18", offsetof(CPUState, gpr[18]) },
3068 { "r19", offsetof(CPUState, gpr[19]) },
3069 { "r20", offsetof(CPUState, gpr[20]) },
3070 { "r21", offsetof(CPUState, gpr[21]) },
3071 { "r22", offsetof(CPUState, gpr[22]) },
3072 { "r23", offsetof(CPUState, gpr[23]) },
3073 { "r24", offsetof(CPUState, gpr[24]) },
3074 { "r25", offsetof(CPUState, gpr[25]) },
3075 { "r26", offsetof(CPUState, gpr[26]) },
3076 { "r27", offsetof(CPUState, gpr[27]) },
3077 { "r28", offsetof(CPUState, gpr[28]) },
3078 { "r29", offsetof(CPUState, gpr[29]) },
3079 { "r30", offsetof(CPUState, gpr[30]) },
3080 { "r31", offsetof(CPUState, gpr[31]) },
j_mayerff937db2007-09-19 05:49:13 +00003081 /* Floating point registers */
3082 { "f0", offsetof(CPUState, fpr[0]) },
3083 { "f1", offsetof(CPUState, fpr[1]) },
3084 { "f2", offsetof(CPUState, fpr[2]) },
3085 { "f3", offsetof(CPUState, fpr[3]) },
3086 { "f4", offsetof(CPUState, fpr[4]) },
3087 { "f5", offsetof(CPUState, fpr[5]) },
3088 { "f6", offsetof(CPUState, fpr[6]) },
3089 { "f7", offsetof(CPUState, fpr[7]) },
3090 { "f8", offsetof(CPUState, fpr[8]) },
3091 { "f9", offsetof(CPUState, fpr[9]) },
3092 { "f10", offsetof(CPUState, fpr[10]) },
3093 { "f11", offsetof(CPUState, fpr[11]) },
3094 { "f12", offsetof(CPUState, fpr[12]) },
3095 { "f13", offsetof(CPUState, fpr[13]) },
3096 { "f14", offsetof(CPUState, fpr[14]) },
3097 { "f15", offsetof(CPUState, fpr[15]) },
3098 { "f16", offsetof(CPUState, fpr[16]) },
3099 { "f17", offsetof(CPUState, fpr[17]) },
3100 { "f18", offsetof(CPUState, fpr[18]) },
3101 { "f19", offsetof(CPUState, fpr[19]) },
3102 { "f20", offsetof(CPUState, fpr[20]) },
3103 { "f21", offsetof(CPUState, fpr[21]) },
3104 { "f22", offsetof(CPUState, fpr[22]) },
3105 { "f23", offsetof(CPUState, fpr[23]) },
3106 { "f24", offsetof(CPUState, fpr[24]) },
3107 { "f25", offsetof(CPUState, fpr[25]) },
3108 { "f26", offsetof(CPUState, fpr[26]) },
3109 { "f27", offsetof(CPUState, fpr[27]) },
3110 { "f28", offsetof(CPUState, fpr[28]) },
3111 { "f29", offsetof(CPUState, fpr[29]) },
3112 { "f30", offsetof(CPUState, fpr[30]) },
3113 { "f31", offsetof(CPUState, fpr[31]) },
3114 { "fpscr", offsetof(CPUState, fpscr) },
3115 /* Next instruction pointer */
bellard57206fd2004-04-25 18:54:52 +00003116 { "nip|pc", offsetof(CPUState, nip) },
bellarda541f292004-04-12 20:39:29 +00003117 { "lr", offsetof(CPUState, lr) },
3118 { "ctr", offsetof(CPUState, ctr) },
bellard9fddaa02004-05-21 12:59:32 +00003119 { "decr", 0, &monitor_get_decr, },
bellarda541f292004-04-12 20:39:29 +00003120 { "ccr", 0, &monitor_get_ccr, },
j_mayerff937db2007-09-19 05:49:13 +00003121 /* Machine state register */
bellarda541f292004-04-12 20:39:29 +00003122 { "msr", 0, &monitor_get_msr, },
3123 { "xer", 0, &monitor_get_xer, },
bellard9fddaa02004-05-21 12:59:32 +00003124 { "tbu", 0, &monitor_get_tbu, },
3125 { "tbl", 0, &monitor_get_tbl, },
j_mayerff937db2007-09-19 05:49:13 +00003126#if defined(TARGET_PPC64)
3127 /* Address space register */
3128 { "asr", offsetof(CPUState, asr) },
3129#endif
3130 /* Segment registers */
bellarda541f292004-04-12 20:39:29 +00003131 { "sdr1", offsetof(CPUState, sdr1) },
3132 { "sr0", offsetof(CPUState, sr[0]) },
3133 { "sr1", offsetof(CPUState, sr[1]) },
3134 { "sr2", offsetof(CPUState, sr[2]) },
3135 { "sr3", offsetof(CPUState, sr[3]) },
3136 { "sr4", offsetof(CPUState, sr[4]) },
3137 { "sr5", offsetof(CPUState, sr[5]) },
3138 { "sr6", offsetof(CPUState, sr[6]) },
3139 { "sr7", offsetof(CPUState, sr[7]) },
3140 { "sr8", offsetof(CPUState, sr[8]) },
3141 { "sr9", offsetof(CPUState, sr[9]) },
3142 { "sr10", offsetof(CPUState, sr[10]) },
3143 { "sr11", offsetof(CPUState, sr[11]) },
3144 { "sr12", offsetof(CPUState, sr[12]) },
3145 { "sr13", offsetof(CPUState, sr[13]) },
3146 { "sr14", offsetof(CPUState, sr[14]) },
3147 { "sr15", offsetof(CPUState, sr[15]) },
3148 /* Too lazy to put BATs and SPRs ... */
bellarde95c8d52004-09-30 22:22:08 +00003149#elif defined(TARGET_SPARC)
3150 { "g0", offsetof(CPUState, gregs[0]) },
3151 { "g1", offsetof(CPUState, gregs[1]) },
3152 { "g2", offsetof(CPUState, gregs[2]) },
3153 { "g3", offsetof(CPUState, gregs[3]) },
3154 { "g4", offsetof(CPUState, gregs[4]) },
3155 { "g5", offsetof(CPUState, gregs[5]) },
3156 { "g6", offsetof(CPUState, gregs[6]) },
3157 { "g7", offsetof(CPUState, gregs[7]) },
3158 { "o0", 0, monitor_get_reg },
3159 { "o1", 1, monitor_get_reg },
3160 { "o2", 2, monitor_get_reg },
3161 { "o3", 3, monitor_get_reg },
3162 { "o4", 4, monitor_get_reg },
3163 { "o5", 5, monitor_get_reg },
3164 { "o6", 6, monitor_get_reg },
3165 { "o7", 7, monitor_get_reg },
3166 { "l0", 8, monitor_get_reg },
3167 { "l1", 9, monitor_get_reg },
3168 { "l2", 10, monitor_get_reg },
3169 { "l3", 11, monitor_get_reg },
3170 { "l4", 12, monitor_get_reg },
3171 { "l5", 13, monitor_get_reg },
3172 { "l6", 14, monitor_get_reg },
3173 { "l7", 15, monitor_get_reg },
3174 { "i0", 16, monitor_get_reg },
3175 { "i1", 17, monitor_get_reg },
3176 { "i2", 18, monitor_get_reg },
3177 { "i3", 19, monitor_get_reg },
3178 { "i4", 20, monitor_get_reg },
3179 { "i5", 21, monitor_get_reg },
3180 { "i6", 22, monitor_get_reg },
3181 { "i7", 23, monitor_get_reg },
3182 { "pc", offsetof(CPUState, pc) },
3183 { "npc", offsetof(CPUState, npc) },
3184 { "y", offsetof(CPUState, y) },
bellard7b936c02005-10-30 17:05:13 +00003185#ifndef TARGET_SPARC64
bellarde95c8d52004-09-30 22:22:08 +00003186 { "psr", 0, &monitor_get_psr, },
3187 { "wim", offsetof(CPUState, wim) },
bellard7b936c02005-10-30 17:05:13 +00003188#endif
bellarde95c8d52004-09-30 22:22:08 +00003189 { "tbr", offsetof(CPUState, tbr) },
3190 { "fsr", offsetof(CPUState, fsr) },
3191 { "f0", offsetof(CPUState, fpr[0]) },
3192 { "f1", offsetof(CPUState, fpr[1]) },
3193 { "f2", offsetof(CPUState, fpr[2]) },
3194 { "f3", offsetof(CPUState, fpr[3]) },
3195 { "f4", offsetof(CPUState, fpr[4]) },
3196 { "f5", offsetof(CPUState, fpr[5]) },
3197 { "f6", offsetof(CPUState, fpr[6]) },
3198 { "f7", offsetof(CPUState, fpr[7]) },
3199 { "f8", offsetof(CPUState, fpr[8]) },
3200 { "f9", offsetof(CPUState, fpr[9]) },
3201 { "f10", offsetof(CPUState, fpr[10]) },
3202 { "f11", offsetof(CPUState, fpr[11]) },
3203 { "f12", offsetof(CPUState, fpr[12]) },
3204 { "f13", offsetof(CPUState, fpr[13]) },
3205 { "f14", offsetof(CPUState, fpr[14]) },
3206 { "f15", offsetof(CPUState, fpr[15]) },
3207 { "f16", offsetof(CPUState, fpr[16]) },
3208 { "f17", offsetof(CPUState, fpr[17]) },
3209 { "f18", offsetof(CPUState, fpr[18]) },
3210 { "f19", offsetof(CPUState, fpr[19]) },
3211 { "f20", offsetof(CPUState, fpr[20]) },
3212 { "f21", offsetof(CPUState, fpr[21]) },
3213 { "f22", offsetof(CPUState, fpr[22]) },
3214 { "f23", offsetof(CPUState, fpr[23]) },
3215 { "f24", offsetof(CPUState, fpr[24]) },
3216 { "f25", offsetof(CPUState, fpr[25]) },
3217 { "f26", offsetof(CPUState, fpr[26]) },
3218 { "f27", offsetof(CPUState, fpr[27]) },
3219 { "f28", offsetof(CPUState, fpr[28]) },
3220 { "f29", offsetof(CPUState, fpr[29]) },
3221 { "f30", offsetof(CPUState, fpr[30]) },
3222 { "f31", offsetof(CPUState, fpr[31]) },
bellard7b936c02005-10-30 17:05:13 +00003223#ifdef TARGET_SPARC64
3224 { "f32", offsetof(CPUState, fpr[32]) },
3225 { "f34", offsetof(CPUState, fpr[34]) },
3226 { "f36", offsetof(CPUState, fpr[36]) },
3227 { "f38", offsetof(CPUState, fpr[38]) },
3228 { "f40", offsetof(CPUState, fpr[40]) },
3229 { "f42", offsetof(CPUState, fpr[42]) },
3230 { "f44", offsetof(CPUState, fpr[44]) },
3231 { "f46", offsetof(CPUState, fpr[46]) },
3232 { "f48", offsetof(CPUState, fpr[48]) },
3233 { "f50", offsetof(CPUState, fpr[50]) },
3234 { "f52", offsetof(CPUState, fpr[52]) },
3235 { "f54", offsetof(CPUState, fpr[54]) },
3236 { "f56", offsetof(CPUState, fpr[56]) },
3237 { "f58", offsetof(CPUState, fpr[58]) },
3238 { "f60", offsetof(CPUState, fpr[60]) },
3239 { "f62", offsetof(CPUState, fpr[62]) },
3240 { "asi", offsetof(CPUState, asi) },
3241 { "pstate", offsetof(CPUState, pstate) },
3242 { "cansave", offsetof(CPUState, cansave) },
3243 { "canrestore", offsetof(CPUState, canrestore) },
3244 { "otherwin", offsetof(CPUState, otherwin) },
3245 { "wstate", offsetof(CPUState, wstate) },
3246 { "cleanwin", offsetof(CPUState, cleanwin) },
3247 { "fprs", offsetof(CPUState, fprs) },
3248#endif
bellard9307c4c2004-04-04 12:57:25 +00003249#endif
3250 { NULL },
3251};
3252
aliguori376253e2009-03-05 23:01:23 +00003253static void expr_error(Monitor *mon, const char *msg)
bellard9dc39cb2004-03-14 21:38:27 +00003254{
aliguori376253e2009-03-05 23:01:23 +00003255 monitor_printf(mon, "%s\n", msg);
bellard9307c4c2004-04-04 12:57:25 +00003256 longjmp(expr_env, 1);
3257}
3258
Markus Armbruster09b94182010-01-20 13:07:30 +01003259/* return 0 if OK, -1 if not found */
bellard92a31b12005-02-10 22:00:52 +00003260static int get_monitor_def(target_long *pval, const char *name)
bellard9307c4c2004-04-04 12:57:25 +00003261{
blueswir18662d652008-10-02 18:32:44 +00003262 const MonitorDef *md;
bellard92a31b12005-02-10 22:00:52 +00003263 void *ptr;
3264
bellard9307c4c2004-04-04 12:57:25 +00003265 for(md = monitor_defs; md->name != NULL; md++) {
3266 if (compare_cmd(name, md->name)) {
3267 if (md->get_value) {
bellarde95c8d52004-09-30 22:22:08 +00003268 *pval = md->get_value(md, md->offset);
bellard9307c4c2004-04-04 12:57:25 +00003269 } else {
bellard6a00d602005-11-21 23:25:50 +00003270 CPUState *env = mon_get_cpu();
bellard6a00d602005-11-21 23:25:50 +00003271 ptr = (uint8_t *)env + md->offset;
bellard92a31b12005-02-10 22:00:52 +00003272 switch(md->type) {
3273 case MD_I32:
3274 *pval = *(int32_t *)ptr;
3275 break;
3276 case MD_TLONG:
3277 *pval = *(target_long *)ptr;
3278 break;
3279 default:
3280 *pval = 0;
3281 break;
3282 }
bellard9307c4c2004-04-04 12:57:25 +00003283 }
3284 return 0;
3285 }
3286 }
3287 return -1;
3288}
3289
3290static void next(void)
3291{
Blue Swirl660f11b2009-07-31 21:16:51 +00003292 if (*pch != '\0') {
bellard9307c4c2004-04-04 12:57:25 +00003293 pch++;
blueswir1cd390082008-11-16 13:53:32 +00003294 while (qemu_isspace(*pch))
bellard9307c4c2004-04-04 12:57:25 +00003295 pch++;
3296 }
3297}
3298
aliguori376253e2009-03-05 23:01:23 +00003299static int64_t expr_sum(Monitor *mon);
bellard9307c4c2004-04-04 12:57:25 +00003300
aliguori376253e2009-03-05 23:01:23 +00003301static int64_t expr_unary(Monitor *mon)
bellard9307c4c2004-04-04 12:57:25 +00003302{
blueswir1c2efc952007-09-25 17:28:42 +00003303 int64_t n;
bellard9307c4c2004-04-04 12:57:25 +00003304 char *p;
bellard6a00d602005-11-21 23:25:50 +00003305 int ret;
bellard9307c4c2004-04-04 12:57:25 +00003306
3307 switch(*pch) {
3308 case '+':
3309 next();
aliguori376253e2009-03-05 23:01:23 +00003310 n = expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00003311 break;
3312 case '-':
3313 next();
aliguori376253e2009-03-05 23:01:23 +00003314 n = -expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00003315 break;
3316 case '~':
3317 next();
aliguori376253e2009-03-05 23:01:23 +00003318 n = ~expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00003319 break;
3320 case '(':
3321 next();
aliguori376253e2009-03-05 23:01:23 +00003322 n = expr_sum(mon);
bellard9307c4c2004-04-04 12:57:25 +00003323 if (*pch != ')') {
aliguori376253e2009-03-05 23:01:23 +00003324 expr_error(mon, "')' expected");
bellard9307c4c2004-04-04 12:57:25 +00003325 }
3326 next();
3327 break;
bellard81d09122004-07-14 17:21:37 +00003328 case '\'':
3329 pch++;
3330 if (*pch == '\0')
aliguori376253e2009-03-05 23:01:23 +00003331 expr_error(mon, "character constant expected");
bellard81d09122004-07-14 17:21:37 +00003332 n = *pch;
3333 pch++;
3334 if (*pch != '\'')
aliguori376253e2009-03-05 23:01:23 +00003335 expr_error(mon, "missing terminating \' character");
bellard81d09122004-07-14 17:21:37 +00003336 next();
3337 break;
bellard9307c4c2004-04-04 12:57:25 +00003338 case '$':
3339 {
3340 char buf[128], *q;
ths69b34972007-12-17 03:15:52 +00003341 target_long reg=0;
ths3b46e622007-09-17 08:09:54 +00003342
bellard9307c4c2004-04-04 12:57:25 +00003343 pch++;
3344 q = buf;
3345 while ((*pch >= 'a' && *pch <= 'z') ||
3346 (*pch >= 'A' && *pch <= 'Z') ||
3347 (*pch >= '0' && *pch <= '9') ||
bellard57206fd2004-04-25 18:54:52 +00003348 *pch == '_' || *pch == '.') {
bellard9307c4c2004-04-04 12:57:25 +00003349 if ((q - buf) < sizeof(buf) - 1)
3350 *q++ = *pch;
3351 pch++;
3352 }
blueswir1cd390082008-11-16 13:53:32 +00003353 while (qemu_isspace(*pch))
bellard9307c4c2004-04-04 12:57:25 +00003354 pch++;
3355 *q = 0;
blueswir17743e582007-09-24 18:39:04 +00003356 ret = get_monitor_def(&reg, buf);
Markus Armbruster09b94182010-01-20 13:07:30 +01003357 if (ret < 0)
aliguori376253e2009-03-05 23:01:23 +00003358 expr_error(mon, "unknown register");
blueswir17743e582007-09-24 18:39:04 +00003359 n = reg;
bellard9307c4c2004-04-04 12:57:25 +00003360 }
3361 break;
3362 case '\0':
aliguori376253e2009-03-05 23:01:23 +00003363 expr_error(mon, "unexpected end of expression");
bellard9307c4c2004-04-04 12:57:25 +00003364 n = 0;
3365 break;
3366 default:
blueswir17743e582007-09-24 18:39:04 +00003367#if TARGET_PHYS_ADDR_BITS > 32
bellard4f4fbf72006-06-25 18:28:12 +00003368 n = strtoull(pch, &p, 0);
3369#else
bellard9307c4c2004-04-04 12:57:25 +00003370 n = strtoul(pch, &p, 0);
bellard4f4fbf72006-06-25 18:28:12 +00003371#endif
bellard9307c4c2004-04-04 12:57:25 +00003372 if (pch == p) {
aliguori376253e2009-03-05 23:01:23 +00003373 expr_error(mon, "invalid char in expression");
bellard9307c4c2004-04-04 12:57:25 +00003374 }
3375 pch = p;
blueswir1cd390082008-11-16 13:53:32 +00003376 while (qemu_isspace(*pch))
bellard9307c4c2004-04-04 12:57:25 +00003377 pch++;
3378 break;
3379 }
3380 return n;
3381}
3382
3383
aliguori376253e2009-03-05 23:01:23 +00003384static int64_t expr_prod(Monitor *mon)
bellard9307c4c2004-04-04 12:57:25 +00003385{
blueswir1c2efc952007-09-25 17:28:42 +00003386 int64_t val, val2;
bellard92a31b12005-02-10 22:00:52 +00003387 int op;
ths3b46e622007-09-17 08:09:54 +00003388
aliguori376253e2009-03-05 23:01:23 +00003389 val = expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00003390 for(;;) {
3391 op = *pch;
3392 if (op != '*' && op != '/' && op != '%')
3393 break;
3394 next();
aliguori376253e2009-03-05 23:01:23 +00003395 val2 = expr_unary(mon);
bellard9307c4c2004-04-04 12:57:25 +00003396 switch(op) {
3397 default:
3398 case '*':
3399 val *= val2;
3400 break;
3401 case '/':
3402 case '%':
ths5fafdf22007-09-16 21:08:06 +00003403 if (val2 == 0)
aliguori376253e2009-03-05 23:01:23 +00003404 expr_error(mon, "division by zero");
bellard9307c4c2004-04-04 12:57:25 +00003405 if (op == '/')
3406 val /= val2;
3407 else
3408 val %= val2;
3409 break;
3410 }
3411 }
3412 return val;
3413}
3414
aliguori376253e2009-03-05 23:01:23 +00003415static int64_t expr_logic(Monitor *mon)
bellard9307c4c2004-04-04 12:57:25 +00003416{
blueswir1c2efc952007-09-25 17:28:42 +00003417 int64_t val, val2;
bellard92a31b12005-02-10 22:00:52 +00003418 int op;
bellard9307c4c2004-04-04 12:57:25 +00003419
aliguori376253e2009-03-05 23:01:23 +00003420 val = expr_prod(mon);
bellard9307c4c2004-04-04 12:57:25 +00003421 for(;;) {
3422 op = *pch;
3423 if (op != '&' && op != '|' && op != '^')
3424 break;
3425 next();
aliguori376253e2009-03-05 23:01:23 +00003426 val2 = expr_prod(mon);
bellard9307c4c2004-04-04 12:57:25 +00003427 switch(op) {
3428 default:
3429 case '&':
3430 val &= val2;
3431 break;
3432 case '|':
3433 val |= val2;
3434 break;
3435 case '^':
3436 val ^= val2;
3437 break;
3438 }
3439 }
3440 return val;
3441}
3442
aliguori376253e2009-03-05 23:01:23 +00003443static int64_t expr_sum(Monitor *mon)
bellard9307c4c2004-04-04 12:57:25 +00003444{
blueswir1c2efc952007-09-25 17:28:42 +00003445 int64_t val, val2;
bellard92a31b12005-02-10 22:00:52 +00003446 int op;
bellard9307c4c2004-04-04 12:57:25 +00003447
aliguori376253e2009-03-05 23:01:23 +00003448 val = expr_logic(mon);
bellard9307c4c2004-04-04 12:57:25 +00003449 for(;;) {
3450 op = *pch;
3451 if (op != '+' && op != '-')
3452 break;
3453 next();
aliguori376253e2009-03-05 23:01:23 +00003454 val2 = expr_logic(mon);
bellard9307c4c2004-04-04 12:57:25 +00003455 if (op == '+')
3456 val += val2;
3457 else
3458 val -= val2;
3459 }
3460 return val;
3461}
3462
aliguori376253e2009-03-05 23:01:23 +00003463static int get_expr(Monitor *mon, int64_t *pval, const char **pp)
bellard9307c4c2004-04-04 12:57:25 +00003464{
3465 pch = *pp;
3466 if (setjmp(expr_env)) {
3467 *pp = pch;
3468 return -1;
3469 }
blueswir1cd390082008-11-16 13:53:32 +00003470 while (qemu_isspace(*pch))
bellard9307c4c2004-04-04 12:57:25 +00003471 pch++;
aliguori376253e2009-03-05 23:01:23 +00003472 *pval = expr_sum(mon);
bellard9307c4c2004-04-04 12:57:25 +00003473 *pp = pch;
3474 return 0;
3475}
3476
Markus Armbruster3350a4d2010-01-25 14:23:03 +01003477static int get_double(Monitor *mon, double *pval, const char **pp)
3478{
3479 const char *p = *pp;
3480 char *tailp;
3481 double d;
3482
3483 d = strtod(p, &tailp);
3484 if (tailp == p) {
3485 monitor_printf(mon, "Number expected\n");
3486 return -1;
3487 }
3488 if (d != d || d - d != 0) {
3489 /* NaN or infinity */
3490 monitor_printf(mon, "Bad number\n");
3491 return -1;
3492 }
3493 *pval = d;
3494 *pp = tailp;
3495 return 0;
3496}
3497
bellard9307c4c2004-04-04 12:57:25 +00003498static int get_str(char *buf, int buf_size, const char **pp)
3499{
3500 const char *p;
3501 char *q;
3502 int c;
3503
bellard81d09122004-07-14 17:21:37 +00003504 q = buf;
bellard9307c4c2004-04-04 12:57:25 +00003505 p = *pp;
blueswir1cd390082008-11-16 13:53:32 +00003506 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00003507 p++;
3508 if (*p == '\0') {
3509 fail:
bellard81d09122004-07-14 17:21:37 +00003510 *q = '\0';
bellard9307c4c2004-04-04 12:57:25 +00003511 *pp = p;
3512 return -1;
3513 }
bellard9307c4c2004-04-04 12:57:25 +00003514 if (*p == '\"') {
3515 p++;
3516 while (*p != '\0' && *p != '\"') {
3517 if (*p == '\\') {
3518 p++;
3519 c = *p++;
3520 switch(c) {
3521 case 'n':
3522 c = '\n';
3523 break;
3524 case 'r':
3525 c = '\r';
3526 break;
3527 case '\\':
3528 case '\'':
3529 case '\"':
3530 break;
3531 default:
3532 qemu_printf("unsupported escape code: '\\%c'\n", c);
3533 goto fail;
3534 }
3535 if ((q - buf) < buf_size - 1) {
3536 *q++ = c;
3537 }
3538 } else {
3539 if ((q - buf) < buf_size - 1) {
3540 *q++ = *p;
3541 }
3542 p++;
3543 }
3544 }
3545 if (*p != '\"') {
bellard5b602122004-05-22 21:41:05 +00003546 qemu_printf("unterminated string\n");
bellard9307c4c2004-04-04 12:57:25 +00003547 goto fail;
3548 }
3549 p++;
3550 } else {
blueswir1cd390082008-11-16 13:53:32 +00003551 while (*p != '\0' && !qemu_isspace(*p)) {
bellard9307c4c2004-04-04 12:57:25 +00003552 if ((q - buf) < buf_size - 1) {
3553 *q++ = *p;
3554 }
3555 p++;
3556 }
bellard9307c4c2004-04-04 12:57:25 +00003557 }
bellard81d09122004-07-14 17:21:37 +00003558 *q = '\0';
bellard9307c4c2004-04-04 12:57:25 +00003559 *pp = p;
3560 return 0;
3561}
3562
Luiz Capitulino4590fd82009-06-09 18:21:30 -03003563/*
3564 * Store the command-name in cmdname, and return a pointer to
3565 * the remaining of the command string.
3566 */
3567static const char *get_command_name(const char *cmdline,
3568 char *cmdname, size_t nlen)
3569{
3570 size_t len;
3571 const char *p, *pstart;
3572
3573 p = cmdline;
3574 while (qemu_isspace(*p))
3575 p++;
3576 if (*p == '\0')
3577 return NULL;
3578 pstart = p;
3579 while (*p != '\0' && *p != '/' && !qemu_isspace(*p))
3580 p++;
3581 len = p - pstart;
3582 if (len > nlen - 1)
3583 len = nlen - 1;
3584 memcpy(cmdname, pstart, len);
3585 cmdname[len] = '\0';
3586 return p;
3587}
3588
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003589/**
3590 * Read key of 'type' into 'key' and return the current
3591 * 'type' pointer.
3592 */
3593static char *key_get_info(const char *type, char **key)
3594{
3595 size_t len;
3596 char *p, *str;
3597
3598 if (*type == ',')
3599 type++;
3600
3601 p = strchr(type, ':');
3602 if (!p) {
3603 *key = NULL;
3604 return NULL;
3605 }
3606 len = p - type;
3607
3608 str = qemu_malloc(len + 1);
3609 memcpy(str, type, len);
3610 str[len] = '\0';
3611
3612 *key = str;
3613 return ++p;
3614}
3615
bellard9307c4c2004-04-04 12:57:25 +00003616static int default_fmt_format = 'x';
3617static int default_fmt_size = 4;
3618
3619#define MAX_ARGS 16
3620
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02003621static int is_valid_option(const char *c, const char *typestr)
3622{
3623 char option[3];
3624
3625 option[0] = '-';
3626 option[1] = *c;
3627 option[2] = '\0';
3628
3629 typestr = strstr(typestr, option);
3630 return (typestr != NULL);
3631}
3632
Luiz Capitulino945c5ac2010-09-13 13:17:58 -03003633static const mon_cmd_t *search_dispatch_table(const mon_cmd_t *disp_table,
3634 const char *cmdname)
Luiz Capitulino7fd669a2009-11-26 22:58:54 -02003635{
3636 const mon_cmd_t *cmd;
3637
Luiz Capitulino945c5ac2010-09-13 13:17:58 -03003638 for (cmd = disp_table; cmd->name != NULL; cmd++) {
Luiz Capitulino7fd669a2009-11-26 22:58:54 -02003639 if (compare_cmd(cmdname, cmd->name)) {
3640 return cmd;
3641 }
3642 }
3643
3644 return NULL;
3645}
3646
Luiz Capitulino945c5ac2010-09-13 13:17:58 -03003647static const mon_cmd_t *monitor_find_command(const char *cmdname)
3648{
3649 return search_dispatch_table(mon_cmds, cmdname);
3650}
3651
Luiz Capitulino030db6e2010-09-10 16:03:38 -03003652static const mon_cmd_t *qmp_find_query_cmd(const char *info_item)
3653{
Luiz Capitulino3e12a752010-09-15 17:20:33 -03003654 return search_dispatch_table(qmp_query_cmds, info_item);
Luiz Capitulino030db6e2010-09-10 16:03:38 -03003655}
3656
Luiz Capitulinobead3ce2010-09-15 17:08:39 -03003657static const mon_cmd_t *qmp_find_cmd(const char *cmdname)
3658{
Luiz Capitulinof36b4af2010-09-15 17:17:45 -03003659 return search_dispatch_table(qmp_cmds, cmdname);
Luiz Capitulinobead3ce2010-09-15 17:08:39 -03003660}
3661
Anthony Liguoric227f092009-10-01 16:12:16 -05003662static const mon_cmd_t *monitor_parse_command(Monitor *mon,
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003663 const char *cmdline,
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003664 QDict *qdict)
bellard9307c4c2004-04-04 12:57:25 +00003665{
Luiz Capitulino4590fd82009-06-09 18:21:30 -03003666 const char *p, *typestr;
Luiz Capitulino53773582009-08-28 15:27:25 -03003667 int c;
Anthony Liguoric227f092009-10-01 16:12:16 -05003668 const mon_cmd_t *cmd;
bellard9307c4c2004-04-04 12:57:25 +00003669 char cmdname[256];
3670 char buf[1024];
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003671 char *key;
bellard9dc39cb2004-03-14 21:38:27 +00003672
3673#ifdef DEBUG
aliguori376253e2009-03-05 23:01:23 +00003674 monitor_printf(mon, "command='%s'\n", cmdline);
bellard9dc39cb2004-03-14 21:38:27 +00003675#endif
ths3b46e622007-09-17 08:09:54 +00003676
bellard9307c4c2004-04-04 12:57:25 +00003677 /* extract the command name */
Luiz Capitulino4590fd82009-06-09 18:21:30 -03003678 p = get_command_name(cmdline, cmdname, sizeof(cmdname));
3679 if (!p)
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003680 return NULL;
ths3b46e622007-09-17 08:09:54 +00003681
Luiz Capitulino7fd669a2009-11-26 22:58:54 -02003682 cmd = monitor_find_command(cmdname);
3683 if (!cmd) {
Luiz Capitulinod91d9bf2009-06-09 18:21:54 -03003684 monitor_printf(mon, "unknown command: '%s'\n", cmdname);
Luiz Capitulino55f81d92009-08-28 15:27:22 -03003685 return NULL;
Luiz Capitulinod91d9bf2009-06-09 18:21:54 -03003686 }
bellard9307c4c2004-04-04 12:57:25 +00003687
bellard9307c4c2004-04-04 12:57:25 +00003688 /* parse the parameters */
3689 typestr = cmd->args_type;
bellard9307c4c2004-04-04 12:57:25 +00003690 for(;;) {
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003691 typestr = key_get_info(typestr, &key);
3692 if (!typestr)
bellard9307c4c2004-04-04 12:57:25 +00003693 break;
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003694 c = *typestr;
bellard9307c4c2004-04-04 12:57:25 +00003695 typestr++;
3696 switch(c) {
3697 case 'F':
bellard81d09122004-07-14 17:21:37 +00003698 case 'B':
bellard9307c4c2004-04-04 12:57:25 +00003699 case 's':
3700 {
3701 int ret;
ths3b46e622007-09-17 08:09:54 +00003702
blueswir1cd390082008-11-16 13:53:32 +00003703 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00003704 p++;
3705 if (*typestr == '?') {
3706 typestr++;
3707 if (*p == '\0') {
3708 /* no optional string: NULL argument */
Luiz Capitulino53773582009-08-28 15:27:25 -03003709 break;
bellard9307c4c2004-04-04 12:57:25 +00003710 }
3711 }
3712 ret = get_str(buf, sizeof(buf), &p);
3713 if (ret < 0) {
bellard81d09122004-07-14 17:21:37 +00003714 switch(c) {
3715 case 'F':
aliguori376253e2009-03-05 23:01:23 +00003716 monitor_printf(mon, "%s: filename expected\n",
3717 cmdname);
bellard81d09122004-07-14 17:21:37 +00003718 break;
3719 case 'B':
aliguori376253e2009-03-05 23:01:23 +00003720 monitor_printf(mon, "%s: block device name expected\n",
3721 cmdname);
bellard81d09122004-07-14 17:21:37 +00003722 break;
3723 default:
aliguori376253e2009-03-05 23:01:23 +00003724 monitor_printf(mon, "%s: string expected\n", cmdname);
bellard81d09122004-07-14 17:21:37 +00003725 break;
3726 }
bellard9307c4c2004-04-04 12:57:25 +00003727 goto fail;
3728 }
Luiz Capitulino53773582009-08-28 15:27:25 -03003729 qdict_put(qdict, key, qstring_from_str(buf));
bellard9307c4c2004-04-04 12:57:25 +00003730 }
3731 break;
Markus Armbruster361127d2010-02-10 20:24:35 +01003732 case 'O':
3733 {
3734 QemuOptsList *opts_list;
3735 QemuOpts *opts;
3736
3737 opts_list = qemu_find_opts(key);
3738 if (!opts_list || opts_list->desc->name) {
3739 goto bad_type;
3740 }
3741 while (qemu_isspace(*p)) {
3742 p++;
3743 }
3744 if (!*p)
3745 break;
3746 if (get_str(buf, sizeof(buf), &p) < 0) {
3747 goto fail;
3748 }
3749 opts = qemu_opts_parse(opts_list, buf, 1);
3750 if (!opts) {
3751 goto fail;
3752 }
3753 qemu_opts_to_qdict(opts, qdict);
3754 qemu_opts_del(opts);
3755 }
3756 break;
bellard9307c4c2004-04-04 12:57:25 +00003757 case '/':
3758 {
3759 int count, format, size;
ths3b46e622007-09-17 08:09:54 +00003760
blueswir1cd390082008-11-16 13:53:32 +00003761 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00003762 p++;
3763 if (*p == '/') {
3764 /* format found */
3765 p++;
3766 count = 1;
blueswir1cd390082008-11-16 13:53:32 +00003767 if (qemu_isdigit(*p)) {
bellard9307c4c2004-04-04 12:57:25 +00003768 count = 0;
blueswir1cd390082008-11-16 13:53:32 +00003769 while (qemu_isdigit(*p)) {
bellard9307c4c2004-04-04 12:57:25 +00003770 count = count * 10 + (*p - '0');
3771 p++;
3772 }
3773 }
3774 size = -1;
3775 format = -1;
3776 for(;;) {
3777 switch(*p) {
3778 case 'o':
3779 case 'd':
3780 case 'u':
3781 case 'x':
3782 case 'i':
3783 case 'c':
3784 format = *p++;
3785 break;
3786 case 'b':
3787 size = 1;
3788 p++;
3789 break;
3790 case 'h':
3791 size = 2;
3792 p++;
3793 break;
3794 case 'w':
3795 size = 4;
3796 p++;
3797 break;
3798 case 'g':
3799 case 'L':
3800 size = 8;
3801 p++;
3802 break;
3803 default:
3804 goto next;
3805 }
3806 }
3807 next:
blueswir1cd390082008-11-16 13:53:32 +00003808 if (*p != '\0' && !qemu_isspace(*p)) {
aliguori376253e2009-03-05 23:01:23 +00003809 monitor_printf(mon, "invalid char in format: '%c'\n",
3810 *p);
bellard9307c4c2004-04-04 12:57:25 +00003811 goto fail;
3812 }
bellard9307c4c2004-04-04 12:57:25 +00003813 if (format < 0)
3814 format = default_fmt_format;
bellard4c27ba22004-04-25 18:05:08 +00003815 if (format != 'i') {
3816 /* for 'i', not specifying a size gives -1 as size */
3817 if (size < 0)
3818 size = default_fmt_size;
aurel32e90f0092008-10-01 21:45:51 +00003819 default_fmt_size = size;
bellard4c27ba22004-04-25 18:05:08 +00003820 }
bellard9307c4c2004-04-04 12:57:25 +00003821 default_fmt_format = format;
3822 } else {
3823 count = 1;
3824 format = default_fmt_format;
bellard4c27ba22004-04-25 18:05:08 +00003825 if (format != 'i') {
3826 size = default_fmt_size;
3827 } else {
3828 size = -1;
3829 }
bellard9307c4c2004-04-04 12:57:25 +00003830 }
Luiz Capitulinof7188bb2009-08-28 15:27:10 -03003831 qdict_put(qdict, "count", qint_from_int(count));
3832 qdict_put(qdict, "format", qint_from_int(format));
3833 qdict_put(qdict, "size", qint_from_int(size));
bellard9307c4c2004-04-04 12:57:25 +00003834 }
3835 break;
3836 case 'i':
bellard92a31b12005-02-10 22:00:52 +00003837 case 'l':
Luiz Capitulinob6e098d2009-12-18 13:25:04 -02003838 case 'M':
bellard9307c4c2004-04-04 12:57:25 +00003839 {
blueswir1c2efc952007-09-25 17:28:42 +00003840 int64_t val;
blueswir17743e582007-09-24 18:39:04 +00003841
blueswir1cd390082008-11-16 13:53:32 +00003842 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00003843 p++;
bellard34405572004-06-08 00:55:58 +00003844 if (*typestr == '?' || *typestr == '.') {
bellard34405572004-06-08 00:55:58 +00003845 if (*typestr == '?') {
Luiz Capitulino53773582009-08-28 15:27:25 -03003846 if (*p == '\0') {
3847 typestr++;
3848 break;
3849 }
bellard34405572004-06-08 00:55:58 +00003850 } else {
3851 if (*p == '.') {
3852 p++;
blueswir1cd390082008-11-16 13:53:32 +00003853 while (qemu_isspace(*p))
bellard34405572004-06-08 00:55:58 +00003854 p++;
bellard34405572004-06-08 00:55:58 +00003855 } else {
Luiz Capitulino53773582009-08-28 15:27:25 -03003856 typestr++;
3857 break;
bellard34405572004-06-08 00:55:58 +00003858 }
3859 }
bellard13224a82006-07-14 22:03:35 +00003860 typestr++;
bellard9307c4c2004-04-04 12:57:25 +00003861 }
aliguori376253e2009-03-05 23:01:23 +00003862 if (get_expr(mon, &val, &p))
bellard9307c4c2004-04-04 12:57:25 +00003863 goto fail;
Luiz Capitulino675ebef2009-08-28 15:27:26 -03003864 /* Check if 'i' is greater than 32-bit */
3865 if ((c == 'i') && ((val >> 32) & 0xffffffff)) {
3866 monitor_printf(mon, "\'%s\' has failed: ", cmdname);
3867 monitor_printf(mon, "integer is for 32-bit values\n");
3868 goto fail;
Luiz Capitulinob6e098d2009-12-18 13:25:04 -02003869 } else if (c == 'M') {
3870 val <<= 20;
Luiz Capitulino675ebef2009-08-28 15:27:26 -03003871 }
Luiz Capitulino53773582009-08-28 15:27:25 -03003872 qdict_put(qdict, key, qint_from_int(val));
bellard9307c4c2004-04-04 12:57:25 +00003873 }
3874 break;
Jes Sorensendbc0c672010-10-21 17:15:47 +02003875 case 'o':
3876 {
3877 ssize_t val;
3878 char *end;
3879
3880 while (qemu_isspace(*p)) {
3881 p++;
3882 }
3883 if (*typestr == '?') {
3884 typestr++;
3885 if (*p == '\0') {
3886 break;
3887 }
3888 }
3889 val = strtosz(p, &end);
3890 if (val < 0) {
3891 monitor_printf(mon, "invalid size\n");
3892 goto fail;
3893 }
3894 qdict_put(qdict, key, qint_from_int(val));
3895 p = end;
3896 }
3897 break;
Markus Armbrusterfccfb11e2010-01-25 14:23:06 +01003898 case 'T':
Markus Armbruster3350a4d2010-01-25 14:23:03 +01003899 {
3900 double val;
3901
3902 while (qemu_isspace(*p))
3903 p++;
3904 if (*typestr == '?') {
3905 typestr++;
3906 if (*p == '\0') {
3907 break;
3908 }
3909 }
3910 if (get_double(mon, &val, &p) < 0) {
3911 goto fail;
3912 }
Jes Sorensen07de3e62010-10-21 17:15:49 +02003913 if (p[0] && p[1] == 's') {
Markus Armbrusterfccfb11e2010-01-25 14:23:06 +01003914 switch (*p) {
3915 case 'm':
3916 val /= 1e3; p += 2; break;
3917 case 'u':
3918 val /= 1e6; p += 2; break;
3919 case 'n':
3920 val /= 1e9; p += 2; break;
3921 }
3922 }
Markus Armbruster3350a4d2010-01-25 14:23:03 +01003923 if (*p && !qemu_isspace(*p)) {
3924 monitor_printf(mon, "Unknown unit suffix\n");
3925 goto fail;
3926 }
3927 qdict_put(qdict, key, qfloat_from_double(val));
3928 }
3929 break;
Markus Armbruster942cd1f2010-03-26 09:07:09 +01003930 case 'b':
3931 {
3932 const char *beg;
3933 int val;
3934
3935 while (qemu_isspace(*p)) {
3936 p++;
3937 }
3938 beg = p;
3939 while (qemu_isgraph(*p)) {
3940 p++;
3941 }
3942 if (p - beg == 2 && !memcmp(beg, "on", p - beg)) {
3943 val = 1;
3944 } else if (p - beg == 3 && !memcmp(beg, "off", p - beg)) {
3945 val = 0;
3946 } else {
3947 monitor_printf(mon, "Expected 'on' or 'off'\n");
3948 goto fail;
3949 }
3950 qdict_put(qdict, key, qbool_from_int(val));
3951 }
3952 break;
bellard9307c4c2004-04-04 12:57:25 +00003953 case '-':
3954 {
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02003955 const char *tmp = p;
Luiz Capitulinoeb159d12010-05-28 15:25:24 -03003956 int skip_key = 0;
bellard9307c4c2004-04-04 12:57:25 +00003957 /* option */
ths3b46e622007-09-17 08:09:54 +00003958
bellard9307c4c2004-04-04 12:57:25 +00003959 c = *typestr++;
3960 if (c == '\0')
3961 goto bad_type;
blueswir1cd390082008-11-16 13:53:32 +00003962 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00003963 p++;
bellard9307c4c2004-04-04 12:57:25 +00003964 if (*p == '-') {
3965 p++;
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02003966 if(c != *p) {
3967 if(!is_valid_option(p, typestr)) {
3968
3969 monitor_printf(mon, "%s: unsupported option -%c\n",
3970 cmdname, *p);
3971 goto fail;
3972 } else {
3973 skip_key = 1;
3974 }
bellard9307c4c2004-04-04 12:57:25 +00003975 }
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02003976 if(skip_key) {
3977 p = tmp;
3978 } else {
Luiz Capitulinoeb159d12010-05-28 15:25:24 -03003979 /* has option */
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02003980 p++;
Luiz Capitulinoeb159d12010-05-28 15:25:24 -03003981 qdict_put(qdict, key, qbool_from_int(1));
lirans@il.ibm.comfbc3d962009-11-02 15:41:13 +02003982 }
bellard9307c4c2004-04-04 12:57:25 +00003983 }
bellard9307c4c2004-04-04 12:57:25 +00003984 }
3985 break;
3986 default:
3987 bad_type:
aliguori376253e2009-03-05 23:01:23 +00003988 monitor_printf(mon, "%s: unknown type '%c'\n", cmdname, c);
bellard9307c4c2004-04-04 12:57:25 +00003989 goto fail;
3990 }
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03003991 qemu_free(key);
3992 key = NULL;
bellard9307c4c2004-04-04 12:57:25 +00003993 }
3994 /* check that all arguments were parsed */
blueswir1cd390082008-11-16 13:53:32 +00003995 while (qemu_isspace(*p))
bellard9307c4c2004-04-04 12:57:25 +00003996 p++;
3997 if (*p != '\0') {
aliguori376253e2009-03-05 23:01:23 +00003998 monitor_printf(mon, "%s: extraneous characters at the end of line\n",
3999 cmdname);
bellard9307c4c2004-04-04 12:57:25 +00004000 goto fail;
4001 }
4002
Luiz Capitulino55f81d92009-08-28 15:27:22 -03004003 return cmd;
Gerd Hoffmannac7531e2009-08-14 10:36:06 +02004004
Luiz Capitulino55f81d92009-08-28 15:27:22 -03004005fail:
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03004006 qemu_free(key);
Luiz Capitulino55f81d92009-08-28 15:27:22 -03004007 return NULL;
4008}
4009
Markus Armbrusterd6f46832010-02-17 10:52:26 +01004010void monitor_set_error(Monitor *mon, QError *qerror)
4011{
4012 /* report only the first error */
4013 if (!mon->error) {
4014 mon->error = qerror;
4015 } else {
4016 MON_DEBUG("Additional error report at %s:%d\n",
4017 qerror->file, qerror->linenr);
4018 QDECREF(qerror);
4019 }
4020}
4021
Luiz Capitulinobb89c2e2010-02-10 23:50:05 -02004022static void handler_audit(Monitor *mon, const mon_cmd_t *cmd, int ret)
4023{
Markus Armbrustercde0fc72010-03-02 14:56:34 +01004024 if (monitor_ctrl_mode(mon)) {
4025 if (ret && !monitor_has_error(mon)) {
4026 /*
4027 * If it returns failure, it must have passed on error.
4028 *
4029 * Action: Report an internal error to the client if in QMP.
4030 */
Markus Armbrusterab5b0272010-03-02 18:15:09 +01004031 qerror_report(QERR_UNDEFINED_ERROR);
Markus Armbrustercde0fc72010-03-02 14:56:34 +01004032 MON_DEBUG("command '%s' returned failure but did not pass an error\n",
4033 cmd->name);
Luiz Capitulinobb89c2e2010-02-10 23:50:05 -02004034 }
Luiz Capitulinobb89c2e2010-02-10 23:50:05 -02004035
4036#ifdef CONFIG_DEBUG_MONITOR
Markus Armbrustercde0fc72010-03-02 14:56:34 +01004037 if (!ret && monitor_has_error(mon)) {
4038 /*
4039 * If it returns success, it must not have passed an error.
4040 *
4041 * Action: Report the passed error to the client.
4042 */
4043 MON_DEBUG("command '%s' returned success but passed an error\n",
4044 cmd->name);
4045 }
Luiz Capitulino10e4f602010-02-10 23:50:06 -02004046
Markus Armbrustercde0fc72010-03-02 14:56:34 +01004047 if (mon_print_count_get(mon) > 0 && strcmp(cmd->name, "info") != 0) {
4048 /*
4049 * Handlers should not call Monitor print functions.
4050 *
4051 * Action: Ignore them in QMP.
4052 *
4053 * (XXX: we don't check any 'info' or 'query' command here
4054 * because the user print function _is_ called by do_info(), hence
4055 * we will trigger this check. This problem will go away when we
4056 * make 'query' commands real and kill do_info())
4057 */
4058 MON_DEBUG("command '%s' called print functions %d time(s)\n",
4059 cmd->name, mon_print_count_get(mon));
4060 }
Luiz Capitulinobb89c2e2010-02-10 23:50:05 -02004061#endif
Markus Armbrustercde0fc72010-03-02 14:56:34 +01004062 } else {
4063 assert(!monitor_has_error(mon));
4064 QDECREF(mon->error);
4065 mon->error = NULL;
4066 }
Luiz Capitulinobb89c2e2010-02-10 23:50:05 -02004067}
4068
Luiz Capitulinof3c157c2009-11-26 22:58:55 -02004069static void handle_user_command(Monitor *mon, const char *cmdline)
Luiz Capitulino55f81d92009-08-28 15:27:22 -03004070{
Luiz Capitulino55f81d92009-08-28 15:27:22 -03004071 QDict *qdict;
Anthony Liguoric227f092009-10-01 16:12:16 -05004072 const mon_cmd_t *cmd;
Luiz Capitulino55f81d92009-08-28 15:27:22 -03004073
4074 qdict = qdict_new();
4075
Luiz Capitulino590fb3b2009-08-28 15:27:24 -03004076 cmd = monitor_parse_command(mon, cmdline, qdict);
Luiz Capitulino13917be2009-10-07 13:41:54 -03004077 if (!cmd)
4078 goto out;
4079
Luiz Capitulino4903de02010-09-16 11:01:32 -03004080 if (handler_is_async(cmd)) {
Adam Litke940cc302010-01-25 12:18:44 -06004081 user_async_cmd_handler(mon, cmd, qdict);
Luiz Capitulino9e807212010-09-16 10:58:59 -03004082 } else if (handler_is_qobject(cmd)) {
Luiz Capitulinode79ba62010-09-16 11:06:11 -03004083 QObject *data = NULL;
4084
4085 /* XXX: ignores the error code */
4086 cmd->mhandler.cmd_new(mon, qdict, &data);
4087 assert(!monitor_has_error(mon));
4088 if (data) {
4089 cmd->user_print(mon, data);
4090 qobject_decref(data);
4091 }
Luiz Capitulino13917be2009-10-07 13:41:54 -03004092 } else {
Luiz Capitulinoaf4ce882009-10-07 13:41:52 -03004093 cmd->mhandler.cmd(mon, qdict);
Luiz Capitulino55f81d92009-08-28 15:27:22 -03004094 }
4095
Luiz Capitulino13917be2009-10-07 13:41:54 -03004096out:
Luiz Capitulinof7188bb2009-08-28 15:27:10 -03004097 QDECREF(qdict);
bellard9dc39cb2004-03-14 21:38:27 +00004098}
4099
bellard81d09122004-07-14 17:21:37 +00004100static void cmd_completion(const char *name, const char *list)
4101{
4102 const char *p, *pstart;
4103 char cmd[128];
4104 int len;
4105
4106 p = list;
4107 for(;;) {
4108 pstart = p;
4109 p = strchr(p, '|');
4110 if (!p)
4111 p = pstart + strlen(pstart);
4112 len = p - pstart;
4113 if (len > sizeof(cmd) - 2)
4114 len = sizeof(cmd) - 2;
4115 memcpy(cmd, pstart, len);
4116 cmd[len] = '\0';
4117 if (name[0] == '\0' || !strncmp(name, cmd, strlen(name))) {
aliguori731b0362009-03-05 23:01:42 +00004118 readline_add_completion(cur_mon->rs, cmd);
bellard81d09122004-07-14 17:21:37 +00004119 }
4120 if (*p == '\0')
4121 break;
4122 p++;
4123 }
4124}
4125
4126static void file_completion(const char *input)
4127{
4128 DIR *ffs;
4129 struct dirent *d;
4130 char path[1024];
4131 char file[1024], file_prefix[1024];
4132 int input_path_len;
4133 const char *p;
4134
ths5fafdf22007-09-16 21:08:06 +00004135 p = strrchr(input, '/');
bellard81d09122004-07-14 17:21:37 +00004136 if (!p) {
4137 input_path_len = 0;
4138 pstrcpy(file_prefix, sizeof(file_prefix), input);
blueswir1363a37d2008-08-21 17:58:08 +00004139 pstrcpy(path, sizeof(path), ".");
bellard81d09122004-07-14 17:21:37 +00004140 } else {
4141 input_path_len = p - input + 1;
4142 memcpy(path, input, input_path_len);
4143 if (input_path_len > sizeof(path) - 1)
4144 input_path_len = sizeof(path) - 1;
4145 path[input_path_len] = '\0';
4146 pstrcpy(file_prefix, sizeof(file_prefix), p + 1);
4147 }
4148#ifdef DEBUG_COMPLETION
aliguori376253e2009-03-05 23:01:23 +00004149 monitor_printf(cur_mon, "input='%s' path='%s' prefix='%s'\n",
4150 input, path, file_prefix);
bellard81d09122004-07-14 17:21:37 +00004151#endif
4152 ffs = opendir(path);
4153 if (!ffs)
4154 return;
4155 for(;;) {
4156 struct stat sb;
4157 d = readdir(ffs);
4158 if (!d)
4159 break;
Kusanagi Kouichi46c7fc12010-10-20 18:00:01 +09004160
4161 if (strcmp(d->d_name, ".") == 0 || strcmp(d->d_name, "..") == 0) {
4162 continue;
4163 }
4164
bellard81d09122004-07-14 17:21:37 +00004165 if (strstart(d->d_name, file_prefix, NULL)) {
4166 memcpy(file, input, input_path_len);
blueswir1363a37d2008-08-21 17:58:08 +00004167 if (input_path_len < sizeof(file))
4168 pstrcpy(file + input_path_len, sizeof(file) - input_path_len,
4169 d->d_name);
bellard81d09122004-07-14 17:21:37 +00004170 /* stat the file to find out if it's a directory.
4171 * In that case add a slash to speed up typing long paths
4172 */
4173 stat(file, &sb);
4174 if(S_ISDIR(sb.st_mode))
blueswir1363a37d2008-08-21 17:58:08 +00004175 pstrcat(file, sizeof(file), "/");
aliguori731b0362009-03-05 23:01:42 +00004176 readline_add_completion(cur_mon->rs, file);
bellard81d09122004-07-14 17:21:37 +00004177 }
4178 }
4179 closedir(ffs);
4180}
4181
aliguori51de9762009-03-05 23:00:43 +00004182static void block_completion_it(void *opaque, BlockDriverState *bs)
bellard81d09122004-07-14 17:21:37 +00004183{
aliguori51de9762009-03-05 23:00:43 +00004184 const char *name = bdrv_get_device_name(bs);
bellard81d09122004-07-14 17:21:37 +00004185 const char *input = opaque;
4186
4187 if (input[0] == '\0' ||
4188 !strncmp(name, (char *)input, strlen(input))) {
aliguori731b0362009-03-05 23:01:42 +00004189 readline_add_completion(cur_mon->rs, name);
bellard81d09122004-07-14 17:21:37 +00004190 }
4191}
4192
4193/* NOTE: this parser is an approximate form of the real command parser */
4194static void parse_cmdline(const char *cmdline,
4195 int *pnb_args, char **args)
4196{
4197 const char *p;
4198 int nb_args, ret;
4199 char buf[1024];
4200
4201 p = cmdline;
4202 nb_args = 0;
4203 for(;;) {
blueswir1cd390082008-11-16 13:53:32 +00004204 while (qemu_isspace(*p))
bellard81d09122004-07-14 17:21:37 +00004205 p++;
4206 if (*p == '\0')
4207 break;
4208 if (nb_args >= MAX_ARGS)
4209 break;
4210 ret = get_str(buf, sizeof(buf), &p);
4211 args[nb_args] = qemu_strdup(buf);
4212 nb_args++;
4213 if (ret < 0)
4214 break;
4215 }
4216 *pnb_args = nb_args;
4217}
4218
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03004219static const char *next_arg_type(const char *typestr)
4220{
4221 const char *p = strchr(typestr, ':');
4222 return (p != NULL ? ++p : typestr);
4223}
4224
aliguori4c36ba32009-03-05 23:01:37 +00004225static void monitor_find_completion(const char *cmdline)
bellard81d09122004-07-14 17:21:37 +00004226{
4227 const char *cmdname;
4228 char *args[MAX_ARGS];
4229 int nb_args, i, len;
4230 const char *ptype, *str;
Anthony Liguoric227f092009-10-01 16:12:16 -05004231 const mon_cmd_t *cmd;
bellard64866c32006-05-07 18:03:31 +00004232 const KeyDef *key;
bellard81d09122004-07-14 17:21:37 +00004233
4234 parse_cmdline(cmdline, &nb_args, args);
4235#ifdef DEBUG_COMPLETION
4236 for(i = 0; i < nb_args; i++) {
aliguori376253e2009-03-05 23:01:23 +00004237 monitor_printf(cur_mon, "arg%d = '%s'\n", i, (char *)args[i]);
bellard81d09122004-07-14 17:21:37 +00004238 }
4239#endif
4240
4241 /* if the line ends with a space, it means we want to complete the
4242 next arg */
4243 len = strlen(cmdline);
blueswir1cd390082008-11-16 13:53:32 +00004244 if (len > 0 && qemu_isspace(cmdline[len - 1])) {
Jan Kiszka03a63482010-06-16 00:38:33 +02004245 if (nb_args >= MAX_ARGS) {
4246 goto cleanup;
4247 }
bellard81d09122004-07-14 17:21:37 +00004248 args[nb_args++] = qemu_strdup("");
4249 }
4250 if (nb_args <= 1) {
4251 /* command completion */
4252 if (nb_args == 0)
4253 cmdname = "";
4254 else
4255 cmdname = args[0];
aliguori731b0362009-03-05 23:01:42 +00004256 readline_set_completion_index(cur_mon->rs, strlen(cmdname));
aliguori376253e2009-03-05 23:01:23 +00004257 for(cmd = mon_cmds; cmd->name != NULL; cmd++) {
bellard81d09122004-07-14 17:21:37 +00004258 cmd_completion(cmdname, cmd->name);
4259 }
4260 } else {
4261 /* find the command */
Jan Kiszka03a63482010-06-16 00:38:33 +02004262 for (cmd = mon_cmds; cmd->name != NULL; cmd++) {
4263 if (compare_cmd(args[0], cmd->name)) {
4264 break;
4265 }
bellard81d09122004-07-14 17:21:37 +00004266 }
Jan Kiszka03a63482010-06-16 00:38:33 +02004267 if (!cmd->name) {
4268 goto cleanup;
4269 }
4270
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03004271 ptype = next_arg_type(cmd->args_type);
bellard81d09122004-07-14 17:21:37 +00004272 for(i = 0; i < nb_args - 2; i++) {
4273 if (*ptype != '\0') {
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03004274 ptype = next_arg_type(ptype);
bellard81d09122004-07-14 17:21:37 +00004275 while (*ptype == '?')
Luiz Capitulino4d76d2b2009-08-28 15:27:09 -03004276 ptype = next_arg_type(ptype);
bellard81d09122004-07-14 17:21:37 +00004277 }
4278 }
4279 str = args[nb_args - 1];
Blue Swirl2a1704a2009-08-23 20:10:28 +00004280 if (*ptype == '-' && ptype[1] != '\0') {
Jan Kiszka3b6dbf22010-06-16 00:38:34 +02004281 ptype = next_arg_type(ptype);
Blue Swirl2a1704a2009-08-23 20:10:28 +00004282 }
bellard81d09122004-07-14 17:21:37 +00004283 switch(*ptype) {
4284 case 'F':
4285 /* file completion */
aliguori731b0362009-03-05 23:01:42 +00004286 readline_set_completion_index(cur_mon->rs, strlen(str));
bellard81d09122004-07-14 17:21:37 +00004287 file_completion(str);
4288 break;
4289 case 'B':
4290 /* block device name completion */
aliguori731b0362009-03-05 23:01:42 +00004291 readline_set_completion_index(cur_mon->rs, strlen(str));
bellard81d09122004-07-14 17:21:37 +00004292 bdrv_iterate(block_completion_it, (void *)str);
4293 break;
bellard7fe48482004-10-09 18:08:01 +00004294 case 's':
4295 /* XXX: more generic ? */
4296 if (!strcmp(cmd->name, "info")) {
aliguori731b0362009-03-05 23:01:42 +00004297 readline_set_completion_index(cur_mon->rs, strlen(str));
bellard7fe48482004-10-09 18:08:01 +00004298 for(cmd = info_cmds; cmd->name != NULL; cmd++) {
4299 cmd_completion(str, cmd->name);
4300 }
bellard64866c32006-05-07 18:03:31 +00004301 } else if (!strcmp(cmd->name, "sendkey")) {
blueswir1e600d1e2009-03-08 17:42:02 +00004302 char *sep = strrchr(str, '-');
4303 if (sep)
4304 str = sep + 1;
aliguori731b0362009-03-05 23:01:42 +00004305 readline_set_completion_index(cur_mon->rs, strlen(str));
bellard64866c32006-05-07 18:03:31 +00004306 for(key = key_defs; key->name != NULL; key++) {
4307 cmd_completion(str, key->name);
4308 }
Jan Kiszkaf3353c62009-06-25 08:22:02 +02004309 } else if (!strcmp(cmd->name, "help|?")) {
4310 readline_set_completion_index(cur_mon->rs, strlen(str));
4311 for (cmd = mon_cmds; cmd->name != NULL; cmd++) {
4312 cmd_completion(str, cmd->name);
4313 }
bellard7fe48482004-10-09 18:08:01 +00004314 }
4315 break;
bellard81d09122004-07-14 17:21:37 +00004316 default:
4317 break;
4318 }
4319 }
Jan Kiszka03a63482010-06-16 00:38:33 +02004320
4321cleanup:
4322 for (i = 0; i < nb_args; i++) {
bellard81d09122004-07-14 17:21:37 +00004323 qemu_free(args[i]);
Jan Kiszka03a63482010-06-16 00:38:33 +02004324 }
bellard81d09122004-07-14 17:21:37 +00004325}
4326
aliguori731b0362009-03-05 23:01:42 +00004327static int monitor_can_read(void *opaque)
bellard9dc39cb2004-03-14 21:38:27 +00004328{
aliguori731b0362009-03-05 23:01:42 +00004329 Monitor *mon = opaque;
4330
Jan Kiszkac62313b2009-12-04 14:05:29 +01004331 return (mon->suspend_cnt == 0) ? 1 : 0;
bellard9dc39cb2004-03-14 21:38:27 +00004332}
4333
Luiz Capitulino09069b12010-02-04 18:10:06 -02004334static int invalid_qmp_mode(const Monitor *mon, const char *cmd_name)
4335{
4336 int is_cap = compare_cmd(cmd_name, "qmp_capabilities");
4337 return (qmp_cmd_mode(mon) ? is_cap : !is_cap);
4338}
4339
Luiz Capitulino2dbc8db2010-05-26 16:13:09 -03004340/*
Luiz Capitulino4af91932010-06-22 11:44:05 -03004341 * Argument validation rules:
4342 *
4343 * 1. The argument must exist in cmd_args qdict
4344 * 2. The argument type must be the expected one
4345 *
4346 * Special case: If the argument doesn't exist in cmd_args and
4347 * the QMP_ACCEPT_UNKNOWNS flag is set, then the
4348 * checking is skipped for it.
4349 */
4350static int check_client_args_type(const QDict *client_args,
4351 const QDict *cmd_args, int flags)
4352{
4353 const QDictEntry *ent;
4354
4355 for (ent = qdict_first(client_args); ent;ent = qdict_next(client_args,ent)){
4356 QObject *obj;
4357 QString *arg_type;
4358 const QObject *client_arg = qdict_entry_value(ent);
4359 const char *client_arg_name = qdict_entry_key(ent);
4360
4361 obj = qdict_get(cmd_args, client_arg_name);
4362 if (!obj) {
4363 if (flags & QMP_ACCEPT_UNKNOWNS) {
4364 /* handler accepts unknowns */
4365 continue;
4366 }
4367 /* client arg doesn't exist */
4368 qerror_report(QERR_INVALID_PARAMETER, client_arg_name);
4369 return -1;
4370 }
4371
4372 arg_type = qobject_to_qstring(obj);
4373 assert(arg_type != NULL);
4374
4375 /* check if argument's type is correct */
4376 switch (qstring_get_str(arg_type)[0]) {
4377 case 'F':
4378 case 'B':
4379 case 's':
4380 if (qobject_type(client_arg) != QTYPE_QSTRING) {
4381 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4382 "string");
4383 return -1;
4384 }
4385 break;
4386 case 'i':
4387 case 'l':
4388 case 'M':
Jes Sorensendbc0c672010-10-21 17:15:47 +02004389 case 'o':
Luiz Capitulino4af91932010-06-22 11:44:05 -03004390 if (qobject_type(client_arg) != QTYPE_QINT) {
4391 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4392 "int");
4393 return -1;
4394 }
4395 break;
Luiz Capitulino4af91932010-06-22 11:44:05 -03004396 case 'T':
4397 if (qobject_type(client_arg) != QTYPE_QINT &&
4398 qobject_type(client_arg) != QTYPE_QFLOAT) {
4399 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4400 "number");
4401 return -1;
4402 }
4403 break;
4404 case 'b':
4405 case '-':
4406 if (qobject_type(client_arg) != QTYPE_QBOOL) {
4407 qerror_report(QERR_INVALID_PARAMETER_TYPE, client_arg_name,
4408 "bool");
4409 return -1;
4410 }
4411 break;
4412 case 'O':
4413 assert(flags & QMP_ACCEPT_UNKNOWNS);
4414 break;
4415 case '/':
4416 case '.':
4417 /*
4418 * These types are not supported by QMP and thus are not
4419 * handled here. Fall through.
4420 */
4421 default:
4422 abort();
4423 }
4424 }
4425
4426 return 0;
4427}
4428
4429/*
Luiz Capitulino2dbc8db2010-05-26 16:13:09 -03004430 * - Check if the client has passed all mandatory args
4431 * - Set special flags for argument validation
4432 */
4433static int check_mandatory_args(const QDict *cmd_args,
4434 const QDict *client_args, int *flags)
4435{
4436 const QDictEntry *ent;
4437
4438 for (ent = qdict_first(cmd_args); ent; ent = qdict_next(cmd_args, ent)) {
4439 const char *cmd_arg_name = qdict_entry_key(ent);
4440 QString *type = qobject_to_qstring(qdict_entry_value(ent));
4441 assert(type != NULL);
4442
4443 if (qstring_get_str(type)[0] == 'O') {
4444 assert((*flags & QMP_ACCEPT_UNKNOWNS) == 0);
4445 *flags |= QMP_ACCEPT_UNKNOWNS;
4446 } else if (qstring_get_str(type)[0] != '-' &&
4447 qstring_get_str(type)[1] != '?' &&
4448 !qdict_haskey(client_args, cmd_arg_name)) {
4449 qerror_report(QERR_MISSING_PARAMETER, cmd_arg_name);
4450 return -1;
4451 }
4452 }
4453
4454 return 0;
4455}
4456
4457static QDict *qdict_from_args_type(const char *args_type)
4458{
4459 int i;
4460 QDict *qdict;
4461 QString *key, *type, *cur_qs;
4462
4463 assert(args_type != NULL);
4464
4465 qdict = qdict_new();
4466
4467 if (args_type == NULL || args_type[0] == '\0') {
4468 /* no args, empty qdict */
4469 goto out;
4470 }
4471
4472 key = qstring_new();
4473 type = qstring_new();
4474
4475 cur_qs = key;
4476
4477 for (i = 0;; i++) {
4478 switch (args_type[i]) {
4479 case ',':
4480 case '\0':
4481 qdict_put(qdict, qstring_get_str(key), type);
4482 QDECREF(key);
4483 if (args_type[i] == '\0') {
4484 goto out;
4485 }
4486 type = qstring_new(); /* qdict has ref */
4487 cur_qs = key = qstring_new();
4488 break;
4489 case ':':
4490 cur_qs = type;
4491 break;
4492 default:
4493 qstring_append_chr(cur_qs, args_type[i]);
4494 break;
4495 }
4496 }
4497
4498out:
4499 return qdict;
4500}
4501
4502/*
4503 * Client argument checking rules:
4504 *
4505 * 1. Client must provide all mandatory arguments
Luiz Capitulino4af91932010-06-22 11:44:05 -03004506 * 2. Each argument provided by the client must be expected
4507 * 3. Each argument provided by the client must have the type expected
4508 * by the command
Luiz Capitulino2dbc8db2010-05-26 16:13:09 -03004509 */
4510static int qmp_check_client_args(const mon_cmd_t *cmd, QDict *client_args)
4511{
4512 int flags, err;
4513 QDict *cmd_args;
4514
4515 cmd_args = qdict_from_args_type(cmd->args_type);
4516
4517 flags = 0;
4518 err = check_mandatory_args(cmd_args, client_args, &flags);
4519 if (err) {
4520 goto out;
4521 }
4522
Luiz Capitulino4af91932010-06-22 11:44:05 -03004523 err = check_client_args_type(client_args, cmd_args, flags);
Luiz Capitulino2dbc8db2010-05-26 16:13:09 -03004524
4525out:
4526 QDECREF(cmd_args);
4527 return err;
4528}
4529
Luiz Capitulinoc917c8f2010-05-31 17:28:01 -03004530/*
4531 * Input object checking rules
4532 *
4533 * 1. Input object must be a dict
4534 * 2. The "execute" key must exist
4535 * 3. The "execute" key must be a string
4536 * 4. If the "arguments" key exists, it must be a dict
4537 * 5. If the "id" key exists, it can be anything (ie. json-value)
4538 * 6. Any argument not listed above is considered invalid
4539 */
4540static QDict *qmp_check_input_obj(QObject *input_obj)
4541{
4542 const QDictEntry *ent;
4543 int has_exec_key = 0;
4544 QDict *input_dict;
4545
4546 if (qobject_type(input_obj) != QTYPE_QDICT) {
4547 qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "object");
4548 return NULL;
4549 }
4550
4551 input_dict = qobject_to_qdict(input_obj);
4552
4553 for (ent = qdict_first(input_dict); ent; ent = qdict_next(input_dict, ent)){
4554 const char *arg_name = qdict_entry_key(ent);
4555 const QObject *arg_obj = qdict_entry_value(ent);
4556
4557 if (!strcmp(arg_name, "execute")) {
4558 if (qobject_type(arg_obj) != QTYPE_QSTRING) {
4559 qerror_report(QERR_QMP_BAD_INPUT_OBJECT_MEMBER, "execute",
4560 "string");
4561 return NULL;
4562 }
4563 has_exec_key = 1;
4564 } else if (!strcmp(arg_name, "arguments")) {
4565 if (qobject_type(arg_obj) != QTYPE_QDICT) {
4566 qerror_report(QERR_QMP_BAD_INPUT_OBJECT_MEMBER, "arguments",
4567 "object");
4568 return NULL;
4569 }
4570 } else if (!strcmp(arg_name, "id")) {
4571 /* FIXME: check duplicated IDs for async commands */
4572 } else {
4573 qerror_report(QERR_QMP_EXTRA_MEMBER, arg_name);
4574 return NULL;
4575 }
4576 }
4577
4578 if (!has_exec_key) {
4579 qerror_report(QERR_QMP_BAD_INPUT_OBJECT, "execute");
4580 return NULL;
4581 }
4582
4583 return input_dict;
4584}
4585
Luiz Capitulino030db6e2010-09-10 16:03:38 -03004586static void qmp_call_query_cmd(Monitor *mon, const mon_cmd_t *cmd)
4587{
4588 QObject *ret_data = NULL;
4589
Luiz Capitulino4903de02010-09-16 11:01:32 -03004590 if (handler_is_async(cmd)) {
Luiz Capitulino030db6e2010-09-10 16:03:38 -03004591 qmp_async_info_handler(mon, cmd);
4592 if (monitor_has_error(mon)) {
4593 monitor_protocol_emitter(mon, NULL);
4594 }
4595 } else {
4596 cmd->mhandler.info_new(mon, &ret_data);
4597 if (ret_data) {
4598 monitor_protocol_emitter(mon, ret_data);
4599 qobject_decref(ret_data);
4600 }
4601 }
4602}
4603
Luiz Capitulinofc29df72010-09-16 11:11:18 -03004604static void qmp_call_cmd(Monitor *mon, const mon_cmd_t *cmd,
4605 const QDict *params)
4606{
4607 int ret;
4608 QObject *data = NULL;
4609
4610 mon_print_count_init(mon);
4611
4612 ret = cmd->mhandler.cmd_new(mon, params, &data);
4613 handler_audit(mon, cmd, ret);
4614 monitor_protocol_emitter(mon, data);
4615 qobject_decref(data);
4616}
4617
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004618static void handle_qmp_command(JSONMessageParser *parser, QList *tokens)
4619{
4620 int err;
4621 QObject *obj;
4622 QDict *input, *args;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004623 const mon_cmd_t *cmd;
4624 Monitor *mon = cur_mon;
Luiz Capitulino030db6e2010-09-10 16:03:38 -03004625 const char *cmd_name, *query_cmd;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004626
Luiz Capitulino030db6e2010-09-10 16:03:38 -03004627 query_cmd = NULL;
Luiz Capitulinoe4940c62010-06-24 17:58:20 -03004628 args = input = NULL;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004629
4630 obj = json_parser_parse(tokens, NULL);
4631 if (!obj) {
4632 // FIXME: should be triggered in json_parser_parse()
Markus Armbrusterab5b0272010-03-02 18:15:09 +01004633 qerror_report(QERR_JSON_PARSING);
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004634 goto err_out;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004635 }
4636
Luiz Capitulinoc917c8f2010-05-31 17:28:01 -03004637 input = qmp_check_input_obj(obj);
4638 if (!input) {
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004639 qobject_decref(obj);
4640 goto err_out;
4641 }
4642
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004643 mon->mc->id = qdict_get(input, "id");
4644 qobject_incref(mon->mc->id);
4645
Luiz Capitulino0bbab462010-05-31 17:32:50 -03004646 cmd_name = qdict_get_str(input, "execute");
Luiz Capitulino09069b12010-02-04 18:10:06 -02004647 if (invalid_qmp_mode(mon, cmd_name)) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01004648 qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);
Luiz Capitulinoe4940c62010-06-24 17:58:20 -03004649 goto err_out;
Luiz Capitulino09069b12010-02-04 18:10:06 -02004650 }
4651
Luiz Capitulinod1249ea2010-09-13 14:44:27 -03004652 if (strstart(cmd_name, "query-", &query_cmd)) {
Luiz Capitulino030db6e2010-09-10 16:03:38 -03004653 cmd = qmp_find_query_cmd(query_cmd);
Luiz Capitulino5e23f482009-11-26 22:59:02 -02004654 } else {
Luiz Capitulinobead3ce2010-09-15 17:08:39 -03004655 cmd = qmp_find_cmd(cmd_name);
Luiz Capitulino0fb88582010-09-15 10:56:17 -03004656 }
4657
Luiz Capitulinod1249ea2010-09-13 14:44:27 -03004658 if (!cmd) {
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004659 qerror_report(QERR_COMMAND_NOT_FOUND, cmd_name);
4660 goto err_out;
4661 }
4662
4663 obj = qdict_get(input, "arguments");
4664 if (!obj) {
4665 args = qdict_new();
4666 } else {
4667 args = qobject_to_qdict(obj);
4668 QINCREF(args);
4669 }
4670
Luiz Capitulino2dbc8db2010-05-26 16:13:09 -03004671 err = qmp_check_client_args(cmd, args);
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004672 if (err < 0) {
4673 goto err_out;
4674 }
4675
Luiz Capitulino030db6e2010-09-10 16:03:38 -03004676 if (query_cmd) {
4677 qmp_call_query_cmd(mon, cmd);
Luiz Capitulino4903de02010-09-16 11:01:32 -03004678 } else if (handler_is_async(cmd)) {
Luiz Capitulino5af7bba2010-06-22 19:10:46 -03004679 err = qmp_async_cmd_handler(mon, cmd, args);
4680 if (err) {
4681 /* emit the error response */
4682 goto err_out;
4683 }
Adam Litke940cc302010-01-25 12:18:44 -06004684 } else {
Luiz Capitulinofc29df72010-09-16 11:11:18 -03004685 qmp_call_cmd(mon, cmd, args);
Adam Litke940cc302010-01-25 12:18:44 -06004686 }
Luiz Capitulinoe4940c62010-06-24 17:58:20 -03004687
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004688 goto out;
4689
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004690err_out:
4691 monitor_protocol_emitter(mon, NULL);
4692out:
Luiz Capitulinoe4940c62010-06-24 17:58:20 -03004693 QDECREF(input);
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004694 QDECREF(args);
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004695}
4696
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004697/**
4698 * monitor_control_read(): Read and handle QMP input
4699 */
4700static void monitor_control_read(void *opaque, const uint8_t *buf, int size)
4701{
4702 Monitor *old_mon = cur_mon;
4703
4704 cur_mon = opaque;
4705
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004706 json_message_parser_feed(&cur_mon->mc->parser, (const char *) buf, size);
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004707
4708 cur_mon = old_mon;
4709}
4710
aliguori731b0362009-03-05 23:01:42 +00004711static void monitor_read(void *opaque, const uint8_t *buf, int size)
bellard9dc39cb2004-03-14 21:38:27 +00004712{
aliguori731b0362009-03-05 23:01:42 +00004713 Monitor *old_mon = cur_mon;
bellard9dc39cb2004-03-14 21:38:27 +00004714 int i;
aliguori376253e2009-03-05 23:01:23 +00004715
aliguori731b0362009-03-05 23:01:42 +00004716 cur_mon = opaque;
bellard7e2515e2004-08-01 21:52:19 +00004717
aliguoricde76ee2009-03-05 23:01:51 +00004718 if (cur_mon->rs) {
4719 for (i = 0; i < size; i++)
4720 readline_handle_byte(cur_mon->rs, buf[i]);
4721 } else {
4722 if (size == 0 || buf[size - 1] != 0)
4723 monitor_printf(cur_mon, "corrupted command\n");
4724 else
Luiz Capitulinof3c157c2009-11-26 22:58:55 -02004725 handle_user_command(cur_mon, (char *)buf);
aliguoricde76ee2009-03-05 23:01:51 +00004726 }
aliguori731b0362009-03-05 23:01:42 +00004727
4728 cur_mon = old_mon;
4729}
aliguorid8f44602008-10-06 13:52:44 +00004730
aliguori376253e2009-03-05 23:01:23 +00004731static void monitor_command_cb(Monitor *mon, const char *cmdline, void *opaque)
bellard7e2515e2004-08-01 21:52:19 +00004732{
aliguori731b0362009-03-05 23:01:42 +00004733 monitor_suspend(mon);
Luiz Capitulinof3c157c2009-11-26 22:58:55 -02004734 handle_user_command(mon, cmdline);
aliguori731b0362009-03-05 23:01:42 +00004735 monitor_resume(mon);
aliguorid8f44602008-10-06 13:52:44 +00004736}
4737
aliguoricde76ee2009-03-05 23:01:51 +00004738int monitor_suspend(Monitor *mon)
aliguorid8f44602008-10-06 13:52:44 +00004739{
aliguoricde76ee2009-03-05 23:01:51 +00004740 if (!mon->rs)
4741 return -ENOTTY;
aliguori731b0362009-03-05 23:01:42 +00004742 mon->suspend_cnt++;
aliguoricde76ee2009-03-05 23:01:51 +00004743 return 0;
aliguorid8f44602008-10-06 13:52:44 +00004744}
4745
aliguori376253e2009-03-05 23:01:23 +00004746void monitor_resume(Monitor *mon)
aliguorid8f44602008-10-06 13:52:44 +00004747{
aliguoricde76ee2009-03-05 23:01:51 +00004748 if (!mon->rs)
4749 return;
aliguori731b0362009-03-05 23:01:42 +00004750 if (--mon->suspend_cnt == 0)
4751 readline_show_prompt(mon->rs);
bellard7e2515e2004-08-01 21:52:19 +00004752}
4753
Luiz Capitulinoca9567e2010-02-04 18:10:04 -02004754static QObject *get_qmp_greeting(void)
4755{
4756 QObject *ver;
4757
4758 do_info_version(NULL, &ver);
4759 return qobject_from_jsonf("{'QMP':{'version': %p,'capabilities': []}}",ver);
4760}
4761
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004762/**
4763 * monitor_control_event(): Print QMP gretting
4764 */
4765static void monitor_control_event(void *opaque, int event)
4766{
Luiz Capitulino47116d12010-02-08 17:01:30 -02004767 QObject *data;
4768 Monitor *mon = opaque;
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004769
Luiz Capitulino47116d12010-02-08 17:01:30 -02004770 switch (event) {
4771 case CHR_EVENT_OPENED:
Luiz Capitulino4a7e1192010-02-04 18:10:05 -02004772 mon->mc->command_mode = 0;
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004773 json_message_parser_init(&mon->mc->parser, handle_qmp_command);
Luiz Capitulinoca9567e2010-02-04 18:10:04 -02004774 data = get_qmp_greeting();
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004775 monitor_json_emitter(mon, data);
4776 qobject_decref(data);
Luiz Capitulino47116d12010-02-08 17:01:30 -02004777 break;
4778 case CHR_EVENT_CLOSED:
4779 json_message_parser_destroy(&mon->mc->parser);
4780 break;
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004781 }
4782}
4783
aliguori731b0362009-03-05 23:01:42 +00004784static void monitor_event(void *opaque, int event)
ths86e94de2007-01-05 22:01:59 +00004785{
aliguori376253e2009-03-05 23:01:23 +00004786 Monitor *mon = opaque;
4787
aliguori2724b182009-03-05 23:01:47 +00004788 switch (event) {
4789 case CHR_EVENT_MUX_IN:
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +02004790 mon->mux_out = 0;
4791 if (mon->reset_seen) {
4792 readline_restart(mon->rs);
4793 monitor_resume(mon);
4794 monitor_flush(mon);
4795 } else {
4796 mon->suspend_cnt = 0;
4797 }
aliguori2724b182009-03-05 23:01:47 +00004798 break;
ths86e94de2007-01-05 22:01:59 +00004799
aliguori2724b182009-03-05 23:01:47 +00004800 case CHR_EVENT_MUX_OUT:
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +02004801 if (mon->reset_seen) {
4802 if (mon->suspend_cnt == 0) {
4803 monitor_printf(mon, "\n");
4804 }
4805 monitor_flush(mon);
4806 monitor_suspend(mon);
4807 } else {
4808 mon->suspend_cnt++;
4809 }
4810 mon->mux_out = 1;
aliguori2724b182009-03-05 23:01:47 +00004811 break;
4812
Amit Shahb6b8df52009-10-07 18:31:16 +05304813 case CHR_EVENT_OPENED:
aliguori2724b182009-03-05 23:01:47 +00004814 monitor_printf(mon, "QEMU %s monitor - type 'help' for more "
4815 "information\n", QEMU_VERSION);
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +02004816 if (!mon->mux_out) {
aliguori2724b182009-03-05 23:01:47 +00004817 readline_show_prompt(mon->rs);
Gerd Hoffmanna7aec5d2009-09-10 10:58:54 +02004818 }
4819 mon->reset_seen = 1;
aliguori2724b182009-03-05 23:01:47 +00004820 break;
4821 }
ths86e94de2007-01-05 22:01:59 +00004822}
4823
aliguori76655d62009-03-06 20:27:37 +00004824
4825/*
4826 * Local variables:
4827 * c-indent-level: 4
4828 * c-basic-offset: 4
4829 * tab-width: 8
4830 * End:
4831 */
4832
aliguori731b0362009-03-05 23:01:42 +00004833void monitor_init(CharDriverState *chr, int flags)
bellard9dc39cb2004-03-14 21:38:27 +00004834{
aliguori731b0362009-03-05 23:01:42 +00004835 static int is_first_init = 1;
aliguori87127162009-03-05 23:01:29 +00004836 Monitor *mon;
ths20d8a3e2007-02-18 17:04:49 +00004837
4838 if (is_first_init) {
balrogc8256f92008-06-08 22:45:01 +00004839 key_timer = qemu_new_timer(vm_clock, release_keys, NULL);
ths20d8a3e2007-02-18 17:04:49 +00004840 is_first_init = 0;
4841 }
aliguori87127162009-03-05 23:01:29 +00004842
4843 mon = qemu_mallocz(sizeof(*mon));
ths20d8a3e2007-02-18 17:04:49 +00004844
aliguori87127162009-03-05 23:01:29 +00004845 mon->chr = chr;
aliguori731b0362009-03-05 23:01:42 +00004846 mon->flags = flags;
aliguoricde76ee2009-03-05 23:01:51 +00004847 if (flags & MONITOR_USE_READLINE) {
4848 mon->rs = readline_init(mon, monitor_find_completion);
4849 monitor_read_command(mon, 0);
4850 }
aliguori87127162009-03-05 23:01:29 +00004851
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004852 if (monitor_ctrl_mode(mon)) {
Luiz Capitulino5fa737a2009-11-26 22:59:01 -02004853 mon->mc = qemu_mallocz(sizeof(MonitorControl));
Luiz Capitulino9b57c022009-11-26 22:58:58 -02004854 /* Control mode requires special handlers */
4855 qemu_chr_add_handlers(chr, monitor_can_read, monitor_control_read,
4856 monitor_control_event, mon);
4857 } else {
4858 qemu_chr_add_handlers(chr, monitor_can_read, monitor_read,
4859 monitor_event, mon);
4860 }
aliguori87127162009-03-05 23:01:29 +00004861
Blue Swirl72cf2d42009-09-12 07:36:22 +00004862 QLIST_INSERT_HEAD(&mon_list, mon, entry);
Markus Armbruster8631b602010-02-18 11:41:55 +01004863 if (!default_mon || (flags & MONITOR_IS_DEFAULT))
4864 default_mon = mon;
bellard7e2515e2004-08-01 21:52:19 +00004865}
4866
aliguori376253e2009-03-05 23:01:23 +00004867static void bdrv_password_cb(Monitor *mon, const char *password, void *opaque)
bellard7e2515e2004-08-01 21:52:19 +00004868{
aliguoribb5fc202009-03-05 23:01:15 +00004869 BlockDriverState *bs = opaque;
4870 int ret = 0;
bellard7e2515e2004-08-01 21:52:19 +00004871
aliguoribb5fc202009-03-05 23:01:15 +00004872 if (bdrv_set_key(bs, password) != 0) {
aliguori376253e2009-03-05 23:01:23 +00004873 monitor_printf(mon, "invalid password\n");
aliguoribb5fc202009-03-05 23:01:15 +00004874 ret = -EPERM;
bellard7e2515e2004-08-01 21:52:19 +00004875 }
aliguori731b0362009-03-05 23:01:42 +00004876 if (mon->password_completion_cb)
4877 mon->password_completion_cb(mon->password_opaque, ret);
aliguoribb5fc202009-03-05 23:01:15 +00004878
aliguori731b0362009-03-05 23:01:42 +00004879 monitor_read_command(mon, 1);
bellard9dc39cb2004-03-14 21:38:27 +00004880}
aliguoric0f4ce72009-03-05 23:01:01 +00004881
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02004882int monitor_read_bdrv_key_start(Monitor *mon, BlockDriverState *bs,
4883 BlockDriverCompletionFunc *completion_cb,
4884 void *opaque)
aliguoric0f4ce72009-03-05 23:01:01 +00004885{
aliguoricde76ee2009-03-05 23:01:51 +00004886 int err;
4887
aliguoribb5fc202009-03-05 23:01:15 +00004888 if (!bdrv_key_required(bs)) {
4889 if (completion_cb)
4890 completion_cb(opaque, 0);
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02004891 return 0;
aliguoribb5fc202009-03-05 23:01:15 +00004892 }
aliguoric0f4ce72009-03-05 23:01:01 +00004893
Luiz Capitulino94171e12009-12-07 21:37:00 +01004894 if (monitor_ctrl_mode(mon)) {
Markus Armbrusterab5b0272010-03-02 18:15:09 +01004895 qerror_report(QERR_DEVICE_ENCRYPTED, bdrv_get_device_name(bs));
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02004896 return -1;
Luiz Capitulino94171e12009-12-07 21:37:00 +01004897 }
4898
aliguori376253e2009-03-05 23:01:23 +00004899 monitor_printf(mon, "%s (%s) is encrypted.\n", bdrv_get_device_name(bs),
4900 bdrv_get_encrypted_filename(bs));
aliguoribb5fc202009-03-05 23:01:15 +00004901
aliguori731b0362009-03-05 23:01:42 +00004902 mon->password_completion_cb = completion_cb;
4903 mon->password_opaque = opaque;
aliguoribb5fc202009-03-05 23:01:15 +00004904
aliguoricde76ee2009-03-05 23:01:51 +00004905 err = monitor_read_password(mon, bdrv_password_cb, bs);
4906
4907 if (err && completion_cb)
4908 completion_cb(opaque, err);
Luiz Capitulino0bbc47b2010-02-10 23:50:01 -02004909
4910 return err;
aliguoric0f4ce72009-03-05 23:01:01 +00004911}